RECIPIENTPOLICY

using System;
using System.Runtime.InteropServices;

[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
public struct CRYPT_INTEGER_BLOB
{
    public uint cbData;
    public IntPtr pbData;
}

[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
public struct ENDPOINTADDRESS
{
    public IntPtr serviceUrl;
    public IntPtr policyUrl;
    public CRYPT_INTEGER_BLOB rawCertificate;
}

[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
public struct CLAIMLIST
{
    public uint count;
    public IntPtr claims;
}

[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
public struct RECIPIENTPOLICY
{
    public ENDPOINTADDRESS recipient;
    public ENDPOINTADDRESS issuer;
    public IntPtr tokenType;
    public CLAIMLIST requiredClaims;
    public CLAIMLIST optionalClaims;
    public IntPtr privacyUrl;
    public uint privacyVersion;
}

Imports System.Runtime.InteropServices

<StructLayout(LayoutKind.Sequential, CharSet:=CharSet.Unicode)>
Public Structure CRYPT_INTEGER_BLOB
    Public cbData As UInteger
    Public pbData As IntPtr
End Structure

<StructLayout(LayoutKind.Sequential, CharSet:=CharSet.Unicode)>
Public Structure ENDPOINTADDRESS
    Public serviceUrl As IntPtr
    Public policyUrl As IntPtr
    Public rawCertificate As CRYPT_INTEGER_BLOB
End Structure

<StructLayout(LayoutKind.Sequential, CharSet:=CharSet.Unicode)>
Public Structure CLAIMLIST
    Public count As UInteger
    Public claims As IntPtr
End Structure

<StructLayout(LayoutKind.Sequential, CharSet:=CharSet.Unicode)>
Public Structure RECIPIENTPOLICY
    Public recipient As ENDPOINTADDRESS
    Public issuer As ENDPOINTADDRESS
    Public tokenType As IntPtr
    Public requiredClaims As CLAIMLIST
    Public optionalClaims As CLAIMLIST
    Public privacyUrl As IntPtr
    Public privacyVersion As UInteger
End Structure

import ctypes
from ctypes import wintypes

class CRYPT_INTEGER_BLOB(ctypes.Structure):
    _fields_ = [
        ("cbData", wintypes.DWORD),
        ("pbData", ctypes.c_void_p),
    ]

class ENDPOINTADDRESS(ctypes.Structure):
    _fields_ = [
        ("serviceUrl", ctypes.c_void_p),
        ("policyUrl", ctypes.c_void_p),
        ("rawCertificate", CRYPT_INTEGER_BLOB),
    ]

class CLAIMLIST(ctypes.Structure):
    _fields_ = [
        ("count", wintypes.DWORD),
        ("claims", ctypes.c_void_p),
    ]

class RECIPIENTPOLICY(ctypes.Structure):
    _fields_ = [
        ("recipient", ENDPOINTADDRESS),
        ("issuer", ENDPOINTADDRESS),
        ("tokenType", ctypes.c_void_p),
        ("requiredClaims", CLAIMLIST),
        ("optionalClaims", CLAIMLIST),
        ("privacyUrl", ctypes.c_void_p),
        ("privacyVersion", wintypes.DWORD),
    ]

#[repr(C)]
pub struct CRYPT_INTEGER_BLOB {
    pub cbData: u32,
    pub pbData: *mut core::ffi::c_void,
}

#[repr(C)]
pub struct ENDPOINTADDRESS {
    pub serviceUrl: *mut core::ffi::c_void,
    pub policyUrl: *mut core::ffi::c_void,
    pub rawCertificate: CRYPT_INTEGER_BLOB,
}

#[repr(C)]
pub struct CLAIMLIST {
    pub count: u32,
    pub claims: *mut core::ffi::c_void,
}

#[repr(C)]
pub struct RECIPIENTPOLICY {
    pub recipient: ENDPOINTADDRESS,
    pub issuer: ENDPOINTADDRESS,
    pub tokenType: *mut core::ffi::c_void,
    pub requiredClaims: CLAIMLIST,
    pub optionalClaims: CLAIMLIST,
    pub privacyUrl: *mut core::ffi::c_void,
    pub privacyVersion: u32,
}

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

type CRYPT_INTEGER_BLOB struct {
	cbData uint32
	pbData uintptr
}

type ENDPOINTADDRESS struct {
	serviceUrl uintptr
	policyUrl uintptr
	rawCertificate CRYPT_INTEGER_BLOB
}

type CLAIMLIST struct {
	count uint32
	claims uintptr
}

type RECIPIENTPOLICY struct {
	recipient ENDPOINTADDRESS
	issuer ENDPOINTADDRESS
	tokenType uintptr
	requiredClaims CLAIMLIST
	optionalClaims CLAIMLIST
	privacyUrl uintptr
	privacyVersion uint32
}

type
  CRYPT_INTEGER_BLOB = record
    cbData: DWORD;
    pbData: Pointer;
  end;

  ENDPOINTADDRESS = record
    serviceUrl: Pointer;
    policyUrl: Pointer;
    rawCertificate: CRYPT_INTEGER_BLOB;
  end;

  CLAIMLIST = record
    count: DWORD;
    claims: Pointer;
  end;

  RECIPIENTPOLICY = record
    recipient: ENDPOINTADDRESS;
    issuer: ENDPOINTADDRESS;
    tokenType: Pointer;
    requiredClaims: CLAIMLIST;
    optionalClaims: CLAIMLIST;
    privacyUrl: Pointer;
    privacyVersion: DWORD;
  end;

const CRYPT_INTEGER_BLOB = extern struct {
    cbData: u32,
    pbData: ?*anyopaque,
};

const ENDPOINTADDRESS = extern struct {
    serviceUrl: ?*anyopaque,
    policyUrl: ?*anyopaque,
    rawCertificate: CRYPT_INTEGER_BLOB,
};

const CLAIMLIST = extern struct {
    count: u32,
    claims: ?*anyopaque,
};

const RECIPIENTPOLICY = extern struct {
    recipient: ENDPOINTADDRESS,
    issuer: ENDPOINTADDRESS,
    tokenType: ?*anyopaque,
    requiredClaims: CLAIMLIST,
    optionalClaims: CLAIMLIST,
    privacyUrl: ?*anyopaque,
    privacyVersion: u32,
};

type
  CRYPT_INTEGER_BLOB {.bycopy.} = object
    cbData: uint32
    pbData: pointer

  ENDPOINTADDRESS {.bycopy.} = object
    serviceUrl: pointer
    policyUrl: pointer
    rawCertificate: CRYPT_INTEGER_BLOB

  CLAIMLIST {.bycopy.} = object
    count: uint32
    claims: pointer

  RECIPIENTPOLICY {.bycopy.} = object
    recipient: ENDPOINTADDRESS
    issuer: ENDPOINTADDRESS
    tokenType: pointer
    requiredClaims: CLAIMLIST
    optionalClaims: CLAIMLIST
    privacyUrl: pointer
    privacyVersion: uint32

struct CRYPT_INTEGER_BLOB
{
    uint cbData;
    void* pbData;
}

struct ENDPOINTADDRESS
{
    void* serviceUrl;
    void* policyUrl;
    CRYPT_INTEGER_BLOB rawCertificate;
}

struct CLAIMLIST
{
    uint count;
    void* claims;
}

struct RECIPIENTPOLICY
{
    ENDPOINTADDRESS recipient;
    ENDPOINTADDRESS issuer;
    void* tokenType;
    CLAIMLIST requiredClaims;
    CLAIMLIST optionalClaims;
    void* privacyUrl;
    uint privacyVersion;
}