RPC_CLIENT_INTERFACE

using System;
using System.Runtime.InteropServices;

[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
public struct RPC_VERSION
{
    public ushort MajorVersion;
    public ushort MinorVersion;
}

[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
public struct RPC_SYNTAX_IDENTIFIER
{
    public Guid SyntaxGUID;
    public RPC_VERSION SyntaxVersion;
}

[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
public struct RPC_CLIENT_INTERFACE
{
    public uint Length;
    public RPC_SYNTAX_IDENTIFIER InterfaceId;
    public RPC_SYNTAX_IDENTIFIER TransferSyntax;
    public IntPtr DispatchTable;
    public uint RpcProtseqEndpointCount;
    public IntPtr RpcProtseqEndpoint;
    public UIntPtr Reserved;
    public IntPtr InterpreterInfo;
    public uint Flags;
}

Imports System.Runtime.InteropServices

<StructLayout(LayoutKind.Sequential, CharSet:=CharSet.Unicode)>
Public Structure RPC_VERSION
    Public MajorVersion As UShort
    Public MinorVersion As UShort
End Structure

<StructLayout(LayoutKind.Sequential, CharSet:=CharSet.Unicode)>
Public Structure RPC_SYNTAX_IDENTIFIER
    Public SyntaxGUID As Guid
    Public SyntaxVersion As RPC_VERSION
End Structure

<StructLayout(LayoutKind.Sequential, CharSet:=CharSet.Unicode)>
Public Structure RPC_CLIENT_INTERFACE
    Public Length As UInteger
    Public InterfaceId As RPC_SYNTAX_IDENTIFIER
    Public TransferSyntax As RPC_SYNTAX_IDENTIFIER
    Public DispatchTable As IntPtr
    Public RpcProtseqEndpointCount As UInteger
    Public RpcProtseqEndpoint As IntPtr
    Public Reserved As UIntPtr
    Public InterpreterInfo As IntPtr
    Public Flags As UInteger
End Structure

import ctypes
from ctypes import wintypes

class RPC_VERSION(ctypes.Structure):
    _fields_ = [
        ("MajorVersion", ctypes.c_ushort),
        ("MinorVersion", ctypes.c_ushort),
    ]

class RPC_SYNTAX_IDENTIFIER(ctypes.Structure):
    _fields_ = [
        ("SyntaxGUID", GUID),
        ("SyntaxVersion", RPC_VERSION),
    ]

class RPC_CLIENT_INTERFACE(ctypes.Structure):
    _fields_ = [
        ("Length", wintypes.DWORD),
        ("InterfaceId", RPC_SYNTAX_IDENTIFIER),
        ("TransferSyntax", RPC_SYNTAX_IDENTIFIER),
        ("DispatchTable", ctypes.c_void_p),
        ("RpcProtseqEndpointCount", wintypes.DWORD),
        ("RpcProtseqEndpoint", ctypes.c_void_p),
        ("Reserved", ctypes.c_size_t),
        ("InterpreterInfo", ctypes.c_void_p),
        ("Flags", wintypes.DWORD),
    ]

#[repr(C)]
pub struct RPC_VERSION {
    pub MajorVersion: u16,
    pub MinorVersion: u16,
}

#[repr(C)]
pub struct RPC_SYNTAX_IDENTIFIER {
    pub SyntaxGUID: GUID,
    pub SyntaxVersion: RPC_VERSION,
}

#[repr(C)]
pub struct RPC_CLIENT_INTERFACE {
    pub Length: u32,
    pub InterfaceId: RPC_SYNTAX_IDENTIFIER,
    pub TransferSyntax: RPC_SYNTAX_IDENTIFIER,
    pub DispatchTable: *mut core::ffi::c_void,
    pub RpcProtseqEndpointCount: u32,
    pub RpcProtseqEndpoint: *mut core::ffi::c_void,
    pub Reserved: usize,
    pub InterpreterInfo: *mut core::ffi::c_void,
    pub Flags: u32,
}

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

type RPC_VERSION struct {
	MajorVersion uint16
	MinorVersion uint16
}

type RPC_SYNTAX_IDENTIFIER struct {
	SyntaxGUID windows.GUID
	SyntaxVersion RPC_VERSION
}

type RPC_CLIENT_INTERFACE struct {
	Length uint32
	InterfaceId RPC_SYNTAX_IDENTIFIER
	TransferSyntax RPC_SYNTAX_IDENTIFIER
	DispatchTable uintptr
	RpcProtseqEndpointCount uint32
	RpcProtseqEndpoint uintptr
	Reserved uintptr
	InterpreterInfo uintptr
	Flags uint32
}

type
  RPC_VERSION = record
    MajorVersion: Word;
    MinorVersion: Word;
  end;

  RPC_SYNTAX_IDENTIFIER = record
    SyntaxGUID: TGUID;
    SyntaxVersion: RPC_VERSION;
  end;

  RPC_CLIENT_INTERFACE = record
    Length: DWORD;
    InterfaceId: RPC_SYNTAX_IDENTIFIER;
    TransferSyntax: RPC_SYNTAX_IDENTIFIER;
    DispatchTable: Pointer;
    RpcProtseqEndpointCount: DWORD;
    RpcProtseqEndpoint: Pointer;
    Reserved: NativeUInt;
    InterpreterInfo: Pointer;
    Flags: DWORD;
  end;

const RPC_VERSION = extern struct {
    MajorVersion: u16,
    MinorVersion: u16,
};

const RPC_SYNTAX_IDENTIFIER = extern struct {
    SyntaxGUID: GUID,
    SyntaxVersion: RPC_VERSION,
};

const RPC_CLIENT_INTERFACE = extern struct {
    Length: u32,
    InterfaceId: RPC_SYNTAX_IDENTIFIER,
    TransferSyntax: RPC_SYNTAX_IDENTIFIER,
    DispatchTable: ?*anyopaque,
    RpcProtseqEndpointCount: u32,
    RpcProtseqEndpoint: ?*anyopaque,
    Reserved: usize,
    InterpreterInfo: ?*anyopaque,
    Flags: u32,
};

type
  RPC_VERSION {.bycopy.} = object
    MajorVersion: uint16
    MinorVersion: uint16

  RPC_SYNTAX_IDENTIFIER {.bycopy.} = object
    SyntaxGUID: GUID
    SyntaxVersion: RPC_VERSION

  RPC_CLIENT_INTERFACE {.bycopy.} = object
    Length: uint32
    InterfaceId: RPC_SYNTAX_IDENTIFIER
    TransferSyntax: RPC_SYNTAX_IDENTIFIER
    DispatchTable: pointer
    RpcProtseqEndpointCount: uint32
    RpcProtseqEndpoint: pointer
    Reserved: uint
    InterpreterInfo: pointer
    Flags: uint32

struct RPC_VERSION
{
    ushort MajorVersion;
    ushort MinorVersion;
}

struct RPC_SYNTAX_IDENTIFIER
{
    GUID SyntaxGUID;
    RPC_VERSION SyntaxVersion;
}

struct RPC_CLIENT_INTERFACE
{
    uint Length;
    RPC_SYNTAX_IDENTIFIER InterfaceId;
    RPC_SYNTAX_IDENTIFIER TransferSyntax;
    void* DispatchTable;
    uint RpcProtseqEndpointCount;
    void* RpcProtseqEndpoint;
    size_t Reserved;
    void* InterpreterInfo;
    uint Flags;
}