DOMAIN_TREE

using System;
using System.Runtime.InteropServices;

[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
public struct DOMAINDESC
{
    public IntPtr pszName;
    public IntPtr pszPath;
    public IntPtr pszNCName;
    public IntPtr pszTrustParent;
    public IntPtr pszObjectClass;
    public uint ulFlags;
    [MarshalAs(UnmanagedType.Bool)] public bool fDownLevel;
    public IntPtr pdChildList;
    public IntPtr pdNextSibling;
}

[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
public struct DOMAIN_TREE
{
    public uint dsSize;
    public uint dwCount;
    [MarshalAs(UnmanagedType.ByValArray, SizeConst = 1)] public DOMAINDESC[] aDomains;
}

Imports System.Runtime.InteropServices

<StructLayout(LayoutKind.Sequential, CharSet:=CharSet.Unicode)>
Public Structure DOMAINDESC
    Public pszName As IntPtr
    Public pszPath As IntPtr
    Public pszNCName As IntPtr
    Public pszTrustParent As IntPtr
    Public pszObjectClass As IntPtr
    Public ulFlags As UInteger
    <MarshalAs(UnmanagedType.Bool)> Public fDownLevel As Boolean
    Public pdChildList As IntPtr
    Public pdNextSibling As IntPtr
End Structure

<StructLayout(LayoutKind.Sequential, CharSet:=CharSet.Unicode)>
Public Structure DOMAIN_TREE
    Public dsSize As UInteger
    Public dwCount As UInteger
    <MarshalAs(UnmanagedType.ByValArray, SizeConst:=1)> Public aDomains() As DOMAINDESC
End Structure

import ctypes
from ctypes import wintypes

class DOMAINDESC(ctypes.Structure):
    _fields_ = [
        ("pszName", ctypes.c_void_p),
        ("pszPath", ctypes.c_void_p),
        ("pszNCName", ctypes.c_void_p),
        ("pszTrustParent", ctypes.c_void_p),
        ("pszObjectClass", ctypes.c_void_p),
        ("ulFlags", wintypes.DWORD),
        ("fDownLevel", wintypes.BOOL),
        ("pdChildList", ctypes.c_void_p),
        ("pdNextSibling", ctypes.c_void_p),
    ]

class DOMAIN_TREE(ctypes.Structure):
    _fields_ = [
        ("dsSize", wintypes.DWORD),
        ("dwCount", wintypes.DWORD),
        ("aDomains", DOMAINDESC * 1),
    ]

#[repr(C)]
pub struct DOMAINDESC {
    pub pszName: *mut core::ffi::c_void,
    pub pszPath: *mut core::ffi::c_void,
    pub pszNCName: *mut core::ffi::c_void,
    pub pszTrustParent: *mut core::ffi::c_void,
    pub pszObjectClass: *mut core::ffi::c_void,
    pub ulFlags: u32,
    pub fDownLevel: i32,
    pub pdChildList: *mut core::ffi::c_void,
    pub pdNextSibling: *mut core::ffi::c_void,
}

#[repr(C)]
pub struct DOMAIN_TREE {
    pub dsSize: u32,
    pub dwCount: u32,
    pub aDomains: [DOMAINDESC; 1],
}

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

type DOMAINDESC struct {
	pszName uintptr
	pszPath uintptr
	pszNCName uintptr
	pszTrustParent uintptr
	pszObjectClass uintptr
	ulFlags uint32
	fDownLevel int32
	pdChildList uintptr
	pdNextSibling uintptr
}

type DOMAIN_TREE struct {
	dsSize uint32
	dwCount uint32
	aDomains [1]DOMAINDESC
}

type
  DOMAINDESC = record
    pszName: Pointer;
    pszPath: Pointer;
    pszNCName: Pointer;
    pszTrustParent: Pointer;
    pszObjectClass: Pointer;
    ulFlags: DWORD;
    fDownLevel: BOOL;
    pdChildList: Pointer;
    pdNextSibling: Pointer;
  end;

  DOMAIN_TREE = record
    dsSize: DWORD;
    dwCount: DWORD;
    aDomains: array[0..0] of DOMAINDESC;
  end;

const DOMAINDESC = extern struct {
    pszName: ?*anyopaque,
    pszPath: ?*anyopaque,
    pszNCName: ?*anyopaque,
    pszTrustParent: ?*anyopaque,
    pszObjectClass: ?*anyopaque,
    ulFlags: u32,
    fDownLevel: i32,
    pdChildList: ?*anyopaque,
    pdNextSibling: ?*anyopaque,
};

const DOMAIN_TREE = extern struct {
    dsSize: u32,
    dwCount: u32,
    aDomains: [1]DOMAINDESC,
};

type
  DOMAINDESC {.bycopy.} = object
    pszName: pointer
    pszPath: pointer
    pszNCName: pointer
    pszTrustParent: pointer
    pszObjectClass: pointer
    ulFlags: uint32
    fDownLevel: int32
    pdChildList: pointer
    pdNextSibling: pointer

  DOMAIN_TREE {.bycopy.} = object
    dsSize: uint32
    dwCount: uint32
    aDomains: array[1, DOMAINDESC]

struct DOMAINDESC
{
    void* pszName;
    void* pszPath;
    void* pszNCName;
    void* pszTrustParent;
    void* pszObjectClass;
    uint ulFlags;
    int fDownLevel;
    void* pdChildList;
    void* pdNextSibling;
}

struct DOMAIN_TREE
{
    uint dsSize;
    uint dwCount;
    DOMAINDESC[1] aDomains;
}