RPC_SERVER_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_SERVER_INTERFACE
{
    public uint Length;
    public RPC_SYNTAX_IDENTIFIER InterfaceId;
    public RPC_SYNTAX_IDENTIFIER TransferSyntax;
    public IntPtr DispatchTable;
    public uint RpcProtseqEndpointCount;
    public IntPtr RpcProtseqEndpoint;
    public IntPtr DefaultManagerEpv;
    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_SERVER_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 DefaultManagerEpv As IntPtr
    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_SERVER_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),
        ("DefaultManagerEpv", ctypes.c_void_p),
        ("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_SERVER_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 DefaultManagerEpv: *mut core::ffi::c_void,
    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_SERVER_INTERFACE struct {
	Length uint32
	InterfaceId RPC_SYNTAX_IDENTIFIER
	TransferSyntax RPC_SYNTAX_IDENTIFIER
	DispatchTable uintptr
	RpcProtseqEndpointCount uint32
	RpcProtseqEndpoint uintptr
	DefaultManagerEpv 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_SERVER_INTERFACE = record
    Length: DWORD;
    InterfaceId: RPC_SYNTAX_IDENTIFIER;
    TransferSyntax: RPC_SYNTAX_IDENTIFIER;
    DispatchTable: Pointer;
    RpcProtseqEndpointCount: DWORD;
    RpcProtseqEndpoint: Pointer;
    DefaultManagerEpv: Pointer;
    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_SERVER_INTERFACE = extern struct {
    Length: u32,
    InterfaceId: RPC_SYNTAX_IDENTIFIER,
    TransferSyntax: RPC_SYNTAX_IDENTIFIER,
    DispatchTable: ?*anyopaque,
    RpcProtseqEndpointCount: u32,
    RpcProtseqEndpoint: ?*anyopaque,
    DefaultManagerEpv: ?*anyopaque,
    InterpreterInfo: ?*anyopaque,
    Flags: u32,
};

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

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

  RPC_SERVER_INTERFACE {.bycopy.} = object
    Length: uint32
    InterfaceId: RPC_SYNTAX_IDENTIFIER
    TransferSyntax: RPC_SYNTAX_IDENTIFIER
    DispatchTable: pointer
    RpcProtseqEndpointCount: uint32
    RpcProtseqEndpoint: pointer
    DefaultManagerEpv: pointer
    InterpreterInfo: pointer
    Flags: uint32

struct RPC_VERSION
{
    ushort MajorVersion;
    ushort MinorVersion;
}

struct RPC_SYNTAX_IDENTIFIER
{
    GUID SyntaxGUID;
    RPC_VERSION SyntaxVersion;
}

struct RPC_SERVER_INTERFACE
{
    uint Length;
    RPC_SYNTAX_IDENTIFIER InterfaceId;
    RPC_SYNTAX_IDENTIFIER TransferSyntax;
    void* DispatchTable;
    uint RpcProtseqEndpointCount;
    void* RpcProtseqEndpoint;
    void* DefaultManagerEpv;
    void* InterpreterInfo;
    uint Flags;
}