DHCP_POLICY

using System;
using System.Runtime.InteropServices;

[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
public struct DHCP_POLICY
{
    public IntPtr PolicyName;
    [MarshalAs(UnmanagedType.Bool)] public bool IsGlobalPolicy;
    public uint Subnet;
    public uint ProcessingOrder;
    public IntPtr Conditions;
    public IntPtr Expressions;
    public IntPtr Ranges;
    public IntPtr Description;
    [MarshalAs(UnmanagedType.Bool)] public bool Enabled;
}

Imports System.Runtime.InteropServices

<StructLayout(LayoutKind.Sequential, CharSet:=CharSet.Unicode)>
Public Structure DHCP_POLICY
    Public PolicyName As IntPtr
    <MarshalAs(UnmanagedType.Bool)> Public IsGlobalPolicy As Boolean
    Public Subnet As UInteger
    Public ProcessingOrder As UInteger
    Public Conditions As IntPtr
    Public Expressions As IntPtr
    Public Ranges As IntPtr
    Public Description As IntPtr
    <MarshalAs(UnmanagedType.Bool)> Public Enabled As Boolean
End Structure

import ctypes
from ctypes import wintypes

class DHCP_POLICY(ctypes.Structure):
    _fields_ = [
        ("PolicyName", ctypes.c_void_p),
        ("IsGlobalPolicy", wintypes.BOOL),
        ("Subnet", wintypes.DWORD),
        ("ProcessingOrder", wintypes.DWORD),
        ("Conditions", ctypes.c_void_p),
        ("Expressions", ctypes.c_void_p),
        ("Ranges", ctypes.c_void_p),
        ("Description", ctypes.c_void_p),
        ("Enabled", wintypes.BOOL),
    ]

#[repr(C)]
pub struct DHCP_POLICY {
    pub PolicyName: *mut core::ffi::c_void,
    pub IsGlobalPolicy: i32,
    pub Subnet: u32,
    pub ProcessingOrder: u32,
    pub Conditions: *mut core::ffi::c_void,
    pub Expressions: *mut core::ffi::c_void,
    pub Ranges: *mut core::ffi::c_void,
    pub Description: *mut core::ffi::c_void,
    pub Enabled: i32,
}

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

type DHCP_POLICY struct {
	PolicyName uintptr
	IsGlobalPolicy int32
	Subnet uint32
	ProcessingOrder uint32
	Conditions uintptr
	Expressions uintptr
	Ranges uintptr
	Description uintptr
	Enabled int32
}

type
  DHCP_POLICY = record
    PolicyName: Pointer;
    IsGlobalPolicy: BOOL;
    Subnet: DWORD;
    ProcessingOrder: DWORD;
    Conditions: Pointer;
    Expressions: Pointer;
    Ranges: Pointer;
    Description: Pointer;
    Enabled: BOOL;
  end;

const DHCP_POLICY = extern struct {
    PolicyName: ?*anyopaque,
    IsGlobalPolicy: i32,
    Subnet: u32,
    ProcessingOrder: u32,
    Conditions: ?*anyopaque,
    Expressions: ?*anyopaque,
    Ranges: ?*anyopaque,
    Description: ?*anyopaque,
    Enabled: i32,
};

type
  DHCP_POLICY {.bycopy.} = object
    PolicyName: pointer
    IsGlobalPolicy: int32
    Subnet: uint32
    ProcessingOrder: uint32
    Conditions: pointer
    Expressions: pointer
    Ranges: pointer
    Description: pointer
    Enabled: int32

struct DHCP_POLICY
{
    void* PolicyName;
    int IsGlobalPolicy;
    uint Subnet;
    uint ProcessingOrder;
    void* Conditions;
    void* Expressions;
    void* Ranges;
    void* Description;
    int Enabled;
}