WS_METADATA_ENDPOINT

using System;
using System.Runtime.InteropServices;

[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
public struct WS_STRING
{
    public uint length;
    public IntPtr chars;
}

[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
public struct WS_ENDPOINT_ADDRESS
{
    public WS_STRING url;
    public IntPtr headers;
    public IntPtr extensions;
    public IntPtr identity;
}

[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
public struct WS_METADATA_ENDPOINT
{
    public WS_ENDPOINT_ADDRESS endpointAddress;
    public IntPtr endpointPolicy;
    public IntPtr portName;
    public IntPtr serviceName;
    public IntPtr serviceNs;
    public IntPtr bindingName;
    public IntPtr bindingNs;
    public IntPtr portTypeName;
    public IntPtr portTypeNs;
}

Imports System.Runtime.InteropServices

<StructLayout(LayoutKind.Sequential, CharSet:=CharSet.Unicode)>
Public Structure WS_STRING
    Public length As UInteger
    Public chars As IntPtr
End Structure

<StructLayout(LayoutKind.Sequential, CharSet:=CharSet.Unicode)>
Public Structure WS_ENDPOINT_ADDRESS
    Public url As WS_STRING
    Public headers As IntPtr
    Public extensions As IntPtr
    Public identity As IntPtr
End Structure

<StructLayout(LayoutKind.Sequential, CharSet:=CharSet.Unicode)>
Public Structure WS_METADATA_ENDPOINT
    Public endpointAddress As WS_ENDPOINT_ADDRESS
    Public endpointPolicy As IntPtr
    Public portName As IntPtr
    Public serviceName As IntPtr
    Public serviceNs As IntPtr
    Public bindingName As IntPtr
    Public bindingNs As IntPtr
    Public portTypeName As IntPtr
    Public portTypeNs As IntPtr
End Structure

import ctypes
from ctypes import wintypes

class WS_STRING(ctypes.Structure):
    _fields_ = [
        ("length", wintypes.DWORD),
        ("chars", ctypes.c_void_p),
    ]

class WS_ENDPOINT_ADDRESS(ctypes.Structure):
    _fields_ = [
        ("url", WS_STRING),
        ("headers", ctypes.c_void_p),
        ("extensions", ctypes.c_void_p),
        ("identity", ctypes.c_void_p),
    ]

class WS_METADATA_ENDPOINT(ctypes.Structure):
    _fields_ = [
        ("endpointAddress", WS_ENDPOINT_ADDRESS),
        ("endpointPolicy", ctypes.c_void_p),
        ("portName", ctypes.c_void_p),
        ("serviceName", ctypes.c_void_p),
        ("serviceNs", ctypes.c_void_p),
        ("bindingName", ctypes.c_void_p),
        ("bindingNs", ctypes.c_void_p),
        ("portTypeName", ctypes.c_void_p),
        ("portTypeNs", ctypes.c_void_p),
    ]

#[repr(C)]
pub struct WS_STRING {
    pub length: u32,
    pub chars: *mut core::ffi::c_void,
}

#[repr(C)]
pub struct WS_ENDPOINT_ADDRESS {
    pub url: WS_STRING,
    pub headers: *mut core::ffi::c_void,
    pub extensions: *mut core::ffi::c_void,
    pub identity: *mut core::ffi::c_void,
}

#[repr(C)]
pub struct WS_METADATA_ENDPOINT {
    pub endpointAddress: WS_ENDPOINT_ADDRESS,
    pub endpointPolicy: *mut core::ffi::c_void,
    pub portName: *mut core::ffi::c_void,
    pub serviceName: *mut core::ffi::c_void,
    pub serviceNs: *mut core::ffi::c_void,
    pub bindingName: *mut core::ffi::c_void,
    pub bindingNs: *mut core::ffi::c_void,
    pub portTypeName: *mut core::ffi::c_void,
    pub portTypeNs: *mut core::ffi::c_void,
}

import "golang.org/x/sys/windows"

type WS_STRING struct {
	length uint32
	chars uintptr
}

type WS_ENDPOINT_ADDRESS struct {
	url WS_STRING
	headers uintptr
	extensions uintptr
	identity uintptr
}

type WS_METADATA_ENDPOINT struct {
	endpointAddress WS_ENDPOINT_ADDRESS
	endpointPolicy uintptr
	portName uintptr
	serviceName uintptr
	serviceNs uintptr
	bindingName uintptr
	bindingNs uintptr
	portTypeName uintptr
	portTypeNs uintptr
}

type
  WS_STRING = record
    length: DWORD;
    chars: Pointer;
  end;

  WS_ENDPOINT_ADDRESS = record
    url: WS_STRING;
    headers: Pointer;
    extensions: Pointer;
    identity: Pointer;
  end;

  WS_METADATA_ENDPOINT = record
    endpointAddress: WS_ENDPOINT_ADDRESS;
    endpointPolicy: Pointer;
    portName: Pointer;
    serviceName: Pointer;
    serviceNs: Pointer;
    bindingName: Pointer;
    bindingNs: Pointer;
    portTypeName: Pointer;
    portTypeNs: Pointer;
  end;

const WS_STRING = extern struct {
    length: u32,
    chars: ?*anyopaque,
};

const WS_ENDPOINT_ADDRESS = extern struct {
    url: WS_STRING,
    headers: ?*anyopaque,
    extensions: ?*anyopaque,
    identity: ?*anyopaque,
};

const WS_METADATA_ENDPOINT = extern struct {
    endpointAddress: WS_ENDPOINT_ADDRESS,
    endpointPolicy: ?*anyopaque,
    portName: ?*anyopaque,
    serviceName: ?*anyopaque,
    serviceNs: ?*anyopaque,
    bindingName: ?*anyopaque,
    bindingNs: ?*anyopaque,
    portTypeName: ?*anyopaque,
    portTypeNs: ?*anyopaque,
};

type
  WS_STRING {.bycopy.} = object
    length: uint32
    chars: pointer

  WS_ENDPOINT_ADDRESS {.bycopy.} = object
    url: WS_STRING
    headers: pointer
    extensions: pointer
    identity: pointer

  WS_METADATA_ENDPOINT {.bycopy.} = object
    endpointAddress: WS_ENDPOINT_ADDRESS
    endpointPolicy: pointer
    portName: pointer
    serviceName: pointer
    serviceNs: pointer
    bindingName: pointer
    bindingNs: pointer
    portTypeName: pointer
    portTypeNs: pointer

struct WS_STRING
{
    uint length;
    void* chars;
}

struct WS_ENDPOINT_ADDRESS
{
    WS_STRING url;
    void* headers;
    void* extensions;
    void* identity;
}

struct WS_METADATA_ENDPOINT
{
    WS_ENDPOINT_ADDRESS endpointAddress;
    void* endpointPolicy;
    void* portName;
    void* serviceName;
    void* serviceNs;
    void* bindingName;
    void* bindingNs;
    void* portTypeName;
    void* portTypeNs;
}