Windows.h bindings for Odin. Generated with bind-odin

Windows.odin

package win32

foreign import kernel32 "system:kernel32.lib";
foreign import user32 "system:user32.lib";
foreign import ole32 "system:ole32.lib";
foreign import shell32 "system:shell32.lib";
foreign import gdi32 "system:gdi32.lib";
foreign import comdlg32 "system:comdlg32.lib";
foreign import bcrypt "system:bcrypt.lib";
foreign import advapi32 "system:advapi32.lib";
foreign import winmm "system:winmm.lib";
foreign import opengl32 "system:opengl32.lib";
foreign import userenv "system:userenv.lib";
foreign import synchronization "system:synchronization.lib";
foreign import oleaut32 "system:oleaut32.lib";
foreign import WS2_32 "system:WS2_32.lib";

import _c "core:c"

/* Opaque Types */
__crt_locale_data :: struct {}
_ACTIVATION_CONTEXT :: struct {}
__crt_multibyte_data :: struct {}
_TEB :: struct {}
_NDR_CORRELATION_INFO :: struct {}
_NDR_ASYNC_MESSAGE :: struct {}
NET_ADDRESS_INFO_ :: struct {}
_wireSAFEARRAY :: struct {
    cDims         : USHORT,
    fFeatures     : USHORT,
    cbElements    : ULONG,
    cLocks        : ULONG,
    uArrayStructs : SAFEARRAYUNION,
    rgsabound     : [1]SAFEARRAYBOUND,
}
_SC_NOTIFICATION_REGISTRATION :: struct {}
_PROC_THREAD_ATTRIBUTE_LIST :: struct {}
/* Defines */

uintptr_t :: u64;

va_list :: ^_c.uchar;

size_t :: u64;

ptrdiff_t :: i64;

intptr_t :: i64;

__vcrt_bool :: _c.bool;

wchar_t :: _c.ushort;

/* EXCEPTION_DISPOSITION :: enum { */
EXCEPTION_DISPOSITION :: _c.int;
    ExceptionContinueExecution :: 0;
    ExceptionContinueSearch :: ExceptionContinueExecution + 1;
    ExceptionNestedException :: ExceptionContinueSearch + 1;
    ExceptionCollidedUnwind :: ExceptionNestedException + 1;
/* } */
;

ULONG :: _c.ulong;

PULONG :: ^ULONG;

USHORT :: _c.ushort;

PUSHORT :: ^USHORT;

UCHAR :: _c.uchar;

PUCHAR :: ^UCHAR;

PSZ :: ^_c.uchar;

DWORD :: _c.ulong;

BOOL :: _c.int;

BYTE :: _c.uchar;

WORD :: _c.ushort;

FLOAT :: _c.float;

PFLOAT :: ^FLOAT;

PBOOL :: ^BOOL;

LPBOOL :: ^BOOL;

PBYTE :: ^BYTE;

LPBYTE :: ^BYTE;

PINT :: ^_c.int;

LPINT :: ^_c.int;

PWORD :: ^WORD;

LPWORD :: ^WORD;

LPLONG :: ^_c.long;

PDWORD :: ^DWORD;

LPDWORD :: ^DWORD;

LPVOID :: rawptr;

LPCVOID :: rawptr;

INT :: _c.int;

UINT :: _c.uint;

PUINT :: ^_c.uint;

__crt_bool :: _c.bool;

errno_t :: _c.int;

wint_t :: _c.ushort;

wctype_t :: _c.ushort;

__time32_t :: _c.long;

__time64_t :: i64;

__crt_locale_data_public :: struct {
    _locale_pctype      : ^_c.ushort,
    _locale_mb_cur_max  : _c.int,
    _locale_lc_codepage : _c.uint,
};

__crt_locale_pointers :: struct {
    locinfo : ^__crt_locale_data,
    mbcinfo : ^__crt_multibyte_data,
};

_locale_t :: ^__crt_locale_pointers;

_Mbstatet :: struct {
    _Wchar : _c.ulong,
    _Byte  : _c.ushort,
    _State : _c.ushort,
};

mbstate_t :: _Mbstatet;

time_t :: __time64_t;

rsize_t :: _c.size_t;

POINTER_64_INT :: u64;

INT8 :: _c.schar;
PINT8 :: ^_c.schar;

INT16 :: _c.short;
PINT16 :: ^_c.short;

INT32 :: _c.int;
PINT32 :: ^_c.int;

INT64 :: i64;
PINT64 :: ^i64;

UINT8 :: _c.uchar;
PUINT8 :: ^_c.uchar;

UINT16 :: _c.ushort;
PUINT16 :: ^_c.ushort;

UINT32 :: _c.uint;
PUINT32 :: ^_c.uint;

UINT64 :: u64;
PUINT64 :: ^u64;

LONG32 :: _c.int;
PLONG32 :: ^_c.int;

ULONG32 :: _c.uint;
PULONG32 :: ^_c.uint;

DWORD32 :: _c.uint;
PDWORD32 :: ^_c.uint;

INT_PTR :: i64;
PINT_PTR :: ^i64;

UINT_PTR :: u64;
PUINT_PTR :: ^u64;

LONG_PTR :: i64;
PLONG_PTR :: ^i64;

ULONG_PTR :: u64;
PULONG_PTR :: ^u64;

SHANDLE_PTR :: i64;

HANDLE_PTR :: u64;

UHALF_PTR :: _c.uint;
PUHALF_PTR :: ^_c.uint;

HALF_PTR :: _c.int;
PHALF_PTR :: ^_c.int;

SIZE_T :: ULONG_PTR;
PSIZE_T :: ^ULONG_PTR;

SSIZE_T :: LONG_PTR;
PSSIZE_T :: ^LONG_PTR;

DWORD_PTR :: ULONG_PTR;
PDWORD_PTR :: ^ULONG_PTR;

LONG64 :: i64;
PLONG64 :: ^i64;

ULONG64 :: u64;
PULONG64 :: ^u64;

DWORD64 :: u64;
PDWORD64 :: ^u64;

KAFFINITY :: ULONG_PTR;

PKAFFINITY :: ^KAFFINITY;

PVOID :: rawptr;

PVOID64 :: rawptr;

CHAR :: _c.uchar;

SHORT :: _c.short;

LONG :: _c.long;

;

WCHAR :: _c.wchar_t;

PWCHAR :: ^WCHAR;
LPWCH :: ^WCHAR;
PWCH :: ^WCHAR;

LPCWCH :: ^WCHAR;
PCWCH :: ^WCHAR;

NWPSTR :: ^WCHAR;
LPWSTR :: ^WCHAR;
PWSTR :: ^WCHAR;

PZPWSTR :: ^PWSTR;

PCZPWSTR :: ^PWSTR;

LPUWSTR :: ^WCHAR;
PUWSTR :: ^WCHAR;

LPCWSTR :: ^WCHAR;
PCWSTR :: ^WCHAR;

PZPCWSTR :: ^PCWSTR;

PCZPCWSTR :: ^PCWSTR;

LPCUWSTR :: ^WCHAR;
PCUWSTR :: ^WCHAR;

PZZWSTR :: ^WCHAR;

PCZZWSTR :: ^WCHAR;

PUZZWSTR :: ^WCHAR;

PCUZZWSTR :: ^WCHAR;

PNZWCH :: ^WCHAR;

PCNZWCH :: ^WCHAR;

PUNZWCH :: ^WCHAR;

PCUNZWCH :: ^WCHAR;

LPCWCHAR :: ^WCHAR;
PCWCHAR :: ^WCHAR;

LPCUWCHAR :: ^WCHAR;
PCUWCHAR :: ^WCHAR;

UCSCHAR :: _c.ulong;

PUCSCHAR :: ^UCSCHAR;

PCUCSCHAR :: ^UCSCHAR;

PUCSSTR :: ^UCSCHAR;

PUUCSSTR :: ^UCSCHAR;

PCUCSSTR :: ^UCSCHAR;

PCUUCSSTR :: ^UCSCHAR;

PUUCSCHAR :: ^UCSCHAR;

PCUUCSCHAR :: ^UCSCHAR;

PCHAR :: ^CHAR;
LPCH :: ^CHAR;
PCH :: ^CHAR;

LPCCH :: ^CHAR;
PCCH :: ^CHAR;

NPSTR :: ^CHAR;
LPSTR :: ^CHAR;
PSTR :: ^CHAR;

PZPSTR :: ^PSTR;

PCZPSTR :: ^PSTR;

LPCSTR :: ^CHAR;
PCSTR :: ^CHAR;

PZPCSTR :: ^PCSTR;

PCZPCSTR :: ^PCSTR;

PZZSTR :: ^CHAR;

PCZZSTR :: ^CHAR;

PNZCH :: ^CHAR;

PCNZCH :: ^CHAR;

TCHAR :: _c.uchar;
PTCHAR :: ^_c.uchar;

TBYTE :: _c.uchar;
PTBYTE :: ^_c.uchar;

LPTCH :: LPCH;
PTCH :: LPCH;

LPCTCH :: LPCCH;
PCTCH :: LPCCH;

PTSTR :: LPSTR;
LPTSTR :: LPSTR;
PUTSTR :: LPSTR;
LPUTSTR :: LPSTR;

PCTSTR :: LPCSTR;
LPCTSTR :: LPCSTR;
PCUTSTR :: LPCSTR;
LPCUTSTR :: LPCSTR;

PZZTSTR :: PZZSTR;
PUZZTSTR :: PZZSTR;

PCZZTSTR :: PCZZSTR;
PCUZZTSTR :: PCZZSTR;

PZPTSTR :: PZPSTR;

PNZTCH :: PNZCH;
PUNZTCH :: PNZCH;

PCNZTCH :: PCNZCH;
PCUNZTCH :: PCNZCH;

PSHORT :: ^SHORT;

PLONG :: ^LONG;

PROCESSOR_NUMBER :: struct {
    Group    : WORD,
    Number   : BYTE,
    Reserved : BYTE,
};
PPROCESSOR_NUMBER :: ^PROCESSOR_NUMBER;

GROUP_AFFINITY :: struct {
    Mask     : KAFFINITY,
    Group    : WORD,
    Reserved : [3]WORD,
};
PGROUP_AFFINITY :: ^GROUP_AFFINITY;

HANDLE :: rawptr;

PHANDLE :: ^HANDLE;

FCHAR :: BYTE;

FSHORT :: WORD;

FLONG :: DWORD;

HRESULT :: _c.long;

CCHAR :: _c.uchar;

LCID :: DWORD;

PLCID :: PDWORD;

LANGID :: WORD;

/* COMPARTMENT_ID :: enum { */
COMPARTMENT_ID :: _c.int;
    UNSPECIFIED_COMPARTMENT_ID :: 0;
    DEFAULT_COMPARTMENT_ID :: UNSPECIFIED_COMPARTMENT_ID + 1;
/* } */
PCOMPARTMENT_ID :: ^COMPARTMENT_ID;

FLOAT128 :: struct {
    LowPart  : i64,
    HighPart : i64,
};

PFLOAT128 :: ^FLOAT128;

LONGLONG :: i64;

ULONGLONG :: u64;

PLONGLONG :: ^LONGLONG;

PULONGLONG :: ^ULONGLONG;

USN :: LONGLONG;

LARGE_INTEGER :: struct #raw_union {
    s : struct {
        LowPart  : DWORD,
        HighPart : LONG,
    },
    u : struct {
        LowPart  : DWORD,
        HighPart : LONG,
    },
    QuadPart : LONGLONG,
};

PLARGE_INTEGER :: ^LARGE_INTEGER;

ULARGE_INTEGER :: struct #raw_union {
    s : struct {
        LowPart  : DWORD,
        HighPart : DWORD,
    },
    u : struct {
        LowPart  : DWORD,
        HighPart : DWORD,
    },
    QuadPart : ULONGLONG,
};

PULARGE_INTEGER :: ^ULARGE_INTEGER;

RTL_REFERENCE_COUNT :: LONG_PTR;
PRTL_REFERENCE_COUNT :: ^LONG_PTR;

RTL_REFERENCE_COUNT32 :: LONG;
PRTL_REFERENCE_COUNT32 :: ^LONG;

LUID :: struct {
    LowPart  : DWORD,
    HighPart : LONG,
};
PLUID :: ^LUID;

DWORDLONG :: ULONGLONG;

PDWORDLONG :: ^DWORDLONG;

BOOLEAN :: BYTE;

PBOOLEAN :: ^BOOLEAN;

LIST_ENTRY :: struct {
    Flink : ^LIST_ENTRY,
    Blink : ^LIST_ENTRY,
};
PLIST_ENTRY :: ^LIST_ENTRY;
PRLIST_ENTRY :: ^LIST_ENTRY;

SINGLE_LIST_ENTRY :: struct {
    Next : ^SINGLE_LIST_ENTRY,
};
PSINGLE_LIST_ENTRY :: ^SINGLE_LIST_ENTRY;

LIST_ENTRY32 :: struct {
    Flink : DWORD,
    Blink : DWORD,
};

PLIST_ENTRY32 :: ^LIST_ENTRY32;

LIST_ENTRY64 :: struct {
    Flink : ULONGLONG,
    Blink : ULONGLONG,
};

PLIST_ENTRY64 :: ^LIST_ENTRY64;

GUID :: struct {
    Data1 : _c.ulong,
    Data2 : _c.ushort,
    Data3 : _c.ushort,
    Data4 : [8]_c.uchar,
};

LPGUID :: ^GUID;

LPCGUID :: ^GUID;

IID :: GUID;

LPIID :: ^IID;

CLSID :: GUID;

LPCLSID :: ^CLSID;

FMTID :: GUID;

LPFMTID :: ^FMTID;

OBJECTID :: struct {
    Lineage    : GUID,
    Uniquifier : DWORD,
};

EXCEPTION_ROUTINE :: #type (proc "stdcall" (ExceptionRecord : ^EXCEPTION_RECORD, EstablisherFrame : PVOID, ContextRecord : ^CONTEXT, DispatcherContext : PVOID) -> EXCEPTION_DISPOSITION);

PEXCEPTION_ROUTINE :: ^EXCEPTION_ROUTINE;

KSPIN_LOCK :: ULONG_PTR;

PKSPIN_LOCK :: ^KSPIN_LOCK;

M128A :: struct {
    Low  : ULONGLONG,
    High : LONGLONG,
};
PM128A :: ^M128A;

XSAVE_FORMAT :: struct {
    ControlWord    : WORD,
    StatusWord     : WORD,
    TagWord        : BYTE,
    Reserved1      : BYTE,
    ErrorOpcode    : WORD,
    ErrorOffset    : DWORD,
    ErrorSelector  : WORD,
    Reserved2      : WORD,
    DataOffset     : DWORD,
    DataSelector   : WORD,
    Reserved3      : WORD,
    MxCsr          : DWORD,
    MxCsr_Mask     : DWORD,
    FloatRegisters : [8]M128A,
    XmmRegisters   : [16]M128A,
    Reserved4      : [96]BYTE,
};
PXSAVE_FORMAT :: ^XSAVE_FORMAT;

XSAVE_CET_U_FORMAT :: struct {
    Ia32CetUMsr   : DWORD64,
    Ia32Pl3SspMsr : DWORD64,
};
PXSAVE_CET_U_FORMAT :: ^XSAVE_CET_U_FORMAT;

XSAVE_AREA_HEADER :: struct {
    Mask           : DWORD64,
    CompactionMask : DWORD64,
    Reserved2      : [6]DWORD64,
};
PXSAVE_AREA_HEADER :: ^XSAVE_AREA_HEADER;

XSAVE_AREA :: struct {
    LegacyState : XSAVE_FORMAT,
    Header      : XSAVE_AREA_HEADER,
};
PXSAVE_AREA :: ^XSAVE_AREA;

XSTATE_CONTEXT :: struct {
    Mask      : DWORD64,
    Length    : DWORD,
    Reserved1 : DWORD,
    Area      : PXSAVE_AREA,
    Buffer    : PVOID,
};
PXSTATE_CONTEXT :: ^XSTATE_CONTEXT;

SCOPE_TABLE_AMD64 :: struct {
    Count       : DWORD,
    ScopeRecord : [1]struct {
    BeginAddress   : DWORD,
    EndAddress     : DWORD,
    HandlerAddress : DWORD,
    JumpTarget     : DWORD,
},
};
PSCOPE_TABLE_AMD64 :: ^SCOPE_TABLE_AMD64;

XMM_SAVE_AREA32 :: XSAVE_FORMAT;
PXMM_SAVE_AREA32 :: ^XSAVE_FORMAT;

CONTEXT :: struct {
    P1Home               : DWORD64,
    P2Home               : DWORD64,
    P3Home               : DWORD64,
    P4Home               : DWORD64,
    P5Home               : DWORD64,
    P6Home               : DWORD64,
    ContextFlags         : DWORD,
    MxCsr                : DWORD,
    SegCs                : WORD,
    SegDs                : WORD,
    SegEs                : WORD,
    SegFs                : WORD,
    SegGs                : WORD,
    SegSs                : WORD,
    EFlags               : DWORD,
    Dr0                  : DWORD64,
    Dr1                  : DWORD64,
    Dr2                  : DWORD64,
    Dr3                  : DWORD64,
    Dr6                  : DWORD64,
    Dr7                  : DWORD64,
    Rax                  : DWORD64,
    Rcx                  : DWORD64,
    Rdx                  : DWORD64,
    Rbx                  : DWORD64,
    Rsp                  : DWORD64,
    Rbp                  : DWORD64,
    Rsi                  : DWORD64,
    Rdi                  : DWORD64,
    R8                   : DWORD64,
    R9                   : DWORD64,
    R10                  : DWORD64,
    R11                  : DWORD64,
    R12                  : DWORD64,
    R13                  : DWORD64,
    R14                  : DWORD64,
    R15                  : DWORD64,
    Rip                  : DWORD64,
    u : struct #raw_union {
        FltSave : XMM_SAVE_AREA32,
        s : struct {
            Header : [2]M128A,
            Legacy : [8]M128A,
            Xmm0   : M128A,
            Xmm1   : M128A,
            Xmm2   : M128A,
            Xmm3   : M128A,
            Xmm4   : M128A,
            Xmm5   : M128A,
            Xmm6   : M128A,
            Xmm7   : M128A,
            Xmm8   : M128A,
            Xmm9   : M128A,
            Xmm10  : M128A,
            Xmm11  : M128A,
            Xmm12  : M128A,
            Xmm13  : M128A,
            Xmm14  : M128A,
            Xmm15  : M128A,
        },
    },
    VectorRegister       : [26]M128A,
    VectorControl        : DWORD64,
    DebugControl         : DWORD64,
    LastBranchToRip      : DWORD64,
    LastBranchFromRip    : DWORD64,
    LastExceptionToRip   : DWORD64,
    LastExceptionFromRip : DWORD64,
};
PCONTEXT :: ^CONTEXT;

RUNTIME_FUNCTION :: _IMAGE_RUNTIME_FUNCTION_ENTRY;
PRUNTIME_FUNCTION :: ^_IMAGE_RUNTIME_FUNCTION_ENTRY;

SCOPE_TABLE :: SCOPE_TABLE_AMD64;
PSCOPE_TABLE :: ^SCOPE_TABLE_AMD64;

UNWIND_HISTORY_TABLE_ENTRY :: struct {
    ImageBase     : DWORD64,
    FunctionEntry : PRUNTIME_FUNCTION,
};
PUNWIND_HISTORY_TABLE_ENTRY :: ^UNWIND_HISTORY_TABLE_ENTRY;

UNWIND_HISTORY_TABLE :: struct {
    Count       : DWORD,
    LocalHint   : BYTE,
    GlobalHint  : BYTE,
    Search      : BYTE,
    Once        : BYTE,
    LowAddress  : DWORD64,
    HighAddress : DWORD64,
    Entry       : [12]UNWIND_HISTORY_TABLE_ENTRY,
};
PUNWIND_HISTORY_TABLE :: ^UNWIND_HISTORY_TABLE;

GET_RUNTIME_FUNCTION_CALLBACK :: #type (proc(ControlPc : DWORD64, Context : PVOID) -> PRUNTIME_FUNCTION);

PGET_RUNTIME_FUNCTION_CALLBACK :: ^GET_RUNTIME_FUNCTION_CALLBACK;

OUT_OF_PROCESS_FUNCTION_TABLE_CALLBACK :: #type (proc(Process : HANDLE, TableAddress : PVOID, Entries : PDWORD, Functions : ^PRUNTIME_FUNCTION) -> DWORD);

POUT_OF_PROCESS_FUNCTION_TABLE_CALLBACK :: ^OUT_OF_PROCESS_FUNCTION_TABLE_CALLBACK;

DISPATCHER_CONTEXT :: struct {
    ControlPc        : DWORD64,
    ImageBase        : DWORD64,
    FunctionEntry    : PRUNTIME_FUNCTION,
    EstablisherFrame : DWORD64,
    TargetIp         : DWORD64,
    ContextRecord    : PCONTEXT,
    LanguageHandler  : PEXCEPTION_ROUTINE,
    HandlerData      : PVOID,
    HistoryTable     : PUNWIND_HISTORY_TABLE,
    ScopeIndex       : DWORD,
    Fill0            : DWORD,
};
PDISPATCHER_CONTEXT :: ^DISPATCHER_CONTEXT;

PEXCEPTION_FILTER :: (proc(ExceptionPointers : ^EXCEPTION_POINTERS, EstablisherFrame : PVOID) -> LONG);

PTERMINATION_HANDLER :: proc(_abnormal_termination : BOOLEAN, EstablisherFrame : PVOID);

KNONVOLATILE_CONTEXT_POINTERS :: struct {
    u : struct #raw_union {
        FloatingContext : [16]PM128A,
        s : struct {
            Xmm0  : PM128A,
            Xmm1  : PM128A,
            Xmm2  : PM128A,
            Xmm3  : PM128A,
            Xmm4  : PM128A,
            Xmm5  : PM128A,
            Xmm6  : PM128A,
            Xmm7  : PM128A,
            Xmm8  : PM128A,
            Xmm9  : PM128A,
            Xmm10 : PM128A,
            Xmm11 : PM128A,
            Xmm12 : PM128A,
            Xmm13 : PM128A,
            Xmm14 : PM128A,
            Xmm15 : PM128A,
        },
    },
    u2 : struct #raw_union {
        IntegerContext : [16]PDWORD64,
        s : struct {
            Rax : PDWORD64,
            Rcx : PDWORD64,
            Rdx : PDWORD64,
            Rbx : PDWORD64,
            Rsp : PDWORD64,
            Rbp : PDWORD64,
            Rsi : PDWORD64,
            Rdi : PDWORD64,
            R8  : PDWORD64,
            R9  : PDWORD64,
            R10 : PDWORD64,
            R11 : PDWORD64,
            R12 : PDWORD64,
            R13 : PDWORD64,
            R14 : PDWORD64,
            R15 : PDWORD64,
        },
    },
};
PKNONVOLATILE_CONTEXT_POINTERS :: ^KNONVOLATILE_CONTEXT_POINTERS;

SCOPE_TABLE_ARM :: struct {
    Count       : DWORD,
    ScopeRecord : [1]struct {
    BeginAddress   : DWORD,
    EndAddress     : DWORD,
    HandlerAddress : DWORD,
    JumpTarget     : DWORD,
},
};
PSCOPE_TABLE_ARM :: ^SCOPE_TABLE_ARM;

SCOPE_TABLE_ARM64 :: struct {
    Count       : DWORD,
    ScopeRecord : [1]struct {
    BeginAddress   : DWORD,
    EndAddress     : DWORD,
    HandlerAddress : DWORD,
    JumpTarget     : DWORD,
},
};
PSCOPE_TABLE_ARM64 :: ^SCOPE_TABLE_ARM64;

KNONVOLATILE_CONTEXT_POINTERS_ARM64 :: struct {
    X19 : PDWORD64,
    X20 : PDWORD64,
    X21 : PDWORD64,
    X22 : PDWORD64,
    X23 : PDWORD64,
    X24 : PDWORD64,
    X25 : PDWORD64,
    X26 : PDWORD64,
    X27 : PDWORD64,
    X28 : PDWORD64,
    Fp  : PDWORD64,
    Lr  : PDWORD64,
    D8  : PDWORD64,
    D9  : PDWORD64,
    D10 : PDWORD64,
    D11 : PDWORD64,
    D12 : PDWORD64,
    D13 : PDWORD64,
    D14 : PDWORD64,
    D15 : PDWORD64,
};
PKNONVOLATILE_CONTEXT_POINTERS_ARM64 :: ^KNONVOLATILE_CONTEXT_POINTERS_ARM64;

LDT_ENTRY :: struct {
    LimitLow : WORD,
    BaseLow  : WORD,
    HighWord : struct #raw_union {
        Bytes : struct {
            BaseMid : BYTE,
            Flags1  : BYTE,
            Flags2  : BYTE,
            BaseHi  : BYTE,
        },
        Bits : bit_field {
            BaseMid     : 8,
            Type        : 5,
            Dpl         : 2,
            Pres        : 1,
            LimitHi     : 4,
            Sys         : 1,
            Reserved_0  : 1,
            Default_Big : 1,
            Granularity : 1,
            BaseHi      : 8,
        },
    },
};
PLDT_ENTRY :: ^LDT_ENTRY;

WOW64_FLOATING_SAVE_AREA :: struct {
    ControlWord   : DWORD,
    StatusWord    : DWORD,
    TagWord       : DWORD,
    ErrorOffset   : DWORD,
    ErrorSelector : DWORD,
    DataOffset    : DWORD,
    DataSelector  : DWORD,
    RegisterArea  : [80]BYTE,
    Cr0NpxState   : DWORD,
};

PWOW64_FLOATING_SAVE_AREA :: ^WOW64_FLOATING_SAVE_AREA;

WOW64_CONTEXT :: struct {
    ContextFlags      : DWORD,
    Dr0               : DWORD,
    Dr1               : DWORD,
    Dr2               : DWORD,
    Dr3               : DWORD,
    Dr6               : DWORD,
    Dr7               : DWORD,
    FloatSave         : WOW64_FLOATING_SAVE_AREA,
    SegGs             : DWORD,
    SegFs             : DWORD,
    SegEs             : DWORD,
    SegDs             : DWORD,
    Edi               : DWORD,
    Esi               : DWORD,
    Ebx               : DWORD,
    Edx               : DWORD,
    Ecx               : DWORD,
    Eax               : DWORD,
    Ebp               : DWORD,
    Eip               : DWORD,
    SegCs             : DWORD,
    EFlags            : DWORD,
    Esp               : DWORD,
    SegSs             : DWORD,
    ExtendedRegisters : [512]BYTE,
};

PWOW64_CONTEXT :: ^WOW64_CONTEXT;

WOW64_LDT_ENTRY :: struct {
    LimitLow : WORD,
    BaseLow  : WORD,
    HighWord : struct #raw_union {
        Bytes : struct {
            BaseMid : BYTE,
            Flags1  : BYTE,
            Flags2  : BYTE,
            BaseHi  : BYTE,
        },
        Bits : bit_field {
            BaseMid     : 8,
            Type        : 5,
            Dpl         : 2,
            Pres        : 1,
            LimitHi     : 4,
            Sys         : 1,
            Reserved_0  : 1,
            Default_Big : 1,
            Granularity : 1,
            BaseHi      : 8,
        },
    },
};
PWOW64_LDT_ENTRY :: ^WOW64_LDT_ENTRY;

WOW64_DESCRIPTOR_TABLE_ENTRY :: struct {
    Selector   : DWORD,
    Descriptor : WOW64_LDT_ENTRY,
};
PWOW64_DESCRIPTOR_TABLE_ENTRY :: ^WOW64_DESCRIPTOR_TABLE_ENTRY;

EXCEPTION_RECORD :: struct {
    ExceptionCode        : DWORD,
    ExceptionFlags       : DWORD,
    ExceptionRecord      : ^EXCEPTION_RECORD,
    ExceptionAddress     : PVOID,
    NumberParameters     : DWORD,
    ExceptionInformation : [15]ULONG_PTR,
};

PEXCEPTION_RECORD :: ^EXCEPTION_RECORD;

EXCEPTION_RECORD32 :: struct {
    ExceptionCode        : DWORD,
    ExceptionFlags       : DWORD,
    ExceptionRecord      : DWORD,
    ExceptionAddress     : DWORD,
    NumberParameters     : DWORD,
    ExceptionInformation : [15]DWORD,
};
PEXCEPTION_RECORD32 :: ^EXCEPTION_RECORD32;

EXCEPTION_RECORD64 :: struct {
    ExceptionCode        : DWORD,
    ExceptionFlags       : DWORD,
    ExceptionRecord      : DWORD64,
    ExceptionAddress     : DWORD64,
    NumberParameters     : DWORD,
    __unusedAlignment    : DWORD,
    ExceptionInformation : [15]DWORD64,
};
PEXCEPTION_RECORD64 :: ^EXCEPTION_RECORD64;

EXCEPTION_POINTERS :: struct {
    ExceptionRecord : PEXCEPTION_RECORD,
    ContextRecord   : PCONTEXT,
};
PEXCEPTION_POINTERS :: ^EXCEPTION_POINTERS;

PACCESS_TOKEN :: PVOID;

PSECURITY_DESCRIPTOR :: PVOID;

PSID :: PVOID;

PCLAIMS_BLOB :: PVOID;

ACCESS_MASK :: DWORD;

PACCESS_MASK :: ^ACCESS_MASK;

GENERIC_MAPPING :: struct {
    GenericRead    : ACCESS_MASK,
    GenericWrite   : ACCESS_MASK,
    GenericExecute : ACCESS_MASK,
    GenericAll     : ACCESS_MASK,
};

PGENERIC_MAPPING :: ^GENERIC_MAPPING;

LUID_AND_ATTRIBUTES :: struct {
    Luid       : LUID,
    Attributes : DWORD,
};
PLUID_AND_ATTRIBUTES :: ^LUID_AND_ATTRIBUTES;

LUID_AND_ATTRIBUTES_ARRAY :: [1]LUID_AND_ATTRIBUTES;

PLUID_AND_ATTRIBUTES_ARRAY :: ^LUID_AND_ATTRIBUTES_ARRAY;

SID_IDENTIFIER_AUTHORITY :: struct {
    Value : [6]BYTE,
};
PSID_IDENTIFIER_AUTHORITY :: ^SID_IDENTIFIER_AUTHORITY;

SID :: struct {
    Revision            : BYTE,
    SubAuthorityCount   : BYTE,
    IdentifierAuthority : SID_IDENTIFIER_AUTHORITY,
    SubAuthority        : [1]DWORD,
};
PISID :: ^SID;

SE_SID :: struct #raw_union {
    Sid    : SID,
    Buffer : [(size_of(SID) - size_of(DWORD) + ((15) * size_of(DWORD)))]BYTE,
};
PSE_SID :: ^SE_SID;

/* SID_NAME_USE :: enum { */
SID_NAME_USE :: _c.int;
    SidTypeUser :: 1;
    SidTypeGroup :: SidTypeUser + 1;
    SidTypeDomain :: SidTypeGroup + 1;
    SidTypeAlias :: SidTypeDomain + 1;
    SidTypeWellKnownGroup :: SidTypeAlias + 1;
    SidTypeDeletedAccount :: SidTypeWellKnownGroup + 1;
    SidTypeInvalid :: SidTypeDeletedAccount + 1;
    SidTypeUnknown :: SidTypeInvalid + 1;
    SidTypeComputer :: SidTypeUnknown + 1;
    SidTypeLabel :: SidTypeComputer + 1;
    SidTypeLogonSession :: SidTypeLabel + 1;
/* } */
PSID_NAME_USE :: ^SID_NAME_USE;

SID_AND_ATTRIBUTES :: struct {
    Sid        : PSID,
    Attributes : DWORD,
};
PSID_AND_ATTRIBUTES :: ^SID_AND_ATTRIBUTES;

SID_AND_ATTRIBUTES_ARRAY :: [1]SID_AND_ATTRIBUTES;

PSID_AND_ATTRIBUTES_ARRAY :: ^SID_AND_ATTRIBUTES_ARRAY;

SID_HASH_ENTRY :: ULONG_PTR;
PSID_HASH_ENTRY :: ^ULONG_PTR;

SID_AND_ATTRIBUTES_HASH :: struct {
    SidCount : DWORD,
    SidAttr  : PSID_AND_ATTRIBUTES,
    Hash     : [32]SID_HASH_ENTRY,
};
PSID_AND_ATTRIBUTES_HASH :: ^SID_AND_ATTRIBUTES_HASH;

/* WELL_KNOWN_SID_TYPE :: enum { */
WELL_KNOWN_SID_TYPE :: _c.int;
    WinNullSid :: 0;
    WinWorldSid :: 1;
    WinLocalSid :: 2;
    WinCreatorOwnerSid :: 3;
    WinCreatorGroupSid :: 4;
    WinCreatorOwnerServerSid :: 5;
    WinCreatorGroupServerSid :: 6;
    WinNtAuthoritySid :: 7;
    WinDialupSid :: 8;
    WinNetworkSid :: 9;
    WinBatchSid :: 10;
    WinInteractiveSid :: 11;
    WinServiceSid :: 12;
    WinAnonymousSid :: 13;
    WinProxySid :: 14;
    WinEnterpriseControllersSid :: 15;
    WinSelfSid :: 16;
    WinAuthenticatedUserSid :: 17;
    WinRestrictedCodeSid :: 18;
    WinTerminalServerSid :: 19;
    WinRemoteLogonIdSid :: 20;
    WinLogonIdsSid :: 21;
    WinLocalSystemSid :: 22;
    WinLocalServiceSid :: 23;
    WinNetworkServiceSid :: 24;
    WinBuiltinDomainSid :: 25;
    WinBuiltinAdministratorsSid :: 26;
    WinBuiltinUsersSid :: 27;
    WinBuiltinGuestsSid :: 28;
    WinBuiltinPowerUsersSid :: 29;
    WinBuiltinAccountOperatorsSid :: 30;
    WinBuiltinSystemOperatorsSid :: 31;
    WinBuiltinPrintOperatorsSid :: 32;
    WinBuiltinBackupOperatorsSid :: 33;
    WinBuiltinReplicatorSid :: 34;
    WinBuiltinPreWindows2000CompatibleAccessSid :: 35;
    WinBuiltinRemoteDesktopUsersSid :: 36;
    WinBuiltinNetworkConfigurationOperatorsSid :: 37;
    WinAccountAdministratorSid :: 38;
    WinAccountGuestSid :: 39;
    WinAccountKrbtgtSid :: 40;
    WinAccountDomainAdminsSid :: 41;
    WinAccountDomainUsersSid :: 42;
    WinAccountDomainGuestsSid :: 43;
    WinAccountComputersSid :: 44;
    WinAccountControllersSid :: 45;
    WinAccountCertAdminsSid :: 46;
    WinAccountSchemaAdminsSid :: 47;
    WinAccountEnterpriseAdminsSid :: 48;
    WinAccountPolicyAdminsSid :: 49;
    WinAccountRasAndIasServersSid :: 50;
    WinNTLMAuthenticationSid :: 51;
    WinDigestAuthenticationSid :: 52;
    WinSChannelAuthenticationSid :: 53;
    WinThisOrganizationSid :: 54;
    WinOtherOrganizationSid :: 55;
    WinBuiltinIncomingForestTrustBuildersSid :: 56;
    WinBuiltinPerfMonitoringUsersSid :: 57;
    WinBuiltinPerfLoggingUsersSid :: 58;
    WinBuiltinAuthorizationAccessSid :: 59;
    WinBuiltinTerminalServerLicenseServersSid :: 60;
    WinBuiltinDCOMUsersSid :: 61;
    WinBuiltinIUsersSid :: 62;
    WinIUserSid :: 63;
    WinBuiltinCryptoOperatorsSid :: 64;
    WinUntrustedLabelSid :: 65;
    WinLowLabelSid :: 66;
    WinMediumLabelSid :: 67;
    WinHighLabelSid :: 68;
    WinSystemLabelSid :: 69;
    WinWriteRestrictedCodeSid :: 70;
    WinCreatorOwnerRightsSid :: 71;
    WinCacheablePrincipalsGroupSid :: 72;
    WinNonCacheablePrincipalsGroupSid :: 73;
    WinEnterpriseReadonlyControllersSid :: 74;
    WinAccountReadonlyControllersSid :: 75;
    WinBuiltinEventLogReadersGroup :: 76;
    WinNewEnterpriseReadonlyControllersSid :: 77;
    WinBuiltinCertSvcDComAccessGroup :: 78;
    WinMediumPlusLabelSid :: 79;
    WinLocalLogonSid :: 80;
    WinConsoleLogonSid :: 81;
    WinThisOrganizationCertificateSid :: 82;
    WinApplicationPackageAuthoritySid :: 83;
    WinBuiltinAnyPackageSid :: 84;
    WinCapabilityInternetClientSid :: 85;
    WinCapabilityInternetClientServerSid :: 86;
    WinCapabilityPrivateNetworkClientServerSid :: 87;
    WinCapabilityPicturesLibrarySid :: 88;
    WinCapabilityVideosLibrarySid :: 89;
    WinCapabilityMusicLibrarySid :: 90;
    WinCapabilityDocumentsLibrarySid :: 91;
    WinCapabilitySharedUserCertificatesSid :: 92;
    WinCapabilityEnterpriseAuthenticationSid :: 93;
    WinCapabilityRemovableStorageSid :: 94;
    WinBuiltinRDSRemoteAccessServersSid :: 95;
    WinBuiltinRDSEndpointServersSid :: 96;
    WinBuiltinRDSManagementServersSid :: 97;
    WinUserModeDriversSid :: 98;
    WinBuiltinHyperVAdminsSid :: 99;
    WinAccountCloneableControllersSid :: 100;
    WinBuiltinAccessControlAssistanceOperatorsSid :: 101;
    WinBuiltinRemoteManagementUsersSid :: 102;
    WinAuthenticationAuthorityAssertedSid :: 103;
    WinAuthenticationServiceAssertedSid :: 104;
    WinLocalAccountSid :: 105;
    WinLocalAccountAndAdministratorSid :: 106;
    WinAccountProtectedUsersSid :: 107;
    WinCapabilityAppointmentsSid :: 108;
    WinCapabilityContactsSid :: 109;
    WinAccountDefaultSystemManagedSid :: 110;
    WinBuiltinDefaultSystemManagedGroupSid :: 111;
    WinBuiltinStorageReplicaAdminsSid :: 112;
    WinAccountKeyAdminsSid :: 113;
    WinAccountEnterpriseKeyAdminsSid :: 114;
    WinAuthenticationKeyTrustSid :: 115;
    WinAuthenticationKeyPropertyMFASid :: 116;
    WinAuthenticationKeyPropertyAttestationSid :: 117;
    WinAuthenticationFreshKeyAuthSid :: 118;
    WinBuiltinDeviceOwnersSid :: 119;
/* } */
;

ACL :: struct {
    AclRevision : BYTE,
    Sbz1        : BYTE,
    AclSize     : WORD,
    AceCount    : WORD,
    Sbz2        : WORD,
};

PACL :: ^ACL;

ACE_HEADER :: struct {
    AceType  : BYTE,
    AceFlags : BYTE,
    AceSize  : WORD,
};

PACE_HEADER :: ^ACE_HEADER;

ACCESS_ALLOWED_ACE :: struct {
    Header   : ACE_HEADER,
    Mask     : ACCESS_MASK,
    SidStart : DWORD,
};

PACCESS_ALLOWED_ACE :: ^ACCESS_ALLOWED_ACE;

ACCESS_DENIED_ACE :: struct {
    Header   : ACE_HEADER,
    Mask     : ACCESS_MASK,
    SidStart : DWORD,
};

PACCESS_DENIED_ACE :: ^ACCESS_DENIED_ACE;

SYSTEM_AUDIT_ACE :: struct {
    Header   : ACE_HEADER,
    Mask     : ACCESS_MASK,
    SidStart : DWORD,
};

PSYSTEM_AUDIT_ACE :: ^SYSTEM_AUDIT_ACE;

SYSTEM_ALARM_ACE :: struct {
    Header   : ACE_HEADER,
    Mask     : ACCESS_MASK,
    SidStart : DWORD,
};

PSYSTEM_ALARM_ACE :: ^SYSTEM_ALARM_ACE;

SYSTEM_RESOURCE_ATTRIBUTE_ACE :: struct {
    Header   : ACE_HEADER,
    Mask     : ACCESS_MASK,
    SidStart : DWORD,
};
PSYSTEM_RESOURCE_ATTRIBUTE_ACE :: ^SYSTEM_RESOURCE_ATTRIBUTE_ACE;

SYSTEM_SCOPED_POLICY_ID_ACE :: struct {
    Header   : ACE_HEADER,
    Mask     : ACCESS_MASK,
    SidStart : DWORD,
};
PSYSTEM_SCOPED_POLICY_ID_ACE :: ^SYSTEM_SCOPED_POLICY_ID_ACE;

SYSTEM_MANDATORY_LABEL_ACE :: struct {
    Header   : ACE_HEADER,
    Mask     : ACCESS_MASK,
    SidStart : DWORD,
};
PSYSTEM_MANDATORY_LABEL_ACE :: ^SYSTEM_MANDATORY_LABEL_ACE;

SYSTEM_PROCESS_TRUST_LABEL_ACE :: struct {
    Header   : ACE_HEADER,
    Mask     : ACCESS_MASK,
    SidStart : DWORD,
};
PSYSTEM_PROCESS_TRUST_LABEL_ACE :: ^SYSTEM_PROCESS_TRUST_LABEL_ACE;

SYSTEM_ACCESS_FILTER_ACE :: struct {
    Header   : ACE_HEADER,
    Mask     : ACCESS_MASK,
    SidStart : DWORD,
};
PSYSTEM_ACCESS_FILTER_ACE :: ^SYSTEM_ACCESS_FILTER_ACE;

ACCESS_ALLOWED_OBJECT_ACE :: struct {
    Header              : ACE_HEADER,
    Mask                : ACCESS_MASK,
    Flags               : DWORD,
    ObjectType          : GUID,
    InheritedObjectType : GUID,
    SidStart            : DWORD,
};
PACCESS_ALLOWED_OBJECT_ACE :: ^ACCESS_ALLOWED_OBJECT_ACE;

ACCESS_DENIED_OBJECT_ACE :: struct {
    Header              : ACE_HEADER,
    Mask                : ACCESS_MASK,
    Flags               : DWORD,
    ObjectType          : GUID,
    InheritedObjectType : GUID,
    SidStart            : DWORD,
};
PACCESS_DENIED_OBJECT_ACE :: ^ACCESS_DENIED_OBJECT_ACE;

SYSTEM_AUDIT_OBJECT_ACE :: struct {
    Header              : ACE_HEADER,
    Mask                : ACCESS_MASK,
    Flags               : DWORD,
    ObjectType          : GUID,
    InheritedObjectType : GUID,
    SidStart            : DWORD,
};
PSYSTEM_AUDIT_OBJECT_ACE :: ^SYSTEM_AUDIT_OBJECT_ACE;

SYSTEM_ALARM_OBJECT_ACE :: struct {
    Header              : ACE_HEADER,
    Mask                : ACCESS_MASK,
    Flags               : DWORD,
    ObjectType          : GUID,
    InheritedObjectType : GUID,
    SidStart            : DWORD,
};
PSYSTEM_ALARM_OBJECT_ACE :: ^SYSTEM_ALARM_OBJECT_ACE;

ACCESS_ALLOWED_CALLBACK_ACE :: struct {
    Header   : ACE_HEADER,
    Mask     : ACCESS_MASK,
    SidStart : DWORD,
};
PACCESS_ALLOWED_CALLBACK_ACE :: ^ACCESS_ALLOWED_CALLBACK_ACE;

ACCESS_DENIED_CALLBACK_ACE :: struct {
    Header   : ACE_HEADER,
    Mask     : ACCESS_MASK,
    SidStart : DWORD,
};
PACCESS_DENIED_CALLBACK_ACE :: ^ACCESS_DENIED_CALLBACK_ACE;

SYSTEM_AUDIT_CALLBACK_ACE :: struct {
    Header   : ACE_HEADER,
    Mask     : ACCESS_MASK,
    SidStart : DWORD,
};
PSYSTEM_AUDIT_CALLBACK_ACE :: ^SYSTEM_AUDIT_CALLBACK_ACE;

SYSTEM_ALARM_CALLBACK_ACE :: struct {
    Header   : ACE_HEADER,
    Mask     : ACCESS_MASK,
    SidStart : DWORD,
};
PSYSTEM_ALARM_CALLBACK_ACE :: ^SYSTEM_ALARM_CALLBACK_ACE;

ACCESS_ALLOWED_CALLBACK_OBJECT_ACE :: struct {
    Header              : ACE_HEADER,
    Mask                : ACCESS_MASK,
    Flags               : DWORD,
    ObjectType          : GUID,
    InheritedObjectType : GUID,
    SidStart            : DWORD,
};
PACCESS_ALLOWED_CALLBACK_OBJECT_ACE :: ^ACCESS_ALLOWED_CALLBACK_OBJECT_ACE;

ACCESS_DENIED_CALLBACK_OBJECT_ACE :: struct {
    Header              : ACE_HEADER,
    Mask                : ACCESS_MASK,
    Flags               : DWORD,
    ObjectType          : GUID,
    InheritedObjectType : GUID,
    SidStart            : DWORD,
};
PACCESS_DENIED_CALLBACK_OBJECT_ACE :: ^ACCESS_DENIED_CALLBACK_OBJECT_ACE;

SYSTEM_AUDIT_CALLBACK_OBJECT_ACE :: struct {
    Header              : ACE_HEADER,
    Mask                : ACCESS_MASK,
    Flags               : DWORD,
    ObjectType          : GUID,
    InheritedObjectType : GUID,
    SidStart            : DWORD,
};
PSYSTEM_AUDIT_CALLBACK_OBJECT_ACE :: ^SYSTEM_AUDIT_CALLBACK_OBJECT_ACE;

SYSTEM_ALARM_CALLBACK_OBJECT_ACE :: struct {
    Header              : ACE_HEADER,
    Mask                : ACCESS_MASK,
    Flags               : DWORD,
    ObjectType          : GUID,
    InheritedObjectType : GUID,
    SidStart            : DWORD,
};
PSYSTEM_ALARM_CALLBACK_OBJECT_ACE :: ^SYSTEM_ALARM_CALLBACK_OBJECT_ACE;

/* ACL_INFORMATION_CLASS :: enum { */
ACL_INFORMATION_CLASS :: _c.int;
    AclRevisionInformation :: 1;
    AclSizeInformation :: AclRevisionInformation + 1;
/* } */
;

ACL_REVISION_INFORMATION :: struct {
    AclRevision : DWORD,
};

PACL_REVISION_INFORMATION :: ^ACL_REVISION_INFORMATION;

ACL_SIZE_INFORMATION :: struct {
    AceCount      : DWORD,
    AclBytesInUse : DWORD,
    AclBytesFree  : DWORD,
};

PACL_SIZE_INFORMATION :: ^ACL_SIZE_INFORMATION;

SECURITY_DESCRIPTOR_CONTROL :: WORD;
PSECURITY_DESCRIPTOR_CONTROL :: ^WORD;

SECURITY_DESCRIPTOR_RELATIVE :: struct {
    Revision : BYTE,
    Sbz1     : BYTE,
    Control  : SECURITY_DESCRIPTOR_CONTROL,
    Owner    : DWORD,
    Group    : DWORD,
    Sacl     : DWORD,
    Dacl     : DWORD,
};
PISECURITY_DESCRIPTOR_RELATIVE :: ^SECURITY_DESCRIPTOR_RELATIVE;

SECURITY_DESCRIPTOR :: struct {
    Revision : BYTE,
    Sbz1     : BYTE,
    Control  : SECURITY_DESCRIPTOR_CONTROL,
    Owner    : PSID,
    Group    : PSID,
    Sacl     : PACL,
    Dacl     : PACL,
};
PISECURITY_DESCRIPTOR :: ^SECURITY_DESCRIPTOR;

SECURITY_OBJECT_AI_PARAMS :: struct {
    Size           : DWORD,
    ConstraintMask : DWORD,
};
PSECURITY_OBJECT_AI_PARAMS :: ^SECURITY_OBJECT_AI_PARAMS;

OBJECT_TYPE_LIST :: struct {
    Level      : WORD,
    Sbz        : WORD,
    ObjectType : ^GUID,
};
POBJECT_TYPE_LIST :: ^OBJECT_TYPE_LIST;

/* AUDIT_EVENT_TYPE :: enum { */
AUDIT_EVENT_TYPE :: _c.int;
    AuditEventObjectAccess :: 0;
    AuditEventDirectoryServiceAccess :: AuditEventObjectAccess + 1;
/* } */
PAUDIT_EVENT_TYPE :: ^AUDIT_EVENT_TYPE;

PRIVILEGE_SET :: struct {
    PrivilegeCount : DWORD,
    Control        : DWORD,
    Privilege      : [1]LUID_AND_ATTRIBUTES,
};
PPRIVILEGE_SET :: ^PRIVILEGE_SET;

/* ACCESS_REASON_TYPE :: enum { */
ACCESS_REASON_TYPE :: _c.int;
    AccessReasonNone :: 0x00000000;
    AccessReasonAllowedAce :: 0x00010000;
    AccessReasonDeniedAce :: 0x00020000;
    AccessReasonAllowedParentAce :: 0x00030000;
    AccessReasonDeniedParentAce :: 0x00040000;
    AccessReasonNotGrantedByCape :: 0x00050000;
    AccessReasonNotGrantedByParentCape :: 0x00060000;
    AccessReasonNotGrantedToAppContainer :: 0x00070000;
    AccessReasonMissingPrivilege :: 0x00100000;
    AccessReasonFromPrivilege :: 0x00200000;
    AccessReasonIntegrityLevel :: 0x00300000;
    AccessReasonOwnership :: 0x00400000;
    AccessReasonNullDacl :: 0x00500000;
    AccessReasonEmptyDacl :: 0x00600000;
    AccessReasonNoSD :: 0x00700000;
    AccessReasonNoGrant :: 0x00800000;
    AccessReasonTrustLabel :: 0x00900000;
    AccessReasonFilterAce :: 0x00a00000;
/* } */
;

ACCESS_REASON :: DWORD;

ACCESS_REASONS :: struct {
    Data : [32]ACCESS_REASON,
};
PACCESS_REASONS :: ^ACCESS_REASONS;

SE_SECURITY_DESCRIPTOR :: struct {
    Size               : DWORD,
    Flags              : DWORD,
    SecurityDescriptor : PSECURITY_DESCRIPTOR,
};
PSE_SECURITY_DESCRIPTOR :: ^SE_SECURITY_DESCRIPTOR;

SE_ACCESS_REQUEST :: struct {
    Size                    : DWORD,
    SeSecurityDescriptor    : PSE_SECURITY_DESCRIPTOR,
    DesiredAccess           : ACCESS_MASK,
    PreviouslyGrantedAccess : ACCESS_MASK,
    PrincipalSelfSid        : PSID,
    GenericMapping          : PGENERIC_MAPPING,
    ObjectTypeListCount     : DWORD,
    ObjectTypeList          : POBJECT_TYPE_LIST,
};
PSE_ACCESS_REQUEST :: ^SE_ACCESS_REQUEST;

SE_ACCESS_REPLY :: struct {
    Size            : DWORD,
    ResultListCount : DWORD,
    GrantedAccess   : PACCESS_MASK,
    AccessStatus    : PDWORD,
    AccessReason    : PACCESS_REASONS,
    Privileges      : ^PPRIVILEGE_SET,
};
PSE_ACCESS_REPLY :: ^SE_ACCESS_REPLY;

/* SECURITY_IMPERSONATION_LEVEL :: enum { */
SECURITY_IMPERSONATION_LEVEL :: _c.int;
    SecurityAnonymous :: 0;
    SecurityIdentification :: SecurityAnonymous + 1;
    SecurityImpersonation :: SecurityIdentification + 1;
    SecurityDelegation :: SecurityImpersonation + 1;
/* } */
PSECURITY_IMPERSONATION_LEVEL :: ^SECURITY_IMPERSONATION_LEVEL;

/* TOKEN_TYPE :: enum { */
TOKEN_TYPE :: _c.int;
    TokenPrimary :: 1;
    TokenImpersonation :: TokenPrimary + 1;
/* } */
;

PTOKEN_TYPE :: ^TOKEN_TYPE;

/* TOKEN_ELEVATION_TYPE :: enum { */
TOKEN_ELEVATION_TYPE :: _c.int;
    TokenElevationTypeDefault :: 1;
    TokenElevationTypeFull :: TokenElevationTypeDefault + 1;
    TokenElevationTypeLimited :: TokenElevationTypeFull + 1;
/* } */
PTOKEN_ELEVATION_TYPE :: ^TOKEN_ELEVATION_TYPE;

/* TOKEN_INFORMATION_CLASS :: enum { */
TOKEN_INFORMATION_CLASS :: _c.int;
    TokenUser :: 1;
    TokenGroups :: TokenUser + 1;
    TokenPrivileges :: TokenGroups + 1;
    TokenOwner :: TokenPrivileges + 1;
    TokenPrimaryGroup :: TokenOwner + 1;
    TokenDefaultDacl :: TokenPrimaryGroup + 1;
    TokenSource :: TokenDefaultDacl + 1;
    TokenType :: TokenSource + 1;
    TokenImpersonationLevel :: TokenType + 1;
    TokenStatistics :: TokenImpersonationLevel + 1;
    TokenRestrictedSids :: TokenStatistics + 1;
    TokenSessionId :: TokenRestrictedSids + 1;
    TokenGroupsAndPrivileges :: TokenSessionId + 1;
    TokenSessionReference :: TokenGroupsAndPrivileges + 1;
    TokenSandBoxInert :: TokenSessionReference + 1;
    TokenAuditPolicy :: TokenSandBoxInert + 1;
    TokenOrigin :: TokenAuditPolicy + 1;
    TokenElevationType :: TokenOrigin + 1;
    TokenLinkedToken :: TokenElevationType + 1;
    TokenElevation :: TokenLinkedToken + 1;
    TokenHasRestrictions :: TokenElevation + 1;
    TokenAccessInformation :: TokenHasRestrictions + 1;
    TokenVirtualizationAllowed :: TokenAccessInformation + 1;
    TokenVirtualizationEnabled :: TokenVirtualizationAllowed + 1;
    TokenIntegrityLevel :: TokenVirtualizationEnabled + 1;
    TokenUIAccess :: TokenIntegrityLevel + 1;
    TokenMandatoryPolicy :: TokenUIAccess + 1;
    TokenLogonSid :: TokenMandatoryPolicy + 1;
    TokenIsAppContainer :: TokenLogonSid + 1;
    TokenCapabilities :: TokenIsAppContainer + 1;
    TokenAppContainerSid :: TokenCapabilities + 1;
    TokenAppContainerNumber :: TokenAppContainerSid + 1;
    TokenUserClaimAttributes :: TokenAppContainerNumber + 1;
    TokenDeviceClaimAttributes :: TokenUserClaimAttributes + 1;
    TokenRestrictedUserClaimAttributes :: TokenDeviceClaimAttributes + 1;
    TokenRestrictedDeviceClaimAttributes :: TokenRestrictedUserClaimAttributes + 1;
    TokenDeviceGroups :: TokenRestrictedDeviceClaimAttributes + 1;
    TokenRestrictedDeviceGroups :: TokenDeviceGroups + 1;
    TokenSecurityAttributes :: TokenRestrictedDeviceGroups + 1;
    TokenIsRestricted :: TokenSecurityAttributes + 1;
    TokenProcessTrustLevel :: TokenIsRestricted + 1;
    TokenPrivateNameSpace :: TokenProcessTrustLevel + 1;
    TokenSingletonAttributes :: TokenPrivateNameSpace + 1;
    TokenBnoIsolation :: TokenSingletonAttributes + 1;
    TokenChildProcessFlags :: TokenBnoIsolation + 1;
    TokenIsLessPrivilegedAppContainer :: TokenChildProcessFlags + 1;
    TokenIsSandboxed :: TokenIsLessPrivilegedAppContainer + 1;
    TokenOriginatingProcessTrustLevel :: TokenIsSandboxed + 1;
    MaxTokenInfoClass :: TokenOriginatingProcessTrustLevel + 1;
/* } */
PTOKEN_INFORMATION_CLASS :: ^TOKEN_INFORMATION_CLASS;

TOKEN_USER :: struct {
    User : SID_AND_ATTRIBUTES,
};
PTOKEN_USER :: ^TOKEN_USER;

SE_TOKEN_USER :: struct {
    u : struct #raw_union {
        TokenUser : TOKEN_USER,
        User      : SID_AND_ATTRIBUTES,
    },
    u2 : struct #raw_union {
        Sid    : SID,
        Buffer : [(size_of(SID) - size_of(DWORD) + ((15) * size_of(DWORD)))]BYTE,
    },
};
PSE_TOKEN_USER :: struct {
    u : struct #raw_union {
        TokenUser : TOKEN_USER,
        User      : SID_AND_ATTRIBUTES,
    },
    u2 : struct #raw_union {
        Sid    : SID,
        Buffer : [(size_of(SID) - size_of(DWORD) + ((15) * size_of(DWORD)))]BYTE,
    },
};

TOKEN_GROUPS :: struct {
    GroupCount : DWORD,
    Groups     : [1]SID_AND_ATTRIBUTES,
};
PTOKEN_GROUPS :: ^TOKEN_GROUPS;

TOKEN_PRIVILEGES :: struct {
    PrivilegeCount : DWORD,
    Privileges     : [1]LUID_AND_ATTRIBUTES,
};
PTOKEN_PRIVILEGES :: ^TOKEN_PRIVILEGES;

TOKEN_OWNER :: struct {
    Owner : PSID,
};
PTOKEN_OWNER :: ^TOKEN_OWNER;

TOKEN_PRIMARY_GROUP :: struct {
    PrimaryGroup : PSID,
};
PTOKEN_PRIMARY_GROUP :: ^TOKEN_PRIMARY_GROUP;

TOKEN_DEFAULT_DACL :: struct {
    DefaultDacl : PACL,
};
PTOKEN_DEFAULT_DACL :: ^TOKEN_DEFAULT_DACL;

TOKEN_USER_CLAIMS :: struct {
    UserClaims : PCLAIMS_BLOB,
};
PTOKEN_USER_CLAIMS :: ^TOKEN_USER_CLAIMS;

TOKEN_DEVICE_CLAIMS :: struct {
    DeviceClaims : PCLAIMS_BLOB,
};
PTOKEN_DEVICE_CLAIMS :: ^TOKEN_DEVICE_CLAIMS;

TOKEN_GROUPS_AND_PRIVILEGES :: struct {
    SidCount            : DWORD,
    SidLength           : DWORD,
    Sids                : PSID_AND_ATTRIBUTES,
    RestrictedSidCount  : DWORD,
    RestrictedSidLength : DWORD,
    RestrictedSids      : PSID_AND_ATTRIBUTES,
    PrivilegeCount      : DWORD,
    PrivilegeLength     : DWORD,
    Privileges          : PLUID_AND_ATTRIBUTES,
    AuthenticationId    : LUID,
};
PTOKEN_GROUPS_AND_PRIVILEGES :: ^TOKEN_GROUPS_AND_PRIVILEGES;

TOKEN_LINKED_TOKEN :: struct {
    LinkedToken : HANDLE,
};
PTOKEN_LINKED_TOKEN :: ^TOKEN_LINKED_TOKEN;

TOKEN_ELEVATION :: struct {
    TokenIsElevated : DWORD,
};
PTOKEN_ELEVATION :: ^TOKEN_ELEVATION;

TOKEN_MANDATORY_LABEL :: struct {
    Label : SID_AND_ATTRIBUTES,
};
PTOKEN_MANDATORY_LABEL :: ^TOKEN_MANDATORY_LABEL;

TOKEN_MANDATORY_POLICY :: struct {
    Policy : DWORD,
};
PTOKEN_MANDATORY_POLICY :: ^TOKEN_MANDATORY_POLICY;

PSECURITY_ATTRIBUTES_OPAQUE :: PVOID;

TOKEN_ACCESS_INFORMATION :: struct {
    SidHash            : PSID_AND_ATTRIBUTES_HASH,
    RestrictedSidHash  : PSID_AND_ATTRIBUTES_HASH,
    Privileges         : PTOKEN_PRIVILEGES,
    AuthenticationId   : LUID,
    TokenType          : TOKEN_TYPE,
    ImpersonationLevel : SECURITY_IMPERSONATION_LEVEL,
    MandatoryPolicy    : TOKEN_MANDATORY_POLICY,
    Flags              : DWORD,
    AppContainerNumber : DWORD,
    PackageSid         : PSID,
    CapabilitiesHash   : PSID_AND_ATTRIBUTES_HASH,
    TrustLevelSid      : PSID,
    SecurityAttributes : PSECURITY_ATTRIBUTES_OPAQUE,
};
PTOKEN_ACCESS_INFORMATION :: ^TOKEN_ACCESS_INFORMATION;

TOKEN_AUDIT_POLICY :: struct {
    PerUserPolicy : [(((59)) >> 1) + 1]BYTE,
};
PTOKEN_AUDIT_POLICY :: ^TOKEN_AUDIT_POLICY;

TOKEN_SOURCE :: struct {
    SourceName       : [8]CHAR,
    SourceIdentifier : LUID,
};
PTOKEN_SOURCE :: ^TOKEN_SOURCE;

TOKEN_STATISTICS :: struct {
    TokenId            : LUID,
    AuthenticationId   : LUID,
    ExpirationTime     : LARGE_INTEGER,
    TokenType          : TOKEN_TYPE,
    ImpersonationLevel : SECURITY_IMPERSONATION_LEVEL,
    DynamicCharged     : DWORD,
    DynamicAvailable   : DWORD,
    GroupCount         : DWORD,
    PrivilegeCount     : DWORD,
    ModifiedId         : LUID,
};
PTOKEN_STATISTICS :: ^TOKEN_STATISTICS;

TOKEN_CONTROL :: struct {
    TokenId          : LUID,
    AuthenticationId : LUID,
    ModifiedId       : LUID,
    TokenSource      : TOKEN_SOURCE,
};
PTOKEN_CONTROL :: ^TOKEN_CONTROL;

TOKEN_ORIGIN :: struct {
    OriginatingLogonSession : LUID,
};
PTOKEN_ORIGIN :: ^TOKEN_ORIGIN;

/* MANDATORY_LEVEL :: enum { */
MANDATORY_LEVEL :: _c.int;
    MandatoryLevelUntrusted :: 0;
    MandatoryLevelLow :: MandatoryLevelUntrusted + 1;
    MandatoryLevelMedium :: MandatoryLevelLow + 1;
    MandatoryLevelHigh :: MandatoryLevelMedium + 1;
    MandatoryLevelSystem :: MandatoryLevelHigh + 1;
    MandatoryLevelSecureProcess :: MandatoryLevelSystem + 1;
    MandatoryLevelCount :: MandatoryLevelSecureProcess + 1;
/* } */
PMANDATORY_LEVEL :: ^MANDATORY_LEVEL;

TOKEN_APPCONTAINER_INFORMATION :: struct {
    TokenAppContainer : PSID,
};
PTOKEN_APPCONTAINER_INFORMATION :: ^TOKEN_APPCONTAINER_INFORMATION;

TOKEN_SID_INFORMATION :: struct {
    Sid : PSID,
};
PTOKEN_SID_INFORMATION :: ^TOKEN_SID_INFORMATION;

TOKEN_BNO_ISOLATION_INFORMATION :: struct {
    IsolationPrefix  : PWSTR,
    IsolationEnabled : BOOLEAN,
};
PTOKEN_BNO_ISOLATION_INFORMATION :: ^TOKEN_BNO_ISOLATION_INFORMATION;

CLAIM_SECURITY_ATTRIBUTE_FQBN_VALUE :: struct {
    Version : DWORD64,
    Name    : PWSTR,
};
PCLAIM_SECURITY_ATTRIBUTE_FQBN_VALUE :: ^CLAIM_SECURITY_ATTRIBUTE_FQBN_VALUE;

CLAIM_SECURITY_ATTRIBUTE_OCTET_STRING_VALUE :: struct {
    pValue      : PVOID,
    ValueLength : DWORD,
};
PCLAIM_SECURITY_ATTRIBUTE_OCTET_STRING_VALUE :: ^CLAIM_SECURITY_ATTRIBUTE_OCTET_STRING_VALUE;

CLAIM_SECURITY_ATTRIBUTE_V1 :: struct {
    Name       : PWSTR,
    ValueType  : WORD,
    Reserved   : WORD,
    Flags      : DWORD,
    ValueCount : DWORD,
    Values : struct #raw_union {
        pInt64       : PLONG64,
        pUint64      : PDWORD64,
        ppString     : ^PWSTR,
        pFqbn        : PCLAIM_SECURITY_ATTRIBUTE_FQBN_VALUE,
        pOctetString : PCLAIM_SECURITY_ATTRIBUTE_OCTET_STRING_VALUE,
    },
};
PCLAIM_SECURITY_ATTRIBUTE_V1 :: ^CLAIM_SECURITY_ATTRIBUTE_V1;

CLAIM_SECURITY_ATTRIBUTE_RELATIVE_V1 :: struct {
    Name       : DWORD,
    ValueType  : WORD,
    Reserved   : WORD,
    Flags      : DWORD,
    ValueCount : DWORD,
    Values : struct #raw_union {
        pInt64       : [1]DWORD,
        pUint64      : [1]DWORD,
        ppString     : [1]DWORD,
        pFqbn        : [1]DWORD,
        pOctetString : [1]DWORD,
    },
};
PCLAIM_SECURITY_ATTRIBUTE_RELATIVE_V1 :: ^CLAIM_SECURITY_ATTRIBUTE_RELATIVE_V1;

CLAIM_SECURITY_ATTRIBUTES_INFORMATION :: struct {
    Version        : WORD,
    Reserved       : WORD,
    AttributeCount : DWORD,
    Attribute : struct #raw_union {
        pAttributeV1 : PCLAIM_SECURITY_ATTRIBUTE_V1,
    },
};
PCLAIM_SECURITY_ATTRIBUTES_INFORMATION :: ^CLAIM_SECURITY_ATTRIBUTES_INFORMATION;

SECURITY_CONTEXT_TRACKING_MODE :: BOOLEAN;
PSECURITY_CONTEXT_TRACKING_MODE :: ^BOOLEAN;

SECURITY_QUALITY_OF_SERVICE :: struct {
    Length              : DWORD,
    ImpersonationLevel  : SECURITY_IMPERSONATION_LEVEL,
    ContextTrackingMode : SECURITY_CONTEXT_TRACKING_MODE,
    EffectiveOnly       : BOOLEAN,
};
PSECURITY_QUALITY_OF_SERVICE :: ^SECURITY_QUALITY_OF_SERVICE;

SE_IMPERSONATION_STATE :: struct {
    Token         : PACCESS_TOKEN,
    CopyOnOpen    : BOOLEAN,
    EffectiveOnly : BOOLEAN,
    Level         : SECURITY_IMPERSONATION_LEVEL,
};
PSE_IMPERSONATION_STATE :: ^SE_IMPERSONATION_STATE;

SECURITY_INFORMATION :: DWORD;
PSECURITY_INFORMATION :: ^DWORD;

SE_SIGNING_LEVEL :: BYTE;
PSE_SIGNING_LEVEL :: ^BYTE;

/* SE_IMAGE_SIGNATURE_TYPE :: enum { */
SE_IMAGE_SIGNATURE_TYPE :: _c.int;
    SeImageSignatureNone :: 0;
    SeImageSignatureEmbedded :: SeImageSignatureNone + 1;
    SeImageSignatureCache :: SeImageSignatureEmbedded + 1;
    SeImageSignatureCatalogCached :: SeImageSignatureCache + 1;
    SeImageSignatureCatalogNotCached :: SeImageSignatureCatalogCached + 1;
    SeImageSignatureCatalogHint :: SeImageSignatureCatalogNotCached + 1;
    SeImageSignaturePackageCatalog :: SeImageSignatureCatalogHint + 1;
/* } */
PSE_IMAGE_SIGNATURE_TYPE :: ^SE_IMAGE_SIGNATURE_TYPE;

/* SE_LEARNING_MODE_DATA_TYPE :: enum { */
SE_LEARNING_MODE_DATA_TYPE :: _c.int;
    SeLearningModeInvalidType :: 0;
    SeLearningModeSettings :: SeLearningModeInvalidType + 1;
    SeLearningModeMax :: SeLearningModeSettings + 1;
/* } */
;

SECURITY_CAPABILITIES :: struct {
    AppContainerSid : PSID,
    Capabilities    : PSID_AND_ATTRIBUTES,
    CapabilityCount : DWORD,
    Reserved        : DWORD,
};
PSECURITY_CAPABILITIES :: ^SECURITY_CAPABILITIES;
LPSECURITY_CAPABILITIES :: ^SECURITY_CAPABILITIES;

JOB_SET_ARRAY :: struct {
    JobHandle   : HANDLE,
    MemberLevel : DWORD,
    Flags       : DWORD,
};
PJOB_SET_ARRAY :: ^JOB_SET_ARRAY;

EXCEPTION_REGISTRATION_RECORD :: struct {
    Next    : ^EXCEPTION_REGISTRATION_RECORD,
    Handler : PEXCEPTION_ROUTINE,
};

PEXCEPTION_REGISTRATION_RECORD :: ^EXCEPTION_REGISTRATION_RECORD;

NT_TIB :: struct {
    ExceptionList        : ^EXCEPTION_REGISTRATION_RECORD,
    StackBase            : PVOID,
    StackLimit           : PVOID,
    SubSystemTib         : PVOID,
    FiberData            : PVOID,
    ArbitraryUserPointer : PVOID,
    Self                 : ^NT_TIB,
};

PNT_TIB :: ^NT_TIB;

NT_TIB32 :: struct {
    ExceptionList        : DWORD,
    StackBase            : DWORD,
    StackLimit           : DWORD,
    SubSystemTib         : DWORD,
    FiberData            : DWORD,
    ArbitraryUserPointer : DWORD,
    Self                 : DWORD,
};
PNT_TIB32 :: ^NT_TIB32;

NT_TIB64 :: struct {
    ExceptionList        : DWORD64,
    StackBase            : DWORD64,
    StackLimit           : DWORD64,
    SubSystemTib         : DWORD64,
    FiberData            : DWORD64,
    ArbitraryUserPointer : DWORD64,
    Self                 : DWORD64,
};
PNT_TIB64 :: ^NT_TIB64;

UMS_CREATE_THREAD_ATTRIBUTES :: struct {
    UmsVersion        : DWORD,
    UmsContext        : PVOID,
    UmsCompletionList : PVOID,
};
PUMS_CREATE_THREAD_ATTRIBUTES :: ^UMS_CREATE_THREAD_ATTRIBUTES;

WOW64_ARCHITECTURE_INFORMATION :: bit_field {
    Machine       : 16,
    KernelMode    : 1,
    UserMode      : 1,
    Native        : 1,
    Process       : 1,
    ReservedZero0 : 12,
};

QUOTA_LIMITS :: struct {
    PagedPoolLimit        : SIZE_T,
    NonPagedPoolLimit     : SIZE_T,
    MinimumWorkingSetSize : SIZE_T,
    MaximumWorkingSetSize : SIZE_T,
    PagefileLimit         : SIZE_T,
    TimeLimit             : LARGE_INTEGER,
};
PQUOTA_LIMITS :: ^QUOTA_LIMITS;

RATE_QUOTA_LIMIT :: struct #raw_union {
    RateData : DWORD,
    s : bit_field {
        RatePercent : 7,
        Reserved0   : 25,
    },
};
PRATE_QUOTA_LIMIT :: ^RATE_QUOTA_LIMIT;

QUOTA_LIMITS_EX :: struct {
    PagedPoolLimit        : SIZE_T,
    NonPagedPoolLimit     : SIZE_T,
    MinimumWorkingSetSize : SIZE_T,
    MaximumWorkingSetSize : SIZE_T,
    PagefileLimit         : SIZE_T,
    TimeLimit             : LARGE_INTEGER,
    WorkingSetLimit       : SIZE_T,
    Reserved2             : SIZE_T,
    Reserved3             : SIZE_T,
    Reserved4             : SIZE_T,
    Flags                 : DWORD,
    CpuRateLimit          : RATE_QUOTA_LIMIT,
};
PQUOTA_LIMITS_EX :: ^QUOTA_LIMITS_EX;

IO_COUNTERS :: struct {
    ReadOperationCount  : ULONGLONG,
    WriteOperationCount : ULONGLONG,
    OtherOperationCount : ULONGLONG,
    ReadTransferCount   : ULONGLONG,
    WriteTransferCount  : ULONGLONG,
    OtherTransferCount  : ULONGLONG,
};

PIO_COUNTERS :: ^IO_COUNTERS;

/* HARDWARE_COUNTER_TYPE :: enum { */
HARDWARE_COUNTER_TYPE :: _c.int;
    PMCCounter :: 0;
    MaxHardwareCounterType :: PMCCounter + 1;
/* } */
PHARDWARE_COUNTER_TYPE :: ^HARDWARE_COUNTER_TYPE;

/* PROCESS_MITIGATION_POLICY :: enum { */
PROCESS_MITIGATION_POLICY :: _c.int;
    ProcessDEPPolicy :: 0;
    ProcessASLRPolicy :: ProcessDEPPolicy + 1;
    ProcessDynamicCodePolicy :: ProcessASLRPolicy + 1;
    ProcessStrictHandleCheckPolicy :: ProcessDynamicCodePolicy + 1;
    ProcessSystemCallDisablePolicy :: ProcessStrictHandleCheckPolicy + 1;
    ProcessMitigationOptionsMask :: ProcessSystemCallDisablePolicy + 1;
    ProcessExtensionPointDisablePolicy :: ProcessMitigationOptionsMask + 1;
    ProcessControlFlowGuardPolicy :: ProcessExtensionPointDisablePolicy + 1;
    ProcessSignaturePolicy :: ProcessControlFlowGuardPolicy + 1;
    ProcessFontDisablePolicy :: ProcessSignaturePolicy + 1;
    ProcessImageLoadPolicy :: ProcessFontDisablePolicy + 1;
    ProcessSystemCallFilterPolicy :: ProcessImageLoadPolicy + 1;
    ProcessPayloadRestrictionPolicy :: ProcessSystemCallFilterPolicy + 1;
    ProcessChildProcessPolicy :: ProcessPayloadRestrictionPolicy + 1;
    ProcessSideChannelIsolationPolicy :: ProcessChildProcessPolicy + 1;
    MaxProcessMitigationPolicy :: ProcessSideChannelIsolationPolicy + 1;
/* } */
PPROCESS_MITIGATION_POLICY :: ^PROCESS_MITIGATION_POLICY;

PROCESS_MITIGATION_ASLR_POLICY :: struct {
    u : struct #raw_union {
        Flags : DWORD,
        s : bit_field {
            EnableBottomUpRandomization : 1,
            EnableForceRelocateImages   : 1,
            EnableHighEntropy           : 1,
            DisallowStrippedImages      : 1,
            ReservedFlags               : 28,
        },
    },
};
PPROCESS_MITIGATION_ASLR_POLICY :: ^PROCESS_MITIGATION_ASLR_POLICY;

PROCESS_MITIGATION_DEP_POLICY :: struct {
    u : struct #raw_union {
        Flags : DWORD,
        s : bit_field {
            Enable                   : 1,
            DisableAtlThunkEmulation : 1,
            ReservedFlags            : 30,
        },
    },
    Permanent : BOOLEAN,
};
PPROCESS_MITIGATION_DEP_POLICY :: ^PROCESS_MITIGATION_DEP_POLICY;

PROCESS_MITIGATION_STRICT_HANDLE_CHECK_POLICY :: struct {
    u : struct #raw_union {
        Flags : DWORD,
        s : bit_field {
            RaiseExceptionOnInvalidHandleReference : 1,
            HandleExceptionsPermanentlyEnabled     : 1,
            ReservedFlags                          : 30,
        },
    },
};
PPROCESS_MITIGATION_STRICT_HANDLE_CHECK_POLICY :: ^PROCESS_MITIGATION_STRICT_HANDLE_CHECK_POLICY;

PROCESS_MITIGATION_SYSTEM_CALL_DISABLE_POLICY :: struct {
    u : struct #raw_union {
        Flags : DWORD,
        s : bit_field {
            DisallowWin32kSystemCalls      : 1,
            AuditDisallowWin32kSystemCalls : 1,
            ReservedFlags                  : 30,
        },
    },
};
PPROCESS_MITIGATION_SYSTEM_CALL_DISABLE_POLICY :: ^PROCESS_MITIGATION_SYSTEM_CALL_DISABLE_POLICY;

PROCESS_MITIGATION_EXTENSION_POINT_DISABLE_POLICY :: struct {
    u : struct #raw_union {
        Flags : DWORD,
        s : bit_field {
            DisableExtensionPoints : 1,
            ReservedFlags          : 31,
        },
    },
};
PPROCESS_MITIGATION_EXTENSION_POINT_DISABLE_POLICY :: ^PROCESS_MITIGATION_EXTENSION_POINT_DISABLE_POLICY;

PROCESS_MITIGATION_DYNAMIC_CODE_POLICY :: struct {
    u : struct #raw_union {
        Flags : DWORD,
        s : bit_field {
            ProhibitDynamicCode      : 1,
            AllowThreadOptOut        : 1,
            AllowRemoteDowngrade     : 1,
            AuditProhibitDynamicCode : 1,
            ReservedFlags            : 28,
        },
    },
};
PPROCESS_MITIGATION_DYNAMIC_CODE_POLICY :: ^PROCESS_MITIGATION_DYNAMIC_CODE_POLICY;

PROCESS_MITIGATION_CONTROL_FLOW_GUARD_POLICY :: struct {
    u : struct #raw_union {
        Flags : DWORD,
        s : bit_field {
            EnableControlFlowGuard  : 1,
            EnableExportSuppression : 1,
            StrictMode              : 1,
            ReservedFlags           : 29,
        },
    },
};
PPROCESS_MITIGATION_CONTROL_FLOW_GUARD_POLICY :: ^PROCESS_MITIGATION_CONTROL_FLOW_GUARD_POLICY;

PROCESS_MITIGATION_BINARY_SIGNATURE_POLICY :: struct {
    u : struct #raw_union {
        Flags : DWORD,
        s : bit_field {
            MicrosoftSignedOnly      : 1,
            StoreSignedOnly          : 1,
            MitigationOptIn          : 1,
            AuditMicrosoftSignedOnly : 1,
            AuditStoreSignedOnly     : 1,
            ReservedFlags            : 27,
        },
    },
};
PPROCESS_MITIGATION_BINARY_SIGNATURE_POLICY :: ^PROCESS_MITIGATION_BINARY_SIGNATURE_POLICY;

PROCESS_MITIGATION_FONT_DISABLE_POLICY :: struct {
    u : struct #raw_union {
        Flags : DWORD,
        s : bit_field {
            DisableNonSystemFonts     : 1,
            AuditNonSystemFontLoading : 1,
            ReservedFlags             : 30,
        },
    },
};
PPROCESS_MITIGATION_FONT_DISABLE_POLICY :: ^PROCESS_MITIGATION_FONT_DISABLE_POLICY;

PROCESS_MITIGATION_IMAGE_LOAD_POLICY :: struct {
    u : struct #raw_union {
        Flags : DWORD,
        s : bit_field {
            NoRemoteImages                 : 1,
            NoLowMandatoryLabelImages      : 1,
            PreferSystem32Images           : 1,
            AuditNoRemoteImages            : 1,
            AuditNoLowMandatoryLabelImages : 1,
            ReservedFlags                  : 27,
        },
    },
};
PPROCESS_MITIGATION_IMAGE_LOAD_POLICY :: ^PROCESS_MITIGATION_IMAGE_LOAD_POLICY;

PROCESS_MITIGATION_SYSTEM_CALL_FILTER_POLICY :: struct {
    u : struct #raw_union {
        Flags : DWORD,
        s : bit_field {
            FilterId      : 4,
            ReservedFlags : 28,
        },
    },
};
PPROCESS_MITIGATION_SYSTEM_CALL_FILTER_POLICY :: ^PROCESS_MITIGATION_SYSTEM_CALL_FILTER_POLICY;

PROCESS_MITIGATION_PAYLOAD_RESTRICTION_POLICY :: struct {
    u : struct #raw_union {
        Flags : DWORD,
        s : bit_field {
            EnableExportAddressFilter     : 1,
            AuditExportAddressFilter      : 1,
            EnableExportAddressFilterPlus : 1,
            AuditExportAddressFilterPlus  : 1,
            EnableImportAddressFilter     : 1,
            AuditImportAddressFilter      : 1,
            EnableRopStackPivot           : 1,
            AuditRopStackPivot            : 1,
            EnableRopCallerCheck          : 1,
            AuditRopCallerCheck           : 1,
            EnableRopSimExec              : 1,
            AuditRopSimExec               : 1,
            ReservedFlags                 : 20,
        },
    },
};
PPROCESS_MITIGATION_PAYLOAD_RESTRICTION_POLICY :: ^PROCESS_MITIGATION_PAYLOAD_RESTRICTION_POLICY;

PROCESS_MITIGATION_CHILD_PROCESS_POLICY :: struct {
    u : struct #raw_union {
        Flags : DWORD,
        s : bit_field {
            NoChildProcessCreation      : 1,
            AuditNoChildProcessCreation : 1,
            AllowSecureProcessCreation  : 1,
            ReservedFlags               : 29,
        },
    },
};
PPROCESS_MITIGATION_CHILD_PROCESS_POLICY :: ^PROCESS_MITIGATION_CHILD_PROCESS_POLICY;

PROCESS_MITIGATION_SIDE_CHANNEL_ISOLATION_POLICY :: struct {
    u : struct #raw_union {
        Flags : DWORD,
        s : bit_field {
            SmtBranchTargetIsolation      : 1,
            IsolateSecurityDomain         : 1,
            DisablePageCombine            : 1,
            SpeculativeStoreBypassDisable : 1,
            ReservedFlags                 : 28,
        },
    },
};
PPROCESS_MITIGATION_SIDE_CHANNEL_ISOLATION_POLICY :: ^PROCESS_MITIGATION_SIDE_CHANNEL_ISOLATION_POLICY;

JOBOBJECT_BASIC_ACCOUNTING_INFORMATION :: struct {
    TotalUserTime             : LARGE_INTEGER,
    TotalKernelTime           : LARGE_INTEGER,
    ThisPeriodTotalUserTime   : LARGE_INTEGER,
    ThisPeriodTotalKernelTime : LARGE_INTEGER,
    TotalPageFaultCount       : DWORD,
    TotalProcesses            : DWORD,
    ActiveProcesses           : DWORD,
    TotalTerminatedProcesses  : DWORD,
};
PJOBOBJECT_BASIC_ACCOUNTING_INFORMATION :: ^JOBOBJECT_BASIC_ACCOUNTING_INFORMATION;

JOBOBJECT_BASIC_LIMIT_INFORMATION :: struct {
    PerProcessUserTimeLimit : LARGE_INTEGER,
    PerJobUserTimeLimit     : LARGE_INTEGER,
    LimitFlags              : DWORD,
    MinimumWorkingSetSize   : SIZE_T,
    MaximumWorkingSetSize   : SIZE_T,
    ActiveProcessLimit      : DWORD,
    Affinity                : ULONG_PTR,
    PriorityClass           : DWORD,
    SchedulingClass         : DWORD,
};
PJOBOBJECT_BASIC_LIMIT_INFORMATION :: ^JOBOBJECT_BASIC_LIMIT_INFORMATION;

JOBOBJECT_EXTENDED_LIMIT_INFORMATION :: struct {
    BasicLimitInformation : JOBOBJECT_BASIC_LIMIT_INFORMATION,
    IoInfo                : IO_COUNTERS,
    ProcessMemoryLimit    : SIZE_T,
    JobMemoryLimit        : SIZE_T,
    PeakProcessMemoryUsed : SIZE_T,
    PeakJobMemoryUsed     : SIZE_T,
};
PJOBOBJECT_EXTENDED_LIMIT_INFORMATION :: ^JOBOBJECT_EXTENDED_LIMIT_INFORMATION;

JOBOBJECT_BASIC_PROCESS_ID_LIST :: struct {
    NumberOfAssignedProcesses : DWORD,
    NumberOfProcessIdsInList  : DWORD,
    ProcessIdList             : [1]ULONG_PTR,
};
PJOBOBJECT_BASIC_PROCESS_ID_LIST :: ^JOBOBJECT_BASIC_PROCESS_ID_LIST;

JOBOBJECT_BASIC_UI_RESTRICTIONS :: struct {
    UIRestrictionsClass : DWORD,
};
PJOBOBJECT_BASIC_UI_RESTRICTIONS :: ^JOBOBJECT_BASIC_UI_RESTRICTIONS;

JOBOBJECT_SECURITY_LIMIT_INFORMATION :: struct {
    SecurityLimitFlags : DWORD,
    JobToken           : HANDLE,
    SidsToDisable      : PTOKEN_GROUPS,
    PrivilegesToDelete : PTOKEN_PRIVILEGES,
    RestrictedSids     : PTOKEN_GROUPS,
};
PJOBOBJECT_SECURITY_LIMIT_INFORMATION :: ^JOBOBJECT_SECURITY_LIMIT_INFORMATION;

JOBOBJECT_END_OF_JOB_TIME_INFORMATION :: struct {
    EndOfJobTimeAction : DWORD,
};
PJOBOBJECT_END_OF_JOB_TIME_INFORMATION :: ^JOBOBJECT_END_OF_JOB_TIME_INFORMATION;

JOBOBJECT_ASSOCIATE_COMPLETION_PORT :: struct {
    CompletionKey  : PVOID,
    CompletionPort : HANDLE,
};
PJOBOBJECT_ASSOCIATE_COMPLETION_PORT :: ^JOBOBJECT_ASSOCIATE_COMPLETION_PORT;

JOBOBJECT_BASIC_AND_IO_ACCOUNTING_INFORMATION :: struct {
    BasicInfo : JOBOBJECT_BASIC_ACCOUNTING_INFORMATION,
    IoInfo    : IO_COUNTERS,
};
PJOBOBJECT_BASIC_AND_IO_ACCOUNTING_INFORMATION :: ^JOBOBJECT_BASIC_AND_IO_ACCOUNTING_INFORMATION;

JOBOBJECT_JOBSET_INFORMATION :: struct {
    MemberLevel : DWORD,
};
PJOBOBJECT_JOBSET_INFORMATION :: ^JOBOBJECT_JOBSET_INFORMATION;

/* JOBOBJECT_RATE_CONTROL_TOLERANCE :: enum { */
JOBOBJECT_RATE_CONTROL_TOLERANCE :: _c.int;
    ToleranceLow :: 1;
    ToleranceMedium :: ToleranceLow + 1;
    ToleranceHigh :: ToleranceMedium + 1;
/* } */
PJOBOBJECT_RATE_CONTROL_TOLERANCE :: ^JOBOBJECT_RATE_CONTROL_TOLERANCE;

/* JOBOBJECT_RATE_CONTROL_TOLERANCE_INTERVAL :: enum { */
JOBOBJECT_RATE_CONTROL_TOLERANCE_INTERVAL :: _c.int;
    ToleranceIntervalShort :: 1;
    ToleranceIntervalMedium :: ToleranceIntervalShort + 1;
    ToleranceIntervalLong :: ToleranceIntervalMedium + 1;
/* } */
PJOBOBJECT_RATE_CONTROL_TOLERANCE_INTERVAL :: ^JOBOBJECT_RATE_CONTROL_TOLERANCE_INTERVAL;

JOBOBJECT_NOTIFICATION_LIMIT_INFORMATION :: struct {
    IoReadBytesLimit             : DWORD64,
    IoWriteBytesLimit            : DWORD64,
    PerJobUserTimeLimit          : LARGE_INTEGER,
    JobMemoryLimit               : DWORD64,
    RateControlTolerance         : JOBOBJECT_RATE_CONTROL_TOLERANCE,
    RateControlToleranceInterval : JOBOBJECT_RATE_CONTROL_TOLERANCE_INTERVAL,
    LimitFlags                   : DWORD,
};
PJOBOBJECT_NOTIFICATION_LIMIT_INFORMATION :: ^JOBOBJECT_NOTIFICATION_LIMIT_INFORMATION;

JOBOBJECT_NOTIFICATION_LIMIT_INFORMATION_2 :: struct {
    IoReadBytesLimit                : DWORD64,
    IoWriteBytesLimit               : DWORD64,
    PerJobUserTimeLimit             : LARGE_INTEGER,
    u : struct #raw_union {
        JobHighMemoryLimit : DWORD64,
        JobMemoryLimit     : DWORD64,
    },
    u2 : struct #raw_union {
        RateControlTolerance    : JOBOBJECT_RATE_CONTROL_TOLERANCE,
        CpuRateControlTolerance : JOBOBJECT_RATE_CONTROL_TOLERANCE,
    },
    u3 : struct #raw_union {
        RateControlToleranceInterval    : JOBOBJECT_RATE_CONTROL_TOLERANCE_INTERVAL,
        CpuRateControlToleranceInterval : JOBOBJECT_RATE_CONTROL_TOLERANCE_INTERVAL,
    },
    LimitFlags                      : DWORD,
    IoRateControlTolerance          : JOBOBJECT_RATE_CONTROL_TOLERANCE,
    JobLowMemoryLimit               : DWORD64,
    IoRateControlToleranceInterval  : JOBOBJECT_RATE_CONTROL_TOLERANCE_INTERVAL,
    NetRateControlTolerance         : JOBOBJECT_RATE_CONTROL_TOLERANCE,
    NetRateControlToleranceInterval : JOBOBJECT_RATE_CONTROL_TOLERANCE_INTERVAL,
};

JOBOBJECT_LIMIT_VIOLATION_INFORMATION :: struct {
    LimitFlags                : DWORD,
    ViolationLimitFlags       : DWORD,
    IoReadBytes               : DWORD64,
    IoReadBytesLimit          : DWORD64,
    IoWriteBytes              : DWORD64,
    IoWriteBytesLimit         : DWORD64,
    PerJobUserTime            : LARGE_INTEGER,
    PerJobUserTimeLimit       : LARGE_INTEGER,
    JobMemory                 : DWORD64,
    JobMemoryLimit            : DWORD64,
    RateControlTolerance      : JOBOBJECT_RATE_CONTROL_TOLERANCE,
    RateControlToleranceLimit : JOBOBJECT_RATE_CONTROL_TOLERANCE,
};
PJOBOBJECT_LIMIT_VIOLATION_INFORMATION :: ^JOBOBJECT_LIMIT_VIOLATION_INFORMATION;

JOBOBJECT_LIMIT_VIOLATION_INFORMATION_2 :: struct {
    LimitFlags                   : DWORD,
    ViolationLimitFlags          : DWORD,
    IoReadBytes                  : DWORD64,
    IoReadBytesLimit             : DWORD64,
    IoWriteBytes                 : DWORD64,
    IoWriteBytesLimit            : DWORD64,
    PerJobUserTime               : LARGE_INTEGER,
    PerJobUserTimeLimit          : LARGE_INTEGER,
    JobMemory                    : DWORD64,
    u : struct #raw_union {
        JobHighMemoryLimit : DWORD64,
        JobMemoryLimit     : DWORD64,
    },
    u2 : struct #raw_union {
        RateControlTolerance    : JOBOBJECT_RATE_CONTROL_TOLERANCE,
        CpuRateControlTolerance : JOBOBJECT_RATE_CONTROL_TOLERANCE,
    },
    u3 : struct #raw_union {
        RateControlToleranceLimit    : JOBOBJECT_RATE_CONTROL_TOLERANCE,
        CpuRateControlToleranceLimit : JOBOBJECT_RATE_CONTROL_TOLERANCE,
    },
    JobLowMemoryLimit            : DWORD64,
    IoRateControlTolerance       : JOBOBJECT_RATE_CONTROL_TOLERANCE,
    IoRateControlToleranceLimit  : JOBOBJECT_RATE_CONTROL_TOLERANCE,
    NetRateControlTolerance      : JOBOBJECT_RATE_CONTROL_TOLERANCE,
    NetRateControlToleranceLimit : JOBOBJECT_RATE_CONTROL_TOLERANCE,
};

JOBOBJECT_CPU_RATE_CONTROL_INFORMATION :: struct {
    ControlFlags : DWORD,
    u : struct #raw_union {
        CpuRate : DWORD,
        Weight  : DWORD,
        s : struct {
            MinRate : WORD,
            MaxRate : WORD,
        },
    },
};
PJOBOBJECT_CPU_RATE_CONTROL_INFORMATION :: ^JOBOBJECT_CPU_RATE_CONTROL_INFORMATION;

/* JOB_OBJECT_NET_RATE_CONTROL_FLAGS :: enum { */
JOB_OBJECT_NET_RATE_CONTROL_FLAGS :: _c.int;
    JOB_OBJECT_NET_RATE_CONTROL_ENABLE :: 0x1;
    JOB_OBJECT_NET_RATE_CONTROL_MAX_BANDWIDTH :: 0x2;
    JOB_OBJECT_NET_RATE_CONTROL_DSCP_TAG :: 0x4;
    JOB_OBJECT_NET_RATE_CONTROL_VALID_FLAGS :: 0x7;
/* } */
;

;

JOBOBJECT_NET_RATE_CONTROL_INFORMATION :: struct {
    MaxBandwidth : DWORD64,
    ControlFlags : JOB_OBJECT_NET_RATE_CONTROL_FLAGS,
    DscpTag      : BYTE,
};

/* JOB_OBJECT_IO_RATE_CONTROL_FLAGS :: enum { */
JOB_OBJECT_IO_RATE_CONTROL_FLAGS :: _c.int;
    JOB_OBJECT_IO_RATE_CONTROL_ENABLE :: 0x1;
    JOB_OBJECT_IO_RATE_CONTROL_STANDALONE_VOLUME :: 0x2;
    JOB_OBJECT_IO_RATE_CONTROL_FORCE_UNIT_ACCESS_ALL :: 0x4;
    JOB_OBJECT_IO_RATE_CONTROL_FORCE_UNIT_ACCESS_ON_SOFT_CAP :: 0x8;
    JOB_OBJECT_IO_RATE_CONTROL_VALID_FLAGS ::     JOB_OBJECT_IO_RATE_CONTROL_ENABLE | JOB_OBJECT_IO_RATE_CONTROL_STANDALONE_VOLUME | JOB_OBJECT_IO_RATE_CONTROL_FORCE_UNIT_ACCESS_ALL | JOB_OBJECT_IO_RATE_CONTROL_FORCE_UNIT_ACCESS_ON_SOFT_CAP;
/* } */
;

JOBOBJECT_IO_RATE_CONTROL_INFORMATION_NATIVE :: struct {
    MaxIops          : LONG64,
    MaxBandwidth     : LONG64,
    ReservationIops  : LONG64,
    VolumeName       : PWSTR,
    BaseIoSize       : DWORD,
    ControlFlags     : JOB_OBJECT_IO_RATE_CONTROL_FLAGS,
    VolumeNameLength : WORD,
};

JOBOBJECT_IO_RATE_CONTROL_INFORMATION_NATIVE_V1 :: JOBOBJECT_IO_RATE_CONTROL_INFORMATION_NATIVE;

JOBOBJECT_IO_RATE_CONTROL_INFORMATION_NATIVE_V2 :: struct {
    MaxIops                        : LONG64,
    MaxBandwidth                   : LONG64,
    ReservationIops                : LONG64,
    VolumeName                     : PWSTR,
    BaseIoSize                     : DWORD,
    ControlFlags                   : JOB_OBJECT_IO_RATE_CONTROL_FLAGS,
    VolumeNameLength               : WORD,
    CriticalReservationIops        : LONG64,
    ReservationBandwidth           : LONG64,
    CriticalReservationBandwidth   : LONG64,
    MaxTimePercent                 : LONG64,
    ReservationTimePercent         : LONG64,
    CriticalReservationTimePercent : LONG64,
};

JOBOBJECT_IO_RATE_CONTROL_INFORMATION_NATIVE_V3 :: struct {
    MaxIops                        : LONG64,
    MaxBandwidth                   : LONG64,
    ReservationIops                : LONG64,
    VolumeName                     : PWSTR,
    BaseIoSize                     : DWORD,
    ControlFlags                   : JOB_OBJECT_IO_RATE_CONTROL_FLAGS,
    VolumeNameLength               : WORD,
    CriticalReservationIops        : LONG64,
    ReservationBandwidth           : LONG64,
    CriticalReservationBandwidth   : LONG64,
    MaxTimePercent                 : LONG64,
    ReservationTimePercent         : LONG64,
    CriticalReservationTimePercent : LONG64,
    SoftMaxIops                    : LONG64,
    SoftMaxBandwidth               : LONG64,
    SoftMaxTimePercent             : LONG64,
    LimitExcessNotifyIops          : LONG64,
    LimitExcessNotifyBandwidth     : LONG64,
    LimitExcessNotifyTimePercent   : LONG64,
};

/* JOBOBJECT_IO_ATTRIBUTION_CONTROL_FLAGS :: enum { */
JOBOBJECT_IO_ATTRIBUTION_CONTROL_FLAGS :: _c.int;
    JOBOBJECT_IO_ATTRIBUTION_CONTROL_ENABLE :: 0x1;
    JOBOBJECT_IO_ATTRIBUTION_CONTROL_DISABLE :: 0x2;
    JOBOBJECT_IO_ATTRIBUTION_CONTROL_VALID_FLAGS :: 0x3;
/* } */
;

JOBOBJECT_IO_ATTRIBUTION_STATS :: struct {
    IoCount                       : ULONG_PTR,
    TotalNonOverlappedQueueTime   : ULONGLONG,
    TotalNonOverlappedServiceTime : ULONGLONG,
    TotalSize                     : ULONGLONG,
};
PJOBOBJECT_IO_ATTRIBUTION_STATS :: ^JOBOBJECT_IO_ATTRIBUTION_STATS;

JOBOBJECT_IO_ATTRIBUTION_INFORMATION :: struct {
    ControlFlags : DWORD,
    ReadStats    : JOBOBJECT_IO_ATTRIBUTION_STATS,
    WriteStats   : JOBOBJECT_IO_ATTRIBUTION_STATS,
};
PJOBOBJECT_IO_ATTRIBUTION_INFORMATION :: ^JOBOBJECT_IO_ATTRIBUTION_INFORMATION;

/* JOBOBJECTINFOCLASS :: enum { */
JOBOBJECTINFOCLASS :: _c.int;
    JobObjectBasicAccountingInformation :: 1;
    JobObjectBasicLimitInformation :: JobObjectBasicAccountingInformation + 1;
    JobObjectBasicProcessIdList :: JobObjectBasicLimitInformation + 1;
    JobObjectBasicUIRestrictions :: JobObjectBasicProcessIdList + 1;
    JobObjectSecurityLimitInformation :: JobObjectBasicUIRestrictions + 1;
    JobObjectEndOfJobTimeInformation :: JobObjectSecurityLimitInformation + 1;
    JobObjectAssociateCompletionPortInformation :: JobObjectEndOfJobTimeInformation + 1;
    JobObjectBasicAndIoAccountingInformation :: JobObjectAssociateCompletionPortInformation + 1;
    JobObjectExtendedLimitInformation :: JobObjectBasicAndIoAccountingInformation + 1;
    JobObjectJobSetInformation :: JobObjectExtendedLimitInformation + 1;
    JobObjectGroupInformation :: JobObjectJobSetInformation + 1;
    JobObjectNotificationLimitInformation :: JobObjectGroupInformation + 1;
    JobObjectLimitViolationInformation :: JobObjectNotificationLimitInformation + 1;
    JobObjectGroupInformationEx :: JobObjectLimitViolationInformation + 1;
    JobObjectCpuRateControlInformation :: JobObjectGroupInformationEx + 1;
    JobObjectCompletionFilter :: JobObjectCpuRateControlInformation + 1;
    JobObjectCompletionCounter :: JobObjectCompletionFilter + 1;
    JobObjectReserved1Information :: 18;
    JobObjectReserved2Information :: JobObjectReserved1Information + 1;
    JobObjectReserved3Information :: JobObjectReserved2Information + 1;
    JobObjectReserved4Information :: JobObjectReserved3Information + 1;
    JobObjectReserved5Information :: JobObjectReserved4Information + 1;
    JobObjectReserved6Information :: JobObjectReserved5Information + 1;
    JobObjectReserved7Information :: JobObjectReserved6Information + 1;
    JobObjectReserved8Information :: JobObjectReserved7Information + 1;
    JobObjectReserved9Information :: JobObjectReserved8Information + 1;
    JobObjectReserved10Information :: JobObjectReserved9Information + 1;
    JobObjectReserved11Information :: JobObjectReserved10Information + 1;
    JobObjectReserved12Information :: JobObjectReserved11Information + 1;
    JobObjectReserved13Information :: JobObjectReserved12Information + 1;
    JobObjectReserved14Information :: 31;
    JobObjectNetRateControlInformation :: JobObjectReserved14Information + 1;
    JobObjectNotificationLimitInformation2 :: JobObjectNetRateControlInformation + 1;
    JobObjectLimitViolationInformation2 :: JobObjectNotificationLimitInformation2 + 1;
    JobObjectCreateSilo :: JobObjectLimitViolationInformation2 + 1;
    JobObjectSiloBasicInformation :: JobObjectCreateSilo + 1;
    JobObjectReserved15Information :: 37;
    JobObjectReserved16Information :: 38;
    JobObjectReserved17Information :: 39;
    JobObjectReserved18Information :: 40;
    JobObjectReserved19Information :: 41;
    JobObjectReserved20Information :: 42;
    JobObjectReserved21Information :: 43;
    JobObjectReserved22Information :: 44;
    JobObjectReserved23Information :: 45;
    JobObjectReserved24Information :: 46;
    JobObjectReserved25Information :: 47;
    MaxJobObjectInfoClass :: JobObjectReserved25Information + 1;
/* } */
;

SILOOBJECT_BASIC_INFORMATION :: struct {
    SiloId            : DWORD,
    SiloParentId      : DWORD,
    NumberOfProcesses : DWORD,
    IsInServerSilo    : BOOLEAN,
    Reserved          : [3]BYTE,
};
PSILOOBJECT_BASIC_INFORMATION :: ^SILOOBJECT_BASIC_INFORMATION;

/* SERVERSILO_STATE :: enum { */
SERVERSILO_STATE :: _c.int;
    SERVERSILO_INITING :: 0;
    SERVERSILO_STARTED :: SERVERSILO_INITING + 1;
    SERVERSILO_SHUTTING_DOWN :: SERVERSILO_STARTED + 1;
    SERVERSILO_TERMINATING :: SERVERSILO_SHUTTING_DOWN + 1;
    SERVERSILO_TERMINATED :: SERVERSILO_TERMINATING + 1;
/* } */
PSERVERSILO_STATE :: ^SERVERSILO_STATE;

SERVERSILO_BASIC_INFORMATION :: struct {
    ServiceSessionId : DWORD,
    State            : SERVERSILO_STATE,
    ExitStatus       : DWORD,
};
PSERVERSILO_BASIC_INFORMATION :: ^SERVERSILO_BASIC_INFORMATION;

/* FIRMWARE_TYPE :: enum { */
FIRMWARE_TYPE :: _c.int;
    FirmwareTypeUnknown :: 0;
    FirmwareTypeBios :: FirmwareTypeUnknown + 1;
    FirmwareTypeUefi :: FirmwareTypeBios + 1;
    FirmwareTypeMax :: FirmwareTypeUefi + 1;
/* } */
PFIRMWARE_TYPE :: ^FIRMWARE_TYPE;

/* LOGICAL_PROCESSOR_RELATIONSHIP :: enum { */
LOGICAL_PROCESSOR_RELATIONSHIP :: _c.int;
    RelationProcessorCore :: 0;
    RelationNumaNode :: RelationProcessorCore + 1;
    RelationCache :: RelationNumaNode + 1;
    RelationProcessorPackage :: RelationCache + 1;
    RelationGroup :: RelationProcessorPackage + 1;
    RelationAll :: 0xffff;
/* } */
;

/* PROCESSOR_CACHE_TYPE :: enum { */
PROCESSOR_CACHE_TYPE :: _c.int;
    CacheUnified :: 0;
    CacheInstruction :: CacheUnified + 1;
    CacheData :: CacheInstruction + 1;
    CacheTrace :: CacheData + 1;
/* } */
;

CACHE_DESCRIPTOR :: struct {
    Level         : BYTE,
    Associativity : BYTE,
    LineSize      : WORD,
    Size          : DWORD,
    Type          : PROCESSOR_CACHE_TYPE,
};
PCACHE_DESCRIPTOR :: ^CACHE_DESCRIPTOR;

SYSTEM_LOGICAL_PROCESSOR_INFORMATION :: struct {
    ProcessorMask : ULONG_PTR,
    Relationship  : LOGICAL_PROCESSOR_RELATIONSHIP,
    u : struct #raw_union {
        ProcessorCore : struct {
            Flags : BYTE,
        },
        NumaNode : struct {
            NodeNumber : DWORD,
        },
        Cache         : CACHE_DESCRIPTOR,
        Reserved      : [2]ULONGLONG,
    },
};
PSYSTEM_LOGICAL_PROCESSOR_INFORMATION :: ^SYSTEM_LOGICAL_PROCESSOR_INFORMATION;

PROCESSOR_RELATIONSHIP :: struct {
    Flags           : BYTE,
    EfficiencyClass : BYTE,
    Reserved        : [20]BYTE,
    GroupCount      : WORD,
    GroupMask       : [1]GROUP_AFFINITY,
};
PPROCESSOR_RELATIONSHIP :: ^PROCESSOR_RELATIONSHIP;

NUMA_NODE_RELATIONSHIP :: struct {
    NodeNumber : DWORD,
    Reserved   : [20]BYTE,
    GroupMask  : GROUP_AFFINITY,
};
PNUMA_NODE_RELATIONSHIP :: ^NUMA_NODE_RELATIONSHIP;

CACHE_RELATIONSHIP :: struct {
    Level         : BYTE,
    Associativity : BYTE,
    LineSize      : WORD,
    CacheSize     : DWORD,
    Type          : PROCESSOR_CACHE_TYPE,
    Reserved      : [20]BYTE,
    GroupMask     : GROUP_AFFINITY,
};
PCACHE_RELATIONSHIP :: ^CACHE_RELATIONSHIP;

PROCESSOR_GROUP_INFO :: struct {
    MaximumProcessorCount : BYTE,
    ActiveProcessorCount  : BYTE,
    Reserved              : [38]BYTE,
    ActiveProcessorMask   : KAFFINITY,
};
PPROCESSOR_GROUP_INFO :: ^PROCESSOR_GROUP_INFO;

GROUP_RELATIONSHIP :: struct {
    MaximumGroupCount : WORD,
    ActiveGroupCount  : WORD,
    Reserved          : [20]BYTE,
    GroupInfo         : [1]PROCESSOR_GROUP_INFO,
};
PGROUP_RELATIONSHIP :: ^GROUP_RELATIONSHIP;

SYSTEM_LOGICAL_PROCESSOR_INFORMATION_EX :: struct {
    Relationship : LOGICAL_PROCESSOR_RELATIONSHIP,
    Size         : DWORD,
    u : struct #raw_union {
        Processor : PROCESSOR_RELATIONSHIP,
        NumaNode  : NUMA_NODE_RELATIONSHIP,
        Cache     : CACHE_RELATIONSHIP,
        Group     : GROUP_RELATIONSHIP,
    },
};

PSYSTEM_LOGICAL_PROCESSOR_INFORMATION_EX :: ^SYSTEM_LOGICAL_PROCESSOR_INFORMATION_EX;

/* CPU_SET_INFORMATION_TYPE :: enum { */
CPU_SET_INFORMATION_TYPE :: _c.int;
    CpuSetInformation :: 0;
/* } */
PCPU_SET_INFORMATION_TYPE :: ^CPU_SET_INFORMATION_TYPE;

SYSTEM_CPU_SET_INFORMATION :: struct {
    Size : DWORD,
    Type : CPU_SET_INFORMATION_TYPE,
    u : struct #raw_union {
        CpuSet : struct {
            Id                    : DWORD,
            Group                 : WORD,
            LogicalProcessorIndex : BYTE,
            CoreIndex             : BYTE,
            LastLevelCacheIndex   : BYTE,
            NumaNodeIndex         : BYTE,
            EfficiencyClass       : BYTE,
            u2 : struct #raw_union {
                AllFlags : BYTE,
                s : bit_field {
                    Parked                   : 1,
                    Allocated                : 1,
                    AllocatedToTargetProcess : 1,
                    RealTime                 : 1,
                    ReservedFlags            : 4,
                },
            },
            using _ : struct #raw_union {
                Reserved        : DWORD,
                SchedulingClass : BYTE,
            },
            AllocationTag         : DWORD64,
        },
    },
};

PSYSTEM_CPU_SET_INFORMATION :: ^SYSTEM_CPU_SET_INFORMATION;

SYSTEM_PROCESSOR_CYCLE_TIME_INFORMATION :: struct {
    CycleTime : DWORD64,
};
PSYSTEM_PROCESSOR_CYCLE_TIME_INFORMATION :: ^SYSTEM_PROCESSOR_CYCLE_TIME_INFORMATION;

XSTATE_FEATURE :: struct {
    Offset : DWORD,
    Size   : DWORD,
};
PXSTATE_FEATURE :: ^XSTATE_FEATURE;

XSTATE_CONFIGURATION :: struct {
    EnabledFeatures                      : DWORD64,
    EnabledVolatileFeatures              : DWORD64,
    Size                                 : DWORD,
    using _ : struct #raw_union {
        ControlFlags : DWORD,
        using _ : bit_field {
            OptimizedSave     : 1,
            CompactionEnabled : 1,
        },
    },
    Features                             : [(64)]XSTATE_FEATURE,
    EnabledSupervisorFeatures            : DWORD64,
    AlignedFeatures                      : DWORD64,
    AllFeatureSize                       : DWORD,
    AllFeatures                          : [(64)]DWORD,
    EnabledUserVisibleSupervisorFeatures : DWORD64,
};
PXSTATE_CONFIGURATION :: ^XSTATE_CONFIGURATION;

MEMORY_BASIC_INFORMATION :: struct {
    BaseAddress       : PVOID,
    AllocationBase    : PVOID,
    AllocationProtect : DWORD,
    RegionSize        : SIZE_T,
    State             : DWORD,
    Protect           : DWORD,
    Type              : DWORD,
};
PMEMORY_BASIC_INFORMATION :: ^MEMORY_BASIC_INFORMATION;

MEMORY_BASIC_INFORMATION32 :: struct {
    BaseAddress       : DWORD,
    AllocationBase    : DWORD,
    AllocationProtect : DWORD,
    RegionSize        : DWORD,
    State             : DWORD,
    Protect           : DWORD,
    Type              : DWORD,
};
PMEMORY_BASIC_INFORMATION32 :: ^MEMORY_BASIC_INFORMATION32;

MEMORY_BASIC_INFORMATION64 :: struct {
    BaseAddress       : ULONGLONG,
    AllocationBase    : ULONGLONG,
    AllocationProtect : DWORD,
    __alignment1      : DWORD,
    RegionSize        : ULONGLONG,
    State             : DWORD,
    Protect           : DWORD,
    Type              : DWORD,
    __alignment2      : DWORD,
};
PMEMORY_BASIC_INFORMATION64 :: ^MEMORY_BASIC_INFORMATION64;

CFG_CALL_TARGET_INFO :: struct {
    Offset : ULONG_PTR,
    Flags  : ULONG_PTR,
};
PCFG_CALL_TARGET_INFO :: ^CFG_CALL_TARGET_INFO;

MEM_ADDRESS_REQUIREMENTS :: struct {
    LowestStartingAddress : PVOID,
    HighestEndingAddress  : PVOID,
    Alignment             : SIZE_T,
};
PMEM_ADDRESS_REQUIREMENTS :: ^MEM_ADDRESS_REQUIREMENTS;

/* MEM_EXTENDED_PARAMETER_TYPE :: enum { */
MEM_EXTENDED_PARAMETER_TYPE :: _c.int;
    MemExtendedParameterInvalidType :: 0;
    MemExtendedParameterAddressRequirements :: MemExtendedParameterInvalidType + 1;
    MemExtendedParameterNumaNode :: MemExtendedParameterAddressRequirements + 1;
    MemExtendedParameterPartitionHandle :: MemExtendedParameterNumaNode + 1;
    MemExtendedParameterUserPhysicalHandle :: MemExtendedParameterPartitionHandle + 1;
    MemExtendedParameterAttributeFlags :: MemExtendedParameterUserPhysicalHandle + 1;
    MemExtendedParameterMax :: MemExtendedParameterAttributeFlags + 1;
/* } */
PMEM_EXTENDED_PARAMETER_TYPE :: ^MEM_EXTENDED_PARAMETER_TYPE;

MEM_EXTENDED_PARAMETER :: struct {
    s : bit_field {
        Type     : 8,
        Reserved : 64 - 8,
    },
    u : struct #raw_union {
        ULong64 : DWORD64,
        Pointer : PVOID,
        Size    : SIZE_T,
        Handle  : HANDLE,
        ULong   : DWORD,
    },
};
PMEM_EXTENDED_PARAMETER :: ^MEM_EXTENDED_PARAMETER;

/* MEM_SECTION_EXTENDED_PARAMETER_TYPE :: enum { */
MEM_SECTION_EXTENDED_PARAMETER_TYPE :: _c.int;
    MemSectionExtendedParameterInvalidType :: 0;
    MemSectionExtendedParameterUserPhysicalFlags :: MemSectionExtendedParameterInvalidType + 1;
    MemSectionExtendedParameterNumaNode :: MemSectionExtendedParameterUserPhysicalFlags + 1;
    MemSectionExtendedParameterMax :: MemSectionExtendedParameterNumaNode + 1;
/* } */
PMEM_SECTION_EXTENDED_PARAMETER_TYPE :: ^MEM_SECTION_EXTENDED_PARAMETER_TYPE;

ENCLAVE_CREATE_INFO_SGX :: struct {
    Secs : [4096]BYTE,
};
PENCLAVE_CREATE_INFO_SGX :: ^ENCLAVE_CREATE_INFO_SGX;

ENCLAVE_INIT_INFO_SGX :: struct {
    SigStruct  : [1808]BYTE,
    Reserved1  : [240]BYTE,
    EInitToken : [304]BYTE,
    Reserved2  : [1744]BYTE,
};
PENCLAVE_INIT_INFO_SGX :: ^ENCLAVE_INIT_INFO_SGX;

ENCLAVE_CREATE_INFO_VBS :: struct {
    Flags   : DWORD,
    OwnerID : [32]BYTE,
};
PENCLAVE_CREATE_INFO_VBS :: ^ENCLAVE_CREATE_INFO_VBS;

ENCLAVE_CREATE_INFO_VBS_BASIC :: struct {
    Flags   : DWORD,
    OwnerID : [32]BYTE,
};
PENCLAVE_CREATE_INFO_VBS_BASIC :: ^ENCLAVE_CREATE_INFO_VBS_BASIC;

ENCLAVE_LOAD_DATA_VBS_BASIC :: struct {
    PageType : DWORD,
};
PENCLAVE_LOAD_DATA_VBS_BASIC :: ^ENCLAVE_LOAD_DATA_VBS_BASIC;

ENCLAVE_INIT_INFO_VBS_BASIC :: struct {
    FamilyId    : [16]BYTE,
    ImageId     : [16]BYTE,
    EnclaveSize : ULONGLONG,
    EnclaveSvn  : DWORD,
    Reserved    : DWORD,
    u : struct #raw_union {
        SignatureInfoHandle : HANDLE,
        Unused              : ULONGLONG,
    },
};
PENCLAVE_INIT_INFO_VBS_BASIC :: ^ENCLAVE_INIT_INFO_VBS_BASIC;

ENCLAVE_INIT_INFO_VBS :: struct {
    Length      : DWORD,
    ThreadCount : DWORD,
};
PENCLAVE_INIT_INFO_VBS :: ^ENCLAVE_INIT_INFO_VBS;

ENCLAVE_TARGET_FUNCTION :: #type (proc(PVOID) -> PVOID);

PENCLAVE_TARGET_FUNCTION :: ^ENCLAVE_TARGET_FUNCTION;

LPENCLAVE_TARGET_FUNCTION :: PENCLAVE_TARGET_FUNCTION;

FILE_ID_128 :: struct {
    Identifier : [16]BYTE,
};
PFILE_ID_128 :: ^FILE_ID_128;

FILE_NOTIFY_INFORMATION :: struct {
    NextEntryOffset : DWORD,
    Action          : DWORD,
    FileNameLength  : DWORD,
    FileName        : [1]WCHAR,
};
PFILE_NOTIFY_INFORMATION :: ^FILE_NOTIFY_INFORMATION;

FILE_NOTIFY_EXTENDED_INFORMATION :: struct {
    NextEntryOffset      : DWORD,
    Action               : DWORD,
    CreationTime         : LARGE_INTEGER,
    LastModificationTime : LARGE_INTEGER,
    LastChangeTime       : LARGE_INTEGER,
    LastAccessTime       : LARGE_INTEGER,
    AllocatedLength      : LARGE_INTEGER,
    FileSize             : LARGE_INTEGER,
    FileAttributes       : DWORD,
    ReparsePointTag      : DWORD,
    FileId               : LARGE_INTEGER,
    ParentFileId         : LARGE_INTEGER,
    FileNameLength       : DWORD,
    FileName             : [1]WCHAR,
};
PFILE_NOTIFY_EXTENDED_INFORMATION :: ^FILE_NOTIFY_EXTENDED_INFORMATION;

FILE_SEGMENT_ELEMENT :: struct #raw_union {
    Buffer    : PVOID64,
    Alignment : ULONGLONG,
};
PFILE_SEGMENT_ELEMENT :: ^FILE_SEGMENT_ELEMENT;

REPARSE_GUID_DATA_BUFFER :: struct {
    ReparseTag           : DWORD,
    ReparseDataLength    : WORD,
    Reserved             : WORD,
    ReparseGuid          : GUID,
    GenericReparseBuffer : struct {
        DataBuffer : [1]BYTE,
    },
};
PREPARSE_GUID_DATA_BUFFER :: ^REPARSE_GUID_DATA_BUFFER;

SCRUB_DATA_INPUT :: struct {
    Size          : DWORD,
    Flags         : DWORD,
    MaximumIos    : DWORD,
    ObjectId      : [4]DWORD,
    Reserved      : [25]DWORD,
    ResumeContext : [816]BYTE,
};
PSCRUB_DATA_INPUT :: ^SCRUB_DATA_INPUT;

SCRUB_PARITY_EXTENT :: struct {
    Offset : LONGLONG,
    Length : ULONGLONG,
};
PSCRUB_PARITY_EXTENT :: ^SCRUB_PARITY_EXTENT;

SCRUB_PARITY_EXTENT_DATA :: struct {
    Size                         : WORD,
    Flags                        : WORD,
    NumberOfParityExtents        : WORD,
    MaximumNumberOfParityExtents : WORD,
    ParityExtents                : [1]SCRUB_PARITY_EXTENT,
};
PSCRUB_PARITY_EXTENT_DATA :: ^SCRUB_PARITY_EXTENT_DATA;

SCRUB_DATA_OUTPUT :: struct {
    Size                            : DWORD,
    Flags                           : DWORD,
    Status                          : DWORD,
    ErrorFileOffset                 : ULONGLONG,
    ErrorLength                     : ULONGLONG,
    NumberOfBytesRepaired           : ULONGLONG,
    NumberOfBytesFailed             : ULONGLONG,
    InternalFileReference           : ULONGLONG,
    ResumeContextLength             : WORD,
    ParityExtentDataOffset          : WORD,
    Reserved                        : [9]DWORD,
    NumberOfMetadataBytesProcessed  : ULONGLONG,
    NumberOfDataBytesProcessed      : ULONGLONG,
    TotalNumberOfMetadataBytesInUse : ULONGLONG,
    TotalNumberOfDataBytesInUse     : ULONGLONG,
    ResumeContext                   : [816]BYTE,
};
PSCRUB_DATA_OUTPUT :: ^SCRUB_DATA_OUTPUT;

/* SharedVirtualDiskSupportType :: enum { */
SharedVirtualDiskSupportType :: _c.int;
    SharedVirtualDisksUnsupported :: 0;
    SharedVirtualDisksSupported :: 1;
    SharedVirtualDiskSnapshotsSupported :: 3;
    SharedVirtualDiskCDPSnapshotsSupported :: 7;
/* } */
;

/* SharedVirtualDiskHandleState :: enum { */
SharedVirtualDiskHandleState :: _c.int;
    SharedVirtualDiskHandleStateNone :: 0;
    SharedVirtualDiskHandleStateFileShared :: 1;
    SharedVirtualDiskHandleStateHandleShared :: 3;
/* } */
;

SHARED_VIRTUAL_DISK_SUPPORT :: struct {
    SharedVirtualDiskSupport : SharedVirtualDiskSupportType,
    HandleState              : SharedVirtualDiskHandleState,
};
PSHARED_VIRTUAL_DISK_SUPPORT :: ^SHARED_VIRTUAL_DISK_SUPPORT;

REARRANGE_FILE_DATA :: struct {
    SourceStartingOffset : ULONGLONG,
    TargetOffset         : ULONGLONG,
    SourceFileHandle     : HANDLE,
    Length               : DWORD,
    Flags                : DWORD,
};
PREARRANGE_FILE_DATA :: ^REARRANGE_FILE_DATA;

REARRANGE_FILE_DATA32 :: struct {
    SourceStartingOffset : ULONGLONG,
    TargetOffset         : ULONGLONG,
    SourceFileHandle     : UINT32,
    Length               : DWORD,
    Flags                : DWORD,
};
PREARRANGE_FILE_DATA32 :: ^REARRANGE_FILE_DATA32;

SHUFFLE_FILE_DATA :: struct {
    StartingOffset : LONGLONG,
    Length         : LONGLONG,
    Flags          : DWORD,
};
PSHUFFLE_FILE_DATA :: ^SHUFFLE_FILE_DATA;

NETWORK_APP_INSTANCE_EA :: struct {
    AppInstanceID : GUID,
    CsvFlags      : DWORD,
};
PNETWORK_APP_INSTANCE_EA :: ^NETWORK_APP_INSTANCE_EA;

/* SYSTEM_POWER_STATE :: enum { */
SYSTEM_POWER_STATE :: _c.int;
    PowerSystemUnspecified :: 0;
    PowerSystemWorking :: 1;
    PowerSystemSleeping1 :: 2;
    PowerSystemSleeping2 :: 3;
    PowerSystemSleeping3 :: 4;
    PowerSystemHibernate :: 5;
    PowerSystemShutdown :: 6;
    PowerSystemMaximum :: 7;
/* } */
PSYSTEM_POWER_STATE :: ^SYSTEM_POWER_STATE;

/* POWER_ACTION :: enum { */
POWER_ACTION :: _c.int;
    PowerActionNone :: 0;
    PowerActionReserved :: PowerActionNone + 1;
    PowerActionSleep :: PowerActionReserved + 1;
    PowerActionHibernate :: PowerActionSleep + 1;
    PowerActionShutdown :: PowerActionHibernate + 1;
    PowerActionShutdownReset :: PowerActionShutdown + 1;
    PowerActionShutdownOff :: PowerActionShutdownReset + 1;
    PowerActionWarmEject :: PowerActionShutdownOff + 1;
    PowerActionDisplayOff :: PowerActionWarmEject + 1;
/* } */
PPOWER_ACTION :: ^POWER_ACTION;

/* DEVICE_POWER_STATE :: enum { */
DEVICE_POWER_STATE :: _c.int;
    PowerDeviceUnspecified :: 0;
    PowerDeviceD0 :: PowerDeviceUnspecified + 1;
    PowerDeviceD1 :: PowerDeviceD0 + 1;
    PowerDeviceD2 :: PowerDeviceD1 + 1;
    PowerDeviceD3 :: PowerDeviceD2 + 1;
    PowerDeviceMaximum :: PowerDeviceD3 + 1;
/* } */
PDEVICE_POWER_STATE :: ^DEVICE_POWER_STATE;

/* MONITOR_DISPLAY_STATE :: enum { */
MONITOR_DISPLAY_STATE :: _c.int;
    PowerMonitorOff :: 0;
    PowerMonitorOn :: PowerMonitorOff + 1;
    PowerMonitorDim :: PowerMonitorOn + 1;
/* } */
PMONITOR_DISPLAY_STATE :: ^MONITOR_DISPLAY_STATE;

/* USER_ACTIVITY_PRESENCE :: enum { */
USER_ACTIVITY_PRESENCE :: _c.int;
    PowerUserPresent :: 0;
    PowerUserNotPresent :: PowerUserPresent + 1;
    PowerUserInactive :: PowerUserNotPresent + 1;
    PowerUserMaximum :: PowerUserInactive + 1;
    PowerUserInvalid ::     PowerUserMaximum;
/* } */
PUSER_ACTIVITY_PRESENCE :: ^USER_ACTIVITY_PRESENCE;

EXECUTION_STATE :: DWORD;
PEXECUTION_STATE :: ^DWORD;

/* LATENCY_TIME :: enum { */
LATENCY_TIME :: _c.int;
    LT_DONT_CARE :: 0;
    LT_LOWEST_LATENCY :: LT_DONT_CARE + 1;
/* } */
;

/* POWER_REQUEST_TYPE :: enum { */
POWER_REQUEST_TYPE :: _c.int;
    PowerRequestDisplayRequired :: 0;
    PowerRequestSystemRequired :: PowerRequestDisplayRequired + 1;
    PowerRequestAwayModeRequired :: PowerRequestSystemRequired + 1;
    PowerRequestExecutionRequired :: PowerRequestAwayModeRequired + 1;
/* } */
PPOWER_REQUEST_TYPE :: ^POWER_REQUEST_TYPE;

CM_POWER_DATA :: struct {
    PD_Size                 : DWORD,
    PD_MostRecentPowerState : DEVICE_POWER_STATE,
    PD_Capabilities         : DWORD,
    PD_D1Latency            : DWORD,
    PD_D2Latency            : DWORD,
    PD_D3Latency            : DWORD,
    PD_PowerStateMapping    : [7]DEVICE_POWER_STATE,
    PD_DeepestSystemWake    : SYSTEM_POWER_STATE,
};
PCM_POWER_DATA :: ^CM_POWER_DATA;

/* POWER_INFORMATION_LEVEL :: enum { */
POWER_INFORMATION_LEVEL :: _c.int;
    SystemPowerPolicyAc :: 0;
    SystemPowerPolicyDc :: SystemPowerPolicyAc + 1;
    VerifySystemPolicyAc :: SystemPowerPolicyDc + 1;
    VerifySystemPolicyDc :: VerifySystemPolicyAc + 1;
    SystemPowerCapabilities :: VerifySystemPolicyDc + 1;
    SystemBatteryState :: SystemPowerCapabilities + 1;
    SystemPowerStateHandler :: SystemBatteryState + 1;
    ProcessorStateHandler :: SystemPowerStateHandler + 1;
    SystemPowerPolicyCurrent :: ProcessorStateHandler + 1;
    AdministratorPowerPolicy :: SystemPowerPolicyCurrent + 1;
    SystemReserveHiberFile :: AdministratorPowerPolicy + 1;
    ProcessorInformation :: SystemReserveHiberFile + 1;
    SystemPowerInformation :: ProcessorInformation + 1;
    ProcessorStateHandler2 :: SystemPowerInformation + 1;
    LastWakeTime :: ProcessorStateHandler2 + 1;
    LastSleepTime :: LastWakeTime + 1;
    SystemExecutionState :: LastSleepTime + 1;
    SystemPowerStateNotifyHandler :: SystemExecutionState + 1;
    ProcessorPowerPolicyAc :: SystemPowerStateNotifyHandler + 1;
    ProcessorPowerPolicyDc :: ProcessorPowerPolicyAc + 1;
    VerifyProcessorPowerPolicyAc :: ProcessorPowerPolicyDc + 1;
    VerifyProcessorPowerPolicyDc :: VerifyProcessorPowerPolicyAc + 1;
    ProcessorPowerPolicyCurrent :: VerifyProcessorPowerPolicyDc + 1;
    SystemPowerStateLogging :: ProcessorPowerPolicyCurrent + 1;
    SystemPowerLoggingEntry :: SystemPowerStateLogging + 1;
    SetPowerSettingValue :: SystemPowerLoggingEntry + 1;
    NotifyUserPowerSetting :: SetPowerSettingValue + 1;
    PowerInformationLevelUnused0 :: NotifyUserPowerSetting + 1;
    SystemMonitorHiberBootPowerOff :: PowerInformationLevelUnused0 + 1;
    SystemVideoState :: SystemMonitorHiberBootPowerOff + 1;
    TraceApplicationPowerMessage :: SystemVideoState + 1;
    TraceApplicationPowerMessageEnd :: TraceApplicationPowerMessage + 1;
    ProcessorPerfStates :: TraceApplicationPowerMessageEnd + 1;
    ProcessorIdleStates :: ProcessorPerfStates + 1;
    ProcessorCap :: ProcessorIdleStates + 1;
    SystemWakeSource :: ProcessorCap + 1;
    SystemHiberFileInformation :: SystemWakeSource + 1;
    TraceServicePowerMessage :: SystemHiberFileInformation + 1;
    ProcessorLoad :: TraceServicePowerMessage + 1;
    PowerShutdownNotification :: ProcessorLoad + 1;
    MonitorCapabilities :: PowerShutdownNotification + 1;
    SessionPowerInit :: MonitorCapabilities + 1;
    SessionDisplayState :: SessionPowerInit + 1;
    PowerRequestCreate :: SessionDisplayState + 1;
    PowerRequestAction :: PowerRequestCreate + 1;
    GetPowerRequestList :: PowerRequestAction + 1;
    ProcessorInformationEx :: GetPowerRequestList + 1;
    NotifyUserModeLegacyPowerEvent :: ProcessorInformationEx + 1;
    GroupPark :: NotifyUserModeLegacyPowerEvent + 1;
    ProcessorIdleDomains :: GroupPark + 1;
    WakeTimerList :: ProcessorIdleDomains + 1;
    SystemHiberFileSize :: WakeTimerList + 1;
    ProcessorIdleStatesHv :: SystemHiberFileSize + 1;
    ProcessorPerfStatesHv :: ProcessorIdleStatesHv + 1;
    ProcessorPerfCapHv :: ProcessorPerfStatesHv + 1;
    ProcessorSetIdle :: ProcessorPerfCapHv + 1;
    LogicalProcessorIdling :: ProcessorSetIdle + 1;
    UserPresence :: LogicalProcessorIdling + 1;
    PowerSettingNotificationName :: UserPresence + 1;
    GetPowerSettingValue :: PowerSettingNotificationName + 1;
    IdleResiliency :: GetPowerSettingValue + 1;
    SessionRITState :: IdleResiliency + 1;
    SessionConnectNotification :: SessionRITState + 1;
    SessionPowerCleanup :: SessionConnectNotification + 1;
    SessionLockState :: SessionPowerCleanup + 1;
    SystemHiberbootState :: SessionLockState + 1;
    PlatformInformation :: SystemHiberbootState + 1;
    PdcInvocation :: PlatformInformation + 1;
    MonitorInvocation :: PdcInvocation + 1;
    FirmwareTableInformationRegistered :: MonitorInvocation + 1;
    SetShutdownSelectedTime :: FirmwareTableInformationRegistered + 1;
    SuspendResumeInvocation :: SetShutdownSelectedTime + 1;
    PlmPowerRequestCreate :: SuspendResumeInvocation + 1;
    ScreenOff :: PlmPowerRequestCreate + 1;
    CsDeviceNotification :: ScreenOff + 1;
    PlatformRole :: CsDeviceNotification + 1;
    LastResumePerformance :: PlatformRole + 1;
    DisplayBurst :: LastResumePerformance + 1;
    ExitLatencySamplingPercentage :: DisplayBurst + 1;
    RegisterSpmPowerSettings :: ExitLatencySamplingPercentage + 1;
    PlatformIdleStates :: RegisterSpmPowerSettings + 1;
    ProcessorIdleVeto :: PlatformIdleStates + 1;
    PlatformIdleVeto :: ProcessorIdleVeto + 1;
    SystemBatteryStatePrecise :: PlatformIdleVeto + 1;
    ThermalEvent :: SystemBatteryStatePrecise + 1;
    PowerRequestActionInternal :: ThermalEvent + 1;
    BatteryDeviceState :: PowerRequestActionInternal + 1;
    PowerInformationInternal :: BatteryDeviceState + 1;
    ThermalStandby :: PowerInformationInternal + 1;
    SystemHiberFileType :: ThermalStandby + 1;
    PhysicalPowerButtonPress :: SystemHiberFileType + 1;
    QueryPotentialDripsConstraint :: PhysicalPowerButtonPress + 1;
    EnergyTrackerCreate :: QueryPotentialDripsConstraint + 1;
    EnergyTrackerQuery :: EnergyTrackerCreate + 1;
    UpdateBlackBoxRecorder :: EnergyTrackerQuery + 1;
    PowerInformationLevelMaximum :: UpdateBlackBoxRecorder + 1;
/* } */
;

/* POWER_USER_PRESENCE_TYPE :: enum { */
POWER_USER_PRESENCE_TYPE :: _c.int;
    UserNotPresent :: 0;
    UserPresent :: 1;
    UserUnknown :: 0xff;
/* } */
PPOWER_USER_PRESENCE_TYPE :: ^POWER_USER_PRESENCE_TYPE;

POWER_USER_PRESENCE :: struct {
    UserPresence : POWER_USER_PRESENCE_TYPE,
};
PPOWER_USER_PRESENCE :: ^POWER_USER_PRESENCE;

POWER_SESSION_CONNECT :: struct {
    Connected : BOOLEAN,
    Console   : BOOLEAN,
};
PPOWER_SESSION_CONNECT :: ^POWER_SESSION_CONNECT;

POWER_SESSION_TIMEOUTS :: struct {
    InputTimeout   : DWORD,
    DisplayTimeout : DWORD,
};
PPOWER_SESSION_TIMEOUTS :: ^POWER_SESSION_TIMEOUTS;

POWER_SESSION_RIT_STATE :: struct {
    Active        : BOOLEAN,
    LastInputTime : DWORD,
};
PPOWER_SESSION_RIT_STATE :: ^POWER_SESSION_RIT_STATE;

POWER_SESSION_WINLOGON :: struct {
    SessionId : DWORD,
    Console   : BOOLEAN,
    Locked    : BOOLEAN,
};
PPOWER_SESSION_WINLOGON :: ^POWER_SESSION_WINLOGON;

POWER_IDLE_RESILIENCY :: struct {
    CoalescingTimeout    : DWORD,
    IdleResiliencyPeriod : DWORD,
};
PPOWER_IDLE_RESILIENCY :: ^POWER_IDLE_RESILIENCY;

/* POWER_MONITOR_REQUEST_REASON :: enum { */
POWER_MONITOR_REQUEST_REASON :: _c.int;
    MonitorRequestReasonUnknown :: 0;
    MonitorRequestReasonPowerButton :: MonitorRequestReasonUnknown + 1;
    MonitorRequestReasonRemoteConnection :: MonitorRequestReasonPowerButton + 1;
    MonitorRequestReasonScMonitorpower :: MonitorRequestReasonRemoteConnection + 1;
    MonitorRequestReasonUserInput :: MonitorRequestReasonScMonitorpower + 1;
    MonitorRequestReasonAcDcDisplayBurst :: MonitorRequestReasonUserInput + 1;
    MonitorRequestReasonUserDisplayBurst :: MonitorRequestReasonAcDcDisplayBurst + 1;
    MonitorRequestReasonPoSetSystemState :: MonitorRequestReasonUserDisplayBurst + 1;
    MonitorRequestReasonSetThreadExecutionState :: MonitorRequestReasonPoSetSystemState + 1;
    MonitorRequestReasonFullWake :: MonitorRequestReasonSetThreadExecutionState + 1;
    MonitorRequestReasonSessionUnlock :: MonitorRequestReasonFullWake + 1;
    MonitorRequestReasonScreenOffRequest :: MonitorRequestReasonSessionUnlock + 1;
    MonitorRequestReasonIdleTimeout :: MonitorRequestReasonScreenOffRequest + 1;
    MonitorRequestReasonPolicyChange :: MonitorRequestReasonIdleTimeout + 1;
    MonitorRequestReasonSleepButton :: MonitorRequestReasonPolicyChange + 1;
    MonitorRequestReasonLid :: MonitorRequestReasonSleepButton + 1;
    MonitorRequestReasonBatteryCountChange :: MonitorRequestReasonLid + 1;
    MonitorRequestReasonGracePeriod :: MonitorRequestReasonBatteryCountChange + 1;
    MonitorRequestReasonPnP :: MonitorRequestReasonGracePeriod + 1;
    MonitorRequestReasonDP :: MonitorRequestReasonPnP + 1;
    MonitorRequestReasonSxTransition :: MonitorRequestReasonDP + 1;
    MonitorRequestReasonSystemIdle :: MonitorRequestReasonSxTransition + 1;
    MonitorRequestReasonNearProximity :: MonitorRequestReasonSystemIdle + 1;
    MonitorRequestReasonThermalStandby :: MonitorRequestReasonNearProximity + 1;
    MonitorRequestReasonResumePdc :: MonitorRequestReasonThermalStandby + 1;
    MonitorRequestReasonResumeS4 :: MonitorRequestReasonResumePdc + 1;
    MonitorRequestReasonTerminal :: MonitorRequestReasonResumeS4 + 1;
    MonitorRequestReasonPdcSignal :: MonitorRequestReasonTerminal + 1;
    MonitorRequestReasonAcDcDisplayBurstSuppressed :: MonitorRequestReasonPdcSignal + 1;
    MonitorRequestReasonSystemStateEntered :: MonitorRequestReasonAcDcDisplayBurstSuppressed + 1;
    MonitorRequestReasonWinrt :: MonitorRequestReasonSystemStateEntered + 1;
    MonitorRequestReasonUserInputKeyboard :: MonitorRequestReasonWinrt + 1;
    MonitorRequestReasonUserInputMouse :: MonitorRequestReasonUserInputKeyboard + 1;
    MonitorRequestReasonUserInputTouch :: MonitorRequestReasonUserInputMouse + 1;
    MonitorRequestReasonUserInputPen :: MonitorRequestReasonUserInputTouch + 1;
    MonitorRequestReasonUserInputAccelerometer :: MonitorRequestReasonUserInputPen + 1;
    MonitorRequestReasonUserInputHid :: MonitorRequestReasonUserInputAccelerometer + 1;
    MonitorRequestReasonUserInputPoUserPresent :: MonitorRequestReasonUserInputHid + 1;
    MonitorRequestReasonUserInputSessionSwitch :: MonitorRequestReasonUserInputPoUserPresent + 1;
    MonitorRequestReasonUserInputInitialization :: MonitorRequestReasonUserInputSessionSwitch + 1;
    MonitorRequestReasonPdcSignalWindowsMobilePwrNotif :: MonitorRequestReasonUserInputInitialization + 1;
    MonitorRequestReasonPdcSignalWindowsMobileShell :: MonitorRequestReasonPdcSignalWindowsMobilePwrNotif + 1;
    MonitorRequestReasonPdcSignalHeyCortana :: MonitorRequestReasonPdcSignalWindowsMobileShell + 1;
    MonitorRequestReasonPdcSignalHolographicShell :: MonitorRequestReasonPdcSignalHeyCortana + 1;
    MonitorRequestReasonPdcSignalFingerprint :: MonitorRequestReasonPdcSignalHolographicShell + 1;
    MonitorRequestReasonDirectedDrips :: MonitorRequestReasonPdcSignalFingerprint + 1;
    MonitorRequestReasonMax :: MonitorRequestReasonDirectedDrips + 1;
/* } */
;

/* POWER_MONITOR_REQUEST_TYPE :: enum { */
POWER_MONITOR_REQUEST_TYPE :: _c.int;
    MonitorRequestTypeOff :: 0;
    MonitorRequestTypeOnAndPresent :: MonitorRequestTypeOff + 1;
    MonitorRequestTypeToggleOn :: MonitorRequestTypeOnAndPresent + 1;
/* } */
;

POWER_MONITOR_INVOCATION :: struct {
    Console       : BOOLEAN,
    RequestReason : POWER_MONITOR_REQUEST_REASON,
};
PPOWER_MONITOR_INVOCATION :: ^POWER_MONITOR_INVOCATION;

RESUME_PERFORMANCE :: struct {
    PostTimeMs              : DWORD,
    TotalResumeTimeMs       : ULONGLONG,
    ResumeCompleteTimestamp : ULONGLONG,
};
PRESUME_PERFORMANCE :: ^RESUME_PERFORMANCE;

/* SYSTEM_POWER_CONDITION :: enum { */
SYSTEM_POWER_CONDITION :: _c.int;
    PoAc :: 0;
    PoDc :: PoAc + 1;
    PoHot :: PoDc + 1;
    PoConditionMaximum :: PoHot + 1;
/* } */
;

SET_POWER_SETTING_VALUE :: struct {
    Version        : DWORD,
    Guid           : GUID,
    PowerCondition : SYSTEM_POWER_CONDITION,
    DataLength     : DWORD,
    Data           : [1]BYTE,
};
PSET_POWER_SETTING_VALUE :: ^SET_POWER_SETTING_VALUE;

NOTIFY_USER_POWER_SETTING :: struct {
    Guid : GUID,
};
PNOTIFY_USER_POWER_SETTING :: ^NOTIFY_USER_POWER_SETTING;

APPLICATIONLAUNCH_SETTING_VALUE :: struct {
    ActivationTime   : LARGE_INTEGER,
    Flags            : DWORD,
    ButtonInstanceID : DWORD,
};
PAPPLICATIONLAUNCH_SETTING_VALUE :: ^APPLICATIONLAUNCH_SETTING_VALUE;

/* POWER_PLATFORM_ROLE :: enum { */
POWER_PLATFORM_ROLE :: _c.int;
    PlatformRoleUnspecified :: 0;
    PlatformRoleDesktop :: PlatformRoleUnspecified + 1;
    PlatformRoleMobile :: PlatformRoleDesktop + 1;
    PlatformRoleWorkstation :: PlatformRoleMobile + 1;
    PlatformRoleEnterpriseServer :: PlatformRoleWorkstation + 1;
    PlatformRoleSOHOServer :: PlatformRoleEnterpriseServer + 1;
    PlatformRoleAppliancePC :: PlatformRoleSOHOServer + 1;
    PlatformRolePerformanceServer :: PlatformRoleAppliancePC + 1;
    PlatformRoleSlate :: PlatformRolePerformanceServer + 1;
    PlatformRoleMaximum :: PlatformRoleSlate + 1;
/* } */
PPOWER_PLATFORM_ROLE :: ^POWER_PLATFORM_ROLE;

POWER_PLATFORM_INFORMATION :: struct {
    AoAc : BOOLEAN,
};
PPOWER_PLATFORM_INFORMATION :: ^POWER_PLATFORM_INFORMATION;

BATTERY_REPORTING_SCALE :: struct {
    Granularity : DWORD,
    Capacity    : DWORD,
};
PBATTERY_REPORTING_SCALE :: ^BATTERY_REPORTING_SCALE;

PPM_WMI_LEGACY_PERFSTATE :: struct {
    Frequency        : DWORD,
    Flags            : DWORD,
    PercentFrequency : DWORD,
};
PPPM_WMI_LEGACY_PERFSTATE :: ^PPM_WMI_LEGACY_PERFSTATE;

PPM_WMI_IDLE_STATE :: struct {
    Latency        : DWORD,
    Power          : DWORD,
    TimeCheck      : DWORD,
    PromotePercent : BYTE,
    DemotePercent  : BYTE,
    StateType      : BYTE,
    Reserved       : BYTE,
    StateFlags     : DWORD,
    Context        : DWORD,
    IdleHandler    : DWORD,
    Reserved1      : DWORD,
};
PPPM_WMI_IDLE_STATE :: ^PPM_WMI_IDLE_STATE;

PPM_WMI_IDLE_STATES :: struct {
    Type             : DWORD,
    Count            : DWORD,
    TargetState      : DWORD,
    OldState         : DWORD,
    TargetProcessors : DWORD64,
    State            : [1]PPM_WMI_IDLE_STATE,
};
PPPM_WMI_IDLE_STATES :: ^PPM_WMI_IDLE_STATES;

PPM_WMI_IDLE_STATES_EX :: struct {
    Type             : DWORD,
    Count            : DWORD,
    TargetState      : DWORD,
    OldState         : DWORD,
    TargetProcessors : PVOID,
    State            : [1]PPM_WMI_IDLE_STATE,
};
PPPM_WMI_IDLE_STATES_EX :: ^PPM_WMI_IDLE_STATES_EX;

PPM_WMI_PERF_STATE :: struct {
    Frequency        : DWORD,
    Power            : DWORD,
    PercentFrequency : BYTE,
    IncreaseLevel    : BYTE,
    DecreaseLevel    : BYTE,
    Type             : BYTE,
    IncreaseTime     : DWORD,
    DecreaseTime     : DWORD,
    Control          : DWORD64,
    Status           : DWORD64,
    HitCount         : DWORD,
    Reserved1        : DWORD,
    Reserved2        : DWORD64,
    Reserved3        : DWORD64,
};
PPPM_WMI_PERF_STATE :: ^PPM_WMI_PERF_STATE;

PPM_WMI_PERF_STATES :: struct {
    Count             : DWORD,
    MaxFrequency      : DWORD,
    CurrentState      : DWORD,
    MaxPerfState      : DWORD,
    MinPerfState      : DWORD,
    LowestPerfState   : DWORD,
    ThermalConstraint : DWORD,
    BusyAdjThreshold  : BYTE,
    PolicyType        : BYTE,
    Type              : BYTE,
    Reserved          : BYTE,
    TimerInterval     : DWORD,
    TargetProcessors  : DWORD64,
    PStateHandler     : DWORD,
    PStateContext     : DWORD,
    TStateHandler     : DWORD,
    TStateContext     : DWORD,
    FeedbackHandler   : DWORD,
    Reserved1         : DWORD,
    Reserved2         : DWORD64,
    State             : [1]PPM_WMI_PERF_STATE,
};
PPPM_WMI_PERF_STATES :: ^PPM_WMI_PERF_STATES;

PPM_WMI_PERF_STATES_EX :: struct {
    Count             : DWORD,
    MaxFrequency      : DWORD,
    CurrentState      : DWORD,
    MaxPerfState      : DWORD,
    MinPerfState      : DWORD,
    LowestPerfState   : DWORD,
    ThermalConstraint : DWORD,
    BusyAdjThreshold  : BYTE,
    PolicyType        : BYTE,
    Type              : BYTE,
    Reserved          : BYTE,
    TimerInterval     : DWORD,
    TargetProcessors  : PVOID,
    PStateHandler     : DWORD,
    PStateContext     : DWORD,
    TStateHandler     : DWORD,
    TStateContext     : DWORD,
    FeedbackHandler   : DWORD,
    Reserved1         : DWORD,
    Reserved2         : DWORD64,
    State             : [1]PPM_WMI_PERF_STATE,
};
PPPM_WMI_PERF_STATES_EX :: ^PPM_WMI_PERF_STATES_EX;

PPM_IDLE_STATE_ACCOUNTING :: struct {
    IdleTransitions    : DWORD,
    FailedTransitions  : DWORD,
    InvalidBucketIndex : DWORD,
    TotalTime          : DWORD64,
    IdleTimeBuckets    : [6]DWORD,
};
PPPM_IDLE_STATE_ACCOUNTING :: ^PPM_IDLE_STATE_ACCOUNTING;

PPM_IDLE_ACCOUNTING :: struct {
    StateCount       : DWORD,
    TotalTransitions : DWORD,
    ResetCount       : DWORD,
    StartTime        : DWORD64,
    State            : [1]PPM_IDLE_STATE_ACCOUNTING,
};
PPPM_IDLE_ACCOUNTING :: ^PPM_IDLE_ACCOUNTING;

PPM_IDLE_STATE_BUCKET_EX :: struct {
    TotalTimeUs : DWORD64,
    MinTimeUs   : DWORD,
    MaxTimeUs   : DWORD,
    Count       : DWORD,
};
PPPM_IDLE_STATE_BUCKET_EX :: ^PPM_IDLE_STATE_BUCKET_EX;

PPM_IDLE_STATE_ACCOUNTING_EX :: struct {
    TotalTime            : DWORD64,
    IdleTransitions      : DWORD,
    FailedTransitions    : DWORD,
    InvalidBucketIndex   : DWORD,
    MinTimeUs            : DWORD,
    MaxTimeUs            : DWORD,
    CancelledTransitions : DWORD,
    IdleTimeBuckets      : [16]PPM_IDLE_STATE_BUCKET_EX,
};
PPPM_IDLE_STATE_ACCOUNTING_EX :: ^PPM_IDLE_STATE_ACCOUNTING_EX;

PPM_IDLE_ACCOUNTING_EX :: struct {
    StateCount       : DWORD,
    TotalTransitions : DWORD,
    ResetCount       : DWORD,
    AbortCount       : DWORD,
    StartTime        : DWORD64,
    State            : [1]PPM_IDLE_STATE_ACCOUNTING_EX,
};
PPPM_IDLE_ACCOUNTING_EX :: ^PPM_IDLE_ACCOUNTING_EX;

PPM_PERFSTATE_EVENT :: struct {
    State     : DWORD,
    Status    : DWORD,
    Latency   : DWORD,
    Speed     : DWORD,
    Processor : DWORD,
};
PPPM_PERFSTATE_EVENT :: ^PPM_PERFSTATE_EVENT;

PPM_PERFSTATE_DOMAIN_EVENT :: struct {
    State      : DWORD,
    Latency    : DWORD,
    Speed      : DWORD,
    Processors : DWORD64,
};
PPPM_PERFSTATE_DOMAIN_EVENT :: ^PPM_PERFSTATE_DOMAIN_EVENT;

PPM_IDLESTATE_EVENT :: struct {
    NewState   : DWORD,
    OldState   : DWORD,
    Processors : DWORD64,
};
PPPM_IDLESTATE_EVENT :: ^PPM_IDLESTATE_EVENT;

PPM_THERMALCHANGE_EVENT :: struct {
    ThermalConstraint : DWORD,
    Processors        : DWORD64,
};
PPPM_THERMALCHANGE_EVENT :: ^PPM_THERMALCHANGE_EVENT;

PPM_THERMAL_POLICY_EVENT :: struct {
    Mode       : BYTE,
    Processors : DWORD64,
};
PPPM_THERMAL_POLICY_EVENT :: ^PPM_THERMAL_POLICY_EVENT;

POWER_ACTION_POLICY :: struct {
    Action    : POWER_ACTION,
    Flags     : DWORD,
    EventCode : DWORD,
};
PPOWER_ACTION_POLICY :: ^POWER_ACTION_POLICY;

SYSTEM_POWER_LEVEL :: struct {
    Enable         : BOOLEAN,
    Spare          : [3]BYTE,
    BatteryLevel   : DWORD,
    PowerPolicy    : POWER_ACTION_POLICY,
    MinSystemState : SYSTEM_POWER_STATE,
};
PSYSTEM_POWER_LEVEL :: ^SYSTEM_POWER_LEVEL;

SYSTEM_POWER_POLICY :: struct {
    Revision                    : DWORD,
    PowerButton                 : POWER_ACTION_POLICY,
    SleepButton                 : POWER_ACTION_POLICY,
    LidClose                    : POWER_ACTION_POLICY,
    LidOpenWake                 : SYSTEM_POWER_STATE,
    Reserved                    : DWORD,
    Idle                        : POWER_ACTION_POLICY,
    IdleTimeout                 : DWORD,
    IdleSensitivity             : BYTE,
    DynamicThrottle             : BYTE,
    Spare2                      : [2]BYTE,
    MinSleep                    : SYSTEM_POWER_STATE,
    MaxSleep                    : SYSTEM_POWER_STATE,
    ReducedLatencySleep         : SYSTEM_POWER_STATE,
    WinLogonFlags               : DWORD,
    Spare3                      : DWORD,
    DozeS4Timeout               : DWORD,
    BroadcastCapacityResolution : DWORD,
    DischargePolicy             : [4]SYSTEM_POWER_LEVEL,
    VideoTimeout                : DWORD,
    VideoDimDisplay             : BOOLEAN,
    VideoReserved               : [3]DWORD,
    SpindownTimeout             : DWORD,
    OptimizeForPower            : BOOLEAN,
    FanThrottleTolerance        : BYTE,
    ForcedThrottle              : BYTE,
    MinThrottle                 : BYTE,
    OverThrottled               : POWER_ACTION_POLICY,
};
PSYSTEM_POWER_POLICY :: ^SYSTEM_POWER_POLICY;

PROCESSOR_IDLESTATE_INFO :: struct {
    TimeCheck      : DWORD,
    DemotePercent  : BYTE,
    PromotePercent : BYTE,
    Spare          : [2]BYTE,
};
PPROCESSOR_IDLESTATE_INFO :: ^PROCESSOR_IDLESTATE_INFO;

PROCESSOR_IDLESTATE_POLICY :: struct {
    Revision    : WORD,
    Flags : struct #raw_union {
        AsWORD : WORD,
        s : bit_field {
            AllowScaling : 1,
            Disabled     : 1,
            Reserved     : 14,
        },
    },
    PolicyCount : DWORD,
    Policy      : [0x3]PROCESSOR_IDLESTATE_INFO,
};
PPROCESSOR_IDLESTATE_POLICY :: ^PROCESSOR_IDLESTATE_POLICY;

PROCESSOR_POWER_POLICY_INFO :: struct {
    TimeCheck      : DWORD,
    DemoteLimit    : DWORD,
    PromoteLimit   : DWORD,
    DemotePercent  : BYTE,
    PromotePercent : BYTE,
    Spare          : [2]BYTE,
    using _ : bit_field {
        AllowDemotion  : 1,
        AllowPromotion : 1,
        Reserved       : 30,
    },
};
PPROCESSOR_POWER_POLICY_INFO :: ^PROCESSOR_POWER_POLICY_INFO;

PROCESSOR_POWER_POLICY :: struct {
    Revision        : DWORD,
    DynamicThrottle : BYTE,
    Spare           : [3]BYTE,
    using _ : bit_field {
        DisableCStates  : 1,
        Reserved        : 31,
    },
    PolicyCount     : DWORD,
    Policy          : [3]PROCESSOR_POWER_POLICY_INFO,
};
PPROCESSOR_POWER_POLICY :: ^PROCESSOR_POWER_POLICY;

PROCESSOR_PERFSTATE_POLICY :: struct {
    Revision         : DWORD,
    MaxThrottle      : BYTE,
    MinThrottle      : BYTE,
    BusyAdjThreshold : BYTE,
    u : struct #raw_union {
        Spare : BYTE,
        Flags : struct #raw_union {
            AsBYTE : BYTE,
            s : bit_field {
                NoDomainAccounting : 1,
                IncreasePolicy     : 2,
                DecreasePolicy     : 2,
                Reserved           : 3,
            },
        },
    },
    TimeCheck        : DWORD,
    IncreaseTime     : DWORD,
    DecreaseTime     : DWORD,
    IncreasePercent  : DWORD,
    DecreasePercent  : DWORD,
};
PPROCESSOR_PERFSTATE_POLICY :: ^PROCESSOR_PERFSTATE_POLICY;

ADMINISTRATOR_POWER_POLICY :: struct {
    MinSleep           : SYSTEM_POWER_STATE,
    MaxSleep           : SYSTEM_POWER_STATE,
    MinVideoTimeout    : DWORD,
    MaxVideoTimeout    : DWORD,
    MinSpindownTimeout : DWORD,
    MaxSpindownTimeout : DWORD,
};
PADMINISTRATOR_POWER_POLICY :: ^ADMINISTRATOR_POWER_POLICY;

/* HIBERFILE_BUCKET_SIZE :: enum { */
HIBERFILE_BUCKET_SIZE :: _c.int;
    HiberFileBucket1GB :: 0;
    HiberFileBucket2GB :: HiberFileBucket1GB + 1;
    HiberFileBucket4GB :: HiberFileBucket2GB + 1;
    HiberFileBucket8GB :: HiberFileBucket4GB + 1;
    HiberFileBucket16GB :: HiberFileBucket8GB + 1;
    HiberFileBucket32GB :: HiberFileBucket16GB + 1;
    HiberFileBucketUnlimited :: HiberFileBucket32GB + 1;
    HiberFileBucketMax :: HiberFileBucketUnlimited + 1;
/* } */
PHIBERFILE_BUCKET_SIZE :: ^HIBERFILE_BUCKET_SIZE;

HIBERFILE_BUCKET :: struct {
    MaxPhysicalMemory     : DWORD64,
    PhysicalMemoryPercent : [0x03]DWORD,
};
PHIBERFILE_BUCKET :: ^HIBERFILE_BUCKET;

SYSTEM_POWER_CAPABILITIES :: struct {
    PowerButtonPresent        : BOOLEAN,
    SleepButtonPresent        : BOOLEAN,
    LidPresent                : BOOLEAN,
    SystemS1                  : BOOLEAN,
    SystemS2                  : BOOLEAN,
    SystemS3                  : BOOLEAN,
    SystemS4                  : BOOLEAN,
    SystemS5                  : BOOLEAN,
    HiberFilePresent          : BOOLEAN,
    FullWake                  : BOOLEAN,
    VideoDimPresent           : BOOLEAN,
    ApmPresent                : BOOLEAN,
    UpsPresent                : BOOLEAN,
    ThermalControl            : BOOLEAN,
    ProcessorThrottle         : BOOLEAN,
    ProcessorMinThrottle      : BYTE,
    ProcessorMaxThrottle      : BYTE,
    FastSystemS4              : BOOLEAN,
    Hiberboot                 : BOOLEAN,
    WakeAlarmPresent          : BOOLEAN,
    AoAc                      : BOOLEAN,
    DiskSpinDown              : BOOLEAN,
    HiberFileType             : BYTE,
    AoAcConnectivitySupported : BOOLEAN,
    spare3                    : [6]BYTE,
    SystemBatteriesPresent    : BOOLEAN,
    BatteriesAreShortTerm     : BOOLEAN,
    BatteryScale              : [3]BATTERY_REPORTING_SCALE,
    AcOnLineWake              : SYSTEM_POWER_STATE,
    SoftLidWake               : SYSTEM_POWER_STATE,
    RtcWake                   : SYSTEM_POWER_STATE,
    MinDeviceWakeState        : SYSTEM_POWER_STATE,
    DefaultLowLatencyWake     : SYSTEM_POWER_STATE,
};
PSYSTEM_POWER_CAPABILITIES :: ^SYSTEM_POWER_CAPABILITIES;

SYSTEM_BATTERY_STATE :: struct {
    AcOnLine          : BOOLEAN,
    BatteryPresent    : BOOLEAN,
    Charging          : BOOLEAN,
    Discharging       : BOOLEAN,
    Spare1            : [3]BOOLEAN,
    Tag               : BYTE,
    MaxCapacity       : DWORD,
    RemainingCapacity : DWORD,
    Rate              : DWORD,
    EstimatedTime     : DWORD,
    DefaultAlert1     : DWORD,
    DefaultAlert2     : DWORD,
};
PSYSTEM_BATTERY_STATE :: ^SYSTEM_BATTERY_STATE;

IMAGE_DOS_HEADER :: struct {
    e_magic    : WORD,
    e_cblp     : WORD,
    e_cp       : WORD,
    e_crlc     : WORD,
    e_cparhdr  : WORD,
    e_minalloc : WORD,
    e_maxalloc : WORD,
    e_ss       : WORD,
    e_sp       : WORD,
    e_csum     : WORD,
    e_ip       : WORD,
    e_cs       : WORD,
    e_lfarlc   : WORD,
    e_ovno     : WORD,
    e_res      : [4]WORD,
    e_oemid    : WORD,
    e_oeminfo  : WORD,
    e_res2     : [10]WORD,
    e_lfanew   : LONG,
};
PIMAGE_DOS_HEADER :: ^IMAGE_DOS_HEADER;

IMAGE_OS2_HEADER :: struct {
    ne_magic        : WORD,
    ne_ver          : CHAR,
    ne_rev          : CHAR,
    ne_enttab       : WORD,
    ne_cbenttab     : WORD,
    ne_crc          : LONG,
    ne_flags        : WORD,
    ne_autodata     : WORD,
    ne_heap         : WORD,
    ne_stack        : WORD,
    ne_csip         : LONG,
    ne_sssp         : LONG,
    ne_cseg         : WORD,
    ne_cmod         : WORD,
    ne_cbnrestab    : WORD,
    ne_segtab       : WORD,
    ne_rsrctab      : WORD,
    ne_restab       : WORD,
    ne_modtab       : WORD,
    ne_imptab       : WORD,
    ne_nrestab      : LONG,
    ne_cmovent      : WORD,
    ne_align        : WORD,
    ne_cres         : WORD,
    ne_exetyp       : BYTE,
    ne_flagsothers  : BYTE,
    ne_pretthunks   : WORD,
    ne_psegrefbytes : WORD,
    ne_swaparea     : WORD,
    ne_expver       : WORD,
};
PIMAGE_OS2_HEADER :: ^IMAGE_OS2_HEADER;

IMAGE_VXD_HEADER :: struct {
    e32_magic        : WORD,
    e32_border       : BYTE,
    e32_worder       : BYTE,
    e32_level        : DWORD,
    e32_cpu          : WORD,
    e32_os           : WORD,
    e32_ver          : DWORD,
    e32_mflags       : DWORD,
    e32_mpages       : DWORD,
    e32_startobj     : DWORD,
    e32_eip          : DWORD,
    e32_stackobj     : DWORD,
    e32_esp          : DWORD,
    e32_pagesize     : DWORD,
    e32_lastpagesize : DWORD,
    e32_fixupsize    : DWORD,
    e32_fixupsum     : DWORD,
    e32_ldrsize      : DWORD,
    e32_ldrsum       : DWORD,
    e32_objtab       : DWORD,
    e32_objcnt       : DWORD,
    e32_objmap       : DWORD,
    e32_itermap      : DWORD,
    e32_rsrctab      : DWORD,
    e32_rsrccnt      : DWORD,
    e32_restab       : DWORD,
    e32_enttab       : DWORD,
    e32_dirtab       : DWORD,
    e32_dircnt       : DWORD,
    e32_fpagetab     : DWORD,
    e32_frectab      : DWORD,
    e32_impmod       : DWORD,
    e32_impmodcnt    : DWORD,
    e32_impproc      : DWORD,
    e32_pagesum      : DWORD,
    e32_datapage     : DWORD,
    e32_preload      : DWORD,
    e32_nrestab      : DWORD,
    e32_cbnrestab    : DWORD,
    e32_nressum      : DWORD,
    e32_autodata     : DWORD,
    e32_debuginfo    : DWORD,
    e32_debuglen     : DWORD,
    e32_instpreload  : DWORD,
    e32_instdemand   : DWORD,
    e32_heapsize     : DWORD,
    e32_res3         : [12]BYTE,
    e32_winresoff    : DWORD,
    e32_winreslen    : DWORD,
    e32_devid        : WORD,
    e32_ddkver       : WORD,
};
PIMAGE_VXD_HEADER :: ^IMAGE_VXD_HEADER;

IMAGE_FILE_HEADER :: struct {
    Machine              : WORD,
    NumberOfSections     : WORD,
    TimeDateStamp        : DWORD,
    PointerToSymbolTable : DWORD,
    NumberOfSymbols      : DWORD,
    SizeOfOptionalHeader : WORD,
    Characteristics      : WORD,
};
PIMAGE_FILE_HEADER :: ^IMAGE_FILE_HEADER;

IMAGE_DATA_DIRECTORY :: struct {
    VirtualAddress : DWORD,
    Size           : DWORD,
};
PIMAGE_DATA_DIRECTORY :: ^IMAGE_DATA_DIRECTORY;

IMAGE_OPTIONAL_HEADER32 :: struct {
    Magic                       : WORD,
    MajorLinkerVersion          : BYTE,
    MinorLinkerVersion          : BYTE,
    SizeOfCode                  : DWORD,
    SizeOfInitializedData       : DWORD,
    SizeOfUninitializedData     : DWORD,
    AddressOfEntryPoint         : DWORD,
    BaseOfCode                  : DWORD,
    BaseOfData                  : DWORD,
    ImageBase                   : DWORD,
    SectionAlignment            : DWORD,
    FileAlignment               : DWORD,
    MajorOperatingSystemVersion : WORD,
    MinorOperatingSystemVersion : WORD,
    MajorImageVersion           : WORD,
    MinorImageVersion           : WORD,
    MajorSubsystemVersion       : WORD,
    MinorSubsystemVersion       : WORD,
    Win32VersionValue           : DWORD,
    SizeOfImage                 : DWORD,
    SizeOfHeaders               : DWORD,
    CheckSum                    : DWORD,
    Subsystem                   : WORD,
    DllCharacteristics          : WORD,
    SizeOfStackReserve          : DWORD,
    SizeOfStackCommit           : DWORD,
    SizeOfHeapReserve           : DWORD,
    SizeOfHeapCommit            : DWORD,
    LoaderFlags                 : DWORD,
    NumberOfRvaAndSizes         : DWORD,
    DataDirectory               : [16]IMAGE_DATA_DIRECTORY,
};
PIMAGE_OPTIONAL_HEADER32 :: ^IMAGE_OPTIONAL_HEADER32;

IMAGE_ROM_OPTIONAL_HEADER :: struct {
    Magic                   : WORD,
    MajorLinkerVersion      : BYTE,
    MinorLinkerVersion      : BYTE,
    SizeOfCode              : DWORD,
    SizeOfInitializedData   : DWORD,
    SizeOfUninitializedData : DWORD,
    AddressOfEntryPoint     : DWORD,
    BaseOfCode              : DWORD,
    BaseOfData              : DWORD,
    BaseOfBss               : DWORD,
    GprMask                 : DWORD,
    CprMask                 : [4]DWORD,
    GpValue                 : DWORD,
};
PIMAGE_ROM_OPTIONAL_HEADER :: ^IMAGE_ROM_OPTIONAL_HEADER;

IMAGE_OPTIONAL_HEADER64 :: struct {
    Magic                       : WORD,
    MajorLinkerVersion          : BYTE,
    MinorLinkerVersion          : BYTE,
    SizeOfCode                  : DWORD,
    SizeOfInitializedData       : DWORD,
    SizeOfUninitializedData     : DWORD,
    AddressOfEntryPoint         : DWORD,
    BaseOfCode                  : DWORD,
    ImageBase                   : ULONGLONG,
    SectionAlignment            : DWORD,
    FileAlignment               : DWORD,
    MajorOperatingSystemVersion : WORD,
    MinorOperatingSystemVersion : WORD,
    MajorImageVersion           : WORD,
    MinorImageVersion           : WORD,
    MajorSubsystemVersion       : WORD,
    MinorSubsystemVersion       : WORD,
    Win32VersionValue           : DWORD,
    SizeOfImage                 : DWORD,
    SizeOfHeaders               : DWORD,
    CheckSum                    : DWORD,
    Subsystem                   : WORD,
    DllCharacteristics          : WORD,
    SizeOfStackReserve          : ULONGLONG,
    SizeOfStackCommit           : ULONGLONG,
    SizeOfHeapReserve           : ULONGLONG,
    SizeOfHeapCommit            : ULONGLONG,
    LoaderFlags                 : DWORD,
    NumberOfRvaAndSizes         : DWORD,
    DataDirectory               : [16]IMAGE_DATA_DIRECTORY,
};
PIMAGE_OPTIONAL_HEADER64 :: ^IMAGE_OPTIONAL_HEADER64;

IMAGE_OPTIONAL_HEADER :: IMAGE_OPTIONAL_HEADER64;

PIMAGE_OPTIONAL_HEADER :: PIMAGE_OPTIONAL_HEADER64;

IMAGE_NT_HEADERS64 :: struct {
    Signature      : DWORD,
    FileHeader     : IMAGE_FILE_HEADER,
    OptionalHeader : IMAGE_OPTIONAL_HEADER64,
};
PIMAGE_NT_HEADERS64 :: ^IMAGE_NT_HEADERS64;

IMAGE_NT_HEADERS32 :: struct {
    Signature      : DWORD,
    FileHeader     : IMAGE_FILE_HEADER,
    OptionalHeader : IMAGE_OPTIONAL_HEADER32,
};
PIMAGE_NT_HEADERS32 :: ^IMAGE_NT_HEADERS32;

IMAGE_ROM_HEADERS :: struct {
    FileHeader     : IMAGE_FILE_HEADER,
    OptionalHeader : IMAGE_ROM_OPTIONAL_HEADER,
};
PIMAGE_ROM_HEADERS :: ^IMAGE_ROM_HEADERS;

IMAGE_NT_HEADERS :: IMAGE_NT_HEADERS64;

PIMAGE_NT_HEADERS :: PIMAGE_NT_HEADERS64;

ANON_OBJECT_HEADER :: struct {
    Sig1          : WORD,
    Sig2          : WORD,
    Version       : WORD,
    Machine       : WORD,
    TimeDateStamp : DWORD,
    ClassID       : CLSID,
    SizeOfData    : DWORD,
};

ANON_OBJECT_HEADER_V2 :: struct {
    Sig1           : WORD,
    Sig2           : WORD,
    Version        : WORD,
    Machine        : WORD,
    TimeDateStamp  : DWORD,
    ClassID        : CLSID,
    SizeOfData     : DWORD,
    Flags          : DWORD,
    MetaDataSize   : DWORD,
    MetaDataOffset : DWORD,
};

ANON_OBJECT_HEADER_BIGOBJ :: struct {
    Sig1                 : WORD,
    Sig2                 : WORD,
    Version              : WORD,
    Machine              : WORD,
    TimeDateStamp        : DWORD,
    ClassID              : CLSID,
    SizeOfData           : DWORD,
    Flags                : DWORD,
    MetaDataSize         : DWORD,
    MetaDataOffset       : DWORD,
    NumberOfSections     : DWORD,
    PointerToSymbolTable : DWORD,
    NumberOfSymbols      : DWORD,
};

IMAGE_SECTION_HEADER :: struct {
    Name                 : [8]BYTE,
    Misc : struct #raw_union {
        PhysicalAddress : DWORD,
        VirtualSize     : DWORD,
    },
    VirtualAddress       : DWORD,
    SizeOfRawData        : DWORD,
    PointerToRawData     : DWORD,
    PointerToRelocations : DWORD,
    PointerToLinenumbers : DWORD,
    NumberOfRelocations  : WORD,
    NumberOfLinenumbers  : WORD,
    Characteristics      : DWORD,
};
PIMAGE_SECTION_HEADER :: ^IMAGE_SECTION_HEADER;

IMAGE_SYMBOL :: struct {
    N : struct #raw_union {
        ShortName : [8]BYTE,
        Name : struct {
            Short : DWORD,
            Long  : DWORD,
        },
        LongName  : [2]DWORD,
    },
    Value              : DWORD,
    SectionNumber      : SHORT,
    Type               : WORD,
    StorageClass       : BYTE,
    NumberOfAuxSymbols : BYTE,
};

PIMAGE_SYMBOL :: ^IMAGE_SYMBOL;

IMAGE_SYMBOL_EX :: struct {
    N : struct #raw_union {
        ShortName : [8]BYTE,
        Name : struct {
            Short : DWORD,
            Long  : DWORD,
        },
        LongName  : [2]DWORD,
    },
    Value              : DWORD,
    SectionNumber      : LONG,
    Type               : WORD,
    StorageClass       : BYTE,
    NumberOfAuxSymbols : BYTE,
};

PIMAGE_SYMBOL_EX :: ^IMAGE_SYMBOL_EX;

IMAGE_AUX_SYMBOL_TOKEN_DEF :: struct {
    bAuxType         : BYTE,
    bReserved        : BYTE,
    SymbolTableIndex : DWORD,
    rgbReserved      : [12]BYTE,
};

PIMAGE_AUX_SYMBOL_TOKEN_DEF :: ^IMAGE_AUX_SYMBOL_TOKEN_DEF;

IMAGE_AUX_SYMBOL :: struct #raw_union {
    Sym : struct {
        TagIndex : DWORD,
        Misc : struct #raw_union {
            LnSz : struct {
                Linenumber : WORD,
                Size       : WORD,
            },
            TotalSize : DWORD,
        },
        FcnAry : struct #raw_union {
            Function : struct {
                PointerToLinenumber   : DWORD,
                PointerToNextFunction : DWORD,
            },
            Array : struct {
                Dimension : [4]WORD,
            },
        },
        TvIndex  : WORD,
    },
    File : struct {
        Name : [18]BYTE,
    },
    Section : struct {
        Length              : DWORD,
        NumberOfRelocations : WORD,
        NumberOfLinenumbers : WORD,
        CheckSum            : DWORD,
        Number              : SHORT,
        Selection           : BYTE,
        bReserved           : BYTE,
        HighNumber          : SHORT,
    },
    TokenDef : IMAGE_AUX_SYMBOL_TOKEN_DEF,
    CRC : struct {
        crc         : DWORD,
        rgbReserved : [14]BYTE,
    },
};

PIMAGE_AUX_SYMBOL :: ^IMAGE_AUX_SYMBOL;

IMAGE_AUX_SYMBOL_EX :: struct #raw_union {
    Sym : struct {
        WeakDefaultSymIndex : DWORD,
        WeakSearchType      : DWORD,
        rgbReserved         : [12]BYTE,
    },
    File : struct {
        Name : [size_of(IMAGE_SYMBOL_EX)]BYTE,
    },
    Section : struct {
        Length              : DWORD,
        NumberOfRelocations : WORD,
        NumberOfLinenumbers : WORD,
        CheckSum            : DWORD,
        Number              : SHORT,
        Selection           : BYTE,
        bReserved           : BYTE,
        HighNumber          : SHORT,
        rgbReserved         : [2]BYTE,
    },
    s : struct {
        TokenDef    : IMAGE_AUX_SYMBOL_TOKEN_DEF,
        rgbReserved : [2]BYTE,
    },
    CRC : struct {
        crc         : DWORD,
        rgbReserved : [16]BYTE,
    },
};

PIMAGE_AUX_SYMBOL_EX :: ^IMAGE_AUX_SYMBOL_EX;

/* IMAGE_AUX_SYMBOL_TYPE :: enum { */
IMAGE_AUX_SYMBOL_TYPE :: _c.int;
    IMAGE_AUX_SYMBOL_TYPE_TOKEN_DEF :: 1;
/* } */
;

IMAGE_RELOCATION :: struct {
    u : struct #raw_union {
        VirtualAddress : DWORD,
        RelocCount     : DWORD,
    },
    SymbolTableIndex : DWORD,
    Type             : WORD,
};

PIMAGE_RELOCATION :: ^IMAGE_RELOCATION;

IMAGE_LINENUMBER :: struct {
    Type : struct #raw_union {
        SymbolTableIndex : DWORD,
        VirtualAddress   : DWORD,
    },
    Linenumber : WORD,
};

PIMAGE_LINENUMBER :: ^IMAGE_LINENUMBER;

IMAGE_BASE_RELOCATION :: struct {
    VirtualAddress : DWORD,
    SizeOfBlock    : DWORD,
};

PIMAGE_BASE_RELOCATION :: ^IMAGE_BASE_RELOCATION;

IMAGE_ARCHIVE_MEMBER_HEADER :: struct {
    Name      : [16]BYTE,
    Date      : [12]BYTE,
    UserID    : [6]BYTE,
    GroupID   : [6]BYTE,
    Mode      : [8]BYTE,
    Size      : [10]BYTE,
    EndHeader : [2]BYTE,
};
PIMAGE_ARCHIVE_MEMBER_HEADER :: ^IMAGE_ARCHIVE_MEMBER_HEADER;

IMAGE_EXPORT_DIRECTORY :: struct {
    Characteristics       : DWORD,
    TimeDateStamp         : DWORD,
    MajorVersion          : WORD,
    MinorVersion          : WORD,
    Name                  : DWORD,
    Base                  : DWORD,
    NumberOfFunctions     : DWORD,
    NumberOfNames         : DWORD,
    AddressOfFunctions    : DWORD,
    AddressOfNames        : DWORD,
    AddressOfNameOrdinals : DWORD,
};
PIMAGE_EXPORT_DIRECTORY :: ^IMAGE_EXPORT_DIRECTORY;

IMAGE_IMPORT_BY_NAME :: struct {
    Hint : WORD,
    Name : [1]CHAR,
};
PIMAGE_IMPORT_BY_NAME :: ^IMAGE_IMPORT_BY_NAME;

IMAGE_THUNK_DATA64 :: struct {
    u1 : struct #raw_union {
        ForwarderString : ULONGLONG,
        Function        : ULONGLONG,
        Ordinal         : ULONGLONG,
        AddressOfData   : ULONGLONG,
    },
};

PIMAGE_THUNK_DATA64 :: ^IMAGE_THUNK_DATA64;

IMAGE_THUNK_DATA32 :: struct {
    u1 : struct #raw_union {
        ForwarderString : DWORD,
        Function        : DWORD,
        Ordinal         : DWORD,
        AddressOfData   : DWORD,
    },
};

PIMAGE_THUNK_DATA32 :: ^IMAGE_THUNK_DATA32;

PIMAGE_TLS_CALLBACK :: proc "stdcall" (DllHandle : PVOID, Reason : DWORD, Reserved : PVOID);

IMAGE_TLS_DIRECTORY64 :: struct {
    StartAddressOfRawData : ULONGLONG,
    EndAddressOfRawData   : ULONGLONG,
    AddressOfIndex        : ULONGLONG,
    AddressOfCallBacks    : ULONGLONG,
    SizeOfZeroFill        : DWORD,
    u : struct #raw_union {
        Characteristics : DWORD,
        s : bit_field {
            Reserved0 : 20,
            Alignment : 4,
            Reserved1 : 8,
        },
    },
};

PIMAGE_TLS_DIRECTORY64 :: ^IMAGE_TLS_DIRECTORY64;

IMAGE_TLS_DIRECTORY32 :: struct {
    StartAddressOfRawData : DWORD,
    EndAddressOfRawData   : DWORD,
    AddressOfIndex        : DWORD,
    AddressOfCallBacks    : DWORD,
    SizeOfZeroFill        : DWORD,
    u : struct #raw_union {
        Characteristics : DWORD,
        s : bit_field {
            Reserved0 : 20,
            Alignment : 4,
            Reserved1 : 8,
        },
    },
};

PIMAGE_TLS_DIRECTORY32 :: ^IMAGE_TLS_DIRECTORY32;

IMAGE_THUNK_DATA :: IMAGE_THUNK_DATA64;

PIMAGE_THUNK_DATA :: PIMAGE_THUNK_DATA64;

IMAGE_TLS_DIRECTORY :: IMAGE_TLS_DIRECTORY64;

PIMAGE_TLS_DIRECTORY :: PIMAGE_TLS_DIRECTORY64;

IMAGE_IMPORT_DESCRIPTOR :: struct {
    u : struct #raw_union {
        Characteristics    : DWORD,
        OriginalFirstThunk : DWORD,
    },
    TimeDateStamp  : DWORD,
    ForwarderChain : DWORD,
    Name           : DWORD,
    FirstThunk     : DWORD,
};

PIMAGE_IMPORT_DESCRIPTOR :: ^IMAGE_IMPORT_DESCRIPTOR;

IMAGE_BOUND_IMPORT_DESCRIPTOR :: struct {
    TimeDateStamp               : DWORD,
    OffsetModuleName            : WORD,
    NumberOfModuleForwarderRefs : WORD,
};
PIMAGE_BOUND_IMPORT_DESCRIPTOR :: ^IMAGE_BOUND_IMPORT_DESCRIPTOR;

IMAGE_BOUND_FORWARDER_REF :: struct {
    TimeDateStamp    : DWORD,
    OffsetModuleName : WORD,
    Reserved         : WORD,
};
PIMAGE_BOUND_FORWARDER_REF :: ^IMAGE_BOUND_FORWARDER_REF;

IMAGE_DELAYLOAD_DESCRIPTOR :: struct {
    Attributes : struct #raw_union {
        AllAttributes : DWORD,
        s : bit_field {
            RvaBased           : 1,
            ReservedAttributes : 31,
        },
    },
    DllNameRVA                 : DWORD,
    ModuleHandleRVA            : DWORD,
    ImportAddressTableRVA      : DWORD,
    ImportNameTableRVA         : DWORD,
    BoundImportAddressTableRVA : DWORD,
    UnloadInformationTableRVA  : DWORD,
    TimeDateStamp              : DWORD,
};
PIMAGE_DELAYLOAD_DESCRIPTOR :: ^IMAGE_DELAYLOAD_DESCRIPTOR;

PCIMAGE_DELAYLOAD_DESCRIPTOR :: ^IMAGE_DELAYLOAD_DESCRIPTOR;

IMAGE_RESOURCE_DIRECTORY :: struct {
    Characteristics      : DWORD,
    TimeDateStamp        : DWORD,
    MajorVersion         : WORD,
    MinorVersion         : WORD,
    NumberOfNamedEntries : WORD,
    NumberOfIdEntries    : WORD,
};
PIMAGE_RESOURCE_DIRECTORY :: ^IMAGE_RESOURCE_DIRECTORY;

IMAGE_RESOURCE_DIRECTORY_ENTRY :: struct {
    u : struct #raw_union {
        s : bit_field {
            NameOffset   : 31,
            NameIsString : 1,
        },
        Name : DWORD,
        Id   : WORD,
    },
    u2 : struct #raw_union {
        OffsetToData : DWORD,
        s2 : bit_field {
            OffsetToDirectory : 31,
            DataIsDirectory   : 1,
        },
    },
};
PIMAGE_RESOURCE_DIRECTORY_ENTRY :: ^IMAGE_RESOURCE_DIRECTORY_ENTRY;

IMAGE_RESOURCE_DIRECTORY_STRING :: struct {
    Length     : WORD,
    NameString : [1]CHAR,
};
PIMAGE_RESOURCE_DIRECTORY_STRING :: ^IMAGE_RESOURCE_DIRECTORY_STRING;

IMAGE_RESOURCE_DIR_STRING_U :: struct {
    Length     : WORD,
    NameString : [1]WCHAR,
};
PIMAGE_RESOURCE_DIR_STRING_U :: ^IMAGE_RESOURCE_DIR_STRING_U;

IMAGE_RESOURCE_DATA_ENTRY :: struct {
    OffsetToData : DWORD,
    Size         : DWORD,
    CodePage     : DWORD,
    Reserved     : DWORD,
};
PIMAGE_RESOURCE_DATA_ENTRY :: ^IMAGE_RESOURCE_DATA_ENTRY;

IMAGE_LOAD_CONFIG_CODE_INTEGRITY :: struct {
    Flags         : WORD,
    Catalog       : WORD,
    CatalogOffset : DWORD,
    Reserved      : DWORD,
};
PIMAGE_LOAD_CONFIG_CODE_INTEGRITY :: ^IMAGE_LOAD_CONFIG_CODE_INTEGRITY;

IMAGE_DYNAMIC_RELOCATION_TABLE :: struct {
    Version : DWORD,
    Size    : DWORD,
};
PIMAGE_DYNAMIC_RELOCATION_TABLE :: ^IMAGE_DYNAMIC_RELOCATION_TABLE;

IMAGE_DYNAMIC_RELOCATION32 :: struct {
    Symbol        : DWORD,
    BaseRelocSize : DWORD,
};
PIMAGE_DYNAMIC_RELOCATION32 :: ^IMAGE_DYNAMIC_RELOCATION32;

IMAGE_DYNAMIC_RELOCATION64 :: struct {
    Symbol        : ULONGLONG,
    BaseRelocSize : DWORD,
};
PIMAGE_DYNAMIC_RELOCATION64 :: ^IMAGE_DYNAMIC_RELOCATION64;

IMAGE_DYNAMIC_RELOCATION32_V2 :: struct {
    HeaderSize    : DWORD,
    FixupInfoSize : DWORD,
    Symbol        : DWORD,
    SymbolGroup   : DWORD,
    Flags         : DWORD,
};
PIMAGE_DYNAMIC_RELOCATION32_V2 :: ^IMAGE_DYNAMIC_RELOCATION32_V2;

IMAGE_DYNAMIC_RELOCATION64_V2 :: struct {
    HeaderSize    : DWORD,
    FixupInfoSize : DWORD,
    Symbol        : ULONGLONG,
    SymbolGroup   : DWORD,
    Flags         : DWORD,
};
PIMAGE_DYNAMIC_RELOCATION64_V2 :: ^IMAGE_DYNAMIC_RELOCATION64_V2;

IMAGE_DYNAMIC_RELOCATION :: IMAGE_DYNAMIC_RELOCATION64;

PIMAGE_DYNAMIC_RELOCATION :: PIMAGE_DYNAMIC_RELOCATION64;

IMAGE_DYNAMIC_RELOCATION_V2 :: IMAGE_DYNAMIC_RELOCATION64_V2;

PIMAGE_DYNAMIC_RELOCATION_V2 :: PIMAGE_DYNAMIC_RELOCATION64_V2;

IMAGE_PROLOGUE_DYNAMIC_RELOCATION_HEADER :: struct {
    PrologueByteCount : BYTE,
};

PIMAGE_PROLOGUE_DYNAMIC_RELOCATION_HEADER :: ^IMAGE_PROLOGUE_DYNAMIC_RELOCATION_HEADER;

IMAGE_EPILOGUE_DYNAMIC_RELOCATION_HEADER :: struct {
    EpilogueCount               : DWORD,
    EpilogueByteCount           : BYTE,
    BranchDescriptorElementSize : BYTE,
    BranchDescriptorCount       : WORD,
};

PIMAGE_EPILOGUE_DYNAMIC_RELOCATION_HEADER :: ^IMAGE_EPILOGUE_DYNAMIC_RELOCATION_HEADER;

IMAGE_IMPORT_CONTROL_TRANSFER_DYNAMIC_RELOCATION :: bit_field {
    PageRelativeOffset : 12,
    IndirectCall       : 1,
    IATIndex           : 19,
};

PIMAGE_IMPORT_CONTROL_TRANSFER_DYNAMIC_RELOCATION :: ^IMAGE_IMPORT_CONTROL_TRANSFER_DYNAMIC_RELOCATION;

IMAGE_INDIR_CONTROL_TRANSFER_DYNAMIC_RELOCATION :: bit_field {
    PageRelativeOffset : 12,
    IndirectCall       : 1,
    RexWPrefix         : 1,
    CfgCheck           : 1,
    Reserved           : 1,
};

PIMAGE_INDIR_CONTROL_TRANSFER_DYNAMIC_RELOCATION :: ^IMAGE_INDIR_CONTROL_TRANSFER_DYNAMIC_RELOCATION;

IMAGE_SWITCHTABLE_BRANCH_DYNAMIC_RELOCATION :: bit_field {
    PageRelativeOffset : 12,
    RegisterNumber     : 4,
};

PIMAGE_SWITCHTABLE_BRANCH_DYNAMIC_RELOCATION :: ^IMAGE_SWITCHTABLE_BRANCH_DYNAMIC_RELOCATION;

IMAGE_LOAD_CONFIG_DIRECTORY32 :: struct {
    Size                                     : DWORD,
    TimeDateStamp                            : DWORD,
    MajorVersion                             : WORD,
    MinorVersion                             : WORD,
    GlobalFlagsClear                         : DWORD,
    GlobalFlagsSet                           : DWORD,
    CriticalSectionDefaultTimeout            : DWORD,
    DeCommitFreeBlockThreshold               : DWORD,
    DeCommitTotalFreeThreshold               : DWORD,
    LockPrefixTable                          : DWORD,
    MaximumAllocationSize                    : DWORD,
    VirtualMemoryThreshold                   : DWORD,
    ProcessHeapFlags                         : DWORD,
    ProcessAffinityMask                      : DWORD,
    CSDVersion                               : WORD,
    DependentLoadFlags                       : WORD,
    EditList                                 : DWORD,
    SecurityCookie                           : DWORD,
    SEHandlerTable                           : DWORD,
    SEHandlerCount                           : DWORD,
    GuardCFCheckFunctionPointer              : DWORD,
    GuardCFDispatchFunctionPointer           : DWORD,
    GuardCFFunctionTable                     : DWORD,
    GuardCFFunctionCount                     : DWORD,
    GuardFlags                               : DWORD,
    CodeIntegrity                            : IMAGE_LOAD_CONFIG_CODE_INTEGRITY,
    GuardAddressTakenIatEntryTable           : DWORD,
    GuardAddressTakenIatEntryCount           : DWORD,
    GuardLongJumpTargetTable                 : DWORD,
    GuardLongJumpTargetCount                 : DWORD,
    DynamicValueRelocTable                   : DWORD,
    CHPEMetadataPointer                      : DWORD,
    GuardRFFailureRoutine                    : DWORD,
    GuardRFFailureRoutineFunctionPointer     : DWORD,
    DynamicValueRelocTableOffset             : DWORD,
    DynamicValueRelocTableSection            : WORD,
    Reserved2                                : WORD,
    GuardRFVerifyStackPointerFunctionPointer : DWORD,
    HotPatchTableOffset                      : DWORD,
    Reserved3                                : DWORD,
    EnclaveConfigurationPointer              : DWORD,
    VolatileMetadataPointer                  : DWORD,
};
PIMAGE_LOAD_CONFIG_DIRECTORY32 :: ^IMAGE_LOAD_CONFIG_DIRECTORY32;

IMAGE_LOAD_CONFIG_DIRECTORY64 :: struct {
    Size                                     : DWORD,
    TimeDateStamp                            : DWORD,
    MajorVersion                             : WORD,
    MinorVersion                             : WORD,
    GlobalFlagsClear                         : DWORD,
    GlobalFlagsSet                           : DWORD,
    CriticalSectionDefaultTimeout            : DWORD,
    DeCommitFreeBlockThreshold               : ULONGLONG,
    DeCommitTotalFreeThreshold               : ULONGLONG,
    LockPrefixTable                          : ULONGLONG,
    MaximumAllocationSize                    : ULONGLONG,
    VirtualMemoryThreshold                   : ULONGLONG,
    ProcessAffinityMask                      : ULONGLONG,
    ProcessHeapFlags                         : DWORD,
    CSDVersion                               : WORD,
    DependentLoadFlags                       : WORD,
    EditList                                 : ULONGLONG,
    SecurityCookie                           : ULONGLONG,
    SEHandlerTable                           : ULONGLONG,
    SEHandlerCount                           : ULONGLONG,
    GuardCFCheckFunctionPointer              : ULONGLONG,
    GuardCFDispatchFunctionPointer           : ULONGLONG,
    GuardCFFunctionTable                     : ULONGLONG,
    GuardCFFunctionCount                     : ULONGLONG,
    GuardFlags                               : DWORD,
    CodeIntegrity                            : IMAGE_LOAD_CONFIG_CODE_INTEGRITY,
    GuardAddressTakenIatEntryTable           : ULONGLONG,
    GuardAddressTakenIatEntryCount           : ULONGLONG,
    GuardLongJumpTargetTable                 : ULONGLONG,
    GuardLongJumpTargetCount                 : ULONGLONG,
    DynamicValueRelocTable                   : ULONGLONG,
    CHPEMetadataPointer                      : ULONGLONG,
    GuardRFFailureRoutine                    : ULONGLONG,
    GuardRFFailureRoutineFunctionPointer     : ULONGLONG,
    DynamicValueRelocTableOffset             : DWORD,
    DynamicValueRelocTableSection            : WORD,
    Reserved2                                : WORD,
    GuardRFVerifyStackPointerFunctionPointer : ULONGLONG,
    HotPatchTableOffset                      : DWORD,
    Reserved3                                : DWORD,
    EnclaveConfigurationPointer              : ULONGLONG,
    VolatileMetadataPointer                  : ULONGLONG,
};
PIMAGE_LOAD_CONFIG_DIRECTORY64 :: ^IMAGE_LOAD_CONFIG_DIRECTORY64;

IMAGE_LOAD_CONFIG_DIRECTORY :: IMAGE_LOAD_CONFIG_DIRECTORY64;

PIMAGE_LOAD_CONFIG_DIRECTORY :: PIMAGE_LOAD_CONFIG_DIRECTORY64;

IMAGE_HOT_PATCH_INFO :: struct {
    Version        : DWORD,
    Size           : DWORD,
    SequenceNumber : DWORD,
    BaseImageList  : DWORD,
    BaseImageCount : DWORD,
    BufferOffset   : DWORD,
    ExtraPatchSize : DWORD,
};
PIMAGE_HOT_PATCH_INFO :: ^IMAGE_HOT_PATCH_INFO;

IMAGE_HOT_PATCH_BASE :: struct {
    SequenceNumber        : DWORD,
    Flags                 : DWORD,
    OriginalTimeDateStamp : DWORD,
    OriginalCheckSum      : DWORD,
    CodeIntegrityInfo     : DWORD,
    CodeIntegritySize     : DWORD,
    PatchTable            : DWORD,
    BufferOffset          : DWORD,
};
PIMAGE_HOT_PATCH_BASE :: ^IMAGE_HOT_PATCH_BASE;

IMAGE_HOT_PATCH_HASHES :: struct {
    SHA256 : [32]BYTE,
    SHA1   : [20]BYTE,
};
PIMAGE_HOT_PATCH_HASHES :: ^IMAGE_HOT_PATCH_HASHES;

IMAGE_CE_RUNTIME_FUNCTION_ENTRY :: struct {
    FuncStart     : DWORD,
    using _ : bit_field {
        PrologLen     : 8,
        FuncLen       : 22,
        ThirtyTwoBit  : 1,
        ExceptionFlag : 1,
    },
};
PIMAGE_CE_RUNTIME_FUNCTION_ENTRY :: ^IMAGE_CE_RUNTIME_FUNCTION_ENTRY;

IMAGE_ARM_RUNTIME_FUNCTION_ENTRY :: struct {
    BeginAddress : DWORD,
    u : struct #raw_union {
        UnwindData : DWORD,
        s : bit_field {
            Flag           : 2,
            FunctionLength : 11,
            Ret            : 2,
            H              : 1,
            Reg            : 3,
            R              : 1,
            L              : 1,
            C              : 1,
            StackAdjust    : 10,
        },
    },
};
PIMAGE_ARM_RUNTIME_FUNCTION_ENTRY :: ^IMAGE_ARM_RUNTIME_FUNCTION_ENTRY;

IMAGE_ARM64_RUNTIME_FUNCTION_ENTRY :: struct {
    BeginAddress : DWORD,
    u : struct #raw_union {
        UnwindData : DWORD,
        s : bit_field {
            Flag           : 2,
            FunctionLength : 11,
            RegF           : 3,
            RegI           : 4,
            H              : 1,
            CR             : 2,
            FrameSize      : 9,
        },
    },
};
PIMAGE_ARM64_RUNTIME_FUNCTION_ENTRY :: ^IMAGE_ARM64_RUNTIME_FUNCTION_ENTRY;

IMAGE_ALPHA64_RUNTIME_FUNCTION_ENTRY :: struct {
    BeginAddress     : ULONGLONG,
    EndAddress       : ULONGLONG,
    ExceptionHandler : ULONGLONG,
    HandlerData      : ULONGLONG,
    PrologEndAddress : ULONGLONG,
};
PIMAGE_ALPHA64_RUNTIME_FUNCTION_ENTRY :: ^IMAGE_ALPHA64_RUNTIME_FUNCTION_ENTRY;

IMAGE_ALPHA_RUNTIME_FUNCTION_ENTRY :: struct {
    BeginAddress     : DWORD,
    EndAddress       : DWORD,
    ExceptionHandler : DWORD,
    HandlerData      : DWORD,
    PrologEndAddress : DWORD,
};
PIMAGE_ALPHA_RUNTIME_FUNCTION_ENTRY :: ^IMAGE_ALPHA_RUNTIME_FUNCTION_ENTRY;

_IMAGE_RUNTIME_FUNCTION_ENTRY :: struct {
    BeginAddress : DWORD,
    EndAddress   : DWORD,
    u : struct #raw_union {
        UnwindInfoAddress : DWORD,
        UnwindData        : DWORD,
    },
};
_PIMAGE_RUNTIME_FUNCTION_ENTRY :: ^_IMAGE_RUNTIME_FUNCTION_ENTRY;

IMAGE_IA64_RUNTIME_FUNCTION_ENTRY :: _IMAGE_RUNTIME_FUNCTION_ENTRY;

PIMAGE_IA64_RUNTIME_FUNCTION_ENTRY :: _PIMAGE_RUNTIME_FUNCTION_ENTRY;

IMAGE_RUNTIME_FUNCTION_ENTRY :: _IMAGE_RUNTIME_FUNCTION_ENTRY;

PIMAGE_RUNTIME_FUNCTION_ENTRY :: _PIMAGE_RUNTIME_FUNCTION_ENTRY;

IMAGE_ENCLAVE_CONFIG32 :: struct {
    Size                      : DWORD,
    MinimumRequiredConfigSize : DWORD,
    PolicyFlags               : DWORD,
    NumberOfImports           : DWORD,
    ImportList                : DWORD,
    ImportEntrySize           : DWORD,
    FamilyID                  : [16]BYTE,
    ImageID                   : [16]BYTE,
    ImageVersion              : DWORD,
    SecurityVersion           : DWORD,
    EnclaveSize               : DWORD,
    NumberOfThreads           : DWORD,
    EnclaveFlags              : DWORD,
};
PIMAGE_ENCLAVE_CONFIG32 :: ^IMAGE_ENCLAVE_CONFIG32;

IMAGE_ENCLAVE_CONFIG64 :: struct {
    Size                      : DWORD,
    MinimumRequiredConfigSize : DWORD,
    PolicyFlags               : DWORD,
    NumberOfImports           : DWORD,
    ImportList                : DWORD,
    ImportEntrySize           : DWORD,
    FamilyID                  : [16]BYTE,
    ImageID                   : [16]BYTE,
    ImageVersion              : DWORD,
    SecurityVersion           : DWORD,
    EnclaveSize               : ULONGLONG,
    NumberOfThreads           : DWORD,
    EnclaveFlags              : DWORD,
};
PIMAGE_ENCLAVE_CONFIG64 :: ^IMAGE_ENCLAVE_CONFIG64;

IMAGE_ENCLAVE_CONFIG :: IMAGE_ENCLAVE_CONFIG64;

PIMAGE_ENCLAVE_CONFIG :: PIMAGE_ENCLAVE_CONFIG64;

IMAGE_ENCLAVE_IMPORT :: struct {
    MatchType              : DWORD,
    MinimumSecurityVersion : DWORD,
    UniqueOrAuthorID       : [32]BYTE,
    FamilyID               : [16]BYTE,
    ImageID                : [16]BYTE,
    ImportName             : DWORD,
    Reserved               : DWORD,
};
PIMAGE_ENCLAVE_IMPORT :: ^IMAGE_ENCLAVE_IMPORT;

IMAGE_DEBUG_DIRECTORY :: struct {
    Characteristics  : DWORD,
    TimeDateStamp    : DWORD,
    MajorVersion     : WORD,
    MinorVersion     : WORD,
    Type             : DWORD,
    SizeOfData       : DWORD,
    AddressOfRawData : DWORD,
    PointerToRawData : DWORD,
};
PIMAGE_DEBUG_DIRECTORY :: ^IMAGE_DEBUG_DIRECTORY;

IMAGE_COFF_SYMBOLS_HEADER :: struct {
    NumberOfSymbols      : DWORD,
    LvaToFirstSymbol     : DWORD,
    NumberOfLinenumbers  : DWORD,
    LvaToFirstLinenumber : DWORD,
    RvaToFirstByteOfCode : DWORD,
    RvaToLastByteOfCode  : DWORD,
    RvaToFirstByteOfData : DWORD,
    RvaToLastByteOfData  : DWORD,
};
PIMAGE_COFF_SYMBOLS_HEADER :: ^IMAGE_COFF_SYMBOLS_HEADER;

FPO_DATA :: struct {
    ulOffStart : DWORD,
    cbProcSize : DWORD,
    cdwLocals  : DWORD,
    cdwParams  : WORD,
    using _ : bit_field {
        cbProlog   : 8,
        cbRegs     : 3,
        fHasSEH    : 1,
        fUseBP     : 1,
        reserved   : 1,
        cbFrame    : 2,
    },
};
PFPO_DATA :: ^FPO_DATA;

IMAGE_DEBUG_MISC :: struct {
    DataType : DWORD,
    Length   : DWORD,
    Unicode  : BOOLEAN,
    Reserved : [3]BYTE,
    Data     : [1]BYTE,
};
PIMAGE_DEBUG_MISC :: ^IMAGE_DEBUG_MISC;

IMAGE_FUNCTION_ENTRY :: struct {
    StartingAddress : DWORD,
    EndingAddress   : DWORD,
    EndOfPrologue   : DWORD,
};
PIMAGE_FUNCTION_ENTRY :: ^IMAGE_FUNCTION_ENTRY;

IMAGE_FUNCTION_ENTRY64 :: struct {
    StartingAddress : ULONGLONG,
    EndingAddress   : ULONGLONG,
    u : struct #raw_union {
        EndOfPrologue     : ULONGLONG,
        UnwindInfoAddress : ULONGLONG,
    },
};
PIMAGE_FUNCTION_ENTRY64 :: ^IMAGE_FUNCTION_ENTRY64;

IMAGE_SEPARATE_DEBUG_HEADER :: struct {
    Signature          : WORD,
    Flags              : WORD,
    Machine            : WORD,
    Characteristics    : WORD,
    TimeDateStamp      : DWORD,
    CheckSum           : DWORD,
    ImageBase          : DWORD,
    SizeOfImage        : DWORD,
    NumberOfSections   : DWORD,
    ExportedNamesSize  : DWORD,
    DebugDirectorySize : DWORD,
    SectionAlignment   : DWORD,
    Reserved           : [2]DWORD,
};
PIMAGE_SEPARATE_DEBUG_HEADER :: ^IMAGE_SEPARATE_DEBUG_HEADER;

NON_PAGED_DEBUG_INFO :: struct {
    Signature       : WORD,
    Flags           : WORD,
    Size            : DWORD,
    Machine         : WORD,
    Characteristics : WORD,
    TimeDateStamp   : DWORD,
    CheckSum        : DWORD,
    SizeOfImage     : DWORD,
    ImageBase       : ULONGLONG,
};
PNON_PAGED_DEBUG_INFO :: ^NON_PAGED_DEBUG_INFO;

IMAGE_ARCHITECTURE_HEADER :: struct {
    using _ : bit_field {
        AmaskValue    : 1,
        _ : 7,
        AmaskShift    : 8,
        _ : 16,
    },
    FirstEntryRVA : DWORD,
};
PIMAGE_ARCHITECTURE_HEADER :: ^IMAGE_ARCHITECTURE_HEADER;

IMAGE_ARCHITECTURE_ENTRY :: struct {
    FixupInstRVA : DWORD,
    NewInst      : DWORD,
};
PIMAGE_ARCHITECTURE_ENTRY :: ^IMAGE_ARCHITECTURE_ENTRY;

IMPORT_OBJECT_HEADER :: struct {
    Sig1          : WORD,
    Sig2          : WORD,
    Version       : WORD,
    Machine       : WORD,
    TimeDateStamp : DWORD,
    SizeOfData    : DWORD,
    u : struct #raw_union {
        Ordinal : WORD,
        Hint    : WORD,
    },
    using _ : bit_field {
        Type          : 2,
        NameType      : 3,
        Reserved      : 11,
    },
};

/* IMPORT_OBJECT_TYPE :: enum { */
IMPORT_OBJECT_TYPE :: _c.int;
    IMPORT_OBJECT_CODE :: 0;
    IMPORT_OBJECT_DATA :: 1;
    IMPORT_OBJECT_CONST :: 2;
/* } */
;

/* IMPORT_OBJECT_NAME_TYPE :: enum { */
IMPORT_OBJECT_NAME_TYPE :: _c.int;
    IMPORT_OBJECT_ORDINAL :: 0;
    IMPORT_OBJECT_NAME :: 1;
    IMPORT_OBJECT_NAME_NO_PREFIX :: 2;
    IMPORT_OBJECT_NAME_UNDECORATE :: 3;
    IMPORT_OBJECT_NAME_EXPORTAS :: 4;
/* } */
;

/* ReplacesCorHdrNumericDefines :: enum { */
ReplacesCorHdrNumericDefines :: _c.int;
    COMIMAGE_FLAGS_ILONLY :: 0x00000001;
    COMIMAGE_FLAGS_32BITREQUIRED :: 0x00000002;
    COMIMAGE_FLAGS_IL_LIBRARY :: 0x00000004;
    COMIMAGE_FLAGS_STRONGNAMESIGNED :: 0x00000008;
    COMIMAGE_FLAGS_NATIVE_ENTRYPOINT :: 0x00000010;
    COMIMAGE_FLAGS_TRACKDEBUGDATA :: 0x00010000;
    COMIMAGE_FLAGS_32BITPREFERRED :: 0x00020000;
    COR_VERSION_MAJOR_V2 :: 2;
    COR_VERSION_MAJOR ::     COR_VERSION_MAJOR_V2;
    COR_VERSION_MINOR :: 5;
    COR_DELETED_NAME_LENGTH :: 8;
    COR_VTABLEGAP_NAME_LENGTH :: 8;
    NATIVE_TYPE_MAX_CB :: 1;
    COR_ILMETHOD_SECT_SMALL_MAX_DATASIZE :: 0xFF;
    IMAGE_COR_MIH_METHODRVA :: 0x01;
    IMAGE_COR_MIH_EHRVA :: 0x02;
    IMAGE_COR_MIH_BASICBLOCK :: 0x08;
    COR_VTABLE_32BIT :: 0x01;
    COR_VTABLE_64BIT :: 0x02;
    COR_VTABLE_FROM_UNMANAGED :: 0x04;
    COR_VTABLE_FROM_UNMANAGED_RETAIN_APPDOMAIN :: 0x08;
    COR_VTABLE_CALL_MOST_DERIVED :: 0x10;
    IMAGE_COR_EATJ_THUNK_SIZE :: 32;
    MAX_CLASS_NAME :: 1024;
    MAX_PACKAGE_NAME :: 1024;
/* } */
;

IMAGE_COR20_HEADER :: struct {
    cb                      : DWORD,
    MajorRuntimeVersion     : WORD,
    MinorRuntimeVersion     : WORD,
    MetaData                : IMAGE_DATA_DIRECTORY,
    Flags                   : DWORD,
    u : struct #raw_union {
        EntryPointToken : DWORD,
        EntryPointRVA   : DWORD,
    },
    Resources               : IMAGE_DATA_DIRECTORY,
    StrongNameSignature     : IMAGE_DATA_DIRECTORY,
    CodeManagerTable        : IMAGE_DATA_DIRECTORY,
    VTableFixups            : IMAGE_DATA_DIRECTORY,
    ExportAddressTableJumps : IMAGE_DATA_DIRECTORY,
    ManagedNativeHeader     : IMAGE_DATA_DIRECTORY,
};
PIMAGE_COR20_HEADER :: ^IMAGE_COR20_HEADER;

SLIST_ENTRY :: struct {
    Next : ^SLIST_ENTRY,
};
PSLIST_ENTRY :: ^SLIST_ENTRY;

SLIST_HEADER :: struct #raw_union {
    s : struct {
        Alignment : ULONGLONG,
        Region    : ULONGLONG,
    },
    HeaderX64 : bit_field {
        Depth     : 16,
        Sequence  : 48,
        Reserved  : 4,
        NextEntry : 60,
    },
};
PSLIST_HEADER :: ^SLIST_HEADER;

RTL_RUN_ONCE :: struct #raw_union {
    Ptr : PVOID,
};
PRTL_RUN_ONCE :: ^RTL_RUN_ONCE;

RTL_BARRIER :: struct {
    Reserved1 : DWORD,
    Reserved2 : DWORD,
    Reserved3 : [2]ULONG_PTR,
    Reserved4 : DWORD,
    Reserved5 : DWORD,
};
PRTL_BARRIER :: ^RTL_BARRIER;

MESSAGE_RESOURCE_ENTRY :: struct {
    Length : WORD,
    Flags  : WORD,
    Text   : [1]BYTE,
};
PMESSAGE_RESOURCE_ENTRY :: ^MESSAGE_RESOURCE_ENTRY;

MESSAGE_RESOURCE_BLOCK :: struct {
    LowId           : DWORD,
    HighId          : DWORD,
    OffsetToEntries : DWORD,
};
PMESSAGE_RESOURCE_BLOCK :: ^MESSAGE_RESOURCE_BLOCK;

MESSAGE_RESOURCE_DATA :: struct {
    NumberOfBlocks : DWORD,
    Blocks         : [1]MESSAGE_RESOURCE_BLOCK,
};
PMESSAGE_RESOURCE_DATA :: ^MESSAGE_RESOURCE_DATA;

OSVERSIONINFOA :: struct {
    dwOSVersionInfoSize : DWORD,
    dwMajorVersion      : DWORD,
    dwMinorVersion      : DWORD,
    dwBuildNumber       : DWORD,
    dwPlatformId        : DWORD,
    szCSDVersion        : [128]CHAR,
};
POSVERSIONINFOA :: ^OSVERSIONINFOA;
LPOSVERSIONINFOA :: ^OSVERSIONINFOA;

OSVERSIONINFOW :: struct {
    dwOSVersionInfoSize : DWORD,
    dwMajorVersion      : DWORD,
    dwMinorVersion      : DWORD,
    dwBuildNumber       : DWORD,
    dwPlatformId        : DWORD,
    szCSDVersion        : [128]WCHAR,
};
POSVERSIONINFOW :: ^OSVERSIONINFOW;
LPOSVERSIONINFOW :: ^OSVERSIONINFOW;
RTL_OSVERSIONINFOW :: struct {
    dwOSVersionInfoSize : DWORD,
    dwMajorVersion      : DWORD,
    dwMinorVersion      : DWORD,
    dwBuildNumber       : DWORD,
    dwPlatformId        : DWORD,
    szCSDVersion        : [128]WCHAR,
};
PRTL_OSVERSIONINFOW :: ^RTL_OSVERSIONINFOW;

OSVERSIONINFO :: OSVERSIONINFOA;

POSVERSIONINFO :: POSVERSIONINFOA;

LPOSVERSIONINFO :: LPOSVERSIONINFOA;

OSVERSIONINFOEXA :: struct {
    dwOSVersionInfoSize : DWORD,
    dwMajorVersion      : DWORD,
    dwMinorVersion      : DWORD,
    dwBuildNumber       : DWORD,
    dwPlatformId        : DWORD,
    szCSDVersion        : [128]CHAR,
    wServicePackMajor   : WORD,
    wServicePackMinor   : WORD,
    wSuiteMask          : WORD,
    wProductType        : BYTE,
    wReserved           : BYTE,
};
POSVERSIONINFOEXA :: ^OSVERSIONINFOEXA;
LPOSVERSIONINFOEXA :: ^OSVERSIONINFOEXA;

OSVERSIONINFOEXW :: struct {
    dwOSVersionInfoSize : DWORD,
    dwMajorVersion      : DWORD,
    dwMinorVersion      : DWORD,
    dwBuildNumber       : DWORD,
    dwPlatformId        : DWORD,
    szCSDVersion        : [128]WCHAR,
    wServicePackMajor   : WORD,
    wServicePackMinor   : WORD,
    wSuiteMask          : WORD,
    wProductType        : BYTE,
    wReserved           : BYTE,
};
POSVERSIONINFOEXW :: ^OSVERSIONINFOEXW;
LPOSVERSIONINFOEXW :: ^OSVERSIONINFOEXW;
RTL_OSVERSIONINFOEXW :: struct {
    dwOSVersionInfoSize : DWORD,
    dwMajorVersion      : DWORD,
    dwMinorVersion      : DWORD,
    dwBuildNumber       : DWORD,
    dwPlatformId        : DWORD,
    szCSDVersion        : [128]WCHAR,
    wServicePackMajor   : WORD,
    wServicePackMinor   : WORD,
    wSuiteMask          : WORD,
    wProductType        : BYTE,
    wReserved           : BYTE,
};
PRTL_OSVERSIONINFOEXW :: ^RTL_OSVERSIONINFOEXW;

OSVERSIONINFOEX :: OSVERSIONINFOEXA;

POSVERSIONINFOEX :: POSVERSIONINFOEXA;

LPOSVERSIONINFOEX :: LPOSVERSIONINFOEXA;

/* RTL_UMS_THREAD_INFO_CLASS :: enum { */
RTL_UMS_THREAD_INFO_CLASS :: _c.int;
    UmsThreadInvalidInfoClass :: 0;
    UmsThreadUserContext :: UmsThreadInvalidInfoClass + 1;
    UmsThreadPriority :: UmsThreadUserContext + 1;
    UmsThreadAffinity :: UmsThreadPriority + 1;
    UmsThreadTeb :: UmsThreadAffinity + 1;
    UmsThreadIsSuspended :: UmsThreadTeb + 1;
    UmsThreadIsTerminated :: UmsThreadIsSuspended + 1;
    UmsThreadMaxInfoClass :: UmsThreadIsTerminated + 1;
/* } */
PRTL_UMS_THREAD_INFO_CLASS :: ^RTL_UMS_THREAD_INFO_CLASS;

/* RTL_UMS_SCHEDULER_REASON :: enum { */
RTL_UMS_SCHEDULER_REASON :: _c.int;
    UmsSchedulerStartup :: 0;
    UmsSchedulerThreadBlocked :: UmsSchedulerStartup + 1;
    UmsSchedulerThreadYield :: UmsSchedulerThreadBlocked + 1;
/* } */
PRTL_UMS_SCHEDULER_REASON :: ^RTL_UMS_SCHEDULER_REASON;

RTL_UMS_SCHEDULER_ENTRY_POINT :: #type proc "stdcall" (Reason : RTL_UMS_SCHEDULER_REASON, ActivationPayload : ULONG_PTR, SchedulerParam : PVOID);

PRTL_UMS_SCHEDULER_ENTRY_POINT :: ^RTL_UMS_SCHEDULER_ENTRY_POINT;

/* OS_DEPLOYEMENT_STATE_VALUES :: enum { */
OS_DEPLOYEMENT_STATE_VALUES :: _c.int;
    OS_DEPLOYMENT_STANDARD :: 1;
    OS_DEPLOYMENT_COMPACT :: OS_DEPLOYMENT_STANDARD + 1;
/* } */
;

NV_MEMORY_RANGE :: struct {
    BaseAddress : rawptr,
    Length      : SIZE_T,
};
PNV_MEMORY_RANGE :: ^NV_MEMORY_RANGE;

CORRELATION_VECTOR :: struct {
    Version : CHAR,
    Vector  : [129]CHAR,
};

PCORRELATION_VECTOR :: ^CORRELATION_VECTOR;

CUSTOM_SYSTEM_EVENT_TRIGGER_CONFIG :: struct {
    Size      : DWORD,
    TriggerId : PCWSTR,
};
PCUSTOM_SYSTEM_EVENT_TRIGGER_CONFIG :: ^CUSTOM_SYSTEM_EVENT_TRIGGER_CONFIG;

/* IMAGE_POLICY_ENTRY_TYPE :: enum { */
IMAGE_POLICY_ENTRY_TYPE :: _c.int;
    ImagePolicyEntryTypeNone :: 0;
    ImagePolicyEntryTypeBool :: ImagePolicyEntryTypeNone + 1;
    ImagePolicyEntryTypeInt8 :: ImagePolicyEntryTypeBool + 1;
    ImagePolicyEntryTypeUInt8 :: ImagePolicyEntryTypeInt8 + 1;
    ImagePolicyEntryTypeInt16 :: ImagePolicyEntryTypeUInt8 + 1;
    ImagePolicyEntryTypeUInt16 :: ImagePolicyEntryTypeInt16 + 1;
    ImagePolicyEntryTypeInt32 :: ImagePolicyEntryTypeUInt16 + 1;
    ImagePolicyEntryTypeUInt32 :: ImagePolicyEntryTypeInt32 + 1;
    ImagePolicyEntryTypeInt64 :: ImagePolicyEntryTypeUInt32 + 1;
    ImagePolicyEntryTypeUInt64 :: ImagePolicyEntryTypeInt64 + 1;
    ImagePolicyEntryTypeAnsiString :: ImagePolicyEntryTypeUInt64 + 1;
    ImagePolicyEntryTypeUnicodeString :: ImagePolicyEntryTypeAnsiString + 1;
    ImagePolicyEntryTypeOverride :: ImagePolicyEntryTypeUnicodeString + 1;
    ImagePolicyEntryTypeMaximum :: ImagePolicyEntryTypeOverride + 1;
/* } */
;

/* IMAGE_POLICY_ID :: enum { */
IMAGE_POLICY_ID :: _c.int;
    ImagePolicyIdNone :: 0;
    ImagePolicyIdEtw :: ImagePolicyIdNone + 1;
    ImagePolicyIdDebug :: ImagePolicyIdEtw + 1;
    ImagePolicyIdCrashDump :: ImagePolicyIdDebug + 1;
    ImagePolicyIdCrashDumpKey :: ImagePolicyIdCrashDump + 1;
    ImagePolicyIdCrashDumpKeyGuid :: ImagePolicyIdCrashDumpKey + 1;
    ImagePolicyIdParentSd :: ImagePolicyIdCrashDumpKeyGuid + 1;
    ImagePolicyIdParentSdRev :: ImagePolicyIdParentSd + 1;
    ImagePolicyIdSvn :: ImagePolicyIdParentSdRev + 1;
    ImagePolicyIdDeviceId :: ImagePolicyIdSvn + 1;
    ImagePolicyIdCapability :: ImagePolicyIdDeviceId + 1;
    ImagePolicyIdScenarioId :: ImagePolicyIdCapability + 1;
    ImagePolicyIdMaximum :: ImagePolicyIdScenarioId + 1;
/* } */
;

IMAGE_POLICY_ENTRY :: struct {
    Type     : IMAGE_POLICY_ENTRY_TYPE,
    PolicyId : IMAGE_POLICY_ID,
    u : struct #raw_union {
        None               : rawptr,
        BoolValue          : BOOLEAN,
        Int8Value          : INT8,
        UInt8Value         : UINT8,
        Int16Value         : INT16,
        UInt16Value        : UINT16,
        Int32Value         : INT32,
        UInt32Value        : UINT32,
        Int64Value         : INT64,
        UInt64Value        : UINT64,
        AnsiStringValue    : PCSTR,
        UnicodeStringValue : PCWSTR,
    },
};

PCIMAGE_POLICY_ENTRY :: ^IMAGE_POLICY_ENTRY;

IMAGE_POLICY_METADATA :: struct {
    Version       : BYTE,
    Reserved0     : [7]BYTE,
    ApplicationId : ULONGLONG,
    Policies      : []IMAGE_POLICY_ENTRY,
};

PCIMAGE_POLICY_METADATA :: ^IMAGE_POLICY_METADATA;

RTL_CRITICAL_SECTION_DEBUG :: struct {
    Type                      : WORD,
    CreatorBackTraceIndex     : WORD,
    CriticalSection           : ^RTL_CRITICAL_SECTION,
    ProcessLocksList          : LIST_ENTRY,
    EntryCount                : DWORD,
    ContentionCount           : DWORD,
    Flags                     : DWORD,
    CreatorBackTraceIndexHigh : WORD,
    SpareWORD                 : WORD,
};
PRTL_CRITICAL_SECTION_DEBUG :: ^RTL_CRITICAL_SECTION_DEBUG;
RTL_RESOURCE_DEBUG :: struct {
    Type                      : WORD,
    CreatorBackTraceIndex     : WORD,
    CriticalSection           : ^RTL_CRITICAL_SECTION,
    ProcessLocksList          : LIST_ENTRY,
    EntryCount                : DWORD,
    ContentionCount           : DWORD,
    Flags                     : DWORD,
    CreatorBackTraceIndexHigh : WORD,
    SpareWORD                 : WORD,
};
PRTL_RESOURCE_DEBUG :: ^RTL_RESOURCE_DEBUG;

RTL_CRITICAL_SECTION :: struct {
    DebugInfo      : PRTL_CRITICAL_SECTION_DEBUG,
    LockCount      : LONG,
    RecursionCount : LONG,
    OwningThread   : HANDLE,
    LockSemaphore  : HANDLE,
    SpinCount      : ULONG_PTR,
};
PRTL_CRITICAL_SECTION :: ^RTL_CRITICAL_SECTION;

RTL_SRWLOCK :: struct {
    Ptr : PVOID,
};
PRTL_SRWLOCK :: ^RTL_SRWLOCK;

RTL_CONDITION_VARIABLE :: struct {
    Ptr : PVOID,
};
PRTL_CONDITION_VARIABLE :: ^RTL_CONDITION_VARIABLE;

PAPCFUNC :: proc "stdcall" (Parameter : ULONG_PTR);

PVECTORED_EXCEPTION_HANDLER :: (proc "stdcall" (ExceptionInfo : ^EXCEPTION_POINTERS) -> LONG);

/* HEAP_INFORMATION_CLASS :: enum { */
HEAP_INFORMATION_CLASS :: _c.int;
    HeapCompatibilityInformation :: 0;
    HeapEnableTerminationOnCorruption :: 1;
    HeapOptimizeResources :: 3;
/* } */
;

HEAP_OPTIMIZE_RESOURCES_INFORMATION :: struct {
    Version : DWORD,
    Flags   : DWORD,
};
PHEAP_OPTIMIZE_RESOURCES_INFORMATION :: ^HEAP_OPTIMIZE_RESOURCES_INFORMATION;

WAITORTIMERCALLBACKFUNC :: proc "stdcall" (PVOID, BOOLEAN);

WORKERCALLBACKFUNC :: proc "stdcall" (PVOID);

APC_CALLBACK_FUNCTION :: proc "stdcall" (DWORD, PVOID, PVOID);

WAITORTIMERCALLBACK :: WAITORTIMERCALLBACKFUNC;

PFLS_CALLBACK_FUNCTION :: proc "stdcall" (lpFlsData : PVOID);

PSECURE_MEMORY_CACHE_CALLBACK :: (proc "stdcall" (Addr : PVOID, Range : SIZE_T) -> BOOLEAN);

/* ACTIVATION_CONTEXT_INFO_CLASS :: enum { */
ACTIVATION_CONTEXT_INFO_CLASS :: _c.int;
    ActivationContextBasicInformation :: 1;
    ActivationContextDetailedInformation :: 2;
    AssemblyDetailedInformationInActivationContext :: 3;
    FileInformationInAssemblyOfAssemblyInActivationContext :: 4;
    RunlevelInformationInActivationContext :: 5;
    CompatibilityInformationInActivationContext :: 6;
    ActivationContextManifestResourceName :: 7;
    MaxActivationContextInfoClass :: ActivationContextManifestResourceName + 1;
    AssemblyDetailedInformationInActivationContxt :: 3;
    FileInformationInAssemblyOfAssemblyInActivationContxt :: 4;
/* } */
;

ACTIVATION_CONTEXT_QUERY_INDEX :: struct {
    ulAssemblyIndex       : DWORD,
    ulFileIndexInAssembly : DWORD,
};
PACTIVATION_CONTEXT_QUERY_INDEX :: ^ACTIVATION_CONTEXT_QUERY_INDEX;

PCACTIVATION_CONTEXT_QUERY_INDEX :: ^ACTIVATION_CONTEXT_QUERY_INDEX;

ASSEMBLY_FILE_DETAILED_INFORMATION :: struct {
    ulFlags          : DWORD,
    ulFilenameLength : DWORD,
    ulPathLength     : DWORD,
    lpFileName       : PCWSTR,
    lpFilePath       : PCWSTR,
};
PASSEMBLY_FILE_DETAILED_INFORMATION :: ^ASSEMBLY_FILE_DETAILED_INFORMATION;

PCASSEMBLY_FILE_DETAILED_INFORMATION :: ^ASSEMBLY_FILE_DETAILED_INFORMATION;

ACTIVATION_CONTEXT_ASSEMBLY_DETAILED_INFORMATION :: struct {
    ulFlags                           : DWORD,
    ulEncodedAssemblyIdentityLength   : DWORD,
    ulManifestPathType                : DWORD,
    ulManifestPathLength              : DWORD,
    liManifestLastWriteTime           : LARGE_INTEGER,
    ulPolicyPathType                  : DWORD,
    ulPolicyPathLength                : DWORD,
    liPolicyLastWriteTime             : LARGE_INTEGER,
    ulMetadataSatelliteRosterIndex    : DWORD,
    ulManifestVersionMajor            : DWORD,
    ulManifestVersionMinor            : DWORD,
    ulPolicyVersionMajor              : DWORD,
    ulPolicyVersionMinor              : DWORD,
    ulAssemblyDirectoryNameLength     : DWORD,
    lpAssemblyEncodedAssemblyIdentity : PCWSTR,
    lpAssemblyManifestPath            : PCWSTR,
    lpAssemblyPolicyPath              : PCWSTR,
    lpAssemblyDirectoryName           : PCWSTR,
    ulFileCount                       : DWORD,
};
PACTIVATION_CONTEXT_ASSEMBLY_DETAILED_INFORMATION :: ^ACTIVATION_CONTEXT_ASSEMBLY_DETAILED_INFORMATION;

PCACTIVATION_CONTEXT_ASSEMBLY_DETAILED_INFORMATION :: ^ACTIVATION_CONTEXT_ASSEMBLY_DETAILED_INFORMATION;

/* ACTCTX_REQUESTED_RUN_LEVEL :: enum { */
ACTCTX_REQUESTED_RUN_LEVEL :: _c.int;
    ACTCTX_RUN_LEVEL_UNSPECIFIED :: 0;
    ACTCTX_RUN_LEVEL_AS_INVOKER :: ACTCTX_RUN_LEVEL_UNSPECIFIED + 1;
    ACTCTX_RUN_LEVEL_HIGHEST_AVAILABLE :: ACTCTX_RUN_LEVEL_AS_INVOKER + 1;
    ACTCTX_RUN_LEVEL_REQUIRE_ADMIN :: ACTCTX_RUN_LEVEL_HIGHEST_AVAILABLE + 1;
    ACTCTX_RUN_LEVEL_NUMBERS :: ACTCTX_RUN_LEVEL_REQUIRE_ADMIN + 1;
/* } */
;

ACTIVATION_CONTEXT_RUN_LEVEL_INFORMATION :: struct {
    ulFlags  : DWORD,
    RunLevel : ACTCTX_REQUESTED_RUN_LEVEL,
    UiAccess : DWORD,
};
PACTIVATION_CONTEXT_RUN_LEVEL_INFORMATION :: ^ACTIVATION_CONTEXT_RUN_LEVEL_INFORMATION;

PCACTIVATION_CONTEXT_RUN_LEVEL_INFORMATION :: ^ACTIVATION_CONTEXT_RUN_LEVEL_INFORMATION;

/* ACTCTX_COMPATIBILITY_ELEMENT_TYPE :: enum { */
ACTCTX_COMPATIBILITY_ELEMENT_TYPE :: _c.int;
    ACTCTX_COMPATIBILITY_ELEMENT_TYPE_UNKNOWN :: 0;
    ACTCTX_COMPATIBILITY_ELEMENT_TYPE_OS :: ACTCTX_COMPATIBILITY_ELEMENT_TYPE_UNKNOWN + 1;
    ACTCTX_COMPATIBILITY_ELEMENT_TYPE_MITIGATION :: ACTCTX_COMPATIBILITY_ELEMENT_TYPE_OS + 1;
    ACTCTX_COMPATIBILITY_ELEMENT_TYPE_MAXVERSIONTESTED :: ACTCTX_COMPATIBILITY_ELEMENT_TYPE_MITIGATION + 1;
/* } */
;

COMPATIBILITY_CONTEXT_ELEMENT :: struct {
    Id               : GUID,
    Type             : ACTCTX_COMPATIBILITY_ELEMENT_TYPE,
    MaxVersionTested : ULONGLONG,
};
PCOMPATIBILITY_CONTEXT_ELEMENT :: ^COMPATIBILITY_CONTEXT_ELEMENT;

PCCOMPATIBILITY_CONTEXT_ELEMENT :: ^COMPATIBILITY_CONTEXT_ELEMENT;

SUPPORTED_OS_INFO :: struct {
    MajorVersion : WORD,
    MinorVersion : WORD,
};
PSUPPORTED_OS_INFO :: ^SUPPORTED_OS_INFO;

MAXVERSIONTESTED_INFO :: struct {
    MaxVersionTested : ULONGLONG,
};
PMAXVERSIONTESTED_INFO :: ^MAXVERSIONTESTED_INFO;

ACTIVATION_CONTEXT_DETAILED_INFORMATION :: struct {
    dwFlags                      : DWORD,
    ulFormatVersion              : DWORD,
    ulAssemblyCount              : DWORD,
    ulRootManifestPathType       : DWORD,
    ulRootManifestPathChars      : DWORD,
    ulRootConfigurationPathType  : DWORD,
    ulRootConfigurationPathChars : DWORD,
    ulAppDirPathType             : DWORD,
    ulAppDirPathChars            : DWORD,
    lpRootManifestPath           : PCWSTR,
    lpRootConfigurationPath      : PCWSTR,
    lpAppDirPath                 : PCWSTR,
};
PACTIVATION_CONTEXT_DETAILED_INFORMATION :: ^ACTIVATION_CONTEXT_DETAILED_INFORMATION;

PCACTIVATION_CONTEXT_DETAILED_INFORMATION :: ^ACTIVATION_CONTEXT_DETAILED_INFORMATION;

HARDWARE_COUNTER_DATA :: struct {
    Type     : HARDWARE_COUNTER_TYPE,
    Reserved : DWORD,
    Value    : DWORD64,
};
PHARDWARE_COUNTER_DATA :: ^HARDWARE_COUNTER_DATA;

PERFORMANCE_DATA :: struct {
    Size               : WORD,
    Version            : BYTE,
    HwCountersCount    : BYTE,
    ContextSwitchCount : DWORD,
    WaitReasonBitMap   : DWORD64,
    CycleTime          : DWORD64,
    RetryCount         : DWORD,
    Reserved           : DWORD,
    HwCounters         : [16]HARDWARE_COUNTER_DATA,
};
PPERFORMANCE_DATA :: ^PERFORMANCE_DATA;

EVENTLOGRECORD :: struct {
    Length              : DWORD,
    Reserved            : DWORD,
    RecordNumber        : DWORD,
    TimeGenerated       : DWORD,
    TimeWritten         : DWORD,
    EventID             : DWORD,
    EventType           : WORD,
    NumStrings          : WORD,
    EventCategory       : WORD,
    ReservedFlags       : WORD,
    ClosingRecordNumber : DWORD,
    StringOffset        : DWORD,
    UserSidLength       : DWORD,
    UserSidOffset       : DWORD,
    DataLength          : DWORD,
    DataOffset          : DWORD,
};
PEVENTLOGRECORD :: ^EVENTLOGRECORD;

EVENTSFORLOGFILE :: struct {};

PEVENTSFORLOGFILE :: ^EVENTSFORLOGFILE;

PACKEDEVENTINFO :: struct {};

PPACKEDEVENTINFO :: ^PACKEDEVENTINFO;

/* SERVICE_NODE_TYPE :: enum { */
SERVICE_NODE_TYPE :: _c.int;
    DriverType :: 0x00000001;
    FileSystemType :: 0x00000002;
    Win32ServiceOwnProcess :: 0x00000010;
    Win32ServiceShareProcess :: 0x00000020;
    AdapterType :: 0x00000004;
    RecognizerType :: 0x00000008;
/* } */
;

/* SERVICE_LOAD_TYPE :: enum { */
SERVICE_LOAD_TYPE :: _c.int;
    BootLoad :: 0x00000000;
    SystemLoad :: 0x00000001;
    AutoLoad :: 0x00000002;
    DemandLoad :: 0x00000003;
    DisableLoad :: 0x00000004;
/* } */
;

/* SERVICE_ERROR_TYPE :: enum { */
SERVICE_ERROR_TYPE :: _c.int;
    IgnoreError :: 0x00000000;
    NormalError :: 0x00000001;
    SevereError :: 0x00000002;
    CriticalError :: 0x00000003;
/* } */
;

TAPE_ERASE :: struct {
    Type      : DWORD,
    Immediate : BOOLEAN,
};
PTAPE_ERASE :: ^TAPE_ERASE;

TAPE_PREPARE :: struct {
    Operation : DWORD,
    Immediate : BOOLEAN,
};
PTAPE_PREPARE :: ^TAPE_PREPARE;

TAPE_WRITE_MARKS :: struct {
    Type      : DWORD,
    Count     : DWORD,
    Immediate : BOOLEAN,
};
PTAPE_WRITE_MARKS :: ^TAPE_WRITE_MARKS;

TAPE_GET_POSITION :: struct {
    Type      : DWORD,
    Partition : DWORD,
    Offset    : LARGE_INTEGER,
};
PTAPE_GET_POSITION :: ^TAPE_GET_POSITION;

TAPE_SET_POSITION :: struct {
    Method    : DWORD,
    Partition : DWORD,
    Offset    : LARGE_INTEGER,
    Immediate : BOOLEAN,
};
PTAPE_SET_POSITION :: ^TAPE_SET_POSITION;

TAPE_GET_DRIVE_PARAMETERS :: struct {
    ECC                   : BOOLEAN,
    Compression           : BOOLEAN,
    DataPadding           : BOOLEAN,
    ReportSetmarks        : BOOLEAN,
    DefaultBlockSize      : DWORD,
    MaximumBlockSize      : DWORD,
    MinimumBlockSize      : DWORD,
    MaximumPartitionCount : DWORD,
    FeaturesLow           : DWORD,
    FeaturesHigh          : DWORD,
    EOTWarningZoneSize    : DWORD,
};
PTAPE_GET_DRIVE_PARAMETERS :: ^TAPE_GET_DRIVE_PARAMETERS;

TAPE_SET_DRIVE_PARAMETERS :: struct {
    ECC                : BOOLEAN,
    Compression        : BOOLEAN,
    DataPadding        : BOOLEAN,
    ReportSetmarks     : BOOLEAN,
    EOTWarningZoneSize : DWORD,
};
PTAPE_SET_DRIVE_PARAMETERS :: ^TAPE_SET_DRIVE_PARAMETERS;

TAPE_GET_MEDIA_PARAMETERS :: struct {
    Capacity       : LARGE_INTEGER,
    Remaining      : LARGE_INTEGER,
    BlockSize      : DWORD,
    PartitionCount : DWORD,
    WriteProtected : BOOLEAN,
};
PTAPE_GET_MEDIA_PARAMETERS :: ^TAPE_GET_MEDIA_PARAMETERS;

TAPE_SET_MEDIA_PARAMETERS :: struct {
    BlockSize : DWORD,
};
PTAPE_SET_MEDIA_PARAMETERS :: ^TAPE_SET_MEDIA_PARAMETERS;

TAPE_CREATE_PARTITION :: struct {
    Method : DWORD,
    Count  : DWORD,
    Size   : DWORD,
};
PTAPE_CREATE_PARTITION :: ^TAPE_CREATE_PARTITION;

TAPE_WMI_OPERATIONS :: struct {
    Method         : DWORD,
    DataBufferSize : DWORD,
    DataBuffer     : PVOID,
};
PTAPE_WMI_OPERATIONS :: ^TAPE_WMI_OPERATIONS;

/* TAPE_DRIVE_PROBLEM_TYPE :: enum { */
TAPE_DRIVE_PROBLEM_TYPE :: _c.int;
    TapeDriveProblemNone :: 0;
    TapeDriveReadWriteWarning :: TapeDriveProblemNone + 1;
    TapeDriveReadWriteError :: TapeDriveReadWriteWarning + 1;
    TapeDriveReadWarning :: TapeDriveReadWriteError + 1;
    TapeDriveWriteWarning :: TapeDriveReadWarning + 1;
    TapeDriveReadError :: TapeDriveWriteWarning + 1;
    TapeDriveWriteError :: TapeDriveReadError + 1;
    TapeDriveHardwareError :: TapeDriveWriteError + 1;
    TapeDriveUnsupportedMedia :: TapeDriveHardwareError + 1;
    TapeDriveScsiConnectionError :: TapeDriveUnsupportedMedia + 1;
    TapeDriveTimetoClean :: TapeDriveScsiConnectionError + 1;
    TapeDriveCleanDriveNow :: TapeDriveTimetoClean + 1;
    TapeDriveMediaLifeExpired :: TapeDriveCleanDriveNow + 1;
    TapeDriveSnappedTape :: TapeDriveMediaLifeExpired + 1;
/* } */
;

UOW :: GUID;
PUOW :: ^GUID;

CRM_PROTOCOL_ID :: GUID;
PCRM_PROTOCOL_ID :: ^GUID;

NOTIFICATION_MASK :: ULONG;

TRANSACTION_NOTIFICATION :: struct {
    TransactionKey          : PVOID,
    TransactionNotification : ULONG,
    TmVirtualClock          : LARGE_INTEGER,
    ArgumentLength          : ULONG,
};
PTRANSACTION_NOTIFICATION :: ^TRANSACTION_NOTIFICATION;

TRANSACTION_NOTIFICATION_RECOVERY_ARGUMENT :: struct {
    EnlistmentId : GUID,
    UOW          : UOW,
};
PTRANSACTION_NOTIFICATION_RECOVERY_ARGUMENT :: ^TRANSACTION_NOTIFICATION_RECOVERY_ARGUMENT;

TRANSACTION_NOTIFICATION_TM_ONLINE_ARGUMENT :: struct {
    TmIdentity : GUID,
    Flags      : ULONG,
};
PTRANSACTION_NOTIFICATION_TM_ONLINE_ARGUMENT :: ^TRANSACTION_NOTIFICATION_TM_ONLINE_ARGUMENT;

SAVEPOINT_ID :: ULONG;
PSAVEPOINT_ID :: ^ULONG;

TRANSACTION_NOTIFICATION_SAVEPOINT_ARGUMENT :: struct {
    SavepointId : SAVEPOINT_ID,
};
PTRANSACTION_NOTIFICATION_SAVEPOINT_ARGUMENT :: ^TRANSACTION_NOTIFICATION_SAVEPOINT_ARGUMENT;

TRANSACTION_NOTIFICATION_PROPAGATE_ARGUMENT :: struct {
    PropagationCookie : ULONG,
    UOW               : GUID,
    TmIdentity        : GUID,
    BufferLength      : ULONG,
};
PTRANSACTION_NOTIFICATION_PROPAGATE_ARGUMENT :: ^TRANSACTION_NOTIFICATION_PROPAGATE_ARGUMENT;

TRANSACTION_NOTIFICATION_MARSHAL_ARGUMENT :: struct {
    MarshalCookie : ULONG,
    UOW           : GUID,
};
PTRANSACTION_NOTIFICATION_MARSHAL_ARGUMENT :: ^TRANSACTION_NOTIFICATION_MARSHAL_ARGUMENT;

TRANSACTION_NOTIFICATION_PROMOTE_ARGUMENT :: TRANSACTION_NOTIFICATION_PROPAGATE_ARGUMENT;
PTRANSACTION_NOTIFICATION_PROMOTE_ARGUMENT :: ^TRANSACTION_NOTIFICATION_PROPAGATE_ARGUMENT;

KCRM_MARSHAL_HEADER :: struct {
    VersionMajor : ULONG,
    VersionMinor : ULONG,
    NumProtocols : ULONG,
    Unused       : ULONG,
};
PKCRM_MARSHAL_HEADER :: ^KCRM_MARSHAL_HEADER;
PRKCRM_MARSHAL_HEADER :: ^KCRM_MARSHAL_HEADER;

KCRM_TRANSACTION_BLOB :: struct {
    UOW            : UOW,
    TmIdentity     : GUID,
    IsolationLevel : ULONG,
    IsolationFlags : ULONG,
    Timeout        : ULONG,
    Description    : [64]WCHAR,
};
PKCRM_TRANSACTION_BLOB :: ^KCRM_TRANSACTION_BLOB;
PRKCRM_TRANSACTION_BLOB :: ^KCRM_TRANSACTION_BLOB;

KCRM_PROTOCOL_BLOB :: struct {
    ProtocolId              : CRM_PROTOCOL_ID,
    StaticInfoLength        : ULONG,
    TransactionIdInfoLength : ULONG,
    Unused1                 : ULONG,
    Unused2                 : ULONG,
};
PKCRM_PROTOCOL_BLOB :: ^KCRM_PROTOCOL_BLOB;
PRKCRM_PROTOCOL_BLOB :: ^KCRM_PROTOCOL_BLOB;

/* TRANSACTION_OUTCOME :: enum { */
TRANSACTION_OUTCOME :: _c.int;
    TransactionOutcomeUndetermined :: 1;
    TransactionOutcomeCommitted :: TransactionOutcomeUndetermined + 1;
    TransactionOutcomeAborted :: TransactionOutcomeCommitted + 1;
/* } */
;

/* TRANSACTION_STATE :: enum { */
TRANSACTION_STATE :: _c.int;
    TransactionStateNormal :: 1;
    TransactionStateIndoubt :: TransactionStateNormal + 1;
    TransactionStateCommittedNotify :: TransactionStateIndoubt + 1;
/* } */
;

TRANSACTION_BASIC_INFORMATION :: struct {
    TransactionId : GUID,
    State         : DWORD,
    Outcome       : DWORD,
};
PTRANSACTION_BASIC_INFORMATION :: ^TRANSACTION_BASIC_INFORMATION;

TRANSACTIONMANAGER_BASIC_INFORMATION :: struct {
    TmIdentity   : GUID,
    VirtualClock : LARGE_INTEGER,
};
PTRANSACTIONMANAGER_BASIC_INFORMATION :: ^TRANSACTIONMANAGER_BASIC_INFORMATION;

TRANSACTIONMANAGER_LOG_INFORMATION :: struct {
    LogIdentity : GUID,
};
PTRANSACTIONMANAGER_LOG_INFORMATION :: ^TRANSACTIONMANAGER_LOG_INFORMATION;

TRANSACTIONMANAGER_LOGPATH_INFORMATION :: struct {
    LogPathLength : DWORD,
    LogPath       : [1]WCHAR,
};
PTRANSACTIONMANAGER_LOGPATH_INFORMATION :: ^TRANSACTIONMANAGER_LOGPATH_INFORMATION;

TRANSACTIONMANAGER_RECOVERY_INFORMATION :: struct {
    LastRecoveredLsn : ULONGLONG,
};
PTRANSACTIONMANAGER_RECOVERY_INFORMATION :: ^TRANSACTIONMANAGER_RECOVERY_INFORMATION;

TRANSACTIONMANAGER_OLDEST_INFORMATION :: struct {
    OldestTransactionGuid : GUID,
};
PTRANSACTIONMANAGER_OLDEST_INFORMATION :: ^TRANSACTIONMANAGER_OLDEST_INFORMATION;

TRANSACTION_PROPERTIES_INFORMATION :: struct {
    IsolationLevel    : DWORD,
    IsolationFlags    : DWORD,
    Timeout           : LARGE_INTEGER,
    Outcome           : DWORD,
    DescriptionLength : DWORD,
    Description       : [1]WCHAR,
};
PTRANSACTION_PROPERTIES_INFORMATION :: ^TRANSACTION_PROPERTIES_INFORMATION;

TRANSACTION_BIND_INFORMATION :: struct {
    TmHandle : HANDLE,
};
PTRANSACTION_BIND_INFORMATION :: ^TRANSACTION_BIND_INFORMATION;

TRANSACTION_ENLISTMENT_PAIR :: struct {
    EnlistmentId      : GUID,
    ResourceManagerId : GUID,
};
PTRANSACTION_ENLISTMENT_PAIR :: ^TRANSACTION_ENLISTMENT_PAIR;

TRANSACTION_ENLISTMENTS_INFORMATION :: struct {
    NumberOfEnlistments : DWORD,
    EnlistmentPair      : [1]TRANSACTION_ENLISTMENT_PAIR,
};
PTRANSACTION_ENLISTMENTS_INFORMATION :: ^TRANSACTION_ENLISTMENTS_INFORMATION;

TRANSACTION_SUPERIOR_ENLISTMENT_INFORMATION :: struct {
    SuperiorEnlistmentPair : TRANSACTION_ENLISTMENT_PAIR,
};
PTRANSACTION_SUPERIOR_ENLISTMENT_INFORMATION :: ^TRANSACTION_SUPERIOR_ENLISTMENT_INFORMATION;

RESOURCEMANAGER_BASIC_INFORMATION :: struct {
    ResourceManagerId : GUID,
    DescriptionLength : DWORD,
    Description       : [1]WCHAR,
};
PRESOURCEMANAGER_BASIC_INFORMATION :: ^RESOURCEMANAGER_BASIC_INFORMATION;

RESOURCEMANAGER_COMPLETION_INFORMATION :: struct {
    IoCompletionPortHandle : HANDLE,
    CompletionKey          : ULONG_PTR,
};
PRESOURCEMANAGER_COMPLETION_INFORMATION :: ^RESOURCEMANAGER_COMPLETION_INFORMATION;

/* TRANSACTION_INFORMATION_CLASS :: enum { */
TRANSACTION_INFORMATION_CLASS :: _c.int;
    TransactionBasicInformation :: 0;
    TransactionPropertiesInformation :: TransactionBasicInformation + 1;
    TransactionEnlistmentInformation :: TransactionPropertiesInformation + 1;
    TransactionSuperiorEnlistmentInformation :: TransactionEnlistmentInformation + 1;
    TransactionBindInformation :: TransactionSuperiorEnlistmentInformation + 1;
    TransactionDTCPrivateInformation :: TransactionBindInformation + 1;
/* } */
;

/* TRANSACTIONMANAGER_INFORMATION_CLASS :: enum { */
TRANSACTIONMANAGER_INFORMATION_CLASS :: _c.int;
    TransactionManagerBasicInformation :: 0;
    TransactionManagerLogInformation :: TransactionManagerBasicInformation + 1;
    TransactionManagerLogPathInformation :: TransactionManagerLogInformation + 1;
    TransactionManagerRecoveryInformation :: 4;
    TransactionManagerOnlineProbeInformation :: 3;
    TransactionManagerOldestTransactionInformation :: 5;
/* } */
;

/* RESOURCEMANAGER_INFORMATION_CLASS :: enum { */
RESOURCEMANAGER_INFORMATION_CLASS :: _c.int;
    ResourceManagerBasicInformation :: 0;
    ResourceManagerCompletionInformation :: ResourceManagerBasicInformation + 1;
/* } */
;

ENLISTMENT_BASIC_INFORMATION :: struct {
    EnlistmentId      : GUID,
    TransactionId     : GUID,
    ResourceManagerId : GUID,
};
PENLISTMENT_BASIC_INFORMATION :: ^ENLISTMENT_BASIC_INFORMATION;

ENLISTMENT_CRM_INFORMATION :: struct {
    CrmTransactionManagerId : GUID,
    CrmResourceManagerId    : GUID,
    CrmEnlistmentId         : GUID,
};
PENLISTMENT_CRM_INFORMATION :: ^ENLISTMENT_CRM_INFORMATION;

/* ENLISTMENT_INFORMATION_CLASS :: enum { */
ENLISTMENT_INFORMATION_CLASS :: _c.int;
    EnlistmentBasicInformation :: 0;
    EnlistmentRecoveryInformation :: EnlistmentBasicInformation + 1;
    EnlistmentCrmInformation :: EnlistmentRecoveryInformation + 1;
/* } */
;

TRANSACTION_LIST_ENTRY :: struct {
    UOW : UOW,
};
PTRANSACTION_LIST_ENTRY :: ^TRANSACTION_LIST_ENTRY;

TRANSACTION_LIST_INFORMATION :: struct {
    NumberOfTransactions   : DWORD,
    TransactionInformation : [1]TRANSACTION_LIST_ENTRY,
};
PTRANSACTION_LIST_INFORMATION :: ^TRANSACTION_LIST_INFORMATION;

/* KTMOBJECT_TYPE :: enum { */
KTMOBJECT_TYPE :: _c.int;
    KTMOBJECT_TRANSACTION :: 0;
    KTMOBJECT_TRANSACTION_MANAGER :: KTMOBJECT_TRANSACTION + 1;
    KTMOBJECT_RESOURCE_MANAGER :: KTMOBJECT_TRANSACTION_MANAGER + 1;
    KTMOBJECT_ENLISTMENT :: KTMOBJECT_RESOURCE_MANAGER + 1;
    KTMOBJECT_INVALID :: KTMOBJECT_ENLISTMENT + 1;
/* } */
PKTMOBJECT_TYPE :: ^KTMOBJECT_TYPE;

KTMOBJECT_CURSOR :: struct {
    LastQuery     : GUID,
    ObjectIdCount : DWORD,
    ObjectIds     : [1]GUID,
};
PKTMOBJECT_CURSOR :: ^KTMOBJECT_CURSOR;

TP_VERSION :: DWORD;
PTP_VERSION :: ^DWORD;

TP_CALLBACK_INSTANCE :: struct {};

PTP_CALLBACK_INSTANCE :: ^TP_CALLBACK_INSTANCE;

PTP_SIMPLE_CALLBACK :: proc "stdcall" (Instance : PTP_CALLBACK_INSTANCE, Context : PVOID);

TP_POOL :: struct {};

PTP_POOL :: ^TP_POOL;

/* TP_CALLBACK_PRIORITY :: enum { */
TP_CALLBACK_PRIORITY :: _c.int;
    TP_CALLBACK_PRIORITY_HIGH :: 0;
    TP_CALLBACK_PRIORITY_NORMAL :: TP_CALLBACK_PRIORITY_HIGH + 1;
    TP_CALLBACK_PRIORITY_LOW :: TP_CALLBACK_PRIORITY_NORMAL + 1;
    TP_CALLBACK_PRIORITY_INVALID :: TP_CALLBACK_PRIORITY_LOW + 1;
    TP_CALLBACK_PRIORITY_COUNT ::     TP_CALLBACK_PRIORITY_INVALID;
/* } */
;

TP_POOL_STACK_INFORMATION :: struct {
    StackReserve : SIZE_T,
    StackCommit  : SIZE_T,
};
PTP_POOL_STACK_INFORMATION :: ^TP_POOL_STACK_INFORMATION;

TP_CLEANUP_GROUP :: struct {};

PTP_CLEANUP_GROUP :: ^TP_CLEANUP_GROUP;

PTP_CLEANUP_GROUP_CANCEL_CALLBACK :: proc "stdcall" (ObjectContext : PVOID, CleanupContext : PVOID);

TP_CALLBACK_ENVIRON_V3 :: struct {
    Version                    : TP_VERSION,
    Pool                       : PTP_POOL,
    CleanupGroup               : PTP_CLEANUP_GROUP,
    CleanupGroupCancelCallback : PTP_CLEANUP_GROUP_CANCEL_CALLBACK,
    RaceDll                    : PVOID,
    ActivationContext          : ^_ACTIVATION_CONTEXT,
    FinalizationCallback       : PTP_SIMPLE_CALLBACK,
    u : struct #raw_union {
        Flags : DWORD,
        s : bit_field {
            LongFunction : 1,
            Persistent   : 1,
            Private      : 30,
        },
    },
    CallbackPriority           : TP_CALLBACK_PRIORITY,
    Size                       : DWORD,
};

TP_CALLBACK_ENVIRON :: TP_CALLBACK_ENVIRON_V3;
PTP_CALLBACK_ENVIRON :: ^TP_CALLBACK_ENVIRON_V3;

TP_WORK :: struct {};

PTP_WORK :: ^TP_WORK;

PTP_WORK_CALLBACK :: proc "stdcall" (Instance : PTP_CALLBACK_INSTANCE, Context : PVOID, Work : PTP_WORK);

TP_TIMER :: struct {};

PTP_TIMER :: ^TP_TIMER;

PTP_TIMER_CALLBACK :: proc "stdcall" (Instance : PTP_CALLBACK_INSTANCE, Context : PVOID, Timer : PTP_TIMER);

TP_WAIT_RESULT :: DWORD;

TP_WAIT :: struct {};

PTP_WAIT :: ^TP_WAIT;

PTP_WAIT_CALLBACK :: proc "stdcall" (Instance : PTP_CALLBACK_INSTANCE, Context : PVOID, Wait : PTP_WAIT, WaitResult : TP_WAIT_RESULT);

TP_IO :: struct {};

PTP_IO :: ^TP_IO;

WPARAM :: UINT_PTR;

LPARAM :: LONG_PTR;

LRESULT :: LONG_PTR;

SPHANDLE :: ^HANDLE;

LPHANDLE :: ^HANDLE;

HGLOBAL :: HANDLE;

HLOCAL :: HANDLE;

GLOBALHANDLE :: HANDLE;

LOCALHANDLE :: HANDLE;

FARPROC :: (proc "stdcall" () -> INT_PTR);

NEARPROC :: (proc "stdcall" () -> INT_PTR);

PROC :: (proc "stdcall" () -> INT_PTR);

ATOM :: WORD;

HKEY__ :: struct {
    unused : _c.int,
};

HKEY :: ^HKEY__;

PHKEY :: ^HKEY;

HMETAFILE__ :: struct {
    unused : _c.int,
};

HMETAFILE :: ^HMETAFILE__;

HINSTANCE__ :: struct {
    unused : _c.int,
};

HINSTANCE :: ^HINSTANCE__;

HMODULE :: HINSTANCE;

HRGN__ :: struct {
    unused : _c.int,
};

HRGN :: ^HRGN__;

HRSRC__ :: struct {
    unused : _c.int,
};

HRSRC :: ^HRSRC__;

HSPRITE__ :: struct {
    unused : _c.int,
};

HSPRITE :: ^HSPRITE__;

HLSURF__ :: struct {
    unused : _c.int,
};

HLSURF :: ^HLSURF__;

HSTR__ :: struct {
    unused : _c.int,
};

HSTR :: ^HSTR__;

HTASK__ :: struct {
    unused : _c.int,
};

HTASK :: ^HTASK__;

HWINSTA__ :: struct {
    unused : _c.int,
};

HWINSTA :: ^HWINSTA__;

HKL__ :: struct {
    unused : _c.int,
};

HKL :: ^HKL__;

HFILE :: _c.int;

FILETIME :: struct {
    dwLowDateTime  : DWORD,
    dwHighDateTime : DWORD,
};
PFILETIME :: ^FILETIME;
LPFILETIME :: ^FILETIME;

HWND__ :: struct {
    unused : _c.int,
};

HWND :: ^HWND__;

HHOOK__ :: struct {
    unused : _c.int,
};

HHOOK :: ^HHOOK__;

HGDIOBJ :: rawptr;

HACCEL__ :: struct {
    unused : _c.int,
};

HACCEL :: ^HACCEL__;

HBITMAP__ :: struct {
    unused : _c.int,
};

HBITMAP :: ^HBITMAP__;

HBRUSH__ :: struct {
    unused : _c.int,
};

HBRUSH :: ^HBRUSH__;

HCOLORSPACE__ :: struct {
    unused : _c.int,
};

HCOLORSPACE :: ^HCOLORSPACE__;

HDC__ :: struct {
    unused : _c.int,
};

HDC :: ^HDC__;

HGLRC__ :: struct {
    unused : _c.int,
};

HGLRC :: ^HGLRC__;

HDESK__ :: struct {
    unused : _c.int,
};

HDESK :: ^HDESK__;

HENHMETAFILE__ :: struct {
    unused : _c.int,
};

HENHMETAFILE :: ^HENHMETAFILE__;

HFONT__ :: struct {
    unused : _c.int,
};

HFONT :: ^HFONT__;

HICON__ :: struct {
    unused : _c.int,
};

HICON :: ^HICON__;

HMENU__ :: struct {
    unused : _c.int,
};

HMENU :: ^HMENU__;

HPALETTE__ :: struct {
    unused : _c.int,
};

HPALETTE :: ^HPALETTE__;

HPEN__ :: struct {
    unused : _c.int,
};

HPEN :: ^HPEN__;

HWINEVENTHOOK__ :: struct {
    unused : _c.int,
};

HWINEVENTHOOK :: ^HWINEVENTHOOK__;

HMONITOR__ :: struct {
    unused : _c.int,
};

HMONITOR :: ^HMONITOR__;

HUMPD__ :: struct {
    unused : _c.int,
};

HUMPD :: ^HUMPD__;

HCURSOR :: HICON;

COLORREF :: DWORD;

LPCOLORREF :: ^DWORD;

RECT :: struct {
    left   : LONG,
    top    : LONG,
    right  : LONG,
    bottom : LONG,
};
PRECT :: ^RECT;
NPRECT :: ^RECT;
LPRECT :: ^RECT;

LPCRECT :: ^RECT;

RECTL :: struct {
    left   : LONG,
    top    : LONG,
    right  : LONG,
    bottom : LONG,
};
PRECTL :: ^RECTL;
LPRECTL :: ^RECTL;

LPCRECTL :: ^RECTL;

POINT :: struct {
    x : LONG,
    y : LONG,
};
PPOINT :: ^POINT;
NPPOINT :: ^POINT;
LPPOINT :: ^POINT;

POINTL :: struct {
    x : LONG,
    y : LONG,
};
PPOINTL :: ^POINTL;

SIZE :: struct {
    cx : LONG,
    cy : LONG,
};
PSIZE :: ^SIZE;
LPSIZE :: ^SIZE;

SIZEL :: SIZE;

PSIZEL :: ^SIZE;
LPSIZEL :: ^SIZE;

POINTS :: struct {
    x : SHORT,
    y : SHORT,
};
PPOINTS :: ^POINTS;
LPPOINTS :: ^POINTS;

DPI_AWARENESS_CONTEXT__ :: struct {
    unused : _c.int,
};

DPI_AWARENESS_CONTEXT :: ^DPI_AWARENESS_CONTEXT__;

/* DPI_AWARENESS :: enum { */
DPI_AWARENESS :: _c.int;
    DPI_AWARENESS_INVALID :: -1;
    DPI_AWARENESS_UNAWARE :: 0;
    DPI_AWARENESS_SYSTEM_AWARE :: 1;
    DPI_AWARENESS_PER_MONITOR_AWARE :: 2;
/* } */
;

/* DPI_HOSTING_BEHAVIOR :: enum { */
DPI_HOSTING_BEHAVIOR :: _c.int;
    DPI_HOSTING_BEHAVIOR_INVALID :: -1;
    DPI_HOSTING_BEHAVIOR_DEFAULT :: 0;
    DPI_HOSTING_BEHAVIOR_MIXED :: 1;
/* } */
;

SECURITY_ATTRIBUTES :: struct {
    nLength              : DWORD,
    lpSecurityDescriptor : LPVOID,
    bInheritHandle       : BOOL,
};
PSECURITY_ATTRIBUTES :: ^SECURITY_ATTRIBUTES;
LPSECURITY_ATTRIBUTES :: ^SECURITY_ATTRIBUTES;

OVERLAPPED :: struct {
    Internal     : ULONG_PTR,
    InternalHigh : ULONG_PTR,
    u : struct #raw_union {
        s : struct {
            Offset     : DWORD,
            OffsetHigh : DWORD,
        },
        Pointer : PVOID,
    },
    hEvent       : HANDLE,
};
LPOVERLAPPED :: ^OVERLAPPED;

OVERLAPPED_ENTRY :: struct {
    lpCompletionKey            : ULONG_PTR,
    lpOverlapped               : LPOVERLAPPED,
    Internal                   : ULONG_PTR,
    dwNumberOfBytesTransferred : DWORD,
};
LPOVERLAPPED_ENTRY :: ^OVERLAPPED_ENTRY;

SYSTEMTIME :: struct {
    wYear         : WORD,
    wMonth        : WORD,
    wDayOfWeek    : WORD,
    wDay          : WORD,
    wHour         : WORD,
    wMinute       : WORD,
    wSecond       : WORD,
    wMilliseconds : WORD,
};
PSYSTEMTIME :: ^SYSTEMTIME;
LPSYSTEMTIME :: ^SYSTEMTIME;

WIN32_FIND_DATAA :: struct {
    dwFileAttributes   : DWORD,
    ftCreationTime     : FILETIME,
    ftLastAccessTime   : FILETIME,
    ftLastWriteTime    : FILETIME,
    nFileSizeHigh      : DWORD,
    nFileSizeLow       : DWORD,
    dwReserved0        : DWORD,
    dwReserved1        : DWORD,
    cFileName          : [260]CHAR,
    cAlternateFileName : [14]CHAR,
};
PWIN32_FIND_DATAA :: ^WIN32_FIND_DATAA;
LPWIN32_FIND_DATAA :: ^WIN32_FIND_DATAA;

WIN32_FIND_DATAW :: struct {
    dwFileAttributes   : DWORD,
    ftCreationTime     : FILETIME,
    ftLastAccessTime   : FILETIME,
    ftLastWriteTime    : FILETIME,
    nFileSizeHigh      : DWORD,
    nFileSizeLow       : DWORD,
    dwReserved0        : DWORD,
    dwReserved1        : DWORD,
    cFileName          : [260]WCHAR,
    cAlternateFileName : [14]WCHAR,
};
PWIN32_FIND_DATAW :: ^WIN32_FIND_DATAW;
LPWIN32_FIND_DATAW :: ^WIN32_FIND_DATAW;

WIN32_FIND_DATA :: WIN32_FIND_DATAA;

PWIN32_FIND_DATA :: PWIN32_FIND_DATAA;

LPWIN32_FIND_DATA :: LPWIN32_FIND_DATAA;

/* FINDEX_INFO_LEVELS :: enum { */
FINDEX_INFO_LEVELS :: _c.int;
    FindExInfoStandard :: 0;
    FindExInfoBasic :: FindExInfoStandard + 1;
    FindExInfoMaxInfoLevel :: FindExInfoBasic + 1;
/* } */
;

/* FINDEX_SEARCH_OPS :: enum { */
FINDEX_SEARCH_OPS :: _c.int;
    FindExSearchNameMatch :: 0;
    FindExSearchLimitToDirectories :: FindExSearchNameMatch + 1;
    FindExSearchLimitToDevices :: FindExSearchLimitToDirectories + 1;
    FindExSearchMaxSearchOp :: FindExSearchLimitToDevices + 1;
/* } */
;

/* READ_DIRECTORY_NOTIFY_INFORMATION_CLASS :: enum { */
READ_DIRECTORY_NOTIFY_INFORMATION_CLASS :: _c.int;
    ReadDirectoryNotifyInformation :: 1;
    ReadDirectoryNotifyExtendedInformation :: ReadDirectoryNotifyInformation + 1;
/* } */
PREAD_DIRECTORY_NOTIFY_INFORMATION_CLASS :: ^READ_DIRECTORY_NOTIFY_INFORMATION_CLASS;

/* GET_FILEEX_INFO_LEVELS :: enum { */
GET_FILEEX_INFO_LEVELS :: _c.int;
    GetFileExInfoStandard :: 0;
    GetFileExMaxInfoLevel :: GetFileExInfoStandard + 1;
/* } */
;

/* FILE_INFO_BY_HANDLE_CLASS :: enum { */
FILE_INFO_BY_HANDLE_CLASS :: _c.int;
    FileBasicInfo :: 0;
    FileStandardInfo :: FileBasicInfo + 1;
    FileNameInfo :: FileStandardInfo + 1;
    FileRenameInfo :: FileNameInfo + 1;
    FileDispositionInfo :: FileRenameInfo + 1;
    FileAllocationInfo :: FileDispositionInfo + 1;
    FileEndOfFileInfo :: FileAllocationInfo + 1;
    FileStreamInfo :: FileEndOfFileInfo + 1;
    FileCompressionInfo :: FileStreamInfo + 1;
    FileAttributeTagInfo :: FileCompressionInfo + 1;
    FileIdBothDirectoryInfo :: FileAttributeTagInfo + 1;
    FileIdBothDirectoryRestartInfo :: FileIdBothDirectoryInfo + 1;
    FileIoPriorityHintInfo :: FileIdBothDirectoryRestartInfo + 1;
    FileRemoteProtocolInfo :: FileIoPriorityHintInfo + 1;
    FileFullDirectoryInfo :: FileRemoteProtocolInfo + 1;
    FileFullDirectoryRestartInfo :: FileFullDirectoryInfo + 1;
    FileStorageInfo :: FileFullDirectoryRestartInfo + 1;
    FileAlignmentInfo :: FileStorageInfo + 1;
    FileIdInfo :: FileAlignmentInfo + 1;
    FileIdExtdDirectoryInfo :: FileIdInfo + 1;
    FileIdExtdDirectoryRestartInfo :: FileIdExtdDirectoryInfo + 1;
    FileDispositionInfoEx :: FileIdExtdDirectoryRestartInfo + 1;
    FileRenameInfoEx :: FileDispositionInfoEx + 1;
    FileCaseSensitiveInfo :: FileRenameInfoEx + 1;
    FileNormalizedNameInfo :: FileCaseSensitiveInfo + 1;
    MaximumFileInfoByHandleClass :: FileNormalizedNameInfo + 1;
/* } */
PFILE_INFO_BY_HANDLE_CLASS :: ^FILE_INFO_BY_HANDLE_CLASS;

CRITICAL_SECTION :: RTL_CRITICAL_SECTION;

PCRITICAL_SECTION :: PRTL_CRITICAL_SECTION;

LPCRITICAL_SECTION :: PRTL_CRITICAL_SECTION;

CRITICAL_SECTION_DEBUG :: RTL_CRITICAL_SECTION_DEBUG;

PCRITICAL_SECTION_DEBUG :: PRTL_CRITICAL_SECTION_DEBUG;

LPCRITICAL_SECTION_DEBUG :: PRTL_CRITICAL_SECTION_DEBUG;

LPOVERLAPPED_COMPLETION_ROUTINE :: proc "stdcall" (dwErrorCode : DWORD, dwNumberOfBytesTransfered : DWORD, lpOverlapped : LPOVERLAPPED);

PROCESS_HEAP_ENTRY :: struct {
    lpData       : PVOID,
    cbData       : DWORD,
    cbOverhead   : BYTE,
    iRegionIndex : BYTE,
    wFlags       : WORD,
    u : struct #raw_union {
        Block : struct {
            hMem       : HANDLE,
            dwReserved : [3]DWORD,
        },
        Region : struct {
            dwCommittedSize   : DWORD,
            dwUnCommittedSize : DWORD,
            lpFirstBlock      : LPVOID,
            lpLastBlock       : LPVOID,
        },
    },
};
LPPROCESS_HEAP_ENTRY :: ^PROCESS_HEAP_ENTRY;
PPROCESS_HEAP_ENTRY :: ^PROCESS_HEAP_ENTRY;

REASON_CONTEXT :: struct {
    Version : ULONG,
    Flags   : DWORD,
    Reason : struct #raw_union {
        Detailed : struct {
            LocalizedReasonModule : HMODULE,
            LocalizedReasonId     : ULONG,
            ReasonStringCount     : ULONG,
            ReasonStrings         : ^LPWSTR,
        },
        SimpleReasonString : LPWSTR,
    },
};
PREASON_CONTEXT :: ^REASON_CONTEXT;

PTHREAD_START_ROUTINE :: (proc "stdcall" (lpThreadParameter : LPVOID) -> DWORD);

LPTHREAD_START_ROUTINE :: PTHREAD_START_ROUTINE;

PENCLAVE_ROUTINE :: (proc "stdcall" (lpThreadParameter : LPVOID) -> LPVOID);

LPENCLAVE_ROUTINE :: PENCLAVE_ROUTINE;

EXCEPTION_DEBUG_INFO :: struct {
    ExceptionRecord : EXCEPTION_RECORD,
    dwFirstChance   : DWORD,
};
LPEXCEPTION_DEBUG_INFO :: ^EXCEPTION_DEBUG_INFO;

CREATE_THREAD_DEBUG_INFO :: struct {
    hThread           : HANDLE,
    lpThreadLocalBase : LPVOID,
    lpStartAddress    : LPTHREAD_START_ROUTINE,
};
LPCREATE_THREAD_DEBUG_INFO :: ^CREATE_THREAD_DEBUG_INFO;

CREATE_PROCESS_DEBUG_INFO :: struct {
    hFile                 : HANDLE,
    hProcess              : HANDLE,
    hThread               : HANDLE,
    lpBaseOfImage         : LPVOID,
    dwDebugInfoFileOffset : DWORD,
    nDebugInfoSize        : DWORD,
    lpThreadLocalBase     : LPVOID,
    lpStartAddress        : LPTHREAD_START_ROUTINE,
    lpImageName           : LPVOID,
    fUnicode              : WORD,
};
LPCREATE_PROCESS_DEBUG_INFO :: ^CREATE_PROCESS_DEBUG_INFO;

EXIT_THREAD_DEBUG_INFO :: struct {
    dwExitCode : DWORD,
};
LPEXIT_THREAD_DEBUG_INFO :: ^EXIT_THREAD_DEBUG_INFO;

EXIT_PROCESS_DEBUG_INFO :: struct {
    dwExitCode : DWORD,
};
LPEXIT_PROCESS_DEBUG_INFO :: ^EXIT_PROCESS_DEBUG_INFO;

LOAD_DLL_DEBUG_INFO :: struct {
    hFile                 : HANDLE,
    lpBaseOfDll           : LPVOID,
    dwDebugInfoFileOffset : DWORD,
    nDebugInfoSize        : DWORD,
    lpImageName           : LPVOID,
    fUnicode              : WORD,
};
LPLOAD_DLL_DEBUG_INFO :: ^LOAD_DLL_DEBUG_INFO;

UNLOAD_DLL_DEBUG_INFO :: struct {
    lpBaseOfDll : LPVOID,
};
LPUNLOAD_DLL_DEBUG_INFO :: ^UNLOAD_DLL_DEBUG_INFO;

OUTPUT_DEBUG_STRING_INFO :: struct {
    lpDebugStringData  : LPSTR,
    fUnicode           : WORD,
    nDebugStringLength : WORD,
};
LPOUTPUT_DEBUG_STRING_INFO :: ^OUTPUT_DEBUG_STRING_INFO;

RIP_INFO :: struct {
    dwError : DWORD,
    dwType  : DWORD,
};
LPRIP_INFO :: ^RIP_INFO;

DEBUG_EVENT :: struct {
    dwDebugEventCode : DWORD,
    dwProcessId      : DWORD,
    dwThreadId       : DWORD,
    u : struct #raw_union {
        Exception         : EXCEPTION_DEBUG_INFO,
        CreateThread      : CREATE_THREAD_DEBUG_INFO,
        CreateProcessInfo : CREATE_PROCESS_DEBUG_INFO,
        ExitThread        : EXIT_THREAD_DEBUG_INFO,
        ExitProcess       : EXIT_PROCESS_DEBUG_INFO,
        LoadDll           : LOAD_DLL_DEBUG_INFO,
        UnloadDll         : UNLOAD_DLL_DEBUG_INFO,
        DebugString       : OUTPUT_DEBUG_STRING_INFO,
        RipInfo           : RIP_INFO,
    },
};
LPDEBUG_EVENT :: ^DEBUG_EVENT;

LPCONTEXT :: PCONTEXT;

DISK_SPACE_INFORMATION :: struct {
    ActualTotalAllocationUnits           : ULONGLONG,
    ActualAvailableAllocationUnits       : ULONGLONG,
    ActualPoolUnavailableAllocationUnits : ULONGLONG,
    CallerTotalAllocationUnits           : ULONGLONG,
    CallerAvailableAllocationUnits       : ULONGLONG,
    CallerPoolUnavailableAllocationUnits : ULONGLONG,
    UsedAllocationUnits                  : ULONGLONG,
    TotalReservedAllocationUnits         : ULONGLONG,
    VolumeStorageReserveAllocationUnits  : ULONGLONG,
    AvailableCommittedAllocationUnits    : ULONGLONG,
    PoolAvailableAllocationUnits         : ULONGLONG,
    SectorsPerAllocationUnit             : DWORD,
    BytesPerSector                       : DWORD,
};

WIN32_FILE_ATTRIBUTE_DATA :: struct {
    dwFileAttributes : DWORD,
    ftCreationTime   : FILETIME,
    ftLastAccessTime : FILETIME,
    ftLastWriteTime  : FILETIME,
    nFileSizeHigh    : DWORD,
    nFileSizeLow     : DWORD,
};
LPWIN32_FILE_ATTRIBUTE_DATA :: ^WIN32_FILE_ATTRIBUTE_DATA;

BY_HANDLE_FILE_INFORMATION :: struct {
    dwFileAttributes     : DWORD,
    ftCreationTime       : FILETIME,
    ftLastAccessTime     : FILETIME,
    ftLastWriteTime      : FILETIME,
    dwVolumeSerialNumber : DWORD,
    nFileSizeHigh        : DWORD,
    nFileSizeLow         : DWORD,
    nNumberOfLinks       : DWORD,
    nFileIndexHigh       : DWORD,
    nFileIndexLow        : DWORD,
};
PBY_HANDLE_FILE_INFORMATION :: ^BY_HANDLE_FILE_INFORMATION;
LPBY_HANDLE_FILE_INFORMATION :: ^BY_HANDLE_FILE_INFORMATION;

CREATEFILE2_EXTENDED_PARAMETERS :: struct {
    dwSize               : DWORD,
    dwFileAttributes     : DWORD,
    dwFileFlags          : DWORD,
    dwSecurityQosFlags   : DWORD,
    lpSecurityAttributes : LPSECURITY_ATTRIBUTES,
    hTemplateFile        : HANDLE,
};
PCREATEFILE2_EXTENDED_PARAMETERS :: ^CREATEFILE2_EXTENDED_PARAMETERS;
LPCREATEFILE2_EXTENDED_PARAMETERS :: ^CREATEFILE2_EXTENDED_PARAMETERS;

/* STREAM_INFO_LEVELS :: enum { */
STREAM_INFO_LEVELS :: _c.int;
    FindStreamInfoStandard :: 0;
    FindStreamInfoMaxInfoLevel :: FindStreamInfoStandard + 1;
/* } */
;

WIN32_FIND_STREAM_DATA :: struct {
    StreamSize  : LARGE_INTEGER,
    cStreamName : [260 + 36]WCHAR,
};
PWIN32_FIND_STREAM_DATA :: ^WIN32_FIND_STREAM_DATA;

PTOP_LEVEL_EXCEPTION_FILTER :: (proc "stdcall" (ExceptionInfo : ^EXCEPTION_POINTERS) -> LONG);

LPTOP_LEVEL_EXCEPTION_FILTER :: PTOP_LEVEL_EXCEPTION_FILTER;

HEAP_SUMMARY :: struct {
    cb           : DWORD,
    cbAllocated  : SIZE_T,
    cbCommitted  : SIZE_T,
    cbReserved   : SIZE_T,
    cbMaxReserve : SIZE_T,
};
PHEAP_SUMMARY :: ^HEAP_SUMMARY;

LPHEAP_SUMMARY :: PHEAP_SUMMARY;

SRWLOCK :: RTL_SRWLOCK;
PSRWLOCK :: ^RTL_SRWLOCK;

INIT_ONCE :: RTL_RUN_ONCE;

PINIT_ONCE :: PRTL_RUN_ONCE;

LPINIT_ONCE :: PRTL_RUN_ONCE;

PINIT_ONCE_FN :: (proc "stdcall" (InitOnce : PINIT_ONCE, Parameter : PVOID, Context : ^PVOID) -> BOOL);

CONDITION_VARIABLE :: RTL_CONDITION_VARIABLE;
PCONDITION_VARIABLE :: ^RTL_CONDITION_VARIABLE;

PTIMERAPCROUTINE :: proc "stdcall" (lpArgToCompletionRoutine : LPVOID, dwTimerLowValue : DWORD, dwTimerHighValue : DWORD);

SYNCHRONIZATION_BARRIER :: RTL_BARRIER;

PSYNCHRONIZATION_BARRIER :: PRTL_BARRIER;

LPSYNCHRONIZATION_BARRIER :: PRTL_BARRIER;

PROCESS_INFORMATION :: struct {
    hProcess    : HANDLE,
    hThread     : HANDLE,
    dwProcessId : DWORD,
    dwThreadId  : DWORD,
};
PPROCESS_INFORMATION :: ^PROCESS_INFORMATION;
LPPROCESS_INFORMATION :: ^PROCESS_INFORMATION;

STARTUPINFOA :: struct {
    cb              : DWORD,
    lpReserved      : LPSTR,
    lpDesktop       : LPSTR,
    lpTitle         : LPSTR,
    dwX             : DWORD,
    dwY             : DWORD,
    dwXSize         : DWORD,
    dwYSize         : DWORD,
    dwXCountChars   : DWORD,
    dwYCountChars   : DWORD,
    dwFillAttribute : DWORD,
    dwFlags         : DWORD,
    wShowWindow     : WORD,
    cbReserved2     : WORD,
    lpReserved2     : LPBYTE,
    hStdInput       : HANDLE,
    hStdOutput      : HANDLE,
    hStdError       : HANDLE,
};
LPSTARTUPINFOA :: ^STARTUPINFOA;

STARTUPINFOW :: struct {
    cb              : DWORD,
    lpReserved      : LPWSTR,
    lpDesktop       : LPWSTR,
    lpTitle         : LPWSTR,
    dwX             : DWORD,
    dwY             : DWORD,
    dwXSize         : DWORD,
    dwYSize         : DWORD,
    dwXCountChars   : DWORD,
    dwYCountChars   : DWORD,
    dwFillAttribute : DWORD,
    dwFlags         : DWORD,
    wShowWindow     : WORD,
    cbReserved2     : WORD,
    lpReserved2     : LPBYTE,
    hStdInput       : HANDLE,
    hStdOutput      : HANDLE,
    hStdError       : HANDLE,
};
LPSTARTUPINFOW :: ^STARTUPINFOW;

STARTUPINFO :: STARTUPINFOA;

LPSTARTUPINFO :: LPSTARTUPINFOA;

PPROC_THREAD_ATTRIBUTE_LIST :: ^_PROC_THREAD_ATTRIBUTE_LIST;
LPPROC_THREAD_ATTRIBUTE_LIST :: ^_PROC_THREAD_ATTRIBUTE_LIST;

/* THREAD_INFORMATION_CLASS :: enum { */
THREAD_INFORMATION_CLASS :: _c.int;
    ThreadMemoryPriority :: 0;
    ThreadAbsoluteCpuPriority :: ThreadMemoryPriority + 1;
    ThreadDynamicCodePolicy :: ThreadAbsoluteCpuPriority + 1;
    ThreadPowerThrottling :: ThreadDynamicCodePolicy + 1;
    ThreadInformationClassMax :: ThreadPowerThrottling + 1;
/* } */
;

MEMORY_PRIORITY_INFORMATION :: struct {
    MemoryPriority : ULONG,
};
PMEMORY_PRIORITY_INFORMATION :: ^MEMORY_PRIORITY_INFORMATION;

THREAD_POWER_THROTTLING_STATE :: struct {
    Version     : ULONG,
    ControlMask : ULONG,
    StateMask   : ULONG,
};

/* PROCESS_INFORMATION_CLASS :: enum { */
PROCESS_INFORMATION_CLASS :: _c.int;
    ProcessMemoryPriority :: 0;
    ProcessMemoryExhaustionInfo :: ProcessMemoryPriority + 1;
    ProcessAppMemoryInfo :: ProcessMemoryExhaustionInfo + 1;
    ProcessInPrivateInfo :: ProcessAppMemoryInfo + 1;
    ProcessPowerThrottling :: ProcessInPrivateInfo + 1;
    ProcessReservedValue1 :: ProcessPowerThrottling + 1;
    ProcessTelemetryCoverageInfo :: ProcessReservedValue1 + 1;
    ProcessProtectionLevelInfo :: ProcessTelemetryCoverageInfo + 1;
    ProcessLeapSecondInfo :: ProcessProtectionLevelInfo + 1;
    ProcessInformationClassMax :: ProcessLeapSecondInfo + 1;
/* } */
;

APP_MEMORY_INFORMATION :: struct {
    AvailableCommit        : ULONG64,
    PrivateCommitUsage     : ULONG64,
    PeakPrivateCommitUsage : ULONG64,
    TotalCommitUsage       : ULONG64,
};
PAPP_MEMORY_INFORMATION :: ^APP_MEMORY_INFORMATION;

/* PROCESS_MEMORY_EXHAUSTION_TYPE :: enum { */
PROCESS_MEMORY_EXHAUSTION_TYPE :: _c.int;
    PMETypeFailFastOnCommitFailure :: 0;
    PMETypeMax :: PMETypeFailFastOnCommitFailure + 1;
/* } */
PPROCESS_MEMORY_EXHAUSTION_TYPE :: ^PROCESS_MEMORY_EXHAUSTION_TYPE;

PROCESS_MEMORY_EXHAUSTION_INFO :: struct {
    Version  : USHORT,
    Reserved : USHORT,
    Type     : PROCESS_MEMORY_EXHAUSTION_TYPE,
    Value    : ULONG_PTR,
};
PPROCESS_MEMORY_EXHAUSTION_INFO :: ^PROCESS_MEMORY_EXHAUSTION_INFO;

PROCESS_POWER_THROTTLING_STATE :: struct {
    Version     : ULONG,
    ControlMask : ULONG,
    StateMask   : ULONG,
};
PPROCESS_POWER_THROTTLING_STATE :: ^PROCESS_POWER_THROTTLING_STATE;

PROCESS_PROTECTION_LEVEL_INFORMATION :: struct {
    ProtectionLevel : DWORD,
};

PROCESS_LEAP_SECOND_INFO :: struct {
    Flags    : ULONG,
    Reserved : ULONG,
};
PPROCESS_LEAP_SECOND_INFO :: ^PROCESS_LEAP_SECOND_INFO;

SYSTEM_INFO :: struct {
    u : struct #raw_union {
        dwOemId : DWORD,
        s : struct {
            wProcessorArchitecture : WORD,
            wReserved              : WORD,
        },
    },
    dwPageSize                  : DWORD,
    lpMinimumApplicationAddress : LPVOID,
    lpMaximumApplicationAddress : LPVOID,
    dwActiveProcessorMask       : DWORD_PTR,
    dwNumberOfProcessors        : DWORD,
    dwProcessorType             : DWORD,
    dwAllocationGranularity     : DWORD,
    wProcessorLevel             : WORD,
    wProcessorRevision          : WORD,
};
LPSYSTEM_INFO :: ^SYSTEM_INFO;

MEMORYSTATUSEX :: struct {
    dwLength                : DWORD,
    dwMemoryLoad            : DWORD,
    ullTotalPhys            : DWORDLONG,
    ullAvailPhys            : DWORDLONG,
    ullTotalPageFile        : DWORDLONG,
    ullAvailPageFile        : DWORDLONG,
    ullTotalVirtual         : DWORDLONG,
    ullAvailVirtual         : DWORDLONG,
    ullAvailExtendedVirtual : DWORDLONG,
};
LPMEMORYSTATUSEX :: ^MEMORYSTATUSEX;

/* COMPUTER_NAME_FORMAT :: enum { */
COMPUTER_NAME_FORMAT :: _c.int;
    ComputerNameNetBIOS :: 0;
    ComputerNameDnsHostname :: ComputerNameNetBIOS + 1;
    ComputerNameDnsDomain :: ComputerNameDnsHostname + 1;
    ComputerNameDnsFullyQualified :: ComputerNameDnsDomain + 1;
    ComputerNamePhysicalNetBIOS :: ComputerNameDnsFullyQualified + 1;
    ComputerNamePhysicalDnsHostname :: ComputerNamePhysicalNetBIOS + 1;
    ComputerNamePhysicalDnsDomain :: ComputerNamePhysicalDnsHostname + 1;
    ComputerNamePhysicalDnsFullyQualified :: ComputerNamePhysicalDnsDomain + 1;
    ComputerNameMax :: ComputerNamePhysicalDnsFullyQualified + 1;
/* } */
;

/* MEMORY_RESOURCE_NOTIFICATION_TYPE :: enum { */
MEMORY_RESOURCE_NOTIFICATION_TYPE :: _c.int;
    LowMemoryResourceNotification :: 0;
    HighMemoryResourceNotification :: LowMemoryResourceNotification + 1;
/* } */
;

WIN32_MEMORY_RANGE_ENTRY :: struct {
    VirtualAddress : PVOID,
    NumberOfBytes  : SIZE_T,
};
PWIN32_MEMORY_RANGE_ENTRY :: ^WIN32_MEMORY_RANGE_ENTRY;

BAD_MEMORY_CALLBACK_ROUTINE :: #type proc "stdcall" ();

PBAD_MEMORY_CALLBACK_ROUTINE :: ^BAD_MEMORY_CALLBACK_ROUTINE;

/* OFFER_PRIORITY :: enum { */
OFFER_PRIORITY :: _c.int;
    VmOfferPriorityVeryLow :: 1;
    VmOfferPriorityLow :: VmOfferPriorityVeryLow + 1;
    VmOfferPriorityBelowNormal :: VmOfferPriorityLow + 1;
    VmOfferPriorityNormal :: VmOfferPriorityBelowNormal + 1;
/* } */
;

/* WIN32_MEMORY_INFORMATION_CLASS :: enum { */
WIN32_MEMORY_INFORMATION_CLASS :: _c.int;
    MemoryRegionInfo :: 0;
/* } */
;

WIN32_MEMORY_REGION_INFORMATION :: struct {
    AllocationBase    : PVOID,
    AllocationProtect : ULONG,
    u : struct #raw_union {
        Flags : ULONG,
        s : bit_field {
            Private        : 1,
            MappedDataFile : 1,
            MappedImage    : 1,
            MappedPageFile : 1,
            MappedPhysical : 1,
            DirectMapped   : 1,
            Reserved       : 26,
        },
    },
    RegionSize        : SIZE_T,
    CommitSize        : SIZE_T,
};

PTP_WIN32_IO_CALLBACK :: proc "stdcall" (Instance : PTP_CALLBACK_INSTANCE, Context : PVOID, Overlapped : PVOID, IoResult : ULONG, NumberOfBytesTransferred : ULONG_PTR, Io : PTP_IO);

JOBOBJECT_IO_RATE_CONTROL_INFORMATION :: struct {
    MaxIops         : LONG64,
    MaxBandwidth    : LONG64,
    ReservationIops : LONG64,
    VolumeName      : PCWSTR,
    BaseIoSize      : ULONG,
    ControlFlags    : ULONG,
};

ENUMUILANG :: struct {
    NumOfEnumUILang    : ULONG,
    SizeOfEnumUIBuffer : ULONG,
    pEnumUIBuffer      : ^LANGID,
};
PENUMUILANG :: ^ENUMUILANG;

ENUMRESLANGPROCA :: (proc "stdcall" (hModule : HMODULE, lpType : LPCSTR, lpName : LPCSTR, wLanguage : WORD, lParam : LONG_PTR) -> BOOL);

ENUMRESLANGPROCW :: (proc "stdcall" (hModule : HMODULE, lpType : LPCWSTR, lpName : LPCWSTR, wLanguage : WORD, lParam : LONG_PTR) -> BOOL);

ENUMRESNAMEPROCA :: (proc "stdcall" (hModule : HMODULE, lpType : LPCSTR, lpName : LPSTR, lParam : LONG_PTR) -> BOOL);

ENUMRESNAMEPROCW :: (proc "stdcall" (hModule : HMODULE, lpType : LPCWSTR, lpName : LPWSTR, lParam : LONG_PTR) -> BOOL);

ENUMRESTYPEPROCA :: (proc "stdcall" (hModule : HMODULE, lpType : LPSTR, lParam : LONG_PTR) -> BOOL);

ENUMRESTYPEPROCW :: (proc "stdcall" (hModule : HMODULE, lpType : LPWSTR, lParam : LONG_PTR) -> BOOL);

PGET_MODULE_HANDLE_EXA :: (proc "stdcall" (dwFlags : DWORD, lpModuleName : LPCSTR, phModule : ^HMODULE) -> BOOL);

PGET_MODULE_HANDLE_EXW :: (proc "stdcall" (dwFlags : DWORD, lpModuleName : LPCWSTR, phModule : ^HMODULE) -> BOOL);

REDIRECTION_FUNCTION_DESCRIPTOR :: struct {
    DllName           : PCSTR,
    FunctionName      : PCSTR,
    RedirectionTarget : PVOID,
};
PREDIRECTION_FUNCTION_DESCRIPTOR :: ^REDIRECTION_FUNCTION_DESCRIPTOR;

PCREDIRECTION_FUNCTION_DESCRIPTOR :: ^REDIRECTION_FUNCTION_DESCRIPTOR;

REDIRECTION_DESCRIPTOR :: struct {
    Version       : ULONG,
    FunctionCount : ULONG,
    Redirections  : PCREDIRECTION_FUNCTION_DESCRIPTOR,
};
PREDIRECTION_DESCRIPTOR :: ^REDIRECTION_DESCRIPTOR;

PCREDIRECTION_DESCRIPTOR :: ^REDIRECTION_DESCRIPTOR;

DLL_DIRECTORY_COOKIE :: PVOID;
PDLL_DIRECTORY_COOKIE :: ^PVOID;

PFIBER_START_ROUTINE :: proc "stdcall" (lpFiberParameter : LPVOID);

LPFIBER_START_ROUTINE :: PFIBER_START_ROUTINE;

PFIBER_CALLOUT_ROUTINE :: (proc "stdcall" (lpParameter : LPVOID) -> LPVOID);

LPLDT_ENTRY :: LPVOID;

COMMPROP :: struct {
    wPacketLength       : WORD,
    wPacketVersion      : WORD,
    dwServiceMask       : DWORD,
    dwReserved1         : DWORD,
    dwMaxTxQueue        : DWORD,
    dwMaxRxQueue        : DWORD,
    dwMaxBaud           : DWORD,
    dwProvSubType       : DWORD,
    dwProvCapabilities  : DWORD,
    dwSettableParams    : DWORD,
    dwSettableBaud      : DWORD,
    wSettableData       : WORD,
    wSettableStopParity : WORD,
    dwCurrentTxQueue    : DWORD,
    dwCurrentRxQueue    : DWORD,
    dwProvSpec1         : DWORD,
    dwProvSpec2         : DWORD,
    wcProvChar          : [1]WCHAR,
};
LPCOMMPROP :: ^COMMPROP;

COMSTAT :: struct {
    using _ : bit_field {
        fCtsHold  : 1,
        fDsrHold  : 1,
        fRlsdHold : 1,
        fXoffHold : 1,
        fXoffSent : 1,
        fEof      : 1,
        fTxim     : 1,
        fReserved : 25,
    },
    cbInQue   : DWORD,
    cbOutQue  : DWORD,
};
LPCOMSTAT :: ^COMSTAT;

DCB :: struct {
    DCBlength         : DWORD,
    BaudRate          : DWORD,
    using _ : bit_field {
        fBinary           : 1,
        fParity           : 1,
        fOutxCtsFlow      : 1,
        fOutxDsrFlow      : 1,
        fDtrControl       : 2,
        fDsrSensitivity   : 1,
        fTXContinueOnXoff : 1,
        fOutX             : 1,
        fInX              : 1,
        fErrorChar        : 1,
        fNull             : 1,
        fRtsControl       : 2,
        fAbortOnError     : 1,
        fDummy2           : 17,
    },
    wReserved         : WORD,
    XonLim            : WORD,
    XoffLim           : WORD,
    ByteSize          : BYTE,
    Parity            : BYTE,
    StopBits          : BYTE,
    XonChar           : _c.uchar,
    XoffChar          : _c.uchar,
    ErrorChar         : _c.uchar,
    EofChar           : _c.uchar,
    EvtChar           : _c.uchar,
    wReserved1        : WORD,
};
LPDCB :: ^DCB;

COMMTIMEOUTS :: struct {
    ReadIntervalTimeout         : DWORD,
    ReadTotalTimeoutMultiplier  : DWORD,
    ReadTotalTimeoutConstant    : DWORD,
    WriteTotalTimeoutMultiplier : DWORD,
    WriteTotalTimeoutConstant   : DWORD,
};
LPCOMMTIMEOUTS :: ^COMMTIMEOUTS;

COMMCONFIG :: struct {
    dwSize            : DWORD,
    wVersion          : WORD,
    wReserved         : WORD,
    dcb               : DCB,
    dwProviderSubType : DWORD,
    dwProviderOffset  : DWORD,
    dwProviderSize    : DWORD,
    wcProviderData    : [1]WCHAR,
};
LPCOMMCONFIG :: ^COMMCONFIG;

MEMORYSTATUS :: struct {
    dwLength        : DWORD,
    dwMemoryLoad    : DWORD,
    dwTotalPhys     : SIZE_T,
    dwAvailPhys     : SIZE_T,
    dwTotalPageFile : SIZE_T,
    dwAvailPageFile : SIZE_T,
    dwTotalVirtual  : SIZE_T,
    dwAvailVirtual  : SIZE_T,
};
LPMEMORYSTATUS :: ^MEMORYSTATUS;

JIT_DEBUG_INFO :: struct {
    dwSize                  : DWORD,
    dwProcessorArchitecture : DWORD,
    dwThreadID              : DWORD,
    dwReserved0             : DWORD,
    lpExceptionAddress      : ULONG64,
    lpExceptionRecord       : ULONG64,
    lpContextRecord         : ULONG64,
};
LPJIT_DEBUG_INFO :: ^JIT_DEBUG_INFO;

JIT_DEBUG_INFO32 :: JIT_DEBUG_INFO;
LPJIT_DEBUG_INFO32 :: ^JIT_DEBUG_INFO;

JIT_DEBUG_INFO64 :: JIT_DEBUG_INFO;
LPJIT_DEBUG_INFO64 :: ^JIT_DEBUG_INFO;

LPEXCEPTION_RECORD :: PEXCEPTION_RECORD;

LPEXCEPTION_POINTERS :: PEXCEPTION_POINTERS;

OFSTRUCT :: struct {
    cBytes     : BYTE,
    fFixedDisk : BYTE,
    nErrCode   : WORD,
    Reserved1  : WORD,
    Reserved2  : WORD,
    szPathName : [128]CHAR,
};
LPOFSTRUCT :: ^OFSTRUCT;
POFSTRUCT :: ^OFSTRUCT;

PUMS_CONTEXT :: rawptr;

PUMS_COMPLETION_LIST :: rawptr;

UMS_THREAD_INFO_CLASS :: RTL_UMS_THREAD_INFO_CLASS;
PUMS_THREAD_INFO_CLASS :: ^RTL_UMS_THREAD_INFO_CLASS;

UMS_SCHEDULER_REASON :: RTL_UMS_SCHEDULER_REASON;

PUMS_SCHEDULER_ENTRY_POINT :: PRTL_UMS_SCHEDULER_ENTRY_POINT;

UMS_SCHEDULER_STARTUP_INFO :: struct {
    UmsVersion     : ULONG,
    CompletionList : PUMS_COMPLETION_LIST,
    SchedulerProc  : PUMS_SCHEDULER_ENTRY_POINT,
    SchedulerParam : PVOID,
};
PUMS_SCHEDULER_STARTUP_INFO :: ^UMS_SCHEDULER_STARTUP_INFO;

UMS_SYSTEM_THREAD_INFORMATION :: struct {
    UmsVersion : ULONG,
    u : struct #raw_union {
        s : bit_field {
            IsUmsSchedulerThread : 1,
            IsUmsWorkerThread    : 1,
        },
        ThreadUmsFlags : ULONG,
    },
};
PUMS_SYSTEM_THREAD_INFORMATION :: ^UMS_SYSTEM_THREAD_INFORMATION;

POWER_REQUEST_CONTEXT :: REASON_CONTEXT;
PPOWER_REQUEST_CONTEXT :: ^REASON_CONTEXT;
LPPOWER_REQUEST_CONTEXT :: ^REASON_CONTEXT;

/* DEP_SYSTEM_POLICY_TYPE :: enum { */
DEP_SYSTEM_POLICY_TYPE :: _c.int;
    DEPPolicyAlwaysOff :: 0;
    DEPPolicyAlwaysOn :: DEPPolicyAlwaysOff + 1;
    DEPPolicyOptIn :: DEPPolicyAlwaysOn + 1;
    DEPPolicyOptOut :: DEPPolicyOptIn + 1;
    DEPTotalPolicyCount :: DEPPolicyOptOut + 1;
/* } */
;

PFE_EXPORT_FUNC :: (proc "stdcall" (pbData : PBYTE, pvCallbackContext : PVOID, ulLength : ULONG) -> DWORD);

PFE_IMPORT_FUNC :: (proc "stdcall" (pbData : PBYTE, pvCallbackContext : PVOID, ulLength : PULONG) -> DWORD);

WIN32_STREAM_ID :: struct {
    dwStreamId         : DWORD,
    dwStreamAttributes : DWORD,
    Size               : LARGE_INTEGER,
    dwStreamNameSize   : DWORD,
    cStreamName        : [1]WCHAR,
};
LPWIN32_STREAM_ID :: ^WIN32_STREAM_ID;

STARTUPINFOEXA :: struct {
    StartupInfo     : STARTUPINFOA,
    lpAttributeList : LPPROC_THREAD_ATTRIBUTE_LIST,
};
LPSTARTUPINFOEXA :: ^STARTUPINFOEXA;

STARTUPINFOEXW :: struct {
    StartupInfo     : STARTUPINFOW,
    lpAttributeList : LPPROC_THREAD_ATTRIBUTE_LIST,
};
LPSTARTUPINFOEXW :: ^STARTUPINFOEXW;

STARTUPINFOEX :: STARTUPINFOEXA;

LPSTARTUPINFOEX :: LPSTARTUPINFOEXA;

/* PROC_THREAD_ATTRIBUTE_NUM :: enum { */
PROC_THREAD_ATTRIBUTE_NUM :: _c.int;
    ProcThreadAttributeParentProcess :: 0;
    ProcThreadAttributeHandleList :: 2;
    ProcThreadAttributeGroupAffinity :: 3;
    ProcThreadAttributePreferredNode :: 4;
    ProcThreadAttributeIdealProcessor :: 5;
    ProcThreadAttributeUmsThread :: 6;
    ProcThreadAttributeMitigationPolicy :: 7;
    ProcThreadAttributeSecurityCapabilities :: 9;
    ProcThreadAttributeProtectionLevel :: 11;
    ProcThreadAttributeJobList :: 13;
    ProcThreadAttributeChildProcessPolicy :: 14;
    ProcThreadAttributeAllApplicationPackagesPolicy :: 15;
    ProcThreadAttributeWin32kFilter :: 16;
    ProcThreadAttributeSafeOpenPromptOriginClaim :: 17;
    ProcThreadAttributeDesktopAppPolicy :: 18;
    ProcThreadAttributePseudoConsole :: 22;
/* } */
;

PGET_SYSTEM_WOW64_DIRECTORY_A :: (proc "stdcall" (lpBuffer : LPSTR, uSize : UINT) -> UINT);

PGET_SYSTEM_WOW64_DIRECTORY_W :: (proc "stdcall" (lpBuffer : LPWSTR, uSize : UINT) -> UINT);

LPPROGRESS_ROUTINE :: (proc "stdcall" (TotalFileSize : LARGE_INTEGER, TotalBytesTransferred : LARGE_INTEGER, StreamSize : LARGE_INTEGER, StreamBytesTransferred : LARGE_INTEGER, dwStreamNumber : DWORD, dwCallbackReason : DWORD, hSourceFile : HANDLE, hDestinationFile : HANDLE, lpData : LPVOID) -> DWORD);

/* COPYFILE2_MESSAGE_TYPE :: enum { */
COPYFILE2_MESSAGE_TYPE :: _c.int;
    COPYFILE2_CALLBACK_NONE :: 0;
    COPYFILE2_CALLBACK_CHUNK_STARTED :: COPYFILE2_CALLBACK_NONE + 1;
    COPYFILE2_CALLBACK_CHUNK_FINISHED :: COPYFILE2_CALLBACK_CHUNK_STARTED + 1;
    COPYFILE2_CALLBACK_STREAM_STARTED :: COPYFILE2_CALLBACK_CHUNK_FINISHED + 1;
    COPYFILE2_CALLBACK_STREAM_FINISHED :: COPYFILE2_CALLBACK_STREAM_STARTED + 1;
    COPYFILE2_CALLBACK_POLL_CONTINUE :: COPYFILE2_CALLBACK_STREAM_FINISHED + 1;
    COPYFILE2_CALLBACK_ERROR :: COPYFILE2_CALLBACK_POLL_CONTINUE + 1;
    COPYFILE2_CALLBACK_MAX :: COPYFILE2_CALLBACK_ERROR + 1;
/* } */
;

/* COPYFILE2_MESSAGE_ACTION :: enum { */
COPYFILE2_MESSAGE_ACTION :: _c.int;
    COPYFILE2_PROGRESS_CONTINUE :: 0;
    COPYFILE2_PROGRESS_CANCEL :: COPYFILE2_PROGRESS_CONTINUE + 1;
    COPYFILE2_PROGRESS_STOP :: COPYFILE2_PROGRESS_CANCEL + 1;
    COPYFILE2_PROGRESS_QUIET :: COPYFILE2_PROGRESS_STOP + 1;
    COPYFILE2_PROGRESS_PAUSE :: COPYFILE2_PROGRESS_QUIET + 1;
/* } */
;

/* COPYFILE2_COPY_PHASE :: enum { */
COPYFILE2_COPY_PHASE :: _c.int;
    COPYFILE2_PHASE_NONE :: 0;
    COPYFILE2_PHASE_PREPARE_SOURCE :: COPYFILE2_PHASE_NONE + 1;
    COPYFILE2_PHASE_PREPARE_DEST :: COPYFILE2_PHASE_PREPARE_SOURCE + 1;
    COPYFILE2_PHASE_READ_SOURCE :: COPYFILE2_PHASE_PREPARE_DEST + 1;
    COPYFILE2_PHASE_WRITE_DESTINATION :: COPYFILE2_PHASE_READ_SOURCE + 1;
    COPYFILE2_PHASE_SERVER_COPY :: COPYFILE2_PHASE_WRITE_DESTINATION + 1;
    COPYFILE2_PHASE_NAMEGRAFT_COPY :: COPYFILE2_PHASE_SERVER_COPY + 1;
    COPYFILE2_PHASE_MAX :: COPYFILE2_PHASE_NAMEGRAFT_COPY + 1;
/* } */
;

COPYFILE2_MESSAGE :: struct {
    Type      : COPYFILE2_MESSAGE_TYPE,
    dwPadding : DWORD,
    Info : struct #raw_union {
        ChunkStarted : struct {
            dwStreamNumber   : DWORD,
            dwReserved       : DWORD,
            hSourceFile      : HANDLE,
            hDestinationFile : HANDLE,
            uliChunkNumber   : ULARGE_INTEGER,
            uliChunkSize     : ULARGE_INTEGER,
            uliStreamSize    : ULARGE_INTEGER,
            uliTotalFileSize : ULARGE_INTEGER,
        },
        ChunkFinished : struct {
            dwStreamNumber            : DWORD,
            dwFlags                   : DWORD,
            hSourceFile               : HANDLE,
            hDestinationFile          : HANDLE,
            uliChunkNumber            : ULARGE_INTEGER,
            uliChunkSize              : ULARGE_INTEGER,
            uliStreamSize             : ULARGE_INTEGER,
            uliStreamBytesTransferred : ULARGE_INTEGER,
            uliTotalFileSize          : ULARGE_INTEGER,
            uliTotalBytesTransferred  : ULARGE_INTEGER,
        },
        StreamStarted : struct {
            dwStreamNumber   : DWORD,
            dwReserved       : DWORD,
            hSourceFile      : HANDLE,
            hDestinationFile : HANDLE,
            uliStreamSize    : ULARGE_INTEGER,
            uliTotalFileSize : ULARGE_INTEGER,
        },
        StreamFinished : struct {
            dwStreamNumber            : DWORD,
            dwReserved                : DWORD,
            hSourceFile               : HANDLE,
            hDestinationFile          : HANDLE,
            uliStreamSize             : ULARGE_INTEGER,
            uliStreamBytesTransferred : ULARGE_INTEGER,
            uliTotalFileSize          : ULARGE_INTEGER,
            uliTotalBytesTransferred  : ULARGE_INTEGER,
        },
        PollContinue : struct {
            dwReserved : DWORD,
        },
        Error : struct {
            CopyPhase                 : COPYFILE2_COPY_PHASE,
            dwStreamNumber            : DWORD,
            hrFailure                 : HRESULT,
            dwReserved                : DWORD,
            uliChunkNumber            : ULARGE_INTEGER,
            uliStreamSize             : ULARGE_INTEGER,
            uliStreamBytesTransferred : ULARGE_INTEGER,
            uliTotalFileSize          : ULARGE_INTEGER,
            uliTotalBytesTransferred  : ULARGE_INTEGER,
        },
    },
};

PCOPYFILE2_PROGRESS_ROUTINE :: (proc "stdcall" (pMessage : ^COPYFILE2_MESSAGE, pvCallbackContext : PVOID) -> COPYFILE2_MESSAGE_ACTION);

COPYFILE2_EXTENDED_PARAMETERS :: struct {
    dwSize            : DWORD,
    dwCopyFlags       : DWORD,
    pfCancel          : ^BOOL,
    pProgressRoutine  : PCOPYFILE2_PROGRESS_ROUTINE,
    pvCallbackContext : PVOID,
};

EVENTLOG_FULL_INFORMATION :: struct {
    dwFull : DWORD,
};
LPEVENTLOG_FULL_INFORMATION :: ^EVENTLOG_FULL_INFORMATION;

OPERATION_ID :: ULONG;

OPERATION_START_PARAMETERS :: struct {
    Version     : ULONG,
    OperationId : OPERATION_ID,
    Flags       : ULONG,
};
POPERATION_START_PARAMETERS :: ^OPERATION_START_PARAMETERS;

OPERATION_END_PARAMETERS :: struct {
    Version     : ULONG,
    OperationId : OPERATION_ID,
    Flags       : ULONG,
};
POPERATION_END_PARAMETERS :: ^OPERATION_END_PARAMETERS;

HW_PROFILE_INFOA :: struct {
    dwDockInfo      : DWORD,
    szHwProfileGuid : [39]CHAR,
    szHwProfileName : [80]CHAR,
};
LPHW_PROFILE_INFOA :: ^HW_PROFILE_INFOA;

HW_PROFILE_INFOW :: struct {
    dwDockInfo      : DWORD,
    szHwProfileGuid : [39]WCHAR,
    szHwProfileName : [80]WCHAR,
};
LPHW_PROFILE_INFOW :: ^HW_PROFILE_INFOW;

HW_PROFILE_INFO :: HW_PROFILE_INFOA;

LPHW_PROFILE_INFO :: LPHW_PROFILE_INFOA;

TIME_ZONE_INFORMATION :: struct {
    Bias         : LONG,
    StandardName : [32]WCHAR,
    StandardDate : SYSTEMTIME,
    StandardBias : LONG,
    DaylightName : [32]WCHAR,
    DaylightDate : SYSTEMTIME,
    DaylightBias : LONG,
};
PTIME_ZONE_INFORMATION :: ^TIME_ZONE_INFORMATION;
LPTIME_ZONE_INFORMATION :: ^TIME_ZONE_INFORMATION;

DYNAMIC_TIME_ZONE_INFORMATION :: struct {
    Bias                        : LONG,
    StandardName                : [32]WCHAR,
    StandardDate                : SYSTEMTIME,
    StandardBias                : LONG,
    DaylightName                : [32]WCHAR,
    DaylightDate                : SYSTEMTIME,
    DaylightBias                : LONG,
    TimeZoneKeyName             : [128]WCHAR,
    DynamicDaylightTimeDisabled : BOOLEAN,
};
PDYNAMIC_TIME_ZONE_INFORMATION :: ^DYNAMIC_TIME_ZONE_INFORMATION;

SYSTEM_POWER_STATUS :: struct {
    ACLineStatus        : BYTE,
    BatteryFlag         : BYTE,
    BatteryLifePercent  : BYTE,
    SystemStatusFlag    : BYTE,
    BatteryLifeTime     : DWORD,
    BatteryFullLifeTime : DWORD,
};
LPSYSTEM_POWER_STATUS :: ^SYSTEM_POWER_STATUS;

ACTCTXA :: struct {
    cbSize                 : ULONG,
    dwFlags                : DWORD,
    lpSource               : LPCSTR,
    wProcessorArchitecture : USHORT,
    wLangId                : LANGID,
    lpAssemblyDirectory    : LPCSTR,
    lpResourceName         : LPCSTR,
    lpApplicationName      : LPCSTR,
    hModule                : HMODULE,
};
PACTCTXA :: ^ACTCTXA;

ACTCTXW :: struct {
    cbSize                 : ULONG,
    dwFlags                : DWORD,
    lpSource               : LPCWSTR,
    wProcessorArchitecture : USHORT,
    wLangId                : LANGID,
    lpAssemblyDirectory    : LPCWSTR,
    lpResourceName         : LPCWSTR,
    lpApplicationName      : LPCWSTR,
    hModule                : HMODULE,
};
PACTCTXW :: ^ACTCTXW;

ACTCTX :: ACTCTXA;

PACTCTX :: PACTCTXA;

PCACTCTXA :: ^ACTCTXA;

PCACTCTXW :: ^ACTCTXW;

PCACTCTX :: PCACTCTXA;

ACTCTX_SECTION_KEYED_DATA_2600 :: struct {
    cbSize                    : ULONG,
    ulDataFormatVersion       : ULONG,
    lpData                    : PVOID,
    ulLength                  : ULONG,
    lpSectionGlobalData       : PVOID,
    ulSectionGlobalDataLength : ULONG,
    lpSectionBase             : PVOID,
    ulSectionTotalLength      : ULONG,
    hActCtx                   : HANDLE,
    ulAssemblyRosterIndex     : ULONG,
};
PACTCTX_SECTION_KEYED_DATA_2600 :: ^ACTCTX_SECTION_KEYED_DATA_2600;

PCACTCTX_SECTION_KEYED_DATA_2600 :: ^ACTCTX_SECTION_KEYED_DATA_2600;

ACTCTX_SECTION_KEYED_DATA_ASSEMBLY_METADATA :: struct {
    lpInformation             : PVOID,
    lpSectionBase             : PVOID,
    ulSectionLength           : ULONG,
    lpSectionGlobalDataBase   : PVOID,
    ulSectionGlobalDataLength : ULONG,
};
PACTCTX_SECTION_KEYED_DATA_ASSEMBLY_METADATA :: ^ACTCTX_SECTION_KEYED_DATA_ASSEMBLY_METADATA;

PCACTCTX_SECTION_KEYED_DATA_ASSEMBLY_METADATA :: ^ACTCTX_SECTION_KEYED_DATA_ASSEMBLY_METADATA;

ACTCTX_SECTION_KEYED_DATA :: struct {
    cbSize                    : ULONG,
    ulDataFormatVersion       : ULONG,
    lpData                    : PVOID,
    ulLength                  : ULONG,
    lpSectionGlobalData       : PVOID,
    ulSectionGlobalDataLength : ULONG,
    lpSectionBase             : PVOID,
    ulSectionTotalLength      : ULONG,
    hActCtx                   : HANDLE,
    ulAssemblyRosterIndex     : ULONG,
    ulFlags                   : ULONG,
    AssemblyMetadata          : ACTCTX_SECTION_KEYED_DATA_ASSEMBLY_METADATA,
};
PACTCTX_SECTION_KEYED_DATA :: ^ACTCTX_SECTION_KEYED_DATA;

PCACTCTX_SECTION_KEYED_DATA :: ^ACTCTX_SECTION_KEYED_DATA;

ACTIVATION_CONTEXT_BASIC_INFORMATION :: struct {
    hActCtx : HANDLE,
    dwFlags : DWORD,
};
PACTIVATION_CONTEXT_BASIC_INFORMATION :: ^ACTIVATION_CONTEXT_BASIC_INFORMATION;

PCACTIVATION_CONTEXT_BASIC_INFORMATION :: ^ACTIVATION_CONTEXT_BASIC_INFORMATION;

PQUERYACTCTXW_FUNC :: (proc "stdcall" (dwFlags : DWORD, hActCtx : HANDLE, pvSubInstance : PVOID, ulInfoClass : ULONG, pvBuffer : PVOID, cbBuffer : SIZE_T, pcbWrittenOrRequired : ^SIZE_T) -> BOOL);

APPLICATION_RECOVERY_CALLBACK :: (proc "stdcall" (pvParameter : PVOID) -> DWORD);

FILE_BASIC_INFO :: struct {
    CreationTime   : LARGE_INTEGER,
    LastAccessTime : LARGE_INTEGER,
    LastWriteTime  : LARGE_INTEGER,
    ChangeTime     : LARGE_INTEGER,
    FileAttributes : DWORD,
};
PFILE_BASIC_INFO :: ^FILE_BASIC_INFO;

FILE_STANDARD_INFO :: struct {
    AllocationSize : LARGE_INTEGER,
    EndOfFile      : LARGE_INTEGER,
    NumberOfLinks  : DWORD,
    DeletePending  : BOOLEAN,
    Directory      : BOOLEAN,
};
PFILE_STANDARD_INFO :: ^FILE_STANDARD_INFO;

FILE_NAME_INFO :: struct {
    FileNameLength : DWORD,
    FileName       : [1]WCHAR,
};
PFILE_NAME_INFO :: ^FILE_NAME_INFO;

FILE_CASE_SENSITIVE_INFO :: struct {
    Flags : ULONG,
};
PFILE_CASE_SENSITIVE_INFO :: ^FILE_CASE_SENSITIVE_INFO;

FILE_RENAME_INFO :: struct {
    u : struct #raw_union {
        ReplaceIfExists : BOOLEAN,
        Flags           : DWORD,
    },
    RootDirectory  : HANDLE,
    FileNameLength : DWORD,
    FileName       : [1]WCHAR,
};
PFILE_RENAME_INFO :: ^FILE_RENAME_INFO;

FILE_ALLOCATION_INFO :: struct {
    AllocationSize : LARGE_INTEGER,
};
PFILE_ALLOCATION_INFO :: ^FILE_ALLOCATION_INFO;

FILE_END_OF_FILE_INFO :: struct {
    EndOfFile : LARGE_INTEGER,
};
PFILE_END_OF_FILE_INFO :: ^FILE_END_OF_FILE_INFO;

FILE_STREAM_INFO :: struct {
    NextEntryOffset      : DWORD,
    StreamNameLength     : DWORD,
    StreamSize           : LARGE_INTEGER,
    StreamAllocationSize : LARGE_INTEGER,
    StreamName           : [1]WCHAR,
};
PFILE_STREAM_INFO :: ^FILE_STREAM_INFO;

FILE_COMPRESSION_INFO :: struct {
    CompressedFileSize   : LARGE_INTEGER,
    CompressionFormat    : WORD,
    CompressionUnitShift : UCHAR,
    ChunkShift           : UCHAR,
    ClusterShift         : UCHAR,
    Reserved             : [3]UCHAR,
};
PFILE_COMPRESSION_INFO :: ^FILE_COMPRESSION_INFO;

FILE_ATTRIBUTE_TAG_INFO :: struct {
    FileAttributes : DWORD,
    ReparseTag     : DWORD,
};
PFILE_ATTRIBUTE_TAG_INFO :: ^FILE_ATTRIBUTE_TAG_INFO;

FILE_DISPOSITION_INFO :: struct {
    DeleteFileA : BOOLEAN,
};
PFILE_DISPOSITION_INFO :: ^FILE_DISPOSITION_INFO;

FILE_DISPOSITION_INFO_EX :: struct {
    Flags : DWORD,
};
PFILE_DISPOSITION_INFO_EX :: ^FILE_DISPOSITION_INFO_EX;

FILE_ID_BOTH_DIR_INFO :: struct {
    NextEntryOffset : DWORD,
    FileIndex       : DWORD,
    CreationTime    : LARGE_INTEGER,
    LastAccessTime  : LARGE_INTEGER,
    LastWriteTime   : LARGE_INTEGER,
    ChangeTime      : LARGE_INTEGER,
    EndOfFile       : LARGE_INTEGER,
    AllocationSize  : LARGE_INTEGER,
    FileAttributes  : DWORD,
    FileNameLength  : DWORD,
    EaSize          : DWORD,
    ShortNameLength : CCHAR,
    ShortName       : [12]WCHAR,
    FileId          : LARGE_INTEGER,
    FileName        : [1]WCHAR,
};
PFILE_ID_BOTH_DIR_INFO :: ^FILE_ID_BOTH_DIR_INFO;

FILE_FULL_DIR_INFO :: struct {
    NextEntryOffset : ULONG,
    FileIndex       : ULONG,
    CreationTime    : LARGE_INTEGER,
    LastAccessTime  : LARGE_INTEGER,
    LastWriteTime   : LARGE_INTEGER,
    ChangeTime      : LARGE_INTEGER,
    EndOfFile       : LARGE_INTEGER,
    AllocationSize  : LARGE_INTEGER,
    FileAttributes  : ULONG,
    FileNameLength  : ULONG,
    EaSize          : ULONG,
    FileName        : [1]WCHAR,
};
PFILE_FULL_DIR_INFO :: ^FILE_FULL_DIR_INFO;

/* PRIORITY_HINT :: enum { */
PRIORITY_HINT :: _c.int;
    IoPriorityHintVeryLow :: 0;
    IoPriorityHintLow :: IoPriorityHintVeryLow + 1;
    IoPriorityHintNormal :: IoPriorityHintLow + 1;
    MaximumIoPriorityHintType :: IoPriorityHintNormal + 1;
/* } */
;

FILE_IO_PRIORITY_HINT_INFO :: struct {
    PriorityHint : PRIORITY_HINT,
};
PFILE_IO_PRIORITY_HINT_INFO :: ^FILE_IO_PRIORITY_HINT_INFO;

FILE_ALIGNMENT_INFO :: struct {
    AlignmentRequirement : ULONG,
};
PFILE_ALIGNMENT_INFO :: ^FILE_ALIGNMENT_INFO;

FILE_STORAGE_INFO :: struct {
    LogicalBytesPerSector                                 : ULONG,
    PhysicalBytesPerSectorForAtomicity                    : ULONG,
    PhysicalBytesPerSectorForPerformance                  : ULONG,
    FileSystemEffectivePhysicalBytesPerSectorForAtomicity : ULONG,
    Flags                                                 : ULONG,
    ByteOffsetForSectorAlignment                          : ULONG,
    ByteOffsetForPartitionAlignment                       : ULONG,
};
PFILE_STORAGE_INFO :: ^FILE_STORAGE_INFO;

FILE_ID_INFO :: struct {
    VolumeSerialNumber : ULONGLONG,
    FileId             : FILE_ID_128,
};
PFILE_ID_INFO :: ^FILE_ID_INFO;

FILE_ID_EXTD_DIR_INFO :: struct {
    NextEntryOffset : ULONG,
    FileIndex       : ULONG,
    CreationTime    : LARGE_INTEGER,
    LastAccessTime  : LARGE_INTEGER,
    LastWriteTime   : LARGE_INTEGER,
    ChangeTime      : LARGE_INTEGER,
    EndOfFile       : LARGE_INTEGER,
    AllocationSize  : LARGE_INTEGER,
    FileAttributes  : ULONG,
    FileNameLength  : ULONG,
    EaSize          : ULONG,
    ReparsePointTag : ULONG,
    FileId          : FILE_ID_128,
    FileName        : [1]WCHAR,
};
PFILE_ID_EXTD_DIR_INFO :: ^FILE_ID_EXTD_DIR_INFO;

FILE_REMOTE_PROTOCOL_INFO :: struct {
    StructureVersion     : USHORT,
    StructureSize        : USHORT,
    Protocol             : ULONG,
    ProtocolMajorVersion : USHORT,
    ProtocolMinorVersion : USHORT,
    ProtocolRevision     : USHORT,
    Reserved             : USHORT,
    Flags                : ULONG,
    GenericReserved : struct {
        Reserved : [8]ULONG,
    },
    ProtocolSpecific : struct #raw_union {
        Smb2 : struct {
            Server : struct {
                Capabilities : ULONG,
            },
            Share : struct {
                Capabilities : ULONG,
                CachingFlags : ULONG,
            },
        },
        Reserved : [16]ULONG,
    },
};
PFILE_REMOTE_PROTOCOL_INFO :: ^FILE_REMOTE_PROTOCOL_INFO;

/* FILE_ID_TYPE :: enum { */
FILE_ID_TYPE :: _c.int;
    FileIdType :: 0;
    ObjectIdType :: FileIdType + 1;
    ExtendedFileIdType :: ObjectIdType + 1;
    MaximumFileIdType :: ExtendedFileIdType + 1;
/* } */
PFILE_ID_TYPE :: ^FILE_ID_TYPE;

FILE_ID_DESCRIPTOR :: struct {
    dwSize : DWORD,
    Type   : FILE_ID_TYPE,
    u : struct #raw_union {
        FileId         : LARGE_INTEGER,
        ObjectId       : GUID,
        ExtendedFileId : FILE_ID_128,
    },
};
LPFILE_ID_DESCRIPTOR :: ^FILE_ID_DESCRIPTOR;

DRAWPATRECT :: struct {
    ptPosition : POINT,
    ptSize     : POINT,
    wStyle     : WORD,
    wPattern   : WORD,
};
PDRAWPATRECT :: ^DRAWPATRECT;

PSINJECTDATA :: struct {
    DataBytes      : DWORD,
    InjectionPoint : WORD,
    PageNumber     : WORD,
};
PPSINJECTDATA :: ^PSINJECTDATA;

PSFEATURE_OUTPUT :: struct {
    bPageIndependent : BOOL,
    bSetPageDevice   : BOOL,
};
PPSFEATURE_OUTPUT :: ^PSFEATURE_OUTPUT;

PSFEATURE_CUSTPAPER :: struct {
    lOrientation  : LONG,
    lWidth        : LONG,
    lHeight       : LONG,
    lWidthOffset  : LONG,
    lHeightOffset : LONG,
};
PPSFEATURE_CUSTPAPER :: ^PSFEATURE_CUSTPAPER;

XFORM :: struct {
    eM11 : FLOAT,
    eM12 : FLOAT,
    eM21 : FLOAT,
    eM22 : FLOAT,
    eDx  : FLOAT,
    eDy  : FLOAT,
};
PXFORM :: ^XFORM;
LPXFORM :: ^XFORM;

BITMAP :: struct {
    bmType       : LONG,
    bmWidth      : LONG,
    bmHeight     : LONG,
    bmWidthBytes : LONG,
    bmPlanes     : WORD,
    bmBitsPixel  : WORD,
    bmBits       : LPVOID,
};
PBITMAP :: ^BITMAP;
NPBITMAP :: ^BITMAP;
LPBITMAP :: ^BITMAP;

RGBTRIPLE :: struct {
    rgbtBlue  : BYTE,
    rgbtGreen : BYTE,
    rgbtRed   : BYTE,
};
PRGBTRIPLE :: ^RGBTRIPLE;
NPRGBTRIPLE :: ^RGBTRIPLE;
LPRGBTRIPLE :: ^RGBTRIPLE;

RGBQUAD :: struct {
    rgbBlue     : BYTE,
    rgbGreen    : BYTE,
    rgbRed      : BYTE,
    rgbReserved : BYTE,
};

LPRGBQUAD :: ^RGBQUAD;

LCSCSTYPE :: LONG;

LCSGAMUTMATCH :: LONG;

FXPT16DOT16 :: _c.long;
LPFXPT16DOT16 :: ^_c.long;

FXPT2DOT30 :: _c.long;
LPFXPT2DOT30 :: ^_c.long;

CIEXYZ :: struct {
    ciexyzX : FXPT2DOT30,
    ciexyzY : FXPT2DOT30,
    ciexyzZ : FXPT2DOT30,
};

LPCIEXYZ :: ^CIEXYZ;

CIEXYZTRIPLE :: struct {
    ciexyzRed   : CIEXYZ,
    ciexyzGreen : CIEXYZ,
    ciexyzBlue  : CIEXYZ,
};

LPCIEXYZTRIPLE :: ^CIEXYZTRIPLE;

LOGCOLORSPACEA :: struct {
    lcsSignature  : DWORD,
    lcsVersion    : DWORD,
    lcsSize       : DWORD,
    lcsCSType     : LCSCSTYPE,
    lcsIntent     : LCSGAMUTMATCH,
    lcsEndpoints  : CIEXYZTRIPLE,
    lcsGammaRed   : DWORD,
    lcsGammaGreen : DWORD,
    lcsGammaBlue  : DWORD,
    lcsFilename   : [260]CHAR,
};
LPLOGCOLORSPACEA :: ^LOGCOLORSPACEA;

LOGCOLORSPACEW :: struct {
    lcsSignature  : DWORD,
    lcsVersion    : DWORD,
    lcsSize       : DWORD,
    lcsCSType     : LCSCSTYPE,
    lcsIntent     : LCSGAMUTMATCH,
    lcsEndpoints  : CIEXYZTRIPLE,
    lcsGammaRed   : DWORD,
    lcsGammaGreen : DWORD,
    lcsGammaBlue  : DWORD,
    lcsFilename   : [260]WCHAR,
};
LPLOGCOLORSPACEW :: ^LOGCOLORSPACEW;

LOGCOLORSPACE :: LOGCOLORSPACEA;

LPLOGCOLORSPACE :: LPLOGCOLORSPACEA;

BITMAPCOREHEADER :: struct {
    bcSize     : DWORD,
    bcWidth    : WORD,
    bcHeight   : WORD,
    bcPlanes   : WORD,
    bcBitCount : WORD,
};
LPBITMAPCOREHEADER :: ^BITMAPCOREHEADER;
PBITMAPCOREHEADER :: ^BITMAPCOREHEADER;

BITMAPINFOHEADER :: struct {
    biSize          : DWORD,
    biWidth         : LONG,
    biHeight        : LONG,
    biPlanes        : WORD,
    biBitCount      : WORD,
    biCompression   : DWORD,
    biSizeImage     : DWORD,
    biXPelsPerMeter : LONG,
    biYPelsPerMeter : LONG,
    biClrUsed       : DWORD,
    biClrImportant  : DWORD,
};
LPBITMAPINFOHEADER :: ^BITMAPINFOHEADER;
PBITMAPINFOHEADER :: ^BITMAPINFOHEADER;

BITMAPV4HEADER :: struct {
    bV4Size          : DWORD,
    bV4Width         : LONG,
    bV4Height        : LONG,
    bV4Planes        : WORD,
    bV4BitCount      : WORD,
    bV4V4Compression : DWORD,
    bV4SizeImage     : DWORD,
    bV4XPelsPerMeter : LONG,
    bV4YPelsPerMeter : LONG,
    bV4ClrUsed       : DWORD,
    bV4ClrImportant  : DWORD,
    bV4RedMask       : DWORD,
    bV4GreenMask     : DWORD,
    bV4BlueMask      : DWORD,
    bV4AlphaMask     : DWORD,
    bV4CSType        : DWORD,
    bV4Endpoints     : CIEXYZTRIPLE,
    bV4GammaRed      : DWORD,
    bV4GammaGreen    : DWORD,
    bV4GammaBlue     : DWORD,
};
LPBITMAPV4HEADER :: ^BITMAPV4HEADER;
PBITMAPV4HEADER :: ^BITMAPV4HEADER;

BITMAPV5HEADER :: struct {
    bV5Size          : DWORD,
    bV5Width         : LONG,
    bV5Height        : LONG,
    bV5Planes        : WORD,
    bV5BitCount      : WORD,
    bV5Compression   : DWORD,
    bV5SizeImage     : DWORD,
    bV5XPelsPerMeter : LONG,
    bV5YPelsPerMeter : LONG,
    bV5ClrUsed       : DWORD,
    bV5ClrImportant  : DWORD,
    bV5RedMask       : DWORD,
    bV5GreenMask     : DWORD,
    bV5BlueMask      : DWORD,
    bV5AlphaMask     : DWORD,
    bV5CSType        : DWORD,
    bV5Endpoints     : CIEXYZTRIPLE,
    bV5GammaRed      : DWORD,
    bV5GammaGreen    : DWORD,
    bV5GammaBlue     : DWORD,
    bV5Intent        : DWORD,
    bV5ProfileData   : DWORD,
    bV5ProfileSize   : DWORD,
    bV5Reserved      : DWORD,
};
LPBITMAPV5HEADER :: ^BITMAPV5HEADER;
PBITMAPV5HEADER :: ^BITMAPV5HEADER;

BITMAPINFO :: struct {
    bmiHeader : BITMAPINFOHEADER,
    bmiColors : [1]RGBQUAD,
};
LPBITMAPINFO :: ^BITMAPINFO;
PBITMAPINFO :: ^BITMAPINFO;

BITMAPCOREINFO :: struct {
    bmciHeader : BITMAPCOREHEADER,
    bmciColors : [1]RGBTRIPLE,
};
LPBITMAPCOREINFO :: ^BITMAPCOREINFO;
PBITMAPCOREINFO :: ^BITMAPCOREINFO;

BITMAPFILEHEADER :: struct {
    bfType      : WORD,
    bfSize      : DWORD,
    bfReserved1 : WORD,
    bfReserved2 : WORD,
    bfOffBits   : DWORD,
};
LPBITMAPFILEHEADER :: ^BITMAPFILEHEADER;
PBITMAPFILEHEADER :: ^BITMAPFILEHEADER;

FONTSIGNATURE :: struct {
    fsUsb : [4]DWORD,
    fsCsb : [2]DWORD,
};
PFONTSIGNATURE :: ^FONTSIGNATURE;
LPFONTSIGNATURE :: ^FONTSIGNATURE;

CHARSETINFO :: struct {
    ciCharset : UINT,
    ciACP     : UINT,
    fs        : FONTSIGNATURE,
};
PCHARSETINFO :: ^CHARSETINFO;
NPCHARSETINFO :: ^CHARSETINFO;
LPCHARSETINFO :: ^CHARSETINFO;

LOCALESIGNATURE :: struct {
    lsUsb          : [4]DWORD,
    lsCsbDefault   : [2]DWORD,
    lsCsbSupported : [2]DWORD,
};
PLOCALESIGNATURE :: ^LOCALESIGNATURE;
LPLOCALESIGNATURE :: ^LOCALESIGNATURE;

HANDLETABLE :: struct {
    objectHandle : [1]HGDIOBJ,
};
PHANDLETABLE :: ^HANDLETABLE;
LPHANDLETABLE :: ^HANDLETABLE;

METARECORD :: struct {
    rdSize     : DWORD,
    rdFunction : WORD,
    rdParm     : [1]WORD,
};

PMETARECORD :: ^METARECORD;

LPMETARECORD :: ^METARECORD;

METAFILEPICT :: struct {
    mm   : LONG,
    xExt : LONG,
    yExt : LONG,
    hMF  : HMETAFILE,
};
LPMETAFILEPICT :: ^METAFILEPICT;

METAHEADER :: struct {
    mtType         : WORD,
    mtHeaderSize   : WORD,
    mtVersion      : WORD,
    mtSize         : DWORD,
    mtNoObjects    : WORD,
    mtMaxRecord    : DWORD,
    mtNoParameters : WORD,
};

PMETAHEADER :: ^METAHEADER;

LPMETAHEADER :: ^METAHEADER;

ENHMETARECORD :: struct {
    iType : DWORD,
    nSize : DWORD,
    dParm : [1]DWORD,
};
PENHMETARECORD :: ^ENHMETARECORD;
LPENHMETARECORD :: ^ENHMETARECORD;

ENHMETAHEADER :: struct {
    iType          : DWORD,
    nSize          : DWORD,
    rclBounds      : RECTL,
    rclFrame       : RECTL,
    dSignature     : DWORD,
    nVersion       : DWORD,
    nBytes         : DWORD,
    nRecords       : DWORD,
    nHandles       : WORD,
    sReserved      : WORD,
    nDescription   : DWORD,
    offDescription : DWORD,
    nPalEntries    : DWORD,
    szlDevice      : SIZEL,
    szlMillimeters : SIZEL,
    cbPixelFormat  : DWORD,
    offPixelFormat : DWORD,
    bOpenGL        : DWORD,
    szlMicrometers : SIZEL,
};
PENHMETAHEADER :: ^ENHMETAHEADER;
LPENHMETAHEADER :: ^ENHMETAHEADER;

BCHAR :: BYTE;

TEXTMETRICA :: struct {
    tmHeight           : LONG,
    tmAscent           : LONG,
    tmDescent          : LONG,
    tmInternalLeading  : LONG,
    tmExternalLeading  : LONG,
    tmAveCharWidth     : LONG,
    tmMaxCharWidth     : LONG,
    tmWeight           : LONG,
    tmOverhang         : LONG,
    tmDigitizedAspectX : LONG,
    tmDigitizedAspectY : LONG,
    tmFirstChar        : BYTE,
    tmLastChar         : BYTE,
    tmDefaultChar      : BYTE,
    tmBreakChar        : BYTE,
    tmItalic           : BYTE,
    tmUnderlined       : BYTE,
    tmStruckOut        : BYTE,
    tmPitchAndFamily   : BYTE,
    tmCharSet          : BYTE,
};
PTEXTMETRICA :: ^TEXTMETRICA;
NPTEXTMETRICA :: ^TEXTMETRICA;
LPTEXTMETRICA :: ^TEXTMETRICA;

TEXTMETRICW :: struct {
    tmHeight           : LONG,
    tmAscent           : LONG,
    tmDescent          : LONG,
    tmInternalLeading  : LONG,
    tmExternalLeading  : LONG,
    tmAveCharWidth     : LONG,
    tmMaxCharWidth     : LONG,
    tmWeight           : LONG,
    tmOverhang         : LONG,
    tmDigitizedAspectX : LONG,
    tmDigitizedAspectY : LONG,
    tmFirstChar        : WCHAR,
    tmLastChar         : WCHAR,
    tmDefaultChar      : WCHAR,
    tmBreakChar        : WCHAR,
    tmItalic           : BYTE,
    tmUnderlined       : BYTE,
    tmStruckOut        : BYTE,
    tmPitchAndFamily   : BYTE,
    tmCharSet          : BYTE,
};
PTEXTMETRICW :: ^TEXTMETRICW;
NPTEXTMETRICW :: ^TEXTMETRICW;
LPTEXTMETRICW :: ^TEXTMETRICW;

TEXTMETRIC :: TEXTMETRICA;

PTEXTMETRIC :: PTEXTMETRICA;

NPTEXTMETRIC :: NPTEXTMETRICA;

LPTEXTMETRIC :: LPTEXTMETRICA;

NEWTEXTMETRICA :: struct {
    tmHeight           : LONG,
    tmAscent           : LONG,
    tmDescent          : LONG,
    tmInternalLeading  : LONG,
    tmExternalLeading  : LONG,
    tmAveCharWidth     : LONG,
    tmMaxCharWidth     : LONG,
    tmWeight           : LONG,
    tmOverhang         : LONG,
    tmDigitizedAspectX : LONG,
    tmDigitizedAspectY : LONG,
    tmFirstChar        : BYTE,
    tmLastChar         : BYTE,
    tmDefaultChar      : BYTE,
    tmBreakChar        : BYTE,
    tmItalic           : BYTE,
    tmUnderlined       : BYTE,
    tmStruckOut        : BYTE,
    tmPitchAndFamily   : BYTE,
    tmCharSet          : BYTE,
    ntmFlags           : DWORD,
    ntmSizeEM          : UINT,
    ntmCellHeight      : UINT,
    ntmAvgWidth        : UINT,
};
PNEWTEXTMETRICA :: ^NEWTEXTMETRICA;
NPNEWTEXTMETRICA :: ^NEWTEXTMETRICA;
LPNEWTEXTMETRICA :: ^NEWTEXTMETRICA;

NEWTEXTMETRICW :: struct {
    tmHeight           : LONG,
    tmAscent           : LONG,
    tmDescent          : LONG,
    tmInternalLeading  : LONG,
    tmExternalLeading  : LONG,
    tmAveCharWidth     : LONG,
    tmMaxCharWidth     : LONG,
    tmWeight           : LONG,
    tmOverhang         : LONG,
    tmDigitizedAspectX : LONG,
    tmDigitizedAspectY : LONG,
    tmFirstChar        : WCHAR,
    tmLastChar         : WCHAR,
    tmDefaultChar      : WCHAR,
    tmBreakChar        : WCHAR,
    tmItalic           : BYTE,
    tmUnderlined       : BYTE,
    tmStruckOut        : BYTE,
    tmPitchAndFamily   : BYTE,
    tmCharSet          : BYTE,
    ntmFlags           : DWORD,
    ntmSizeEM          : UINT,
    ntmCellHeight      : UINT,
    ntmAvgWidth        : UINT,
};
PNEWTEXTMETRICW :: ^NEWTEXTMETRICW;
NPNEWTEXTMETRICW :: ^NEWTEXTMETRICW;
LPNEWTEXTMETRICW :: ^NEWTEXTMETRICW;

NEWTEXTMETRIC :: NEWTEXTMETRICA;

PNEWTEXTMETRIC :: PNEWTEXTMETRICA;

NPNEWTEXTMETRIC :: NPNEWTEXTMETRICA;

LPNEWTEXTMETRIC :: LPNEWTEXTMETRICA;

NEWTEXTMETRICEXA :: struct {
    ntmTm      : NEWTEXTMETRICA,
    ntmFontSig : FONTSIGNATURE,
};

NEWTEXTMETRICEXW :: struct {
    ntmTm      : NEWTEXTMETRICW,
    ntmFontSig : FONTSIGNATURE,
};

NEWTEXTMETRICEX :: NEWTEXTMETRICEXA;

PELARRAY :: struct {
    paXCount : LONG,
    paYCount : LONG,
    paXExt   : LONG,
    paYExt   : LONG,
    paRGBs   : BYTE,
};
PPELARRAY :: ^PELARRAY;
NPPELARRAY :: ^PELARRAY;
LPPELARRAY :: ^PELARRAY;

LOGBRUSH :: struct {
    lbStyle : UINT,
    lbColor : COLORREF,
    lbHatch : ULONG_PTR,
};
PLOGBRUSH :: ^LOGBRUSH;
NPLOGBRUSH :: ^LOGBRUSH;
LPLOGBRUSH :: ^LOGBRUSH;

LOGBRUSH32 :: struct {
    lbStyle : UINT,
    lbColor : COLORREF,
    lbHatch : ULONG,
};
PLOGBRUSH32 :: ^LOGBRUSH32;
NPLOGBRUSH32 :: ^LOGBRUSH32;
LPLOGBRUSH32 :: ^LOGBRUSH32;

PATTERN :: LOGBRUSH;

PPATTERN :: ^PATTERN;

NPPATTERN :: ^PATTERN;

LPPATTERN :: ^PATTERN;

LOGPEN :: struct {
    lopnStyle : UINT,
    lopnWidth : POINT,
    lopnColor : COLORREF,
};
PLOGPEN :: ^LOGPEN;
NPLOGPEN :: ^LOGPEN;
LPLOGPEN :: ^LOGPEN;

EXTLOGPEN :: struct {
    elpPenStyle   : DWORD,
    elpWidth      : DWORD,
    elpBrushStyle : UINT,
    elpColor      : COLORREF,
    elpHatch      : ULONG_PTR,
    elpNumEntries : DWORD,
    elpStyleEntry : [1]DWORD,
};
PEXTLOGPEN :: ^EXTLOGPEN;
NPEXTLOGPEN :: ^EXTLOGPEN;
LPEXTLOGPEN :: ^EXTLOGPEN;

EXTLOGPEN32 :: struct {
    elpPenStyle   : DWORD,
    elpWidth      : DWORD,
    elpBrushStyle : UINT,
    elpColor      : COLORREF,
    elpHatch      : ULONG,
    elpNumEntries : DWORD,
    elpStyleEntry : [1]DWORD,
};
PEXTLOGPEN32 :: ^EXTLOGPEN32;
NPEXTLOGPEN32 :: ^EXTLOGPEN32;
LPEXTLOGPEN32 :: ^EXTLOGPEN32;

PALETTEENTRY :: struct {
    peRed   : BYTE,
    peGreen : BYTE,
    peBlue  : BYTE,
    peFlags : BYTE,
};
PPALETTEENTRY :: ^PALETTEENTRY;
LPPALETTEENTRY :: ^PALETTEENTRY;

LOGPALETTE :: struct {
    palVersion    : WORD,
    palNumEntries : WORD,
    palPalEntry   : [1]PALETTEENTRY,
};
PLOGPALETTE :: ^LOGPALETTE;
NPLOGPALETTE :: ^LOGPALETTE;
LPLOGPALETTE :: ^LOGPALETTE;

LOGFONTA :: struct {
    lfHeight         : LONG,
    lfWidth          : LONG,
    lfEscapement     : LONG,
    lfOrientation    : LONG,
    lfWeight         : LONG,
    lfItalic         : BYTE,
    lfUnderline      : BYTE,
    lfStrikeOut      : BYTE,
    lfCharSet        : BYTE,
    lfOutPrecision   : BYTE,
    lfClipPrecision  : BYTE,
    lfQuality        : BYTE,
    lfPitchAndFamily : BYTE,
    lfFaceName       : [32]CHAR,
};
PLOGFONTA :: ^LOGFONTA;
NPLOGFONTA :: ^LOGFONTA;
LPLOGFONTA :: ^LOGFONTA;

LOGFONTW :: struct {
    lfHeight         : LONG,
    lfWidth          : LONG,
    lfEscapement     : LONG,
    lfOrientation    : LONG,
    lfWeight         : LONG,
    lfItalic         : BYTE,
    lfUnderline      : BYTE,
    lfStrikeOut      : BYTE,
    lfCharSet        : BYTE,
    lfOutPrecision   : BYTE,
    lfClipPrecision  : BYTE,
    lfQuality        : BYTE,
    lfPitchAndFamily : BYTE,
    lfFaceName       : [32]WCHAR,
};
PLOGFONTW :: ^LOGFONTW;
NPLOGFONTW :: ^LOGFONTW;
LPLOGFONTW :: ^LOGFONTW;

LOGFONT :: LOGFONTA;

PLOGFONT :: PLOGFONTA;

NPLOGFONT :: NPLOGFONTA;

LPLOGFONT :: LPLOGFONTA;

ENUMLOGFONTA :: struct {
    elfLogFont  : LOGFONTA,
    elfFullName : [64]BYTE,
    elfStyle    : [32]BYTE,
};
LPENUMLOGFONTA :: ^ENUMLOGFONTA;

ENUMLOGFONTW :: struct {
    elfLogFont  : LOGFONTW,
    elfFullName : [64]WCHAR,
    elfStyle    : [32]WCHAR,
};
LPENUMLOGFONTW :: ^ENUMLOGFONTW;

ENUMLOGFONT :: ENUMLOGFONTA;

LPENUMLOGFONT :: LPENUMLOGFONTA;

ENUMLOGFONTEXA :: struct {
    elfLogFont  : LOGFONTA,
    elfFullName : [64]BYTE,
    elfStyle    : [32]BYTE,
    elfScript   : [32]BYTE,
};
LPENUMLOGFONTEXA :: ^ENUMLOGFONTEXA;

ENUMLOGFONTEXW :: struct {
    elfLogFont  : LOGFONTW,
    elfFullName : [64]WCHAR,
    elfStyle    : [32]WCHAR,
    elfScript   : [32]WCHAR,
};
LPENUMLOGFONTEXW :: ^ENUMLOGFONTEXW;

ENUMLOGFONTEX :: ENUMLOGFONTEXA;

LPENUMLOGFONTEX :: LPENUMLOGFONTEXA;

PANOSE :: struct {
    bFamilyType      : BYTE,
    bSerifStyle      : BYTE,
    bWeight          : BYTE,
    bProportion      : BYTE,
    bContrast        : BYTE,
    bStrokeVariation : BYTE,
    bArmStyle        : BYTE,
    bLetterform      : BYTE,
    bMidline         : BYTE,
    bXHeight         : BYTE,
};
LPPANOSE :: ^PANOSE;

EXTLOGFONTA :: struct {
    elfLogFont   : LOGFONTA,
    elfFullName  : [64]BYTE,
    elfStyle     : [32]BYTE,
    elfVersion   : DWORD,
    elfStyleSize : DWORD,
    elfMatch     : DWORD,
    elfReserved  : DWORD,
    elfVendorId  : [4]BYTE,
    elfCulture   : DWORD,
    elfPanose    : PANOSE,
};
PEXTLOGFONTA :: ^EXTLOGFONTA;
NPEXTLOGFONTA :: ^EXTLOGFONTA;
LPEXTLOGFONTA :: ^EXTLOGFONTA;

EXTLOGFONTW :: struct {
    elfLogFont   : LOGFONTW,
    elfFullName  : [64]WCHAR,
    elfStyle     : [32]WCHAR,
    elfVersion   : DWORD,
    elfStyleSize : DWORD,
    elfMatch     : DWORD,
    elfReserved  : DWORD,
    elfVendorId  : [4]BYTE,
    elfCulture   : DWORD,
    elfPanose    : PANOSE,
};
PEXTLOGFONTW :: ^EXTLOGFONTW;
NPEXTLOGFONTW :: ^EXTLOGFONTW;
LPEXTLOGFONTW :: ^EXTLOGFONTW;

EXTLOGFONT :: EXTLOGFONTA;

PEXTLOGFONT :: PEXTLOGFONTA;

NPEXTLOGFONT :: NPEXTLOGFONTA;

LPEXTLOGFONT :: LPEXTLOGFONTA;

DEVMODEA :: struct {
    dmDeviceName       : [32]BYTE,
    dmSpecVersion      : WORD,
    dmDriverVersion    : WORD,
    dmSize             : WORD,
    dmDriverExtra      : WORD,
    dmFields           : DWORD,
    u : struct #raw_union {
        s : struct {
            dmOrientation   : _c.short,
            dmPaperSize     : _c.short,
            dmPaperLength   : _c.short,
            dmPaperWidth    : _c.short,
            dmScale         : _c.short,
            dmCopies        : _c.short,
            dmDefaultSource : _c.short,
            dmPrintQuality  : _c.short,
        },
        s2 : struct {
            dmPosition           : POINTL,
            dmDisplayOrientation : DWORD,
            dmDisplayFixedOutput : DWORD,
        },
    },
    dmColor            : _c.short,
    dmDuplex           : _c.short,
    dmYResolution      : _c.short,
    dmTTOption         : _c.short,
    dmCollate          : _c.short,
    dmFormName         : [32]BYTE,
    dmLogPixels        : WORD,
    dmBitsPerPel       : DWORD,
    dmPelsWidth        : DWORD,
    dmPelsHeight       : DWORD,
    u2 : struct #raw_union {
        dmDisplayFlags : DWORD,
        dmNup          : DWORD,
    },
    dmDisplayFrequency : DWORD,
    dmICMMethod        : DWORD,
    dmICMIntent        : DWORD,
    dmMediaType        : DWORD,
    dmDitherType       : DWORD,
    dmReserved1        : DWORD,
    dmReserved2        : DWORD,
    dmPanningWidth     : DWORD,
    dmPanningHeight    : DWORD,
};
PDEVMODEA :: ^DEVMODEA;
NPDEVMODEA :: ^DEVMODEA;
LPDEVMODEA :: ^DEVMODEA;

DEVMODEW :: struct {
    dmDeviceName       : [32]WCHAR,
    dmSpecVersion      : WORD,
    dmDriverVersion    : WORD,
    dmSize             : WORD,
    dmDriverExtra      : WORD,
    dmFields           : DWORD,
    u : struct #raw_union {
        s : struct {
            dmOrientation   : _c.short,
            dmPaperSize     : _c.short,
            dmPaperLength   : _c.short,
            dmPaperWidth    : _c.short,
            dmScale         : _c.short,
            dmCopies        : _c.short,
            dmDefaultSource : _c.short,
            dmPrintQuality  : _c.short,
        },
        s2 : struct {
            dmPosition           : POINTL,
            dmDisplayOrientation : DWORD,
            dmDisplayFixedOutput : DWORD,
        },
    },
    dmColor            : _c.short,
    dmDuplex           : _c.short,
    dmYResolution      : _c.short,
    dmTTOption         : _c.short,
    dmCollate          : _c.short,
    dmFormName         : [32]WCHAR,
    dmLogPixels        : WORD,
    dmBitsPerPel       : DWORD,
    dmPelsWidth        : DWORD,
    dmPelsHeight       : DWORD,
    u2 : struct #raw_union {
        dmDisplayFlags : DWORD,
        dmNup          : DWORD,
    },
    dmDisplayFrequency : DWORD,
    dmICMMethod        : DWORD,
    dmICMIntent        : DWORD,
    dmMediaType        : DWORD,
    dmDitherType       : DWORD,
    dmReserved1        : DWORD,
    dmReserved2        : DWORD,
    dmPanningWidth     : DWORD,
    dmPanningHeight    : DWORD,
};
PDEVMODEW :: ^DEVMODEW;
NPDEVMODEW :: ^DEVMODEW;
LPDEVMODEW :: ^DEVMODEW;

DEVMODE :: DEVMODEA;

PDEVMODE :: PDEVMODEA;

NPDEVMODE :: NPDEVMODEA;

LPDEVMODE :: LPDEVMODEA;

DISPLAY_DEVICEA :: struct {
    cb           : DWORD,
    DeviceName   : [32]CHAR,
    DeviceString : [128]CHAR,
    StateFlags   : DWORD,
    DeviceID     : [128]CHAR,
    DeviceKey    : [128]CHAR,
};
PDISPLAY_DEVICEA :: ^DISPLAY_DEVICEA;
LPDISPLAY_DEVICEA :: ^DISPLAY_DEVICEA;

DISPLAY_DEVICEW :: struct {
    cb           : DWORD,
    DeviceName   : [32]WCHAR,
    DeviceString : [128]WCHAR,
    StateFlags   : DWORD,
    DeviceID     : [128]WCHAR,
    DeviceKey    : [128]WCHAR,
};
PDISPLAY_DEVICEW :: ^DISPLAY_DEVICEW;
LPDISPLAY_DEVICEW :: ^DISPLAY_DEVICEW;

DISPLAY_DEVICE :: DISPLAY_DEVICEA;

PDISPLAY_DEVICE :: PDISPLAY_DEVICEA;

LPDISPLAY_DEVICE :: LPDISPLAY_DEVICEA;

DISPLAYCONFIG_RATIONAL :: struct {
    Numerator   : UINT32,
    Denominator : UINT32,
};

/* DISPLAYCONFIG_VIDEO_OUTPUT_TECHNOLOGY :: enum { */
DISPLAYCONFIG_VIDEO_OUTPUT_TECHNOLOGY :: _c.int;
    DISPLAYCONFIG_OUTPUT_TECHNOLOGY_OTHER :: -1;
    DISPLAYCONFIG_OUTPUT_TECHNOLOGY_HD15 :: 0;
    DISPLAYCONFIG_OUTPUT_TECHNOLOGY_SVIDEO :: 1;
    DISPLAYCONFIG_OUTPUT_TECHNOLOGY_COMPOSITE_VIDEO :: 2;
    DISPLAYCONFIG_OUTPUT_TECHNOLOGY_COMPONENT_VIDEO :: 3;
    DISPLAYCONFIG_OUTPUT_TECHNOLOGY_DVI :: 4;
    DISPLAYCONFIG_OUTPUT_TECHNOLOGY_HDMI :: 5;
    DISPLAYCONFIG_OUTPUT_TECHNOLOGY_LVDS :: 6;
    DISPLAYCONFIG_OUTPUT_TECHNOLOGY_D_JPN :: 8;
    DISPLAYCONFIG_OUTPUT_TECHNOLOGY_SDI :: 9;
    DISPLAYCONFIG_OUTPUT_TECHNOLOGY_DISPLAYPORT_EXTERNAL :: 10;
    DISPLAYCONFIG_OUTPUT_TECHNOLOGY_DISPLAYPORT_EMBEDDED :: 11;
    DISPLAYCONFIG_OUTPUT_TECHNOLOGY_UDI_EXTERNAL :: 12;
    DISPLAYCONFIG_OUTPUT_TECHNOLOGY_UDI_EMBEDDED :: 13;
    DISPLAYCONFIG_OUTPUT_TECHNOLOGY_SDTVDONGLE :: 14;
    DISPLAYCONFIG_OUTPUT_TECHNOLOGY_MIRACAST :: 15;
    DISPLAYCONFIG_OUTPUT_TECHNOLOGY_INDIRECT_WIRED :: 16;
    DISPLAYCONFIG_OUTPUT_TECHNOLOGY_INDIRECT_VIRTUAL :: 17;
    DISPLAYCONFIG_OUTPUT_TECHNOLOGY_INTERNAL :: 0x80000000;
    DISPLAYCONFIG_OUTPUT_TECHNOLOGY_FORCE_UINT32 :: 0xFFFFFFFF;
/* } */
;

/* DISPLAYCONFIG_SCANLINE_ORDERING :: enum { */
DISPLAYCONFIG_SCANLINE_ORDERING :: _c.int;
    DISPLAYCONFIG_SCANLINE_ORDERING_UNSPECIFIED :: 0;
    DISPLAYCONFIG_SCANLINE_ORDERING_PROGRESSIVE :: 1;
    DISPLAYCONFIG_SCANLINE_ORDERING_INTERLACED :: 2;
    DISPLAYCONFIG_SCANLINE_ORDERING_INTERLACED_UPPERFIELDFIRST ::     DISPLAYCONFIG_SCANLINE_ORDERING_INTERLACED;
    DISPLAYCONFIG_SCANLINE_ORDERING_INTERLACED_LOWERFIELDFIRST :: 3;
    DISPLAYCONFIG_SCANLINE_ORDERING_FORCE_UINT32 :: 0xFFFFFFFF;
/* } */
;

DISPLAYCONFIG_2DREGION :: struct {
    cx : UINT32,
    cy : UINT32,
};

DISPLAYCONFIG_VIDEO_SIGNAL_INFO :: struct {
    pixelRate        : UINT64,
    hSyncFreq        : DISPLAYCONFIG_RATIONAL,
    vSyncFreq        : DISPLAYCONFIG_RATIONAL,
    activeSize       : DISPLAYCONFIG_2DREGION,
    totalSize        : DISPLAYCONFIG_2DREGION,
    u : struct #raw_union {
        AdditionalSignalInfo : bit_field {
            videoStandard    : 16,
            vSyncFreqDivider : 6,
            reserved         : 10,
        },
        videoStandard        : UINT32,
    },
    scanLineOrdering : DISPLAYCONFIG_SCANLINE_ORDERING,
};

/* DISPLAYCONFIG_SCALING :: enum { */
DISPLAYCONFIG_SCALING :: _c.int;
    DISPLAYCONFIG_SCALING_IDENTITY :: 1;
    DISPLAYCONFIG_SCALING_CENTERED :: 2;
    DISPLAYCONFIG_SCALING_STRETCHED :: 3;
    DISPLAYCONFIG_SCALING_ASPECTRATIOCENTEREDMAX :: 4;
    DISPLAYCONFIG_SCALING_CUSTOM :: 5;
    DISPLAYCONFIG_SCALING_PREFERRED :: 128;
    DISPLAYCONFIG_SCALING_FORCE_UINT32 :: 0xFFFFFFFF;
/* } */
;

/* DISPLAYCONFIG_ROTATION :: enum { */
DISPLAYCONFIG_ROTATION :: _c.int;
    DISPLAYCONFIG_ROTATION_IDENTITY :: 1;
    DISPLAYCONFIG_ROTATION_ROTATE90 :: 2;
    DISPLAYCONFIG_ROTATION_ROTATE180 :: 3;
    DISPLAYCONFIG_ROTATION_ROTATE270 :: 4;
    DISPLAYCONFIG_ROTATION_FORCE_UINT32 :: 0xFFFFFFFF;
/* } */
;

/* DISPLAYCONFIG_MODE_INFO_TYPE :: enum { */
DISPLAYCONFIG_MODE_INFO_TYPE :: _c.int;
    DISPLAYCONFIG_MODE_INFO_TYPE_SOURCE :: 1;
    DISPLAYCONFIG_MODE_INFO_TYPE_TARGET :: 2;
    DISPLAYCONFIG_MODE_INFO_TYPE_DESKTOP_IMAGE :: 3;
    DISPLAYCONFIG_MODE_INFO_TYPE_FORCE_UINT32 :: 0xFFFFFFFF;
/* } */
;

/* DISPLAYCONFIG_PIXELFORMAT :: enum { */
DISPLAYCONFIG_PIXELFORMAT :: _c.int;
    DISPLAYCONFIG_PIXELFORMAT_8BPP :: 1;
    DISPLAYCONFIG_PIXELFORMAT_16BPP :: 2;
    DISPLAYCONFIG_PIXELFORMAT_24BPP :: 3;
    DISPLAYCONFIG_PIXELFORMAT_32BPP :: 4;
    DISPLAYCONFIG_PIXELFORMAT_NONGDI :: 5;
    DISPLAYCONFIG_PIXELFORMAT_FORCE_UINT32 :: 0xffffffff;
/* } */
;

DISPLAYCONFIG_SOURCE_MODE :: struct {
    width       : UINT32,
    height      : UINT32,
    pixelFormat : DISPLAYCONFIG_PIXELFORMAT,
    position    : POINTL,
};

DISPLAYCONFIG_TARGET_MODE :: struct {
    targetVideoSignalInfo : DISPLAYCONFIG_VIDEO_SIGNAL_INFO,
};

DISPLAYCONFIG_DESKTOP_IMAGE_INFO :: struct {
    PathSourceSize     : POINTL,
    DesktopImageRegion : RECTL,
    DesktopImageClip   : RECTL,
};

DISPLAYCONFIG_MODE_INFO :: struct {
    infoType  : DISPLAYCONFIG_MODE_INFO_TYPE,
    id        : UINT32,
    adapterId : LUID,
    u : struct #raw_union {
        targetMode       : DISPLAYCONFIG_TARGET_MODE,
        sourceMode       : DISPLAYCONFIG_SOURCE_MODE,
        desktopImageInfo : DISPLAYCONFIG_DESKTOP_IMAGE_INFO,
    },
};

DISPLAYCONFIG_PATH_SOURCE_INFO :: struct {
    adapterId   : LUID,
    id          : UINT32,
    u : struct #raw_union {
        modeInfoIdx : UINT32,
        s : bit_field {
            cloneGroupId      : 16,
            sourceModeInfoIdx : 16,
        },
    },
    statusFlags : UINT32,
};

DISPLAYCONFIG_PATH_TARGET_INFO :: struct {
    adapterId        : LUID,
    id               : UINT32,
    u : struct #raw_union {
        modeInfoIdx : UINT32,
        s : bit_field {
            desktopModeInfoIdx : 16,
            targetModeInfoIdx  : 16,
        },
    },
    outputTechnology : DISPLAYCONFIG_VIDEO_OUTPUT_TECHNOLOGY,
    rotation         : DISPLAYCONFIG_ROTATION,
    scaling          : DISPLAYCONFIG_SCALING,
    refreshRate      : DISPLAYCONFIG_RATIONAL,
    scanLineOrdering : DISPLAYCONFIG_SCANLINE_ORDERING,
    targetAvailable  : BOOL,
    statusFlags      : UINT32,
};

DISPLAYCONFIG_PATH_INFO :: struct {
    sourceInfo : DISPLAYCONFIG_PATH_SOURCE_INFO,
    targetInfo : DISPLAYCONFIG_PATH_TARGET_INFO,
    flags      : UINT32,
};

/* DISPLAYCONFIG_TOPOLOGY_ID :: enum { */
DISPLAYCONFIG_TOPOLOGY_ID :: _c.int;
    DISPLAYCONFIG_TOPOLOGY_INTERNAL :: 0x00000001;
    DISPLAYCONFIG_TOPOLOGY_CLONE :: 0x00000002;
    DISPLAYCONFIG_TOPOLOGY_EXTEND :: 0x00000004;
    DISPLAYCONFIG_TOPOLOGY_EXTERNAL :: 0x00000008;
    DISPLAYCONFIG_TOPOLOGY_FORCE_UINT32 :: 0xFFFFFFFF;
/* } */
;

/* DISPLAYCONFIG_DEVICE_INFO_TYPE :: enum { */
DISPLAYCONFIG_DEVICE_INFO_TYPE :: _c.int;
    DISPLAYCONFIG_DEVICE_INFO_GET_SOURCE_NAME :: 1;
    DISPLAYCONFIG_DEVICE_INFO_GET_TARGET_NAME :: 2;
    DISPLAYCONFIG_DEVICE_INFO_GET_TARGET_PREFERRED_MODE :: 3;
    DISPLAYCONFIG_DEVICE_INFO_GET_ADAPTER_NAME :: 4;
    DISPLAYCONFIG_DEVICE_INFO_SET_TARGET_PERSISTENCE :: 5;
    DISPLAYCONFIG_DEVICE_INFO_GET_TARGET_BASE_TYPE :: 6;
    DISPLAYCONFIG_DEVICE_INFO_GET_SUPPORT_VIRTUAL_RESOLUTION :: 7;
    DISPLAYCONFIG_DEVICE_INFO_SET_SUPPORT_VIRTUAL_RESOLUTION :: 8;
    DISPLAYCONFIG_DEVICE_INFO_GET_ADVANCED_COLOR_INFO :: 9;
    DISPLAYCONFIG_DEVICE_INFO_SET_ADVANCED_COLOR_STATE :: 10;
    DISPLAYCONFIG_DEVICE_INFO_GET_SDR_WHITE_LEVEL :: 11;
    DISPLAYCONFIG_DEVICE_INFO_FORCE_UINT32 :: 0xFFFFFFFF;
/* } */
;

DISPLAYCONFIG_DEVICE_INFO_HEADER :: struct {
    type      : DISPLAYCONFIG_DEVICE_INFO_TYPE,
    size      : UINT32,
    adapterId : LUID,
    id        : UINT32,
};

DISPLAYCONFIG_SOURCE_DEVICE_NAME :: struct {
    header            : DISPLAYCONFIG_DEVICE_INFO_HEADER,
    viewGdiDeviceName : [32]WCHAR,
};

DISPLAYCONFIG_TARGET_DEVICE_NAME_FLAGS :: struct {
    u : struct #raw_union {
        s : bit_field {
            friendlyNameFromEdid : 1,
            friendlyNameForced   : 1,
            edidIdsValid         : 1,
            reserved             : 29,
        },
        value : UINT32,
    },
};

DISPLAYCONFIG_TARGET_DEVICE_NAME :: struct {
    header                    : DISPLAYCONFIG_DEVICE_INFO_HEADER,
    flags                     : DISPLAYCONFIG_TARGET_DEVICE_NAME_FLAGS,
    outputTechnology          : DISPLAYCONFIG_VIDEO_OUTPUT_TECHNOLOGY,
    edidManufactureId         : UINT16,
    edidProductCodeId         : UINT16,
    connectorInstance         : UINT32,
    monitorFriendlyDeviceName : [64]WCHAR,
    monitorDevicePath         : [128]WCHAR,
};

DISPLAYCONFIG_TARGET_PREFERRED_MODE :: struct {
    header     : DISPLAYCONFIG_DEVICE_INFO_HEADER,
    width      : UINT32,
    height     : UINT32,
    targetMode : DISPLAYCONFIG_TARGET_MODE,
};

DISPLAYCONFIG_ADAPTER_NAME :: struct {
    header            : DISPLAYCONFIG_DEVICE_INFO_HEADER,
    adapterDevicePath : [128]WCHAR,
};

DISPLAYCONFIG_TARGET_BASE_TYPE :: struct {
    header               : DISPLAYCONFIG_DEVICE_INFO_HEADER,
    baseOutputTechnology : DISPLAYCONFIG_VIDEO_OUTPUT_TECHNOLOGY,
};

DISPLAYCONFIG_SET_TARGET_PERSISTENCE :: struct {
    header : DISPLAYCONFIG_DEVICE_INFO_HEADER,
    u : struct #raw_union {
        s : bit_field {
            bootPersistenceOn : 1,
            reserved          : 31,
        },
        value : UINT32,
    },
};

DISPLAYCONFIG_SUPPORT_VIRTUAL_RESOLUTION :: struct {
    header : DISPLAYCONFIG_DEVICE_INFO_HEADER,
    s : struct #raw_union {
        s : bit_field {
            disableMonitorVirtualResolution : 1,
            reserved                        : 31,
        },
        value : UINT32,
    },
};

/* DISPLAYCONFIG_COLOR_ENCODING :: enum { */
DISPLAYCONFIG_COLOR_ENCODING :: _c.int;
    DISPLAYCONFIG_COLOR_ENCODING_RGB :: 0;
    DISPLAYCONFIG_COLOR_ENCODING_YCBCR444 :: 1;
    DISPLAYCONFIG_COLOR_ENCODING_YCBCR422 :: 2;
    DISPLAYCONFIG_COLOR_ENCODING_YCBCR420 :: 3;
    DISPLAYCONFIG_COLOR_ENCODING_INTENSITY :: 4;
    DISPLAYCONFIG_COLOR_ENCODING_FORCE_UINT32 :: 0xFFFFFFFF;
/* } */
;

DISPLAYCONFIG_GET_ADVANCED_COLOR_INFO :: struct {
    header              : DISPLAYCONFIG_DEVICE_INFO_HEADER,
    u : struct #raw_union {
        s : bit_field {
            advancedColorSupported     : 1,
            advancedColorEnabled       : 1,
            wideColorEnforced          : 1,
            advancedColorForceDisabled : 1,
            reserved                   : 28,
        },
        value : UINT32,
    },
    colorEncoding       : DISPLAYCONFIG_COLOR_ENCODING,
    bitsPerColorChannel : UINT32,
};

DISPLAYCONFIG_SET_ADVANCED_COLOR_STATE :: struct {
    header : DISPLAYCONFIG_DEVICE_INFO_HEADER,
    u : struct #raw_union {
        s : bit_field {
            enableAdvancedColor : 1,
            reserved            : 31,
        },
        value : UINT32,
    },
};

DISPLAYCONFIG_SDR_WHITE_LEVEL :: struct {
    header        : DISPLAYCONFIG_DEVICE_INFO_HEADER,
    SDRWhiteLevel : ULONG,
};

RGNDATAHEADER :: struct {
    dwSize   : DWORD,
    iType    : DWORD,
    nCount   : DWORD,
    nRgnSize : DWORD,
    rcBound  : RECT,
};
PRGNDATAHEADER :: ^RGNDATAHEADER;

RGNDATA :: struct {
    rdh    : RGNDATAHEADER,
    Buffer : [1]_c.uchar,
};
PRGNDATA :: ^RGNDATA;
NPRGNDATA :: ^RGNDATA;
LPRGNDATA :: ^RGNDATA;

ABC :: struct {
    abcA : _c.int,
    abcB : UINT,
    abcC : _c.int,
};
PABC :: ^ABC;
NPABC :: ^ABC;
LPABC :: ^ABC;

ABCFLOAT :: struct {
    abcfA : FLOAT,
    abcfB : FLOAT,
    abcfC : FLOAT,
};
PABCFLOAT :: ^ABCFLOAT;
NPABCFLOAT :: ^ABCFLOAT;
LPABCFLOAT :: ^ABCFLOAT;

OUTLINETEXTMETRICA :: struct {
    otmSize                : UINT,
    otmTextMetrics         : TEXTMETRICA,
    otmFiller              : BYTE,
    otmPanoseNumber        : PANOSE,
    otmfsSelection         : UINT,
    otmfsType              : UINT,
    otmsCharSlopeRise      : _c.int,
    otmsCharSlopeRun       : _c.int,
    otmItalicAngle         : _c.int,
    otmEMSquare            : UINT,
    otmAscent              : _c.int,
    otmDescent             : _c.int,
    otmLineGap             : UINT,
    otmsCapEmHeight        : UINT,
    otmsXHeight            : UINT,
    otmrcFontBox           : RECT,
    otmMacAscent           : _c.int,
    otmMacDescent          : _c.int,
    otmMacLineGap          : UINT,
    otmusMinimumPPEM       : UINT,
    otmptSubscriptSize     : POINT,
    otmptSubscriptOffset   : POINT,
    otmptSuperscriptSize   : POINT,
    otmptSuperscriptOffset : POINT,
    otmsStrikeoutSize      : UINT,
    otmsStrikeoutPosition  : _c.int,
    otmsUnderscoreSize     : _c.int,
    otmsUnderscorePosition : _c.int,
    otmpFamilyName         : PSTR,
    otmpFaceName           : PSTR,
    otmpStyleName          : PSTR,
    otmpFullName           : PSTR,
};
POUTLINETEXTMETRICA :: ^OUTLINETEXTMETRICA;
NPOUTLINETEXTMETRICA :: ^OUTLINETEXTMETRICA;
LPOUTLINETEXTMETRICA :: ^OUTLINETEXTMETRICA;

OUTLINETEXTMETRICW :: struct {
    otmSize                : UINT,
    otmTextMetrics         : TEXTMETRICW,
    otmFiller              : BYTE,
    otmPanoseNumber        : PANOSE,
    otmfsSelection         : UINT,
    otmfsType              : UINT,
    otmsCharSlopeRise      : _c.int,
    otmsCharSlopeRun       : _c.int,
    otmItalicAngle         : _c.int,
    otmEMSquare            : UINT,
    otmAscent              : _c.int,
    otmDescent             : _c.int,
    otmLineGap             : UINT,
    otmsCapEmHeight        : UINT,
    otmsXHeight            : UINT,
    otmrcFontBox           : RECT,
    otmMacAscent           : _c.int,
    otmMacDescent          : _c.int,
    otmMacLineGap          : UINT,
    otmusMinimumPPEM       : UINT,
    otmptSubscriptSize     : POINT,
    otmptSubscriptOffset   : POINT,
    otmptSuperscriptSize   : POINT,
    otmptSuperscriptOffset : POINT,
    otmsStrikeoutSize      : UINT,
    otmsStrikeoutPosition  : _c.int,
    otmsUnderscoreSize     : _c.int,
    otmsUnderscorePosition : _c.int,
    otmpFamilyName         : PSTR,
    otmpFaceName           : PSTR,
    otmpStyleName          : PSTR,
    otmpFullName           : PSTR,
};
POUTLINETEXTMETRICW :: ^OUTLINETEXTMETRICW;
NPOUTLINETEXTMETRICW :: ^OUTLINETEXTMETRICW;
LPOUTLINETEXTMETRICW :: ^OUTLINETEXTMETRICW;

OUTLINETEXTMETRIC :: OUTLINETEXTMETRICA;

POUTLINETEXTMETRIC :: POUTLINETEXTMETRICA;

NPOUTLINETEXTMETRIC :: NPOUTLINETEXTMETRICA;

LPOUTLINETEXTMETRIC :: LPOUTLINETEXTMETRICA;

POLYTEXTA :: struct {
    x       : _c.int,
    y       : _c.int,
    n       : UINT,
    lpstr   : LPCSTR,
    uiFlags : UINT,
    rcl     : RECT,
    pdx     : ^_c.int,
};
PPOLYTEXTA :: ^POLYTEXTA;
NPPOLYTEXTA :: ^POLYTEXTA;
LPPOLYTEXTA :: ^POLYTEXTA;

POLYTEXTW :: struct {
    x       : _c.int,
    y       : _c.int,
    n       : UINT,
    lpstr   : LPCWSTR,
    uiFlags : UINT,
    rcl     : RECT,
    pdx     : ^_c.int,
};
PPOLYTEXTW :: ^POLYTEXTW;
NPPOLYTEXTW :: ^POLYTEXTW;
LPPOLYTEXTW :: ^POLYTEXTW;

POLYTEXT :: POLYTEXTA;

PPOLYTEXT :: PPOLYTEXTA;

NPPOLYTEXT :: NPPOLYTEXTA;

LPPOLYTEXT :: LPPOLYTEXTA;

FIXED :: struct {
    fract : WORD,
    value : _c.short,
};

MAT2 :: struct {
    eM11 : FIXED,
    eM12 : FIXED,
    eM21 : FIXED,
    eM22 : FIXED,
};
LPMAT2 :: ^MAT2;

GLYPHMETRICS :: struct {
    gmBlackBoxX     : UINT,
    gmBlackBoxY     : UINT,
    gmptGlyphOrigin : POINT,
    gmCellIncX      : _c.short,
    gmCellIncY      : _c.short,
};
LPGLYPHMETRICS :: ^GLYPHMETRICS;

POINTFX :: struct {
    x : FIXED,
    y : FIXED,
};
LPPOINTFX :: ^POINTFX;

TTPOLYCURVE :: struct {
    wType : WORD,
    cpfx  : WORD,
    apfx  : [1]POINTFX,
};
LPTTPOLYCURVE :: ^TTPOLYCURVE;

TTPOLYGONHEADER :: struct {
    cb       : DWORD,
    dwType   : DWORD,
    pfxStart : POINTFX,
};
LPTTPOLYGONHEADER :: ^TTPOLYGONHEADER;

GCP_RESULTSA :: struct {
    lStructSize : DWORD,
    lpOutString : LPSTR,
    lpOrder     : ^UINT,
    lpDx        : ^_c.int,
    lpCaretPos  : ^_c.int,
    lpClass     : LPSTR,
    lpGlyphs    : LPWSTR,
    nGlyphs     : UINT,
    nMaxFit     : _c.int,
};
LPGCP_RESULTSA :: ^GCP_RESULTSA;

GCP_RESULTSW :: struct {
    lStructSize : DWORD,
    lpOutString : LPWSTR,
    lpOrder     : ^UINT,
    lpDx        : ^_c.int,
    lpCaretPos  : ^_c.int,
    lpClass     : LPSTR,
    lpGlyphs    : LPWSTR,
    nGlyphs     : UINT,
    nMaxFit     : _c.int,
};
LPGCP_RESULTSW :: ^GCP_RESULTSW;

GCP_RESULTS :: GCP_RESULTSA;

LPGCP_RESULTS :: LPGCP_RESULTSA;

RASTERIZER_STATUS :: struct {
    nSize       : _c.short,
    wFlags      : _c.short,
    nLanguageID : _c.short,
};
LPRASTERIZER_STATUS :: ^RASTERIZER_STATUS;

PIXELFORMATDESCRIPTOR :: struct {
    nSize           : WORD,
    nVersion        : WORD,
    dwFlags         : DWORD,
    iPixelType      : BYTE,
    cColorBits      : BYTE,
    cRedBits        : BYTE,
    cRedShift       : BYTE,
    cGreenBits      : BYTE,
    cGreenShift     : BYTE,
    cBlueBits       : BYTE,
    cBlueShift      : BYTE,
    cAlphaBits      : BYTE,
    cAlphaShift     : BYTE,
    cAccumBits      : BYTE,
    cAccumRedBits   : BYTE,
    cAccumGreenBits : BYTE,
    cAccumBlueBits  : BYTE,
    cAccumAlphaBits : BYTE,
    cDepthBits      : BYTE,
    cStencilBits    : BYTE,
    cAuxBuffers     : BYTE,
    iLayerType      : BYTE,
    bReserved       : BYTE,
    dwLayerMask     : DWORD,
    dwVisibleMask   : DWORD,
    dwDamageMask    : DWORD,
};
PPIXELFORMATDESCRIPTOR :: ^PIXELFORMATDESCRIPTOR;
LPPIXELFORMATDESCRIPTOR :: ^PIXELFORMATDESCRIPTOR;

OLDFONTENUMPROCA :: (proc "stdcall" (^LOGFONTA, ^TEXTMETRICA, DWORD, LPARAM) -> _c.int);

OLDFONTENUMPROCW :: (proc "stdcall" (^LOGFONTW, ^TEXTMETRICW, DWORD, LPARAM) -> _c.int);

FONTENUMPROCA :: OLDFONTENUMPROCA;

FONTENUMPROCW :: OLDFONTENUMPROCW;

FONTENUMPROC :: FONTENUMPROCA;

GOBJENUMPROC :: (proc "stdcall" (LPVOID, LPARAM) -> _c.int);

LINEDDAPROC :: proc "stdcall" (_c.int, _c.int, LPARAM);

LPFNDEVMODE :: (proc "stdcall" (HWND, HMODULE, LPDEVMODE, LPSTR, LPSTR, LPDEVMODE, LPSTR, UINT) -> UINT);

LPFNDEVCAPS :: (proc "stdcall" (LPSTR, LPSTR, UINT, LPSTR, LPDEVMODE) -> DWORD);

WCRANGE :: struct {
    wcLow   : WCHAR,
    cGlyphs : USHORT,
};
PWCRANGE :: ^WCRANGE;
LPWCRANGE :: ^WCRANGE;

GLYPHSET :: struct {
    cbThis           : DWORD,
    flAccel          : DWORD,
    cGlyphsSupported : DWORD,
    cRanges          : DWORD,
    ranges           : [1]WCRANGE,
};
PGLYPHSET :: ^GLYPHSET;
LPGLYPHSET :: ^GLYPHSET;

DESIGNVECTOR :: struct {
    dvReserved : DWORD,
    dvNumAxes  : DWORD,
    dvValues   : [16]LONG,
};
PDESIGNVECTOR :: ^DESIGNVECTOR;
LPDESIGNVECTOR :: ^DESIGNVECTOR;

AXISINFOA :: struct {
    axMinValue : LONG,
    axMaxValue : LONG,
    axAxisName : [16]BYTE,
};
PAXISINFOA :: ^AXISINFOA;
LPAXISINFOA :: ^AXISINFOA;

AXISINFOW :: struct {
    axMinValue : LONG,
    axMaxValue : LONG,
    axAxisName : [16]WCHAR,
};
PAXISINFOW :: ^AXISINFOW;
LPAXISINFOW :: ^AXISINFOW;

AXISINFO :: AXISINFOA;

PAXISINFO :: PAXISINFOA;

LPAXISINFO :: LPAXISINFOA;

AXESLISTA :: struct {
    axlReserved : DWORD,
    axlNumAxes  : DWORD,
    axlAxisInfo : [16]AXISINFOA,
};
PAXESLISTA :: ^AXESLISTA;
LPAXESLISTA :: ^AXESLISTA;

AXESLISTW :: struct {
    axlReserved : DWORD,
    axlNumAxes  : DWORD,
    axlAxisInfo : [16]AXISINFOW,
};
PAXESLISTW :: ^AXESLISTW;
LPAXESLISTW :: ^AXESLISTW;

AXESLIST :: AXESLISTA;

PAXESLIST :: PAXESLISTA;

LPAXESLIST :: LPAXESLISTA;

ENUMLOGFONTEXDVA :: struct {
    elfEnumLogfontEx : ENUMLOGFONTEXA,
    elfDesignVector  : DESIGNVECTOR,
};
PENUMLOGFONTEXDVA :: ^ENUMLOGFONTEXDVA;
LPENUMLOGFONTEXDVA :: ^ENUMLOGFONTEXDVA;

ENUMLOGFONTEXDVW :: struct {
    elfEnumLogfontEx : ENUMLOGFONTEXW,
    elfDesignVector  : DESIGNVECTOR,
};
PENUMLOGFONTEXDVW :: ^ENUMLOGFONTEXDVW;
LPENUMLOGFONTEXDVW :: ^ENUMLOGFONTEXDVW;

ENUMLOGFONTEXDV :: ENUMLOGFONTEXDVA;

PENUMLOGFONTEXDV :: PENUMLOGFONTEXDVA;

LPENUMLOGFONTEXDV :: LPENUMLOGFONTEXDVA;

ENUMTEXTMETRICA :: struct {
    etmNewTextMetricEx : NEWTEXTMETRICEXA,
    etmAxesList        : AXESLISTA,
};
PENUMTEXTMETRICA :: ^ENUMTEXTMETRICA;
LPENUMTEXTMETRICA :: ^ENUMTEXTMETRICA;

ENUMTEXTMETRICW :: struct {
    etmNewTextMetricEx : NEWTEXTMETRICEXW,
    etmAxesList        : AXESLISTW,
};
PENUMTEXTMETRICW :: ^ENUMTEXTMETRICW;
LPENUMTEXTMETRICW :: ^ENUMTEXTMETRICW;

ENUMTEXTMETRIC :: ENUMTEXTMETRICA;

PENUMTEXTMETRIC :: PENUMTEXTMETRICA;

LPENUMTEXTMETRIC :: LPENUMTEXTMETRICA;

COLOR16 :: USHORT;

TRIVERTEX :: struct {
    x     : LONG,
    y     : LONG,
    Red   : COLOR16,
    Green : COLOR16,
    Blue  : COLOR16,
    Alpha : COLOR16,
};
PTRIVERTEX :: ^TRIVERTEX;
LPTRIVERTEX :: ^TRIVERTEX;

GRADIENT_TRIANGLE :: struct {
    Vertex1 : ULONG,
    Vertex2 : ULONG,
    Vertex3 : ULONG,
};
PGRADIENT_TRIANGLE :: ^GRADIENT_TRIANGLE;
LPGRADIENT_TRIANGLE :: ^GRADIENT_TRIANGLE;

GRADIENT_RECT :: struct {
    UpperLeft  : ULONG,
    LowerRight : ULONG,
};
PGRADIENT_RECT :: ^GRADIENT_RECT;
LPGRADIENT_RECT :: ^GRADIENT_RECT;

BLENDFUNCTION :: struct {
    BlendOp             : BYTE,
    BlendFlags          : BYTE,
    SourceConstantAlpha : BYTE,
    AlphaFormat         : BYTE,
};
PBLENDFUNCTION :: ^BLENDFUNCTION;

MFENUMPROC :: (proc "stdcall" (hdc : HDC, lpht : ^HANDLETABLE, lpMR : ^METARECORD, nObj : _c.int, param : LPARAM) -> _c.int);

ENHMFENUMPROC :: (proc "stdcall" (hdc : HDC, lpht : ^HANDLETABLE, lpmr : ^ENHMETARECORD, nHandles : _c.int, data : LPARAM) -> _c.int);

DIBSECTION :: struct {
    dsBm        : BITMAP,
    dsBmih      : BITMAPINFOHEADER,
    dsBitfields : [3]DWORD,
    dshSection  : HANDLE,
    dsOffset    : DWORD,
};
LPDIBSECTION :: ^DIBSECTION;
PDIBSECTION :: ^DIBSECTION;

COLORADJUSTMENT :: struct {
    caSize            : WORD,
    caFlags           : WORD,
    caIlluminantIndex : WORD,
    caRedGamma        : WORD,
    caGreenGamma      : WORD,
    caBlueGamma       : WORD,
    caReferenceBlack  : WORD,
    caReferenceWhite  : WORD,
    caContrast        : SHORT,
    caBrightness      : SHORT,
    caColorfulness    : SHORT,
    caRedGreenTint    : SHORT,
};
PCOLORADJUSTMENT :: ^COLORADJUSTMENT;
LPCOLORADJUSTMENT :: ^COLORADJUSTMENT;

ABORTPROC :: (proc "stdcall" (HDC, _c.int) -> BOOL);

DOCINFOA :: struct {
    cbSize       : _c.int,
    lpszDocName  : LPCSTR,
    lpszOutput   : LPCSTR,
    lpszDatatype : LPCSTR,
    fwType       : DWORD,
};
LPDOCINFOA :: ^DOCINFOA;

DOCINFOW :: struct {
    cbSize       : _c.int,
    lpszDocName  : LPCWSTR,
    lpszOutput   : LPCWSTR,
    lpszDatatype : LPCWSTR,
    fwType       : DWORD,
};
LPDOCINFOW :: ^DOCINFOW;

DOCINFO :: DOCINFOA;

LPDOCINFO :: LPDOCINFOA;

KERNINGPAIR :: struct {
    wFirst      : WORD,
    wSecond     : WORD,
    iKernAmount : _c.int,
};
LPKERNINGPAIR :: ^KERNINGPAIR;

ICMENUMPROCA :: (proc "stdcall" (LPSTR, LPARAM) -> _c.int);

ICMENUMPROCW :: (proc "stdcall" (LPWSTR, LPARAM) -> _c.int);

EMR :: struct {
    iType : DWORD,
    nSize : DWORD,
};
PEMR :: ^EMR;

EMRTEXT :: struct {
    ptlReference : POINTL,
    nChars       : DWORD,
    offString    : DWORD,
    fOptions     : DWORD,
    rcl          : RECTL,
    offDx        : DWORD,
};
PEMRTEXT :: ^EMRTEXT;

EMRABORTPATH :: struct {
    emr : EMR,
};
PEMRABORTPATH :: ^EMRABORTPATH;
EMRBEGINPATH :: struct {
    emr : EMR,
};
PEMRBEGINPATH :: ^EMRBEGINPATH;
EMRENDPATH :: struct {
    emr : EMR,
};
PEMRENDPATH :: ^EMRENDPATH;
EMRCLOSEFIGURE :: struct {
    emr : EMR,
};
PEMRCLOSEFIGURE :: ^EMRCLOSEFIGURE;
EMRFLATTENPATH :: struct {
    emr : EMR,
};
PEMRFLATTENPATH :: ^EMRFLATTENPATH;
EMRWIDENPATH :: struct {
    emr : EMR,
};
PEMRWIDENPATH :: ^EMRWIDENPATH;
EMRSETMETARGN :: struct {
    emr : EMR,
};
PEMRSETMETARGN :: ^EMRSETMETARGN;
EMRSAVEDC :: struct {
    emr : EMR,
};
PEMRSAVEDC :: ^EMRSAVEDC;
EMRREALIZEPALETTE :: struct {
    emr : EMR,
};
PEMRREALIZEPALETTE :: ^EMRREALIZEPALETTE;

EMRSELECTCLIPPATH :: struct {
    emr   : EMR,
    iMode : DWORD,
};
PEMRSELECTCLIPPATH :: ^EMRSELECTCLIPPATH;
EMRSETBKMODE :: struct {
    emr   : EMR,
    iMode : DWORD,
};
PEMRSETBKMODE :: ^EMRSETBKMODE;
EMRSETMAPMODE :: struct {
    emr   : EMR,
    iMode : DWORD,
};
PEMRSETMAPMODE :: ^EMRSETMAPMODE;
EMRSETLAYOUT :: struct {
    emr   : EMR,
    iMode : DWORD,
};
PEMRSETLAYOUT :: ^EMRSETLAYOUT;
EMRSETPOLYFILLMODE :: struct {
    emr   : EMR,
    iMode : DWORD,
};
PEMRSETPOLYFILLMODE :: ^EMRSETPOLYFILLMODE;
EMRSETROP2 :: struct {
    emr   : EMR,
    iMode : DWORD,
};
PEMRSETROP2 :: ^EMRSETROP2;
EMRSETSTRETCHBLTMODE :: struct {
    emr   : EMR,
    iMode : DWORD,
};
PEMRSETSTRETCHBLTMODE :: ^EMRSETSTRETCHBLTMODE;
EMRSETICMMODE :: struct {
    emr   : EMR,
    iMode : DWORD,
};
PEMRSETICMMODE :: ^EMRSETICMMODE;
EMRSETTEXTALIGN :: struct {
    emr   : EMR,
    iMode : DWORD,
};
PEMRSETTEXTALIGN :: ^EMRSETTEXTALIGN;

EMRSETMITERLIMIT :: struct {
    emr         : EMR,
    eMiterLimit : FLOAT,
};
PEMRSETMITERLIMIT :: ^EMRSETMITERLIMIT;

EMRRESTOREDC :: struct {
    emr       : EMR,
    iRelative : LONG,
};
PEMRRESTOREDC :: ^EMRRESTOREDC;

EMRSETARCDIRECTION :: struct {
    emr           : EMR,
    iArcDirection : DWORD,
};
PEMRSETARCDIRECTION :: ^EMRSETARCDIRECTION;

EMRSETMAPPERFLAGS :: struct {
    emr     : EMR,
    dwFlags : DWORD,
};
PEMRSETMAPPERFLAGS :: ^EMRSETMAPPERFLAGS;

EMRSETBKCOLOR :: struct {
    emr     : EMR,
    crColor : COLORREF,
};
PEMRSETBKCOLOR :: ^EMRSETBKCOLOR;
EMRSETTEXTCOLOR :: struct {
    emr     : EMR,
    crColor : COLORREF,
};
PEMRSETTEXTCOLOR :: ^EMRSETTEXTCOLOR;

EMRSELECTOBJECT :: struct {
    emr      : EMR,
    ihObject : DWORD,
};
PEMRSELECTOBJECT :: ^EMRSELECTOBJECT;
EMRDELETEOBJECT :: struct {
    emr      : EMR,
    ihObject : DWORD,
};
PEMRDELETEOBJECT :: ^EMRDELETEOBJECT;

EMRSELECTPALETTE :: struct {
    emr   : EMR,
    ihPal : DWORD,
};
PEMRSELECTPALETTE :: ^EMRSELECTPALETTE;

EMRRESIZEPALETTE :: struct {
    emr      : EMR,
    ihPal    : DWORD,
    cEntries : DWORD,
};
PEMRRESIZEPALETTE :: ^EMRRESIZEPALETTE;

EMRSETPALETTEENTRIES :: struct {
    emr         : EMR,
    ihPal       : DWORD,
    iStart      : DWORD,
    cEntries    : DWORD,
    aPalEntries : [1]PALETTEENTRY,
};
PEMRSETPALETTEENTRIES :: ^EMRSETPALETTEENTRIES;

EMRSETCOLORADJUSTMENT :: struct {
    emr             : EMR,
    ColorAdjustment : COLORADJUSTMENT,
};
PEMRSETCOLORADJUSTMENT :: ^EMRSETCOLORADJUSTMENT;

EMRGDICOMMENT :: struct {
    emr    : EMR,
    cbData : DWORD,
    Data   : [1]BYTE,
};
PEMRGDICOMMENT :: ^EMRGDICOMMENT;

EMREOF :: struct {
    emr           : EMR,
    nPalEntries   : DWORD,
    offPalEntries : DWORD,
    nSizeLast     : DWORD,
};
PEMREOF :: ^EMREOF;

EMRLINETO :: struct {
    emr : EMR,
    ptl : POINTL,
};
PEMRLINETO :: ^EMRLINETO;
EMRMOVETOEX :: struct {
    emr : EMR,
    ptl : POINTL,
};
PEMRMOVETOEX :: ^EMRMOVETOEX;

EMROFFSETCLIPRGN :: struct {
    emr       : EMR,
    ptlOffset : POINTL,
};
PEMROFFSETCLIPRGN :: ^EMROFFSETCLIPRGN;

EMRFILLPATH :: struct {
    emr       : EMR,
    rclBounds : RECTL,
};
PEMRFILLPATH :: ^EMRFILLPATH;
EMRSTROKEANDFILLPATH :: struct {
    emr       : EMR,
    rclBounds : RECTL,
};
PEMRSTROKEANDFILLPATH :: ^EMRSTROKEANDFILLPATH;
EMRSTROKEPATH :: struct {
    emr       : EMR,
    rclBounds : RECTL,
};
PEMRSTROKEPATH :: ^EMRSTROKEPATH;

EMREXCLUDECLIPRECT :: struct {
    emr     : EMR,
    rclClip : RECTL,
};
PEMREXCLUDECLIPRECT :: ^EMREXCLUDECLIPRECT;
EMRINTERSECTCLIPRECT :: struct {
    emr     : EMR,
    rclClip : RECTL,
};
PEMRINTERSECTCLIPRECT :: ^EMRINTERSECTCLIPRECT;

EMRSETVIEWPORTORGEX :: struct {
    emr       : EMR,
    ptlOrigin : POINTL,
};
PEMRSETVIEWPORTORGEX :: ^EMRSETVIEWPORTORGEX;
EMRSETWINDOWORGEX :: struct {
    emr       : EMR,
    ptlOrigin : POINTL,
};
PEMRSETWINDOWORGEX :: ^EMRSETWINDOWORGEX;
EMRSETBRUSHORGEX :: struct {
    emr       : EMR,
    ptlOrigin : POINTL,
};
PEMRSETBRUSHORGEX :: ^EMRSETBRUSHORGEX;

EMRSETVIEWPORTEXTEX :: struct {
    emr       : EMR,
    szlExtent : SIZEL,
};
PEMRSETVIEWPORTEXTEX :: ^EMRSETVIEWPORTEXTEX;
EMRSETWINDOWEXTEX :: struct {
    emr       : EMR,
    szlExtent : SIZEL,
};
PEMRSETWINDOWEXTEX :: ^EMRSETWINDOWEXTEX;

EMRSCALEVIEWPORTEXTEX :: struct {
    emr    : EMR,
    xNum   : LONG,
    xDenom : LONG,
    yNum   : LONG,
    yDenom : LONG,
};
PEMRSCALEVIEWPORTEXTEX :: ^EMRSCALEVIEWPORTEXTEX;
EMRSCALEWINDOWEXTEX :: struct {
    emr    : EMR,
    xNum   : LONG,
    xDenom : LONG,
    yNum   : LONG,
    yDenom : LONG,
};
PEMRSCALEWINDOWEXTEX :: ^EMRSCALEWINDOWEXTEX;

EMRSETWORLDTRANSFORM :: struct {
    emr   : EMR,
    xform : XFORM,
};
PEMRSETWORLDTRANSFORM :: ^EMRSETWORLDTRANSFORM;

EMRMODIFYWORLDTRANSFORM :: struct {
    emr   : EMR,
    xform : XFORM,
    iMode : DWORD,
};
PEMRMODIFYWORLDTRANSFORM :: ^EMRMODIFYWORLDTRANSFORM;

EMRSETPIXELV :: struct {
    emr      : EMR,
    ptlPixel : POINTL,
    crColor  : COLORREF,
};
PEMRSETPIXELV :: ^EMRSETPIXELV;

EMREXTFLOODFILL :: struct {
    emr      : EMR,
    ptlStart : POINTL,
    crColor  : COLORREF,
    iMode    : DWORD,
};
PEMREXTFLOODFILL :: ^EMREXTFLOODFILL;

EMRELLIPSE :: struct {
    emr    : EMR,
    rclBox : RECTL,
};
PEMRELLIPSE :: ^EMRELLIPSE;
EMRRECTANGLE :: struct {
    emr    : EMR,
    rclBox : RECTL,
};
PEMRRECTANGLE :: ^EMRRECTANGLE;

EMRROUNDRECT :: struct {
    emr       : EMR,
    rclBox    : RECTL,
    szlCorner : SIZEL,
};
PEMRROUNDRECT :: ^EMRROUNDRECT;

EMRARC :: struct {
    emr      : EMR,
    rclBox   : RECTL,
    ptlStart : POINTL,
    ptlEnd   : POINTL,
};
PEMRARC :: ^EMRARC;
EMRARCTO :: struct {
    emr      : EMR,
    rclBox   : RECTL,
    ptlStart : POINTL,
    ptlEnd   : POINTL,
};
PEMRARCTO :: ^EMRARCTO;
EMRCHORD :: struct {
    emr      : EMR,
    rclBox   : RECTL,
    ptlStart : POINTL,
    ptlEnd   : POINTL,
};
PEMRCHORD :: ^EMRCHORD;
EMRPIE :: struct {
    emr      : EMR,
    rclBox   : RECTL,
    ptlStart : POINTL,
    ptlEnd   : POINTL,
};
PEMRPIE :: ^EMRPIE;

EMRANGLEARC :: struct {
    emr         : EMR,
    ptlCenter   : POINTL,
    nRadius     : DWORD,
    eStartAngle : FLOAT,
    eSweepAngle : FLOAT,
};
PEMRANGLEARC :: ^EMRANGLEARC;

EMRPOLYLINE :: struct {
    emr       : EMR,
    rclBounds : RECTL,
    cptl      : DWORD,
    aptl      : [1]POINTL,
};
PEMRPOLYLINE :: ^EMRPOLYLINE;
EMRPOLYBEZIER :: struct {
    emr       : EMR,
    rclBounds : RECTL,
    cptl      : DWORD,
    aptl      : [1]POINTL,
};
PEMRPOLYBEZIER :: ^EMRPOLYBEZIER;
EMRPOLYGON :: struct {
    emr       : EMR,
    rclBounds : RECTL,
    cptl      : DWORD,
    aptl      : [1]POINTL,
};
PEMRPOLYGON :: ^EMRPOLYGON;
EMRPOLYBEZIERTO :: struct {
    emr       : EMR,
    rclBounds : RECTL,
    cptl      : DWORD,
    aptl      : [1]POINTL,
};
PEMRPOLYBEZIERTO :: ^EMRPOLYBEZIERTO;
EMRPOLYLINETO :: struct {
    emr       : EMR,
    rclBounds : RECTL,
    cptl      : DWORD,
    aptl      : [1]POINTL,
};
PEMRPOLYLINETO :: ^EMRPOLYLINETO;

EMRPOLYLINE16 :: struct {
    emr       : EMR,
    rclBounds : RECTL,
    cpts      : DWORD,
    apts      : [1]POINTS,
};
PEMRPOLYLINE16 :: ^EMRPOLYLINE16;
EMRPOLYBEZIER16 :: struct {
    emr       : EMR,
    rclBounds : RECTL,
    cpts      : DWORD,
    apts      : [1]POINTS,
};
PEMRPOLYBEZIER16 :: ^EMRPOLYBEZIER16;
EMRPOLYGON16 :: struct {
    emr       : EMR,
    rclBounds : RECTL,
    cpts      : DWORD,
    apts      : [1]POINTS,
};
PEMRPOLYGON16 :: ^EMRPOLYGON16;
EMRPOLYBEZIERTO16 :: struct {
    emr       : EMR,
    rclBounds : RECTL,
    cpts      : DWORD,
    apts      : [1]POINTS,
};
PEMRPOLYBEZIERTO16 :: ^EMRPOLYBEZIERTO16;
EMRPOLYLINETO16 :: struct {
    emr       : EMR,
    rclBounds : RECTL,
    cpts      : DWORD,
    apts      : [1]POINTS,
};
PEMRPOLYLINETO16 :: ^EMRPOLYLINETO16;

EMRPOLYDRAW :: struct {
    emr       : EMR,
    rclBounds : RECTL,
    cptl      : DWORD,
    aptl      : [1]POINTL,
    abTypes   : [1]BYTE,
};
PEMRPOLYDRAW :: ^EMRPOLYDRAW;

EMRPOLYDRAW16 :: struct {
    emr       : EMR,
    rclBounds : RECTL,
    cpts      : DWORD,
    apts      : [1]POINTS,
    abTypes   : [1]BYTE,
};
PEMRPOLYDRAW16 :: ^EMRPOLYDRAW16;

EMRPOLYPOLYLINE :: struct {
    emr         : EMR,
    rclBounds   : RECTL,
    nPolys      : DWORD,
    cptl        : DWORD,
    aPolyCounts : [1]DWORD,
    aptl        : [1]POINTL,
};
PEMRPOLYPOLYLINE :: ^EMRPOLYPOLYLINE;
EMRPOLYPOLYGON :: struct {
    emr         : EMR,
    rclBounds   : RECTL,
    nPolys      : DWORD,
    cptl        : DWORD,
    aPolyCounts : [1]DWORD,
    aptl        : [1]POINTL,
};
PEMRPOLYPOLYGON :: ^EMRPOLYPOLYGON;

EMRPOLYPOLYLINE16 :: struct {
    emr         : EMR,
    rclBounds   : RECTL,
    nPolys      : DWORD,
    cpts        : DWORD,
    aPolyCounts : [1]DWORD,
    apts        : [1]POINTS,
};
PEMRPOLYPOLYLINE16 :: ^EMRPOLYPOLYLINE16;
EMRPOLYPOLYGON16 :: struct {
    emr         : EMR,
    rclBounds   : RECTL,
    nPolys      : DWORD,
    cpts        : DWORD,
    aPolyCounts : [1]DWORD,
    apts        : [1]POINTS,
};
PEMRPOLYPOLYGON16 :: ^EMRPOLYPOLYGON16;

EMRINVERTRGN :: struct {
    emr       : EMR,
    rclBounds : RECTL,
    cbRgnData : DWORD,
    RgnData   : [1]BYTE,
};
PEMRINVERTRGN :: ^EMRINVERTRGN;
EMRPAINTRGN :: struct {
    emr       : EMR,
    rclBounds : RECTL,
    cbRgnData : DWORD,
    RgnData   : [1]BYTE,
};
PEMRPAINTRGN :: ^EMRPAINTRGN;

EMRFILLRGN :: struct {
    emr       : EMR,
    rclBounds : RECTL,
    cbRgnData : DWORD,
    ihBrush   : DWORD,
    RgnData   : [1]BYTE,
};
PEMRFILLRGN :: ^EMRFILLRGN;

EMRFRAMERGN :: struct {
    emr       : EMR,
    rclBounds : RECTL,
    cbRgnData : DWORD,
    ihBrush   : DWORD,
    szlStroke : SIZEL,
    RgnData   : [1]BYTE,
};
PEMRFRAMERGN :: ^EMRFRAMERGN;

EMREXTSELECTCLIPRGN :: struct {
    emr       : EMR,
    cbRgnData : DWORD,
    iMode     : DWORD,
    RgnData   : [1]BYTE,
};
PEMREXTSELECTCLIPRGN :: ^EMREXTSELECTCLIPRGN;

EMREXTTEXTOUTA :: struct {
    emr           : EMR,
    rclBounds     : RECTL,
    iGraphicsMode : DWORD,
    exScale       : FLOAT,
    eyScale       : FLOAT,
    emrtext       : EMRTEXT,
};
PEMREXTTEXTOUTA :: ^EMREXTTEXTOUTA;
EMREXTTEXTOUTW :: struct {
    emr           : EMR,
    rclBounds     : RECTL,
    iGraphicsMode : DWORD,
    exScale       : FLOAT,
    eyScale       : FLOAT,
    emrtext       : EMRTEXT,
};
PEMREXTTEXTOUTW :: ^EMREXTTEXTOUTW;

EMRPOLYTEXTOUTA :: struct {
    emr           : EMR,
    rclBounds     : RECTL,
    iGraphicsMode : DWORD,
    exScale       : FLOAT,
    eyScale       : FLOAT,
    cStrings      : LONG,
    aemrtext      : [1]EMRTEXT,
};
PEMRPOLYTEXTOUTA :: ^EMRPOLYTEXTOUTA;
EMRPOLYTEXTOUTW :: struct {
    emr           : EMR,
    rclBounds     : RECTL,
    iGraphicsMode : DWORD,
    exScale       : FLOAT,
    eyScale       : FLOAT,
    cStrings      : LONG,
    aemrtext      : [1]EMRTEXT,
};
PEMRPOLYTEXTOUTW :: ^EMRPOLYTEXTOUTW;

EMRBITBLT :: struct {
    emr          : EMR,
    rclBounds    : RECTL,
    xDest        : LONG,
    yDest        : LONG,
    cxDest       : LONG,
    cyDest       : LONG,
    dwRop        : DWORD,
    xSrc         : LONG,
    ySrc         : LONG,
    xformSrc     : XFORM,
    crBkColorSrc : COLORREF,
    iUsageSrc    : DWORD,
    offBmiSrc    : DWORD,
    cbBmiSrc     : DWORD,
    offBitsSrc   : DWORD,
    cbBitsSrc    : DWORD,
};
PEMRBITBLT :: ^EMRBITBLT;

EMRSTRETCHBLT :: struct {
    emr          : EMR,
    rclBounds    : RECTL,
    xDest        : LONG,
    yDest        : LONG,
    cxDest       : LONG,
    cyDest       : LONG,
    dwRop        : DWORD,
    xSrc         : LONG,
    ySrc         : LONG,
    xformSrc     : XFORM,
    crBkColorSrc : COLORREF,
    iUsageSrc    : DWORD,
    offBmiSrc    : DWORD,
    cbBmiSrc     : DWORD,
    offBitsSrc   : DWORD,
    cbBitsSrc    : DWORD,
    cxSrc        : LONG,
    cySrc        : LONG,
};
PEMRSTRETCHBLT :: ^EMRSTRETCHBLT;

EMRMASKBLT :: struct {
    emr          : EMR,
    rclBounds    : RECTL,
    xDest        : LONG,
    yDest        : LONG,
    cxDest       : LONG,
    cyDest       : LONG,
    dwRop        : DWORD,
    xSrc         : LONG,
    ySrc         : LONG,
    xformSrc     : XFORM,
    crBkColorSrc : COLORREF,
    iUsageSrc    : DWORD,
    offBmiSrc    : DWORD,
    cbBmiSrc     : DWORD,
    offBitsSrc   : DWORD,
    cbBitsSrc    : DWORD,
    xMask        : LONG,
    yMask        : LONG,
    iUsageMask   : DWORD,
    offBmiMask   : DWORD,
    cbBmiMask    : DWORD,
    offBitsMask  : DWORD,
    cbBitsMask   : DWORD,
};
PEMRMASKBLT :: ^EMRMASKBLT;

EMRPLGBLT :: struct {
    emr          : EMR,
    rclBounds    : RECTL,
    aptlDest     : [3]POINTL,
    xSrc         : LONG,
    ySrc         : LONG,
    cxSrc        : LONG,
    cySrc        : LONG,
    xformSrc     : XFORM,
    crBkColorSrc : COLORREF,
    iUsageSrc    : DWORD,
    offBmiSrc    : DWORD,
    cbBmiSrc     : DWORD,
    offBitsSrc   : DWORD,
    cbBitsSrc    : DWORD,
    xMask        : LONG,
    yMask        : LONG,
    iUsageMask   : DWORD,
    offBmiMask   : DWORD,
    cbBmiMask    : DWORD,
    offBitsMask  : DWORD,
    cbBitsMask   : DWORD,
};
PEMRPLGBLT :: ^EMRPLGBLT;

EMRSETDIBITSTODEVICE :: struct {
    emr        : EMR,
    rclBounds  : RECTL,
    xDest      : LONG,
    yDest      : LONG,
    xSrc       : LONG,
    ySrc       : LONG,
    cxSrc      : LONG,
    cySrc      : LONG,
    offBmiSrc  : DWORD,
    cbBmiSrc   : DWORD,
    offBitsSrc : DWORD,
    cbBitsSrc  : DWORD,
    iUsageSrc  : DWORD,
    iStartScan : DWORD,
    cScans     : DWORD,
};
PEMRSETDIBITSTODEVICE :: ^EMRSETDIBITSTODEVICE;

EMRSTRETCHDIBITS :: struct {
    emr        : EMR,
    rclBounds  : RECTL,
    xDest      : LONG,
    yDest      : LONG,
    xSrc       : LONG,
    ySrc       : LONG,
    cxSrc      : LONG,
    cySrc      : LONG,
    offBmiSrc  : DWORD,
    cbBmiSrc   : DWORD,
    offBitsSrc : DWORD,
    cbBitsSrc  : DWORD,
    iUsageSrc  : DWORD,
    dwRop      : DWORD,
    cxDest     : LONG,
    cyDest     : LONG,
};
PEMRSTRETCHDIBITS :: ^EMRSTRETCHDIBITS;

EMREXTCREATEFONTINDIRECTW :: struct {
    emr    : EMR,
    ihFont : DWORD,
    elfw   : EXTLOGFONTW,
};
PEMREXTCREATEFONTINDIRECTW :: ^EMREXTCREATEFONTINDIRECTW;

EMRCREATEPALETTE :: struct {
    emr   : EMR,
    ihPal : DWORD,
    lgpl  : LOGPALETTE,
};
PEMRCREATEPALETTE :: ^EMRCREATEPALETTE;

EMRCREATEPEN :: struct {
    emr   : EMR,
    ihPen : DWORD,
    lopn  : LOGPEN,
};
PEMRCREATEPEN :: ^EMRCREATEPEN;

EMREXTCREATEPEN :: struct {
    emr     : EMR,
    ihPen   : DWORD,
    offBmi  : DWORD,
    cbBmi   : DWORD,
    offBits : DWORD,
    cbBits  : DWORD,
    elp     : EXTLOGPEN32,
};
PEMREXTCREATEPEN :: ^EMREXTCREATEPEN;

EMRCREATEBRUSHINDIRECT :: struct {
    emr     : EMR,
    ihBrush : DWORD,
    lb      : LOGBRUSH32,
};
PEMRCREATEBRUSHINDIRECT :: ^EMRCREATEBRUSHINDIRECT;

EMRCREATEMONOBRUSH :: struct {
    emr     : EMR,
    ihBrush : DWORD,
    iUsage  : DWORD,
    offBmi  : DWORD,
    cbBmi   : DWORD,
    offBits : DWORD,
    cbBits  : DWORD,
};
PEMRCREATEMONOBRUSH :: ^EMRCREATEMONOBRUSH;

EMRCREATEDIBPATTERNBRUSHPT :: struct {
    emr     : EMR,
    ihBrush : DWORD,
    iUsage  : DWORD,
    offBmi  : DWORD,
    cbBmi   : DWORD,
    offBits : DWORD,
    cbBits  : DWORD,
};
PEMRCREATEDIBPATTERNBRUSHPT :: ^EMRCREATEDIBPATTERNBRUSHPT;

EMRFORMAT :: struct {
    dSignature : DWORD,
    nVersion   : DWORD,
    cbData     : DWORD,
    offData    : DWORD,
};
PEMRFORMAT :: ^EMRFORMAT;

EMRGLSRECORD :: struct {
    emr    : EMR,
    cbData : DWORD,
    Data   : [1]BYTE,
};
PEMRGLSRECORD :: ^EMRGLSRECORD;

EMRGLSBOUNDEDRECORD :: struct {
    emr       : EMR,
    rclBounds : RECTL,
    cbData    : DWORD,
    Data      : [1]BYTE,
};
PEMRGLSBOUNDEDRECORD :: ^EMRGLSBOUNDEDRECORD;

EMRPIXELFORMAT :: struct {
    emr : EMR,
    pfd : PIXELFORMATDESCRIPTOR,
};
PEMRPIXELFORMAT :: ^EMRPIXELFORMAT;

EMRCREATECOLORSPACE :: struct {
    emr  : EMR,
    ihCS : DWORD,
    lcs  : LOGCOLORSPACEA,
};
PEMRCREATECOLORSPACE :: ^EMRCREATECOLORSPACE;

EMRSETCOLORSPACE :: struct {
    emr  : EMR,
    ihCS : DWORD,
};
PEMRSETCOLORSPACE :: ^EMRSETCOLORSPACE;
EMRSELECTCOLORSPACE :: struct {
    emr  : EMR,
    ihCS : DWORD,
};
PEMRSELECTCOLORSPACE :: ^EMRSELECTCOLORSPACE;
EMRDELETECOLORSPACE :: struct {
    emr  : EMR,
    ihCS : DWORD,
};
PEMRDELETECOLORSPACE :: ^EMRDELETECOLORSPACE;

EMREXTESCAPE :: struct {
    emr       : EMR,
    iEscape   : INT,
    cbEscData : INT,
    EscData   : [1]BYTE,
};
PEMREXTESCAPE :: ^EMREXTESCAPE;
EMRDRAWESCAPE :: struct {
    emr       : EMR,
    iEscape   : INT,
    cbEscData : INT,
    EscData   : [1]BYTE,
};
PEMRDRAWESCAPE :: ^EMRDRAWESCAPE;

EMRNAMEDESCAPE :: struct {
    emr       : EMR,
    iEscape   : INT,
    cbDriver  : INT,
    cbEscData : INT,
    EscData   : [1]BYTE,
};
PEMRNAMEDESCAPE :: ^EMRNAMEDESCAPE;

EMRSETICMPROFILE :: struct {
    emr     : EMR,
    dwFlags : DWORD,
    cbName  : DWORD,
    cbData  : DWORD,
    Data    : [1]BYTE,
};
PEMRSETICMPROFILE :: ^EMRSETICMPROFILE;
EMRSETICMPROFILEA :: struct {
    emr     : EMR,
    dwFlags : DWORD,
    cbName  : DWORD,
    cbData  : DWORD,
    Data    : [1]BYTE,
};
PEMRSETICMPROFILEA :: ^EMRSETICMPROFILEA;
EMRSETICMPROFILEW :: struct {
    emr     : EMR,
    dwFlags : DWORD,
    cbName  : DWORD,
    cbData  : DWORD,
    Data    : [1]BYTE,
};
PEMRSETICMPROFILEW :: ^EMRSETICMPROFILEW;

EMRCREATECOLORSPACEW :: struct {
    emr     : EMR,
    ihCS    : DWORD,
    lcs     : LOGCOLORSPACEW,
    dwFlags : DWORD,
    cbData  : DWORD,
    Data    : [1]BYTE,
};
PEMRCREATECOLORSPACEW :: ^EMRCREATECOLORSPACEW;

EMRCOLORMATCHTOTARGET :: struct {
    emr      : EMR,
    dwAction : DWORD,
    dwFlags  : DWORD,
    cbName   : DWORD,
    cbData   : DWORD,
    Data     : [1]BYTE,
};
PEMRCOLORMATCHTOTARGET :: ^EMRCOLORMATCHTOTARGET;

EMRCOLORCORRECTPALETTE :: struct {
    emr         : EMR,
    ihPalette   : DWORD,
    nFirstEntry : DWORD,
    nPalEntries : DWORD,
    nReserved   : DWORD,
};
PEMRCOLORCORRECTPALETTE :: ^EMRCOLORCORRECTPALETTE;

EMRALPHABLEND :: struct {
    emr          : EMR,
    rclBounds    : RECTL,
    xDest        : LONG,
    yDest        : LONG,
    cxDest       : LONG,
    cyDest       : LONG,
    dwRop        : DWORD,
    xSrc         : LONG,
    ySrc         : LONG,
    xformSrc     : XFORM,
    crBkColorSrc : COLORREF,
    iUsageSrc    : DWORD,
    offBmiSrc    : DWORD,
    cbBmiSrc     : DWORD,
    offBitsSrc   : DWORD,
    cbBitsSrc    : DWORD,
    cxSrc        : LONG,
    cySrc        : LONG,
};
PEMRALPHABLEND :: ^EMRALPHABLEND;

EMRGRADIENTFILL :: struct {
    emr       : EMR,
    rclBounds : RECTL,
    nVer      : DWORD,
    nTri      : DWORD,
    ulMode    : ULONG,
    Ver       : [1]TRIVERTEX,
};
PEMRGRADIENTFILL :: ^EMRGRADIENTFILL;

EMRTRANSPARENTBLT :: struct {
    emr          : EMR,
    rclBounds    : RECTL,
    xDest        : LONG,
    yDest        : LONG,
    cxDest       : LONG,
    cyDest       : LONG,
    dwRop        : DWORD,
    xSrc         : LONG,
    ySrc         : LONG,
    xformSrc     : XFORM,
    crBkColorSrc : COLORREF,
    iUsageSrc    : DWORD,
    offBmiSrc    : DWORD,
    cbBmiSrc     : DWORD,
    offBitsSrc   : DWORD,
    cbBitsSrc    : DWORD,
    cxSrc        : LONG,
    cySrc        : LONG,
};
PEMRTRANSPARENTBLT :: ^EMRTRANSPARENTBLT;

POINTFLOAT :: struct {
    x : FLOAT,
    y : FLOAT,
};
PPOINTFLOAT :: ^POINTFLOAT;

GLYPHMETRICSFLOAT :: struct {
    gmfBlackBoxX     : FLOAT,
    gmfBlackBoxY     : FLOAT,
    gmfptGlyphOrigin : POINTFLOAT,
    gmfCellIncX      : FLOAT,
    gmfCellIncY      : FLOAT,
};
PGLYPHMETRICSFLOAT :: ^GLYPHMETRICSFLOAT;
LPGLYPHMETRICSFLOAT :: ^GLYPHMETRICSFLOAT;

LAYERPLANEDESCRIPTOR :: struct {
    nSize           : WORD,
    nVersion        : WORD,
    dwFlags         : DWORD,
    iPixelType      : BYTE,
    cColorBits      : BYTE,
    cRedBits        : BYTE,
    cRedShift       : BYTE,
    cGreenBits      : BYTE,
    cGreenShift     : BYTE,
    cBlueBits       : BYTE,
    cBlueShift      : BYTE,
    cAlphaBits      : BYTE,
    cAlphaShift     : BYTE,
    cAccumBits      : BYTE,
    cAccumRedBits   : BYTE,
    cAccumGreenBits : BYTE,
    cAccumBlueBits  : BYTE,
    cAccumAlphaBits : BYTE,
    cDepthBits      : BYTE,
    cStencilBits    : BYTE,
    cAuxBuffers     : BYTE,
    iLayerPlane     : BYTE,
    bReserved       : BYTE,
    crTransparent   : COLORREF,
};
PLAYERPLANEDESCRIPTOR :: ^LAYERPLANEDESCRIPTOR;
LPLAYERPLANEDESCRIPTOR :: ^LAYERPLANEDESCRIPTOR;

WGLSWAP :: struct {
    hdc     : HDC,
    uiFlags : UINT,
};
PWGLSWAP :: ^WGLSWAP;
LPWGLSWAP :: ^WGLSWAP;

HDWP :: HANDLE;

LPMENUTEMPLATEA :: PVOID;

LPMENUTEMPLATEW :: PVOID;

LPMENUTEMPLATE :: LPMENUTEMPLATEA;

WNDPROC :: (proc "stdcall" (HWND, UINT, WPARAM, LPARAM) -> LRESULT);

DLGPROC :: (proc "stdcall" (HWND, UINT, WPARAM, LPARAM) -> INT_PTR);

TIMERPROC :: proc "stdcall" (HWND, UINT, UINT_PTR, DWORD);

GRAYSTRINGPROC :: (proc "stdcall" (HDC, LPARAM, _c.int) -> BOOL);

WNDENUMPROC :: (proc "stdcall" (HWND, LPARAM) -> BOOL);

HOOKPROC :: (proc "stdcall" (code : _c.int, wParam : WPARAM, lParam : LPARAM) -> LRESULT);

SENDASYNCPROC :: proc "stdcall" (HWND, UINT, ULONG_PTR, LRESULT);

PROPENUMPROCA :: (proc "stdcall" (HWND, LPCSTR, HANDLE) -> BOOL);

PROPENUMPROCW :: (proc "stdcall" (HWND, LPCWSTR, HANDLE) -> BOOL);

PROPENUMPROCEXA :: (proc "stdcall" (HWND, LPSTR, HANDLE, ULONG_PTR) -> BOOL);

PROPENUMPROCEXW :: (proc "stdcall" (HWND, LPWSTR, HANDLE, ULONG_PTR) -> BOOL);

EDITWORDBREAKPROCA :: (proc "stdcall" (lpch : LPSTR, ichCurrent : _c.int, cch : _c.int, code : _c.int) -> _c.int);

EDITWORDBREAKPROCW :: (proc "stdcall" (lpch : LPWSTR, ichCurrent : _c.int, cch : _c.int, code : _c.int) -> _c.int);

DRAWSTATEPROC :: (proc "stdcall" (hdc : HDC, lData : LPARAM, wData : WPARAM, cx : _c.int, cy : _c.int) -> BOOL);

PROPENUMPROC :: PROPENUMPROCA;

PROPENUMPROCEX :: PROPENUMPROCEXA;

EDITWORDBREAKPROC :: EDITWORDBREAKPROCA;

NAMEENUMPROCA :: (proc "stdcall" (LPSTR, LPARAM) -> BOOL);

NAMEENUMPROCW :: (proc "stdcall" (LPWSTR, LPARAM) -> BOOL);

WINSTAENUMPROCA :: NAMEENUMPROCA;

DESKTOPENUMPROCA :: NAMEENUMPROCA;

WINSTAENUMPROCW :: NAMEENUMPROCW;

DESKTOPENUMPROCW :: NAMEENUMPROCW;

WINSTAENUMPROC :: WINSTAENUMPROCA;

DESKTOPENUMPROC :: DESKTOPENUMPROCA;

CBT_CREATEWNDA :: struct {
    lpcs            : ^CREATESTRUCTA,
    hwndInsertAfter : HWND,
};
LPCBT_CREATEWNDA :: ^CBT_CREATEWNDA;

CBT_CREATEWNDW :: struct {
    lpcs            : ^CREATESTRUCTW,
    hwndInsertAfter : HWND,
};
LPCBT_CREATEWNDW :: ^CBT_CREATEWNDW;

CBT_CREATEWND :: CBT_CREATEWNDA;

LPCBT_CREATEWND :: LPCBT_CREATEWNDA;

CBTACTIVATESTRUCT :: struct {
    fMouse     : BOOL,
    hWndActive : HWND,
};
LPCBTACTIVATESTRUCT :: ^CBTACTIVATESTRUCT;

WTSSESSION_NOTIFICATION :: struct {
    cbSize      : DWORD,
    dwSessionId : DWORD,
};
PWTSSESSION_NOTIFICATION :: ^WTSSESSION_NOTIFICATION;

SHELLHOOKINFO :: struct {
    hwnd : HWND,
    rc   : RECT,
};
LPSHELLHOOKINFO :: ^SHELLHOOKINFO;

EVENTMSG :: struct {
    message : UINT,
    paramL  : UINT,
    paramH  : UINT,
    time    : DWORD,
    hwnd    : HWND,
};
PEVENTMSGMSG :: ^EVENTMSG;
NPEVENTMSGMSG :: ^EVENTMSG;
LPEVENTMSGMSG :: ^EVENTMSG;

PEVENTMSG :: ^EVENTMSG;
NPEVENTMSG :: ^EVENTMSG;
LPEVENTMSG :: ^EVENTMSG;

CWPSTRUCT :: struct {
    lParam  : LPARAM,
    wParam  : WPARAM,
    message : UINT,
    hwnd    : HWND,
};
PCWPSTRUCT :: ^CWPSTRUCT;
NPCWPSTRUCT :: ^CWPSTRUCT;
LPCWPSTRUCT :: ^CWPSTRUCT;

CWPRETSTRUCT :: struct {
    lResult : LRESULT,
    lParam  : LPARAM,
    wParam  : WPARAM,
    message : UINT,
    hwnd    : HWND,
};
PCWPRETSTRUCT :: ^CWPRETSTRUCT;
NPCWPRETSTRUCT :: ^CWPRETSTRUCT;
LPCWPRETSTRUCT :: ^CWPRETSTRUCT;

KBDLLHOOKSTRUCT :: struct {
    vkCode      : DWORD,
    scanCode    : DWORD,
    flags       : DWORD,
    time        : DWORD,
    dwExtraInfo : ULONG_PTR,
};
LPKBDLLHOOKSTRUCT :: ^KBDLLHOOKSTRUCT;
PKBDLLHOOKSTRUCT :: ^KBDLLHOOKSTRUCT;

MSLLHOOKSTRUCT :: struct {
    pt          : POINT,
    mouseData   : DWORD,
    flags       : DWORD,
    time        : DWORD,
    dwExtraInfo : ULONG_PTR,
};
LPMSLLHOOKSTRUCT :: ^MSLLHOOKSTRUCT;
PMSLLHOOKSTRUCT :: ^MSLLHOOKSTRUCT;

DEBUGHOOKINFO :: struct {
    idThread          : DWORD,
    idThreadInstaller : DWORD,
    lParam            : LPARAM,
    wParam            : WPARAM,
    code              : _c.int,
};
PDEBUGHOOKINFO :: ^DEBUGHOOKINFO;
NPDEBUGHOOKINFO :: ^DEBUGHOOKINFO;
LPDEBUGHOOKINFO :: ^DEBUGHOOKINFO;

MOUSEHOOKSTRUCT :: struct {
    pt           : POINT,
    hwnd         : HWND,
    wHitTestCode : UINT,
    dwExtraInfo  : ULONG_PTR,
};
LPMOUSEHOOKSTRUCT :: ^MOUSEHOOKSTRUCT;
PMOUSEHOOKSTRUCT :: ^MOUSEHOOKSTRUCT;

MOUSEHOOKSTRUCTEX :: struct {
    s         : MOUSEHOOKSTRUCT,
    mouseData : DWORD,
};
LPMOUSEHOOKSTRUCTEX :: ^MOUSEHOOKSTRUCTEX;
PMOUSEHOOKSTRUCTEX :: ^MOUSEHOOKSTRUCTEX;

HARDWAREHOOKSTRUCT :: struct {
    hwnd    : HWND,
    message : UINT,
    wParam  : WPARAM,
    lParam  : LPARAM,
};
LPHARDWAREHOOKSTRUCT :: ^HARDWAREHOOKSTRUCT;
PHARDWAREHOOKSTRUCT :: ^HARDWAREHOOKSTRUCT;

MOUSEMOVEPOINT :: struct {
    x           : _c.int,
    y           : _c.int,
    time        : DWORD,
    dwExtraInfo : ULONG_PTR,
};
PMOUSEMOVEPOINT :: ^MOUSEMOVEPOINT;
LPMOUSEMOVEPOINT :: ^MOUSEMOVEPOINT;

USEROBJECTFLAGS :: struct {
    fInherit  : BOOL,
    fReserved : BOOL,
    dwFlags   : DWORD,
};
PUSEROBJECTFLAGS :: ^USEROBJECTFLAGS;

WNDCLASSEXA :: struct {
    cbSize        : UINT,
    style         : UINT,
    lpfnWndProc   : WNDPROC,
    cbClsExtra    : _c.int,
    cbWndExtra    : _c.int,
    hInstance     : HINSTANCE,
    hIcon         : HICON,
    hCursor       : HCURSOR,
    hbrBackground : HBRUSH,
    lpszMenuName  : LPCSTR,
    lpszClassName : LPCSTR,
    hIconSm       : HICON,
};
PWNDCLASSEXA :: ^WNDCLASSEXA;
NPWNDCLASSEXA :: ^WNDCLASSEXA;
LPWNDCLASSEXA :: ^WNDCLASSEXA;

WNDCLASSEXW :: struct {
    cbSize        : UINT,
    style         : UINT,
    lpfnWndProc   : WNDPROC,
    cbClsExtra    : _c.int,
    cbWndExtra    : _c.int,
    hInstance     : HINSTANCE,
    hIcon         : HICON,
    hCursor       : HCURSOR,
    hbrBackground : HBRUSH,
    lpszMenuName  : LPCWSTR,
    lpszClassName : LPCWSTR,
    hIconSm       : HICON,
};
PWNDCLASSEXW :: ^WNDCLASSEXW;
NPWNDCLASSEXW :: ^WNDCLASSEXW;
LPWNDCLASSEXW :: ^WNDCLASSEXW;

WNDCLASSEX :: WNDCLASSEXA;

PWNDCLASSEX :: PWNDCLASSEXA;

NPWNDCLASSEX :: NPWNDCLASSEXA;

LPWNDCLASSEX :: LPWNDCLASSEXA;

WNDCLASSA :: struct {
    style         : UINT,
    lpfnWndProc   : WNDPROC,
    cbClsExtra    : _c.int,
    cbWndExtra    : _c.int,
    hInstance     : HINSTANCE,
    hIcon         : HICON,
    hCursor       : HCURSOR,
    hbrBackground : HBRUSH,
    lpszMenuName  : LPCSTR,
    lpszClassName : LPCSTR,
};
PWNDCLASSA :: ^WNDCLASSA;
NPWNDCLASSA :: ^WNDCLASSA;
LPWNDCLASSA :: ^WNDCLASSA;

WNDCLASSW :: struct {
    style         : UINT,
    lpfnWndProc   : WNDPROC,
    cbClsExtra    : _c.int,
    cbWndExtra    : _c.int,
    hInstance     : HINSTANCE,
    hIcon         : HICON,
    hCursor       : HCURSOR,
    hbrBackground : HBRUSH,
    lpszMenuName  : LPCWSTR,
    lpszClassName : LPCWSTR,
};
PWNDCLASSW :: ^WNDCLASSW;
NPWNDCLASSW :: ^WNDCLASSW;
LPWNDCLASSW :: ^WNDCLASSW;

WNDCLASS :: WNDCLASSA;

PWNDCLASS :: PWNDCLASSA;

NPWNDCLASS :: NPWNDCLASSA;

LPWNDCLASS :: LPWNDCLASSA;

MSG :: struct {
    hwnd    : HWND,
    message : UINT,
    wParam  : WPARAM,
    lParam  : LPARAM,
    time    : DWORD,
    pt      : POINT,
};
PMSG :: ^MSG;
NPMSG :: ^MSG;
LPMSG :: ^MSG;

MINMAXINFO :: struct {
    ptReserved     : POINT,
    ptMaxSize      : POINT,
    ptMaxPosition  : POINT,
    ptMinTrackSize : POINT,
    ptMaxTrackSize : POINT,
};
PMINMAXINFO :: ^MINMAXINFO;
LPMINMAXINFO :: ^MINMAXINFO;

COPYDATASTRUCT :: struct {
    dwData : ULONG_PTR,
    cbData : DWORD,
    lpData : PVOID,
};
PCOPYDATASTRUCT :: ^COPYDATASTRUCT;

MDINEXTMENU :: struct {
    hmenuIn   : HMENU,
    hmenuNext : HMENU,
    hwndNext  : HWND,
};
PMDINEXTMENU :: ^MDINEXTMENU;
LPMDINEXTMENU :: ^MDINEXTMENU;

POWERBROADCAST_SETTING :: struct {
    PowerSetting : GUID,
    DataLength   : DWORD,
    Data         : [1]UCHAR,
};
PPOWERBROADCAST_SETTING :: ^POWERBROADCAST_SETTING;

WINDOWPOS :: struct {
    hwnd            : HWND,
    hwndInsertAfter : HWND,
    x               : _c.int,
    y               : _c.int,
    cx              : _c.int,
    cy              : _c.int,
    flags           : UINT,
};
LPWINDOWPOS :: ^WINDOWPOS;
PWINDOWPOS :: ^WINDOWPOS;

NCCALCSIZE_PARAMS :: struct {
    rgrc  : [3]RECT,
    lppos : PWINDOWPOS,
};
LPNCCALCSIZE_PARAMS :: ^NCCALCSIZE_PARAMS;

TRACKMOUSEEVENT :: struct {
    cbSize      : DWORD,
    dwFlags     : DWORD,
    hwndTrack   : HWND,
    dwHoverTime : DWORD,
};
LPTRACKMOUSEEVENT :: ^TRACKMOUSEEVENT;

ACCEL :: struct {
    fVirt : BYTE,
    key   : WORD,
    cmd   : WORD,
};
LPACCEL :: ^ACCEL;

PAINTSTRUCT :: struct {
    hdc         : HDC,
    fErase      : BOOL,
    rcPaint     : RECT,
    fRestore    : BOOL,
    fIncUpdate  : BOOL,
    rgbReserved : [32]BYTE,
};
PPAINTSTRUCT :: ^PAINTSTRUCT;
NPPAINTSTRUCT :: ^PAINTSTRUCT;
LPPAINTSTRUCT :: ^PAINTSTRUCT;

CREATESTRUCTA :: struct {
    lpCreateParams : LPVOID,
    hInstance      : HINSTANCE,
    hMenu          : HMENU,
    hwndParent     : HWND,
    cy             : _c.int,
    cx             : _c.int,
    y              : _c.int,
    x              : _c.int,
    style          : LONG,
    lpszName       : LPCSTR,
    lpszClass      : LPCSTR,
    dwExStyle      : DWORD,
};
LPCREATESTRUCTA :: ^CREATESTRUCTA;

CREATESTRUCTW :: struct {
    lpCreateParams : LPVOID,
    hInstance      : HINSTANCE,
    hMenu          : HMENU,
    hwndParent     : HWND,
    cy             : _c.int,
    cx             : _c.int,
    y              : _c.int,
    x              : _c.int,
    style          : LONG,
    lpszName       : LPCWSTR,
    lpszClass      : LPCWSTR,
    dwExStyle      : DWORD,
};
LPCREATESTRUCTW :: ^CREATESTRUCTW;

CREATESTRUCT :: CREATESTRUCTA;

LPCREATESTRUCT :: LPCREATESTRUCTA;

WINDOWPLACEMENT :: struct {
    length           : UINT,
    flags            : UINT,
    showCmd          : UINT,
    ptMinPosition    : POINT,
    ptMaxPosition    : POINT,
    rcNormalPosition : RECT,
};

PWINDOWPLACEMENT :: ^WINDOWPLACEMENT;
LPWINDOWPLACEMENT :: ^WINDOWPLACEMENT;

NMHDR :: struct {
    hwndFrom : HWND,
    idFrom   : UINT_PTR,
    code     : UINT,
};

LPNMHDR :: ^NMHDR;

STYLESTRUCT :: struct {
    styleOld : DWORD,
    styleNew : DWORD,
};
LPSTYLESTRUCT :: ^STYLESTRUCT;

MEASUREITEMSTRUCT :: struct {
    CtlType    : UINT,
    CtlID      : UINT,
    itemID     : UINT,
    itemWidth  : UINT,
    itemHeight : UINT,
    itemData   : ULONG_PTR,
};
PMEASUREITEMSTRUCT :: ^MEASUREITEMSTRUCT;
LPMEASUREITEMSTRUCT :: ^MEASUREITEMSTRUCT;

DRAWITEMSTRUCT :: struct {
    CtlType    : UINT,
    CtlID      : UINT,
    itemID     : UINT,
    itemAction : UINT,
    itemState  : UINT,
    hwndItem   : HWND,
    hDC        : HDC,
    rcItem     : RECT,
    itemData   : ULONG_PTR,
};
PDRAWITEMSTRUCT :: ^DRAWITEMSTRUCT;
LPDRAWITEMSTRUCT :: ^DRAWITEMSTRUCT;

DELETEITEMSTRUCT :: struct {
    CtlType  : UINT,
    CtlID    : UINT,
    itemID   : UINT,
    hwndItem : HWND,
    itemData : ULONG_PTR,
};
PDELETEITEMSTRUCT :: ^DELETEITEMSTRUCT;
LPDELETEITEMSTRUCT :: ^DELETEITEMSTRUCT;

COMPAREITEMSTRUCT :: struct {
    CtlType    : UINT,
    CtlID      : UINT,
    hwndItem   : HWND,
    itemID1    : UINT,
    itemData1  : ULONG_PTR,
    itemID2    : UINT,
    itemData2  : ULONG_PTR,
    dwLocaleId : DWORD,
};
PCOMPAREITEMSTRUCT :: ^COMPAREITEMSTRUCT;
LPCOMPAREITEMSTRUCT :: ^COMPAREITEMSTRUCT;

BSMINFO :: struct {
    cbSize : UINT,
    hdesk  : HDESK,
    hwnd   : HWND,
    luid   : LUID,
};
PBSMINFO :: ^BSMINFO;

HDEVNOTIFY :: PVOID;

PHDEVNOTIFY :: ^HDEVNOTIFY;

HPOWERNOTIFY :: PVOID;

PHPOWERNOTIFY :: ^HPOWERNOTIFY;

PREGISTERCLASSNAMEW :: (proc "stdcall" (LPCWSTR) -> BOOLEAN);

UPDATELAYEREDWINDOWINFO :: struct {
    cbSize   : DWORD,
    hdcDst   : HDC,
    pptDst   : ^POINT,
    psize    : ^SIZE,
    hdcSrc   : HDC,
    pptSrc   : ^POINT,
    crKey    : COLORREF,
    pblend   : ^BLENDFUNCTION,
    dwFlags  : DWORD,
    prcDirty : ^RECT,
};
PUPDATELAYEREDWINDOWINFO :: ^UPDATELAYEREDWINDOWINFO;

FLASHWINFO :: struct {
    cbSize    : UINT,
    hwnd      : HWND,
    dwFlags   : DWORD,
    uCount    : UINT,
    dwTimeout : DWORD,
};
PFLASHWINFO :: ^FLASHWINFO;

DLGTEMPLATE :: struct {
    style           : DWORD,
    dwExtendedStyle : DWORD,
    cdit            : WORD,
    x               : _c.short,
    y               : _c.short,
    cx              : _c.short,
    cy              : _c.short,
};

LPDLGTEMPLATEA :: ^DLGTEMPLATE;

LPDLGTEMPLATEW :: ^DLGTEMPLATE;

LPDLGTEMPLATE :: LPDLGTEMPLATEA;

LPCDLGTEMPLATEA :: ^DLGTEMPLATE;

LPCDLGTEMPLATEW :: ^DLGTEMPLATE;

LPCDLGTEMPLATE :: LPCDLGTEMPLATEA;

DLGITEMTEMPLATE :: struct {
    style           : DWORD,
    dwExtendedStyle : DWORD,
    x               : _c.short,
    y               : _c.short,
    cx              : _c.short,
    cy              : _c.short,
    id              : WORD,
};

PDLGITEMTEMPLATEA :: ^DLGITEMTEMPLATE;

PDLGITEMTEMPLATEW :: ^DLGITEMTEMPLATE;

PDLGITEMTEMPLATE :: PDLGITEMTEMPLATEA;

LPDLGITEMTEMPLATEA :: ^DLGITEMTEMPLATE;

LPDLGITEMTEMPLATEW :: ^DLGITEMTEMPLATE;

LPDLGITEMTEMPLATE :: LPDLGITEMTEMPLATEA;

/* DIALOG_CONTROL_DPI_CHANGE_BEHAVIORS :: enum { */
DIALOG_CONTROL_DPI_CHANGE_BEHAVIORS :: _c.int;
    DCDC_DEFAULT :: 0x0000;
    DCDC_DISABLE_FONT_UPDATE :: 0x0001;
    DCDC_DISABLE_RELAYOUT :: 0x0002;
/* } */
;

/* DIALOG_DPI_CHANGE_BEHAVIORS :: enum { */
DIALOG_DPI_CHANGE_BEHAVIORS :: _c.int;
    DDC_DEFAULT :: 0x0000;
    DDC_DISABLE_ALL :: 0x0001;
    DDC_DISABLE_RESIZE :: 0x0002;
    DDC_DISABLE_CONTROL_RELAYOUT :: 0x0004;
/* } */
;

MOUSEINPUT :: struct {
    dx          : LONG,
    dy          : LONG,
    mouseData   : DWORD,
    dwFlags     : DWORD,
    time        : DWORD,
    dwExtraInfo : ULONG_PTR,
};
PMOUSEINPUT :: ^MOUSEINPUT;
LPMOUSEINPUT :: ^MOUSEINPUT;

KEYBDINPUT :: struct {
    wVk         : WORD,
    wScan       : WORD,
    dwFlags     : DWORD,
    time        : DWORD,
    dwExtraInfo : ULONG_PTR,
};
PKEYBDINPUT :: ^KEYBDINPUT;
LPKEYBDINPUT :: ^KEYBDINPUT;

HARDWAREINPUT :: struct {
    uMsg    : DWORD,
    wParamL : WORD,
    wParamH : WORD,
};
PHARDWAREINPUT :: ^HARDWAREINPUT;
LPHARDWAREINPUT :: ^HARDWAREINPUT;

INPUT :: struct {
    type : DWORD,
    u : struct #raw_union {
        mi : MOUSEINPUT,
        ki : KEYBDINPUT,
        hi : HARDWAREINPUT,
    },
};
PINPUT :: ^INPUT;
LPINPUT :: ^INPUT;

HTOUCHINPUT__ :: struct {
    unused : _c.int,
};

HTOUCHINPUT :: ^HTOUCHINPUT__;

TOUCHINPUT :: struct {
    x           : LONG,
    y           : LONG,
    hSource     : HANDLE,
    dwID        : DWORD,
    dwFlags     : DWORD,
    dwMask      : DWORD,
    dwTime      : DWORD,
    dwExtraInfo : ULONG_PTR,
    cxContact   : DWORD,
    cyContact   : DWORD,
};
PTOUCHINPUT :: ^TOUCHINPUT;

PCTOUCHINPUT :: ^TOUCHINPUT;

/* tagPOINTER_INPUT_TYPE :: enum { */
tagPOINTER_INPUT_TYPE :: _c.int;
    PT_POINTER :: 1;
    PT_TOUCH :: 2;
    PT_PEN :: 3;
    PT_MOUSE :: 4;
    PT_TOUCHPAD :: 5;
/* } */
;

POINTER_INPUT_TYPE :: DWORD;

POINTER_FLAGS :: UINT32;

/* POINTER_BUTTON_CHANGE_TYPE :: enum { */
POINTER_BUTTON_CHANGE_TYPE :: _c.int;
    POINTER_CHANGE_NONE :: 0;
    POINTER_CHANGE_FIRSTBUTTON_DOWN :: POINTER_CHANGE_NONE + 1;
    POINTER_CHANGE_FIRSTBUTTON_UP :: POINTER_CHANGE_FIRSTBUTTON_DOWN + 1;
    POINTER_CHANGE_SECONDBUTTON_DOWN :: POINTER_CHANGE_FIRSTBUTTON_UP + 1;
    POINTER_CHANGE_SECONDBUTTON_UP :: POINTER_CHANGE_SECONDBUTTON_DOWN + 1;
    POINTER_CHANGE_THIRDBUTTON_DOWN :: POINTER_CHANGE_SECONDBUTTON_UP + 1;
    POINTER_CHANGE_THIRDBUTTON_UP :: POINTER_CHANGE_THIRDBUTTON_DOWN + 1;
    POINTER_CHANGE_FOURTHBUTTON_DOWN :: POINTER_CHANGE_THIRDBUTTON_UP + 1;
    POINTER_CHANGE_FOURTHBUTTON_UP :: POINTER_CHANGE_FOURTHBUTTON_DOWN + 1;
    POINTER_CHANGE_FIFTHBUTTON_DOWN :: POINTER_CHANGE_FOURTHBUTTON_UP + 1;
    POINTER_CHANGE_FIFTHBUTTON_UP :: POINTER_CHANGE_FIFTHBUTTON_DOWN + 1;
/* } */
;

POINTER_INFO :: struct {
    pointerType           : POINTER_INPUT_TYPE,
    pointerId             : UINT32,
    frameId               : UINT32,
    pointerFlags          : POINTER_FLAGS,
    sourceDevice          : HANDLE,
    hwndTarget            : HWND,
    ptPixelLocation       : POINT,
    ptHimetricLocation    : POINT,
    ptPixelLocationRaw    : POINT,
    ptHimetricLocationRaw : POINT,
    dwTime                : DWORD,
    historyCount          : UINT32,
    InputData             : INT32,
    dwKeyStates           : DWORD,
    PerformanceCount      : UINT64,
    ButtonChangeType      : POINTER_BUTTON_CHANGE_TYPE,
};

TOUCH_FLAGS :: UINT32;

TOUCH_MASK :: UINT32;

POINTER_TOUCH_INFO :: struct {
    pointerInfo  : POINTER_INFO,
    touchFlags   : TOUCH_FLAGS,
    touchMask    : TOUCH_MASK,
    rcContact    : RECT,
    rcContactRaw : RECT,
    orientation  : UINT32,
    pressure     : UINT32,
};

PEN_FLAGS :: UINT32;

PEN_MASK :: UINT32;

POINTER_PEN_INFO :: struct {
    pointerInfo : POINTER_INFO,
    penFlags    : PEN_FLAGS,
    penMask     : PEN_MASK,
    pressure    : UINT32,
    rotation    : UINT32,
    tiltX       : INT32,
    tiltY       : INT32,
};

/* POINTER_FEEDBACK_MODE :: enum { */
POINTER_FEEDBACK_MODE :: _c.int;
    POINTER_FEEDBACK_DEFAULT :: 1;
    POINTER_FEEDBACK_INDIRECT :: 2;
    POINTER_FEEDBACK_NONE :: 3;
/* } */
;

USAGE_PROPERTIES :: struct {
    level           : USHORT,
    page            : USHORT,
    usage           : USHORT,
    logicalMinimum  : INT32,
    logicalMaximum  : INT32,
    unit            : USHORT,
    exponent        : USHORT,
    count           : BYTE,
    physicalMinimum : INT32,
    physicalMaximum : INT32,
};
PUSAGE_PROPERTIES :: ^USAGE_PROPERTIES;

POINTER_TYPE_INFO :: struct {
    type : POINTER_INPUT_TYPE,
    u : struct #raw_union {
        touchInfo : POINTER_TOUCH_INFO,
        penInfo   : POINTER_PEN_INFO,
    },
};
PPOINTER_TYPE_INFO :: ^POINTER_TYPE_INFO;

INPUT_INJECTION_VALUE :: struct {
    page  : USHORT,
    usage : USHORT,
    value : INT32,
    index : USHORT,
};
PINPUT_INJECTION_VALUE :: ^INPUT_INJECTION_VALUE;

HSYNTHETICPOINTERDEVICE__ :: struct {
    unused : _c.int,
};

HSYNTHETICPOINTERDEVICE :: ^HSYNTHETICPOINTERDEVICE__;

TOUCH_HIT_TESTING_PROXIMITY_EVALUATION :: struct {
    score         : UINT16,
    adjustedPoint : POINT,
};
PTOUCH_HIT_TESTING_PROXIMITY_EVALUATION :: ^TOUCH_HIT_TESTING_PROXIMITY_EVALUATION;

TOUCH_HIT_TESTING_INPUT :: struct {
    pointerId              : UINT32,
    point                  : POINT,
    boundingBox            : RECT,
    nonOccludedBoundingBox : RECT,
    orientation            : UINT32,
};
PTOUCH_HIT_TESTING_INPUT :: ^TOUCH_HIT_TESTING_INPUT;

/* FEEDBACK_TYPE :: enum { */
FEEDBACK_TYPE :: _c.int;
    FEEDBACK_TOUCH_CONTACTVISUALIZATION :: 1;
    FEEDBACK_PEN_BARRELVISUALIZATION :: 2;
    FEEDBACK_PEN_TAP :: 3;
    FEEDBACK_PEN_DOUBLETAP :: 4;
    FEEDBACK_PEN_PRESSANDHOLD :: 5;
    FEEDBACK_PEN_RIGHTTAP :: 6;
    FEEDBACK_TOUCH_TAP :: 7;
    FEEDBACK_TOUCH_DOUBLETAP :: 8;
    FEEDBACK_TOUCH_PRESSANDHOLD :: 9;
    FEEDBACK_TOUCH_RIGHTTAP :: 10;
    FEEDBACK_GESTURE_PRESSANDTAP :: 11;
    FEEDBACK_MAX :: 0xFFFFFFFF;
/* } */
;

INPUT_TRANSFORM :: struct {
    u : struct #raw_union {
        s : struct {
            _11 : _c.float,
            _12 : _c.float,
            _13 : _c.float,
            _14 : _c.float,
            _21 : _c.float,
            _22 : _c.float,
            _23 : _c.float,
            _24 : _c.float,
            _31 : _c.float,
            _32 : _c.float,
            _33 : _c.float,
            _34 : _c.float,
            _41 : _c.float,
            _42 : _c.float,
            _43 : _c.float,
            _44 : _c.float,
        },
        m : [4][4]_c.float,
    },
};

LASTINPUTINFO :: struct {
    cbSize : UINT,
    dwTime : DWORD,
};
PLASTINPUTINFO :: ^LASTINPUTINFO;

TPMPARAMS :: struct {
    cbSize    : UINT,
    rcExclude : RECT,
};

LPTPMPARAMS :: ^TPMPARAMS;

MENUINFO :: struct {
    cbSize          : DWORD,
    fMask           : DWORD,
    dwStyle         : DWORD,
    cyMax           : UINT,
    hbrBack         : HBRUSH,
    dwContextHelpID : DWORD,
    dwMenuData      : ULONG_PTR,
};
LPMENUINFO :: ^MENUINFO;

LPCMENUINFO :: ^MENUINFO;

MENUGETOBJECTINFO :: struct {
    dwFlags : DWORD,
    uPos    : UINT,
    hmenu   : HMENU,
    riid    : PVOID,
    pvObj   : PVOID,
};
PMENUGETOBJECTINFO :: ^MENUGETOBJECTINFO;

MENUITEMINFOA :: struct {
    cbSize        : UINT,
    fMask         : UINT,
    fType         : UINT,
    fState        : UINT,
    wID           : UINT,
    hSubMenu      : HMENU,
    hbmpChecked   : HBITMAP,
    hbmpUnchecked : HBITMAP,
    dwItemData    : ULONG_PTR,
    dwTypeData    : LPSTR,
    cch           : UINT,
    hbmpItem      : HBITMAP,
};
LPMENUITEMINFOA :: ^MENUITEMINFOA;

MENUITEMINFOW :: struct {
    cbSize        : UINT,
    fMask         : UINT,
    fType         : UINT,
    fState        : UINT,
    wID           : UINT,
    hSubMenu      : HMENU,
    hbmpChecked   : HBITMAP,
    hbmpUnchecked : HBITMAP,
    dwItemData    : ULONG_PTR,
    dwTypeData    : LPWSTR,
    cch           : UINT,
    hbmpItem      : HBITMAP,
};
LPMENUITEMINFOW :: ^MENUITEMINFOW;

MENUITEMINFO :: MENUITEMINFOA;

LPMENUITEMINFO :: LPMENUITEMINFOA;

LPCMENUITEMINFOA :: ^MENUITEMINFOA;

LPCMENUITEMINFOW :: ^MENUITEMINFOW;

LPCMENUITEMINFO :: LPCMENUITEMINFOA;

DROPSTRUCT :: struct {
    hwndSource    : HWND,
    hwndSink      : HWND,
    wFmt          : DWORD,
    dwData        : ULONG_PTR,
    ptDrop        : POINT,
    dwControlData : DWORD,
};
PDROPSTRUCT :: ^DROPSTRUCT;
LPDROPSTRUCT :: ^DROPSTRUCT;

DRAWTEXTPARAMS :: struct {
    cbSize        : UINT,
    iTabLength    : _c.int,
    iLeftMargin   : _c.int,
    iRightMargin  : _c.int,
    uiLengthDrawn : UINT,
};
LPDRAWTEXTPARAMS :: ^DRAWTEXTPARAMS;

HELPINFO :: struct {
    cbSize       : UINT,
    iContextType : _c.int,
    iCtrlId      : _c.int,
    hItemHandle  : HANDLE,
    dwContextId  : DWORD_PTR,
    MousePos     : POINT,
};
LPHELPINFO :: ^HELPINFO;

MSGBOXCALLBACK :: proc "stdcall" (lpHelpInfo : LPHELPINFO);

MSGBOXPARAMSA :: struct {
    cbSize             : UINT,
    hwndOwner          : HWND,
    hInstance          : HINSTANCE,
    lpszText           : LPCSTR,
    lpszCaption        : LPCSTR,
    dwStyle            : DWORD,
    lpszIcon           : LPCSTR,
    dwContextHelpId    : DWORD_PTR,
    lpfnMsgBoxCallback : MSGBOXCALLBACK,
    dwLanguageId       : DWORD,
};
PMSGBOXPARAMSA :: ^MSGBOXPARAMSA;
LPMSGBOXPARAMSA :: ^MSGBOXPARAMSA;

MSGBOXPARAMSW :: struct {
    cbSize             : UINT,
    hwndOwner          : HWND,
    hInstance          : HINSTANCE,
    lpszText           : LPCWSTR,
    lpszCaption        : LPCWSTR,
    dwStyle            : DWORD,
    lpszIcon           : LPCWSTR,
    dwContextHelpId    : DWORD_PTR,
    lpfnMsgBoxCallback : MSGBOXCALLBACK,
    dwLanguageId       : DWORD,
};
PMSGBOXPARAMSW :: ^MSGBOXPARAMSW;
LPMSGBOXPARAMSW :: ^MSGBOXPARAMSW;

MSGBOXPARAMS :: MSGBOXPARAMSA;

PMSGBOXPARAMS :: PMSGBOXPARAMSA;

LPMSGBOXPARAMS :: LPMSGBOXPARAMSA;

MENUITEMTEMPLATEHEADER :: struct {
    versionNumber : WORD,
    offset        : WORD,
};
PMENUITEMTEMPLATEHEADER :: ^MENUITEMTEMPLATEHEADER;

MENUITEMTEMPLATE :: struct {
    mtOption : WORD,
    mtID     : WORD,
    mtString : [1]WCHAR,
};
PMENUITEMTEMPLATE :: ^MENUITEMTEMPLATE;

ICONINFO :: struct {
    fIcon    : BOOL,
    xHotspot : DWORD,
    yHotspot : DWORD,
    hbmMask  : HBITMAP,
    hbmColor : HBITMAP,
};

PICONINFO :: ^ICONINFO;

CURSORSHAPE :: struct {
    xHotSpot  : _c.int,
    yHotSpot  : _c.int,
    cx        : _c.int,
    cy        : _c.int,
    cbWidth   : _c.int,
    Planes    : BYTE,
    BitsPixel : BYTE,
};
LPCURSORSHAPE :: ^CURSORSHAPE;

ICONINFOEXA :: struct {
    cbSize    : DWORD,
    fIcon     : BOOL,
    xHotspot  : DWORD,
    yHotspot  : DWORD,
    hbmMask   : HBITMAP,
    hbmColor  : HBITMAP,
    wResID    : WORD,
    szModName : [260]CHAR,
    szResName : [260]CHAR,
};
PICONINFOEXA :: ^ICONINFOEXA;

ICONINFOEXW :: struct {
    cbSize    : DWORD,
    fIcon     : BOOL,
    xHotspot  : DWORD,
    yHotspot  : DWORD,
    hbmMask   : HBITMAP,
    hbmColor  : HBITMAP,
    wResID    : WORD,
    szModName : [260]WCHAR,
    szResName : [260]WCHAR,
};
PICONINFOEXW :: ^ICONINFOEXW;

ICONINFOEX :: ICONINFOEXA;

PICONINFOEX :: PICONINFOEXA;

/* EDIT_CONTROL_FEATURE :: enum { */
EDIT_CONTROL_FEATURE :: _c.int;
    EDIT_CONTROL_FEATURE_ENTERPRISE_DATA_PROTECTION_PASTE_SUPPORT :: 0;
    EDIT_CONTROL_FEATURE_PASTE_NOTIFICATIONS :: 1;
/* } */
;

SCROLLINFO :: struct {
    cbSize    : UINT,
    fMask     : UINT,
    nMin      : _c.int,
    nMax      : _c.int,
    nPage     : UINT,
    nPos      : _c.int,
    nTrackPos : _c.int,
};
LPSCROLLINFO :: ^SCROLLINFO;

LPCSCROLLINFO :: ^SCROLLINFO;

MDICREATESTRUCTA :: struct {
    szClass : LPCSTR,
    szTitle : LPCSTR,
    hOwner  : HANDLE,
    x       : _c.int,
    y       : _c.int,
    cx      : _c.int,
    cy      : _c.int,
    style   : DWORD,
    lParam  : LPARAM,
};
LPMDICREATESTRUCTA :: ^MDICREATESTRUCTA;

MDICREATESTRUCTW :: struct {
    szClass : LPCWSTR,
    szTitle : LPCWSTR,
    hOwner  : HANDLE,
    x       : _c.int,
    y       : _c.int,
    cx      : _c.int,
    cy      : _c.int,
    style   : DWORD,
    lParam  : LPARAM,
};
LPMDICREATESTRUCTW :: ^MDICREATESTRUCTW;

MDICREATESTRUCT :: MDICREATESTRUCTA;

LPMDICREATESTRUCT :: LPMDICREATESTRUCTA;

CLIENTCREATESTRUCT :: struct {
    hWindowMenu  : HANDLE,
    idFirstChild : UINT,
};
LPCLIENTCREATESTRUCT :: ^CLIENTCREATESTRUCT;

HELPPOLY :: DWORD;

MULTIKEYHELPA :: struct {
    mkSize      : DWORD,
    mkKeylist   : CHAR,
    szKeyphrase : [1]CHAR,
};
PMULTIKEYHELPA :: ^MULTIKEYHELPA;
LPMULTIKEYHELPA :: ^MULTIKEYHELPA;

MULTIKEYHELPW :: struct {
    mkSize      : DWORD,
    mkKeylist   : WCHAR,
    szKeyphrase : [1]WCHAR,
};
PMULTIKEYHELPW :: ^MULTIKEYHELPW;
LPMULTIKEYHELPW :: ^MULTIKEYHELPW;

MULTIKEYHELP :: MULTIKEYHELPA;

PMULTIKEYHELP :: PMULTIKEYHELPA;

LPMULTIKEYHELP :: LPMULTIKEYHELPA;

HELPWININFOA :: struct {
    wStructSize : _c.int,
    x           : _c.int,
    y           : _c.int,
    dx          : _c.int,
    dy          : _c.int,
    wMax        : _c.int,
    rgchMember  : [2]CHAR,
};
PHELPWININFOA :: ^HELPWININFOA;
LPHELPWININFOA :: ^HELPWININFOA;

HELPWININFOW :: struct {
    wStructSize : _c.int,
    x           : _c.int,
    y           : _c.int,
    dx          : _c.int,
    dy          : _c.int,
    wMax        : _c.int,
    rgchMember  : [2]WCHAR,
};
PHELPWININFOW :: ^HELPWININFOW;
LPHELPWININFOW :: ^HELPWININFOW;

HELPWININFO :: HELPWININFOA;

PHELPWININFO :: PHELPWININFOA;

LPHELPWININFO :: LPHELPWININFOA;

TOUCHPREDICTIONPARAMETERS :: struct {
    cbSize          : UINT,
    dwLatency       : UINT,
    dwSampleTime    : UINT,
    bUseHWTimeStamp : UINT,
};
PTOUCHPREDICTIONPARAMETERS :: ^TOUCHPREDICTIONPARAMETERS;

/* HANDEDNESS :: enum { */
HANDEDNESS :: _c.int;
    HANDEDNESS_LEFT :: 0;
    HANDEDNESS_RIGHT :: HANDEDNESS_LEFT + 1;
/* } */
PHANDEDNESS :: ^HANDEDNESS;

NONCLIENTMETRICSA :: struct {
    cbSize             : UINT,
    iBorderWidth       : _c.int,
    iScrollWidth       : _c.int,
    iScrollHeight      : _c.int,
    iCaptionWidth      : _c.int,
    iCaptionHeight     : _c.int,
    lfCaptionFont      : LOGFONTA,
    iSmCaptionWidth    : _c.int,
    iSmCaptionHeight   : _c.int,
    lfSmCaptionFont    : LOGFONTA,
    iMenuWidth         : _c.int,
    iMenuHeight        : _c.int,
    lfMenuFont         : LOGFONTA,
    lfStatusFont       : LOGFONTA,
    lfMessageFont      : LOGFONTA,
    iPaddedBorderWidth : _c.int,
};
PNONCLIENTMETRICSA :: ^NONCLIENTMETRICSA;
LPNONCLIENTMETRICSA :: ^NONCLIENTMETRICSA;

NONCLIENTMETRICSW :: struct {
    cbSize             : UINT,
    iBorderWidth       : _c.int,
    iScrollWidth       : _c.int,
    iScrollHeight      : _c.int,
    iCaptionWidth      : _c.int,
    iCaptionHeight     : _c.int,
    lfCaptionFont      : LOGFONTW,
    iSmCaptionWidth    : _c.int,
    iSmCaptionHeight   : _c.int,
    lfSmCaptionFont    : LOGFONTW,
    iMenuWidth         : _c.int,
    iMenuHeight        : _c.int,
    lfMenuFont         : LOGFONTW,
    lfStatusFont       : LOGFONTW,
    lfMessageFont      : LOGFONTW,
    iPaddedBorderWidth : _c.int,
};
PNONCLIENTMETRICSW :: ^NONCLIENTMETRICSW;
LPNONCLIENTMETRICSW :: ^NONCLIENTMETRICSW;

NONCLIENTMETRICS :: NONCLIENTMETRICSA;

PNONCLIENTMETRICS :: PNONCLIENTMETRICSA;

LPNONCLIENTMETRICS :: LPNONCLIENTMETRICSA;

MINIMIZEDMETRICS :: struct {
    cbSize   : UINT,
    iWidth   : _c.int,
    iHorzGap : _c.int,
    iVertGap : _c.int,
    iArrange : _c.int,
};
PMINIMIZEDMETRICS :: ^MINIMIZEDMETRICS;
LPMINIMIZEDMETRICS :: ^MINIMIZEDMETRICS;

ICONMETRICSA :: struct {
    cbSize       : UINT,
    iHorzSpacing : _c.int,
    iVertSpacing : _c.int,
    iTitleWrap   : _c.int,
    lfFont       : LOGFONTA,
};
PICONMETRICSA :: ^ICONMETRICSA;
LPICONMETRICSA :: ^ICONMETRICSA;

ICONMETRICSW :: struct {
    cbSize       : UINT,
    iHorzSpacing : _c.int,
    iVertSpacing : _c.int,
    iTitleWrap   : _c.int,
    lfFont       : LOGFONTW,
};
PICONMETRICSW :: ^ICONMETRICSW;
LPICONMETRICSW :: ^ICONMETRICSW;

ICONMETRICS :: ICONMETRICSA;

PICONMETRICS :: PICONMETRICSA;

LPICONMETRICS :: LPICONMETRICSA;

ANIMATIONINFO :: struct {
    cbSize      : UINT,
    iMinAnimate : _c.int,
};
LPANIMATIONINFO :: ^ANIMATIONINFO;

SERIALKEYSA :: struct {
    cbSize         : UINT,
    dwFlags        : DWORD,
    lpszActivePort : LPSTR,
    lpszPort       : LPSTR,
    iBaudRate      : UINT,
    iPortState     : UINT,
    iActive        : UINT,
};
LPSERIALKEYSA :: ^SERIALKEYSA;

SERIALKEYSW :: struct {
    cbSize         : UINT,
    dwFlags        : DWORD,
    lpszActivePort : LPWSTR,
    lpszPort       : LPWSTR,
    iBaudRate      : UINT,
    iPortState     : UINT,
    iActive        : UINT,
};
LPSERIALKEYSW :: ^SERIALKEYSW;

SERIALKEYS :: SERIALKEYSA;

LPSERIALKEYS :: LPSERIALKEYSA;

HIGHCONTRASTA :: struct {
    cbSize            : UINT,
    dwFlags           : DWORD,
    lpszDefaultScheme : LPSTR,
};
LPHIGHCONTRASTA :: ^HIGHCONTRASTA;

HIGHCONTRASTW :: struct {
    cbSize            : UINT,
    dwFlags           : DWORD,
    lpszDefaultScheme : LPWSTR,
};
LPHIGHCONTRASTW :: ^HIGHCONTRASTW;

HIGHCONTRAST :: HIGHCONTRASTA;

LPHIGHCONTRAST :: LPHIGHCONTRASTA;

VIDEOPARAMETERS :: struct {
    Guid                  : GUID,
    dwOffset              : ULONG,
    dwCommand             : ULONG,
    dwFlags               : ULONG,
    dwMode                : ULONG,
    dwTVStandard          : ULONG,
    dwAvailableModes      : ULONG,
    dwAvailableTVStandard : ULONG,
    dwFlickerFilter       : ULONG,
    dwOverScanX           : ULONG,
    dwOverScanY           : ULONG,
    dwMaxUnscaledX        : ULONG,
    dwMaxUnscaledY        : ULONG,
    dwPositionX           : ULONG,
    dwPositionY           : ULONG,
    dwBrightness          : ULONG,
    dwContrast            : ULONG,
    dwCPType              : ULONG,
    dwCPCommand           : ULONG,
    dwCPStandard          : ULONG,
    dwCPKey               : ULONG,
    bCP_APSTriggerBits    : ULONG,
    bOEMCopyProtection    : [256]UCHAR,
};
PVIDEOPARAMETERS :: ^VIDEOPARAMETERS;
LPVIDEOPARAMETERS :: ^VIDEOPARAMETERS;

FILTERKEYS :: struct {
    cbSize      : UINT,
    dwFlags     : DWORD,
    iWaitMSec   : DWORD,
    iDelayMSec  : DWORD,
    iRepeatMSec : DWORD,
    iBounceMSec : DWORD,
};
LPFILTERKEYS :: ^FILTERKEYS;

STICKYKEYS :: struct {
    cbSize  : UINT,
    dwFlags : DWORD,
};
LPSTICKYKEYS :: ^STICKYKEYS;

MOUSEKEYS :: struct {
    cbSize          : UINT,
    dwFlags         : DWORD,
    iMaxSpeed       : DWORD,
    iTimeToMaxSpeed : DWORD,
    iCtrlSpeed      : DWORD,
    dwReserved1     : DWORD,
    dwReserved2     : DWORD,
};
LPMOUSEKEYS :: ^MOUSEKEYS;

ACCESSTIMEOUT :: struct {
    cbSize       : UINT,
    dwFlags      : DWORD,
    iTimeOutMSec : DWORD,
};
LPACCESSTIMEOUT :: ^ACCESSTIMEOUT;

SOUNDSENTRYA :: struct {
    cbSize                 : UINT,
    dwFlags                : DWORD,
    iFSTextEffect          : DWORD,
    iFSTextEffectMSec      : DWORD,
    iFSTextEffectColorBits : DWORD,
    iFSGrafEffect          : DWORD,
    iFSGrafEffectMSec      : DWORD,
    iFSGrafEffectColor     : DWORD,
    iWindowsEffect         : DWORD,
    iWindowsEffectMSec     : DWORD,
    lpszWindowsEffectDLL   : LPSTR,
    iWindowsEffectOrdinal  : DWORD,
};
LPSOUNDSENTRYA :: ^SOUNDSENTRYA;

SOUNDSENTRYW :: struct {
    cbSize                 : UINT,
    dwFlags                : DWORD,
    iFSTextEffect          : DWORD,
    iFSTextEffectMSec      : DWORD,
    iFSTextEffectColorBits : DWORD,
    iFSGrafEffect          : DWORD,
    iFSGrafEffectMSec      : DWORD,
    iFSGrafEffectColor     : DWORD,
    iWindowsEffect         : DWORD,
    iWindowsEffectMSec     : DWORD,
    lpszWindowsEffectDLL   : LPWSTR,
    iWindowsEffectOrdinal  : DWORD,
};
LPSOUNDSENTRYW :: ^SOUNDSENTRYW;

SOUNDSENTRY :: SOUNDSENTRYA;

LPSOUNDSENTRY :: LPSOUNDSENTRYA;

TOGGLEKEYS :: struct {
    cbSize  : UINT,
    dwFlags : DWORD,
};
LPTOGGLEKEYS :: ^TOGGLEKEYS;

AUDIODESCRIPTION :: struct {
    cbSize  : UINT,
    Enabled : BOOL,
    Locale  : LCID,
};
LPAUDIODESCRIPTION :: ^AUDIODESCRIPTION;

MONITORINFO :: struct {
    cbSize    : DWORD,
    rcMonitor : RECT,
    rcWork    : RECT,
    dwFlags   : DWORD,
};
LPMONITORINFO :: ^MONITORINFO;

MONITORINFOEXA :: struct {
    s        : MONITORINFO,
    szDevice : [32]CHAR,
};
LPMONITORINFOEXA :: ^MONITORINFOEXA;

MONITORINFOEXW :: struct {
    s        : MONITORINFO,
    szDevice : [32]WCHAR,
};
LPMONITORINFOEXW :: ^MONITORINFOEXW;

MONITORINFOEX :: MONITORINFOEXA;

LPMONITORINFOEX :: LPMONITORINFOEXA;

MONITORENUMPROC :: (proc "stdcall" (HMONITOR, HDC, LPRECT, LPARAM) -> BOOL);

WINEVENTPROC :: proc "stdcall" (hWinEventHook : HWINEVENTHOOK, event : DWORD, hwnd : HWND, idObject : LONG, idChild : LONG, idEventThread : DWORD, dwmsEventTime : DWORD);

GUITHREADINFO :: struct {
    cbSize        : DWORD,
    flags         : DWORD,
    hwndActive    : HWND,
    hwndFocus     : HWND,
    hwndCapture   : HWND,
    hwndMenuOwner : HWND,
    hwndMoveSize  : HWND,
    hwndCaret     : HWND,
    rcCaret       : RECT,
};
PGUITHREADINFO :: ^GUITHREADINFO;
LPGUITHREADINFO :: ^GUITHREADINFO;

CURSORINFO :: struct {
    cbSize      : DWORD,
    flags       : DWORD,
    hCursor     : HCURSOR,
    ptScreenPos : POINT,
};
PCURSORINFO :: ^CURSORINFO;
LPCURSORINFO :: ^CURSORINFO;

WINDOWINFO :: struct {
    cbSize          : DWORD,
    rcWindow        : RECT,
    rcClient        : RECT,
    dwStyle         : DWORD,
    dwExStyle       : DWORD,
    dwWindowStatus  : DWORD,
    cxWindowBorders : UINT,
    cyWindowBorders : UINT,
    atomWindowType  : ATOM,
    wCreatorVersion : WORD,
};
PWINDOWINFO :: ^WINDOWINFO;
LPWINDOWINFO :: ^WINDOWINFO;

TITLEBARINFO :: struct {
    cbSize     : DWORD,
    rcTitleBar : RECT,
    rgstate    : [5 + 1]DWORD,
};
PTITLEBARINFO :: ^TITLEBARINFO;
LPTITLEBARINFO :: ^TITLEBARINFO;

TITLEBARINFOEX :: struct {
    cbSize     : DWORD,
    rcTitleBar : RECT,
    rgstate    : [5 + 1]DWORD,
    rgrect     : [5 + 1]RECT,
};
PTITLEBARINFOEX :: ^TITLEBARINFOEX;
LPTITLEBARINFOEX :: ^TITLEBARINFOEX;

MENUBARINFO :: struct {
    cbSize      : DWORD,
    rcBar       : RECT,
    hMenu       : HMENU,
    hwndMenu    : HWND,
    using _ : bit_field {
        fBarFocused : 1,
        fFocused    : 1,
    },
};
PMENUBARINFO :: ^MENUBARINFO;
LPMENUBARINFO :: ^MENUBARINFO;

SCROLLBARINFO :: struct {
    cbSize        : DWORD,
    rcScrollBar   : RECT,
    dxyLineButton : _c.int,
    xyThumbTop    : _c.int,
    xyThumbBottom : _c.int,
    reserved      : _c.int,
    rgstate       : [5 + 1]DWORD,
};
PSCROLLBARINFO :: ^SCROLLBARINFO;
LPSCROLLBARINFO :: ^SCROLLBARINFO;

COMBOBOXINFO :: struct {
    cbSize      : DWORD,
    rcItem      : RECT,
    rcButton    : RECT,
    stateButton : DWORD,
    hwndCombo   : HWND,
    hwndItem    : HWND,
    hwndList    : HWND,
};
PCOMBOBOXINFO :: ^COMBOBOXINFO;
LPCOMBOBOXINFO :: ^COMBOBOXINFO;

ALTTABINFO :: struct {
    cbSize    : DWORD,
    cItems    : _c.int,
    cColumns  : _c.int,
    cRows     : _c.int,
    iColFocus : _c.int,
    iRowFocus : _c.int,
    cxItem    : _c.int,
    cyItem    : _c.int,
    ptStart   : POINT,
};
PALTTABINFO :: ^ALTTABINFO;
LPALTTABINFO :: ^ALTTABINFO;

HRAWINPUT__ :: struct {
    unused : _c.int,
};

HRAWINPUT :: ^HRAWINPUT__;

RAWINPUTHEADER :: struct {
    dwType  : DWORD,
    dwSize  : DWORD,
    hDevice : HANDLE,
    wParam  : WPARAM,
};
PRAWINPUTHEADER :: ^RAWINPUTHEADER;
LPRAWINPUTHEADER :: ^RAWINPUTHEADER;

RAWMOUSE :: struct {
    usFlags            : USHORT,
    u : struct #raw_union {
        ulButtons : ULONG,
        s : struct {
            usButtonFlags : USHORT,
            usButtonData  : USHORT,
        },
    },
    ulRawButtons       : ULONG,
    lLastX             : LONG,
    lLastY             : LONG,
    ulExtraInformation : ULONG,
};
PRAWMOUSE :: ^RAWMOUSE;
LPRAWMOUSE :: ^RAWMOUSE;

RAWKEYBOARD :: struct {
    MakeCode         : USHORT,
    Flags            : USHORT,
    Reserved         : USHORT,
    VKey             : USHORT,
    Message          : UINT,
    ExtraInformation : ULONG,
};
PRAWKEYBOARD :: ^RAWKEYBOARD;
LPRAWKEYBOARD :: ^RAWKEYBOARD;

RAWHID :: struct {
    dwSizeHid : DWORD,
    dwCount   : DWORD,
    bRawData  : [1]BYTE,
};
PRAWHID :: ^RAWHID;
LPRAWHID :: ^RAWHID;

RAWINPUT :: struct {
    header : RAWINPUTHEADER,
    data : struct #raw_union {
        mouse    : RAWMOUSE,
        keyboard : RAWKEYBOARD,
        hid      : RAWHID,
    },
};
PRAWINPUT :: ^RAWINPUT;
LPRAWINPUT :: ^RAWINPUT;

RID_DEVICE_INFO_MOUSE :: struct {
    dwId                : DWORD,
    dwNumberOfButtons   : DWORD,
    dwSampleRate        : DWORD,
    fHasHorizontalWheel : BOOL,
};
PRID_DEVICE_INFO_MOUSE :: ^RID_DEVICE_INFO_MOUSE;

RID_DEVICE_INFO_KEYBOARD :: struct {
    dwType                 : DWORD,
    dwSubType              : DWORD,
    dwKeyboardMode         : DWORD,
    dwNumberOfFunctionKeys : DWORD,
    dwNumberOfIndicators   : DWORD,
    dwNumberOfKeysTotal    : DWORD,
};
PRID_DEVICE_INFO_KEYBOARD :: ^RID_DEVICE_INFO_KEYBOARD;

RID_DEVICE_INFO_HID :: struct {
    dwVendorId      : DWORD,
    dwProductId     : DWORD,
    dwVersionNumber : DWORD,
    usUsagePage     : USHORT,
    usUsage         : USHORT,
};
PRID_DEVICE_INFO_HID :: ^RID_DEVICE_INFO_HID;

RID_DEVICE_INFO :: struct {
    cbSize : DWORD,
    dwType : DWORD,
    u : struct #raw_union {
        mouse    : RID_DEVICE_INFO_MOUSE,
        keyboard : RID_DEVICE_INFO_KEYBOARD,
        hid      : RID_DEVICE_INFO_HID,
    },
};
PRID_DEVICE_INFO :: ^RID_DEVICE_INFO;
LPRID_DEVICE_INFO :: ^RID_DEVICE_INFO;

RAWINPUTDEVICE :: struct {
    usUsagePage : USHORT,
    usUsage     : USHORT,
    dwFlags     : DWORD,
    hwndTarget  : HWND,
};
PRAWINPUTDEVICE :: ^RAWINPUTDEVICE;
LPRAWINPUTDEVICE :: ^RAWINPUTDEVICE;

PCRAWINPUTDEVICE :: ^RAWINPUTDEVICE;

RAWINPUTDEVICELIST :: struct {
    hDevice : HANDLE,
    dwType  : DWORD,
};
PRAWINPUTDEVICELIST :: ^RAWINPUTDEVICELIST;

/* POINTER_DEVICE_TYPE :: enum { */
POINTER_DEVICE_TYPE :: _c.int;
    POINTER_DEVICE_TYPE_INTEGRATED_PEN :: 0x00000001;
    POINTER_DEVICE_TYPE_EXTERNAL_PEN :: 0x00000002;
    POINTER_DEVICE_TYPE_TOUCH :: 0x00000003;
    POINTER_DEVICE_TYPE_TOUCH_PAD :: 0x00000004;
    POINTER_DEVICE_TYPE_MAX :: 0xFFFFFFFF;
/* } */
;

POINTER_DEVICE_INFO :: struct {
    displayOrientation : DWORD,
    device             : HANDLE,
    pointerDeviceType  : POINTER_DEVICE_TYPE,
    monitor            : HMONITOR,
    startingCursorId   : ULONG,
    maxActiveContacts  : USHORT,
    productString      : [520]WCHAR,
};

POINTER_DEVICE_PROPERTY :: struct {
    logicalMin   : INT32,
    logicalMax   : INT32,
    physicalMin  : INT32,
    physicalMax  : INT32,
    unit         : UINT32,
    unitExponent : UINT32,
    usagePageId  : USHORT,
    usageId      : USHORT,
};

/* POINTER_DEVICE_CURSOR_TYPE :: enum { */
POINTER_DEVICE_CURSOR_TYPE :: _c.int;
    POINTER_DEVICE_CURSOR_TYPE_UNKNOWN :: 0x00000000;
    POINTER_DEVICE_CURSOR_TYPE_TIP :: 0x00000001;
    POINTER_DEVICE_CURSOR_TYPE_ERASER :: 0x00000002;
    POINTER_DEVICE_CURSOR_TYPE_MAX :: 0xFFFFFFFF;
/* } */
;

POINTER_DEVICE_CURSOR_INFO :: struct {
    cursorId : UINT32,
    cursor   : POINTER_DEVICE_CURSOR_TYPE,
};

CHANGEFILTERSTRUCT :: struct {
    cbSize    : DWORD,
    ExtStatus : DWORD,
};
PCHANGEFILTERSTRUCT :: ^CHANGEFILTERSTRUCT;

HGESTUREINFO__ :: struct {
    unused : _c.int,
};

HGESTUREINFO :: ^HGESTUREINFO__;

GESTUREINFO :: struct {
    cbSize       : UINT,
    dwFlags      : DWORD,
    dwID         : DWORD,
    hwndTarget   : HWND,
    ptsLocation  : POINTS,
    dwInstanceID : DWORD,
    dwSequenceID : DWORD,
    ullArguments : ULONGLONG,
    cbExtraArgs  : UINT,
};
PGESTUREINFO :: ^GESTUREINFO;

PCGESTUREINFO :: ^GESTUREINFO;

GESTURENOTIFYSTRUCT :: struct {
    cbSize       : UINT,
    dwFlags      : DWORD,
    hwndTarget   : HWND,
    ptsLocation  : POINTS,
    dwInstanceID : DWORD,
};
PGESTURENOTIFYSTRUCT :: ^GESTURENOTIFYSTRUCT;

GESTURECONFIG :: struct {
    dwID    : DWORD,
    dwWant  : DWORD,
    dwBlock : DWORD,
};
PGESTURECONFIG :: ^GESTURECONFIG;

/* INPUT_MESSAGE_DEVICE_TYPE :: enum { */
INPUT_MESSAGE_DEVICE_TYPE :: _c.int;
    IMDT_UNAVAILABLE :: 0x00000000;
    IMDT_KEYBOARD :: 0x00000001;
    IMDT_MOUSE :: 0x00000002;
    IMDT_TOUCH :: 0x00000004;
    IMDT_PEN :: 0x00000008;
    IMDT_TOUCHPAD :: 0x00000010;
/* } */
;

/* INPUT_MESSAGE_ORIGIN_ID :: enum { */
INPUT_MESSAGE_ORIGIN_ID :: _c.int;
    IMO_UNAVAILABLE :: 0x00000000;
    IMO_HARDWARE :: 0x00000001;
    IMO_INJECTED :: 0x00000002;
    IMO_SYSTEM :: 0x00000004;
/* } */
;

INPUT_MESSAGE_SOURCE :: struct {
    deviceType : INPUT_MESSAGE_DEVICE_TYPE,
    originId   : INPUT_MESSAGE_ORIGIN_ID,
};

/* AR_STATE :: enum { */
AR_STATE :: _c.int;
    AR_ENABLED :: 0x0;
    AR_DISABLED :: 0x1;
    AR_SUPPRESSED :: 0x2;
    AR_REMOTESESSION :: 0x4;
    AR_MULTIMON :: 0x8;
    AR_NOSENSOR :: 0x10;
    AR_NOT_SUPPORTED :: 0x20;
    AR_DOCKED :: 0x40;
    AR_LAPTOP :: 0x80;
/* } */
PAR_STATE :: ^AR_STATE;

/* ORIENTATION_PREFERENCE :: enum { */
ORIENTATION_PREFERENCE :: _c.int;
    ORIENTATION_PREFERENCE_NONE :: 0x0;
    ORIENTATION_PREFERENCE_LANDSCAPE :: 0x1;
    ORIENTATION_PREFERENCE_PORTRAIT :: 0x2;
    ORIENTATION_PREFERENCE_LANDSCAPE_FLIPPED :: 0x4;
    ORIENTATION_PREFERENCE_PORTRAIT_FLIPPED :: 0x8;
/* } */
;

LGRPID :: DWORD;

LCTYPE :: DWORD;

CALTYPE :: DWORD;

CALID :: DWORD;

CPINFO :: struct {
    MaxCharSize : UINT,
    DefaultChar : [2]BYTE,
    LeadByte    : [12]BYTE,
};
LPCPINFO :: ^CPINFO;

GEOTYPE :: DWORD;

GEOCLASS :: DWORD;

GEOID :: LONG;

CPINFOEXA :: struct {
    MaxCharSize        : UINT,
    DefaultChar        : [2]BYTE,
    LeadByte           : [12]BYTE,
    UnicodeDefaultChar : WCHAR,
    CodePage           : UINT,
    CodePageName       : [260]CHAR,
};
LPCPINFOEXA :: ^CPINFOEXA;

CPINFOEXW :: struct {
    MaxCharSize        : UINT,
    DefaultChar        : [2]BYTE,
    LeadByte           : [12]BYTE,
    UnicodeDefaultChar : WCHAR,
    CodePage           : UINT,
    CodePageName       : [260]WCHAR,
};
LPCPINFOEXW :: ^CPINFOEXW;

CPINFOEX :: CPINFOEXA;

LPCPINFOEX :: LPCPINFOEXA;

NUMBERFMTA :: struct {
    NumDigits     : UINT,
    LeadingZero   : UINT,
    Grouping      : UINT,
    lpDecimalSep  : LPSTR,
    lpThousandSep : LPSTR,
    NegativeOrder : UINT,
};
LPNUMBERFMTA :: ^NUMBERFMTA;

NUMBERFMTW :: struct {
    NumDigits     : UINT,
    LeadingZero   : UINT,
    Grouping      : UINT,
    lpDecimalSep  : LPWSTR,
    lpThousandSep : LPWSTR,
    NegativeOrder : UINT,
};
LPNUMBERFMTW :: ^NUMBERFMTW;

NUMBERFMT :: NUMBERFMTA;

LPNUMBERFMT :: LPNUMBERFMTA;

CURRENCYFMTA :: struct {
    NumDigits        : UINT,
    LeadingZero      : UINT,
    Grouping         : UINT,
    lpDecimalSep     : LPSTR,
    lpThousandSep    : LPSTR,
    NegativeOrder    : UINT,
    PositiveOrder    : UINT,
    lpCurrencySymbol : LPSTR,
};
LPCURRENCYFMTA :: ^CURRENCYFMTA;

CURRENCYFMTW :: struct {
    NumDigits        : UINT,
    LeadingZero      : UINT,
    Grouping         : UINT,
    lpDecimalSep     : LPWSTR,
    lpThousandSep    : LPWSTR,
    NegativeOrder    : UINT,
    PositiveOrder    : UINT,
    lpCurrencySymbol : LPWSTR,
};
LPCURRENCYFMTW :: ^CURRENCYFMTW;

CURRENCYFMT :: CURRENCYFMTA;

LPCURRENCYFMT :: LPCURRENCYFMTA;

/* SYSNLS_FUNCTION :: enum { */
SYSNLS_FUNCTION :: _c.int;
    COMPARE_STRING :: 0x0001;
/* } */
;

NLS_FUNCTION :: DWORD;

NLSVERSIONINFO :: struct {
    dwNLSVersionInfoSize : DWORD,
    dwNLSVersion         : DWORD,
    dwDefinedVersion     : DWORD,
    dwEffectiveId        : DWORD,
    guidCustomVersion    : GUID,
};
LPNLSVERSIONINFO :: ^NLSVERSIONINFO;

NLSVERSIONINFOEX :: struct {
    dwNLSVersionInfoSize : DWORD,
    dwNLSVersion         : DWORD,
    dwDefinedVersion     : DWORD,
    dwEffectiveId        : DWORD,
    guidCustomVersion    : GUID,
};
LPNLSVERSIONINFOEX :: ^NLSVERSIONINFOEX;

/* SYSGEOTYPE :: enum { */
SYSGEOTYPE :: _c.int;
    GEO_NATION :: 0x0001;
    GEO_LATITUDE :: 0x0002;
    GEO_LONGITUDE :: 0x0003;
    GEO_ISO2 :: 0x0004;
    GEO_ISO3 :: 0x0005;
    GEO_RFC1766 :: 0x0006;
    GEO_LCID :: 0x0007;
    GEO_FRIENDLYNAME :: 0x0008;
    GEO_OFFICIALNAME :: 0x0009;
    GEO_TIMEZONES :: 0x000A;
    GEO_OFFICIALLANGUAGES :: 0x000B;
    GEO_ISO_UN_NUMBER :: 0x000C;
    GEO_PARENT :: 0x000D;
    GEO_DIALINGCODE :: 0x000E;
    GEO_CURRENCYCODE :: 0x000F;
    GEO_CURRENCYSYMBOL :: 0x0010;
    GEO_NAME :: 0x0011;
    GEO_ID :: 0x0012;
/* } */
;

/* SYSGEOCLASS :: enum { */
SYSGEOCLASS :: _c.int;
    GEOCLASS_NATION :: 16;
    GEOCLASS_REGION :: 14;
    GEOCLASS_ALL :: 0;
/* } */
;

/* NORM_FORM :: enum { */
NORM_FORM :: _c.int;
    NormalizationOther :: 0;
    NormalizationC :: 0x1;
    NormalizationD :: 0x2;
    NormalizationKC :: 0x5;
    NormalizationKD :: 0x6;
/* } */
;

LANGUAGEGROUP_ENUMPROCA :: (proc "stdcall" (LGRPID, LPSTR, LPSTR, DWORD, LONG_PTR) -> BOOL);

LANGGROUPLOCALE_ENUMPROCA :: (proc "stdcall" (LGRPID, LCID, LPSTR, LONG_PTR) -> BOOL);

UILANGUAGE_ENUMPROCA :: (proc "stdcall" (LPSTR, LONG_PTR) -> BOOL);

CODEPAGE_ENUMPROCA :: (proc "stdcall" (LPSTR) -> BOOL);

DATEFMT_ENUMPROCA :: (proc "stdcall" (LPSTR) -> BOOL);

DATEFMT_ENUMPROCEXA :: (proc "stdcall" (LPSTR, CALID) -> BOOL);

TIMEFMT_ENUMPROCA :: (proc "stdcall" (LPSTR) -> BOOL);

CALINFO_ENUMPROCA :: (proc "stdcall" (LPSTR) -> BOOL);

CALINFO_ENUMPROCEXA :: (proc "stdcall" (LPSTR, CALID) -> BOOL);

LOCALE_ENUMPROCA :: (proc "stdcall" (LPSTR) -> BOOL);

LOCALE_ENUMPROCW :: (proc "stdcall" (LPWSTR) -> BOOL);

LANGUAGEGROUP_ENUMPROCW :: (proc "stdcall" (LGRPID, LPWSTR, LPWSTR, DWORD, LONG_PTR) -> BOOL);

LANGGROUPLOCALE_ENUMPROCW :: (proc "stdcall" (LGRPID, LCID, LPWSTR, LONG_PTR) -> BOOL);

UILANGUAGE_ENUMPROCW :: (proc "stdcall" (LPWSTR, LONG_PTR) -> BOOL);

CODEPAGE_ENUMPROCW :: (proc "stdcall" (LPWSTR) -> BOOL);

DATEFMT_ENUMPROCW :: (proc "stdcall" (LPWSTR) -> BOOL);

DATEFMT_ENUMPROCEXW :: (proc "stdcall" (LPWSTR, CALID) -> BOOL);

TIMEFMT_ENUMPROCW :: (proc "stdcall" (LPWSTR) -> BOOL);

CALINFO_ENUMPROCW :: (proc "stdcall" (LPWSTR) -> BOOL);

CALINFO_ENUMPROCEXW :: (proc "stdcall" (LPWSTR, CALID) -> BOOL);

GEO_ENUMPROC :: (proc "stdcall" (GEOID) -> BOOL);

GEO_ENUMNAMEPROC :: (proc "stdcall" (PWSTR, LPARAM) -> BOOL);

FILEMUIINFO :: struct {
    dwSize               : DWORD,
    dwVersion            : DWORD,
    dwFileType           : DWORD,
    pChecksum            : [16]BYTE,
    pServiceChecksum     : [16]BYTE,
    dwLanguageNameOffset : DWORD,
    dwTypeIDMainSize     : DWORD,
    dwTypeIDMainOffset   : DWORD,
    dwTypeNameMainOffset : DWORD,
    dwTypeIDMUISize      : DWORD,
    dwTypeIDMUIOffset    : DWORD,
    dwTypeNameMUIOffset  : DWORD,
    abBuffer             : [8]BYTE,
};
PFILEMUIINFO :: ^FILEMUIINFO;

CALINFO_ENUMPROCEXEX :: (proc "stdcall" (LPWSTR, CALID, LPWSTR, LPARAM) -> BOOL);

DATEFMT_ENUMPROCEXEX :: (proc "stdcall" (LPWSTR, CALID, LPARAM) -> BOOL);

TIMEFMT_ENUMPROCEX :: (proc "stdcall" (LPWSTR, LPARAM) -> BOOL);

LOCALE_ENUMPROCEX :: (proc "stdcall" (LPWSTR, DWORD, LPARAM) -> BOOL);

COORD :: struct {
    X : SHORT,
    Y : SHORT,
};
PCOORD :: ^COORD;

SMALL_RECT :: struct {
    Left   : SHORT,
    Top    : SHORT,
    Right  : SHORT,
    Bottom : SHORT,
};
PSMALL_RECT :: ^SMALL_RECT;

KEY_EVENT_RECORD :: struct {
    bKeyDown          : BOOL,
    wRepeatCount      : WORD,
    wVirtualKeyCode   : WORD,
    wVirtualScanCode  : WORD,
    uChar : struct #raw_union {
        UnicodeChar : WCHAR,
        AsciiChar   : CHAR,
    },
    dwControlKeyState : DWORD,
};
PKEY_EVENT_RECORD :: ^KEY_EVENT_RECORD;

MOUSE_EVENT_RECORD :: struct {
    dwMousePosition   : COORD,
    dwButtonState     : DWORD,
    dwControlKeyState : DWORD,
    dwEventFlags      : DWORD,
};
PMOUSE_EVENT_RECORD :: ^MOUSE_EVENT_RECORD;

WINDOW_BUFFER_SIZE_RECORD :: struct {
    dwSize : COORD,
};
PWINDOW_BUFFER_SIZE_RECORD :: ^WINDOW_BUFFER_SIZE_RECORD;

MENU_EVENT_RECORD :: struct {
    dwCommandId : UINT,
};
PMENU_EVENT_RECORD :: ^MENU_EVENT_RECORD;

FOCUS_EVENT_RECORD :: struct {
    bSetFocus : BOOL,
};
PFOCUS_EVENT_RECORD :: ^FOCUS_EVENT_RECORD;

INPUT_RECORD :: struct {
    EventType : WORD,
    Event : struct #raw_union {
        KeyEvent              : KEY_EVENT_RECORD,
        MouseEvent            : MOUSE_EVENT_RECORD,
        WindowBufferSizeEvent : WINDOW_BUFFER_SIZE_RECORD,
        MenuEvent             : MENU_EVENT_RECORD,
        FocusEvent            : FOCUS_EVENT_RECORD,
    },
};
PINPUT_RECORD :: ^INPUT_RECORD;

CHAR_INFO :: struct {
    Char : struct #raw_union {
        UnicodeChar : WCHAR,
        AsciiChar   : CHAR,
    },
    Attributes : WORD,
};
PCHAR_INFO :: ^CHAR_INFO;

CONSOLE_FONT_INFO :: struct {
    nFont      : DWORD,
    dwFontSize : COORD,
};
PCONSOLE_FONT_INFO :: ^CONSOLE_FONT_INFO;

HPCON :: rawptr;

CONSOLE_READCONSOLE_CONTROL :: struct {
    nLength           : ULONG,
    nInitialChars     : ULONG,
    dwCtrlWakeupMask  : ULONG,
    dwControlKeyState : ULONG,
};
PCONSOLE_READCONSOLE_CONTROL :: ^CONSOLE_READCONSOLE_CONTROL;

PHANDLER_ROUTINE :: (proc "stdcall" (CtrlType : DWORD) -> BOOL);

CONSOLE_CURSOR_INFO :: struct {
    dwSize   : DWORD,
    bVisible : BOOL,
};
PCONSOLE_CURSOR_INFO :: ^CONSOLE_CURSOR_INFO;

CONSOLE_SCREEN_BUFFER_INFO :: struct {
    dwSize              : COORD,
    dwCursorPosition    : COORD,
    wAttributes         : WORD,
    srWindow            : SMALL_RECT,
    dwMaximumWindowSize : COORD,
};
PCONSOLE_SCREEN_BUFFER_INFO :: ^CONSOLE_SCREEN_BUFFER_INFO;

CONSOLE_SCREEN_BUFFER_INFOEX :: struct {
    cbSize               : ULONG,
    dwSize               : COORD,
    dwCursorPosition     : COORD,
    wAttributes          : WORD,
    srWindow             : SMALL_RECT,
    dwMaximumWindowSize  : COORD,
    wPopupAttributes     : WORD,
    bFullscreenSupported : BOOL,
    ColorTable           : [16]COLORREF,
};
PCONSOLE_SCREEN_BUFFER_INFOEX :: ^CONSOLE_SCREEN_BUFFER_INFOEX;

CONSOLE_FONT_INFOEX :: struct {
    cbSize     : ULONG,
    nFont      : DWORD,
    dwFontSize : COORD,
    FontFamily : UINT,
    FontWeight : UINT,
    FaceName   : [32]WCHAR,
};
PCONSOLE_FONT_INFOEX :: ^CONSOLE_FONT_INFOEX;

CONSOLE_SELECTION_INFO :: struct {
    dwFlags           : DWORD,
    dwSelectionAnchor : COORD,
    srSelection       : SMALL_RECT,
};
PCONSOLE_SELECTION_INFO :: ^CONSOLE_SELECTION_INFO;

CONSOLE_HISTORY_INFO :: struct {
    cbSize                 : UINT,
    HistoryBufferSize      : UINT,
    NumberOfHistoryBuffers : UINT,
    dwFlags                : DWORD,
};
PCONSOLE_HISTORY_INFO :: ^CONSOLE_HISTORY_INFO;

VS_FIXEDFILEINFO :: struct {
    dwSignature        : DWORD,
    dwStrucVersion     : DWORD,
    dwFileVersionMS    : DWORD,
    dwFileVersionLS    : DWORD,
    dwProductVersionMS : DWORD,
    dwProductVersionLS : DWORD,
    dwFileFlagsMask    : DWORD,
    dwFileFlags        : DWORD,
    dwFileOS           : DWORD,
    dwFileType         : DWORD,
    dwFileSubtype      : DWORD,
    dwFileDateMS       : DWORD,
    dwFileDateLS       : DWORD,
};

LSTATUS :: LONG;

REGSAM :: ACCESS_MASK;

val_context :: struct {
    valuelen      : _c.int,
    value_context : LPVOID,
    val_buff_ptr  : LPVOID,
};

PVALCONTEXT :: ^val_context;

PVALUEA :: struct {
    pv_valuename     : LPSTR,
    pv_valuelen      : _c.int,
    pv_value_context : LPVOID,
    pv_type          : DWORD,
};
PPVALUEA :: ^PVALUEA;

PVALUEW :: struct {
    pv_valuename     : LPWSTR,
    pv_valuelen      : _c.int,
    pv_value_context : LPVOID,
    pv_type          : DWORD,
};
PPVALUEW :: ^PVALUEW;

PVALUE :: PVALUEA;

PPVALUE :: PPVALUEA;

QUERYHANDLER :: #type (proc(keycontext : LPVOID, val_list : PVALCONTEXT, num_vals : DWORD, outputbuffer : LPVOID, total_outlen : ^DWORD, input_blen : DWORD) -> DWORD);

PQUERYHANDLER :: ^QUERYHANDLER;

REG_PROVIDER :: struct {
    pi_R0_1val     : PQUERYHANDLER,
    pi_R0_allvals  : PQUERYHANDLER,
    pi_R3_1val     : PQUERYHANDLER,
    pi_R3_allvals  : PQUERYHANDLER,
    pi_flags       : DWORD,
    pi_key_context : LPVOID,
};

PPROVIDER :: ^REG_PROVIDER;

VALENTA :: struct {
    ve_valuename : LPSTR,
    ve_valuelen  : DWORD,
    ve_valueptr  : DWORD_PTR,
    ve_type      : DWORD,
};
PVALENTA :: ^VALENTA;

VALENTW :: struct {
    ve_valuename : LPWSTR,
    ve_valuelen  : DWORD,
    ve_valueptr  : DWORD_PTR,
    ve_type      : DWORD,
};
PVALENTW :: ^VALENTW;

VALENT :: VALENTA;

PVALENT :: PVALENTA;

NETRESOURCEA :: struct {
    dwScope       : DWORD,
    dwType        : DWORD,
    dwDisplayType : DWORD,
    dwUsage       : DWORD,
    lpLocalName   : LPSTR,
    lpRemoteName  : LPSTR,
    lpComment     : LPSTR,
    lpProvider    : LPSTR,
};
LPNETRESOURCEA :: ^NETRESOURCEA;

NETRESOURCEW :: struct {
    dwScope       : DWORD,
    dwType        : DWORD,
    dwDisplayType : DWORD,
    dwUsage       : DWORD,
    lpLocalName   : LPWSTR,
    lpRemoteName  : LPWSTR,
    lpComment     : LPWSTR,
    lpProvider    : LPWSTR,
};
LPNETRESOURCEW :: ^NETRESOURCEW;

NETRESOURCE :: NETRESOURCEA;

LPNETRESOURCE :: LPNETRESOURCEA;

CONNECTDLGSTRUCTA :: struct {
    cbStructure : DWORD,
    hwndOwner   : HWND,
    lpConnRes   : LPNETRESOURCEA,
    dwFlags     : DWORD,
    dwDevNum    : DWORD,
};
LPCONNECTDLGSTRUCTA :: ^CONNECTDLGSTRUCTA;

CONNECTDLGSTRUCTW :: struct {
    cbStructure : DWORD,
    hwndOwner   : HWND,
    lpConnRes   : LPNETRESOURCEW,
    dwFlags     : DWORD,
    dwDevNum    : DWORD,
};
LPCONNECTDLGSTRUCTW :: ^CONNECTDLGSTRUCTW;

CONNECTDLGSTRUCT :: CONNECTDLGSTRUCTA;

LPCONNECTDLGSTRUCT :: LPCONNECTDLGSTRUCTA;

DISCDLGSTRUCTA :: struct {
    cbStructure  : DWORD,
    hwndOwner    : HWND,
    lpLocalName  : LPSTR,
    lpRemoteName : LPSTR,
    dwFlags      : DWORD,
};
LPDISCDLGSTRUCTA :: ^DISCDLGSTRUCTA;

DISCDLGSTRUCTW :: struct {
    cbStructure  : DWORD,
    hwndOwner    : HWND,
    lpLocalName  : LPWSTR,
    lpRemoteName : LPWSTR,
    dwFlags      : DWORD,
};
LPDISCDLGSTRUCTW :: ^DISCDLGSTRUCTW;

DISCDLGSTRUCT :: DISCDLGSTRUCTA;

LPDISCDLGSTRUCT :: LPDISCDLGSTRUCTA;

UNIVERSAL_NAME_INFOA :: struct {
    lpUniversalName : LPSTR,
};
LPUNIVERSAL_NAME_INFOA :: ^UNIVERSAL_NAME_INFOA;

UNIVERSAL_NAME_INFOW :: struct {
    lpUniversalName : LPWSTR,
};
LPUNIVERSAL_NAME_INFOW :: ^UNIVERSAL_NAME_INFOW;

UNIVERSAL_NAME_INFO :: UNIVERSAL_NAME_INFOA;

LPUNIVERSAL_NAME_INFO :: LPUNIVERSAL_NAME_INFOA;

REMOTE_NAME_INFOA :: struct {
    lpUniversalName  : LPSTR,
    lpConnectionName : LPSTR,
    lpRemainingPath  : LPSTR,
};
LPREMOTE_NAME_INFOA :: ^REMOTE_NAME_INFOA;

REMOTE_NAME_INFOW :: struct {
    lpUniversalName  : LPWSTR,
    lpConnectionName : LPWSTR,
    lpRemainingPath  : LPWSTR,
};
LPREMOTE_NAME_INFOW :: ^REMOTE_NAME_INFOW;

REMOTE_NAME_INFO :: REMOTE_NAME_INFOA;

LPREMOTE_NAME_INFO :: LPREMOTE_NAME_INFOA;

NETINFOSTRUCT :: struct {
    cbStructure       : DWORD,
    dwProviderVersion : DWORD,
    dwStatus          : DWORD,
    dwCharacteristics : DWORD,
    dwHandle          : ULONG_PTR,
    wNetType          : WORD,
    dwPrinters        : DWORD,
    dwDrives          : DWORD,
};
LPNETINFOSTRUCT :: ^NETINFOSTRUCT;

NETCONNECTINFOSTRUCT :: struct {
    cbStructure   : DWORD,
    dwFlags       : DWORD,
    dwSpeed       : DWORD,
    dwDelay       : DWORD,
    dwOptDataSize : DWORD,
};
LPNETCONNECTINFOSTRUCT :: ^NETCONNECTINFOSTRUCT;

DDEACK :: bit_field {
    bAppReturnCode : 8,
    reserved       : 6,
    fBusy          : 1,
    fAck           : 1,
};

DDEADVISE :: struct {
    using _ : bit_field {
        reserved  : 14,
        fDeferUpd : 1,
        fAckReq   : 1,
    },
    cfFormat  : _c.short,
};

DDEDATA :: struct {
    using _ : bit_field {
        unused    : 12,
        fResponse : 1,
        fRelease  : 1,
        reserved  : 1,
        fAckReq   : 1,
    },
    cfFormat  : _c.short,
    Value     : [1]BYTE,
};

DDEPOKE :: struct {
    using _ : bit_field {
        unused    : 13,
        fRelease  : 1,
        fReserved : 2,
    },
    cfFormat  : _c.short,
    Value     : [1]BYTE,
};

DDELN :: struct {
    using _ : bit_field {
        unused    : 13,
        fRelease  : 1,
        fDeferUpd : 1,
        fAckReq   : 1,
    },
    cfFormat  : _c.short,
};

DDEUP :: struct {
    using _ : bit_field {
        unused    : 12,
        fAck      : 1,
        fRelease  : 1,
        fReserved : 1,
        fAckReq   : 1,
    },
    cfFormat  : _c.short,
    rgb       : [1]BYTE,
};

HCONVLIST__ :: struct {
    unused : _c.int,
};

HCONVLIST :: ^HCONVLIST__;

HCONV__ :: struct {
    unused : _c.int,
};

HCONV :: ^HCONV__;

HSZ__ :: struct {
    unused : _c.int,
};

HSZ :: ^HSZ__;

HDDEDATA__ :: struct {
    unused : _c.int,
};

HDDEDATA :: ^HDDEDATA__;

HSZPAIR :: struct {
    hszSvc   : HSZ,
    hszTopic : HSZ,
};
PHSZPAIR :: ^HSZPAIR;

CONVCONTEXT :: struct {
    cb         : UINT,
    wFlags     : UINT,
    wCountryID : UINT,
    iCodePage  : _c.int,
    dwLangID   : DWORD,
    dwSecurity : DWORD,
    qos        : SECURITY_QUALITY_OF_SERVICE,
};
PCONVCONTEXT :: ^CONVCONTEXT;

CONVINFO :: struct {
    cb            : DWORD,
    hUser         : DWORD_PTR,
    hConvPartner  : HCONV,
    hszSvcPartner : HSZ,
    hszServiceReq : HSZ,
    hszTopic      : HSZ,
    hszItem       : HSZ,
    wFmt          : UINT,
    wType         : UINT,
    wStatus       : UINT,
    wConvst       : UINT,
    wLastError    : UINT,
    hConvList     : HCONVLIST,
    ConvCtxt      : CONVCONTEXT,
    hwnd          : HWND,
    hwndPartner   : HWND,
};
PCONVINFO :: ^CONVINFO;

FNCALLBACK :: #type (proc "stdcall" (wType : UINT, wFmt : UINT, hConv : HCONV, hsz1 : HSZ, hsz2 : HSZ, hData : HDDEDATA, dwData1 : ULONG_PTR, dwData2 : ULONG_PTR) -> HDDEDATA);

PFNCALLBACK :: (proc "stdcall" (wType : UINT, wFmt : UINT, hConv : HCONV, hsz1 : HSZ, hsz2 : HSZ, hData : HDDEDATA, dwData1 : ULONG_PTR, dwData2 : ULONG_PTR) -> HDDEDATA);

DDEML_MSG_HOOK_DATA :: struct {
    uiLo   : UINT_PTR,
    uiHi   : UINT_PTR,
    cbData : DWORD,
    Data   : [8]DWORD,
};
PDDEML_MSG_HOOK_DATA :: ^DDEML_MSG_HOOK_DATA;

MONMSGSTRUCT :: struct {
    cb     : UINT,
    hwndTo : HWND,
    dwTime : DWORD,
    hTask  : HANDLE,
    wMsg   : UINT,
    wParam : WPARAM,
    lParam : LPARAM,
    dmhd   : DDEML_MSG_HOOK_DATA,
};
PMONMSGSTRUCT :: ^MONMSGSTRUCT;

MONCBSTRUCT :: struct {
    cb      : UINT,
    dwTime  : DWORD,
    hTask   : HANDLE,
    dwRet   : DWORD,
    wType   : UINT,
    wFmt    : UINT,
    hConv   : HCONV,
    hsz1    : HSZ,
    hsz2    : HSZ,
    hData   : HDDEDATA,
    dwData1 : ULONG_PTR,
    dwData2 : ULONG_PTR,
    cc      : CONVCONTEXT,
    cbData  : DWORD,
    Data    : [8]DWORD,
};
PMONCBSTRUCT :: ^MONCBSTRUCT;

MONHSZSTRUCTA :: struct {
    cb       : UINT,
    fsAction : BOOL,
    dwTime   : DWORD,
    hsz      : HSZ,
    hTask    : HANDLE,
    str      : [1]CHAR,
};
PMONHSZSTRUCTA :: ^MONHSZSTRUCTA;

MONHSZSTRUCTW :: struct {
    cb       : UINT,
    fsAction : BOOL,
    dwTime   : DWORD,
    hsz      : HSZ,
    hTask    : HANDLE,
    str      : [1]WCHAR,
};
PMONHSZSTRUCTW :: ^MONHSZSTRUCTW;

MONHSZSTRUCT :: MONHSZSTRUCTA;

PMONHSZSTRUCT :: PMONHSZSTRUCTA;

MONERRSTRUCT :: struct {
    cb         : UINT,
    wLastError : UINT,
    dwTime     : DWORD,
    hTask      : HANDLE,
};
PMONERRSTRUCT :: ^MONERRSTRUCT;

MONLINKSTRUCT :: struct {
    cb           : UINT,
    dwTime       : DWORD,
    hTask        : HANDLE,
    fEstablished : BOOL,
    fNoData      : BOOL,
    hszSvc       : HSZ,
    hszTopic     : HSZ,
    hszItem      : HSZ,
    wFmt         : UINT,
    fServer      : BOOL,
    hConvServer  : HCONV,
    hConvClient  : HCONV,
};
PMONLINKSTRUCT :: ^MONLINKSTRUCT;

MONCONVSTRUCT :: struct {
    cb          : UINT,
    fConnect    : BOOL,
    dwTime      : DWORD,
    hTask       : HANDLE,
    hszSvc      : HSZ,
    hszTopic    : HSZ,
    hConvClient : HCONV,
    hConvServer : HCONV,
};
PMONCONVSTRUCT :: ^MONCONVSTRUCT;

CRGB :: struct {
    bRed   : BYTE,
    bGreen : BYTE,
    bBlue  : BYTE,
    bExtra : BYTE,
};

MMVERSION :: UINT;

MMRESULT :: UINT;

LPUINT :: ^UINT;

MMTIME :: struct {
    wType : UINT,
    u : struct #raw_union {
        ms     : DWORD,
        sample : DWORD,
        cb     : DWORD,
        ticks  : DWORD,
        smpte : struct {
            hour  : BYTE,
            min   : BYTE,
            sec   : BYTE,
            frame : BYTE,
            fps   : BYTE,
            dummy : BYTE,
            pad   : [2]BYTE,
        },
        midi : struct {
            songptrpos : DWORD,
        },
    },
};
PMMTIME :: ^MMTIME;
NPMMTIME :: ^MMTIME;
LPMMTIME :: ^MMTIME;

HDRVR__ :: struct {
    unused : _c.int,
};

HDRVR :: ^HDRVR__;

DRVCALLBACK :: #type proc "stdcall" (hdrvr : HDRVR, uMsg : UINT, dwUser : DWORD_PTR, dw1 : DWORD_PTR, dw2 : DWORD_PTR);

LPDRVCALLBACK :: ^DRVCALLBACK;

PDRVCALLBACK :: ^DRVCALLBACK;

MCIERROR :: DWORD;

MCIDEVICEID :: UINT;

YIELDPROC :: (proc "stdcall" (mciId : MCIDEVICEID, dwYieldData : DWORD) -> UINT);

MCI_GENERIC_PARMS :: struct {
    dwCallback : DWORD_PTR,
};
PMCI_GENERIC_PARMS :: ^MCI_GENERIC_PARMS;
LPMCI_GENERIC_PARMS :: ^MCI_GENERIC_PARMS;

MCI_OPEN_PARMSA :: struct {
    dwCallback       : DWORD_PTR,
    wDeviceID        : MCIDEVICEID,
    lpstrDeviceType  : LPCSTR,
    lpstrElementName : LPCSTR,
    lpstrAlias       : LPCSTR,
};
PMCI_OPEN_PARMSA :: ^MCI_OPEN_PARMSA;
LPMCI_OPEN_PARMSA :: ^MCI_OPEN_PARMSA;

MCI_OPEN_PARMSW :: struct {
    dwCallback       : DWORD_PTR,
    wDeviceID        : MCIDEVICEID,
    lpstrDeviceType  : LPCWSTR,
    lpstrElementName : LPCWSTR,
    lpstrAlias       : LPCWSTR,
};
PMCI_OPEN_PARMSW :: ^MCI_OPEN_PARMSW;
LPMCI_OPEN_PARMSW :: ^MCI_OPEN_PARMSW;

MCI_OPEN_PARMS :: MCI_OPEN_PARMSA;

PMCI_OPEN_PARMS :: PMCI_OPEN_PARMSA;

LPMCI_OPEN_PARMS :: LPMCI_OPEN_PARMSA;

MCI_PLAY_PARMS :: struct {
    dwCallback : DWORD_PTR,
    dwFrom     : DWORD,
    dwTo       : DWORD,
};
PMCI_PLAY_PARMS :: ^MCI_PLAY_PARMS;
LPMCI_PLAY_PARMS :: ^MCI_PLAY_PARMS;

MCI_SEEK_PARMS :: struct {
    dwCallback : DWORD_PTR,
    dwTo       : DWORD,
};
PMCI_SEEK_PARMS :: ^MCI_SEEK_PARMS;
LPMCI_SEEK_PARMS :: ^MCI_SEEK_PARMS;

MCI_STATUS_PARMS :: struct {
    dwCallback : DWORD_PTR,
    dwReturn   : DWORD_PTR,
    dwItem     : DWORD,
    dwTrack    : DWORD,
};
PMCI_STATUS_PARMS :: ^MCI_STATUS_PARMS;
LPMCI_STATUS_PARMS :: ^MCI_STATUS_PARMS;

MCI_INFO_PARMSA :: struct {
    dwCallback  : DWORD_PTR,
    lpstrReturn : LPSTR,
    dwRetSize   : DWORD,
};
LPMCI_INFO_PARMSA :: ^MCI_INFO_PARMSA;

MCI_INFO_PARMSW :: struct {
    dwCallback  : DWORD_PTR,
    lpstrReturn : LPWSTR,
    dwRetSize   : DWORD,
};
LPMCI_INFO_PARMSW :: ^MCI_INFO_PARMSW;

MCI_INFO_PARMS :: MCI_INFO_PARMSA;

LPMCI_INFO_PARMS :: LPMCI_INFO_PARMSA;

MCI_GETDEVCAPS_PARMS :: struct {
    dwCallback : DWORD_PTR,
    dwReturn   : DWORD,
    dwItem     : DWORD,
};
PMCI_GETDEVCAPS_PARMS :: ^MCI_GETDEVCAPS_PARMS;
LPMCI_GETDEVCAPS_PARMS :: ^MCI_GETDEVCAPS_PARMS;

MCI_SYSINFO_PARMSA :: struct {
    dwCallback  : DWORD_PTR,
    lpstrReturn : LPSTR,
    dwRetSize   : DWORD,
    dwNumber    : DWORD,
    wDeviceType : UINT,
};
PMCI_SYSINFO_PARMSA :: ^MCI_SYSINFO_PARMSA;
LPMCI_SYSINFO_PARMSA :: ^MCI_SYSINFO_PARMSA;

MCI_SYSINFO_PARMSW :: struct {
    dwCallback  : DWORD_PTR,
    lpstrReturn : LPWSTR,
    dwRetSize   : DWORD,
    dwNumber    : DWORD,
    wDeviceType : UINT,
};
PMCI_SYSINFO_PARMSW :: ^MCI_SYSINFO_PARMSW;
LPMCI_SYSINFO_PARMSW :: ^MCI_SYSINFO_PARMSW;

MCI_SYSINFO_PARMS :: MCI_SYSINFO_PARMSA;

PMCI_SYSINFO_PARMS :: PMCI_SYSINFO_PARMSA;

LPMCI_SYSINFO_PARMS :: LPMCI_SYSINFO_PARMSA;

MCI_SET_PARMS :: struct {
    dwCallback   : DWORD_PTR,
    dwTimeFormat : DWORD,
    dwAudio      : DWORD,
};
PMCI_SET_PARMS :: ^MCI_SET_PARMS;
LPMCI_SET_PARMS :: ^MCI_SET_PARMS;

MCI_BREAK_PARMS :: struct {
    dwCallback : DWORD_PTR,
    nVirtKey   : _c.int,
    hwndBreak  : HWND,
};
PMCI_BREAK_PARMS :: ^MCI_BREAK_PARMS;
LPMCI_BREAK_PARMS :: ^MCI_BREAK_PARMS;

MCI_SAVE_PARMSA :: struct {
    dwCallback : DWORD_PTR,
    lpfilename : LPCSTR,
};
PMCI_SAVE_PARMSA :: ^MCI_SAVE_PARMSA;
LPMCI_SAVE_PARMSA :: ^MCI_SAVE_PARMSA;

MCI_SAVE_PARMSW :: struct {
    dwCallback : DWORD_PTR,
    lpfilename : LPCWSTR,
};
PMCI_SAVE_PARMSW :: ^MCI_SAVE_PARMSW;
LPMCI_SAVE_PARMSW :: ^MCI_SAVE_PARMSW;

MCI_SAVE_PARMS :: MCI_SAVE_PARMSA;

PMCI_SAVE_PARMS :: PMCI_SAVE_PARMSA;

LPMCI_SAVE_PARMS :: LPMCI_SAVE_PARMSA;

MCI_LOAD_PARMSA :: struct {
    dwCallback : DWORD_PTR,
    lpfilename : LPCSTR,
};
PMCI_LOAD_PARMSA :: ^MCI_LOAD_PARMSA;
LPMCI_LOAD_PARMSA :: ^MCI_LOAD_PARMSA;

MCI_LOAD_PARMSW :: struct {
    dwCallback : DWORD_PTR,
    lpfilename : LPCWSTR,
};
PMCI_LOAD_PARMSW :: ^MCI_LOAD_PARMSW;
LPMCI_LOAD_PARMSW :: ^MCI_LOAD_PARMSW;

MCI_LOAD_PARMS :: MCI_LOAD_PARMSA;

PMCI_LOAD_PARMS :: PMCI_LOAD_PARMSA;

LPMCI_LOAD_PARMS :: LPMCI_LOAD_PARMSA;

MCI_RECORD_PARMS :: struct {
    dwCallback : DWORD_PTR,
    dwFrom     : DWORD,
    dwTo       : DWORD,
};
LPMCI_RECORD_PARMS :: ^MCI_RECORD_PARMS;

MCI_VD_PLAY_PARMS :: struct {
    dwCallback : DWORD_PTR,
    dwFrom     : DWORD,
    dwTo       : DWORD,
    dwSpeed    : DWORD,
};
PMCI_VD_PLAY_PARMS :: ^MCI_VD_PLAY_PARMS;
LPMCI_VD_PLAY_PARMS :: ^MCI_VD_PLAY_PARMS;

MCI_VD_STEP_PARMS :: struct {
    dwCallback : DWORD_PTR,
    dwFrames   : DWORD,
};
PMCI_VD_STEP_PARMS :: ^MCI_VD_STEP_PARMS;
LPMCI_VD_STEP_PARMS :: ^MCI_VD_STEP_PARMS;

MCI_VD_ESCAPE_PARMSA :: struct {
    dwCallback   : DWORD_PTR,
    lpstrCommand : LPCSTR,
};
PMCI_VD_ESCAPE_PARMSA :: ^MCI_VD_ESCAPE_PARMSA;
LPMCI_VD_ESCAPE_PARMSA :: ^MCI_VD_ESCAPE_PARMSA;

MCI_VD_ESCAPE_PARMSW :: struct {
    dwCallback   : DWORD_PTR,
    lpstrCommand : LPCWSTR,
};
PMCI_VD_ESCAPE_PARMSW :: ^MCI_VD_ESCAPE_PARMSW;
LPMCI_VD_ESCAPE_PARMSW :: ^MCI_VD_ESCAPE_PARMSW;

MCI_VD_ESCAPE_PARMS :: MCI_VD_ESCAPE_PARMSA;

PMCI_VD_ESCAPE_PARMS :: PMCI_VD_ESCAPE_PARMSA;

LPMCI_VD_ESCAPE_PARMS :: LPMCI_VD_ESCAPE_PARMSA;

MCI_WAVE_OPEN_PARMSA :: struct {
    dwCallback       : DWORD_PTR,
    wDeviceID        : MCIDEVICEID,
    lpstrDeviceType  : LPCSTR,
    lpstrElementName : LPCSTR,
    lpstrAlias       : LPCSTR,
    dwBufferSeconds  : DWORD,
};
PMCI_WAVE_OPEN_PARMSA :: ^MCI_WAVE_OPEN_PARMSA;
LPMCI_WAVE_OPEN_PARMSA :: ^MCI_WAVE_OPEN_PARMSA;

MCI_WAVE_OPEN_PARMSW :: struct {
    dwCallback       : DWORD_PTR,
    wDeviceID        : MCIDEVICEID,
    lpstrDeviceType  : LPCWSTR,
    lpstrElementName : LPCWSTR,
    lpstrAlias       : LPCWSTR,
    dwBufferSeconds  : DWORD,
};
PMCI_WAVE_OPEN_PARMSW :: ^MCI_WAVE_OPEN_PARMSW;
LPMCI_WAVE_OPEN_PARMSW :: ^MCI_WAVE_OPEN_PARMSW;

MCI_WAVE_OPEN_PARMS :: MCI_WAVE_OPEN_PARMSA;

PMCI_WAVE_OPEN_PARMS :: PMCI_WAVE_OPEN_PARMSA;

LPMCI_WAVE_OPEN_PARMS :: LPMCI_WAVE_OPEN_PARMSA;

MCI_WAVE_DELETE_PARMS :: struct {
    dwCallback : DWORD_PTR,
    dwFrom     : DWORD,
    dwTo       : DWORD,
};
PMCI_WAVE_DELETE_PARMS :: ^MCI_WAVE_DELETE_PARMS;
LPMCI_WAVE_DELETE_PARMS :: ^MCI_WAVE_DELETE_PARMS;

MCI_WAVE_SET_PARMS :: struct {
    dwCallback      : DWORD_PTR,
    dwTimeFormat    : DWORD,
    dwAudio         : DWORD,
    wInput          : UINT,
    wOutput         : UINT,
    wFormatTag      : WORD,
    wReserved2      : WORD,
    nChannels       : WORD,
    wReserved3      : WORD,
    nSamplesPerSec  : DWORD,
    nAvgBytesPerSec : DWORD,
    nBlockAlign     : WORD,
    wReserved4      : WORD,
    wBitsPerSample  : WORD,
    wReserved5      : WORD,
};
PMCI_WAVE_SET_PARMS :: ^MCI_WAVE_SET_PARMS;
LPMCI_WAVE_SET_PARMS :: ^MCI_WAVE_SET_PARMS;

MCI_SEQ_SET_PARMS :: struct {
    dwCallback   : DWORD_PTR,
    dwTimeFormat : DWORD,
    dwAudio      : DWORD,
    dwTempo      : DWORD,
    dwPort       : DWORD,
    dwSlave      : DWORD,
    dwMaster     : DWORD,
    dwOffset     : DWORD,
};
PMCI_SEQ_SET_PARMS :: ^MCI_SEQ_SET_PARMS;
LPMCI_SEQ_SET_PARMS :: ^MCI_SEQ_SET_PARMS;

MCI_ANIM_OPEN_PARMSA :: struct {
    dwCallback       : DWORD_PTR,
    wDeviceID        : MCIDEVICEID,
    lpstrDeviceType  : LPCSTR,
    lpstrElementName : LPCSTR,
    lpstrAlias       : LPCSTR,
    dwStyle          : DWORD,
    hWndParent       : HWND,
};
PMCI_ANIM_OPEN_PARMSA :: ^MCI_ANIM_OPEN_PARMSA;
LPMCI_ANIM_OPEN_PARMSA :: ^MCI_ANIM_OPEN_PARMSA;

MCI_ANIM_OPEN_PARMSW :: struct {
    dwCallback       : DWORD_PTR,
    wDeviceID        : MCIDEVICEID,
    lpstrDeviceType  : LPCWSTR,
    lpstrElementName : LPCWSTR,
    lpstrAlias       : LPCWSTR,
    dwStyle          : DWORD,
    hWndParent       : HWND,
};
PMCI_ANIM_OPEN_PARMSW :: ^MCI_ANIM_OPEN_PARMSW;
LPMCI_ANIM_OPEN_PARMSW :: ^MCI_ANIM_OPEN_PARMSW;

MCI_ANIM_OPEN_PARMS :: MCI_ANIM_OPEN_PARMSA;

PMCI_ANIM_OPEN_PARMS :: PMCI_ANIM_OPEN_PARMSA;

LPMCI_ANIM_OPEN_PARMS :: LPMCI_ANIM_OPEN_PARMSA;

MCI_ANIM_PLAY_PARMS :: struct {
    dwCallback : DWORD_PTR,
    dwFrom     : DWORD,
    dwTo       : DWORD,
    dwSpeed    : DWORD,
};
PMCI_ANIM_PLAY_PARMS :: ^MCI_ANIM_PLAY_PARMS;
LPMCI_ANIM_PLAY_PARMS :: ^MCI_ANIM_PLAY_PARMS;

MCI_ANIM_STEP_PARMS :: struct {
    dwCallback : DWORD_PTR,
    dwFrames   : DWORD,
};
PMCI_ANIM_STEP_PARMS :: ^MCI_ANIM_STEP_PARMS;
LPMCI_ANIM_STEP_PARMS :: ^MCI_ANIM_STEP_PARMS;

MCI_ANIM_WINDOW_PARMSA :: struct {
    dwCallback : DWORD_PTR,
    hWnd       : HWND,
    nCmdShow   : UINT,
    lpstrText  : LPCSTR,
};
PMCI_ANIM_WINDOW_PARMSA :: ^MCI_ANIM_WINDOW_PARMSA;
LPMCI_ANIM_WINDOW_PARMSA :: ^MCI_ANIM_WINDOW_PARMSA;

MCI_ANIM_WINDOW_PARMSW :: struct {
    dwCallback : DWORD_PTR,
    hWnd       : HWND,
    nCmdShow   : UINT,
    lpstrText  : LPCWSTR,
};
PMCI_ANIM_WINDOW_PARMSW :: ^MCI_ANIM_WINDOW_PARMSW;
LPMCI_ANIM_WINDOW_PARMSW :: ^MCI_ANIM_WINDOW_PARMSW;

MCI_ANIM_WINDOW_PARMS :: MCI_ANIM_WINDOW_PARMSA;

PMCI_ANIM_WINDOW_PARMS :: PMCI_ANIM_WINDOW_PARMSA;

LPMCI_ANIM_WINDOW_PARMS :: LPMCI_ANIM_WINDOW_PARMSA;

MCI_ANIM_RECT_PARMS :: struct {
    dwCallback : DWORD_PTR,
    rc         : RECT,
};

PMCI_ANIM_RECT_PARMS :: ^MCI_ANIM_RECT_PARMS;

LPMCI_ANIM_RECT_PARMS :: ^MCI_ANIM_RECT_PARMS;

MCI_ANIM_UPDATE_PARMS :: struct {
    dwCallback : DWORD_PTR,
    rc         : RECT,
    hDC        : HDC,
};
PMCI_ANIM_UPDATE_PARMS :: ^MCI_ANIM_UPDATE_PARMS;
LPMCI_ANIM_UPDATE_PARMS :: ^MCI_ANIM_UPDATE_PARMS;

MCI_OVLY_OPEN_PARMSA :: struct {
    dwCallback       : DWORD_PTR,
    wDeviceID        : MCIDEVICEID,
    lpstrDeviceType  : LPCSTR,
    lpstrElementName : LPCSTR,
    lpstrAlias       : LPCSTR,
    dwStyle          : DWORD,
    hWndParent       : HWND,
};
PMCI_OVLY_OPEN_PARMSA :: ^MCI_OVLY_OPEN_PARMSA;
LPMCI_OVLY_OPEN_PARMSA :: ^MCI_OVLY_OPEN_PARMSA;

MCI_OVLY_OPEN_PARMSW :: struct {
    dwCallback       : DWORD_PTR,
    wDeviceID        : MCIDEVICEID,
    lpstrDeviceType  : LPCWSTR,
    lpstrElementName : LPCWSTR,
    lpstrAlias       : LPCWSTR,
    dwStyle          : DWORD,
    hWndParent       : HWND,
};
PMCI_OVLY_OPEN_PARMSW :: ^MCI_OVLY_OPEN_PARMSW;
LPMCI_OVLY_OPEN_PARMSW :: ^MCI_OVLY_OPEN_PARMSW;

MCI_OVLY_OPEN_PARMS :: MCI_OVLY_OPEN_PARMSA;

PMCI_OVLY_OPEN_PARMS :: PMCI_OVLY_OPEN_PARMSA;

LPMCI_OVLY_OPEN_PARMS :: LPMCI_OVLY_OPEN_PARMSA;

MCI_OVLY_WINDOW_PARMSA :: struct {
    dwCallback : DWORD_PTR,
    hWnd       : HWND,
    nCmdShow   : UINT,
    lpstrText  : LPCSTR,
};
PMCI_OVLY_WINDOW_PARMSA :: ^MCI_OVLY_WINDOW_PARMSA;
LPMCI_OVLY_WINDOW_PARMSA :: ^MCI_OVLY_WINDOW_PARMSA;

MCI_OVLY_WINDOW_PARMSW :: struct {
    dwCallback : DWORD_PTR,
    hWnd       : HWND,
    nCmdShow   : UINT,
    lpstrText  : LPCWSTR,
};
PMCI_OVLY_WINDOW_PARMSW :: ^MCI_OVLY_WINDOW_PARMSW;
LPMCI_OVLY_WINDOW_PARMSW :: ^MCI_OVLY_WINDOW_PARMSW;

MCI_OVLY_WINDOW_PARMS :: MCI_OVLY_WINDOW_PARMSA;

PMCI_OVLY_WINDOW_PARMS :: PMCI_OVLY_WINDOW_PARMSA;

LPMCI_OVLY_WINDOW_PARMS :: LPMCI_OVLY_WINDOW_PARMSA;

MCI_OVLY_RECT_PARMS :: struct {
    dwCallback : DWORD_PTR,
    rc         : RECT,
};
PMCI_OVLY_RECT_PARMS :: ^MCI_OVLY_RECT_PARMS;
LPMCI_OVLY_RECT_PARMS :: ^MCI_OVLY_RECT_PARMS;

MCI_OVLY_SAVE_PARMSA :: struct {
    dwCallback : DWORD_PTR,
    lpfilename : LPCSTR,
    rc         : RECT,
};
PMCI_OVLY_SAVE_PARMSA :: ^MCI_OVLY_SAVE_PARMSA;
LPMCI_OVLY_SAVE_PARMSA :: ^MCI_OVLY_SAVE_PARMSA;

MCI_OVLY_SAVE_PARMSW :: struct {
    dwCallback : DWORD_PTR,
    lpfilename : LPCWSTR,
    rc         : RECT,
};
PMCI_OVLY_SAVE_PARMSW :: ^MCI_OVLY_SAVE_PARMSW;
LPMCI_OVLY_SAVE_PARMSW :: ^MCI_OVLY_SAVE_PARMSW;

MCI_OVLY_SAVE_PARMS :: MCI_OVLY_SAVE_PARMSA;

PMCI_OVLY_SAVE_PARMS :: PMCI_OVLY_SAVE_PARMSA;

LPMCI_OVLY_SAVE_PARMS :: LPMCI_OVLY_SAVE_PARMSA;

MCI_OVLY_LOAD_PARMSA :: struct {
    dwCallback : DWORD_PTR,
    lpfilename : LPCSTR,
    rc         : RECT,
};
PMCI_OVLY_LOAD_PARMSA :: ^MCI_OVLY_LOAD_PARMSA;
LPMCI_OVLY_LOAD_PARMSA :: ^MCI_OVLY_LOAD_PARMSA;

MCI_OVLY_LOAD_PARMSW :: struct {
    dwCallback : DWORD_PTR,
    lpfilename : LPCWSTR,
    rc         : RECT,
};
PMCI_OVLY_LOAD_PARMSW :: ^MCI_OVLY_LOAD_PARMSW;
LPMCI_OVLY_LOAD_PARMSW :: ^MCI_OVLY_LOAD_PARMSW;

MCI_OVLY_LOAD_PARMS :: MCI_OVLY_LOAD_PARMSA;

PMCI_OVLY_LOAD_PARMS :: PMCI_OVLY_LOAD_PARMSA;

LPMCI_OVLY_LOAD_PARMS :: LPMCI_OVLY_LOAD_PARMSA;

DRVCONFIGINFOEX :: struct {
    dwDCISize          : DWORD,
    lpszDCISectionName : LPCWSTR,
    lpszDCIAliasName   : LPCWSTR,
    dnDevNode          : DWORD,
};
PDRVCONFIGINFOEX :: ^DRVCONFIGINFOEX;
NPDRVCONFIGINFOEX :: ^DRVCONFIGINFOEX;
LPDRVCONFIGINFOEX :: ^DRVCONFIGINFOEX;

DRVCONFIGINFO :: struct {
    dwDCISize          : DWORD,
    lpszDCISectionName : LPCWSTR,
    lpszDCIAliasName   : LPCWSTR,
};
PDRVCONFIGINFO :: ^DRVCONFIGINFO;
NPDRVCONFIGINFO :: ^DRVCONFIGINFO;
LPDRVCONFIGINFO :: ^DRVCONFIGINFO;

DRIVERPROC :: (proc "stdcall" (DWORD_PTR, HDRVR, UINT, LPARAM, LPARAM) -> LRESULT);

DRIVERMSGPROC :: (proc "stdcall" (DWORD, DWORD, DWORD_PTR, DWORD_PTR, DWORD_PTR) -> DWORD);

FOURCC :: DWORD;

HPSTR :: ^_c.uchar;

HMMIO__ :: struct {
    unused : _c.int,
};

HMMIO :: ^HMMIO__;

MMIOPROC :: #type (proc "stdcall" (lpmmioinfo : LPSTR, uMsg : UINT, lParam1 : LPARAM, lParam2 : LPARAM) -> LRESULT);

LPMMIOPROC :: ^MMIOPROC;

MMIOINFO :: struct {
    dwFlags     : DWORD,
    fccIOProc   : FOURCC,
    pIOProc     : LPMMIOPROC,
    wErrorRet   : UINT,
    htask       : HTASK,
    cchBuffer   : LONG,
    pchBuffer   : HPSTR,
    pchNext     : HPSTR,
    pchEndRead  : HPSTR,
    pchEndWrite : HPSTR,
    lBufOffset  : LONG,
    lDiskOffset : LONG,
    adwInfo     : [3]DWORD,
    dwReserved1 : DWORD,
    dwReserved2 : DWORD,
    hmmio       : HMMIO,
};
PMMIOINFO :: ^MMIOINFO;
NPMMIOINFO :: ^MMIOINFO;
LPMMIOINFO :: ^MMIOINFO;

LPCMMIOINFO :: ^MMIOINFO;

MMCKINFO :: struct {
    ckid         : FOURCC,
    cksize       : DWORD,
    fccType      : FOURCC,
    dwDataOffset : DWORD,
    dwFlags      : DWORD,
};
PMMCKINFO :: ^MMCKINFO;
NPMMCKINFO :: ^MMCKINFO;
LPMMCKINFO :: ^MMCKINFO;

LPCMMCKINFO :: ^MMCKINFO;

TIMECALLBACK :: #type proc "stdcall" (uTimerID : UINT, uMsg : UINT, dwUser : DWORD_PTR, dw1 : DWORD_PTR, dw2 : DWORD_PTR);

LPTIMECALLBACK :: ^TIMECALLBACK;

HWAVE__ :: struct {
    unused : _c.int,
};

HWAVE :: ^HWAVE__;

HWAVEIN__ :: struct {
    unused : _c.int,
};

HWAVEIN :: ^HWAVEIN__;

HWAVEOUT__ :: struct {
    unused : _c.int,
};

HWAVEOUT :: ^HWAVEOUT__;

LPHWAVEIN :: ^HWAVEIN;

LPHWAVEOUT :: ^HWAVEOUT;

WAVECALLBACK :: DRVCALLBACK;

LPWAVECALLBACK :: ^WAVECALLBACK;

WAVEHDR :: struct {
    lpData          : LPSTR,
    dwBufferLength  : DWORD,
    dwBytesRecorded : DWORD,
    dwUser          : DWORD_PTR,
    dwFlags         : DWORD,
    dwLoops         : DWORD,
    lpNext          : ^WAVEHDR,
    reserved        : DWORD_PTR,
};
PWAVEHDR :: ^WAVEHDR;
NPWAVEHDR :: ^WAVEHDR;
LPWAVEHDR :: ^WAVEHDR;

WAVEOUTCAPSA :: struct {
    wMid           : WORD,
    wPid           : WORD,
    vDriverVersion : MMVERSION,
    szPname        : [32]CHAR,
    dwFormats      : DWORD,
    wChannels      : WORD,
    wReserved1     : WORD,
    dwSupport      : DWORD,
};
PWAVEOUTCAPSA :: ^WAVEOUTCAPSA;
NPWAVEOUTCAPSA :: ^WAVEOUTCAPSA;
LPWAVEOUTCAPSA :: ^WAVEOUTCAPSA;

WAVEOUTCAPSW :: struct {
    wMid           : WORD,
    wPid           : WORD,
    vDriverVersion : MMVERSION,
    szPname        : [32]WCHAR,
    dwFormats      : DWORD,
    wChannels      : WORD,
    wReserved1     : WORD,
    dwSupport      : DWORD,
};
PWAVEOUTCAPSW :: ^WAVEOUTCAPSW;
NPWAVEOUTCAPSW :: ^WAVEOUTCAPSW;
LPWAVEOUTCAPSW :: ^WAVEOUTCAPSW;

WAVEOUTCAPS :: WAVEOUTCAPSA;

PWAVEOUTCAPS :: PWAVEOUTCAPSA;

NPWAVEOUTCAPS :: NPWAVEOUTCAPSA;

LPWAVEOUTCAPS :: LPWAVEOUTCAPSA;

WAVEOUTCAPS2A :: struct {
    wMid             : WORD,
    wPid             : WORD,
    vDriverVersion   : MMVERSION,
    szPname          : [32]CHAR,
    dwFormats        : DWORD,
    wChannels        : WORD,
    wReserved1       : WORD,
    dwSupport        : DWORD,
    ManufacturerGuid : GUID,
    ProductGuid      : GUID,
    NameGuid         : GUID,
};
PWAVEOUTCAPS2A :: ^WAVEOUTCAPS2A;
NPWAVEOUTCAPS2A :: ^WAVEOUTCAPS2A;
LPWAVEOUTCAPS2A :: ^WAVEOUTCAPS2A;

WAVEOUTCAPS2W :: struct {
    wMid             : WORD,
    wPid             : WORD,
    vDriverVersion   : MMVERSION,
    szPname          : [32]WCHAR,
    dwFormats        : DWORD,
    wChannels        : WORD,
    wReserved1       : WORD,
    dwSupport        : DWORD,
    ManufacturerGuid : GUID,
    ProductGuid      : GUID,
    NameGuid         : GUID,
};
PWAVEOUTCAPS2W :: ^WAVEOUTCAPS2W;
NPWAVEOUTCAPS2W :: ^WAVEOUTCAPS2W;
LPWAVEOUTCAPS2W :: ^WAVEOUTCAPS2W;

WAVEOUTCAPS2 :: WAVEOUTCAPS2A;

PWAVEOUTCAPS2 :: PWAVEOUTCAPS2A;

NPWAVEOUTCAPS2 :: NPWAVEOUTCAPS2A;

LPWAVEOUTCAPS2 :: LPWAVEOUTCAPS2A;

WAVEINCAPSA :: struct {
    wMid           : WORD,
    wPid           : WORD,
    vDriverVersion : MMVERSION,
    szPname        : [32]CHAR,
    dwFormats      : DWORD,
    wChannels      : WORD,
    wReserved1     : WORD,
};
PWAVEINCAPSA :: ^WAVEINCAPSA;
NPWAVEINCAPSA :: ^WAVEINCAPSA;
LPWAVEINCAPSA :: ^WAVEINCAPSA;

WAVEINCAPSW :: struct {
    wMid           : WORD,
    wPid           : WORD,
    vDriverVersion : MMVERSION,
    szPname        : [32]WCHAR,
    dwFormats      : DWORD,
    wChannels      : WORD,
    wReserved1     : WORD,
};
PWAVEINCAPSW :: ^WAVEINCAPSW;
NPWAVEINCAPSW :: ^WAVEINCAPSW;
LPWAVEINCAPSW :: ^WAVEINCAPSW;

WAVEINCAPS :: WAVEINCAPSA;

PWAVEINCAPS :: PWAVEINCAPSA;

NPWAVEINCAPS :: NPWAVEINCAPSA;

LPWAVEINCAPS :: LPWAVEINCAPSA;

WAVEINCAPS2A :: struct {
    wMid             : WORD,
    wPid             : WORD,
    vDriverVersion   : MMVERSION,
    szPname          : [32]CHAR,
    dwFormats        : DWORD,
    wChannels        : WORD,
    wReserved1       : WORD,
    ManufacturerGuid : GUID,
    ProductGuid      : GUID,
    NameGuid         : GUID,
};
PWAVEINCAPS2A :: ^WAVEINCAPS2A;
NPWAVEINCAPS2A :: ^WAVEINCAPS2A;
LPWAVEINCAPS2A :: ^WAVEINCAPS2A;

WAVEINCAPS2W :: struct {
    wMid             : WORD,
    wPid             : WORD,
    vDriverVersion   : MMVERSION,
    szPname          : [32]WCHAR,
    dwFormats        : DWORD,
    wChannels        : WORD,
    wReserved1       : WORD,
    ManufacturerGuid : GUID,
    ProductGuid      : GUID,
    NameGuid         : GUID,
};
PWAVEINCAPS2W :: ^WAVEINCAPS2W;
NPWAVEINCAPS2W :: ^WAVEINCAPS2W;
LPWAVEINCAPS2W :: ^WAVEINCAPS2W;

WAVEINCAPS2 :: WAVEINCAPS2A;

PWAVEINCAPS2 :: PWAVEINCAPS2A;

NPWAVEINCAPS2 :: NPWAVEINCAPS2A;

LPWAVEINCAPS2 :: LPWAVEINCAPS2A;

WAVEFORMAT :: struct {
    wFormatTag      : WORD,
    nChannels       : WORD,
    nSamplesPerSec  : DWORD,
    nAvgBytesPerSec : DWORD,
    nBlockAlign     : WORD,
};
PWAVEFORMAT :: ^WAVEFORMAT;
NPWAVEFORMAT :: ^WAVEFORMAT;
LPWAVEFORMAT :: ^WAVEFORMAT;

PCMWAVEFORMAT :: struct {
    wf             : WAVEFORMAT,
    wBitsPerSample : WORD,
};
PPCMWAVEFORMAT :: ^PCMWAVEFORMAT;
NPPCMWAVEFORMAT :: ^PCMWAVEFORMAT;
LPPCMWAVEFORMAT :: ^PCMWAVEFORMAT;

WAVEFORMATEX :: struct {
    wFormatTag      : WORD,
    nChannels       : WORD,
    nSamplesPerSec  : DWORD,
    nAvgBytesPerSec : DWORD,
    nBlockAlign     : WORD,
    wBitsPerSample  : WORD,
    cbSize          : WORD,
};
PWAVEFORMATEX :: ^WAVEFORMATEX;
NPWAVEFORMATEX :: ^WAVEFORMATEX;
LPWAVEFORMATEX :: ^WAVEFORMATEX;

LPCWAVEFORMATEX :: ^WAVEFORMATEX;

HMIDI__ :: struct {
    unused : _c.int,
};

HMIDI :: ^HMIDI__;

HMIDIIN__ :: struct {
    unused : _c.int,
};

HMIDIIN :: ^HMIDIIN__;

HMIDIOUT__ :: struct {
    unused : _c.int,
};

HMIDIOUT :: ^HMIDIOUT__;

HMIDISTRM__ :: struct {
    unused : _c.int,
};

HMIDISTRM :: ^HMIDISTRM__;

LPHMIDI :: ^HMIDI;

LPHMIDIIN :: ^HMIDIIN;

LPHMIDIOUT :: ^HMIDIOUT;

LPHMIDISTRM :: ^HMIDISTRM;

MIDICALLBACK :: DRVCALLBACK;

LPMIDICALLBACK :: ^MIDICALLBACK;

PATCHARRAY :: [128]WORD;

LPPATCHARRAY :: ^WORD;

KEYARRAY :: [128]WORD;

LPKEYARRAY :: ^WORD;

MIDIOUTCAPSA :: struct {
    wMid           : WORD,
    wPid           : WORD,
    vDriverVersion : MMVERSION,
    szPname        : [32]CHAR,
    wTechnology    : WORD,
    wVoices        : WORD,
    wNotes         : WORD,
    wChannelMask   : WORD,
    dwSupport      : DWORD,
};
PMIDIOUTCAPSA :: ^MIDIOUTCAPSA;
NPMIDIOUTCAPSA :: ^MIDIOUTCAPSA;
LPMIDIOUTCAPSA :: ^MIDIOUTCAPSA;

MIDIOUTCAPSW :: struct {
    wMid           : WORD,
    wPid           : WORD,
    vDriverVersion : MMVERSION,
    szPname        : [32]WCHAR,
    wTechnology    : WORD,
    wVoices        : WORD,
    wNotes         : WORD,
    wChannelMask   : WORD,
    dwSupport      : DWORD,
};
PMIDIOUTCAPSW :: ^MIDIOUTCAPSW;
NPMIDIOUTCAPSW :: ^MIDIOUTCAPSW;
LPMIDIOUTCAPSW :: ^MIDIOUTCAPSW;

MIDIOUTCAPS :: MIDIOUTCAPSA;

PMIDIOUTCAPS :: PMIDIOUTCAPSA;

NPMIDIOUTCAPS :: NPMIDIOUTCAPSA;

LPMIDIOUTCAPS :: LPMIDIOUTCAPSA;

MIDIOUTCAPS2A :: struct {
    wMid             : WORD,
    wPid             : WORD,
    vDriverVersion   : MMVERSION,
    szPname          : [32]CHAR,
    wTechnology      : WORD,
    wVoices          : WORD,
    wNotes           : WORD,
    wChannelMask     : WORD,
    dwSupport        : DWORD,
    ManufacturerGuid : GUID,
    ProductGuid      : GUID,
    NameGuid         : GUID,
};
PMIDIOUTCAPS2A :: ^MIDIOUTCAPS2A;
NPMIDIOUTCAPS2A :: ^MIDIOUTCAPS2A;
LPMIDIOUTCAPS2A :: ^MIDIOUTCAPS2A;

MIDIOUTCAPS2W :: struct {
    wMid             : WORD,
    wPid             : WORD,
    vDriverVersion   : MMVERSION,
    szPname          : [32]WCHAR,
    wTechnology      : WORD,
    wVoices          : WORD,
    wNotes           : WORD,
    wChannelMask     : WORD,
    dwSupport        : DWORD,
    ManufacturerGuid : GUID,
    ProductGuid      : GUID,
    NameGuid         : GUID,
};
PMIDIOUTCAPS2W :: ^MIDIOUTCAPS2W;
NPMIDIOUTCAPS2W :: ^MIDIOUTCAPS2W;
LPMIDIOUTCAPS2W :: ^MIDIOUTCAPS2W;

MIDIOUTCAPS2 :: MIDIOUTCAPS2A;

PMIDIOUTCAPS2 :: PMIDIOUTCAPS2A;

NPMIDIOUTCAPS2 :: NPMIDIOUTCAPS2A;

LPMIDIOUTCAPS2 :: LPMIDIOUTCAPS2A;

MIDIINCAPSA :: struct {
    wMid           : WORD,
    wPid           : WORD,
    vDriverVersion : MMVERSION,
    szPname        : [32]CHAR,
    dwSupport      : DWORD,
};
PMIDIINCAPSA :: ^MIDIINCAPSA;
NPMIDIINCAPSA :: ^MIDIINCAPSA;
LPMIDIINCAPSA :: ^MIDIINCAPSA;

MIDIINCAPSW :: struct {
    wMid           : WORD,
    wPid           : WORD,
    vDriverVersion : MMVERSION,
    szPname        : [32]WCHAR,
    dwSupport      : DWORD,
};
PMIDIINCAPSW :: ^MIDIINCAPSW;
NPMIDIINCAPSW :: ^MIDIINCAPSW;
LPMIDIINCAPSW :: ^MIDIINCAPSW;

MIDIINCAPS :: MIDIINCAPSA;

PMIDIINCAPS :: PMIDIINCAPSA;

NPMIDIINCAPS :: NPMIDIINCAPSA;

LPMIDIINCAPS :: LPMIDIINCAPSA;

MIDIINCAPS2A :: struct {
    wMid             : WORD,
    wPid             : WORD,
    vDriverVersion   : MMVERSION,
    szPname          : [32]CHAR,
    dwSupport        : DWORD,
    ManufacturerGuid : GUID,
    ProductGuid      : GUID,
    NameGuid         : GUID,
};
PMIDIINCAPS2A :: ^MIDIINCAPS2A;
NPMIDIINCAPS2A :: ^MIDIINCAPS2A;
LPMIDIINCAPS2A :: ^MIDIINCAPS2A;

MIDIINCAPS2W :: struct {
    wMid             : WORD,
    wPid             : WORD,
    vDriverVersion   : MMVERSION,
    szPname          : [32]WCHAR,
    dwSupport        : DWORD,
    ManufacturerGuid : GUID,
    ProductGuid      : GUID,
    NameGuid         : GUID,
};
PMIDIINCAPS2W :: ^MIDIINCAPS2W;
NPMIDIINCAPS2W :: ^MIDIINCAPS2W;
LPMIDIINCAPS2W :: ^MIDIINCAPS2W;

MIDIINCAPS2 :: MIDIINCAPS2A;

PMIDIINCAPS2 :: PMIDIINCAPS2A;

NPMIDIINCAPS2 :: NPMIDIINCAPS2A;

LPMIDIINCAPS2 :: LPMIDIINCAPS2A;

MIDIHDR :: struct {
    lpData          : LPSTR,
    dwBufferLength  : DWORD,
    dwBytesRecorded : DWORD,
    dwUser          : DWORD_PTR,
    dwFlags         : DWORD,
    lpNext          : ^MIDIHDR,
    reserved        : DWORD_PTR,
    dwOffset        : DWORD,
    dwReserved      : [8]DWORD_PTR,
};
PMIDIHDR :: ^MIDIHDR;
NPMIDIHDR :: ^MIDIHDR;
LPMIDIHDR :: ^MIDIHDR;

MIDIEVENT :: struct {
    dwDeltaTime : DWORD,
    dwStreamID  : DWORD,
    dwEvent     : DWORD,
    dwParms     : [1]DWORD,
};

MIDISTRMBUFFVER :: struct {
    dwVersion    : DWORD,
    dwMid        : DWORD,
    dwOEMVersion : DWORD,
};

MIDIPROPTIMEDIV :: struct {
    cbStruct  : DWORD,
    dwTimeDiv : DWORD,
};
LPMIDIPROPTIMEDIV :: ^MIDIPROPTIMEDIV;

MIDIPROPTEMPO :: struct {
    cbStruct : DWORD,
    dwTempo  : DWORD,
};
LPMIDIPROPTEMPO :: ^MIDIPROPTEMPO;

AUXCAPSA :: struct {
    wMid           : WORD,
    wPid           : WORD,
    vDriverVersion : MMVERSION,
    szPname        : [32]CHAR,
    wTechnology    : WORD,
    wReserved1     : WORD,
    dwSupport      : DWORD,
};
PAUXCAPSA :: ^AUXCAPSA;
NPAUXCAPSA :: ^AUXCAPSA;
LPAUXCAPSA :: ^AUXCAPSA;

AUXCAPSW :: struct {
    wMid           : WORD,
    wPid           : WORD,
    vDriverVersion : MMVERSION,
    szPname        : [32]WCHAR,
    wTechnology    : WORD,
    wReserved1     : WORD,
    dwSupport      : DWORD,
};
PAUXCAPSW :: ^AUXCAPSW;
NPAUXCAPSW :: ^AUXCAPSW;
LPAUXCAPSW :: ^AUXCAPSW;

AUXCAPS :: AUXCAPSA;

PAUXCAPS :: PAUXCAPSA;

NPAUXCAPS :: NPAUXCAPSA;

LPAUXCAPS :: LPAUXCAPSA;

AUXCAPS2A :: struct {
    wMid             : WORD,
    wPid             : WORD,
    vDriverVersion   : MMVERSION,
    szPname          : [32]CHAR,
    wTechnology      : WORD,
    wReserved1       : WORD,
    dwSupport        : DWORD,
    ManufacturerGuid : GUID,
    ProductGuid      : GUID,
    NameGuid         : GUID,
};
PAUXCAPS2A :: ^AUXCAPS2A;
NPAUXCAPS2A :: ^AUXCAPS2A;
LPAUXCAPS2A :: ^AUXCAPS2A;

AUXCAPS2W :: struct {
    wMid             : WORD,
    wPid             : WORD,
    vDriverVersion   : MMVERSION,
    szPname          : [32]WCHAR,
    wTechnology      : WORD,
    wReserved1       : WORD,
    dwSupport        : DWORD,
    ManufacturerGuid : GUID,
    ProductGuid      : GUID,
    NameGuid         : GUID,
};
PAUXCAPS2W :: ^AUXCAPS2W;
NPAUXCAPS2W :: ^AUXCAPS2W;
LPAUXCAPS2W :: ^AUXCAPS2W;

AUXCAPS2 :: AUXCAPS2A;

PAUXCAPS2 :: PAUXCAPS2A;

NPAUXCAPS2 :: NPAUXCAPS2A;

LPAUXCAPS2 :: LPAUXCAPS2A;

HMIXEROBJ__ :: struct {
    unused : _c.int,
};

HMIXEROBJ :: ^HMIXEROBJ__;

LPHMIXEROBJ :: ^HMIXEROBJ;

HMIXER__ :: struct {
    unused : _c.int,
};

HMIXER :: ^HMIXER__;

LPHMIXER :: ^HMIXER;

MIXERCAPSA :: struct {
    wMid           : WORD,
    wPid           : WORD,
    vDriverVersion : MMVERSION,
    szPname        : [32]CHAR,
    fdwSupport     : DWORD,
    cDestinations  : DWORD,
};
PMIXERCAPSA :: ^MIXERCAPSA;
LPMIXERCAPSA :: ^MIXERCAPSA;

MIXERCAPSW :: struct {
    wMid           : WORD,
    wPid           : WORD,
    vDriverVersion : MMVERSION,
    szPname        : [32]WCHAR,
    fdwSupport     : DWORD,
    cDestinations  : DWORD,
};
PMIXERCAPSW :: ^MIXERCAPSW;
LPMIXERCAPSW :: ^MIXERCAPSW;

MIXERCAPS :: MIXERCAPSA;

PMIXERCAPS :: PMIXERCAPSA;

LPMIXERCAPS :: LPMIXERCAPSA;

MIXERCAPS2A :: struct {
    wMid             : WORD,
    wPid             : WORD,
    vDriverVersion   : MMVERSION,
    szPname          : [32]CHAR,
    fdwSupport       : DWORD,
    cDestinations    : DWORD,
    ManufacturerGuid : GUID,
    ProductGuid      : GUID,
    NameGuid         : GUID,
};
PMIXERCAPS2A :: ^MIXERCAPS2A;
LPMIXERCAPS2A :: ^MIXERCAPS2A;

MIXERCAPS2W :: struct {
    wMid             : WORD,
    wPid             : WORD,
    vDriverVersion   : MMVERSION,
    szPname          : [32]WCHAR,
    fdwSupport       : DWORD,
    cDestinations    : DWORD,
    ManufacturerGuid : GUID,
    ProductGuid      : GUID,
    NameGuid         : GUID,
};
PMIXERCAPS2W :: ^MIXERCAPS2W;
LPMIXERCAPS2W :: ^MIXERCAPS2W;

MIXERCAPS2 :: MIXERCAPS2A;

PMIXERCAPS2 :: PMIXERCAPS2A;

LPMIXERCAPS2 :: LPMIXERCAPS2A;

MIXERLINEA :: struct {
    cbStruct        : DWORD,
    dwDestination   : DWORD,
    dwSource        : DWORD,
    dwLineID        : DWORD,
    fdwLine         : DWORD,
    dwUser          : DWORD_PTR,
    dwComponentType : DWORD,
    cChannels       : DWORD,
    cConnections    : DWORD,
    cControls       : DWORD,
    szShortName     : [16]CHAR,
    szName          : [64]CHAR,
    Target : struct {
        dwType         : DWORD,
        dwDeviceID     : DWORD,
        wMid           : WORD,
        wPid           : WORD,
        vDriverVersion : MMVERSION,
        szPname        : [32]CHAR,
    },
};
PMIXERLINEA :: ^MIXERLINEA;
LPMIXERLINEA :: ^MIXERLINEA;

MIXERLINEW :: struct {
    cbStruct        : DWORD,
    dwDestination   : DWORD,
    dwSource        : DWORD,
    dwLineID        : DWORD,
    fdwLine         : DWORD,
    dwUser          : DWORD_PTR,
    dwComponentType : DWORD,
    cChannels       : DWORD,
    cConnections    : DWORD,
    cControls       : DWORD,
    szShortName     : [16]WCHAR,
    szName          : [64]WCHAR,
    Target : struct {
        dwType         : DWORD,
        dwDeviceID     : DWORD,
        wMid           : WORD,
        wPid           : WORD,
        vDriverVersion : MMVERSION,
        szPname        : [32]WCHAR,
    },
};
PMIXERLINEW :: ^MIXERLINEW;
LPMIXERLINEW :: ^MIXERLINEW;

MIXERLINE :: MIXERLINEA;

PMIXERLINE :: PMIXERLINEA;

LPMIXERLINE :: LPMIXERLINEA;

MIXERCONTROLA :: struct {
    cbStruct       : DWORD,
    dwControlID    : DWORD,
    dwControlType  : DWORD,
    fdwControl     : DWORD,
    cMultipleItems : DWORD,
    szShortName    : [16]CHAR,
    szName         : [64]CHAR,
    Bounds : struct #raw_union {
        s : struct {
            lMinimum : LONG,
            lMaximum : LONG,
        },
        s2 : struct {
            dwMinimum : DWORD,
            dwMaximum : DWORD,
        },
        dwReserved : [6]DWORD,
    },
    Metrics : struct #raw_union {
        cSteps       : DWORD,
        cbCustomData : DWORD,
        dwReserved   : [6]DWORD,
    },
};
PMIXERCONTROLA :: ^MIXERCONTROLA;
LPMIXERCONTROLA :: ^MIXERCONTROLA;

MIXERCONTROLW :: struct {
    cbStruct       : DWORD,
    dwControlID    : DWORD,
    dwControlType  : DWORD,
    fdwControl     : DWORD,
    cMultipleItems : DWORD,
    szShortName    : [16]WCHAR,
    szName         : [64]WCHAR,
    Bounds : struct #raw_union {
        s : struct {
            lMinimum : LONG,
            lMaximum : LONG,
        },
        s2 : struct {
            dwMinimum : DWORD,
            dwMaximum : DWORD,
        },
        dwReserved : [6]DWORD,
    },
    Metrics : struct #raw_union {
        cSteps       : DWORD,
        cbCustomData : DWORD,
        dwReserved   : [6]DWORD,
    },
};
PMIXERCONTROLW :: ^MIXERCONTROLW;
LPMIXERCONTROLW :: ^MIXERCONTROLW;

MIXERCONTROL :: MIXERCONTROLA;

PMIXERCONTROL :: PMIXERCONTROLA;

LPMIXERCONTROL :: LPMIXERCONTROLA;

MIXERLINECONTROLSA :: struct {
    cbStruct  : DWORD,
    dwLineID  : DWORD,
    u : struct #raw_union {
        dwControlID   : DWORD,
        dwControlType : DWORD,
    },
    cControls : DWORD,
    cbmxctrl  : DWORD,
    pamxctrl  : LPMIXERCONTROLA,
};
PMIXERLINECONTROLSA :: ^MIXERLINECONTROLSA;
LPMIXERLINECONTROLSA :: ^MIXERLINECONTROLSA;

MIXERLINECONTROLSW :: struct {
    cbStruct  : DWORD,
    dwLineID  : DWORD,
    u : struct #raw_union {
        dwControlID   : DWORD,
        dwControlType : DWORD,
    },
    cControls : DWORD,
    cbmxctrl  : DWORD,
    pamxctrl  : LPMIXERCONTROLW,
};
PMIXERLINECONTROLSW :: ^MIXERLINECONTROLSW;
LPMIXERLINECONTROLSW :: ^MIXERLINECONTROLSW;

MIXERLINECONTROLS :: MIXERLINECONTROLSA;

PMIXERLINECONTROLS :: PMIXERLINECONTROLSA;

LPMIXERLINECONTROLS :: LPMIXERLINECONTROLSA;

MIXERCONTROLDETAILS :: struct {
    cbStruct    : DWORD,
    dwControlID : DWORD,
    cChannels   : DWORD,
    u : struct #raw_union {
        hwndOwner      : HWND,
        cMultipleItems : DWORD,
    },
    cbDetails   : DWORD,
    paDetails   : LPVOID,
};
PMIXERCONTROLDETAILS :: ^MIXERCONTROLDETAILS;
LPMIXERCONTROLDETAILS :: ^MIXERCONTROLDETAILS;

MIXERCONTROLDETAILS_LISTTEXTA :: struct {
    dwParam1 : DWORD,
    dwParam2 : DWORD,
    szName   : [64]CHAR,
};
PMIXERCONTROLDETAILS_LISTTEXTA :: ^MIXERCONTROLDETAILS_LISTTEXTA;
LPMIXERCONTROLDETAILS_LISTTEXTA :: ^MIXERCONTROLDETAILS_LISTTEXTA;

MIXERCONTROLDETAILS_LISTTEXTW :: struct {
    dwParam1 : DWORD,
    dwParam2 : DWORD,
    szName   : [64]WCHAR,
};
PMIXERCONTROLDETAILS_LISTTEXTW :: ^MIXERCONTROLDETAILS_LISTTEXTW;
LPMIXERCONTROLDETAILS_LISTTEXTW :: ^MIXERCONTROLDETAILS_LISTTEXTW;

MIXERCONTROLDETAILS_LISTTEXT :: MIXERCONTROLDETAILS_LISTTEXTA;

PMIXERCONTROLDETAILS_LISTTEXT :: PMIXERCONTROLDETAILS_LISTTEXTA;

LPMIXERCONTROLDETAILS_LISTTEXT :: LPMIXERCONTROLDETAILS_LISTTEXTA;

MIXERCONTROLDETAILS_BOOLEAN :: struct {
    fValue : LONG,
};
PMIXERCONTROLDETAILS_BOOLEAN :: ^MIXERCONTROLDETAILS_BOOLEAN;
LPMIXERCONTROLDETAILS_BOOLEAN :: ^MIXERCONTROLDETAILS_BOOLEAN;

MIXERCONTROLDETAILS_SIGNED :: struct {
    lValue : LONG,
};
PMIXERCONTROLDETAILS_SIGNED :: ^MIXERCONTROLDETAILS_SIGNED;
LPMIXERCONTROLDETAILS_SIGNED :: ^MIXERCONTROLDETAILS_SIGNED;

MIXERCONTROLDETAILS_UNSIGNED :: struct {
    dwValue : DWORD,
};
PMIXERCONTROLDETAILS_UNSIGNED :: ^MIXERCONTROLDETAILS_UNSIGNED;
LPMIXERCONTROLDETAILS_UNSIGNED :: ^MIXERCONTROLDETAILS_UNSIGNED;

TIMECAPS :: struct {
    wPeriodMin : UINT,
    wPeriodMax : UINT,
};
PTIMECAPS :: ^TIMECAPS;
NPTIMECAPS :: ^TIMECAPS;
LPTIMECAPS :: ^TIMECAPS;

JOYCAPSA :: struct {
    wMid        : WORD,
    wPid        : WORD,
    szPname     : [32]CHAR,
    wXmin       : UINT,
    wXmax       : UINT,
    wYmin       : UINT,
    wYmax       : UINT,
    wZmin       : UINT,
    wZmax       : UINT,
    wNumButtons : UINT,
    wPeriodMin  : UINT,
    wPeriodMax  : UINT,
    wRmin       : UINT,
    wRmax       : UINT,
    wUmin       : UINT,
    wUmax       : UINT,
    wVmin       : UINT,
    wVmax       : UINT,
    wCaps       : UINT,
    wMaxAxes    : UINT,
    wNumAxes    : UINT,
    wMaxButtons : UINT,
    szRegKey    : [32]CHAR,
    szOEMVxD    : [260]CHAR,
};
PJOYCAPSA :: ^JOYCAPSA;
NPJOYCAPSA :: ^JOYCAPSA;
LPJOYCAPSA :: ^JOYCAPSA;

JOYCAPSW :: struct {
    wMid        : WORD,
    wPid        : WORD,
    szPname     : [32]WCHAR,
    wXmin       : UINT,
    wXmax       : UINT,
    wYmin       : UINT,
    wYmax       : UINT,
    wZmin       : UINT,
    wZmax       : UINT,
    wNumButtons : UINT,
    wPeriodMin  : UINT,
    wPeriodMax  : UINT,
    wRmin       : UINT,
    wRmax       : UINT,
    wUmin       : UINT,
    wUmax       : UINT,
    wVmin       : UINT,
    wVmax       : UINT,
    wCaps       : UINT,
    wMaxAxes    : UINT,
    wNumAxes    : UINT,
    wMaxButtons : UINT,
    szRegKey    : [32]WCHAR,
    szOEMVxD    : [260]WCHAR,
};
PJOYCAPSW :: ^JOYCAPSW;
NPJOYCAPSW :: ^JOYCAPSW;
LPJOYCAPSW :: ^JOYCAPSW;

JOYCAPS :: JOYCAPSA;

PJOYCAPS :: PJOYCAPSA;

NPJOYCAPS :: NPJOYCAPSA;

LPJOYCAPS :: LPJOYCAPSA;

JOYCAPS2A :: struct {
    wMid             : WORD,
    wPid             : WORD,
    szPname          : [32]CHAR,
    wXmin            : UINT,
    wXmax            : UINT,
    wYmin            : UINT,
    wYmax            : UINT,
    wZmin            : UINT,
    wZmax            : UINT,
    wNumButtons      : UINT,
    wPeriodMin       : UINT,
    wPeriodMax       : UINT,
    wRmin            : UINT,
    wRmax            : UINT,
    wUmin            : UINT,
    wUmax            : UINT,
    wVmin            : UINT,
    wVmax            : UINT,
    wCaps            : UINT,
    wMaxAxes         : UINT,
    wNumAxes         : UINT,
    wMaxButtons      : UINT,
    szRegKey         : [32]CHAR,
    szOEMVxD         : [260]CHAR,
    ManufacturerGuid : GUID,
    ProductGuid      : GUID,
    NameGuid         : GUID,
};
PJOYCAPS2A :: ^JOYCAPS2A;
NPJOYCAPS2A :: ^JOYCAPS2A;
LPJOYCAPS2A :: ^JOYCAPS2A;

JOYCAPS2W :: struct {
    wMid             : WORD,
    wPid             : WORD,
    szPname          : [32]WCHAR,
    wXmin            : UINT,
    wXmax            : UINT,
    wYmin            : UINT,
    wYmax            : UINT,
    wZmin            : UINT,
    wZmax            : UINT,
    wNumButtons      : UINT,
    wPeriodMin       : UINT,
    wPeriodMax       : UINT,
    wRmin            : UINT,
    wRmax            : UINT,
    wUmin            : UINT,
    wUmax            : UINT,
    wVmin            : UINT,
    wVmax            : UINT,
    wCaps            : UINT,
    wMaxAxes         : UINT,
    wNumAxes         : UINT,
    wMaxButtons      : UINT,
    szRegKey         : [32]WCHAR,
    szOEMVxD         : [260]WCHAR,
    ManufacturerGuid : GUID,
    ProductGuid      : GUID,
    NameGuid         : GUID,
};
PJOYCAPS2W :: ^JOYCAPS2W;
NPJOYCAPS2W :: ^JOYCAPS2W;
LPJOYCAPS2W :: ^JOYCAPS2W;

JOYCAPS2 :: JOYCAPS2A;

PJOYCAPS2 :: PJOYCAPS2A;

NPJOYCAPS2 :: NPJOYCAPS2A;

LPJOYCAPS2 :: LPJOYCAPS2A;

JOYINFO :: struct {
    wXpos    : UINT,
    wYpos    : UINT,
    wZpos    : UINT,
    wButtons : UINT,
};
PJOYINFO :: ^JOYINFO;
NPJOYINFO :: ^JOYINFO;
LPJOYINFO :: ^JOYINFO;

JOYINFOEX :: struct {
    dwSize         : DWORD,
    dwFlags        : DWORD,
    dwXpos         : DWORD,
    dwYpos         : DWORD,
    dwZpos         : DWORD,
    dwRpos         : DWORD,
    dwUpos         : DWORD,
    dwVpos         : DWORD,
    dwButtons      : DWORD,
    dwButtonNumber : DWORD,
    dwPOV          : DWORD,
    dwReserved1    : DWORD,
    dwReserved2    : DWORD,
};
PJOYINFOEX :: ^JOYINFOEX;
NPJOYINFOEX :: ^JOYINFOEX;
LPJOYINFOEX :: ^JOYINFOEX;

NCB :: struct {
    ncb_command  : UCHAR,
    ncb_retcode  : UCHAR,
    ncb_lsn      : UCHAR,
    ncb_num      : UCHAR,
    ncb_buffer   : PUCHAR,
    ncb_length   : WORD,
    ncb_callname : [16]UCHAR,
    ncb_name     : [16]UCHAR,
    ncb_rto      : UCHAR,
    ncb_sto      : UCHAR,
    ncb_post     : proc "stdcall" (^NCB),
    ncb_lana_num : UCHAR,
    ncb_cmd_cplt : UCHAR,
    ncb_reserve  : [18]UCHAR,
    ncb_event    : HANDLE,
};
PNCB :: ^NCB;

ADAPTER_STATUS :: struct {
    adapter_address   : [6]UCHAR,
    rev_major         : UCHAR,
    reserved0         : UCHAR,
    adapter_type      : UCHAR,
    rev_minor         : UCHAR,
    duration          : WORD,
    frmr_recv         : WORD,
    frmr_xmit         : WORD,
    iframe_recv_err   : WORD,
    xmit_aborts       : WORD,
    xmit_success      : DWORD,
    recv_success      : DWORD,
    iframe_xmit_err   : WORD,
    recv_buff_unavail : WORD,
    t1_timeouts       : WORD,
    ti_timeouts       : WORD,
    reserved1         : DWORD,
    free_ncbs         : WORD,
    max_cfg_ncbs      : WORD,
    max_ncbs          : WORD,
    xmit_buf_unavail  : WORD,
    max_dgram_size    : WORD,
    pending_sess      : WORD,
    max_cfg_sess      : WORD,
    max_sess          : WORD,
    max_sess_pkt_size : WORD,
    name_count        : WORD,
};
PADAPTER_STATUS :: ^ADAPTER_STATUS;

NAME_BUFFER :: struct {
    name       : [16]UCHAR,
    name_num   : UCHAR,
    name_flags : UCHAR,
};
PNAME_BUFFER :: ^NAME_BUFFER;

SESSION_HEADER :: struct {
    sess_name           : UCHAR,
    num_sess            : UCHAR,
    rcv_dg_outstanding  : UCHAR,
    rcv_any_outstanding : UCHAR,
};
PSESSION_HEADER :: ^SESSION_HEADER;

SESSION_BUFFER :: struct {
    lsn               : UCHAR,
    state             : UCHAR,
    local_name        : [16]UCHAR,
    remote_name       : [16]UCHAR,
    rcvs_outstanding  : UCHAR,
    sends_outstanding : UCHAR,
};
PSESSION_BUFFER :: ^SESSION_BUFFER;

LANA_ENUM :: struct {
    length : UCHAR,
    lana   : [254 + 1]UCHAR,
};
PLANA_ENUM :: ^LANA_ENUM;

FIND_NAME_HEADER :: struct {
    node_count   : WORD,
    reserved     : UCHAR,
    unique_group : UCHAR,
};
PFIND_NAME_HEADER :: ^FIND_NAME_HEADER;

FIND_NAME_BUFFER :: struct {
    length           : UCHAR,
    access_control   : UCHAR,
    frame_control    : UCHAR,
    destination_addr : [6]UCHAR,
    source_addr      : [6]UCHAR,
    routing_info     : [18]UCHAR,
};
PFIND_NAME_BUFFER :: ^FIND_NAME_BUFFER;

ACTION_HEADER :: struct {
    transport_id : ULONG,
    action_code  : USHORT,
    reserved     : USHORT,
};
PACTION_HEADER :: ^ACTION_HEADER;

I_RPC_HANDLE :: rawptr;

RPC_STATUS :: _c.long;

RPC_CSTR :: ^_c.uchar;

RPC_WSTR :: ^_c.ushort;

RPC_CWSTR :: ^_c.ushort;

RPC_BINDING_HANDLE :: I_RPC_HANDLE;

handle_t :: RPC_BINDING_HANDLE;

UUID :: GUID;

RPC_BINDING_VECTOR :: struct {
    Count    : _c.ulong,
    BindingH : [1]RPC_BINDING_HANDLE,
};

UUID_VECTOR :: struct {
    Count : _c.ulong,
    Uuid  : [1]^UUID,
};

RPC_IF_HANDLE :: rawptr;

RPC_IF_ID :: struct {
    Uuid      : UUID,
    VersMajor : _c.ushort,
    VersMinor : _c.ushort,
};

RPC_PROTSEQ_VECTORA :: struct {
    Count   : _c.uint,
    Protseq : [1]^_c.uchar,
};

RPC_PROTSEQ_VECTORW :: struct {
    Count   : _c.uint,
    Protseq : [1]^_c.ushort,
};

RPC_POLICY :: struct {
    Length        : _c.uint,
    EndpointFlags : _c.ulong,
    NICFlags      : _c.ulong,
};
PRPC_POLICY :: ^RPC_POLICY;

RPC_OBJECT_INQ_FN :: #type proc "stdcall" (ObjectUuid : ^UUID, TypeUuid : ^UUID, Status : ^RPC_STATUS);

RPC_IF_CALLBACK_FN :: #type (proc "stdcall" (InterfaceUuid : RPC_IF_HANDLE, Context : rawptr) -> RPC_STATUS);

RPC_SECURITY_CALLBACK_FN :: #type proc "stdcall" (Context : rawptr);

RPC_STATS_VECTOR :: struct {
    Count : _c.uint,
    Stats : [1]_c.ulong,
};

RPC_IF_ID_VECTOR :: struct {
    Count : _c.ulong,
    IfId  : [1]^RPC_IF_ID,
};

RPC_AUTH_IDENTITY_HANDLE :: rawptr;

RPC_AUTHZ_HANDLE :: rawptr;

RPC_SECURITY_QOS :: struct {
    Version           : _c.ulong,
    Capabilities      : _c.ulong,
    IdentityTracking  : _c.ulong,
    ImpersonationType : _c.ulong,
};
PRPC_SECURITY_QOS :: ^RPC_SECURITY_QOS;

SEC_WINNT_AUTH_IDENTITY_W :: struct {
    User           : ^_c.ushort,
    UserLength     : _c.ulong,
    Domain         : ^_c.ushort,
    DomainLength   : _c.ulong,
    Password       : ^_c.ushort,
    PasswordLength : _c.ulong,
    Flags          : _c.ulong,
};
PSEC_WINNT_AUTH_IDENTITY_W :: ^SEC_WINNT_AUTH_IDENTITY_W;

SEC_WINNT_AUTH_IDENTITY_A :: struct {
    User           : ^_c.uchar,
    UserLength     : _c.ulong,
    Domain         : ^_c.uchar,
    DomainLength   : _c.ulong,
    Password       : ^_c.uchar,
    PasswordLength : _c.ulong,
    Flags          : _c.ulong,
};
PSEC_WINNT_AUTH_IDENTITY_A :: ^SEC_WINNT_AUTH_IDENTITY_A;

RPC_HTTP_TRANSPORT_CREDENTIALS_W :: struct {
    TransportCredentials     : ^SEC_WINNT_AUTH_IDENTITY_W,
    Flags                    : _c.ulong,
    AuthenticationTarget     : _c.ulong,
    NumberOfAuthnSchemes     : _c.ulong,
    AuthnSchemes             : ^_c.ulong,
    ServerCertificateSubject : ^_c.ushort,
};
PRPC_HTTP_TRANSPORT_CREDENTIALS_W :: ^RPC_HTTP_TRANSPORT_CREDENTIALS_W;

RPC_HTTP_TRANSPORT_CREDENTIALS_A :: struct {
    TransportCredentials     : ^SEC_WINNT_AUTH_IDENTITY_A,
    Flags                    : _c.ulong,
    AuthenticationTarget     : _c.ulong,
    NumberOfAuthnSchemes     : _c.ulong,
    AuthnSchemes             : ^_c.ulong,
    ServerCertificateSubject : ^_c.uchar,
};
PRPC_HTTP_TRANSPORT_CREDENTIALS_A :: ^RPC_HTTP_TRANSPORT_CREDENTIALS_A;

RPC_HTTP_TRANSPORT_CREDENTIALS_V2_W :: struct {
    TransportCredentials      : ^SEC_WINNT_AUTH_IDENTITY_W,
    Flags                     : _c.ulong,
    AuthenticationTarget      : _c.ulong,
    NumberOfAuthnSchemes      : _c.ulong,
    AuthnSchemes              : ^_c.ulong,
    ServerCertificateSubject  : ^_c.ushort,
    ProxyCredentials          : ^SEC_WINNT_AUTH_IDENTITY_W,
    NumberOfProxyAuthnSchemes : _c.ulong,
    ProxyAuthnSchemes         : ^_c.ulong,
};
PRPC_HTTP_TRANSPORT_CREDENTIALS_V2_W :: ^RPC_HTTP_TRANSPORT_CREDENTIALS_V2_W;

RPC_HTTP_TRANSPORT_CREDENTIALS_V2_A :: struct {
    TransportCredentials      : ^SEC_WINNT_AUTH_IDENTITY_A,
    Flags                     : _c.ulong,
    AuthenticationTarget      : _c.ulong,
    NumberOfAuthnSchemes      : _c.ulong,
    AuthnSchemes              : ^_c.ulong,
    ServerCertificateSubject  : ^_c.uchar,
    ProxyCredentials          : ^SEC_WINNT_AUTH_IDENTITY_A,
    NumberOfProxyAuthnSchemes : _c.ulong,
    ProxyAuthnSchemes         : ^_c.ulong,
};
PRPC_HTTP_TRANSPORT_CREDENTIALS_V2_A :: ^RPC_HTTP_TRANSPORT_CREDENTIALS_V2_A;

RPC_HTTP_TRANSPORT_CREDENTIALS_V3_W :: struct {
    TransportCredentials      : RPC_AUTH_IDENTITY_HANDLE,
    Flags                     : _c.ulong,
    AuthenticationTarget      : _c.ulong,
    NumberOfAuthnSchemes      : _c.ulong,
    AuthnSchemes              : ^_c.ulong,
    ServerCertificateSubject  : ^_c.ushort,
    ProxyCredentials          : RPC_AUTH_IDENTITY_HANDLE,
    NumberOfProxyAuthnSchemes : _c.ulong,
    ProxyAuthnSchemes         : ^_c.ulong,
};
PRPC_HTTP_TRANSPORT_CREDENTIALS_V3_W :: ^RPC_HTTP_TRANSPORT_CREDENTIALS_V3_W;

RPC_HTTP_TRANSPORT_CREDENTIALS_V3_A :: struct {
    TransportCredentials      : RPC_AUTH_IDENTITY_HANDLE,
    Flags                     : _c.ulong,
    AuthenticationTarget      : _c.ulong,
    NumberOfAuthnSchemes      : _c.ulong,
    AuthnSchemes              : ^_c.ulong,
    ServerCertificateSubject  : ^_c.uchar,
    ProxyCredentials          : RPC_AUTH_IDENTITY_HANDLE,
    NumberOfProxyAuthnSchemes : _c.ulong,
    ProxyAuthnSchemes         : ^_c.ulong,
};
PRPC_HTTP_TRANSPORT_CREDENTIALS_V3_A :: ^RPC_HTTP_TRANSPORT_CREDENTIALS_V3_A;

RPC_SECURITY_QOS_V2_W :: struct {
    Version                    : _c.ulong,
    Capabilities               : _c.ulong,
    IdentityTracking           : _c.ulong,
    ImpersonationType          : _c.ulong,
    AdditionalSecurityInfoType : _c.ulong,
    u : struct #raw_union {
        HttpCredentials : ^RPC_HTTP_TRANSPORT_CREDENTIALS_W,
    },
};
PRPC_SECURITY_QOS_V2_W :: ^RPC_SECURITY_QOS_V2_W;

RPC_SECURITY_QOS_V2_A :: struct {
    Version                    : _c.ulong,
    Capabilities               : _c.ulong,
    IdentityTracking           : _c.ulong,
    ImpersonationType          : _c.ulong,
    AdditionalSecurityInfoType : _c.ulong,
    u : struct #raw_union {
        HttpCredentials : ^RPC_HTTP_TRANSPORT_CREDENTIALS_A,
    },
};
PRPC_SECURITY_QOS_V2_A :: ^RPC_SECURITY_QOS_V2_A;

RPC_SECURITY_QOS_V3_W :: struct {
    Version                    : _c.ulong,
    Capabilities               : _c.ulong,
    IdentityTracking           : _c.ulong,
    ImpersonationType          : _c.ulong,
    AdditionalSecurityInfoType : _c.ulong,
    u : struct #raw_union {
        HttpCredentials : ^RPC_HTTP_TRANSPORT_CREDENTIALS_W,
    },
    Sid                        : rawptr,
};
PRPC_SECURITY_QOS_V3_W :: ^RPC_SECURITY_QOS_V3_W;

RPC_SECURITY_QOS_V3_A :: struct {
    Version                    : _c.ulong,
    Capabilities               : _c.ulong,
    IdentityTracking           : _c.ulong,
    ImpersonationType          : _c.ulong,
    AdditionalSecurityInfoType : _c.ulong,
    u : struct #raw_union {
        HttpCredentials : ^RPC_HTTP_TRANSPORT_CREDENTIALS_A,
    },
    Sid                        : rawptr,
};
PRPC_SECURITY_QOS_V3_A :: ^RPC_SECURITY_QOS_V3_A;

RPC_SECURITY_QOS_V4_W :: struct {
    Version                    : _c.ulong,
    Capabilities               : _c.ulong,
    IdentityTracking           : _c.ulong,
    ImpersonationType          : _c.ulong,
    AdditionalSecurityInfoType : _c.ulong,
    u : struct #raw_union {
        HttpCredentials : ^RPC_HTTP_TRANSPORT_CREDENTIALS_W,
    },
    Sid                        : rawptr,
    EffectiveOnly              : _c.uint,
};
PRPC_SECURITY_QOS_V4_W :: ^RPC_SECURITY_QOS_V4_W;

RPC_SECURITY_QOS_V4_A :: struct {
    Version                    : _c.ulong,
    Capabilities               : _c.ulong,
    IdentityTracking           : _c.ulong,
    ImpersonationType          : _c.ulong,
    AdditionalSecurityInfoType : _c.ulong,
    u : struct #raw_union {
        HttpCredentials : ^RPC_HTTP_TRANSPORT_CREDENTIALS_A,
    },
    Sid                        : rawptr,
    EffectiveOnly              : _c.uint,
};
PRPC_SECURITY_QOS_V4_A :: ^RPC_SECURITY_QOS_V4_A;

RPC_SECURITY_QOS_V5_W :: struct {
    Version                    : _c.ulong,
    Capabilities               : _c.ulong,
    IdentityTracking           : _c.ulong,
    ImpersonationType          : _c.ulong,
    AdditionalSecurityInfoType : _c.ulong,
    u : struct #raw_union {
        HttpCredentials : ^RPC_HTTP_TRANSPORT_CREDENTIALS_W,
    },
    Sid                        : rawptr,
    EffectiveOnly              : _c.uint,
    ServerSecurityDescriptor   : rawptr,
};
PRPC_SECURITY_QOS_V5_W :: ^RPC_SECURITY_QOS_V5_W;

RPC_SECURITY_QOS_V5_A :: struct {
    Version                    : _c.ulong,
    Capabilities               : _c.ulong,
    IdentityTracking           : _c.ulong,
    ImpersonationType          : _c.ulong,
    AdditionalSecurityInfoType : _c.ulong,
    u : struct #raw_union {
        HttpCredentials : ^RPC_HTTP_TRANSPORT_CREDENTIALS_A,
    },
    Sid                        : rawptr,
    EffectiveOnly              : _c.uint,
    ServerSecurityDescriptor   : rawptr,
};
PRPC_SECURITY_QOS_V5_A :: ^RPC_SECURITY_QOS_V5_A;

RPC_BINDING_HANDLE_TEMPLATE_V1_W :: struct {
    Version          : _c.ulong,
    Flags            : _c.ulong,
    ProtocolSequence : _c.ulong,
    NetworkAddress   : ^_c.ushort,
    StringEndpoint   : ^_c.ushort,
    u1 : struct #raw_union {
        Reserved : ^_c.ushort,
    },
    ObjectUuid       : UUID,
};
PRPC_BINDING_HANDLE_TEMPLATE_V1_W :: ^RPC_BINDING_HANDLE_TEMPLATE_V1_W;

RPC_BINDING_HANDLE_TEMPLATE_V1_A :: struct {
    Version          : _c.ulong,
    Flags            : _c.ulong,
    ProtocolSequence : _c.ulong,
    NetworkAddress   : ^_c.uchar,
    StringEndpoint   : ^_c.uchar,
    u1 : struct #raw_union {
        Reserved : ^_c.uchar,
    },
    ObjectUuid       : UUID,
};
PRPC_BINDING_HANDLE_TEMPLATE_V1_A :: ^RPC_BINDING_HANDLE_TEMPLATE_V1_A;

RPC_BINDING_HANDLE_SECURITY_V1_W :: struct {
    Version         : _c.ulong,
    ServerPrincName : ^_c.ushort,
    AuthnLevel      : _c.ulong,
    AuthnSvc        : _c.ulong,
    AuthIdentity    : ^SEC_WINNT_AUTH_IDENTITY_W,
    SecurityQos     : ^RPC_SECURITY_QOS,
};
PRPC_BINDING_HANDLE_SECURITY_V1_W :: ^RPC_BINDING_HANDLE_SECURITY_V1_W;

RPC_BINDING_HANDLE_SECURITY_V1_A :: struct {
    Version         : _c.ulong,
    ServerPrincName : ^_c.uchar,
    AuthnLevel      : _c.ulong,
    AuthnSvc        : _c.ulong,
    AuthIdentity    : ^SEC_WINNT_AUTH_IDENTITY_A,
    SecurityQos     : ^RPC_SECURITY_QOS,
};
PRPC_BINDING_HANDLE_SECURITY_V1_A :: ^RPC_BINDING_HANDLE_SECURITY_V1_A;

RPC_BINDING_HANDLE_OPTIONS_V1 :: struct {
    Version     : _c.ulong,
    Flags       : _c.ulong,
    ComTimeout  : _c.ulong,
    CallTimeout : _c.ulong,
};
PRPC_BINDING_HANDLE_OPTIONS_V1 :: ^RPC_BINDING_HANDLE_OPTIONS_V1;

/* RPC_HTTP_REDIRECTOR_STAGE :: enum { */
RPC_HTTP_REDIRECTOR_STAGE :: _c.int;
    RPCHTTP_RS_REDIRECT :: 1;
    RPCHTTP_RS_ACCESS_1 :: RPCHTTP_RS_REDIRECT + 1;
    RPCHTTP_RS_SESSION :: RPCHTTP_RS_ACCESS_1 + 1;
    RPCHTTP_RS_ACCESS_2 :: RPCHTTP_RS_SESSION + 1;
    RPCHTTP_RS_INTERFACE :: RPCHTTP_RS_ACCESS_2 + 1;
/* } */
;

RPC_NEW_HTTP_PROXY_CHANNEL :: (proc "stdcall" (RedirectorStage : RPC_HTTP_REDIRECTOR_STAGE, ServerName : RPC_WSTR, ServerPort : RPC_WSTR, RemoteUser : RPC_WSTR, AuthType : RPC_WSTR, ResourceUuid : rawptr, SessionId : rawptr, Interface : rawptr, Reserved : rawptr, Flags : _c.ulong, NewServerName : ^RPC_WSTR, NewServerPort : ^RPC_WSTR) -> RPC_STATUS);

RPC_HTTP_PROXY_FREE_STRING :: proc "stdcall" (String : RPC_WSTR);

RPC_AUTH_KEY_RETRIEVAL_FN :: proc "stdcall" (Arg : rawptr, ServerPrincName : RPC_WSTR, KeyVer : _c.ulong, Key : ^rawptr, Status : ^RPC_STATUS);

RPC_CLIENT_INFORMATION1 :: struct {
    UserName     : ^_c.uchar,
    ComputerName : ^_c.uchar,
    Privilege    : _c.ushort,
    AuthFlags    : _c.ulong,
};
PRPC_CLIENT_INFORMATION1 :: ^RPC_CLIENT_INFORMATION1;

RPC_EP_INQ_HANDLE :: ^I_RPC_HANDLE;

RPC_MGMT_AUTHORIZATION_FN :: (proc "stdcall" (ClientBinding : RPC_BINDING_HANDLE, RequestedMgmtOperation : _c.ulong, Status : ^RPC_STATUS) -> _c.int);

RPC_INTERFACE_GROUP :: rawptr;
PRPC_INTERFACE_GROUP :: ^rawptr;

RPC_ENDPOINT_TEMPLATEW :: struct {
    Version            : _c.ulong,
    ProtSeq            : RPC_WSTR,
    Endpoint           : RPC_WSTR,
    SecurityDescriptor : rawptr,
    Backlog            : _c.ulong,
};
PRPC_ENDPOINT_TEMPLATEW :: ^RPC_ENDPOINT_TEMPLATEW;

RPC_ENDPOINT_TEMPLATEA :: struct {
    Version            : _c.ulong,
    ProtSeq            : RPC_CSTR,
    Endpoint           : RPC_CSTR,
    SecurityDescriptor : rawptr,
    Backlog            : _c.ulong,
};
PRPC_ENDPOINT_TEMPLATEA :: ^RPC_ENDPOINT_TEMPLATEA;

RPC_INTERFACE_TEMPLATEA :: struct {
    Version            : _c.ulong,
    IfSpec             : RPC_IF_HANDLE,
    MgrTypeUuid        : ^UUID,
    MgrEpv             : rawptr,
    Flags              : _c.uint,
    MaxCalls           : _c.uint,
    MaxRpcSize         : _c.uint,
    IfCallback         : ^RPC_IF_CALLBACK_FN,
    UuidVector         : ^UUID_VECTOR,
    Annotation         : RPC_CSTR,
    SecurityDescriptor : rawptr,
};
PRPC_INTERFACE_TEMPLATEA :: ^RPC_INTERFACE_TEMPLATEA;

RPC_INTERFACE_TEMPLATEW :: struct {
    Version            : _c.ulong,
    IfSpec             : RPC_IF_HANDLE,
    MgrTypeUuid        : ^UUID,
    MgrEpv             : rawptr,
    Flags              : _c.uint,
    MaxCalls           : _c.uint,
    MaxRpcSize         : _c.uint,
    IfCallback         : ^RPC_IF_CALLBACK_FN,
    UuidVector         : ^UUID_VECTOR,
    Annotation         : RPC_WSTR,
    SecurityDescriptor : rawptr,
};
PRPC_INTERFACE_TEMPLATEW :: ^RPC_INTERFACE_TEMPLATEW;

RPC_INTERFACE_GROUP_IDLE_CALLBACK_FN :: #type proc "stdcall" (IfGroup : RPC_INTERFACE_GROUP, IdleCallbackContext : rawptr, IsGroupIdle : _c.ulong);

RPC_VERSION :: struct {
    MajorVersion : _c.ushort,
    MinorVersion : _c.ushort,
};

RPC_SYNTAX_IDENTIFIER :: struct {
    SyntaxGUID    : GUID,
    SyntaxVersion : RPC_VERSION,
};
PRPC_SYNTAX_IDENTIFIER :: ^RPC_SYNTAX_IDENTIFIER;

RPC_MESSAGE :: struct {
    Handle                  : RPC_BINDING_HANDLE,
    DataRepresentation      : _c.ulong,
    Buffer                  : rawptr,
    BufferLength            : _c.uint,
    ProcNum                 : _c.uint,
    TransferSyntax          : PRPC_SYNTAX_IDENTIFIER,
    RpcInterfaceInformation : rawptr,
    ReservedForRuntime      : rawptr,
    ManagerEpv              : rawptr,
    ImportContext           : rawptr,
    RpcFlags                : _c.ulong,
};
PRPC_MESSAGE :: ^RPC_MESSAGE;

RPC_FORWARD_FUNCTION :: #type (proc "stdcall" (InterfaceId : ^UUID, InterfaceVersion : ^RPC_VERSION, ObjectId : ^UUID, Rpcpro : ^_c.uchar, ppDestEndpoint : ^rawptr) -> RPC_STATUS);

/* RPC_ADDRESS_CHANGE_TYPE :: enum { */
RPC_ADDRESS_CHANGE_TYPE :: _c.int;
    PROTOCOL_NOT_LOADED :: 1;
    PROTOCOL_LOADED :: PROTOCOL_NOT_LOADED + 1;
    PROTOCOL_ADDRESS_CHANGE :: PROTOCOL_LOADED + 1;
/* } */
;

RPC_ADDRESS_CHANGE_FN :: #type proc "stdcall" (arg : rawptr);

RPC_DISPATCH_FUNCTION :: proc "stdcall" (Message : PRPC_MESSAGE);

RPC_DISPATCH_TABLE :: struct {
    DispatchTableCount : _c.uint,
    DispatchTable      : ^RPC_DISPATCH_FUNCTION,
    Reserved           : LONG_PTR,
};
PRPC_DISPATCH_TABLE :: ^RPC_DISPATCH_TABLE;

RPC_PROTSEQ_ENDPOINT :: struct {
    RpcProtocolSequence : ^_c.uchar,
    Endpoint            : ^_c.uchar,
};
PRPC_PROTSEQ_ENDPOINT :: ^RPC_PROTSEQ_ENDPOINT;

RPC_SERVER_INTERFACE :: struct {
    Length                  : _c.uint,
    InterfaceId             : RPC_SYNTAX_IDENTIFIER,
    TransferSyntax          : RPC_SYNTAX_IDENTIFIER,
    DispatchTable           : PRPC_DISPATCH_TABLE,
    RpcProtseqEndpointCount : _c.uint,
    RpcProtseqEndpoint      : PRPC_PROTSEQ_ENDPOINT,
    DefaultManagerEpv       : rawptr,
    InterpreterInfo         : rawptr,
    Flags                   : _c.uint,
};
PRPC_SERVER_INTERFACE :: ^RPC_SERVER_INTERFACE;

RPC_CLIENT_INTERFACE :: struct {
    Length                  : _c.uint,
    InterfaceId             : RPC_SYNTAX_IDENTIFIER,
    TransferSyntax          : RPC_SYNTAX_IDENTIFIER,
    DispatchTable           : PRPC_DISPATCH_TABLE,
    RpcProtseqEndpointCount : _c.uint,
    RpcProtseqEndpoint      : PRPC_PROTSEQ_ENDPOINT,
    Reserved                : ULONG_PTR,
    InterpreterInfo         : rawptr,
    Flags                   : _c.uint,
};
PRPC_CLIENT_INTERFACE :: ^RPC_CLIENT_INTERFACE;

I_RPC_MUTEX :: rawptr;

/* LRPC_SYSTEM_HANDLE_MARSHAL_DIRECTION :: enum { */
LRPC_SYSTEM_HANDLE_MARSHAL_DIRECTION :: _c.int;
    MarshalDirectionMarshal :: 0;
    MarshalDirectionUnmarshal :: MarshalDirectionMarshal + 1;
/* } */
;

PRPC_RUNDOWN :: proc "stdcall" (AssociationContext : rawptr);

RPC_SEC_CONTEXT_KEY_INFO :: struct {
    EncryptAlgorithm   : _c.ulong,
    KeySize            : _c.ulong,
    SignatureAlgorithm : _c.ulong,
};
PRPC_SEC_CONTEXT_KEY_INFO :: ^RPC_SEC_CONTEXT_KEY_INFO;

RPC_TRANSFER_SYNTAX :: struct {
    Uuid      : UUID,
    VersMajor : _c.ushort,
    VersMinor : _c.ushort,
};

RPCLT_PDU_FILTER_FUNC :: proc(Buffer : rawptr, BufferLength : _c.uint, fDatagram : _c.int);

RPC_SETFILTER_FUNC :: proc(pfnFilter : RPCLT_PDU_FILTER_FUNC);

RPC_BLOCKING_FN :: (proc(hWnd : rawptr, Context : rawptr, hSyncEvent : rawptr) -> RPC_STATUS);

RPC_C_OPT_COOKIE_AUTH_DESCRIPTOR :: struct {
    BufferSize : _c.ulong,
    Buffer     : ^_c.uchar,
};

RDR_CALLOUT_STATE :: struct {
    LastError           : RPC_STATUS,
    LastEEInfo          : rawptr,
    LastCalledStage     : RPC_HTTP_REDIRECTOR_STAGE,
    ServerName          : ^_c.ushort,
    ServerPort          : ^_c.ushort,
    RemoteUser          : ^_c.ushort,
    AuthType            : ^_c.ushort,
    ResourceTypePresent : _c.uchar,
    SessionIdPresent    : _c.uchar,
    InterfacePresent    : _c.uchar,
    ResourceType        : UUID,
    SessionId           : UUID,
    Interface           : RPC_SYNTAX_IDENTIFIER,
    CertContext         : rawptr,
};

I_RpcProxyIsValidMachineFn :: (proc "stdcall" (Machine : RPC_WSTR, DotMachine : RPC_WSTR, PortNumber : _c.ulong) -> RPC_STATUS);

I_RpcProxyGetClientAddressFn :: (proc "stdcall" (Context : rawptr, Buffer : ^_c.uchar, BufferLength : ^_c.ulong) -> RPC_STATUS);

I_RpcProxyGetConnectionTimeoutFn :: (proc "stdcall" (ConnectionTimeout : ^_c.ulong) -> RPC_STATUS);

I_RpcPerformCalloutFn :: (proc "stdcall" (Context : rawptr, CallOutState : ^RDR_CALLOUT_STATE, Stage : RPC_HTTP_REDIRECTOR_STAGE) -> RPC_STATUS);

I_RpcFreeCalloutStateFn :: proc "stdcall" (CallOutState : ^RDR_CALLOUT_STATE);

I_RpcProxyGetClientSessionAndResourceUUID :: (proc "stdcall" (Context : rawptr, SessionIdPresent : ^_c.int, SessionId : ^UUID, ResourceIdPresent : ^_c.int, ResourceId : ^UUID) -> RPC_STATUS);

I_RpcProxyFilterIfFn :: (proc "stdcall" (Context : rawptr, IfUuid : ^UUID, IfMajorVersion : _c.ushort, fAllow : ^_c.int) -> RPC_STATUS);

/* RpcPerfCounters :: enum { */
RpcPerfCounters :: _c.int;
    RpcCurrentUniqueUser :: 1;
    RpcBackEndConnectionAttempts :: RpcCurrentUniqueUser + 1;
    RpcBackEndConnectionFailed :: RpcBackEndConnectionAttempts + 1;
    RpcRequestsPerSecond :: RpcBackEndConnectionFailed + 1;
    RpcIncomingConnections :: RpcRequestsPerSecond + 1;
    RpcIncomingBandwidth :: RpcIncomingConnections + 1;
    RpcOutgoingBandwidth :: RpcIncomingBandwidth + 1;
    RpcAttemptedLbsDecisions :: RpcOutgoingBandwidth + 1;
    RpcFailedLbsDecisions :: RpcAttemptedLbsDecisions + 1;
    RpcAttemptedLbsMessages :: RpcFailedLbsDecisions + 1;
    RpcFailedLbsMessages :: RpcAttemptedLbsMessages + 1;
    RpcLastCounter :: RpcFailedLbsMessages + 1;
/* } */
;

I_RpcProxyUpdatePerfCounterFn :: proc "stdcall" (Counter : RpcPerfCounters, ModifyTrend : _c.int, Size : _c.ulong);

I_RpcProxyUpdatePerfCounterBackendServerFn :: proc "stdcall" (MachineName : ^_c.ushort, IsConnectEvent : _c.int);

I_RpcProxyCallbackInterface :: struct {
    IsValidMachineFn                         : I_RpcProxyIsValidMachineFn,
    GetClientAddressFn                       : I_RpcProxyGetClientAddressFn,
    GetConnectionTimeoutFn                   : I_RpcProxyGetConnectionTimeoutFn,
    PerformCalloutFn                         : I_RpcPerformCalloutFn,
    FreeCalloutStateFn                       : I_RpcFreeCalloutStateFn,
    GetClientSessionAndResourceUUIDFn        : I_RpcProxyGetClientSessionAndResourceUUID,
    ProxyFilterIfFn                          : I_RpcProxyFilterIfFn,
    RpcProxyUpdatePerfCounterFn              : I_RpcProxyUpdatePerfCounterFn,
    RpcProxyUpdatePerfCounterBackendServerFn : I_RpcProxyUpdatePerfCounterBackendServerFn,
};

RPC_NS_HANDLE :: rawptr;

/* RPC_NOTIFICATION_TYPES :: enum { */
RPC_NOTIFICATION_TYPES :: _c.int;
    RpcNotificationTypeNone :: 0;
    RpcNotificationTypeEvent :: RpcNotificationTypeNone + 1;
    RpcNotificationTypeApc :: RpcNotificationTypeEvent + 1;
    RpcNotificationTypeIoc :: RpcNotificationTypeApc + 1;
    RpcNotificationTypeHwnd :: RpcNotificationTypeIoc + 1;
    RpcNotificationTypeCallback :: RpcNotificationTypeHwnd + 1;
/* } */
;

/* RPC_ASYNC_EVENT :: enum { */
RPC_ASYNC_EVENT :: _c.int;
    RpcCallComplete :: 0;
    RpcSendComplete :: RpcCallComplete + 1;
    RpcReceiveComplete :: RpcSendComplete + 1;
    RpcClientDisconnect :: RpcReceiveComplete + 1;
    RpcClientCancel :: RpcClientDisconnect + 1;
/* } */
;

RPCNOTIFICATION_ROUTINE :: #type proc "stdcall" (pAsync : ^RPC_ASYNC_STATE, Context : rawptr, Event : RPC_ASYNC_EVENT);

PFN_RPCNOTIFICATION_ROUTINE :: ^RPCNOTIFICATION_ROUTINE;

RPC_ASYNC_NOTIFICATION_INFO :: struct #raw_union {
    APC : struct {
        NotificationRoutine : PFN_RPCNOTIFICATION_ROUTINE,
        hThread             : HANDLE,
    },
    IOC : struct {
        hIOPort                    : HANDLE,
        dwNumberOfBytesTransferred : DWORD,
        dwCompletionKey            : DWORD_PTR,
        lpOverlapped               : LPOVERLAPPED,
    },
    HWND : struct {
        hWnd : HWND,
        Msg  : UINT,
    },
    hEvent              : HANDLE,
    NotificationRoutine : PFN_RPCNOTIFICATION_ROUTINE,
};
PRPC_ASYNC_NOTIFICATION_INFO :: ^RPC_ASYNC_NOTIFICATION_INFO;

RPC_ASYNC_STATE :: struct {
    Size             : _c.uint,
    Signature        : _c.ulong,
    Lock             : _c.long,
    Flags            : _c.ulong,
    StubInfo         : rawptr,
    UserInfo         : rawptr,
    RuntimeInfo      : rawptr,
    Event            : RPC_ASYNC_EVENT,
    NotificationType : RPC_NOTIFICATION_TYPES,
    u                : RPC_ASYNC_NOTIFICATION_INFO,
    Reserved         : [4]LONG_PTR,
};
PRPC_ASYNC_STATE :: ^RPC_ASYNC_STATE;

/* ExtendedErrorParamTypes :: enum { */
ExtendedErrorParamTypes :: _c.int;
    eeptAnsiString :: 1;
    eeptUnicodeString :: eeptAnsiString + 1;
    eeptLongVal :: eeptUnicodeString + 1;
    eeptShortVal :: eeptLongVal + 1;
    eeptPointerVal :: eeptShortVal + 1;
    eeptNone :: eeptPointerVal + 1;
    eeptBinary :: eeptNone + 1;
/* } */
;

BinaryParam :: struct {
    Buffer : rawptr,
    Size   : _c.short,
};

RPC_EE_INFO_PARAM :: struct {
    ParameterType : ExtendedErrorParamTypes,
    u : struct #raw_union {
        AnsiString    : LPSTR,
        UnicodeString : LPWSTR,
        LVal          : _c.long,
        SVal          : _c.short,
        PVal          : ULONGLONG,
        BVal          : BinaryParam,
    },
};

RPC_EXTENDED_ERROR_INFO :: struct {
    Version             : ULONG,
    ComputerName        : LPWSTR,
    ProcessID           : ULONG,
    u : struct #raw_union {
        SystemTime : SYSTEMTIME,
        FileTime   : FILETIME,
    },
    GeneratingComponent : ULONG,
    Status              : ULONG,
    DetectionLocation   : USHORT,
    Flags               : USHORT,
    NumberOfParameters  : _c.int,
    Parameters          : [4]RPC_EE_INFO_PARAM,
};

RPC_ERROR_ENUM_HANDLE :: struct {
    Signature  : ULONG,
    CurrentPos : rawptr,
    Head       : rawptr,
};

/* RpcLocalAddressFormat :: enum { */
RpcLocalAddressFormat :: _c.int;
    rlafInvalid :: 0;
    rlafIPv4 :: rlafInvalid + 1;
    rlafIPv6 :: rlafIPv4 + 1;
/* } */
;

RPC_CALL_LOCAL_ADDRESS_V1 :: struct {
    Version       : _c.uint,
    Buffer        : rawptr,
    BufferSize    : _c.ulong,
    AddressFormat : RpcLocalAddressFormat,
};
PRPC_CALL_LOCAL_ADDRESS_V1 :: ^RPC_CALL_LOCAL_ADDRESS_V1;

RPC_CALL_ATTRIBUTES_V1_W :: struct {
    Version                         : _c.uint,
    Flags                           : _c.ulong,
    ServerPrincipalNameBufferLength : _c.ulong,
    ServerPrincipalName             : ^_c.ushort,
    ClientPrincipalNameBufferLength : _c.ulong,
    ClientPrincipalName             : ^_c.ushort,
    AuthenticationLevel             : _c.ulong,
    AuthenticationService           : _c.ulong,
    NullSession                     : BOOL,
};

RPC_CALL_ATTRIBUTES_V1_A :: struct {
    Version                         : _c.uint,
    Flags                           : _c.ulong,
    ServerPrincipalNameBufferLength : _c.ulong,
    ServerPrincipalName             : ^_c.uchar,
    ClientPrincipalNameBufferLength : _c.ulong,
    ClientPrincipalName             : ^_c.uchar,
    AuthenticationLevel             : _c.ulong,
    AuthenticationService           : _c.ulong,
    NullSession                     : BOOL,
};

/* RpcCallType :: enum { */
RpcCallType :: _c.int;
    rctInvalid :: 0;
    rctNormal :: rctInvalid + 1;
    rctTraining :: rctNormal + 1;
    rctGuaranteed :: rctTraining + 1;
/* } */
;

/* RpcCallClientLocality :: enum { */
RpcCallClientLocality :: _c.int;
    rcclInvalid :: 0;
    rcclLocal :: rcclInvalid + 1;
    rcclRemote :: rcclLocal + 1;
    rcclClientUnknownLocality :: rcclRemote + 1;
/* } */
;

RPC_CALL_ATTRIBUTES_V2_W :: struct {
    Version                         : _c.uint,
    Flags                           : _c.ulong,
    ServerPrincipalNameBufferLength : _c.ulong,
    ServerPrincipalName             : ^_c.ushort,
    ClientPrincipalNameBufferLength : _c.ulong,
    ClientPrincipalName             : ^_c.ushort,
    AuthenticationLevel             : _c.ulong,
    AuthenticationService           : _c.ulong,
    NullSession                     : BOOL,
    KernelModeCaller                : BOOL,
    ProtocolSequence                : _c.ulong,
    IsClientLocal                   : RpcCallClientLocality,
    ClientPID                       : HANDLE,
    CallStatus                      : _c.ulong,
    CallType                        : RpcCallType,
    CallLocalAddress                : ^RPC_CALL_LOCAL_ADDRESS_V1,
    OpNum                           : _c.ushort,
    InterfaceUuid                   : UUID,
};

RPC_CALL_ATTRIBUTES_V2_A :: struct {
    Version                         : _c.uint,
    Flags                           : _c.ulong,
    ServerPrincipalNameBufferLength : _c.ulong,
    ServerPrincipalName             : ^_c.uchar,
    ClientPrincipalNameBufferLength : _c.ulong,
    ClientPrincipalName             : ^_c.uchar,
    AuthenticationLevel             : _c.ulong,
    AuthenticationService           : _c.ulong,
    NullSession                     : BOOL,
    KernelModeCaller                : BOOL,
    ProtocolSequence                : _c.ulong,
    IsClientLocal                   : _c.ulong,
    ClientPID                       : HANDLE,
    CallStatus                      : _c.ulong,
    CallType                        : RpcCallType,
    CallLocalAddress                : ^RPC_CALL_LOCAL_ADDRESS_V1,
    OpNum                           : _c.ushort,
    InterfaceUuid                   : UUID,
};

RPC_CALL_ATTRIBUTES_V3_W :: struct {
    Version                         : _c.uint,
    Flags                           : _c.ulong,
    ServerPrincipalNameBufferLength : _c.ulong,
    ServerPrincipalName             : ^_c.ushort,
    ClientPrincipalNameBufferLength : _c.ulong,
    ClientPrincipalName             : ^_c.ushort,
    AuthenticationLevel             : _c.ulong,
    AuthenticationService           : _c.ulong,
    NullSession                     : BOOL,
    KernelModeCaller                : BOOL,
    ProtocolSequence                : _c.ulong,
    IsClientLocal                   : RpcCallClientLocality,
    ClientPID                       : HANDLE,
    CallStatus                      : _c.ulong,
    CallType                        : RpcCallType,
    CallLocalAddress                : ^RPC_CALL_LOCAL_ADDRESS_V1,
    OpNum                           : _c.ushort,
    InterfaceUuid                   : UUID,
    ClientIdentifierBufferLength    : _c.ulong,
    ClientIdentifier                : ^_c.uchar,
};

RPC_CALL_ATTRIBUTES_V3_A :: struct {
    Version                         : _c.uint,
    Flags                           : _c.ulong,
    ServerPrincipalNameBufferLength : _c.ulong,
    ServerPrincipalName             : ^_c.uchar,
    ClientPrincipalNameBufferLength : _c.ulong,
    ClientPrincipalName             : ^_c.uchar,
    AuthenticationLevel             : _c.ulong,
    AuthenticationService           : _c.ulong,
    NullSession                     : BOOL,
    KernelModeCaller                : BOOL,
    ProtocolSequence                : _c.ulong,
    IsClientLocal                   : _c.ulong,
    ClientPID                       : HANDLE,
    CallStatus                      : _c.ulong,
    CallType                        : RpcCallType,
    CallLocalAddress                : ^RPC_CALL_LOCAL_ADDRESS_V1,
    OpNum                           : _c.ushort,
    InterfaceUuid                   : UUID,
    ClientIdentifierBufferLength    : _c.ulong,
    ClientIdentifier                : ^_c.uchar,
};

RPC_CALL_ATTRIBUTES :: RPC_CALL_ATTRIBUTES_V3_A;

/* RPC_NOTIFICATIONS :: enum { */
RPC_NOTIFICATIONS :: _c.int;
    RpcNotificationCallNone :: 0;
    RpcNotificationClientDisconnect :: 1;
    RpcNotificationCallCancel :: 2;
/* } */
;

HDROP__ :: struct {
    unused : _c.int,
};

HDROP :: ^HDROP__;

DRAGINFOA :: struct {
    uSize       : UINT,
    pt          : POINT,
    fNC         : BOOL,
    lpFileList  : PZZSTR,
    grfKeyState : DWORD,
};
LPDRAGINFOA :: ^DRAGINFOA;

DRAGINFOW :: struct {
    uSize       : UINT,
    pt          : POINT,
    fNC         : BOOL,
    lpFileList  : PZZWSTR,
    grfKeyState : DWORD,
};
LPDRAGINFOW :: ^DRAGINFOW;

DRAGINFO :: DRAGINFOA;

LPDRAGINFO :: LPDRAGINFOA;

APPBARDATA :: struct {
    cbSize           : DWORD,
    hWnd             : HWND,
    uCallbackMessage : UINT,
    uEdge            : UINT,
    rc               : RECT,
    lParam           : LPARAM,
};
PAPPBARDATA :: ^APPBARDATA;

FILEOP_FLAGS :: WORD;

PRINTEROP_FLAGS :: WORD;

SHFILEOPSTRUCTA :: struct {
    hwnd                  : HWND,
    wFunc                 : UINT,
    pFrom                 : PCZZSTR,
    pTo                   : PCZZSTR,
    fFlags                : FILEOP_FLAGS,
    fAnyOperationsAborted : BOOL,
    hNameMappings         : LPVOID,
    lpszProgressTitle     : PCSTR,
};
LPSHFILEOPSTRUCTA :: ^SHFILEOPSTRUCTA;

SHFILEOPSTRUCTW :: struct {
    hwnd                  : HWND,
    wFunc                 : UINT,
    pFrom                 : PCZZWSTR,
    pTo                   : PCZZWSTR,
    fFlags                : FILEOP_FLAGS,
    fAnyOperationsAborted : BOOL,
    hNameMappings         : LPVOID,
    lpszProgressTitle     : PCWSTR,
};
LPSHFILEOPSTRUCTW :: ^SHFILEOPSTRUCTW;

SHFILEOPSTRUCT :: SHFILEOPSTRUCTA;

LPSHFILEOPSTRUCT :: LPSHFILEOPSTRUCTA;

SHNAMEMAPPINGA :: struct {
    pszOldPath : LPSTR,
    pszNewPath : LPSTR,
    cchOldPath : _c.int,
    cchNewPath : _c.int,
};
LPSHNAMEMAPPINGA :: ^SHNAMEMAPPINGA;

SHNAMEMAPPINGW :: struct {
    pszOldPath : LPWSTR,
    pszNewPath : LPWSTR,
    cchOldPath : _c.int,
    cchNewPath : _c.int,
};
LPSHNAMEMAPPINGW :: ^SHNAMEMAPPINGW;

SHNAMEMAPPING :: SHNAMEMAPPINGA;

LPSHNAMEMAPPING :: LPSHNAMEMAPPINGA;

SHELLEXECUTEINFOA :: struct {
    cbSize       : DWORD,
    fMask        : ULONG,
    hwnd         : HWND,
    lpVerb       : LPCSTR,
    lpFile       : LPCSTR,
    lpParameters : LPCSTR,
    lpDirectory  : LPCSTR,
    nShow        : _c.int,
    hInstApp     : HINSTANCE,
    lpIDList     : rawptr,
    lpClass      : LPCSTR,
    hkeyClass    : HKEY,
    dwHotKey     : DWORD,
    u : struct #raw_union {
        hIcon    : HANDLE,
        hMonitor : HANDLE,
    },
    hProcess     : HANDLE,
};
LPSHELLEXECUTEINFOA :: ^SHELLEXECUTEINFOA;

SHELLEXECUTEINFOW :: struct {
    cbSize       : DWORD,
    fMask        : ULONG,
    hwnd         : HWND,
    lpVerb       : LPCWSTR,
    lpFile       : LPCWSTR,
    lpParameters : LPCWSTR,
    lpDirectory  : LPCWSTR,
    nShow        : _c.int,
    hInstApp     : HINSTANCE,
    lpIDList     : rawptr,
    lpClass      : LPCWSTR,
    hkeyClass    : HKEY,
    dwHotKey     : DWORD,
    u : struct #raw_union {
        hIcon    : HANDLE,
        hMonitor : HANDLE,
    },
    hProcess     : HANDLE,
};
LPSHELLEXECUTEINFOW :: ^SHELLEXECUTEINFOW;

SHELLEXECUTEINFO :: SHELLEXECUTEINFOA;

LPSHELLEXECUTEINFO :: LPSHELLEXECUTEINFOA;

SHCREATEPROCESSINFOW :: struct {
    cbSize               : DWORD,
    fMask                : ULONG,
    hwnd                 : HWND,
    pszFile              : LPCWSTR,
    pszParameters        : LPCWSTR,
    pszCurrentDirectory  : LPCWSTR,
    hUserToken           : HANDLE,
    lpProcessAttributes  : LPSECURITY_ATTRIBUTES,
    lpThreadAttributes   : LPSECURITY_ATTRIBUTES,
    bInheritHandles      : BOOL,
    dwCreationFlags      : DWORD,
    lpStartupInfo        : LPSTARTUPINFOW,
    lpProcessInformation : LPPROCESS_INFORMATION,
};
PSHCREATEPROCESSINFOW :: ^SHCREATEPROCESSINFOW;

/* ASSOCCLASS :: enum { */
ASSOCCLASS :: _c.int;
    ASSOCCLASS_SHELL_KEY :: 0;
    ASSOCCLASS_PROGID_KEY :: ASSOCCLASS_SHELL_KEY + 1;
    ASSOCCLASS_PROGID_STR :: ASSOCCLASS_PROGID_KEY + 1;
    ASSOCCLASS_CLSID_KEY :: ASSOCCLASS_PROGID_STR + 1;
    ASSOCCLASS_CLSID_STR :: ASSOCCLASS_CLSID_KEY + 1;
    ASSOCCLASS_APP_KEY :: ASSOCCLASS_CLSID_STR + 1;
    ASSOCCLASS_APP_STR :: ASSOCCLASS_APP_KEY + 1;
    ASSOCCLASS_SYSTEM_STR :: ASSOCCLASS_APP_STR + 1;
    ASSOCCLASS_FOLDER :: ASSOCCLASS_SYSTEM_STR + 1;
    ASSOCCLASS_STAR :: ASSOCCLASS_FOLDER + 1;
    ASSOCCLASS_FIXED_PROGID_STR :: ASSOCCLASS_STAR + 1;
    ASSOCCLASS_PROTOCOL_STR :: ASSOCCLASS_FIXED_PROGID_STR + 1;
/* } */
;

ASSOCIATIONELEMENT :: struct {
    ac       : ASSOCCLASS,
    hkClass  : HKEY,
    pszClass : PCWSTR,
};

SHQUERYRBINFO :: struct {
    cbSize      : DWORD,
    i64Size     : i64,
    i64NumItems : i64,
};
LPSHQUERYRBINFO :: ^SHQUERYRBINFO;

/* QUERY_USER_NOTIFICATION_STATE :: enum { */
QUERY_USER_NOTIFICATION_STATE :: _c.int;
    QUNS_NOT_PRESENT :: 1;
    QUNS_BUSY :: 2;
    QUNS_RUNNING_D3D_FULL_SCREEN :: 3;
    QUNS_PRESENTATION_MODE :: 4;
    QUNS_ACCEPTS_NOTIFICATIONS :: 5;
    QUNS_QUIET_TIME :: 6;
    QUNS_APP :: 7;
/* } */
;

NOTIFYICONDATAA :: struct {
    cbSize           : DWORD,
    hWnd             : HWND,
    uID              : UINT,
    uFlags           : UINT,
    uCallbackMessage : UINT,
    hIcon            : HICON,
    szTip            : [128]CHAR,
    dwState          : DWORD,
    dwStateMask      : DWORD,
    szInfo           : [256]CHAR,
    u : struct #raw_union {
        uTimeout : UINT,
        uVersion : UINT,
    },
    szInfoTitle      : [64]CHAR,
    dwInfoFlags      : DWORD,
    guidItem         : GUID,
    hBalloonIcon     : HICON,
};
PNOTIFYICONDATAA :: ^NOTIFYICONDATAA;

NOTIFYICONDATAW :: struct {
    cbSize           : DWORD,
    hWnd             : HWND,
    uID              : UINT,
    uFlags           : UINT,
    uCallbackMessage : UINT,
    hIcon            : HICON,
    szTip            : [128]WCHAR,
    dwState          : DWORD,
    dwStateMask      : DWORD,
    szInfo           : [256]WCHAR,
    u : struct #raw_union {
        uTimeout : UINT,
        uVersion : UINT,
    },
    szInfoTitle      : [64]WCHAR,
    dwInfoFlags      : DWORD,
    guidItem         : GUID,
    hBalloonIcon     : HICON,
};
PNOTIFYICONDATAW :: ^NOTIFYICONDATAW;

NOTIFYICONDATA :: NOTIFYICONDATAA;

PNOTIFYICONDATA :: PNOTIFYICONDATAA;

NOTIFYICONIDENTIFIER :: struct {
    cbSize   : DWORD,
    hWnd     : HWND,
    uID      : UINT,
    guidItem : GUID,
};
PNOTIFYICONIDENTIFIER :: ^NOTIFYICONIDENTIFIER;

SHFILEINFOA :: struct {
    hIcon         : HICON,
    iIcon         : _c.int,
    dwAttributes  : DWORD,
    szDisplayName : [260]CHAR,
    szTypeName    : [80]CHAR,
};

SHFILEINFOW :: struct {
    hIcon         : HICON,
    iIcon         : _c.int,
    dwAttributes  : DWORD,
    szDisplayName : [260]WCHAR,
    szTypeName    : [80]WCHAR,
};

SHFILEINFO :: SHFILEINFOA;

SHSTOCKICONINFO :: struct {
    cbSize         : DWORD,
    hIcon          : HICON,
    iSysImageIndex : _c.int,
    iIcon          : _c.int,
    szPath         : [260]WCHAR,
};

/* SHSTOCKICONID :: enum { */
SHSTOCKICONID :: _c.int;
    SIID_DOCNOASSOC :: 0;
    SIID_DOCASSOC :: 1;
    SIID_APPLICATION :: 2;
    SIID_FOLDER :: 3;
    SIID_FOLDEROPEN :: 4;
    SIID_DRIVE525 :: 5;
    SIID_DRIVE35 :: 6;
    SIID_DRIVEREMOVE :: 7;
    SIID_DRIVEFIXED :: 8;
    SIID_DRIVENET :: 9;
    SIID_DRIVENETDISABLED :: 10;
    SIID_DRIVECD :: 11;
    SIID_DRIVERAM :: 12;
    SIID_WORLD :: 13;
    SIID_SERVER :: 15;
    SIID_PRINTER :: 16;
    SIID_MYNETWORK :: 17;
    SIID_FIND :: 22;
    SIID_HELP :: 23;
    SIID_SHARE :: 28;
    SIID_LINK :: 29;
    SIID_SLOWFILE :: 30;
    SIID_RECYCLER :: 31;
    SIID_RECYCLERFULL :: 32;
    SIID_MEDIACDAUDIO :: 40;
    SIID_LOCK :: 47;
    SIID_AUTOLIST :: 49;
    SIID_PRINTERNET :: 50;
    SIID_SERVERSHARE :: 51;
    SIID_PRINTERFAX :: 52;
    SIID_PRINTERFAXNET :: 53;
    SIID_PRINTERFILE :: 54;
    SIID_STACK :: 55;
    SIID_MEDIASVCD :: 56;
    SIID_STUFFEDFOLDER :: 57;
    SIID_DRIVEUNKNOWN :: 58;
    SIID_DRIVEDVD :: 59;
    SIID_MEDIADVD :: 60;
    SIID_MEDIADVDRAM :: 61;
    SIID_MEDIADVDRW :: 62;
    SIID_MEDIADVDR :: 63;
    SIID_MEDIADVDROM :: 64;
    SIID_MEDIACDAUDIOPLUS :: 65;
    SIID_MEDIACDRW :: 66;
    SIID_MEDIACDR :: 67;
    SIID_MEDIACDBURN :: 68;
    SIID_MEDIABLANKCD :: 69;
    SIID_MEDIACDROM :: 70;
    SIID_AUDIOFILES :: 71;
    SIID_IMAGEFILES :: 72;
    SIID_VIDEOFILES :: 73;
    SIID_MIXEDFILES :: 74;
    SIID_FOLDERBACK :: 75;
    SIID_FOLDERFRONT :: 76;
    SIID_SHIELD :: 77;
    SIID_WARNING :: 78;
    SIID_INFO :: 79;
    SIID_ERROR :: 80;
    SIID_KEY :: 81;
    SIID_SOFTWARE :: 82;
    SIID_RENAME :: 83;
    SIID_DELETE :: 84;
    SIID_MEDIAAUDIODVD :: 85;
    SIID_MEDIAMOVIEDVD :: 86;
    SIID_MEDIAENHANCEDCD :: 87;
    SIID_MEDIAENHANCEDDVD :: 88;
    SIID_MEDIAHDDVD :: 89;
    SIID_MEDIABLURAY :: 90;
    SIID_MEDIAVCD :: 91;
    SIID_MEDIADVDPLUSR :: 92;
    SIID_MEDIADVDPLUSRW :: 93;
    SIID_DESKTOPPC :: 94;
    SIID_MOBILEPC :: 95;
    SIID_USERS :: 96;
    SIID_MEDIASMARTMEDIA :: 97;
    SIID_MEDIACOMPACTFLASH :: 98;
    SIID_DEVICECELLPHONE :: 99;
    SIID_DEVICECAMERA :: 100;
    SIID_DEVICEVIDEOCAMERA :: 101;
    SIID_DEVICEAUDIOPLAYER :: 102;
    SIID_NETWORKCONNECT :: 103;
    SIID_INTERNET :: 104;
    SIID_ZIPFILE :: 105;
    SIID_SETTINGS :: 106;
    SIID_DRIVEHDDVD :: 132;
    SIID_DRIVEBD :: 133;
    SIID_MEDIAHDDVDROM :: 134;
    SIID_MEDIAHDDVDR :: 135;
    SIID_MEDIAHDDVDRAM :: 136;
    SIID_MEDIABDROM :: 137;
    SIID_MEDIABDR :: 138;
    SIID_MEDIABDRE :: 139;
    SIID_CLUSTEREDDRIVE :: 140;
    SIID_MAX_ICONS :: 181;
/* } */
;

OPEN_PRINTER_PROPS_INFOA :: struct {
    dwSize       : DWORD,
    pszSheetName : LPSTR,
    uSheetIndex  : UINT,
    dwFlags      : DWORD,
    bModal       : BOOL,
};
POPEN_PRINTER_PROPS_INFOA :: ^OPEN_PRINTER_PROPS_INFOA;

OPEN_PRINTER_PROPS_INFOW :: struct {
    dwSize       : DWORD,
    pszSheetName : LPWSTR,
    uSheetIndex  : UINT,
    dwFlags      : DWORD,
    bModal       : BOOL,
};
POPEN_PRINTER_PROPS_INFOW :: ^OPEN_PRINTER_PROPS_INFOW;

OPEN_PRINTER_PROPS_INFO :: OPEN_PRINTER_PROPS_INFOA;

POPEN_PRINTER_PROPS_INFO :: POPEN_PRINTER_PROPS_INFOA;

PFNCANSHAREFOLDERW :: (proc "stdcall" (pszPath : PCWSTR) -> HRESULT);

PFNSHOWSHAREFOLDERUIW :: (proc "stdcall" (hwndParent : HWND, pszPath : PCWSTR) -> HRESULT);

NC_ADDRESS :: struct {
    pAddrInfo    : ^NET_ADDRESS_INFO_,
    PortNumber   : USHORT,
    PrefixLength : BYTE,
};
PNC_ADDRESS :: ^NC_ADDRESS;

PERF_DATA_BLOCK :: struct {
    Signature        : [4]WCHAR,
    LittleEndian     : DWORD,
    Version          : DWORD,
    Revision         : DWORD,
    TotalByteLength  : DWORD,
    HeaderLength     : DWORD,
    NumObjectTypes   : DWORD,
    DefaultObject    : LONG,
    SystemTime       : SYSTEMTIME,
    PerfTime         : LARGE_INTEGER,
    PerfFreq         : LARGE_INTEGER,
    PerfTime100nSec  : LARGE_INTEGER,
    SystemNameLength : DWORD,
    SystemNameOffset : DWORD,
};
PPERF_DATA_BLOCK :: ^PERF_DATA_BLOCK;

PERF_OBJECT_TYPE :: struct {
    TotalByteLength      : DWORD,
    DefinitionLength     : DWORD,
    HeaderLength         : DWORD,
    ObjectNameTitleIndex : DWORD,
    ObjectNameTitle      : DWORD,
    ObjectHelpTitleIndex : DWORD,
    ObjectHelpTitle      : DWORD,
    DetailLevel          : DWORD,
    NumCounters          : DWORD,
    DefaultCounter       : LONG,
    NumInstances         : LONG,
    CodePage             : DWORD,
    PerfTime             : LARGE_INTEGER,
    PerfFreq             : LARGE_INTEGER,
};
PPERF_OBJECT_TYPE :: ^PERF_OBJECT_TYPE;

PERF_COUNTER_DEFINITION :: struct {
    ByteLength            : DWORD,
    CounterNameTitleIndex : DWORD,
    CounterNameTitle      : DWORD,
    CounterHelpTitleIndex : DWORD,
    CounterHelpTitle      : DWORD,
    DefaultScale          : LONG,
    DetailLevel           : DWORD,
    CounterType           : DWORD,
    CounterSize           : DWORD,
    CounterOffset         : DWORD,
};
PPERF_COUNTER_DEFINITION :: ^PERF_COUNTER_DEFINITION;

PERF_INSTANCE_DEFINITION :: struct {
    ByteLength             : DWORD,
    ParentObjectTitleIndex : DWORD,
    ParentObjectInstance   : DWORD,
    UniqueID               : LONG,
    NameOffset             : DWORD,
    NameLength             : DWORD,
};
PPERF_INSTANCE_DEFINITION :: ^PERF_INSTANCE_DEFINITION;

PERF_COUNTER_BLOCK :: struct {
    ByteLength : DWORD,
};
PPERF_COUNTER_BLOCK :: ^PERF_COUNTER_BLOCK;

PM_OPEN_PROC :: #type (proc "stdcall" (LPWSTR) -> DWORD);

PM_COLLECT_PROC :: #type (proc "stdcall" (lpValueName : LPWSTR, lppData : ^LPVOID, lpcbTotalBytes : LPDWORD, lpNumObjectTypes : LPDWORD) -> DWORD);

PM_CLOSE_PROC :: #type (proc "stdcall" () -> DWORD);

PM_QUERY_PROC :: #type (proc "stdcall" (LPDWORD, ^LPVOID, LPDWORD, LPDWORD) -> DWORD);

u_char :: _c.uchar;

u_short :: _c.ushort;

u_int :: _c.uint;

u_long :: _c.ulong;

SOCKET :: UINT_PTR;

fd_set :: struct {
    fd_count : u_int,
    fd_array : [64]SOCKET,
};

TIMEVAL :: struct {
    tv_sec  : _c.long,
    tv_usec : _c.long,
};

HOSTENT :: struct {
    h_name      : ^_c.uchar,
    h_aliases   : ^^_c.uchar,
    h_addrtype  : _c.short,
    h_length    : _c.short,
    h_addr_list : ^^_c.uchar,
};

netent :: struct {
    n_name     : ^_c.uchar,
    n_aliases  : ^^_c.uchar,
    n_addrtype : _c.short,
    n_net      : u_long,
};

SERVENT :: struct {
    s_name    : ^_c.uchar,
    s_aliases : ^^_c.uchar,
    s_proto   : ^_c.uchar,
    s_port    : _c.short,
};

PROTOENT :: struct {
    p_name    : ^_c.uchar,
    p_aliases : ^^_c.uchar,
    p_proto   : _c.short,
};

IN_ADDR :: struct {
    S_un : struct #raw_union {
        S_un_b : struct {
            s_b1 : UCHAR,
            s_b2 : UCHAR,
            s_b3 : UCHAR,
            s_b4 : UCHAR,
        },
        S_un_w : struct {
            s_w1 : USHORT,
            s_w2 : USHORT,
        },
        S_addr : ULONG,
    },
};
PIN_ADDR :: ^IN_ADDR;
LPIN_ADDR :: ^IN_ADDR;

SOCKADDR_IN :: struct {
    sin_family : _c.short,
    sin_port   : u_short,
    sin_addr   : IN_ADDR,
    sin_zero   : [8]_c.uchar,
};

WSADATA :: struct {
    wVersion       : WORD,
    wHighVersion   : WORD,
    iMaxSockets    : _c.ushort,
    iMaxUdpDg      : _c.ushort,
    lpVendorInfo   : ^_c.uchar,
    szDescription  : [256 + 1]_c.uchar,
    szSystemStatus : [128 + 1]_c.uchar,
};

LPWSADATA :: ^WSADATA;

ip_mreq :: struct {
    imr_multiaddr : IN_ADDR,
    imr_interface : IN_ADDR,
};

SOCKADDR :: struct {
    sa_family : u_short,
    sa_data   : [14]_c.uchar,
};

sockproto :: struct {
    sp_family   : u_short,
    sp_protocol : u_short,
};

LINGER :: struct {
    l_onoff  : u_short,
    l_linger : u_short,
};

TRANSMIT_FILE_BUFFERS :: struct {
    Head       : PVOID,
    HeadLength : DWORD,
    Tail       : PVOID,
    TailLength : DWORD,
};
PTRANSMIT_FILE_BUFFERS :: ^TRANSMIT_FILE_BUFFERS;
LPTRANSMIT_FILE_BUFFERS :: ^TRANSMIT_FILE_BUFFERS;

;

PSOCKADDR :: ^SOCKADDR;

LPSOCKADDR :: ^SOCKADDR;

;

PSOCKADDR_IN :: ^SOCKADDR_IN;

LPSOCKADDR_IN :: ^SOCKADDR_IN;

;

PLINGER :: ^LINGER;

LPLINGER :: ^LINGER;

FD_SET :: fd_set;

PFD_SET :: ^fd_set;

LPFD_SET :: ^fd_set;

;

PHOSTENT :: ^HOSTENT;

LPHOSTENT :: ^HOSTENT;

;

PSERVENT :: ^SERVENT;

LPSERVENT :: ^SERVENT;

;

PPROTOENT :: ^PROTOENT;

LPPROTOENT :: ^PROTOENT;

;

PTIMEVAL :: ^TIMEVAL;

LPTIMEVAL :: ^TIMEVAL;

ALG_ID :: _c.uint;

HCRYPTPROV :: ULONG_PTR;

HCRYPTKEY :: ULONG_PTR;

HCRYPTHASH :: ULONG_PTR;

CMS_KEY_INFO :: struct {
    dwVersion : DWORD,
    Algid     : ALG_ID,
    pbOID     : ^BYTE,
    cbOID     : DWORD,
};
PCMS_KEY_INFO :: ^CMS_KEY_INFO;

HMAC_INFO :: struct {
    HashAlgid     : ALG_ID,
    pbInnerString : ^BYTE,
    cbInnerString : DWORD,
    pbOuterString : ^BYTE,
    cbOuterString : DWORD,
};
PHMAC_INFO :: ^HMAC_INFO;

SCHANNEL_ALG :: struct {
    dwUse      : DWORD,
    Algid      : ALG_ID,
    cBits      : DWORD,
    dwFlags    : DWORD,
    dwReserved : DWORD,
};
PSCHANNEL_ALG :: ^SCHANNEL_ALG;

PROV_ENUMALGS :: struct {
    aiAlgid   : ALG_ID,
    dwBitLen  : DWORD,
    dwNameLen : DWORD,
    szName    : [20]CHAR,
};

PROV_ENUMALGS_EX :: struct {
    aiAlgid       : ALG_ID,
    dwDefaultLen  : DWORD,
    dwMinLen      : DWORD,
    dwMaxLen      : DWORD,
    dwProtocols   : DWORD,
    dwNameLen     : DWORD,
    szName        : [20]CHAR,
    dwLongNameLen : DWORD,
    szLongName    : [40]CHAR,
};

BLOBHEADER :: struct {
    bType    : BYTE,
    bVersion : BYTE,
    reserved : WORD,
    aiKeyAlg : ALG_ID,
};
PUBLICKEYSTRUC :: struct {
    bType    : BYTE,
    bVersion : BYTE,
    reserved : WORD,
    aiKeyAlg : ALG_ID,
};

RSAPUBKEY :: struct {
    magic  : DWORD,
    bitlen : DWORD,
    pubexp : DWORD,
};

DHPUBKEY :: struct {
    magic  : DWORD,
    bitlen : DWORD,
};
DSSPUBKEY :: struct {
    magic  : DWORD,
    bitlen : DWORD,
};
KEAPUBKEY :: struct {
    magic  : DWORD,
    bitlen : DWORD,
};
TEKPUBKEY :: struct {
    magic  : DWORD,
    bitlen : DWORD,
};

DSSSEED :: struct {
    counter : DWORD,
    seed    : [20]BYTE,
};

DHPUBKEY_VER3 :: struct {
    magic   : DWORD,
    bitlenP : DWORD,
    bitlenQ : DWORD,
    bitlenJ : DWORD,
    DSSSeed : DSSSEED,
};
DSSPUBKEY_VER3 :: struct {
    magic   : DWORD,
    bitlenP : DWORD,
    bitlenQ : DWORD,
    bitlenJ : DWORD,
    DSSSeed : DSSSEED,
};

DHPRIVKEY_VER3 :: struct {
    magic   : DWORD,
    bitlenP : DWORD,
    bitlenQ : DWORD,
    bitlenJ : DWORD,
    bitlenX : DWORD,
    DSSSeed : DSSSEED,
};
DSSPRIVKEY_VER3 :: struct {
    magic   : DWORD,
    bitlenP : DWORD,
    bitlenQ : DWORD,
    bitlenJ : DWORD,
    bitlenX : DWORD,
    DSSSeed : DSSSEED,
};

KEY_TYPE_SUBTYPE :: struct {
    dwKeySpec : DWORD,
    Type      : GUID,
    Subtype   : GUID,
};
PKEY_TYPE_SUBTYPE :: ^KEY_TYPE_SUBTYPE;

CERT_FORTEZZA_DATA_PROP :: struct {
    SerialNumber : [8]_c.uchar,
    CertIndex    : _c.int,
    CertLabel    : [36]_c.uchar,
};

CRYPT_RC4_KEY_STATE :: struct {
    Key  : [16]_c.uchar,
    SBox : [256]_c.uchar,
    i    : _c.uchar,
    j    : _c.uchar,
};
PCRYPT_RC4_KEY_STATE :: ^CRYPT_RC4_KEY_STATE;

CRYPT_DES_KEY_STATE :: struct {
    Key      : [8]_c.uchar,
    IV       : [8]_c.uchar,
    Feedback : [8]_c.uchar,
};
PCRYPT_DES_KEY_STATE :: ^CRYPT_DES_KEY_STATE;

CRYPT_3DES_KEY_STATE :: struct {
    Key      : [24]_c.uchar,
    IV       : [8]_c.uchar,
    Feedback : [8]_c.uchar,
};
PCRYPT_3DES_KEY_STATE :: ^CRYPT_3DES_KEY_STATE;

CRYPT_AES_128_KEY_STATE :: struct {
    Key             : [16]_c.uchar,
    IV              : [16]_c.uchar,
    EncryptionState : [11][16]_c.uchar,
    DecryptionState : [11][16]_c.uchar,
    Feedback        : [16]_c.uchar,
};
PCRYPT_AES_128_KEY_STATE :: ^CRYPT_AES_128_KEY_STATE;

CRYPT_AES_256_KEY_STATE :: struct {
    Key             : [32]_c.uchar,
    IV              : [16]_c.uchar,
    EncryptionState : [15][16]_c.uchar,
    DecryptionState : [15][16]_c.uchar,
    Feedback        : [16]_c.uchar,
};
PCRYPT_AES_256_KEY_STATE :: ^CRYPT_AES_256_KEY_STATE;

CRYPT_INTEGER_BLOB :: struct {
    cbData : DWORD,
    pbData : ^BYTE,
};
PCRYPT_INTEGER_BLOB :: ^CRYPT_INTEGER_BLOB;
CRYPT_UINT_BLOB :: struct {
    cbData : DWORD,
    pbData : ^BYTE,
};
PCRYPT_UINT_BLOB :: ^CRYPT_UINT_BLOB;
CRYPT_OBJID_BLOB :: struct {
    cbData : DWORD,
    pbData : ^BYTE,
};
PCRYPT_OBJID_BLOB :: ^CRYPT_OBJID_BLOB;
CERT_NAME_BLOB :: struct {
    cbData : DWORD,
    pbData : ^BYTE,
};
PCERT_NAME_BLOB :: ^CERT_NAME_BLOB;
CERT_RDN_VALUE_BLOB :: struct {
    cbData : DWORD,
    pbData : ^BYTE,
};
PCERT_RDN_VALUE_BLOB :: ^CERT_RDN_VALUE_BLOB;
CERT_BLOB :: struct {
    cbData : DWORD,
    pbData : ^BYTE,
};
PCERT_BLOB :: ^CERT_BLOB;
CRL_BLOB :: struct {
    cbData : DWORD,
    pbData : ^BYTE,
};
PCRL_BLOB :: ^CRL_BLOB;
DATA_BLOB :: struct {
    cbData : DWORD,
    pbData : ^BYTE,
};
PDATA_BLOB :: ^DATA_BLOB;
CRYPT_DATA_BLOB :: struct {
    cbData : DWORD,
    pbData : ^BYTE,
};
PCRYPT_DATA_BLOB :: ^CRYPT_DATA_BLOB;
CRYPT_HASH_BLOB :: struct {
    cbData : DWORD,
    pbData : ^BYTE,
};
PCRYPT_HASH_BLOB :: ^CRYPT_HASH_BLOB;
CRYPT_DIGEST_BLOB :: struct {
    cbData : DWORD,
    pbData : ^BYTE,
};
PCRYPT_DIGEST_BLOB :: ^CRYPT_DIGEST_BLOB;
CRYPT_DER_BLOB :: struct {
    cbData : DWORD,
    pbData : ^BYTE,
};
PCRYPT_DER_BLOB :: ^CRYPT_DER_BLOB;
CRYPT_ATTR_BLOB :: struct {
    cbData : DWORD,
    pbData : ^BYTE,
};
PCRYPT_ATTR_BLOB :: ^CRYPT_ATTR_BLOB;

CMS_DH_KEY_INFO :: struct {
    dwVersion          : DWORD,
    Algid              : ALG_ID,
    pszContentEncObjId : LPSTR,
    PubInfo            : CRYPT_DATA_BLOB,
    pReserved          : rawptr,
};
PCMS_DH_KEY_INFO :: ^CMS_DH_KEY_INFO;

NTSTATUS :: LONG;

PNTSTATUS :: ^NTSTATUS;

BCRYPT_KEY_LENGTHS_STRUCT :: struct {
    dwMinLength : ULONG,
    dwMaxLength : ULONG,
    dwIncrement : ULONG,
};

BCRYPT_AUTH_TAG_LENGTHS_STRUCT :: BCRYPT_KEY_LENGTHS_STRUCT;

BCRYPT_OID :: struct {
    cbOID : ULONG,
    pbOID : PUCHAR,
};

BCRYPT_OID_LIST :: struct {
    dwOIDCount : ULONG,
    pOIDs      : ^BCRYPT_OID,
};

BCRYPT_PKCS1_PADDING_INFO :: struct {
    pszAlgId : LPCWSTR,
};

BCRYPT_PSS_PADDING_INFO :: struct {
    pszAlgId : LPCWSTR,
    cbSalt   : ULONG,
};

BCRYPT_OAEP_PADDING_INFO :: struct {
    pszAlgId : LPCWSTR,
    pbLabel  : PUCHAR,
    cbLabel  : ULONG,
};

BCRYPT_AUTHENTICATED_CIPHER_MODE_INFO :: struct {
    cbSize        : ULONG,
    dwInfoVersion : ULONG,
    pbNonce       : PUCHAR,
    cbNonce       : ULONG,
    pbAuthData    : PUCHAR,
    cbAuthData    : ULONG,
    pbTag         : PUCHAR,
    cbTag         : ULONG,
    pbMacContext  : PUCHAR,
    cbMacContext  : ULONG,
    cbAAD         : ULONG,
    cbData        : ULONGLONG,
    dwFlags       : ULONG,
};
PBCRYPT_AUTHENTICATED_CIPHER_MODE_INFO :: ^BCRYPT_AUTHENTICATED_CIPHER_MODE_INFO;

BCryptBuffer :: struct {
    cbBuffer   : ULONG,
    BufferType : ULONG,
    pvBuffer   : PVOID,
};
PBCryptBuffer :: ^BCryptBuffer;

BCryptBufferDesc :: struct {
    ulVersion : ULONG,
    cBuffers  : ULONG,
    pBuffers  : PBCryptBuffer,
};
PBCryptBufferDesc :: ^BCryptBufferDesc;

BCRYPT_HANDLE :: PVOID;

BCRYPT_ALG_HANDLE :: PVOID;

BCRYPT_KEY_HANDLE :: PVOID;

BCRYPT_HASH_HANDLE :: PVOID;

BCRYPT_SECRET_HANDLE :: PVOID;

BCRYPT_KEY_BLOB :: struct {
    Magic : ULONG,
};

BCRYPT_RSAKEY_BLOB :: struct {
    Magic       : ULONG,
    BitLength   : ULONG,
    cbPublicExp : ULONG,
    cbModulus   : ULONG,
    cbPrime1    : ULONG,
    cbPrime2    : ULONG,
};

BCRYPT_ECCKEY_BLOB :: struct {
    dwMagic : ULONG,
    cbKey   : ULONG,
};
PBCRYPT_ECCKEY_BLOB :: ^BCRYPT_ECCKEY_BLOB;

SSL_ECCKEY_BLOB :: struct {
    dwCurveType : ULONG,
    cbKey       : ULONG,
};
PSSL_ECCKEY_BLOB :: ^SSL_ECCKEY_BLOB;

/* ECC_CURVE_TYPE_ENUM :: enum { */
ECC_CURVE_TYPE_ENUM :: _c.int;
    BCRYPT_ECC_PRIME_SHORT_WEIERSTRASS_CURVE :: 0x1;
    BCRYPT_ECC_PRIME_TWISTED_EDWARDS_CURVE :: 0x2;
    BCRYPT_ECC_PRIME_MONTGOMERY_CURVE :: 0x3;
/* } */
;

/* ECC_CURVE_ALG_ID_ENUM :: enum { */
ECC_CURVE_ALG_ID_ENUM :: _c.int;
    BCRYPT_NO_CURVE_GENERATION_ALG_ID :: 0x0;
/* } */
;

BCRYPT_ECCFULLKEY_BLOB :: struct {
    dwMagic                : ULONG,
    dwVersion              : ULONG,
    dwCurveType            : ECC_CURVE_TYPE_ENUM,
    dwCurveGenerationAlgId : ECC_CURVE_ALG_ID_ENUM,
    cbFieldLength          : ULONG,
    cbSubgroupOrder        : ULONG,
    cbCofactor             : ULONG,
    cbSeed                 : ULONG,
};
PBCRYPT_ECCFULLKEY_BLOB :: ^BCRYPT_ECCFULLKEY_BLOB;

BCRYPT_DH_KEY_BLOB :: struct {
    dwMagic : ULONG,
    cbKey   : ULONG,
};
PBCRYPT_DH_KEY_BLOB :: ^BCRYPT_DH_KEY_BLOB;

BCRYPT_DH_PARAMETER_HEADER :: struct {
    cbLength    : ULONG,
    dwMagic     : ULONG,
    cbKeyLength : ULONG,
};

BCRYPT_DSA_KEY_BLOB :: struct {
    dwMagic : ULONG,
    cbKey   : ULONG,
    Count   : [4]UCHAR,
    Seed    : [20]UCHAR,
    q       : [20]UCHAR,
};
PBCRYPT_DSA_KEY_BLOB :: ^BCRYPT_DSA_KEY_BLOB;

/* HASHALGORITHM_ENUM :: enum { */
HASHALGORITHM_ENUM :: _c.int;
    DSA_HASH_ALGORITHM_SHA1 :: 0;
    DSA_HASH_ALGORITHM_SHA256 :: DSA_HASH_ALGORITHM_SHA1 + 1;
    DSA_HASH_ALGORITHM_SHA512 :: DSA_HASH_ALGORITHM_SHA256 + 1;
/* } */
;

/* DSAFIPSVERSION_ENUM :: enum { */
DSAFIPSVERSION_ENUM :: _c.int;
    DSA_FIPS186_2 :: 0;
    DSA_FIPS186_3 :: DSA_FIPS186_2 + 1;
/* } */
;

BCRYPT_DSA_KEY_BLOB_V2 :: struct {
    dwMagic         : ULONG,
    cbKey           : ULONG,
    hashAlgorithm   : HASHALGORITHM_ENUM,
    standardVersion : DSAFIPSVERSION_ENUM,
    cbSeedLength    : ULONG,
    cbGroupSize     : ULONG,
    Count           : [4]UCHAR,
};
PBCRYPT_DSA_KEY_BLOB_V2 :: ^BCRYPT_DSA_KEY_BLOB_V2;

BCRYPT_KEY_DATA_BLOB_HEADER :: struct {
    dwMagic   : ULONG,
    dwVersion : ULONG,
    cbKeyData : ULONG,
};
PBCRYPT_KEY_DATA_BLOB_HEADER :: ^BCRYPT_KEY_DATA_BLOB_HEADER;

BCRYPT_DSA_PARAMETER_HEADER :: struct {
    cbLength    : ULONG,
    dwMagic     : ULONG,
    cbKeyLength : ULONG,
    Count       : [4]UCHAR,
    Seed        : [20]UCHAR,
    q           : [20]UCHAR,
};

BCRYPT_DSA_PARAMETER_HEADER_V2 :: struct {
    cbLength        : ULONG,
    dwMagic         : ULONG,
    cbKeyLength     : ULONG,
    hashAlgorithm   : HASHALGORITHM_ENUM,
    standardVersion : DSAFIPSVERSION_ENUM,
    cbSeedLength    : ULONG,
    cbGroupSize     : ULONG,
    Count           : [4]UCHAR,
};

BCRYPT_ECC_CURVE_NAMES :: struct {
    dwEccCurveNames : ULONG,
    pEccCurveNames  : ^LPWSTR,
};

/* BCRYPT_HASH_OPERATION_TYPE :: enum { */
BCRYPT_HASH_OPERATION_TYPE :: _c.int;
    BCRYPT_HASH_OPERATION_HASH_DATA :: 1;
    BCRYPT_HASH_OPERATION_FINISH_HASH :: 2;
/* } */
;

BCRYPT_MULTI_HASH_OPERATION :: struct {
    iHash         : ULONG,
    hashOperation : BCRYPT_HASH_OPERATION_TYPE,
    pbBuffer      : PUCHAR,
    cbBuffer      : ULONG,
};

/* BCRYPT_MULTI_OPERATION_TYPE :: enum { */
BCRYPT_MULTI_OPERATION_TYPE :: _c.int;
    BCRYPT_OPERATION_TYPE_HASH :: 1;
/* } */
;

BCRYPT_MULTI_OBJECT_LENGTH_STRUCT :: struct {
    cbPerObject  : ULONG,
    cbPerElement : ULONG,
};

BCRYPT_ALGORITHM_IDENTIFIER :: struct {
    pszName : LPWSTR,
    dwClass : ULONG,
    dwFlags : ULONG,
};

BCRYPT_PROVIDER_NAME :: struct {
    pszProviderName : LPWSTR,
};

BCRYPT_INTERFACE_VERSION :: struct {
    MajorVersion : USHORT,
    MinorVersion : USHORT,
};
PBCRYPT_INTERFACE_VERSION :: ^BCRYPT_INTERFACE_VERSION;

CRYPT_INTERFACE_REG :: struct {
    dwInterface    : ULONG,
    dwFlags        : ULONG,
    cFunctions     : ULONG,
    rgpszFunctions : ^PWSTR,
};
PCRYPT_INTERFACE_REG :: ^CRYPT_INTERFACE_REG;

CRYPT_IMAGE_REG :: struct {
    pszImage      : PWSTR,
    cInterfaces   : ULONG,
    rgpInterfaces : ^PCRYPT_INTERFACE_REG,
};
PCRYPT_IMAGE_REG :: ^CRYPT_IMAGE_REG;

CRYPT_PROVIDER_REG :: struct {
    cAliases     : ULONG,
    rgpszAliases : ^PWSTR,
    pUM          : PCRYPT_IMAGE_REG,
    pKM          : PCRYPT_IMAGE_REG,
};
PCRYPT_PROVIDER_REG :: ^CRYPT_PROVIDER_REG;

CRYPT_PROVIDERS :: struct {
    cProviders     : ULONG,
    rgpszProviders : ^PWSTR,
};
PCRYPT_PROVIDERS :: ^CRYPT_PROVIDERS;

CRYPT_CONTEXT_CONFIG :: struct {
    dwFlags    : ULONG,
    dwReserved : ULONG,
};
PCRYPT_CONTEXT_CONFIG :: ^CRYPT_CONTEXT_CONFIG;

CRYPT_CONTEXT_FUNCTION_CONFIG :: struct {
    dwFlags    : ULONG,
    dwReserved : ULONG,
};
PCRYPT_CONTEXT_FUNCTION_CONFIG :: ^CRYPT_CONTEXT_FUNCTION_CONFIG;

CRYPT_CONTEXTS :: struct {
    cContexts     : ULONG,
    rgpszContexts : ^PWSTR,
};
PCRYPT_CONTEXTS :: ^CRYPT_CONTEXTS;

CRYPT_CONTEXT_FUNCTIONS :: struct {
    cFunctions     : ULONG,
    rgpszFunctions : ^PWSTR,
};
PCRYPT_CONTEXT_FUNCTIONS :: ^CRYPT_CONTEXT_FUNCTIONS;

CRYPT_CONTEXT_FUNCTION_PROVIDERS :: struct {
    cProviders     : ULONG,
    rgpszProviders : ^PWSTR,
};
PCRYPT_CONTEXT_FUNCTION_PROVIDERS :: ^CRYPT_CONTEXT_FUNCTION_PROVIDERS;

CRYPT_PROPERTY_REF :: struct {
    pszProperty : PWSTR,
    cbValue     : ULONG,
    pbValue     : PUCHAR,
};
PCRYPT_PROPERTY_REF :: ^CRYPT_PROPERTY_REF;

CRYPT_IMAGE_REF :: struct {
    pszImage : PWSTR,
    dwFlags  : ULONG,
};
PCRYPT_IMAGE_REF :: ^CRYPT_IMAGE_REF;

CRYPT_PROVIDER_REF :: struct {
    dwInterface   : ULONG,
    pszFunction   : PWSTR,
    pszProvider   : PWSTR,
    cProperties   : ULONG,
    rgpProperties : ^PCRYPT_PROPERTY_REF,
    pUM           : PCRYPT_IMAGE_REF,
    pKM           : PCRYPT_IMAGE_REF,
};
PCRYPT_PROVIDER_REF :: ^CRYPT_PROVIDER_REF;

CRYPT_PROVIDER_REFS :: struct {
    cProviders   : ULONG,
    rgpProviders : ^PCRYPT_PROVIDER_REF,
};
PCRYPT_PROVIDER_REFS :: ^CRYPT_PROVIDER_REFS;

SECURITY_STATUS :: LONG;

PFN_NCRYPT_ALLOC :: (proc "stdcall" (cbSize : SIZE_T) -> LPVOID);

PFN_NCRYPT_FREE :: proc "stdcall" (pv : LPVOID);

NCRYPT_ALLOC_PARA :: struct {
    cbSize   : DWORD,
    pfnAlloc : PFN_NCRYPT_ALLOC,
    pfnFree  : PFN_NCRYPT_FREE,
};

NCryptBuffer :: BCryptBuffer;

PNCryptBuffer :: ^BCryptBuffer;

NCryptBufferDesc :: BCryptBufferDesc;

PNCryptBufferDesc :: ^BCryptBufferDesc;

NCRYPT_HANDLE :: ULONG_PTR;

NCRYPT_PROV_HANDLE :: ULONG_PTR;

NCRYPT_KEY_HANDLE :: ULONG_PTR;

NCRYPT_HASH_HANDLE :: ULONG_PTR;

NCRYPT_SECRET_HANDLE :: ULONG_PTR;

NCRYPT_CIPHER_PADDING_INFO :: struct {
    cbSize      : ULONG,
    dwFlags     : DWORD,
    pbIV        : PUCHAR,
    cbIV        : ULONG,
    pbOtherInfo : PUCHAR,
    cbOtherInfo : ULONG,
};
PNCRYPT_CIPHER_PADDING_INFO :: ^NCRYPT_CIPHER_PADDING_INFO;

NCRYPT_PLATFORM_ATTEST_PADDING_INFO :: struct {
    magic   : ULONG,
    pcrMask : ULONG,
};

NCRYPT_KEY_ATTEST_PADDING_INFO :: struct {
    magic     : ULONG,
    pbKeyBlob : PUCHAR,
    cbKeyBlob : ULONG,
    pbKeyAuth : PUCHAR,
    cbKeyAuth : ULONG,
};

NCRYPT_ISOLATED_KEY_ATTESTED_ATTRIBUTES :: struct {
    Version         : ULONG,
    Flags           : ULONG,
    cbPublicKeyBlob : ULONG,
};
PNCRYPT_ISOLATED_KEY_ATTESTED_ATTRIBUTES :: ^NCRYPT_ISOLATED_KEY_ATTESTED_ATTRIBUTES;

NCRYPT_VSM_KEY_ATTESTATION_STATEMENT :: struct {
    Magic        : ULONG,
    Version      : ULONG,
    cbSignature  : ULONG,
    cbReport     : ULONG,
    cbAttributes : ULONG,
};
PNCRYPT_VSM_KEY_ATTESTATION_STATEMENT :: ^NCRYPT_VSM_KEY_ATTESTATION_STATEMENT;

NCRYPT_VSM_KEY_ATTESTATION_CLAIM_RESTRICTIONS :: struct {
    Version        : ULONG,
    TrustletId     : ULONGLONG,
    MinSvn         : ULONG,
    FlagsMask      : ULONG,
    FlagsExpected  : ULONG,
    using _ : bit_field {
        AllowDebugging : 1,
        Reserved       : 31,
    },
};
PNCRYPT_VSM_KEY_ATTESTATION_CLAIM_RESTRICTIONS :: ^NCRYPT_VSM_KEY_ATTESTATION_CLAIM_RESTRICTIONS;

NCRYPT_EXPORTED_ISOLATED_KEY_HEADER :: struct {
    Version       : ULONG,
    KeyUsage      : ULONG,
    using _ : bit_field {
        PerBootKey    : 1,
        Reserved      : 31,
    },
    cbAlgName     : ULONG,
    cbNonce       : ULONG,
    cbAuthTag     : ULONG,
    cbWrappingKey : ULONG,
    cbIsolatedKey : ULONG,
};
PNCRYPT_EXPORTED_ISOLATED_KEY_HEADER :: ^NCRYPT_EXPORTED_ISOLATED_KEY_HEADER;

NCRYPT_EXPORTED_ISOLATED_KEY_ENVELOPE :: struct {
    Header : NCRYPT_EXPORTED_ISOLATED_KEY_HEADER,
};
PNCRYPT_EXPORTED_ISOLATED_KEY_ENVELOPE :: ^NCRYPT_EXPORTED_ISOLATED_KEY_ENVELOPE;

NCRYPT_PCP_TPM_WEB_AUTHN_ATTESTATION_STATEMENT :: struct {
    Magic         : UINT32,
    Version       : UINT32,
    HeaderSize    : UINT32,
    cbCertifyInfo : UINT32,
    cbSignature   : UINT32,
    cbTpmPublic   : UINT32,
};
PNCRYPT_PCP_TPM_WEB_AUTHN_ATTESTATION_STATEMENT :: ^NCRYPT_PCP_TPM_WEB_AUTHN_ATTESTATION_STATEMENT;

NCRYPT_TPM_PLATFORM_ATTESTATION_STATEMENT :: struct {
    Magic       : ULONG,
    Version     : ULONG,
    pcrAlg      : ULONG,
    cbSignature : ULONG,
    cbQuote     : ULONG,
    cbPcrs      : ULONG,
};
PNCRYPT_TPM_PLATFORM_ATTESTATION_STATEMENT :: ^NCRYPT_TPM_PLATFORM_ATTESTATION_STATEMENT;

NCryptAlgorithmName :: struct {
    pszName         : LPWSTR,
    dwClass         : DWORD,
    dwAlgOperations : DWORD,
    dwFlags         : DWORD,
};

NCryptKeyName :: struct {
    pszName         : LPWSTR,
    pszAlgid        : LPWSTR,
    dwLegacyKeySpec : DWORD,
    dwFlags         : DWORD,
};

NCryptProviderName :: struct {
    pszName    : LPWSTR,
    pszComment : LPWSTR,
};

NCRYPT_UI_POLICY :: struct {
    dwVersion        : DWORD,
    dwFlags          : DWORD,
    pszCreationTitle : LPCWSTR,
    pszFriendlyName  : LPCWSTR,
    pszDescription   : LPCWSTR,
};

NCRYPT_KEY_ACCESS_POLICY_BLOB :: struct {
    dwVersion        : DWORD,
    dwPolicyFlags    : DWORD,
    cbUserSid        : DWORD,
    cbApplicationSid : DWORD,
};

NCRYPT_SUPPORTED_LENGTHS :: struct {
    dwMinLength     : DWORD,
    dwMaxLength     : DWORD,
    dwIncrement     : DWORD,
    dwDefaultLength : DWORD,
};

NCRYPT_PCP_HMAC_AUTH_SIGNATURE_INFO :: struct {
    dwVersion    : DWORD,
    iExpiration  : INT32,
    pabNonce     : [32]BYTE,
    pabPolicyRef : [32]BYTE,
    pabHMAC      : [32]BYTE,
};

NCRYPT_PCP_TPM_FW_VERSION_INFO :: struct {
    major1 : UINT16,
    major2 : UINT16,
    minor1 : UINT16,
    minor2 : UINT16,
};

NCRYPT_PCP_RAW_POLICYDIGEST_INFO :: struct {
    dwVersion : DWORD,
    cbDigest  : DWORD,
};

NCRYPT_KEY_BLOB_HEADER :: struct {
    cbSize    : ULONG,
    dwMagic   : ULONG,
    cbAlgName : ULONG,
    cbKeyData : ULONG,
};
PNCRYPT_KEY_BLOB_HEADER :: ^NCRYPT_KEY_BLOB_HEADER;

NCRYPT_TPM_LOADABLE_KEY_BLOB_HEADER :: struct {
    magic     : DWORD,
    cbHeader  : DWORD,
    cbPublic  : DWORD,
    cbPrivate : DWORD,
    cbName    : DWORD,
};
PNCRYPT_TPM_LOADABLE_KEY_BLOB_HEADER :: ^NCRYPT_TPM_LOADABLE_KEY_BLOB_HEADER;

HCRYPTPROV_OR_NCRYPT_KEY_HANDLE :: ULONG_PTR;

HCRYPTPROV_LEGACY :: ULONG_PTR;

CRYPT_BIT_BLOB :: struct {
    cbData      : DWORD,
    pbData      : ^BYTE,
    cUnusedBits : DWORD,
};
PCRYPT_BIT_BLOB :: ^CRYPT_BIT_BLOB;

CRYPT_ALGORITHM_IDENTIFIER :: struct {
    pszObjId   : LPSTR,
    Parameters : CRYPT_OBJID_BLOB,
};
PCRYPT_ALGORITHM_IDENTIFIER :: ^CRYPT_ALGORITHM_IDENTIFIER;

CRYPT_OBJID_TABLE :: struct {
    dwAlgId  : DWORD,
    pszObjId : LPCSTR,
};
PCRYPT_OBJID_TABLE :: ^CRYPT_OBJID_TABLE;

CRYPT_HASH_INFO :: struct {
    HashAlgorithm : CRYPT_ALGORITHM_IDENTIFIER,
    Hash          : CRYPT_HASH_BLOB,
};
PCRYPT_HASH_INFO :: ^CRYPT_HASH_INFO;

CERT_EXTENSION :: struct {
    pszObjId  : LPSTR,
    fCritical : BOOL,
    Value     : CRYPT_OBJID_BLOB,
};
PCERT_EXTENSION :: ^CERT_EXTENSION;

PCCERT_EXTENSION :: ^CERT_EXTENSION;

CRYPT_ATTRIBUTE_TYPE_VALUE :: struct {
    pszObjId : LPSTR,
    Value    : CRYPT_OBJID_BLOB,
};
PCRYPT_ATTRIBUTE_TYPE_VALUE :: ^CRYPT_ATTRIBUTE_TYPE_VALUE;

CRYPT_ATTRIBUTE :: struct {
    pszObjId : LPSTR,
    cValue   : DWORD,
    rgValue  : PCRYPT_ATTR_BLOB,
};
PCRYPT_ATTRIBUTE :: ^CRYPT_ATTRIBUTE;

CRYPT_ATTRIBUTES :: struct {
    cAttr  : DWORD,
    rgAttr : PCRYPT_ATTRIBUTE,
};
PCRYPT_ATTRIBUTES :: ^CRYPT_ATTRIBUTES;

CERT_RDN_ATTR :: struct {
    pszObjId    : LPSTR,
    dwValueType : DWORD,
    Value       : CERT_RDN_VALUE_BLOB,
};
PCERT_RDN_ATTR :: ^CERT_RDN_ATTR;

CERT_RDN :: struct {
    cRDNAttr  : DWORD,
    rgRDNAttr : PCERT_RDN_ATTR,
};
PCERT_RDN :: ^CERT_RDN;

CERT_NAME_INFO :: struct {
    cRDN  : DWORD,
    rgRDN : PCERT_RDN,
};
PCERT_NAME_INFO :: ^CERT_NAME_INFO;

CERT_NAME_VALUE :: struct {
    dwValueType : DWORD,
    Value       : CERT_RDN_VALUE_BLOB,
};
PCERT_NAME_VALUE :: ^CERT_NAME_VALUE;

CERT_PUBLIC_KEY_INFO :: struct {
    Algorithm : CRYPT_ALGORITHM_IDENTIFIER,
    PublicKey : CRYPT_BIT_BLOB,
};
PCERT_PUBLIC_KEY_INFO :: ^CERT_PUBLIC_KEY_INFO;

CRYPT_ECC_PRIVATE_KEY_INFO :: struct {
    dwVersion  : DWORD,
    PrivateKey : CRYPT_DER_BLOB,
    szCurveOid : LPSTR,
    PublicKey  : CRYPT_BIT_BLOB,
};
PCRYPT_ECC_PRIVATE_KEY_INFO :: ^CRYPT_ECC_PRIVATE_KEY_INFO;

CRYPT_PRIVATE_KEY_INFO :: struct {
    Version     : DWORD,
    Algorithm   : CRYPT_ALGORITHM_IDENTIFIER,
    PrivateKey  : CRYPT_DER_BLOB,
    pAttributes : PCRYPT_ATTRIBUTES,
};
PCRYPT_PRIVATE_KEY_INFO :: ^CRYPT_PRIVATE_KEY_INFO;

CRYPT_ENCRYPTED_PRIVATE_KEY_INFO :: struct {
    EncryptionAlgorithm : CRYPT_ALGORITHM_IDENTIFIER,
    EncryptedPrivateKey : CRYPT_DATA_BLOB,
};
PCRYPT_ENCRYPTED_PRIVATE_KEY_INFO :: ^CRYPT_ENCRYPTED_PRIVATE_KEY_INFO;

PCRYPT_DECRYPT_PRIVATE_KEY_FUNC :: (proc "stdcall" (Algorithm : CRYPT_ALGORITHM_IDENTIFIER, EncryptedPrivateKey : CRYPT_DATA_BLOB, pbClearTextKey : ^BYTE, pcbClearTextKey : ^DWORD, pVoidDecryptFunc : LPVOID) -> BOOL);

PCRYPT_ENCRYPT_PRIVATE_KEY_FUNC :: (proc "stdcall" (pAlgorithm : ^CRYPT_ALGORITHM_IDENTIFIER, pClearTextPrivateKey : ^CRYPT_DATA_BLOB, pbEncryptedKey : ^BYTE, pcbEncryptedKey : ^DWORD, pVoidEncryptFunc : LPVOID) -> BOOL);

PCRYPT_RESOLVE_HCRYPTPROV_FUNC :: (proc "stdcall" (pPrivateKeyInfo : ^CRYPT_PRIVATE_KEY_INFO, phCryptProv : ^HCRYPTPROV, pVoidResolveFunc : LPVOID) -> BOOL);

CRYPT_PKCS8_IMPORT_PARAMS :: struct {
    PrivateKey             : CRYPT_DIGEST_BLOB,
    pResolvehCryptProvFunc : PCRYPT_RESOLVE_HCRYPTPROV_FUNC,
    pVoidResolveFunc       : LPVOID,
    pDecryptPrivateKeyFunc : PCRYPT_DECRYPT_PRIVATE_KEY_FUNC,
    pVoidDecryptFunc       : LPVOID,
};
PCRYPT_PKCS8_IMPORT_PARAMS :: ^CRYPT_PKCS8_IMPORT_PARAMS;
CRYPT_PRIVATE_KEY_BLOB_AND_PARAMS :: struct {
    PrivateKey             : CRYPT_DIGEST_BLOB,
    pResolvehCryptProvFunc : PCRYPT_RESOLVE_HCRYPTPROV_FUNC,
    pVoidResolveFunc       : LPVOID,
    pDecryptPrivateKeyFunc : PCRYPT_DECRYPT_PRIVATE_KEY_FUNC,
    pVoidDecryptFunc       : LPVOID,
};
PCRYPT_PRIVATE_KEY_BLOB_AND_PARAMS :: ^CRYPT_PRIVATE_KEY_BLOB_AND_PARAMS;

CRYPT_PKCS8_EXPORT_PARAMS :: struct {
    hCryptProv             : HCRYPTPROV,
    dwKeySpec              : DWORD,
    pszPrivateKeyObjId     : LPSTR,
    pEncryptPrivateKeyFunc : PCRYPT_ENCRYPT_PRIVATE_KEY_FUNC,
    pVoidEncryptFunc       : LPVOID,
};
PCRYPT_PKCS8_EXPORT_PARAMS :: ^CRYPT_PKCS8_EXPORT_PARAMS;

CERT_INFO :: struct {
    dwVersion            : DWORD,
    SerialNumber         : CRYPT_INTEGER_BLOB,
    SignatureAlgorithm   : CRYPT_ALGORITHM_IDENTIFIER,
    Issuer               : CERT_NAME_BLOB,
    NotBefore            : FILETIME,
    NotAfter             : FILETIME,
    Subject              : CERT_NAME_BLOB,
    SubjectPublicKeyInfo : CERT_PUBLIC_KEY_INFO,
    IssuerUniqueId       : CRYPT_BIT_BLOB,
    SubjectUniqueId      : CRYPT_BIT_BLOB,
    cExtension           : DWORD,
    rgExtension          : PCERT_EXTENSION,
};
PCERT_INFO :: ^CERT_INFO;

CRL_ENTRY :: struct {
    SerialNumber   : CRYPT_INTEGER_BLOB,
    RevocationDate : FILETIME,
    cExtension     : DWORD,
    rgExtension    : PCERT_EXTENSION,
};
PCRL_ENTRY :: ^CRL_ENTRY;

CRL_INFO :: struct {
    dwVersion          : DWORD,
    SignatureAlgorithm : CRYPT_ALGORITHM_IDENTIFIER,
    Issuer             : CERT_NAME_BLOB,
    ThisUpdate         : FILETIME,
    NextUpdate         : FILETIME,
    cCRLEntry          : DWORD,
    rgCRLEntry         : PCRL_ENTRY,
    cExtension         : DWORD,
    rgExtension        : PCERT_EXTENSION,
};
PCRL_INFO :: ^CRL_INFO;

CERT_OR_CRL_BLOB :: struct {
    dwChoice  : DWORD,
    cbEncoded : DWORD,
    pbEncoded : ^BYTE,
};
PCERT_OR_CRL_BLOB :: ^CERT_OR_CRL_BLOB;

CERT_OR_CRL_BUNDLE :: struct {
    cItem  : DWORD,
    rgItem : PCERT_OR_CRL_BLOB,
};
PCERT_OR_CRL_BUNDLE :: ^CERT_OR_CRL_BUNDLE;

CERT_REQUEST_INFO :: struct {
    dwVersion            : DWORD,
    Subject              : CERT_NAME_BLOB,
    SubjectPublicKeyInfo : CERT_PUBLIC_KEY_INFO,
    cAttribute           : DWORD,
    rgAttribute          : PCRYPT_ATTRIBUTE,
};
PCERT_REQUEST_INFO :: ^CERT_REQUEST_INFO;

CERT_KEYGEN_REQUEST_INFO :: struct {
    dwVersion            : DWORD,
    SubjectPublicKeyInfo : CERT_PUBLIC_KEY_INFO,
    pwszChallengeString  : LPWSTR,
};
PCERT_KEYGEN_REQUEST_INFO :: ^CERT_KEYGEN_REQUEST_INFO;

CERT_SIGNED_CONTENT_INFO :: struct {
    ToBeSigned         : CRYPT_DER_BLOB,
    SignatureAlgorithm : CRYPT_ALGORITHM_IDENTIFIER,
    Signature          : CRYPT_BIT_BLOB,
};
PCERT_SIGNED_CONTENT_INFO :: ^CERT_SIGNED_CONTENT_INFO;

CTL_USAGE :: struct {
    cUsageIdentifier     : DWORD,
    rgpszUsageIdentifier : ^LPSTR,
};
PCTL_USAGE :: ^CTL_USAGE;
CERT_ENHKEY_USAGE :: struct {
    cUsageIdentifier     : DWORD,
    rgpszUsageIdentifier : ^LPSTR,
};
PCERT_ENHKEY_USAGE :: ^CERT_ENHKEY_USAGE;

PCCTL_USAGE :: ^CTL_USAGE;

PCCERT_ENHKEY_USAGE :: ^CERT_ENHKEY_USAGE;

CTL_ENTRY :: struct {
    SubjectIdentifier : CRYPT_DATA_BLOB,
    cAttribute        : DWORD,
    rgAttribute       : PCRYPT_ATTRIBUTE,
};
PCTL_ENTRY :: ^CTL_ENTRY;

CTL_INFO :: struct {
    dwVersion        : DWORD,
    SubjectUsage     : CTL_USAGE,
    ListIdentifier   : CRYPT_DATA_BLOB,
    SequenceNumber   : CRYPT_INTEGER_BLOB,
    ThisUpdate       : FILETIME,
    NextUpdate       : FILETIME,
    SubjectAlgorithm : CRYPT_ALGORITHM_IDENTIFIER,
    cCTLEntry        : DWORD,
    rgCTLEntry       : PCTL_ENTRY,
    cExtension       : DWORD,
    rgExtension      : PCERT_EXTENSION,
};
PCTL_INFO :: ^CTL_INFO;

CRYPT_TIME_STAMP_REQUEST_INFO :: struct {
    pszTimeStampAlgorithm : LPSTR,
    pszContentType        : LPSTR,
    Content               : CRYPT_OBJID_BLOB,
    cAttribute            : DWORD,
    rgAttribute           : PCRYPT_ATTRIBUTE,
};
PCRYPT_TIME_STAMP_REQUEST_INFO :: ^CRYPT_TIME_STAMP_REQUEST_INFO;

CRYPT_ENROLLMENT_NAME_VALUE_PAIR :: struct {
    pwszName  : LPWSTR,
    pwszValue : LPWSTR,
};
PCRYPT_ENROLLMENT_NAME_VALUE_PAIR :: ^CRYPT_ENROLLMENT_NAME_VALUE_PAIR;

CRYPT_CSP_PROVIDER :: struct {
    dwKeySpec        : DWORD,
    pwszProviderName : LPWSTR,
    Signature        : CRYPT_BIT_BLOB,
};
PCRYPT_CSP_PROVIDER :: ^CRYPT_CSP_PROVIDER;

PFN_CRYPT_ALLOC :: (proc "stdcall" (cbSize : _c.size_t) -> LPVOID);

PFN_CRYPT_FREE :: proc "stdcall" (pv : LPVOID);

CRYPT_ENCODE_PARA :: struct {
    cbSize   : DWORD,
    pfnAlloc : PFN_CRYPT_ALLOC,
    pfnFree  : PFN_CRYPT_FREE,
};
PCRYPT_ENCODE_PARA :: ^CRYPT_ENCODE_PARA;

CRYPT_DECODE_PARA :: struct {
    cbSize   : DWORD,
    pfnAlloc : PFN_CRYPT_ALLOC,
    pfnFree  : PFN_CRYPT_FREE,
};
PCRYPT_DECODE_PARA :: ^CRYPT_DECODE_PARA;

CERT_EXTENSIONS :: struct {
    cExtension  : DWORD,
    rgExtension : PCERT_EXTENSION,
};
PCERT_EXTENSIONS :: ^CERT_EXTENSIONS;

CERT_AUTHORITY_KEY_ID_INFO :: struct {
    KeyId            : CRYPT_DATA_BLOB,
    CertIssuer       : CERT_NAME_BLOB,
    CertSerialNumber : CRYPT_INTEGER_BLOB,
};
PCERT_AUTHORITY_KEY_ID_INFO :: ^CERT_AUTHORITY_KEY_ID_INFO;

CERT_PRIVATE_KEY_VALIDITY :: struct {
    NotBefore : FILETIME,
    NotAfter  : FILETIME,
};
PCERT_PRIVATE_KEY_VALIDITY :: ^CERT_PRIVATE_KEY_VALIDITY;

CERT_KEY_ATTRIBUTES_INFO :: struct {
    KeyId                  : CRYPT_DATA_BLOB,
    IntendedKeyUsage       : CRYPT_BIT_BLOB,
    pPrivateKeyUsagePeriod : PCERT_PRIVATE_KEY_VALIDITY,
};
PCERT_KEY_ATTRIBUTES_INFO :: ^CERT_KEY_ATTRIBUTES_INFO;

CERT_POLICY_ID :: struct {
    cCertPolicyElementId     : DWORD,
    rgpszCertPolicyElementId : ^LPSTR,
};
PCERT_POLICY_ID :: ^CERT_POLICY_ID;

CERT_KEY_USAGE_RESTRICTION_INFO :: struct {
    cCertPolicyId      : DWORD,
    rgCertPolicyId     : PCERT_POLICY_ID,
    RestrictedKeyUsage : CRYPT_BIT_BLOB,
};
PCERT_KEY_USAGE_RESTRICTION_INFO :: ^CERT_KEY_USAGE_RESTRICTION_INFO;

CERT_OTHER_NAME :: struct {
    pszObjId : LPSTR,
    Value    : CRYPT_OBJID_BLOB,
};
PCERT_OTHER_NAME :: ^CERT_OTHER_NAME;

CERT_ALT_NAME_ENTRY :: struct {
    dwAltNameChoice : DWORD,
    u : struct #raw_union {
        pOtherName      : PCERT_OTHER_NAME,
        pwszRfc822Name  : LPWSTR,
        pwszDNSName     : LPWSTR,
        DirectoryName   : CERT_NAME_BLOB,
        pwszURL         : LPWSTR,
        IPAddress       : CRYPT_DATA_BLOB,
        pszRegisteredID : LPSTR,
    },
};
PCERT_ALT_NAME_ENTRY :: ^CERT_ALT_NAME_ENTRY;

CERT_ALT_NAME_INFO :: struct {
    cAltEntry  : DWORD,
    rgAltEntry : PCERT_ALT_NAME_ENTRY,
};
PCERT_ALT_NAME_INFO :: ^CERT_ALT_NAME_INFO;

CERT_BASIC_CONSTRAINTS_INFO :: struct {
    SubjectType          : CRYPT_BIT_BLOB,
    fPathLenConstraint   : BOOL,
    dwPathLenConstraint  : DWORD,
    cSubtreesConstraint  : DWORD,
    rgSubtreesConstraint : ^CERT_NAME_BLOB,
};
PCERT_BASIC_CONSTRAINTS_INFO :: ^CERT_BASIC_CONSTRAINTS_INFO;

CERT_BASIC_CONSTRAINTS2_INFO :: struct {
    fCA                 : BOOL,
    fPathLenConstraint  : BOOL,
    dwPathLenConstraint : DWORD,
};
PCERT_BASIC_CONSTRAINTS2_INFO :: ^CERT_BASIC_CONSTRAINTS2_INFO;

CERT_POLICY_QUALIFIER_INFO :: struct {
    pszPolicyQualifierId : LPSTR,
    Qualifier            : CRYPT_OBJID_BLOB,
};
PCERT_POLICY_QUALIFIER_INFO :: ^CERT_POLICY_QUALIFIER_INFO;

CERT_POLICY_INFO :: struct {
    pszPolicyIdentifier : LPSTR,
    cPolicyQualifier    : DWORD,
    rgPolicyQualifier   : ^CERT_POLICY_QUALIFIER_INFO,
};
PCERT_POLICY_INFO :: ^CERT_POLICY_INFO;

CERT_POLICIES_INFO :: struct {
    cPolicyInfo  : DWORD,
    rgPolicyInfo : ^CERT_POLICY_INFO,
};
PCERT_POLICIES_INFO :: ^CERT_POLICIES_INFO;

CERT_POLICY_QUALIFIER_NOTICE_REFERENCE :: struct {
    pszOrganization : LPSTR,
    cNoticeNumbers  : DWORD,
    rgNoticeNumbers : ^_c.int,
};
PCERT_POLICY_QUALIFIER_NOTICE_REFERENCE :: ^CERT_POLICY_QUALIFIER_NOTICE_REFERENCE;

CERT_POLICY_QUALIFIER_USER_NOTICE :: struct {
    pNoticeReference : ^CERT_POLICY_QUALIFIER_NOTICE_REFERENCE,
    pszDisplayText   : LPWSTR,
};
PCERT_POLICY_QUALIFIER_USER_NOTICE :: ^CERT_POLICY_QUALIFIER_USER_NOTICE;

CPS_URLS :: struct {
    pszURL     : LPWSTR,
    pAlgorithm : ^CRYPT_ALGORITHM_IDENTIFIER,
    pDigest    : ^CRYPT_DATA_BLOB,
};
PCPS_URLS :: ^CPS_URLS;

CERT_POLICY95_QUALIFIER1 :: struct {
    pszPracticesReference  : LPWSTR,
    pszNoticeIdentifier    : LPSTR,
    pszNSINoticeIdentifier : LPSTR,
    cCPSURLs               : DWORD,
    rgCPSURLs              : ^CPS_URLS,
};
PCERT_POLICY95_QUALIFIER1 :: ^CERT_POLICY95_QUALIFIER1;

CERT_POLICY_MAPPING :: struct {
    pszIssuerDomainPolicy  : LPSTR,
    pszSubjectDomainPolicy : LPSTR,
};
PCERT_POLICY_MAPPING :: ^CERT_POLICY_MAPPING;

CERT_POLICY_MAPPINGS_INFO :: struct {
    cPolicyMapping  : DWORD,
    rgPolicyMapping : PCERT_POLICY_MAPPING,
};
PCERT_POLICY_MAPPINGS_INFO :: ^CERT_POLICY_MAPPINGS_INFO;

CERT_POLICY_CONSTRAINTS_INFO :: struct {
    fRequireExplicitPolicy           : BOOL,
    dwRequireExplicitPolicySkipCerts : DWORD,
    fInhibitPolicyMapping            : BOOL,
    dwInhibitPolicyMappingSkipCerts  : DWORD,
};
PCERT_POLICY_CONSTRAINTS_INFO :: ^CERT_POLICY_CONSTRAINTS_INFO;

CRYPT_CONTENT_INFO_SEQUENCE_OF_ANY :: struct {
    pszObjId : LPSTR,
    cValue   : DWORD,
    rgValue  : PCRYPT_DER_BLOB,
};
PCRYPT_CONTENT_INFO_SEQUENCE_OF_ANY :: ^CRYPT_CONTENT_INFO_SEQUENCE_OF_ANY;

CRYPT_CONTENT_INFO :: struct {
    pszObjId : LPSTR,
    Content  : CRYPT_DER_BLOB,
};
PCRYPT_CONTENT_INFO :: ^CRYPT_CONTENT_INFO;

CRYPT_SEQUENCE_OF_ANY :: struct {
    cValue  : DWORD,
    rgValue : PCRYPT_DER_BLOB,
};
PCRYPT_SEQUENCE_OF_ANY :: ^CRYPT_SEQUENCE_OF_ANY;

CERT_AUTHORITY_KEY_ID2_INFO :: struct {
    KeyId                     : CRYPT_DATA_BLOB,
    AuthorityCertIssuer       : CERT_ALT_NAME_INFO,
    AuthorityCertSerialNumber : CRYPT_INTEGER_BLOB,
};
PCERT_AUTHORITY_KEY_ID2_INFO :: ^CERT_AUTHORITY_KEY_ID2_INFO;

CERT_ACCESS_DESCRIPTION :: struct {
    pszAccessMethod : LPSTR,
    AccessLocation  : CERT_ALT_NAME_ENTRY,
};
PCERT_ACCESS_DESCRIPTION :: ^CERT_ACCESS_DESCRIPTION;

CERT_AUTHORITY_INFO_ACCESS :: struct {
    cAccDescr  : DWORD,
    rgAccDescr : PCERT_ACCESS_DESCRIPTION,
};
PCERT_AUTHORITY_INFO_ACCESS :: ^CERT_AUTHORITY_INFO_ACCESS;
CERT_SUBJECT_INFO_ACCESS :: struct {
    cAccDescr  : DWORD,
    rgAccDescr : PCERT_ACCESS_DESCRIPTION,
};
PCERT_SUBJECT_INFO_ACCESS :: ^CERT_SUBJECT_INFO_ACCESS;

CRL_DIST_POINT_NAME :: struct {
    dwDistPointNameChoice : DWORD,
    u : struct #raw_union {
        FullName : CERT_ALT_NAME_INFO,
    },
};
PCRL_DIST_POINT_NAME :: ^CRL_DIST_POINT_NAME;

CRL_DIST_POINT :: struct {
    DistPointName : CRL_DIST_POINT_NAME,
    ReasonFlags   : CRYPT_BIT_BLOB,
    CRLIssuer     : CERT_ALT_NAME_INFO,
};
PCRL_DIST_POINT :: ^CRL_DIST_POINT;

CRL_DIST_POINTS_INFO :: struct {
    cDistPoint  : DWORD,
    rgDistPoint : PCRL_DIST_POINT,
};
PCRL_DIST_POINTS_INFO :: ^CRL_DIST_POINTS_INFO;

CROSS_CERT_DIST_POINTS_INFO :: struct {
    dwSyncDeltaTime : DWORD,
    cDistPoint      : DWORD,
    rgDistPoint     : PCERT_ALT_NAME_INFO,
};
PCROSS_CERT_DIST_POINTS_INFO :: ^CROSS_CERT_DIST_POINTS_INFO;

CERT_PAIR :: struct {
    Forward : CERT_BLOB,
    Reverse : CERT_BLOB,
};
PCERT_PAIR :: ^CERT_PAIR;

CRL_ISSUING_DIST_POINT :: struct {
    DistPointName          : CRL_DIST_POINT_NAME,
    fOnlyContainsUserCerts : BOOL,
    fOnlyContainsCACerts   : BOOL,
    OnlySomeReasonFlags    : CRYPT_BIT_BLOB,
    fIndirectCRL           : BOOL,
};
PCRL_ISSUING_DIST_POINT :: ^CRL_ISSUING_DIST_POINT;

CERT_GENERAL_SUBTREE :: struct {
    Base      : CERT_ALT_NAME_ENTRY,
    dwMinimum : DWORD,
    fMaximum  : BOOL,
    dwMaximum : DWORD,
};
PCERT_GENERAL_SUBTREE :: ^CERT_GENERAL_SUBTREE;

CERT_NAME_CONSTRAINTS_INFO :: struct {
    cPermittedSubtree  : DWORD,
    rgPermittedSubtree : PCERT_GENERAL_SUBTREE,
    cExcludedSubtree   : DWORD,
    rgExcludedSubtree  : PCERT_GENERAL_SUBTREE,
};
PCERT_NAME_CONSTRAINTS_INFO :: ^CERT_NAME_CONSTRAINTS_INFO;

CERT_DSS_PARAMETERS :: struct {
    p : CRYPT_UINT_BLOB,
    q : CRYPT_UINT_BLOB,
    g : CRYPT_UINT_BLOB,
};
PCERT_DSS_PARAMETERS :: ^CERT_DSS_PARAMETERS;

CERT_DH_PARAMETERS :: struct {
    p : CRYPT_UINT_BLOB,
    g : CRYPT_UINT_BLOB,
};
PCERT_DH_PARAMETERS :: ^CERT_DH_PARAMETERS;

CERT_ECC_SIGNATURE :: struct {
    r : CRYPT_UINT_BLOB,
    s : CRYPT_UINT_BLOB,
};
PCERT_ECC_SIGNATURE :: ^CERT_ECC_SIGNATURE;

CERT_X942_DH_VALIDATION_PARAMS :: struct {
    seed        : CRYPT_BIT_BLOB,
    pgenCounter : DWORD,
};
PCERT_X942_DH_VALIDATION_PARAMS :: ^CERT_X942_DH_VALIDATION_PARAMS;

CERT_X942_DH_PARAMETERS :: struct {
    p                 : CRYPT_UINT_BLOB,
    g                 : CRYPT_UINT_BLOB,
    q                 : CRYPT_UINT_BLOB,
    j                 : CRYPT_UINT_BLOB,
    pValidationParams : PCERT_X942_DH_VALIDATION_PARAMS,
};
PCERT_X942_DH_PARAMETERS :: ^CERT_X942_DH_PARAMETERS;

CRYPT_X942_OTHER_INFO :: struct {
    pszContentEncryptionObjId : LPSTR,
    rgbCounter                : [4]BYTE,
    rgbKeyLength              : [4]BYTE,
    PubInfo                   : CRYPT_DATA_BLOB,
};
PCRYPT_X942_OTHER_INFO :: ^CRYPT_X942_OTHER_INFO;

CRYPT_ECC_CMS_SHARED_INFO :: struct {
    Algorithm      : CRYPT_ALGORITHM_IDENTIFIER,
    EntityUInfo    : CRYPT_DATA_BLOB,
    rgbSuppPubInfo : [4]BYTE,
};
PCRYPT_ECC_CMS_SHARED_INFO :: ^CRYPT_ECC_CMS_SHARED_INFO;

CRYPT_RC2_CBC_PARAMETERS :: struct {
    dwVersion : DWORD,
    fIV       : BOOL,
    rgbIV     : [8]BYTE,
};
PCRYPT_RC2_CBC_PARAMETERS :: ^CRYPT_RC2_CBC_PARAMETERS;

CRYPT_SMIME_CAPABILITY :: struct {
    pszObjId   : LPSTR,
    Parameters : CRYPT_OBJID_BLOB,
};
PCRYPT_SMIME_CAPABILITY :: ^CRYPT_SMIME_CAPABILITY;

CRYPT_SMIME_CAPABILITIES :: struct {
    cCapability  : DWORD,
    rgCapability : PCRYPT_SMIME_CAPABILITY,
};
PCRYPT_SMIME_CAPABILITIES :: ^CRYPT_SMIME_CAPABILITIES;

CERT_QC_STATEMENT :: struct {
    pszStatementId : LPSTR,
    StatementInfo  : CRYPT_OBJID_BLOB,
};
PCERT_QC_STATEMENT :: ^CERT_QC_STATEMENT;

CERT_QC_STATEMENTS_EXT_INFO :: struct {
    cStatement  : DWORD,
    rgStatement : PCERT_QC_STATEMENT,
};
PCERT_QC_STATEMENTS_EXT_INFO :: ^CERT_QC_STATEMENTS_EXT_INFO;

CRYPT_MASK_GEN_ALGORITHM :: struct {
    pszObjId      : LPSTR,
    HashAlgorithm : CRYPT_ALGORITHM_IDENTIFIER,
};
PCRYPT_MASK_GEN_ALGORITHM :: ^CRYPT_MASK_GEN_ALGORITHM;

CRYPT_RSA_SSA_PSS_PARAMETERS :: struct {
    HashAlgorithm    : CRYPT_ALGORITHM_IDENTIFIER,
    MaskGenAlgorithm : CRYPT_MASK_GEN_ALGORITHM,
    dwSaltLength     : DWORD,
    dwTrailerField   : DWORD,
};
PCRYPT_RSA_SSA_PSS_PARAMETERS :: ^CRYPT_RSA_SSA_PSS_PARAMETERS;

CRYPT_PSOURCE_ALGORITHM :: struct {
    pszObjId           : LPSTR,
    EncodingParameters : CRYPT_DATA_BLOB,
};
PCRYPT_PSOURCE_ALGORITHM :: ^CRYPT_PSOURCE_ALGORITHM;

CRYPT_RSAES_OAEP_PARAMETERS :: struct {
    HashAlgorithm    : CRYPT_ALGORITHM_IDENTIFIER,
    MaskGenAlgorithm : CRYPT_MASK_GEN_ALGORITHM,
    PSourceAlgorithm : CRYPT_PSOURCE_ALGORITHM,
};
PCRYPT_RSAES_OAEP_PARAMETERS :: ^CRYPT_RSAES_OAEP_PARAMETERS;

CMC_TAGGED_ATTRIBUTE :: struct {
    dwBodyPartID : DWORD,
    Attribute    : CRYPT_ATTRIBUTE,
};
PCMC_TAGGED_ATTRIBUTE :: ^CMC_TAGGED_ATTRIBUTE;

CMC_TAGGED_CERT_REQUEST :: struct {
    dwBodyPartID      : DWORD,
    SignedCertRequest : CRYPT_DER_BLOB,
};
PCMC_TAGGED_CERT_REQUEST :: ^CMC_TAGGED_CERT_REQUEST;

CMC_TAGGED_REQUEST :: struct {
    dwTaggedRequestChoice : DWORD,
    u : struct #raw_union {
        pTaggedCertRequest : PCMC_TAGGED_CERT_REQUEST,
    },
};
PCMC_TAGGED_REQUEST :: ^CMC_TAGGED_REQUEST;

CMC_TAGGED_CONTENT_INFO :: struct {
    dwBodyPartID       : DWORD,
    EncodedContentInfo : CRYPT_DER_BLOB,
};
PCMC_TAGGED_CONTENT_INFO :: ^CMC_TAGGED_CONTENT_INFO;

CMC_TAGGED_OTHER_MSG :: struct {
    dwBodyPartID : DWORD,
    pszObjId     : LPSTR,
    Value        : CRYPT_OBJID_BLOB,
};
PCMC_TAGGED_OTHER_MSG :: ^CMC_TAGGED_OTHER_MSG;

CMC_DATA_INFO :: struct {
    cTaggedAttribute    : DWORD,
    rgTaggedAttribute   : PCMC_TAGGED_ATTRIBUTE,
    cTaggedRequest      : DWORD,
    rgTaggedRequest     : PCMC_TAGGED_REQUEST,
    cTaggedContentInfo  : DWORD,
    rgTaggedContentInfo : PCMC_TAGGED_CONTENT_INFO,
    cTaggedOtherMsg     : DWORD,
    rgTaggedOtherMsg    : PCMC_TAGGED_OTHER_MSG,
};
PCMC_DATA_INFO :: ^CMC_DATA_INFO;

CMC_RESPONSE_INFO :: struct {
    cTaggedAttribute    : DWORD,
    rgTaggedAttribute   : PCMC_TAGGED_ATTRIBUTE,
    cTaggedContentInfo  : DWORD,
    rgTaggedContentInfo : PCMC_TAGGED_CONTENT_INFO,
    cTaggedOtherMsg     : DWORD,
    rgTaggedOtherMsg    : PCMC_TAGGED_OTHER_MSG,
};
PCMC_RESPONSE_INFO :: ^CMC_RESPONSE_INFO;

CMC_PEND_INFO :: struct {
    PendToken : CRYPT_DATA_BLOB,
    PendTime  : FILETIME,
};
PCMC_PEND_INFO :: ^CMC_PEND_INFO;

CMC_STATUS_INFO :: struct {
    dwStatus          : DWORD,
    cBodyList         : DWORD,
    rgdwBodyList      : ^DWORD,
    pwszStatusString  : LPWSTR,
    dwOtherInfoChoice : DWORD,
    u : struct #raw_union {
        dwFailInfo : DWORD,
        pPendInfo  : PCMC_PEND_INFO,
    },
};
PCMC_STATUS_INFO :: ^CMC_STATUS_INFO;

CMC_ADD_EXTENSIONS_INFO :: struct {
    dwCmcDataReference : DWORD,
    cCertReference     : DWORD,
    rgdwCertReference  : ^DWORD,
    cExtension         : DWORD,
    rgExtension        : PCERT_EXTENSION,
};
PCMC_ADD_EXTENSIONS_INFO :: ^CMC_ADD_EXTENSIONS_INFO;

CMC_ADD_ATTRIBUTES_INFO :: struct {
    dwCmcDataReference : DWORD,
    cCertReference     : DWORD,
    rgdwCertReference  : ^DWORD,
    cAttribute         : DWORD,
    rgAttribute        : PCRYPT_ATTRIBUTE,
};
PCMC_ADD_ATTRIBUTES_INFO :: ^CMC_ADD_ATTRIBUTES_INFO;

CERT_TEMPLATE_EXT :: struct {
    pszObjId       : LPSTR,
    dwMajorVersion : DWORD,
    fMinorVersion  : BOOL,
    dwMinorVersion : DWORD,
};
PCERT_TEMPLATE_EXT :: ^CERT_TEMPLATE_EXT;

CERT_HASHED_URL :: struct {
    HashAlgorithm : CRYPT_ALGORITHM_IDENTIFIER,
    Hash          : CRYPT_HASH_BLOB,
    pwszUrl       : LPWSTR,
};
PCERT_HASHED_URL :: ^CERT_HASHED_URL;

CERT_LOGOTYPE_DETAILS :: struct {
    pwszMimeType : LPWSTR,
    cHashedUrl   : DWORD,
    rgHashedUrl  : PCERT_HASHED_URL,
};
PCERT_LOGOTYPE_DETAILS :: ^CERT_LOGOTYPE_DETAILS;

CERT_LOGOTYPE_REFERENCE :: struct {
    cHashedUrl  : DWORD,
    rgHashedUrl : PCERT_HASHED_URL,
};
PCERT_LOGOTYPE_REFERENCE :: ^CERT_LOGOTYPE_REFERENCE;

CERT_LOGOTYPE_IMAGE_INFO :: struct {
    dwLogotypeImageInfoChoice       : DWORD,
    dwFileSize                      : DWORD,
    dwXSize                         : DWORD,
    dwYSize                         : DWORD,
    dwLogotypeImageResolutionChoice : DWORD,
    u : struct #raw_union {
        dwNumBits   : DWORD,
        dwTableSize : DWORD,
    },
    pwszLanguage                    : LPWSTR,
};
PCERT_LOGOTYPE_IMAGE_INFO :: ^CERT_LOGOTYPE_IMAGE_INFO;

CERT_LOGOTYPE_IMAGE :: struct {
    LogotypeDetails    : CERT_LOGOTYPE_DETAILS,
    pLogotypeImageInfo : PCERT_LOGOTYPE_IMAGE_INFO,
};
PCERT_LOGOTYPE_IMAGE :: ^CERT_LOGOTYPE_IMAGE;

CERT_LOGOTYPE_AUDIO_INFO :: struct {
    dwFileSize   : DWORD,
    dwPlayTime   : DWORD,
    dwChannels   : DWORD,
    dwSampleRate : DWORD,
    pwszLanguage : LPWSTR,
};
PCERT_LOGOTYPE_AUDIO_INFO :: ^CERT_LOGOTYPE_AUDIO_INFO;

CERT_LOGOTYPE_AUDIO :: struct {
    LogotypeDetails    : CERT_LOGOTYPE_DETAILS,
    pLogotypeAudioInfo : PCERT_LOGOTYPE_AUDIO_INFO,
};
PCERT_LOGOTYPE_AUDIO :: ^CERT_LOGOTYPE_AUDIO;

CERT_LOGOTYPE_DATA :: struct {
    cLogotypeImage  : DWORD,
    rgLogotypeImage : PCERT_LOGOTYPE_IMAGE,
    cLogotypeAudio  : DWORD,
    rgLogotypeAudio : PCERT_LOGOTYPE_AUDIO,
};
PCERT_LOGOTYPE_DATA :: ^CERT_LOGOTYPE_DATA;

CERT_LOGOTYPE_INFO :: struct {
    dwLogotypeInfoChoice : DWORD,
    u : struct #raw_union {
        pLogotypeDirectInfo   : PCERT_LOGOTYPE_DATA,
        pLogotypeIndirectInfo : PCERT_LOGOTYPE_REFERENCE,
    },
};
PCERT_LOGOTYPE_INFO :: ^CERT_LOGOTYPE_INFO;

CERT_OTHER_LOGOTYPE_INFO :: struct {
    pszObjId     : LPSTR,
    LogotypeInfo : CERT_LOGOTYPE_INFO,
};
PCERT_OTHER_LOGOTYPE_INFO :: ^CERT_OTHER_LOGOTYPE_INFO;

CERT_LOGOTYPE_EXT_INFO :: struct {
    cCommunityLogo  : DWORD,
    rgCommunityLogo : PCERT_LOGOTYPE_INFO,
    pIssuerLogo     : PCERT_LOGOTYPE_INFO,
    pSubjectLogo    : PCERT_LOGOTYPE_INFO,
    cOtherLogo      : DWORD,
    rgOtherLogo     : PCERT_OTHER_LOGOTYPE_INFO,
};
PCERT_LOGOTYPE_EXT_INFO :: ^CERT_LOGOTYPE_EXT_INFO;

CERT_BIOMETRIC_DATA :: struct {
    dwTypeOfBiometricDataChoice : DWORD,
    u : struct #raw_union {
        dwPredefined : DWORD,
        pszObjId     : LPSTR,
    },
    HashedUrl                   : CERT_HASHED_URL,
};
PCERT_BIOMETRIC_DATA :: ^CERT_BIOMETRIC_DATA;

CERT_BIOMETRIC_EXT_INFO :: struct {
    cBiometricData  : DWORD,
    rgBiometricData : PCERT_BIOMETRIC_DATA,
};
PCERT_BIOMETRIC_EXT_INFO :: ^CERT_BIOMETRIC_EXT_INFO;

OCSP_SIGNATURE_INFO :: struct {
    SignatureAlgorithm : CRYPT_ALGORITHM_IDENTIFIER,
    Signature          : CRYPT_BIT_BLOB,
    cCertEncoded       : DWORD,
    rgCertEncoded      : PCERT_BLOB,
};
POCSP_SIGNATURE_INFO :: ^OCSP_SIGNATURE_INFO;

OCSP_SIGNED_REQUEST_INFO :: struct {
    ToBeSigned             : CRYPT_DER_BLOB,
    pOptionalSignatureInfo : POCSP_SIGNATURE_INFO,
};
POCSP_SIGNED_REQUEST_INFO :: ^OCSP_SIGNED_REQUEST_INFO;

OCSP_CERT_ID :: struct {
    HashAlgorithm  : CRYPT_ALGORITHM_IDENTIFIER,
    IssuerNameHash : CRYPT_HASH_BLOB,
    IssuerKeyHash  : CRYPT_HASH_BLOB,
    SerialNumber   : CRYPT_INTEGER_BLOB,
};
POCSP_CERT_ID :: ^OCSP_CERT_ID;

OCSP_REQUEST_ENTRY :: struct {
    CertId      : OCSP_CERT_ID,
    cExtension  : DWORD,
    rgExtension : PCERT_EXTENSION,
};
POCSP_REQUEST_ENTRY :: ^OCSP_REQUEST_ENTRY;

OCSP_REQUEST_INFO :: struct {
    dwVersion      : DWORD,
    pRequestorName : PCERT_ALT_NAME_ENTRY,
    cRequestEntry  : DWORD,
    rgRequestEntry : POCSP_REQUEST_ENTRY,
    cExtension     : DWORD,
    rgExtension    : PCERT_EXTENSION,
};
POCSP_REQUEST_INFO :: ^OCSP_REQUEST_INFO;

OCSP_RESPONSE_INFO :: struct {
    dwStatus : DWORD,
    pszObjId : LPSTR,
    Value    : CRYPT_OBJID_BLOB,
};
POCSP_RESPONSE_INFO :: ^OCSP_RESPONSE_INFO;

OCSP_BASIC_SIGNED_RESPONSE_INFO :: struct {
    ToBeSigned    : CRYPT_DER_BLOB,
    SignatureInfo : OCSP_SIGNATURE_INFO,
};
POCSP_BASIC_SIGNED_RESPONSE_INFO :: ^OCSP_BASIC_SIGNED_RESPONSE_INFO;

OCSP_BASIC_REVOKED_INFO :: struct {
    RevocationDate  : FILETIME,
    dwCrlReasonCode : DWORD,
};
POCSP_BASIC_REVOKED_INFO :: ^OCSP_BASIC_REVOKED_INFO;

OCSP_BASIC_RESPONSE_ENTRY :: struct {
    CertId       : OCSP_CERT_ID,
    dwCertStatus : DWORD,
    u : struct #raw_union {
        pRevokedInfo : POCSP_BASIC_REVOKED_INFO,
    },
    ThisUpdate   : FILETIME,
    NextUpdate   : FILETIME,
    cExtension   : DWORD,
    rgExtension  : PCERT_EXTENSION,
};
POCSP_BASIC_RESPONSE_ENTRY :: ^OCSP_BASIC_RESPONSE_ENTRY;

OCSP_BASIC_RESPONSE_INFO :: struct {
    dwVersion           : DWORD,
    dwResponderIdChoice : DWORD,
    u : struct #raw_union {
        ByNameResponderId : CERT_NAME_BLOB,
        ByKeyResponderId  : CRYPT_HASH_BLOB,
    },
    ProducedAt          : FILETIME,
    cResponseEntry      : DWORD,
    rgResponseEntry     : POCSP_BASIC_RESPONSE_ENTRY,
    cExtension          : DWORD,
    rgExtension         : PCERT_EXTENSION,
};
POCSP_BASIC_RESPONSE_INFO :: ^OCSP_BASIC_RESPONSE_INFO;

CERT_SUPPORTED_ALGORITHM_INFO :: struct {
    Algorithm            : CRYPT_ALGORITHM_IDENTIFIER,
    IntendedKeyUsage     : CRYPT_BIT_BLOB,
    IntendedCertPolicies : CERT_POLICIES_INFO,
};
PCERT_SUPPORTED_ALGORITHM_INFO :: ^CERT_SUPPORTED_ALGORITHM_INFO;

CERT_TPM_SPECIFICATION_INFO :: struct {
    pwszFamily : LPWSTR,
    dwLevel    : DWORD,
    dwRevision : DWORD,
};
PCERT_TPM_SPECIFICATION_INFO :: ^CERT_TPM_SPECIFICATION_INFO;

HCRYPTOIDFUNCSET :: rawptr;

HCRYPTOIDFUNCADDR :: rawptr;

CRYPT_OID_FUNC_ENTRY :: struct {
    pszOID     : LPCSTR,
    pvFuncAddr : rawptr,
};
PCRYPT_OID_FUNC_ENTRY :: ^CRYPT_OID_FUNC_ENTRY;

PFN_CRYPT_ENUM_OID_FUNC :: (proc "stdcall" (dwEncodingType : DWORD, pszFuncName : LPCSTR, pszOID : LPCSTR, cValue : DWORD, rgdwValueType : []DWORD, rgpwszValueName : []LPCWSTR, rgpbValueData : []^BYTE, rgcbValueData : []DWORD, pvArg : rawptr) -> BOOL);

CRYPT_OID_INFO :: struct {
    cbSize    : DWORD,
    pszOID    : LPCSTR,
    pwszName  : LPCWSTR,
    dwGroupId : DWORD,
    u : struct #raw_union {
        dwValue  : DWORD,
        Algid    : ALG_ID,
        dwLength : DWORD,
    },
    ExtraInfo : CRYPT_DATA_BLOB,
};
PCRYPT_OID_INFO :: ^CRYPT_OID_INFO;

CCRYPT_OID_INFO :: CRYPT_OID_INFO;
PCCRYPT_OID_INFO :: ^CRYPT_OID_INFO;

PFN_CRYPT_ENUM_OID_INFO :: (proc "stdcall" (pInfo : PCCRYPT_OID_INFO, pvArg : rawptr) -> BOOL);

CERT_STRONG_SIGN_SERIALIZED_INFO :: struct {
    dwFlags                    : DWORD,
    pwszCNGSignHashAlgids      : LPWSTR,
    pwszCNGPubKeyMinBitLengths : LPWSTR,
};
PCERT_STRONG_SIGN_SERIALIZED_INFO :: ^CERT_STRONG_SIGN_SERIALIZED_INFO;

CERT_STRONG_SIGN_PARA :: struct {
    cbSize       : DWORD,
    dwInfoChoice : DWORD,
    u : struct #raw_union {
        pvInfo          : rawptr,
        pSerializedInfo : PCERT_STRONG_SIGN_SERIALIZED_INFO,
        pszOID          : LPSTR,
    },
};
PCERT_STRONG_SIGN_PARA :: ^CERT_STRONG_SIGN_PARA;

PCCERT_STRONG_SIGN_PARA :: ^CERT_STRONG_SIGN_PARA;

HCRYPTMSG :: rawptr;

CERT_ISSUER_SERIAL_NUMBER :: struct {
    Issuer       : CERT_NAME_BLOB,
    SerialNumber : CRYPT_INTEGER_BLOB,
};
PCERT_ISSUER_SERIAL_NUMBER :: ^CERT_ISSUER_SERIAL_NUMBER;

CERT_ID :: struct {
    dwIdChoice : DWORD,
    u : struct #raw_union {
        IssuerSerialNumber : CERT_ISSUER_SERIAL_NUMBER,
        KeyId              : CRYPT_HASH_BLOB,
        HashId             : CRYPT_HASH_BLOB,
    },
};
PCERT_ID :: ^CERT_ID;

CMSG_SIGNER_ENCODE_INFO :: struct {
    cbSize        : DWORD,
    pCertInfo     : PCERT_INFO,
    u : struct #raw_union {
        hCryptProv : HCRYPTPROV,
        hNCryptKey : NCRYPT_KEY_HANDLE,
    },
    dwKeySpec     : DWORD,
    HashAlgorithm : CRYPT_ALGORITHM_IDENTIFIER,
    pvHashAuxInfo : rawptr,
    cAuthAttr     : DWORD,
    rgAuthAttr    : PCRYPT_ATTRIBUTE,
    cUnauthAttr   : DWORD,
    rgUnauthAttr  : PCRYPT_ATTRIBUTE,
};
PCMSG_SIGNER_ENCODE_INFO :: ^CMSG_SIGNER_ENCODE_INFO;

CMSG_SIGNED_ENCODE_INFO :: struct {
    cbSize        : DWORD,
    cSigners      : DWORD,
    rgSigners     : PCMSG_SIGNER_ENCODE_INFO,
    cCertEncoded  : DWORD,
    rgCertEncoded : PCERT_BLOB,
    cCrlEncoded   : DWORD,
    rgCrlEncoded  : PCRL_BLOB,
};
PCMSG_SIGNED_ENCODE_INFO :: ^CMSG_SIGNED_ENCODE_INFO;

PCMSG_RECIPIENT_ENCODE_INFO :: ^CMSG_RECIPIENT_ENCODE_INFO;

CMSG_ENVELOPED_ENCODE_INFO :: struct {
    cbSize                     : DWORD,
    hCryptProv                 : HCRYPTPROV_LEGACY,
    ContentEncryptionAlgorithm : CRYPT_ALGORITHM_IDENTIFIER,
    pvEncryptionAuxInfo        : rawptr,
    cRecipients                : DWORD,
    rgpRecipients              : ^PCERT_INFO,
};
PCMSG_ENVELOPED_ENCODE_INFO :: ^CMSG_ENVELOPED_ENCODE_INFO;

CMSG_KEY_TRANS_RECIPIENT_ENCODE_INFO :: struct {
    cbSize                 : DWORD,
    KeyEncryptionAlgorithm : CRYPT_ALGORITHM_IDENTIFIER,
    pvKeyEncryptionAuxInfo : rawptr,
    hCryptProv             : HCRYPTPROV_LEGACY,
    RecipientPublicKey     : CRYPT_BIT_BLOB,
    RecipientId            : CERT_ID,
};
PCMSG_KEY_TRANS_RECIPIENT_ENCODE_INFO :: ^CMSG_KEY_TRANS_RECIPIENT_ENCODE_INFO;

CMSG_RECIPIENT_ENCRYPTED_KEY_ENCODE_INFO :: struct {
    cbSize             : DWORD,
    RecipientPublicKey : CRYPT_BIT_BLOB,
    RecipientId        : CERT_ID,
    Date               : FILETIME,
    pOtherAttr         : PCRYPT_ATTRIBUTE_TYPE_VALUE,
};
PCMSG_RECIPIENT_ENCRYPTED_KEY_ENCODE_INFO :: ^CMSG_RECIPIENT_ENCRYPTED_KEY_ENCODE_INFO;

CMSG_KEY_AGREE_RECIPIENT_ENCODE_INFO :: struct {
    cbSize                    : DWORD,
    KeyEncryptionAlgorithm    : CRYPT_ALGORITHM_IDENTIFIER,
    pvKeyEncryptionAuxInfo    : rawptr,
    KeyWrapAlgorithm          : CRYPT_ALGORITHM_IDENTIFIER,
    pvKeyWrapAuxInfo          : rawptr,
    hCryptProv                : HCRYPTPROV_LEGACY,
    dwKeySpec                 : DWORD,
    dwKeyChoice               : DWORD,
    u : struct #raw_union {
        pEphemeralAlgorithm : PCRYPT_ALGORITHM_IDENTIFIER,
        pSenderId           : PCERT_ID,
    },
    UserKeyingMaterial        : CRYPT_DATA_BLOB,
    cRecipientEncryptedKeys   : DWORD,
    rgpRecipientEncryptedKeys : ^PCMSG_RECIPIENT_ENCRYPTED_KEY_ENCODE_INFO,
};
PCMSG_KEY_AGREE_RECIPIENT_ENCODE_INFO :: ^CMSG_KEY_AGREE_RECIPIENT_ENCODE_INFO;

CMSG_MAIL_LIST_RECIPIENT_ENCODE_INFO :: struct {
    cbSize                 : DWORD,
    KeyEncryptionAlgorithm : CRYPT_ALGORITHM_IDENTIFIER,
    pvKeyEncryptionAuxInfo : rawptr,
    hCryptProv             : HCRYPTPROV,
    dwKeyChoice            : DWORD,
    u : struct #raw_union {
        hKeyEncryptionKey  : HCRYPTKEY,
        pvKeyEncryptionKey : rawptr,
    },
    KeyId                  : CRYPT_DATA_BLOB,
    Date                   : FILETIME,
    pOtherAttr             : PCRYPT_ATTRIBUTE_TYPE_VALUE,
};
PCMSG_MAIL_LIST_RECIPIENT_ENCODE_INFO :: ^CMSG_MAIL_LIST_RECIPIENT_ENCODE_INFO;

CMSG_RECIPIENT_ENCODE_INFO :: struct {
    dwRecipientChoice : DWORD,
    u : struct #raw_union {
        pKeyTrans : PCMSG_KEY_TRANS_RECIPIENT_ENCODE_INFO,
        pKeyAgree : PCMSG_KEY_AGREE_RECIPIENT_ENCODE_INFO,
        pMailList : PCMSG_MAIL_LIST_RECIPIENT_ENCODE_INFO,
    },
};

CMSG_RC2_AUX_INFO :: struct {
    cbSize   : DWORD,
    dwBitLen : DWORD,
};
PCMSG_RC2_AUX_INFO :: ^CMSG_RC2_AUX_INFO;

CMSG_SP3_COMPATIBLE_AUX_INFO :: struct {
    cbSize  : DWORD,
    dwFlags : DWORD,
};
PCMSG_SP3_COMPATIBLE_AUX_INFO :: ^CMSG_SP3_COMPATIBLE_AUX_INFO;

CMSG_RC4_AUX_INFO :: struct {
    cbSize   : DWORD,
    dwBitLen : DWORD,
};
PCMSG_RC4_AUX_INFO :: ^CMSG_RC4_AUX_INFO;

CMSG_SIGNED_AND_ENVELOPED_ENCODE_INFO :: struct {
    cbSize        : DWORD,
    SignedInfo    : CMSG_SIGNED_ENCODE_INFO,
    EnvelopedInfo : CMSG_ENVELOPED_ENCODE_INFO,
};
PCMSG_SIGNED_AND_ENVELOPED_ENCODE_INFO :: ^CMSG_SIGNED_AND_ENVELOPED_ENCODE_INFO;

CMSG_HASHED_ENCODE_INFO :: struct {
    cbSize        : DWORD,
    hCryptProv    : HCRYPTPROV_LEGACY,
    HashAlgorithm : CRYPT_ALGORITHM_IDENTIFIER,
    pvHashAuxInfo : rawptr,
};
PCMSG_HASHED_ENCODE_INFO :: ^CMSG_HASHED_ENCODE_INFO;

CMSG_ENCRYPTED_ENCODE_INFO :: struct {
    cbSize                     : DWORD,
    ContentEncryptionAlgorithm : CRYPT_ALGORITHM_IDENTIFIER,
    pvEncryptionAuxInfo        : rawptr,
};
PCMSG_ENCRYPTED_ENCODE_INFO :: ^CMSG_ENCRYPTED_ENCODE_INFO;

PFN_CMSG_STREAM_OUTPUT :: (proc "stdcall" (pvArg : rawptr, pbData : ^BYTE, cbData : DWORD, fFinal : BOOL) -> BOOL);

CMSG_STREAM_INFO :: struct {
    cbContent       : DWORD,
    pfnStreamOutput : PFN_CMSG_STREAM_OUTPUT,
    pvArg           : rawptr,
};
PCMSG_STREAM_INFO :: ^CMSG_STREAM_INFO;

CMSG_SIGNER_INFO :: struct {
    dwVersion               : DWORD,
    Issuer                  : CERT_NAME_BLOB,
    SerialNumber            : CRYPT_INTEGER_BLOB,
    HashAlgorithm           : CRYPT_ALGORITHM_IDENTIFIER,
    HashEncryptionAlgorithm : CRYPT_ALGORITHM_IDENTIFIER,
    EncryptedHash           : CRYPT_DATA_BLOB,
    AuthAttrs               : CRYPT_ATTRIBUTES,
    UnauthAttrs             : CRYPT_ATTRIBUTES,
};
PCMSG_SIGNER_INFO :: ^CMSG_SIGNER_INFO;

CMSG_CMS_SIGNER_INFO :: struct {
    dwVersion               : DWORD,
    SignerId                : CERT_ID,
    HashAlgorithm           : CRYPT_ALGORITHM_IDENTIFIER,
    HashEncryptionAlgorithm : CRYPT_ALGORITHM_IDENTIFIER,
    EncryptedHash           : CRYPT_DATA_BLOB,
    AuthAttrs               : CRYPT_ATTRIBUTES,
    UnauthAttrs             : CRYPT_ATTRIBUTES,
};
PCMSG_CMS_SIGNER_INFO :: ^CMSG_CMS_SIGNER_INFO;

CMSG_ATTR :: CRYPT_ATTRIBUTES;

PCMSG_ATTR :: ^CRYPT_ATTRIBUTES;

CMSG_KEY_TRANS_RECIPIENT_INFO :: struct {
    dwVersion              : DWORD,
    RecipientId            : CERT_ID,
    KeyEncryptionAlgorithm : CRYPT_ALGORITHM_IDENTIFIER,
    EncryptedKey           : CRYPT_DATA_BLOB,
};
PCMSG_KEY_TRANS_RECIPIENT_INFO :: ^CMSG_KEY_TRANS_RECIPIENT_INFO;

CMSG_RECIPIENT_ENCRYPTED_KEY_INFO :: struct {
    RecipientId  : CERT_ID,
    EncryptedKey : CRYPT_DATA_BLOB,
    Date         : FILETIME,
    pOtherAttr   : PCRYPT_ATTRIBUTE_TYPE_VALUE,
};
PCMSG_RECIPIENT_ENCRYPTED_KEY_INFO :: ^CMSG_RECIPIENT_ENCRYPTED_KEY_INFO;

CMSG_KEY_AGREE_RECIPIENT_INFO :: struct {
    dwVersion                 : DWORD,
    dwOriginatorChoice        : DWORD,
    u : struct #raw_union {
        OriginatorCertId        : CERT_ID,
        OriginatorPublicKeyInfo : CERT_PUBLIC_KEY_INFO,
    },
    UserKeyingMaterial        : CRYPT_DATA_BLOB,
    KeyEncryptionAlgorithm    : CRYPT_ALGORITHM_IDENTIFIER,
    cRecipientEncryptedKeys   : DWORD,
    rgpRecipientEncryptedKeys : ^PCMSG_RECIPIENT_ENCRYPTED_KEY_INFO,
};
PCMSG_KEY_AGREE_RECIPIENT_INFO :: ^CMSG_KEY_AGREE_RECIPIENT_INFO;

CMSG_MAIL_LIST_RECIPIENT_INFO :: struct {
    dwVersion              : DWORD,
    KeyId                  : CRYPT_DATA_BLOB,
    KeyEncryptionAlgorithm : CRYPT_ALGORITHM_IDENTIFIER,
    EncryptedKey           : CRYPT_DATA_BLOB,
    Date                   : FILETIME,
    pOtherAttr             : PCRYPT_ATTRIBUTE_TYPE_VALUE,
};
PCMSG_MAIL_LIST_RECIPIENT_INFO :: ^CMSG_MAIL_LIST_RECIPIENT_INFO;

CMSG_CMS_RECIPIENT_INFO :: struct {
    dwRecipientChoice : DWORD,
    u : struct #raw_union {
        pKeyTrans : PCMSG_KEY_TRANS_RECIPIENT_INFO,
        pKeyAgree : PCMSG_KEY_AGREE_RECIPIENT_INFO,
        pMailList : PCMSG_MAIL_LIST_RECIPIENT_INFO,
    },
};
PCMSG_CMS_RECIPIENT_INFO :: ^CMSG_CMS_RECIPIENT_INFO;

CMSG_CTRL_VERIFY_SIGNATURE_EX_PARA :: struct {
    cbSize        : DWORD,
    hCryptProv    : HCRYPTPROV_LEGACY,
    dwSignerIndex : DWORD,
    dwSignerType  : DWORD,
    pvSigner      : rawptr,
};
PCMSG_CTRL_VERIFY_SIGNATURE_EX_PARA :: ^CMSG_CTRL_VERIFY_SIGNATURE_EX_PARA;

CMSG_CTRL_DECRYPT_PARA :: struct {
    cbSize           : DWORD,
    u : struct #raw_union {
        hCryptProv : HCRYPTPROV,
        hNCryptKey : NCRYPT_KEY_HANDLE,
    },
    dwKeySpec        : DWORD,
    dwRecipientIndex : DWORD,
};
PCMSG_CTRL_DECRYPT_PARA :: ^CMSG_CTRL_DECRYPT_PARA;

CMSG_CTRL_KEY_TRANS_DECRYPT_PARA :: struct {
    cbSize           : DWORD,
    u : struct #raw_union {
        hCryptProv : HCRYPTPROV,
        hNCryptKey : NCRYPT_KEY_HANDLE,
    },
    dwKeySpec        : DWORD,
    pKeyTrans        : PCMSG_KEY_TRANS_RECIPIENT_INFO,
    dwRecipientIndex : DWORD,
};
PCMSG_CTRL_KEY_TRANS_DECRYPT_PARA :: ^CMSG_CTRL_KEY_TRANS_DECRYPT_PARA;

CMSG_CTRL_KEY_AGREE_DECRYPT_PARA :: struct {
    cbSize                       : DWORD,
    u : struct #raw_union {
        hCryptProv : HCRYPTPROV,
        hNCryptKey : NCRYPT_KEY_HANDLE,
    },
    dwKeySpec                    : DWORD,
    pKeyAgree                    : PCMSG_KEY_AGREE_RECIPIENT_INFO,
    dwRecipientIndex             : DWORD,
    dwRecipientEncryptedKeyIndex : DWORD,
    OriginatorPublicKey          : CRYPT_BIT_BLOB,
};
PCMSG_CTRL_KEY_AGREE_DECRYPT_PARA :: ^CMSG_CTRL_KEY_AGREE_DECRYPT_PARA;

CMSG_CTRL_MAIL_LIST_DECRYPT_PARA :: struct {
    cbSize           : DWORD,
    hCryptProv       : HCRYPTPROV,
    pMailList        : PCMSG_MAIL_LIST_RECIPIENT_INFO,
    dwRecipientIndex : DWORD,
    dwKeyChoice      : DWORD,
    u : struct #raw_union {
        hKeyEncryptionKey  : HCRYPTKEY,
        pvKeyEncryptionKey : rawptr,
    },
};
PCMSG_CTRL_MAIL_LIST_DECRYPT_PARA :: ^CMSG_CTRL_MAIL_LIST_DECRYPT_PARA;

CMSG_CTRL_ADD_SIGNER_UNAUTH_ATTR_PARA :: struct {
    cbSize        : DWORD,
    dwSignerIndex : DWORD,
    blob          : CRYPT_DATA_BLOB,
};
PCMSG_CTRL_ADD_SIGNER_UNAUTH_ATTR_PARA :: ^CMSG_CTRL_ADD_SIGNER_UNAUTH_ATTR_PARA;

CMSG_CTRL_DEL_SIGNER_UNAUTH_ATTR_PARA :: struct {
    cbSize            : DWORD,
    dwSignerIndex     : DWORD,
    dwUnauthAttrIndex : DWORD,
};
PCMSG_CTRL_DEL_SIGNER_UNAUTH_ATTR_PARA :: ^CMSG_CTRL_DEL_SIGNER_UNAUTH_ATTR_PARA;

PFN_CMSG_ALLOC :: (proc "stdcall" (cb : _c.size_t) -> rawptr);

PFN_CMSG_FREE :: proc "stdcall" (pv : rawptr);

PFN_CMSG_GEN_ENCRYPT_KEY :: (proc "stdcall" (phCryptProv : ^HCRYPTPROV, paiEncrypt : PCRYPT_ALGORITHM_IDENTIFIER, pvEncryptAuxInfo : PVOID, pPublicKeyInfo : PCERT_PUBLIC_KEY_INFO, pfnAlloc : PFN_CMSG_ALLOC, phEncryptKey : ^HCRYPTKEY, ppbEncryptParameters : ^PBYTE, pcbEncryptParameters : PDWORD) -> BOOL);

PFN_CMSG_EXPORT_ENCRYPT_KEY :: (proc "stdcall" (hCryptProv : HCRYPTPROV, hEncryptKey : HCRYPTKEY, pPublicKeyInfo : PCERT_PUBLIC_KEY_INFO, pbData : PBYTE, pcbData : PDWORD) -> BOOL);

PFN_CMSG_IMPORT_ENCRYPT_KEY :: (proc "stdcall" (hCryptProv : HCRYPTPROV, dwKeySpec : DWORD, paiEncrypt : PCRYPT_ALGORITHM_IDENTIFIER, paiPubKey : PCRYPT_ALGORITHM_IDENTIFIER, pbEncodedKey : PBYTE, cbEncodedKey : DWORD, phEncryptKey : ^HCRYPTKEY) -> BOOL);

CMSG_CONTENT_ENCRYPT_INFO :: struct {
    cbSize                       : DWORD,
    hCryptProv                   : HCRYPTPROV_LEGACY,
    ContentEncryptionAlgorithm   : CRYPT_ALGORITHM_IDENTIFIER,
    pvEncryptionAuxInfo          : rawptr,
    cRecipients                  : DWORD,
    rgCmsRecipients              : PCMSG_RECIPIENT_ENCODE_INFO,
    pfnAlloc                     : PFN_CMSG_ALLOC,
    pfnFree                      : PFN_CMSG_FREE,
    dwEncryptFlags               : DWORD,
    u : struct #raw_union {
        hContentEncryptKey    : HCRYPTKEY,
        hCNGContentEncryptKey : BCRYPT_KEY_HANDLE,
    },
    dwFlags                      : DWORD,
    fCNG                         : BOOL,
    pbCNGContentEncryptKeyObject : ^BYTE,
    pbContentEncryptKey          : ^BYTE,
    cbContentEncryptKey          : DWORD,
};
PCMSG_CONTENT_ENCRYPT_INFO :: ^CMSG_CONTENT_ENCRYPT_INFO;

PFN_CMSG_GEN_CONTENT_ENCRYPT_KEY :: (proc "stdcall" (pContentEncryptInfo : PCMSG_CONTENT_ENCRYPT_INFO, dwFlags : DWORD, pvReserved : rawptr) -> BOOL);

CMSG_KEY_TRANS_ENCRYPT_INFO :: struct {
    cbSize                 : DWORD,
    dwRecipientIndex       : DWORD,
    KeyEncryptionAlgorithm : CRYPT_ALGORITHM_IDENTIFIER,
    EncryptedKey           : CRYPT_DATA_BLOB,
    dwFlags                : DWORD,
};
PCMSG_KEY_TRANS_ENCRYPT_INFO :: ^CMSG_KEY_TRANS_ENCRYPT_INFO;

PFN_CMSG_EXPORT_KEY_TRANS :: (proc "stdcall" (pContentEncryptInfo : PCMSG_CONTENT_ENCRYPT_INFO, pKeyTransEncodeInfo : PCMSG_KEY_TRANS_RECIPIENT_ENCODE_INFO, pKeyTransEncryptInfo : PCMSG_KEY_TRANS_ENCRYPT_INFO, dwFlags : DWORD, pvReserved : rawptr) -> BOOL);

CMSG_KEY_AGREE_KEY_ENCRYPT_INFO :: struct {
    cbSize       : DWORD,
    EncryptedKey : CRYPT_DATA_BLOB,
};
PCMSG_KEY_AGREE_KEY_ENCRYPT_INFO :: ^CMSG_KEY_AGREE_KEY_ENCRYPT_INFO;

CMSG_KEY_AGREE_ENCRYPT_INFO :: struct {
    cbSize                    : DWORD,
    dwRecipientIndex          : DWORD,
    KeyEncryptionAlgorithm    : CRYPT_ALGORITHM_IDENTIFIER,
    UserKeyingMaterial        : CRYPT_DATA_BLOB,
    dwOriginatorChoice        : DWORD,
    u : struct #raw_union {
        OriginatorCertId        : CERT_ID,
        OriginatorPublicKeyInfo : CERT_PUBLIC_KEY_INFO,
    },
    cKeyAgreeKeyEncryptInfo   : DWORD,
    rgpKeyAgreeKeyEncryptInfo : ^PCMSG_KEY_AGREE_KEY_ENCRYPT_INFO,
    dwFlags                   : DWORD,
};
PCMSG_KEY_AGREE_ENCRYPT_INFO :: ^CMSG_KEY_AGREE_ENCRYPT_INFO;

PFN_CMSG_EXPORT_KEY_AGREE :: (proc "stdcall" (pContentEncryptInfo : PCMSG_CONTENT_ENCRYPT_INFO, pKeyAgreeEncodeInfo : PCMSG_KEY_AGREE_RECIPIENT_ENCODE_INFO, pKeyAgreeEncryptInfo : PCMSG_KEY_AGREE_ENCRYPT_INFO, dwFlags : DWORD, pvReserved : rawptr) -> BOOL);

CMSG_MAIL_LIST_ENCRYPT_INFO :: struct {
    cbSize                 : DWORD,
    dwRecipientIndex       : DWORD,
    KeyEncryptionAlgorithm : CRYPT_ALGORITHM_IDENTIFIER,
    EncryptedKey           : CRYPT_DATA_BLOB,
    dwFlags                : DWORD,
};
PCMSG_MAIL_LIST_ENCRYPT_INFO :: ^CMSG_MAIL_LIST_ENCRYPT_INFO;

PFN_CMSG_EXPORT_MAIL_LIST :: (proc "stdcall" (pContentEncryptInfo : PCMSG_CONTENT_ENCRYPT_INFO, pMailListEncodeInfo : PCMSG_MAIL_LIST_RECIPIENT_ENCODE_INFO, pMailListEncryptInfo : PCMSG_MAIL_LIST_ENCRYPT_INFO, dwFlags : DWORD, pvReserved : rawptr) -> BOOL);

PFN_CMSG_IMPORT_KEY_TRANS :: (proc "stdcall" (pContentEncryptionAlgorithm : PCRYPT_ALGORITHM_IDENTIFIER, pKeyTransDecryptPara : PCMSG_CTRL_KEY_TRANS_DECRYPT_PARA, dwFlags : DWORD, pvReserved : rawptr, phContentEncryptKey : ^HCRYPTKEY) -> BOOL);

PFN_CMSG_IMPORT_KEY_AGREE :: (proc "stdcall" (pContentEncryptionAlgorithm : PCRYPT_ALGORITHM_IDENTIFIER, pKeyAgreeDecryptPara : PCMSG_CTRL_KEY_AGREE_DECRYPT_PARA, dwFlags : DWORD, pvReserved : rawptr, phContentEncryptKey : ^HCRYPTKEY) -> BOOL);

PFN_CMSG_IMPORT_MAIL_LIST :: (proc "stdcall" (pContentEncryptionAlgorithm : PCRYPT_ALGORITHM_IDENTIFIER, pMailListDecryptPara : PCMSG_CTRL_MAIL_LIST_DECRYPT_PARA, dwFlags : DWORD, pvReserved : rawptr, phContentEncryptKey : ^HCRYPTKEY) -> BOOL);

CMSG_CNG_CONTENT_DECRYPT_INFO :: struct {
    cbSize                       : DWORD,
    ContentEncryptionAlgorithm   : CRYPT_ALGORITHM_IDENTIFIER,
    pfnAlloc                     : PFN_CMSG_ALLOC,
    pfnFree                      : PFN_CMSG_FREE,
    hNCryptKey                   : NCRYPT_KEY_HANDLE,
    pbContentEncryptKey          : ^BYTE,
    cbContentEncryptKey          : DWORD,
    hCNGContentEncryptKey        : BCRYPT_KEY_HANDLE,
    pbCNGContentEncryptKeyObject : ^BYTE,
};
PCMSG_CNG_CONTENT_DECRYPT_INFO :: ^CMSG_CNG_CONTENT_DECRYPT_INFO;

PFN_CMSG_CNG_IMPORT_KEY_TRANS :: (proc "stdcall" (pCNGContentDecryptInfo : PCMSG_CNG_CONTENT_DECRYPT_INFO, pKeyTransDecryptPara : PCMSG_CTRL_KEY_TRANS_DECRYPT_PARA, dwFlags : DWORD, pvReserved : rawptr) -> BOOL);

PFN_CMSG_CNG_IMPORT_KEY_AGREE :: (proc "stdcall" (pCNGContentDecryptInfo : PCMSG_CNG_CONTENT_DECRYPT_INFO, pKeyAgreeDecryptPara : PCMSG_CTRL_KEY_AGREE_DECRYPT_PARA, dwFlags : DWORD, pvReserved : rawptr) -> BOOL);

PFN_CMSG_CNG_IMPORT_CONTENT_ENCRYPT_KEY :: (proc "stdcall" (pCNGContentDecryptInfo : PCMSG_CNG_CONTENT_DECRYPT_INFO, dwFlags : DWORD, pvReserved : rawptr) -> BOOL);

HCERTSTORE :: rawptr;

CERT_CONTEXT :: struct {
    dwCertEncodingType : DWORD,
    pbCertEncoded      : ^BYTE,
    cbCertEncoded      : DWORD,
    pCertInfo          : PCERT_INFO,
    hCertStore         : HCERTSTORE,
};
PCERT_CONTEXT :: ^CERT_CONTEXT;

PCCERT_CONTEXT :: ^CERT_CONTEXT;

CRL_CONTEXT :: struct {
    dwCertEncodingType : DWORD,
    pbCrlEncoded       : ^BYTE,
    cbCrlEncoded       : DWORD,
    pCrlInfo           : PCRL_INFO,
    hCertStore         : HCERTSTORE,
};
PCRL_CONTEXT :: ^CRL_CONTEXT;

PCCRL_CONTEXT :: ^CRL_CONTEXT;

CTL_CONTEXT :: struct {
    dwMsgAndCertEncodingType : DWORD,
    pbCtlEncoded             : ^BYTE,
    cbCtlEncoded             : DWORD,
    pCtlInfo                 : PCTL_INFO,
    hCertStore               : HCERTSTORE,
    hCryptMsg                : HCRYPTMSG,
    pbCtlContent             : ^BYTE,
    cbCtlContent             : DWORD,
};
PCTL_CONTEXT :: ^CTL_CONTEXT;

PCCTL_CONTEXT :: ^CTL_CONTEXT;

/* CertKeyType :: enum { */
CertKeyType :: _c.int;
    KeyTypeOther :: 0;
    KeyTypeVirtualSmartCard :: 1;
    KeyTypePhysicalSmartCard :: 2;
    KeyTypePassport :: 3;
    KeyTypePassportRemote :: 4;
    KeyTypePassportSmartCard :: 5;
    KeyTypeHardware :: 6;
    KeyTypeSoftware :: 7;
    KeyTypeSelfSigned :: 8;
/* } */
;

CRYPT_KEY_PROV_PARAM :: struct {
    dwParam : DWORD,
    pbData  : ^BYTE,
    cbData  : DWORD,
    dwFlags : DWORD,
};
PCRYPT_KEY_PROV_PARAM :: ^CRYPT_KEY_PROV_PARAM;

CRYPT_KEY_PROV_INFO :: struct {
    pwszContainerName : LPWSTR,
    pwszProvName      : LPWSTR,
    dwProvType        : DWORD,
    dwFlags           : DWORD,
    cProvParam        : DWORD,
    rgProvParam       : PCRYPT_KEY_PROV_PARAM,
    dwKeySpec         : DWORD,
};
PCRYPT_KEY_PROV_INFO :: ^CRYPT_KEY_PROV_INFO;

CERT_KEY_CONTEXT :: struct {
    cbSize    : DWORD,
    u : struct #raw_union {
        hCryptProv : HCRYPTPROV,
        hNCryptKey : NCRYPT_KEY_HANDLE,
    },
    dwKeySpec : DWORD,
};
PCERT_KEY_CONTEXT :: ^CERT_KEY_CONTEXT;

ROOT_INFO_LUID :: struct {
    LowPart  : DWORD,
    HighPart : LONG,
};
PROOT_INFO_LUID :: ^ROOT_INFO_LUID;

CRYPT_SMART_CARD_ROOT_INFO :: struct {
    rgbCardID : [16]BYTE,
    luid      : ROOT_INFO_LUID,
};
PCRYPT_SMART_CARD_ROOT_INFO :: ^CRYPT_SMART_CARD_ROOT_INFO;

CERT_SYSTEM_STORE_RELOCATE_PARA :: struct {
    u : struct #raw_union {
        hKeyBase : HKEY,
        pvBase   : rawptr,
    },
    u2 : struct #raw_union {
        pvSystemStore   : rawptr,
        pszSystemStore  : LPCSTR,
        pwszSystemStore : LPCWSTR,
    },
};
PCERT_SYSTEM_STORE_RELOCATE_PARA :: ^CERT_SYSTEM_STORE_RELOCATE_PARA;

CERT_REGISTRY_STORE_CLIENT_GPT_PARA :: struct {
    hKeyBase    : HKEY,
    pwszRegPath : LPWSTR,
};
PCERT_REGISTRY_STORE_CLIENT_GPT_PARA :: ^CERT_REGISTRY_STORE_CLIENT_GPT_PARA;

CERT_REGISTRY_STORE_ROAMING_PARA :: struct {
    hKey               : HKEY,
    pwszStoreDirectory : LPWSTR,
};
PCERT_REGISTRY_STORE_ROAMING_PARA :: ^CERT_REGISTRY_STORE_ROAMING_PARA;

CERT_LDAP_STORE_OPENED_PARA :: struct {
    pvLdapSessionHandle : rawptr,
    pwszLdapUrl         : LPCWSTR,
};
PCERT_LDAP_STORE_OPENED_PARA :: ^CERT_LDAP_STORE_OPENED_PARA;

HCERTSTOREPROV :: rawptr;

CERT_STORE_PROV_INFO :: struct {
    cbSize              : DWORD,
    cStoreProvFunc      : DWORD,
    rgpvStoreProvFunc   : ^rawptr,
    hStoreProv          : HCERTSTOREPROV,
    dwStoreProvFlags    : DWORD,
    hStoreProvFuncAddr2 : HCRYPTOIDFUNCADDR,
};
PCERT_STORE_PROV_INFO :: ^CERT_STORE_PROV_INFO;

PFN_CERT_DLL_OPEN_STORE_PROV_FUNC :: (proc "stdcall" (lpszStoreProvider : LPCSTR, dwEncodingType : DWORD, hCryptProv : HCRYPTPROV_LEGACY, dwFlags : DWORD, pvPara : rawptr, hCertStore : HCERTSTORE, pStoreProvInfo : PCERT_STORE_PROV_INFO) -> BOOL);

PFN_CERT_STORE_PROV_CLOSE :: proc "stdcall" (hStoreProv : HCERTSTOREPROV, dwFlags : DWORD);

PFN_CERT_STORE_PROV_READ_CERT :: (proc "stdcall" (hStoreProv : HCERTSTOREPROV, pStoreCertContext : PCCERT_CONTEXT, dwFlags : DWORD, ppProvCertContext : ^PCCERT_CONTEXT) -> BOOL);

PFN_CERT_STORE_PROV_WRITE_CERT :: (proc "stdcall" (hStoreProv : HCERTSTOREPROV, pCertContext : PCCERT_CONTEXT, dwFlags : DWORD) -> BOOL);

PFN_CERT_STORE_PROV_DELETE_CERT :: (proc "stdcall" (hStoreProv : HCERTSTOREPROV, pCertContext : PCCERT_CONTEXT, dwFlags : DWORD) -> BOOL);

PFN_CERT_STORE_PROV_SET_CERT_PROPERTY :: (proc "stdcall" (hStoreProv : HCERTSTOREPROV, pCertContext : PCCERT_CONTEXT, dwPropId : DWORD, dwFlags : DWORD, pvData : rawptr) -> BOOL);

PFN_CERT_STORE_PROV_READ_CRL :: (proc "stdcall" (hStoreProv : HCERTSTOREPROV, pStoreCrlContext : PCCRL_CONTEXT, dwFlags : DWORD, ppProvCrlContext : ^PCCRL_CONTEXT) -> BOOL);

PFN_CERT_STORE_PROV_WRITE_CRL :: (proc "stdcall" (hStoreProv : HCERTSTOREPROV, pCrlContext : PCCRL_CONTEXT, dwFlags : DWORD) -> BOOL);

PFN_CERT_STORE_PROV_DELETE_CRL :: (proc "stdcall" (hStoreProv : HCERTSTOREPROV, pCrlContext : PCCRL_CONTEXT, dwFlags : DWORD) -> BOOL);

PFN_CERT_STORE_PROV_SET_CRL_PROPERTY :: (proc "stdcall" (hStoreProv : HCERTSTOREPROV, pCrlContext : PCCRL_CONTEXT, dwPropId : DWORD, dwFlags : DWORD, pvData : rawptr) -> BOOL);

PFN_CERT_STORE_PROV_READ_CTL :: (proc "stdcall" (hStoreProv : HCERTSTOREPROV, pStoreCtlContext : PCCTL_CONTEXT, dwFlags : DWORD, ppProvCtlContext : ^PCCTL_CONTEXT) -> BOOL);

PFN_CERT_STORE_PROV_WRITE_CTL :: (proc "stdcall" (hStoreProv : HCERTSTOREPROV, pCtlContext : PCCTL_CONTEXT, dwFlags : DWORD) -> BOOL);

PFN_CERT_STORE_PROV_DELETE_CTL :: (proc "stdcall" (hStoreProv : HCERTSTOREPROV, pCtlContext : PCCTL_CONTEXT, dwFlags : DWORD) -> BOOL);

PFN_CERT_STORE_PROV_SET_CTL_PROPERTY :: (proc "stdcall" (hStoreProv : HCERTSTOREPROV, pCtlContext : PCCTL_CONTEXT, dwPropId : DWORD, dwFlags : DWORD, pvData : rawptr) -> BOOL);

PFN_CERT_STORE_PROV_CONTROL :: (proc "stdcall" (hStoreProv : HCERTSTOREPROV, dwFlags : DWORD, dwCtrlType : DWORD, pvCtrlPara : rawptr) -> BOOL);

CERT_STORE_PROV_FIND_INFO :: struct {
    cbSize                   : DWORD,
    dwMsgAndCertEncodingType : DWORD,
    dwFindFlags              : DWORD,
    dwFindType               : DWORD,
    pvFindPara               : rawptr,
};
PCERT_STORE_PROV_FIND_INFO :: ^CERT_STORE_PROV_FIND_INFO;

CCERT_STORE_PROV_FIND_INFO :: CERT_STORE_PROV_FIND_INFO;
PCCERT_STORE_PROV_FIND_INFO :: ^CERT_STORE_PROV_FIND_INFO;

PFN_CERT_STORE_PROV_FIND_CERT :: (proc "stdcall" (hStoreProv : HCERTSTOREPROV, pFindInfo : PCCERT_STORE_PROV_FIND_INFO, pPrevCertContext : PCCERT_CONTEXT, dwFlags : DWORD, ppvStoreProvFindInfo : ^rawptr, ppProvCertContext : ^PCCERT_CONTEXT) -> BOOL);

PFN_CERT_STORE_PROV_FREE_FIND_CERT :: (proc "stdcall" (hStoreProv : HCERTSTOREPROV, pCertContext : PCCERT_CONTEXT, pvStoreProvFindInfo : rawptr, dwFlags : DWORD) -> BOOL);

PFN_CERT_STORE_PROV_GET_CERT_PROPERTY :: (proc "stdcall" (hStoreProv : HCERTSTOREPROV, pCertContext : PCCERT_CONTEXT, dwPropId : DWORD, dwFlags : DWORD, pvData : rawptr, pcbData : ^DWORD) -> BOOL);

PFN_CERT_STORE_PROV_FIND_CRL :: (proc "stdcall" (hStoreProv : HCERTSTOREPROV, pFindInfo : PCCERT_STORE_PROV_FIND_INFO, pPrevCrlContext : PCCRL_CONTEXT, dwFlags : DWORD, ppvStoreProvFindInfo : ^rawptr, ppProvCrlContext : ^PCCRL_CONTEXT) -> BOOL);

PFN_CERT_STORE_PROV_FREE_FIND_CRL :: (proc "stdcall" (hStoreProv : HCERTSTOREPROV, pCrlContext : PCCRL_CONTEXT, pvStoreProvFindInfo : rawptr, dwFlags : DWORD) -> BOOL);

PFN_CERT_STORE_PROV_GET_CRL_PROPERTY :: (proc "stdcall" (hStoreProv : HCERTSTOREPROV, pCrlContext : PCCRL_CONTEXT, dwPropId : DWORD, dwFlags : DWORD, pvData : rawptr, pcbData : ^DWORD) -> BOOL);

PFN_CERT_STORE_PROV_FIND_CTL :: (proc "stdcall" (hStoreProv : HCERTSTOREPROV, pFindInfo : PCCERT_STORE_PROV_FIND_INFO, pPrevCtlContext : PCCTL_CONTEXT, dwFlags : DWORD, ppvStoreProvFindInfo : ^rawptr, ppProvCtlContext : ^PCCTL_CONTEXT) -> BOOL);

PFN_CERT_STORE_PROV_FREE_FIND_CTL :: (proc "stdcall" (hStoreProv : HCERTSTOREPROV, pCtlContext : PCCTL_CONTEXT, pvStoreProvFindInfo : rawptr, dwFlags : DWORD) -> BOOL);

PFN_CERT_STORE_PROV_GET_CTL_PROPERTY :: (proc "stdcall" (hStoreProv : HCERTSTOREPROV, pCtlContext : PCCTL_CONTEXT, dwPropId : DWORD, dwFlags : DWORD, pvData : rawptr, pcbData : ^DWORD) -> BOOL);

CRL_FIND_ISSUED_FOR_PARA :: struct {
    pSubjectCert : PCCERT_CONTEXT,
    pIssuerCert  : PCCERT_CONTEXT,
};
PCRL_FIND_ISSUED_FOR_PARA :: ^CRL_FIND_ISSUED_FOR_PARA;

CTL_ANY_SUBJECT_INFO :: struct {
    SubjectAlgorithm  : CRYPT_ALGORITHM_IDENTIFIER,
    SubjectIdentifier : CRYPT_DATA_BLOB,
};
PCTL_ANY_SUBJECT_INFO :: ^CTL_ANY_SUBJECT_INFO;

CTL_FIND_USAGE_PARA :: struct {
    cbSize         : DWORD,
    SubjectUsage   : CTL_USAGE,
    ListIdentifier : CRYPT_DATA_BLOB,
    pSigner        : PCERT_INFO,
};
PCTL_FIND_USAGE_PARA :: ^CTL_FIND_USAGE_PARA;

CTL_FIND_SUBJECT_PARA :: struct {
    cbSize        : DWORD,
    pUsagePara    : PCTL_FIND_USAGE_PARA,
    dwSubjectType : DWORD,
    pvSubject     : rawptr,
};
PCTL_FIND_SUBJECT_PARA :: ^CTL_FIND_SUBJECT_PARA;

PFN_CERT_CREATE_CONTEXT_SORT_FUNC :: (proc "stdcall" (cbTotalEncoded : DWORD, cbRemainEncoded : DWORD, cEntry : DWORD, pvSort : rawptr) -> BOOL);

CERT_CREATE_CONTEXT_PARA :: struct {
    cbSize  : DWORD,
    pfnFree : PFN_CRYPT_FREE,
    pvFree  : rawptr,
    pfnSort : PFN_CERT_CREATE_CONTEXT_SORT_FUNC,
    pvSort  : rawptr,
};
PCERT_CREATE_CONTEXT_PARA :: ^CERT_CREATE_CONTEXT_PARA;

CERT_SYSTEM_STORE_INFO :: struct {
    cbSize : DWORD,
};
PCERT_SYSTEM_STORE_INFO :: ^CERT_SYSTEM_STORE_INFO;

CERT_PHYSICAL_STORE_INFO :: struct {
    cbSize               : DWORD,
    pszOpenStoreProvider : LPSTR,
    dwOpenEncodingType   : DWORD,
    dwOpenFlags          : DWORD,
    OpenParameters       : CRYPT_DATA_BLOB,
    dwFlags              : DWORD,
    dwPriority           : DWORD,
};
PCERT_PHYSICAL_STORE_INFO :: ^CERT_PHYSICAL_STORE_INFO;

PFN_CERT_ENUM_SYSTEM_STORE_LOCATION :: (proc "stdcall" (pwszStoreLocation : LPCWSTR, dwFlags : DWORD, pvReserved : rawptr, pvArg : rawptr) -> BOOL);

PFN_CERT_ENUM_SYSTEM_STORE :: (proc "stdcall" (pvSystemStore : rawptr, dwFlags : DWORD, pStoreInfo : PCERT_SYSTEM_STORE_INFO, pvReserved : rawptr, pvArg : rawptr) -> BOOL);

PFN_CERT_ENUM_PHYSICAL_STORE :: (proc "stdcall" (pvSystemStore : rawptr, dwFlags : DWORD, pwszStoreName : LPCWSTR, pStoreInfo : PCERT_PHYSICAL_STORE_INFO, pvReserved : rawptr, pvArg : rawptr) -> BOOL);

CTL_VERIFY_USAGE_PARA :: struct {
    cbSize         : DWORD,
    ListIdentifier : CRYPT_DATA_BLOB,
    cCtlStore      : DWORD,
    rghCtlStore    : ^HCERTSTORE,
    cSignerStore   : DWORD,
    rghSignerStore : ^HCERTSTORE,
};
PCTL_VERIFY_USAGE_PARA :: ^CTL_VERIFY_USAGE_PARA;

CTL_VERIFY_USAGE_STATUS :: struct {
    cbSize          : DWORD,
    dwError         : DWORD,
    dwFlags         : DWORD,
    ppCtl           : ^PCCTL_CONTEXT,
    dwCtlEntryIndex : DWORD,
    ppSigner        : ^PCCERT_CONTEXT,
    dwSignerIndex   : DWORD,
};
PCTL_VERIFY_USAGE_STATUS :: ^CTL_VERIFY_USAGE_STATUS;

CERT_REVOCATION_CRL_INFO :: struct {
    cbSize           : DWORD,
    pBaseCrlContext  : PCCRL_CONTEXT,
    pDeltaCrlContext : PCCRL_CONTEXT,
    pCrlEntry        : PCRL_ENTRY,
    fDeltaCrlEntry   : BOOL,
};
PCERT_REVOCATION_CRL_INFO :: ^CERT_REVOCATION_CRL_INFO;

PCERT_REVOCATION_CHAIN_PARA :: ^CERT_REVOCATION_CHAIN_PARA;

CERT_REVOCATION_PARA :: struct {
    cbSize       : DWORD,
    pIssuerCert  : PCCERT_CONTEXT,
    cCertStore   : DWORD,
    rgCertStore  : ^HCERTSTORE,
    hCrlStore    : HCERTSTORE,
    pftTimeToUse : LPFILETIME,
};
PCERT_REVOCATION_PARA :: ^CERT_REVOCATION_PARA;

CERT_REVOCATION_STATUS :: struct {
    cbSize            : DWORD,
    dwIndex           : DWORD,
    dwError           : DWORD,
    dwReason          : DWORD,
    fHasFreshnessTime : BOOL,
    dwFreshnessTime   : DWORD,
};
PCERT_REVOCATION_STATUS :: ^CERT_REVOCATION_STATUS;

CRYPT_VERIFY_CERT_SIGN_STRONG_PROPERTIES_INFO :: struct {
    CertSignHashCNGAlgPropData        : CRYPT_DATA_BLOB,
    CertIssuerPubKeyBitLengthPropData : CRYPT_DATA_BLOB,
};
PCRYPT_VERIFY_CERT_SIGN_STRONG_PROPERTIES_INFO :: ^CRYPT_VERIFY_CERT_SIGN_STRONG_PROPERTIES_INFO;

CRYPT_VERIFY_CERT_SIGN_WEAK_HASH_INFO :: struct {
    cCNGHashAlgid      : DWORD,
    rgpwszCNGHashAlgid : ^PCWSTR,
    dwWeakIndex        : DWORD,
};
PCRYPT_VERIFY_CERT_SIGN_WEAK_HASH_INFO :: ^CRYPT_VERIFY_CERT_SIGN_WEAK_HASH_INFO;

PFN_CRYPT_EXTRACT_ENCODED_SIGNATURE_PARAMETERS_FUNC :: (proc "stdcall" (dwCertEncodingType : DWORD, pSignatureAlgorithm : PCRYPT_ALGORITHM_IDENTIFIER, ppvDecodedSignPara : ^rawptr, ppwszCNGHashAlgid : ^LPWSTR) -> BOOL);

PFN_CRYPT_SIGN_AND_ENCODE_HASH_FUNC :: (proc "stdcall" (hKey : NCRYPT_KEY_HANDLE, dwCertEncodingType : DWORD, pSignatureAlgorithm : PCRYPT_ALGORITHM_IDENTIFIER, pvDecodedSignPara : rawptr, pwszCNGPubKeyAlgid : LPCWSTR, pwszCNGHashAlgid : LPCWSTR, pbComputedHash : ^BYTE, cbComputedHash : DWORD, pbSignature : ^BYTE, pcbSignature : ^DWORD) -> BOOL);

PFN_CRYPT_VERIFY_ENCODED_SIGNATURE_FUNC :: (proc "stdcall" (dwCertEncodingType : DWORD, pPubKeyInfo : PCERT_PUBLIC_KEY_INFO, pSignatureAlgorithm : PCRYPT_ALGORITHM_IDENTIFIER, pvDecodedSignPara : rawptr, pwszCNGPubKeyAlgid : LPCWSTR, pwszCNGHashAlgid : LPCWSTR, pbComputedHash : ^BYTE, cbComputedHash : DWORD, pbSignature : ^BYTE, cbSignature : DWORD) -> BOOL);

HCRYPTDEFAULTCONTEXT :: rawptr;

CRYPT_DEFAULT_CONTEXT_MULTI_OID_PARA :: struct {
    cOID     : DWORD,
    rgpszOID : ^LPSTR,
};
PCRYPT_DEFAULT_CONTEXT_MULTI_OID_PARA :: ^CRYPT_DEFAULT_CONTEXT_MULTI_OID_PARA;

PFN_CRYPT_EXPORT_PUBLIC_KEY_INFO_EX2_FUNC :: (proc "stdcall" (hNCryptKey : NCRYPT_KEY_HANDLE, dwCertEncodingType : DWORD, pszPublicKeyObjId : LPSTR, dwFlags : DWORD, pvAuxInfo : rawptr, pInfo : PCERT_PUBLIC_KEY_INFO, pcbInfo : ^DWORD) -> BOOL);

PFN_CRYPT_EXPORT_PUBLIC_KEY_INFO_FROM_BCRYPT_HANDLE_FUNC :: (proc "stdcall" (hBCryptKey : BCRYPT_KEY_HANDLE, dwCertEncodingType : DWORD, pszPublicKeyObjId : LPSTR, dwFlags : DWORD, pvAuxInfo : rawptr, pInfo : PCERT_PUBLIC_KEY_INFO, pcbInfo : ^DWORD) -> BOOL);

PFN_IMPORT_PUBLIC_KEY_INFO_EX2_FUNC :: (proc "stdcall" (dwCertEncodingType : DWORD, pInfo : PCERT_PUBLIC_KEY_INFO, dwFlags : DWORD, pvAuxInfo : rawptr, phKey : ^BCRYPT_KEY_HANDLE) -> BOOL);

PFN_IMPORT_PRIV_KEY_FUNC :: (proc "stdcall" (hCryptProv : HCRYPTPROV, pPrivateKeyInfo : ^CRYPT_PRIVATE_KEY_INFO, dwFlags : DWORD, pvAuxInfo : rawptr) -> BOOL);

PFN_EXPORT_PRIV_KEY_FUNC :: (proc "stdcall" (hCryptProv : HCRYPTPROV, dwKeySpec : DWORD, pszPrivateKeyObjId : LPSTR, dwFlags : DWORD, pvAuxInfo : rawptr, pPrivateKeyInfo : ^CRYPT_PRIVATE_KEY_INFO, pcbPrivateKeyInfo : ^DWORD) -> BOOL);

PFN_CRYPT_GET_SIGNER_CERTIFICATE :: (proc "stdcall" (pvGetArg : rawptr, dwCertEncodingType : DWORD, pSignerId : PCERT_INFO, hMsgCertStore : HCERTSTORE) -> PCCERT_CONTEXT);

CRYPT_SIGN_MESSAGE_PARA :: struct {
    cbSize             : DWORD,
    dwMsgEncodingType  : DWORD,
    pSigningCert       : PCCERT_CONTEXT,
    HashAlgorithm      : CRYPT_ALGORITHM_IDENTIFIER,
    pvHashAuxInfo      : rawptr,
    cMsgCert           : DWORD,
    rgpMsgCert         : ^PCCERT_CONTEXT,
    cMsgCrl            : DWORD,
    rgpMsgCrl          : ^PCCRL_CONTEXT,
    cAuthAttr          : DWORD,
    rgAuthAttr         : PCRYPT_ATTRIBUTE,
    cUnauthAttr        : DWORD,
    rgUnauthAttr       : PCRYPT_ATTRIBUTE,
    dwFlags            : DWORD,
    dwInnerContentType : DWORD,
};
PCRYPT_SIGN_MESSAGE_PARA :: ^CRYPT_SIGN_MESSAGE_PARA;

CRYPT_VERIFY_MESSAGE_PARA :: struct {
    cbSize                   : DWORD,
    dwMsgAndCertEncodingType : DWORD,
    hCryptProv               : HCRYPTPROV_LEGACY,
    pfnGetSignerCertificate  : PFN_CRYPT_GET_SIGNER_CERTIFICATE,
    pvGetArg                 : rawptr,
};
PCRYPT_VERIFY_MESSAGE_PARA :: ^CRYPT_VERIFY_MESSAGE_PARA;

CRYPT_ENCRYPT_MESSAGE_PARA :: struct {
    cbSize                     : DWORD,
    dwMsgEncodingType          : DWORD,
    hCryptProv                 : HCRYPTPROV_LEGACY,
    ContentEncryptionAlgorithm : CRYPT_ALGORITHM_IDENTIFIER,
    pvEncryptionAuxInfo        : rawptr,
    dwFlags                    : DWORD,
    dwInnerContentType         : DWORD,
};
PCRYPT_ENCRYPT_MESSAGE_PARA :: ^CRYPT_ENCRYPT_MESSAGE_PARA;

CRYPT_DECRYPT_MESSAGE_PARA :: struct {
    cbSize                   : DWORD,
    dwMsgAndCertEncodingType : DWORD,
    cCertStore               : DWORD,
    rghCertStore             : ^HCERTSTORE,
};
PCRYPT_DECRYPT_MESSAGE_PARA :: ^CRYPT_DECRYPT_MESSAGE_PARA;

CRYPT_HASH_MESSAGE_PARA :: struct {
    cbSize            : DWORD,
    dwMsgEncodingType : DWORD,
    hCryptProv        : HCRYPTPROV_LEGACY,
    HashAlgorithm     : CRYPT_ALGORITHM_IDENTIFIER,
    pvHashAuxInfo     : rawptr,
};
PCRYPT_HASH_MESSAGE_PARA :: ^CRYPT_HASH_MESSAGE_PARA;

CRYPT_KEY_SIGN_MESSAGE_PARA :: struct {
    cbSize                   : DWORD,
    dwMsgAndCertEncodingType : DWORD,
    u : struct #raw_union {
        hCryptProv : HCRYPTPROV,
        hNCryptKey : NCRYPT_KEY_HANDLE,
    },
    dwKeySpec                : DWORD,
    HashAlgorithm            : CRYPT_ALGORITHM_IDENTIFIER,
    pvHashAuxInfo            : rawptr,
    PubKeyAlgorithm          : CRYPT_ALGORITHM_IDENTIFIER,
};
PCRYPT_KEY_SIGN_MESSAGE_PARA :: ^CRYPT_KEY_SIGN_MESSAGE_PARA;

CRYPT_KEY_VERIFY_MESSAGE_PARA :: struct {
    cbSize            : DWORD,
    dwMsgEncodingType : DWORD,
    hCryptProv        : HCRYPTPROV_LEGACY,
};
PCRYPT_KEY_VERIFY_MESSAGE_PARA :: ^CRYPT_KEY_VERIFY_MESSAGE_PARA;

CERT_CHAIN :: struct {
    cCerts         : DWORD,
    certs          : PCERT_BLOB,
    keyLocatorInfo : CRYPT_KEY_PROV_INFO,
};
PCERT_CHAIN :: ^CERT_CHAIN;

HCRYPTASYNC :: HANDLE;
PHCRYPTASYNC :: ^HANDLE;

PFN_CRYPT_ASYNC_PARAM_FREE_FUNC :: proc "stdcall" (pszParamOid : LPSTR, pvParam : LPVOID);

CRYPT_BLOB_ARRAY :: struct {
    cBlob  : DWORD,
    rgBlob : PCRYPT_DATA_BLOB,
};
PCRYPT_BLOB_ARRAY :: ^CRYPT_BLOB_ARRAY;

CRYPT_CREDENTIALS :: struct {
    cbSize            : DWORD,
    pszCredentialsOid : LPCSTR,
    pvCredentials     : LPVOID,
};
PCRYPT_CREDENTIALS :: ^CRYPT_CREDENTIALS;

CRYPT_PASSWORD_CREDENTIALSA :: struct {
    cbSize      : DWORD,
    pszUsername : LPSTR,
    pszPassword : LPSTR,
};
PCRYPT_PASSWORD_CREDENTIALSA :: ^CRYPT_PASSWORD_CREDENTIALSA;

CRYPT_PASSWORD_CREDENTIALSW :: struct {
    cbSize      : DWORD,
    pszUsername : LPWSTR,
    pszPassword : LPWSTR,
};
PCRYPT_PASSWORD_CREDENTIALSW :: ^CRYPT_PASSWORD_CREDENTIALSW;

CRYPT_PASSWORD_CREDENTIALS :: CRYPT_PASSWORD_CREDENTIALSA;

PCRYPT_PASSWORD_CREDENTIALS :: PCRYPT_PASSWORD_CREDENTIALSA;

PFN_FREE_ENCODED_OBJECT_FUNC :: proc "stdcall" (pszObjectOid : LPCSTR, pObject : PCRYPT_BLOB_ARRAY, pvFreeContext : LPVOID);

CRYPTNET_URL_CACHE_PRE_FETCH_INFO :: struct {
    cbSize         : DWORD,
    dwObjectType   : DWORD,
    dwError        : DWORD,
    dwReserved     : DWORD,
    ThisUpdateTime : FILETIME,
    NextUpdateTime : FILETIME,
    PublishTime    : FILETIME,
};
PCRYPTNET_URL_CACHE_PRE_FETCH_INFO :: ^CRYPTNET_URL_CACHE_PRE_FETCH_INFO;

CRYPTNET_URL_CACHE_FLUSH_INFO :: struct {
    cbSize          : DWORD,
    dwExemptSeconds : DWORD,
    ExpireTime      : FILETIME,
};
PCRYPTNET_URL_CACHE_FLUSH_INFO :: ^CRYPTNET_URL_CACHE_FLUSH_INFO;

CRYPTNET_URL_CACHE_RESPONSE_INFO :: struct {
    cbSize           : DWORD,
    wResponseType    : WORD,
    wResponseFlags   : WORD,
    LastModifiedTime : FILETIME,
    dwMaxAge         : DWORD,
    pwszETag         : LPCWSTR,
    dwProxyId        : DWORD,
};
PCRYPTNET_URL_CACHE_RESPONSE_INFO :: ^CRYPTNET_URL_CACHE_RESPONSE_INFO;

CRYPT_RETRIEVE_AUX_INFO :: struct {
    cbSize                     : DWORD,
    pLastSyncTime              : ^FILETIME,
    dwMaxUrlRetrievalByteCount : DWORD,
    pPreFetchInfo              : PCRYPTNET_URL_CACHE_PRE_FETCH_INFO,
    pFlushInfo                 : PCRYPTNET_URL_CACHE_FLUSH_INFO,
    ppResponseInfo             : ^PCRYPTNET_URL_CACHE_RESPONSE_INFO,
    pwszCacheFileNamePrefix    : LPWSTR,
    pftCacheResync             : LPFILETIME,
    fProxyCacheRetrieval       : BOOL,
    dwHttpStatusCode           : DWORD,
    ppwszErrorResponseHeaders  : ^LPWSTR,
    ppErrorContentBlob         : ^PCRYPT_DATA_BLOB,
};
PCRYPT_RETRIEVE_AUX_INFO :: ^CRYPT_RETRIEVE_AUX_INFO;

PFN_CRYPT_CANCEL_RETRIEVAL :: (proc "stdcall" (dwFlags : DWORD, pvArg : rawptr) -> BOOL);

PFN_CRYPT_ASYNC_RETRIEVAL_COMPLETION_FUNC :: proc "stdcall" (pvCompletion : LPVOID, dwCompletionCode : DWORD, pszUrl : LPCSTR, pszObjectOid : LPSTR, pvObject : LPVOID);

CRYPT_ASYNC_RETRIEVAL_COMPLETION :: struct {
    pfnCompletion : PFN_CRYPT_ASYNC_RETRIEVAL_COMPLETION_FUNC,
    pvCompletion  : LPVOID,
};
PCRYPT_ASYNC_RETRIEVAL_COMPLETION :: ^CRYPT_ASYNC_RETRIEVAL_COMPLETION;

PFN_CANCEL_ASYNC_RETRIEVAL_FUNC :: (proc "stdcall" (hAsyncRetrieve : HCRYPTASYNC) -> BOOL);

CRYPT_URL_ARRAY :: struct {
    cUrl     : DWORD,
    rgwszUrl : ^LPWSTR,
};
PCRYPT_URL_ARRAY :: ^CRYPT_URL_ARRAY;

CRYPT_URL_INFO :: struct {
    cbSize          : DWORD,
    dwSyncDeltaTime : DWORD,
    cGroup          : DWORD,
    rgcGroupEntry   : ^DWORD,
};
PCRYPT_URL_INFO :: ^CRYPT_URL_INFO;

CERT_CRL_CONTEXT_PAIR :: struct {
    pCertContext : PCCERT_CONTEXT,
    pCrlContext  : PCCRL_CONTEXT,
};
PCERT_CRL_CONTEXT_PAIR :: ^CERT_CRL_CONTEXT_PAIR;

PCCERT_CRL_CONTEXT_PAIR :: ^CERT_CRL_CONTEXT_PAIR;

CRYPT_GET_TIME_VALID_OBJECT_EXTRA_INFO :: struct {
    cbSize             : DWORD,
    iDeltaCrlIndicator : _c.int,
    pftCacheResync     : LPFILETIME,
    pLastSyncTime      : LPFILETIME,
    pMaxAgeTime        : LPFILETIME,
    pChainPara         : PCERT_REVOCATION_CHAIN_PARA,
    pDeltaCrlIndicator : PCRYPT_INTEGER_BLOB,
};
PCRYPT_GET_TIME_VALID_OBJECT_EXTRA_INFO :: ^CRYPT_GET_TIME_VALID_OBJECT_EXTRA_INFO;

PFN_CRYPT_ENUM_KEYID_PROP :: (proc "stdcall" (pKeyIdentifier : ^CRYPT_HASH_BLOB, dwFlags : DWORD, pvReserved : rawptr, pvArg : rawptr, cProp : DWORD, rgdwPropId : ^DWORD, rgpvData : ^rawptr, rgcbData : ^DWORD) -> BOOL);

HCERTCHAINENGINE :: HANDLE;

CERT_CHAIN_ENGINE_CONFIG :: struct {
    cbSize                    : DWORD,
    hRestrictedRoot           : HCERTSTORE,
    hRestrictedTrust          : HCERTSTORE,
    hRestrictedOther          : HCERTSTORE,
    cAdditionalStore          : DWORD,
    rghAdditionalStore        : ^HCERTSTORE,
    dwFlags                   : DWORD,
    dwUrlRetrievalTimeout     : DWORD,
    MaximumCachedCertificates : DWORD,
    CycleDetectionModulus     : DWORD,
    hExclusiveRoot            : HCERTSTORE,
    hExclusiveTrustedPeople   : HCERTSTORE,
    dwExclusiveFlags          : DWORD,
};
PCERT_CHAIN_ENGINE_CONFIG :: ^CERT_CHAIN_ENGINE_CONFIG;

CERT_TRUST_STATUS :: struct {
    dwErrorStatus : DWORD,
    dwInfoStatus  : DWORD,
};
PCERT_TRUST_STATUS :: ^CERT_TRUST_STATUS;

CERT_REVOCATION_INFO :: struct {
    cbSize             : DWORD,
    dwRevocationResult : DWORD,
    pszRevocationOid   : LPCSTR,
    pvOidSpecificInfo  : LPVOID,
    fHasFreshnessTime  : BOOL,
    dwFreshnessTime    : DWORD,
    pCrlInfo           : PCERT_REVOCATION_CRL_INFO,
};
PCERT_REVOCATION_INFO :: ^CERT_REVOCATION_INFO;

CERT_TRUST_LIST_INFO :: struct {
    cbSize      : DWORD,
    pCtlEntry   : PCTL_ENTRY,
    pCtlContext : PCCTL_CONTEXT,
};
PCERT_TRUST_LIST_INFO :: ^CERT_TRUST_LIST_INFO;

CERT_CHAIN_ELEMENT :: struct {
    cbSize                : DWORD,
    pCertContext          : PCCERT_CONTEXT,
    TrustStatus           : CERT_TRUST_STATUS,
    pRevocationInfo       : PCERT_REVOCATION_INFO,
    pIssuanceUsage        : PCERT_ENHKEY_USAGE,
    pApplicationUsage     : PCERT_ENHKEY_USAGE,
    pwszExtendedErrorInfo : LPCWSTR,
};
PCERT_CHAIN_ELEMENT :: ^CERT_CHAIN_ELEMENT;

PCCERT_CHAIN_ELEMENT :: ^CERT_CHAIN_ELEMENT;

CERT_SIMPLE_CHAIN :: struct {
    cbSize                      : DWORD,
    TrustStatus                 : CERT_TRUST_STATUS,
    cElement                    : DWORD,
    rgpElement                  : ^PCERT_CHAIN_ELEMENT,
    pTrustListInfo              : PCERT_TRUST_LIST_INFO,
    fHasRevocationFreshnessTime : BOOL,
    dwRevocationFreshnessTime   : DWORD,
};
PCERT_SIMPLE_CHAIN :: ^CERT_SIMPLE_CHAIN;

PCCERT_SIMPLE_CHAIN :: ^CERT_SIMPLE_CHAIN;

PCERT_CHAIN_CONTEXT :: ^CERT_CHAIN_CONTEXT;

PCCERT_CHAIN_CONTEXT :: ^CERT_CHAIN_CONTEXT;

CERT_CHAIN_CONTEXT :: struct {
    cbSize                      : DWORD,
    TrustStatus                 : CERT_TRUST_STATUS,
    cChain                      : DWORD,
    rgpChain                    : ^PCERT_SIMPLE_CHAIN,
    cLowerQualityChainContext   : DWORD,
    rgpLowerQualityChainContext : ^PCCERT_CHAIN_CONTEXT,
    fHasRevocationFreshnessTime : BOOL,
    dwRevocationFreshnessTime   : DWORD,
    dwCreateFlags               : DWORD,
    ChainId                     : GUID,
};

CERT_USAGE_MATCH :: struct {
    dwType : DWORD,
    Usage  : CERT_ENHKEY_USAGE,
};
PCERT_USAGE_MATCH :: ^CERT_USAGE_MATCH;

CTL_USAGE_MATCH :: struct {
    dwType : DWORD,
    Usage  : CTL_USAGE,
};
PCTL_USAGE_MATCH :: ^CTL_USAGE_MATCH;

CERT_CHAIN_PARA :: struct {
    cbSize         : DWORD,
    RequestedUsage : CERT_USAGE_MATCH,
};
PCERT_CHAIN_PARA :: ^CERT_CHAIN_PARA;

CERT_REVOCATION_CHAIN_PARA :: struct {
    cbSize                     : DWORD,
    hChainEngine               : HCERTCHAINENGINE,
    hAdditionalStore           : HCERTSTORE,
    dwChainFlags               : DWORD,
    dwUrlRetrievalTimeout      : DWORD,
    pftCurrentTime             : LPFILETIME,
    pftCacheResync             : LPFILETIME,
    cbMaxUrlRetrievalByteCount : DWORD,
};

CRL_REVOCATION_INFO :: struct {
    pCrlEntry       : PCRL_ENTRY,
    pCrlContext     : PCCRL_CONTEXT,
    pCrlIssuerChain : PCCERT_CHAIN_CONTEXT,
};
PCRL_REVOCATION_INFO :: ^CRL_REVOCATION_INFO;

PFN_CERT_CHAIN_FIND_BY_ISSUER_CALLBACK :: (proc "stdcall" (pCert : PCCERT_CONTEXT, pvFindArg : rawptr) -> BOOL);

CERT_CHAIN_FIND_ISSUER_PARA :: struct {
    cbSize                   : DWORD,
    pszUsageIdentifier       : LPCSTR,
    dwKeySpec                : DWORD,
    dwAcquirePrivateKeyFlags : DWORD,
    cIssuer                  : DWORD,
    rgIssuer                 : ^CERT_NAME_BLOB,
    pfnFindCallback          : PFN_CERT_CHAIN_FIND_BY_ISSUER_CALLBACK,
    pvFindArg                : rawptr,
};
PCERT_CHAIN_FIND_ISSUER_PARA :: ^CERT_CHAIN_FIND_ISSUER_PARA;
CERT_CHAIN_FIND_BY_ISSUER_PARA :: struct {
    cbSize                   : DWORD,
    pszUsageIdentifier       : LPCSTR,
    dwKeySpec                : DWORD,
    dwAcquirePrivateKeyFlags : DWORD,
    cIssuer                  : DWORD,
    rgIssuer                 : ^CERT_NAME_BLOB,
    pfnFindCallback          : PFN_CERT_CHAIN_FIND_BY_ISSUER_CALLBACK,
    pvFindArg                : rawptr,
};
PCERT_CHAIN_FIND_BY_ISSUER_PARA :: ^CERT_CHAIN_FIND_BY_ISSUER_PARA;

CERT_CHAIN_POLICY_PARA :: struct {
    cbSize            : DWORD,
    dwFlags           : DWORD,
    pvExtraPolicyPara : rawptr,
};
PCERT_CHAIN_POLICY_PARA :: ^CERT_CHAIN_POLICY_PARA;

CERT_CHAIN_POLICY_STATUS :: struct {
    cbSize              : DWORD,
    dwError             : DWORD,
    lChainIndex         : LONG,
    lElementIndex       : LONG,
    pvExtraPolicyStatus : rawptr,
};
PCERT_CHAIN_POLICY_STATUS :: ^CERT_CHAIN_POLICY_STATUS;

AUTHENTICODE_EXTRA_CERT_CHAIN_POLICY_PARA :: struct {
    cbSize              : DWORD,
    dwRegPolicySettings : DWORD,
    pSignerInfo         : PCMSG_SIGNER_INFO,
};
PAUTHENTICODE_EXTRA_CERT_CHAIN_POLICY_PARA :: ^AUTHENTICODE_EXTRA_CERT_CHAIN_POLICY_PARA;

AUTHENTICODE_EXTRA_CERT_CHAIN_POLICY_STATUS :: struct {
    cbSize      : DWORD,
    fCommercial : BOOL,
};
PAUTHENTICODE_EXTRA_CERT_CHAIN_POLICY_STATUS :: ^AUTHENTICODE_EXTRA_CERT_CHAIN_POLICY_STATUS;

AUTHENTICODE_TS_EXTRA_CERT_CHAIN_POLICY_PARA :: struct {
    cbSize              : DWORD,
    dwRegPolicySettings : DWORD,
    fCommercial         : BOOL,
};
PAUTHENTICODE_TS_EXTRA_CERT_CHAIN_POLICY_PARA :: ^AUTHENTICODE_TS_EXTRA_CERT_CHAIN_POLICY_PARA;

HTTPSPolicyCallbackData :: struct {
    u : struct #raw_union {
        cbStruct : DWORD,
        cbSize   : DWORD,
    },
    dwAuthType     : DWORD,
    fdwChecks      : DWORD,
    pwszServerName : ^WCHAR,
};
PHTTPSPolicyCallbackData :: ^HTTPSPolicyCallbackData;
SSL_EXTRA_CERT_CHAIN_POLICY_PARA :: struct {
    u : struct #raw_union {
        cbStruct : DWORD,
        cbSize   : DWORD,
    },
    dwAuthType     : DWORD,
    fdwChecks      : DWORD,
    pwszServerName : ^WCHAR,
};
PSSL_EXTRA_CERT_CHAIN_POLICY_PARA :: ^SSL_EXTRA_CERT_CHAIN_POLICY_PARA;

EV_EXTRA_CERT_CHAIN_POLICY_PARA :: struct {
    cbSize                      : DWORD,
    dwRootProgramQualifierFlags : DWORD,
};
PEV_EXTRA_CERT_CHAIN_POLICY_PARA :: ^EV_EXTRA_CERT_CHAIN_POLICY_PARA;

EV_EXTRA_CERT_CHAIN_POLICY_STATUS :: struct {
    cbSize               : DWORD,
    dwQualifiers         : DWORD,
    dwIssuanceUsageIndex : DWORD,
};
PEV_EXTRA_CERT_CHAIN_POLICY_STATUS :: ^EV_EXTRA_CERT_CHAIN_POLICY_STATUS;

SSL_F12_EXTRA_CERT_CHAIN_POLICY_STATUS :: struct {
    cbSize          : DWORD,
    dwErrorLevel    : DWORD,
    dwErrorCategory : DWORD,
    dwReserved      : DWORD,
    wszErrorText    : [256]WCHAR,
};
PSSL_F12_EXTRA_CERT_CHAIN_POLICY_STATUS :: ^SSL_F12_EXTRA_CERT_CHAIN_POLICY_STATUS;

SSL_HPKP_HEADER_EXTRA_CERT_CHAIN_POLICY_PARA :: struct {
    cbSize         : DWORD,
    dwReserved     : DWORD,
    pwszServerName : LPWSTR,
    rgpszHpkpValue : [2]LPSTR,
};
PSSL_HPKP_HEADER_EXTRA_CERT_CHAIN_POLICY_PARA :: ^SSL_HPKP_HEADER_EXTRA_CERT_CHAIN_POLICY_PARA;

SSL_KEY_PIN_EXTRA_CERT_CHAIN_POLICY_PARA :: struct {
    cbSize         : DWORD,
    dwReserved     : DWORD,
    pwszServerName : PCWSTR,
};
PSSL_KEY_PIN_EXTRA_CERT_CHAIN_POLICY_PARA :: ^SSL_KEY_PIN_EXTRA_CERT_CHAIN_POLICY_PARA;

SSL_KEY_PIN_EXTRA_CERT_CHAIN_POLICY_STATUS :: struct {
    cbSize       : DWORD,
    lError       : LONG,
    wszErrorText : [512]WCHAR,
};
PSSL_KEY_PIN_EXTRA_CERT_CHAIN_POLICY_STATUS :: ^SSL_KEY_PIN_EXTRA_CERT_CHAIN_POLICY_STATUS;

CRYPT_PKCS12_PBE_PARAMS :: struct {
    iIterations : _c.int,
    cbSalt      : ULONG,
};

PKCS12_PBES2_EXPORT_PARAMS :: struct {
    dwSize            : DWORD,
    hNcryptDescriptor : PVOID,
    pwszPbes2Alg      : LPWSTR,
};
PPKCS12_PBES2_EXPORT_PARAMS :: ^PKCS12_PBES2_EXPORT_PARAMS;

HCERT_SERVER_OCSP_RESPONSE :: rawptr;

PCERT_SERVER_OCSP_RESPONSE_CONTEXT :: ^CERT_SERVER_OCSP_RESPONSE_CONTEXT;

PCCERT_SERVER_OCSP_RESPONSE_CONTEXT :: ^CERT_SERVER_OCSP_RESPONSE_CONTEXT;

CERT_SERVER_OCSP_RESPONSE_CONTEXT :: struct {
    cbSize                : DWORD,
    pbEncodedOcspResponse : ^BYTE,
    cbEncodedOcspResponse : DWORD,
};

PFN_CERT_SERVER_OCSP_RESPONSE_UPDATE_CALLBACK :: proc "stdcall" (pChainContext : PCCERT_CHAIN_CONTEXT, pServerOcspResponseContext : PCCERT_SERVER_OCSP_RESPONSE_CONTEXT, pNewCrlContext : PCCRL_CONTEXT, pPrevCrlContext : PCCRL_CONTEXT, pvArg : PVOID, dwWriteOcspFileError : DWORD);

CERT_SERVER_OCSP_RESPONSE_OPEN_PARA :: struct {
    cbSize              : DWORD,
    dwFlags             : DWORD,
    pcbUsedSize         : ^DWORD,
    pwszOcspDirectory   : PWSTR,
    pfnUpdateCallback   : PFN_CERT_SERVER_OCSP_RESPONSE_UPDATE_CALLBACK,
    pvUpdateCallbackArg : PVOID,
};
PCERT_SERVER_OCSP_RESPONSE_OPEN_PARA :: ^CERT_SERVER_OCSP_RESPONSE_OPEN_PARA;

CERT_SELECT_CHAIN_PARA :: struct {
    hChainEngine     : HCERTCHAINENGINE,
    pTime            : PFILETIME,
    hAdditionalStore : HCERTSTORE,
    pChainPara       : PCERT_CHAIN_PARA,
    dwFlags          : DWORD,
};
PCERT_SELECT_CHAIN_PARA :: ^CERT_SELECT_CHAIN_PARA;

PCCERT_SELECT_CHAIN_PARA :: ^CERT_SELECT_CHAIN_PARA;

CERT_SELECT_CRITERIA :: struct {
    dwType : DWORD,
    cPara  : DWORD,
    ppPara : ^rawptr,
};
PCERT_SELECT_CRITERIA :: ^CERT_SELECT_CRITERIA;

PCCERT_SELECT_CRITERIA :: ^CERT_SELECT_CRITERIA;

CRYPT_TIMESTAMP_REQUEST :: struct {
    dwVersion      : DWORD,
    HashAlgorithm  : CRYPT_ALGORITHM_IDENTIFIER,
    HashedMessage  : CRYPT_DER_BLOB,
    pszTSAPolicyId : LPSTR,
    Nonce          : CRYPT_INTEGER_BLOB,
    fCertReq       : BOOL,
    cExtension     : DWORD,
    rgExtension    : PCERT_EXTENSION,
};
PCRYPT_TIMESTAMP_REQUEST :: ^CRYPT_TIMESTAMP_REQUEST;

CRYPT_TIMESTAMP_RESPONSE :: struct {
    dwStatus    : DWORD,
    cFreeText   : DWORD,
    rgFreeText  : ^LPWSTR,
    FailureInfo : CRYPT_BIT_BLOB,
    ContentInfo : CRYPT_DER_BLOB,
};
PCRYPT_TIMESTAMP_RESPONSE :: ^CRYPT_TIMESTAMP_RESPONSE;

CRYPT_TIMESTAMP_ACCURACY :: struct {
    dwSeconds : DWORD,
    dwMillis  : DWORD,
    dwMicros  : DWORD,
};
PCRYPT_TIMESTAMP_ACCURACY :: ^CRYPT_TIMESTAMP_ACCURACY;

CRYPT_TIMESTAMP_INFO :: struct {
    dwVersion      : DWORD,
    pszTSAPolicyId : LPSTR,
    HashAlgorithm  : CRYPT_ALGORITHM_IDENTIFIER,
    HashedMessage  : CRYPT_DER_BLOB,
    SerialNumber   : CRYPT_INTEGER_BLOB,
    ftTime         : FILETIME,
    pvAccuracy     : PCRYPT_TIMESTAMP_ACCURACY,
    fOrdering      : BOOL,
    Nonce          : CRYPT_DER_BLOB,
    Tsa            : CRYPT_DER_BLOB,
    cExtension     : DWORD,
    rgExtension    : PCERT_EXTENSION,
};
PCRYPT_TIMESTAMP_INFO :: ^CRYPT_TIMESTAMP_INFO;

CRYPT_TIMESTAMP_CONTEXT :: struct {
    cbEncoded  : DWORD,
    pbEncoded  : ^BYTE,
    pTimeStamp : PCRYPT_TIMESTAMP_INFO,
};
PCRYPT_TIMESTAMP_CONTEXT :: ^CRYPT_TIMESTAMP_CONTEXT;

CRYPT_TIMESTAMP_PARA :: struct {
    pszTSAPolicyId : LPCSTR,
    fRequestCerts  : BOOL,
    Nonce          : CRYPT_INTEGER_BLOB,
    cExtension     : DWORD,
    rgExtension    : PCERT_EXTENSION,
};
PCRYPT_TIMESTAMP_PARA :: ^CRYPT_TIMESTAMP_PARA;

PFN_CRYPT_OBJECT_LOCATOR_PROVIDER_FLUSH :: (proc "stdcall" (pContext : LPVOID, rgIdentifierOrNameList : ^PCERT_NAME_BLOB, dwIdentifierOrNameListCount : DWORD) -> BOOL);

PFN_CRYPT_OBJECT_LOCATOR_PROVIDER_GET :: (proc "stdcall" (pPluginContext : LPVOID, pIdentifier : PCRYPT_DATA_BLOB, dwNameType : DWORD, pNameBlob : PCERT_NAME_BLOB, ppbContent : ^PBYTE, pcbContent : ^DWORD, ppwszPassword : ^PCWSTR, ppIdentifier : ^PCRYPT_DATA_BLOB) -> BOOL);

PFN_CRYPT_OBJECT_LOCATOR_PROVIDER_RELEASE :: proc "stdcall" (dwReason : DWORD, pPluginContext : LPVOID);

PFN_CRYPT_OBJECT_LOCATOR_PROVIDER_FREE_PASSWORD :: proc "stdcall" (pPluginContext : LPVOID, pwszPassword : PCWSTR);

PFN_CRYPT_OBJECT_LOCATOR_PROVIDER_FREE :: proc "stdcall" (pPluginContext : LPVOID, pbData : PBYTE);

PFN_CRYPT_OBJECT_LOCATOR_PROVIDER_FREE_IDENTIFIER :: proc "stdcall" (pPluginContext : LPVOID, pIdentifier : PCRYPT_DATA_BLOB);

CRYPT_OBJECT_LOCATOR_PROVIDER_TABLE :: struct {
    cbSize            : DWORD,
    pfnGet            : PFN_CRYPT_OBJECT_LOCATOR_PROVIDER_GET,
    pfnRelease        : PFN_CRYPT_OBJECT_LOCATOR_PROVIDER_RELEASE,
    pfnFreePassword   : PFN_CRYPT_OBJECT_LOCATOR_PROVIDER_FREE_PASSWORD,
    pfnFree           : PFN_CRYPT_OBJECT_LOCATOR_PROVIDER_FREE,
    pfnFreeIdentifier : PFN_CRYPT_OBJECT_LOCATOR_PROVIDER_FREE_IDENTIFIER,
};
PCRYPT_OBJECT_LOCATOR_PROVIDER_TABLE :: ^CRYPT_OBJECT_LOCATOR_PROVIDER_TABLE;

PFN_CRYPT_OBJECT_LOCATOR_PROVIDER_INITIALIZE :: (proc "stdcall" (pfnFlush : PFN_CRYPT_OBJECT_LOCATOR_PROVIDER_FLUSH, pContext : LPVOID, pdwExpectedObjectCount : ^DWORD, ppFuncTable : ^PCRYPT_OBJECT_LOCATOR_PROVIDER_TABLE, ppPluginContext : ^rawptr) -> BOOL);

PFN_CERT_IS_WEAK_HASH :: (proc "stdcall" (dwHashUseType : DWORD, pwszCNGHashAlgid : LPCWSTR, dwChainFlags : DWORD, pSignerChainContext : PCCERT_CHAIN_CONTEXT, pTimeStamp : LPFILETIME, pwszFileName : LPCWSTR) -> BOOL);

CRYPTPROTECT_PROMPTSTRUCT :: struct {
    cbSize        : DWORD,
    dwPromptFlags : DWORD,
    hwndApp       : HWND,
    szPrompt      : LPCWSTR,
};
PCRYPTPROTECT_PROMPTSTRUCT :: ^CRYPTPROTECT_PROMPTSTRUCT;

EFS_CERTIFICATE_BLOB :: struct {
    dwCertEncodingType : DWORD,
    cbData             : DWORD,
    pbData             : PBYTE,
};
PEFS_CERTIFICATE_BLOB :: ^EFS_CERTIFICATE_BLOB;

EFS_HASH_BLOB :: struct {
    cbData : DWORD,
    pbData : PBYTE,
};
PEFS_HASH_BLOB :: ^EFS_HASH_BLOB;

EFS_RPC_BLOB :: struct {
    cbData : DWORD,
    pbData : PBYTE,
};
PEFS_RPC_BLOB :: ^EFS_RPC_BLOB;

EFS_PIN_BLOB :: struct {
    cbPadding : DWORD,
    cbData    : DWORD,
    pbData    : PBYTE,
};
PEFS_PIN_BLOB :: ^EFS_PIN_BLOB;

EFS_KEY_INFO :: struct {
    dwVersion : DWORD,
    Entropy   : ULONG,
    Algorithm : ALG_ID,
    KeyLength : ULONG,
};
PEFS_KEY_INFO :: ^EFS_KEY_INFO;

EFS_COMPATIBILITY_INFO :: struct {
    EfsVersion : DWORD,
};
PEFS_COMPATIBILITY_INFO :: ^EFS_COMPATIBILITY_INFO;

EFS_VERSION_INFO :: struct {
    EfsVersion : DWORD,
    SubVersion : DWORD,
};
PEFS_VERSION_INFO :: ^EFS_VERSION_INFO;

EFS_DECRYPTION_STATUS_INFO :: struct {
    dwDecryptionError : DWORD,
    dwHashOffset      : DWORD,
    cbHash            : DWORD,
};
PEFS_DECRYPTION_STATUS_INFO :: ^EFS_DECRYPTION_STATUS_INFO;

EFS_ENCRYPTION_STATUS_INFO :: struct {
    bHasCurrentKey    : BOOL,
    dwEncryptionError : DWORD,
};
PEFS_ENCRYPTION_STATUS_INFO :: ^EFS_ENCRYPTION_STATUS_INFO;

ENCRYPTION_CERTIFICATE :: struct {
    cbTotalLength : DWORD,
    pUserSid      : ^SID,
    pCertBlob     : PEFS_CERTIFICATE_BLOB,
};
PENCRYPTION_CERTIFICATE :: ^ENCRYPTION_CERTIFICATE;

ENCRYPTION_CERTIFICATE_HASH :: struct {
    cbTotalLength        : DWORD,
    pUserSid             : ^SID,
    pHash                : PEFS_HASH_BLOB,
    lpDisplayInformation : LPWSTR,
};
PENCRYPTION_CERTIFICATE_HASH :: ^ENCRYPTION_CERTIFICATE_HASH;

ENCRYPTION_CERTIFICATE_HASH_LIST :: struct {
    nCert_Hash : DWORD,
    pUsers     : ^PENCRYPTION_CERTIFICATE_HASH,
};
PENCRYPTION_CERTIFICATE_HASH_LIST :: ^ENCRYPTION_CERTIFICATE_HASH_LIST;

ENCRYPTION_CERTIFICATE_LIST :: struct {
    nUsers : DWORD,
    pUsers : ^PENCRYPTION_CERTIFICATE,
};
PENCRYPTION_CERTIFICATE_LIST :: ^ENCRYPTION_CERTIFICATE_LIST;

ENCRYPTED_FILE_METADATA_SIGNATURE :: struct {
    dwEfsAccessType        : DWORD,
    pCertificatesAdded     : PENCRYPTION_CERTIFICATE_HASH_LIST,
    pEncryptionCertificate : PENCRYPTION_CERTIFICATE,
    pEfsStreamSignature    : PEFS_RPC_BLOB,
};
PENCRYPTED_FILE_METADATA_SIGNATURE :: ^ENCRYPTED_FILE_METADATA_SIGNATURE;

ENCRYPTION_PROTECTOR :: struct {
    cbTotalLength         : DWORD,
    pUserSid              : ^SID,
    lpProtectorDescriptor : LPWSTR,
};
PENCRYPTION_PROTECTOR :: ^ENCRYPTION_PROTECTOR;

ENCRYPTION_PROTECTOR_LIST :: struct {
    nProtectors : DWORD,
    pProtectors : ^PENCRYPTION_PROTECTOR,
};
PENCRYPTION_PROTECTOR_LIST :: ^ENCRYPTION_PROTECTOR_LIST;

RPC_IMPORT_CONTEXT_P :: struct {
    LookupContext  : RPC_NS_HANDLE,
    ProposedHandle : RPC_BINDING_HANDLE,
    Bindings       : ^RPC_BINDING_VECTOR,
};
PRPC_IMPORT_CONTEXT_P :: ^RPC_IMPORT_CONTEXT_P;

byte :: _c.uchar;

cs_byte :: byte;

boolean :: _c.uchar;

NDR_CCONTEXT :: rawptr;

NDR_SCONTEXT :: ^struct {
    pad         : [2]rawptr,
    userContext : rawptr,
};

NDR_RUNDOWN :: proc "stdcall" (context_ : rawptr);

NDR_NOTIFY_ROUTINE :: proc "stdcall" ();

NDR_NOTIFY2_ROUTINE :: proc "stdcall" (flag : boolean);

SCONTEXT_QUEUE :: struct {
    NumberOfObjects : _c.ulong,
    ArrayOfObjects  : ^NDR_SCONTEXT,
};
PSCONTEXT_QUEUE :: ^SCONTEXT_QUEUE;

error_status_t :: _c.ulong;

RPC_BUFPTR :: ^_c.uchar;

RPC_LENGTH :: _c.ulong;

EXPR_EVAL :: proc "stdcall" (^MIDL_STUB_MESSAGE);

PFORMAT_STRING :: ^_c.uchar;

ARRAY_INFO :: struct {
    Dimension             : _c.long,
    BufferConformanceMark : ^_c.ulong,
    BufferVarianceMark    : ^_c.ulong,
    MaxCountArray         : ^_c.ulong,
    OffsetArray           : ^_c.ulong,
    ActualCountArray      : ^_c.ulong,
};
PARRAY_INFO :: ^ARRAY_INFO;

PNDR_ASYNC_MESSAGE :: ^_NDR_ASYNC_MESSAGE;

PNDR_CORRELATION_INFO :: ^_NDR_CORRELATION_INFO;

;

PMIDL_SYNTAX_INFO :: ^MIDL_SYNTAX_INFO;

NDR_ALLOC_ALL_NODES_CONTEXT :: struct {};

NDR_POINTER_QUEUE_STATE :: struct {};

_NDR_PROC_CONTEXT :: struct {};

MIDL_STUB_MESSAGE :: struct {
    RpcMsg                     : PRPC_MESSAGE,
    Buffer                     : ^_c.uchar,
    BufferStart                : ^_c.uchar,
    BufferEnd                  : ^_c.uchar,
    BufferMark                 : ^_c.uchar,
    BufferLength               : _c.ulong,
    MemorySize                 : _c.ulong,
    Memory                     : ^_c.uchar,
    IsClient                   : _c.uchar,
    Pad                        : _c.uchar,
    uFlags2                    : _c.ushort,
    ReuseBuffer                : _c.int,
    pAllocAllNodesContext      : ^NDR_ALLOC_ALL_NODES_CONTEXT,
    pPointerQueueState         : ^NDR_POINTER_QUEUE_STATE,
    IgnoreEmbeddedPointers     : _c.int,
    PointerBufferMark          : ^_c.uchar,
    CorrDespIncrement          : _c.uchar,
    uFlags                     : _c.uchar,
    UniquePtrCount             : _c.ushort,
    MaxCount                   : ULONG_PTR,
    Offset                     : _c.ulong,
    ActualCount                : _c.ulong,
    pfnAllocate                : (proc "stdcall" (_c.size_t) -> rawptr),
    pfnFree                    : proc "stdcall" (rawptr),
    StackTop                   : ^_c.uchar,
    pPresentedType             : ^_c.uchar,
    pTransmitType              : ^_c.uchar,
    SavedHandle                : handle_t,
    StubDesc                   : ^MIDL_STUB_DESC,
    FullPtrXlatTables          : ^FULL_PTR_XLAT_TABLES,
    FullPtrRefId               : _c.ulong,
    PointerLength              : _c.ulong,
    using _ : bit_field {
        fInDontFree                : 1,
        fDontCallFreeInst          : 1,
        fUnused1                   : 1,
        fHasReturn                 : 1,
        fHasExtensions             : 1,
        fHasNewCorrDesc            : 1,
        fIsIn                      : 1,
        fIsOut                     : 1,
        fIsOicf                    : 1,
        fBufferValid               : 1,
        fHasMemoryValidateCallback : 1,
        fInFree                    : 1,
        fNeedMCCP                  : 1,
        fUnused2                   : 3,
        fUnused3                   : 16,
    },
    dwDestContext              : _c.ulong,
    pvDestContext              : rawptr,
    SavedContextHandles        : ^NDR_SCONTEXT,
    ParamNumber                : _c.long,
    pRpcChannelBuffer          : ^IRpcChannelBuffer,
    pArrayInfo                 : PARRAY_INFO,
    SizePtrCountArray          : ^_c.ulong,
    SizePtrOffsetArray         : ^_c.ulong,
    SizePtrLengthArray         : ^_c.ulong,
    pArgQueue                  : rawptr,
    dwStubPhase                : _c.ulong,
    LowStackMark               : rawptr,
    pAsyncMsg                  : PNDR_ASYNC_MESSAGE,
    pCorrInfo                  : PNDR_CORRELATION_INFO,
    pCorrMemory                : ^_c.uchar,
    pMemoryList                : rawptr,
    pCSInfo                    : INT_PTR,
    ConformanceMark            : ^_c.uchar,
    VarianceMark               : ^_c.uchar,
    Unused                     : INT_PTR,
    pContext                   : ^_NDR_PROC_CONTEXT,
    ContextHandleHash          : rawptr,
    pUserMarshalList           : rawptr,
    Reserved51_3               : INT_PTR,
    Reserved51_4               : INT_PTR,
    Reserved51_5               : INT_PTR,
};
PMIDL_STUB_MESSAGE :: ^MIDL_STUB_MESSAGE;

;

GENERIC_BINDING_ROUTINE :: (proc "stdcall" (rawptr) -> rawptr);

GENERIC_UNBIND_ROUTINE :: proc "stdcall" (rawptr, ^_c.uchar);

GENERIC_BINDING_ROUTINE_PAIR :: struct {
    pfnBind   : GENERIC_BINDING_ROUTINE,
    pfnUnbind : GENERIC_UNBIND_ROUTINE,
};
PGENERIC_BINDING_ROUTINE_PAIR :: ^GENERIC_BINDING_ROUTINE_PAIR;

GENERIC_BINDING_INFO :: struct {
    pObj      : rawptr,
    Size      : _c.uint,
    pfnBind   : GENERIC_BINDING_ROUTINE,
    pfnUnbind : GENERIC_UNBIND_ROUTINE,
};
PGENERIC_BINDING_INFO :: ^GENERIC_BINDING_INFO;

XMIT_HELPER_ROUTINE :: proc "stdcall" (PMIDL_STUB_MESSAGE);

XMIT_ROUTINE_QUINTUPLE :: struct {
    pfnTranslateToXmit   : XMIT_HELPER_ROUTINE,
    pfnTranslateFromXmit : XMIT_HELPER_ROUTINE,
    pfnFreeXmit          : XMIT_HELPER_ROUTINE,
    pfnFreeInst          : XMIT_HELPER_ROUTINE,
};
PXMIT_ROUTINE_QUINTUPLE :: ^XMIT_ROUTINE_QUINTUPLE;

USER_MARSHAL_SIZING_ROUTINE :: (proc "stdcall" (^_c.ulong, _c.ulong, rawptr) -> _c.ulong);

USER_MARSHAL_MARSHALLING_ROUTINE :: (proc "stdcall" (^_c.ulong, ^_c.uchar, rawptr) -> ^_c.uchar);

USER_MARSHAL_UNMARSHALLING_ROUTINE :: (proc "stdcall" (^_c.ulong, ^_c.uchar, rawptr) -> ^_c.uchar);

USER_MARSHAL_FREEING_ROUTINE :: proc "stdcall" (^_c.ulong, rawptr);

USER_MARSHAL_ROUTINE_QUADRUPLE :: struct {
    pfnBufferSize : USER_MARSHAL_SIZING_ROUTINE,
    pfnMarshall   : USER_MARSHAL_MARSHALLING_ROUTINE,
    pfnUnmarshall : USER_MARSHAL_UNMARSHALLING_ROUTINE,
    pfnFree       : USER_MARSHAL_FREEING_ROUTINE,
};

/* USER_MARSHAL_CB_TYPE :: enum { */
USER_MARSHAL_CB_TYPE :: _c.int;
    USER_MARSHAL_CB_BUFFER_SIZE :: 0;
    USER_MARSHAL_CB_MARSHALL :: USER_MARSHAL_CB_BUFFER_SIZE + 1;
    USER_MARSHAL_CB_UNMARSHALL :: USER_MARSHAL_CB_MARSHALL + 1;
    USER_MARSHAL_CB_FREE :: USER_MARSHAL_CB_UNMARSHALL + 1;
/* } */
;

USER_MARSHAL_CB :: struct {
    Flags       : _c.ulong,
    pStubMsg    : PMIDL_STUB_MESSAGE,
    pReserve    : PFORMAT_STRING,
    Signature   : _c.ulong,
    CBType      : USER_MARSHAL_CB_TYPE,
    pFormat     : PFORMAT_STRING,
    pTypeFormat : PFORMAT_STRING,
};

MALLOC_FREE_STRUCT :: struct {
    pfnAllocate : (proc "stdcall" (_c.size_t) -> rawptr),
    pfnFree     : proc "stdcall" (rawptr),
};

COMM_FAULT_OFFSETS :: struct {
    CommOffset  : _c.short,
    FaultOffset : _c.short,
};

/* IDL_CS_CONVERT :: enum { */
IDL_CS_CONVERT :: _c.int;
    IDL_CS_NO_CONVERT :: 0;
    IDL_CS_IN_PLACE_CONVERT :: IDL_CS_NO_CONVERT + 1;
    IDL_CS_NEW_BUFFER_CONVERT :: IDL_CS_IN_PLACE_CONVERT + 1;
/* } */
;

CS_TYPE_NET_SIZE_ROUTINE :: proc "stdcall" (hBinding : RPC_BINDING_HANDLE, ulNetworkCodeSet : _c.ulong, ulLocalBufferSize : _c.ulong, conversionType : ^IDL_CS_CONVERT, pulNetworkBufferSize : ^_c.ulong, pStatus : ^error_status_t);

CS_TYPE_LOCAL_SIZE_ROUTINE :: proc "stdcall" (hBinding : RPC_BINDING_HANDLE, ulNetworkCodeSet : _c.ulong, ulNetworkBufferSize : _c.ulong, conversionType : ^IDL_CS_CONVERT, pulLocalBufferSize : ^_c.ulong, pStatus : ^error_status_t);

CS_TYPE_TO_NETCS_ROUTINE :: proc "stdcall" (hBinding : RPC_BINDING_HANDLE, ulNetworkCodeSet : _c.ulong, pLocalData : rawptr, ulLocalDataLength : _c.ulong, pNetworkData : ^byte, pulNetworkDataLength : ^_c.ulong, pStatus : ^error_status_t);

CS_TYPE_FROM_NETCS_ROUTINE :: proc "stdcall" (hBinding : RPC_BINDING_HANDLE, ulNetworkCodeSet : _c.ulong, pNetworkData : ^byte, ulNetworkDataLength : _c.ulong, ulLocalBufferSize : _c.ulong, pLocalData : rawptr, pulLocalDataLength : ^_c.ulong, pStatus : ^error_status_t);

CS_TAG_GETTING_ROUTINE :: proc "stdcall" (hBinding : RPC_BINDING_HANDLE, fServerSide : _c.int, pulSendingTag : ^_c.ulong, pulDesiredReceivingTag : ^_c.ulong, pulReceivingTag : ^_c.ulong, pStatus : ^error_status_t);

NDR_CS_SIZE_CONVERT_ROUTINES :: struct {
    pfnNetSize   : CS_TYPE_NET_SIZE_ROUTINE,
    pfnToNetCs   : CS_TYPE_TO_NETCS_ROUTINE,
    pfnLocalSize : CS_TYPE_LOCAL_SIZE_ROUTINE,
    pfnFromNetCs : CS_TYPE_FROM_NETCS_ROUTINE,
};

NDR_CS_ROUTINES :: struct {
    pSizeConvertRoutines : ^NDR_CS_SIZE_CONVERT_ROUTINES,
    pTagGettingRoutines  : ^CS_TAG_GETTING_ROUTINE,
};

NDR_EXPR_DESC :: struct {
    pOffset     : ^_c.ushort,
    pFormatExpr : PFORMAT_STRING,
};

MIDL_STUB_DESC :: struct {
    RpcInterfaceInformation     : rawptr,
    pfnAllocate                 : (proc "stdcall" (_c.size_t) -> rawptr),
    pfnFree                     : proc "stdcall" (rawptr),
    IMPLICIT_HANDLE_INFO : struct #raw_union {
        pAutoHandle         : ^handle_t,
        pPrimitiveHandle    : ^handle_t,
        pGenericBindingInfo : PGENERIC_BINDING_INFO,
    },
    apfnNdrRundownRoutines      : ^NDR_RUNDOWN,
    aGenericBindingRoutinePairs : ^GENERIC_BINDING_ROUTINE_PAIR,
    apfnExprEval                : ^EXPR_EVAL,
    aXmitQuintuple              : ^XMIT_ROUTINE_QUINTUPLE,
    pFormatTypes                : ^_c.uchar,
    fCheckBounds                : _c.int,
    Version                     : _c.ulong,
    pMallocFreeStruct           : ^MALLOC_FREE_STRUCT,
    MIDLVersion                 : _c.long,
    CommFaultOffsets            : ^COMM_FAULT_OFFSETS,
    aUserMarshalQuadruple       : ^USER_MARSHAL_ROUTINE_QUADRUPLE,
    NotifyRoutineTable          : ^NDR_NOTIFY_ROUTINE,
    mFlags                      : ULONG_PTR,
    CsRoutineTables             : ^NDR_CS_ROUTINES,
    ProxyServerInfo             : rawptr,
    pExprInfo                   : ^NDR_EXPR_DESC,
};

PMIDL_STUB_DESC :: ^MIDL_STUB_DESC;

PMIDL_XMIT_TYPE :: rawptr;

STUB_THUNK :: proc "stdcall" (PMIDL_STUB_MESSAGE);

SERVER_ROUTINE :: (proc "stdcall" () -> _c.long);

MIDL_METHOD_PROPERTY :: struct {
    Id    : _c.ulong,
    Value : ULONG_PTR,
};
PMIDL_METHOD_PROPERTY :: ^MIDL_METHOD_PROPERTY;

MIDL_METHOD_PROPERTY_MAP :: struct {
    Count      : _c.ulong,
    Properties : ^MIDL_METHOD_PROPERTY,
};
PMIDL_METHOD_PROPERTY_MAP :: ^MIDL_METHOD_PROPERTY_MAP;

MIDL_INTERFACE_METHOD_PROPERTIES :: struct {
    MethodCount      : _c.ushort,
    MethodProperties : ^^MIDL_METHOD_PROPERTY_MAP,
};

MIDL_SERVER_INFO :: struct {
    pStubDesc       : PMIDL_STUB_DESC,
    DispatchTable   : ^SERVER_ROUTINE,
    ProcString      : PFORMAT_STRING,
    FmtStringOffset : ^_c.ushort,
    ThunkTable      : ^STUB_THUNK,
    pTransferSyntax : PRPC_SYNTAX_IDENTIFIER,
    nCount          : ULONG_PTR,
    pSyntaxInfo     : PMIDL_SYNTAX_INFO,
};
PMIDL_SERVER_INFO :: ^MIDL_SERVER_INFO;

MIDL_STUBLESS_PROXY_INFO :: struct {
    pStubDesc          : PMIDL_STUB_DESC,
    ProcFormatString   : PFORMAT_STRING,
    FormatStringOffset : ^_c.ushort,
    pTransferSyntax    : PRPC_SYNTAX_IDENTIFIER,
    nCount             : ULONG_PTR,
    pSyntaxInfo        : PMIDL_SYNTAX_INFO,
};

PMIDL_STUBLESS_PROXY_INFO :: ^MIDL_STUBLESS_PROXY_INFO;

MIDL_SYNTAX_INFO :: struct {
    TransferSyntax        : RPC_SYNTAX_IDENTIFIER,
    DispatchTable         : ^RPC_DISPATCH_TABLE,
    ProcString            : PFORMAT_STRING,
    FmtStringOffset       : ^_c.ushort,
    TypeString            : PFORMAT_STRING,
    aUserMarshalQuadruple : rawptr,
    pMethodProperties     : ^MIDL_INTERFACE_METHOD_PROPERTIES,
    pReserved2            : ULONG_PTR,
};
;

PARAM_OFFSETTABLE :: ^_c.ushort;
PPARAM_OFFSETTABLE :: ^_c.ushort;

CLIENT_CALL_RETURN :: struct #raw_union {
    Pointer : rawptr,
    Simple  : LONG_PTR,
};

/* XLAT_SIDE :: enum { */
XLAT_SIDE :: _c.int;
    XLAT_SERVER :: 1;
    XLAT_CLIENT :: XLAT_SERVER + 1;
/* } */
;

FULL_PTR_XLAT_TABLES :: struct {
    RefIdToPointer : rawptr,
    PointerToRefId : rawptr,
    NextRefId      : _c.ulong,
    XlatSide       : XLAT_SIDE,
};
PFULL_PTR_XLAT_TABLES :: ^FULL_PTR_XLAT_TABLES;

/* system_handle_t :: enum { */
system_handle_t :: _c.int;
    SYSTEM_HANDLE_FILE :: 0;
    SYSTEM_HANDLE_SEMAPHORE :: 1;
    SYSTEM_HANDLE_EVENT :: 2;
    SYSTEM_HANDLE_MUTEX :: 3;
    SYSTEM_HANDLE_PROCESS :: 4;
    SYSTEM_HANDLE_TOKEN :: 5;
    SYSTEM_HANDLE_SECTION :: 6;
    SYSTEM_HANDLE_REG_KEY :: 7;
    SYSTEM_HANDLE_THREAD :: 8;
    SYSTEM_HANDLE_COMPOSITION_OBJECT :: 9;
    SYSTEM_HANDLE_SOCKET :: 10;
    SYSTEM_HANDLE_JOB :: 11;
    SYSTEM_HANDLE_PIPE :: 12;
    SYSTEM_HANDLE_MAX :: 12;
    SYSTEM_HANDLE_INVALID :: 0xFF;
/* } */
;

/* using _ :: enum  { */
    MidlInterceptionInfoVersionOne :: 1;
/* } */
;

/* using _ :: enum  { */
    MidlWinrtTypeSerializationInfoVersionOne :: 1;
/* } */
;

MIDL_INTERCEPTION_INFO :: struct {
    Version               : _c.ulong,
    ProcString            : PFORMAT_STRING,
    ProcFormatOffsetTable : ^_c.ushort,
    ProcCount             : _c.ulong,
    TypeString            : PFORMAT_STRING,
};
PMIDL_INTERCEPTION_INFO :: ^MIDL_INTERCEPTION_INFO;

MIDL_WINRT_TYPE_SERIALIZATION_INFO :: struct {
    Version          : _c.ulong,
    TypeFormatString : PFORMAT_STRING,
    FormatStringSize : _c.ushort,
    TypeOffset       : _c.ushort,
    StubDesc         : PMIDL_STUB_DESC,
};
PMIDL_WINRT_TYPE_SERIALIZATION_INFO :: ^MIDL_WINRT_TYPE_SERIALIZATION_INFO;

/* STUB_PHASE :: enum { */
STUB_PHASE :: _c.int;
    STUB_UNMARSHAL :: 0;
    STUB_CALL_SERVER :: STUB_UNMARSHAL + 1;
    STUB_MARSHAL :: STUB_CALL_SERVER + 1;
    STUB_CALL_SERVER_NO_HRESULT :: STUB_MARSHAL + 1;
/* } */
;

/* PROXY_PHASE :: enum { */
PROXY_PHASE :: _c.int;
    PROXY_CALCSIZE :: 0;
    PROXY_GETBUFFER :: PROXY_CALCSIZE + 1;
    PROXY_MARSHAL :: PROXY_GETBUFFER + 1;
    PROXY_SENDRECEIVE :: PROXY_MARSHAL + 1;
    PROXY_UNMARSHAL :: PROXY_SENDRECEIVE + 1;
/* } */
;

RPC_SS_THREAD_HANDLE :: rawptr;

RPC_CLIENT_ALLOC :: #type (proc "stdcall" (Size : _c.size_t) -> rawptr);

RPC_CLIENT_FREE :: #type proc "stdcall" (Ptr : rawptr);

NDR_USER_MARSHAL_INFO_LEVEL1 :: struct {
    Buffer            : rawptr,
    BufferSize        : _c.ulong,
    pfnAllocate       : (proc "stdcall" (_c.size_t) -> rawptr),
    pfnFree           : proc "stdcall" (rawptr),
    pRpcChannelBuffer : ^IRpcChannelBuffer,
    Reserved          : [5]ULONG_PTR,
};

NDR_USER_MARSHAL_INFO :: struct {
    InformationLevel : _c.ulong,
    u : struct #raw_union {
        Level1 : NDR_USER_MARSHAL_INFO_LEVEL1,
    },
};

OLECHAR :: WCHAR;

LPOLESTR :: ^OLECHAR;

LPCOLESTR :: ^OLECHAR;

;

;

;

;

DOUBLE :: _c.double;

COAUTHIDENTITY :: struct {
    User           : ^USHORT,
    UserLength     : ULONG,
    Domain         : ^USHORT,
    DomainLength   : ULONG,
    Password       : ^USHORT,
    PasswordLength : ULONG,
    Flags          : ULONG,
};

COAUTHINFO :: struct {
    dwAuthnSvc           : DWORD,
    dwAuthzSvc           : DWORD,
    pwszServerPrincName  : LPWSTR,
    dwAuthnLevel         : DWORD,
    dwImpersonationLevel : DWORD,
    pAuthIdentityData    : ^COAUTHIDENTITY,
    dwCapabilities       : DWORD,
};

SCODE :: LONG;

PSCODE :: ^SCODE;

/* MEMCTX :: enum { */
MEMCTX :: _c.int;
    MEMCTX_TASK :: 1;
    MEMCTX_SHARED :: 2;
    MEMCTX_MACSYSTEM :: 3;
    MEMCTX_UNKNOWN :: -1;
    MEMCTX_SAME :: -2;
/* } */
;

/* CLSCTX :: enum { */
CLSCTX :: _c.int;
    CLSCTX_INPROC_SERVER :: 0x1;
    CLSCTX_INPROC_HANDLER :: 0x2;
    CLSCTX_LOCAL_SERVER :: 0x4;
    CLSCTX_INPROC_SERVER16 :: 0x8;
    CLSCTX_REMOTE_SERVER :: 0x10;
    CLSCTX_INPROC_HANDLER16 :: 0x20;
    CLSCTX_RESERVED1 :: 0x40;
    CLSCTX_RESERVED2 :: 0x80;
    CLSCTX_RESERVED3 :: 0x100;
    CLSCTX_RESERVED4 :: 0x200;
    CLSCTX_NO_CODE_DOWNLOAD :: 0x400;
    CLSCTX_RESERVED5 :: 0x800;
    CLSCTX_NO_CUSTOM_MARSHAL :: 0x1000;
    CLSCTX_ENABLE_CODE_DOWNLOAD :: 0x2000;
    CLSCTX_NO_FAILURE_LOG :: 0x4000;
    CLSCTX_DISABLE_AAA :: 0x8000;
    CLSCTX_ENABLE_AAA :: 0x10000;
    CLSCTX_FROM_DEFAULT_CONTEXT :: 0x20000;
    CLSCTX_ACTIVATE_X86_SERVER :: 0x40000;
    CLSCTX_ACTIVATE_32_BIT_SERVER ::     CLSCTX_ACTIVATE_X86_SERVER;
    CLSCTX_ACTIVATE_64_BIT_SERVER :: 0x80000;
    CLSCTX_ENABLE_CLOAKING :: 0x100000;
    CLSCTX_APPCONTAINER :: 0x400000;
    CLSCTX_ACTIVATE_AAA_AS_IU :: 0x800000;
    CLSCTX_RESERVED6 :: 0x1000000;
    CLSCTX_ACTIVATE_ARM32_SERVER :: 0x2000000;
    CLSCTX_PS_DLL :: 0x80000000;
/* } */
;

/* MSHLFLAGS :: enum { */
MSHLFLAGS :: _c.int;
    MSHLFLAGS_NORMAL :: 0;
    MSHLFLAGS_TABLESTRONG :: 1;
    MSHLFLAGS_TABLEWEAK :: 2;
    MSHLFLAGS_NOPING :: 4;
    MSHLFLAGS_RESERVED1 :: 8;
    MSHLFLAGS_RESERVED2 :: 16;
    MSHLFLAGS_RESERVED3 :: 32;
    MSHLFLAGS_RESERVED4 :: 64;
/* } */
;

/* MSHCTX :: enum { */
MSHCTX :: _c.int;
    MSHCTX_LOCAL :: 0;
    MSHCTX_NOSHAREDMEM :: 1;
    MSHCTX_DIFFERENTMACHINE :: 2;
    MSHCTX_INPROC :: 3;
    MSHCTX_CROSSCTX :: 4;
    MSHCTX_RESERVED1 :: 5;
/* } */
;

BYTE_BLOB :: struct {
    clSize : ULONG,
    abData : [1]byte,
};

UP_BYTE_BLOB :: ^BYTE_BLOB;

WORD_BLOB :: struct {
    clSize : ULONG,
    asData : [1]_c.ushort,
};

UP_WORD_BLOB :: ^WORD_BLOB;

DWORD_BLOB :: struct {
    clSize : ULONG,
    alData : [1]ULONG,
};

UP_DWORD_BLOB :: ^DWORD_BLOB;

FLAGGED_BYTE_BLOB :: struct {
    fFlags : ULONG,
    clSize : ULONG,
    abData : [1]byte,
};

UP_FLAGGED_BYTE_BLOB :: ^FLAGGED_BYTE_BLOB;

FLAGGED_WORD_BLOB :: struct {
    fFlags : ULONG,
    clSize : ULONG,
    asData : [1]_c.ushort,
};

UP_FLAGGED_WORD_BLOB :: ^FLAGGED_WORD_BLOB;

BYTE_SIZEDARR :: struct {
    clSize : ULONG,
    pData  : ^byte,
};

WORD_SIZEDARR :: struct {
    clSize : ULONG,
    pData  : ^_c.ushort,
};

DWORD_SIZEDARR :: struct {
    clSize : ULONG,
    pData  : ^ULONG,
};

HYPER_SIZEDARR :: struct {
    clSize : ULONG,
    pData  : ^i64,
};

;

BLOB :: struct {
    cbSize    : ULONG,
    pBlobData : ^BYTE,
};

LPBLOB :: ^BLOB;

RemHGLOBAL :: struct {
    fNullHGlobal : LONG,
    cbData       : ULONG,
    data         : [1]byte,
};

RemHMETAFILEPICT :: struct {
    mm     : LONG,
    xExt   : LONG,
    yExt   : LONG,
    cbData : ULONG,
    data   : [1]byte,
};

RemHENHMETAFILE :: struct {
    cbData : ULONG,
    data   : [1]byte,
};

RemHBITMAP :: struct {
    cbData : ULONG,
    data   : [1]byte,
};

RemHPALETTE :: struct {
    cbData : ULONG,
    data   : [1]byte,
};

RemHBRUSH :: struct {
    cbData : ULONG,
    data   : [1]byte,
};

/* DVASPECT :: enum { */
DVASPECT :: _c.int;
    DVASPECT_CONTENT :: 1;
    DVASPECT_THUMBNAIL :: 2;
    DVASPECT_ICON :: 4;
    DVASPECT_DOCPRINT :: 8;
/* } */
;

/* STGC :: enum { */
STGC :: _c.int;
    STGC_DEFAULT :: 0;
    STGC_OVERWRITE :: 1;
    STGC_ONLYIFCURRENT :: 2;
    STGC_DANGEROUSLYCOMMITMERELYTODISKCACHE :: 4;
    STGC_CONSOLIDATE :: 8;
/* } */
;

/* STGMOVE :: enum { */
STGMOVE :: _c.int;
    STGMOVE_MOVE :: 0;
    STGMOVE_COPY :: 1;
    STGMOVE_SHALLOWCOPY :: 2;
/* } */
;

/* STATFLAG :: enum { */
STATFLAG :: _c.int;
    STATFLAG_DEFAULT :: 0;
    STATFLAG_NONAME :: 1;
    STATFLAG_NOOPEN :: 2;
/* } */
;

HCONTEXT :: rawptr;

;

;

userCLIPFORMAT :: struct {
    fContext : LONG,
    u : struct #raw_union {
        dwValue  : DWORD,
        pwszName : ^_c.wchar_t,
    },
};

wireCLIPFORMAT :: ^userCLIPFORMAT;

CLIPFORMAT :: WORD;

GDI_NONREMOTE :: struct {
    fContext : LONG,
    u : struct #raw_union {
        hInproc : LONG,
        hRemote : ^DWORD_BLOB,
    },
};

userHGLOBAL :: struct {
    fContext : LONG,
    u : struct #raw_union {
        hInproc   : LONG,
        hRemote   : ^FLAGGED_BYTE_BLOB,
        hInproc64 : i64,
    },
};

wireHGLOBAL :: ^userHGLOBAL;

userHMETAFILE :: struct {
    fContext : LONG,
    u : struct #raw_union {
        hInproc   : LONG,
        hRemote   : ^BYTE_BLOB,
        hInproc64 : i64,
    },
};

remoteMETAFILEPICT :: struct {
    mm   : LONG,
    xExt : LONG,
    yExt : LONG,
    hMF  : ^userHMETAFILE,
};

userHMETAFILEPICT :: struct {
    fContext : LONG,
    u : struct #raw_union {
        hInproc   : LONG,
        hRemote   : ^remoteMETAFILEPICT,
        hInproc64 : i64,
    },
};

userHENHMETAFILE :: struct {
    fContext : LONG,
    u : struct #raw_union {
        hInproc   : LONG,
        hRemote   : ^BYTE_BLOB,
        hInproc64 : i64,
    },
};

userBITMAP :: struct {
    bmType       : LONG,
    bmWidth      : LONG,
    bmHeight     : LONG,
    bmWidthBytes : LONG,
    bmPlanes     : WORD,
    bmBitsPixel  : WORD,
    cbSize       : ULONG,
    pBuffer      : [1]byte,
};

userHBITMAP :: struct {
    fContext : LONG,
    u : struct #raw_union {
        hInproc   : LONG,
        hRemote   : ^userBITMAP,
        hInproc64 : i64,
    },
};

userHPALETTE :: struct {
    fContext : LONG,
    u : struct #raw_union {
        hInproc   : LONG,
        hRemote   : ^LOGPALETTE,
        hInproc64 : i64,
    },
};

RemotableHandle :: struct {
    fContext : LONG,
    u : struct #raw_union {
        hInproc : LONG,
        hRemote : LONG,
    },
};

wireHWND :: ^RemotableHandle;

wireHMENU :: ^RemotableHandle;

wireHACCEL :: ^RemotableHandle;

wireHBRUSH :: ^RemotableHandle;

wireHFONT :: ^RemotableHandle;

wireHDC :: ^RemotableHandle;

wireHICON :: ^RemotableHandle;

wireHRGN :: ^RemotableHandle;

wireHMONITOR :: ^RemotableHandle;

wireHBITMAP :: ^userHBITMAP;

wireHPALETTE :: ^userHPALETTE;

wireHENHMETAFILE :: ^userHENHMETAFILE;

wireHMETAFILE :: ^userHMETAFILE;

wireHMETAFILEPICT :: ^userHMETAFILEPICT;

HMETAFILEPICT :: rawptr;

DATE :: _c.double;

CY :: struct #raw_union {
    s : struct {
        Lo : ULONG,
        Hi : LONG,
    },
    int64 : LONGLONG,
};

LPCY :: ^CY;

DECIMAL :: struct {
    wReserved : USHORT,
    u : struct #raw_union {
        s : struct {
            scale : BYTE,
            sign  : BYTE,
        },
        signscale : USHORT,
    },
    Hi32      : ULONG,
    u2 : struct #raw_union {
        s2 : struct {
            Lo32  : ULONG,
            Mid32 : ULONG,
        },
        Lo64 : ULONGLONG,
    },
};

LPDECIMAL :: ^DECIMAL;

wireBSTR :: ^FLAGGED_WORD_BLOB;

BSTR :: ^OLECHAR;

LPBSTR :: ^BSTR;

VARIANT_BOOL :: _c.short;

BSTRBLOB :: struct {
    cbSize : ULONG,
    pData  : ^BYTE,
};

LPBSTRBLOB :: ^BSTRBLOB;

CLIPDATA :: struct {
    cbSize    : ULONG,
    ulClipFmt : LONG,
    pClipData : ^BYTE,
};

VARTYPE :: _c.ushort;

/* VARENUM :: enum { */
VARENUM :: _c.int;
    VT_EMPTY :: 0;
    VT_NULL :: 1;
    VT_I2 :: 2;
    VT_I4 :: 3;
    VT_R4 :: 4;
    VT_R8 :: 5;
    VT_CY :: 6;
    VT_DATE :: 7;
    VT_BSTR :: 8;
    VT_DISPATCH :: 9;
    VT_ERROR :: 10;
    VT_BOOL :: 11;
    VT_VARIANT :: 12;
    VT_UNKNOWN :: 13;
    VT_DECIMAL :: 14;
    VT_I1 :: 16;
    VT_UI1 :: 17;
    VT_UI2 :: 18;
    VT_UI4 :: 19;
    VT_I8 :: 20;
    VT_UI8 :: 21;
    VT_INT :: 22;
    VT_UINT :: 23;
    VT_VOID :: 24;
    VT_HRESULT :: 25;
    VT_PTR :: 26;
    VT_SAFEARRAY :: 27;
    VT_CARRAY :: 28;
    VT_USERDEFINED :: 29;
    VT_LPSTR :: 30;
    VT_LPWSTR :: 31;
    VT_RECORD :: 36;
    VT_INT_PTR :: 37;
    VT_UINT_PTR :: 38;
    VT_FILETIME :: 64;
    VT_BLOB :: 65;
    VT_STREAM :: 66;
    VT_STORAGE :: 67;
    VT_STREAMED_OBJECT :: 68;
    VT_STORED_OBJECT :: 69;
    VT_BLOB_OBJECT :: 70;
    VT_CF :: 71;
    VT_CLSID :: 72;
    VT_VERSIONED_STREAM :: 73;
    VT_BSTR_BLOB :: 0xfff;
    VT_VECTOR :: 0x1000;
    VT_ARRAY :: 0x2000;
    VT_BYREF :: 0x4000;
    VT_RESERVED :: 0x8000;
    VT_ILLEGAL :: 0xffff;
    VT_ILLEGALMASKED :: 0xfff;
    VT_TYPEMASK :: 0xfff;
/* } */
;

PROPID :: ULONG;

PROPERTYKEY :: struct {
    fmtid : GUID,
    pid   : DWORD,
};

CSPLATFORM :: struct {
    dwPlatformId    : DWORD,
    dwVersionHi     : DWORD,
    dwVersionLo     : DWORD,
    dwProcessorArch : DWORD,
};

QUERYCONTEXT :: struct {
    dwContext   : DWORD,
    Platform    : CSPLATFORM,
    Locale      : LCID,
    dwVersionHi : DWORD,
    dwVersionLo : DWORD,
};

/* TYSPEC :: enum { */
TYSPEC :: _c.int;
    TYSPEC_CLSID :: 0;
    TYSPEC_FILEEXT :: (TYSPEC_CLSID + 1);
    TYSPEC_MIMETYPE :: (TYSPEC_FILEEXT + 1);
    TYSPEC_FILENAME :: (TYSPEC_MIMETYPE + 1);
    TYSPEC_PROGID :: (TYSPEC_FILENAME + 1);
    TYSPEC_PACKAGENAME :: (TYSPEC_PROGID + 1);
    TYSPEC_OBJECTID :: (TYSPEC_PACKAGENAME + 1);
/* } */
;

uCLSSPEC :: struct {
    tyspec       : DWORD,
    tagged_union : struct #raw_union {
        clsid      : CLSID,
        pFileExt   : LPOLESTR,
        pMimeType  : LPOLESTR,
        pProgId    : LPOLESTR,
        pFileName  : LPOLESTR,
        ByName : struct {
            pPackageName : LPOLESTR,
            PolicyId     : GUID,
        },
        ByObjectId : struct {
            ObjectId : GUID,
            PolicyId : GUID,
        },
    },
};

STORAGE_HOTPLUG_INFO :: struct {
    Size                     : DWORD,
    MediaRemovable           : BOOLEAN,
    MediaHotplug             : BOOLEAN,
    DeviceHotplug            : BOOLEAN,
    WriteCacheEnableOverride : BOOLEAN,
};
PSTORAGE_HOTPLUG_INFO :: ^STORAGE_HOTPLUG_INFO;

STORAGE_DEVICE_NUMBER :: struct {
    DeviceType      : DWORD,
    DeviceNumber    : DWORD,
    PartitionNumber : DWORD,
};
PSTORAGE_DEVICE_NUMBER :: ^STORAGE_DEVICE_NUMBER;

STORAGE_DEVICE_NUMBERS :: struct {
    Version         : DWORD,
    Size            : DWORD,
    NumberOfDevices : DWORD,
    Devices         : [1]STORAGE_DEVICE_NUMBER,
};
PSTORAGE_DEVICE_NUMBERS :: ^STORAGE_DEVICE_NUMBERS;

STORAGE_DEVICE_NUMBER_EX :: struct {
    Version         : DWORD,
    Size            : DWORD,
    Flags           : DWORD,
    DeviceType      : DWORD,
    DeviceNumber    : DWORD,
    DeviceGuid      : GUID,
    PartitionNumber : DWORD,
};
PSTORAGE_DEVICE_NUMBER_EX :: ^STORAGE_DEVICE_NUMBER_EX;

STORAGE_BUS_RESET_REQUEST :: struct {
    PathId : BYTE,
};
PSTORAGE_BUS_RESET_REQUEST :: ^STORAGE_BUS_RESET_REQUEST;

STORAGE_BREAK_RESERVATION_REQUEST :: struct {
    Length   : DWORD,
    _unused  : BYTE,
    PathId   : BYTE,
    TargetId : BYTE,
    Lun      : BYTE,
};
PSTORAGE_BREAK_RESERVATION_REQUEST :: ^STORAGE_BREAK_RESERVATION_REQUEST;

PREVENT_MEDIA_REMOVAL :: struct {
    PreventMediaRemoval : BOOLEAN,
};
PPREVENT_MEDIA_REMOVAL :: ^PREVENT_MEDIA_REMOVAL;

CLASS_MEDIA_CHANGE_CONTEXT :: struct {
    MediaChangeCount : DWORD,
    NewState         : DWORD,
};
PCLASS_MEDIA_CHANGE_CONTEXT :: ^CLASS_MEDIA_CHANGE_CONTEXT;

TAPE_STATISTICS :: struct {
    Version                : DWORD,
    Flags                  : DWORD,
    RecoveredWrites        : LARGE_INTEGER,
    UnrecoveredWrites      : LARGE_INTEGER,
    RecoveredReads         : LARGE_INTEGER,
    UnrecoveredReads       : LARGE_INTEGER,
    CompressionRatioReads  : BYTE,
    CompressionRatioWrites : BYTE,
};
PTAPE_STATISTICS :: ^TAPE_STATISTICS;

TAPE_GET_STATISTICS :: struct {
    Operation : DWORD,
};
PTAPE_GET_STATISTICS :: ^TAPE_GET_STATISTICS;

/* STORAGE_MEDIA_TYPE :: enum { */
STORAGE_MEDIA_TYPE :: _c.int;
    DDS_4mm :: 0x20;
    MiniQic :: DDS_4mm + 1;
    Travan :: MiniQic + 1;
    QIC :: Travan + 1;
    MP_8mm :: QIC + 1;
    AME_8mm :: MP_8mm + 1;
    AIT1_8mm :: AME_8mm + 1;
    DLT :: AIT1_8mm + 1;
    NCTP :: DLT + 1;
    IBM_3480 :: NCTP + 1;
    IBM_3490E :: IBM_3480 + 1;
    IBM_Magstar_3590 :: IBM_3490E + 1;
    IBM_Magstar_MP :: IBM_Magstar_3590 + 1;
    STK_DATA_D3 :: IBM_Magstar_MP + 1;
    SONY_DTF :: STK_DATA_D3 + 1;
    DV_6mm :: SONY_DTF + 1;
    DMI :: DV_6mm + 1;
    SONY_D2 :: DMI + 1;
    CLEANER_CARTRIDGE :: SONY_D2 + 1;
    CD_ROM :: CLEANER_CARTRIDGE + 1;
    CD_R :: CD_ROM + 1;
    CD_RW :: CD_R + 1;
    DVD_ROM :: CD_RW + 1;
    DVD_R :: DVD_ROM + 1;
    DVD_RW :: DVD_R + 1;
    MO_3_RW :: DVD_RW + 1;
    MO_5_WO :: MO_3_RW + 1;
    MO_5_RW :: MO_5_WO + 1;
    MO_5_LIMDOW :: MO_5_RW + 1;
    PC_5_WO :: MO_5_LIMDOW + 1;
    PC_5_RW :: PC_5_WO + 1;
    PD_5_RW :: PC_5_RW + 1;
    ABL_5_WO :: PD_5_RW + 1;
    PINNACLE_APEX_5_RW :: ABL_5_WO + 1;
    SONY_12_WO :: PINNACLE_APEX_5_RW + 1;
    PHILIPS_12_WO :: SONY_12_WO + 1;
    HITACHI_12_WO :: PHILIPS_12_WO + 1;
    CYGNET_12_WO :: HITACHI_12_WO + 1;
    KODAK_14_WO :: CYGNET_12_WO + 1;
    MO_NFR_525 :: KODAK_14_WO + 1;
    NIKON_12_RW :: MO_NFR_525 + 1;
    IOMEGA_ZIP :: NIKON_12_RW + 1;
    IOMEGA_JAZ :: IOMEGA_ZIP + 1;
    SYQUEST_EZ135 :: IOMEGA_JAZ + 1;
    SYQUEST_EZFLYER :: SYQUEST_EZ135 + 1;
    SYQUEST_SYJET :: SYQUEST_EZFLYER + 1;
    AVATAR_F2 :: SYQUEST_SYJET + 1;
    MP2_8mm :: AVATAR_F2 + 1;
    DST_S :: MP2_8mm + 1;
    DST_M :: DST_S + 1;
    DST_L :: DST_M + 1;
    VXATape_1 :: DST_L + 1;
    VXATape_2 :: VXATape_1 + 1;
    STK_9840 :: VXATape_2 + 1;
    LTO_Ultrium :: STK_9840 + 1;
    LTO_Accelis :: LTO_Ultrium + 1;
    DVD_RAM :: LTO_Accelis + 1;
    AIT_8mm :: DVD_RAM + 1;
    ADR_1 :: AIT_8mm + 1;
    ADR_2 :: ADR_1 + 1;
    STK_9940 :: ADR_2 + 1;
    SAIT :: STK_9940 + 1;
    VXATape :: SAIT + 1;
/* } */
PSTORAGE_MEDIA_TYPE :: ^STORAGE_MEDIA_TYPE;

/* STORAGE_BUS_TYPE :: enum { */
STORAGE_BUS_TYPE :: _c.int;
    BusTypeUnknown :: 0x00;
    BusTypeScsi :: BusTypeUnknown + 1;
    BusTypeAtapi :: BusTypeScsi + 1;
    BusTypeAta :: BusTypeAtapi + 1;
    BusType1394 :: BusTypeAta + 1;
    BusTypeSsa :: BusType1394 + 1;
    BusTypeFibre :: BusTypeSsa + 1;
    BusTypeUsb :: BusTypeFibre + 1;
    BusTypeRAID :: BusTypeUsb + 1;
    BusTypeiScsi :: BusTypeRAID + 1;
    BusTypeSas :: BusTypeiScsi + 1;
    BusTypeSata :: BusTypeSas + 1;
    BusTypeSd :: BusTypeSata + 1;
    BusTypeMmc :: BusTypeSd + 1;
    BusTypeVirtual :: BusTypeMmc + 1;
    BusTypeFileBackedVirtual :: BusTypeVirtual + 1;
    BusTypeSpaces :: BusTypeFileBackedVirtual + 1;
    BusTypeNvme :: BusTypeSpaces + 1;
    BusTypeSCM :: BusTypeNvme + 1;
    BusTypeUfs :: BusTypeSCM + 1;
    BusTypeMax :: BusTypeUfs + 1;
    BusTypeMaxReserved :: 0x7F;
/* } */
PSTORAGE_BUS_TYPE :: ^STORAGE_BUS_TYPE;

DEVICE_MEDIA_INFO :: struct {
    DeviceSpecific : struct #raw_union {
        DiskInfo : struct {
            Cylinders            : LARGE_INTEGER,
            MediaType            : STORAGE_MEDIA_TYPE,
            TracksPerCylinder    : DWORD,
            SectorsPerTrack      : DWORD,
            BytesPerSector       : DWORD,
            NumberMediaSides     : DWORD,
            MediaCharacteristics : DWORD,
        },
        RemovableDiskInfo : struct {
            Cylinders            : LARGE_INTEGER,
            MediaType            : STORAGE_MEDIA_TYPE,
            TracksPerCylinder    : DWORD,
            SectorsPerTrack      : DWORD,
            BytesPerSector       : DWORD,
            NumberMediaSides     : DWORD,
            MediaCharacteristics : DWORD,
        },
        TapeInfo : struct {
            MediaType            : STORAGE_MEDIA_TYPE,
            MediaCharacteristics : DWORD,
            CurrentBlockSize     : DWORD,
            BusType              : STORAGE_BUS_TYPE,
            BusSpecificData : struct #raw_union {
                ScsiInformation : struct {
                    MediumType  : BYTE,
                    DensityCode : BYTE,
                },
            },
        },
    },
};
PDEVICE_MEDIA_INFO :: ^DEVICE_MEDIA_INFO;

GET_MEDIA_TYPES :: struct {
    DeviceType     : DWORD,
    MediaInfoCount : DWORD,
    MediaInfo      : [1]DEVICE_MEDIA_INFO,
};
PGET_MEDIA_TYPES :: ^GET_MEDIA_TYPES;

STORAGE_PREDICT_FAILURE :: struct {
    PredictFailure : DWORD,
    VendorSpecific : [512]BYTE,
};
PSTORAGE_PREDICT_FAILURE :: ^STORAGE_PREDICT_FAILURE;

STORAGE_FAILURE_PREDICTION_CONFIG :: struct {
    Version  : DWORD,
    Size     : DWORD,
    Set      : BOOLEAN,
    Enabled  : BOOLEAN,
    Reserved : WORD,
};
PSTORAGE_FAILURE_PREDICTION_CONFIG :: ^STORAGE_FAILURE_PREDICTION_CONFIG;

/* STORAGE_QUERY_TYPE :: enum { */
STORAGE_QUERY_TYPE :: _c.int;
    PropertyStandardQuery :: 0;
    PropertyExistsQuery :: PropertyStandardQuery + 1;
    PropertyMaskQuery :: PropertyExistsQuery + 1;
    PropertyQueryMaxDefined :: PropertyMaskQuery + 1;
/* } */
PSTORAGE_QUERY_TYPE :: ^STORAGE_QUERY_TYPE;

/* STORAGE_SET_TYPE :: enum { */
STORAGE_SET_TYPE :: _c.int;
    PropertyStandardSet :: 0;
    PropertyExistsSet :: PropertyStandardSet + 1;
    PropertySetMaxDefined :: PropertyExistsSet + 1;
/* } */
PSTORAGE_SET_TYPE :: ^STORAGE_SET_TYPE;

/* STORAGE_PROPERTY_ID :: enum { */
STORAGE_PROPERTY_ID :: _c.int;
    StorageDeviceProperty :: 0;
    StorageAdapterProperty :: StorageDeviceProperty + 1;
    StorageDeviceIdProperty :: StorageAdapterProperty + 1;
    StorageDeviceUniqueIdProperty :: StorageDeviceIdProperty + 1;
    StorageDeviceWriteCacheProperty :: StorageDeviceUniqueIdProperty + 1;
    StorageMiniportProperty :: StorageDeviceWriteCacheProperty + 1;
    StorageAccessAlignmentProperty :: StorageMiniportProperty + 1;
    StorageDeviceSeekPenaltyProperty :: StorageAccessAlignmentProperty + 1;
    StorageDeviceTrimProperty :: StorageDeviceSeekPenaltyProperty + 1;
    StorageDeviceWriteAggregationProperty :: StorageDeviceTrimProperty + 1;
    StorageDeviceDeviceTelemetryProperty :: StorageDeviceWriteAggregationProperty + 1;
    StorageDeviceLBProvisioningProperty :: StorageDeviceDeviceTelemetryProperty + 1;
    StorageDevicePowerProperty :: StorageDeviceLBProvisioningProperty + 1;
    StorageDeviceCopyOffloadProperty :: StorageDevicePowerProperty + 1;
    StorageDeviceResiliencyProperty :: StorageDeviceCopyOffloadProperty + 1;
    StorageDeviceMediumProductType :: StorageDeviceResiliencyProperty + 1;
    StorageAdapterRpmbProperty :: StorageDeviceMediumProductType + 1;
    StorageAdapterCryptoProperty :: StorageAdapterRpmbProperty + 1;
    StorageDeviceIoCapabilityProperty :: 48;
    StorageAdapterProtocolSpecificProperty :: StorageDeviceIoCapabilityProperty + 1;
    StorageDeviceProtocolSpecificProperty :: StorageAdapterProtocolSpecificProperty + 1;
    StorageAdapterTemperatureProperty :: StorageDeviceProtocolSpecificProperty + 1;
    StorageDeviceTemperatureProperty :: StorageAdapterTemperatureProperty + 1;
    StorageAdapterPhysicalTopologyProperty :: StorageDeviceTemperatureProperty + 1;
    StorageDevicePhysicalTopologyProperty :: StorageAdapterPhysicalTopologyProperty + 1;
    StorageDeviceAttributesProperty :: StorageDevicePhysicalTopologyProperty + 1;
    StorageDeviceManagementStatus :: StorageDeviceAttributesProperty + 1;
    StorageAdapterSerialNumberProperty :: StorageDeviceManagementStatus + 1;
    StorageDeviceLocationProperty :: StorageAdapterSerialNumberProperty + 1;
    StorageDeviceNumaProperty :: StorageDeviceLocationProperty + 1;
    StorageDeviceZonedDeviceProperty :: StorageDeviceNumaProperty + 1;
    StorageDeviceUnsafeShutdownCount :: StorageDeviceZonedDeviceProperty + 1;
    StorageDeviceEnduranceProperty :: StorageDeviceUnsafeShutdownCount + 1;
/* } */
PSTORAGE_PROPERTY_ID :: ^STORAGE_PROPERTY_ID;

STORAGE_PROPERTY_QUERY :: struct {
    PropertyId           : STORAGE_PROPERTY_ID,
    QueryType            : STORAGE_QUERY_TYPE,
    AdditionalParameters : [1]BYTE,
};
PSTORAGE_PROPERTY_QUERY :: ^STORAGE_PROPERTY_QUERY;

STORAGE_PROPERTY_SET :: struct {
    PropertyId           : STORAGE_PROPERTY_ID,
    SetType              : STORAGE_SET_TYPE,
    AdditionalParameters : [1]BYTE,
};
PSTORAGE_PROPERTY_SET :: ^STORAGE_PROPERTY_SET;

STORAGE_DESCRIPTOR_HEADER :: struct {
    Version : DWORD,
    Size    : DWORD,
};
PSTORAGE_DESCRIPTOR_HEADER :: ^STORAGE_DESCRIPTOR_HEADER;

STORAGE_DEVICE_DESCRIPTOR :: struct {
    Version               : DWORD,
    Size                  : DWORD,
    DeviceType            : BYTE,
    DeviceTypeModifier    : BYTE,
    RemovableMedia        : BOOLEAN,
    CommandQueueing       : BOOLEAN,
    VendorIdOffset        : DWORD,
    ProductIdOffset       : DWORD,
    ProductRevisionOffset : DWORD,
    SerialNumberOffset    : DWORD,
    BusType               : STORAGE_BUS_TYPE,
    RawPropertiesLength   : DWORD,
    RawDeviceProperties   : [1]BYTE,
};
PSTORAGE_DEVICE_DESCRIPTOR :: ^STORAGE_DEVICE_DESCRIPTOR;

STORAGE_ADAPTER_DESCRIPTOR :: struct {
    Version               : DWORD,
    Size                  : DWORD,
    MaximumTransferLength : DWORD,
    MaximumPhysicalPages  : DWORD,
    AlignmentMask         : DWORD,
    AdapterUsesPio        : BOOLEAN,
    AdapterScansDown      : BOOLEAN,
    CommandQueueing       : BOOLEAN,
    AcceleratedTransfer   : BOOLEAN,
    BusType               : BYTE,
    BusMajorVersion       : WORD,
    BusMinorVersion       : WORD,
    SrbType               : BYTE,
    AddressType           : BYTE,
};
PSTORAGE_ADAPTER_DESCRIPTOR :: ^STORAGE_ADAPTER_DESCRIPTOR;

STORAGE_ACCESS_ALIGNMENT_DESCRIPTOR :: struct {
    Version                       : DWORD,
    Size                          : DWORD,
    BytesPerCacheLine             : DWORD,
    BytesOffsetForCacheAlignment  : DWORD,
    BytesPerLogicalSector         : DWORD,
    BytesPerPhysicalSector        : DWORD,
    BytesOffsetForSectorAlignment : DWORD,
};
PSTORAGE_ACCESS_ALIGNMENT_DESCRIPTOR :: ^STORAGE_ACCESS_ALIGNMENT_DESCRIPTOR;

STORAGE_MEDIUM_PRODUCT_TYPE_DESCRIPTOR :: struct {
    Version           : DWORD,
    Size              : DWORD,
    MediumProductType : DWORD,
};
PSTORAGE_MEDIUM_PRODUCT_TYPE_DESCRIPTOR :: ^STORAGE_MEDIUM_PRODUCT_TYPE_DESCRIPTOR;

/* STORAGE_PORT_CODE_SET :: enum { */
STORAGE_PORT_CODE_SET :: _c.int;
    StoragePortCodeSetReserved :: 0;
    StoragePortCodeSetStorport :: 1;
    StoragePortCodeSetSCSIport :: 2;
    StoragePortCodeSetSpaceport :: 3;
    StoragePortCodeSetATAport :: 4;
    StoragePortCodeSetUSBport :: 5;
    StoragePortCodeSetSBP2port :: 6;
    StoragePortCodeSetSDport :: 7;
/* } */
PSTORAGE_PORT_CODE_SET :: ^STORAGE_PORT_CODE_SET;

STORAGE_MINIPORT_DESCRIPTOR :: struct {
    Version              : DWORD,
    Size                 : DWORD,
    Portdriver           : STORAGE_PORT_CODE_SET,
    LUNResetSupported    : BOOLEAN,
    TargetResetSupported : BOOLEAN,
    IoTimeoutValue       : WORD,
    ExtraIoInfoSupported : BOOLEAN,
    Reserved0            : [3]BYTE,
    Reserved1            : DWORD,
};
PSTORAGE_MINIPORT_DESCRIPTOR :: ^STORAGE_MINIPORT_DESCRIPTOR;

/* STORAGE_IDENTIFIER_CODE_SET :: enum { */
STORAGE_IDENTIFIER_CODE_SET :: _c.int;
    StorageIdCodeSetReserved :: 0;
    StorageIdCodeSetBinary :: 1;
    StorageIdCodeSetAscii :: 2;
    StorageIdCodeSetUtf8 :: 3;
/* } */
PSTORAGE_IDENTIFIER_CODE_SET :: ^STORAGE_IDENTIFIER_CODE_SET;

/* STORAGE_IDENTIFIER_TYPE :: enum { */
STORAGE_IDENTIFIER_TYPE :: _c.int;
    StorageIdTypeVendorSpecific :: 0;
    StorageIdTypeVendorId :: 1;
    StorageIdTypeEUI64 :: 2;
    StorageIdTypeFCPHName :: 3;
    StorageIdTypePortRelative :: 4;
    StorageIdTypeTargetPortGroup :: 5;
    StorageIdTypeLogicalUnitGroup :: 6;
    StorageIdTypeMD5LogicalUnitIdentifier :: 7;
    StorageIdTypeScsiNameString :: 8;
/* } */
PSTORAGE_IDENTIFIER_TYPE :: ^STORAGE_IDENTIFIER_TYPE;

/* STORAGE_ID_NAA_FORMAT :: enum { */
STORAGE_ID_NAA_FORMAT :: _c.int;
    StorageIdNAAFormatIEEEExtended :: 2;
    StorageIdNAAFormatIEEERegistered :: 3;
    StorageIdNAAFormatIEEEERegisteredExtended :: 5;
/* } */
PSTORAGE_ID_NAA_FORMAT :: ^STORAGE_ID_NAA_FORMAT;

/* STORAGE_ASSOCIATION_TYPE :: enum { */
STORAGE_ASSOCIATION_TYPE :: _c.int;
    StorageIdAssocDevice :: 0;
    StorageIdAssocPort :: 1;
    StorageIdAssocTarget :: 2;
/* } */
PSTORAGE_ASSOCIATION_TYPE :: ^STORAGE_ASSOCIATION_TYPE;

STORAGE_IDENTIFIER :: struct {
    CodeSet        : STORAGE_IDENTIFIER_CODE_SET,
    Type           : STORAGE_IDENTIFIER_TYPE,
    IdentifierSize : WORD,
    NextOffset     : WORD,
    Association    : STORAGE_ASSOCIATION_TYPE,
    Identifier     : [1]BYTE,
};
PSTORAGE_IDENTIFIER :: ^STORAGE_IDENTIFIER;

STORAGE_DEVICE_ID_DESCRIPTOR :: struct {
    Version             : DWORD,
    Size                : DWORD,
    NumberOfIdentifiers : DWORD,
    Identifiers         : [1]BYTE,
};
PSTORAGE_DEVICE_ID_DESCRIPTOR :: ^STORAGE_DEVICE_ID_DESCRIPTOR;

DEVICE_SEEK_PENALTY_DESCRIPTOR :: struct {
    Version           : DWORD,
    Size              : DWORD,
    IncursSeekPenalty : BOOLEAN,
};
PDEVICE_SEEK_PENALTY_DESCRIPTOR :: ^DEVICE_SEEK_PENALTY_DESCRIPTOR;

DEVICE_WRITE_AGGREGATION_DESCRIPTOR :: struct {
    Version                      : DWORD,
    Size                         : DWORD,
    BenefitsFromWriteAggregation : BOOLEAN,
};
PDEVICE_WRITE_AGGREGATION_DESCRIPTOR :: ^DEVICE_WRITE_AGGREGATION_DESCRIPTOR;

DEVICE_TRIM_DESCRIPTOR :: struct {
    Version     : DWORD,
    Size        : DWORD,
    TrimEnabled : BOOLEAN,
};
PDEVICE_TRIM_DESCRIPTOR :: ^DEVICE_TRIM_DESCRIPTOR;

DEVICE_LB_PROVISIONING_DESCRIPTOR :: struct {
    Version                        : DWORD,
    Size                           : DWORD,
    using _ : bit_field {
        ThinProvisioningEnabled        : 1,
        ThinProvisioningReadZeros      : 1,
        AnchorSupported                : 3,
        UnmapGranularityAlignmentValid : 1,
        Reserved0                      : 2,
    },
    Reserved1                      : [7]BYTE,
    OptimalUnmapGranularity        : DWORDLONG,
    UnmapGranularityAlignment      : DWORDLONG,
    MaxUnmapLbaCount               : DWORD,
    MaxUnmapBlockDescriptorCount   : DWORD,
};
PDEVICE_LB_PROVISIONING_DESCRIPTOR :: ^DEVICE_LB_PROVISIONING_DESCRIPTOR;

STORAGE_LB_PROVISIONING_MAP_RESOURCES :: struct {
    Size                           : DWORD,
    Version                        : DWORD,
    using _ : bit_field {
        AvailableMappingResourcesValid : 1,
        UsedMappingResourcesValid      : 1,
        Reserved0                      : 6,
    },
    Reserved1                      : [3]BYTE,
    using _ : bit_field {
        AvailableMappingResourcesScope : 2,
        UsedMappingResourcesScope      : 2,
        Reserved2                      : 4,
    },
    Reserved3                      : [3]BYTE,
    AvailableMappingResources      : DWORDLONG,
    UsedMappingResources           : DWORDLONG,
};
PSTORAGE_LB_PROVISIONING_MAP_RESOURCES :: ^STORAGE_LB_PROVISIONING_MAP_RESOURCES;

DEVICE_POWER_DESCRIPTOR :: struct {
    Version                           : DWORD,
    Size                              : DWORD,
    DeviceAttentionSupported          : BOOLEAN,
    AsynchronousNotificationSupported : BOOLEAN,
    IdlePowerManagementEnabled        : BOOLEAN,
    D3ColdEnabled                     : BOOLEAN,
    D3ColdSupported                   : BOOLEAN,
    NoVerifyDuringIdlePower           : BOOLEAN,
    Reserved                          : [2]BYTE,
    IdleTimeoutInMS                   : DWORD,
};
PDEVICE_POWER_DESCRIPTOR :: ^DEVICE_POWER_DESCRIPTOR;

DEVICE_COPY_OFFLOAD_DESCRIPTOR :: struct {
    Version                            : DWORD,
    Size                               : DWORD,
    MaximumTokenLifetime               : DWORD,
    DefaultTokenLifetime               : DWORD,
    MaximumTransferSize                : DWORDLONG,
    OptimalTransferCount               : DWORDLONG,
    MaximumDataDescriptors             : DWORD,
    MaximumTransferLengthPerDescriptor : DWORD,
    OptimalTransferLengthPerDescriptor : DWORD,
    OptimalTransferLengthGranularity   : WORD,
    Reserved                           : [2]BYTE,
};
PDEVICE_COPY_OFFLOAD_DESCRIPTOR :: ^DEVICE_COPY_OFFLOAD_DESCRIPTOR;

STORAGE_DEVICE_RESILIENCY_DESCRIPTOR :: struct {
    Version                : DWORD,
    Size                   : DWORD,
    NameOffset             : DWORD,
    NumberOfLogicalCopies  : DWORD,
    NumberOfPhysicalCopies : DWORD,
    PhysicalDiskRedundancy : DWORD,
    NumberOfColumns        : DWORD,
    Interleave             : DWORD,
};
PSTORAGE_DEVICE_RESILIENCY_DESCRIPTOR :: ^STORAGE_DEVICE_RESILIENCY_DESCRIPTOR;

/* STORAGE_RPMB_FRAME_TYPE :: enum { */
STORAGE_RPMB_FRAME_TYPE :: _c.int;
    StorageRpmbFrameTypeUnknown :: 0;
    StorageRpmbFrameTypeStandard :: StorageRpmbFrameTypeUnknown + 1;
    StorageRpmbFrameTypeMax :: StorageRpmbFrameTypeStandard + 1;
/* } */
PSTORAGE_RPMB_FRAME_TYPE :: ^STORAGE_RPMB_FRAME_TYPE;

STORAGE_RPMB_DESCRIPTOR :: struct {
    Version                     : DWORD,
    Size                        : DWORD,
    SizeInBytes                 : DWORD,
    MaxReliableWriteSizeInBytes : DWORD,
    FrameFormat                 : STORAGE_RPMB_FRAME_TYPE,
};
PSTORAGE_RPMB_DESCRIPTOR :: ^STORAGE_RPMB_DESCRIPTOR;

/* STORAGE_CRYPTO_ALGORITHM_ID :: enum { */
STORAGE_CRYPTO_ALGORITHM_ID :: _c.int;
    StorageCryptoAlgorithmUnknown :: 0;
    StorageCryptoAlgorithmXTSAES :: 1;
    StorageCryptoAlgorithmBitlockerAESCBC :: StorageCryptoAlgorithmXTSAES + 1;
    StorageCryptoAlgorithmAESECB :: StorageCryptoAlgorithmBitlockerAESCBC + 1;
    StorageCryptoAlgorithmESSIVAESCBC :: StorageCryptoAlgorithmAESECB + 1;
    StorageCryptoAlgorithmMax :: StorageCryptoAlgorithmESSIVAESCBC + 1;
/* } */
PSTORAGE_CRYPTO_ALGORITHM_ID :: ^STORAGE_CRYPTO_ALGORITHM_ID;

/* STORAGE_CRYPTO_KEY_SIZE :: enum { */
STORAGE_CRYPTO_KEY_SIZE :: _c.int;
    StorageCryptoKeySizeUnknown :: 0;
    StorageCryptoKeySize128Bits :: 1;
    StorageCryptoKeySize192Bits :: StorageCryptoKeySize128Bits + 1;
    StorageCryptoKeySize256Bits :: StorageCryptoKeySize192Bits + 1;
    StorageCryptoKeySize512Bits :: StorageCryptoKeySize256Bits + 1;
/* } */
PSTORAGE_CRYPTO_KEY_SIZE :: ^STORAGE_CRYPTO_KEY_SIZE;

STORAGE_CRYPTO_CAPABILITY :: struct {
    Version               : DWORD,
    Size                  : DWORD,
    CryptoCapabilityIndex : DWORD,
    AlgorithmId           : STORAGE_CRYPTO_ALGORITHM_ID,
    KeySize               : STORAGE_CRYPTO_KEY_SIZE,
    DataUnitSizeBitmask   : DWORD,
};
PSTORAGE_CRYPTO_CAPABILITY :: ^STORAGE_CRYPTO_CAPABILITY;

STORAGE_CRYPTO_DESCRIPTOR :: struct {
    Version               : DWORD,
    Size                  : DWORD,
    NumKeysSupported      : DWORD,
    NumCryptoCapabilities : DWORD,
    CryptoCapabilities    : [1]STORAGE_CRYPTO_CAPABILITY,
};
PSTORAGE_CRYPTO_DESCRIPTOR :: ^STORAGE_CRYPTO_DESCRIPTOR;

/* STORAGE_TIER_MEDIA_TYPE :: enum { */
STORAGE_TIER_MEDIA_TYPE :: _c.int;
    StorageTierMediaTypeUnspecified :: 0;
    StorageTierMediaTypeDisk :: 1;
    StorageTierMediaTypeSsd :: 2;
    StorageTierMediaTypeScm :: 4;
    StorageTierMediaTypeMax :: StorageTierMediaTypeScm + 1;
/* } */
PSTORAGE_TIER_MEDIA_TYPE :: ^STORAGE_TIER_MEDIA_TYPE;

/* STORAGE_TIER_CLASS :: enum { */
STORAGE_TIER_CLASS :: _c.int;
    StorageTierClassUnspecified :: 0;
    StorageTierClassCapacity :: StorageTierClassUnspecified + 1;
    StorageTierClassPerformance :: StorageTierClassCapacity + 1;
    StorageTierClassMax :: StorageTierClassPerformance + 1;
/* } */
PSTORAGE_TIER_CLASS :: ^STORAGE_TIER_CLASS;

STORAGE_TIER :: struct {
    Id                  : GUID,
    Name                : [(256)]WCHAR,
    Description         : [(256)]WCHAR,
    Flags               : DWORDLONG,
    ProvisionedCapacity : DWORDLONG,
    MediaType           : STORAGE_TIER_MEDIA_TYPE,
    Class               : STORAGE_TIER_CLASS,
};
PSTORAGE_TIER :: ^STORAGE_TIER;

STORAGE_DEVICE_TIERING_DESCRIPTOR :: struct {
    Version               : DWORD,
    Size                  : DWORD,
    Flags                 : DWORD,
    TotalNumberOfTiers    : DWORD,
    NumberOfTiersReturned : DWORD,
    Tiers                 : [1]STORAGE_TIER,
};
PSTORAGE_DEVICE_TIERING_DESCRIPTOR :: ^STORAGE_DEVICE_TIERING_DESCRIPTOR;

STORAGE_DEVICE_FAULT_DOMAIN_DESCRIPTOR :: struct {
    Version              : DWORD,
    Size                 : DWORD,
    NumberOfFaultDomains : DWORD,
    FaultDomainIds       : [1]GUID,
};
PSTORAGE_DEVICE_FAULT_DOMAIN_DESCRIPTOR :: ^STORAGE_DEVICE_FAULT_DOMAIN_DESCRIPTOR;

/* STORAGE_PROTOCOL_TYPE :: enum { */
STORAGE_PROTOCOL_TYPE :: _c.int;
    ProtocolTypeUnknown :: 0x00;
    ProtocolTypeScsi :: ProtocolTypeUnknown + 1;
    ProtocolTypeAta :: ProtocolTypeScsi + 1;
    ProtocolTypeNvme :: ProtocolTypeAta + 1;
    ProtocolTypeSd :: ProtocolTypeNvme + 1;
    ProtocolTypeUfs :: ProtocolTypeSd + 1;
    ProtocolTypeProprietary :: 0x7E;
    ProtocolTypeMaxReserved :: 0x7F;
/* } */
PSTORAGE_PROTOCOL_TYPE :: ^STORAGE_PROTOCOL_TYPE;

/* STORAGE_PROTOCOL_NVME_DATA_TYPE :: enum { */
STORAGE_PROTOCOL_NVME_DATA_TYPE :: _c.int;
    NVMeDataTypeUnknown :: 0;
    NVMeDataTypeIdentify :: NVMeDataTypeUnknown + 1;
    NVMeDataTypeLogPage :: NVMeDataTypeIdentify + 1;
    NVMeDataTypeFeature :: NVMeDataTypeLogPage + 1;
/* } */
PSTORAGE_PROTOCOL_NVME_DATA_TYPE :: ^STORAGE_PROTOCOL_NVME_DATA_TYPE;

/* STORAGE_PROTOCOL_ATA_DATA_TYPE :: enum { */
STORAGE_PROTOCOL_ATA_DATA_TYPE :: _c.int;
    AtaDataTypeUnknown :: 0;
    AtaDataTypeIdentify :: AtaDataTypeUnknown + 1;
    AtaDataTypeLogPage :: AtaDataTypeIdentify + 1;
/* } */
PSTORAGE_PROTOCOL_ATA_DATA_TYPE :: ^STORAGE_PROTOCOL_ATA_DATA_TYPE;

/* STORAGE_PROTOCOL_UFS_DATA_TYPE :: enum { */
STORAGE_PROTOCOL_UFS_DATA_TYPE :: _c.int;
    UfsDataTypeUnknown :: 0;
    UfsDataTypeQueryDescriptor :: UfsDataTypeUnknown + 1;
    UfsDataTypeMax :: UfsDataTypeQueryDescriptor + 1;
/* } */
PSTORAGE_PROTOCOL_UFS_DATA_TYPE :: ^STORAGE_PROTOCOL_UFS_DATA_TYPE;

STORAGE_PROTOCOL_SPECIFIC_DATA :: struct {
    ProtocolType                 : STORAGE_PROTOCOL_TYPE,
    DataType                     : DWORD,
    ProtocolDataRequestValue     : DWORD,
    ProtocolDataRequestSubValue  : DWORD,
    ProtocolDataOffset           : DWORD,
    ProtocolDataLength           : DWORD,
    FixedProtocolReturnData      : DWORD,
    ProtocolDataRequestSubValue2 : DWORD,
    ProtocolDataRequestSubValue3 : DWORD,
    Reserved                     : DWORD,
};
PSTORAGE_PROTOCOL_SPECIFIC_DATA :: ^STORAGE_PROTOCOL_SPECIFIC_DATA;

STORAGE_PROTOCOL_SPECIFIC_DATA_EXT :: struct {
    ProtocolType            : STORAGE_PROTOCOL_TYPE,
    DataType                : DWORD,
    ProtocolDataValue       : DWORD,
    ProtocolDataSubValue    : DWORD,
    ProtocolDataOffset      : DWORD,
    ProtocolDataLength      : DWORD,
    FixedProtocolReturnData : DWORD,
    ProtocolDataSubValue2   : DWORD,
    ProtocolDataSubValue3   : DWORD,
    ProtocolDataSubValue4   : DWORD,
    ProtocolDataSubValue5   : DWORD,
    Reserved                : [5]DWORD,
};
PSTORAGE_PROTOCOL_SPECIFIC_DATA_EXT :: ^STORAGE_PROTOCOL_SPECIFIC_DATA_EXT;

STORAGE_PROTOCOL_DATA_DESCRIPTOR :: struct {
    Version              : DWORD,
    Size                 : DWORD,
    ProtocolSpecificData : STORAGE_PROTOCOL_SPECIFIC_DATA,
};
PSTORAGE_PROTOCOL_DATA_DESCRIPTOR :: ^STORAGE_PROTOCOL_DATA_DESCRIPTOR;

STORAGE_PROTOCOL_DATA_DESCRIPTOR_EXT :: struct {
    Version              : DWORD,
    Size                 : DWORD,
    ProtocolSpecificData : STORAGE_PROTOCOL_SPECIFIC_DATA_EXT,
};
PSTORAGE_PROTOCOL_DATA_DESCRIPTOR_EXT :: ^STORAGE_PROTOCOL_DATA_DESCRIPTOR_EXT;

STORAGE_TEMPERATURE_INFO :: struct {
    Index                   : WORD,
    Temperature             : SHORT,
    OverThreshold           : SHORT,
    UnderThreshold          : SHORT,
    OverThresholdChangable  : BOOLEAN,
    UnderThresholdChangable : BOOLEAN,
    EventGenerated          : BOOLEAN,
    Reserved0               : BYTE,
    Reserved1               : DWORD,
};
PSTORAGE_TEMPERATURE_INFO :: ^STORAGE_TEMPERATURE_INFO;

STORAGE_TEMPERATURE_DATA_DESCRIPTOR :: struct {
    Version             : DWORD,
    Size                : DWORD,
    CriticalTemperature : SHORT,
    WarningTemperature  : SHORT,
    InfoCount           : WORD,
    Reserved0           : [2]BYTE,
    Reserved1           : [2]DWORD,
    TemperatureInfo     : [1]STORAGE_TEMPERATURE_INFO,
};
PSTORAGE_TEMPERATURE_DATA_DESCRIPTOR :: ^STORAGE_TEMPERATURE_DATA_DESCRIPTOR;

STORAGE_TEMPERATURE_THRESHOLD :: struct {
    Version       : DWORD,
    Size          : DWORD,
    Flags         : WORD,
    Index         : WORD,
    Threshold     : SHORT,
    OverThreshold : BOOLEAN,
    Reserved      : BYTE,
};
PSTORAGE_TEMPERATURE_THRESHOLD :: ^STORAGE_TEMPERATURE_THRESHOLD;

/* STORAGE_DEVICE_FORM_FACTOR :: enum { */
STORAGE_DEVICE_FORM_FACTOR :: _c.int;
    FormFactorUnknown :: 0;
    FormFactor3_5 :: FormFactorUnknown + 1;
    FormFactor2_5 :: FormFactor3_5 + 1;
    FormFactor1_8 :: FormFactor2_5 + 1;
    FormFactor1_8Less :: FormFactor1_8 + 1;
    FormFactorEmbedded :: FormFactor1_8Less + 1;
    FormFactorMemoryCard :: FormFactorEmbedded + 1;
    FormFactormSata :: FormFactorMemoryCard + 1;
    FormFactorM_2 :: FormFactormSata + 1;
    FormFactorPCIeBoard :: FormFactorM_2 + 1;
    FormFactorDimm :: FormFactorPCIeBoard + 1;
/* } */
PSTORAGE_DEVICE_FORM_FACTOR :: ^STORAGE_DEVICE_FORM_FACTOR;

/* STORAGE_COMPONENT_HEALTH_STATUS :: enum { */
STORAGE_COMPONENT_HEALTH_STATUS :: _c.int;
    HealthStatusUnknown :: 0;
    HealthStatusNormal :: HealthStatusUnknown + 1;
    HealthStatusThrottled :: HealthStatusNormal + 1;
    HealthStatusWarning :: HealthStatusThrottled + 1;
    HealthStatusDisabled :: HealthStatusWarning + 1;
    HealthStatusFailed :: HealthStatusDisabled + 1;
/* } */
PSTORAGE_COMPONENT_HEALTH_STATUS :: ^STORAGE_COMPONENT_HEALTH_STATUS;

STORAGE_SPEC_VERSION :: struct #raw_union {
    s : struct {
        MinorVersion : struct #raw_union {
            s : struct {
                SubMinor : BYTE,
                Minor    : BYTE,
            },
            AsUshort : WORD,
        },
        MajorVersion : WORD,
    },
    AsUlong : DWORD,
};
PSTORAGE_SPEC_VERSION :: ^STORAGE_SPEC_VERSION;

STORAGE_PHYSICAL_DEVICE_DATA :: struct {
    DeviceId         : DWORD,
    Role             : DWORD,
    HealthStatus     : STORAGE_COMPONENT_HEALTH_STATUS,
    CommandProtocol  : STORAGE_PROTOCOL_TYPE,
    SpecVersion      : STORAGE_SPEC_VERSION,
    FormFactor       : STORAGE_DEVICE_FORM_FACTOR,
    Vendor           : [8]BYTE,
    Model            : [40]BYTE,
    FirmwareRevision : [16]BYTE,
    Capacity         : DWORDLONG,
    PhysicalLocation : [32]BYTE,
    Reserved         : [2]DWORD,
};
PSTORAGE_PHYSICAL_DEVICE_DATA :: ^STORAGE_PHYSICAL_DEVICE_DATA;

STORAGE_PHYSICAL_ADAPTER_DATA :: struct {
    AdapterId         : DWORD,
    HealthStatus      : STORAGE_COMPONENT_HEALTH_STATUS,
    CommandProtocol   : STORAGE_PROTOCOL_TYPE,
    SpecVersion       : STORAGE_SPEC_VERSION,
    Vendor            : [8]BYTE,
    Model             : [40]BYTE,
    FirmwareRevision  : [16]BYTE,
    PhysicalLocation  : [32]BYTE,
    ExpanderConnected : BOOLEAN,
    Reserved0         : [3]BYTE,
    Reserved1         : [3]DWORD,
};
PSTORAGE_PHYSICAL_ADAPTER_DATA :: ^STORAGE_PHYSICAL_ADAPTER_DATA;

STORAGE_PHYSICAL_NODE_DATA :: struct {
    NodeId            : DWORD,
    AdapterCount      : DWORD,
    AdapterDataLength : DWORD,
    AdapterDataOffset : DWORD,
    DeviceCount       : DWORD,
    DeviceDataLength  : DWORD,
    DeviceDataOffset  : DWORD,
    Reserved          : [3]DWORD,
};
PSTORAGE_PHYSICAL_NODE_DATA :: ^STORAGE_PHYSICAL_NODE_DATA;

STORAGE_PHYSICAL_TOPOLOGY_DESCRIPTOR :: struct {
    Version   : DWORD,
    Size      : DWORD,
    NodeCount : DWORD,
    Reserved  : DWORD,
    Node      : [1]STORAGE_PHYSICAL_NODE_DATA,
};
PSTORAGE_PHYSICAL_TOPOLOGY_DESCRIPTOR :: ^STORAGE_PHYSICAL_TOPOLOGY_DESCRIPTOR;

STORAGE_DEVICE_IO_CAPABILITY_DESCRIPTOR :: struct {
    Version           : DWORD,
    Size              : DWORD,
    LunMaxIoCount     : DWORD,
    AdapterMaxIoCount : DWORD,
};
PSTORAGE_DEVICE_IO_CAPABILITY_DESCRIPTOR :: ^STORAGE_DEVICE_IO_CAPABILITY_DESCRIPTOR;

STORAGE_DEVICE_ATTRIBUTES_DESCRIPTOR :: struct {
    Version    : DWORD,
    Size       : DWORD,
    Attributes : DWORD64,
};
PSTORAGE_DEVICE_ATTRIBUTES_DESCRIPTOR :: ^STORAGE_DEVICE_ATTRIBUTES_DESCRIPTOR;

/* STORAGE_DISK_HEALTH_STATUS :: enum { */
STORAGE_DISK_HEALTH_STATUS :: _c.int;
    DiskHealthUnknown :: 0;
    DiskHealthUnhealthy :: DiskHealthUnknown + 1;
    DiskHealthWarning :: DiskHealthUnhealthy + 1;
    DiskHealthHealthy :: DiskHealthWarning + 1;
    DiskHealthMax :: DiskHealthHealthy + 1;
/* } */
PSTORAGE_DISK_HEALTH_STATUS :: ^STORAGE_DISK_HEALTH_STATUS;

/* STORAGE_DISK_OPERATIONAL_STATUS :: enum { */
STORAGE_DISK_OPERATIONAL_STATUS :: _c.int;
    DiskOpStatusNone :: 0;
    DiskOpStatusUnknown :: DiskOpStatusNone + 1;
    DiskOpStatusOk :: DiskOpStatusUnknown + 1;
    DiskOpStatusPredictingFailure :: DiskOpStatusOk + 1;
    DiskOpStatusInService :: DiskOpStatusPredictingFailure + 1;
    DiskOpStatusHardwareError :: DiskOpStatusInService + 1;
    DiskOpStatusNotUsable :: DiskOpStatusHardwareError + 1;
    DiskOpStatusTransientError :: DiskOpStatusNotUsable + 1;
    DiskOpStatusMissing :: DiskOpStatusTransientError + 1;
/* } */
PSTORAGE_DISK_OPERATIONAL_STATUS :: ^STORAGE_DISK_OPERATIONAL_STATUS;

/* STORAGE_OPERATIONAL_STATUS_REASON :: enum { */
STORAGE_OPERATIONAL_STATUS_REASON :: _c.int;
    DiskOpReasonUnknown :: 0;
    DiskOpReasonScsiSenseCode :: DiskOpReasonUnknown + 1;
    DiskOpReasonMedia :: DiskOpReasonScsiSenseCode + 1;
    DiskOpReasonIo :: DiskOpReasonMedia + 1;
    DiskOpReasonThresholdExceeded :: DiskOpReasonIo + 1;
    DiskOpReasonLostData :: DiskOpReasonThresholdExceeded + 1;
    DiskOpReasonEnergySource :: DiskOpReasonLostData + 1;
    DiskOpReasonConfiguration :: DiskOpReasonEnergySource + 1;
    DiskOpReasonDeviceController :: DiskOpReasonConfiguration + 1;
    DiskOpReasonMediaController :: DiskOpReasonDeviceController + 1;
    DiskOpReasonComponent :: DiskOpReasonMediaController + 1;
    DiskOpReasonNVDIMM_N :: DiskOpReasonComponent + 1;
    DiskOpReasonBackgroundOperation :: DiskOpReasonNVDIMM_N + 1;
    DiskOpReasonInvalidFirmware :: DiskOpReasonBackgroundOperation + 1;
    DiskOpReasonHealthCheck :: DiskOpReasonInvalidFirmware + 1;
    DiskOpReasonLostDataPersistence :: DiskOpReasonHealthCheck + 1;
    DiskOpReasonDisabledByPlatform :: DiskOpReasonLostDataPersistence + 1;
    DiskOpReasonLostWritePersistence :: DiskOpReasonDisabledByPlatform + 1;
    DiskOpReasonDataPersistenceLossImminent :: DiskOpReasonLostWritePersistence + 1;
    DiskOpReasonWritePersistenceLossImminent :: DiskOpReasonDataPersistenceLossImminent + 1;
    DiskOpReasonMax :: DiskOpReasonWritePersistenceLossImminent + 1;
/* } */
PSTORAGE_OPERATIONAL_STATUS_REASON :: ^STORAGE_OPERATIONAL_STATUS_REASON;

STORAGE_OPERATIONAL_REASON :: struct {
    Version  : DWORD,
    Size     : DWORD,
    Reason   : STORAGE_OPERATIONAL_STATUS_REASON,
    RawBytes : struct #raw_union {
        ScsiSenseKey : struct {
            SenseKey : BYTE,
            ASC      : BYTE,
            ASCQ     : BYTE,
            Reserved : BYTE,
        },
        NVDIMM_N : struct {
            CriticalHealth       : BYTE,
            ModuleHealth         : [2]BYTE,
            ErrorThresholdStatus : BYTE,
        },
        AsUlong      : DWORD,
    },
};
PSTORAGE_OPERATIONAL_REASON :: ^STORAGE_OPERATIONAL_REASON;

STORAGE_DEVICE_MANAGEMENT_STATUS :: struct {
    Version                   : DWORD,
    Size                      : DWORD,
    Health                    : STORAGE_DISK_HEALTH_STATUS,
    NumberOfOperationalStatus : DWORD,
    NumberOfAdditionalReasons : DWORD,
    OperationalStatus         : [16]STORAGE_DISK_OPERATIONAL_STATUS,
    AdditionalReasons         : [1]STORAGE_OPERATIONAL_REASON,
};
PSTORAGE_DEVICE_MANAGEMENT_STATUS :: ^STORAGE_DEVICE_MANAGEMENT_STATUS;

STORAGE_ADAPTER_SERIAL_NUMBER :: struct {
    Version      : DWORD,
    Size         : DWORD,
    SerialNumber : [(128)]WCHAR,
};
PSTORAGE_ADAPTER_SERIAL_NUMBER :: ^STORAGE_ADAPTER_SERIAL_NUMBER;

/* STORAGE_ZONED_DEVICE_TYPES :: enum { */
STORAGE_ZONED_DEVICE_TYPES :: _c.int;
    ZonedDeviceTypeUnknown :: 0;
    ZonedDeviceTypeHostManaged :: ZonedDeviceTypeUnknown + 1;
    ZonedDeviceTypeHostAware :: ZonedDeviceTypeHostManaged + 1;
    ZonedDeviceTypeDeviceManaged :: ZonedDeviceTypeHostAware + 1;
/* } */
PSTORAGE_ZONED_DEVICE_TYPES :: ^STORAGE_ZONED_DEVICE_TYPES;

/* STORAGE_ZONE_TYPES :: enum { */
STORAGE_ZONE_TYPES :: _c.int;
    ZoneTypeUnknown :: 0;
    ZoneTypeConventional :: 1;
    ZoneTypeSequentialWriteRequired :: 2;
    ZoneTypeSequentialWritePreferred :: 3;
    ZoneTypeMax :: ZoneTypeSequentialWritePreferred + 1;
/* } */
PSTORAGE_ZONE_TYPES :: ^STORAGE_ZONE_TYPES;

STORAGE_ZONE_GROUP :: struct {
    ZoneCount : DWORD,
    ZoneType  : STORAGE_ZONE_TYPES,
    ZoneSize  : DWORDLONG,
};
PSTORAGE_ZONE_GROUP :: ^STORAGE_ZONE_GROUP;

STORAGE_ZONED_DEVICE_DESCRIPTOR :: struct {
    Version        : DWORD,
    Size           : DWORD,
    DeviceType     : STORAGE_ZONED_DEVICE_TYPES,
    ZoneCount      : DWORD,
    ZoneAttributes : struct #raw_union {
        SequentialRequiredZone : struct {
            MaxOpenZoneCount : DWORD,
            UnrestrictedRead : BOOLEAN,
            Reserved         : [3]BYTE,
        },
        SequentialPreferredZone : struct {
            OptimalOpenZoneCount : DWORD,
            Reserved             : DWORD,
        },
    },
    ZoneGroupCount : DWORD,
    ZoneGroup      : [1]STORAGE_ZONE_GROUP,
};
PSTORAGE_ZONED_DEVICE_DESCRIPTOR :: ^STORAGE_ZONED_DEVICE_DESCRIPTOR;

DEVICE_LOCATION :: struct {
    Socket  : DWORD,
    Slot    : DWORD,
    Adapter : DWORD,
    Port    : DWORD,
    u : struct #raw_union {
        s : struct {
            Channel : DWORD,
            Device  : DWORD,
        },
        s2 : struct {
            Target : DWORD,
            Lun    : DWORD,
        },
    },
};
PDEVICE_LOCATION :: ^DEVICE_LOCATION;

STORAGE_DEVICE_LOCATION_DESCRIPTOR :: struct {
    Version      : DWORD,
    Size         : DWORD,
    Location     : DEVICE_LOCATION,
    StringOffset : DWORD,
};
PSTORAGE_DEVICE_LOCATION_DESCRIPTOR :: ^STORAGE_DEVICE_LOCATION_DESCRIPTOR;

STORAGE_DEVICE_NUMA_PROPERTY :: struct {
    Version  : DWORD,
    Size     : DWORD,
    NumaNode : DWORD,
};
PSTORAGE_DEVICE_NUMA_PROPERTY :: ^STORAGE_DEVICE_NUMA_PROPERTY;

STORAGE_DEVICE_UNSAFE_SHUTDOWN_COUNT :: struct {
    Version             : DWORD,
    Size                : DWORD,
    UnsafeShutdownCount : DWORD,
};
PSTORAGE_DEVICE_UNSAFE_SHUTDOWN_COUNT :: ^STORAGE_DEVICE_UNSAFE_SHUTDOWN_COUNT;

STORAGE_HW_ENDURANCE_INFO :: struct {
    ValidFields    : DWORD,
    GroupId        : DWORD,
    Flags : bit_field {
        Shared   : 1,
        Reserved : 31,
    },
    LifePercentage : DWORD,
    BytesReadCount : [16]BYTE,
    ByteWriteCount : [16]BYTE,
};
PSTORAGE_HW_ENDURANCE_INFO :: ^STORAGE_HW_ENDURANCE_INFO;

STORAGE_HW_ENDURANCE_DATA_DESCRIPTOR :: struct {
    Version       : DWORD,
    Size          : DWORD,
    EnduranceInfo : STORAGE_HW_ENDURANCE_INFO,
};
PSTORAGE_HW_ENDURANCE_DATA_DESCRIPTOR :: ^STORAGE_HW_ENDURANCE_DATA_DESCRIPTOR;

DEVICE_DATA_MANAGEMENT_SET_ACTION :: DWORD;
DEVICE_DSM_ACTION :: DWORD;

DEVICE_DATA_SET_RANGE :: struct {
    StartingOffset : LONGLONG,
    LengthInBytes  : DWORDLONG,
};
PDEVICE_DATA_SET_RANGE :: ^DEVICE_DATA_SET_RANGE;
DEVICE_DSM_RANGE :: struct {
    StartingOffset : LONGLONG,
    LengthInBytes  : DWORDLONG,
};
PDEVICE_DSM_RANGE :: ^DEVICE_DSM_RANGE;

DEVICE_MANAGE_DATA_SET_ATTRIBUTES :: struct {
    Size                 : DWORD,
    Action               : DEVICE_DSM_ACTION,
    Flags                : DWORD,
    ParameterBlockOffset : DWORD,
    ParameterBlockLength : DWORD,
    DataSetRangesOffset  : DWORD,
    DataSetRangesLength  : DWORD,
};
PDEVICE_MANAGE_DATA_SET_ATTRIBUTES :: ^DEVICE_MANAGE_DATA_SET_ATTRIBUTES;
DEVICE_DSM_INPUT :: struct {
    Size                 : DWORD,
    Action               : DEVICE_DSM_ACTION,
    Flags                : DWORD,
    ParameterBlockOffset : DWORD,
    ParameterBlockLength : DWORD,
    DataSetRangesOffset  : DWORD,
    DataSetRangesLength  : DWORD,
};
PDEVICE_DSM_INPUT :: ^DEVICE_DSM_INPUT;

DEVICE_MANAGE_DATA_SET_ATTRIBUTES_OUTPUT :: struct {
    Size                : DWORD,
    Action              : DEVICE_DSM_ACTION,
    Flags               : DWORD,
    OperationStatus     : DWORD,
    ExtendedError       : DWORD,
    TargetDetailedError : DWORD,
    ReservedStatus      : DWORD,
    OutputBlockOffset   : DWORD,
    OutputBlockLength   : DWORD,
};
PDEVICE_MANAGE_DATA_SET_ATTRIBUTES_OUTPUT :: ^DEVICE_MANAGE_DATA_SET_ATTRIBUTES_OUTPUT;
DEVICE_DSM_OUTPUT :: struct {
    Size                : DWORD,
    Action              : DEVICE_DSM_ACTION,
    Flags               : DWORD,
    OperationStatus     : DWORD,
    ExtendedError       : DWORD,
    TargetDetailedError : DWORD,
    ReservedStatus      : DWORD,
    OutputBlockOffset   : DWORD,
    OutputBlockLength   : DWORD,
};
PDEVICE_DSM_OUTPUT :: ^DEVICE_DSM_OUTPUT;

DEVICE_DSM_DEFINITION :: struct {
    Action                  : DEVICE_DSM_ACTION,
    SingleRange             : BOOLEAN,
    ParameterBlockAlignment : DWORD,
    ParameterBlockLength    : DWORD,
    HasOutput               : BOOLEAN,
    OutputBlockAlignment    : DWORD,
    OutputBlockLength       : DWORD,
};
PDEVICE_DSM_DEFINITION :: ^DEVICE_DSM_DEFINITION;

DEVICE_DSM_NOTIFICATION_PARAMETERS :: struct {
    Size           : DWORD,
    Flags          : DWORD,
    NumFileTypeIDs : DWORD,
    FileTypeID     : [1]GUID,
};
PDEVICE_DSM_NOTIFICATION_PARAMETERS :: ^DEVICE_DSM_NOTIFICATION_PARAMETERS;

STORAGE_OFFLOAD_TOKEN :: struct {
    TokenType     : [4]BYTE,
    Reserved      : [2]BYTE,
    TokenIdLength : [2]BYTE,
    u : struct #raw_union {
        StorageOffloadZeroDataToken : struct {
            Reserved2 : [0x1F8]BYTE,
        },
        Token                       : [0x1F8]BYTE,
    },
};
PSTORAGE_OFFLOAD_TOKEN :: ^STORAGE_OFFLOAD_TOKEN;

DEVICE_DSM_OFFLOAD_READ_PARAMETERS :: struct {
    Flags      : DWORD,
    TimeToLive : DWORD,
    Reserved   : [2]DWORD,
};
PDEVICE_DSM_OFFLOAD_READ_PARAMETERS :: ^DEVICE_DSM_OFFLOAD_READ_PARAMETERS;

STORAGE_OFFLOAD_READ_OUTPUT :: struct {
    OffloadReadFlags : DWORD,
    Reserved         : DWORD,
    LengthProtected  : DWORDLONG,
    TokenLength      : DWORD,
    Token            : STORAGE_OFFLOAD_TOKEN,
};
PSTORAGE_OFFLOAD_READ_OUTPUT :: ^STORAGE_OFFLOAD_READ_OUTPUT;

DEVICE_DSM_OFFLOAD_WRITE_PARAMETERS :: struct {
    Flags       : DWORD,
    Reserved    : DWORD,
    TokenOffset : DWORDLONG,
    Token       : STORAGE_OFFLOAD_TOKEN,
};
PDEVICE_DSM_OFFLOAD_WRITE_PARAMETERS :: ^DEVICE_DSM_OFFLOAD_WRITE_PARAMETERS;

STORAGE_OFFLOAD_WRITE_OUTPUT :: struct {
    OffloadWriteFlags : DWORD,
    Reserved          : DWORD,
    LengthCopied      : DWORDLONG,
};
PSTORAGE_OFFLOAD_WRITE_OUTPUT :: ^STORAGE_OFFLOAD_WRITE_OUTPUT;

DEVICE_DATA_SET_LBP_STATE_PARAMETERS :: struct {
    Version       : DWORD,
    Size          : DWORD,
    Flags         : DWORD,
    OutputVersion : DWORD,
};
PDEVICE_DATA_SET_LBP_STATE_PARAMETERS :: ^DEVICE_DATA_SET_LBP_STATE_PARAMETERS;
DEVICE_DSM_ALLOCATION_PARAMETERS :: struct {
    Version       : DWORD,
    Size          : DWORD,
    Flags         : DWORD,
    OutputVersion : DWORD,
};
PDEVICE_DSM_ALLOCATION_PARAMETERS :: ^DEVICE_DSM_ALLOCATION_PARAMETERS;

DEVICE_DATA_SET_LB_PROVISIONING_STATE :: struct {
    Size                         : DWORD,
    Version                      : DWORD,
    SlabSizeInBytes              : DWORDLONG,
    SlabOffsetDeltaInBytes       : DWORD,
    SlabAllocationBitMapBitCount : DWORD,
    SlabAllocationBitMapLength   : DWORD,
    SlabAllocationBitMap         : [1]DWORD,
};
PDEVICE_DATA_SET_LB_PROVISIONING_STATE :: ^DEVICE_DATA_SET_LB_PROVISIONING_STATE;
DEVICE_DSM_ALLOCATION_OUTPUT :: struct {
    Size                         : DWORD,
    Version                      : DWORD,
    SlabSizeInBytes              : DWORDLONG,
    SlabOffsetDeltaInBytes       : DWORD,
    SlabAllocationBitMapBitCount : DWORD,
    SlabAllocationBitMapLength   : DWORD,
    SlabAllocationBitMap         : [1]DWORD,
};
PDEVICE_DSM_ALLOCATION_OUTPUT :: ^DEVICE_DSM_ALLOCATION_OUTPUT;

DEVICE_DATA_SET_LB_PROVISIONING_STATE_V2 :: struct {
    Size                         : DWORD,
    Version                      : DWORD,
    SlabSizeInBytes              : DWORDLONG,
    SlabOffsetDeltaInBytes       : DWORDLONG,
    SlabAllocationBitMapBitCount : DWORD,
    SlabAllocationBitMapLength   : DWORD,
    SlabAllocationBitMap         : [1]DWORD,
};
PDEVICE_DATA_SET_LB_PROVISIONING_STATE_V2 :: ^DEVICE_DATA_SET_LB_PROVISIONING_STATE_V2;
DEVICE_DSM_ALLOCATION_OUTPUT2 :: struct {
    Size                         : DWORD,
    Version                      : DWORD,
    SlabSizeInBytes              : DWORDLONG,
    SlabOffsetDeltaInBytes       : DWORDLONG,
    SlabAllocationBitMapBitCount : DWORD,
    SlabAllocationBitMapLength   : DWORD,
    SlabAllocationBitMap         : [1]DWORD,
};
PDEVICE_DSM_ALLOCATION_OUTPUT2 :: ^DEVICE_DSM_ALLOCATION_OUTPUT2;

DEVICE_DATA_SET_REPAIR_PARAMETERS :: struct {
    NumberOfRepairCopies : DWORD,
    SourceCopy           : DWORD,
    RepairCopies         : [1]DWORD,
};
PDEVICE_DATA_SET_REPAIR_PARAMETERS :: ^DEVICE_DATA_SET_REPAIR_PARAMETERS;
DEVICE_DSM_REPAIR_PARAMETERS :: struct {
    NumberOfRepairCopies : DWORD,
    SourceCopy           : DWORD,
    RepairCopies         : [1]DWORD,
};
PDEVICE_DSM_REPAIR_PARAMETERS :: ^DEVICE_DSM_REPAIR_PARAMETERS;

DEVICE_DATA_SET_REPAIR_OUTPUT :: struct {
    ParityExtent : DEVICE_DSM_RANGE,
};
PDEVICE_DATA_SET_REPAIR_OUTPUT :: ^DEVICE_DATA_SET_REPAIR_OUTPUT;
DEVICE_DSM_REPAIR_OUTPUT :: struct {
    ParityExtent : DEVICE_DSM_RANGE,
};
PDEVICE_DSM_REPAIR_OUTPUT :: ^DEVICE_DSM_REPAIR_OUTPUT;

DEVICE_DATA_SET_SCRUB_OUTPUT :: struct {
    BytesProcessed : DWORDLONG,
    BytesRepaired  : DWORDLONG,
    BytesFailed    : DWORDLONG,
};
PDEVICE_DATA_SET_SCRUB_OUTPUT :: ^DEVICE_DATA_SET_SCRUB_OUTPUT;
DEVICE_DSM_SCRUB_OUTPUT :: struct {
    BytesProcessed : DWORDLONG,
    BytesRepaired  : DWORDLONG,
    BytesFailed    : DWORDLONG,
};
PDEVICE_DSM_SCRUB_OUTPUT :: ^DEVICE_DSM_SCRUB_OUTPUT;

DEVICE_DATA_SET_SCRUB_EX_OUTPUT :: struct {
    BytesProcessed : DWORDLONG,
    BytesRepaired  : DWORDLONG,
    BytesFailed    : DWORDLONG,
    ParityExtent   : DEVICE_DSM_RANGE,
};
PDEVICE_DATA_SET_SCRUB_EX_OUTPUT :: ^DEVICE_DATA_SET_SCRUB_EX_OUTPUT;
DEVICE_DSM_SCRUB_OUTPUT2 :: struct {
    BytesProcessed : DWORDLONG,
    BytesRepaired  : DWORDLONG,
    BytesFailed    : DWORDLONG,
    ParityExtent   : DEVICE_DSM_RANGE,
};
PDEVICE_DSM_SCRUB_OUTPUT2 :: ^DEVICE_DSM_SCRUB_OUTPUT2;

DEVICE_DSM_TIERING_QUERY_INPUT :: struct {
    Version         : DWORD,
    Size            : DWORD,
    Flags           : DWORD,
    NumberOfTierIds : DWORD,
    TierIds         : [1]GUID,
};
PDEVICE_DSM_TIERING_QUERY_INPUT :: ^DEVICE_DSM_TIERING_QUERY_INPUT;
DEVICE_DSM_TIERING_QUERY_PARAMETERS :: struct {
    Version         : DWORD,
    Size            : DWORD,
    Flags           : DWORD,
    NumberOfTierIds : DWORD,
    TierIds         : [1]GUID,
};
PDEVICE_DSM_TIERING_QUERY_PARAMETERS :: ^DEVICE_DSM_TIERING_QUERY_PARAMETERS;

STORAGE_TIER_REGION :: struct {
    TierId : GUID,
    Offset : DWORDLONG,
    Length : DWORDLONG,
};
PSTORAGE_TIER_REGION :: ^STORAGE_TIER_REGION;

DEVICE_DSM_TIERING_QUERY_OUTPUT :: struct {
    Version                 : DWORD,
    Size                    : DWORD,
    Flags                   : DWORD,
    Reserved                : DWORD,
    Alignment               : DWORDLONG,
    TotalNumberOfRegions    : DWORD,
    NumberOfRegionsReturned : DWORD,
    Regions                 : [1]STORAGE_TIER_REGION,
};
PDEVICE_DSM_TIERING_QUERY_OUTPUT :: ^DEVICE_DSM_TIERING_QUERY_OUTPUT;

DEVICE_DSM_NVCACHE_CHANGE_PRIORITY_PARAMETERS :: struct {
    Size           : DWORD,
    TargetPriority : BYTE,
    Reserved       : [3]BYTE,
};
PDEVICE_DSM_NVCACHE_CHANGE_PRIORITY_PARAMETERS :: ^DEVICE_DSM_NVCACHE_CHANGE_PRIORITY_PARAMETERS;

DEVICE_DATA_SET_TOPOLOGY_ID_QUERY_OUTPUT :: struct {
    TopologyRangeBytes : DWORDLONG,
    TopologyId         : [16]BYTE,
};
PDEVICE_DATA_SET_TOPOLOGY_ID_QUERY_OUTPUT :: ^DEVICE_DATA_SET_TOPOLOGY_ID_QUERY_OUTPUT;
DEVICE_DSM_TOPOLOGY_ID_QUERY_OUTPUT :: struct {
    TopologyRangeBytes : DWORDLONG,
    TopologyId         : [16]BYTE,
};
PDEVICE_DSM_TOPOLOGY_ID_QUERY_OUTPUT :: ^DEVICE_DSM_TOPOLOGY_ID_QUERY_OUTPUT;

DEVICE_STORAGE_ADDRESS_RANGE :: struct {
    StartAddress  : LONGLONG,
    LengthInBytes : DWORDLONG,
};
PDEVICE_STORAGE_ADDRESS_RANGE :: ^DEVICE_STORAGE_ADDRESS_RANGE;

DEVICE_DSM_PHYSICAL_ADDRESSES_OUTPUT :: struct {
    Version                : DWORD,
    Flags                  : DWORD,
    TotalNumberOfRanges    : DWORD,
    NumberOfRangesReturned : DWORD,
    Ranges                 : [1]DEVICE_STORAGE_ADDRESS_RANGE,
};
PDEVICE_DSM_PHYSICAL_ADDRESSES_OUTPUT :: ^DEVICE_DSM_PHYSICAL_ADDRESSES_OUTPUT;

DEVICE_DSM_REPORT_ZONES_PARAMETERS :: struct {
    Size         : DWORD,
    ReportOption : BYTE,
    Partial      : BYTE,
    Reserved     : [2]BYTE,
};
PDEVICE_DSM_REPORT_ZONES_PARAMETERS :: ^DEVICE_DSM_REPORT_ZONES_PARAMETERS;

/* STORAGE_ZONES_ATTRIBUTES :: enum { */
STORAGE_ZONES_ATTRIBUTES :: _c.int;
    ZonesAttributeTypeAndLengthMayDifferent :: 0;
    ZonesAttributeTypeSameLengthSame :: 1;
    ZonesAttributeTypeSameLastZoneLengthDifferent :: 2;
    ZonesAttributeTypeMayDifferentLengthSame :: 3;
/* } */
PSTORAGE_ZONES_ATTRIBUTES :: ^STORAGE_ZONES_ATTRIBUTES;

/* STORAGE_ZONE_CONDITION :: enum { */
STORAGE_ZONE_CONDITION :: _c.int;
    ZoneConditionConventional :: 0x00;
    ZoneConditionEmpty :: 0x01;
    ZoneConditionImplicitlyOpened :: 0x02;
    ZoneConditionExplicitlyOpened :: 0x03;
    ZoneConditionClosed :: 0x04;
    ZoneConditionReadOnly :: 0x0D;
    ZoneConditionFull :: 0x0E;
    ZoneConditionOffline :: 0x0F;
/* } */
PSTORAGE_ZONE_CONDITION :: ^STORAGE_ZONE_CONDITION;

STORAGE_ZONE_DESCRIPTOR :: struct {
    Size                       : DWORD,
    ZoneType                   : STORAGE_ZONE_TYPES,
    ZoneCondition              : STORAGE_ZONE_CONDITION,
    ResetWritePointerRecommend : BOOLEAN,
    Reserved0                  : [3]BYTE,
    ZoneSize                   : DWORDLONG,
    WritePointerOffset         : DWORDLONG,
};
PSTORAGE_ZONE_DESCRIPTOR :: ^STORAGE_ZONE_DESCRIPTOR;

DEVICE_DSM_REPORT_ZONES_DATA :: struct {
    Size            : DWORD,
    ZoneCount       : DWORD,
    Attributes      : STORAGE_ZONES_ATTRIBUTES,
    Reserved0       : DWORD,
    ZoneDescriptors : [1]STORAGE_ZONE_DESCRIPTOR,
};
PDEVICE_DSM_REPORT_ZONES_DATA :: ^DEVICE_DSM_REPORT_ZONES_DATA;
DEVICE_DSM_REPORT_ZONES_OUTPUT :: struct {
    Size            : DWORD,
    ZoneCount       : DWORD,
    Attributes      : STORAGE_ZONES_ATTRIBUTES,
    Reserved0       : DWORD,
    ZoneDescriptors : [1]STORAGE_ZONE_DESCRIPTOR,
};
PDEVICE_DSM_REPORT_ZONES_OUTPUT :: ^DEVICE_DSM_REPORT_ZONES_OUTPUT;

DEVICE_STORAGE_RANGE_ATTRIBUTES :: struct {
    LengthInBytes : DWORDLONG,
    using _ : struct #raw_union {
        AllFlags : DWORD,
        using _ : bit_field {
            IsRangeBad : 1,
        },
    },
    Reserved      : DWORD,
};
PDEVICE_STORAGE_RANGE_ATTRIBUTES :: ^DEVICE_STORAGE_RANGE_ATTRIBUTES;

DEVICE_DSM_RANGE_ERROR_INFO :: struct {
    Version                : DWORD,
    Flags                  : DWORD,
    TotalNumberOfRanges    : DWORD,
    NumberOfRangesReturned : DWORD,
    Ranges                 : [1]DEVICE_STORAGE_RANGE_ATTRIBUTES,
};
PDEVICE_DSM_RANGE_ERROR_INFO :: ^DEVICE_DSM_RANGE_ERROR_INFO;
DEVICE_DSM_RANGE_ERROR_OUTPUT :: struct {
    Version                : DWORD,
    Flags                  : DWORD,
    TotalNumberOfRanges    : DWORD,
    NumberOfRangesReturned : DWORD,
    Ranges                 : [1]DEVICE_STORAGE_RANGE_ATTRIBUTES,
};
PDEVICE_DSM_RANGE_ERROR_OUTPUT :: ^DEVICE_DSM_RANGE_ERROR_OUTPUT;

DEVICE_DSM_LOST_QUERY_PARAMETERS :: struct {
    Version     : DWORD,
    Granularity : DWORDLONG,
};
PDEVICE_DSM_LOST_QUERY_PARAMETERS :: ^DEVICE_DSM_LOST_QUERY_PARAMETERS;

DEVICE_DSM_LOST_QUERY_OUTPUT :: struct {
    Version      : DWORD,
    Size         : DWORD,
    Alignment    : DWORDLONG,
    NumberOfBits : DWORD,
    BitMap       : [1]DWORD,
};
PDEVICE_DSM_LOST_QUERY_OUTPUT :: ^DEVICE_DSM_LOST_QUERY_OUTPUT;

DEVICE_DSM_FREE_SPACE_OUTPUT :: struct {
    Version   : DWORD,
    FreeSpace : DWORDLONG,
};
PDEVICE_DSM_FREE_SPACE_OUTPUT :: ^DEVICE_DSM_FREE_SPACE_OUTPUT;

DEVICE_DSM_CONVERSION_OUTPUT :: struct {
    Version : DWORD,
    Source  : GUID,
};
PDEVICE_DSM_CONVERSION_OUTPUT :: ^DEVICE_DSM_CONVERSION_OUTPUT;

STORAGE_GET_BC_PROPERTIES_OUTPUT :: struct {
    MaximumRequestsPerPeriod : DWORD,
    MinimumPeriod            : DWORD,
    MaximumRequestSize       : DWORDLONG,
    EstimatedTimePerRequest  : DWORD,
    NumOutStandingRequests   : DWORD,
    RequestSize              : DWORDLONG,
};
PSTORAGE_GET_BC_PROPERTIES_OUTPUT :: ^STORAGE_GET_BC_PROPERTIES_OUTPUT;

STORAGE_ALLOCATE_BC_STREAM_INPUT :: struct {
    Version           : DWORD,
    RequestsPerPeriod : DWORD,
    Period            : DWORD,
    RetryFailures     : BOOLEAN,
    Discardable       : BOOLEAN,
    Reserved1         : [2]BOOLEAN,
    AccessType        : DWORD,
    AccessMode        : DWORD,
};
PSTORAGE_ALLOCATE_BC_STREAM_INPUT :: ^STORAGE_ALLOCATE_BC_STREAM_INPUT;

STORAGE_ALLOCATE_BC_STREAM_OUTPUT :: struct {
    RequestSize            : DWORDLONG,
    NumOutStandingRequests : DWORD,
};
PSTORAGE_ALLOCATE_BC_STREAM_OUTPUT :: ^STORAGE_ALLOCATE_BC_STREAM_OUTPUT;

STORAGE_PRIORITY_HINT_SUPPORT :: struct {
    SupportFlags : DWORD,
};
PSTORAGE_PRIORITY_HINT_SUPPORT :: ^STORAGE_PRIORITY_HINT_SUPPORT;

/* STORAGE_DIAGNOSTIC_LEVEL :: enum { */
STORAGE_DIAGNOSTIC_LEVEL :: _c.int;
    StorageDiagnosticLevelDefault :: 0;
    StorageDiagnosticLevelMax :: StorageDiagnosticLevelDefault + 1;
/* } */
PSTORAGE_DIAGNOSTIC_LEVEL :: ^STORAGE_DIAGNOSTIC_LEVEL;

/* STORAGE_DIAGNOSTIC_TARGET_TYPE :: enum { */
STORAGE_DIAGNOSTIC_TARGET_TYPE :: _c.int;
    StorageDiagnosticTargetTypeUndefined :: 0;
    StorageDiagnosticTargetTypePort :: StorageDiagnosticTargetTypeUndefined + 1;
    StorageDiagnosticTargetTypeMiniport :: StorageDiagnosticTargetTypePort + 1;
    StorageDiagnosticTargetTypeHbaFirmware :: StorageDiagnosticTargetTypeMiniport + 1;
    StorageDiagnosticTargetTypeMax :: StorageDiagnosticTargetTypeHbaFirmware + 1;
/* } */
PSTORAGE_DIAGNOSTIC_TARGET_TYPE :: ^STORAGE_DIAGNOSTIC_TARGET_TYPE;

STORAGE_DIAGNOSTIC_REQUEST :: struct {
    Version    : DWORD,
    Size       : DWORD,
    Reserved   : DWORD,
    TargetType : STORAGE_DIAGNOSTIC_TARGET_TYPE,
    Level      : STORAGE_DIAGNOSTIC_LEVEL,
};
PSTORAGE_DIAGNOSTIC_REQUEST :: ^STORAGE_DIAGNOSTIC_REQUEST;

STORAGE_DIAGNOSTIC_DATA :: struct {
    Version              : DWORD,
    Size                 : DWORD,
    ProviderId           : GUID,
    BufferSize           : DWORD,
    Reserved             : DWORD,
    DiagnosticDataBuffer : [1]BYTE,
};
PSTORAGE_DIAGNOSTIC_DATA :: ^STORAGE_DIAGNOSTIC_DATA;

PHYSICAL_ELEMENT_STATUS_REQUEST :: struct {
    Version         : DWORD,
    Size            : DWORD,
    StartingElement : DWORD,
    Filter          : BYTE,
    ReportType      : BYTE,
    Reserved        : [2]BYTE,
};
PPHYSICAL_ELEMENT_STATUS_REQUEST :: ^PHYSICAL_ELEMENT_STATUS_REQUEST;

PHYSICAL_ELEMENT_STATUS_DESCRIPTOR :: struct {
    Version               : DWORD,
    Size                  : DWORD,
    ElementIdentifier     : DWORD,
    PhysicalElementType   : BYTE,
    PhysicalElementHealth : BYTE,
    Reserved1             : [2]BYTE,
    AssociatedCapacity    : DWORDLONG,
    Reserved2             : [4]DWORD,
};
PPHYSICAL_ELEMENT_STATUS_DESCRIPTOR :: ^PHYSICAL_ELEMENT_STATUS_DESCRIPTOR;

PHYSICAL_ELEMENT_STATUS :: struct {
    Version                       : DWORD,
    Size                          : DWORD,
    DescriptorCount               : DWORD,
    ReturnedDescriptorCount       : DWORD,
    ElementIdentifierBeingDepoped : DWORD,
    Reserved                      : DWORD,
    Descriptors                   : [1]PHYSICAL_ELEMENT_STATUS_DESCRIPTOR,
};
PPHYSICAL_ELEMENT_STATUS :: ^PHYSICAL_ELEMENT_STATUS;

REMOVE_ELEMENT_AND_TRUNCATE_REQUEST :: struct {
    Version           : DWORD,
    Size              : DWORD,
    RequestCapacity   : DWORDLONG,
    ElementIdentifier : DWORD,
    Reserved          : DWORD,
};
PREMOVE_ELEMENT_AND_TRUNCATE_REQUEST :: ^REMOVE_ELEMENT_AND_TRUNCATE_REQUEST;

STORAGE_READ_CAPACITY :: struct {
    Version        : DWORD,
    Size           : DWORD,
    BlockLength    : DWORD,
    NumberOfBlocks : LARGE_INTEGER,
    DiskLength     : LARGE_INTEGER,
};
PSTORAGE_READ_CAPACITY :: ^STORAGE_READ_CAPACITY;

/* WRITE_CACHE_TYPE :: enum { */
WRITE_CACHE_TYPE :: _c.int;
    WriteCacheTypeUnknown :: 0;
    WriteCacheTypeNone :: WriteCacheTypeUnknown + 1;
    WriteCacheTypeWriteBack :: WriteCacheTypeNone + 1;
    WriteCacheTypeWriteThrough :: WriteCacheTypeWriteBack + 1;
/* } */
;

/* WRITE_CACHE_ENABLE :: enum { */
WRITE_CACHE_ENABLE :: _c.int;
    WriteCacheEnableUnknown :: 0;
    WriteCacheDisabled :: WriteCacheEnableUnknown + 1;
    WriteCacheEnabled :: WriteCacheDisabled + 1;
/* } */
;

/* WRITE_CACHE_CHANGE :: enum { */
WRITE_CACHE_CHANGE :: _c.int;
    WriteCacheChangeUnknown :: 0;
    WriteCacheNotChangeable :: WriteCacheChangeUnknown + 1;
    WriteCacheChangeable :: WriteCacheNotChangeable + 1;
/* } */
;

/* WRITE_THROUGH :: enum { */
WRITE_THROUGH :: _c.int;
    WriteThroughUnknown :: 0;
    WriteThroughNotSupported :: WriteThroughUnknown + 1;
    WriteThroughSupported :: WriteThroughNotSupported + 1;
/* } */
;

STORAGE_WRITE_CACHE_PROPERTY :: struct {
    Version                    : DWORD,
    Size                       : DWORD,
    WriteCacheType             : WRITE_CACHE_TYPE,
    WriteCacheEnabled          : WRITE_CACHE_ENABLE,
    WriteCacheChangeable       : WRITE_CACHE_CHANGE,
    WriteThroughSupported      : WRITE_THROUGH,
    FlushCacheSupported        : BOOLEAN,
    UserDefinedPowerProtection : BOOLEAN,
    NVCacheEnabled             : BOOLEAN,
};
PSTORAGE_WRITE_CACHE_PROPERTY :: ^STORAGE_WRITE_CACHE_PROPERTY;

/* DEVICEDUMP_COLLECTION_TYPEIDE_NOTIFICATION_TYPE :: enum { */
DEVICEDUMP_COLLECTION_TYPEIDE_NOTIFICATION_TYPE :: _c.int;
    TCCollectionBugCheck :: 1;
    TCCollectionApplicationRequested :: TCCollectionBugCheck + 1;
    TCCollectionDeviceRequested :: TCCollectionApplicationRequested + 1;
/* } */
PDEVICEDUMP_COLLECTION_TYPE :: ^DEVICEDUMP_COLLECTION_TYPEIDE_NOTIFICATION_TYPE;

DEVICEDUMP_SUBSECTION_POINTER :: struct {
    dwSize   : DWORD,
    dwFlags  : DWORD,
    dwOffset : DWORD,
};
PDEVICEDUMP_SUBSECTION_POINTER :: ^DEVICEDUMP_SUBSECTION_POINTER;

DEVICEDUMP_STRUCTURE_VERSION :: struct {
    dwSignature : DWORD,
    dwVersion   : DWORD,
    dwSize      : DWORD,
};
PDEVICEDUMP_STRUCTURE_VERSION :: ^DEVICEDUMP_STRUCTURE_VERSION;

DEVICEDUMP_SECTION_HEADER :: struct {
    guidDeviceDataId              : GUID,
    sOrganizationID               : [16]BYTE,
    dwFirmwareRevision            : DWORD,
    sModelNumber                  : [32]BYTE,
    szDeviceManufacturingID       : [32]BYTE,
    dwFlags                       : DWORD,
    bRestrictedPrivateDataVersion : DWORD,
    dwFirmwareIssueId             : DWORD,
    szIssueDescriptionString      : [132]BYTE,
};
PDEVICEDUMP_SECTION_HEADER :: ^DEVICEDUMP_SECTION_HEADER;

GP_LOG_PAGE_DESCRIPTOR :: struct {
    LogAddress : WORD,
    LogSectors : WORD,
};
PGP_LOG_PAGE_DESCRIPTOR :: ^GP_LOG_PAGE_DESCRIPTOR;

DEVICEDUMP_PUBLIC_SUBSECTION :: struct {
    dwFlags       : DWORD,
    GPLogTable    : [16]GP_LOG_PAGE_DESCRIPTOR,
    szDescription : [16]CHAR,
    bData         : [1]BYTE,
};
PDEVICEDUMP_PUBLIC_SUBSECTION :: ^DEVICEDUMP_PUBLIC_SUBSECTION;

DEVICEDUMP_RESTRICTED_SUBSECTION :: struct {
    bData : [1]BYTE,
};
PDEVICEDUMP_RESTRICTED_SUBSECTION :: ^DEVICEDUMP_RESTRICTED_SUBSECTION;

DEVICEDUMP_PRIVATE_SUBSECTION :: struct {
    dwFlags : DWORD,
    GPLogId : GP_LOG_PAGE_DESCRIPTOR,
    bData   : [1]BYTE,
};
PDEVICEDUMP_PRIVATE_SUBSECTION :: ^DEVICEDUMP_PRIVATE_SUBSECTION;

DEVICEDUMP_STORAGEDEVICE_DATA :: struct {
    Descriptor            : DEVICEDUMP_STRUCTURE_VERSION,
    SectionHeader         : DEVICEDUMP_SECTION_HEADER,
    dwBufferSize          : DWORD,
    dwReasonForCollection : DWORD,
    PublicData            : DEVICEDUMP_SUBSECTION_POINTER,
    RestrictedData        : DEVICEDUMP_SUBSECTION_POINTER,
    PrivateData           : DEVICEDUMP_SUBSECTION_POINTER,
};
PDEVICEDUMP_STORAGEDEVICE_DATA :: ^DEVICEDUMP_STORAGEDEVICE_DATA;

DEVICEDUMP_STORAGESTACK_PUBLIC_STATE_RECORD :: struct {
    Cdb             : [16]BYTE,
    Command         : [16]BYTE,
    StartTime       : DWORDLONG,
    EndTime         : DWORDLONG,
    OperationStatus : DWORD,
    OperationError  : DWORD,
    StackSpecific : struct #raw_union {
        ExternalStack : struct {
            dwReserved : DWORD,
        },
        AtaPort : struct {
            dwAtaPortSpecific : DWORD,
        },
        StorPort : struct {
            SrbTag : DWORD,
        },
    },
};
PDEVICEDUMP_STORAGESTACK_PUBLIC_STATE_RECORD :: ^DEVICEDUMP_STORAGESTACK_PUBLIC_STATE_RECORD;

DEVICEDUMP_STORAGESTACK_PUBLIC_DUMP :: struct {
    Descriptor            : DEVICEDUMP_STRUCTURE_VERSION,
    dwReasonForCollection : DWORD,
    cDriverName           : [16]BYTE,
    uiNumRecords          : DWORD,
    RecordArray           : [1]DEVICEDUMP_STORAGESTACK_PUBLIC_STATE_RECORD,
};
PDEVICEDUMP_STORAGESTACK_PUBLIC_DUMP :: ^DEVICEDUMP_STORAGESTACK_PUBLIC_DUMP;

STORAGE_IDLE_POWER :: struct {
    Version         : DWORD,
    Size            : DWORD,
    using _ : bit_field {
        WakeCapableHint : 1,
        D3ColdSupported : 1,
        Reserved        : 30,
    },
    D3IdleTimeout   : DWORD,
};
PSTORAGE_IDLE_POWER :: ^STORAGE_IDLE_POWER;

/* STORAGE_POWERUP_REASON_TYPE :: enum { */
STORAGE_POWERUP_REASON_TYPE :: _c.int;
    StoragePowerupUnknown :: 0;
    StoragePowerupIO :: StoragePowerupUnknown + 1;
    StoragePowerupDeviceAttention :: StoragePowerupIO + 1;
/* } */
PSTORAGE_POWERUP_REASON_TYPE :: ^STORAGE_POWERUP_REASON_TYPE;

STORAGE_IDLE_POWERUP_REASON :: struct {
    Version       : DWORD,
    Size          : DWORD,
    PowerupReason : STORAGE_POWERUP_REASON_TYPE,
};
PSTORAGE_IDLE_POWERUP_REASON :: ^STORAGE_IDLE_POWERUP_REASON;

/* STORAGE_DEVICE_POWER_CAP_UNITS :: enum { */
STORAGE_DEVICE_POWER_CAP_UNITS :: _c.int;
    StorageDevicePowerCapUnitsPercent :: 0;
    StorageDevicePowerCapUnitsMilliwatts :: StorageDevicePowerCapUnitsPercent + 1;
/* } */
PSTORAGE_DEVICE_POWER_CAP_UNITS :: ^STORAGE_DEVICE_POWER_CAP_UNITS;

STORAGE_DEVICE_POWER_CAP :: struct {
    Version  : DWORD,
    Size     : DWORD,
    Units    : STORAGE_DEVICE_POWER_CAP_UNITS,
    MaxPower : DWORDLONG,
};
PSTORAGE_DEVICE_POWER_CAP :: ^STORAGE_DEVICE_POWER_CAP;

STORAGE_RPMB_DATA_FRAME :: struct {
    Stuff                 : [196]BYTE,
    KeyOrMAC              : [32]BYTE,
    Data                  : [256]BYTE,
    Nonce                 : [16]BYTE,
    WriteCounter          : [4]BYTE,
    Address               : [2]BYTE,
    BlockCount            : [2]BYTE,
    OperationResult       : [2]BYTE,
    RequestOrResponseType : [2]BYTE,
};
PSTORAGE_RPMB_DATA_FRAME :: ^STORAGE_RPMB_DATA_FRAME;

/* STORAGE_RPMB_COMMAND_TYPE :: enum { */
STORAGE_RPMB_COMMAND_TYPE :: _c.int;
    StorRpmbProgramAuthKey :: 0x00000001;
    StorRpmbQueryWriteCounter :: 0x00000002;
    StorRpmbAuthenticatedWrite :: 0x00000003;
    StorRpmbAuthenticatedRead :: 0x00000004;
    StorRpmbReadResultRequest :: 0x00000005;
    StorRpmbAuthenticatedDeviceConfigWrite :: 0x00000006;
    StorRpmbAuthenticatedDeviceConfigRead :: 0x00000007;
/* } */
PSTORAGE_RPMB_COMMAND_TYPE :: ^STORAGE_RPMB_COMMAND_TYPE;

STORAGE_EVENT_NOTIFICATION :: struct {
    Version : DWORD,
    Size    : DWORD,
    Events  : DWORDLONG,
};
PSTORAGE_EVENT_NOTIFICATION :: ^STORAGE_EVENT_NOTIFICATION;

/* STORAGE_COUNTER_TYPE :: enum { */
STORAGE_COUNTER_TYPE :: _c.int;
    StorageCounterTypeUnknown :: 0;
    StorageCounterTypeTemperatureCelsius :: StorageCounterTypeUnknown + 1;
    StorageCounterTypeTemperatureCelsiusMax :: StorageCounterTypeTemperatureCelsius + 1;
    StorageCounterTypeReadErrorsTotal :: StorageCounterTypeTemperatureCelsiusMax + 1;
    StorageCounterTypeReadErrorsCorrected :: StorageCounterTypeReadErrorsTotal + 1;
    StorageCounterTypeReadErrorsUncorrected :: StorageCounterTypeReadErrorsCorrected + 1;
    StorageCounterTypeWriteErrorsTotal :: StorageCounterTypeReadErrorsUncorrected + 1;
    StorageCounterTypeWriteErrorsCorrected :: StorageCounterTypeWriteErrorsTotal + 1;
    StorageCounterTypeWriteErrorsUncorrected :: StorageCounterTypeWriteErrorsCorrected + 1;
    StorageCounterTypeManufactureDate :: StorageCounterTypeWriteErrorsUncorrected + 1;
    StorageCounterTypeStartStopCycleCount :: StorageCounterTypeManufactureDate + 1;
    StorageCounterTypeStartStopCycleCountMax :: StorageCounterTypeStartStopCycleCount + 1;
    StorageCounterTypeLoadUnloadCycleCount :: StorageCounterTypeStartStopCycleCountMax + 1;
    StorageCounterTypeLoadUnloadCycleCountMax :: StorageCounterTypeLoadUnloadCycleCount + 1;
    StorageCounterTypeWearPercentage :: StorageCounterTypeLoadUnloadCycleCountMax + 1;
    StorageCounterTypeWearPercentageWarning :: StorageCounterTypeWearPercentage + 1;
    StorageCounterTypeWearPercentageMax :: StorageCounterTypeWearPercentageWarning + 1;
    StorageCounterTypePowerOnHours :: StorageCounterTypeWearPercentageMax + 1;
    StorageCounterTypeReadLatency100NSMax :: StorageCounterTypePowerOnHours + 1;
    StorageCounterTypeWriteLatency100NSMax :: StorageCounterTypeReadLatency100NSMax + 1;
    StorageCounterTypeFlushLatency100NSMax :: StorageCounterTypeWriteLatency100NSMax + 1;
    StorageCounterTypeMax :: StorageCounterTypeFlushLatency100NSMax + 1;
/* } */
PSTORAGE_COUNTER_TYPE :: ^STORAGE_COUNTER_TYPE;

STORAGE_COUNTER :: struct {
    Type  : STORAGE_COUNTER_TYPE,
    Value : struct #raw_union {
        ManufactureDate : struct {
            Week : DWORD,
            Year : DWORD,
        },
        AsUlonglong     : DWORDLONG,
    },
};
PSTORAGE_COUNTER :: ^STORAGE_COUNTER;

STORAGE_COUNTERS :: struct {
    Version          : DWORD,
    Size             : DWORD,
    NumberOfCounters : DWORD,
    Counters         : [1]STORAGE_COUNTER,
};
PSTORAGE_COUNTERS :: ^STORAGE_COUNTERS;

STORAGE_HW_FIRMWARE_INFO_QUERY :: struct {
    Version  : DWORD,
    Size     : DWORD,
    Flags    : DWORD,
    Reserved : DWORD,
};
PSTORAGE_HW_FIRMWARE_INFO_QUERY :: ^STORAGE_HW_FIRMWARE_INFO_QUERY;

STORAGE_HW_FIRMWARE_SLOT_INFO :: struct {
    Version    : DWORD,
    Size       : DWORD,
    SlotNumber : BYTE,
    using _ : bit_field {
        ReadOnly   : 1,
        Reserved0  : 7,
    },
    Reserved1  : [6]BYTE,
    Revision   : [16]BYTE,
};
PSTORAGE_HW_FIRMWARE_SLOT_INFO :: ^STORAGE_HW_FIRMWARE_SLOT_INFO;

STORAGE_HW_FIRMWARE_INFO :: struct {
    Version               : DWORD,
    Size                  : DWORD,
    using _ : bit_field {
        SupportUpgrade        : 1,
        Reserved0             : 7,
    },
    SlotCount             : BYTE,
    ActiveSlot            : BYTE,
    PendingActivateSlot   : BYTE,
    FirmwareShared        : BOOLEAN,
    Reserved              : [3]BYTE,
    ImagePayloadAlignment : DWORD,
    ImagePayloadMaxSize   : DWORD,
    Slot                  : [1]STORAGE_HW_FIRMWARE_SLOT_INFO,
};
PSTORAGE_HW_FIRMWARE_INFO :: ^STORAGE_HW_FIRMWARE_INFO;

STORAGE_HW_FIRMWARE_DOWNLOAD :: struct {
    Version     : DWORD,
    Size        : DWORD,
    Flags       : DWORD,
    Slot        : BYTE,
    Reserved    : [3]BYTE,
    Offset      : DWORDLONG,
    BufferSize  : DWORDLONG,
    ImageBuffer : [1]BYTE,
};
PSTORAGE_HW_FIRMWARE_DOWNLOAD :: ^STORAGE_HW_FIRMWARE_DOWNLOAD;

STORAGE_HW_FIRMWARE_DOWNLOAD_V2 :: struct {
    Version     : DWORD,
    Size        : DWORD,
    Flags       : DWORD,
    Slot        : BYTE,
    Reserved    : [3]BYTE,
    Offset      : DWORDLONG,
    BufferSize  : DWORDLONG,
    ImageSize   : DWORD,
    Reserved2   : DWORD,
    ImageBuffer : [1]BYTE,
};
PSTORAGE_HW_FIRMWARE_DOWNLOAD_V2 :: ^STORAGE_HW_FIRMWARE_DOWNLOAD_V2;

STORAGE_HW_FIRMWARE_ACTIVATE :: struct {
    Version   : DWORD,
    Size      : DWORD,
    Flags     : DWORD,
    Slot      : BYTE,
    Reserved0 : [3]BYTE,
};
PSTORAGE_HW_FIRMWARE_ACTIVATE :: ^STORAGE_HW_FIRMWARE_ACTIVATE;

STORAGE_PROTOCOL_COMMAND :: struct {
    Version                      : DWORD,
    Length                       : DWORD,
    ProtocolType                 : STORAGE_PROTOCOL_TYPE,
    Flags                        : DWORD,
    ReturnStatus                 : DWORD,
    ErrorCode                    : DWORD,
    CommandLength                : DWORD,
    ErrorInfoLength              : DWORD,
    DataToDeviceTransferLength   : DWORD,
    DataFromDeviceTransferLength : DWORD,
    TimeOutValue                 : DWORD,
    ErrorInfoOffset              : DWORD,
    DataToDeviceBufferOffset     : DWORD,
    DataFromDeviceBufferOffset   : DWORD,
    CommandSpecific              : DWORD,
    Reserved0                    : DWORD,
    FixedProtocolReturnData      : DWORD,
    Reserved1                    : [3]DWORD,
    Command                      : [1]BYTE,
};
PSTORAGE_PROTOCOL_COMMAND :: ^STORAGE_PROTOCOL_COMMAND;

/* STORAGE_ATTRIBUTE_MGMT_ACTION :: enum { */
STORAGE_ATTRIBUTE_MGMT_ACTION :: _c.int;
    StorAttributeMgmt_ClearAttribute :: 0;
    StorAttributeMgmt_SetAttribute :: 1;
    StorAttributeMgmt_ResetAttribute :: 2;
/* } */
PSTORAGE_ATTRIBUTE_MGMT_ACTION :: ^STORAGE_ATTRIBUTE_MGMT_ACTION;

STORAGE_ATTRIBUTE_MGMT :: struct {
    Version   : DWORD,
    Size      : DWORD,
    Action    : STORAGE_ATTRIBUTE_MGMT_ACTION,
    Attribute : DWORD,
};
PSTORAGE_ATTRIBUTE_MGMT :: ^STORAGE_ATTRIBUTE_MGMT;

SCM_PD_HEALTH_NOTIFICATION_DATA :: struct {
    DeviceGuid : GUID,
};
PSCM_PD_HEALTH_NOTIFICATION_DATA :: ^SCM_PD_HEALTH_NOTIFICATION_DATA;

SCM_LOGICAL_DEVICE_INSTANCE :: struct {
    Version      : DWORD,
    Size         : DWORD,
    DeviceGuid   : GUID,
    SymbolicLink : [256]WCHAR,
};
PSCM_LOGICAL_DEVICE_INSTANCE :: ^SCM_LOGICAL_DEVICE_INSTANCE;

SCM_LOGICAL_DEVICES :: struct {
    Version     : DWORD,
    Size        : DWORD,
    DeviceCount : DWORD,
    Devices     : [1]SCM_LOGICAL_DEVICE_INSTANCE,
};
PSCM_LOGICAL_DEVICES :: ^SCM_LOGICAL_DEVICES;

SCM_PHYSICAL_DEVICE_INSTANCE :: struct {
    Version      : DWORD,
    Size         : DWORD,
    NfitHandle   : DWORD,
    SymbolicLink : [256]WCHAR,
};
PSCM_PHYSICAL_DEVICE_INSTANCE :: ^SCM_PHYSICAL_DEVICE_INSTANCE;

SCM_PHYSICAL_DEVICES :: struct {
    Version     : DWORD,
    Size        : DWORD,
    DeviceCount : DWORD,
    Devices     : [1]SCM_PHYSICAL_DEVICE_INSTANCE,
};
PSCM_PHYSICAL_DEVICES :: ^SCM_PHYSICAL_DEVICES;

/* SCM_REGION_FLAG :: enum { */
SCM_REGION_FLAG :: _c.int;
    ScmRegionFlagNone :: 0x0;
    ScmRegionFlagLabel :: 0x1;
/* } */
PSCM_REGION_FLAG :: ^SCM_REGION_FLAG;

SCM_REGION :: struct {
    Version           : DWORD,
    Size              : DWORD,
    Flags             : DWORD,
    NfitHandle        : DWORD,
    LogicalDeviceGuid : GUID,
    AddressRangeType  : GUID,
    AssociatedId      : DWORD,
    Length            : DWORD64,
    StartingDPA       : DWORD64,
    BaseSPA           : DWORD64,
    SPAOffset         : DWORD64,
    RegionOffset      : DWORD64,
};
PSCM_REGION :: ^SCM_REGION;

SCM_REGIONS :: struct {
    Version     : DWORD,
    Size        : DWORD,
    RegionCount : DWORD,
    Regions     : [1]SCM_REGION,
};
PSCM_REGIONS :: ^SCM_REGIONS;

SCM_INTERLEAVED_PD_INFO :: struct {
    DeviceHandle : DWORD,
    DeviceGuid   : GUID,
};
PSCM_INTERLEAVED_PD_INFO :: ^SCM_INTERLEAVED_PD_INFO;

SCM_LD_INTERLEAVE_SET_INFO :: struct {
    Version           : DWORD,
    Size              : DWORD,
    InterleaveSetSize : DWORD,
    InterleaveSet     : [1]SCM_INTERLEAVED_PD_INFO,
};
PSCM_LD_INTERLEAVE_SET_INFO :: ^SCM_LD_INTERLEAVE_SET_INFO;

/* SCM_PD_QUERY_TYPE :: enum { */
SCM_PD_QUERY_TYPE :: _c.int;
    ScmPhysicalDeviceQuery_Descriptor :: 0;
    ScmPhysicalDeviceQuery_IsSupported :: ScmPhysicalDeviceQuery_Descriptor + 1;
    ScmPhysicalDeviceQuery_Max :: ScmPhysicalDeviceQuery_IsSupported + 1;
/* } */
PSCM_PD_QUERY_TYPE :: ^SCM_PD_QUERY_TYPE;

/* SCM_PD_PROPERTY_ID :: enum { */
SCM_PD_PROPERTY_ID :: _c.int;
    ScmPhysicalDeviceProperty_DeviceInfo :: 0;
    ScmPhysicalDeviceProperty_ManagementStatus :: ScmPhysicalDeviceProperty_DeviceInfo + 1;
    ScmPhysicalDeviceProperty_FirmwareInfo :: ScmPhysicalDeviceProperty_ManagementStatus + 1;
    ScmPhysicalDeviceProperty_LocationString :: ScmPhysicalDeviceProperty_FirmwareInfo + 1;
    ScmPhysicalDeviceProperty_DeviceSpecificInfo :: ScmPhysicalDeviceProperty_LocationString + 1;
    ScmPhysicalDeviceProperty_DeviceHandle :: ScmPhysicalDeviceProperty_DeviceSpecificInfo + 1;
    ScmPhysicalDeviceProperty_Max :: ScmPhysicalDeviceProperty_DeviceHandle + 1;
/* } */
PSCM_PD_PROPERTY_ID :: ^SCM_PD_PROPERTY_ID;

SCM_PD_PROPERTY_QUERY :: struct {
    Version              : DWORD,
    Size                 : DWORD,
    PropertyId           : SCM_PD_PROPERTY_ID,
    QueryType            : SCM_PD_QUERY_TYPE,
    AdditionalParameters : [1]BYTE,
};
PSCM_PD_PROPERTY_QUERY :: ^SCM_PD_PROPERTY_QUERY;

SCM_PD_DESCRIPTOR_HEADER :: struct {
    Version : DWORD,
    Size    : DWORD,
};
PSCM_PD_DESCRIPTOR_HEADER :: ^SCM_PD_DESCRIPTOR_HEADER;

SCM_PD_DEVICE_HANDLE :: struct {
    Version      : DWORD,
    Size         : DWORD,
    DeviceGuid   : GUID,
    DeviceHandle : DWORD,
};
PSCM_PD_DEVICE_HANDLE :: ^SCM_PD_DEVICE_HANDLE;

SCM_PD_DEVICE_INFO :: struct {
    Version                      : DWORD,
    Size                         : DWORD,
    DeviceGuid                   : GUID,
    UnsafeShutdownCount          : DWORD,
    PersistentMemorySizeInBytes  : DWORD64,
    VolatileMemorySizeInBytes    : DWORD64,
    TotalMemorySizeInBytes       : DWORD64,
    SlotNumber                   : DWORD,
    DeviceHandle                 : DWORD,
    PhysicalId                   : WORD,
    NumberOfFormatInterfaceCodes : BYTE,
    FormatInterfaceCodes         : [8]WORD,
    VendorId                     : DWORD,
    ProductId                    : DWORD,
    SubsystemDeviceId            : DWORD,
    SubsystemVendorId            : DWORD,
    ManufacturingLocation        : BYTE,
    ManufacturingWeek            : BYTE,
    ManufacturingYear            : BYTE,
    SerialNumber4Byte            : DWORD,
    SerialNumberLengthInChars    : DWORD,
    SerialNumber                 : [1]CHAR,
};
PSCM_PD_DEVICE_INFO :: ^SCM_PD_DEVICE_INFO;

SCM_PD_DEVICE_SPECIFIC_PROPERTY :: struct {
    Name  : [128]WCHAR,
    Value : LONGLONG,
};
PSCM_PD_DEVICE_SPECIFIC_PROPERTY :: ^SCM_PD_DEVICE_SPECIFIC_PROPERTY;

SCM_PD_DEVICE_SPECIFIC_INFO :: struct {
    Version                  : DWORD,
    Size                     : DWORD,
    NumberOfProperties       : DWORD,
    DeviceSpecificProperties : [1]SCM_PD_DEVICE_SPECIFIC_PROPERTY,
};
PSCM_PD_DEVICE_SPECIFIC_INFO :: ^SCM_PD_DEVICE_SPECIFIC_INFO;

SCM_PD_FIRMWARE_SLOT_INFO :: struct {
    Version    : DWORD,
    Size       : DWORD,
    SlotNumber : BYTE,
    using _ : bit_field {
        ReadOnly   : 1,
        Reserved0  : 7,
    },
    Reserved1  : [6]BYTE,
    Revision   : [32]BYTE,
};
PSCM_PD_FIRMWARE_SLOT_INFO :: ^SCM_PD_FIRMWARE_SLOT_INFO;

SCM_PD_FIRMWARE_INFO :: struct {
    Version        : DWORD,
    Size           : DWORD,
    ActiveSlot     : BYTE,
    NextActiveSlot : BYTE,
    SlotCount      : BYTE,
    Slots          : [1]SCM_PD_FIRMWARE_SLOT_INFO,
};
PSCM_PD_FIRMWARE_INFO :: ^SCM_PD_FIRMWARE_INFO;

/* SCM_PD_HEALTH_STATUS :: enum { */
SCM_PD_HEALTH_STATUS :: _c.int;
    ScmPhysicalDeviceHealth_Unknown :: 0;
    ScmPhysicalDeviceHealth_Unhealthy :: ScmPhysicalDeviceHealth_Unknown + 1;
    ScmPhysicalDeviceHealth_Warning :: ScmPhysicalDeviceHealth_Unhealthy + 1;
    ScmPhysicalDeviceHealth_Healthy :: ScmPhysicalDeviceHealth_Warning + 1;
    ScmPhysicalDeviceHealth_Max :: ScmPhysicalDeviceHealth_Healthy + 1;
/* } */
PSCM_PD_HEALTH_STATUS :: ^SCM_PD_HEALTH_STATUS;

/* SCM_PD_OPERATIONAL_STATUS :: enum { */
SCM_PD_OPERATIONAL_STATUS :: _c.int;
    ScmPhysicalDeviceOpStatus_Unknown :: 0;
    ScmPhysicalDeviceOpStatus_Ok :: ScmPhysicalDeviceOpStatus_Unknown + 1;
    ScmPhysicalDeviceOpStatus_PredictingFailure :: ScmPhysicalDeviceOpStatus_Ok + 1;
    ScmPhysicalDeviceOpStatus_InService :: ScmPhysicalDeviceOpStatus_PredictingFailure + 1;
    ScmPhysicalDeviceOpStatus_HardwareError :: ScmPhysicalDeviceOpStatus_InService + 1;
    ScmPhysicalDeviceOpStatus_NotUsable :: ScmPhysicalDeviceOpStatus_HardwareError + 1;
    ScmPhysicalDeviceOpStatus_TransientError :: ScmPhysicalDeviceOpStatus_NotUsable + 1;
    ScmPhysicalDeviceOpStatus_Missing :: ScmPhysicalDeviceOpStatus_TransientError + 1;
    ScmPhysicalDeviceOpStatus_Max :: ScmPhysicalDeviceOpStatus_Missing + 1;
/* } */
PSCM_PD_OPERATIONAL_STATUS :: ^SCM_PD_OPERATIONAL_STATUS;

/* SCM_PD_OPERATIONAL_STATUS_REASON :: enum { */
SCM_PD_OPERATIONAL_STATUS_REASON :: _c.int;
    ScmPhysicalDeviceOpReason_Unknown :: 0;
    ScmPhysicalDeviceOpReason_Media :: ScmPhysicalDeviceOpReason_Unknown + 1;
    ScmPhysicalDeviceOpReason_ThresholdExceeded :: ScmPhysicalDeviceOpReason_Media + 1;
    ScmPhysicalDeviceOpReason_LostData :: ScmPhysicalDeviceOpReason_ThresholdExceeded + 1;
    ScmPhysicalDeviceOpReason_EnergySource :: ScmPhysicalDeviceOpReason_LostData + 1;
    ScmPhysicalDeviceOpReason_Configuration :: ScmPhysicalDeviceOpReason_EnergySource + 1;
    ScmPhysicalDeviceOpReason_DeviceController :: ScmPhysicalDeviceOpReason_Configuration + 1;
    ScmPhysicalDeviceOpReason_MediaController :: ScmPhysicalDeviceOpReason_DeviceController + 1;
    ScmPhysicalDeviceOpReason_Component :: ScmPhysicalDeviceOpReason_MediaController + 1;
    ScmPhysicalDeviceOpReason_BackgroundOperation :: ScmPhysicalDeviceOpReason_Component + 1;
    ScmPhysicalDeviceOpReason_InvalidFirmware :: ScmPhysicalDeviceOpReason_BackgroundOperation + 1;
    ScmPhysicalDeviceOpReason_HealthCheck :: ScmPhysicalDeviceOpReason_InvalidFirmware + 1;
    ScmPhysicalDeviceOpReason_LostDataPersistence :: ScmPhysicalDeviceOpReason_HealthCheck + 1;
    ScmPhysicalDeviceOpReason_DisabledByPlatform :: ScmPhysicalDeviceOpReason_LostDataPersistence + 1;
    ScmPhysicalDeviceOpReason_PermanentError :: ScmPhysicalDeviceOpReason_DisabledByPlatform + 1;
    ScmPhysicalDeviceOpReason_LostWritePersistence :: ScmPhysicalDeviceOpReason_PermanentError + 1;
    ScmPhysicalDeviceOpReason_FatalError :: ScmPhysicalDeviceOpReason_LostWritePersistence + 1;
    ScmPhysicalDeviceOpReason_DataPersistenceLossImminent :: ScmPhysicalDeviceOpReason_FatalError + 1;
    ScmPhysicalDeviceOpReason_WritePersistenceLossImminent :: ScmPhysicalDeviceOpReason_DataPersistenceLossImminent + 1;
    ScmPhysicalDeviceOpReason_MediaRemainingSpareBlock :: ScmPhysicalDeviceOpReason_WritePersistenceLossImminent + 1;
    ScmPhysicalDeviceOpReason_PerformanceDegradation :: ScmPhysicalDeviceOpReason_MediaRemainingSpareBlock + 1;
    ScmPhysicalDeviceOpReason_ExcessiveTemperature :: ScmPhysicalDeviceOpReason_PerformanceDegradation + 1;
    ScmPhysicalDeviceOpReason_Max :: ScmPhysicalDeviceOpReason_ExcessiveTemperature + 1;
/* } */
PSCM_PD_OPERATIONAL_STATUS_REASON :: ^SCM_PD_OPERATIONAL_STATUS_REASON;

SCM_PD_MANAGEMENT_STATUS :: struct {
    Version                   : DWORD,
    Size                      : DWORD,
    Health                    : SCM_PD_HEALTH_STATUS,
    NumberOfOperationalStatus : DWORD,
    NumberOfAdditionalReasons : DWORD,
    OperationalStatus         : [16]SCM_PD_OPERATIONAL_STATUS,
    AdditionalReasons         : [1]SCM_PD_OPERATIONAL_STATUS_REASON,
};
PSCM_PD_MANAGEMENT_STATUS :: ^SCM_PD_MANAGEMENT_STATUS;

SCM_PD_LOCATION_STRING :: struct {
    Version  : DWORD,
    Size     : DWORD,
    Location : [1]WCHAR,
};
PSCM_PD_LOCATION_STRING :: ^SCM_PD_LOCATION_STRING;

SCM_PD_FIRMWARE_DOWNLOAD :: struct {
    Version                  : DWORD,
    Size                     : DWORD,
    Flags                    : DWORD,
    Slot                     : BYTE,
    Reserved                 : [3]BYTE,
    Offset                   : DWORD64,
    FirmwareImageSizeInBytes : DWORD,
    FirmwareImage            : [1]BYTE,
};
PSCM_PD_FIRMWARE_DOWNLOAD :: ^SCM_PD_FIRMWARE_DOWNLOAD;

SCM_PD_FIRMWARE_ACTIVATE :: struct {
    Version : DWORD,
    Size    : DWORD,
    Flags   : DWORD,
    Slot    : BYTE,
};
PSCM_PD_FIRMWARE_ACTIVATE :: ^SCM_PD_FIRMWARE_ACTIVATE;

SCM_PD_PASSTHROUGH_INPUT :: struct {
    Version      : DWORD,
    Size         : DWORD,
    ProtocolGuid : GUID,
    DataSize     : DWORD,
    Data         : [1]BYTE,
};
PSCM_PD_PASSTHROUGH_INPUT :: ^SCM_PD_PASSTHROUGH_INPUT;

SCM_PD_PASSTHROUGH_OUTPUT :: struct {
    Version      : DWORD,
    Size         : DWORD,
    ProtocolGuid : GUID,
    DataSize     : DWORD,
    Data         : [1]BYTE,
};
PSCM_PD_PASSTHROUGH_OUTPUT :: ^SCM_PD_PASSTHROUGH_OUTPUT;

SCM_PD_PASSTHROUGH_INVDIMM_INPUT :: struct {
    Opcode                 : DWORD,
    OpcodeParametersLength : DWORD,
    OpcodeParameters       : [1]BYTE,
};
PSCM_PD_PASSTHROUGH_INVDIMM_INPUT :: ^SCM_PD_PASSTHROUGH_INVDIMM_INPUT;

SCM_PD_PASSTHROUGH_INVDIMM_OUTPUT :: struct {
    GeneralStatus    : WORD,
    ExtendedStatus   : WORD,
    OutputDataLength : DWORD,
    OutputData       : [1]BYTE,
};
PSCM_PD_PASSTHROUGH_INVDIMM_OUTPUT :: ^SCM_PD_PASSTHROUGH_INVDIMM_OUTPUT;

SCM_PD_REINITIALIZE_MEDIA_INPUT :: struct {
    Version : DWORD,
    Size    : DWORD,
    Options : bit_field {
        Overwrite : 1,
    },
};
PSCM_PD_REINITIALIZE_MEDIA_INPUT :: ^SCM_PD_REINITIALIZE_MEDIA_INPUT;

/* SCM_PD_MEDIA_REINITIALIZATION_STATUS :: enum { */
SCM_PD_MEDIA_REINITIALIZATION_STATUS :: _c.int;
    ScmPhysicalDeviceReinit_Success :: 0;
    ScmPhysicalDeviceReinit_RebootNeeded :: ScmPhysicalDeviceReinit_Success + 1;
    ScmPhysicalDeviceReinit_ColdBootNeeded :: ScmPhysicalDeviceReinit_RebootNeeded + 1;
    ScmPhysicalDeviceReinit_Max :: ScmPhysicalDeviceReinit_ColdBootNeeded + 1;
/* } */
PSCM_PD_MEDIA_REINITIALIZATION_STATUS :: ^SCM_PD_MEDIA_REINITIALIZATION_STATUS;

SCM_PD_REINITIALIZE_MEDIA_OUTPUT :: struct {
    Version : DWORD,
    Size    : DWORD,
    Status  : SCM_PD_MEDIA_REINITIALIZATION_STATUS,
};
PSCM_PD_REINITIALIZE_MEDIA_OUTPUT :: ^SCM_PD_REINITIALIZE_MEDIA_OUTPUT;

/* MEDIA_TYPE :: enum { */
MEDIA_TYPE :: _c.int;
    Unknown :: 0;
    F5_1Pt2_512 :: Unknown + 1;
    F3_1Pt44_512 :: F5_1Pt2_512 + 1;
    F3_2Pt88_512 :: F3_1Pt44_512 + 1;
    F3_20Pt8_512 :: F3_2Pt88_512 + 1;
    F3_720_512 :: F3_20Pt8_512 + 1;
    F5_360_512 :: F3_720_512 + 1;
    F5_320_512 :: F5_360_512 + 1;
    F5_320_1024 :: F5_320_512 + 1;
    F5_180_512 :: F5_320_1024 + 1;
    F5_160_512 :: F5_180_512 + 1;
    RemovableMedia :: F5_160_512 + 1;
    FixedMedia :: RemovableMedia + 1;
    F3_120M_512 :: FixedMedia + 1;
    F3_640_512 :: F3_120M_512 + 1;
    F5_640_512 :: F3_640_512 + 1;
    F5_720_512 :: F5_640_512 + 1;
    F3_1Pt2_512 :: F5_720_512 + 1;
    F3_1Pt23_1024 :: F3_1Pt2_512 + 1;
    F5_1Pt23_1024 :: F3_1Pt23_1024 + 1;
    F3_128Mb_512 :: F5_1Pt23_1024 + 1;
    F3_230Mb_512 :: F3_128Mb_512 + 1;
    F8_256_128 :: F3_230Mb_512 + 1;
    F3_200Mb_512 :: F8_256_128 + 1;
    F3_240M_512 :: F3_200Mb_512 + 1;
    F3_32M_512 :: F3_240M_512 + 1;
/* } */
PMEDIA_TYPE :: ^MEDIA_TYPE;

FORMAT_PARAMETERS :: struct {
    MediaType           : MEDIA_TYPE,
    StartCylinderNumber : DWORD,
    EndCylinderNumber   : DWORD,
    StartHeadNumber     : DWORD,
    EndHeadNumber       : DWORD,
};
PFORMAT_PARAMETERS :: ^FORMAT_PARAMETERS;

BAD_TRACK_NUMBER :: WORD;

PBAD_TRACK_NUMBER :: ^WORD;

FORMAT_EX_PARAMETERS :: struct {
    MediaType           : MEDIA_TYPE,
    StartCylinderNumber : DWORD,
    EndCylinderNumber   : DWORD,
    StartHeadNumber     : DWORD,
    EndHeadNumber       : DWORD,
    FormatGapLength     : WORD,
    SectorsPerTrack     : WORD,
    SectorNumber        : [1]WORD,
};
PFORMAT_EX_PARAMETERS :: ^FORMAT_EX_PARAMETERS;

DISK_GEOMETRY :: struct {
    Cylinders         : LARGE_INTEGER,
    MediaType         : MEDIA_TYPE,
    TracksPerCylinder : DWORD,
    SectorsPerTrack   : DWORD,
    BytesPerSector    : DWORD,
};
PDISK_GEOMETRY :: ^DISK_GEOMETRY;

PARTITION_INFORMATION :: struct {
    StartingOffset      : LARGE_INTEGER,
    PartitionLength     : LARGE_INTEGER,
    HiddenSectors       : DWORD,
    PartitionNumber     : DWORD,
    PartitionType       : BYTE,
    BootIndicator       : BOOLEAN,
    RecognizedPartition : BOOLEAN,
    RewritePartition    : BOOLEAN,
};
PPARTITION_INFORMATION :: ^PARTITION_INFORMATION;

SET_PARTITION_INFORMATION :: struct {
    PartitionType : BYTE,
};
PSET_PARTITION_INFORMATION :: ^SET_PARTITION_INFORMATION;

DRIVE_LAYOUT_INFORMATION :: struct {
    PartitionCount : DWORD,
    Signature      : DWORD,
    PartitionEntry : [1]PARTITION_INFORMATION,
};
PDRIVE_LAYOUT_INFORMATION :: ^DRIVE_LAYOUT_INFORMATION;

VERIFY_INFORMATION :: struct {
    StartingOffset : LARGE_INTEGER,
    Length         : DWORD,
};
PVERIFY_INFORMATION :: ^VERIFY_INFORMATION;

REASSIGN_BLOCKS :: struct {
    Reserved    : WORD,
    Count       : WORD,
    BlockNumber : [1]DWORD,
};
PREASSIGN_BLOCKS :: ^REASSIGN_BLOCKS;

REASSIGN_BLOCKS_EX :: struct {
    Reserved    : WORD,
    Count       : WORD,
    BlockNumber : [1]LARGE_INTEGER,
};
PREASSIGN_BLOCKS_EX :: ^REASSIGN_BLOCKS_EX;

/* PARTITION_STYLE :: enum { */
PARTITION_STYLE :: _c.int;
    PARTITION_STYLE_MBR :: 0;
    PARTITION_STYLE_GPT :: PARTITION_STYLE_MBR + 1;
    PARTITION_STYLE_RAW :: PARTITION_STYLE_GPT + 1;
/* } */
;

PARTITION_INFORMATION_GPT :: struct {
    PartitionType : GUID,
    PartitionId   : GUID,
    Attributes    : DWORD64,
    Name          : [36]WCHAR,
};
PPARTITION_INFORMATION_GPT :: ^PARTITION_INFORMATION_GPT;

PARTITION_INFORMATION_MBR :: struct {
    PartitionType       : BYTE,
    BootIndicator       : BOOLEAN,
    RecognizedPartition : BOOLEAN,
    HiddenSectors       : DWORD,
    PartitionId         : GUID,
};
PPARTITION_INFORMATION_MBR :: ^PARTITION_INFORMATION_MBR;

SET_PARTITION_INFORMATION_MBR :: SET_PARTITION_INFORMATION;

SET_PARTITION_INFORMATION_GPT :: PARTITION_INFORMATION_GPT;

SET_PARTITION_INFORMATION_EX :: struct {
    PartitionStyle : PARTITION_STYLE,
    u : struct #raw_union {
        Mbr : SET_PARTITION_INFORMATION_MBR,
        Gpt : SET_PARTITION_INFORMATION_GPT,
    },
};
PSET_PARTITION_INFORMATION_EX :: ^SET_PARTITION_INFORMATION_EX;

CREATE_DISK_GPT :: struct {
    DiskId            : GUID,
    MaxPartitionCount : DWORD,
};
PCREATE_DISK_GPT :: ^CREATE_DISK_GPT;

CREATE_DISK_MBR :: struct {
    Signature : DWORD,
};
PCREATE_DISK_MBR :: ^CREATE_DISK_MBR;

CREATE_DISK :: struct {
    PartitionStyle : PARTITION_STYLE,
    u : struct #raw_union {
        Mbr : CREATE_DISK_MBR,
        Gpt : CREATE_DISK_GPT,
    },
};
PCREATE_DISK :: ^CREATE_DISK;

GET_LENGTH_INFORMATION :: struct {
    Length : LARGE_INTEGER,
};
PGET_LENGTH_INFORMATION :: ^GET_LENGTH_INFORMATION;

PARTITION_INFORMATION_EX :: struct {
    PartitionStyle     : PARTITION_STYLE,
    StartingOffset     : LARGE_INTEGER,
    PartitionLength    : LARGE_INTEGER,
    PartitionNumber    : DWORD,
    RewritePartition   : BOOLEAN,
    IsServicePartition : BOOLEAN,
    u : struct #raw_union {
        Mbr : PARTITION_INFORMATION_MBR,
        Gpt : PARTITION_INFORMATION_GPT,
    },
};
PPARTITION_INFORMATION_EX :: ^PARTITION_INFORMATION_EX;

DRIVE_LAYOUT_INFORMATION_GPT :: struct {
    DiskId               : GUID,
    StartingUsableOffset : LARGE_INTEGER,
    UsableLength         : LARGE_INTEGER,
    MaxPartitionCount    : DWORD,
};
PDRIVE_LAYOUT_INFORMATION_GPT :: ^DRIVE_LAYOUT_INFORMATION_GPT;

DRIVE_LAYOUT_INFORMATION_MBR :: struct {
    Signature : DWORD,
    CheckSum  : DWORD,
};
PDRIVE_LAYOUT_INFORMATION_MBR :: ^DRIVE_LAYOUT_INFORMATION_MBR;

DRIVE_LAYOUT_INFORMATION_EX :: struct {
    PartitionStyle : DWORD,
    PartitionCount : DWORD,
    u : struct #raw_union {
        Mbr : DRIVE_LAYOUT_INFORMATION_MBR,
        Gpt : DRIVE_LAYOUT_INFORMATION_GPT,
    },
    PartitionEntry : [1]PARTITION_INFORMATION_EX,
};
PDRIVE_LAYOUT_INFORMATION_EX :: ^DRIVE_LAYOUT_INFORMATION_EX;

/* DETECTION_TYPE :: enum { */
DETECTION_TYPE :: _c.int;
    DetectNone :: 0;
    DetectInt13 :: DetectNone + 1;
    DetectExInt13 :: DetectInt13 + 1;
/* } */
;

DISK_INT13_INFO :: struct {
    DriveSelect     : WORD,
    MaxCylinders    : DWORD,
    SectorsPerTrack : WORD,
    MaxHeads        : WORD,
    NumberDrives    : WORD,
};
PDISK_INT13_INFO :: ^DISK_INT13_INFO;

DISK_EX_INT13_INFO :: struct {
    ExBufferSize      : WORD,
    ExFlags           : WORD,
    ExCylinders       : DWORD,
    ExHeads           : DWORD,
    ExSectorsPerTrack : DWORD,
    ExSectorsPerDrive : DWORD64,
    ExSectorSize      : WORD,
    ExReserved        : WORD,
};
PDISK_EX_INT13_INFO :: ^DISK_EX_INT13_INFO;

DISK_DETECTION_INFO :: struct {
    SizeOfDetectInfo : DWORD,
    DetectionType    : DETECTION_TYPE,
    u : struct #raw_union {
        s : struct {
            Int13   : DISK_INT13_INFO,
            ExInt13 : DISK_EX_INT13_INFO,
        },
    },
};
PDISK_DETECTION_INFO :: ^DISK_DETECTION_INFO;

DISK_PARTITION_INFO :: struct {
    SizeOfPartitionInfo : DWORD,
    PartitionStyle      : PARTITION_STYLE,
    u : struct #raw_union {
        Mbr : struct {
            Signature : DWORD,
            CheckSum  : DWORD,
        },
        Gpt : struct {
            DiskId : GUID,
        },
    },
};
PDISK_PARTITION_INFO :: ^DISK_PARTITION_INFO;

DISK_GEOMETRY_EX :: struct {
    Geometry : DISK_GEOMETRY,
    DiskSize : LARGE_INTEGER,
    Data     : [1]BYTE,
};
PDISK_GEOMETRY_EX :: ^DISK_GEOMETRY_EX;

DISK_CONTROLLER_NUMBER :: struct {
    ControllerNumber : DWORD,
    DiskNumber       : DWORD,
};
PDISK_CONTROLLER_NUMBER :: ^DISK_CONTROLLER_NUMBER;

/* DISK_CACHE_RETENTION_PRIORITY :: enum { */
DISK_CACHE_RETENTION_PRIORITY :: _c.int;
    EqualPriority :: 0;
    KeepPrefetchedData :: EqualPriority + 1;
    KeepReadData :: KeepPrefetchedData + 1;
/* } */
;

DISK_CACHE_INFORMATION :: struct {
    ParametersSavable             : BOOLEAN,
    ReadCacheEnabled              : BOOLEAN,
    WriteCacheEnabled             : BOOLEAN,
    ReadRetentionPriority         : DISK_CACHE_RETENTION_PRIORITY,
    WriteRetentionPriority        : DISK_CACHE_RETENTION_PRIORITY,
    DisablePrefetchTransferLength : WORD,
    PrefetchScalar                : BOOLEAN,
    u : struct #raw_union {
        ScalarPrefetch : struct {
            Minimum       : WORD,
            Maximum       : WORD,
            MaximumBlocks : WORD,
        },
        BlockPrefetch : struct {
            Minimum : WORD,
            Maximum : WORD,
        },
    },
};
PDISK_CACHE_INFORMATION :: ^DISK_CACHE_INFORMATION;

DISK_GROW_PARTITION :: struct {
    PartitionNumber : DWORD,
    BytesToGrow     : LARGE_INTEGER,
};
PDISK_GROW_PARTITION :: ^DISK_GROW_PARTITION;

HISTOGRAM_BUCKET :: struct {
    Reads  : DWORD,
    Writes : DWORD,
};
PHISTOGRAM_BUCKET :: ^HISTOGRAM_BUCKET;

DISK_HISTOGRAM :: struct {
    DiskSize     : LARGE_INTEGER,
    Start        : LARGE_INTEGER,
    End          : LARGE_INTEGER,
    Average      : LARGE_INTEGER,
    AverageRead  : LARGE_INTEGER,
    AverageWrite : LARGE_INTEGER,
    Granularity  : DWORD,
    Size         : DWORD,
    ReadCount    : DWORD,
    WriteCount   : DWORD,
    Histogram    : PHISTOGRAM_BUCKET,
};
PDISK_HISTOGRAM :: ^DISK_HISTOGRAM;

DISK_PERFORMANCE :: struct {
    BytesRead           : LARGE_INTEGER,
    BytesWritten        : LARGE_INTEGER,
    ReadTime            : LARGE_INTEGER,
    WriteTime           : LARGE_INTEGER,
    IdleTime            : LARGE_INTEGER,
    ReadCount           : DWORD,
    WriteCount          : DWORD,
    QueueDepth          : DWORD,
    SplitCount          : DWORD,
    QueryTime           : LARGE_INTEGER,
    StorageDeviceNumber : DWORD,
    StorageManagerName  : [8]WCHAR,
};
PDISK_PERFORMANCE :: ^DISK_PERFORMANCE;

DISK_RECORD :: struct {
    ByteOffset     : LARGE_INTEGER,
    StartTime      : LARGE_INTEGER,
    EndTime        : LARGE_INTEGER,
    VirtualAddress : PVOID,
    NumberOfBytes  : DWORD,
    DeviceNumber   : BYTE,
    ReadRequest    : BOOLEAN,
};
PDISK_RECORD :: ^DISK_RECORD;

DISK_LOGGING :: struct {
    Function      : BYTE,
    BufferAddress : PVOID,
    BufferSize    : DWORD,
};
PDISK_LOGGING :: ^DISK_LOGGING;

/* BIN_TYPES :: enum { */
BIN_TYPES :: _c.int;
    RequestSize :: 0;
    RequestLocation :: RequestSize + 1;
/* } */
;

BIN_RANGE :: struct {
    StartValue : LARGE_INTEGER,
    Length     : LARGE_INTEGER,
};
PBIN_RANGE :: ^BIN_RANGE;

PERF_BIN :: struct {
    NumberOfBins : DWORD,
    TypeOfBin    : DWORD,
    BinsRanges   : [1]BIN_RANGE,
};
PPERF_BIN :: ^PERF_BIN;

BIN_COUNT :: struct {
    BinRange : BIN_RANGE,
    BinCount : DWORD,
};
PBIN_COUNT :: ^BIN_COUNT;

BIN_RESULTS :: struct {
    NumberOfBins : DWORD,
    BinCounts    : [1]BIN_COUNT,
};
PBIN_RESULTS :: ^BIN_RESULTS;

GETVERSIONINPARAMS :: struct {
    bVersion      : BYTE,
    bRevision     : BYTE,
    bReserved     : BYTE,
    bIDEDeviceMap : BYTE,
    fCapabilities : DWORD,
    dwReserved    : [4]DWORD,
};
PGETVERSIONINPARAMS :: ^GETVERSIONINPARAMS;
LPGETVERSIONINPARAMS :: ^GETVERSIONINPARAMS;

IDEREGS :: struct {
    bFeaturesReg     : BYTE,
    bSectorCountReg  : BYTE,
    bSectorNumberReg : BYTE,
    bCylLowReg       : BYTE,
    bCylHighReg      : BYTE,
    bDriveHeadReg    : BYTE,
    bCommandReg      : BYTE,
    bReserved        : BYTE,
};
PIDEREGS :: ^IDEREGS;
LPIDEREGS :: ^IDEREGS;

SENDCMDINPARAMS :: struct {
    cBufferSize  : DWORD,
    irDriveRegs  : IDEREGS,
    bDriveNumber : BYTE,
    bReserved    : [3]BYTE,
    dwReserved   : [4]DWORD,
    bBuffer      : [1]BYTE,
};
PSENDCMDINPARAMS :: ^SENDCMDINPARAMS;
LPSENDCMDINPARAMS :: ^SENDCMDINPARAMS;

DRIVERSTATUS :: struct {
    bDriverError : BYTE,
    bIDEError    : BYTE,
    bReserved    : [2]BYTE,
    dwReserved   : [2]DWORD,
};
PDRIVERSTATUS :: ^DRIVERSTATUS;
LPDRIVERSTATUS :: ^DRIVERSTATUS;

SENDCMDOUTPARAMS :: struct {
    cBufferSize  : DWORD,
    DriverStatus : DRIVERSTATUS,
    bBuffer      : [1]BYTE,
};
PSENDCMDOUTPARAMS :: ^SENDCMDOUTPARAMS;
LPSENDCMDOUTPARAMS :: ^SENDCMDOUTPARAMS;

GET_DISK_ATTRIBUTES :: struct {
    Version    : DWORD,
    Reserved1  : DWORD,
    Attributes : DWORDLONG,
};
PGET_DISK_ATTRIBUTES :: ^GET_DISK_ATTRIBUTES;

SET_DISK_ATTRIBUTES :: struct {
    Version        : DWORD,
    Persist        : BOOLEAN,
    Reserved1      : [3]BYTE,
    Attributes     : DWORDLONG,
    AttributesMask : DWORDLONG,
    Reserved2      : [4]DWORD,
};
PSET_DISK_ATTRIBUTES :: ^SET_DISK_ATTRIBUTES;

/* ELEMENT_TYPE :: enum { */
ELEMENT_TYPE :: _c.int;
    AllElements :: 0;
    ChangerTransport :: AllElements + 1;
    ChangerSlot :: ChangerTransport + 1;
    ChangerIEPort :: ChangerSlot + 1;
    ChangerDrive :: ChangerIEPort + 1;
    ChangerDoor :: ChangerDrive + 1;
    ChangerKeypad :: ChangerDoor + 1;
    ChangerMaxElement :: ChangerKeypad + 1;
/* } */
PELEMENT_TYPE :: ^ELEMENT_TYPE;

CHANGER_ELEMENT :: struct {
    ElementType    : ELEMENT_TYPE,
    ElementAddress : DWORD,
};
PCHANGER_ELEMENT :: ^CHANGER_ELEMENT;

CHANGER_ELEMENT_LIST :: struct {
    Element          : CHANGER_ELEMENT,
    NumberOfElements : DWORD,
};
PCHANGER_ELEMENT_LIST :: ^CHANGER_ELEMENT_LIST;

GET_CHANGER_PARAMETERS :: struct {
    Size                       : DWORD,
    NumberTransportElements    : WORD,
    NumberStorageElements      : WORD,
    NumberCleanerSlots         : WORD,
    NumberIEElements           : WORD,
    NumberDataTransferElements : WORD,
    NumberOfDoors              : WORD,
    FirstSlotNumber            : WORD,
    FirstDriveNumber           : WORD,
    FirstTransportNumber       : WORD,
    FirstIEPortNumber          : WORD,
    FirstCleanerSlotAddress    : WORD,
    MagazineSize               : WORD,
    DriveCleanTimeout          : DWORD,
    Features0                  : DWORD,
    Features1                  : DWORD,
    MoveFromTransport          : BYTE,
    MoveFromSlot               : BYTE,
    MoveFromIePort             : BYTE,
    MoveFromDrive              : BYTE,
    ExchangeFromTransport      : BYTE,
    ExchangeFromSlot           : BYTE,
    ExchangeFromIePort         : BYTE,
    ExchangeFromDrive          : BYTE,
    LockUnlockCapabilities     : BYTE,
    PositionCapabilities       : BYTE,
    Reserved1                  : [2]BYTE,
    Reserved2                  : [2]DWORD,
};
PGET_CHANGER_PARAMETERS :: ^GET_CHANGER_PARAMETERS;

CHANGER_PRODUCT_DATA :: struct {
    VendorId     : [8]BYTE,
    ProductId    : [16]BYTE,
    Revision     : [4]BYTE,
    SerialNumber : [32]BYTE,
    DeviceType   : BYTE,
};
PCHANGER_PRODUCT_DATA :: ^CHANGER_PRODUCT_DATA;

CHANGER_SET_ACCESS :: struct {
    Element : CHANGER_ELEMENT,
    Control : DWORD,
};
PCHANGER_SET_ACCESS :: ^CHANGER_SET_ACCESS;

CHANGER_READ_ELEMENT_STATUS :: struct {
    ElementList   : CHANGER_ELEMENT_LIST,
    VolumeTagInfo : BOOLEAN,
};
PCHANGER_READ_ELEMENT_STATUS :: ^CHANGER_READ_ELEMENT_STATUS;

CHANGER_ELEMENT_STATUS :: struct {
    Element           : CHANGER_ELEMENT,
    SrcElementAddress : CHANGER_ELEMENT,
    Flags             : DWORD,
    ExceptionCode     : DWORD,
    TargetId          : BYTE,
    Lun               : BYTE,
    Reserved          : WORD,
    PrimaryVolumeID   : [36]BYTE,
    AlternateVolumeID : [36]BYTE,
};
PCHANGER_ELEMENT_STATUS :: ^CHANGER_ELEMENT_STATUS;

CHANGER_ELEMENT_STATUS_EX :: struct {
    Element               : CHANGER_ELEMENT,
    SrcElementAddress     : CHANGER_ELEMENT,
    Flags                 : DWORD,
    ExceptionCode         : DWORD,
    TargetId              : BYTE,
    Lun                   : BYTE,
    Reserved              : WORD,
    PrimaryVolumeID       : [36]BYTE,
    AlternateVolumeID     : [36]BYTE,
    VendorIdentification  : [8]BYTE,
    ProductIdentification : [16]BYTE,
    SerialNumber          : [32]BYTE,
};
PCHANGER_ELEMENT_STATUS_EX :: ^CHANGER_ELEMENT_STATUS_EX;

CHANGER_INITIALIZE_ELEMENT_STATUS :: struct {
    ElementList : CHANGER_ELEMENT_LIST,
    BarCodeScan : BOOLEAN,
};
PCHANGER_INITIALIZE_ELEMENT_STATUS :: ^CHANGER_INITIALIZE_ELEMENT_STATUS;

CHANGER_SET_POSITION :: struct {
    Transport   : CHANGER_ELEMENT,
    Destination : CHANGER_ELEMENT,
    Flip        : BOOLEAN,
};
PCHANGER_SET_POSITION :: ^CHANGER_SET_POSITION;

CHANGER_EXCHANGE_MEDIUM :: struct {
    Transport    : CHANGER_ELEMENT,
    Source       : CHANGER_ELEMENT,
    Destination1 : CHANGER_ELEMENT,
    Destination2 : CHANGER_ELEMENT,
    Flip1        : BOOLEAN,
    Flip2        : BOOLEAN,
};
PCHANGER_EXCHANGE_MEDIUM :: ^CHANGER_EXCHANGE_MEDIUM;

CHANGER_MOVE_MEDIUM :: struct {
    Transport   : CHANGER_ELEMENT,
    Source      : CHANGER_ELEMENT,
    Destination : CHANGER_ELEMENT,
    Flip        : BOOLEAN,
};
PCHANGER_MOVE_MEDIUM :: ^CHANGER_MOVE_MEDIUM;

CHANGER_SEND_VOLUME_TAG_INFORMATION :: struct {
    StartingElement  : CHANGER_ELEMENT,
    ActionCode       : DWORD,
    VolumeIDTemplate : [40]BYTE,
};
PCHANGER_SEND_VOLUME_TAG_INFORMATION :: ^CHANGER_SEND_VOLUME_TAG_INFORMATION;

READ_ELEMENT_ADDRESS_INFO :: struct {
    NumberOfElements : DWORD,
    ElementStatus    : [1]CHANGER_ELEMENT_STATUS,
};
PREAD_ELEMENT_ADDRESS_INFO :: ^READ_ELEMENT_ADDRESS_INFO;

/* CHANGER_DEVICE_PROBLEM_TYPE :: enum { */
CHANGER_DEVICE_PROBLEM_TYPE :: _c.int;
    DeviceProblemNone :: 0;
    DeviceProblemHardware :: DeviceProblemNone + 1;
    DeviceProblemCHMError :: DeviceProblemHardware + 1;
    DeviceProblemDoorOpen :: DeviceProblemCHMError + 1;
    DeviceProblemCalibrationError :: DeviceProblemDoorOpen + 1;
    DeviceProblemTargetFailure :: DeviceProblemCalibrationError + 1;
    DeviceProblemCHMMoveError :: DeviceProblemTargetFailure + 1;
    DeviceProblemCHMZeroError :: DeviceProblemCHMMoveError + 1;
    DeviceProblemCartridgeInsertError :: DeviceProblemCHMZeroError + 1;
    DeviceProblemPositionError :: DeviceProblemCartridgeInsertError + 1;
    DeviceProblemSensorError :: DeviceProblemPositionError + 1;
    DeviceProblemCartridgeEjectError :: DeviceProblemSensorError + 1;
    DeviceProblemGripperError :: DeviceProblemCartridgeEjectError + 1;
    DeviceProblemDriveError :: DeviceProblemGripperError + 1;
/* } */
PCHANGER_DEVICE_PROBLEM_TYPE :: ^CHANGER_DEVICE_PROBLEM_TYPE;

PATHNAME_BUFFER :: struct {
    PathNameLength : DWORD,
    Name           : [1]WCHAR,
};
PPATHNAME_BUFFER :: ^PATHNAME_BUFFER;

FSCTL_QUERY_FAT_BPB_BUFFER :: struct {
    First0x24BytesOfBootSector : [0x24]BYTE,
};
PFSCTL_QUERY_FAT_BPB_BUFFER :: ^FSCTL_QUERY_FAT_BPB_BUFFER;

NTFS_VOLUME_DATA_BUFFER :: struct {
    VolumeSerialNumber           : LARGE_INTEGER,
    NumberSectors                : LARGE_INTEGER,
    TotalClusters                : LARGE_INTEGER,
    FreeClusters                 : LARGE_INTEGER,
    TotalReserved                : LARGE_INTEGER,
    BytesPerSector               : DWORD,
    BytesPerCluster              : DWORD,
    BytesPerFileRecordSegment    : DWORD,
    ClustersPerFileRecordSegment : DWORD,
    MftValidDataLength           : LARGE_INTEGER,
    MftStartLcn                  : LARGE_INTEGER,
    Mft2StartLcn                 : LARGE_INTEGER,
    MftZoneStart                 : LARGE_INTEGER,
    MftZoneEnd                   : LARGE_INTEGER,
};
PNTFS_VOLUME_DATA_BUFFER :: ^NTFS_VOLUME_DATA_BUFFER;

NTFS_EXTENDED_VOLUME_DATA :: struct {
    ByteCount                : DWORD,
    MajorVersion             : WORD,
    MinorVersion             : WORD,
    BytesPerPhysicalSector   : DWORD,
    LfsMajorVersion          : WORD,
    LfsMinorVersion          : WORD,
    MaxDeviceTrimExtentCount : DWORD,
    MaxDeviceTrimByteCount   : DWORD,
    MaxVolumeTrimExtentCount : DWORD,
    MaxVolumeTrimByteCount   : DWORD,
};
PNTFS_EXTENDED_VOLUME_DATA :: ^NTFS_EXTENDED_VOLUME_DATA;

REFS_VOLUME_DATA_BUFFER :: struct {
    ByteCount                 : DWORD,
    MajorVersion              : DWORD,
    MinorVersion              : DWORD,
    BytesPerPhysicalSector    : DWORD,
    VolumeSerialNumber        : LARGE_INTEGER,
    NumberSectors             : LARGE_INTEGER,
    TotalClusters             : LARGE_INTEGER,
    FreeClusters              : LARGE_INTEGER,
    TotalReserved             : LARGE_INTEGER,
    BytesPerSector            : DWORD,
    BytesPerCluster           : DWORD,
    MaximumSizeOfResidentFile : LARGE_INTEGER,
    Reserved                  : [10]LARGE_INTEGER,
};
PREFS_VOLUME_DATA_BUFFER :: ^REFS_VOLUME_DATA_BUFFER;

STARTING_LCN_INPUT_BUFFER :: struct {
    StartingLcn : LARGE_INTEGER,
};
PSTARTING_LCN_INPUT_BUFFER :: ^STARTING_LCN_INPUT_BUFFER;

STARTING_LCN_INPUT_BUFFER_EX :: struct {
    StartingLcn : LARGE_INTEGER,
    Flags       : DWORD,
};
PSTARTING_LCN_INPUT_BUFFER_EX :: ^STARTING_LCN_INPUT_BUFFER_EX;

VOLUME_BITMAP_BUFFER :: struct {
    StartingLcn : LARGE_INTEGER,
    BitmapSize  : LARGE_INTEGER,
    Buffer      : [1]BYTE,
};
PVOLUME_BITMAP_BUFFER :: ^VOLUME_BITMAP_BUFFER;

STARTING_VCN_INPUT_BUFFER :: struct {
    StartingVcn : LARGE_INTEGER,
};
PSTARTING_VCN_INPUT_BUFFER :: ^STARTING_VCN_INPUT_BUFFER;

RETRIEVAL_POINTERS_BUFFER :: struct {
    ExtentCount : DWORD,
    StartingVcn : LARGE_INTEGER,
    Extents : [1]struct {
    NextVcn : LARGE_INTEGER,
    Lcn     : LARGE_INTEGER,
},
};
PRETRIEVAL_POINTERS_BUFFER :: ^RETRIEVAL_POINTERS_BUFFER;

RETRIEVAL_POINTERS_AND_REFCOUNT_BUFFER :: struct {
    ExtentCount : DWORD,
    StartingVcn : LARGE_INTEGER,
    Extents : [1]struct {
    NextVcn        : LARGE_INTEGER,
    Lcn            : LARGE_INTEGER,
    ReferenceCount : DWORD,
},
};
PRETRIEVAL_POINTERS_AND_REFCOUNT_BUFFER :: ^RETRIEVAL_POINTERS_AND_REFCOUNT_BUFFER;

RETRIEVAL_POINTER_COUNT :: struct {
    ExtentCount : DWORD,
};
PRETRIEVAL_POINTER_COUNT :: ^RETRIEVAL_POINTER_COUNT;

NTFS_FILE_RECORD_INPUT_BUFFER :: struct {
    FileReferenceNumber : LARGE_INTEGER,
};
PNTFS_FILE_RECORD_INPUT_BUFFER :: ^NTFS_FILE_RECORD_INPUT_BUFFER;

NTFS_FILE_RECORD_OUTPUT_BUFFER :: struct {
    FileReferenceNumber : LARGE_INTEGER,
    FileRecordLength    : DWORD,
    FileRecordBuffer    : [1]BYTE,
};
PNTFS_FILE_RECORD_OUTPUT_BUFFER :: ^NTFS_FILE_RECORD_OUTPUT_BUFFER;

MOVE_FILE_DATA :: struct {
    FileHandle   : HANDLE,
    StartingVcn  : LARGE_INTEGER,
    StartingLcn  : LARGE_INTEGER,
    ClusterCount : DWORD,
};
PMOVE_FILE_DATA :: ^MOVE_FILE_DATA;

MOVE_FILE_RECORD_DATA :: struct {
    FileHandle       : HANDLE,
    SourceFileRecord : LARGE_INTEGER,
    TargetFileRecord : LARGE_INTEGER,
};
PMOVE_FILE_RECORD_DATA :: ^MOVE_FILE_RECORD_DATA;

MOVE_FILE_DATA32 :: struct {
    FileHandle   : UINT32,
    StartingVcn  : LARGE_INTEGER,
    StartingLcn  : LARGE_INTEGER,
    ClusterCount : DWORD,
};
PMOVE_FILE_DATA32 :: ^MOVE_FILE_DATA32;

FIND_BY_SID_DATA :: struct {
    Restart : DWORD,
    Sid     : SID,
};
PFIND_BY_SID_DATA :: ^FIND_BY_SID_DATA;

FIND_BY_SID_OUTPUT :: struct {
    NextEntryOffset : DWORD,
    FileIndex       : DWORD,
    FileNameLength  : DWORD,
    FileName        : [1]WCHAR,
};
PFIND_BY_SID_OUTPUT :: ^FIND_BY_SID_OUTPUT;

MFT_ENUM_DATA_V0 :: struct {
    StartFileReferenceNumber : DWORDLONG,
    LowUsn                   : USN,
    HighUsn                  : USN,
};
PMFT_ENUM_DATA_V0 :: ^MFT_ENUM_DATA_V0;

MFT_ENUM_DATA_V1 :: struct {
    StartFileReferenceNumber : DWORDLONG,
    LowUsn                   : USN,
    HighUsn                  : USN,
    MinMajorVersion          : WORD,
    MaxMajorVersion          : WORD,
};
PMFT_ENUM_DATA_V1 :: ^MFT_ENUM_DATA_V1;

MFT_ENUM_DATA :: MFT_ENUM_DATA_V1;
PMFT_ENUM_DATA :: ^MFT_ENUM_DATA_V1;

CREATE_USN_JOURNAL_DATA :: struct {
    MaximumSize     : DWORDLONG,
    AllocationDelta : DWORDLONG,
};
PCREATE_USN_JOURNAL_DATA :: ^CREATE_USN_JOURNAL_DATA;

READ_FILE_USN_DATA :: struct {
    MinMajorVersion : WORD,
    MaxMajorVersion : WORD,
};
PREAD_FILE_USN_DATA :: ^READ_FILE_USN_DATA;

READ_USN_JOURNAL_DATA_V0 :: struct {
    StartUsn          : USN,
    ReasonMask        : DWORD,
    ReturnOnlyOnClose : DWORD,
    Timeout           : DWORDLONG,
    BytesToWaitFor    : DWORDLONG,
    UsnJournalID      : DWORDLONG,
};
PREAD_USN_JOURNAL_DATA_V0 :: ^READ_USN_JOURNAL_DATA_V0;

READ_USN_JOURNAL_DATA_V1 :: struct {
    StartUsn          : USN,
    ReasonMask        : DWORD,
    ReturnOnlyOnClose : DWORD,
    Timeout           : DWORDLONG,
    BytesToWaitFor    : DWORDLONG,
    UsnJournalID      : DWORDLONG,
    MinMajorVersion   : WORD,
    MaxMajorVersion   : WORD,
};
PREAD_USN_JOURNAL_DATA_V1 :: ^READ_USN_JOURNAL_DATA_V1;

READ_USN_JOURNAL_DATA :: READ_USN_JOURNAL_DATA_V1;
PREAD_USN_JOURNAL_DATA :: ^READ_USN_JOURNAL_DATA_V1;

USN_TRACK_MODIFIED_RANGES :: struct {
    Flags             : DWORD,
    Unused            : DWORD,
    ChunkSize         : DWORDLONG,
    FileSizeThreshold : LONGLONG,
};
PUSN_TRACK_MODIFIED_RANGES :: ^USN_TRACK_MODIFIED_RANGES;

USN_RANGE_TRACK_OUTPUT :: struct {
    Usn : USN,
};
PUSN_RANGE_TRACK_OUTPUT :: ^USN_RANGE_TRACK_OUTPUT;

USN_RECORD_V2 :: struct {
    RecordLength              : DWORD,
    MajorVersion              : WORD,
    MinorVersion              : WORD,
    FileReferenceNumber       : DWORDLONG,
    ParentFileReferenceNumber : DWORDLONG,
    Usn                       : USN,
    TimeStamp                 : LARGE_INTEGER,
    Reason                    : DWORD,
    SourceInfo                : DWORD,
    SecurityId                : DWORD,
    FileAttributes            : DWORD,
    FileNameLength            : WORD,
    FileNameOffset            : WORD,
    FileName                  : [1]WCHAR,
};
PUSN_RECORD_V2 :: ^USN_RECORD_V2;

USN_RECORD_V3 :: struct {
    RecordLength              : DWORD,
    MajorVersion              : WORD,
    MinorVersion              : WORD,
    FileReferenceNumber       : FILE_ID_128,
    ParentFileReferenceNumber : FILE_ID_128,
    Usn                       : USN,
    TimeStamp                 : LARGE_INTEGER,
    Reason                    : DWORD,
    SourceInfo                : DWORD,
    SecurityId                : DWORD,
    FileAttributes            : DWORD,
    FileNameLength            : WORD,
    FileNameOffset            : WORD,
    FileName                  : [1]WCHAR,
};
PUSN_RECORD_V3 :: ^USN_RECORD_V3;

USN_RECORD :: USN_RECORD_V2;
PUSN_RECORD :: ^USN_RECORD_V2;

USN_RECORD_COMMON_HEADER :: struct {
    RecordLength : DWORD,
    MajorVersion : WORD,
    MinorVersion : WORD,
};
PUSN_RECORD_COMMON_HEADER :: ^USN_RECORD_COMMON_HEADER;

USN_RECORD_EXTENT :: struct {
    Offset : LONGLONG,
    Length : LONGLONG,
};
PUSN_RECORD_EXTENT :: ^USN_RECORD_EXTENT;

USN_RECORD_V4 :: struct {
    Header                    : USN_RECORD_COMMON_HEADER,
    FileReferenceNumber       : FILE_ID_128,
    ParentFileReferenceNumber : FILE_ID_128,
    Usn                       : USN,
    Reason                    : DWORD,
    SourceInfo                : DWORD,
    RemainingExtents          : DWORD,
    NumberOfExtents           : WORD,
    ExtentSize                : WORD,
    Extents                   : [1]USN_RECORD_EXTENT,
};
PUSN_RECORD_V4 :: ^USN_RECORD_V4;

USN_RECORD_UNION :: struct #raw_union {
    Header : USN_RECORD_COMMON_HEADER,
    V2     : USN_RECORD_V2,
    V3     : USN_RECORD_V3,
    V4     : USN_RECORD_V4,
};
PUSN_RECORD_UNION :: ^USN_RECORD_UNION;

USN_JOURNAL_DATA_V0 :: struct {
    UsnJournalID    : DWORDLONG,
    FirstUsn        : USN,
    NextUsn         : USN,
    LowestValidUsn  : USN,
    MaxUsn          : USN,
    MaximumSize     : DWORDLONG,
    AllocationDelta : DWORDLONG,
};
PUSN_JOURNAL_DATA_V0 :: ^USN_JOURNAL_DATA_V0;

USN_JOURNAL_DATA_V1 :: struct {
    UsnJournalID             : DWORDLONG,
    FirstUsn                 : USN,
    NextUsn                  : USN,
    LowestValidUsn           : USN,
    MaxUsn                   : USN,
    MaximumSize              : DWORDLONG,
    AllocationDelta          : DWORDLONG,
    MinSupportedMajorVersion : WORD,
    MaxSupportedMajorVersion : WORD,
};
PUSN_JOURNAL_DATA_V1 :: ^USN_JOURNAL_DATA_V1;

USN_JOURNAL_DATA_V2 :: struct {
    UsnJournalID                : DWORDLONG,
    FirstUsn                    : USN,
    NextUsn                     : USN,
    LowestValidUsn              : USN,
    MaxUsn                      : USN,
    MaximumSize                 : DWORDLONG,
    AllocationDelta             : DWORDLONG,
    MinSupportedMajorVersion    : WORD,
    MaxSupportedMajorVersion    : WORD,
    Flags                       : DWORD,
    RangeTrackChunkSize         : DWORDLONG,
    RangeTrackFileSizeThreshold : LONGLONG,
};
PUSN_JOURNAL_DATA_V2 :: ^USN_JOURNAL_DATA_V2;

USN_JOURNAL_DATA :: USN_JOURNAL_DATA_V1;
PUSN_JOURNAL_DATA :: ^USN_JOURNAL_DATA_V1;

DELETE_USN_JOURNAL_DATA :: struct {
    UsnJournalID : DWORDLONG,
    DeleteFlags  : DWORD,
};
PDELETE_USN_JOURNAL_DATA :: ^DELETE_USN_JOURNAL_DATA;

MARK_HANDLE_INFO :: struct {
    u : struct #raw_union {
        UsnSourceInfo : DWORD,
        CopyNumber    : DWORD,
    },
    VolumeHandle : HANDLE,
    HandleInfo   : DWORD,
};
PMARK_HANDLE_INFO :: ^MARK_HANDLE_INFO;

MARK_HANDLE_INFO32 :: struct {
    u : struct #raw_union {
        UsnSourceInfo : DWORD,
        CopyNumber    : DWORD,
    },
    VolumeHandle : UINT32,
    HandleInfo   : DWORD,
};
PMARK_HANDLE_INFO32 :: ^MARK_HANDLE_INFO32;

BULK_SECURITY_TEST_DATA :: struct {
    DesiredAccess : ACCESS_MASK,
    SecurityIds   : [1]DWORD,
};
PBULK_SECURITY_TEST_DATA :: ^BULK_SECURITY_TEST_DATA;

FILE_PREFETCH :: struct {
    Type     : DWORD,
    Count    : DWORD,
    Prefetch : [1]DWORDLONG,
};
PFILE_PREFETCH :: ^FILE_PREFETCH;

FILE_PREFETCH_EX :: struct {
    Type     : DWORD,
    Count    : DWORD,
    Context  : PVOID,
    Prefetch : [1]DWORDLONG,
};
PFILE_PREFETCH_EX :: ^FILE_PREFETCH_EX;

FILESYSTEM_STATISTICS :: struct {
    FileSystemType          : WORD,
    Version                 : WORD,
    SizeOfCompleteStructure : DWORD,
    UserFileReads           : DWORD,
    UserFileReadBytes       : DWORD,
    UserDiskReads           : DWORD,
    UserFileWrites          : DWORD,
    UserFileWriteBytes      : DWORD,
    UserDiskWrites          : DWORD,
    MetaDataReads           : DWORD,
    MetaDataReadBytes       : DWORD,
    MetaDataDiskReads       : DWORD,
    MetaDataWrites          : DWORD,
    MetaDataWriteBytes      : DWORD,
    MetaDataDiskWrites      : DWORD,
};
PFILESYSTEM_STATISTICS :: ^FILESYSTEM_STATISTICS;

FAT_STATISTICS :: struct {
    CreateHits          : DWORD,
    SuccessfulCreates   : DWORD,
    FailedCreates       : DWORD,
    NonCachedReads      : DWORD,
    NonCachedReadBytes  : DWORD,
    NonCachedWrites     : DWORD,
    NonCachedWriteBytes : DWORD,
    NonCachedDiskReads  : DWORD,
    NonCachedDiskWrites : DWORD,
};
PFAT_STATISTICS :: ^FAT_STATISTICS;

EXFAT_STATISTICS :: struct {
    CreateHits          : DWORD,
    SuccessfulCreates   : DWORD,
    FailedCreates       : DWORD,
    NonCachedReads      : DWORD,
    NonCachedReadBytes  : DWORD,
    NonCachedWrites     : DWORD,
    NonCachedWriteBytes : DWORD,
    NonCachedDiskReads  : DWORD,
    NonCachedDiskWrites : DWORD,
};
PEXFAT_STATISTICS :: ^EXFAT_STATISTICS;

NTFS_STATISTICS :: struct {
    LogFileFullExceptions              : DWORD,
    OtherExceptions                    : DWORD,
    MftReads                           : DWORD,
    MftReadBytes                       : DWORD,
    MftWrites                          : DWORD,
    MftWriteBytes                      : DWORD,
    MftWritesUserLevel : struct {
        Write   : WORD,
        Create  : WORD,
        SetInfo : WORD,
        Flush   : WORD,
    },
    MftWritesFlushForLogFileFull       : WORD,
    MftWritesLazyWriter                : WORD,
    MftWritesUserRequest               : WORD,
    Mft2Writes                         : DWORD,
    Mft2WriteBytes                     : DWORD,
    Mft2WritesUserLevel : struct {
        Write   : WORD,
        Create  : WORD,
        SetInfo : WORD,
        Flush   : WORD,
    },
    Mft2WritesFlushForLogFileFull      : WORD,
    Mft2WritesLazyWriter               : WORD,
    Mft2WritesUserRequest              : WORD,
    RootIndexReads                     : DWORD,
    RootIndexReadBytes                 : DWORD,
    RootIndexWrites                    : DWORD,
    RootIndexWriteBytes                : DWORD,
    BitmapReads                        : DWORD,
    BitmapReadBytes                    : DWORD,
    BitmapWrites                       : DWORD,
    BitmapWriteBytes                   : DWORD,
    BitmapWritesFlushForLogFileFull    : WORD,
    BitmapWritesLazyWriter             : WORD,
    BitmapWritesUserRequest            : WORD,
    BitmapWritesUserLevel : struct {
        Write   : WORD,
        Create  : WORD,
        SetInfo : WORD,
    },
    MftBitmapReads                     : DWORD,
    MftBitmapReadBytes                 : DWORD,
    MftBitmapWrites                    : DWORD,
    MftBitmapWriteBytes                : DWORD,
    MftBitmapWritesFlushForLogFileFull : WORD,
    MftBitmapWritesLazyWriter          : WORD,
    MftBitmapWritesUserRequest         : WORD,
    MftBitmapWritesUserLevel : struct {
        Write   : WORD,
        Create  : WORD,
        SetInfo : WORD,
        Flush   : WORD,
    },
    UserIndexReads                     : DWORD,
    UserIndexReadBytes                 : DWORD,
    UserIndexWrites                    : DWORD,
    UserIndexWriteBytes                : DWORD,
    LogFileReads                       : DWORD,
    LogFileReadBytes                   : DWORD,
    LogFileWrites                      : DWORD,
    LogFileWriteBytes                  : DWORD,
    Allocate : struct {
        Calls             : DWORD,
        Clusters          : DWORD,
        Hints             : DWORD,
        RunsReturned      : DWORD,
        HintsHonored      : DWORD,
        HintsClusters     : DWORD,
        Cache             : DWORD,
        CacheClusters     : DWORD,
        CacheMiss         : DWORD,
        CacheMissClusters : DWORD,
    },
    DiskResourcesExhausted             : DWORD,
};
PNTFS_STATISTICS :: ^NTFS_STATISTICS;

FILESYSTEM_STATISTICS_EX :: struct {
    FileSystemType          : WORD,
    Version                 : WORD,
    SizeOfCompleteStructure : DWORD,
    UserFileReads           : DWORDLONG,
    UserFileReadBytes       : DWORDLONG,
    UserDiskReads           : DWORDLONG,
    UserFileWrites          : DWORDLONG,
    UserFileWriteBytes      : DWORDLONG,
    UserDiskWrites          : DWORDLONG,
    MetaDataReads           : DWORDLONG,
    MetaDataReadBytes       : DWORDLONG,
    MetaDataDiskReads       : DWORDLONG,
    MetaDataWrites          : DWORDLONG,
    MetaDataWriteBytes      : DWORDLONG,
    MetaDataDiskWrites      : DWORDLONG,
};
PFILESYSTEM_STATISTICS_EX :: ^FILESYSTEM_STATISTICS_EX;

NTFS_STATISTICS_EX :: struct {
    LogFileFullExceptions                                               : DWORD,
    OtherExceptions                                                     : DWORD,
    MftReads                                                            : DWORDLONG,
    MftReadBytes                                                        : DWORDLONG,
    MftWrites                                                           : DWORDLONG,
    MftWriteBytes                                                       : DWORDLONG,
    MftWritesUserLevel : struct {
        Write   : DWORD,
        Create  : DWORD,
        SetInfo : DWORD,
        Flush   : DWORD,
    },
    MftWritesFlushForLogFileFull                                        : DWORD,
    MftWritesLazyWriter                                                 : DWORD,
    MftWritesUserRequest                                                : DWORD,
    Mft2Writes                                                          : DWORDLONG,
    Mft2WriteBytes                                                      : DWORDLONG,
    Mft2WritesUserLevel : struct {
        Write   : DWORD,
        Create  : DWORD,
        SetInfo : DWORD,
        Flush   : DWORD,
    },
    Mft2WritesFlushForLogFileFull                                       : DWORD,
    Mft2WritesLazyWriter                                                : DWORD,
    Mft2WritesUserRequest                                               : DWORD,
    RootIndexReads                                                      : DWORDLONG,
    RootIndexReadBytes                                                  : DWORDLONG,
    RootIndexWrites                                                     : DWORDLONG,
    RootIndexWriteBytes                                                 : DWORDLONG,
    BitmapReads                                                         : DWORDLONG,
    BitmapReadBytes                                                     : DWORDLONG,
    BitmapWrites                                                        : DWORDLONG,
    BitmapWriteBytes                                                    : DWORDLONG,
    BitmapWritesFlushForLogFileFull                                     : DWORD,
    BitmapWritesLazyWriter                                              : DWORD,
    BitmapWritesUserRequest                                             : DWORD,
    BitmapWritesUserLevel : struct {
        Write   : DWORD,
        Create  : DWORD,
        SetInfo : DWORD,
        Flush   : DWORD,
    },
    MftBitmapReads                                                      : DWORDLONG,
    MftBitmapReadBytes                                                  : DWORDLONG,
    MftBitmapWrites                                                     : DWORDLONG,
    MftBitmapWriteBytes                                                 : DWORDLONG,
    MftBitmapWritesFlushForLogFileFull                                  : DWORD,
    MftBitmapWritesLazyWriter                                           : DWORD,
    MftBitmapWritesUserRequest                                          : DWORD,
    MftBitmapWritesUserLevel : struct {
        Write   : DWORD,
        Create  : DWORD,
        SetInfo : DWORD,
        Flush   : DWORD,
    },
    UserIndexReads                                                      : DWORDLONG,
    UserIndexReadBytes                                                  : DWORDLONG,
    UserIndexWrites                                                     : DWORDLONG,
    UserIndexWriteBytes                                                 : DWORDLONG,
    LogFileReads                                                        : DWORDLONG,
    LogFileReadBytes                                                    : DWORDLONG,
    LogFileWrites                                                       : DWORDLONG,
    LogFileWriteBytes                                                   : DWORDLONG,
    Allocate : struct {
        Calls             : DWORD,
        RunsReturned      : DWORD,
        Hints             : DWORD,
        HintsHonored      : DWORD,
        Cache             : DWORD,
        CacheMiss         : DWORD,
        Clusters          : DWORDLONG,
        HintsClusters     : DWORDLONG,
        CacheClusters     : DWORDLONG,
        CacheMissClusters : DWORDLONG,
    },
    DiskResourcesExhausted                                              : DWORD,
    VolumeTrimCount                                                     : DWORDLONG,
    VolumeTrimTime                                                      : DWORDLONG,
    VolumeTrimByteCount                                                 : DWORDLONG,
    FileLevelTrimCount                                                  : DWORDLONG,
    FileLevelTrimTime                                                   : DWORDLONG,
    FileLevelTrimByteCount                                              : DWORDLONG,
    VolumeTrimSkippedCount                                              : DWORDLONG,
    VolumeTrimSkippedByteCount                                          : DWORDLONG,
    NtfsFillStatInfoFromMftRecordCalledCount                            : DWORDLONG,
    NtfsFillStatInfoFromMftRecordBailedBecauseOfAttributeListCount      : DWORDLONG,
    NtfsFillStatInfoFromMftRecordBailedBecauseOfNonResReparsePointCount : DWORDLONG,
};
PNTFS_STATISTICS_EX :: ^NTFS_STATISTICS_EX;

FILE_OBJECTID_BUFFER :: struct {
    ObjectId : [16]BYTE,
    u : struct #raw_union {
        s : struct {
            BirthVolumeId : [16]BYTE,
            BirthObjectId : [16]BYTE,
            DomainId      : [16]BYTE,
        },
        ExtendedInfo : [48]BYTE,
    },
};
PFILE_OBJECTID_BUFFER :: ^FILE_OBJECTID_BUFFER;

FILE_SET_SPARSE_BUFFER :: struct {
    SetSparse : BOOLEAN,
};
PFILE_SET_SPARSE_BUFFER :: ^FILE_SET_SPARSE_BUFFER;

FILE_ZERO_DATA_INFORMATION :: struct {
    FileOffset      : LARGE_INTEGER,
    BeyondFinalZero : LARGE_INTEGER,
};
PFILE_ZERO_DATA_INFORMATION :: ^FILE_ZERO_DATA_INFORMATION;

FILE_ZERO_DATA_INFORMATION_EX :: struct {
    FileOffset      : LARGE_INTEGER,
    BeyondFinalZero : LARGE_INTEGER,
    Flags           : DWORD,
};
PFILE_ZERO_DATA_INFORMATION_EX :: ^FILE_ZERO_DATA_INFORMATION_EX;

FILE_ALLOCATED_RANGE_BUFFER :: struct {
    FileOffset : LARGE_INTEGER,
    Length     : LARGE_INTEGER,
};
PFILE_ALLOCATED_RANGE_BUFFER :: ^FILE_ALLOCATED_RANGE_BUFFER;

ENCRYPTION_BUFFER :: struct {
    EncryptionOperation : DWORD,
    Private             : [1]BYTE,
};
PENCRYPTION_BUFFER :: ^ENCRYPTION_BUFFER;

DECRYPTION_STATUS_BUFFER :: struct {
    NoEncryptedStreams : BOOLEAN,
};
PDECRYPTION_STATUS_BUFFER :: ^DECRYPTION_STATUS_BUFFER;

REQUEST_RAW_ENCRYPTED_DATA :: struct {
    FileOffset : LONGLONG,
    Length     : DWORD,
};
PREQUEST_RAW_ENCRYPTED_DATA :: ^REQUEST_RAW_ENCRYPTED_DATA;

ENCRYPTED_DATA_INFO :: struct {
    StartingFileOffset         : DWORDLONG,
    OutputBufferOffset         : DWORD,
    BytesWithinFileSize        : DWORD,
    BytesWithinValidDataLength : DWORD,
    CompressionFormat          : WORD,
    DataUnitShift              : BYTE,
    ChunkShift                 : BYTE,
    ClusterShift               : BYTE,
    EncryptionFormat           : BYTE,
    NumberOfDataBlocks         : WORD,
    DataBlockSize              : [1]DWORD,
};
PENCRYPTED_DATA_INFO :: ^ENCRYPTED_DATA_INFO;

EXTENDED_ENCRYPTED_DATA_INFO :: struct {
    ExtendedCode : DWORD,
    Length       : DWORD,
    Flags        : DWORD,
    Reserved     : DWORD,
};
PEXTENDED_ENCRYPTED_DATA_INFO :: ^EXTENDED_ENCRYPTED_DATA_INFO;

PLEX_READ_DATA_REQUEST :: struct {
    ByteOffset : LARGE_INTEGER,
    ByteLength : DWORD,
    PlexNumber : DWORD,
};
PPLEX_READ_DATA_REQUEST :: ^PLEX_READ_DATA_REQUEST;

SI_COPYFILE :: struct {
    SourceFileNameLength      : DWORD,
    DestinationFileNameLength : DWORD,
    Flags                     : DWORD,
    FileNameBuffer            : [1]WCHAR,
};
PSI_COPYFILE :: ^SI_COPYFILE;

FILE_MAKE_COMPATIBLE_BUFFER :: struct {
    CloseDisc : BOOLEAN,
};
PFILE_MAKE_COMPATIBLE_BUFFER :: ^FILE_MAKE_COMPATIBLE_BUFFER;

FILE_SET_DEFECT_MGMT_BUFFER :: struct {
    Disable : BOOLEAN,
};
PFILE_SET_DEFECT_MGMT_BUFFER :: ^FILE_SET_DEFECT_MGMT_BUFFER;

FILE_QUERY_SPARING_BUFFER :: struct {
    SparingUnitBytes : DWORD,
    SoftwareSparing  : BOOLEAN,
    TotalSpareBlocks : DWORD,
    FreeSpareBlocks  : DWORD,
};
PFILE_QUERY_SPARING_BUFFER :: ^FILE_QUERY_SPARING_BUFFER;

FILE_QUERY_ON_DISK_VOL_INFO_BUFFER :: struct {
    DirectoryCount                  : LARGE_INTEGER,
    FileCount                       : LARGE_INTEGER,
    FsFormatMajVersion              : WORD,
    FsFormatMinVersion              : WORD,
    FsFormatName                    : [12]WCHAR,
    FormatTime                      : LARGE_INTEGER,
    LastUpdateTime                  : LARGE_INTEGER,
    CopyrightInfo                   : [34]WCHAR,
    AbstractInfo                    : [34]WCHAR,
    FormattingImplementationInfo    : [34]WCHAR,
    LastModifyingImplementationInfo : [34]WCHAR,
};
PFILE_QUERY_ON_DISK_VOL_INFO_BUFFER :: ^FILE_QUERY_ON_DISK_VOL_INFO_BUFFER;

CLSN :: DWORDLONG;

FILE_INITIATE_REPAIR_OUTPUT_BUFFER :: struct {
    Hint1  : DWORDLONG,
    Hint2  : DWORDLONG,
    Clsn   : CLSN,
    Status : DWORD,
};
PFILE_INITIATE_REPAIR_OUTPUT_BUFFER :: ^FILE_INITIATE_REPAIR_OUTPUT_BUFFER;

/* SHRINK_VOLUME_REQUEST_TYPES :: enum { */
SHRINK_VOLUME_REQUEST_TYPES :: _c.int;
    ShrinkPrepare :: 1;
    ShrinkCommit :: ShrinkPrepare + 1;
    ShrinkAbort :: ShrinkCommit + 1;
/* } */
PSHRINK_VOLUME_REQUEST_TYPES :: ^SHRINK_VOLUME_REQUEST_TYPES;

SHRINK_VOLUME_INFORMATION :: struct {
    ShrinkRequestType  : SHRINK_VOLUME_REQUEST_TYPES,
    Flags              : DWORDLONG,
    NewNumberOfSectors : LONGLONG,
};
PSHRINK_VOLUME_INFORMATION :: ^SHRINK_VOLUME_INFORMATION;

TXFS_MODIFY_RM :: struct {
    Flags                   : DWORD,
    LogContainerCountMax    : DWORD,
    LogContainerCountMin    : DWORD,
    LogContainerCount       : DWORD,
    LogGrowthIncrement      : DWORD,
    LogAutoShrinkPercentage : DWORD,
    Reserved                : DWORDLONG,
    LoggingMode             : WORD,
};
PTXFS_MODIFY_RM :: ^TXFS_MODIFY_RM;

TXFS_QUERY_RM_INFORMATION :: struct {
    BytesRequired           : DWORD,
    TailLsn                 : DWORDLONG,
    CurrentLsn              : DWORDLONG,
    ArchiveTailLsn          : DWORDLONG,
    LogContainerSize        : DWORDLONG,
    HighestVirtualClock     : LARGE_INTEGER,
    LogContainerCount       : DWORD,
    LogContainerCountMax    : DWORD,
    LogContainerCountMin    : DWORD,
    LogGrowthIncrement      : DWORD,
    LogAutoShrinkPercentage : DWORD,
    Flags                   : DWORD,
    LoggingMode             : WORD,
    Reserved                : WORD,
    RmState                 : DWORD,
    LogCapacity             : DWORDLONG,
    LogFree                 : DWORDLONG,
    TopsSize                : DWORDLONG,
    TopsUsed                : DWORDLONG,
    TransactionCount        : DWORDLONG,
    OnePCCount              : DWORDLONG,
    TwoPCCount              : DWORDLONG,
    NumberLogFileFull       : DWORDLONG,
    OldestTransactionAge    : DWORDLONG,
    RMName                  : GUID,
    TmLogPathOffset         : DWORD,
};
PTXFS_QUERY_RM_INFORMATION :: ^TXFS_QUERY_RM_INFORMATION;

TXFS_ROLLFORWARD_REDO_INFORMATION :: struct {
    LastVirtualClock   : LARGE_INTEGER,
    LastRedoLsn        : DWORDLONG,
    HighestRecoveryLsn : DWORDLONG,
    Flags              : DWORD,
};
PTXFS_ROLLFORWARD_REDO_INFORMATION :: ^TXFS_ROLLFORWARD_REDO_INFORMATION;

TXFS_START_RM_INFORMATION :: struct {
    Flags                   : DWORD,
    LogContainerSize        : DWORDLONG,
    LogContainerCountMin    : DWORD,
    LogContainerCountMax    : DWORD,
    LogGrowthIncrement      : DWORD,
    LogAutoShrinkPercentage : DWORD,
    TmLogPathOffset         : DWORD,
    TmLogPathLength         : WORD,
    LoggingMode             : WORD,
    LogPathLength           : WORD,
    Reserved                : WORD,
    LogPath                 : [1]WCHAR,
};
PTXFS_START_RM_INFORMATION :: ^TXFS_START_RM_INFORMATION;

TXFS_GET_METADATA_INFO_OUT :: struct {
    TxfFileId : struct {
        LowPart  : LONGLONG,
        HighPart : LONGLONG,
    },
    LockingTransaction : GUID,
    LastLsn            : DWORDLONG,
    TransactionState   : DWORD,
};
PTXFS_GET_METADATA_INFO_OUT :: ^TXFS_GET_METADATA_INFO_OUT;

TXFS_LIST_TRANSACTION_LOCKED_FILES_ENTRY :: struct {
    Offset    : DWORDLONG,
    NameFlags : DWORD,
    FileId    : LONGLONG,
    Reserved1 : DWORD,
    Reserved2 : DWORD,
    Reserved3 : LONGLONG,
    FileName  : [1]WCHAR,
};
PTXFS_LIST_TRANSACTION_LOCKED_FILES_ENTRY :: ^TXFS_LIST_TRANSACTION_LOCKED_FILES_ENTRY;

TXFS_LIST_TRANSACTION_LOCKED_FILES :: struct {
    KtmTransaction     : GUID,
    NumberOfFiles      : DWORDLONG,
    BufferSizeRequired : DWORDLONG,
    Offset             : DWORDLONG,
};
PTXFS_LIST_TRANSACTION_LOCKED_FILES :: ^TXFS_LIST_TRANSACTION_LOCKED_FILES;

TXFS_LIST_TRANSACTIONS_ENTRY :: struct {
    TransactionId    : GUID,
    TransactionState : DWORD,
    Reserved1        : DWORD,
    Reserved2        : DWORD,
    Reserved3        : LONGLONG,
};
PTXFS_LIST_TRANSACTIONS_ENTRY :: ^TXFS_LIST_TRANSACTIONS_ENTRY;

TXFS_LIST_TRANSACTIONS :: struct {
    NumberOfTransactions : DWORDLONG,
    BufferSizeRequired   : DWORDLONG,
};
PTXFS_LIST_TRANSACTIONS :: ^TXFS_LIST_TRANSACTIONS;

TXFS_READ_BACKUP_INFORMATION_OUT :: struct {
    u : struct #raw_union {
        BufferLength : DWORD,
        Buffer       : [1]BYTE,
    },
};
PTXFS_READ_BACKUP_INFORMATION_OUT :: ^TXFS_READ_BACKUP_INFORMATION_OUT;

TXFS_WRITE_BACKUP_INFORMATION :: struct {
    Buffer : [1]BYTE,
};
PTXFS_WRITE_BACKUP_INFORMATION :: ^TXFS_WRITE_BACKUP_INFORMATION;

TXFS_GET_TRANSACTED_VERSION :: struct {
    ThisBaseVersion   : DWORD,
    LatestVersion     : DWORD,
    ThisMiniVersion   : WORD,
    FirstMiniVersion  : WORD,
    LatestMiniVersion : WORD,
};
PTXFS_GET_TRANSACTED_VERSION :: ^TXFS_GET_TRANSACTED_VERSION;

TXFS_SAVEPOINT_INFORMATION :: struct {
    KtmTransaction : HANDLE,
    ActionCode     : DWORD,
    SavepointId    : DWORD,
};
PTXFS_SAVEPOINT_INFORMATION :: ^TXFS_SAVEPOINT_INFORMATION;

TXFS_CREATE_MINIVERSION_INFO :: struct {
    StructureVersion : WORD,
    StructureLength  : WORD,
    BaseVersion      : DWORD,
    MiniVersion      : WORD,
};
PTXFS_CREATE_MINIVERSION_INFO :: ^TXFS_CREATE_MINIVERSION_INFO;

TXFS_TRANSACTION_ACTIVE_INFO :: struct {
    TransactionsActiveAtSnapshot : BOOLEAN,
};
PTXFS_TRANSACTION_ACTIVE_INFO :: ^TXFS_TRANSACTION_ACTIVE_INFO;

BOOT_AREA_INFO :: struct {
    BootSectorCount : DWORD,
    BootSectors : [2]struct {
    Offset : LARGE_INTEGER,
},
};
PBOOT_AREA_INFO :: ^BOOT_AREA_INFO;

RETRIEVAL_POINTER_BASE :: struct {
    FileAreaOffset : LARGE_INTEGER,
};
PRETRIEVAL_POINTER_BASE :: ^RETRIEVAL_POINTER_BASE;

FILE_FS_PERSISTENT_VOLUME_INFORMATION :: struct {
    VolumeFlags : DWORD,
    FlagMask    : DWORD,
    Version     : DWORD,
    Reserved    : DWORD,
};
PFILE_FS_PERSISTENT_VOLUME_INFORMATION :: ^FILE_FS_PERSISTENT_VOLUME_INFORMATION;

FILE_SYSTEM_RECOGNITION_INFORMATION :: struct {
    FileSystem : [9]CHAR,
};
PFILE_SYSTEM_RECOGNITION_INFORMATION :: ^FILE_SYSTEM_RECOGNITION_INFORMATION;

REQUEST_OPLOCK_INPUT_BUFFER :: struct {
    StructureVersion     : WORD,
    StructureLength      : WORD,
    RequestedOplockLevel : DWORD,
    Flags                : DWORD,
};
PREQUEST_OPLOCK_INPUT_BUFFER :: ^REQUEST_OPLOCK_INPUT_BUFFER;

REQUEST_OPLOCK_OUTPUT_BUFFER :: struct {
    StructureVersion    : WORD,
    StructureLength     : WORD,
    OriginalOplockLevel : DWORD,
    NewOplockLevel      : DWORD,
    Flags               : DWORD,
    AccessMode          : ACCESS_MASK,
    ShareMode           : WORD,
};
PREQUEST_OPLOCK_OUTPUT_BUFFER :: ^REQUEST_OPLOCK_OUTPUT_BUFFER;

VIRTUAL_STORAGE_TYPE :: struct {
    DeviceId : DWORD,
    VendorId : GUID,
};
PVIRTUAL_STORAGE_TYPE :: ^VIRTUAL_STORAGE_TYPE;

STORAGE_QUERY_DEPENDENT_VOLUME_REQUEST :: struct {
    RequestLevel : DWORD,
    RequestFlags : DWORD,
};
PSTORAGE_QUERY_DEPENDENT_VOLUME_REQUEST :: ^STORAGE_QUERY_DEPENDENT_VOLUME_REQUEST;

STORAGE_QUERY_DEPENDENT_VOLUME_LEV1_ENTRY :: struct {
    EntryLength           : DWORD,
    DependencyTypeFlags   : DWORD,
    ProviderSpecificFlags : DWORD,
    VirtualStorageType    : VIRTUAL_STORAGE_TYPE,
};
PSTORAGE_QUERY_DEPENDENT_VOLUME_LEV1_ENTRY :: ^STORAGE_QUERY_DEPENDENT_VOLUME_LEV1_ENTRY;

STORAGE_QUERY_DEPENDENT_VOLUME_LEV2_ENTRY :: struct {
    EntryLength               : DWORD,
    DependencyTypeFlags       : DWORD,
    ProviderSpecificFlags     : DWORD,
    VirtualStorageType        : VIRTUAL_STORAGE_TYPE,
    AncestorLevel             : DWORD,
    HostVolumeNameOffset      : DWORD,
    HostVolumeNameSize        : DWORD,
    DependentVolumeNameOffset : DWORD,
    DependentVolumeNameSize   : DWORD,
    RelativePathOffset        : DWORD,
    RelativePathSize          : DWORD,
    DependentDeviceNameOffset : DWORD,
    DependentDeviceNameSize   : DWORD,
};
PSTORAGE_QUERY_DEPENDENT_VOLUME_LEV2_ENTRY :: ^STORAGE_QUERY_DEPENDENT_VOLUME_LEV2_ENTRY;

SD_CHANGE_MACHINE_SID_INPUT :: struct {
    CurrentMachineSIDOffset : WORD,
    CurrentMachineSIDLength : WORD,
    NewMachineSIDOffset     : WORD,
    NewMachineSIDLength     : WORD,
};
PSD_CHANGE_MACHINE_SID_INPUT :: ^SD_CHANGE_MACHINE_SID_INPUT;

SD_CHANGE_MACHINE_SID_OUTPUT :: struct {
    NumSDChangedSuccess    : DWORDLONG,
    NumSDChangedFail       : DWORDLONG,
    NumSDUnused            : DWORDLONG,
    NumSDTotal             : DWORDLONG,
    NumMftSDChangedSuccess : DWORDLONG,
    NumMftSDChangedFail    : DWORDLONG,
    NumMftSDTotal          : DWORDLONG,
};
PSD_CHANGE_MACHINE_SID_OUTPUT :: ^SD_CHANGE_MACHINE_SID_OUTPUT;

SD_QUERY_STATS_INPUT :: struct {
    Reserved : DWORD,
};
PSD_QUERY_STATS_INPUT :: ^SD_QUERY_STATS_INPUT;

SD_QUERY_STATS_OUTPUT :: struct {
    SdsStreamSize     : DWORDLONG,
    SdsAllocationSize : DWORDLONG,
    SiiStreamSize     : DWORDLONG,
    SiiAllocationSize : DWORDLONG,
    SdhStreamSize     : DWORDLONG,
    SdhAllocationSize : DWORDLONG,
    NumSDTotal        : DWORDLONG,
    NumSDUnused       : DWORDLONG,
};
PSD_QUERY_STATS_OUTPUT :: ^SD_QUERY_STATS_OUTPUT;

SD_ENUM_SDS_INPUT :: struct {
    StartingOffset       : DWORDLONG,
    MaxSDEntriesToReturn : DWORDLONG,
};
PSD_ENUM_SDS_INPUT :: ^SD_ENUM_SDS_INPUT;

SD_ENUM_SDS_ENTRY :: struct {
    Hash       : DWORD,
    SecurityId : DWORD,
    Offset     : DWORDLONG,
    Length     : DWORD,
    Descriptor : [1]BYTE,
};
PSD_ENUM_SDS_ENTRY :: ^SD_ENUM_SDS_ENTRY;

SD_ENUM_SDS_OUTPUT :: struct {
    NextOffset           : DWORDLONG,
    NumSDEntriesReturned : DWORDLONG,
    NumSDBytesReturned   : DWORDLONG,
    SDEntry              : [1]SD_ENUM_SDS_ENTRY,
};
PSD_ENUM_SDS_OUTPUT :: ^SD_ENUM_SDS_OUTPUT;

SD_GLOBAL_CHANGE_INPUT :: struct {
    Flags      : DWORD,
    ChangeType : DWORD,
    u : struct #raw_union {
        SdChange     : SD_CHANGE_MACHINE_SID_INPUT,
        SdQueryStats : SD_QUERY_STATS_INPUT,
        SdEnumSds    : SD_ENUM_SDS_INPUT,
    },
};
PSD_GLOBAL_CHANGE_INPUT :: ^SD_GLOBAL_CHANGE_INPUT;

SD_GLOBAL_CHANGE_OUTPUT :: struct {
    Flags      : DWORD,
    ChangeType : DWORD,
    u : struct #raw_union {
        SdChange     : SD_CHANGE_MACHINE_SID_OUTPUT,
        SdQueryStats : SD_QUERY_STATS_OUTPUT,
        SdEnumSds    : SD_ENUM_SDS_OUTPUT,
    },
};
PSD_GLOBAL_CHANGE_OUTPUT :: ^SD_GLOBAL_CHANGE_OUTPUT;

LOOKUP_STREAM_FROM_CLUSTER_INPUT :: struct {
    Flags            : DWORD,
    NumberOfClusters : DWORD,
    Cluster          : [1]LARGE_INTEGER,
};
PLOOKUP_STREAM_FROM_CLUSTER_INPUT :: ^LOOKUP_STREAM_FROM_CLUSTER_INPUT;

LOOKUP_STREAM_FROM_CLUSTER_OUTPUT :: struct {
    Offset             : DWORD,
    NumberOfMatches    : DWORD,
    BufferSizeRequired : DWORD,
};
PLOOKUP_STREAM_FROM_CLUSTER_OUTPUT :: ^LOOKUP_STREAM_FROM_CLUSTER_OUTPUT;

LOOKUP_STREAM_FROM_CLUSTER_ENTRY :: struct {
    OffsetToNext : DWORD,
    Flags        : DWORD,
    Reserved     : LARGE_INTEGER,
    Cluster      : LARGE_INTEGER,
    FileName     : [1]WCHAR,
};
PLOOKUP_STREAM_FROM_CLUSTER_ENTRY :: ^LOOKUP_STREAM_FROM_CLUSTER_ENTRY;

FILE_TYPE_NOTIFICATION_INPUT :: struct {
    Flags          : DWORD,
    NumFileTypeIDs : DWORD,
    FileTypeID     : [1]GUID,
};
PFILE_TYPE_NOTIFICATION_INPUT :: ^FILE_TYPE_NOTIFICATION_INPUT;

CSV_MGMT_LOCK :: struct {
    Flags : DWORD,
};
PCSV_MGMT_LOCK :: ^CSV_MGMT_LOCK;

CSV_NAMESPACE_INFO :: struct {
    Version        : DWORD,
    DeviceNumber   : DWORD,
    StartingOffset : LARGE_INTEGER,
    SectorSize     : DWORD,
};
PCSV_NAMESPACE_INFO :: ^CSV_NAMESPACE_INFO;

/* CSV_CONTROL_OP :: enum { */
CSV_CONTROL_OP :: _c.int;
    CsvControlStartRedirectFile :: 0x02;
    CsvControlStopRedirectFile :: 0x03;
    CsvControlQueryRedirectState :: 0x04;
    CsvControlQueryFileRevision :: 0x06;
    CsvControlQueryMdsPath :: 0x08;
    CsvControlQueryFileRevisionFileId128 :: 0x09;
    CsvControlQueryVolumeRedirectState :: 0x0a;
    CsvControlEnableUSNRangeModificationTracking :: 0x0d;
    CsvControlMarkHandleLocalVolumeMount :: 0x0e;
    CsvControlUnmarkHandleLocalVolumeMount :: 0x0f;
    CsvControlGetCsvFsMdsPathV2 :: 0x12;
    CsvControlDisableCaching :: 0x13;
    CsvControlEnableCaching :: 0x14;
/* } */
PCSV_CONTROL_OP :: ^CSV_CONTROL_OP;

CSV_CONTROL_PARAM :: struct {
    Operation : CSV_CONTROL_OP,
    Unused    : LONGLONG,
};
PCSV_CONTROL_PARAM :: ^CSV_CONTROL_PARAM;

CSV_QUERY_REDIRECT_STATE :: struct {
    MdsNodeId      : DWORD,
    DsNodeId       : DWORD,
    FileRedirected : BOOLEAN,
};
PCSV_QUERY_REDIRECT_STATE :: ^CSV_QUERY_REDIRECT_STATE;

CSV_QUERY_FILE_REVISION :: struct {
    FileId       : LONGLONG,
    FileRevision : [3]LONGLONG,
};
PCSV_QUERY_FILE_REVISION :: ^CSV_QUERY_FILE_REVISION;

CSV_QUERY_FILE_REVISION_FILE_ID_128 :: struct {
    FileId       : FILE_ID_128,
    FileRevision : [3]LONGLONG,
};
PCSV_QUERY_FILE_REVISION_FILE_ID_128 :: ^CSV_QUERY_FILE_REVISION_FILE_ID_128;

CSV_QUERY_MDS_PATH :: struct {
    MdsNodeId  : DWORD,
    DsNodeId   : DWORD,
    PathLength : DWORD,
    Path       : [1]WCHAR,
};
PCSV_QUERY_MDS_PATH :: ^CSV_QUERY_MDS_PATH;

/* CSVFS_DISK_CONNECTIVITY :: enum { */
CSVFS_DISK_CONNECTIVITY :: _c.int;
    CsvFsDiskConnectivityNone :: 0;
    CsvFsDiskConnectivityMdsNodeOnly :: 1;
    CsvFsDiskConnectivitySubsetOfNodes :: 2;
    CsvFsDiskConnectivityAllNodes :: 3;
/* } */
PCSVFS_DISK_CONNECTIVITY :: ^CSVFS_DISK_CONNECTIVITY;

CSV_QUERY_VOLUME_REDIRECT_STATE :: struct {
    MdsNodeId             : DWORD,
    DsNodeId              : DWORD,
    IsDiskConnected       : BOOLEAN,
    ClusterEnableDirectIo : BOOLEAN,
    DiskConnectivity      : CSVFS_DISK_CONNECTIVITY,
};
PCSV_QUERY_VOLUME_REDIRECT_STATE :: ^CSV_QUERY_VOLUME_REDIRECT_STATE;

CSV_QUERY_MDS_PATH_V2 :: struct {
    Version          : LONGLONG,
    RequiredSize     : DWORD,
    MdsNodeId        : DWORD,
    DsNodeId         : DWORD,
    Flags            : DWORD,
    DiskConnectivity : CSVFS_DISK_CONNECTIVITY,
    VolumeId         : GUID,
    IpAddressOffset  : DWORD,
    IpAddressLength  : DWORD,
    PathOffset       : DWORD,
    PathLength       : DWORD,
};
PCSV_QUERY_MDS_PATH_V2 :: ^CSV_QUERY_MDS_PATH_V2;

CSV_QUERY_VETO_FILE_DIRECT_IO_OUTPUT :: struct {
    VetoedFromAltitudeIntegral : DWORDLONG,
    VetoedFromAltitudeDecimal  : DWORDLONG,
    Reason                     : [256]WCHAR,
};
PCSV_QUERY_VETO_FILE_DIRECT_IO_OUTPUT :: ^CSV_QUERY_VETO_FILE_DIRECT_IO_OUTPUT;

/* STORAGE_RESERVE_ID :: enum { */
STORAGE_RESERVE_ID :: _c.int;
    StorageReserveIdNone :: 0;
    StorageReserveIdHard :: StorageReserveIdNone + 1;
    StorageReserveIdSoft :: StorageReserveIdHard + 1;
    StorageReserveIdUpdateScratch :: StorageReserveIdSoft + 1;
    StorageReserveIdMax :: StorageReserveIdUpdateScratch + 1;
/* } */
PSTORAGE_RESERVE_ID :: ^STORAGE_RESERVE_ID;

CSV_IS_OWNED_BY_CSVFS :: struct {
    OwnedByCSVFS : BOOLEAN,
};
PCSV_IS_OWNED_BY_CSVFS :: ^CSV_IS_OWNED_BY_CSVFS;

FILE_LEVEL_TRIM_RANGE :: struct {
    Offset : DWORDLONG,
    Length : DWORDLONG,
};
PFILE_LEVEL_TRIM_RANGE :: ^FILE_LEVEL_TRIM_RANGE;

FILE_LEVEL_TRIM :: struct {
    Key       : DWORD,
    NumRanges : DWORD,
    Ranges    : [1]FILE_LEVEL_TRIM_RANGE,
};
PFILE_LEVEL_TRIM :: ^FILE_LEVEL_TRIM;

FILE_LEVEL_TRIM_OUTPUT :: struct {
    NumRangesProcessed : DWORD,
};
PFILE_LEVEL_TRIM_OUTPUT :: ^FILE_LEVEL_TRIM_OUTPUT;

/* QUERY_FILE_LAYOUT_FILTER_TYPE :: enum { */
QUERY_FILE_LAYOUT_FILTER_TYPE :: _c.int;
    QUERY_FILE_LAYOUT_FILTER_TYPE_NONE :: 0;
    QUERY_FILE_LAYOUT_FILTER_TYPE_CLUSTERS :: 1;
    QUERY_FILE_LAYOUT_FILTER_TYPE_FILEID :: 2;
    QUERY_FILE_LAYOUT_FILTER_TYPE_STORAGE_RESERVE_ID :: 3;
    QUERY_FILE_LAYOUT_NUM_FILTER_TYPES :: QUERY_FILE_LAYOUT_FILTER_TYPE_STORAGE_RESERVE_ID + 1;
/* } */
;

CLUSTER_RANGE :: struct {
    StartingCluster : LARGE_INTEGER,
    ClusterCount    : LARGE_INTEGER,
};
PCLUSTER_RANGE :: ^CLUSTER_RANGE;

FILE_REFERENCE_RANGE :: struct {
    StartingFileReferenceNumber : DWORDLONG,
    EndingFileReferenceNumber   : DWORDLONG,
};
PFILE_REFERENCE_RANGE :: ^FILE_REFERENCE_RANGE;

QUERY_FILE_LAYOUT_INPUT :: struct {
    u : struct #raw_union {
        FilterEntryCount : DWORD,
        NumberOfPairs    : DWORD,
    },
    Flags      : DWORD,
    FilterType : QUERY_FILE_LAYOUT_FILTER_TYPE,
    Reserved   : DWORD,
    Filter : struct #raw_union {
        ClusterRanges       : [1]CLUSTER_RANGE,
        FileReferenceRanges : [1]FILE_REFERENCE_RANGE,
        StorageReserveIds   : [1]STORAGE_RESERVE_ID,
    },
};
PQUERY_FILE_LAYOUT_INPUT :: ^QUERY_FILE_LAYOUT_INPUT;

QUERY_FILE_LAYOUT_OUTPUT :: struct {
    FileEntryCount  : DWORD,
    FirstFileOffset : DWORD,
    Flags           : DWORD,
    Reserved        : DWORD,
};
PQUERY_FILE_LAYOUT_OUTPUT :: ^QUERY_FILE_LAYOUT_OUTPUT;

FILE_LAYOUT_ENTRY :: struct {
    Version             : DWORD,
    NextFileOffset      : DWORD,
    Flags               : DWORD,
    FileAttributes      : DWORD,
    FileReferenceNumber : DWORDLONG,
    FirstNameOffset     : DWORD,
    FirstStreamOffset   : DWORD,
    ExtraInfoOffset     : DWORD,
    ExtraInfoLength     : DWORD,
};
PFILE_LAYOUT_ENTRY :: ^FILE_LAYOUT_ENTRY;

FILE_LAYOUT_NAME_ENTRY :: struct {
    NextNameOffset            : DWORD,
    Flags                     : DWORD,
    ParentFileReferenceNumber : DWORDLONG,
    FileNameLength            : DWORD,
    Reserved                  : DWORD,
    FileName                  : [1]WCHAR,
};
PFILE_LAYOUT_NAME_ENTRY :: ^FILE_LAYOUT_NAME_ENTRY;

FILE_LAYOUT_INFO_ENTRY :: struct {
    BasicInformation : struct {
        CreationTime   : LARGE_INTEGER,
        LastAccessTime : LARGE_INTEGER,
        LastWriteTime  : LARGE_INTEGER,
        ChangeTime     : LARGE_INTEGER,
        FileAttributes : DWORD,
    },
    OwnerId          : DWORD,
    SecurityId       : DWORD,
    Usn              : USN,
    StorageReserveId : STORAGE_RESERVE_ID,
};
PFILE_LAYOUT_INFO_ENTRY :: ^FILE_LAYOUT_INFO_ENTRY;

STREAM_LAYOUT_ENTRY :: struct {
    Version                 : DWORD,
    NextStreamOffset        : DWORD,
    Flags                   : DWORD,
    ExtentInformationOffset : DWORD,
    AllocationSize          : LARGE_INTEGER,
    EndOfFile               : LARGE_INTEGER,
    StreamInformationOffset : DWORD,
    AttributeTypeCode       : DWORD,
    AttributeFlags          : DWORD,
    StreamIdentifierLength  : DWORD,
    StreamIdentifier        : [1]WCHAR,
};
PSTREAM_LAYOUT_ENTRY :: ^STREAM_LAYOUT_ENTRY;

STREAM_EXTENT_ENTRY :: struct {
    Flags             : DWORD,
    ExtentInformation : struct #raw_union {
        RetrievalPointers : RETRIEVAL_POINTERS_BUFFER,
    },
};
PSTREAM_EXTENT_ENTRY :: ^STREAM_EXTENT_ENTRY;

FSCTL_GET_INTEGRITY_INFORMATION_BUFFER :: struct {
    ChecksumAlgorithm        : WORD,
    Reserved                 : WORD,
    Flags                    : DWORD,
    ChecksumChunkSizeInBytes : DWORD,
    ClusterSizeInBytes       : DWORD,
};
PFSCTL_GET_INTEGRITY_INFORMATION_BUFFER :: ^FSCTL_GET_INTEGRITY_INFORMATION_BUFFER;

FSCTL_SET_INTEGRITY_INFORMATION_BUFFER :: struct {
    ChecksumAlgorithm : WORD,
    Reserved          : WORD,
    Flags             : DWORD,
};
PFSCTL_SET_INTEGRITY_INFORMATION_BUFFER :: ^FSCTL_SET_INTEGRITY_INFORMATION_BUFFER;

FSCTL_SET_INTEGRITY_INFORMATION_BUFFER_EX :: struct {
    EnableIntegrity             : BYTE,
    KeepIntegrityStateUnchanged : BYTE,
    Reserved                    : WORD,
    Flags                       : DWORD,
    Version                     : BYTE,
    Reserved2                   : [7]BYTE,
};
PFSCTL_SET_INTEGRITY_INFORMATION_BUFFER_EX :: ^FSCTL_SET_INTEGRITY_INFORMATION_BUFFER_EX;

FSCTL_OFFLOAD_READ_INPUT :: struct {
    Size            : DWORD,
    Flags           : DWORD,
    TokenTimeToLive : DWORD,
    Reserved        : DWORD,
    FileOffset      : DWORDLONG,
    CopyLength      : DWORDLONG,
};
PFSCTL_OFFLOAD_READ_INPUT :: ^FSCTL_OFFLOAD_READ_INPUT;

FSCTL_OFFLOAD_READ_OUTPUT :: struct {
    Size           : DWORD,
    Flags          : DWORD,
    TransferLength : DWORDLONG,
    Token          : [512]BYTE,
};
PFSCTL_OFFLOAD_READ_OUTPUT :: ^FSCTL_OFFLOAD_READ_OUTPUT;

FSCTL_OFFLOAD_WRITE_INPUT :: struct {
    Size           : DWORD,
    Flags          : DWORD,
    FileOffset     : DWORDLONG,
    CopyLength     : DWORDLONG,
    TransferOffset : DWORDLONG,
    Token          : [512]BYTE,
};
PFSCTL_OFFLOAD_WRITE_INPUT :: ^FSCTL_OFFLOAD_WRITE_INPUT;

FSCTL_OFFLOAD_WRITE_OUTPUT :: struct {
    Size          : DWORD,
    Flags         : DWORD,
    LengthWritten : DWORDLONG,
};
PFSCTL_OFFLOAD_WRITE_OUTPUT :: ^FSCTL_OFFLOAD_WRITE_OUTPUT;

SET_PURGE_FAILURE_MODE_INPUT :: struct {
    Flags : DWORD,
};
PSET_PURGE_FAILURE_MODE_INPUT :: ^SET_PURGE_FAILURE_MODE_INPUT;

REPAIR_COPIES_INPUT :: struct {
    Size                 : DWORD,
    Flags                : DWORD,
    FileOffset           : LARGE_INTEGER,
    Length               : DWORD,
    SourceCopy           : DWORD,
    NumberOfRepairCopies : DWORD,
    RepairCopies         : [1]DWORD,
};
PREPAIR_COPIES_INPUT :: ^REPAIR_COPIES_INPUT;

REPAIR_COPIES_OUTPUT :: struct {
    Size             : DWORD,
    Status           : DWORD,
    ResumeFileOffset : LARGE_INTEGER,
};
PREPAIR_COPIES_OUTPUT :: ^REPAIR_COPIES_OUTPUT;

FILE_REGION_INFO :: struct {
    FileOffset : LONGLONG,
    Length     : LONGLONG,
    Usage      : DWORD,
    Reserved   : DWORD,
};
PFILE_REGION_INFO :: ^FILE_REGION_INFO;

FILE_REGION_OUTPUT :: struct {
    Flags                 : DWORD,
    TotalRegionEntryCount : DWORD,
    RegionEntryCount      : DWORD,
    Reserved              : DWORD,
    Region                : [1]FILE_REGION_INFO,
};
PFILE_REGION_OUTPUT :: ^FILE_REGION_OUTPUT;

FILE_REGION_INPUT :: struct {
    FileOffset   : LONGLONG,
    Length       : LONGLONG,
    DesiredUsage : DWORD,
};
PFILE_REGION_INPUT :: ^FILE_REGION_INPUT;

WRITE_USN_REASON_INPUT :: struct {
    Flags            : DWORD,
    UsnReasonToWrite : DWORD,
};
PWRITE_USN_REASON_INPUT :: ^WRITE_USN_REASON_INPUT;

/* FILE_STORAGE_TIER_MEDIA_TYPE :: enum { */
FILE_STORAGE_TIER_MEDIA_TYPE :: _c.int;
    FileStorageTierMediaTypeUnspecified :: 0;
    FileStorageTierMediaTypeDisk :: 1;
    FileStorageTierMediaTypeSsd :: 2;
    FileStorageTierMediaTypeScm :: 4;
    FileStorageTierMediaTypeMax :: FileStorageTierMediaTypeScm + 1;
/* } */
PFILE_STORAGE_TIER_MEDIA_TYPE :: ^FILE_STORAGE_TIER_MEDIA_TYPE;

/* FILE_STORAGE_TIER_CLASS :: enum { */
FILE_STORAGE_TIER_CLASS :: _c.int;
    FileStorageTierClassUnspecified :: 0;
    FileStorageTierClassCapacity :: FileStorageTierClassUnspecified + 1;
    FileStorageTierClassPerformance :: FileStorageTierClassCapacity + 1;
    FileStorageTierClassMax :: FileStorageTierClassPerformance + 1;
/* } */
PFILE_STORAGE_TIER_CLASS :: ^FILE_STORAGE_TIER_CLASS;

FILE_STORAGE_TIER :: struct {
    Id                  : GUID,
    Name                : [(256)]WCHAR,
    Description         : [(256)]WCHAR,
    Flags               : DWORDLONG,
    ProvisionedCapacity : DWORDLONG,
    MediaType           : FILE_STORAGE_TIER_MEDIA_TYPE,
    Class               : FILE_STORAGE_TIER_CLASS,
};
PFILE_STORAGE_TIER :: ^FILE_STORAGE_TIER;

FSCTL_QUERY_STORAGE_CLASSES_OUTPUT :: struct {
    Version               : DWORD,
    Size                  : DWORD,
    Flags                 : DWORD,
    TotalNumberOfTiers    : DWORD,
    NumberOfTiersReturned : DWORD,
    Tiers                 : [1]FILE_STORAGE_TIER,
};
PFSCTL_QUERY_STORAGE_CLASSES_OUTPUT :: ^FSCTL_QUERY_STORAGE_CLASSES_OUTPUT;

STREAM_INFORMATION_ENTRY :: struct {
    Version           : DWORD,
    Flags             : DWORD,
    StreamInformation : struct #raw_union {
        DesiredStorageClass : struct {
            Class : FILE_STORAGE_TIER_CLASS,
            Flags : DWORD,
        },
    },
};
PSTREAM_INFORMATION_ENTRY :: ^STREAM_INFORMATION_ENTRY;

FSCTL_QUERY_REGION_INFO_INPUT :: struct {
    Version         : DWORD,
    Size            : DWORD,
    Flags           : DWORD,
    NumberOfTierIds : DWORD,
    TierIds         : [1]GUID,
};
PFSCTL_QUERY_REGION_INFO_INPUT :: ^FSCTL_QUERY_REGION_INFO_INPUT;

FILE_STORAGE_TIER_REGION :: struct {
    TierId : GUID,
    Offset : DWORDLONG,
    Length : DWORDLONG,
};
PFILE_STORAGE_TIER_REGION :: ^FILE_STORAGE_TIER_REGION;

FSCTL_QUERY_REGION_INFO_OUTPUT :: struct {
    Version                 : DWORD,
    Size                    : DWORD,
    Flags                   : DWORD,
    Reserved                : DWORD,
    Alignment               : DWORDLONG,
    TotalNumberOfRegions    : DWORD,
    NumberOfRegionsReturned : DWORD,
    Regions                 : [1]FILE_STORAGE_TIER_REGION,
};
PFSCTL_QUERY_REGION_INFO_OUTPUT :: ^FSCTL_QUERY_REGION_INFO_OUTPUT;

FILE_DESIRED_STORAGE_CLASS_INFORMATION :: struct {
    Class : FILE_STORAGE_TIER_CLASS,
    Flags : DWORD,
};
PFILE_DESIRED_STORAGE_CLASS_INFORMATION :: ^FILE_DESIRED_STORAGE_CLASS_INFORMATION;

DUPLICATE_EXTENTS_DATA :: struct {
    FileHandle       : HANDLE,
    SourceFileOffset : LARGE_INTEGER,
    TargetFileOffset : LARGE_INTEGER,
    ByteCount        : LARGE_INTEGER,
};
PDUPLICATE_EXTENTS_DATA :: ^DUPLICATE_EXTENTS_DATA;

DUPLICATE_EXTENTS_DATA32 :: struct {
    FileHandle       : UINT32,
    SourceFileOffset : LARGE_INTEGER,
    TargetFileOffset : LARGE_INTEGER,
    ByteCount        : LARGE_INTEGER,
};
PDUPLICATE_EXTENTS_DATA32 :: ^DUPLICATE_EXTENTS_DATA32;

DUPLICATE_EXTENTS_DATA_EX :: struct {
    Size             : SIZE_T,
    FileHandle       : HANDLE,
    SourceFileOffset : LARGE_INTEGER,
    TargetFileOffset : LARGE_INTEGER,
    ByteCount        : LARGE_INTEGER,
    Flags            : DWORD,
};
PDUPLICATE_EXTENTS_DATA_EX :: ^DUPLICATE_EXTENTS_DATA_EX;

DUPLICATE_EXTENTS_DATA_EX32 :: struct {
    Size             : DWORD32,
    FileHandle       : DWORD32,
    SourceFileOffset : LARGE_INTEGER,
    TargetFileOffset : LARGE_INTEGER,
    ByteCount        : LARGE_INTEGER,
    Flags            : DWORD,
};
PDUPLICATE_EXTENTS_DATA_EX32 :: ^DUPLICATE_EXTENTS_DATA_EX32;

/* REFS_SMR_VOLUME_GC_STATE :: enum { */
REFS_SMR_VOLUME_GC_STATE :: _c.int;
    SmrGcStateInactive :: 0;
    SmrGcStatePaused :: 1;
    SmrGcStateActive :: 2;
    SmrGcStateActiveFullSpeed :: 3;
/* } */
PREFS_SMR_VOLUME_GC_STATE :: ^REFS_SMR_VOLUME_GC_STATE;

REFS_SMR_VOLUME_INFO_OUTPUT :: struct {
    Version                         : DWORD,
    Flags                           : DWORD,
    SizeOfRandomlyWritableTier      : LARGE_INTEGER,
    FreeSpaceInRandomlyWritableTier : LARGE_INTEGER,
    SizeofSMRTier                   : LARGE_INTEGER,
    FreeSpaceInSMRTier              : LARGE_INTEGER,
    UsableFreeSpaceInSMRTier        : LARGE_INTEGER,
    VolumeGcState                   : REFS_SMR_VOLUME_GC_STATE,
    VolumeGcLastStatus              : DWORD,
    Unused                          : [7]DWORDLONG,
};
PREFS_SMR_VOLUME_INFO_OUTPUT :: ^REFS_SMR_VOLUME_INFO_OUTPUT;

/* REFS_SMR_VOLUME_GC_ACTION :: enum { */
REFS_SMR_VOLUME_GC_ACTION :: _c.int;
    SmrGcActionStart :: 1;
    SmrGcActionStartFullSpeed :: 2;
    SmrGcActionPause :: 3;
    SmrGcActionStop :: 4;
/* } */
PREFS_SMR_VOLUME_GC_ACTION :: ^REFS_SMR_VOLUME_GC_ACTION;

/* REFS_SMR_VOLUME_GC_METHOD :: enum { */
REFS_SMR_VOLUME_GC_METHOD :: _c.int;
    SmrGcMethodCompaction :: 1;
    SmrGcMethodCompression :: 2;
    SmrGcMethodRotation :: 3;
/* } */
PREFS_SMR_VOLUME_GC_METHOD :: ^REFS_SMR_VOLUME_GC_METHOD;

REFS_SMR_VOLUME_GC_PARAMETERS :: struct {
    Version           : DWORD,
    Flags             : DWORD,
    Action            : REFS_SMR_VOLUME_GC_ACTION,
    Method            : REFS_SMR_VOLUME_GC_METHOD,
    IoGranularity     : DWORD,
    CompressionFormat : DWORD,
    Unused            : [8]DWORDLONG,
};
PREFS_SMR_VOLUME_GC_PARAMETERS :: ^REFS_SMR_VOLUME_GC_PARAMETERS;

STREAMS_QUERY_PARAMETERS_OUTPUT_BUFFER :: struct {
    OptimalWriteSize      : DWORD,
    StreamGranularitySize : DWORD,
    StreamIdMin           : DWORD,
    StreamIdMax           : DWORD,
};
PSTREAMS_QUERY_PARAMETERS_OUTPUT_BUFFER :: ^STREAMS_QUERY_PARAMETERS_OUTPUT_BUFFER;

STREAMS_ASSOCIATE_ID_INPUT_BUFFER :: struct {
    Flags    : DWORD,
    StreamId : DWORD,
};
PSTREAMS_ASSOCIATE_ID_INPUT_BUFFER :: ^STREAMS_ASSOCIATE_ID_INPUT_BUFFER;

STREAMS_QUERY_ID_OUTPUT_BUFFER :: struct {
    StreamId : DWORD,
};
PSTREAMS_QUERY_ID_OUTPUT_BUFFER :: ^STREAMS_QUERY_ID_OUTPUT_BUFFER;

QUERY_BAD_RANGES_INPUT_RANGE :: struct {
    StartOffset   : DWORDLONG,
    LengthInBytes : DWORDLONG,
};
PQUERY_BAD_RANGES_INPUT_RANGE :: ^QUERY_BAD_RANGES_INPUT_RANGE;

QUERY_BAD_RANGES_INPUT :: struct {
    Flags     : DWORD,
    NumRanges : DWORD,
    Ranges    : [1]QUERY_BAD_RANGES_INPUT_RANGE,
};
PQUERY_BAD_RANGES_INPUT :: ^QUERY_BAD_RANGES_INPUT;

QUERY_BAD_RANGES_OUTPUT_RANGE :: struct {
    Flags         : DWORD,
    Reserved      : DWORD,
    StartOffset   : DWORDLONG,
    LengthInBytes : DWORDLONG,
};
PQUERY_BAD_RANGES_OUTPUT_RANGE :: ^QUERY_BAD_RANGES_OUTPUT_RANGE;

QUERY_BAD_RANGES_OUTPUT :: struct {
    Flags              : DWORD,
    NumBadRanges       : DWORD,
    NextOffsetToLookUp : DWORDLONG,
    BadRanges          : [1]QUERY_BAD_RANGES_OUTPUT_RANGE,
};
PQUERY_BAD_RANGES_OUTPUT :: ^QUERY_BAD_RANGES_OUTPUT;

SET_DAX_ALLOC_ALIGNMENT_HINT_INPUT :: struct {
    Flags                  : DWORD,
    AlignmentShift         : DWORD,
    FileOffsetToAlign      : DWORDLONG,
    FallbackAlignmentShift : DWORD,
};
PSET_DAX_ALLOC_ALIGNMENT_HINT_INPUT :: ^SET_DAX_ALLOC_ALIGNMENT_HINT_INPUT;

/* VIRTUAL_STORAGE_BEHAVIOR_CODE :: enum { */
VIRTUAL_STORAGE_BEHAVIOR_CODE :: _c.int;
    VirtualStorageBehaviorUndefined :: 0;
    VirtualStorageBehaviorCacheWriteThrough :: 1;
    VirtualStorageBehaviorCacheWriteBack :: 2;
/* } */
PVIRTUAL_STORAGE_BEHAVIOR_CODE :: ^VIRTUAL_STORAGE_BEHAVIOR_CODE;

VIRTUAL_STORAGE_SET_BEHAVIOR_INPUT :: struct {
    Size         : DWORD,
    BehaviorCode : VIRTUAL_STORAGE_BEHAVIOR_CODE,
};
PVIRTUAL_STORAGE_SET_BEHAVIOR_INPUT :: ^VIRTUAL_STORAGE_SET_BEHAVIOR_INPUT;

ENCRYPTION_KEY_CTRL_INPUT :: struct {
    HeaderSize      : DWORD,
    StructureSize   : DWORD,
    KeyOffset       : WORD,
    KeySize         : WORD,
    DplLock         : DWORD,
    DplUserId       : DWORDLONG,
    DplCredentialId : DWORDLONG,
};
PENCRYPTION_KEY_CTRL_INPUT :: ^ENCRYPTION_KEY_CTRL_INPUT;

WOF_EXTERNAL_INFO :: struct {
    Version  : DWORD,
    Provider : DWORD,
};
PWOF_EXTERNAL_INFO :: ^WOF_EXTERNAL_INFO;

WOF_EXTERNAL_FILE_ID :: struct {
    FileId : FILE_ID_128,
};
PWOF_EXTERNAL_FILE_ID :: ^WOF_EXTERNAL_FILE_ID;

WOF_VERSION_INFO :: struct {
    WofVersion : DWORD,
};
PWOF_VERSION_INFO :: ^WOF_VERSION_INFO;

WIM_PROVIDER_EXTERNAL_INFO :: struct {
    Version      : DWORD,
    Flags        : DWORD,
    DataSourceId : LARGE_INTEGER,
    ResourceHash : [20]BYTE,
};
PWIM_PROVIDER_EXTERNAL_INFO :: ^WIM_PROVIDER_EXTERNAL_INFO;

WIM_PROVIDER_ADD_OVERLAY_INPUT :: struct {
    WimType           : DWORD,
    WimIndex          : DWORD,
    WimFileNameOffset : DWORD,
    WimFileNameLength : DWORD,
};
PWIM_PROVIDER_ADD_OVERLAY_INPUT :: ^WIM_PROVIDER_ADD_OVERLAY_INPUT;

WIM_PROVIDER_UPDATE_OVERLAY_INPUT :: struct {
    DataSourceId      : LARGE_INTEGER,
    WimFileNameOffset : DWORD,
    WimFileNameLength : DWORD,
};
PWIM_PROVIDER_UPDATE_OVERLAY_INPUT :: ^WIM_PROVIDER_UPDATE_OVERLAY_INPUT;

WIM_PROVIDER_REMOVE_OVERLAY_INPUT :: struct {
    DataSourceId : LARGE_INTEGER,
};
PWIM_PROVIDER_REMOVE_OVERLAY_INPUT :: ^WIM_PROVIDER_REMOVE_OVERLAY_INPUT;

WIM_PROVIDER_SUSPEND_OVERLAY_INPUT :: struct {
    DataSourceId : LARGE_INTEGER,
};
PWIM_PROVIDER_SUSPEND_OVERLAY_INPUT :: ^WIM_PROVIDER_SUSPEND_OVERLAY_INPUT;

WIM_PROVIDER_OVERLAY_ENTRY :: struct {
    NextEntryOffset   : DWORD,
    DataSourceId      : LARGE_INTEGER,
    WimGuid           : GUID,
    WimFileNameOffset : DWORD,
    WimType           : DWORD,
    WimIndex          : DWORD,
    Flags             : DWORD,
};
PWIM_PROVIDER_OVERLAY_ENTRY :: ^WIM_PROVIDER_OVERLAY_ENTRY;

FILE_PROVIDER_EXTERNAL_INFO_V0 :: struct {
    Version   : DWORD,
    Algorithm : DWORD,
};
PFILE_PROVIDER_EXTERNAL_INFO_V0 :: ^FILE_PROVIDER_EXTERNAL_INFO_V0;

FILE_PROVIDER_EXTERNAL_INFO_V1 :: struct {
    Version   : DWORD,
    Algorithm : DWORD,
    Flags     : DWORD,
};
PFILE_PROVIDER_EXTERNAL_INFO_V1 :: ^FILE_PROVIDER_EXTERNAL_INFO_V1;

FILE_PROVIDER_EXTERNAL_INFO :: FILE_PROVIDER_EXTERNAL_INFO_V1;

PFILE_PROVIDER_EXTERNAL_INFO :: PFILE_PROVIDER_EXTERNAL_INFO_V1;

CONTAINER_VOLUME_STATE :: struct {
    Flags : DWORD,
};
PCONTAINER_VOLUME_STATE :: ^CONTAINER_VOLUME_STATE;

CONTAINER_ROOT_INFO_INPUT :: struct {
    Flags : DWORD,
};
PCONTAINER_ROOT_INFO_INPUT :: ^CONTAINER_ROOT_INFO_INPUT;

CONTAINER_ROOT_INFO_OUTPUT :: struct {
    ContainerRootIdLength : WORD,
    ContainerRootId       : [1]BYTE,
};
PCONTAINER_ROOT_INFO_OUTPUT :: ^CONTAINER_ROOT_INFO_OUTPUT;

VIRTUALIZATION_INSTANCE_INFO_INPUT :: struct {
    NumberOfWorkerThreads : DWORD,
    Flags                 : DWORD,
};
PVIRTUALIZATION_INSTANCE_INFO_INPUT :: ^VIRTUALIZATION_INSTANCE_INFO_INPUT;

VIRTUALIZATION_INSTANCE_INFO_INPUT_EX :: struct {
    HeaderSize             : WORD,
    Flags                  : DWORD,
    NotificationInfoSize   : DWORD,
    NotificationInfoOffset : WORD,
    ProviderMajorVersion   : WORD,
};
PVIRTUALIZATION_INSTANCE_INFO_INPUT_EX :: ^VIRTUALIZATION_INSTANCE_INFO_INPUT_EX;

VIRTUALIZATION_INSTANCE_INFO_OUTPUT :: struct {
    VirtualizationInstanceID : GUID,
};
PVIRTUALIZATION_INSTANCE_INFO_OUTPUT :: ^VIRTUALIZATION_INSTANCE_INFO_OUTPUT;

GET_FILTER_FILE_IDENTIFIER_INPUT :: struct {
    AltitudeLength : WORD,
    Altitude       : [1]WCHAR,
};
PGET_FILTER_FILE_IDENTIFIER_INPUT :: ^GET_FILTER_FILE_IDENTIFIER_INPUT;

GET_FILTER_FILE_IDENTIFIER_OUTPUT :: struct {
    FilterFileIdentifierLength : WORD,
    FilterFileIdentifier       : [1]BYTE,
};
PGET_FILTER_FILE_IDENTIFIER_OUTPUT :: ^GET_FILTER_FILE_IDENTIFIER_OUTPUT;

DISK_EXTENT :: struct {
    DiskNumber     : DWORD,
    StartingOffset : LARGE_INTEGER,
    ExtentLength   : LARGE_INTEGER,
};
PDISK_EXTENT :: ^DISK_EXTENT;

VOLUME_DISK_EXTENTS :: struct {
    NumberOfDiskExtents : DWORD,
    Extents             : [1]DISK_EXTENT,
};
PVOLUME_DISK_EXTENTS :: ^VOLUME_DISK_EXTENTS;

VOLUME_GET_GPT_ATTRIBUTES_INFORMATION :: struct {
    GptAttributes : DWORDLONG,
};
PVOLUME_GET_GPT_ATTRIBUTES_INFORMATION :: ^VOLUME_GET_GPT_ATTRIBUTES_INFORMATION;

PIO_IRP_EXT_PROCESS_TRACKED_OFFSET_CALLBACK :: proc(SourceContext : ^IO_IRP_EXT_TRACK_OFFSET_HEADER, TargetContext : ^IO_IRP_EXT_TRACK_OFFSET_HEADER, RelativeOffset : LONGLONG);

IO_IRP_EXT_TRACK_OFFSET_HEADER :: struct {
    Validation            : WORD,
    Flags                 : WORD,
    TrackedOffsetCallback : PIO_IRP_EXT_PROCESS_TRACKED_OFFSET_CALLBACK,
};
PIO_IRP_EXT_TRACK_OFFSET_HEADER :: ^IO_IRP_EXT_TRACK_OFFSET_HEADER;

;

UWORD :: WORD;

;

SCARD_IO_REQUEST :: struct {
    dwProtocol  : DWORD,
    cbPciLength : DWORD,
};
PSCARD_IO_REQUEST :: ^SCARD_IO_REQUEST;
LPSCARD_IO_REQUEST :: ^SCARD_IO_REQUEST;

LPCSCARD_IO_REQUEST :: ^SCARD_IO_REQUEST;

SCARD_T0_COMMAND :: struct {
    bCla : BYTE,
    bIns : BYTE,
    bP1  : BYTE,
    bP2  : BYTE,
    bP3  : BYTE,
};
LPSCARD_T0_COMMAND :: ^SCARD_T0_COMMAND;

SCARD_T0_REQUEST :: struct {
    ioRequest : SCARD_IO_REQUEST,
    bSw1      : BYTE,
    bSw2      : BYTE,
    u : struct #raw_union {
        CmdBytes  : SCARD_T0_COMMAND,
        rgbHeader : [5]BYTE,
    },
};

PSCARD_T0_REQUEST :: ^SCARD_T0_REQUEST;
LPSCARD_T0_REQUEST :: ^SCARD_T0_REQUEST;

SCARD_T1_REQUEST :: struct {
    ioRequest : SCARD_IO_REQUEST,
};

PSCARD_T1_REQUEST :: ^SCARD_T1_REQUEST;
LPSCARD_T1_REQUEST :: ^SCARD_T1_REQUEST;

LPCBYTE :: ^BYTE;

;

SCARDCONTEXT :: ULONG_PTR;

PSCARDCONTEXT :: ^SCARDCONTEXT;
LPSCARDCONTEXT :: ^SCARDCONTEXT;

SCARDHANDLE :: ULONG_PTR;

PSCARDHANDLE :: ^SCARDHANDLE;
LPSCARDHANDLE :: ^SCARDHANDLE;

SCARD_READERSTATEA :: struct {
    szReader       : LPCSTR,
    pvUserData     : LPVOID,
    dwCurrentState : DWORD,
    dwEventState   : DWORD,
    cbAtr          : DWORD,
    rgbAtr         : [36]BYTE,
};
PSCARD_READERSTATEA :: ^SCARD_READERSTATEA;
LPSCARD_READERSTATEA :: ^SCARD_READERSTATEA;

SCARD_READERSTATEW :: struct {
    szReader       : LPCWSTR,
    pvUserData     : LPVOID,
    dwCurrentState : DWORD,
    dwEventState   : DWORD,
    cbAtr          : DWORD,
    rgbAtr         : [36]BYTE,
};
PSCARD_READERSTATEW :: ^SCARD_READERSTATEW;
LPSCARD_READERSTATEW :: ^SCARD_READERSTATEW;

SCARD_READERSTATE :: SCARD_READERSTATEA;

PSCARD_READERSTATE :: PSCARD_READERSTATEA;

LPSCARD_READERSTATE :: LPSCARD_READERSTATEA;

SCARD_ATRMASK :: struct {
    cbAtr   : DWORD,
    rgbAtr  : [36]BYTE,
    rgbMask : [36]BYTE,
};
PSCARD_ATRMASK :: ^SCARD_ATRMASK;
LPSCARD_ATRMASK :: ^SCARD_ATRMASK;

LPOCNCONNPROCA :: (proc "stdcall" (SCARDCONTEXT, LPSTR, LPSTR, PVOID) -> SCARDHANDLE);

LPOCNCONNPROCW :: (proc "stdcall" (SCARDCONTEXT, LPWSTR, LPWSTR, PVOID) -> SCARDHANDLE);

LPOCNCHKPROC :: (proc "stdcall" (SCARDCONTEXT, SCARDHANDLE, PVOID) -> BOOL);

LPOCNDSCPROC :: proc "stdcall" (SCARDCONTEXT, SCARDHANDLE, PVOID);

OPENCARD_SEARCH_CRITERIAA :: struct {
    dwStructSize         : DWORD,
    lpstrGroupNames      : LPSTR,
    nMaxGroupNames       : DWORD,
    rgguidInterfaces     : LPCGUID,
    cguidInterfaces      : DWORD,
    lpstrCardNames       : LPSTR,
    nMaxCardNames        : DWORD,
    lpfnCheck            : LPOCNCHKPROC,
    lpfnConnect          : LPOCNCONNPROCA,
    lpfnDisconnect       : LPOCNDSCPROC,
    pvUserData           : LPVOID,
    dwShareMode          : DWORD,
    dwPreferredProtocols : DWORD,
};
POPENCARD_SEARCH_CRITERIAA :: ^OPENCARD_SEARCH_CRITERIAA;
LPOPENCARD_SEARCH_CRITERIAA :: ^OPENCARD_SEARCH_CRITERIAA;

OPENCARD_SEARCH_CRITERIAW :: struct {
    dwStructSize         : DWORD,
    lpstrGroupNames      : LPWSTR,
    nMaxGroupNames       : DWORD,
    rgguidInterfaces     : LPCGUID,
    cguidInterfaces      : DWORD,
    lpstrCardNames       : LPWSTR,
    nMaxCardNames        : DWORD,
    lpfnCheck            : LPOCNCHKPROC,
    lpfnConnect          : LPOCNCONNPROCW,
    lpfnDisconnect       : LPOCNDSCPROC,
    pvUserData           : LPVOID,
    dwShareMode          : DWORD,
    dwPreferredProtocols : DWORD,
};
POPENCARD_SEARCH_CRITERIAW :: ^OPENCARD_SEARCH_CRITERIAW;
LPOPENCARD_SEARCH_CRITERIAW :: ^OPENCARD_SEARCH_CRITERIAW;

OPENCARD_SEARCH_CRITERIA :: OPENCARD_SEARCH_CRITERIAA;

POPENCARD_SEARCH_CRITERIA :: POPENCARD_SEARCH_CRITERIAA;

LPOPENCARD_SEARCH_CRITERIA :: LPOPENCARD_SEARCH_CRITERIAA;

OPENCARDNAME_EXA :: struct {
    dwStructSize            : DWORD,
    hSCardContext           : SCARDCONTEXT,
    hwndOwner               : HWND,
    dwFlags                 : DWORD,
    lpstrTitle              : LPCSTR,
    lpstrSearchDesc         : LPCSTR,
    hIcon                   : HICON,
    pOpenCardSearchCriteria : POPENCARD_SEARCH_CRITERIAA,
    lpfnConnect             : LPOCNCONNPROCA,
    pvUserData              : LPVOID,
    dwShareMode             : DWORD,
    dwPreferredProtocols    : DWORD,
    lpstrRdr                : LPSTR,
    nMaxRdr                 : DWORD,
    lpstrCard               : LPSTR,
    nMaxCard                : DWORD,
    dwActiveProtocol        : DWORD,
    hCardHandle             : SCARDHANDLE,
};
POPENCARDNAME_EXA :: ^OPENCARDNAME_EXA;
LPOPENCARDNAME_EXA :: ^OPENCARDNAME_EXA;

OPENCARDNAME_EXW :: struct {
    dwStructSize            : DWORD,
    hSCardContext           : SCARDCONTEXT,
    hwndOwner               : HWND,
    dwFlags                 : DWORD,
    lpstrTitle              : LPCWSTR,
    lpstrSearchDesc         : LPCWSTR,
    hIcon                   : HICON,
    pOpenCardSearchCriteria : POPENCARD_SEARCH_CRITERIAW,
    lpfnConnect             : LPOCNCONNPROCW,
    pvUserData              : LPVOID,
    dwShareMode             : DWORD,
    dwPreferredProtocols    : DWORD,
    lpstrRdr                : LPWSTR,
    nMaxRdr                 : DWORD,
    lpstrCard               : LPWSTR,
    nMaxCard                : DWORD,
    dwActiveProtocol        : DWORD,
    hCardHandle             : SCARDHANDLE,
};
POPENCARDNAME_EXW :: ^OPENCARDNAME_EXW;
LPOPENCARDNAME_EXW :: ^OPENCARDNAME_EXW;

OPENCARDNAME_EX :: OPENCARDNAME_EXA;

POPENCARDNAME_EX :: POPENCARDNAME_EXA;

LPOPENCARDNAME_EX :: LPOPENCARDNAME_EXA;

/* READER_SEL_REQUEST_MATCH_TYPE :: enum { */
READER_SEL_REQUEST_MATCH_TYPE :: _c.int;
    RSR_MATCH_TYPE_READER_AND_CONTAINER :: 1;
    RSR_MATCH_TYPE_SERIAL_NUMBER :: RSR_MATCH_TYPE_READER_AND_CONTAINER + 1;
    RSR_MATCH_TYPE_ALL_CARDS :: RSR_MATCH_TYPE_SERIAL_NUMBER + 1;
/* } */
;

READER_SEL_REQUEST :: struct {
    dwShareMode          : DWORD,
    dwPreferredProtocols : DWORD,
    MatchType            : READER_SEL_REQUEST_MATCH_TYPE,
    u : struct #raw_union {
        ReaderAndContainerParameter : struct {
            cbReaderNameOffset         : DWORD,
            cchReaderNameLength        : DWORD,
            cbContainerNameOffset      : DWORD,
            cchContainerNameLength     : DWORD,
            dwDesiredCardModuleVersion : DWORD,
            dwCspFlags                 : DWORD,
        },
        SerialNumberParameter : struct {
            cbSerialNumberOffset       : DWORD,
            cbSerialNumberLength       : DWORD,
            dwDesiredCardModuleVersion : DWORD,
        },
    },
};
PREADER_SEL_REQUEST :: ^READER_SEL_REQUEST;

READER_SEL_RESPONSE :: struct {
    cbReaderNameOffset  : DWORD,
    cchReaderNameLength : DWORD,
    cbCardNameOffset    : DWORD,
    cchCardNameLength   : DWORD,
};
PREADER_SEL_RESPONSE :: ^READER_SEL_RESPONSE;

OPENCARDNAMEA :: struct {
    dwStructSize         : DWORD,
    hwndOwner            : HWND,
    hSCardContext        : SCARDCONTEXT,
    lpstrGroupNames      : LPSTR,
    nMaxGroupNames       : DWORD,
    lpstrCardNames       : LPSTR,
    nMaxCardNames        : DWORD,
    rgguidInterfaces     : LPCGUID,
    cguidInterfaces      : DWORD,
    lpstrRdr             : LPSTR,
    nMaxRdr              : DWORD,
    lpstrCard            : LPSTR,
    nMaxCard             : DWORD,
    lpstrTitle           : LPCSTR,
    dwFlags              : DWORD,
    pvUserData           : LPVOID,
    dwShareMode          : DWORD,
    dwPreferredProtocols : DWORD,
    dwActiveProtocol     : DWORD,
    lpfnConnect          : LPOCNCONNPROCA,
    lpfnCheck            : LPOCNCHKPROC,
    lpfnDisconnect       : LPOCNDSCPROC,
    hCardHandle          : SCARDHANDLE,
};
POPENCARDNAMEA :: ^OPENCARDNAMEA;
LPOPENCARDNAMEA :: ^OPENCARDNAMEA;

OPENCARDNAMEW :: struct {
    dwStructSize         : DWORD,
    hwndOwner            : HWND,
    hSCardContext        : SCARDCONTEXT,
    lpstrGroupNames      : LPWSTR,
    nMaxGroupNames       : DWORD,
    lpstrCardNames       : LPWSTR,
    nMaxCardNames        : DWORD,
    rgguidInterfaces     : LPCGUID,
    cguidInterfaces      : DWORD,
    lpstrRdr             : LPWSTR,
    nMaxRdr              : DWORD,
    lpstrCard            : LPWSTR,
    nMaxCard             : DWORD,
    lpstrTitle           : LPCWSTR,
    dwFlags              : DWORD,
    pvUserData           : LPVOID,
    dwShareMode          : DWORD,
    dwPreferredProtocols : DWORD,
    dwActiveProtocol     : DWORD,
    lpfnConnect          : LPOCNCONNPROCW,
    lpfnCheck            : LPOCNCHKPROC,
    lpfnDisconnect       : LPOCNDSCPROC,
    hCardHandle          : SCARDHANDLE,
};
POPENCARDNAMEW :: ^OPENCARDNAMEW;
LPOPENCARDNAMEW :: ^OPENCARDNAMEW;

OPENCARDNAME :: OPENCARDNAMEA;

POPENCARDNAME :: POPENCARDNAMEA;

LPOPENCARDNAME :: LPOPENCARDNAMEA;

_PSP :: struct {};

HPROPSHEETPAGE :: ^_PSP;

LPFNPSPCALLBACKA :: (proc "stdcall" (hwnd : HWND, uMsg : UINT, ppsp : ^PROPSHEETPAGEA_V4) -> UINT);

LPFNPSPCALLBACKW :: (proc "stdcall" (hwnd : HWND, uMsg : UINT, ppsp : ^PROPSHEETPAGEW_V4) -> UINT);

PROPSHEETPAGE_RESOURCE :: LPCDLGTEMPLATE;

PROPSHEETPAGEA_V1 :: struct {
    dwSize      : DWORD,
    dwFlags     : DWORD,
    hInstance   : HINSTANCE,
    u : struct #raw_union {
        pszTemplate : LPCSTR,
        pResource   : PROPSHEETPAGE_RESOURCE,
    },
    u2 : struct #raw_union {
        hIcon   : HICON,
        pszIcon : LPCSTR,
    },
    pszTitle    : LPCSTR,
    pfnDlgProc  : DLGPROC,
    lParam      : LPARAM,
    pfnCallback : LPFNPSPCALLBACKA,
    pcRefParent : ^UINT,
};
LPPROPSHEETPAGEA_V1 :: ^PROPSHEETPAGEA_V1;

LPCPROPSHEETPAGEA_V1 :: ^PROPSHEETPAGEA_V1;

PROPSHEETPAGEA_V2 :: struct {
    dwSize            : DWORD,
    dwFlags           : DWORD,
    hInstance         : HINSTANCE,
    u : struct #raw_union {
        pszTemplate : LPCSTR,
        pResource   : PROPSHEETPAGE_RESOURCE,
    },
    u2 : struct #raw_union {
        hIcon   : HICON,
        pszIcon : LPCSTR,
    },
    pszTitle          : LPCSTR,
    pfnDlgProc        : DLGPROC,
    lParam            : LPARAM,
    pfnCallback       : LPFNPSPCALLBACKA,
    pcRefParent       : ^UINT,
    pszHeaderTitle    : LPCSTR,
    pszHeaderSubTitle : LPCSTR,
};
LPPROPSHEETPAGEA_V2 :: ^PROPSHEETPAGEA_V2;

LPCPROPSHEETPAGEA_V2 :: ^PROPSHEETPAGEA_V2;

PROPSHEETPAGEA_V3 :: struct {
    dwSize            : DWORD,
    dwFlags           : DWORD,
    hInstance         : HINSTANCE,
    u : struct #raw_union {
        pszTemplate : LPCSTR,
        pResource   : PROPSHEETPAGE_RESOURCE,
    },
    u2 : struct #raw_union {
        hIcon   : HICON,
        pszIcon : LPCSTR,
    },
    pszTitle          : LPCSTR,
    pfnDlgProc        : DLGPROC,
    lParam            : LPARAM,
    pfnCallback       : LPFNPSPCALLBACKA,
    pcRefParent       : ^UINT,
    pszHeaderTitle    : LPCSTR,
    pszHeaderSubTitle : LPCSTR,
    hActCtx           : HANDLE,
};
LPPROPSHEETPAGEA_V3 :: ^PROPSHEETPAGEA_V3;

LPCPROPSHEETPAGEA_V3 :: ^PROPSHEETPAGEA_V3;

PROPSHEETPAGEA_V4 :: struct {
    dwSize            : DWORD,
    dwFlags           : DWORD,
    hInstance         : HINSTANCE,
    u : struct #raw_union {
        pszTemplate : LPCSTR,
        pResource   : PROPSHEETPAGE_RESOURCE,
    },
    u2 : struct #raw_union {
        hIcon   : HICON,
        pszIcon : LPCSTR,
    },
    pszTitle          : LPCSTR,
    pfnDlgProc        : DLGPROC,
    lParam            : LPARAM,
    pfnCallback       : LPFNPSPCALLBACKA,
    pcRefParent       : ^UINT,
    pszHeaderTitle    : LPCSTR,
    pszHeaderSubTitle : LPCSTR,
    hActCtx           : HANDLE,
    u3 : struct #raw_union {
        hbmHeader   : HBITMAP,
        pszbmHeader : LPCSTR,
    },
};
LPPROPSHEETPAGEA_V4 :: ^PROPSHEETPAGEA_V4;

LPCPROPSHEETPAGEA_V4 :: ^PROPSHEETPAGEA_V4;

PROPSHEETPAGEW_V1 :: struct {
    dwSize      : DWORD,
    dwFlags     : DWORD,
    hInstance   : HINSTANCE,
    u : struct #raw_union {
        pszTemplate : LPCWSTR,
        pResource   : PROPSHEETPAGE_RESOURCE,
    },
    u2 : struct #raw_union {
        hIcon   : HICON,
        pszIcon : LPCWSTR,
    },
    pszTitle    : LPCWSTR,
    pfnDlgProc  : DLGPROC,
    lParam      : LPARAM,
    pfnCallback : LPFNPSPCALLBACKW,
    pcRefParent : ^UINT,
};
LPPROPSHEETPAGEW_V1 :: ^PROPSHEETPAGEW_V1;

LPCPROPSHEETPAGEW_V1 :: ^PROPSHEETPAGEW_V1;

PROPSHEETPAGEW_V2 :: struct {
    dwSize            : DWORD,
    dwFlags           : DWORD,
    hInstance         : HINSTANCE,
    u : struct #raw_union {
        pszTemplate : LPCWSTR,
        pResource   : PROPSHEETPAGE_RESOURCE,
    },
    u2 : struct #raw_union {
        hIcon   : HICON,
        pszIcon : LPCWSTR,
    },
    pszTitle          : LPCWSTR,
    pfnDlgProc        : DLGPROC,
    lParam            : LPARAM,
    pfnCallback       : LPFNPSPCALLBACKW,
    pcRefParent       : ^UINT,
    pszHeaderTitle    : LPCWSTR,
    pszHeaderSubTitle : LPCWSTR,
};
LPPROPSHEETPAGEW_V2 :: ^PROPSHEETPAGEW_V2;

LPCPROPSHEETPAGEW_V2 :: ^PROPSHEETPAGEW_V2;

PROPSHEETPAGEW_V3 :: struct {
    dwSize            : DWORD,
    dwFlags           : DWORD,
    hInstance         : HINSTANCE,
    u : struct #raw_union {
        pszTemplate : LPCWSTR,
        pResource   : PROPSHEETPAGE_RESOURCE,
    },
    u2 : struct #raw_union {
        hIcon   : HICON,
        pszIcon : LPCWSTR,
    },
    pszTitle          : LPCWSTR,
    pfnDlgProc        : DLGPROC,
    lParam            : LPARAM,
    pfnCallback       : LPFNPSPCALLBACKW,
    pcRefParent       : ^UINT,
    pszHeaderTitle    : LPCWSTR,
    pszHeaderSubTitle : LPCWSTR,
    hActCtx           : HANDLE,
};
LPPROPSHEETPAGEW_V3 :: ^PROPSHEETPAGEW_V3;

LPCPROPSHEETPAGEW_V3 :: ^PROPSHEETPAGEW_V3;

PROPSHEETPAGEW_V4 :: struct {
    dwSize            : DWORD,
    dwFlags           : DWORD,
    hInstance         : HINSTANCE,
    u : struct #raw_union {
        pszTemplate : LPCWSTR,
        pResource   : PROPSHEETPAGE_RESOURCE,
    },
    u2 : struct #raw_union {
        hIcon   : HICON,
        pszIcon : LPCWSTR,
    },
    pszTitle          : LPCWSTR,
    pfnDlgProc        : DLGPROC,
    lParam            : LPARAM,
    pfnCallback       : LPFNPSPCALLBACKW,
    pcRefParent       : ^UINT,
    pszHeaderTitle    : LPCWSTR,
    pszHeaderSubTitle : LPCWSTR,
    hActCtx           : HANDLE,
    u3 : struct #raw_union {
        hbmHeader   : HBITMAP,
        pszbmHeader : LPCWSTR,
    },
};
LPPROPSHEETPAGEW_V4 :: ^PROPSHEETPAGEW_V4;

LPCPROPSHEETPAGEW_V4 :: ^PROPSHEETPAGEW_V4;

PROPSHEETPAGEA_LATEST :: PROPSHEETPAGEA_V4;

PROPSHEETPAGEW_LATEST :: PROPSHEETPAGEW_V4;

LPPROPSHEETPAGEA_LATEST :: LPPROPSHEETPAGEA_V4;

LPPROPSHEETPAGEW_LATEST :: LPPROPSHEETPAGEW_V4;

LPCPROPSHEETPAGEA_LATEST :: LPCPROPSHEETPAGEA_V4;

LPCPROPSHEETPAGEW_LATEST :: LPCPROPSHEETPAGEW_V4;

PROPSHEETPAGEA :: PROPSHEETPAGEA_V4;

PROPSHEETPAGEW :: PROPSHEETPAGEW_V4;

LPPROPSHEETPAGEA :: LPPROPSHEETPAGEA_V4;

LPPROPSHEETPAGEW :: LPPROPSHEETPAGEW_V4;

LPCPROPSHEETPAGEA :: LPCPROPSHEETPAGEA_V4;

LPCPROPSHEETPAGEW :: LPCPROPSHEETPAGEW_V4;

PFNPROPSHEETCALLBACK :: (proc "stdcall" (HWND, UINT, LPARAM) -> _c.int);

PROPSHEETHEADERA_V1 :: struct {
    dwSize      : DWORD,
    dwFlags     : DWORD,
    hwndParent  : HWND,
    hInstance   : HINSTANCE,
    u : struct #raw_union {
        hIcon   : HICON,
        pszIcon : LPCSTR,
    },
    pszCaption  : LPCSTR,
    nPages      : UINT,
    u2 : struct #raw_union {
        nStartPage : UINT,
        pStartPage : LPCSTR,
    },
    u3 : struct #raw_union {
        ppsp   : LPCPROPSHEETPAGEA,
        phpage : ^HPROPSHEETPAGE,
    },
    pfnCallback : PFNPROPSHEETCALLBACK,
};
LPPROPSHEETHEADERA_V1 :: ^PROPSHEETHEADERA_V1;

LPCPROPSHEETHEADERA_V1 :: ^PROPSHEETHEADERA_V1;

PROPSHEETHEADERA_V2 :: struct {
    dwSize       : DWORD,
    dwFlags      : DWORD,
    hwndParent   : HWND,
    hInstance    : HINSTANCE,
    u : struct #raw_union {
        hIcon   : HICON,
        pszIcon : LPCSTR,
    },
    pszCaption   : LPCSTR,
    nPages       : UINT,
    u2 : struct #raw_union {
        nStartPage : UINT,
        pStartPage : LPCSTR,
    },
    u3 : struct #raw_union {
        ppsp   : LPCPROPSHEETPAGEA,
        phpage : ^HPROPSHEETPAGE,
    },
    pfnCallback  : PFNPROPSHEETCALLBACK,
    u4 : struct #raw_union {
        hbmWatermark   : HBITMAP,
        pszbmWatermark : LPCSTR,
    },
    hplWatermark : HPALETTE,
    u5 : struct #raw_union {
        hbmHeader   : HBITMAP,
        pszbmHeader : LPCSTR,
    },
};
LPPROPSHEETHEADERA_V2 :: ^PROPSHEETHEADERA_V2;

LPCPROPSHEETHEADERA_V2 :: ^PROPSHEETHEADERA_V2;

PROPSHEETHEADERW_V1 :: struct {
    dwSize      : DWORD,
    dwFlags     : DWORD,
    hwndParent  : HWND,
    hInstance   : HINSTANCE,
    u : struct #raw_union {
        hIcon   : HICON,
        pszIcon : LPCWSTR,
    },
    pszCaption  : LPCWSTR,
    nPages      : UINT,
    u2 : struct #raw_union {
        nStartPage : UINT,
        pStartPage : LPCWSTR,
    },
    u3 : struct #raw_union {
        ppsp   : LPCPROPSHEETPAGEW,
        phpage : ^HPROPSHEETPAGE,
    },
    pfnCallback : PFNPROPSHEETCALLBACK,
};
LPPROPSHEETHEADERW_V1 :: ^PROPSHEETHEADERW_V1;

LPCPROPSHEETHEADERW_V1 :: ^PROPSHEETHEADERW_V1;

PROPSHEETHEADERW_V2 :: struct {
    dwSize       : DWORD,
    dwFlags      : DWORD,
    hwndParent   : HWND,
    hInstance    : HINSTANCE,
    u : struct #raw_union {
        hIcon   : HICON,
        pszIcon : LPCWSTR,
    },
    pszCaption   : LPCWSTR,
    nPages       : UINT,
    u2 : struct #raw_union {
        nStartPage : UINT,
        pStartPage : LPCWSTR,
    },
    u3 : struct #raw_union {
        ppsp   : LPCPROPSHEETPAGEW,
        phpage : ^HPROPSHEETPAGE,
    },
    pfnCallback  : PFNPROPSHEETCALLBACK,
    u4 : struct #raw_union {
        hbmWatermark   : HBITMAP,
        pszbmWatermark : LPCWSTR,
    },
    hplWatermark : HPALETTE,
    u5 : struct #raw_union {
        hbmHeader   : HBITMAP,
        pszbmHeader : LPCWSTR,
    },
};
LPPROPSHEETHEADERW_V2 :: ^PROPSHEETHEADERW_V2;

LPCPROPSHEETHEADERW_V2 :: ^PROPSHEETHEADERW_V2;

PROPSHEETHEADERA :: PROPSHEETHEADERA_V2;

PROPSHEETHEADERW :: PROPSHEETHEADERW_V2;

LPPROPSHEETHEADERA :: LPPROPSHEETHEADERA_V2;

LPPROPSHEETHEADERW :: LPPROPSHEETHEADERW_V2;

LPCPROPSHEETHEADERA :: LPCPROPSHEETHEADERA_V2;

LPCPROPSHEETHEADERW :: LPCPROPSHEETHEADERW_V2;

LPFNADDPROPSHEETPAGE :: (proc "stdcall" (HPROPSHEETPAGE, LPARAM) -> BOOL);

LPFNADDPROPSHEETPAGES :: (proc "stdcall" (LPVOID, LPFNADDPROPSHEETPAGE, LPARAM) -> BOOL);

PSHNOTIFY :: struct {
    hdr    : NMHDR,
    lParam : LPARAM,
};
LPPSHNOTIFY :: ^PSHNOTIFY;

PRINTER_INFO_1A :: struct {
    Flags        : DWORD,
    pDescription : LPSTR,
    pName        : LPSTR,
    pComment     : LPSTR,
};
PPRINTER_INFO_1A :: ^PRINTER_INFO_1A;
LPPRINTER_INFO_1A :: ^PRINTER_INFO_1A;

PRINTER_INFO_1W :: struct {
    Flags        : DWORD,
    pDescription : LPWSTR,
    pName        : LPWSTR,
    pComment     : LPWSTR,
};
PPRINTER_INFO_1W :: ^PRINTER_INFO_1W;
LPPRINTER_INFO_1W :: ^PRINTER_INFO_1W;

PRINTER_INFO_1 :: PRINTER_INFO_1A;

PPRINTER_INFO_1 :: PPRINTER_INFO_1A;

LPPRINTER_INFO_1 :: LPPRINTER_INFO_1A;

PRINTER_INFO_2A :: struct {
    pServerName         : LPSTR,
    pPrinterName        : LPSTR,
    pShareName          : LPSTR,
    pPortName           : LPSTR,
    pDriverName         : LPSTR,
    pComment            : LPSTR,
    pLocation           : LPSTR,
    pDevMode            : LPDEVMODEA,
    pSepFile            : LPSTR,
    pPrintProcessor     : LPSTR,
    pDatatype           : LPSTR,
    pParameters         : LPSTR,
    pSecurityDescriptor : PSECURITY_DESCRIPTOR,
    Attributes          : DWORD,
    Priority            : DWORD,
    DefaultPriority     : DWORD,
    StartTime           : DWORD,
    UntilTime           : DWORD,
    Status              : DWORD,
    cJobs               : DWORD,
    AveragePPM          : DWORD,
};
PPRINTER_INFO_2A :: ^PRINTER_INFO_2A;
LPPRINTER_INFO_2A :: ^PRINTER_INFO_2A;

PRINTER_INFO_2W :: struct {
    pServerName         : LPWSTR,
    pPrinterName        : LPWSTR,
    pShareName          : LPWSTR,
    pPortName           : LPWSTR,
    pDriverName         : LPWSTR,
    pComment            : LPWSTR,
    pLocation           : LPWSTR,
    pDevMode            : LPDEVMODEW,
    pSepFile            : LPWSTR,
    pPrintProcessor     : LPWSTR,
    pDatatype           : LPWSTR,
    pParameters         : LPWSTR,
    pSecurityDescriptor : PSECURITY_DESCRIPTOR,
    Attributes          : DWORD,
    Priority            : DWORD,
    DefaultPriority     : DWORD,
    StartTime           : DWORD,
    UntilTime           : DWORD,
    Status              : DWORD,
    cJobs               : DWORD,
    AveragePPM          : DWORD,
};
PPRINTER_INFO_2W :: ^PRINTER_INFO_2W;
LPPRINTER_INFO_2W :: ^PRINTER_INFO_2W;

PRINTER_INFO_2 :: PRINTER_INFO_2A;

PPRINTER_INFO_2 :: PPRINTER_INFO_2A;

LPPRINTER_INFO_2 :: LPPRINTER_INFO_2A;

PRINTER_INFO_3 :: struct {
    pSecurityDescriptor : PSECURITY_DESCRIPTOR,
};
PPRINTER_INFO_3 :: ^PRINTER_INFO_3;
LPPRINTER_INFO_3 :: ^PRINTER_INFO_3;

PRINTER_INFO_4A :: struct {
    pPrinterName : LPSTR,
    pServerName  : LPSTR,
    Attributes   : DWORD,
};
PPRINTER_INFO_4A :: ^PRINTER_INFO_4A;
LPPRINTER_INFO_4A :: ^PRINTER_INFO_4A;

PRINTER_INFO_4W :: struct {
    pPrinterName : LPWSTR,
    pServerName  : LPWSTR,
    Attributes   : DWORD,
};
PPRINTER_INFO_4W :: ^PRINTER_INFO_4W;
LPPRINTER_INFO_4W :: ^PRINTER_INFO_4W;

PRINTER_INFO_4 :: PRINTER_INFO_4A;

PPRINTER_INFO_4 :: PPRINTER_INFO_4A;

LPPRINTER_INFO_4 :: LPPRINTER_INFO_4A;

PRINTER_INFO_5A :: struct {
    pPrinterName             : LPSTR,
    pPortName                : LPSTR,
    Attributes               : DWORD,
    DeviceNotSelectedTimeout : DWORD,
    TransmissionRetryTimeout : DWORD,
};
PPRINTER_INFO_5A :: ^PRINTER_INFO_5A;
LPPRINTER_INFO_5A :: ^PRINTER_INFO_5A;

PRINTER_INFO_5W :: struct {
    pPrinterName             : LPWSTR,
    pPortName                : LPWSTR,
    Attributes               : DWORD,
    DeviceNotSelectedTimeout : DWORD,
    TransmissionRetryTimeout : DWORD,
};
PPRINTER_INFO_5W :: ^PRINTER_INFO_5W;
LPPRINTER_INFO_5W :: ^PRINTER_INFO_5W;

PRINTER_INFO_5 :: PRINTER_INFO_5A;

PPRINTER_INFO_5 :: PPRINTER_INFO_5A;

LPPRINTER_INFO_5 :: LPPRINTER_INFO_5A;

PRINTER_INFO_6 :: struct {
    dwStatus : DWORD,
};
PPRINTER_INFO_6 :: ^PRINTER_INFO_6;
LPPRINTER_INFO_6 :: ^PRINTER_INFO_6;

PRINTER_INFO_7A :: struct {
    pszObjectGUID : LPSTR,
    dwAction      : DWORD,
};
PPRINTER_INFO_7A :: ^PRINTER_INFO_7A;
LPPRINTER_INFO_7A :: ^PRINTER_INFO_7A;

PRINTER_INFO_7W :: struct {
    pszObjectGUID : LPWSTR,
    dwAction      : DWORD,
};
PPRINTER_INFO_7W :: ^PRINTER_INFO_7W;
LPPRINTER_INFO_7W :: ^PRINTER_INFO_7W;

PRINTER_INFO_7 :: PRINTER_INFO_7A;

PPRINTER_INFO_7 :: PPRINTER_INFO_7A;

LPPRINTER_INFO_7 :: LPPRINTER_INFO_7A;

PRINTER_INFO_8A :: struct {
    pDevMode : LPDEVMODEA,
};
PPRINTER_INFO_8A :: ^PRINTER_INFO_8A;
LPPRINTER_INFO_8A :: ^PRINTER_INFO_8A;

PRINTER_INFO_8W :: struct {
    pDevMode : LPDEVMODEW,
};
PPRINTER_INFO_8W :: ^PRINTER_INFO_8W;
LPPRINTER_INFO_8W :: ^PRINTER_INFO_8W;

PRINTER_INFO_8 :: PRINTER_INFO_8A;

PPRINTER_INFO_8 :: PPRINTER_INFO_8A;

LPPRINTER_INFO_8 :: LPPRINTER_INFO_8A;

PRINTER_INFO_9A :: struct {
    pDevMode : LPDEVMODEA,
};
PPRINTER_INFO_9A :: ^PRINTER_INFO_9A;
LPPRINTER_INFO_9A :: ^PRINTER_INFO_9A;

PRINTER_INFO_9W :: struct {
    pDevMode : LPDEVMODEW,
};
PPRINTER_INFO_9W :: ^PRINTER_INFO_9W;
LPPRINTER_INFO_9W :: ^PRINTER_INFO_9W;

PRINTER_INFO_9 :: PRINTER_INFO_9A;

PPRINTER_INFO_9 :: PPRINTER_INFO_9A;

LPPRINTER_INFO_9 :: LPPRINTER_INFO_9A;

JOB_INFO_1A :: struct {
    JobId        : DWORD,
    pPrinterName : LPSTR,
    pMachineName : LPSTR,
    pUserName    : LPSTR,
    pDocument    : LPSTR,
    pDatatype    : LPSTR,
    pStatus      : LPSTR,
    Status       : DWORD,
    Priority     : DWORD,
    Position     : DWORD,
    TotalPages   : DWORD,
    PagesPrinted : DWORD,
    Submitted    : SYSTEMTIME,
};
PJOB_INFO_1A :: ^JOB_INFO_1A;
LPJOB_INFO_1A :: ^JOB_INFO_1A;

JOB_INFO_1W :: struct {
    JobId        : DWORD,
    pPrinterName : LPWSTR,
    pMachineName : LPWSTR,
    pUserName    : LPWSTR,
    pDocument    : LPWSTR,
    pDatatype    : LPWSTR,
    pStatus      : LPWSTR,
    Status       : DWORD,
    Priority     : DWORD,
    Position     : DWORD,
    TotalPages   : DWORD,
    PagesPrinted : DWORD,
    Submitted    : SYSTEMTIME,
};
PJOB_INFO_1W :: ^JOB_INFO_1W;
LPJOB_INFO_1W :: ^JOB_INFO_1W;

JOB_INFO_1 :: JOB_INFO_1A;

PJOB_INFO_1 :: PJOB_INFO_1A;

LPJOB_INFO_1 :: LPJOB_INFO_1A;

JOB_INFO_2A :: struct {
    JobId               : DWORD,
    pPrinterName        : LPSTR,
    pMachineName        : LPSTR,
    pUserName           : LPSTR,
    pDocument           : LPSTR,
    pNotifyName         : LPSTR,
    pDatatype           : LPSTR,
    pPrintProcessor     : LPSTR,
    pParameters         : LPSTR,
    pDriverName         : LPSTR,
    pDevMode            : LPDEVMODEA,
    pStatus             : LPSTR,
    pSecurityDescriptor : PSECURITY_DESCRIPTOR,
    Status              : DWORD,
    Priority            : DWORD,
    Position            : DWORD,
    StartTime           : DWORD,
    UntilTime           : DWORD,
    TotalPages          : DWORD,
    Size                : DWORD,
    Submitted           : SYSTEMTIME,
    Time                : DWORD,
    PagesPrinted        : DWORD,
};
PJOB_INFO_2A :: ^JOB_INFO_2A;
LPJOB_INFO_2A :: ^JOB_INFO_2A;

JOB_INFO_2W :: struct {
    JobId               : DWORD,
    pPrinterName        : LPWSTR,
    pMachineName        : LPWSTR,
    pUserName           : LPWSTR,
    pDocument           : LPWSTR,
    pNotifyName         : LPWSTR,
    pDatatype           : LPWSTR,
    pPrintProcessor     : LPWSTR,
    pParameters         : LPWSTR,
    pDriverName         : LPWSTR,
    pDevMode            : LPDEVMODEW,
    pStatus             : LPWSTR,
    pSecurityDescriptor : PSECURITY_DESCRIPTOR,
    Status              : DWORD,
    Priority            : DWORD,
    Position            : DWORD,
    StartTime           : DWORD,
    UntilTime           : DWORD,
    TotalPages          : DWORD,
    Size                : DWORD,
    Submitted           : SYSTEMTIME,
    Time                : DWORD,
    PagesPrinted        : DWORD,
};
PJOB_INFO_2W :: ^JOB_INFO_2W;
LPJOB_INFO_2W :: ^JOB_INFO_2W;

JOB_INFO_2 :: JOB_INFO_2A;

PJOB_INFO_2 :: PJOB_INFO_2A;

LPJOB_INFO_2 :: LPJOB_INFO_2A;

JOB_INFO_3 :: struct {
    JobId     : DWORD,
    NextJobId : DWORD,
    Reserved  : DWORD,
};
PJOB_INFO_3 :: ^JOB_INFO_3;
LPJOB_INFO_3 :: ^JOB_INFO_3;

JOB_INFO_4A :: struct {
    JobId               : DWORD,
    pPrinterName        : LPSTR,
    pMachineName        : LPSTR,
    pUserName           : LPSTR,
    pDocument           : LPSTR,
    pNotifyName         : LPSTR,
    pDatatype           : LPSTR,
    pPrintProcessor     : LPSTR,
    pParameters         : LPSTR,
    pDriverName         : LPSTR,
    pDevMode            : LPDEVMODEA,
    pStatus             : LPSTR,
    pSecurityDescriptor : PSECURITY_DESCRIPTOR,
    Status              : DWORD,
    Priority            : DWORD,
    Position            : DWORD,
    StartTime           : DWORD,
    UntilTime           : DWORD,
    TotalPages          : DWORD,
    Size                : DWORD,
    Submitted           : SYSTEMTIME,
    Time                : DWORD,
    PagesPrinted        : DWORD,
    SizeHigh            : LONG,
};
PJOB_INFO_4A :: ^JOB_INFO_4A;
LPJOB_INFO_4A :: ^JOB_INFO_4A;

JOB_INFO_4W :: struct {
    JobId               : DWORD,
    pPrinterName        : LPWSTR,
    pMachineName        : LPWSTR,
    pUserName           : LPWSTR,
    pDocument           : LPWSTR,
    pNotifyName         : LPWSTR,
    pDatatype           : LPWSTR,
    pPrintProcessor     : LPWSTR,
    pParameters         : LPWSTR,
    pDriverName         : LPWSTR,
    pDevMode            : LPDEVMODEW,
    pStatus             : LPWSTR,
    pSecurityDescriptor : PSECURITY_DESCRIPTOR,
    Status              : DWORD,
    Priority            : DWORD,
    Position            : DWORD,
    StartTime           : DWORD,
    UntilTime           : DWORD,
    TotalPages          : DWORD,
    Size                : DWORD,
    Submitted           : SYSTEMTIME,
    Time                : DWORD,
    PagesPrinted        : DWORD,
    SizeHigh            : LONG,
};
PJOB_INFO_4W :: ^JOB_INFO_4W;
LPJOB_INFO_4W :: ^JOB_INFO_4W;

JOB_INFO_4 :: JOB_INFO_4A;

PJOB_INFO_4 :: PJOB_INFO_4A;

LPJOB_INFO_4 :: LPJOB_INFO_4A;

ADDJOB_INFO_1A :: struct {
    Path  : LPSTR,
    JobId : DWORD,
};
PADDJOB_INFO_1A :: ^ADDJOB_INFO_1A;
LPADDJOB_INFO_1A :: ^ADDJOB_INFO_1A;

ADDJOB_INFO_1W :: struct {
    Path  : LPWSTR,
    JobId : DWORD,
};
PADDJOB_INFO_1W :: ^ADDJOB_INFO_1W;
LPADDJOB_INFO_1W :: ^ADDJOB_INFO_1W;

ADDJOB_INFO_1 :: ADDJOB_INFO_1A;

PADDJOB_INFO_1 :: PADDJOB_INFO_1A;

LPADDJOB_INFO_1 :: LPADDJOB_INFO_1A;

DRIVER_INFO_1A :: struct {
    pName : LPSTR,
};
PDRIVER_INFO_1A :: ^DRIVER_INFO_1A;
LPDRIVER_INFO_1A :: ^DRIVER_INFO_1A;

DRIVER_INFO_1W :: struct {
    pName : LPWSTR,
};
PDRIVER_INFO_1W :: ^DRIVER_INFO_1W;
LPDRIVER_INFO_1W :: ^DRIVER_INFO_1W;

DRIVER_INFO_1 :: DRIVER_INFO_1A;

PDRIVER_INFO_1 :: PDRIVER_INFO_1A;

LPDRIVER_INFO_1 :: LPDRIVER_INFO_1A;

DRIVER_INFO_2A :: struct {
    cVersion     : DWORD,
    pName        : LPSTR,
    pEnvironment : LPSTR,
    pDriverPath  : LPSTR,
    pDataFile    : LPSTR,
    pConfigFile  : LPSTR,
};
PDRIVER_INFO_2A :: ^DRIVER_INFO_2A;
LPDRIVER_INFO_2A :: ^DRIVER_INFO_2A;

DRIVER_INFO_2W :: struct {
    cVersion     : DWORD,
    pName        : LPWSTR,
    pEnvironment : LPWSTR,
    pDriverPath  : LPWSTR,
    pDataFile    : LPWSTR,
    pConfigFile  : LPWSTR,
};
PDRIVER_INFO_2W :: ^DRIVER_INFO_2W;
LPDRIVER_INFO_2W :: ^DRIVER_INFO_2W;

DRIVER_INFO_2 :: DRIVER_INFO_2A;

PDRIVER_INFO_2 :: PDRIVER_INFO_2A;

LPDRIVER_INFO_2 :: LPDRIVER_INFO_2A;

DRIVER_INFO_3A :: struct {
    cVersion         : DWORD,
    pName            : LPSTR,
    pEnvironment     : LPSTR,
    pDriverPath      : LPSTR,
    pDataFile        : LPSTR,
    pConfigFile      : LPSTR,
    pHelpFile        : LPSTR,
    pDependentFiles  : LPSTR,
    pMonitorName     : LPSTR,
    pDefaultDataType : LPSTR,
};
PDRIVER_INFO_3A :: ^DRIVER_INFO_3A;
LPDRIVER_INFO_3A :: ^DRIVER_INFO_3A;

DRIVER_INFO_3W :: struct {
    cVersion         : DWORD,
    pName            : LPWSTR,
    pEnvironment     : LPWSTR,
    pDriverPath      : LPWSTR,
    pDataFile        : LPWSTR,
    pConfigFile      : LPWSTR,
    pHelpFile        : LPWSTR,
    pDependentFiles  : LPWSTR,
    pMonitorName     : LPWSTR,
    pDefaultDataType : LPWSTR,
};
PDRIVER_INFO_3W :: ^DRIVER_INFO_3W;
LPDRIVER_INFO_3W :: ^DRIVER_INFO_3W;

DRIVER_INFO_3 :: DRIVER_INFO_3A;

PDRIVER_INFO_3 :: PDRIVER_INFO_3A;

LPDRIVER_INFO_3 :: LPDRIVER_INFO_3A;

DRIVER_INFO_4A :: struct {
    cVersion          : DWORD,
    pName             : LPSTR,
    pEnvironment      : LPSTR,
    pDriverPath       : LPSTR,
    pDataFile         : LPSTR,
    pConfigFile       : LPSTR,
    pHelpFile         : LPSTR,
    pDependentFiles   : LPSTR,
    pMonitorName      : LPSTR,
    pDefaultDataType  : LPSTR,
    pszzPreviousNames : LPSTR,
};
PDRIVER_INFO_4A :: ^DRIVER_INFO_4A;
LPDRIVER_INFO_4A :: ^DRIVER_INFO_4A;

DRIVER_INFO_4W :: struct {
    cVersion          : DWORD,
    pName             : LPWSTR,
    pEnvironment      : LPWSTR,
    pDriverPath       : LPWSTR,
    pDataFile         : LPWSTR,
    pConfigFile       : LPWSTR,
    pHelpFile         : LPWSTR,
    pDependentFiles   : LPWSTR,
    pMonitorName      : LPWSTR,
    pDefaultDataType  : LPWSTR,
    pszzPreviousNames : LPWSTR,
};
PDRIVER_INFO_4W :: ^DRIVER_INFO_4W;
LPDRIVER_INFO_4W :: ^DRIVER_INFO_4W;

DRIVER_INFO_4 :: DRIVER_INFO_4A;

PDRIVER_INFO_4 :: PDRIVER_INFO_4A;

LPDRIVER_INFO_4 :: LPDRIVER_INFO_4A;

DRIVER_INFO_5A :: struct {
    cVersion           : DWORD,
    pName              : LPSTR,
    pEnvironment       : LPSTR,
    pDriverPath        : LPSTR,
    pDataFile          : LPSTR,
    pConfigFile        : LPSTR,
    dwDriverAttributes : DWORD,
    dwConfigVersion    : DWORD,
    dwDriverVersion    : DWORD,
};
PDRIVER_INFO_5A :: ^DRIVER_INFO_5A;
LPDRIVER_INFO_5A :: ^DRIVER_INFO_5A;

DRIVER_INFO_5W :: struct {
    cVersion           : DWORD,
    pName              : LPWSTR,
    pEnvironment       : LPWSTR,
    pDriverPath        : LPWSTR,
    pDataFile          : LPWSTR,
    pConfigFile        : LPWSTR,
    dwDriverAttributes : DWORD,
    dwConfigVersion    : DWORD,
    dwDriverVersion    : DWORD,
};
PDRIVER_INFO_5W :: ^DRIVER_INFO_5W;
LPDRIVER_INFO_5W :: ^DRIVER_INFO_5W;

DRIVER_INFO_5 :: DRIVER_INFO_5A;

PDRIVER_INFO_5 :: PDRIVER_INFO_5A;

LPDRIVER_INFO_5 :: LPDRIVER_INFO_5A;

DRIVER_INFO_6A :: struct {
    cVersion          : DWORD,
    pName             : LPSTR,
    pEnvironment      : LPSTR,
    pDriverPath       : LPSTR,
    pDataFile         : LPSTR,
    pConfigFile       : LPSTR,
    pHelpFile         : LPSTR,
    pDependentFiles   : LPSTR,
    pMonitorName      : LPSTR,
    pDefaultDataType  : LPSTR,
    pszzPreviousNames : LPSTR,
    ftDriverDate      : FILETIME,
    dwlDriverVersion  : DWORDLONG,
    pszMfgName        : LPSTR,
    pszOEMUrl         : LPSTR,
    pszHardwareID     : LPSTR,
    pszProvider       : LPSTR,
};
PDRIVER_INFO_6A :: ^DRIVER_INFO_6A;
LPDRIVER_INFO_6A :: ^DRIVER_INFO_6A;

DRIVER_INFO_6W :: struct {
    cVersion          : DWORD,
    pName             : LPWSTR,
    pEnvironment      : LPWSTR,
    pDriverPath       : LPWSTR,
    pDataFile         : LPWSTR,
    pConfigFile       : LPWSTR,
    pHelpFile         : LPWSTR,
    pDependentFiles   : LPWSTR,
    pMonitorName      : LPWSTR,
    pDefaultDataType  : LPWSTR,
    pszzPreviousNames : LPWSTR,
    ftDriverDate      : FILETIME,
    dwlDriverVersion  : DWORDLONG,
    pszMfgName        : LPWSTR,
    pszOEMUrl         : LPWSTR,
    pszHardwareID     : LPWSTR,
    pszProvider       : LPWSTR,
};
PDRIVER_INFO_6W :: ^DRIVER_INFO_6W;
LPDRIVER_INFO_6W :: ^DRIVER_INFO_6W;

DRIVER_INFO_6 :: DRIVER_INFO_6A;

PDRIVER_INFO_6 :: PDRIVER_INFO_6A;

LPDRIVER_INFO_6 :: LPDRIVER_INFO_6A;

DRIVER_INFO_8A :: struct {
    cVersion                    : DWORD,
    pName                       : LPSTR,
    pEnvironment                : LPSTR,
    pDriverPath                 : LPSTR,
    pDataFile                   : LPSTR,
    pConfigFile                 : LPSTR,
    pHelpFile                   : LPSTR,
    pDependentFiles             : LPSTR,
    pMonitorName                : LPSTR,
    pDefaultDataType            : LPSTR,
    pszzPreviousNames           : LPSTR,
    ftDriverDate                : FILETIME,
    dwlDriverVersion            : DWORDLONG,
    pszMfgName                  : LPSTR,
    pszOEMUrl                   : LPSTR,
    pszHardwareID               : LPSTR,
    pszProvider                 : LPSTR,
    pszPrintProcessor           : LPSTR,
    pszVendorSetup              : LPSTR,
    pszzColorProfiles           : LPSTR,
    pszInfPath                  : LPSTR,
    dwPrinterDriverAttributes   : DWORD,
    pszzCoreDriverDependencies  : LPSTR,
    ftMinInboxDriverVerDate     : FILETIME,
    dwlMinInboxDriverVerVersion : DWORDLONG,
};
PDRIVER_INFO_8A :: ^DRIVER_INFO_8A;
LPDRIVER_INFO_8A :: ^DRIVER_INFO_8A;

DRIVER_INFO_8W :: struct {
    cVersion                    : DWORD,
    pName                       : LPWSTR,
    pEnvironment                : LPWSTR,
    pDriverPath                 : LPWSTR,
    pDataFile                   : LPWSTR,
    pConfigFile                 : LPWSTR,
    pHelpFile                   : LPWSTR,
    pDependentFiles             : LPWSTR,
    pMonitorName                : LPWSTR,
    pDefaultDataType            : LPWSTR,
    pszzPreviousNames           : LPWSTR,
    ftDriverDate                : FILETIME,
    dwlDriverVersion            : DWORDLONG,
    pszMfgName                  : LPWSTR,
    pszOEMUrl                   : LPWSTR,
    pszHardwareID               : LPWSTR,
    pszProvider                 : LPWSTR,
    pszPrintProcessor           : LPWSTR,
    pszVendorSetup              : LPWSTR,
    pszzColorProfiles           : LPWSTR,
    pszInfPath                  : LPWSTR,
    dwPrinterDriverAttributes   : DWORD,
    pszzCoreDriverDependencies  : LPWSTR,
    ftMinInboxDriverVerDate     : FILETIME,
    dwlMinInboxDriverVerVersion : DWORDLONG,
};
PDRIVER_INFO_8W :: ^DRIVER_INFO_8W;
LPDRIVER_INFO_8W :: ^DRIVER_INFO_8W;

DRIVER_INFO_8 :: DRIVER_INFO_8A;

PDRIVER_INFO_8 :: PDRIVER_INFO_8A;

LPDRIVER_INFO_8 :: LPDRIVER_INFO_8A;

DOC_INFO_1A :: struct {
    pDocName    : LPSTR,
    pOutputFile : LPSTR,
    pDatatype   : LPSTR,
};
PDOC_INFO_1A :: ^DOC_INFO_1A;
LPDOC_INFO_1A :: ^DOC_INFO_1A;

DOC_INFO_1W :: struct {
    pDocName    : LPWSTR,
    pOutputFile : LPWSTR,
    pDatatype   : LPWSTR,
};
PDOC_INFO_1W :: ^DOC_INFO_1W;
LPDOC_INFO_1W :: ^DOC_INFO_1W;

DOC_INFO_1 :: DOC_INFO_1A;

PDOC_INFO_1 :: PDOC_INFO_1A;

LPDOC_INFO_1 :: LPDOC_INFO_1A;

FORM_INFO_1A :: struct {
    Flags         : DWORD,
    pName         : LPSTR,
    Size          : SIZEL,
    ImageableArea : RECTL,
};
PFORM_INFO_1A :: ^FORM_INFO_1A;
LPFORM_INFO_1A :: ^FORM_INFO_1A;

FORM_INFO_1W :: struct {
    Flags         : DWORD,
    pName         : LPWSTR,
    Size          : SIZEL,
    ImageableArea : RECTL,
};
PFORM_INFO_1W :: ^FORM_INFO_1W;
LPFORM_INFO_1W :: ^FORM_INFO_1W;

FORM_INFO_1 :: FORM_INFO_1A;

PFORM_INFO_1 :: PFORM_INFO_1A;

LPFORM_INFO_1 :: LPFORM_INFO_1A;

FORM_INFO_2A :: struct {
    Flags         : DWORD,
    pName         : LPCSTR,
    Size          : SIZEL,
    ImageableArea : RECTL,
    pKeyword      : LPCSTR,
    StringType    : DWORD,
    pMuiDll       : LPCSTR,
    dwResourceId  : DWORD,
    pDisplayName  : LPCSTR,
    wLangId       : LANGID,
};
PFORM_INFO_2A :: ^FORM_INFO_2A;
LPFORM_INFO_2A :: ^FORM_INFO_2A;

FORM_INFO_2W :: struct {
    Flags         : DWORD,
    pName         : LPCWSTR,
    Size          : SIZEL,
    ImageableArea : RECTL,
    pKeyword      : LPCSTR,
    StringType    : DWORD,
    pMuiDll       : LPCWSTR,
    dwResourceId  : DWORD,
    pDisplayName  : LPCWSTR,
    wLangId       : LANGID,
};
PFORM_INFO_2W :: ^FORM_INFO_2W;
LPFORM_INFO_2W :: ^FORM_INFO_2W;

FORM_INFO_2 :: FORM_INFO_2A;

PFORM_INFO_2 :: PFORM_INFO_2A;

LPFORM_INFO_2 :: LPFORM_INFO_2A;

DOC_INFO_2A :: struct {
    pDocName    : LPSTR,
    pOutputFile : LPSTR,
    pDatatype   : LPSTR,
    dwMode      : DWORD,
    JobId       : DWORD,
};
PDOC_INFO_2A :: ^DOC_INFO_2A;
LPDOC_INFO_2A :: ^DOC_INFO_2A;

DOC_INFO_2W :: struct {
    pDocName    : LPWSTR,
    pOutputFile : LPWSTR,
    pDatatype   : LPWSTR,
    dwMode      : DWORD,
    JobId       : DWORD,
};
PDOC_INFO_2W :: ^DOC_INFO_2W;
LPDOC_INFO_2W :: ^DOC_INFO_2W;

DOC_INFO_2 :: DOC_INFO_2A;

PDOC_INFO_2 :: PDOC_INFO_2A;

LPDOC_INFO_2 :: LPDOC_INFO_2A;

DOC_INFO_3A :: struct {
    pDocName    : LPSTR,
    pOutputFile : LPSTR,
    pDatatype   : LPSTR,
    dwFlags     : DWORD,
};
PDOC_INFO_3A :: ^DOC_INFO_3A;
LPDOC_INFO_3A :: ^DOC_INFO_3A;

DOC_INFO_3W :: struct {
    pDocName    : LPWSTR,
    pOutputFile : LPWSTR,
    pDatatype   : LPWSTR,
    dwFlags     : DWORD,
};
PDOC_INFO_3W :: ^DOC_INFO_3W;
LPDOC_INFO_3W :: ^DOC_INFO_3W;

DOC_INFO_3 :: DOC_INFO_3A;

PDOC_INFO_3 :: PDOC_INFO_3A;

LPDOC_INFO_3 :: LPDOC_INFO_3A;

PRINTPROCESSOR_INFO_1A :: struct {
    pName : LPSTR,
};
PPRINTPROCESSOR_INFO_1A :: ^PRINTPROCESSOR_INFO_1A;
LPPRINTPROCESSOR_INFO_1A :: ^PRINTPROCESSOR_INFO_1A;

PRINTPROCESSOR_INFO_1W :: struct {
    pName : LPWSTR,
};
PPRINTPROCESSOR_INFO_1W :: ^PRINTPROCESSOR_INFO_1W;
LPPRINTPROCESSOR_INFO_1W :: ^PRINTPROCESSOR_INFO_1W;

PRINTPROCESSOR_INFO_1 :: PRINTPROCESSOR_INFO_1A;

PPRINTPROCESSOR_INFO_1 :: PPRINTPROCESSOR_INFO_1A;

LPPRINTPROCESSOR_INFO_1 :: LPPRINTPROCESSOR_INFO_1A;

PRINTPROCESSOR_CAPS_1 :: struct {
    dwLevel          : DWORD,
    dwNupOptions     : DWORD,
    dwPageOrderFlags : DWORD,
    dwNumberOfCopies : DWORD,
};
PPRINTPROCESSOR_CAPS_1 :: ^PRINTPROCESSOR_CAPS_1;

PRINTPROCESSOR_CAPS_2 :: struct {
    dwLevel               : DWORD,
    dwNupOptions          : DWORD,
    dwPageOrderFlags      : DWORD,
    dwNumberOfCopies      : DWORD,
    dwDuplexHandlingCaps  : DWORD,
    dwNupDirectionCaps    : DWORD,
    dwNupBorderCaps       : DWORD,
    dwBookletHandlingCaps : DWORD,
    dwScalingCaps         : DWORD,
};
PPRINTPROCESSOR_CAPS_2 :: ^PRINTPROCESSOR_CAPS_2;

PORT_INFO_1A :: struct {
    pName : LPSTR,
};
PPORT_INFO_1A :: ^PORT_INFO_1A;
LPPORT_INFO_1A :: ^PORT_INFO_1A;

PORT_INFO_1W :: struct {
    pName : LPWSTR,
};
PPORT_INFO_1W :: ^PORT_INFO_1W;
LPPORT_INFO_1W :: ^PORT_INFO_1W;

PORT_INFO_1 :: PORT_INFO_1A;

PPORT_INFO_1 :: PPORT_INFO_1A;

LPPORT_INFO_1 :: LPPORT_INFO_1A;

PORT_INFO_2A :: struct {
    pPortName    : LPSTR,
    pMonitorName : LPSTR,
    pDescription : LPSTR,
    fPortType    : DWORD,
    Reserved     : DWORD,
};
PPORT_INFO_2A :: ^PORT_INFO_2A;
LPPORT_INFO_2A :: ^PORT_INFO_2A;

PORT_INFO_2W :: struct {
    pPortName    : LPWSTR,
    pMonitorName : LPWSTR,
    pDescription : LPWSTR,
    fPortType    : DWORD,
    Reserved     : DWORD,
};
PPORT_INFO_2W :: ^PORT_INFO_2W;
LPPORT_INFO_2W :: ^PORT_INFO_2W;

PORT_INFO_2 :: PORT_INFO_2A;

PPORT_INFO_2 :: PPORT_INFO_2A;

LPPORT_INFO_2 :: LPPORT_INFO_2A;

PORT_INFO_3A :: struct {
    dwStatus   : DWORD,
    pszStatus  : LPSTR,
    dwSeverity : DWORD,
};
PPORT_INFO_3A :: ^PORT_INFO_3A;
LPPORT_INFO_3A :: ^PORT_INFO_3A;

PORT_INFO_3W :: struct {
    dwStatus   : DWORD,
    pszStatus  : LPWSTR,
    dwSeverity : DWORD,
};
PPORT_INFO_3W :: ^PORT_INFO_3W;
LPPORT_INFO_3W :: ^PORT_INFO_3W;

PORT_INFO_3 :: PORT_INFO_3A;

PPORT_INFO_3 :: PPORT_INFO_3A;

LPPORT_INFO_3 :: LPPORT_INFO_3A;

MONITOR_INFO_1A :: struct {
    pName : LPSTR,
};
PMONITOR_INFO_1A :: ^MONITOR_INFO_1A;
LPMONITOR_INFO_1A :: ^MONITOR_INFO_1A;

MONITOR_INFO_1W :: struct {
    pName : LPWSTR,
};
PMONITOR_INFO_1W :: ^MONITOR_INFO_1W;
LPMONITOR_INFO_1W :: ^MONITOR_INFO_1W;

MONITOR_INFO_1 :: MONITOR_INFO_1A;

PMONITOR_INFO_1 :: PMONITOR_INFO_1A;

LPMONITOR_INFO_1 :: LPMONITOR_INFO_1A;

MONITOR_INFO_2A :: struct {
    pName        : LPSTR,
    pEnvironment : LPSTR,
    pDLLName     : LPSTR,
};
PMONITOR_INFO_2A :: ^MONITOR_INFO_2A;
LPMONITOR_INFO_2A :: ^MONITOR_INFO_2A;

MONITOR_INFO_2W :: struct {
    pName        : LPWSTR,
    pEnvironment : LPWSTR,
    pDLLName     : LPWSTR,
};
PMONITOR_INFO_2W :: ^MONITOR_INFO_2W;
LPMONITOR_INFO_2W :: ^MONITOR_INFO_2W;

MONITOR_INFO_2 :: MONITOR_INFO_2A;

PMONITOR_INFO_2 :: PMONITOR_INFO_2A;

LPMONITOR_INFO_2 :: LPMONITOR_INFO_2A;

DATATYPES_INFO_1A :: struct {
    pName : LPSTR,
};
PDATATYPES_INFO_1A :: ^DATATYPES_INFO_1A;
LPDATATYPES_INFO_1A :: ^DATATYPES_INFO_1A;

DATATYPES_INFO_1W :: struct {
    pName : LPWSTR,
};
PDATATYPES_INFO_1W :: ^DATATYPES_INFO_1W;
LPDATATYPES_INFO_1W :: ^DATATYPES_INFO_1W;

DATATYPES_INFO_1 :: DATATYPES_INFO_1A;

PDATATYPES_INFO_1 :: PDATATYPES_INFO_1A;

LPDATATYPES_INFO_1 :: LPDATATYPES_INFO_1A;

PRINTER_DEFAULTSA :: struct {
    pDatatype     : LPSTR,
    pDevMode      : LPDEVMODEA,
    DesiredAccess : ACCESS_MASK,
};
PPRINTER_DEFAULTSA :: ^PRINTER_DEFAULTSA;
LPPRINTER_DEFAULTSA :: ^PRINTER_DEFAULTSA;

PRINTER_DEFAULTSW :: struct {
    pDatatype     : LPWSTR,
    pDevMode      : LPDEVMODEW,
    DesiredAccess : ACCESS_MASK,
};
PPRINTER_DEFAULTSW :: ^PRINTER_DEFAULTSW;
LPPRINTER_DEFAULTSW :: ^PRINTER_DEFAULTSW;

PRINTER_DEFAULTS :: PRINTER_DEFAULTSA;

PPRINTER_DEFAULTS :: PPRINTER_DEFAULTSA;

LPPRINTER_DEFAULTS :: LPPRINTER_DEFAULTSA;

PRINTER_ENUM_VALUESA :: struct {
    pValueName  : LPSTR,
    cbValueName : DWORD,
    dwType      : DWORD,
    pData       : LPBYTE,
    cbData      : DWORD,
};
PPRINTER_ENUM_VALUESA :: ^PRINTER_ENUM_VALUESA;
LPPRINTER_ENUM_VALUESA :: ^PRINTER_ENUM_VALUESA;

PRINTER_ENUM_VALUESW :: struct {
    pValueName  : LPWSTR,
    cbValueName : DWORD,
    dwType      : DWORD,
    pData       : LPBYTE,
    cbData      : DWORD,
};
PPRINTER_ENUM_VALUESW :: ^PRINTER_ENUM_VALUESW;
LPPRINTER_ENUM_VALUESW :: ^PRINTER_ENUM_VALUESW;

PRINTER_ENUM_VALUES :: PRINTER_ENUM_VALUESA;

PPRINTER_ENUM_VALUES :: PPRINTER_ENUM_VALUESA;

LPPRINTER_ENUM_VALUES :: LPPRINTER_ENUM_VALUESA;

PRINTER_NOTIFY_OPTIONS_TYPE :: struct {
    Type      : WORD,
    Reserved0 : WORD,
    Reserved1 : DWORD,
    Reserved2 : DWORD,
    Count     : DWORD,
    pFields   : PWORD,
};
PPRINTER_NOTIFY_OPTIONS_TYPE :: ^PRINTER_NOTIFY_OPTIONS_TYPE;
LPPRINTER_NOTIFY_OPTIONS_TYPE :: ^PRINTER_NOTIFY_OPTIONS_TYPE;

PRINTER_NOTIFY_OPTIONS :: struct {
    Version : DWORD,
    Flags   : DWORD,
    Count   : DWORD,
    pTypes  : PPRINTER_NOTIFY_OPTIONS_TYPE,
};
PPRINTER_NOTIFY_OPTIONS :: ^PRINTER_NOTIFY_OPTIONS;
LPPRINTER_NOTIFY_OPTIONS :: ^PRINTER_NOTIFY_OPTIONS;

PRINTER_NOTIFY_INFO_DATA :: struct {
    Type       : WORD,
    Field      : WORD,
    Reserved   : DWORD,
    Id         : DWORD,
    NotifyData : struct #raw_union {
        adwData : [2]DWORD,
        Data : struct {
            cbBuf : DWORD,
            pBuf  : LPVOID,
        },
    },
};
PPRINTER_NOTIFY_INFO_DATA :: ^PRINTER_NOTIFY_INFO_DATA;
LPPRINTER_NOTIFY_INFO_DATA :: ^PRINTER_NOTIFY_INFO_DATA;

PRINTER_NOTIFY_INFO :: struct {
    Version : DWORD,
    Flags   : DWORD,
    Count   : DWORD,
    aData   : [1]PRINTER_NOTIFY_INFO_DATA,
};
PPRINTER_NOTIFY_INFO :: ^PRINTER_NOTIFY_INFO;
LPPRINTER_NOTIFY_INFO :: ^PRINTER_NOTIFY_INFO;

BINARY_CONTAINER :: struct {
    cbBuf : DWORD,
    pData : LPBYTE,
};
PBINARY_CONTAINER :: ^BINARY_CONTAINER;

BIDI_DATA :: struct {
    dwBidiType : DWORD,
    u : struct #raw_union {
        bData  : BOOL,
        iData  : LONG,
        sData  : LPWSTR,
        fData  : FLOAT,
        biData : BINARY_CONTAINER,
    },
};
PBIDI_DATA :: ^BIDI_DATA;
LPBIDI_DATA :: ^BIDI_DATA;

BIDI_REQUEST_DATA :: struct {
    dwReqNumber : DWORD,
    pSchema     : LPWSTR,
    data        : BIDI_DATA,
};
PBIDI_REQUEST_DATA :: ^BIDI_REQUEST_DATA;
LPBIDI_REQUEST_DATA :: ^BIDI_REQUEST_DATA;

BIDI_REQUEST_CONTAINER :: struct {
    Version : DWORD,
    Flags   : DWORD,
    Count   : DWORD,
    aData   : [1]BIDI_REQUEST_DATA,
};
PBIDI_REQUEST_CONTAINER :: ^BIDI_REQUEST_CONTAINER;
LPBIDI_REQUEST_CONTAINER :: ^BIDI_REQUEST_CONTAINER;

BIDI_RESPONSE_DATA :: struct {
    dwResult    : DWORD,
    dwReqNumber : DWORD,
    pSchema     : LPWSTR,
    data        : BIDI_DATA,
};
PBIDI_RESPONSE_DATA :: ^BIDI_RESPONSE_DATA;
LPBIDI_RESPONSE_DATA :: ^BIDI_RESPONSE_DATA;

BIDI_RESPONSE_CONTAINER :: struct {
    Version : DWORD,
    Flags   : DWORD,
    Count   : DWORD,
    aData   : [1]BIDI_RESPONSE_DATA,
};
PBIDI_RESPONSE_CONTAINER :: ^BIDI_RESPONSE_CONTAINER;
LPBIDI_RESPONSE_CONTAINER :: ^BIDI_RESPONSE_CONTAINER;

/* BIDI_TYPE :: enum { */
BIDI_TYPE :: _c.int;
    BIDI_NULL :: 0;
    BIDI_INT :: 1;
    BIDI_FLOAT :: 2;
    BIDI_BOOL :: 3;
    BIDI_STRING :: 4;
    BIDI_TEXT :: 5;
    BIDI_ENUM :: 6;
    BIDI_BLOB :: 7;
/* } */
;

PROVIDOR_INFO_1A :: struct {
    pName        : LPSTR,
    pEnvironment : LPSTR,
    pDLLName     : LPSTR,
};
PPROVIDOR_INFO_1A :: ^PROVIDOR_INFO_1A;
LPPROVIDOR_INFO_1A :: ^PROVIDOR_INFO_1A;

PROVIDOR_INFO_1W :: struct {
    pName        : LPWSTR,
    pEnvironment : LPWSTR,
    pDLLName     : LPWSTR,
};
PPROVIDOR_INFO_1W :: ^PROVIDOR_INFO_1W;
LPPROVIDOR_INFO_1W :: ^PROVIDOR_INFO_1W;

PROVIDOR_INFO_1 :: PROVIDOR_INFO_1A;

PPROVIDOR_INFO_1 :: PPROVIDOR_INFO_1A;

LPPROVIDOR_INFO_1 :: LPPROVIDOR_INFO_1A;

PROVIDOR_INFO_2A :: struct {
    pOrder : LPSTR,
};
PPROVIDOR_INFO_2A :: ^PROVIDOR_INFO_2A;
LPPROVIDOR_INFO_2A :: ^PROVIDOR_INFO_2A;

PROVIDOR_INFO_2W :: struct {
    pOrder : LPWSTR,
};
PPROVIDOR_INFO_2W :: ^PROVIDOR_INFO_2W;
LPPROVIDOR_INFO_2W :: ^PROVIDOR_INFO_2W;

PROVIDOR_INFO_2 :: PROVIDOR_INFO_2A;

PPROVIDOR_INFO_2 :: PPROVIDOR_INFO_2A;

LPPROVIDOR_INFO_2 :: LPPROVIDOR_INFO_2A;

/* PRINTER_OPTION_FLAGS :: enum { */
PRINTER_OPTION_FLAGS :: _c.int;
    PRINTER_OPTION_NO_CACHE :: 1 << 0;
    PRINTER_OPTION_CACHE :: 1 << 1;
    PRINTER_OPTION_CLIENT_CHANGE :: 1 << 2;
    PRINTER_OPTION_NO_CLIENT_DATA :: 1 << 3;
/* } */
;

PRINTER_OPTIONSA :: struct {
    cbSize  : UINT,
    dwFlags : DWORD,
};
PPRINTER_OPTIONSA :: ^PRINTER_OPTIONSA;
LPPRINTER_OPTIONSA :: ^PRINTER_OPTIONSA;

PRINTER_OPTIONSW :: struct {
    cbSize  : UINT,
    dwFlags : DWORD,
};
PPRINTER_OPTIONSW :: ^PRINTER_OPTIONSW;
LPPRINTER_OPTIONSW :: ^PRINTER_OPTIONSW;

PRINTER_OPTIONS :: PRINTER_OPTIONSA;

PPRINTER_OPTIONS :: PPRINTER_OPTIONSA;

LPPRINTER_OPTIONS :: LPPRINTER_OPTIONSA;

PRINTER_CONNECTION_INFO_1A :: struct {
    dwFlags       : DWORD,
    pszDriverName : LPSTR,
};
PPRINTER_CONNECTION_INFO_1A :: ^PRINTER_CONNECTION_INFO_1A;

PRINTER_CONNECTION_INFO_1W :: struct {
    dwFlags       : DWORD,
    pszDriverName : LPWSTR,
};
PPRINTER_CONNECTION_INFO_1W :: ^PRINTER_CONNECTION_INFO_1W;

PRINTER_CONNECTION_INFO_1 :: PRINTER_CONNECTION_INFO_1A;

PPRINTER_CONNECTION_INFO_1 :: PPRINTER_CONNECTION_INFO_1A;

CORE_PRINTER_DRIVERA :: struct {
    CoreDriverGUID   : GUID,
    ftDriverDate     : FILETIME,
    dwlDriverVersion : DWORDLONG,
    szPackageID      : [260]CHAR,
};
PCORE_PRINTER_DRIVERA :: ^CORE_PRINTER_DRIVERA;

CORE_PRINTER_DRIVERW :: struct {
    CoreDriverGUID   : GUID,
    ftDriverDate     : FILETIME,
    dwlDriverVersion : DWORDLONG,
    szPackageID      : [260]WCHAR,
};
PCORE_PRINTER_DRIVERW :: ^CORE_PRINTER_DRIVERW;

CORE_PRINTER_DRIVER :: CORE_PRINTER_DRIVERA;

PCORE_PRINTER_DRIVER :: PCORE_PRINTER_DRIVERA;

/* EPrintPropertyType :: enum { */
EPrintPropertyType :: _c.int;
    kPropertyTypeString :: 1;
    kPropertyTypeInt32 :: kPropertyTypeString + 1;
    kPropertyTypeInt64 :: kPropertyTypeInt32 + 1;
    kPropertyTypeByte :: kPropertyTypeInt64 + 1;
    kPropertyTypeTime :: kPropertyTypeByte + 1;
    kPropertyTypeDevMode :: kPropertyTypeTime + 1;
    kPropertyTypeSD :: kPropertyTypeDevMode + 1;
    kPropertyTypeNotificationReply :: kPropertyTypeSD + 1;
    kPropertyTypeNotificationOptions :: kPropertyTypeNotificationReply + 1;
    kPropertyTypeBuffer :: kPropertyTypeNotificationOptions + 1;
/* } */
;

/* EPrintXPSJobProgress :: enum { */
EPrintXPSJobProgress :: _c.int;
    kAddingDocumentSequence :: 0;
    kDocumentSequenceAdded :: 1;
    kAddingFixedDocument :: 2;
    kFixedDocumentAdded :: 3;
    kAddingFixedPage :: 4;
    kFixedPageAdded :: 5;
    kResourceAdded :: 6;
    kFontAdded :: 7;
    kImageAdded :: 8;
    kXpsDocumentCommitted :: 9;
/* } */
;

/* EPrintXPSJobOperation :: enum { */
EPrintXPSJobOperation :: _c.int;
    kJobProduction :: 1;
    kJobConsumption :: kJobProduction + 1;
/* } */
;

PrintPropertyValue :: struct {
    ePropertyType : EPrintPropertyType,
    value : struct #raw_union {
        propertyByte   : BYTE,
        propertyString : PWSTR,
        propertyInt32  : LONG,
        propertyInt64  : LONGLONG,
        propertyBlob : struct {
            cbBuf : DWORD,
            pBuf  : LPVOID,
        },
    },
};

PrintNamedProperty :: struct {
    propertyName  : ^WCHAR,
    propertyValue : PrintPropertyValue,
};

PrintPropertiesCollection :: struct {
    numberOfProperties   : ULONG,
    propertiesCollection : ^PrintNamedProperty,
};

/* PRINT_EXECUTION_CONTEXT :: enum { */
PRINT_EXECUTION_CONTEXT :: _c.int;
    PRINT_EXECUTION_CONTEXT_APPLICATION :: 0;
    PRINT_EXECUTION_CONTEXT_SPOOLER_SERVICE :: 1;
    PRINT_EXECUTION_CONTEXT_SPOOLER_ISOLATION_HOST :: 2;
    PRINT_EXECUTION_CONTEXT_FILTER_PIPELINE :: 3;
    PRINT_EXECUTION_CONTEXT_WOW64 :: 4;
/* } */
;

PRINT_EXECUTION_DATA :: struct {
    context_     : PRINT_EXECUTION_CONTEXT,
    clientAppPID : DWORD,
};

_CoreCrtSecureSearchSortCompareFunction :: (proc(rawptr, rawptr, rawptr) -> _c.int);

_CoreCrtNonSecureSearchSortCompareFunction :: (proc(rawptr, rawptr) -> _c.int);

_onexit_t :: (proc() -> _c.int);

_purecall_handler :: proc();

_invalid_parameter_handler :: proc(^_c.wchar_t, ^_c.wchar_t, ^_c.wchar_t, _c.uint, _c.uintptr_t);

div_t :: struct {
    quot : _c.int,
    rem  : _c.int,
};

ldiv_t :: struct {
    quot : _c.long,
    rem  : _c.long,
};

lldiv_t :: struct {
    quot : _c.longlong,
    rem  : _c.longlong,
};

_LDOUBLE :: struct {
    ld : [10]_c.uchar,
};

_CRT_DOUBLE :: struct {
    x : _c.double,
};

_CRT_FLOAT :: struct {
    f : _c.float,
};

_LONGDOUBLE :: struct {
    x : _c.double,
};

_LDBL12 :: struct {
    ld12 : [12]_c.uchar,
};

/* REGCLS :: enum { */
REGCLS :: _c.int;
    REGCLS_SINGLEUSE :: 0;
    REGCLS_MULTIPLEUSE :: 1;
    REGCLS_MULTI_SEPARATE :: 2;
    REGCLS_SUSPENDED :: 4;
    REGCLS_SURROGATE :: 8;
    REGCLS_AGILE :: 0x10;
/* } */
;

;

;

/* COINITBASE :: enum { */
COINITBASE :: _c.int;
    COINITBASE_MULTITHREADED :: 0x0;
/* } */
;

;

;

;

LPUNKNOWN :: ^IUnknown;

IUnknownVtbl :: struct {
    QueryInterface : (proc "stdcall" (This : ^IUnknown, riid : ^IID, ppvObject : ^rawptr) -> HRESULT),
    AddRef         : (proc "stdcall" (This : ^IUnknown) -> ULONG),
    Release        : (proc "stdcall" (This : ^IUnknown) -> ULONG),
};

IUnknown :: struct {
    lpVtbl : ^IUnknownVtbl,
};

AsyncIUnknownVtbl :: struct {
    QueryInterface        : (proc "stdcall" (This : ^AsyncIUnknown, riid : ^IID, ppvObject : ^rawptr) -> HRESULT),
    AddRef                : (proc "stdcall" (This : ^AsyncIUnknown) -> ULONG),
    Release               : (proc "stdcall" (This : ^AsyncIUnknown) -> ULONG),
    Begin_QueryInterface  : (proc "stdcall" (This : ^AsyncIUnknown, riid : ^IID) -> HRESULT),
    Finish_QueryInterface : (proc "stdcall" (This : ^AsyncIUnknown, ppvObject : ^rawptr) -> HRESULT),
    Begin_AddRef          : (proc "stdcall" (This : ^AsyncIUnknown) -> HRESULT),
    Finish_AddRef         : (proc "stdcall" (This : ^AsyncIUnknown) -> ULONG),
    Begin_Release         : (proc "stdcall" (This : ^AsyncIUnknown) -> HRESULT),
    Finish_Release        : (proc "stdcall" (This : ^AsyncIUnknown) -> ULONG),
};

AsyncIUnknown :: struct {
    lpVtbl : ^AsyncIUnknownVtbl,
};

LPCLASSFACTORY :: ^IClassFactory;

IClassFactoryVtbl :: struct {
    QueryInterface : (proc "stdcall" (This : ^IClassFactory, riid : ^IID, ppvObject : ^rawptr) -> HRESULT),
    AddRef         : (proc "stdcall" (This : ^IClassFactory) -> ULONG),
    Release        : (proc "stdcall" (This : ^IClassFactory) -> ULONG),
    CreateInstance : (proc "stdcall" (This : ^IClassFactory, pUnkOuter : ^IUnknown, riid : ^IID, ppvObject : ^rawptr) -> HRESULT),
    LockServer     : (proc "stdcall" (This : ^IClassFactory, fLock : BOOL) -> HRESULT),
};

IClassFactory :: struct {
    lpVtbl : ^IClassFactoryVtbl,
};

;

;

;

;

;

;

;

;

;

;

;

;

;

;

;

;

;

;

;

;

;

;

;

;

;

;

;

;

;

;

;

;

;

;

;

;

;

;

;

;

;

;

;

;

;

;

;

;

;

IEnumContextProps :: struct {};

IContext :: struct {};

IObjContext :: struct {};

;

;

;

;

;

COSERVERINFO :: struct {
    dwReserved1 : DWORD,
    pwszName    : LPWSTR,
    pAuthInfo   : ^COAUTHINFO,
    dwReserved2 : DWORD,
};

LPMARSHAL :: ^IMarshal;

IMarshalVtbl :: struct {
    QueryInterface     : (proc "stdcall" (This : ^IMarshal, riid : ^IID, ppvObject : ^rawptr) -> HRESULT),
    AddRef             : (proc "stdcall" (This : ^IMarshal) -> ULONG),
    Release            : (proc "stdcall" (This : ^IMarshal) -> ULONG),
    GetUnmarshalClass  : (proc "stdcall" (This : ^IMarshal, riid : ^IID, pv : rawptr, dwDestContext : DWORD, pvDestContext : rawptr, mshlflags : DWORD, pCid : ^CLSID) -> HRESULT),
    GetMarshalSizeMax  : (proc "stdcall" (This : ^IMarshal, riid : ^IID, pv : rawptr, dwDestContext : DWORD, pvDestContext : rawptr, mshlflags : DWORD, pSize : ^DWORD) -> HRESULT),
    MarshalInterface   : (proc "stdcall" (This : ^IMarshal, pStm : ^IStream, riid : ^IID, pv : rawptr, dwDestContext : DWORD, pvDestContext : rawptr, mshlflags : DWORD) -> HRESULT),
    UnmarshalInterface : (proc "stdcall" (This : ^IMarshal, pStm : ^IStream, riid : ^IID, ppv : ^rawptr) -> HRESULT),
    ReleaseMarshalData : (proc "stdcall" (This : ^IMarshal, pStm : ^IStream) -> HRESULT),
    DisconnectObject   : (proc "stdcall" (This : ^IMarshal, dwReserved : DWORD) -> HRESULT),
};

IMarshal :: struct {
    lpVtbl : ^IMarshalVtbl,
};

INoMarshalVtbl :: struct {
    QueryInterface : (proc "stdcall" (This : ^INoMarshal, riid : ^IID, ppvObject : ^rawptr) -> HRESULT),
    AddRef         : (proc "stdcall" (This : ^INoMarshal) -> ULONG),
    Release        : (proc "stdcall" (This : ^INoMarshal) -> ULONG),
};

INoMarshal :: struct {
    lpVtbl : ^INoMarshalVtbl,
};

IAgileObjectVtbl :: struct {
    QueryInterface : (proc "stdcall" (This : ^IAgileObject, riid : ^IID, ppvObject : ^rawptr) -> HRESULT),
    AddRef         : (proc "stdcall" (This : ^IAgileObject) -> ULONG),
    Release        : (proc "stdcall" (This : ^IAgileObject) -> ULONG),
};

IAgileObject :: struct {
    lpVtbl : ^IAgileObjectVtbl,
};

/* ACTIVATIONTYPE :: enum { */
ACTIVATIONTYPE :: _c.int;
    ACTIVATIONTYPE_UNCATEGORIZED :: 0;
    ACTIVATIONTYPE_FROM_MONIKER :: 0x1;
    ACTIVATIONTYPE_FROM_DATA :: 0x2;
    ACTIVATIONTYPE_FROM_STORAGE :: 0x4;
    ACTIVATIONTYPE_FROM_STREAM :: 0x8;
    ACTIVATIONTYPE_FROM_FILE :: 0x10;
/* } */
;

IActivationFilterVtbl :: struct {
    QueryInterface   : (proc "stdcall" (This : ^IActivationFilter, riid : ^IID, ppvObject : ^rawptr) -> HRESULT),
    AddRef           : (proc "stdcall" (This : ^IActivationFilter) -> ULONG),
    Release          : (proc "stdcall" (This : ^IActivationFilter) -> ULONG),
    HandleActivation : (proc "stdcall" (This : ^IActivationFilter, dwActivationType : DWORD, rclsid : ^IID, pReplacementClsId : ^CLSID) -> HRESULT),
};

IActivationFilter :: struct {
    lpVtbl : ^IActivationFilterVtbl,
};

LPMARSHAL2 :: ^IMarshal2;

IMarshal2Vtbl :: struct {
    QueryInterface     : (proc "stdcall" (This : ^IMarshal2, riid : ^IID, ppvObject : ^rawptr) -> HRESULT),
    AddRef             : (proc "stdcall" (This : ^IMarshal2) -> ULONG),
    Release            : (proc "stdcall" (This : ^IMarshal2) -> ULONG),
    GetUnmarshalClass  : (proc "stdcall" (This : ^IMarshal2, riid : ^IID, pv : rawptr, dwDestContext : DWORD, pvDestContext : rawptr, mshlflags : DWORD, pCid : ^CLSID) -> HRESULT),
    GetMarshalSizeMax  : (proc "stdcall" (This : ^IMarshal2, riid : ^IID, pv : rawptr, dwDestContext : DWORD, pvDestContext : rawptr, mshlflags : DWORD, pSize : ^DWORD) -> HRESULT),
    MarshalInterface   : (proc "stdcall" (This : ^IMarshal2, pStm : ^IStream, riid : ^IID, pv : rawptr, dwDestContext : DWORD, pvDestContext : rawptr, mshlflags : DWORD) -> HRESULT),
    UnmarshalInterface : (proc "stdcall" (This : ^IMarshal2, pStm : ^IStream, riid : ^IID, ppv : ^rawptr) -> HRESULT),
    ReleaseMarshalData : (proc "stdcall" (This : ^IMarshal2, pStm : ^IStream) -> HRESULT),
    DisconnectObject   : (proc "stdcall" (This : ^IMarshal2, dwReserved : DWORD) -> HRESULT),
};

IMarshal2 :: struct {
    lpVtbl : ^IMarshal2Vtbl,
};

LPMALLOC :: ^IMalloc;

IMallocVtbl :: struct {
    QueryInterface : (proc "stdcall" (This : ^IMalloc, riid : ^IID, ppvObject : ^rawptr) -> HRESULT),
    AddRef         : (proc "stdcall" (This : ^IMalloc) -> ULONG),
    Release        : (proc "stdcall" (This : ^IMalloc) -> ULONG),
    Alloc          : (proc "stdcall" (This : ^IMalloc, cb : SIZE_T) -> rawptr),
    Realloc        : (proc "stdcall" (This : ^IMalloc, pv : rawptr, cb : SIZE_T) -> rawptr),
    Free           : proc "stdcall" (This : ^IMalloc, pv : rawptr),
    GetSize        : (proc "stdcall" (This : ^IMalloc, pv : rawptr) -> SIZE_T),
    DidAlloc       : (proc "stdcall" (This : ^IMalloc, pv : rawptr) -> _c.int),
    HeapMinimize   : proc "stdcall" (This : ^IMalloc),
};

IMalloc :: struct {
    lpVtbl : ^IMallocVtbl,
};

LPSTDMARSHALINFO :: ^IStdMarshalInfo;

IStdMarshalInfoVtbl :: struct {
    QueryInterface     : (proc "stdcall" (This : ^IStdMarshalInfo, riid : ^IID, ppvObject : ^rawptr) -> HRESULT),
    AddRef             : (proc "stdcall" (This : ^IStdMarshalInfo) -> ULONG),
    Release            : (proc "stdcall" (This : ^IStdMarshalInfo) -> ULONG),
    GetClassForHandler : (proc "stdcall" (This : ^IStdMarshalInfo, dwDestContext : DWORD, pvDestContext : rawptr, pClsid : ^CLSID) -> HRESULT),
};

IStdMarshalInfo :: struct {
    lpVtbl : ^IStdMarshalInfoVtbl,
};

LPEXTERNALCONNECTION :: ^IExternalConnection;

/* EXTCONN :: enum { */
EXTCONN :: _c.int;
    EXTCONN_STRONG :: 0x1;
    EXTCONN_WEAK :: 0x2;
    EXTCONN_CALLABLE :: 0x4;
/* } */
;

IExternalConnectionVtbl :: struct {
    QueryInterface    : (proc "stdcall" (This : ^IExternalConnection, riid : ^IID, ppvObject : ^rawptr) -> HRESULT),
    AddRef            : (proc "stdcall" (This : ^IExternalConnection) -> ULONG),
    Release           : (proc "stdcall" (This : ^IExternalConnection) -> ULONG),
    AddConnection     : (proc "stdcall" (This : ^IExternalConnection, extconn : DWORD, reserved : DWORD) -> DWORD),
    ReleaseConnection : (proc "stdcall" (This : ^IExternalConnection, extconn : DWORD, reserved : DWORD, fLastReleaseCloses : BOOL) -> DWORD),
};

IExternalConnection :: struct {
    lpVtbl : ^IExternalConnectionVtbl,
};

LPMULTIQI :: ^IMultiQI;

MULTI_QI :: struct {
    pIID : ^IID,
    pItf : ^IUnknown,
    hr   : HRESULT,
};

IMultiQIVtbl :: struct {
    QueryInterface          : (proc "stdcall" (This : ^IMultiQI, riid : ^IID, ppvObject : ^rawptr) -> HRESULT),
    AddRef                  : (proc "stdcall" (This : ^IMultiQI) -> ULONG),
    Release                 : (proc "stdcall" (This : ^IMultiQI) -> ULONG),
    QueryMultipleInterfaces : (proc "stdcall" (This : ^IMultiQI, cMQIs : ULONG, pMQIs : ^MULTI_QI) -> HRESULT),
};

IMultiQI :: struct {
    lpVtbl : ^IMultiQIVtbl,
};

AsyncIMultiQIVtbl :: struct {
    QueryInterface                 : (proc "stdcall" (This : ^AsyncIMultiQI, riid : ^IID, ppvObject : ^rawptr) -> HRESULT),
    AddRef                         : (proc "stdcall" (This : ^AsyncIMultiQI) -> ULONG),
    Release                        : (proc "stdcall" (This : ^AsyncIMultiQI) -> ULONG),
    Begin_QueryMultipleInterfaces  : (proc "stdcall" (This : ^AsyncIMultiQI, cMQIs : ULONG, pMQIs : ^MULTI_QI) -> HRESULT),
    Finish_QueryMultipleInterfaces : (proc "stdcall" (This : ^AsyncIMultiQI, pMQIs : ^MULTI_QI) -> HRESULT),
};

AsyncIMultiQI :: struct {
    lpVtbl : ^AsyncIMultiQIVtbl,
};

IInternalUnknownVtbl :: struct {
    QueryInterface         : (proc "stdcall" (This : ^IInternalUnknown, riid : ^IID, ppvObject : ^rawptr) -> HRESULT),
    AddRef                 : (proc "stdcall" (This : ^IInternalUnknown) -> ULONG),
    Release                : (proc "stdcall" (This : ^IInternalUnknown) -> ULONG),
    QueryInternalInterface : (proc "stdcall" (This : ^IInternalUnknown, riid : ^IID, ppv : ^rawptr) -> HRESULT),
};

IInternalUnknown :: struct {
    lpVtbl : ^IInternalUnknownVtbl,
};

LPENUMUNKNOWN :: ^IEnumUnknown;

IEnumUnknownVtbl :: struct {
    QueryInterface : (proc "stdcall" (This : ^IEnumUnknown, riid : ^IID, ppvObject : ^rawptr) -> HRESULT),
    AddRef         : (proc "stdcall" (This : ^IEnumUnknown) -> ULONG),
    Release        : (proc "stdcall" (This : ^IEnumUnknown) -> ULONG),
    Next           : (proc "stdcall" (This : ^IEnumUnknown, celt : ULONG, rgelt : ^^IUnknown, pceltFetched : ^ULONG) -> HRESULT),
    Skip           : (proc "stdcall" (This : ^IEnumUnknown, celt : ULONG) -> HRESULT),
    Reset          : (proc "stdcall" (This : ^IEnumUnknown) -> HRESULT),
    Clone          : (proc "stdcall" (This : ^IEnumUnknown, ppenum : ^^IEnumUnknown) -> HRESULT),
};

IEnumUnknown :: struct {
    lpVtbl : ^IEnumUnknownVtbl,
};

LPENUMSTRING :: ^IEnumString;

IEnumStringVtbl :: struct {
    QueryInterface : (proc "stdcall" (This : ^IEnumString, riid : ^IID, ppvObject : ^rawptr) -> HRESULT),
    AddRef         : (proc "stdcall" (This : ^IEnumString) -> ULONG),
    Release        : (proc "stdcall" (This : ^IEnumString) -> ULONG),
    Next           : (proc "stdcall" (This : ^IEnumString, celt : ULONG, rgelt : ^LPOLESTR, pceltFetched : ^ULONG) -> HRESULT),
    Skip           : (proc "stdcall" (This : ^IEnumString, celt : ULONG) -> HRESULT),
    Reset          : (proc "stdcall" (This : ^IEnumString) -> HRESULT),
    Clone          : (proc "stdcall" (This : ^IEnumString, ppenum : ^^IEnumString) -> HRESULT),
};

IEnumString :: struct {
    lpVtbl : ^IEnumStringVtbl,
};

ISequentialStreamVtbl :: struct {
    QueryInterface : (proc "stdcall" (This : ^ISequentialStream, riid : ^IID, ppvObject : ^rawptr) -> HRESULT),
    AddRef         : (proc "stdcall" (This : ^ISequentialStream) -> ULONG),
    Release        : (proc "stdcall" (This : ^ISequentialStream) -> ULONG),
    Read           : (proc "stdcall" (This : ^ISequentialStream, pv : rawptr, cb : ULONG, pcbRead : ^ULONG) -> HRESULT),
    Write          : (proc "stdcall" (This : ^ISequentialStream, pv : rawptr, cb : ULONG, pcbWritten : ^ULONG) -> HRESULT),
};

ISequentialStream :: struct {
    lpVtbl : ^ISequentialStreamVtbl,
};

LPSTREAM :: ^IStream;

STATSTG :: struct {
    pwcsName          : LPOLESTR,
    type              : DWORD,
    cbSize            : ULARGE_INTEGER,
    mtime             : FILETIME,
    ctime             : FILETIME,
    atime             : FILETIME,
    grfMode           : DWORD,
    grfLocksSupported : DWORD,
    clsid             : CLSID,
    grfStateBits      : DWORD,
    reserved          : DWORD,
};

/* STGTY :: enum { */
STGTY :: _c.int;
    STGTY_STORAGE :: 1;
    STGTY_STREAM :: 2;
    STGTY_LOCKBYTES :: 3;
    STGTY_PROPERTY :: 4;
/* } */
;

/* STREAM_SEEK :: enum { */
STREAM_SEEK :: _c.int;
    STREAM_SEEK_SET :: 0;
    STREAM_SEEK_CUR :: 1;
    STREAM_SEEK_END :: 2;
/* } */
;

/* LOCKTYPE :: enum { */
LOCKTYPE :: _c.int;
    LOCK_WRITE :: 1;
    LOCK_EXCLUSIVE :: 2;
    LOCK_ONLYONCE :: 4;
/* } */
;

IStreamVtbl :: struct {
    QueryInterface : (proc "stdcall" (This : ^IStream, riid : ^IID, ppvObject : ^rawptr) -> HRESULT),
    AddRef         : (proc "stdcall" (This : ^IStream) -> ULONG),
    Release        : (proc "stdcall" (This : ^IStream) -> ULONG),
    Read           : (proc "stdcall" (This : ^IStream, pv : rawptr, cb : ULONG, pcbRead : ^ULONG) -> HRESULT),
    Write          : (proc "stdcall" (This : ^IStream, pv : rawptr, cb : ULONG, pcbWritten : ^ULONG) -> HRESULT),
    Seek           : (proc "stdcall" (This : ^IStream, dlibMove : LARGE_INTEGER, dwOrigin : DWORD, plibNewPosition : ^ULARGE_INTEGER) -> HRESULT),
    SetSize        : (proc "stdcall" (This : ^IStream, libNewSize : ULARGE_INTEGER) -> HRESULT),
    CopyTo         : (proc "stdcall" (This : ^IStream, pstm : ^IStream, cb : ULARGE_INTEGER, pcbRead : ^ULARGE_INTEGER, pcbWritten : ^ULARGE_INTEGER) -> HRESULT),
    Commit         : (proc "stdcall" (This : ^IStream, grfCommitFlags : DWORD) -> HRESULT),
    Revert         : (proc "stdcall" (This : ^IStream) -> HRESULT),
    LockRegion     : (proc "stdcall" (This : ^IStream, libOffset : ULARGE_INTEGER, cb : ULARGE_INTEGER, dwLockType : DWORD) -> HRESULT),
    UnlockRegion   : (proc "stdcall" (This : ^IStream, libOffset : ULARGE_INTEGER, cb : ULARGE_INTEGER, dwLockType : DWORD) -> HRESULT),
    Stat           : (proc "stdcall" (This : ^IStream, pstatstg : ^STATSTG, grfStatFlag : DWORD) -> HRESULT),
    Clone          : (proc "stdcall" (This : ^IStream, ppstm : ^^IStream) -> HRESULT),
};

IStream :: struct {
    lpVtbl : ^IStreamVtbl,
};

RPCOLEDATAREP :: ULONG;

RPCOLEMESSAGE :: struct {
    reserved1          : rawptr,
    dataRepresentation : RPCOLEDATAREP,
    Buffer             : rawptr,
    cbBuffer           : ULONG,
    iMethod            : ULONG,
    reserved2          : [5]rawptr,
    rpcFlags           : ULONG,
};

PRPCOLEMESSAGE :: ^RPCOLEMESSAGE;

IRpcChannelBufferVtbl :: struct {
    QueryInterface : (proc "stdcall" (This : ^IRpcChannelBuffer, riid : ^IID, ppvObject : ^rawptr) -> HRESULT),
    AddRef         : (proc "stdcall" (This : ^IRpcChannelBuffer) -> ULONG),
    Release        : (proc "stdcall" (This : ^IRpcChannelBuffer) -> ULONG),
    GetBuffer      : (proc "stdcall" (This : ^IRpcChannelBuffer, pMessage : ^RPCOLEMESSAGE, riid : ^IID) -> HRESULT),
    SendReceive    : (proc "stdcall" (This : ^IRpcChannelBuffer, pMessage : ^RPCOLEMESSAGE, pStatus : ^ULONG) -> HRESULT),
    FreeBuffer     : (proc "stdcall" (This : ^IRpcChannelBuffer, pMessage : ^RPCOLEMESSAGE) -> HRESULT),
    GetDestCtx     : (proc "stdcall" (This : ^IRpcChannelBuffer, pdwDestContext : ^DWORD, ppvDestContext : ^rawptr) -> HRESULT),
    IsConnected    : (proc "stdcall" (This : ^IRpcChannelBuffer) -> HRESULT),
};

IRpcChannelBuffer :: struct {
    lpVtbl : ^IRpcChannelBufferVtbl,
};

IRpcChannelBuffer2Vtbl :: struct {
    QueryInterface     : (proc "stdcall" (This : ^IRpcChannelBuffer2, riid : ^IID, ppvObject : ^rawptr) -> HRESULT),
    AddRef             : (proc "stdcall" (This : ^IRpcChannelBuffer2) -> ULONG),
    Release            : (proc "stdcall" (This : ^IRpcChannelBuffer2) -> ULONG),
    GetBuffer          : (proc "stdcall" (This : ^IRpcChannelBuffer2, pMessage : ^RPCOLEMESSAGE, riid : ^IID) -> HRESULT),
    SendReceive        : (proc "stdcall" (This : ^IRpcChannelBuffer2, pMessage : ^RPCOLEMESSAGE, pStatus : ^ULONG) -> HRESULT),
    FreeBuffer         : (proc "stdcall" (This : ^IRpcChannelBuffer2, pMessage : ^RPCOLEMESSAGE) -> HRESULT),
    GetDestCtx         : (proc "stdcall" (This : ^IRpcChannelBuffer2, pdwDestContext : ^DWORD, ppvDestContext : ^rawptr) -> HRESULT),
    IsConnected        : (proc "stdcall" (This : ^IRpcChannelBuffer2) -> HRESULT),
    GetProtocolVersion : (proc "stdcall" (This : ^IRpcChannelBuffer2, pdwVersion : ^DWORD) -> HRESULT),
};

IRpcChannelBuffer2 :: struct {
    lpVtbl : ^IRpcChannelBuffer2Vtbl,
};

IAsyncRpcChannelBufferVtbl :: struct {
    QueryInterface     : (proc "stdcall" (This : ^IAsyncRpcChannelBuffer, riid : ^IID, ppvObject : ^rawptr) -> HRESULT),
    AddRef             : (proc "stdcall" (This : ^IAsyncRpcChannelBuffer) -> ULONG),
    Release            : (proc "stdcall" (This : ^IAsyncRpcChannelBuffer) -> ULONG),
    GetBuffer          : (proc "stdcall" (This : ^IAsyncRpcChannelBuffer, pMessage : ^RPCOLEMESSAGE, riid : ^IID) -> HRESULT),
    SendReceive        : (proc "stdcall" (This : ^IAsyncRpcChannelBuffer, pMessage : ^RPCOLEMESSAGE, pStatus : ^ULONG) -> HRESULT),
    FreeBuffer         : (proc "stdcall" (This : ^IAsyncRpcChannelBuffer, pMessage : ^RPCOLEMESSAGE) -> HRESULT),
    GetDestCtx         : (proc "stdcall" (This : ^IAsyncRpcChannelBuffer, pdwDestContext : ^DWORD, ppvDestContext : ^rawptr) -> HRESULT),
    IsConnected        : (proc "stdcall" (This : ^IAsyncRpcChannelBuffer) -> HRESULT),
    GetProtocolVersion : (proc "stdcall" (This : ^IAsyncRpcChannelBuffer, pdwVersion : ^DWORD) -> HRESULT),
    Send               : (proc "stdcall" (This : ^IAsyncRpcChannelBuffer, pMsg : ^RPCOLEMESSAGE, pSync : ^ISynchronize, pulStatus : ^ULONG) -> HRESULT),
    Receive            : (proc "stdcall" (This : ^IAsyncRpcChannelBuffer, pMsg : ^RPCOLEMESSAGE, pulStatus : ^ULONG) -> HRESULT),
    GetDestCtxEx       : (proc "stdcall" (This : ^IAsyncRpcChannelBuffer, pMsg : ^RPCOLEMESSAGE, pdwDestContext : ^DWORD, ppvDestContext : ^rawptr) -> HRESULT),
};

IAsyncRpcChannelBuffer :: struct {
    lpVtbl : ^IAsyncRpcChannelBufferVtbl,
};

IRpcChannelBuffer3Vtbl :: struct {
    QueryInterface     : (proc "stdcall" (This : ^IRpcChannelBuffer3, riid : ^IID, ppvObject : ^rawptr) -> HRESULT),
    AddRef             : (proc "stdcall" (This : ^IRpcChannelBuffer3) -> ULONG),
    Release            : (proc "stdcall" (This : ^IRpcChannelBuffer3) -> ULONG),
    GetBuffer          : (proc "stdcall" (This : ^IRpcChannelBuffer3, pMessage : ^RPCOLEMESSAGE, riid : ^IID) -> HRESULT),
    SendReceive        : (proc "stdcall" (This : ^IRpcChannelBuffer3, pMessage : ^RPCOLEMESSAGE, pStatus : ^ULONG) -> HRESULT),
    FreeBuffer         : (proc "stdcall" (This : ^IRpcChannelBuffer3, pMessage : ^RPCOLEMESSAGE) -> HRESULT),
    GetDestCtx         : (proc "stdcall" (This : ^IRpcChannelBuffer3, pdwDestContext : ^DWORD, ppvDestContext : ^rawptr) -> HRESULT),
    IsConnected        : (proc "stdcall" (This : ^IRpcChannelBuffer3) -> HRESULT),
    GetProtocolVersion : (proc "stdcall" (This : ^IRpcChannelBuffer3, pdwVersion : ^DWORD) -> HRESULT),
    Send               : (proc "stdcall" (This : ^IRpcChannelBuffer3, pMsg : ^RPCOLEMESSAGE, pulStatus : ^ULONG) -> HRESULT),
    Receive            : (proc "stdcall" (This : ^IRpcChannelBuffer3, pMsg : ^RPCOLEMESSAGE, ulSize : ULONG, pulStatus : ^ULONG) -> HRESULT),
    Cancel             : (proc "stdcall" (This : ^IRpcChannelBuffer3, pMsg : ^RPCOLEMESSAGE) -> HRESULT),
    GetCallContext     : (proc "stdcall" (This : ^IRpcChannelBuffer3, pMsg : ^RPCOLEMESSAGE, riid : ^IID, pInterface : ^rawptr) -> HRESULT),
    GetDestCtxEx       : (proc "stdcall" (This : ^IRpcChannelBuffer3, pMsg : ^RPCOLEMESSAGE, pdwDestContext : ^DWORD, ppvDestContext : ^rawptr) -> HRESULT),
    GetState           : (proc "stdcall" (This : ^IRpcChannelBuffer3, pMsg : ^RPCOLEMESSAGE, pState : ^DWORD) -> HRESULT),
    RegisterAsync      : (proc "stdcall" (This : ^IRpcChannelBuffer3, pMsg : ^RPCOLEMESSAGE, pAsyncMgr : ^IAsyncManager) -> HRESULT),
};

IRpcChannelBuffer3 :: struct {
    lpVtbl : ^IRpcChannelBuffer3Vtbl,
};

IRpcSyntaxNegotiateVtbl :: struct {
    QueryInterface  : (proc "stdcall" (This : ^IRpcSyntaxNegotiate, riid : ^IID, ppvObject : ^rawptr) -> HRESULT),
    AddRef          : (proc "stdcall" (This : ^IRpcSyntaxNegotiate) -> ULONG),
    Release         : (proc "stdcall" (This : ^IRpcSyntaxNegotiate) -> ULONG),
    NegotiateSyntax : (proc "stdcall" (This : ^IRpcSyntaxNegotiate, pMsg : ^RPCOLEMESSAGE) -> HRESULT),
};

IRpcSyntaxNegotiate :: struct {
    lpVtbl : ^IRpcSyntaxNegotiateVtbl,
};

IRpcProxyBufferVtbl :: struct {
    QueryInterface : (proc "stdcall" (This : ^IRpcProxyBuffer, riid : ^IID, ppvObject : ^rawptr) -> HRESULT),
    AddRef         : (proc "stdcall" (This : ^IRpcProxyBuffer) -> ULONG),
    Release        : (proc "stdcall" (This : ^IRpcProxyBuffer) -> ULONG),
    Connect        : (proc "stdcall" (This : ^IRpcProxyBuffer, pRpcChannelBuffer : ^IRpcChannelBuffer) -> HRESULT),
    Disconnect     : proc "stdcall" (This : ^IRpcProxyBuffer),
};

IRpcProxyBuffer :: struct {
    lpVtbl : ^IRpcProxyBufferVtbl,
};

IRpcStubBufferVtbl :: struct {
    QueryInterface            : (proc "stdcall" (This : ^IRpcStubBuffer, riid : ^IID, ppvObject : ^rawptr) -> HRESULT),
    AddRef                    : (proc "stdcall" (This : ^IRpcStubBuffer) -> ULONG),
    Release                   : (proc "stdcall" (This : ^IRpcStubBuffer) -> ULONG),
    Connect                   : (proc "stdcall" (This : ^IRpcStubBuffer, pUnkServer : ^IUnknown) -> HRESULT),
    Disconnect                : proc "stdcall" (This : ^IRpcStubBuffer),
    Invoke                    : (proc "stdcall" (This : ^IRpcStubBuffer, _prpcmsg : ^RPCOLEMESSAGE, _pRpcChannelBuffer : ^IRpcChannelBuffer) -> HRESULT),
    IsIIDSupported            : (proc "stdcall" (This : ^IRpcStubBuffer, riid : ^IID) -> ^IRpcStubBuffer),
    CountRefs                 : (proc "stdcall" (This : ^IRpcStubBuffer) -> ULONG),
    DebugServerQueryInterface : (proc "stdcall" (This : ^IRpcStubBuffer, ppv : ^rawptr) -> HRESULT),
    DebugServerRelease        : proc "stdcall" (This : ^IRpcStubBuffer, pv : rawptr),
};

IRpcStubBuffer :: struct {
    lpVtbl : ^IRpcStubBufferVtbl,
};

IPSFactoryBufferVtbl :: struct {
    QueryInterface : (proc "stdcall" (This : ^IPSFactoryBuffer, riid : ^IID, ppvObject : ^rawptr) -> HRESULT),
    AddRef         : (proc "stdcall" (This : ^IPSFactoryBuffer) -> ULONG),
    Release        : (proc "stdcall" (This : ^IPSFactoryBuffer) -> ULONG),
    CreateProxy    : (proc "stdcall" (This : ^IPSFactoryBuffer, pUnkOuter : ^IUnknown, riid : ^IID, ppProxy : ^^IRpcProxyBuffer, ppv : ^rawptr) -> HRESULT),
    CreateStub     : (proc "stdcall" (This : ^IPSFactoryBuffer, riid : ^IID, pUnkServer : ^IUnknown, ppStub : ^^IRpcStubBuffer) -> HRESULT),
};

IPSFactoryBuffer :: struct {
    lpVtbl : ^IPSFactoryBufferVtbl,
};

SChannelHookCallInfo :: struct {
    iid         : IID,
    cbSize      : DWORD,
    uCausality  : GUID,
    dwServerPid : DWORD,
    iMethod     : DWORD,
    pObject     : rawptr,
};

IChannelHookVtbl :: struct {
    QueryInterface   : (proc "stdcall" (This : ^IChannelHook, riid : ^IID, ppvObject : ^rawptr) -> HRESULT),
    AddRef           : (proc "stdcall" (This : ^IChannelHook) -> ULONG),
    Release          : (proc "stdcall" (This : ^IChannelHook) -> ULONG),
    ClientGetSize    : proc "stdcall" (This : ^IChannelHook, uExtent : ^GUID, riid : ^IID, pDataSize : ^ULONG),
    ClientFillBuffer : proc "stdcall" (This : ^IChannelHook, uExtent : ^GUID, riid : ^IID, pDataSize : ^ULONG, pDataBuffer : rawptr),
    ClientNotify     : proc "stdcall" (This : ^IChannelHook, uExtent : ^GUID, riid : ^IID, cbDataSize : ULONG, pDataBuffer : rawptr, lDataRep : DWORD, hrFault : HRESULT),
    ServerNotify     : proc "stdcall" (This : ^IChannelHook, uExtent : ^GUID, riid : ^IID, cbDataSize : ULONG, pDataBuffer : rawptr, lDataRep : DWORD),
    ServerGetSize    : proc "stdcall" (This : ^IChannelHook, uExtent : ^GUID, riid : ^IID, hrFault : HRESULT, pDataSize : ^ULONG),
    ServerFillBuffer : proc "stdcall" (This : ^IChannelHook, uExtent : ^GUID, riid : ^IID, pDataSize : ^ULONG, pDataBuffer : rawptr, hrFault : HRESULT),
};

IChannelHook :: struct {
    lpVtbl : ^IChannelHookVtbl,
};

SOLE_AUTHENTICATION_SERVICE :: struct {
    dwAuthnSvc     : DWORD,
    dwAuthzSvc     : DWORD,
    pPrincipalName : ^OLECHAR,
    hr             : HRESULT,
};

PSOLE_AUTHENTICATION_SERVICE :: ^SOLE_AUTHENTICATION_SERVICE;

/* EOLE_AUTHENTICATION_CAPABILITIES :: enum { */
EOLE_AUTHENTICATION_CAPABILITIES :: _c.int;
    EOAC_NONE :: 0;
    EOAC_MUTUAL_AUTH :: 0x1;
    EOAC_STATIC_CLOAKING :: 0x20;
    EOAC_DYNAMIC_CLOAKING :: 0x40;
    EOAC_ANY_AUTHORITY :: 0x80;
    EOAC_MAKE_FULLSIC :: 0x100;
    EOAC_DEFAULT :: 0x800;
    EOAC_SECURE_REFS :: 0x2;
    EOAC_ACCESS_CONTROL :: 0x4;
    EOAC_APPID :: 0x8;
    EOAC_DYNAMIC :: 0x10;
    EOAC_REQUIRE_FULLSIC :: 0x200;
    EOAC_AUTO_IMPERSONATE :: 0x400;
    EOAC_DISABLE_AAA :: 0x1000;
    EOAC_NO_CUSTOM_MARSHAL :: 0x2000;
    EOAC_RESERVED1 :: 0x4000;
/* } */
;

SOLE_AUTHENTICATION_INFO :: struct {
    dwAuthnSvc : DWORD,
    dwAuthzSvc : DWORD,
    pAuthInfo  : rawptr,
};

PSOLE_AUTHENTICATION_INFO :: ^SOLE_AUTHENTICATION_INFO;

SOLE_AUTHENTICATION_LIST :: struct {
    cAuthInfo : DWORD,
    aAuthInfo : ^SOLE_AUTHENTICATION_INFO,
};

PSOLE_AUTHENTICATION_LIST :: ^SOLE_AUTHENTICATION_LIST;

IClientSecurityVtbl :: struct {
    QueryInterface : (proc "stdcall" (This : ^IClientSecurity, riid : ^IID, ppvObject : ^rawptr) -> HRESULT),
    AddRef         : (proc "stdcall" (This : ^IClientSecurity) -> ULONG),
    Release        : (proc "stdcall" (This : ^IClientSecurity) -> ULONG),
    QueryBlanket   : (proc "stdcall" (This : ^IClientSecurity, pProxy : ^IUnknown, pAuthnSvc : ^DWORD, pAuthzSvc : ^DWORD, pServerPrincName : ^^OLECHAR, pAuthnLevel : ^DWORD, pImpLevel : ^DWORD, pAuthInfo : ^rawptr, pCapabilites : ^DWORD) -> HRESULT),
    SetBlanket     : (proc "stdcall" (This : ^IClientSecurity, pProxy : ^IUnknown, dwAuthnSvc : DWORD, dwAuthzSvc : DWORD, pServerPrincName : ^OLECHAR, dwAuthnLevel : DWORD, dwImpLevel : DWORD, pAuthInfo : rawptr, dwCapabilities : DWORD) -> HRESULT),
    CopyProxy      : (proc "stdcall" (This : ^IClientSecurity, pProxy : ^IUnknown, ppCopy : ^^IUnknown) -> HRESULT),
};

IClientSecurity :: struct {
    lpVtbl : ^IClientSecurityVtbl,
};

IServerSecurityVtbl :: struct {
    QueryInterface    : (proc "stdcall" (This : ^IServerSecurity, riid : ^IID, ppvObject : ^rawptr) -> HRESULT),
    AddRef            : (proc "stdcall" (This : ^IServerSecurity) -> ULONG),
    Release           : (proc "stdcall" (This : ^IServerSecurity) -> ULONG),
    QueryBlanket      : (proc "stdcall" (This : ^IServerSecurity, pAuthnSvc : ^DWORD, pAuthzSvc : ^DWORD, pServerPrincName : ^^OLECHAR, pAuthnLevel : ^DWORD, pImpLevel : ^DWORD, pPrivs : ^rawptr, pCapabilities : ^DWORD) -> HRESULT),
    ImpersonateClient : (proc "stdcall" (This : ^IServerSecurity) -> HRESULT),
    RevertToSelf      : (proc "stdcall" (This : ^IServerSecurity) -> HRESULT),
    IsImpersonating   : (proc "stdcall" (This : ^IServerSecurity) -> BOOL),
};

IServerSecurity :: struct {
    lpVtbl : ^IServerSecurityVtbl,
};

/* RPCOPT_PROPERTIES :: enum { */
RPCOPT_PROPERTIES :: _c.int;
    COMBND_RPCTIMEOUT :: 0x1;
    COMBND_SERVER_LOCALITY :: 0x2;
    COMBND_RESERVED1 :: 0x4;
    COMBND_RESERVED2 :: 0x5;
    COMBND_RESERVED3 :: 0x8;
    COMBND_RESERVED4 :: 0x10;
/* } */
;

/* RPCOPT_SERVER_LOCALITY_VALUES :: enum { */
RPCOPT_SERVER_LOCALITY_VALUES :: _c.int;
    SERVER_LOCALITY_PROCESS_LOCAL :: 0;
    SERVER_LOCALITY_MACHINE_LOCAL :: 1;
    SERVER_LOCALITY_REMOTE :: 2;
/* } */
;

IRpcOptionsVtbl :: struct {
    QueryInterface : (proc "stdcall" (This : ^IRpcOptions, riid : ^IID, ppvObject : ^rawptr) -> HRESULT),
    AddRef         : (proc "stdcall" (This : ^IRpcOptions) -> ULONG),
    Release        : (proc "stdcall" (This : ^IRpcOptions) -> ULONG),
    Set            : (proc "stdcall" (This : ^IRpcOptions, pPrx : ^IUnknown, dwProperty : RPCOPT_PROPERTIES, dwValue : ULONG_PTR) -> HRESULT),
    Query          : (proc "stdcall" (This : ^IRpcOptions, pPrx : ^IUnknown, dwProperty : RPCOPT_PROPERTIES, pdwValue : ^ULONG_PTR) -> HRESULT),
};

IRpcOptions :: struct {
    lpVtbl : ^IRpcOptionsVtbl,
};

/* GLOBALOPT_PROPERTIES :: enum { */
GLOBALOPT_PROPERTIES :: _c.int;
    COMGLB_EXCEPTION_HANDLING :: 1;
    COMGLB_APPID :: 2;
    COMGLB_RPC_THREADPOOL_SETTING :: 3;
    COMGLB_RO_SETTINGS :: 4;
    COMGLB_UNMARSHALING_POLICY :: 5;
    COMGLB_PROPERTIES_RESERVED1 :: 6;
    COMGLB_PROPERTIES_RESERVED2 :: 7;
    COMGLB_PROPERTIES_RESERVED3 :: 8;
/* } */
;

/* GLOBALOPT_EH_VALUES :: enum { */
GLOBALOPT_EH_VALUES :: _c.int;
    COMGLB_EXCEPTION_HANDLE :: 0;
    COMGLB_EXCEPTION_DONOT_HANDLE_FATAL :: 1;
    COMGLB_EXCEPTION_DONOT_HANDLE ::     COMGLB_EXCEPTION_DONOT_HANDLE_FATAL;
    COMGLB_EXCEPTION_DONOT_HANDLE_ANY :: 2;
/* } */
;

/* GLOBALOPT_RPCTP_VALUES :: enum { */
GLOBALOPT_RPCTP_VALUES :: _c.int;
    COMGLB_RPC_THREADPOOL_SETTING_DEFAULT_POOL :: 0;
    COMGLB_RPC_THREADPOOL_SETTING_PRIVATE_POOL :: 1;
/* } */
;

/* GLOBALOPT_RO_FLAGS :: enum { */
GLOBALOPT_RO_FLAGS :: _c.int;
    COMGLB_STA_MODALLOOP_REMOVE_TOUCH_MESSAGES :: 0x1;
    COMGLB_STA_MODALLOOP_SHARED_QUEUE_REMOVE_INPUT_MESSAGES :: 0x2;
    COMGLB_STA_MODALLOOP_SHARED_QUEUE_DONOT_REMOVE_INPUT_MESSAGES :: 0x4;
    COMGLB_FAST_RUNDOWN :: 0x8;
    COMGLB_RESERVED1 :: 0x10;
    COMGLB_RESERVED2 :: 0x20;
    COMGLB_RESERVED3 :: 0x40;
    COMGLB_STA_MODALLOOP_SHARED_QUEUE_REORDER_POINTER_MESSAGES :: 0x80;
    COMGLB_RESERVED4 :: 0x100;
    COMGLB_RESERVED5 :: 0x200;
    COMGLB_RESERVED6 :: 0x400;
/* } */
;

/* GLOBALOPT_UNMARSHALING_POLICY_VALUES :: enum { */
GLOBALOPT_UNMARSHALING_POLICY_VALUES :: _c.int;
    COMGLB_UNMARSHALING_POLICY_NORMAL :: 0;
    COMGLB_UNMARSHALING_POLICY_STRONG :: 1;
    COMGLB_UNMARSHALING_POLICY_HYBRID :: 2;
/* } */
;

IGlobalOptionsVtbl :: struct {
    QueryInterface : (proc "stdcall" (This : ^IGlobalOptions, riid : ^IID, ppvObject : ^rawptr) -> HRESULT),
    AddRef         : (proc "stdcall" (This : ^IGlobalOptions) -> ULONG),
    Release        : (proc "stdcall" (This : ^IGlobalOptions) -> ULONG),
    Set            : (proc "stdcall" (This : ^IGlobalOptions, dwProperty : GLOBALOPT_PROPERTIES, dwValue : ULONG_PTR) -> HRESULT),
    Query          : (proc "stdcall" (This : ^IGlobalOptions, dwProperty : GLOBALOPT_PROPERTIES, pdwValue : ^ULONG_PTR) -> HRESULT),
};

IGlobalOptions :: struct {
    lpVtbl : ^IGlobalOptionsVtbl,
};

LPSURROGATE :: ^ISurrogate;

ISurrogateVtbl :: struct {
    QueryInterface : (proc "stdcall" (This : ^ISurrogate, riid : ^IID, ppvObject : ^rawptr) -> HRESULT),
    AddRef         : (proc "stdcall" (This : ^ISurrogate) -> ULONG),
    Release        : (proc "stdcall" (This : ^ISurrogate) -> ULONG),
    LoadDllServer  : (proc "stdcall" (This : ^ISurrogate, Clsid : ^IID) -> HRESULT),
    FreeSurrogate  : (proc "stdcall" (This : ^ISurrogate) -> HRESULT),
};

ISurrogate :: struct {
    lpVtbl : ^ISurrogateVtbl,
};

LPGLOBALINTERFACETABLE :: ^IGlobalInterfaceTable;

IGlobalInterfaceTableVtbl :: struct {
    QueryInterface            : (proc "stdcall" (This : ^IGlobalInterfaceTable, riid : ^IID, ppvObject : ^rawptr) -> HRESULT),
    AddRef                    : (proc "stdcall" (This : ^IGlobalInterfaceTable) -> ULONG),
    Release                   : (proc "stdcall" (This : ^IGlobalInterfaceTable) -> ULONG),
    RegisterInterfaceInGlobal : (proc "stdcall" (This : ^IGlobalInterfaceTable, pUnk : ^IUnknown, riid : ^IID, pdwCookie : ^DWORD) -> HRESULT),
    RevokeInterfaceFromGlobal : (proc "stdcall" (This : ^IGlobalInterfaceTable, dwCookie : DWORD) -> HRESULT),
    GetInterfaceFromGlobal    : (proc "stdcall" (This : ^IGlobalInterfaceTable, dwCookie : DWORD, riid : ^IID, ppv : ^rawptr) -> HRESULT),
};

IGlobalInterfaceTable :: struct {
    lpVtbl : ^IGlobalInterfaceTableVtbl,
};

ISynchronizeVtbl :: struct {
    QueryInterface : (proc "stdcall" (This : ^ISynchronize, riid : ^IID, ppvObject : ^rawptr) -> HRESULT),
    AddRef         : (proc "stdcall" (This : ^ISynchronize) -> ULONG),
    Release        : (proc "stdcall" (This : ^ISynchronize) -> ULONG),
    Wait           : (proc "stdcall" (This : ^ISynchronize, dwFlags : DWORD, dwMilliseconds : DWORD) -> HRESULT),
    Signal         : (proc "stdcall" (This : ^ISynchronize) -> HRESULT),
    Reset          : (proc "stdcall" (This : ^ISynchronize) -> HRESULT),
};

ISynchronize :: struct {
    lpVtbl : ^ISynchronizeVtbl,
};

ISynchronizeHandleVtbl :: struct {
    QueryInterface : (proc "stdcall" (This : ^ISynchronizeHandle, riid : ^IID, ppvObject : ^rawptr) -> HRESULT),
    AddRef         : (proc "stdcall" (This : ^ISynchronizeHandle) -> ULONG),
    Release        : (proc "stdcall" (This : ^ISynchronizeHandle) -> ULONG),
    GetHandle      : (proc "stdcall" (This : ^ISynchronizeHandle, ph : ^HANDLE) -> HRESULT),
};

ISynchronizeHandle :: struct {
    lpVtbl : ^ISynchronizeHandleVtbl,
};

ISynchronizeEventVtbl :: struct {
    QueryInterface : (proc "stdcall" (This : ^ISynchronizeEvent, riid : ^IID, ppvObject : ^rawptr) -> HRESULT),
    AddRef         : (proc "stdcall" (This : ^ISynchronizeEvent) -> ULONG),
    Release        : (proc "stdcall" (This : ^ISynchronizeEvent) -> ULONG),
    GetHandle      : (proc "stdcall" (This : ^ISynchronizeEvent, ph : ^HANDLE) -> HRESULT),
    SetEventHandle : (proc "stdcall" (This : ^ISynchronizeEvent, ph : ^HANDLE) -> HRESULT),
};

ISynchronizeEvent :: struct {
    lpVtbl : ^ISynchronizeEventVtbl,
};

ISynchronizeContainerVtbl :: struct {
    QueryInterface : (proc "stdcall" (This : ^ISynchronizeContainer, riid : ^IID, ppvObject : ^rawptr) -> HRESULT),
    AddRef         : (proc "stdcall" (This : ^ISynchronizeContainer) -> ULONG),
    Release        : (proc "stdcall" (This : ^ISynchronizeContainer) -> ULONG),
    AddSynchronize : (proc "stdcall" (This : ^ISynchronizeContainer, pSync : ^ISynchronize) -> HRESULT),
    WaitMultiple   : (proc "stdcall" (This : ^ISynchronizeContainer, dwFlags : DWORD, dwTimeOut : DWORD, ppSync : ^^ISynchronize) -> HRESULT),
};

ISynchronizeContainer :: struct {
    lpVtbl : ^ISynchronizeContainerVtbl,
};

ISynchronizeMutexVtbl :: struct {
    QueryInterface : (proc "stdcall" (This : ^ISynchronizeMutex, riid : ^IID, ppvObject : ^rawptr) -> HRESULT),
    AddRef         : (proc "stdcall" (This : ^ISynchronizeMutex) -> ULONG),
    Release        : (proc "stdcall" (This : ^ISynchronizeMutex) -> ULONG),
    Wait           : (proc "stdcall" (This : ^ISynchronizeMutex, dwFlags : DWORD, dwMilliseconds : DWORD) -> HRESULT),
    Signal         : (proc "stdcall" (This : ^ISynchronizeMutex) -> HRESULT),
    Reset          : (proc "stdcall" (This : ^ISynchronizeMutex) -> HRESULT),
    ReleaseMutex   : (proc "stdcall" (This : ^ISynchronizeMutex) -> HRESULT),
};

ISynchronizeMutex :: struct {
    lpVtbl : ^ISynchronizeMutexVtbl,
};

LPCANCELMETHODCALLS :: ^ICancelMethodCalls;

ICancelMethodCallsVtbl :: struct {
    QueryInterface : (proc "stdcall" (This : ^ICancelMethodCalls, riid : ^IID, ppvObject : ^rawptr) -> HRESULT),
    AddRef         : (proc "stdcall" (This : ^ICancelMethodCalls) -> ULONG),
    Release        : (proc "stdcall" (This : ^ICancelMethodCalls) -> ULONG),
    Cancel         : (proc "stdcall" (This : ^ICancelMethodCalls, ulSeconds : ULONG) -> HRESULT),
    TestCancel     : (proc "stdcall" (This : ^ICancelMethodCalls) -> HRESULT),
};

ICancelMethodCalls :: struct {
    lpVtbl : ^ICancelMethodCallsVtbl,
};

/* DCOM_CALL_STATE :: enum { */
DCOM_CALL_STATE :: _c.int;
    DCOM_NONE :: 0;
    DCOM_CALL_COMPLETE :: 0x1;
    DCOM_CALL_CANCELED :: 0x2;
/* } */
;

IAsyncManagerVtbl :: struct {
    QueryInterface : (proc "stdcall" (This : ^IAsyncManager, riid : ^IID, ppvObject : ^rawptr) -> HRESULT),
    AddRef         : (proc "stdcall" (This : ^IAsyncManager) -> ULONG),
    Release        : (proc "stdcall" (This : ^IAsyncManager) -> ULONG),
    CompleteCall   : (proc "stdcall" (This : ^IAsyncManager, Result : HRESULT) -> HRESULT),
    GetCallContext : (proc "stdcall" (This : ^IAsyncManager, riid : ^IID, pInterface : ^rawptr) -> HRESULT),
    GetState       : (proc "stdcall" (This : ^IAsyncManager, pulStateFlags : ^ULONG) -> HRESULT),
};

IAsyncManager :: struct {
    lpVtbl : ^IAsyncManagerVtbl,
};

ICallFactoryVtbl :: struct {
    QueryInterface : (proc "stdcall" (This : ^ICallFactory, riid : ^IID, ppvObject : ^rawptr) -> HRESULT),
    AddRef         : (proc "stdcall" (This : ^ICallFactory) -> ULONG),
    Release        : (proc "stdcall" (This : ^ICallFactory) -> ULONG),
    CreateCall     : (proc "stdcall" (This : ^ICallFactory, riid : ^IID, pCtrlUnk : ^IUnknown, riid2 : ^IID, ppv : ^^IUnknown) -> HRESULT),
};

ICallFactory :: struct {
    lpVtbl : ^ICallFactoryVtbl,
};

IRpcHelperVtbl :: struct {
    QueryInterface         : (proc "stdcall" (This : ^IRpcHelper, riid : ^IID, ppvObject : ^rawptr) -> HRESULT),
    AddRef                 : (proc "stdcall" (This : ^IRpcHelper) -> ULONG),
    Release                : (proc "stdcall" (This : ^IRpcHelper) -> ULONG),
    GetDCOMProtocolVersion : (proc "stdcall" (This : ^IRpcHelper, pComVersion : ^DWORD) -> HRESULT),
    GetIIDFromOBJREF       : (proc "stdcall" (This : ^IRpcHelper, pObjRef : rawptr, piid : ^^IID) -> HRESULT),
};

IRpcHelper :: struct {
    lpVtbl : ^IRpcHelperVtbl,
};

IReleaseMarshalBuffersVtbl :: struct {
    QueryInterface       : (proc "stdcall" (This : ^IReleaseMarshalBuffers, riid : ^IID, ppvObject : ^rawptr) -> HRESULT),
    AddRef               : (proc "stdcall" (This : ^IReleaseMarshalBuffers) -> ULONG),
    Release              : (proc "stdcall" (This : ^IReleaseMarshalBuffers) -> ULONG),
    ReleaseMarshalBuffer : (proc "stdcall" (This : ^IReleaseMarshalBuffers, pMsg : ^RPCOLEMESSAGE, dwFlags : DWORD, pChnl : ^IUnknown) -> HRESULT),
};

IReleaseMarshalBuffers :: struct {
    lpVtbl : ^IReleaseMarshalBuffersVtbl,
};

IWaitMultipleVtbl :: struct {
    QueryInterface : (proc "stdcall" (This : ^IWaitMultiple, riid : ^IID, ppvObject : ^rawptr) -> HRESULT),
    AddRef         : (proc "stdcall" (This : ^IWaitMultiple) -> ULONG),
    Release        : (proc "stdcall" (This : ^IWaitMultiple) -> ULONG),
    WaitMultiple   : (proc "stdcall" (This : ^IWaitMultiple, timeout : DWORD, pSync : ^^ISynchronize) -> HRESULT),
    AddSynchronize : (proc "stdcall" (This : ^IWaitMultiple, pSync : ^ISynchronize) -> HRESULT),
};

IWaitMultiple :: struct {
    lpVtbl : ^IWaitMultipleVtbl,
};

LPADDRTRACKINGCONTROL :: ^IAddrTrackingControl;

IAddrTrackingControlVtbl :: struct {
    QueryInterface                : (proc "stdcall" (This : ^IAddrTrackingControl, riid : ^IID, ppvObject : ^rawptr) -> HRESULT),
    AddRef                        : (proc "stdcall" (This : ^IAddrTrackingControl) -> ULONG),
    Release                       : (proc "stdcall" (This : ^IAddrTrackingControl) -> ULONG),
    EnableCOMDynamicAddrTracking  : (proc "stdcall" (This : ^IAddrTrackingControl) -> HRESULT),
    DisableCOMDynamicAddrTracking : (proc "stdcall" (This : ^IAddrTrackingControl) -> HRESULT),
};

IAddrTrackingControl :: struct {
    lpVtbl : ^IAddrTrackingControlVtbl,
};

LPADDREXCLUSIONCONTROL :: ^IAddrExclusionControl;

IAddrExclusionControlVtbl :: struct {
    QueryInterface              : (proc "stdcall" (This : ^IAddrExclusionControl, riid : ^IID, ppvObject : ^rawptr) -> HRESULT),
    AddRef                      : (proc "stdcall" (This : ^IAddrExclusionControl) -> ULONG),
    Release                     : (proc "stdcall" (This : ^IAddrExclusionControl) -> ULONG),
    GetCurrentAddrExclusionList : (proc "stdcall" (This : ^IAddrExclusionControl, riid : ^IID, ppEnumerator : ^rawptr) -> HRESULT),
    UpdateAddrExclusionList     : (proc "stdcall" (This : ^IAddrExclusionControl, pEnumerator : ^IUnknown) -> HRESULT),
};

IAddrExclusionControl :: struct {
    lpVtbl : ^IAddrExclusionControlVtbl,
};

IPipeByteVtbl :: struct {
    QueryInterface : (proc "stdcall" (This : ^IPipeByte, riid : ^IID, ppvObject : ^rawptr) -> HRESULT),
    AddRef         : (proc "stdcall" (This : ^IPipeByte) -> ULONG),
    Release        : (proc "stdcall" (This : ^IPipeByte) -> ULONG),
    Pull           : (proc "stdcall" (This : ^IPipeByte, buf : ^BYTE, cRequest : ULONG, pcReturned : ^ULONG) -> HRESULT),
    Push           : (proc "stdcall" (This : ^IPipeByte, buf : ^BYTE, cSent : ULONG) -> HRESULT),
};

IPipeByte :: struct {
    lpVtbl : ^IPipeByteVtbl,
};

AsyncIPipeByteVtbl :: struct {
    QueryInterface : (proc "stdcall" (This : ^AsyncIPipeByte, riid : ^IID, ppvObject : ^rawptr) -> HRESULT),
    AddRef         : (proc "stdcall" (This : ^AsyncIPipeByte) -> ULONG),
    Release        : (proc "stdcall" (This : ^AsyncIPipeByte) -> ULONG),
    Begin_Pull     : (proc "stdcall" (This : ^AsyncIPipeByte, cRequest : ULONG) -> HRESULT),
    Finish_Pull    : (proc "stdcall" (This : ^AsyncIPipeByte, buf : ^BYTE, pcReturned : ^ULONG) -> HRESULT),
    Begin_Push     : (proc "stdcall" (This : ^AsyncIPipeByte, buf : ^BYTE, cSent : ULONG) -> HRESULT),
    Finish_Push    : (proc "stdcall" (This : ^AsyncIPipeByte) -> HRESULT),
};

AsyncIPipeByte :: struct {
    lpVtbl : ^AsyncIPipeByteVtbl,
};

IPipeLongVtbl :: struct {
    QueryInterface : (proc "stdcall" (This : ^IPipeLong, riid : ^IID, ppvObject : ^rawptr) -> HRESULT),
    AddRef         : (proc "stdcall" (This : ^IPipeLong) -> ULONG),
    Release        : (proc "stdcall" (This : ^IPipeLong) -> ULONG),
    Pull           : (proc "stdcall" (This : ^IPipeLong, buf : ^LONG, cRequest : ULONG, pcReturned : ^ULONG) -> HRESULT),
    Push           : (proc "stdcall" (This : ^IPipeLong, buf : ^LONG, cSent : ULONG) -> HRESULT),
};

IPipeLong :: struct {
    lpVtbl : ^IPipeLongVtbl,
};

AsyncIPipeLongVtbl :: struct {
    QueryInterface : (proc "stdcall" (This : ^AsyncIPipeLong, riid : ^IID, ppvObject : ^rawptr) -> HRESULT),
    AddRef         : (proc "stdcall" (This : ^AsyncIPipeLong) -> ULONG),
    Release        : (proc "stdcall" (This : ^AsyncIPipeLong) -> ULONG),
    Begin_Pull     : (proc "stdcall" (This : ^AsyncIPipeLong, cRequest : ULONG) -> HRESULT),
    Finish_Pull    : (proc "stdcall" (This : ^AsyncIPipeLong, buf : ^LONG, pcReturned : ^ULONG) -> HRESULT),
    Begin_Push     : (proc "stdcall" (This : ^AsyncIPipeLong, buf : ^LONG, cSent : ULONG) -> HRESULT),
    Finish_Push    : (proc "stdcall" (This : ^AsyncIPipeLong) -> HRESULT),
};

AsyncIPipeLong :: struct {
    lpVtbl : ^AsyncIPipeLongVtbl,
};

IPipeDoubleVtbl :: struct {
    QueryInterface : (proc "stdcall" (This : ^IPipeDouble, riid : ^IID, ppvObject : ^rawptr) -> HRESULT),
    AddRef         : (proc "stdcall" (This : ^IPipeDouble) -> ULONG),
    Release        : (proc "stdcall" (This : ^IPipeDouble) -> ULONG),
    Pull           : (proc "stdcall" (This : ^IPipeDouble, buf : ^DOUBLE, cRequest : ULONG, pcReturned : ^ULONG) -> HRESULT),
    Push           : (proc "stdcall" (This : ^IPipeDouble, buf : ^DOUBLE, cSent : ULONG) -> HRESULT),
};

IPipeDouble :: struct {
    lpVtbl : ^IPipeDoubleVtbl,
};

AsyncIPipeDoubleVtbl :: struct {
    QueryInterface : (proc "stdcall" (This : ^AsyncIPipeDouble, riid : ^IID, ppvObject : ^rawptr) -> HRESULT),
    AddRef         : (proc "stdcall" (This : ^AsyncIPipeDouble) -> ULONG),
    Release        : (proc "stdcall" (This : ^AsyncIPipeDouble) -> ULONG),
    Begin_Pull     : (proc "stdcall" (This : ^AsyncIPipeDouble, cRequest : ULONG) -> HRESULT),
    Finish_Pull    : (proc "stdcall" (This : ^AsyncIPipeDouble, buf : ^DOUBLE, pcReturned : ^ULONG) -> HRESULT),
    Begin_Push     : (proc "stdcall" (This : ^AsyncIPipeDouble, buf : ^DOUBLE, cSent : ULONG) -> HRESULT),
    Finish_Push    : (proc "stdcall" (This : ^AsyncIPipeDouble) -> HRESULT),
};

AsyncIPipeDouble :: struct {
    lpVtbl : ^AsyncIPipeDoubleVtbl,
};

/* APTTYPEQUALIFIER :: enum { */
APTTYPEQUALIFIER :: _c.int;
    APTTYPEQUALIFIER_NONE :: 0;
    APTTYPEQUALIFIER_IMPLICIT_MTA :: 1;
    APTTYPEQUALIFIER_NA_ON_MTA :: 2;
    APTTYPEQUALIFIER_NA_ON_STA :: 3;
    APTTYPEQUALIFIER_NA_ON_IMPLICIT_MTA :: 4;
    APTTYPEQUALIFIER_NA_ON_MAINSTA :: 5;
    APTTYPEQUALIFIER_APPLICATION_STA :: 6;
    APTTYPEQUALIFIER_RESERVED_1 :: 7;
/* } */
;

/* APTTYPE :: enum { */
APTTYPE :: _c.int;
    APTTYPE_CURRENT :: -1;
    APTTYPE_STA :: 0;
    APTTYPE_MTA :: 1;
    APTTYPE_NA :: 2;
    APTTYPE_MAINSTA :: 3;
/* } */
;

/* THDTYPE :: enum { */
THDTYPE :: _c.int;
    THDTYPE_BLOCKMESSAGES :: 0;
    THDTYPE_PROCESSMESSAGES :: 1;
/* } */
;

APARTMENTID :: DWORD;

IComThreadingInfoVtbl :: struct {
    QueryInterface            : (proc "stdcall" (This : ^IComThreadingInfo, riid : ^IID, ppvObject : ^rawptr) -> HRESULT),
    AddRef                    : (proc "stdcall" (This : ^IComThreadingInfo) -> ULONG),
    Release                   : (proc "stdcall" (This : ^IComThreadingInfo) -> ULONG),
    GetCurrentApartmentType   : (proc "stdcall" (This : ^IComThreadingInfo, pAptType : ^APTTYPE) -> HRESULT),
    GetCurrentThreadType      : (proc "stdcall" (This : ^IComThreadingInfo, pThreadType : ^THDTYPE) -> HRESULT),
    GetCurrentLogicalThreadId : (proc "stdcall" (This : ^IComThreadingInfo, pguidLogicalThreadId : ^GUID) -> HRESULT),
    SetCurrentLogicalThreadId : (proc "stdcall" (This : ^IComThreadingInfo, rguid : ^GUID) -> HRESULT),
};

IComThreadingInfo :: struct {
    lpVtbl : ^IComThreadingInfoVtbl,
};

IProcessInitControlVtbl :: struct {
    QueryInterface          : (proc "stdcall" (This : ^IProcessInitControl, riid : ^IID, ppvObject : ^rawptr) -> HRESULT),
    AddRef                  : (proc "stdcall" (This : ^IProcessInitControl) -> ULONG),
    Release                 : (proc "stdcall" (This : ^IProcessInitControl) -> ULONG),
    ResetInitializerTimeout : (proc "stdcall" (This : ^IProcessInitControl, dwSecondsRemaining : DWORD) -> HRESULT),
};

IProcessInitControl :: struct {
    lpVtbl : ^IProcessInitControlVtbl,
};

IFastRundownVtbl :: struct {
    QueryInterface : (proc "stdcall" (This : ^IFastRundown, riid : ^IID, ppvObject : ^rawptr) -> HRESULT),
    AddRef         : (proc "stdcall" (This : ^IFastRundown) -> ULONG),
    Release        : (proc "stdcall" (This : ^IFastRundown) -> ULONG),
};

IFastRundown :: struct {
    lpVtbl : ^IFastRundownVtbl,
};

/* CO_MARSHALING_CONTEXT_ATTRIBUTES :: enum { */
CO_MARSHALING_CONTEXT_ATTRIBUTES :: _c.int;
    CO_MARSHALING_SOURCE_IS_APP_CONTAINER :: 0;
    CO_MARSHALING_CONTEXT_ATTRIBUTE_RESERVED_1 :: 0x80000000;
    CO_MARSHALING_CONTEXT_ATTRIBUTE_RESERVED_2 :: 0x80000001;
    CO_MARSHALING_CONTEXT_ATTRIBUTE_RESERVED_3 :: 0x80000002;
    CO_MARSHALING_CONTEXT_ATTRIBUTE_RESERVED_4 :: 0x80000003;
    CO_MARSHALING_CONTEXT_ATTRIBUTE_RESERVED_5 :: 0x80000004;
    CO_MARSHALING_CONTEXT_ATTRIBUTE_RESERVED_6 :: 0x80000005;
    CO_MARSHALING_CONTEXT_ATTRIBUTE_RESERVED_7 :: 0x80000006;
    CO_MARSHALING_CONTEXT_ATTRIBUTE_RESERVED_8 :: 0x80000007;
    CO_MARSHALING_CONTEXT_ATTRIBUTE_RESERVED_9 :: 0x80000008;
    CO_MARSHALING_CONTEXT_ATTRIBUTE_RESERVED_10 :: 0x80000009;
    CO_MARSHALING_CONTEXT_ATTRIBUTE_RESERVED_11 :: 0x8000000a;
    CO_MARSHALING_CONTEXT_ATTRIBUTE_RESERVED_12 :: 0x8000000b;
    CO_MARSHALING_CONTEXT_ATTRIBUTE_RESERVED_13 :: 0x8000000c;
    CO_MARSHALING_CONTEXT_ATTRIBUTE_RESERVED_14 :: 0x8000000d;
    CO_MARSHALING_CONTEXT_ATTRIBUTE_RESERVED_15 :: 0x8000000e;
    CO_MARSHALING_CONTEXT_ATTRIBUTE_RESERVED_16 :: 0x8000000f;
    CO_MARSHALING_CONTEXT_ATTRIBUTE_RESERVED_17 :: 0x80000010;
/* } */
;

IMarshalingStreamVtbl :: struct {
    QueryInterface                : (proc "stdcall" (This : ^IMarshalingStream, riid : ^IID, ppvObject : ^rawptr) -> HRESULT),
    AddRef                        : (proc "stdcall" (This : ^IMarshalingStream) -> ULONG),
    Release                       : (proc "stdcall" (This : ^IMarshalingStream) -> ULONG),
    Read                          : (proc "stdcall" (This : ^IMarshalingStream, pv : rawptr, cb : ULONG, pcbRead : ^ULONG) -> HRESULT),
    Write                         : (proc "stdcall" (This : ^IMarshalingStream, pv : rawptr, cb : ULONG, pcbWritten : ^ULONG) -> HRESULT),
    Seek                          : (proc "stdcall" (This : ^IMarshalingStream, dlibMove : LARGE_INTEGER, dwOrigin : DWORD, plibNewPosition : ^ULARGE_INTEGER) -> HRESULT),
    SetSize                       : (proc "stdcall" (This : ^IMarshalingStream, libNewSize : ULARGE_INTEGER) -> HRESULT),
    CopyTo                        : (proc "stdcall" (This : ^IMarshalingStream, pstm : ^IStream, cb : ULARGE_INTEGER, pcbRead : ^ULARGE_INTEGER, pcbWritten : ^ULARGE_INTEGER) -> HRESULT),
    Commit                        : (proc "stdcall" (This : ^IMarshalingStream, grfCommitFlags : DWORD) -> HRESULT),
    Revert                        : (proc "stdcall" (This : ^IMarshalingStream) -> HRESULT),
    LockRegion                    : (proc "stdcall" (This : ^IMarshalingStream, libOffset : ULARGE_INTEGER, cb : ULARGE_INTEGER, dwLockType : DWORD) -> HRESULT),
    UnlockRegion                  : (proc "stdcall" (This : ^IMarshalingStream, libOffset : ULARGE_INTEGER, cb : ULARGE_INTEGER, dwLockType : DWORD) -> HRESULT),
    Stat                          : (proc "stdcall" (This : ^IMarshalingStream, pstatstg : ^STATSTG, grfStatFlag : DWORD) -> HRESULT),
    Clone                         : (proc "stdcall" (This : ^IMarshalingStream, ppstm : ^^IStream) -> HRESULT),
    GetMarshalingContextAttribute : (proc "stdcall" (This : ^IMarshalingStream, attribute : CO_MARSHALING_CONTEXT_ATTRIBUTES, pAttributeValue : ^ULONG_PTR) -> HRESULT),
};

IMarshalingStream :: struct {
    lpVtbl : ^IMarshalingStreamVtbl,
};

IAgileReferenceVtbl :: struct {
    QueryInterface : (proc "stdcall" (This : ^IAgileReference, riid : ^IID, ppvObject : ^rawptr) -> HRESULT),
    AddRef         : (proc "stdcall" (This : ^IAgileReference) -> ULONG),
    Release        : (proc "stdcall" (This : ^IAgileReference) -> ULONG),
    Resolve        : (proc "stdcall" (This : ^IAgileReference, riid : ^IID, ppvObjectReference : ^rawptr) -> HRESULT),
};

IAgileReference :: struct {
    lpVtbl : ^IAgileReferenceVtbl,
};

ServerInformation :: struct {
    dwServerPid       : DWORD,
    dwServerTid       : DWORD,
    ui64ServerAddress : UINT64,
};
PServerInformation :: ^ServerInformation;

CO_MTA_USAGE_COOKIE__ :: struct {
    unused : _c.int,
};

CO_MTA_USAGE_COOKIE :: ^CO_MTA_USAGE_COOKIE__;

/* STDMSHLFLAGS :: enum { */
STDMSHLFLAGS :: _c.int;
    SMEXF_SERVER :: 0x01;
    SMEXF_HANDLER :: 0x02;
/* } */
;

PROPVARIANT :: struct {};

/* COWAIT_FLAGS :: enum { */
COWAIT_FLAGS :: _c.int;
    COWAIT_DEFAULT :: 0;
    COWAIT_WAITALL :: 1;
    COWAIT_ALERTABLE :: 2;
    COWAIT_INPUTAVAILABLE :: 4;
    COWAIT_DISPATCH_CALLS :: 8;
    COWAIT_DISPATCH_WINDOW_MESSAGES :: 0x10;
/* } */
;

/* CWMO_FLAGS :: enum { */
CWMO_FLAGS :: _c.int;
    CWMO_DEFAULT :: 0;
    CWMO_DISPATCH_CALLS :: 1;
    CWMO_DISPATCH_WINDOW_MESSAGES :: 2;
/* } */
;

/* AgileReferenceOptions :: enum { */
AgileReferenceOptions :: _c.int;
    AGILEREFERENCE_DEFAULT :: 0;
    AGILEREFERENCE_DELAYEDMARSHAL :: 1;
/* } */
;

LPFNGETCLASSOBJECT :: (proc "stdcall" (^IID, ^IID, ^LPVOID) -> HRESULT);

LPFNCANUNLOADNOW :: (proc "stdcall" () -> HRESULT);

;

;

;

;

;

;

;

;

;

;

;

;

;

;

;

;

;

;

;

;

;

;

;

;

;

;

;

;

;

;

;

;

;

;

;

;

;

;

;

;

LPMALLOCSPY :: ^IMallocSpy;

IMallocSpyVtbl :: struct {
    QueryInterface   : (proc "stdcall" (This : ^IMallocSpy, riid : ^IID, ppvObject : ^rawptr) -> HRESULT),
    AddRef           : (proc "stdcall" (This : ^IMallocSpy) -> ULONG),
    Release          : (proc "stdcall" (This : ^IMallocSpy) -> ULONG),
    PreAlloc         : (proc "stdcall" (This : ^IMallocSpy, cbRequest : SIZE_T) -> SIZE_T),
    PostAlloc        : (proc "stdcall" (This : ^IMallocSpy, pActual : rawptr) -> rawptr),
    PreFree          : (proc "stdcall" (This : ^IMallocSpy, pRequest : rawptr, fSpyed : BOOL) -> rawptr),
    PostFree         : proc "stdcall" (This : ^IMallocSpy, fSpyed : BOOL),
    PreRealloc       : (proc "stdcall" (This : ^IMallocSpy, pRequest : rawptr, cbRequest : SIZE_T, ppNewRequest : ^rawptr, fSpyed : BOOL) -> SIZE_T),
    PostRealloc      : (proc "stdcall" (This : ^IMallocSpy, pActual : rawptr, fSpyed : BOOL) -> rawptr),
    PreGetSize       : (proc "stdcall" (This : ^IMallocSpy, pRequest : rawptr, fSpyed : BOOL) -> rawptr),
    PostGetSize      : (proc "stdcall" (This : ^IMallocSpy, cbActual : SIZE_T, fSpyed : BOOL) -> SIZE_T),
    PreDidAlloc      : (proc "stdcall" (This : ^IMallocSpy, pRequest : rawptr, fSpyed : BOOL) -> rawptr),
    PostDidAlloc     : (proc "stdcall" (This : ^IMallocSpy, pRequest : rawptr, fSpyed : BOOL, fActual : _c.int) -> _c.int),
    PreHeapMinimize  : proc "stdcall" (This : ^IMallocSpy),
    PostHeapMinimize : proc "stdcall" (This : ^IMallocSpy),
};

IMallocSpy :: struct {
    lpVtbl : ^IMallocSpyVtbl,
};

LPBC :: ^IBindCtx;

LPBINDCTX :: ^IBindCtx;

BIND_OPTS :: struct {
    cbStruct            : DWORD,
    grfFlags            : DWORD,
    grfMode             : DWORD,
    dwTickCountDeadline : DWORD,
};

LPBIND_OPTS :: ^BIND_OPTS;

BIND_OPTS2 :: struct {
    cbStruct            : DWORD,
    grfFlags            : DWORD,
    grfMode             : DWORD,
    dwTickCountDeadline : DWORD,
    dwTrackFlags        : DWORD,
    dwClassContext      : DWORD,
    locale              : LCID,
    pServerInfo         : ^COSERVERINFO,
};

LPBIND_OPTS2 :: ^BIND_OPTS2;

BIND_OPTS3 :: struct {
    cbStruct            : DWORD,
    grfFlags            : DWORD,
    grfMode             : DWORD,
    dwTickCountDeadline : DWORD,
    dwTrackFlags        : DWORD,
    dwClassContext      : DWORD,
    locale              : LCID,
    pServerInfo         : ^COSERVERINFO,
    hwnd                : HWND,
};

LPBIND_OPTS3 :: ^BIND_OPTS3;

/* BIND_FLAGS :: enum { */
BIND_FLAGS :: _c.int;
    BIND_MAYBOTHERUSER :: 1;
    BIND_JUSTTESTEXISTENCE :: 2;
/* } */
;

IBindCtxVtbl :: struct {
    QueryInterface        : (proc "stdcall" (This : ^IBindCtx, riid : ^IID, ppvObject : ^rawptr) -> HRESULT),
    AddRef                : (proc "stdcall" (This : ^IBindCtx) -> ULONG),
    Release               : (proc "stdcall" (This : ^IBindCtx) -> ULONG),
    RegisterObjectBound   : (proc "stdcall" (This : ^IBindCtx, punk : ^IUnknown) -> HRESULT),
    RevokeObjectBound     : (proc "stdcall" (This : ^IBindCtx, punk : ^IUnknown) -> HRESULT),
    ReleaseBoundObjects   : (proc "stdcall" (This : ^IBindCtx) -> HRESULT),
    SetBindOptions        : (proc "stdcall" (This : ^IBindCtx, pbindopts : ^BIND_OPTS) -> HRESULT),
    GetBindOptions        : (proc "stdcall" (This : ^IBindCtx, pbindopts : ^BIND_OPTS) -> HRESULT),
    GetRunningObjectTable : (proc "stdcall" (This : ^IBindCtx, pprot : ^^IRunningObjectTable) -> HRESULT),
    RegisterObjectParam   : (proc "stdcall" (This : ^IBindCtx, pszKey : LPOLESTR, punk : ^IUnknown) -> HRESULT),
    GetObjectParam        : (proc "stdcall" (This : ^IBindCtx, pszKey : LPOLESTR, ppunk : ^^IUnknown) -> HRESULT),
    EnumObjectParam       : (proc "stdcall" (This : ^IBindCtx, ppenum : ^^IEnumString) -> HRESULT),
    RevokeObjectParam     : (proc "stdcall" (This : ^IBindCtx, pszKey : LPOLESTR) -> HRESULT),
};

IBindCtx :: struct {
    lpVtbl : ^IBindCtxVtbl,
};

LPENUMMONIKER :: ^IEnumMoniker;

IEnumMonikerVtbl :: struct {
    QueryInterface : (proc "stdcall" (This : ^IEnumMoniker, riid : ^IID, ppvObject : ^rawptr) -> HRESULT),
    AddRef         : (proc "stdcall" (This : ^IEnumMoniker) -> ULONG),
    Release        : (proc "stdcall" (This : ^IEnumMoniker) -> ULONG),
    Next           : (proc "stdcall" (This : ^IEnumMoniker, celt : ULONG, rgelt : ^^IMoniker, pceltFetched : ^ULONG) -> HRESULT),
    Skip           : (proc "stdcall" (This : ^IEnumMoniker, celt : ULONG) -> HRESULT),
    Reset          : (proc "stdcall" (This : ^IEnumMoniker) -> HRESULT),
    Clone          : (proc "stdcall" (This : ^IEnumMoniker, ppenum : ^^IEnumMoniker) -> HRESULT),
};

IEnumMoniker :: struct {
    lpVtbl : ^IEnumMonikerVtbl,
};

LPRUNNABLEOBJECT :: ^IRunnableObject;

IRunnableObjectVtbl :: struct {
    QueryInterface     : (proc "stdcall" (This : ^IRunnableObject, riid : ^IID, ppvObject : ^rawptr) -> HRESULT),
    AddRef             : (proc "stdcall" (This : ^IRunnableObject) -> ULONG),
    Release            : (proc "stdcall" (This : ^IRunnableObject) -> ULONG),
    GetRunningClass    : (proc "stdcall" (This : ^IRunnableObject, lpClsid : LPCLSID) -> HRESULT),
    Run                : (proc "stdcall" (This : ^IRunnableObject, pbc : LPBINDCTX) -> HRESULT),
    IsRunning          : (proc "stdcall" (This : ^IRunnableObject) -> BOOL),
    LockRunning        : (proc "stdcall" (This : ^IRunnableObject, fLock : BOOL, fLastUnlockCloses : BOOL) -> HRESULT),
    SetContainedObject : (proc "stdcall" (This : ^IRunnableObject, fContained : BOOL) -> HRESULT),
};

IRunnableObject :: struct {
    lpVtbl : ^IRunnableObjectVtbl,
};

LPRUNNINGOBJECTTABLE :: ^IRunningObjectTable;

IRunningObjectTableVtbl :: struct {
    QueryInterface      : (proc "stdcall" (This : ^IRunningObjectTable, riid : ^IID, ppvObject : ^rawptr) -> HRESULT),
    AddRef              : (proc "stdcall" (This : ^IRunningObjectTable) -> ULONG),
    Release             : (proc "stdcall" (This : ^IRunningObjectTable) -> ULONG),
    Register            : (proc "stdcall" (This : ^IRunningObjectTable, grfFlags : DWORD, punkObject : ^IUnknown, pmkObjectName : ^IMoniker, pdwRegister : ^DWORD) -> HRESULT),
    Revoke              : (proc "stdcall" (This : ^IRunningObjectTable, dwRegister : DWORD) -> HRESULT),
    IsRunning           : (proc "stdcall" (This : ^IRunningObjectTable, pmkObjectName : ^IMoniker) -> HRESULT),
    GetObjectA          : (proc "stdcall" (This : ^IRunningObjectTable, pmkObjectName : ^IMoniker, ppunkObject : ^^IUnknown) -> HRESULT),
    NoteChangeTime      : (proc "stdcall" (This : ^IRunningObjectTable, dwRegister : DWORD, pfiletime : ^FILETIME) -> HRESULT),
    GetTimeOfLastChange : (proc "stdcall" (This : ^IRunningObjectTable, pmkObjectName : ^IMoniker, pfiletime : ^FILETIME) -> HRESULT),
    EnumRunning         : (proc "stdcall" (This : ^IRunningObjectTable, ppenumMoniker : ^^IEnumMoniker) -> HRESULT),
};

IRunningObjectTable :: struct {
    lpVtbl : ^IRunningObjectTableVtbl,
};

LPPERSIST :: ^IPersist;

IPersistVtbl :: struct {
    QueryInterface : (proc "stdcall" (This : ^IPersist, riid : ^IID, ppvObject : ^rawptr) -> HRESULT),
    AddRef         : (proc "stdcall" (This : ^IPersist) -> ULONG),
    Release        : (proc "stdcall" (This : ^IPersist) -> ULONG),
    GetClassID     : (proc "stdcall" (This : ^IPersist, pClassID : ^CLSID) -> HRESULT),
};

IPersist :: struct {
    lpVtbl : ^IPersistVtbl,
};

LPPERSISTSTREAM :: ^IPersistStream;

IPersistStreamVtbl :: struct {
    QueryInterface : (proc "stdcall" (This : ^IPersistStream, riid : ^IID, ppvObject : ^rawptr) -> HRESULT),
    AddRef         : (proc "stdcall" (This : ^IPersistStream) -> ULONG),
    Release        : (proc "stdcall" (This : ^IPersistStream) -> ULONG),
    GetClassID     : (proc "stdcall" (This : ^IPersistStream, pClassID : ^CLSID) -> HRESULT),
    IsDirty        : (proc "stdcall" (This : ^IPersistStream) -> HRESULT),
    Load           : (proc "stdcall" (This : ^IPersistStream, pStm : ^IStream) -> HRESULT),
    Save           : (proc "stdcall" (This : ^IPersistStream, pStm : ^IStream, fClearDirty : BOOL) -> HRESULT),
    GetSizeMax     : (proc "stdcall" (This : ^IPersistStream, pcbSize : ^ULARGE_INTEGER) -> HRESULT),
};

IPersistStream :: struct {
    lpVtbl : ^IPersistStreamVtbl,
};

LPMONIKER :: ^IMoniker;

/* MKSYS :: enum { */
MKSYS :: _c.int;
    MKSYS_NONE :: 0;
    MKSYS_GENERICCOMPOSITE :: 1;
    MKSYS_FILEMONIKER :: 2;
    MKSYS_ANTIMONIKER :: 3;
    MKSYS_ITEMMONIKER :: 4;
    MKSYS_POINTERMONIKER :: 5;
    MKSYS_CLASSMONIKER :: 7;
    MKSYS_OBJREFMONIKER :: 8;
    MKSYS_SESSIONMONIKER :: 9;
    MKSYS_LUAMONIKER :: 10;
/* } */
;

/* MKRREDUCE :: enum { */
MKRREDUCE :: _c.int;
    MKRREDUCE_ONE :: (3 << 16);
    MKRREDUCE_TOUSER :: (2 << 16);
    MKRREDUCE_THROUGHUSER :: (1 << 16);
    MKRREDUCE_ALL :: 0;
/* } */
;

IMonikerVtbl :: struct {
    QueryInterface      : (proc "stdcall" (This : ^IMoniker, riid : ^IID, ppvObject : ^rawptr) -> HRESULT),
    AddRef              : (proc "stdcall" (This : ^IMoniker) -> ULONG),
    Release             : (proc "stdcall" (This : ^IMoniker) -> ULONG),
    GetClassID          : (proc "stdcall" (This : ^IMoniker, pClassID : ^CLSID) -> HRESULT),
    IsDirty             : (proc "stdcall" (This : ^IMoniker) -> HRESULT),
    Load                : (proc "stdcall" (This : ^IMoniker, pStm : ^IStream) -> HRESULT),
    Save                : (proc "stdcall" (This : ^IMoniker, pStm : ^IStream, fClearDirty : BOOL) -> HRESULT),
    GetSizeMax          : (proc "stdcall" (This : ^IMoniker, pcbSize : ^ULARGE_INTEGER) -> HRESULT),
    BindToObject        : (proc "stdcall" (This : ^IMoniker, pbc : ^IBindCtx, pmkToLeft : ^IMoniker, riidResult : ^IID, ppvResult : ^rawptr) -> HRESULT),
    BindToStorage       : (proc "stdcall" (This : ^IMoniker, pbc : ^IBindCtx, pmkToLeft : ^IMoniker, riid : ^IID, ppvObj : ^rawptr) -> HRESULT),
    Reduce              : (proc "stdcall" (This : ^IMoniker, pbc : ^IBindCtx, dwReduceHowFar : DWORD, ppmkToLeft : ^^IMoniker, ppmkReduced : ^^IMoniker) -> HRESULT),
    ComposeWith         : (proc "stdcall" (This : ^IMoniker, pmkRight : ^IMoniker, fOnlyIfNotGeneric : BOOL, ppmkComposite : ^^IMoniker) -> HRESULT),
    Enum                : (proc "stdcall" (This : ^IMoniker, fForward : BOOL, ppenumMoniker : ^^IEnumMoniker) -> HRESULT),
    IsEqual             : (proc "stdcall" (This : ^IMoniker, pmkOtherMoniker : ^IMoniker) -> HRESULT),
    Hash                : (proc "stdcall" (This : ^IMoniker, pdwHash : ^DWORD) -> HRESULT),
    IsRunning           : (proc "stdcall" (This : ^IMoniker, pbc : ^IBindCtx, pmkToLeft : ^IMoniker, pmkNewlyRunning : ^IMoniker) -> HRESULT),
    GetTimeOfLastChange : (proc "stdcall" (This : ^IMoniker, pbc : ^IBindCtx, pmkToLeft : ^IMoniker, pFileTime : ^FILETIME) -> HRESULT),
    Inverse             : (proc "stdcall" (This : ^IMoniker, ppmk : ^^IMoniker) -> HRESULT),
    CommonPrefixWith    : (proc "stdcall" (This : ^IMoniker, pmkOther : ^IMoniker, ppmkPrefix : ^^IMoniker) -> HRESULT),
    RelativePathTo      : (proc "stdcall" (This : ^IMoniker, pmkOther : ^IMoniker, ppmkRelPath : ^^IMoniker) -> HRESULT),
    GetDisplayName      : (proc "stdcall" (This : ^IMoniker, pbc : ^IBindCtx, pmkToLeft : ^IMoniker, ppszDisplayName : ^LPOLESTR) -> HRESULT),
    ParseDisplayName    : (proc "stdcall" (This : ^IMoniker, pbc : ^IBindCtx, pmkToLeft : ^IMoniker, pszDisplayName : LPOLESTR, pchEaten : ^ULONG, ppmkOut : ^^IMoniker) -> HRESULT),
    IsSystemMoniker     : (proc "stdcall" (This : ^IMoniker, pdwMksys : ^DWORD) -> HRESULT),
};

IMoniker :: struct {
    lpVtbl : ^IMonikerVtbl,
};

IROTDataVtbl :: struct {
    QueryInterface    : (proc "stdcall" (This : ^IROTData, riid : ^IID, ppvObject : ^rawptr) -> HRESULT),
    AddRef            : (proc "stdcall" (This : ^IROTData) -> ULONG),
    Release           : (proc "stdcall" (This : ^IROTData) -> ULONG),
    GetComparisonData : (proc "stdcall" (This : ^IROTData, pbData : ^byte, cbMax : ULONG, pcbData : ^ULONG) -> HRESULT),
};

IROTData :: struct {
    lpVtbl : ^IROTDataVtbl,
};

LPENUMSTATSTG :: ^IEnumSTATSTG;

IEnumSTATSTGVtbl :: struct {
    QueryInterface : (proc "stdcall" (This : ^IEnumSTATSTG, riid : ^IID, ppvObject : ^rawptr) -> HRESULT),
    AddRef         : (proc "stdcall" (This : ^IEnumSTATSTG) -> ULONG),
    Release        : (proc "stdcall" (This : ^IEnumSTATSTG) -> ULONG),
    Next           : (proc "stdcall" (This : ^IEnumSTATSTG, celt : ULONG, rgelt : ^STATSTG, pceltFetched : ^ULONG) -> HRESULT),
    Skip           : (proc "stdcall" (This : ^IEnumSTATSTG, celt : ULONG) -> HRESULT),
    Reset          : (proc "stdcall" (This : ^IEnumSTATSTG) -> HRESULT),
    Clone          : (proc "stdcall" (This : ^IEnumSTATSTG, ppenum : ^^IEnumSTATSTG) -> HRESULT),
};

IEnumSTATSTG :: struct {
    lpVtbl : ^IEnumSTATSTGVtbl,
};

LPSTORAGE :: ^IStorage;

RemSNB :: struct {
    ulCntStr  : ULONG,
    ulCntChar : ULONG,
    rgString  : [1]OLECHAR,
};

wireSNB :: ^RemSNB;

SNB :: ^LPOLESTR;

IStorageVtbl :: struct {
    QueryInterface  : (proc "stdcall" (This : ^IStorage, riid : ^IID, ppvObject : ^rawptr) -> HRESULT),
    AddRef          : (proc "stdcall" (This : ^IStorage) -> ULONG),
    Release         : (proc "stdcall" (This : ^IStorage) -> ULONG),
    CreateStream    : (proc "stdcall" (This : ^IStorage, pwcsName : ^OLECHAR, grfMode : DWORD, reserved1 : DWORD, reserved2 : DWORD, ppstm : ^^IStream) -> HRESULT),
    OpenStream      : (proc "stdcall" (This : ^IStorage, pwcsName : ^OLECHAR, reserved1 : rawptr, grfMode : DWORD, reserved2 : DWORD, ppstm : ^^IStream) -> HRESULT),
    CreateStorage   : (proc "stdcall" (This : ^IStorage, pwcsName : ^OLECHAR, grfMode : DWORD, reserved1 : DWORD, reserved2 : DWORD, ppstg : ^^IStorage) -> HRESULT),
    OpenStorage     : (proc "stdcall" (This : ^IStorage, pwcsName : ^OLECHAR, pstgPriority : ^IStorage, grfMode : DWORD, snbExclude : SNB, reserved : DWORD, ppstg : ^^IStorage) -> HRESULT),
    CopyTo          : (proc "stdcall" (This : ^IStorage, ciidExclude : DWORD, rgiidExclude : ^IID, snbExclude : SNB, pstgDest : ^IStorage) -> HRESULT),
    MoveElementTo   : (proc "stdcall" (This : ^IStorage, pwcsName : ^OLECHAR, pstgDest : ^IStorage, pwcsNewName : ^OLECHAR, grfFlags : DWORD) -> HRESULT),
    Commit          : (proc "stdcall" (This : ^IStorage, grfCommitFlags : DWORD) -> HRESULT),
    Revert          : (proc "stdcall" (This : ^IStorage) -> HRESULT),
    EnumElements    : (proc "stdcall" (This : ^IStorage, reserved1 : DWORD, reserved2 : rawptr, reserved3 : DWORD, ppenum : ^^IEnumSTATSTG) -> HRESULT),
    DestroyElement  : (proc "stdcall" (This : ^IStorage, pwcsName : ^OLECHAR) -> HRESULT),
    RenameElement   : (proc "stdcall" (This : ^IStorage, pwcsOldName : ^OLECHAR, pwcsNewName : ^OLECHAR) -> HRESULT),
    SetElementTimes : (proc "stdcall" (This : ^IStorage, pwcsName : ^OLECHAR, pctime : ^FILETIME, patime : ^FILETIME, pmtime : ^FILETIME) -> HRESULT),
    SetClass        : (proc "stdcall" (This : ^IStorage, clsid : ^IID) -> HRESULT),
    SetStateBits    : (proc "stdcall" (This : ^IStorage, grfStateBits : DWORD, grfMask : DWORD) -> HRESULT),
    Stat            : (proc "stdcall" (This : ^IStorage, pstatstg : ^STATSTG, grfStatFlag : DWORD) -> HRESULT),
};

IStorage :: struct {
    lpVtbl : ^IStorageVtbl,
};

LPPERSISTFILE :: ^IPersistFile;

IPersistFileVtbl :: struct {
    QueryInterface : (proc "stdcall" (This : ^IPersistFile, riid : ^IID, ppvObject : ^rawptr) -> HRESULT),
    AddRef         : (proc "stdcall" (This : ^IPersistFile) -> ULONG),
    Release        : (proc "stdcall" (This : ^IPersistFile) -> ULONG),
    GetClassID     : (proc "stdcall" (This : ^IPersistFile, pClassID : ^CLSID) -> HRESULT),
    IsDirty        : (proc "stdcall" (This : ^IPersistFile) -> HRESULT),
    Load           : (proc "stdcall" (This : ^IPersistFile, pszFileName : LPCOLESTR, dwMode : DWORD) -> HRESULT),
    Save           : (proc "stdcall" (This : ^IPersistFile, pszFileName : LPCOLESTR, fRemember : BOOL) -> HRESULT),
    SaveCompleted  : (proc "stdcall" (This : ^IPersistFile, pszFileName : LPCOLESTR) -> HRESULT),
    GetCurFile     : (proc "stdcall" (This : ^IPersistFile, ppszFileName : ^LPOLESTR) -> HRESULT),
};

IPersistFile :: struct {
    lpVtbl : ^IPersistFileVtbl,
};

LPPERSISTSTORAGE :: ^IPersistStorage;

IPersistStorageVtbl :: struct {
    QueryInterface  : (proc "stdcall" (This : ^IPersistStorage, riid : ^IID, ppvObject : ^rawptr) -> HRESULT),
    AddRef          : (proc "stdcall" (This : ^IPersistStorage) -> ULONG),
    Release         : (proc "stdcall" (This : ^IPersistStorage) -> ULONG),
    GetClassID      : (proc "stdcall" (This : ^IPersistStorage, pClassID : ^CLSID) -> HRESULT),
    IsDirty         : (proc "stdcall" (This : ^IPersistStorage) -> HRESULT),
    InitNew         : (proc "stdcall" (This : ^IPersistStorage, pStg : ^IStorage) -> HRESULT),
    Load            : (proc "stdcall" (This : ^IPersistStorage, pStg : ^IStorage) -> HRESULT),
    Save            : (proc "stdcall" (This : ^IPersistStorage, pStgSave : ^IStorage, fSameAsLoad : BOOL) -> HRESULT),
    SaveCompleted   : (proc "stdcall" (This : ^IPersistStorage, pStgNew : ^IStorage) -> HRESULT),
    HandsOffStorage : (proc "stdcall" (This : ^IPersistStorage) -> HRESULT),
};

IPersistStorage :: struct {
    lpVtbl : ^IPersistStorageVtbl,
};

LPLOCKBYTES :: ^ILockBytes;

ILockBytesVtbl :: struct {
    QueryInterface : (proc "stdcall" (This : ^ILockBytes, riid : ^IID, ppvObject : ^rawptr) -> HRESULT),
    AddRef         : (proc "stdcall" (This : ^ILockBytes) -> ULONG),
    Release        : (proc "stdcall" (This : ^ILockBytes) -> ULONG),
    ReadAt         : (proc "stdcall" (This : ^ILockBytes, ulOffset : ULARGE_INTEGER, pv : rawptr, cb : ULONG, pcbRead : ^ULONG) -> HRESULT),
    WriteAt        : (proc "stdcall" (This : ^ILockBytes, ulOffset : ULARGE_INTEGER, pv : rawptr, cb : ULONG, pcbWritten : ^ULONG) -> HRESULT),
    Flush          : (proc "stdcall" (This : ^ILockBytes) -> HRESULT),
    SetSize        : (proc "stdcall" (This : ^ILockBytes, cb : ULARGE_INTEGER) -> HRESULT),
    LockRegion     : (proc "stdcall" (This : ^ILockBytes, libOffset : ULARGE_INTEGER, cb : ULARGE_INTEGER, dwLockType : DWORD) -> HRESULT),
    UnlockRegion   : (proc "stdcall" (This : ^ILockBytes, libOffset : ULARGE_INTEGER, cb : ULARGE_INTEGER, dwLockType : DWORD) -> HRESULT),
    Stat           : (proc "stdcall" (This : ^ILockBytes, pstatstg : ^STATSTG, grfStatFlag : DWORD) -> HRESULT),
};

ILockBytes :: struct {
    lpVtbl : ^ILockBytesVtbl,
};

LPENUMFORMATETC :: ^IEnumFORMATETC;

DVTARGETDEVICE :: struct {
    tdSize             : DWORD,
    tdDriverNameOffset : WORD,
    tdDeviceNameOffset : WORD,
    tdPortNameOffset   : WORD,
    tdExtDevmodeOffset : WORD,
    tdData             : [1]BYTE,
};

LPCLIPFORMAT :: ^CLIPFORMAT;

FORMATETC :: struct {
    cfFormat : CLIPFORMAT,
    ptd      : ^DVTARGETDEVICE,
    dwAspect : DWORD,
    lindex   : LONG,
    tymed    : DWORD,
};

LPFORMATETC :: ^FORMATETC;

IEnumFORMATETCVtbl :: struct {
    QueryInterface : (proc "stdcall" (This : ^IEnumFORMATETC, riid : ^IID, ppvObject : ^rawptr) -> HRESULT),
    AddRef         : (proc "stdcall" (This : ^IEnumFORMATETC) -> ULONG),
    Release        : (proc "stdcall" (This : ^IEnumFORMATETC) -> ULONG),
    Next           : (proc "stdcall" (This : ^IEnumFORMATETC, celt : ULONG, rgelt : ^FORMATETC, pceltFetched : ^ULONG) -> HRESULT),
    Skip           : (proc "stdcall" (This : ^IEnumFORMATETC, celt : ULONG) -> HRESULT),
    Reset          : (proc "stdcall" (This : ^IEnumFORMATETC) -> HRESULT),
    Clone          : (proc "stdcall" (This : ^IEnumFORMATETC, ppenum : ^^IEnumFORMATETC) -> HRESULT),
};

IEnumFORMATETC :: struct {
    lpVtbl : ^IEnumFORMATETCVtbl,
};

LPENUMSTATDATA :: ^IEnumSTATDATA;

/* ADVF :: enum { */
ADVF :: _c.int;
    ADVF_NODATA :: 1;
    ADVF_PRIMEFIRST :: 2;
    ADVF_ONLYONCE :: 4;
    ADVF_DATAONSTOP :: 64;
    ADVFCACHE_NOHANDLER :: 8;
    ADVFCACHE_FORCEBUILTIN :: 16;
    ADVFCACHE_ONSAVE :: 32;
/* } */
;

STATDATA :: struct {
    formatetc    : FORMATETC,
    advf         : DWORD,
    pAdvSink     : ^IAdviseSink,
    dwConnection : DWORD,
};

LPSTATDATA :: ^STATDATA;

IEnumSTATDATAVtbl :: struct {
    QueryInterface : (proc "stdcall" (This : ^IEnumSTATDATA, riid : ^IID, ppvObject : ^rawptr) -> HRESULT),
    AddRef         : (proc "stdcall" (This : ^IEnumSTATDATA) -> ULONG),
    Release        : (proc "stdcall" (This : ^IEnumSTATDATA) -> ULONG),
    Next           : (proc "stdcall" (This : ^IEnumSTATDATA, celt : ULONG, rgelt : ^STATDATA, pceltFetched : ^ULONG) -> HRESULT),
    Skip           : (proc "stdcall" (This : ^IEnumSTATDATA, celt : ULONG) -> HRESULT),
    Reset          : (proc "stdcall" (This : ^IEnumSTATDATA) -> HRESULT),
    Clone          : (proc "stdcall" (This : ^IEnumSTATDATA, ppenum : ^^IEnumSTATDATA) -> HRESULT),
};

IEnumSTATDATA :: struct {
    lpVtbl : ^IEnumSTATDATAVtbl,
};

LPROOTSTORAGE :: ^IRootStorage;

IRootStorageVtbl :: struct {
    QueryInterface : (proc "stdcall" (This : ^IRootStorage, riid : ^IID, ppvObject : ^rawptr) -> HRESULT),
    AddRef         : (proc "stdcall" (This : ^IRootStorage) -> ULONG),
    Release        : (proc "stdcall" (This : ^IRootStorage) -> ULONG),
    SwitchToFile   : (proc "stdcall" (This : ^IRootStorage, pszFile : LPOLESTR) -> HRESULT),
};

IRootStorage :: struct {
    lpVtbl : ^IRootStorageVtbl,
};

LPADVISESINK :: ^IAdviseSink;

/* TYMED :: enum { */
TYMED :: _c.int;
    TYMED_HGLOBAL :: 1;
    TYMED_FILE :: 2;
    TYMED_ISTREAM :: 4;
    TYMED_ISTORAGE :: 8;
    TYMED_GDI :: 16;
    TYMED_MFPICT :: 32;
    TYMED_ENHMF :: 64;
    TYMED_NULL :: 0;
/* } */
;

RemSTGMEDIUM :: struct {
    tymed          : DWORD,
    dwHandleType   : DWORD,
    pData          : ULONG,
    pUnkForRelease : ULONG,
    cbData         : ULONG,
    data           : [1]byte,
};

uSTGMEDIUM :: struct {
    tymed          : DWORD,
    u : struct #raw_union {
        hBitmap       : HBITMAP,
        hMetaFilePict : HMETAFILEPICT,
        hEnhMetaFile  : HENHMETAFILE,
        hGlobal       : HGLOBAL,
        lpszFileName  : LPOLESTR,
        pstm          : ^IStream,
        pstg          : ^IStorage,
    },
    pUnkForRelease : ^IUnknown,
};

GDI_OBJECT :: struct {
    ObjectType : DWORD,
    u : struct #raw_union {
        hBitmap  : wireHBITMAP,
        hPalette : wireHPALETTE,
        hGeneric : wireHGLOBAL,
    },
};

userSTGMEDIUM :: struct {
    u : struct {
        tymed : DWORD,
        u : struct #raw_union {
            hMetaFilePict : wireHMETAFILEPICT,
            hHEnhMetaFile : wireHENHMETAFILE,
            hGdiHandle    : ^GDI_OBJECT,
            hGlobal       : wireHGLOBAL,
            lpszFileName  : LPOLESTR,
            pstm          : ^BYTE_BLOB,
            pstg          : ^BYTE_BLOB,
        },
    },
    pUnkForRelease : ^IUnknown,
};

wireSTGMEDIUM :: ^userSTGMEDIUM;

STGMEDIUM :: uSTGMEDIUM;

wireASYNC_STGMEDIUM :: ^userSTGMEDIUM;

ASYNC_STGMEDIUM :: STGMEDIUM;

LPSTGMEDIUM :: ^STGMEDIUM;

userFLAG_STGMEDIUM :: struct {
    ContextFlags   : LONG,
    fPassOwnership : LONG,
    Stgmed         : userSTGMEDIUM,
};

wireFLAG_STGMEDIUM :: ^userFLAG_STGMEDIUM;

FLAG_STGMEDIUM :: struct {
    ContextFlags   : LONG,
    fPassOwnership : LONG,
    Stgmed         : STGMEDIUM,
};

IAdviseSinkVtbl :: struct {
    QueryInterface : (proc "stdcall" (This : ^IAdviseSink, riid : ^IID, ppvObject : ^rawptr) -> HRESULT),
    AddRef         : (proc "stdcall" (This : ^IAdviseSink) -> ULONG),
    Release        : (proc "stdcall" (This : ^IAdviseSink) -> ULONG),
    OnDataChange   : proc "stdcall" (This : ^IAdviseSink, pFormatetc : ^FORMATETC, pStgmed : ^STGMEDIUM),
    OnViewChange   : proc "stdcall" (This : ^IAdviseSink, dwAspect : DWORD, lindex : LONG),
    OnRename       : proc "stdcall" (This : ^IAdviseSink, pmk : ^IMoniker),
    OnSave         : proc "stdcall" (This : ^IAdviseSink),
    OnClose        : proc "stdcall" (This : ^IAdviseSink),
};

IAdviseSink :: struct {
    lpVtbl : ^IAdviseSinkVtbl,
};

AsyncIAdviseSinkVtbl :: struct {
    QueryInterface      : (proc "stdcall" (This : ^AsyncIAdviseSink, riid : ^IID, ppvObject : ^rawptr) -> HRESULT),
    AddRef              : (proc "stdcall" (This : ^AsyncIAdviseSink) -> ULONG),
    Release             : (proc "stdcall" (This : ^AsyncIAdviseSink) -> ULONG),
    Begin_OnDataChange  : proc "stdcall" (This : ^AsyncIAdviseSink, pFormatetc : ^FORMATETC, pStgmed : ^STGMEDIUM),
    Finish_OnDataChange : proc "stdcall" (This : ^AsyncIAdviseSink),
    Begin_OnViewChange  : proc "stdcall" (This : ^AsyncIAdviseSink, dwAspect : DWORD, lindex : LONG),
    Finish_OnViewChange : proc "stdcall" (This : ^AsyncIAdviseSink),
    Begin_OnRename      : proc "stdcall" (This : ^AsyncIAdviseSink, pmk : ^IMoniker),
    Finish_OnRename     : proc "stdcall" (This : ^AsyncIAdviseSink),
    Begin_OnSave        : proc "stdcall" (This : ^AsyncIAdviseSink),
    Finish_OnSave       : proc "stdcall" (This : ^AsyncIAdviseSink),
    Begin_OnClose       : proc "stdcall" (This : ^AsyncIAdviseSink),
    Finish_OnClose      : proc "stdcall" (This : ^AsyncIAdviseSink),
};

AsyncIAdviseSink :: struct {
    lpVtbl : ^AsyncIAdviseSinkVtbl,
};

LPADVISESINK2 :: ^IAdviseSink2;

IAdviseSink2Vtbl :: struct {
    QueryInterface  : (proc "stdcall" (This : ^IAdviseSink2, riid : ^IID, ppvObject : ^rawptr) -> HRESULT),
    AddRef          : (proc "stdcall" (This : ^IAdviseSink2) -> ULONG),
    Release         : (proc "stdcall" (This : ^IAdviseSink2) -> ULONG),
    OnDataChange    : proc "stdcall" (This : ^IAdviseSink2, pFormatetc : ^FORMATETC, pStgmed : ^STGMEDIUM),
    OnViewChange    : proc "stdcall" (This : ^IAdviseSink2, dwAspect : DWORD, lindex : LONG),
    OnRename        : proc "stdcall" (This : ^IAdviseSink2, pmk : ^IMoniker),
    OnSave          : proc "stdcall" (This : ^IAdviseSink2),
    OnClose         : proc "stdcall" (This : ^IAdviseSink2),
    OnLinkSrcChange : proc "stdcall" (This : ^IAdviseSink2, pmk : ^IMoniker),
};

IAdviseSink2 :: struct {
    lpVtbl : ^IAdviseSink2Vtbl,
};

AsyncIAdviseSink2Vtbl :: struct {
    QueryInterface         : (proc "stdcall" (This : ^AsyncIAdviseSink2, riid : ^IID, ppvObject : ^rawptr) -> HRESULT),
    AddRef                 : (proc "stdcall" (This : ^AsyncIAdviseSink2) -> ULONG),
    Release                : (proc "stdcall" (This : ^AsyncIAdviseSink2) -> ULONG),
    Begin_OnDataChange     : proc "stdcall" (This : ^AsyncIAdviseSink2, pFormatetc : ^FORMATETC, pStgmed : ^STGMEDIUM),
    Finish_OnDataChange    : proc "stdcall" (This : ^AsyncIAdviseSink2),
    Begin_OnViewChange     : proc "stdcall" (This : ^AsyncIAdviseSink2, dwAspect : DWORD, lindex : LONG),
    Finish_OnViewChange    : proc "stdcall" (This : ^AsyncIAdviseSink2),
    Begin_OnRename         : proc "stdcall" (This : ^AsyncIAdviseSink2, pmk : ^IMoniker),
    Finish_OnRename        : proc "stdcall" (This : ^AsyncIAdviseSink2),
    Begin_OnSave           : proc "stdcall" (This : ^AsyncIAdviseSink2),
    Finish_OnSave          : proc "stdcall" (This : ^AsyncIAdviseSink2),
    Begin_OnClose          : proc "stdcall" (This : ^AsyncIAdviseSink2),
    Finish_OnClose         : proc "stdcall" (This : ^AsyncIAdviseSink2),
    Begin_OnLinkSrcChange  : proc "stdcall" (This : ^AsyncIAdviseSink2, pmk : ^IMoniker),
    Finish_OnLinkSrcChange : proc "stdcall" (This : ^AsyncIAdviseSink2),
};

AsyncIAdviseSink2 :: struct {
    lpVtbl : ^AsyncIAdviseSink2Vtbl,
};

LPDATAOBJECT :: ^IDataObject;

/* DATADIR :: enum { */
DATADIR :: _c.int;
    DATADIR_GET :: 1;
    DATADIR_SET :: 2;
/* } */
;

IDataObjectVtbl :: struct {
    QueryInterface        : (proc "stdcall" (This : ^IDataObject, riid : ^IID, ppvObject : ^rawptr) -> HRESULT),
    AddRef                : (proc "stdcall" (This : ^IDataObject) -> ULONG),
    Release               : (proc "stdcall" (This : ^IDataObject) -> ULONG),
    GetData               : (proc "stdcall" (This : ^IDataObject, pformatetcIn : ^FORMATETC, pmedium : ^STGMEDIUM) -> HRESULT),
    GetDataHere           : (proc "stdcall" (This : ^IDataObject, pformatetc : ^FORMATETC, pmedium : ^STGMEDIUM) -> HRESULT),
    QueryGetData          : (proc "stdcall" (This : ^IDataObject, pformatetc : ^FORMATETC) -> HRESULT),
    GetCanonicalFormatEtc : (proc "stdcall" (This : ^IDataObject, pformatectIn : ^FORMATETC, pformatetcOut : ^FORMATETC) -> HRESULT),
    SetData               : (proc "stdcall" (This : ^IDataObject, pformatetc : ^FORMATETC, pmedium : ^STGMEDIUM, fRelease : BOOL) -> HRESULT),
    EnumFormatEtc         : (proc "stdcall" (This : ^IDataObject, dwDirection : DWORD, ppenumFormatEtc : ^^IEnumFORMATETC) -> HRESULT),
    DAdvise               : (proc "stdcall" (This : ^IDataObject, pformatetc : ^FORMATETC, advf : DWORD, pAdvSink : ^IAdviseSink, pdwConnection : ^DWORD) -> HRESULT),
    DUnadvise             : (proc "stdcall" (This : ^IDataObject, dwConnection : DWORD) -> HRESULT),
    EnumDAdvise           : (proc "stdcall" (This : ^IDataObject, ppenumAdvise : ^^IEnumSTATDATA) -> HRESULT),
};

IDataObject :: struct {
    lpVtbl : ^IDataObjectVtbl,
};

LPDATAADVISEHOLDER :: ^IDataAdviseHolder;

IDataAdviseHolderVtbl :: struct {
    QueryInterface   : (proc "stdcall" (This : ^IDataAdviseHolder, riid : ^IID, ppvObject : ^rawptr) -> HRESULT),
    AddRef           : (proc "stdcall" (This : ^IDataAdviseHolder) -> ULONG),
    Release          : (proc "stdcall" (This : ^IDataAdviseHolder) -> ULONG),
    Advise           : (proc "stdcall" (This : ^IDataAdviseHolder, pDataObject : ^IDataObject, pFetc : ^FORMATETC, advf : DWORD, pAdvise : ^IAdviseSink, pdwConnection : ^DWORD) -> HRESULT),
    Unadvise         : (proc "stdcall" (This : ^IDataAdviseHolder, dwConnection : DWORD) -> HRESULT),
    EnumAdvise       : (proc "stdcall" (This : ^IDataAdviseHolder, ppenumAdvise : ^^IEnumSTATDATA) -> HRESULT),
    SendOnDataChange : (proc "stdcall" (This : ^IDataAdviseHolder, pDataObject : ^IDataObject, dwReserved : DWORD, advf : DWORD) -> HRESULT),
};

IDataAdviseHolder :: struct {
    lpVtbl : ^IDataAdviseHolderVtbl,
};

LPMESSAGEFILTER :: ^IMessageFilter;

/* CALLTYPE :: enum { */
CALLTYPE :: _c.int;
    CALLTYPE_TOPLEVEL :: 1;
    CALLTYPE_NESTED :: 2;
    CALLTYPE_ASYNC :: 3;
    CALLTYPE_TOPLEVEL_CALLPENDING :: 4;
    CALLTYPE_ASYNC_CALLPENDING :: 5;
/* } */
;

/* SERVERCALL :: enum { */
SERVERCALL :: _c.int;
    SERVERCALL_ISHANDLED :: 0;
    SERVERCALL_REJECTED :: 1;
    SERVERCALL_RETRYLATER :: 2;
/* } */
;

/* PENDINGTYPE :: enum { */
PENDINGTYPE :: _c.int;
    PENDINGTYPE_TOPLEVEL :: 1;
    PENDINGTYPE_NESTED :: 2;
/* } */
;

/* PENDINGMSG :: enum { */
PENDINGMSG :: _c.int;
    PENDINGMSG_CANCELCALL :: 0;
    PENDINGMSG_WAITNOPROCESS :: 1;
    PENDINGMSG_WAITDEFPROCESS :: 2;
/* } */
;

INTERFACEINFO :: struct {
    pUnk    : ^IUnknown,
    iid     : IID,
    wMethod : WORD,
};

LPINTERFACEINFO :: ^INTERFACEINFO;

IMessageFilterVtbl :: struct {
    QueryInterface     : (proc "stdcall" (This : ^IMessageFilter, riid : ^IID, ppvObject : ^rawptr) -> HRESULT),
    AddRef             : (proc "stdcall" (This : ^IMessageFilter) -> ULONG),
    Release            : (proc "stdcall" (This : ^IMessageFilter) -> ULONG),
    HandleInComingCall : (proc "stdcall" (This : ^IMessageFilter, dwCallType : DWORD, htaskCaller : HTASK, dwTickCount : DWORD, lpInterfaceInfo : LPINTERFACEINFO) -> DWORD),
    RetryRejectedCall  : (proc "stdcall" (This : ^IMessageFilter, htaskCallee : HTASK, dwTickCount : DWORD, dwRejectType : DWORD) -> DWORD),
    MessagePending     : (proc "stdcall" (This : ^IMessageFilter, htaskCallee : HTASK, dwTickCount : DWORD, dwPendingType : DWORD) -> DWORD),
};

IMessageFilter :: struct {
    lpVtbl : ^IMessageFilterVtbl,
};

IClassActivatorVtbl :: struct {
    QueryInterface : (proc "stdcall" (This : ^IClassActivator, riid : ^IID, ppvObject : ^rawptr) -> HRESULT),
    AddRef         : (proc "stdcall" (This : ^IClassActivator) -> ULONG),
    Release        : (proc "stdcall" (This : ^IClassActivator) -> ULONG),
    GetClassObject : (proc "stdcall" (This : ^IClassActivator, rclsid : ^IID, dwClassContext : DWORD, locale : LCID, riid : ^IID, ppv : ^rawptr) -> HRESULT),
};

IClassActivator :: struct {
    lpVtbl : ^IClassActivatorVtbl,
};

IFillLockBytesVtbl :: struct {
    QueryInterface : (proc "stdcall" (This : ^IFillLockBytes, riid : ^IID, ppvObject : ^rawptr) -> HRESULT),
    AddRef         : (proc "stdcall" (This : ^IFillLockBytes) -> ULONG),
    Release        : (proc "stdcall" (This : ^IFillLockBytes) -> ULONG),
    FillAppend     : (proc "stdcall" (This : ^IFillLockBytes, pv : rawptr, cb : ULONG, pcbWritten : ^ULONG) -> HRESULT),
    FillAt         : (proc "stdcall" (This : ^IFillLockBytes, ulOffset : ULARGE_INTEGER, pv : rawptr, cb : ULONG, pcbWritten : ^ULONG) -> HRESULT),
    SetFillSize    : (proc "stdcall" (This : ^IFillLockBytes, ulSize : ULARGE_INTEGER) -> HRESULT),
    Terminate      : (proc "stdcall" (This : ^IFillLockBytes, bCanceled : BOOL) -> HRESULT),
};

IFillLockBytes :: struct {
    lpVtbl : ^IFillLockBytesVtbl,
};

IProgressNotifyVtbl :: struct {
    QueryInterface : (proc "stdcall" (This : ^IProgressNotify, riid : ^IID, ppvObject : ^rawptr) -> HRESULT),
    AddRef         : (proc "stdcall" (This : ^IProgressNotify) -> ULONG),
    Release        : (proc "stdcall" (This : ^IProgressNotify) -> ULONG),
    OnProgress     : (proc "stdcall" (This : ^IProgressNotify, dwProgressCurrent : DWORD, dwProgressMaximum : DWORD, fAccurate : BOOL, fOwner : BOOL) -> HRESULT),
};

IProgressNotify :: struct {
    lpVtbl : ^IProgressNotifyVtbl,
};

StorageLayout :: struct {
    LayoutType      : DWORD,
    pwcsElementName : ^OLECHAR,
    cOffset         : LARGE_INTEGER,
    cBytes          : LARGE_INTEGER,
};

ILayoutStorageVtbl :: struct {
    QueryInterface              : (proc "stdcall" (This : ^ILayoutStorage, riid : ^IID, ppvObject : ^rawptr) -> HRESULT),
    AddRef                      : (proc "stdcall" (This : ^ILayoutStorage) -> ULONG),
    Release                     : (proc "stdcall" (This : ^ILayoutStorage) -> ULONG),
    LayoutScript                : (proc "stdcall" (This : ^ILayoutStorage, pStorageLayout : ^StorageLayout, nEntries : DWORD, glfInterleavedFlag : DWORD) -> HRESULT),
    BeginMonitor                : (proc "stdcall" (This : ^ILayoutStorage) -> HRESULT),
    EndMonitor                  : (proc "stdcall" (This : ^ILayoutStorage) -> HRESULT),
    ReLayoutDocfile             : (proc "stdcall" (This : ^ILayoutStorage, pwcsNewDfName : ^OLECHAR) -> HRESULT),
    ReLayoutDocfileOnILockBytes : (proc "stdcall" (This : ^ILayoutStorage, pILockBytes : ^ILockBytes) -> HRESULT),
};

ILayoutStorage :: struct {
    lpVtbl : ^ILayoutStorageVtbl,
};

IBlockingLockVtbl :: struct {
    QueryInterface : (proc "stdcall" (This : ^IBlockingLock, riid : ^IID, ppvObject : ^rawptr) -> HRESULT),
    AddRef         : (proc "stdcall" (This : ^IBlockingLock) -> ULONG),
    Release        : (proc "stdcall" (This : ^IBlockingLock) -> ULONG),
    Lock           : (proc "stdcall" (This : ^IBlockingLock, dwTimeout : DWORD) -> HRESULT),
    Unlock         : (proc "stdcall" (This : ^IBlockingLock) -> HRESULT),
};

IBlockingLock :: struct {
    lpVtbl : ^IBlockingLockVtbl,
};

ITimeAndNoticeControlVtbl :: struct {
    QueryInterface  : (proc "stdcall" (This : ^ITimeAndNoticeControl, riid : ^IID, ppvObject : ^rawptr) -> HRESULT),
    AddRef          : (proc "stdcall" (This : ^ITimeAndNoticeControl) -> ULONG),
    Release         : (proc "stdcall" (This : ^ITimeAndNoticeControl) -> ULONG),
    SuppressChanges : (proc "stdcall" (This : ^ITimeAndNoticeControl, res1 : DWORD, res2 : DWORD) -> HRESULT),
};

ITimeAndNoticeControl :: struct {
    lpVtbl : ^ITimeAndNoticeControlVtbl,
};

IOplockStorageVtbl :: struct {
    QueryInterface  : (proc "stdcall" (This : ^IOplockStorage, riid : ^IID, ppvObject : ^rawptr) -> HRESULT),
    AddRef          : (proc "stdcall" (This : ^IOplockStorage) -> ULONG),
    Release         : (proc "stdcall" (This : ^IOplockStorage) -> ULONG),
    CreateStorageEx : (proc "stdcall" (This : ^IOplockStorage, pwcsName : LPCWSTR, grfMode : DWORD, stgfmt : DWORD, grfAttrs : DWORD, riid : ^IID, ppstgOpen : ^rawptr) -> HRESULT),
    OpenStorageEx   : (proc "stdcall" (This : ^IOplockStorage, pwcsName : LPCWSTR, grfMode : DWORD, stgfmt : DWORD, grfAttrs : DWORD, riid : ^IID, ppstgOpen : ^rawptr) -> HRESULT),
};

IOplockStorage :: struct {
    lpVtbl : ^IOplockStorageVtbl,
};

IDirectWriterLockVtbl :: struct {
    QueryInterface     : (proc "stdcall" (This : ^IDirectWriterLock, riid : ^IID, ppvObject : ^rawptr) -> HRESULT),
    AddRef             : (proc "stdcall" (This : ^IDirectWriterLock) -> ULONG),
    Release            : (proc "stdcall" (This : ^IDirectWriterLock) -> ULONG),
    WaitForWriteAccess : (proc "stdcall" (This : ^IDirectWriterLock, dwTimeout : DWORD) -> HRESULT),
    ReleaseWriteAccess : (proc "stdcall" (This : ^IDirectWriterLock) -> HRESULT),
    HaveWriteAccess    : (proc "stdcall" (This : ^IDirectWriterLock) -> HRESULT),
};

IDirectWriterLock :: struct {
    lpVtbl : ^IDirectWriterLockVtbl,
};

IUrlMonVtbl :: struct {
    QueryInterface    : (proc "stdcall" (This : ^IUrlMon, riid : ^IID, ppvObject : ^rawptr) -> HRESULT),
    AddRef            : (proc "stdcall" (This : ^IUrlMon) -> ULONG),
    Release           : (proc "stdcall" (This : ^IUrlMon) -> ULONG),
    AsyncGetClassBits : (proc "stdcall" (This : ^IUrlMon, rclsid : ^IID, pszTYPE : LPCWSTR, pszExt : LPCWSTR, dwFileVersionMS : DWORD, dwFileVersionLS : DWORD, pszCodeBase : LPCWSTR, pbc : ^IBindCtx, dwClassContext : DWORD, riid : ^IID, flags : DWORD) -> HRESULT),
};

IUrlMon :: struct {
    lpVtbl : ^IUrlMonVtbl,
};

IForegroundTransferVtbl :: struct {
    QueryInterface          : (proc "stdcall" (This : ^IForegroundTransfer, riid : ^IID, ppvObject : ^rawptr) -> HRESULT),
    AddRef                  : (proc "stdcall" (This : ^IForegroundTransfer) -> ULONG),
    Release                 : (proc "stdcall" (This : ^IForegroundTransfer) -> ULONG),
    AllowForegroundTransfer : (proc "stdcall" (This : ^IForegroundTransfer, lpvReserved : rawptr) -> HRESULT),
};

IForegroundTransfer :: struct {
    lpVtbl : ^IForegroundTransferVtbl,
};

IThumbnailExtractorVtbl :: struct {
    QueryInterface   : (proc "stdcall" (This : ^IThumbnailExtractor, riid : ^IID, ppvObject : ^rawptr) -> HRESULT),
    AddRef           : (proc "stdcall" (This : ^IThumbnailExtractor) -> ULONG),
    Release          : (proc "stdcall" (This : ^IThumbnailExtractor) -> ULONG),
    ExtractThumbnail : (proc "stdcall" (This : ^IThumbnailExtractor, pStg : ^IStorage, ulLength : ULONG, ulHeight : ULONG, pulOutputLength : ^ULONG, pulOutputHeight : ^ULONG, phOutputBitmap : ^HBITMAP) -> HRESULT),
    OnFileUpdated    : (proc "stdcall" (This : ^IThumbnailExtractor, pStg : ^IStorage) -> HRESULT),
};

IThumbnailExtractor :: struct {
    lpVtbl : ^IThumbnailExtractorVtbl,
};

IDummyHICONIncluderVtbl :: struct {
    QueryInterface : (proc "stdcall" (This : ^IDummyHICONIncluder, riid : ^IID, ppvObject : ^rawptr) -> HRESULT),
    AddRef         : (proc "stdcall" (This : ^IDummyHICONIncluder) -> ULONG),
    Release        : (proc "stdcall" (This : ^IDummyHICONIncluder) -> ULONG),
    Dummy          : (proc "stdcall" (This : ^IDummyHICONIncluder, h1 : HICON, h2 : HDC) -> HRESULT),
};

IDummyHICONIncluder :: struct {
    lpVtbl : ^IDummyHICONIncluderVtbl,
};

/* ApplicationType :: enum { */
ApplicationType :: _c.int;
    ServerApplication :: 0;
    LibraryApplication :: (ServerApplication + 1);
/* } */
;

/* ShutdownType :: enum { */
ShutdownType :: _c.int;
    IdleShutdown :: 0;
    ForcedShutdown :: (IdleShutdown + 1);
/* } */
;

IProcessLockVtbl :: struct {
    QueryInterface      : (proc "stdcall" (This : ^IProcessLock, riid : ^IID, ppvObject : ^rawptr) -> HRESULT),
    AddRef              : (proc "stdcall" (This : ^IProcessLock) -> ULONG),
    Release             : (proc "stdcall" (This : ^IProcessLock) -> ULONG),
    AddRefOnProcess     : (proc "stdcall" (This : ^IProcessLock) -> ULONG),
    ReleaseRefOnProcess : (proc "stdcall" (This : ^IProcessLock) -> ULONG),
};

IProcessLock :: struct {
    lpVtbl : ^IProcessLockVtbl,
};

ISurrogateServiceVtbl :: struct {
    QueryInterface    : (proc "stdcall" (This : ^ISurrogateService, riid : ^IID, ppvObject : ^rawptr) -> HRESULT),
    AddRef            : (proc "stdcall" (This : ^ISurrogateService) -> ULONG),
    Release           : (proc "stdcall" (This : ^ISurrogateService) -> ULONG),
    Init              : (proc "stdcall" (This : ^ISurrogateService, rguidProcessID : ^GUID, pProcessLock : ^IProcessLock, pfApplicationAware : ^BOOL) -> HRESULT),
    ApplicationLaunch : (proc "stdcall" (This : ^ISurrogateService, rguidApplID : ^GUID, appType : ApplicationType) -> HRESULT),
    ApplicationFree   : (proc "stdcall" (This : ^ISurrogateService, rguidApplID : ^GUID) -> HRESULT),
    CatalogRefresh    : (proc "stdcall" (This : ^ISurrogateService, ulReserved : ULONG) -> HRESULT),
    ProcessShutdown   : (proc "stdcall" (This : ^ISurrogateService, shutdownType : ShutdownType) -> HRESULT),
};

ISurrogateService :: struct {
    lpVtbl : ^ISurrogateServiceVtbl,
};

LPINITIALIZESPY :: ^IInitializeSpy;

IInitializeSpyVtbl :: struct {
    QueryInterface   : (proc "stdcall" (This : ^IInitializeSpy, riid : ^IID, ppvObject : ^rawptr) -> HRESULT),
    AddRef           : (proc "stdcall" (This : ^IInitializeSpy) -> ULONG),
    Release          : (proc "stdcall" (This : ^IInitializeSpy) -> ULONG),
    PreInitialize    : (proc "stdcall" (This : ^IInitializeSpy, dwCoInit : DWORD, dwCurThreadAptRefs : DWORD) -> HRESULT),
    PostInitialize   : (proc "stdcall" (This : ^IInitializeSpy, hrCoInit : HRESULT, dwCoInit : DWORD, dwNewThreadAptRefs : DWORD) -> HRESULT),
    PreUninitialize  : (proc "stdcall" (This : ^IInitializeSpy, dwCurThreadAptRefs : DWORD) -> HRESULT),
    PostUninitialize : (proc "stdcall" (This : ^IInitializeSpy, dwNewThreadAptRefs : DWORD) -> HRESULT),
};

IInitializeSpy :: struct {
    lpVtbl : ^IInitializeSpyVtbl,
};

IApartmentShutdownVtbl :: struct {
    QueryInterface : (proc "stdcall" (This : ^IApartmentShutdown, riid : ^IID, ppvObject : ^rawptr) -> HRESULT),
    AddRef         : (proc "stdcall" (This : ^IApartmentShutdown) -> ULONG),
    Release        : (proc "stdcall" (This : ^IApartmentShutdown) -> ULONG),
    OnUninitialize : proc "stdcall" (This : ^IApartmentShutdown, ui64ApartmentIdentifier : UINT64),
};

IApartmentShutdown :: struct {
    lpVtbl : ^IApartmentShutdownVtbl,
};

;

;

;

;

;

;

;

;

;

;

;

;

;

;

;

;

;

;

;

;

;

;

;

;

;

;

CURRENCY :: CY;

SAFEARRAYBOUND :: struct {
    cElements : ULONG,
    lLbound   : LONG,
};

LPSAFEARRAYBOUND :: ^SAFEARRAYBOUND;

wireVARIANT :: ^_wireVARIANT;

wireBRECORD :: ^_wireBRECORD;

SAFEARR_BSTR :: struct {
    Size  : ULONG,
    aBstr : ^wireBSTR,
};

SAFEARR_UNKNOWN :: struct {
    Size      : ULONG,
    apUnknown : ^^IUnknown,
};

SAFEARR_DISPATCH :: struct {
    Size       : ULONG,
    apDispatch : ^^IDispatch,
};

SAFEARR_VARIANT :: struct {
    Size     : ULONG,
    aVariant : ^wireVARIANT,
};

SAFEARR_BRECORD :: struct {
    Size    : ULONG,
    aRecord : ^wireBRECORD,
};

SAFEARR_HAVEIID :: struct {
    Size      : ULONG,
    apUnknown : ^^IUnknown,
    iid       : IID,
};

/* SF_TYPE :: enum { */
SF_TYPE :: _c.int;
    SF_ERROR ::     VT_ERROR;
    SF_I1 ::     VT_I1;
    SF_I2 ::     VT_I2;
    SF_I4 ::     VT_I4;
    SF_I8 ::     VT_I8;
    SF_BSTR ::     VT_BSTR;
    SF_UNKNOWN ::     VT_UNKNOWN;
    SF_DISPATCH ::     VT_DISPATCH;
    SF_VARIANT ::     VT_VARIANT;
    SF_RECORD ::     VT_RECORD;
    SF_HAVEIID :: (VT_UNKNOWN | VT_RESERVED);
/* } */
;

SAFEARRAYUNION :: struct {
    sfType : ULONG,
    u : struct #raw_union {
        BstrStr     : SAFEARR_BSTR,
        UnknownStr  : SAFEARR_UNKNOWN,
        DispatchStr : SAFEARR_DISPATCH,
        VariantStr  : SAFEARR_VARIANT,
        RecordStr   : SAFEARR_BRECORD,
        HaveIidStr  : SAFEARR_HAVEIID,
        ByteStr     : BYTE_SIZEDARR,
        WordStr     : WORD_SIZEDARR,
        LongStr     : DWORD_SIZEDARR,
        HyperStr    : HYPER_SIZEDARR,
    },
};

wireSAFEARRAY :: ^struct {
    cDims         : USHORT,
    fFeatures     : USHORT,
    cbElements    : ULONG,
    cLocks        : ULONG,
    uArrayStructs : SAFEARRAYUNION,
    rgsabound     : [1]SAFEARRAYBOUND,
};

wirePSAFEARRAY :: ^wireSAFEARRAY;

SAFEARRAY :: struct {
    cDims      : USHORT,
    fFeatures  : USHORT,
    cbElements : ULONG,
    cLocks     : ULONG,
    pvData     : PVOID,
    rgsabound  : [1]SAFEARRAYBOUND,
};

LPSAFEARRAY :: ^SAFEARRAY;

;

VARIANT :: struct {
    n1 : struct #raw_union {
        n2 : struct {
            vt         : VARTYPE,
            wReserved1 : WORD,
            wReserved2 : WORD,
            wReserved3 : WORD,
            n3 : struct #raw_union {
                llVal                     : LONGLONG,
                lVal                      : LONG,
                bVal                      : BYTE,
                iVal                      : SHORT,
                fltVal                    : FLOAT,
                dblVal                    : DOUBLE,
                boolVal                   : VARIANT_BOOL,
                __OBSOLETE__VARIANT_BOOL  : VARIANT_BOOL,
                scode                     : SCODE,
                cyVal                     : CY,
                date                      : DATE,
                bstrVal                   : BSTR,
                punkVal                   : ^IUnknown,
                pdispVal                  : ^IDispatch,
                parray                    : ^SAFEARRAY,
                pbVal                     : ^BYTE,
                piVal                     : ^SHORT,
                plVal                     : ^LONG,
                pllVal                    : ^LONGLONG,
                pfltVal                   : ^FLOAT,
                pdblVal                   : ^DOUBLE,
                pboolVal                  : ^VARIANT_BOOL,
                __OBSOLETE__VARIANT_PBOOL : ^VARIANT_BOOL,
                pscode                    : ^SCODE,
                pcyVal                    : ^CY,
                pdate                     : ^DATE,
                pbstrVal                  : ^BSTR,
                ppunkVal                  : ^^IUnknown,
                ppdispVal                 : ^^IDispatch,
                pparray                   : ^^SAFEARRAY,
                pvarVal                   : ^VARIANT,
                byref                     : PVOID,
                cVal                      : CHAR,
                uiVal                     : USHORT,
                ulVal                     : ULONG,
                ullVal                    : ULONGLONG,
                intVal                    : INT,
                uintVal                   : UINT,
                pdecVal                   : ^DECIMAL,
                pcVal                     : ^CHAR,
                puiVal                    : ^USHORT,
                pulVal                    : ^ULONG,
                pullVal                   : ^ULONGLONG,
                pintVal                   : ^INT,
                puintVal                  : ^UINT,
                brecVal : struct {
                    pvRecord : PVOID,
                    pRecInfo : ^IRecordInfo,
                },
            },
        },
        decVal : DECIMAL,
    },
};

LPVARIANT :: ^VARIANT;

VARIANTARG :: VARIANT;

LPVARIANTARG :: ^VARIANT;

_wireBRECORD :: struct {
    fFlags   : ULONG,
    clSize   : ULONG,
    pRecInfo : ^IRecordInfo,
    pRecord  : ^byte,
};

_wireVARIANT :: struct {
    clSize      : DWORD,
    rpcReserved : DWORD,
    vt          : USHORT,
    wReserved1  : USHORT,
    wReserved2  : USHORT,
    wReserved3  : USHORT,
    u : struct #raw_union {
        llVal     : LONGLONG,
        lVal      : LONG,
        bVal      : BYTE,
        iVal      : SHORT,
        fltVal    : FLOAT,
        dblVal    : DOUBLE,
        boolVal   : VARIANT_BOOL,
        scode     : SCODE,
        cyVal     : CY,
        date      : DATE,
        bstrVal   : wireBSTR,
        punkVal   : ^IUnknown,
        pdispVal  : ^IDispatch,
        parray    : wirePSAFEARRAY,
        brecVal   : wireBRECORD,
        pbVal     : ^BYTE,
        piVal     : ^SHORT,
        plVal     : ^LONG,
        pllVal    : ^LONGLONG,
        pfltVal   : ^FLOAT,
        pdblVal   : ^DOUBLE,
        pboolVal  : ^VARIANT_BOOL,
        pscode    : ^SCODE,
        pcyVal    : ^CY,
        pdate     : ^DATE,
        pbstrVal  : ^wireBSTR,
        ppunkVal  : ^^IUnknown,
        ppdispVal : ^^IDispatch,
        pparray   : ^wirePSAFEARRAY,
        pvarVal   : ^wireVARIANT,
        cVal      : CHAR,
        uiVal     : USHORT,
        ulVal     : ULONG,
        ullVal    : ULONGLONG,
        intVal    : INT,
        uintVal   : UINT,
        decVal    : DECIMAL,
        pdecVal   : ^DECIMAL,
        pcVal     : ^CHAR,
        puiVal    : ^USHORT,
        pulVal    : ^ULONG,
        pullVal   : ^ULONGLONG,
        pintVal   : ^INT,
        puintVal  : ^UINT,
    },
};

DISPID :: LONG;

MEMBERID :: DISPID;

HREFTYPE :: DWORD;

/* TYPEKIND :: enum { */
TYPEKIND :: _c.int;
    TKIND_ENUM :: 0;
    TKIND_RECORD :: (TKIND_ENUM + 1);
    TKIND_MODULE :: (TKIND_RECORD + 1);
    TKIND_INTERFACE :: (TKIND_MODULE + 1);
    TKIND_DISPATCH :: (TKIND_INTERFACE + 1);
    TKIND_COCLASS :: (TKIND_DISPATCH + 1);
    TKIND_ALIAS :: (TKIND_COCLASS + 1);
    TKIND_UNION :: (TKIND_ALIAS + 1);
    TKIND_MAX :: (TKIND_UNION + 1);
/* } */
;

TYPEDESC :: struct {
    u : struct #raw_union {
        lptdesc  : ^TYPEDESC,
        lpadesc  : ^ARRAYDESC,
        hreftype : HREFTYPE,
    },
    vt : VARTYPE,
};

ARRAYDESC :: struct {
    tdescElem : TYPEDESC,
    cDims     : USHORT,
    rgbounds  : [1]SAFEARRAYBOUND,
};

PARAMDESCEX :: struct {
    cBytes          : ULONG,
    varDefaultValue : VARIANTARG,
};

LPPARAMDESCEX :: ^PARAMDESCEX;

PARAMDESC :: struct {
    pparamdescex : LPPARAMDESCEX,
    wParamFlags  : USHORT,
};

LPPARAMDESC :: ^PARAMDESC;

IDLDESC :: struct {
    dwReserved : ULONG_PTR,
    wIDLFlags  : USHORT,
};

LPIDLDESC :: ^IDLDESC;

ELEMDESC :: struct {
    tdesc : TYPEDESC,
    u : struct #raw_union {
        idldesc   : IDLDESC,
        paramdesc : PARAMDESC,
    },
};
LPELEMDESC :: ^ELEMDESC;

TYPEATTR :: struct {
    guid             : GUID,
    lcid             : LCID,
    dwReserved       : DWORD,
    memidConstructor : MEMBERID,
    memidDestructor  : MEMBERID,
    lpstrSchema      : LPOLESTR,
    cbSizeInstance   : ULONG,
    typekind         : TYPEKIND,
    cFuncs           : WORD,
    cVars            : WORD,
    cImplTypes       : WORD,
    cbSizeVft        : WORD,
    cbAlignment      : WORD,
    wTypeFlags       : WORD,
    wMajorVerNum     : WORD,
    wMinorVerNum     : WORD,
    tdescAlias       : TYPEDESC,
    idldescType      : IDLDESC,
};

LPTYPEATTR :: ^TYPEATTR;

DISPPARAMS :: struct {
    rgvarg            : ^VARIANTARG,
    rgdispidNamedArgs : ^DISPID,
    cArgs             : UINT,
    cNamedArgs        : UINT,
};

EXCEPINFO :: struct {
    wCode             : WORD,
    wReserved         : WORD,
    bstrSource        : BSTR,
    bstrDescription   : BSTR,
    bstrHelpFile      : BSTR,
    dwHelpContext     : DWORD,
    pvReserved        : PVOID,
    pfnDeferredFillIn : (proc "stdcall" (^EXCEPINFO) -> HRESULT),
    scode             : SCODE,
};
LPEXCEPINFO :: ^EXCEPINFO;

/* CALLCONV :: enum { */
CALLCONV :: _c.int;
    CC_FASTCALL :: 0;
    CC_CDECL :: 1;
    CC_MSCPASCAL :: (CC_CDECL + 1);
    CC_PASCAL ::     CC_MSCPASCAL;
    CC_MACPASCAL :: (CC_PASCAL + 1);
    CC_STDCALL :: (CC_MACPASCAL + 1);
    CC_FPFASTCALL :: (CC_STDCALL + 1);
    CC_SYSCALL :: (CC_FPFASTCALL + 1);
    CC_MPWCDECL :: (CC_SYSCALL + 1);
    CC_MPWPASCAL :: (CC_MPWCDECL + 1);
    CC_MAX :: (CC_MPWPASCAL + 1);
/* } */
;

/* FUNCKIND :: enum { */
FUNCKIND :: _c.int;
    FUNC_VIRTUAL :: 0;
    FUNC_PUREVIRTUAL :: (FUNC_VIRTUAL + 1);
    FUNC_NONVIRTUAL :: (FUNC_PUREVIRTUAL + 1);
    FUNC_STATIC :: (FUNC_NONVIRTUAL + 1);
    FUNC_DISPATCH :: (FUNC_STATIC + 1);
/* } */
;

/* INVOKEKIND :: enum { */
INVOKEKIND :: _c.int;
    INVOKE_FUNC :: 1;
    INVOKE_PROPERTYGET :: 2;
    INVOKE_PROPERTYPUT :: 4;
    INVOKE_PROPERTYPUTREF :: 8;
/* } */
;

FUNCDESC :: struct {
    memid             : MEMBERID,
    lprgscode         : ^SCODE,
    lprgelemdescParam : ^ELEMDESC,
    funckind          : FUNCKIND,
    invkind           : INVOKEKIND,
    callconv          : CALLCONV,
    cParams           : SHORT,
    cParamsOpt        : SHORT,
    oVft              : SHORT,
    cScodes           : SHORT,
    elemdescFunc      : ELEMDESC,
    wFuncFlags        : WORD,
};

LPFUNCDESC :: ^FUNCDESC;

/* VARKIND :: enum { */
VARKIND :: _c.int;
    VAR_PERINSTANCE :: 0;
    VAR_STATIC :: (VAR_PERINSTANCE + 1);
    VAR_CONST :: (VAR_STATIC + 1);
    VAR_DISPATCH :: (VAR_CONST + 1);
/* } */
;

VARDESC :: struct {
    memid       : MEMBERID,
    lpstrSchema : LPOLESTR,
    u : struct #raw_union {
        oInst      : ULONG,
        lpvarValue : ^VARIANT,
    },
    elemdescVar : ELEMDESC,
    wVarFlags   : WORD,
    varkind     : VARKIND,
};

LPVARDESC :: ^VARDESC;

/* TYPEFLAGS :: enum { */
TYPEFLAGS :: _c.int;
    TYPEFLAG_FAPPOBJECT :: 0x1;
    TYPEFLAG_FCANCREATE :: 0x2;
    TYPEFLAG_FLICENSED :: 0x4;
    TYPEFLAG_FPREDECLID :: 0x8;
    TYPEFLAG_FHIDDEN :: 0x10;
    TYPEFLAG_FCONTROL :: 0x20;
    TYPEFLAG_FDUAL :: 0x40;
    TYPEFLAG_FNONEXTENSIBLE :: 0x80;
    TYPEFLAG_FOLEAUTOMATION :: 0x100;
    TYPEFLAG_FRESTRICTED :: 0x200;
    TYPEFLAG_FAGGREGATABLE :: 0x400;
    TYPEFLAG_FREPLACEABLE :: 0x800;
    TYPEFLAG_FDISPATCHABLE :: 0x1000;
    TYPEFLAG_FREVERSEBIND :: 0x2000;
    TYPEFLAG_FPROXY :: 0x4000;
/* } */
;

/* FUNCFLAGS :: enum { */
FUNCFLAGS :: _c.int;
    FUNCFLAG_FRESTRICTED :: 0x1;
    FUNCFLAG_FSOURCE :: 0x2;
    FUNCFLAG_FBINDABLE :: 0x4;
    FUNCFLAG_FREQUESTEDIT :: 0x8;
    FUNCFLAG_FDISPLAYBIND :: 0x10;
    FUNCFLAG_FDEFAULTBIND :: 0x20;
    FUNCFLAG_FHIDDEN :: 0x40;
    FUNCFLAG_FUSESGETLASTERROR :: 0x80;
    FUNCFLAG_FDEFAULTCOLLELEM :: 0x100;
    FUNCFLAG_FUIDEFAULT :: 0x200;
    FUNCFLAG_FNONBROWSABLE :: 0x400;
    FUNCFLAG_FREPLACEABLE :: 0x800;
    FUNCFLAG_FIMMEDIATEBIND :: 0x1000;
/* } */
;

/* VARFLAGS :: enum { */
VARFLAGS :: _c.int;
    VARFLAG_FREADONLY :: 0x1;
    VARFLAG_FSOURCE :: 0x2;
    VARFLAG_FBINDABLE :: 0x4;
    VARFLAG_FREQUESTEDIT :: 0x8;
    VARFLAG_FDISPLAYBIND :: 0x10;
    VARFLAG_FDEFAULTBIND :: 0x20;
    VARFLAG_FHIDDEN :: 0x40;
    VARFLAG_FRESTRICTED :: 0x80;
    VARFLAG_FDEFAULTCOLLELEM :: 0x100;
    VARFLAG_FUIDEFAULT :: 0x200;
    VARFLAG_FNONBROWSABLE :: 0x400;
    VARFLAG_FREPLACEABLE :: 0x800;
    VARFLAG_FIMMEDIATEBIND :: 0x1000;
/* } */
;

CLEANLOCALSTORAGE :: struct {
    pInterface : ^IUnknown,
    pStorage   : PVOID,
    flags      : DWORD,
};

CUSTDATAITEM :: struct {
    guid     : GUID,
    varValue : VARIANTARG,
};

LPCUSTDATAITEM :: ^CUSTDATAITEM;

CUSTDATA :: struct {
    cCustData   : DWORD,
    prgCustData : LPCUSTDATAITEM,
};

LPCUSTDATA :: ^CUSTDATA;

LPCREATETYPEINFO :: ^ICreateTypeInfo;

ICreateTypeInfoVtbl :: struct {
    QueryInterface       : (proc "stdcall" (This : ^ICreateTypeInfo, riid : ^IID, ppvObject : ^rawptr) -> HRESULT),
    AddRef               : (proc "stdcall" (This : ^ICreateTypeInfo) -> ULONG),
    Release              : (proc "stdcall" (This : ^ICreateTypeInfo) -> ULONG),
    SetGuid              : (proc "stdcall" (This : ^ICreateTypeInfo, guid : ^GUID) -> HRESULT),
    SetTypeFlags         : (proc "stdcall" (This : ^ICreateTypeInfo, uTypeFlags : UINT) -> HRESULT),
    SetDocString         : (proc "stdcall" (This : ^ICreateTypeInfo, pStrDoc : LPOLESTR) -> HRESULT),
    SetHelpContext       : (proc "stdcall" (This : ^ICreateTypeInfo, dwHelpContext : DWORD) -> HRESULT),
    SetVersion           : (proc "stdcall" (This : ^ICreateTypeInfo, wMajorVerNum : WORD, wMinorVerNum : WORD) -> HRESULT),
    AddRefTypeInfo       : (proc "stdcall" (This : ^ICreateTypeInfo, pTInfo : ^ITypeInfo, phRefType : ^HREFTYPE) -> HRESULT),
    AddFuncDesc          : (proc "stdcall" (This : ^ICreateTypeInfo, index : UINT, pFuncDesc : ^FUNCDESC) -> HRESULT),
    AddImplType          : (proc "stdcall" (This : ^ICreateTypeInfo, index : UINT, hRefType : HREFTYPE) -> HRESULT),
    SetImplTypeFlags     : (proc "stdcall" (This : ^ICreateTypeInfo, index : UINT, implTypeFlags : INT) -> HRESULT),
    SetAlignment         : (proc "stdcall" (This : ^ICreateTypeInfo, cbAlignment : WORD) -> HRESULT),
    SetSchema            : (proc "stdcall" (This : ^ICreateTypeInfo, pStrSchema : LPOLESTR) -> HRESULT),
    AddVarDesc           : (proc "stdcall" (This : ^ICreateTypeInfo, index : UINT, pVarDesc : ^VARDESC) -> HRESULT),
    SetFuncAndParamNames : (proc "stdcall" (This : ^ICreateTypeInfo, index : UINT, rgszNames : ^LPOLESTR, cNames : UINT) -> HRESULT),
    SetVarName           : (proc "stdcall" (This : ^ICreateTypeInfo, index : UINT, szName : LPOLESTR) -> HRESULT),
    SetTypeDescAlias     : (proc "stdcall" (This : ^ICreateTypeInfo, pTDescAlias : ^TYPEDESC) -> HRESULT),
    DefineFuncAsDllEntry : (proc "stdcall" (This : ^ICreateTypeInfo, index : UINT, szDllName : LPOLESTR, szProcName : LPOLESTR) -> HRESULT),
    SetFuncDocString     : (proc "stdcall" (This : ^ICreateTypeInfo, index : UINT, szDocString : LPOLESTR) -> HRESULT),
    SetVarDocString      : (proc "stdcall" (This : ^ICreateTypeInfo, index : UINT, szDocString : LPOLESTR) -> HRESULT),
    SetFuncHelpContext   : (proc "stdcall" (This : ^ICreateTypeInfo, index : UINT, dwHelpContext : DWORD) -> HRESULT),
    SetVarHelpContext    : (proc "stdcall" (This : ^ICreateTypeInfo, index : UINT, dwHelpContext : DWORD) -> HRESULT),
    SetMops              : (proc "stdcall" (This : ^ICreateTypeInfo, index : UINT, bstrMops : BSTR) -> HRESULT),
    SetTypeIdldesc       : (proc "stdcall" (This : ^ICreateTypeInfo, pIdlDesc : ^IDLDESC) -> HRESULT),
    LayOut               : (proc "stdcall" (This : ^ICreateTypeInfo) -> HRESULT),
};

ICreateTypeInfo :: struct {
    lpVtbl : ^ICreateTypeInfoVtbl,
};

LPCREATETYPEINFO2 :: ^ICreateTypeInfo2;

ICreateTypeInfo2Vtbl :: struct {
    QueryInterface           : (proc "stdcall" (This : ^ICreateTypeInfo2, riid : ^IID, ppvObject : ^rawptr) -> HRESULT),
    AddRef                   : (proc "stdcall" (This : ^ICreateTypeInfo2) -> ULONG),
    Release                  : (proc "stdcall" (This : ^ICreateTypeInfo2) -> ULONG),
    SetGuid                  : (proc "stdcall" (This : ^ICreateTypeInfo2, guid : ^GUID) -> HRESULT),
    SetTypeFlags             : (proc "stdcall" (This : ^ICreateTypeInfo2, uTypeFlags : UINT) -> HRESULT),
    SetDocString             : (proc "stdcall" (This : ^ICreateTypeInfo2, pStrDoc : LPOLESTR) -> HRESULT),
    SetHelpContext           : (proc "stdcall" (This : ^ICreateTypeInfo2, dwHelpContext : DWORD) -> HRESULT),
    SetVersion               : (proc "stdcall" (This : ^ICreateTypeInfo2, wMajorVerNum : WORD, wMinorVerNum : WORD) -> HRESULT),
    AddRefTypeInfo           : (proc "stdcall" (This : ^ICreateTypeInfo2, pTInfo : ^ITypeInfo, phRefType : ^HREFTYPE) -> HRESULT),
    AddFuncDesc              : (proc "stdcall" (This : ^ICreateTypeInfo2, index : UINT, pFuncDesc : ^FUNCDESC) -> HRESULT),
    AddImplType              : (proc "stdcall" (This : ^ICreateTypeInfo2, index : UINT, hRefType : HREFTYPE) -> HRESULT),
    SetImplTypeFlags         : (proc "stdcall" (This : ^ICreateTypeInfo2, index : UINT, implTypeFlags : INT) -> HRESULT),
    SetAlignment             : (proc "stdcall" (This : ^ICreateTypeInfo2, cbAlignment : WORD) -> HRESULT),
    SetSchema                : (proc "stdcall" (This : ^ICreateTypeInfo2, pStrSchema : LPOLESTR) -> HRESULT),
    AddVarDesc               : (proc "stdcall" (This : ^ICreateTypeInfo2, index : UINT, pVarDesc : ^VARDESC) -> HRESULT),
    SetFuncAndParamNames     : (proc "stdcall" (This : ^ICreateTypeInfo2, index : UINT, rgszNames : ^LPOLESTR, cNames : UINT) -> HRESULT),
    SetVarName               : (proc "stdcall" (This : ^ICreateTypeInfo2, index : UINT, szName : LPOLESTR) -> HRESULT),
    SetTypeDescAlias         : (proc "stdcall" (This : ^ICreateTypeInfo2, pTDescAlias : ^TYPEDESC) -> HRESULT),
    DefineFuncAsDllEntry     : (proc "stdcall" (This : ^ICreateTypeInfo2, index : UINT, szDllName : LPOLESTR, szProcName : LPOLESTR) -> HRESULT),
    SetFuncDocString         : (proc "stdcall" (This : ^ICreateTypeInfo2, index : UINT, szDocString : LPOLESTR) -> HRESULT),
    SetVarDocString          : (proc "stdcall" (This : ^ICreateTypeInfo2, index : UINT, szDocString : LPOLESTR) -> HRESULT),
    SetFuncHelpContext       : (proc "stdcall" (This : ^ICreateTypeInfo2, index : UINT, dwHelpContext : DWORD) -> HRESULT),
    SetVarHelpContext        : (proc "stdcall" (This : ^ICreateTypeInfo2, index : UINT, dwHelpContext : DWORD) -> HRESULT),
    SetMops                  : (proc "stdcall" (This : ^ICreateTypeInfo2, index : UINT, bstrMops : BSTR) -> HRESULT),
    SetTypeIdldesc           : (proc "stdcall" (This : ^ICreateTypeInfo2, pIdlDesc : ^IDLDESC) -> HRESULT),
    LayOut                   : (proc "stdcall" (This : ^ICreateTypeInfo2) -> HRESULT),
    DeleteFuncDesc           : (proc "stdcall" (This : ^ICreateTypeInfo2, index : UINT) -> HRESULT),
    DeleteFuncDescByMemId    : (proc "stdcall" (This : ^ICreateTypeInfo2, memid : MEMBERID, invKind : INVOKEKIND) -> HRESULT),
    DeleteVarDesc            : (proc "stdcall" (This : ^ICreateTypeInfo2, index : UINT) -> HRESULT),
    DeleteVarDescByMemId     : (proc "stdcall" (This : ^ICreateTypeInfo2, memid : MEMBERID) -> HRESULT),
    DeleteImplType           : (proc "stdcall" (This : ^ICreateTypeInfo2, index : UINT) -> HRESULT),
    SetCustData              : (proc "stdcall" (This : ^ICreateTypeInfo2, guid : ^GUID, pVarVal : ^VARIANT) -> HRESULT),
    SetFuncCustData          : (proc "stdcall" (This : ^ICreateTypeInfo2, index : UINT, guid : ^GUID, pVarVal : ^VARIANT) -> HRESULT),
    SetParamCustData         : (proc "stdcall" (This : ^ICreateTypeInfo2, indexFunc : UINT, indexParam : UINT, guid : ^GUID, pVarVal : ^VARIANT) -> HRESULT),
    SetVarCustData           : (proc "stdcall" (This : ^ICreateTypeInfo2, index : UINT, guid : ^GUID, pVarVal : ^VARIANT) -> HRESULT),
    SetImplTypeCustData      : (proc "stdcall" (This : ^ICreateTypeInfo2, index : UINT, guid : ^GUID, pVarVal : ^VARIANT) -> HRESULT),
    SetHelpStringContext     : (proc "stdcall" (This : ^ICreateTypeInfo2, dwHelpStringContext : ULONG) -> HRESULT),
    SetFuncHelpStringContext : (proc "stdcall" (This : ^ICreateTypeInfo2, index : UINT, dwHelpStringContext : ULONG) -> HRESULT),
    SetVarHelpStringContext  : (proc "stdcall" (This : ^ICreateTypeInfo2, index : UINT, dwHelpStringContext : ULONG) -> HRESULT),
    Invalidate               : (proc "stdcall" (This : ^ICreateTypeInfo2) -> HRESULT),
    SetName                  : (proc "stdcall" (This : ^ICreateTypeInfo2, szName : LPOLESTR) -> HRESULT),
};

ICreateTypeInfo2 :: struct {
    lpVtbl : ^ICreateTypeInfo2Vtbl,
};

LPCREATETYPELIB :: ^ICreateTypeLib;

ICreateTypeLibVtbl :: struct {
    QueryInterface  : (proc "stdcall" (This : ^ICreateTypeLib, riid : ^IID, ppvObject : ^rawptr) -> HRESULT),
    AddRef          : (proc "stdcall" (This : ^ICreateTypeLib) -> ULONG),
    Release         : (proc "stdcall" (This : ^ICreateTypeLib) -> ULONG),
    CreateTypeInfo  : (proc "stdcall" (This : ^ICreateTypeLib, szName : LPOLESTR, tkind : TYPEKIND, ppCTInfo : ^^ICreateTypeInfo) -> HRESULT),
    SetName         : (proc "stdcall" (This : ^ICreateTypeLib, szName : LPOLESTR) -> HRESULT),
    SetVersion      : (proc "stdcall" (This : ^ICreateTypeLib, wMajorVerNum : WORD, wMinorVerNum : WORD) -> HRESULT),
    SetGuid         : (proc "stdcall" (This : ^ICreateTypeLib, guid : ^GUID) -> HRESULT),
    SetDocString    : (proc "stdcall" (This : ^ICreateTypeLib, szDoc : LPOLESTR) -> HRESULT),
    SetHelpFileName : (proc "stdcall" (This : ^ICreateTypeLib, szHelpFileName : LPOLESTR) -> HRESULT),
    SetHelpContext  : (proc "stdcall" (This : ^ICreateTypeLib, dwHelpContext : DWORD) -> HRESULT),
    SetLcid         : (proc "stdcall" (This : ^ICreateTypeLib, lcid : LCID) -> HRESULT),
    SetLibFlags     : (proc "stdcall" (This : ^ICreateTypeLib, uLibFlags : UINT) -> HRESULT),
    SaveAllChanges  : (proc "stdcall" (This : ^ICreateTypeLib) -> HRESULT),
};

ICreateTypeLib :: struct {
    lpVtbl : ^ICreateTypeLibVtbl,
};

LPCREATETYPELIB2 :: ^ICreateTypeLib2;

ICreateTypeLib2Vtbl :: struct {
    QueryInterface       : (proc "stdcall" (This : ^ICreateTypeLib2, riid : ^IID, ppvObject : ^rawptr) -> HRESULT),
    AddRef               : (proc "stdcall" (This : ^ICreateTypeLib2) -> ULONG),
    Release              : (proc "stdcall" (This : ^ICreateTypeLib2) -> ULONG),
    CreateTypeInfo       : (proc "stdcall" (This : ^ICreateTypeLib2, szName : LPOLESTR, tkind : TYPEKIND, ppCTInfo : ^^ICreateTypeInfo) -> HRESULT),
    SetName              : (proc "stdcall" (This : ^ICreateTypeLib2, szName : LPOLESTR) -> HRESULT),
    SetVersion           : (proc "stdcall" (This : ^ICreateTypeLib2, wMajorVerNum : WORD, wMinorVerNum : WORD) -> HRESULT),
    SetGuid              : (proc "stdcall" (This : ^ICreateTypeLib2, guid : ^GUID) -> HRESULT),
    SetDocString         : (proc "stdcall" (This : ^ICreateTypeLib2, szDoc : LPOLESTR) -> HRESULT),
    SetHelpFileName      : (proc "stdcall" (This : ^ICreateTypeLib2, szHelpFileName : LPOLESTR) -> HRESULT),
    SetHelpContext       : (proc "stdcall" (This : ^ICreateTypeLib2, dwHelpContext : DWORD) -> HRESULT),
    SetLcid              : (proc "stdcall" (This : ^ICreateTypeLib2, lcid : LCID) -> HRESULT),
    SetLibFlags          : (proc "stdcall" (This : ^ICreateTypeLib2, uLibFlags : UINT) -> HRESULT),
    SaveAllChanges       : (proc "stdcall" (This : ^ICreateTypeLib2) -> HRESULT),
    DeleteTypeInfo       : (proc "stdcall" (This : ^ICreateTypeLib2, szName : LPOLESTR) -> HRESULT),
    SetCustData          : (proc "stdcall" (This : ^ICreateTypeLib2, guid : ^GUID, pVarVal : ^VARIANT) -> HRESULT),
    SetHelpStringContext : (proc "stdcall" (This : ^ICreateTypeLib2, dwHelpStringContext : ULONG) -> HRESULT),
    SetHelpStringDll     : (proc "stdcall" (This : ^ICreateTypeLib2, szFileName : LPOLESTR) -> HRESULT),
};

ICreateTypeLib2 :: struct {
    lpVtbl : ^ICreateTypeLib2Vtbl,
};

LPDISPATCH :: ^IDispatch;

IDispatchVtbl :: struct {
    QueryInterface   : (proc "stdcall" (This : ^IDispatch, riid : ^IID, ppvObject : ^rawptr) -> HRESULT),
    AddRef           : (proc "stdcall" (This : ^IDispatch) -> ULONG),
    Release          : (proc "stdcall" (This : ^IDispatch) -> ULONG),
    GetTypeInfoCount : (proc "stdcall" (This : ^IDispatch, pctinfo : ^UINT) -> HRESULT),
    GetTypeInfo      : (proc "stdcall" (This : ^IDispatch, iTInfo : UINT, lcid : LCID, ppTInfo : ^^ITypeInfo) -> HRESULT),
    GetIDsOfNames    : (proc "stdcall" (This : ^IDispatch, riid : ^IID, rgszNames : ^LPOLESTR, cNames : UINT, lcid : LCID, rgDispId : ^DISPID) -> HRESULT),
    Invoke           : (proc "stdcall" (This : ^IDispatch, dispIdMember : DISPID, riid : ^IID, lcid : LCID, wFlags : WORD, pDispParams : ^DISPPARAMS, pVarResult : ^VARIANT, pExcepInfo : ^EXCEPINFO, puArgErr : ^UINT) -> HRESULT),
};

IDispatch :: struct {
    lpVtbl : ^IDispatchVtbl,
};

LPENUMVARIANT :: ^IEnumVARIANT;

IEnumVARIANTVtbl :: struct {
    QueryInterface : (proc "stdcall" (This : ^IEnumVARIANT, riid : ^IID, ppvObject : ^rawptr) -> HRESULT),
    AddRef         : (proc "stdcall" (This : ^IEnumVARIANT) -> ULONG),
    Release        : (proc "stdcall" (This : ^IEnumVARIANT) -> ULONG),
    Next           : (proc "stdcall" (This : ^IEnumVARIANT, celt : ULONG, rgVar : ^VARIANT, pCeltFetched : ^ULONG) -> HRESULT),
    Skip           : (proc "stdcall" (This : ^IEnumVARIANT, celt : ULONG) -> HRESULT),
    Reset          : (proc "stdcall" (This : ^IEnumVARIANT) -> HRESULT),
    Clone          : (proc "stdcall" (This : ^IEnumVARIANT, ppEnum : ^^IEnumVARIANT) -> HRESULT),
};

IEnumVARIANT :: struct {
    lpVtbl : ^IEnumVARIANTVtbl,
};

LPTYPECOMP :: ^ITypeComp;

/* DESCKIND :: enum { */
DESCKIND :: _c.int;
    DESCKIND_NONE :: 0;
    DESCKIND_FUNCDESC :: (DESCKIND_NONE + 1);
    DESCKIND_VARDESC :: (DESCKIND_FUNCDESC + 1);
    DESCKIND_TYPECOMP :: (DESCKIND_VARDESC + 1);
    DESCKIND_IMPLICITAPPOBJ :: (DESCKIND_TYPECOMP + 1);
    DESCKIND_MAX :: (DESCKIND_IMPLICITAPPOBJ + 1);
/* } */
;

BINDPTR :: struct #raw_union {
    lpfuncdesc : ^FUNCDESC,
    lpvardesc  : ^VARDESC,
    lptcomp    : ^ITypeComp,
};

LPBINDPTR :: ^BINDPTR;

ITypeCompVtbl :: struct {
    QueryInterface : (proc "stdcall" (This : ^ITypeComp, riid : ^IID, ppvObject : ^rawptr) -> HRESULT),
    AddRef         : (proc "stdcall" (This : ^ITypeComp) -> ULONG),
    Release        : (proc "stdcall" (This : ^ITypeComp) -> ULONG),
    Bind           : (proc "stdcall" (This : ^ITypeComp, szName : LPOLESTR, lHashVal : ULONG, wFlags : WORD, ppTInfo : ^^ITypeInfo, pDescKind : ^DESCKIND, pBindPtr : ^BINDPTR) -> HRESULT),
    BindType       : (proc "stdcall" (This : ^ITypeComp, szName : LPOLESTR, lHashVal : ULONG, ppTInfo : ^^ITypeInfo, ppTComp : ^^ITypeComp) -> HRESULT),
};

ITypeComp :: struct {
    lpVtbl : ^ITypeCompVtbl,
};

LPTYPEINFO :: ^ITypeInfo;

ITypeInfoVtbl :: struct {
    QueryInterface       : (proc "stdcall" (This : ^ITypeInfo, riid : ^IID, ppvObject : ^rawptr) -> HRESULT),
    AddRef               : (proc "stdcall" (This : ^ITypeInfo) -> ULONG),
    Release              : (proc "stdcall" (This : ^ITypeInfo) -> ULONG),
    GetTypeAttr          : (proc "stdcall" (This : ^ITypeInfo, ppTypeAttr : ^^TYPEATTR) -> HRESULT),
    GetTypeComp          : (proc "stdcall" (This : ^ITypeInfo, ppTComp : ^^ITypeComp) -> HRESULT),
    GetFuncDesc          : (proc "stdcall" (This : ^ITypeInfo, index : UINT, ppFuncDesc : ^^FUNCDESC) -> HRESULT),
    GetVarDesc           : (proc "stdcall" (This : ^ITypeInfo, index : UINT, ppVarDesc : ^^VARDESC) -> HRESULT),
    GetNames             : (proc "stdcall" (This : ^ITypeInfo, memid : MEMBERID, rgBstrNames : ^BSTR, cMaxNames : UINT, pcNames : ^UINT) -> HRESULT),
    GetRefTypeOfImplType : (proc "stdcall" (This : ^ITypeInfo, index : UINT, pRefType : ^HREFTYPE) -> HRESULT),
    GetImplTypeFlags     : (proc "stdcall" (This : ^ITypeInfo, index : UINT, pImplTypeFlags : ^INT) -> HRESULT),
    GetIDsOfNames        : (proc "stdcall" (This : ^ITypeInfo, rgszNames : ^LPOLESTR, cNames : UINT, pMemId : ^MEMBERID) -> HRESULT),
    Invoke               : (proc "stdcall" (This : ^ITypeInfo, pvInstance : PVOID, memid : MEMBERID, wFlags : WORD, pDispParams : ^DISPPARAMS, pVarResult : ^VARIANT, pExcepInfo : ^EXCEPINFO, puArgErr : ^UINT) -> HRESULT),
    GetDocumentation     : (proc "stdcall" (This : ^ITypeInfo, memid : MEMBERID, pBstrName : ^BSTR, pBstrDocString : ^BSTR, pdwHelpContext : ^DWORD, pBstrHelpFile : ^BSTR) -> HRESULT),
    GetDllEntry          : (proc "stdcall" (This : ^ITypeInfo, memid : MEMBERID, invKind : INVOKEKIND, pBstrDllName : ^BSTR, pBstrName : ^BSTR, pwOrdinal : ^WORD) -> HRESULT),
    GetRefTypeInfo       : (proc "stdcall" (This : ^ITypeInfo, hRefType : HREFTYPE, ppTInfo : ^^ITypeInfo) -> HRESULT),
    AddressOfMember      : (proc "stdcall" (This : ^ITypeInfo, memid : MEMBERID, invKind : INVOKEKIND, ppv : ^PVOID) -> HRESULT),
    CreateInstance       : (proc "stdcall" (This : ^ITypeInfo, pUnkOuter : ^IUnknown, riid : ^IID, ppvObj : ^PVOID) -> HRESULT),
    GetMops              : (proc "stdcall" (This : ^ITypeInfo, memid : MEMBERID, pBstrMops : ^BSTR) -> HRESULT),
    GetContainingTypeLib : (proc "stdcall" (This : ^ITypeInfo, ppTLib : ^^ITypeLib, pIndex : ^UINT) -> HRESULT),
    ReleaseTypeAttr      : proc "stdcall" (This : ^ITypeInfo, pTypeAttr : ^TYPEATTR),
    ReleaseFuncDesc      : proc "stdcall" (This : ^ITypeInfo, pFuncDesc : ^FUNCDESC),
    ReleaseVarDesc       : proc "stdcall" (This : ^ITypeInfo, pVarDesc : ^VARDESC),
};

ITypeInfo :: struct {
    lpVtbl : ^ITypeInfoVtbl,
};

LPTYPEINFO2 :: ^ITypeInfo2;

ITypeInfo2Vtbl :: struct {
    QueryInterface         : (proc "stdcall" (This : ^ITypeInfo2, riid : ^IID, ppvObject : ^rawptr) -> HRESULT),
    AddRef                 : (proc "stdcall" (This : ^ITypeInfo2) -> ULONG),
    Release                : (proc "stdcall" (This : ^ITypeInfo2) -> ULONG),
    GetTypeAttr            : (proc "stdcall" (This : ^ITypeInfo2, ppTypeAttr : ^^TYPEATTR) -> HRESULT),
    GetTypeComp            : (proc "stdcall" (This : ^ITypeInfo2, ppTComp : ^^ITypeComp) -> HRESULT),
    GetFuncDesc            : (proc "stdcall" (This : ^ITypeInfo2, index : UINT, ppFuncDesc : ^^FUNCDESC) -> HRESULT),
    GetVarDesc             : (proc "stdcall" (This : ^ITypeInfo2, index : UINT, ppVarDesc : ^^VARDESC) -> HRESULT),
    GetNames               : (proc "stdcall" (This : ^ITypeInfo2, memid : MEMBERID, rgBstrNames : ^BSTR, cMaxNames : UINT, pcNames : ^UINT) -> HRESULT),
    GetRefTypeOfImplType   : (proc "stdcall" (This : ^ITypeInfo2, index : UINT, pRefType : ^HREFTYPE) -> HRESULT),
    GetImplTypeFlags       : (proc "stdcall" (This : ^ITypeInfo2, index : UINT, pImplTypeFlags : ^INT) -> HRESULT),
    GetIDsOfNames          : (proc "stdcall" (This : ^ITypeInfo2, rgszNames : ^LPOLESTR, cNames : UINT, pMemId : ^MEMBERID) -> HRESULT),
    Invoke                 : (proc "stdcall" (This : ^ITypeInfo2, pvInstance : PVOID, memid : MEMBERID, wFlags : WORD, pDispParams : ^DISPPARAMS, pVarResult : ^VARIANT, pExcepInfo : ^EXCEPINFO, puArgErr : ^UINT) -> HRESULT),
    GetDocumentation       : (proc "stdcall" (This : ^ITypeInfo2, memid : MEMBERID, pBstrName : ^BSTR, pBstrDocString : ^BSTR, pdwHelpContext : ^DWORD, pBstrHelpFile : ^BSTR) -> HRESULT),
    GetDllEntry            : (proc "stdcall" (This : ^ITypeInfo2, memid : MEMBERID, invKind : INVOKEKIND, pBstrDllName : ^BSTR, pBstrName : ^BSTR, pwOrdinal : ^WORD) -> HRESULT),
    GetRefTypeInfo         : (proc "stdcall" (This : ^ITypeInfo2, hRefType : HREFTYPE, ppTInfo : ^^ITypeInfo) -> HRESULT),
    AddressOfMember        : (proc "stdcall" (This : ^ITypeInfo2, memid : MEMBERID, invKind : INVOKEKIND, ppv : ^PVOID) -> HRESULT),
    CreateInstance         : (proc "stdcall" (This : ^ITypeInfo2, pUnkOuter : ^IUnknown, riid : ^IID, ppvObj : ^PVOID) -> HRESULT),
    GetMops                : (proc "stdcall" (This : ^ITypeInfo2, memid : MEMBERID, pBstrMops : ^BSTR) -> HRESULT),
    GetContainingTypeLib   : (proc "stdcall" (This : ^ITypeInfo2, ppTLib : ^^ITypeLib, pIndex : ^UINT) -> HRESULT),
    ReleaseTypeAttr        : proc "stdcall" (This : ^ITypeInfo2, pTypeAttr : ^TYPEATTR),
    ReleaseFuncDesc        : proc "stdcall" (This : ^ITypeInfo2, pFuncDesc : ^FUNCDESC),
    ReleaseVarDesc         : proc "stdcall" (This : ^ITypeInfo2, pVarDesc : ^VARDESC),
    GetTypeKind            : (proc "stdcall" (This : ^ITypeInfo2, pTypeKind : ^TYPEKIND) -> HRESULT),
    GetTypeFlags           : (proc "stdcall" (This : ^ITypeInfo2, pTypeFlags : ^ULONG) -> HRESULT),
    GetFuncIndexOfMemId    : (proc "stdcall" (This : ^ITypeInfo2, memid : MEMBERID, invKind : INVOKEKIND, pFuncIndex : ^UINT) -> HRESULT),
    GetVarIndexOfMemId     : (proc "stdcall" (This : ^ITypeInfo2, memid : MEMBERID, pVarIndex : ^UINT) -> HRESULT),
    GetCustData            : (proc "stdcall" (This : ^ITypeInfo2, guid : ^GUID, pVarVal : ^VARIANT) -> HRESULT),
    GetFuncCustData        : (proc "stdcall" (This : ^ITypeInfo2, index : UINT, guid : ^GUID, pVarVal : ^VARIANT) -> HRESULT),
    GetParamCustData       : (proc "stdcall" (This : ^ITypeInfo2, indexFunc : UINT, indexParam : UINT, guid : ^GUID, pVarVal : ^VARIANT) -> HRESULT),
    GetVarCustData         : (proc "stdcall" (This : ^ITypeInfo2, index : UINT, guid : ^GUID, pVarVal : ^VARIANT) -> HRESULT),
    GetImplTypeCustData    : (proc "stdcall" (This : ^ITypeInfo2, index : UINT, guid : ^GUID, pVarVal : ^VARIANT) -> HRESULT),
    GetDocumentation2      : (proc "stdcall" (This : ^ITypeInfo2, memid : MEMBERID, lcid : LCID, pbstrHelpString : ^BSTR, pdwHelpStringContext : ^DWORD, pbstrHelpStringDll : ^BSTR) -> HRESULT),
    GetAllCustData         : (proc "stdcall" (This : ^ITypeInfo2, pCustData : ^CUSTDATA) -> HRESULT),
    GetAllFuncCustData     : (proc "stdcall" (This : ^ITypeInfo2, index : UINT, pCustData : ^CUSTDATA) -> HRESULT),
    GetAllParamCustData    : (proc "stdcall" (This : ^ITypeInfo2, indexFunc : UINT, indexParam : UINT, pCustData : ^CUSTDATA) -> HRESULT),
    GetAllVarCustData      : (proc "stdcall" (This : ^ITypeInfo2, index : UINT, pCustData : ^CUSTDATA) -> HRESULT),
    GetAllImplTypeCustData : (proc "stdcall" (This : ^ITypeInfo2, index : UINT, pCustData : ^CUSTDATA) -> HRESULT),
};

ITypeInfo2 :: struct {
    lpVtbl : ^ITypeInfo2Vtbl,
};

/* SYSKIND :: enum { */
SYSKIND :: _c.int;
    SYS_WIN16 :: 0;
    SYS_WIN32 :: (SYS_WIN16 + 1);
    SYS_MAC :: (SYS_WIN32 + 1);
    SYS_WIN64 :: (SYS_MAC + 1);
/* } */
;

/* LIBFLAGS :: enum { */
LIBFLAGS :: _c.int;
    LIBFLAG_FRESTRICTED :: 0x1;
    LIBFLAG_FCONTROL :: 0x2;
    LIBFLAG_FHIDDEN :: 0x4;
    LIBFLAG_FHASDISKIMAGE :: 0x8;
/* } */
;

LPTYPELIB :: ^ITypeLib;

TLIBATTR :: struct {
    guid         : GUID,
    lcid         : LCID,
    syskind      : SYSKIND,
    wMajorVerNum : WORD,
    wMinorVerNum : WORD,
    wLibFlags    : WORD,
};

LPTLIBATTR :: ^TLIBATTR;

ITypeLibVtbl :: struct {
    QueryInterface    : (proc "stdcall" (This : ^ITypeLib, riid : ^IID, ppvObject : ^rawptr) -> HRESULT),
    AddRef            : (proc "stdcall" (This : ^ITypeLib) -> ULONG),
    Release           : (proc "stdcall" (This : ^ITypeLib) -> ULONG),
    GetTypeInfoCount  : (proc "stdcall" (This : ^ITypeLib) -> UINT),
    GetTypeInfo       : (proc "stdcall" (This : ^ITypeLib, index : UINT, ppTInfo : ^^ITypeInfo) -> HRESULT),
    GetTypeInfoType   : (proc "stdcall" (This : ^ITypeLib, index : UINT, pTKind : ^TYPEKIND) -> HRESULT),
    GetTypeInfoOfGuid : (proc "stdcall" (This : ^ITypeLib, guid : ^GUID, ppTinfo : ^^ITypeInfo) -> HRESULT),
    GetLibAttr        : (proc "stdcall" (This : ^ITypeLib, ppTLibAttr : ^^TLIBATTR) -> HRESULT),
    GetTypeComp       : (proc "stdcall" (This : ^ITypeLib, ppTComp : ^^ITypeComp) -> HRESULT),
    GetDocumentation  : (proc "stdcall" (This : ^ITypeLib, index : INT, pBstrName : ^BSTR, pBstrDocString : ^BSTR, pdwHelpContext : ^DWORD, pBstrHelpFile : ^BSTR) -> HRESULT),
    IsName            : (proc "stdcall" (This : ^ITypeLib, szNameBuf : LPOLESTR, lHashVal : ULONG, pfName : ^BOOL) -> HRESULT),
    FindName          : (proc "stdcall" (This : ^ITypeLib, szNameBuf : LPOLESTR, lHashVal : ULONG, ppTInfo : ^^ITypeInfo, rgMemId : ^MEMBERID, pcFound : ^USHORT) -> HRESULT),
    ReleaseTLibAttr   : proc "stdcall" (This : ^ITypeLib, pTLibAttr : ^TLIBATTR),
};

ITypeLib :: struct {
    lpVtbl : ^ITypeLibVtbl,
};

LPTYPELIB2 :: ^ITypeLib2;

ITypeLib2Vtbl :: struct {
    QueryInterface    : (proc "stdcall" (This : ^ITypeLib2, riid : ^IID, ppvObject : ^rawptr) -> HRESULT),
    AddRef            : (proc "stdcall" (This : ^ITypeLib2) -> ULONG),
    Release           : (proc "stdcall" (This : ^ITypeLib2) -> ULONG),
    GetTypeInfoCount  : (proc "stdcall" (This : ^ITypeLib2) -> UINT),
    GetTypeInfo       : (proc "stdcall" (This : ^ITypeLib2, index : UINT, ppTInfo : ^^ITypeInfo) -> HRESULT),
    GetTypeInfoType   : (proc "stdcall" (This : ^ITypeLib2, index : UINT, pTKind : ^TYPEKIND) -> HRESULT),
    GetTypeInfoOfGuid : (proc "stdcall" (This : ^ITypeLib2, guid : ^GUID, ppTinfo : ^^ITypeInfo) -> HRESULT),
    GetLibAttr        : (proc "stdcall" (This : ^ITypeLib2, ppTLibAttr : ^^TLIBATTR) -> HRESULT),
    GetTypeComp       : (proc "stdcall" (This : ^ITypeLib2, ppTComp : ^^ITypeComp) -> HRESULT),
    GetDocumentation  : (proc "stdcall" (This : ^ITypeLib2, index : INT, pBstrName : ^BSTR, pBstrDocString : ^BSTR, pdwHelpContext : ^DWORD, pBstrHelpFile : ^BSTR) -> HRESULT),
    IsName            : (proc "stdcall" (This : ^ITypeLib2, szNameBuf : LPOLESTR, lHashVal : ULONG, pfName : ^BOOL) -> HRESULT),
    FindName          : (proc "stdcall" (This : ^ITypeLib2, szNameBuf : LPOLESTR, lHashVal : ULONG, ppTInfo : ^^ITypeInfo, rgMemId : ^MEMBERID, pcFound : ^USHORT) -> HRESULT),
    ReleaseTLibAttr   : proc "stdcall" (This : ^ITypeLib2, pTLibAttr : ^TLIBATTR),
    GetCustData       : (proc "stdcall" (This : ^ITypeLib2, guid : ^GUID, pVarVal : ^VARIANT) -> HRESULT),
    GetLibStatistics  : (proc "stdcall" (This : ^ITypeLib2, pcUniqueNames : ^ULONG, pcchUniqueNames : ^ULONG) -> HRESULT),
    GetDocumentation2 : (proc "stdcall" (This : ^ITypeLib2, index : INT, lcid : LCID, pbstrHelpString : ^BSTR, pdwHelpStringContext : ^DWORD, pbstrHelpStringDll : ^BSTR) -> HRESULT),
    GetAllCustData    : (proc "stdcall" (This : ^ITypeLib2, pCustData : ^CUSTDATA) -> HRESULT),
};

ITypeLib2 :: struct {
    lpVtbl : ^ITypeLib2Vtbl,
};

LPTYPECHANGEEVENTS :: ^ITypeChangeEvents;

/* CHANGEKIND :: enum { */
CHANGEKIND :: _c.int;
    CHANGEKIND_ADDMEMBER :: 0;
    CHANGEKIND_DELETEMEMBER :: (CHANGEKIND_ADDMEMBER + 1);
    CHANGEKIND_SETNAMES :: (CHANGEKIND_DELETEMEMBER + 1);
    CHANGEKIND_SETDOCUMENTATION :: (CHANGEKIND_SETNAMES + 1);
    CHANGEKIND_GENERAL :: (CHANGEKIND_SETDOCUMENTATION + 1);
    CHANGEKIND_INVALIDATE :: (CHANGEKIND_GENERAL + 1);
    CHANGEKIND_CHANGEFAILED :: (CHANGEKIND_INVALIDATE + 1);
    CHANGEKIND_MAX :: (CHANGEKIND_CHANGEFAILED + 1);
/* } */
;

ITypeChangeEventsVtbl :: struct {
    QueryInterface    : (proc "stdcall" (This : ^ITypeChangeEvents, riid : ^IID, ppvObject : ^rawptr) -> HRESULT),
    AddRef            : (proc "stdcall" (This : ^ITypeChangeEvents) -> ULONG),
    Release           : (proc "stdcall" (This : ^ITypeChangeEvents) -> ULONG),
    RequestTypeChange : (proc "stdcall" (This : ^ITypeChangeEvents, changeKind : CHANGEKIND, pTInfoBefore : ^ITypeInfo, pStrName : LPOLESTR, pfCancel : ^INT) -> HRESULT),
    AfterTypeChange   : (proc "stdcall" (This : ^ITypeChangeEvents, changeKind : CHANGEKIND, pTInfoAfter : ^ITypeInfo, pStrName : LPOLESTR) -> HRESULT),
};

ITypeChangeEvents :: struct {
    lpVtbl : ^ITypeChangeEventsVtbl,
};

LPERRORINFO :: ^IErrorInfo;

IErrorInfoVtbl :: struct {
    QueryInterface : (proc "stdcall" (This : ^IErrorInfo, riid : ^IID, ppvObject : ^rawptr) -> HRESULT),
    AddRef         : (proc "stdcall" (This : ^IErrorInfo) -> ULONG),
    Release        : (proc "stdcall" (This : ^IErrorInfo) -> ULONG),
    GetGUID        : (proc "stdcall" (This : ^IErrorInfo, pGUID : ^GUID) -> HRESULT),
    GetSource      : (proc "stdcall" (This : ^IErrorInfo, pBstrSource : ^BSTR) -> HRESULT),
    GetDescription : (proc "stdcall" (This : ^IErrorInfo, pBstrDescription : ^BSTR) -> HRESULT),
    GetHelpFile    : (proc "stdcall" (This : ^IErrorInfo, pBstrHelpFile : ^BSTR) -> HRESULT),
    GetHelpContext : (proc "stdcall" (This : ^IErrorInfo, pdwHelpContext : ^DWORD) -> HRESULT),
};

IErrorInfo :: struct {
    lpVtbl : ^IErrorInfoVtbl,
};

LPCREATEERRORINFO :: ^ICreateErrorInfo;

ICreateErrorInfoVtbl :: struct {
    QueryInterface : (proc "stdcall" (This : ^ICreateErrorInfo, riid : ^IID, ppvObject : ^rawptr) -> HRESULT),
    AddRef         : (proc "stdcall" (This : ^ICreateErrorInfo) -> ULONG),
    Release        : (proc "stdcall" (This : ^ICreateErrorInfo) -> ULONG),
    SetGUID        : (proc "stdcall" (This : ^ICreateErrorInfo, rguid : ^GUID) -> HRESULT),
    SetSource      : (proc "stdcall" (This : ^ICreateErrorInfo, szSource : LPOLESTR) -> HRESULT),
    SetDescription : (proc "stdcall" (This : ^ICreateErrorInfo, szDescription : LPOLESTR) -> HRESULT),
    SetHelpFile    : (proc "stdcall" (This : ^ICreateErrorInfo, szHelpFile : LPOLESTR) -> HRESULT),
    SetHelpContext : (proc "stdcall" (This : ^ICreateErrorInfo, dwHelpContext : DWORD) -> HRESULT),
};

ICreateErrorInfo :: struct {
    lpVtbl : ^ICreateErrorInfoVtbl,
};

LPSUPPORTERRORINFO :: ^ISupportErrorInfo;

ISupportErrorInfoVtbl :: struct {
    QueryInterface             : (proc "stdcall" (This : ^ISupportErrorInfo, riid : ^IID, ppvObject : ^rawptr) -> HRESULT),
    AddRef                     : (proc "stdcall" (This : ^ISupportErrorInfo) -> ULONG),
    Release                    : (proc "stdcall" (This : ^ISupportErrorInfo) -> ULONG),
    InterfaceSupportsErrorInfo : (proc "stdcall" (This : ^ISupportErrorInfo, riid : ^IID) -> HRESULT),
};

ISupportErrorInfo :: struct {
    lpVtbl : ^ISupportErrorInfoVtbl,
};

ITypeFactoryVtbl :: struct {
    QueryInterface     : (proc "stdcall" (This : ^ITypeFactory, riid : ^IID, ppvObject : ^rawptr) -> HRESULT),
    AddRef             : (proc "stdcall" (This : ^ITypeFactory) -> ULONG),
    Release            : (proc "stdcall" (This : ^ITypeFactory) -> ULONG),
    CreateFromTypeInfo : (proc "stdcall" (This : ^ITypeFactory, pTypeInfo : ^ITypeInfo, riid : ^IID, ppv : ^^IUnknown) -> HRESULT),
};

ITypeFactory :: struct {
    lpVtbl : ^ITypeFactoryVtbl,
};

ITypeMarshalVtbl :: struct {
    QueryInterface : (proc "stdcall" (This : ^ITypeMarshal, riid : ^IID, ppvObject : ^rawptr) -> HRESULT),
    AddRef         : (proc "stdcall" (This : ^ITypeMarshal) -> ULONG),
    Release        : (proc "stdcall" (This : ^ITypeMarshal) -> ULONG),
    Size           : (proc "stdcall" (This : ^ITypeMarshal, pvType : PVOID, dwDestContext : DWORD, pvDestContext : PVOID, pSize : ^ULONG) -> HRESULT),
    Marshal        : (proc "stdcall" (This : ^ITypeMarshal, pvType : PVOID, dwDestContext : DWORD, pvDestContext : PVOID, cbBufferLength : ULONG, pBuffer : ^BYTE, pcbWritten : ^ULONG) -> HRESULT),
    Unmarshal      : (proc "stdcall" (This : ^ITypeMarshal, pvType : PVOID, dwFlags : DWORD, cbBufferLength : ULONG, pBuffer : ^BYTE, pcbRead : ^ULONG) -> HRESULT),
    Free           : (proc "stdcall" (This : ^ITypeMarshal, pvType : PVOID) -> HRESULT),
};

ITypeMarshal :: struct {
    lpVtbl : ^ITypeMarshalVtbl,
};

LPRECORDINFO :: ^IRecordInfo;

IRecordInfoVtbl :: struct {
    QueryInterface   : (proc "stdcall" (This : ^IRecordInfo, riid : ^IID, ppvObject : ^rawptr) -> HRESULT),
    AddRef           : (proc "stdcall" (This : ^IRecordInfo) -> ULONG),
    Release          : (proc "stdcall" (This : ^IRecordInfo) -> ULONG),
    RecordInit       : (proc "stdcall" (This : ^IRecordInfo, pvNew : PVOID) -> HRESULT),
    RecordClear      : (proc "stdcall" (This : ^IRecordInfo, pvExisting : PVOID) -> HRESULT),
    RecordCopy       : (proc "stdcall" (This : ^IRecordInfo, pvExisting : PVOID, pvNew : PVOID) -> HRESULT),
    GetGuid          : (proc "stdcall" (This : ^IRecordInfo, pguid : ^GUID) -> HRESULT),
    GetName          : (proc "stdcall" (This : ^IRecordInfo, pbstrName : ^BSTR) -> HRESULT),
    GetSize          : (proc "stdcall" (This : ^IRecordInfo, pcbSize : ^ULONG) -> HRESULT),
    GetTypeInfo      : (proc "stdcall" (This : ^IRecordInfo, ppTypeInfo : ^^ITypeInfo) -> HRESULT),
    GetField         : (proc "stdcall" (This : ^IRecordInfo, pvData : PVOID, szFieldName : LPCOLESTR, pvarField : ^VARIANT) -> HRESULT),
    GetFieldNoCopy   : (proc "stdcall" (This : ^IRecordInfo, pvData : PVOID, szFieldName : LPCOLESTR, pvarField : ^VARIANT, ppvDataCArray : ^PVOID) -> HRESULT),
    PutField         : (proc "stdcall" (This : ^IRecordInfo, wFlags : ULONG, pvData : PVOID, szFieldName : LPCOLESTR, pvarField : ^VARIANT) -> HRESULT),
    PutFieldNoCopy   : (proc "stdcall" (This : ^IRecordInfo, wFlags : ULONG, pvData : PVOID, szFieldName : LPCOLESTR, pvarField : ^VARIANT) -> HRESULT),
    GetFieldNames    : (proc "stdcall" (This : ^IRecordInfo, pcNames : ^ULONG, rgBstrNames : ^BSTR) -> HRESULT),
    IsMatchingType   : (proc "stdcall" (This : ^IRecordInfo, pRecordInfo : ^IRecordInfo) -> BOOL),
    RecordCreate     : (proc "stdcall" (This : ^IRecordInfo) -> PVOID),
    RecordCreateCopy : (proc "stdcall" (This : ^IRecordInfo, pvSource : PVOID, ppvDest : ^PVOID) -> HRESULT),
    RecordDestroy    : (proc "stdcall" (This : ^IRecordInfo, pvRecord : PVOID) -> HRESULT),
};

IRecordInfo :: struct {
    lpVtbl : ^IRecordInfoVtbl,
};

LPERRORLOG :: ^IErrorLog;

IErrorLogVtbl :: struct {
    QueryInterface : (proc "stdcall" (This : ^IErrorLog, riid : ^IID, ppvObject : ^rawptr) -> HRESULT),
    AddRef         : (proc "stdcall" (This : ^IErrorLog) -> ULONG),
    Release        : (proc "stdcall" (This : ^IErrorLog) -> ULONG),
    AddError       : (proc "stdcall" (This : ^IErrorLog, pszPropName : LPCOLESTR, pExcepInfo : ^EXCEPINFO) -> HRESULT),
};

IErrorLog :: struct {
    lpVtbl : ^IErrorLogVtbl,
};

LPPROPERTYBAG :: ^IPropertyBag;

IPropertyBagVtbl :: struct {
    QueryInterface : (proc "stdcall" (This : ^IPropertyBag, riid : ^IID, ppvObject : ^rawptr) -> HRESULT),
    AddRef         : (proc "stdcall" (This : ^IPropertyBag) -> ULONG),
    Release        : (proc "stdcall" (This : ^IPropertyBag) -> ULONG),
    Read           : (proc "stdcall" (This : ^IPropertyBag, pszPropName : LPCOLESTR, pVar : ^VARIANT, pErrorLog : ^IErrorLog) -> HRESULT),
    Write          : (proc "stdcall" (This : ^IPropertyBag, pszPropName : LPCOLESTR, pVar : ^VARIANT) -> HRESULT),
};

IPropertyBag :: struct {
    lpVtbl : ^IPropertyBagVtbl,
};

ITypeLibRegistrationReaderVtbl :: struct {
    QueryInterface           : (proc "stdcall" (This : ^ITypeLibRegistrationReader, riid : ^IID, ppvObject : ^rawptr) -> HRESULT),
    AddRef                   : (proc "stdcall" (This : ^ITypeLibRegistrationReader) -> ULONG),
    Release                  : (proc "stdcall" (This : ^ITypeLibRegistrationReader) -> ULONG),
    EnumTypeLibRegistrations : (proc "stdcall" (This : ^ITypeLibRegistrationReader, ppEnumUnknown : ^^IEnumUnknown) -> HRESULT),
};

ITypeLibRegistrationReader :: struct {
    lpVtbl : ^ITypeLibRegistrationReaderVtbl,
};

ITypeLibRegistrationVtbl :: struct {
    QueryInterface : (proc "stdcall" (This : ^ITypeLibRegistration, riid : ^IID, ppvObject : ^rawptr) -> HRESULT),
    AddRef         : (proc "stdcall" (This : ^ITypeLibRegistration) -> ULONG),
    Release        : (proc "stdcall" (This : ^ITypeLibRegistration) -> ULONG),
    GetGuid        : (proc "stdcall" (This : ^ITypeLibRegistration, pGuid : ^GUID) -> HRESULT),
    GetVersion     : (proc "stdcall" (This : ^ITypeLibRegistration, pVersion : ^BSTR) -> HRESULT),
    GetLcid        : (proc "stdcall" (This : ^ITypeLibRegistration, pLcid : ^LCID) -> HRESULT),
    GetWin32Path   : (proc "stdcall" (This : ^ITypeLibRegistration, pWin32Path : ^BSTR) -> HRESULT),
    GetWin64Path   : (proc "stdcall" (This : ^ITypeLibRegistration, pWin64Path : ^BSTR) -> HRESULT),
    GetDisplayName : (proc "stdcall" (This : ^ITypeLibRegistration, pDisplayName : ^BSTR) -> HRESULT),
    GetFlags       : (proc "stdcall" (This : ^ITypeLibRegistration, pFlags : ^DWORD) -> HRESULT),
    GetHelpDir     : (proc "stdcall" (This : ^ITypeLibRegistration, pHelpDir : ^BSTR) -> HRESULT),
};

ITypeLibRegistration :: struct {
    lpVtbl : ^ITypeLibRegistrationVtbl,
};

VERSIONEDSTREAM :: struct {
    guidVersion : GUID,
    pStream     : ^IStream,
};

LPVERSIONEDSTREAM :: ^VERSIONEDSTREAM;

;

CAC :: struct {
    cElems : ULONG,
    pElems : ^CHAR,
};

CAUB :: struct {
    cElems : ULONG,
    pElems : ^UCHAR,
};

CAI :: struct {
    cElems : ULONG,
    pElems : ^SHORT,
};

CAUI :: struct {
    cElems : ULONG,
    pElems : ^USHORT,
};

CAL :: struct {
    cElems : ULONG,
    pElems : ^LONG,
};

CAUL :: struct {
    cElems : ULONG,
    pElems : ^ULONG,
};

CAFLT :: struct {
    cElems : ULONG,
    pElems : ^FLOAT,
};

CADBL :: struct {
    cElems : ULONG,
    pElems : ^DOUBLE,
};

CACY :: struct {
    cElems : ULONG,
    pElems : ^CY,
};

CADATE :: struct {
    cElems : ULONG,
    pElems : ^DATE,
};

CABSTR :: struct {
    cElems : ULONG,
    pElems : ^BSTR,
};

CABSTRBLOB :: struct {
    cElems : ULONG,
    pElems : ^BSTRBLOB,
};

CABOOL :: struct {
    cElems : ULONG,
    pElems : ^VARIANT_BOOL,
};

CASCODE :: struct {
    cElems : ULONG,
    pElems : ^SCODE,
};

CAPROPVARIANT :: struct {
    cElems : ULONG,
    pElems : ^PROPVARIANT,
};

CAH :: struct {
    cElems : ULONG,
    pElems : ^LARGE_INTEGER,
};

CAUH :: struct {
    cElems : ULONG,
    pElems : ^ULARGE_INTEGER,
};

CALPSTR :: struct {
    cElems : ULONG,
    pElems : ^LPSTR,
};

CALPWSTR :: struct {
    cElems : ULONG,
    pElems : ^LPWSTR,
};

CAFILETIME :: struct {
    cElems : ULONG,
    pElems : ^FILETIME,
};

CACLIPDATA :: struct {
    cElems : ULONG,
    pElems : ^CLIPDATA,
};

CACLSID :: struct {
    cElems : ULONG,
    pElems : ^CLSID,
};

PROPVAR_PAD1 :: WORD;

PROPVAR_PAD2 :: WORD;

PROPVAR_PAD3 :: WORD;

LPPROPVARIANT :: ^PROPVARIANT;

PROPSPEC :: struct {
    ulKind : ULONG,
    u : struct #raw_union {
        propid : PROPID,
        lpwstr : LPOLESTR,
    },
};

STATPROPSTG :: struct {
    lpwstrName : LPOLESTR,
    propid     : PROPID,
    vt         : VARTYPE,
};

STATPROPSETSTG :: struct {
    fmtid       : FMTID,
    clsid       : CLSID,
    grfFlags    : DWORD,
    mtime       : FILETIME,
    ctime       : FILETIME,
    atime       : FILETIME,
    dwOSVersion : DWORD,
};

IPropertyStorageVtbl :: struct {
    QueryInterface      : (proc "stdcall" (This : ^IPropertyStorage, riid : ^IID, ppvObject : ^rawptr) -> HRESULT),
    AddRef              : (proc "stdcall" (This : ^IPropertyStorage) -> ULONG),
    Release             : (proc "stdcall" (This : ^IPropertyStorage) -> ULONG),
    ReadMultiple        : (proc "stdcall" (This : ^IPropertyStorage, cpspec : ULONG, rgpspec : []PROPSPEC, rgpropvar : []PROPVARIANT) -> HRESULT),
    WriteMultiple       : (proc "stdcall" (This : ^IPropertyStorage, cpspec : ULONG, rgpspec : []PROPSPEC, rgpropvar : []PROPVARIANT, propidNameFirst : PROPID) -> HRESULT),
    DeleteMultiple      : (proc "stdcall" (This : ^IPropertyStorage, cpspec : ULONG, rgpspec : []PROPSPEC) -> HRESULT),
    ReadPropertyNames   : (proc "stdcall" (This : ^IPropertyStorage, cpropid : ULONG, rgpropid : []PROPID, rglpwstrName : []LPOLESTR) -> HRESULT),