win32-def/dist/index.struct.cjs

win32 definitions for node-ffi

/**
 * win32-def
 * win32 definitions for node-ffi
 *
 * @version 26.1.1
 * @author waiting
 * @license MIT
 * @link https://waitingsong.github.io/node-win32-api
 */

'use strict';

var assert = require('node:assert');
var ffi = require('koffi');

/* eslint-disable @typescript-eslint/no-explicit-any */
/**
 * @link https://koffi.dev/functions#calling-conventions
 */
var CallingConvention;
(function (CallingConvention) {
    CallingConvention["Cdecl"] = "";
    CallingConvention["Stdcall"] = "__stdcall";
    CallingConvention["Fastcall"] = "__fastcall";
    CallingConvention["Thiscall"] = "__thiscall";
})(CallingConvention || (CallingConvention = {}));

// dict of windef value
const config = {
    _WIN64: process.arch === 'x64',
};
({
    convention: CallingConvention.Cdecl});

/**
 * @link https://koffi.dev/input
 * @link https://tootallnate.github.io/ref/
 */
var Def;
(function (Def) {
    Def["bool"] = "bool";
    Def["byte"] = "uint8_t";
    Def["int"] = "int";
    Def["int8"] = "int8_t";
    Def["int16"] = "int16_t";
    Def["int32"] = "int32_t";
    Def["int64"] = "int64_t";
    Def["float"] = "float";
    Def["long"] = "long";
    Def["longlong"] = "longlong";
    // ptr = 'pointer',
    Def["uchar"] = "uchar";
    Def["uint"] = "uint";
    Def["uint8"] = "uint8_t";
    Def["uint16"] = "uint16_t";
    Def["uint32"] = "uint32_t";
    Def["uint64"] = "uint64_t";
    Def["ulong"] = "ulong";
    Def["ulonglong"] = "ulonglong";
    Def["ushort"] = "ushort";
    Def["void"] = "void";
    Def["boolPtr"] = "bool*";
    Def["bytePtr"] = "uint8_t*";
    Def["charPtr"] = "char*";
    Def["intPtr"] = "int*";
    Def["int8Ptr"] = "int8_t*";
    Def["int16Ptr"] = "int16_t*";
    Def["int32Ptr"] = "int32_t*";
    Def["int64Ptr"] = "int64_t*";
    Def["floatPtr"] = "float*";
    Def["longPtr"] = "long*";
    Def["uintPtr"] = "uint*";
    Def["uint8Ptr"] = "uint8_t*";
    Def["intPtrPtr"] = "int**";
    Def["uint16Ptr"] = "uint16_t*";
    Def["uint32Ptr"] = "uint32_t*";
    Def["uint64Ptr"] = "uint64_t*";
    Def["ulonglongPtr"] = "ulonglong*";
    Def["voidPtr"] = "void*";
    Def["uintPtrPtr"] = "uint**";
    Def["uint16PtrPtr"] = "uint16_t**";
    Def["uint32PtrPtr"] = "uint32_t**";
    Def["uint64PtrPtr"] = "uint64_t**";
    Def["ulonglongPtrPtr"] = "ulonglong**";
    Def["voidPtrPtr"] = "void**";
})(Def || (Def = {}));

// windows data types for ref module https://github.com/TooTallNate/ref
// https://msdn.microsoft.com/en-us/library/windows/desktop/aa383751
const { _WIN64 } = config;
/**
 * @link https://docs.microsoft.com/en-us/windows/win32/secauthz/access-mask-format
 */
const ACCESS_MASK = Def.int32;
const ATOM = Def.uint16;
const DWORD = Def.uint32;
_WIN64 ? Def.uint64Ptr : Def.uint32Ptr;
const PVOID = Def.voidPtr;
/**
 * `uint32` or `uint64` used as value usage (memory address) instead of PVOID (Buffer),
 * Use `HANDLE` (number) for params definition of the api,
 * @see https://stackoverflow.com/questions/18266626/what-is-the-range-of-a-windows-handle-on-a-64-bits-application/29526711#29526711
 */
const HANDLE = _WIN64 ? Def.uint64 : Def.uint32;
const LONG_PTR = _WIN64 ? Def.int64 : Def.int32;
const ULONG_PTR = _WIN64 ? Def.int64 : Def.int32;
Def.void;
Def.uint16;
const WORD = Def.int16;
const BOOL = Def.int32;
Def.bool;
const BYTE = Def.byte;
Def.uint8;
Def.uint8;
// export const CONST;
Def.uint64;
Def.uint32;
Def.uint64;
Def.float;
_WIN64 ? Def.int32 : Def.int16;
const HBRUSH = HANDLE;
const HCURSOR = HANDLE;
const HICON = HANDLE;
const HINSTANCE = HANDLE;
Def.long;
const HWND = HANDLE;
/** A 32-bit signed integer */
const INT = Def.int;
_WIN64 ? Def.int64Ptr : Def.int32Ptr;
Def.int8;
Def.int16;
Def.int32;
Def.int64;
const LONG = Def.long;
Def.longlong;
Def.int32;
Def.int64;
const LPARAM = LONG_PTR;
Def.bytePtr;
Def.int8Ptr;
Def.int16Ptr;
Def.int16Ptr;
Def.voidPtr;
Def.uint16Ptr;
_WIN64 ? Def.int64Ptr : Def.int32Ptr;
Def.int32Ptr;
Def.charPtr;
Def.uint16Ptr;
const LPTSTR = Def.uint16Ptr;
Def.uint16Ptr;
Def.uint32;
Def.boolPtr;
Def.bytePtr;
Def.charPtr;
Def.uint8Ptr;
_WIN64 ? Def.int16Ptr : Def.int8Ptr;
Def.uint16Ptr;
Def.uint32Ptr;
Def.uint64Ptr;
Def.uint32Ptr;
Def.uint64Ptr;
Def.floatPtr;
_WIN64 ? Def.uint64PtrPtr : Def.uint32PtrPtr;
_WIN64 ? Def.uint64PtrPtr : Def.uint32PtrPtr;
Def.intPtrPtr;
Def.int8Ptr;
Def.int16Ptr;
Def.int32Ptr;
Def.int64Ptr;
Def.uint32Ptr;
Def.longPtr;
Def.int64Ptr;
Def.int32Ptr;
Def.int64Ptr;
// ? A 32-bit pointer. On a 32-bit system, this is a native pointer.
// On a 64-bit system, this is a truncated 64-bit pointer.
_WIN64 ? Def.int32Ptr : Def.int32Ptr;
// ? A 64-bit pointer. On a 64-bit system, this is a native pointer.
// On a 32-bit system, this is a sign-extended 32-bit pointer.
_WIN64 ? Def.int64Ptr : Def.int32Ptr;
Def.int16Ptr;
Def.charPtr;
Def.int16Ptr;
Def.uint16Ptr;
Def.uint16Ptr;
const PUINT = Def.uintPtr;
Def.uintPtrPtr;
Def.uint8Ptr;
Def.uint16Ptr;
Def.uint32Ptr;
Def.uint64Ptr;
Def.uintPtr;
Def.uint64Ptr;
Def.uint64PtrPtr;
Def.uintPtr;
Def.uint64Ptr;
Def.uint16Ptr;
Def.uint16Ptr;
Def.uint16Ptr;
Def.uint16Ptr;
Def.uint64;
const SHORT = Def.int16;
Def.int16;
Def.uint16;
Def.uchar;
_WIN64 ? Def.uint32 : Def.uint16;
const UINT = Def.uint;
const UINT_PTR = _WIN64 ? Def.uint64 : Def.uint32;
Def.uint8;
const UINT16 = Def.uint16;
const UINT32 = Def.uint32;
Def.uint64;
const ULONG = Def.uint;
Def.uint64;
Def.uint32;
Def.uint64;
const USHORT = Def.ushort;
const WNDPROC = Def.voidPtr;
Def.voidPtr;
/**
 * Note: original be typedef UINT_PTR WPARAM;
 * CALLBACK WNDCLASSEX.lpfnWndProc may pass negative number and cause process exit.
 */
const WPARAM = UINT_PTR;
/**
 * For 'str16' from https://koffi.dev/input
 */
const WString = 'str16';

class StructUnionCache {
    static cacheStructMap = new Map();
    static cacheUnionMap = new Map();
    // #region STRUCT
    static getStruct(key) {
        assert(key, `key is empty`);
        return StructUnionCache.cacheStructMap.get(key);
    }
    static setStruct(key, value) {
        assert(key, `key is empty`);
        StructUnionCache.cacheStructMap.set(key, value);
    }
    static removeStruct(key) {
        assert(key, `key is empty`);
        return StructUnionCache.cacheStructMap.delete(key);
    }
    // #region UNION
    static getUnion(key) {
        assert(key, `key is empty`);
        return StructUnionCache.cacheUnionMap.get(key);
    }
    static setUnion(key, value) {
        assert(key, `key is empty`);
        StructUnionCache.cacheUnionMap.set(key, value);
    }
    static removeUnion(key) {
        assert(key, `key is empty`);
        return StructUnionCache.cacheUnionMap.delete(key);
    }
}

// #region genSimpleStruct()
/**
 * Generate a simple struct
 * - def must has no nested struct or union
 */
function genSimpleStruct(def, name, pointer) {
    const key = name ? name.trim() : '';
    let ptr = pointer ?? '';
    if (key && !ptr) {
        ptr = key + ' *';
    }
    if (key) {
        const data = StructUnionCache.getStruct(key);
        if (data) {
            return data;
        }
    }
    let ret;
    if (key) {
        const type = ffi.struct(key, def);
        const size = ffi.sizeof(type);
        ret = { name: key, pointer: ptr, CType: type, size };
        StructUnionCache.setStruct(key, ret); // cache named struct only
    }
    else {
        const type = ffi.struct(def);
        const size = ffi.sizeof(type);
        ret = { name: key, pointer: ptr, CType: type, size };
    }
    assert(ret, `ret is null or undefined`);
    return ret;
}
// #region genSimpleUnion()
function genSimpleUnion(def, name, pointer) {
    const key = name ? name.trim() : '';
    let ptr = pointer ? pointer.trim() : '';
    if (key && !ptr) {
        ptr = key + ' *';
    }
    if (key) {
        const data = StructUnionCache.getUnion(key);
        if (data) {
            return data;
        }
    }
    let ret;
    if (key) {
        const type = ffi.union(key, def);
        const size = ffi.sizeof(type);
        ret = { name: key, pointer: ptr, CType: type, size };
        StructUnionCache.setUnion(key, ret); // cache named union only
    }
    else {
        const type = ffi.union(def);
        const size = ffi.sizeof(type);
        ret = { name: key, pointer: ptr, CType: type, size };
    }
    return ret;
}

// #region genStruct()
/**
 * Generate a complex struct,
 * def can have nested struct or union
 * - key s{number} means struct
 * - key u{number} means union
 */
function genStruct(def, name, pointer, sizeColumns) {
    const struct = genComplexStruct(def, name, pointer);
    bindPayloadGetter(struct, sizeColumns);
    return struct;
}
function bindPayloadGetter(struct, sizeColumns) {
    if (typeof struct.sizeColumns === 'undefined') {
        Object.defineProperty(struct, 'sizeColumns', {
            enumerable: true,
            writable: false,
            value: sizeColumns,
        });
    }
    if (typeof struct.payload === 'undefined') {
        // payload must be the new one after each call of the struct factory function
        Object.defineProperty(struct, 'payload', {
            get: function () {
                if (!this.sizeColumns?.length) {
                    return {};
                }
                const ret = {};
                this.sizeColumns.forEach((key) => {
                    if (key) {
                        Object.defineProperty(ret, key, {
                            enumerable: true,
                            writable: false,
                            value: this.size,
                        });
                    }
                });
                return ret;
            },
        });
    }
}
// #region genComplexStruct()
/**
 * Generate a complex struct,
 * def can have nested struct or union
 * - key s{number} means struct
 * - key u{number} means union
 */
function genComplexStruct(def, name, pointer) {
    const key = name ? name.trim() : '';
    const ret = genStructCached(def, key, pointer);
    if (name) {
        assert(ret.name === key, `name: "${ret.name}" !== "${key}"`);
    }
    return ret;
}
const regStructName = /^s\d*$/u;
const regUnionName = /^u\d*$/u;
function genStructCached(def, name, pointer) {
    if (name) {
        const data = StructUnionCache.getStruct(name);
        if (data) {
            return data;
        }
    }
    const data = { ...def };
    // detect nested struct or union, key name start at "s{number*}" means struct, start at "u{number*}" means union
    genItem(data);
    const ret = genSimpleStruct(data, name, pointer);
    return ret;
}
// @region genUnion()
function genUnion(def, name, pointer) {
    const key = name ? name.trim() : '';
    let pname = pointer ?? '';
    if (key && !pname) {
        pname = key + '*';
    }
    const ret = genUnionCached(def, key, pname);
    if (name) {
        assert(ret.name === key, `name: ${ret.name} !== ${key}`);
    }
    return ret;
}
function genUnionCached(def, name, pointer) {
    if (name) {
        const data = StructUnionCache.getUnion(name);
        if (data) {
            return data;
        }
    }
    const data = { ...def };
    // detect nested struct or union, key name start at "s{number*}" means struct, start at "u{number*}" means union
    genItem(data);
    const ret = genSimpleUnion(data, name, pointer);
    return ret;
}
function genItem(data) {
    // detect nested struct or union, key name start at "s{number*}" means struct, start at "u{number*}" means union
    Object.keys(data).forEach((key) => {
        const value = data[key];
        assert(value, `value of key ${key} is null or undefined`);
        if (typeof value === 'string') {
            return;
        }
        if (typeof value === 'function') {
            const nested = value();
            assert(nested, `nested struct must be an object, but got ${typeof nested}`);
            data[key] = nested.CType;
        }
        else if (typeof value === 'object') {
            // Do not check value, because it can be KoffiCType
            // assert(Object.keys(value).length > 0, `value of key ${key} is empty object`)
            if (regStructName.test(key)) {
                const nested = genComplexStruct(value); // do not pass key
                data[key] = nested.CType;
            }
            else if (regUnionName.test(key)) {
                const nested = genUnion(value); // do not pass key
                data[key] = nested.CType;
            }
            else if (Object.keys(value).length === 0) {
                return; // maybe fix array
            }
            /* c8 ignore next 3 */
            else {
                assert(false, `key ${key} must start with 's' or 'u'`);
            }
        }
        /* c8 ignore next 3 */
        else {
            assert(data[key], `value of key ${key} is null or undefined`);
        }
    });
}
/**
 * Generate a fixed int16_t array.
 * convert it back to string through decodeInt16Array()
 */
function genFixedInt16Array(length) {
    assert(length > 0, `length must be greater than 0, but got ${length}`);
    const type = ffi.array('int16_t', length);
    return type;
}
function genFixedArray(length) {
    assert(length > 0, `length must be greater than 0, but got ${length}`);
    const type = ffi.array('int16_t', length, 'Array');
    return type;
}

const key$A = 'INITCOMMONCONTROLSEX';
const ptr$A = `${key$A}*`;
const init$A = {
    dwSize: DWORD,
    dwICC: DWORD,
};
const LPINITCOMMONCONTROLSEX = ptr$A;
const INITCOMMONCONTROLSEX_Name = key$A;
const INITCOMMONCONTROLSEX_Init = init$A;
/**
 * INITCOMMONCONTROLSEX structure
 * @link https://learn.microsoft.com/en-us/windows/win32/api/commctrl/nf-commctrl-initcommoncontrolsex
 */
function INITCOMMONCONTROLSEX_Factory() {
    return genStruct(init$A, key$A, ptr$A, ['dwSize']);
}

const key$z = 'FILETIME';
const ptr$z = `${key$z}*`;
const init$z = {
    dwLowDateTime: DWORD,
    dwHighDateTime: DWORD,
};
const LPFILETIME = ptr$z;
const LPFILETIME_Name = key$z;
const FILETIME_Init = init$z;
/**
 * FILETIME structure
 * @link https://learn.microsoft.com/en-us/windows/win32/api/minwinbase/ns-minwinbase-filetime
 */
function FILETIME_Factory() {
    return genStruct(init$z, key$z, ptr$z);
}

const key$y = 'SYSTEMTIME';
const ptr$y = `${key$y}*`;
const init$y = {
    wYear: WORD,
    wMonth: WORD,
    wDayOfWeek: WORD,
    wDay: WORD,
    wHour: WORD,
    wMinute: WORD,
    wSecond: WORD,
    wMilliseconds: WORD,
};
const LPSYSTEMTIME = ptr$y;
const SYSTEMTIME_Name = key$y;
const SYSTEMTIME_Init = init$y;
/**
 * SYSTEMTIME structure
 * @link https://learn.microsoft.com/en-us/windows/win32/api/minwinbase/ns-minwinbase-systemtime
 */
function SYSTEMTIME_Factory() {
    return genStruct(init$y, key$y, ptr$y);
}

const key$x = 'POINT';
const ptr$x = `${key$x}*`;
const init$x = {
    x: LONG,
    y: LONG,
};
const LPPOINT = ptr$x;
const POINT_Name = key$x;
const POINT_Init = init$x;
/**
 * POINT structure
 * @link https://learn.microsoft.com/en-us/windows/win32/api/windef/ns-windef-point
 */
function POINT_Factory() {
    return genStruct(init$x, key$x, ptr$x);
}

const key$w = 'RECT';
const ptr$w = `${key$w}*`;
const init$w = {
    left: LONG,
    top: LONG,
    right: LONG,
    bottom: LONG,
};
const LPRECT = ptr$w;
const RECT_Name = key$w;
const RECT_Init = init$w;
/**
 * RECT structure
 * @link https://learn.microsoft.com/en-us/windows/win32/api/windef/ns-windef-RECT
 */
function RECT_Factory() {
    return genStruct(init$w, key$w, ptr$w);
}

const key$v = 'DEVMODEW';
const ptr$v = `${key$v}*`;
const init$v = {
    dmDeviceName: genFixedInt16Array(32),
    dmSpecVersion: WORD,
    dmDriverVersion: WORD,
    dmSize: WORD,
    dmDriverExtra: WORD,
    dmFields: DWORD,
    u1: {
        s1: {
            dmOrientation: SHORT,
            dmPaperSize: SHORT,
            dmPaperLength: SHORT,
            dmPaperWidth: SHORT,
            dmScale: SHORT,
            dmCopies: SHORT,
            dmDefaultSource: SHORT,
            dmPrintQuality: SHORT,
        },
        dmPosition: POINT_Factory,
        s2: {
            dmPosition: POINT_Factory,
            dmDisplayOrientation: DWORD,
            dmDisplayFixedOutput: DWORD,
        },
    },
    dmColor: SHORT,
    dmDuplex: SHORT,
    dmYResolution: SHORT,
    dmTTOption: SHORT,
    dmCollate: SHORT,
    dmFormName: genFixedInt16Array(32),
    dmLogPixels: WORD,
    dmBitsPerPel: DWORD,
    dmPelsWidth: DWORD,
    dmPelsHeight: DWORD,
    u2: {
        dmDisplayFlags: DWORD,
        dmNup: DWORD,
    },
    dmDisplayFrequency: DWORD,
    dmICMMethod: DWORD,
    dmICMIntent: DWORD,
    dmMediaType: DWORD,
    dmDitherType: DWORD,
    dmReserved1: DWORD,
    dmReserved2: DWORD,
    dmPanningWidth: DWORD,
    dmPanningHeight: DWORD,
};
const LPDEVMODEW = ptr$v;
const DEVMODEW_Name = key$v;
const DEVMODEW_Init = init$v;
/**
 * DEVMODEW structure
 * @link https://learn.microsoft.com/en-us/windows/win32/api/wingdi/ns-wingdi-devmodew
 */
function DEVMODEW_Factory() {
    return genStruct(init$v, key$v, ptr$v, ['dmSize']);
}

const key$u = 'DISPLAY_DEVICEW';
const ptr$u = `${key$u}*`;
const init$u = {
    cb: DWORD,
    DeviceName: genFixedInt16Array(32),
    DeviceString: genFixedInt16Array(128),
    StateFlags: DWORD,
    DeviceID: genFixedInt16Array(128),
    DeviceKey: genFixedInt16Array(128),
};
const LPDISPLAY_DEVICEW = ptr$u;
const DISPLAY_DEVICEW_Name = key$u;
const DISPLAY_DEVICEW_Init = init$u;
/**
 * DISPLAY_DEVICEW structure
 * @link https://learn.microsoft.com/en-us/windows/win32/api/wingdi/ns-wingdi-display_devicew
 */
function DISPLAY_DEVICEW_Factory() {
    return genStruct(init$u, key$u, ptr$u, ['cb']);
}

const key$t = 'DOC_INFO_1';
const ptr$t = `${key$t}*`;
const init$t = {
    pDocName: WString,
    pOutputFile: WString,
    pDatatype: WString,
};
const LPDOC_INFO_1 = ptr$t;
const DOC_INFO_1_Name = key$t;
const DOC_INFO_1_Init = init$t;
/**
 * DOC_INFO_1 structure,
 * Describes a document that will be printed.
 * @link https://learn.microsoft.com/en-us/windows/win32/printdocs/doc-info-1
 */
function DOC_INFO_1_Factory() {
    return genStruct(init$t, key$t, ptr$t);
}

const key$s = 'JOB_INFO_1';
const ptr$s = `${key$s}*`;
const init$s = {
    JobId: DWORD,
    pPrinterName: LPTSTR,
    pMachineName: LPTSTR,
    pUserName: LPTSTR,
    pDocument: LPTSTR,
    pDatatype: LPTSTR,
    pStatus: LPTSTR,
    Status: DWORD,
    Priority: DWORD,
    Position: DWORD,
    TotalPages: DWORD,
    PagesPrinted: DWORD,
    Submitted: SYSTEMTIME_Factory,
};
const PJOB_INFO_1 = ptr$s;
const JOB_INFO_1_Name = key$s;
const JOB_INFO_1_Init = init$s;
/**
 * JOB_INFO_1 structure,
 * The JOB_INFO_1 structure specifies print-job information such as the job-identifier value
 * @link https://learn.microsoft.com/en-us/windows/win32/printdocs/job-info-1
 */
function JOB_INFO_1_Factory() {
    return genStruct(init$s, key$s, ptr$s);
}

const key$r = 'PRINTER_DEFAULTS';
const ptr$r = `${key$r}*`;
const init$r = {
    pDatatype: LPTSTR,
    pDevMode: DEVMODEW_Factory,
    DesiredAccess: ACCESS_MASK,
};
const PPRINTER_DEFAULTS = ptr$r;
const PRINTER_DEFAULTS_Name = key$r;
const PRINTER_DEFAULTS_Init = init$r;
/**
 * PRINTER_DEFAULTS structure,
 * Specifies the default data type, environment, initialization data, and access rights for a printer.
 * @link https://learn.microsoft.com/en-us/windows/win32/printdocs/printer-defaults
 */
function PRINTER_DEFAULTS_Factory() {
    return genStruct(init$r, key$r, ptr$r);
}

const key$q = 'PRINTER_INFO_1';
const ptr$q = `${key$q}*`;
const init$q = {
    Flags: DWORD,
    pDescription: WString,
    pName: WString,
    pComment: WString,
};
const PPRINTER_INFO_1 = ptr$q;
const PRINTER_INFO_1_Name = key$q;
const PRINTER_INFO_1_Init = init$q;
/**
 * PRINTER_INFO_1 structure,
 * Specifies general printer information
 * @link https://learn.microsoft.com/en-us/windows/win32/printdocs/PRINTER-INFO-1
 */
function PRINTER_INFO_1_Factory() {
    return genStruct(init$q, key$q, ptr$q);
}

const key$p = 'PRINTER_INFO_4';
const ptr$p = `${key$p}*`;
const init$p = {
    pPrinterName: WString,
    pServerName: WString,
    Attributes: DWORD,
};
const PPRINTER_INFO_4 = ptr$p;
const PRINTER_INFO_4_Name = key$p;
const PRINTER_INFO_4_Init = init$p;
/**
 * PRINTER_INFO_4 structure,
 * Specifies general printer information
 * @link https://learn.microsoft.com/en-us/windows/win32/printdocs/PRINTER-INFO-4
 * @description The structure can be used to retrieve minimal printer information on a call to EnumPrinters.
 *  Such a call is a fast and easy way to retrieve the names and attributes of all locally installed printers
 *  on a system and all remote printer connections that a user has established.
 */
function PRINTER_INFO_4_Factory() {
    return genStruct(init$p, key$p, ptr$p);
}

const key$o = 'PRINTER_INFO_5';
const ptr$o = `${key$o}*`;
const init$o = {
    pPrinterName: WString,
    pPortName: WString,
    Attributes: DWORD,
    DeviceNotSelectedTimeout: DWORD,
    TransmissionRetryTimeout: DWORD,
};
const PPRINTER_INFO_5 = ptr$o;
const PRINTER_INFO_5_Name = key$o;
const PRINTER_INFO_5_Init = init$o;
/**
 * PRINTER_INFO_5 structure,
 * structure specifies detailed printer information.
 * @link https://learn.microsoft.com/en-us/windows/win32/printdocs/PRINTER-INFO-5
 */
function PRINTER_INFO_5_Factory() {
    return genStruct(init$o, key$o, ptr$o);
}

const key$n = 'PRINTER_INFO_8';
const ptr$n = `${key$n}*`;
const init$n = {
    pDevMode: DEVMODEW_Factory,
};
const PPRINTER_INFO_8 = ptr$n;
const PRINTER_INFO_8_Name = key$n;
const PRINTER_INFO_8_Init = init$n;
/**
 * PRINTER_INFO_8 structure,
 * specifies the global default printer settings.
 * @link https://learn.microsoft.com/en-us/windows/win32/printdocs/PRINTER-INFO-8
 */
function PRINTER_INFO_8_Factory() {
    return genStruct(init$n, key$n, ptr$n);
}

const key$m = 'PRINTER_INFO_9';
const ptr$m = `${key$m}*`;
const init$m = {
    pDevMode: DEVMODEW_Factory,
};
const PPRINTER_INFO_9 = ptr$m;
const PRINTER_INFO_9_Name = key$m;
const PRINTER_INFO_9_Init = init$m;
/**
 * PRINTER_INFO_9 structure,
 * structure specifies the per-user default printer settings.
 * @link https://learn.microsoft.com/en-us/windows/win32/printdocs/PRINTER-INFO-9
 */
function PRINTER_INFO_9_Factory() {
    return genStruct(init$m, key$m, ptr$m);
}

const key$l = 'PRINTPROCESSOR_INFO_1';
const ptr$l = `${key$l}*`;
const init$l = {
    pName: LPTSTR,
};
const PPRINTPROCESSOR_INFO_1 = ptr$l;
const PRINTPROCESSOR_INFO_1_Name = key$l;
const PRINTPROCESSOR_INFO_1_Init = init$l;
/**
 * PRINTPROCESSOR_INFO_1 structure,
 * Specifies the name of an installed print processor.
 * @link https://learn.microsoft.com/en-us/windows/win32/printdocs/printprocessor-info-1
 */
function PRINTPROCESSOR_INFO_1_Factory() {
    return genStruct(init$l, key$l, ptr$l);
}

const key$k = 'PRINTER_INFO_6';
const ptr$k = `${key$k}*`;
const init$k = {
    dwStatus: DWORD,
};
const PPRINTER_INFO_6 = ptr$k;
const PRINTER_INFO_6_Name = key$k;
const PRINTER_INFO_6_Init = init$k;
/**
 * PRINTER_INFO_6 structure,
 * structure specifies detailed printer information.
 * @link https://learn.microsoft.com/en-us/windows/win32/printdocs/PRINTER-INFO-6
 */
function PRINTER_INFO_6_Factory() {
    return genStruct(init$k, key$k, ptr$k);
}

const key$j = 'ALTTABINFO';
const ptr$j = `${key$j}*`;
const init$j = {
    cbSize: DWORD,
    cItems: INT,
    cColumns: INT,
    cRows: INT,
    iColFocus: INT,
    iRowFocus: INT,
    cxItem: INT,
    cyItem: INT,
    ptStart: POINT_Factory,
};
const LPALTTABINFO = ptr$j;
const ALTTABINFO_Name = key$j;
const ALTTABINFO_Init = init$j;
/**
 * ALTTABINFO structure
 * @link https://learn.microsoft.com/en-us/windows/win32/api/winuser/ns-winuser-alttabinfo
 */
function ALTTABINFO_Factory() {
    return genStruct(init$j, key$j, ptr$j, ['cbSize']);
}

const key$i = 'COPYDATASTRUCT';
const ptr$i = `${key$i}*`;
const init$i = {
    dwData: ULONG_PTR,
    cbData: DWORD,
    lpData: PVOID,
};
const LPCOPYDATASTRUCT = ptr$i;
const COPYDATASTRUCT_Name = key$i;
const COPYDATASTRUCT_Init = init$i;
/**
 * COPYDATASTRUCT structure
 * @link https://learn.microsoft.com/en-us/windows/win32/api/winuser/ns-winuser-copydatastruct
 */
function COPYDATASTRUCT_Factory() {
    return genStruct(init$i, key$i, ptr$i);
}

const key$h = 'FLASHWINFO';
const ptr$h = `${key$h}*`;
const init$h = {
    cbSize: UINT,
    hwnd: HWND,
    dwFlags: DWORD,
    uCount: UINT,
    dwTimeout: DWORD,
};
const PFLASHWINFO = ptr$h;
const FLASHWINFO_Name = key$h;
const FLASHWINFO_Init = init$h;
/**
 * FLASHWINFO structure
 * @link https://learn.microsoft.com/en-us/windows/win32/api/winuser/ns-winuser-FLASHWINFO
 */
function FLASHWINFO_Factory() {
    return genStruct(init$h, key$h, ptr$h, ['cbSize']);
}

const key$g = 'HARDWAREINPUT';
const ptr$g = `${key$g}*`;
const init$g = {
    uMsg: UINT32,
    wParamL: UINT16,
    wParamH: UINT16,
};
const LPHARDWAREINPUT = ptr$g;
const HARDWAREINPUT_Name = key$g;
const HARDWAREINPUT_Init = init$g;
/**
 * HARDWAREINPUT structure
 * @link https://learn.microsoft.com/en-us/windows/win32/api/winuser/ns-winuser-hardwareinput
 */
function HARDWAREINPUT_Factory() {
    return genStruct(init$g, key$g, ptr$g);
}

const key$f = 'KEYBDINPUT';
const ptr$f = `${key$f}*`;
const init$f = {
    wVk: UINT16,
    wScan: UINT16,
    dwFlags: UINT32,
    time: UINT32,
    dwExtraInfo: PUINT,
};
const LPKEYBDINPUT = ptr$f;
const KEYBDINPUT_Name = key$f;
const KEYBDINPUT_Init = init$f;
/**
 * KEYBDINPUT structure
 * @link https://learn.microsoft.com/en-us/windows/win32/api/winuser/ns-winuser-keybdinput
 */
function KEYBDINPUT_Factory() {
    return genStruct(init$f, key$f, ptr$f);
}

const key$e = 'MOUSEINPUT';
const ptr$e = `${key$e}*`;
const init$e = {
    dx: LONG,
    dy: LONG,
    mouseData: UINT32,
    dwFlags: UINT32,
    time: UINT32,
    dwExtraInfo: PUINT,
};
const LPMOUSEINPUT = ptr$e;
const MOUSEINPUT_Name = key$e;
const MOUSEINPUT_Init = init$e;
/**
 * MOUSEINPUT structure
 * @link https://learn.microsoft.com/en-us/windows/win32/api/winuser/ns-winuser-mouseinput
 */
function MOUSEINPUT_Factory() {
    return genStruct(init$e, key$e, ptr$e);
}

const key$d = 'INPUT';
const ptr$d = `${key$d}*`;
const init$d = {
    type: UINT32,
    u: {
        mi: MOUSEINPUT_Factory,
        ki: KEYBDINPUT_Factory,
        hi: HARDWAREINPUT_Factory,
    },
};
const LPINPUT = ptr$d;
const INPUT_Name = key$d;
const INPUT_Init = init$d;
/**
 * INPUT structure
 * @link https://learn.microsoft.com/en-us/windows/win32/api/winuser/ns-winuser-input
 */
function INPUT_Factory() {
    return genStruct(init$d, key$d, ptr$d);
}
// export const INPUT = koffi.struct('INPUT', {
//   type: W.UINT32,
//   u: koffi.union({
//     mi: MOUSEINPUT,
//     ki: KEYBDINPUT,
//     hi: HARDWAREINPUT,
//   }),
// })

const key$c = 'MSG';
const ptr$c = `${key$c}*`;
const init$c = {
    hwnd: HWND,
    message: UINT,
    wParam: WPARAM,
    lParam: LPARAM,
    time: DWORD,
    pt: POINT_Factory,
    lPrivate: DWORD,
};
const LPMSG = ptr$c;
const MSG_Name = key$c;
const MSG_Init = init$c;
/**
 * MSG structure
 * @link https://learn.microsoft.com/en-us/windows/win32/api/winuser/ns-winuser-msg
 */
function MSG_Factory() {
    return genStruct(init$c, key$c, ptr$c);
}

const key$b = 'RAWHID';
const ptr$b = `${key$b}*`;
const init$b = {
    dwSizeHid: DWORD,
    dwCount: DWORD,
    /** bRawData[1] */
    bRawData: BYTE,
};
const LPRAWHID = ptr$b;
const RAWHID_Name = key$b;
const RAWHID_Init = init$b;
/**
 * RAWHID structure
 * @link https://learn.microsoft.com/en-us/windows/win32/api/winuser/ns-winuser-rawhid
 */
function RAWHID_Factory() {
    return genStruct(init$b, key$b, ptr$b);
}

const key$a = 'RAWINPUTHEADER';
const ptr$a = `${key$a}*`;
const init$a = {
    dwType: DWORD,
    dwSize: DWORD,
    hDevice: HANDLE,
    wParam: WPARAM,
};
const LPRAWINPUTHEADER = ptr$a;
const RAWINPUTHEADER_Name = key$a;
const RAWINPUTHEADER_Init = init$a;
/**
 * RAWINPUTHEADER structure
 * @link https://learn.microsoft.com/en-us/windows/win32/api/winuser/ns-winuser-RAWINPUTHEADER
 */
function RAWINPUTHEADER_Factory() {
    return genStruct(init$a, key$a, ptr$a);
}

const key$9 = 'RAWKEYBOARD';
const ptr$9 = `${key$9}*`;
const init$9 = {
    MakeCode: USHORT,
    Flags: USHORT,
    Reserved: USHORT,
    VKey: USHORT,
    Message: UINT,
    ExtraInformation: ULONG,
};
const LPRAWKEYBOARD = ptr$9;
const RAWKEYBOARD_Name = key$9;
const RAWKEYBOARD_Init = init$9;
/**
 * RAWKEYBOARD structure
 * @link https://learn.microsoft.com/en-us/windows/win32/api/winuser/ns-winuser-RAWKEYBOARD
 */
function RAWKEYBOARD_Factory() {
    return genStruct(init$9, key$9, ptr$9);
}

const key$8 = 'RAWMOUSE';
const ptr$8 = `${key$8}*`;
const init$8 = {
    usFlags: USHORT,
    u: {
        ulButtons: ULONG,
        s: {
            usButtonFlags: USHORT,
            usButtonData: USHORT,
        },
    },
    ulRawButtons: ULONG,
    lLastX: LONG,
    lLastY: LONG,
    ulExtraInformation: ULONG,
};
/**
 * RAWMOUSE structure
 * @link https://learn.microsoft.com/en-us/windows/win32/api/winuser/ns-winuser-RAWMOUSE
 */
function RAWMOUSE_Factory() {
    return genStruct(init$8, key$8, ptr$8);
}
const LPRAWMOUSE = ptr$8;
const RAWMOUSE_Name = key$8;
const RAWMOUSE_Init = init$8;

const key$7 = 'RAWINPUT';
const ptr$7 = `${key$7}*`;
const init$7 = {
    header: RAWINPUTHEADER_Factory,
    u: {
        mouse: RAWMOUSE_Factory,
        keyboard: RAWKEYBOARD_Factory,
        hid: RAWHID_Factory,
    },
};
const LPRAWINPUT = ptr$7;
const RAWINPUT_Name = key$7;
const RAWINPUT_Init = init$7;
/**
 * RAWINPUT structure
 * @link https://learn.microsoft.com/en-us/windows/win32/api/winuser/ns-winuser-rawinput
 */
function RAWINPUT_Factory() {
    return genStruct(init$7, key$7, ptr$7);
}

const key$6 = 'RAWINPUTDEVICELIST';
const ptr$6 = `${key$6}*`;
const init$6 = {
    hDevice: HANDLE,
    dwType: DWORD,
};
const LPRAWINPUTDEVICELIST = ptr$6;
const RAWINPUTDEVICELIST_Name = key$6;
const RAWINPUTDEVICELIST_Init = init$6;
/**
 * RAWINPUTDEVICELIST structure
 * @link https://learn.microsoft.com/en-us/windows/win32/api/winuser/ns-winuser-RAWINPUTDEVICELIST
 */
function RAWINPUTDEVICELIST_Factory() {
    return genStruct(init$6, key$6, ptr$6);
}

const key$5 = 'RID_DEVICE_INFO_HID';
const ptr$5 = `${key$5}*`;
const init$5 = {
    dwVendorId: DWORD,
    dwProductId: DWORD,
    dwVersionNumber: DWORD,
    usUsagePage: USHORT,
    usUsage: USHORT,
};
const PRID_DEVICE_INFO_HID = ptr$5;
const RID_DEVICE_INFO_HID_Name = key$5;
const RID_DEVICE_INFO_HID_Init = init$5;
/**
 * RID_DEVICE_INFO_HID structure
 * @link https://learn.microsoft.com/en-us/windows/win32/api/winuser/ns-winuser-RID_DEVICE_INFO_HID
 */
function RID_DEVICE_INFO_HID_Factory() {
    return genStruct(init$5, key$5, ptr$5);
}

const key$4 = 'RID_DEVICE_INFO_KEYBOARD';
const ptr$4 = `${key$4}*`;
const init$4 = {
    dwType: DWORD,
    dwSubType: DWORD,
    dwKeyboardMode: DWORD,
    dwNumberOfFunctionKeys: DWORD,
    dwNumberOfIndicators: DWORD,
    dwNumberOfKeysTotal: DWORD,
};
const PRID_DEVICE_INFO_KEYBOARD = ptr$4;
const RID_DEVICE_INFO_KEYBOARD_Name = key$4;
const RID_DEVICE_INFO_KEYBOARD_Init = init$4;
/**
 * RID_DEVICE_INFO_KEYBOARD structure
 * @link https://learn.microsoft.com/en-us/windows/win32/api/winuser/ns-winuser-RID_DEVICE_INFO_KEYBOARD
 */
function RID_DEVICE_INFO_KEYBOARD_Factory() {
    return genStruct(init$4, key$4, ptr$4);
}

const key$3 = 'RID_DEVICE_INFO_MOUSE';
const ptr$3 = `${key$3}*`;
const init$3 = {
    dwId: DWORD,
    dwNumberOfButtons: DWORD,
    dwSampleRate: DWORD,
    fHasHorizontalWheel: BOOL,
};
const PRID_DEVICE_INFO_MOUSE = ptr$3;
const RID_DEVICE_INFO_MOUSE_Name = key$3;
const RID_DEVICE_INFO_MOUSE_Init = init$3;
/**
 * RID_DEVICE_INFO_MOUSE structure
 * @link https://learn.microsoft.com/en-us/windows/win32/api/winuser/ns-winuser-RID_DEVICE_INFO_MOUSE
 */
function RID_DEVICE_INFO_MOUSE_Factory() {
    return genStruct(init$3, key$3, ptr$3);
}

const key$2 = 'RID_DEVICE_INFO';
const ptr$2 = `${key$2}*`;
const init$2 = {
    cbSize: DWORD,
    dwType: DWORD,
    u: {
        mouse: RID_DEVICE_INFO_MOUSE_Factory,
        keyboard: RID_DEVICE_INFO_KEYBOARD_Factory,
        hid: RID_DEVICE_INFO_HID_Factory,
    },
};
const LPRID_DEVICE_INFO = ptr$2;
const RID_DEVICE_INFO_Name = key$2;
const RID_DEVICE_INFO_Init = init$2;
/**
 * RID_DEVICE_INFO structure
 * @link https://learn.microsoft.com/en-us/windows/win32/api/winuser/ns-winuser-RID_DEVICE_INFO
 */
function RID_DEVICE_INFO_Factory() {
    return genStruct(init$2, key$2, ptr$2, ['cbSize']);
}

const key$1 = 'WNDCLASSEXW';
const ptr$1 = `${key$1}*`;
const init$1 = {
    cbSize: UINT,
    style: UINT,
    lpfnWndProc: WNDPROC,
    cbClsExtra: INT,
    cbWndExtra: INT,
    hInstance: HINSTANCE,
    hIcon: HICON,
    hCursor: HCURSOR,
    hbrBackground: HBRUSH,
    lpszMenuName: WString,
    lpszClassName: WString,
    hIconSm: HICON,
};
const LPWNDCLASSEXW = ptr$1;
const WNDCLASSEXW_Name = key$1;
const WNDCLASSEXW_Init = init$1;
/**
 * WNDCLASSEXW structure
 * @link https://learn.microsoft.com/en-us/windows/win32/api/winuser/ns-winuser-wndclassexw
 */
function WNDCLASSEXW_Factory() {
    return genStruct(init$1, key$1, ptr$1, ['cbSize']);
}

const key = 'WINDOWINFO';
const ptr = `${key}*`;
const init = {
    cbSize: DWORD,
    rcWindow: RECT_Factory,
    rcClient: RECT_Factory,
    dwStyle: DWORD,
    dwExStyle: DWORD,
    dwWindowStatus: DWORD,
    cxWindowBorders: UINT,
    cyWindowBorders: UINT,
    atomWindowType: ATOM,
    wCreatorVersion: WORD,
};
const LPWINDOWINFO = ptr;
const WINDOWINFO_Name = key;
const WINDOWINFO_Init = init;
/**
 * WINDOWINFO structure
 * @link https://learn.microsoft.com/en-us/windows/win32/api/winuser/ns-winuser-WINDOWINFO
 */
function WINDOWINFO_Factory() {
    return genStruct(init, key, ptr, ['cbSize']);
}

function getPRINTER_INFO_X_Ptr(level) {
    // eslint-disable-next-line @typescript-eslint/switch-exhaustiveness-check
    switch (level) {
        case 1: return PPRINTER_INFO_1;
        case 4: return PPRINTER_INFO_4;
        case 5: return PPRINTER_INFO_5;
        case 6: return PPRINTER_INFO_6;
        case 8: return PPRINTER_INFO_8;
        case 9: return PPRINTER_INFO_9;
        /* c8 ignore next 2 */
        default:
            assert(false, `getPRINTER_INFO_X_Ptr(): level not supported: ${level}`);
    }
}
function PRINTER_INFO_X_Factory(level) {
    // eslint-disable-next-line @typescript-eslint/switch-exhaustiveness-check
    switch (level) {
        case 1: return PRINTER_INFO_1_Factory();
        case 4: return PRINTER_INFO_4_Factory();
        case 5: return PRINTER_INFO_5_Factory();
        case 6: return PRINTER_INFO_6_Factory();
        case 8: return PRINTER_INFO_8_Factory();
        case 9: return PRINTER_INFO_9_Factory();
        /* c8 ignore next 2 */
        default:
            assert(false, `level not supported: ${level}`);
    }
}

exports.ALTTABINFO_Factory = ALTTABINFO_Factory;
exports.ALTTABINFO_Init = ALTTABINFO_Init;
exports.ALTTABINFO_Name = ALTTABINFO_Name;
exports.COPYDATASTRUCT_Factory = COPYDATASTRUCT_Factory;
exports.COPYDATASTRUCT_Init = COPYDATASTRUCT_Init;
exports.COPYDATASTRUCT_Name = COPYDATASTRUCT_Name;
exports.DEVMODEW_Factory = DEVMODEW_Factory;
exports.DEVMODEW_Init = DEVMODEW_Init;
exports.DEVMODEW_Name = DEVMODEW_Name;
exports.DISPLAY_DEVICEW_Factory = DISPLAY_DEVICEW_Factory;
exports.DISPLAY_DEVICEW_Init = DISPLAY_DEVICEW_Init;
exports.DISPLAY_DEVICEW_Name = DISPLAY_DEVICEW_Name;
exports.DOC_INFO_1_Factory = DOC_INFO_1_Factory;
exports.DOC_INFO_1_Init = DOC_INFO_1_Init;
exports.DOC_INFO_1_Name = DOC_INFO_1_Name;
exports.FILETIME_Factory = FILETIME_Factory;
exports.FILETIME_Init = FILETIME_Init;
exports.FLASHWINFO_Factory = FLASHWINFO_Factory;
exports.FLASHWINFO_Init = FLASHWINFO_Init;
exports.FLASHWINFO_Name = FLASHWINFO_Name;
exports.HARDWAREINPUT_Factory = HARDWAREINPUT_Factory;
exports.HARDWAREINPUT_Init = HARDWAREINPUT_Init;
exports.HARDWAREINPUT_Name = HARDWAREINPUT_Name;
exports.INITCOMMONCONTROLSEX_Factory = INITCOMMONCONTROLSEX_Factory;
exports.INITCOMMONCONTROLSEX_Init = INITCOMMONCONTROLSEX_Init;
exports.INITCOMMONCONTROLSEX_Name = INITCOMMONCONTROLSEX_Name;
exports.INPUT_Factory = INPUT_Factory;
exports.INPUT_Init = INPUT_Init;
exports.INPUT_Name = INPUT_Name;
exports.JOB_INFO_1_Factory = JOB_INFO_1_Factory;
exports.JOB_INFO_1_Init = JOB_INFO_1_Init;
exports.JOB_INFO_1_Name = JOB_INFO_1_Name;
exports.KEYBDINPUT_Factory = KEYBDINPUT_Factory;
exports.KEYBDINPUT_Init = KEYBDINPUT_Init;
exports.KEYBDINPUT_Name = KEYBDINPUT_Name;
exports.LPALTTABINFO = LPALTTABINFO;
exports.LPCOPYDATASTRUCT = LPCOPYDATASTRUCT;
exports.LPDEVMODEW = LPDEVMODEW;
exports.LPDISPLAY_DEVICEW = LPDISPLAY_DEVICEW;
exports.LPDOC_INFO_1 = LPDOC_INFO_1;
exports.LPFILETIME = LPFILETIME;
exports.LPFILETIME_Name = LPFILETIME_Name;
exports.LPHARDWAREINPUT = LPHARDWAREINPUT;
exports.LPINITCOMMONCONTROLSEX = LPINITCOMMONCONTROLSEX;
exports.LPINPUT = LPINPUT;
exports.LPKEYBDINPUT = LPKEYBDINPUT;
exports.LPMOUSEINPUT = LPMOUSEINPUT;
exports.LPMSG = LPMSG;
exports.LPPOINT = LPPOINT;
exports.LPRAWHID = LPRAWHID;
exports.LPRAWINPUT = LPRAWINPUT;
exports.LPRAWINPUTDEVICELIST = LPRAWINPUTDEVICELIST;
exports.LPRAWINPUTHEADER = LPRAWINPUTHEADER;
exports.LPRAWKEYBOARD = LPRAWKEYBOARD;
exports.LPRAWMOUSE = LPRAWMOUSE;
exports.LPRECT = LPRECT;
exports.LPRID_DEVICE_INFO = LPRID_DEVICE_INFO;
exports.LPSYSTEMTIME = LPSYSTEMTIME;
exports.LPWINDOWINFO = LPWINDOWINFO;
exports.LPWNDCLASSEXW = LPWNDCLASSEXW;
exports.MOUSEINPUT_Factory = MOUSEINPUT_Factory;
exports.MOUSEINPUT_Init = MOUSEINPUT_Init;
exports.MOUSEINPUT_Name = MOUSEINPUT_Name;
exports.MSG_Factory = MSG_Factory;
exports.MSG_Init = MSG_Init;
exports.MSG_Name = MSG_Name;
exports.PFLASHWINFO = PFLASHWINFO;
exports.PJOB_INFO_1 = PJOB_INFO_1;
exports.POINT_Factory = POINT_Factory;
exports.POINT_Init = POINT_Init;
exports.POINT_Name = POINT_Name;
exports.PPRINTER_DEFAULTS = PPRINTER_DEFAULTS;
exports.PPRINTER_INFO_1 = PPRINTER_INFO_1;
exports.PPRINTER_INFO_4 = PPRINTER_INFO_4;
exports.PPRINTER_INFO_5 = PPRINTER_INFO_5;
exports.PPRINTER_INFO_6 = PPRINTER_INFO_6;
exports.PPRINTER_INFO_8 = PPRINTER_INFO_8;
exports.PPRINTER_INFO_9 = PPRINTER_INFO_9;
exports.PPRINTPROCESSOR_INFO_1 = PPRINTPROCESSOR_INFO_1;
exports.PRID_DEVICE_INFO_HID = PRID_DEVICE_INFO_HID;
exports.PRID_DEVICE_INFO_KEYBOARD = PRID_DEVICE_INFO_KEYBOARD;
exports.PRID_DEVICE_INFO_MOUSE = PRID_DEVICE_INFO_MOUSE;
exports.PRINTER_DEFAULTS_Factory = PRINTER_DEFAULTS_Factory;
exports.PRINTER_DEFAULTS_Init = PRINTER_DEFAULTS_Init;
exports.PRINTER_DEFAULTS_Name = PRINTER_DEFAULTS_Name;
exports.PRINTER_INFO_1_Factory = PRINTER_INFO_1_Factory;
exports.PRINTER_INFO_1_Init = PRINTER_INFO_1_Init;
exports.PRINTER_INFO_1_Name = PRINTER_INFO_1_Name;
exports.PRINTER_INFO_4_Factory = PRINTER_INFO_4_Factory;
exports.PRINTER_INFO_4_Init = PRINTER_INFO_4_Init;
exports.PRINTER_INFO_4_Name = PRINTER_INFO_4_Name;
exports.PRINTER_INFO_5_Factory = PRINTER_INFO_5_Factory;
exports.PRINTER_INFO_5_Init = PRINTER_INFO_5_Init;
exports.PRINTER_INFO_5_Name = PRINTER_INFO_5_Name;
exports.PRINTER_INFO_6_Factory = PRINTER_INFO_6_Factory;
exports.PRINTER_INFO_6_Init = PRINTER_INFO_6_Init;
exports.PRINTER_INFO_6_Name = PRINTER_INFO_6_Name;
exports.PRINTER_INFO_8_Factory = PRINTER_INFO_8_Factory;
exports.PRINTER_INFO_8_Init = PRINTER_INFO_8_Init;
exports.PRINTER_INFO_8_Name = PRINTER_INFO_8_Name;
exports.PRINTER_INFO_9_Factory = PRINTER_INFO_9_Factory;
exports.PRINTER_INFO_9_Init = PRINTER_INFO_9_Init;
exports.PRINTER_INFO_9_Name = PRINTER_INFO_9_Name;
exports.PRINTER_INFO_X_Factory = PRINTER_INFO_X_Factory;
exports.PRINTPROCESSOR_INFO_1_Factory = PRINTPROCESSOR_INFO_1_Factory;
exports.PRINTPROCESSOR_INFO_1_Init = PRINTPROCESSOR_INFO_1_Init;
exports.PRINTPROCESSOR_INFO_1_Name = PRINTPROCESSOR_INFO_1_Name;
exports.RAWHID_Factory = RAWHID_Factory;
exports.RAWHID_Init = RAWHID_Init;
exports.RAWHID_Name = RAWHID_Name;
exports.RAWINPUTDEVICELIST_Factory = RAWINPUTDEVICELIST_Factory;
exports.RAWINPUTDEVICELIST_Init = RAWINPUTDEVICELIST_Init;
exports.RAWINPUTDEVICELIST_Name = RAWINPUTDEVICELIST_Name;
exports.RAWINPUTHEADER_Factory = RAWINPUTHEADER_Factory;
exports.RAWINPUTHEADER_Init = RAWINPUTHEADER_Init;
exports.RAWINPUTHEADER_Name = RAWINPUTHEADER_Name;
exports.RAWINPUT_Factory = RAWINPUT_Factory;
exports.RAWINPUT_Init = RAWINPUT_Init;
exports.RAWINPUT_Name = RAWINPUT_Name;
exports.RAWKEYBOARD_Factory = RAWKEYBOARD_Factory;
exports.RAWKEYBOARD_Init = RAWKEYBOARD_Init;
exports.RAWKEYBOARD_Name = RAWKEYBOARD_Name;
exports.RAWMOUSE_Factory = RAWMOUSE_Factory;
exports.RAWMOUSE_Init = RAWMOUSE_Init;
exports.RAWMOUSE_Name = RAWMOUSE_Name;
exports.RECT_Factory = RECT_Factory;
exports.RECT_Init = RECT_Init;
exports.RECT_Name = RECT_Name;
exports.RID_DEVICE_INFO_Factory = RID_DEVICE_INFO_Factory;
exports.RID_DEVICE_INFO_HID_Factory = RID_DEVICE_INFO_HID_Factory;
exports.RID_DEVICE_INFO_HID_Init = RID_DEVICE_INFO_HID_Init;
exports.RID_DEVICE_INFO_HID_Name = RID_DEVICE_INFO_HID_Name;
exports.RID_DEVICE_INFO_Init = RID_DEVICE_INFO_Init;
exports.RID_DEVICE_INFO_KEYBOARD_Factory = RID_DEVICE_INFO_KEYBOARD_Factory;
exports.RID_DEVICE_INFO_KEYBOARD_Init = RID_DEVICE_INFO_KEYBOARD_Init;
exports.RID_DEVICE_INFO_KEYBOARD_Name = RID_DEVICE_INFO_KEYBOARD_Name;
exports.RID_DEVICE_INFO_MOUSE_Factory = RID_DEVICE_INFO_MOUSE_Factory;
exports.RID_DEVICE_INFO_MOUSE_Init = RID_DEVICE_INFO_MOUSE_Init;
exports.RID_DEVICE_INFO_MOUSE_Name = RID_DEVICE_INFO_MOUSE_Name;
exports.RID_DEVICE_INFO_Name = RID_DEVICE_INFO_Name;
exports.SYSTEMTIME_Factory = SYSTEMTIME_Factory;
exports.SYSTEMTIME_Init = SYSTEMTIME_Init;
exports.SYSTEMTIME_Name = SYSTEMTIME_Name;
exports.WINDOWINFO_Factory = WINDOWINFO_Factory;
exports.WINDOWINFO_Init = WINDOWINFO_Init;
exports.WINDOWINFO_Name = WINDOWINFO_Name;
exports.WNDCLASSEXW_Factory = WNDCLASSEXW_Factory;
exports.WNDCLASSEXW_Init = WNDCLASSEXW_Init;
exports.WNDCLASSEXW_Name = WNDCLASSEXW_Name;
exports.genComplexStruct = genComplexStruct;
exports.genFixedArray = genFixedArray;
exports.genFixedInt16Array = genFixedInt16Array;
exports.genSimpleStruct = genSimpleStruct;
exports.genSimpleUnion = genSimpleUnion;
exports.genStruct = genStruct;
exports.genUnion = genUnion;
exports.getPRINTER_INFO_X_Ptr = getPRINTER_INFO_X_Ptr;
//# sourceMappingURL=index.struct.cjs.map