SSL setupapi.rs   Sprache: unbekannt

// Licensed under the Apache License, Version 2.0
// <LICENSE-APACHE or http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your option.
// All files in the project carrying such notice may not be copied, modified, or distributed
// except according to those terms.
//! Public header file for Windows NT Setup and Device Installer services Dll.
use ctypes::c_int;
use shared::basetsd::{DWORD_PTR, UINT_PTR, ULONG_PTR};
use shared::devpropdef::{DEVPROPKEY, DEVPROPTYPE};
use shared::guiddef::{GUID, LPGUID};
use shared::minwindef::{
    BOOL, BYTE, DWORD, FILETIME, HINSTANCE, HKEY, INT, LPARAM, LPCVOID, LPDWORD, MAX_PATH, PBOOL,
    PBYTE, PDWORD, PINT, PUINT, UINT, USHORT, WORD,
};
use shared::windef::{HDC, HICON, HWND, RECT};
use um::commctrl::HIMAGELIST;
use um::prsht::{HPROPSHEETPAGE, LPPROPSHEETHEADERA, LPPROPSHEETHEADERW};
use um::spapidef::SP_LOG_TOKEN;
use um::winnt::{
    ANYSIZE_ARRAY, APPLICATION_ERROR_MASK, CHAR, DWORDLONG, ERROR_SEVERITY_ERROR, HANDLE, LONG,
    LONGLONG, LPCSTR, LPCWSTR, PCSTR, PCWSTR, PSTR, PVOID, PWSTR, WCHAR,
};
use um::winreg::REGSAM;
pub const LINE_LEN: usize = 256;
pub const MAX_INF_STRING_LENGTH: usize = 4096;
pub const MAX_INF_SECTION_NAME_LENGTH: usize = 255;
pub const MAX_TITLE_LEN: usize = 60;
pub const MAX_INSTRUCTION_LEN: usize = 256;
pub const MAX_LABEL_LEN: usize = 30;
pub const MAX_SERVICE_NAME_LEN: usize = 256;
pub const MAX_SUBTITLE_LEN: usize = 256;
pub const SP_MAX_MACHINENAME_LENGTH: usize = MAX_PATH + 3;
pub type HINF = PVOID;
STRUCT!{#[cfg_attr(target_arch = "x86", repr(packed))] struct INFCONTEXT {
    Inf: PVOID,
    CurrentInf: PVOID,
    Section: UINT,
    Line: UINT,
}}
pub type PINFCONTEXT = *mut INFCONTEXT;
STRUCT!{#[cfg_attr(target_arch = "x86", repr(packed))] struct SP_INF_INFORMATION {
    InfStyle: DWORD,
    InfCount: DWORD,
    VersionData: [BYTE; ANYSIZE_ARRAY],
}}
pub type PSP_INF_INFORMATION = *mut SP_INF_INFORMATION;
UNION!{#[cfg_attr(target_arch = "x86", repr(packed))] union SP_ALTPLATFORM_INFO_V3_u {
    [u16; 1],
    Reserved Reserved_mut: WORD,
    Flags Flags_mut: WORD,
}}
STRUCT!{#[cfg_attr(target_arch = "x86", repr(packed))] struct SP_ALTPLATFORM_INFO_V3 {
    cbSize: DWORD,
    Platform: DWORD,
    MajorVersion: DWORD,
    MinorVersion: DWORD,
    ProcessorArchitecture: WORD,
    u: SP_ALTPLATFORM_INFO_V3_u,
    FirstValidatedMajorVersion: DWORD,
    FirstValidatedMinorVersion: DWORD,
    ProductType: BYTE,
    SuiteMask: WORD,
    BuildNumber: DWORD,
}}
pub type PSP_ALTPLATFORM_INFO_V3 = *mut SP_ALTPLATFORM_INFO_V3;
UNION!{#[cfg_attr(target_arch = "x86", repr(packed))] union SP_ALTPLATFORM_INFO_V2_u {
    [u16; 1],
    Reserved Reserved_mut: WORD,
    Flags Flags_mut: WORD,
}}
STRUCT!{#[cfg_attr(target_arch = "x86", repr(packed))] struct SP_ALTPLATFORM_INFO_V2 {
    cbSize: DWORD,
    Platform: DWORD,
    MajorVersion: DWORD,
    MinorVersion: DWORD,
    ProcessorArchitecture: WORD,
    u: SP_ALTPLATFORM_INFO_V2_u,
    FirstValidatedMajorVersion: DWORD,
    FirstValidatedMinorVersion: DWORD,
}}
pub type PSP_ALTPLATFORM_INFO_V2 = *mut SP_ALTPLATFORM_INFO_V2;
STRUCT!{#[cfg_attr(target_arch = "x86", repr(packed))] struct SP_ALTPLATFORM_INFO_V1 {
    cbSize: DWORD,
    Platform: DWORD,
    MajorVersion: DWORD,
    MinorVersion: DWORD,
    ProcessorArchitecture: WORD,
    Reserved: WORD,
}}
pub type PSP_ALTPLATFORM_INFO_V1 = *mut SP_ALTPLATFORM_INFO_V1;
pub type SP_ALTPLATFORM_INFO = SP_ALTPLATFORM_INFO_V2;
pub type PSP_ALTPLATFORM_INFO = PSP_ALTPLATFORM_INFO_V2;
pub const SP_ALTPLATFORM_FLAGS_VERSION_RANGE: WORD = 0x0001;
pub const SP_ALTPLATFORM_FLAGS_SUITE_MASK: WORD = 0x0002;
STRUCT!{#[cfg_attr(target_arch = "x86", repr(packed))] struct SP_ORIGINAL_FILE_INFO_A {
    cbSize: DWORD,
    OriginalInfName: [CHAR; MAX_PATH],
    OriginalCatalogName: [CHAR; MAX_PATH],
}}
pub type PSP_ORIGINAL_FILE_INFO_A = *mut SP_ORIGINAL_FILE_INFO_A;
STRUCT!{#[cfg_attr(target_arch = "x86", repr(packed))] struct SP_ORIGINAL_FILE_INFO_W {
    cbSize: DWORD,
    OriginalInfName: [WCHAR; MAX_PATH],
    OriginalCatalogName: [WCHAR; MAX_PATH],
}}
pub type PSP_ORIGINAL_FILE_INFO_W = *mut SP_ORIGINAL_FILE_INFO_W;
pub const INF_STYLE_NONE: DWORD = 0x00000000;
pub const INF_STYLE_OLDNT: DWORD = 0x00000001;
pub const INF_STYLE_WIN4: DWORD = 0x00000002;
pub const INF_STYLE_CACHE_ENABLE: DWORD = 0x00000010;
pub const INF_STYLE_CACHE_DISABLE: DWORD = 0x00000020;
pub const INF_STYLE_CACHE_IGNORE: DWORD = 0x00000040;
pub const DIRID_ABSOLUTE: DWORD = -1i32 as u32;
pub const DIRID_ABSOLUTE_16BIT: DWORD = 0xffff;
pub const DIRID_NULL: DWORD = 0;
pub const DIRID_SRCPATH: DWORD = 1;
pub const DIRID_WINDOWS: DWORD = 10;
pub const DIRID_SYSTEM: DWORD = 11;
pub const DIRID_DRIVERS: DWORD = 12;
pub const DIRID_IOSUBSYS: DWORD = DIRID_DRIVERS;
pub const DIRID_DRIVER_STORE: DWORD = 13;
pub const DIRID_INF: DWORD = 17;
pub const DIRID_HELP: DWORD = 18;
pub const DIRID_FONTS: DWORD = 20;
pub const DIRID_VIEWERS: DWORD = 21;
pub const DIRID_COLOR: DWORD = 23;
pub const DIRID_APPS: DWORD = 24;
pub const DIRID_SHARED: DWORD = 25;
pub const DIRID_BOOT: DWORD = 30;
pub const DIRID_SYSTEM16: DWORD = 50;
pub const DIRID_SPOOL: DWORD = 51;
pub const DIRID_SPOOLDRIVERS: DWORD = 52;
pub const DIRID_USERPROFILE: DWORD = 53;
pub const DIRID_LOADER: DWORD = 54;
pub const DIRID_PRINTPROCESSOR: DWORD = 55;
pub const DIRID_DEFAULT: DWORD = DIRID_SYSTEM;
pub const DIRID_COMMON_STARTMENU: DWORD = 16406;
pub const DIRID_COMMON_PROGRAMS: DWORD = 16407;
pub const DIRID_COMMON_STARTUP: DWORD = 16408;
pub const DIRID_COMMON_DESKTOPDIRECTORY: DWORD = 16409;
pub const DIRID_COMMON_FAVORITES: DWORD = 16415;
pub const DIRID_COMMON_APPDATA: DWORD = 16419;
pub const DIRID_PROGRAM_FILES: DWORD = 16422;
pub const DIRID_SYSTEM_X86: DWORD = 16425;
pub const DIRID_PROGRAM_FILES_X86: DWORD = 16426;
pub const DIRID_PROGRAM_FILES_COMMON: DWORD = 16427;
pub const DIRID_PROGRAM_FILES_COMMONX86: DWORD = 16428;
pub const DIRID_COMMON_TEMPLATES: DWORD = 16429;
pub const DIRID_COMMON_DOCUMENTS: DWORD = 16430;
pub const DIRID_USER: DWORD = 0x8000;
FN!{stdcall PSP_FILE_CALLBACK_A(
    Context: PVOID,
    Notification: UINT,
    Param1: UINT_PTR,
    Param2: UINT_PTR,
) -> UINT}
FN!{stdcall PSP_FILE_CALLBACK_W(
    Context: PVOID,
    Notification: UINT,
    Param1: UINT_PTR,
    Param2: UINT_PTR,
) -> UINT}
pub const SPFILENOTIFY_STARTQUEUE: UINT = 0x00000001;
pub const SPFILENOTIFY_ENDQUEUE: UINT = 0x00000002;
pub const SPFILENOTIFY_STARTSUBQUEUE: UINT = 0x00000003;
pub const SPFILENOTIFY_ENDSUBQUEUE: UINT = 0x00000004;
pub const SPFILENOTIFY_STARTDELETE: UINT = 0x00000005;
pub const SPFILENOTIFY_ENDDELETE: UINT = 0x00000006;
pub const SPFILENOTIFY_DELETEERROR: UINT = 0x00000007;
pub const SPFILENOTIFY_STARTRENAME: UINT = 0x00000008;
pub const SPFILENOTIFY_ENDRENAME: UINT = 0x00000009;
pub const SPFILENOTIFY_RENAMEERROR: UINT = 0x0000000a;
pub const SPFILENOTIFY_STARTCOPY: UINT = 0x0000000b;
pub const SPFILENOTIFY_ENDCOPY: UINT = 0x0000000c;
pub const SPFILENOTIFY_COPYERROR: UINT = 0x0000000d;
pub const SPFILENOTIFY_NEEDMEDIA: UINT = 0x0000000e;
pub const SPFILENOTIFY_QUEUESCAN: UINT = 0x0000000f;
pub const SPFILENOTIFY_CABINETINFO: UINT = 0x00000010;
pub const SPFILENOTIFY_FILEINCABINET: UINT = 0x00000011;
pub const SPFILENOTIFY_NEEDNEWCABINET: UINT = 0x00000012;
pub const SPFILENOTIFY_FILEEXTRACTED: UINT = 0x00000013;
pub const SPFILENOTIFY_FILEOPDELAYED: UINT = 0x00000014;
pub const SPFILENOTIFY_STARTBACKUP: UINT = 0x00000015;
pub const SPFILENOTIFY_BACKUPERROR: UINT = 0x00000016;
pub const SPFILENOTIFY_ENDBACKUP: UINT = 0x00000017;
pub const SPFILENOTIFY_QUEUESCAN_EX: UINT = 0x00000018;
pub const SPFILENOTIFY_STARTREGISTRATION: UINT = 0x00000019;
pub const SPFILENOTIFY_ENDREGISTRATION: UINT = 0x00000020;
pub const SPFILENOTIFY_QUEUESCAN_SIGNERINFO: UINT = 0x00000040;
pub const SPFILENOTIFY_LANGMISMATCH: UINT = 0x00010000;
pub const SPFILENOTIFY_TARGETEXISTS: UINT = 0x00020000;
pub const SPFILENOTIFY_TARGETNEWER: UINT = 0x00040000;
pub const FILEOP_COPY: UINT = 0;
pub const FILEOP_RENAME: UINT = 1;
pub const FILEOP_DELETE: UINT = 2;
pub const FILEOP_BACKUP: UINT = 3;
pub const FILEOP_ABORT: UINT = 0;
pub const FILEOP_DOIT: UINT = 1;
pub const FILEOP_SKIP: UINT = 2;
pub const FILEOP_RETRY: UINT = FILEOP_DOIT;
pub const FILEOP_NEWPATH: UINT = 4;
pub const COPYFLG_WARN_IF_SKIP: UINT = 0x00000001;
pub const COPYFLG_NOSKIP: UINT = 0x00000002;
pub const COPYFLG_NOVERSIONCHECK: UINT = 0x00000004;
pub const COPYFLG_FORCE_FILE_IN_USE: UINT = 0x00000008;
pub const COPYFLG_NO_OVERWRITE: UINT = 0x00000010;
pub const COPYFLG_NO_VERSION_DIALOG: UINT = 0x00000020;
pub const COPYFLG_OVERWRITE_OLDER_ONLY: UINT = 0x00000040;
pub const COPYFLG_PROTECTED_WINDOWS_DRIVER_FILE: UINT = 0x00000100;
pub const COPYFLG_REPLACEONLY: UINT = 0x00000400;
pub const COPYFLG_NODECOMP: UINT = 0x00000800;
pub const COPYFLG_REPLACE_BOOT_FILE: UINT = 0x00001000;
pub const COPYFLG_NOPRUNE: UINT = 0x00002000;
pub const COPYFLG_IN_USE_TRY_RENAME: UINT = 0x00004000;
pub const DELFLG_IN_USE: UINT = 0x00000001;
pub const DELFLG_IN_USE1: UINT = 0x00010000;
STRUCT!{#[cfg_attr(target_arch = "x86", repr(packed))] struct FILEPATHS_A {
    Target: PCSTR,
    Source: PCSTR,
    Win32Error: UINT,
    Flags: DWORD,
}}
pub type PFILEPATHS_A = *mut FILEPATHS_A;
STRUCT!{#[cfg_attr(target_arch = "x86", repr(packed))] struct FILEPATHS_W {
    Target: PCWSTR,
    Source: PCWSTR,
    Win32Error: UINT,
    Flags: DWORD,
}}
pub type PFILEPATHS_W = *mut FILEPATHS_W;
STRUCT!{#[cfg_attr(target_arch = "x86", repr(packed))] struct FILEPATHS_SIGNERINFO_A {
    Target: PCSTR,
    Source: PCSTR,
    Win32Error: UINT,
    Flags: DWORD,
    DigitalSigner: PCSTR,
    Version: PCSTR,
    CatalogFile: PCSTR,
}}
pub type PFILEPATHS_SIGNERINFO_A = *mut FILEPATHS_SIGNERINFO_A;
STRUCT!{#[cfg_attr(target_arch = "x86", repr(packed))] struct FILEPATHS_SIGNERINFO_W {
    Target: PCWSTR,
    Source: PCWSTR,
    Win32Error: UINT,
    Flags: DWORD,
    DigitalSigner: PCWSTR,
    Version: PCWSTR,
    CatalogFile: PCWSTR,
}}
pub type PFILEPATHS_SIGNERINFO_W = *mut FILEPATHS_SIGNERINFO_W;
STRUCT!{#[cfg_attr(target_arch = "x86", repr(packed))] struct SOURCE_MEDIA_A {
    Reserved: PCSTR,
    Tagfile: PCSTR,
    Description: PCSTR,
    SourcePath: PCSTR,
    SourceFile: PCSTR,
    Flags: DWORD,
}}
pub type PSOURCE_MEDIA_A = *mut SOURCE_MEDIA_A;
STRUCT!{#[cfg_attr(target_arch = "x86", repr(packed))] struct SOURCE_MEDIA_W {
    Reserved: PCWSTR,
    Tagfile: PCWSTR,
    Description: PCWSTR,
    SourcePath: PCWSTR,
    SourceFile: PCWSTR,
    Flags: DWORD,
}}
pub type PSOURCE_MEDIA_W = *mut SOURCE_MEDIA_W;
STRUCT!{#[cfg_attr(target_arch = "x86", repr(packed))] struct CABINET_INFO_A {
    CabinetPath: PCSTR,
    CabinetFile: PCSTR,
    DiskName: PCSTR,
    SetId: USHORT,
    CabinetNumber: USHORT,
}}
pub type PCABINET_INFO_A = *mut CABINET_INFO_A;
STRUCT!{#[cfg_attr(target_arch = "x86", repr(packed))] struct CABINET_INFO_W {
    CabinetPath: PCWSTR,
    CabinetFile: PCWSTR,
    DiskName: PCWSTR,
    SetId: USHORT,
    CabinetNumber: USHORT,
}}
pub type PCABINET_INFO_W = *mut CABINET_INFO_W;
STRUCT!{#[cfg_attr(target_arch = "x86", repr(packed))] struct FILE_IN_CABINET_INFO_A {
    NameInCabinet: PCSTR,
    FileSize: DWORD,
    Win32Error: DWORD,
    DosDate: WORD,
    DosTime: WORD,
    DosAttribs: WORD,
    FullTargetName: [CHAR; MAX_PATH],
}}
pub type PFILE_IN_CABINET_INFO_A = *mut FILE_IN_CABINET_INFO_A;
STRUCT!{#[cfg_attr(target_arch = "x86", repr(packed))] struct FILE_IN_CABINET_INFO_W {
    NameInCabinet: PCWSTR,
    FileSize: DWORD,
    Win32Error: DWORD,
    DosDate: WORD,
    DosTime: WORD,
    DosAttribs: WORD,
    FullTargetName: [WCHAR; MAX_PATH],
}}
pub type PFILE_IN_CABINET_INFO_W = *mut FILE_IN_CABINET_INFO_W;
STRUCT!{#[cfg_attr(target_arch = "x86", repr(packed))] struct SP_REGISTER_CONTROL_STATUSA {
    cbSize: DWORD,
    FileName: PCSTR,
    Win32Error: DWORD,
    FailureCode: DWORD,
}}
pub type PSP_REGISTER_CONTROL_STATUSA = *mut SP_REGISTER_CONTROL_STATUSA;
STRUCT!{#[cfg_attr(target_arch = "x86", repr(packed))] struct SP_REGISTER_CONTROL_STATUSW {
    cbSize: DWORD,
    FileName: PCWSTR,
    Win32Error: DWORD,
    FailureCode: DWORD,
}}
pub type PSP_REGISTER_CONTROL_STATUSW = *mut SP_REGISTER_CONTROL_STATUSW;
pub const SPREG_SUCCESS: DWORD = 0x00000000;
pub const SPREG_LOADLIBRARY: DWORD = 0x00000001;
pub const SPREG_GETPROCADDR: DWORD = 0x00000002;
pub const SPREG_REGSVR: DWORD = 0x00000003;
pub const SPREG_DLLINSTALL: DWORD = 0x00000004;
pub const SPREG_TIMEOUT: DWORD = 0x00000005;
pub const SPREG_UNKNOWN: DWORD = 0xFFFFFFFF;
pub type HSPFILEQ = PVOID;
STRUCT!{#[cfg_attr(target_arch = "x86", repr(packed))] struct SP_FILE_COPY_PARAMS_A {
    cbSize: DWORD,
    QueueHandle: HSPFILEQ,
    SourceRootPath: PCSTR,
    SourcePath: PCSTR,
    SourceFilename: PCSTR,
    SourceDescription: PCSTR,
    SourceTagfile: PCSTR,
    TargetDirectory: PCSTR,
    TargetFilename: PCSTR,
    CopyStyle: DWORD,
    LayoutInf: HINF,
    SecurityDescriptor: PCSTR,
}}
pub type PSP_FILE_COPY_PARAMS_A = *mut SP_FILE_COPY_PARAMS_A;
STRUCT!{#[cfg_attr(target_arch = "x86", repr(packed))] struct SP_FILE_COPY_PARAMS_W {
    cbSize: DWORD,
    QueueHandle: HSPFILEQ,
    SourceRootPath: PCWSTR,
    SourcePath: PCWSTR,
    SourceFilename: PCWSTR,
    SourceDescription: PCWSTR,
    SourceTagfile: PCWSTR,
    TargetDirectory: PCWSTR,
    TargetFilename: PCWSTR,
    CopyStyle: DWORD,
    LayoutInf: HINF,
    SecurityDescriptor: PCWSTR,
}}
pub type PSP_FILE_COPY_PARAMS_W = *mut SP_FILE_COPY_PARAMS_W;
pub type HDSKSPC = PVOID;
pub type HDEVINFO = PVOID;
STRUCT!{#[cfg_attr(target_arch = "x86", repr(packed))] struct SP_DEVINFO_DATA {
    cbSize: DWORD,
    ClassGuid: GUID,
    DevInst: DWORD,
    Reserved: ULONG_PTR,
}}
pub type PSP_DEVINFO_DATA = *mut SP_DEVINFO_DATA;
STRUCT!{#[cfg_attr(target_arch = "x86", repr(packed))] struct SP_DEVICE_INTERFACE_DATA {
    cbSize: DWORD,
    InterfaceClassGuid: GUID,
    Flags: DWORD,
    Reserved: ULONG_PTR,
}}
pub type PSP_DEVICE_INTERFACE_DATA = *mut SP_DEVICE_INTERFACE_DATA;
pub const SPINT_ACTIVE: DWORD = 0x00000001;
pub const SPINT_DEFAULT: DWORD = 0x00000002;
pub const SPINT_REMOVED: DWORD = 0x00000004;
pub type SP_INTERFACE_DEVICE_DATA = SP_DEVICE_INTERFACE_DATA;
pub type PSP_INTERFACE_DEVICE_DATA = PSP_DEVICE_INTERFACE_DATA;
pub const SPID_ACTIVE: DWORD = SPINT_ACTIVE;
pub const SPID_DEFAULT: DWORD = SPINT_DEFAULT;
pub const SPID_REMOVED: DWORD = SPINT_REMOVED;
STRUCT!{#[cfg_attr(target_arch = "x86", repr(packed))] struct SP_DEVICE_INTERFACE_DETAIL_DATA_A {
    cbSize: DWORD,
    DevicePath: [CHAR; ANYSIZE_ARRAY],
}}
pub type PSP_DEVICE_INTERFACE_DETAIL_DATA_A = *mut SP_DEVICE_INTERFACE_DETAIL_DATA_A;
STRUCT!{#[cfg_attr(target_arch = "x86", repr(packed))] struct SP_DEVICE_INTERFACE_DETAIL_DATA_W {
    cbSize: DWORD,
    DevicePath: [WCHAR; ANYSIZE_ARRAY],
}}
pub type PSP_DEVICE_INTERFACE_DETAIL_DATA_W = *mut SP_DEVICE_INTERFACE_DETAIL_DATA_W;
STRUCT!{#[cfg_attr(target_arch = "x86", repr(packed))] struct SP_DEVINFO_LIST_DETAIL_DATA_A {
    cbSize: DWORD,
    ClassGuid: GUID,
    RemoteMachineHandle: HANDLE,
    RemoteMachineName: [CHAR; SP_MAX_MACHINENAME_LENGTH],
}}
pub type PSP_DEVINFO_LIST_DETAIL_DATA_A = *mut SP_DEVINFO_LIST_DETAIL_DATA_A;
STRUCT!{#[cfg_attr(target_arch = "x86", repr(packed))] struct SP_DEVINFO_LIST_DETAIL_DATA_W {
    cbSize: DWORD,
    ClassGuid: GUID,
    RemoteMachineHandle: HANDLE,
    RemoteMachineName: [WCHAR; SP_MAX_MACHINENAME_LENGTH],
}}
pub type PSP_DEVINFO_LIST_DETAIL_DATA_W = *mut SP_DEVINFO_LIST_DETAIL_DATA_W;
pub const DIF_SELECTDEVICE: DI_FUNCTION = 0x00000001;
pub const DIF_INSTALLDEVICE: DI_FUNCTION = 0x00000002;
pub const DIF_ASSIGNRESOURCES: DI_FUNCTION = 0x00000003;
pub const DIF_PROPERTIES: DI_FUNCTION = 0x00000004;
pub const DIF_REMOVE: DI_FUNCTION = 0x00000005;
pub const DIF_FIRSTTIMESETUP: DI_FUNCTION = 0x00000006;
pub const DIF_FOUNDDEVICE: DI_FUNCTION = 0x00000007;
pub const DIF_SELECTCLASSDRIVERS: DI_FUNCTION = 0x00000008;
pub const DIF_VALIDATECLASSDRIVERS: DI_FUNCTION = 0x00000009;
pub const DIF_INSTALLCLASSDRIVERS: DI_FUNCTION = 0x0000000A;
pub const DIF_CALCDISKSPACE: DI_FUNCTION = 0x0000000B;
pub const DIF_DESTROYPRIVATEDATA: DI_FUNCTION = 0x0000000C;
pub const DIF_VALIDATEDRIVER: DI_FUNCTION = 0x0000000D;
pub const DIF_DETECT: DI_FUNCTION = 0x0000000F;
pub const DIF_INSTALLWIZARD: DI_FUNCTION = 0x00000010;
pub const DIF_DESTROYWIZARDDATA: DI_FUNCTION = 0x00000011;
pub const DIF_PROPERTYCHANGE: DI_FUNCTION = 0x00000012;
pub const DIF_ENABLECLASS: DI_FUNCTION = 0x00000013;
pub const DIF_DETECTVERIFY: DI_FUNCTION = 0x00000014;
pub const DIF_INSTALLDEVICEFILES: DI_FUNCTION = 0x00000015;
pub const DIF_UNREMOVE: DI_FUNCTION = 0x00000016;
pub const DIF_SELECTBESTCOMPATDRV: DI_FUNCTION = 0x00000017;
pub const DIF_ALLOW_INSTALL: DI_FUNCTION = 0x00000018;
pub const DIF_REGISTERDEVICE: DI_FUNCTION = 0x00000019;
pub const DIF_NEWDEVICEWIZARD_PRESELECT: DI_FUNCTION = 0x0000001A;
pub const DIF_NEWDEVICEWIZARD_SELECT: DI_FUNCTION = 0x0000001B;
pub const DIF_NEWDEVICEWIZARD_PREANALYZE: DI_FUNCTION = 0x0000001C;
pub const DIF_NEWDEVICEWIZARD_POSTANALYZE: DI_FUNCTION = 0x0000001D;
pub const DIF_NEWDEVICEWIZARD_FINISHINSTALL: DI_FUNCTION = 0x0000001E;
pub const DIF_UNUSED1: DI_FUNCTION = 0x0000001F;
pub const DIF_INSTALLINTERFACES: DI_FUNCTION = 0x00000020;
pub const DIF_DETECTCANCEL: DI_FUNCTION = 0x00000021;
pub const DIF_REGISTER_COINSTALLERS: DI_FUNCTION = 0x00000022;
pub const DIF_ADDPROPERTYPAGE_ADVANCED: DI_FUNCTION = 0x00000023;
pub const DIF_ADDPROPERTYPAGE_BASIC: DI_FUNCTION = 0x00000024;
pub const DIF_RESERVED1: DI_FUNCTION = 0x00000025;
pub const DIF_TROUBLESHOOTER: DI_FUNCTION = 0x00000026;
pub const DIF_POWERMESSAGEWAKE: DI_FUNCTION = 0x00000027;
pub const DIF_ADDREMOTEPROPERTYPAGE_ADVANCED: DI_FUNCTION = 0x00000028;
pub const DIF_UPDATEDRIVER_UI: DI_FUNCTION = 0x00000029;
pub const DIF_FINISHINSTALL_ACTION: DI_FUNCTION = 0x0000002A;
pub const DIF_RESERVED2: DI_FUNCTION = 0x00000030;
pub const DIF_MOVEDEVICE: DI_FUNCTION = 0x0000000E;
pub type DI_FUNCTION = UINT;
STRUCT!{#[cfg_attr(target_arch = "x86", repr(packed))] struct SP_DEVINSTALL_PARAMS_A {
    cbSize: DWORD,
    Flags: DWORD,
    FlagsEx: DWORD,
    hwndParent: HWND,
    InstallMsgHandler: PSP_FILE_CALLBACK_A,
    InstallMsgHandlerContext: PVOID,
    FileQueue: HSPFILEQ,
    ClassInstallReserved: ULONG_PTR,
    Reserved: DWORD,
    DriverPath: [CHAR; MAX_PATH],
}}
pub type PSP_DEVINSTALL_PARAMS_A = *mut SP_DEVINSTALL_PARAMS_A;
STRUCT!{#[cfg_attr(target_arch = "x86", repr(packed))] struct SP_DEVINSTALL_PARAMS_W {
    cbSize: DWORD,
    Flags: DWORD,
    FlagsEx: DWORD,
    hwndParent: HWND,
    InstallMsgHandler: PSP_FILE_CALLBACK_W,
    InstallMsgHandlerContext: PVOID,
    FileQueue: HSPFILEQ,
    ClassInstallReserved: ULONG_PTR,
    Reserved: DWORD,
    DriverPath: [WCHAR; MAX_PATH],
}}
pub type PSP_DEVINSTALL_PARAMS_W = *mut SP_DEVINSTALL_PARAMS_W;
pub const DI_SHOWOEM: DWORD = 0x00000001;
pub const DI_SHOWCOMPAT: DWORD = 0x00000002;
pub const DI_SHOWCLASS: DWORD = 0x00000004;
pub const DI_SHOWALL: DWORD = 0x00000007;
pub const DI_NOVCP: DWORD = 0x00000008;
pub const DI_DIDCOMPAT: DWORD = 0x00000010;
pub const DI_DIDCLASS: DWORD = 0x00000020;
pub const DI_AUTOASSIGNRES: DWORD = 0x00000040;
pub const DI_NEEDRESTART: DWORD = 0x00000080;
pub const DI_NEEDREBOOT: DWORD = 0x00000100;
pub const DI_NOBROWSE: DWORD = 0x00000200;
pub const DI_MULTMFGS: DWORD = 0x00000400;
pub const DI_DISABLED: DWORD = 0x00000800;
pub const DI_GENERALPAGE_ADDED: DWORD = 0x00001000;
pub const DI_RESOURCEPAGE_ADDED: DWORD = 0x00002000;
pub const DI_PROPERTIES_CHANGE: DWORD = 0x00004000;
pub const DI_INF_IS_SORTED: DWORD = 0x00008000;
pub const DI_ENUMSINGLEINF: DWORD = 0x00010000;
pub const DI_DONOTCALLCONFIGMG: DWORD = 0x00020000;
pub const DI_INSTALLDISABLED: DWORD = 0x00040000;
pub const DI_COMPAT_FROM_CLASS: DWORD = 0x00080000;
pub const DI_CLASSINSTALLPARAMS: DWORD = 0x00100000;
pub const DI_NODI_DEFAULTACTION: DWORD = 0x00200000;
pub const DI_QUIETINSTALL: DWORD = 0x00800000;
pub const DI_NOFILECOPY: DWORD = 0x01000000;
pub const DI_FORCECOPY: DWORD = 0x02000000;
pub const DI_DRIVERPAGE_ADDED: DWORD = 0x04000000;
pub const DI_USECI_SELECTSTRINGS: DWORD = 0x08000000;
pub const DI_OVERRIDE_INFFLAGS: DWORD = 0x10000000;
pub const DI_PROPS_NOCHANGEUSAGE: DWORD = 0x20000000;
pub const DI_NOSELECTICONS: DWORD = 0x40000000;
pub const DI_NOWRITE_IDS: DWORD = 0x80000000;
pub const DI_FLAGSEX_RESERVED2: DWORD = 0x00000001;
pub const DI_FLAGSEX_RESERVED3: DWORD = 0x00000002;
pub const DI_FLAGSEX_CI_FAILED: DWORD = 0x00000004;
pub const DI_FLAGSEX_FINISHINSTALL_ACTION: DWORD = 0x00000008;
pub const DI_FLAGSEX_DIDINFOLIST: DWORD = 0x00000010;
pub const DI_FLAGSEX_DIDCOMPATINFO: DWORD = 0x00000020;
pub const DI_FLAGSEX_FILTERCLASSES: DWORD = 0x00000040;
pub const DI_FLAGSEX_SETFAILEDINSTALL: DWORD = 0x00000080;
pub const DI_FLAGSEX_DEVICECHANGE: DWORD = 0x00000100;
pub const DI_FLAGSEX_ALWAYSWRITEIDS: DWORD = 0x00000200;
pub const DI_FLAGSEX_PROPCHANGE_PENDING: DWORD = 0x00000400;
pub const DI_FLAGSEX_ALLOWEXCLUDEDDRVS: DWORD = 0x00000800;
pub const DI_FLAGSEX_NOUIONQUERYREMOVE: DWORD = 0x00001000;
pub const DI_FLAGSEX_USECLASSFORCOMPAT: DWORD = 0x00002000;
pub const DI_FLAGSEX_RESERVED4: DWORD = 0x00004000;
pub const DI_FLAGSEX_NO_DRVREG_MODIFY: DWORD = 0x00008000;
pub const DI_FLAGSEX_IN_SYSTEM_SETUP: DWORD = 0x00010000;
pub const DI_FLAGSEX_INET_DRIVER: DWORD = 0x00020000;
pub const DI_FLAGSEX_APPENDDRIVERLIST: DWORD = 0x00040000;
pub const DI_FLAGSEX_PREINSTALLBACKUP: DWORD = 0x00080000;
pub const DI_FLAGSEX_BACKUPONREPLACE: DWORD = 0x00100000;
pub const DI_FLAGSEX_DRIVERLIST_FROM_URL: DWORD = 0x00200000;
pub const DI_FLAGSEX_RESERVED1: DWORD = 0x00400000;
pub const DI_FLAGSEX_EXCLUDE_OLD_INET_DRIVERS: DWORD = 0x00800000;
pub const DI_FLAGSEX_POWERPAGE_ADDED: DWORD = 0x01000000;
pub const DI_FLAGSEX_FILTERSIMILARDRIVERS: DWORD = 0x02000000;
pub const DI_FLAGSEX_INSTALLEDDRIVER: DWORD = 0x04000000;
pub const DI_FLAGSEX_NO_CLASSLIST_NODE_MERGE: DWORD = 0x08000000;
pub const DI_FLAGSEX_ALTPLATFORM_DRVSEARCH: DWORD = 0x10000000;
pub const DI_FLAGSEX_RESTART_DEVICE_ONLY: DWORD = 0x20000000;
pub const DI_FLAGSEX_RECURSIVESEARCH: DWORD = 0x40000000;
pub const DI_FLAGSEX_SEARCH_PUBLISHED_INFS: DWORD = 0x80000000;
STRUCT!{#[cfg_attr(target_arch = "x86", repr(packed))] struct SP_CLASSINSTALL_HEADER {
    cbSize: DWORD,
    InstallFunction: DI_FUNCTION,
}}
pub type PSP_CLASSINSTALL_HEADER = *mut SP_CLASSINSTALL_HEADER;
STRUCT!{#[cfg_attr(target_arch = "x86", repr(packed))] struct SP_ENABLECLASS_PARAMS {
    ClassInstallHeader: SP_CLASSINSTALL_HEADER,
    ClassGuid: GUID,
    EnableMessage: DWORD,
}}
pub type PSP_ENABLECLASS_PARAMS = *mut SP_ENABLECLASS_PARAMS;
pub const ENABLECLASS_QUERY: DWORD = 0;
pub const ENABLECLASS_SUCCESS: DWORD = 1;
pub const ENABLECLASS_FAILURE: DWORD = 2;
pub const DICS_ENABLE: DWORD = 0x00000001;
pub const DICS_DISABLE: DWORD = 0x00000002;
pub const DICS_PROPCHANGE: DWORD = 0x00000003;
pub const DICS_START: DWORD = 0x00000004;
pub const DICS_STOP: DWORD = 0x00000005;
pub const DICS_FLAG_GLOBAL: DWORD = 0x00000001;
pub const DICS_FLAG_CONFIGSPECIFIC: DWORD = 0x00000002;
pub const DICS_FLAG_CONFIGGENERAL: DWORD = 0x00000004;
STRUCT!{#[cfg_attr(target_arch = "x86", repr(packed))] struct SP_PROPCHANGE_PARAMS {
    ClassInstallHeader: SP_CLASSINSTALL_HEADER,
    StateChange: DWORD,
    Scope: DWORD,
    HwProfile: DWORD,
}}
pub type PSP_PROPCHANGE_PARAMS = *mut SP_PROPCHANGE_PARAMS;
STRUCT!{#[cfg_attr(target_arch = "x86", repr(packed))] struct SP_REMOVEDEVICE_PARAMS {
    ClassInstallHeader: SP_CLASSINSTALL_HEADER,
    Scope: DWORD,
    HwProfile: DWORD,
}}
pub type PSP_REMOVEDEVICE_PARAMS = *mut SP_REMOVEDEVICE_PARAMS;
pub const DI_REMOVEDEVICE_GLOBAL: DWORD = 0x00000001;
pub const DI_REMOVEDEVICE_CONFIGSPECIFIC: DWORD = 0x00000002;
STRUCT!{#[cfg_attr(target_arch = "x86", repr(packed))] struct SP_UNREMOVEDEVICE_PARAMS {
    ClassInstallHeader: SP_CLASSINSTALL_HEADER,
    Scope: DWORD,
    HwProfile: DWORD,
}}
pub type PSP_UNREMOVEDEVICE_PARAMS = *mut SP_UNREMOVEDEVICE_PARAMS;
pub const DI_UNREMOVEDEVICE_CONFIGSPECIFIC: DWORD = 0x00000002;
STRUCT!{#[cfg_attr(target_arch = "x86", repr(packed))] struct SP_SELECTDEVICE_PARAMS_A {
    ClassInstallHeader: SP_CLASSINSTALL_HEADER,
    Title: [CHAR; MAX_TITLE_LEN],
    Instructions: [CHAR; MAX_INSTRUCTION_LEN],
    ListLabel: [CHAR; MAX_LABEL_LEN],
    SubTitle: [CHAR; MAX_SUBTITLE_LEN],
    Reserved: [BYTE; 2],
}}
pub type PSP_SELECTDEVICE_PARAMS_A = *mut SP_SELECTDEVICE_PARAMS_A;
STRUCT!{#[cfg_attr(target_arch = "x86", repr(packed))] struct SP_SELECTDEVICE_PARAMS_W {
    ClassInstallHeader: SP_CLASSINSTALL_HEADER,
    Title: [WCHAR; MAX_TITLE_LEN],
    Instructions: [WCHAR; MAX_INSTRUCTION_LEN],
    ListLabel: [WCHAR; MAX_LABEL_LEN],
    SubTitle: [WCHAR; MAX_SUBTITLE_LEN],
}}
pub type PSP_SELECTDEVICE_PARAMS_W = *mut SP_SELECTDEVICE_PARAMS_W;
FN!{stdcall PDETECT_PROGRESS_NOTIFY(
    ProgressNotifyParam: PVOID,
    DetectComplete: DWORD,
) -> BOOL}
STRUCT!{#[cfg_attr(target_arch = "x86", repr(packed))] struct SP_DETECTDEVICE_PARAMS {
    ClassInstallHeader: SP_CLASSINSTALL_HEADER,
    DetectProgressNotify: PDETECT_PROGRESS_NOTIFY,
    ProgressNotifyParam: PVOID,
}}
pub type PSP_DETECTDEVICE_PARAMS = *mut SP_DETECTDEVICE_PARAMS;
pub const MAX_INSTALLWIZARD_DYNAPAGES: usize = 20;
STRUCT!{#[cfg_attr(target_arch = "x86", repr(packed))] struct SP_INSTALLWIZARD_DATA {
    ClassInstallHeader: SP_CLASSINSTALL_HEADER,
    Flags: DWORD,
    DynamicPages: [HPROPSHEETPAGE; MAX_INSTALLWIZARD_DYNAPAGES],
    NumDynamicPages: DWORD,
    DynamicPageFlags: DWORD,
    PrivateFlags: DWORD,
    PrivateData: LPARAM,
    hwndWizardDlg: HWND,
}}
pub type PSP_INSTALLWIZARD_DATA = *mut SP_INSTALLWIZARD_DATA;
pub const NDW_INSTALLFLAG_DIDFACTDEFS: DWORD = 0x00000001;
pub const NDW_INSTALLFLAG_HARDWAREALLREADYIN: DWORD = 0x00000002;
pub const NDW_INSTALLFLAG_NEEDRESTART: DWORD = DI_NEEDRESTART;
pub const NDW_INSTALLFLAG_NEEDREBOOT: DWORD = DI_NEEDREBOOT;
pub const NDW_INSTALLFLAG_NEEDSHUTDOWN: DWORD = 0x00000200;
pub const NDW_INSTALLFLAG_EXPRESSINTRO: DWORD = 0x00000400;
pub const NDW_INSTALLFLAG_SKIPISDEVINSTALLED: DWORD = 0x00000800;
pub const NDW_INSTALLFLAG_NODETECTEDDEVS: DWORD = 0x00001000;
pub const NDW_INSTALLFLAG_INSTALLSPECIFIC: DWORD = 0x00002000;
pub const NDW_INSTALLFLAG_SKIPCLASSLIST: DWORD = 0x00004000;
pub const NDW_INSTALLFLAG_CI_PICKED_OEM: DWORD = 0x00008000;
pub const NDW_INSTALLFLAG_PCMCIAMODE: DWORD = 0x00010000;
pub const NDW_INSTALLFLAG_PCMCIADEVICE: DWORD = 0x00020000;
pub const NDW_INSTALLFLAG_USERCANCEL: DWORD = 0x00040000;
pub const NDW_INSTALLFLAG_KNOWNCLASS: DWORD = 0x00080000;
pub const DYNAWIZ_FLAG_PAGESADDED: DWORD = 0x00000001;
pub const DYNAWIZ_FLAG_ANALYZE_HANDLECONFLICT: DWORD = 0x00000008;
pub const DYNAWIZ_FLAG_INSTALLDET_NEXT: DWORD = 0x00000002;
pub const DYNAWIZ_FLAG_INSTALLDET_PREV: DWORD = 0x00000004;
pub const MIN_IDD_DYNAWIZ_RESOURCE_ID: c_int = 10000;
pub const MAX_IDD_DYNAWIZ_RESOURCE_ID: c_int = 11000;
pub const IDD_DYNAWIZ_FIRSTPAGE: c_int = 10000;
pub const IDD_DYNAWIZ_SELECT_PREVPAGE: c_int = 10001;
pub const IDD_DYNAWIZ_SELECT_NEXTPAGE: c_int = 10002;
pub const IDD_DYNAWIZ_ANALYZE_PREVPAGE: c_int = 10003;
pub const IDD_DYNAWIZ_ANALYZE_NEXTPAGE: c_int = 10004;
pub const IDD_DYNAWIZ_SELECTDEV_PAGE: c_int = 10009;
pub const IDD_DYNAWIZ_ANALYZEDEV_PAGE: c_int = 10010;
pub const IDD_DYNAWIZ_INSTALLDETECTEDDEVS_PAGE: c_int = 10011;
pub const IDD_DYNAWIZ_SELECTCLASS_PAGE: c_int = 10012;
pub const IDD_DYNAWIZ_INSTALLDETECTED_PREVPAGE: c_int = 10006;
pub const IDD_DYNAWIZ_INSTALLDETECTED_NEXTPAGE: c_int = 10007;
pub const IDD_DYNAWIZ_INSTALLDETECTED_NODEVS: c_int = 10008;
STRUCT!{#[cfg_attr(target_arch = "x86", repr(packed))] struct SP_NEWDEVICEWIZARD_DATA {
    ClassInstallHeader: SP_CLASSINSTALL_HEADER,
    Flags: DWORD,
    DynamicPages: [HPROPSHEETPAGE; MAX_INSTALLWIZARD_DYNAPAGES],
    NumDynamicPages: DWORD,
    hwndWizardDlg: HWND,
}}
pub type PSP_NEWDEVICEWIZARD_DATA = *mut SP_NEWDEVICEWIZARD_DATA;
pub type SP_ADDPROPERTYPAGE_DATA = SP_NEWDEVICEWIZARD_DATA;
pub type PSP_ADDPROPERTYPAGE_DATA = PSP_NEWDEVICEWIZARD_DATA;
STRUCT!{#[cfg_attr(target_arch = "x86", repr(packed))] struct SP_TROUBLESHOOTER_PARAMS_A {
    ClassInstallHeader: SP_CLASSINSTALL_HEADER,
    ChmFile: [CHAR; MAX_PATH],
    HtmlTroubleShooter: [CHAR; MAX_PATH],
}}
pub type PSP_TROUBLESHOOTER_PARAMS_A = *mut SP_TROUBLESHOOTER_PARAMS_A;
STRUCT!{#[cfg_attr(target_arch = "x86", repr(packed))] struct SP_TROUBLESHOOTER_PARAMS_W {
    ClassInstallHeader: SP_CLASSINSTALL_HEADER,
    ChmFile: [WCHAR; MAX_PATH],
    HtmlTroubleShooter: [WCHAR; MAX_PATH],
}}
pub type PSP_TROUBLESHOOTER_PARAMS_W = *mut SP_TROUBLESHOOTER_PARAMS_W;
STRUCT!{#[cfg_attr(target_arch = "x86", repr(packed))] struct SP_POWERMESSAGEWAKE_PARAMS_A {
    ClassInstallHeader: SP_CLASSINSTALL_HEADER,
    PowerMessageWake: [CHAR; LINE_LEN * 2],
}}
pub type PSP_POWERMESSAGEWAKE_PARAMS_A = *mut SP_POWERMESSAGEWAKE_PARAMS_A;
STRUCT!{#[cfg_attr(target_arch = "x86", repr(packed))] struct SP_POWERMESSAGEWAKE_PARAMS_W {
    ClassInstallHeader: SP_CLASSINSTALL_HEADER,
    PowerMessageWake: [WCHAR; LINE_LEN * 2],
}}
pub type PSP_POWERMESSAGEWAKE_PARAMS_W = *mut SP_POWERMESSAGEWAKE_PARAMS_W;
STRUCT!{#[cfg_attr(target_arch = "x86", repr(packed))] struct SP_DRVINFO_DATA_V2_A {
    cbSize: DWORD,
    DriverType: DWORD,
    Reserved: ULONG_PTR,
    Description: [CHAR; LINE_LEN],
    MfgName: [CHAR; LINE_LEN],
    ProviderName: [CHAR; LINE_LEN],
    DriverDate: FILETIME,
    DriverVersion: DWORDLONG,
}}
pub type PSP_DRVINFO_DATA_V2_A = *mut SP_DRVINFO_DATA_V2_A;
STRUCT!{#[cfg_attr(target_arch = "x86", repr(packed))] struct SP_DRVINFO_DATA_V2_W {
    cbSize: DWORD,
    DriverType: DWORD,
    Reserved: ULONG_PTR,
    Description: [WCHAR; LINE_LEN],
    MfgName: [WCHAR; LINE_LEN],
    ProviderName: [WCHAR; LINE_LEN],
    DriverDate: FILETIME,
    DriverVersion: DWORDLONG,
}}
pub type PSP_DRVINFO_DATA_V2_W = *mut SP_DRVINFO_DATA_V2_W;
STRUCT!{#[cfg_attr(target_arch = "x86", repr(packed))] struct SP_DRVINFO_DATA_V1_A {
    cbSize: DWORD,
    DriverType: DWORD,
    Reserved: ULONG_PTR,
    Description: [CHAR; LINE_LEN],
    MfgName: [CHAR; LINE_LEN],
    ProviderName: [CHAR; LINE_LEN],
}}
pub type PSP_DRVINFO_DATA_V1_A = *mut SP_DRVINFO_DATA_V1_A;
STRUCT!{#[cfg_attr(target_arch = "x86", repr(packed))] struct SP_DRVINFO_DATA_V1_W {
    cbSize: DWORD,
    DriverType: DWORD,
    Reserved: ULONG_PTR,
    Description: [WCHAR; LINE_LEN],
    MfgName: [WCHAR; LINE_LEN],
    ProviderName: [WCHAR; LINE_LEN],
}}
pub type PSP_DRVINFO_DATA_V1_W = *mut SP_DRVINFO_DATA_V1_W;
pub type SP_DRVINFO_DATA_A = SP_DRVINFO_DATA_V2_A;
pub type PSP_DRVINFO_DATA_A = PSP_DRVINFO_DATA_V2_A;
pub type SP_DRVINFO_DATA_W = SP_DRVINFO_DATA_V2_W;
pub type PSP_DRVINFO_DATA_W = PSP_DRVINFO_DATA_V2_W;
STRUCT!{#[cfg_attr(target_arch = "x86", repr(packed))] struct SP_DRVINFO_DETAIL_DATA_A {
    cbSize: DWORD,
    InfDate: FILETIME,
    CompatIDsOffset: DWORD,
    CompatIDsLength: DWORD,
    Reserved: ULONG_PTR,
    SectionName: [CHAR; LINE_LEN],
    InfFileName: [CHAR; MAX_PATH],
    DrvDescription: [CHAR; LINE_LEN],
    HardwareID: [CHAR; ANYSIZE_ARRAY],
}}
pub type PSP_DRVINFO_DETAIL_DATA_A = *mut SP_DRVINFO_DETAIL_DATA_A;
STRUCT!{#[cfg_attr(target_arch = "x86", repr(packed))] struct SP_DRVINFO_DETAIL_DATA_W {
    cbSize: DWORD,
    InfDate: FILETIME,
    CompatIDsOffset: DWORD,
    CompatIDsLength: DWORD,
    Reserved: ULONG_PTR,
    SectionName: [WCHAR; LINE_LEN],
    InfFileName: [WCHAR; MAX_PATH],
    DrvDescription: [WCHAR; LINE_LEN],
    HardwareID: [WCHAR; ANYSIZE_ARRAY],
}}
pub type PSP_DRVINFO_DETAIL_DATA_W = *mut SP_DRVINFO_DETAIL_DATA_W;
STRUCT!{#[cfg_attr(target_arch = "x86", repr(packed))] struct SP_DRVINSTALL_PARAMS {
    cbSize: DWORD,
    Rank: DWORD,
    Flags: DWORD,
    PrivateData: DWORD_PTR,
    Reserved: DWORD,
}}
pub type PSP_DRVINSTALL_PARAMS = *mut SP_DRVINSTALL_PARAMS;
pub const DNF_DUPDESC: DWORD = 0x00000001;
pub const DNF_OLDDRIVER: DWORD = 0x00000002;
pub const DNF_EXCLUDEFROMLIST: DWORD = 0x00000004;
pub const DNF_NODRIVER: DWORD = 0x00000008;
pub const DNF_LEGACYINF: DWORD = 0x00000010;
pub const DNF_CLASS_DRIVER: DWORD = 0x00000020;
pub const DNF_COMPATIBLE_DRIVER: DWORD = 0x00000040;
pub const DNF_INET_DRIVER: DWORD = 0x00000080;
pub const DNF_UNUSED1: DWORD = 0x00000100;
pub const DNF_UNUSED2: DWORD = 0x00000200;
pub const DNF_OLD_INET_DRIVER: DWORD = 0x00000400;
pub const DNF_BAD_DRIVER: DWORD = 0x00000800;
pub const DNF_DUPPROVIDER: DWORD = 0x00001000;
pub const DNF_INF_IS_SIGNED: DWORD = 0x00002000;
pub const DNF_OEM_F6_INF: DWORD = 0x00004000;
pub const DNF_DUPDRIVERVER: DWORD = 0x00008000;
pub const DNF_BASIC_DRIVER: DWORD = 0x00010000;
pub const DNF_AUTHENTICODE_SIGNED: DWORD = 0x00020000;
pub const DNF_INSTALLEDDRIVER: DWORD = 0x00040000;
pub const DNF_ALWAYSEXCLUDEFROMLIST: DWORD = 0x00080000;
pub const DNF_INBOX_DRIVER: DWORD = 0x00100000;
pub const DNF_REQUESTADDITIONALSOFTWARE: DWORD = 0x00200000;
pub const DNF_UNUSED_22: DWORD = 0x00400000;
pub const DNF_UNUSED_23: DWORD = 0x00800000;
pub const DNF_UNUSED_24: DWORD = 0x01000000;
pub const DNF_UNUSED_25: DWORD = 0x02000000;
pub const DNF_UNUSED_26: DWORD = 0x04000000;
pub const DNF_UNUSED_27: DWORD = 0x08000000;
pub const DNF_UNUSED_28: DWORD = 0x10000000;
pub const DNF_UNUSED_29: DWORD = 0x20000000;
pub const DNF_UNUSED_30: DWORD = 0x40000000;
pub const DNF_UNUSED_31: DWORD = 0x80000000;
pub const DRIVER_HARDWAREID_RANK: DWORD = 0x00000FFF;
pub const DRIVER_HARDWAREID_MASK: DWORD = 0x80000FFF;
pub const DRIVER_UNTRUSTED_RANK: DWORD = 0x80000000;
pub const DRIVER_W9X_SUSPECT_RANK: DWORD = 0xC0000000;
FN!{stdcall PSP_DETSIG_CMPPROC(
    DeviceInfoSet: HDEVINFO,
    NewDeviceData: PSP_DEVINFO_DATA,
    ExistingDeviceData: PSP_DEVINFO_DATA,
    CompareContext: PVOID,
) -> DWORD}
STRUCT!{#[cfg_attr(target_arch = "x86", repr(packed))] struct COINSTALLER_CONTEXT_DATA {
    PostProcessing: BOOL,
    InstallResult: DWORD,
    PrivateData: PVOID,
}}
pub type PCOINSTALLER_CONTEXT_DATA = *mut COINSTALLER_CONTEXT_DATA;
STRUCT!{#[cfg_attr(target_arch = "x86", repr(packed))] struct SP_CLASSIMAGELIST_DATA {
    cbSize: DWORD,
    ImageList: HIMAGELIST,
    Reserved: ULONG_PTR,
}}
pub type PSP_CLASSIMAGELIST_DATA = *mut SP_CLASSIMAGELIST_DATA;
STRUCT!{#[cfg_attr(target_arch = "x86", repr(packed))] struct SP_PROPSHEETPAGE_REQUEST {
    cbSize: DWORD,
    PageRequested: DWORD,
    DeviceInfoSet: HDEVINFO,
    DeviceInfoData: PSP_DEVINFO_DATA,
}}
pub type PSP_PROPSHEETPAGE_REQUEST = *mut SP_PROPSHEETPAGE_REQUEST;
pub const SPPSR_SELECT_DEVICE_RESOURCES: DWORD = 1;
pub const SPPSR_ENUM_BASIC_DEVICE_PROPERTIES: DWORD = 2;
pub const SPPSR_ENUM_ADV_DEVICE_PROPERTIES: DWORD = 3;
STRUCT!{#[cfg_attr(target_arch = "x86", repr(packed))] struct SP_BACKUP_QUEUE_PARAMS_V2_A {
    cbSize: DWORD,
    FullInfPath: [CHAR; MAX_PATH],
    FilenameOffset: INT,
    ReinstallInstance: [CHAR; MAX_PATH],
}}
pub type PSP_BACKUP_QUEUE_PARAMS_V2_A = *mut SP_BACKUP_QUEUE_PARAMS_V2_A;
STRUCT!{#[cfg_attr(target_arch = "x86", repr(packed))] struct SP_BACKUP_QUEUE_PARAMS_V2_W {
    cbSize: DWORD,
    FullInfPath: [WCHAR; MAX_PATH],
    FilenameOffset: INT,
    ReinstallInstance: [WCHAR; MAX_PATH],
}}
pub type PSP_BACKUP_QUEUE_PARAMS_V2_W = *mut SP_BACKUP_QUEUE_PARAMS_V2_W;
STRUCT!{#[cfg_attr(target_arch = "x86", repr(packed))] struct SP_BACKUP_QUEUE_PARAMS_V1_A {
    cbSize: DWORD,
    FullInfPath: [CHAR; MAX_PATH],
    FilenameOffset: INT,
}}
pub type PSP_BACKUP_QUEUE_PARAMS_V1_A = *mut SP_BACKUP_QUEUE_PARAMS_V1_A;
STRUCT!{#[cfg_attr(target_arch = "x86", repr(packed))] struct SP_BACKUP_QUEUE_PARAMS_V1_W {
    cbSize: DWORD,
    FullInfPath: [WCHAR; MAX_PATH],
    FilenameOffset: INT,
}}
pub type PSP_BACKUP_QUEUE_PARAMS_V1_W = *mut SP_BACKUP_QUEUE_PARAMS_V1_W;
pub type SP_BACKUP_QUEUE_PARAMS_A = SP_BACKUP_QUEUE_PARAMS_V2_A;
pub type PSP_BACKUP_QUEUE_PARAMS_A = PSP_BACKUP_QUEUE_PARAMS_V2_A;
pub type SP_BACKUP_QUEUE_PARAMS_W = SP_BACKUP_QUEUE_PARAMS_V2_W;
pub type PSP_BACKUP_QUEUE_PARAMS_W = PSP_BACKUP_QUEUE_PARAMS_V2_W;
pub const ERROR_EXPECTED_SECTION_NAME: DWORD = APPLICATION_ERROR_MASK | ERROR_SEVERITY_ERROR | 0;
pub const ERROR_BAD_SECTION_NAME_LINE: DWORD = APPLICATION_ERROR_MASK | ERROR_SEVERITY_ERROR | 1;
pub const ERROR_SECTION_NAME_TOO_LONG: DWORD = APPLICATION_ERROR_MASK | ERROR_SEVERITY_ERROR | 2;
pub const ERROR_GENERAL_SYNTAX: DWORD = APPLICATION_ERROR_MASK | ERROR_SEVERITY_ERROR | 3;
pub const ERROR_WRONG_INF_STYLE: DWORD = APPLICATION_ERROR_MASK | ERROR_SEVERITY_ERROR | 0x100;
pub const ERROR_SECTION_NOT_FOUND: DWORD = APPLICATION_ERROR_MASK | ERROR_SEVERITY_ERROR | 0x101;
pub const ERROR_LINE_NOT_FOUND: DWORD = APPLICATION_ERROR_MASK | ERROR_SEVERITY_ERROR | 0x102;
pub const ERROR_NO_BACKUP: DWORD = APPLICATION_ERROR_MASK | ERROR_SEVERITY_ERROR | 0x103;
pub const ERROR_NO_ASSOCIATED_CLASS: DWORD = APPLICATION_ERROR_MASK | ERROR_SEVERITY_ERROR | 0x200;
pub const ERROR_CLASS_MISMATCH: DWORD = APPLICATION_ERROR_MASK | ERROR_SEVERITY_ERROR | 0x201;
pub const ERROR_DUPLICATE_FOUND: DWORD = APPLICATION_ERROR_MASK | ERROR_SEVERITY_ERROR | 0x202;
pub const ERROR_NO_DRIVER_SELECTED: DWORD = APPLICATION_ERROR_MASK | ERROR_SEVERITY_ERROR | 0x203;
pub const ERROR_KEY_DOES_NOT_EXIST: DWORD = APPLICATION_ERROR_MASK | ERROR_SEVERITY_ERROR | 0x204;
pub const ERROR_INVALID_DEVINST_NAME: DWORD = APPLICATION_ERROR_MASK | ERROR_SEVERITY_ERROR
    | 0x205;
pub const ERROR_INVALID_CLASS: DWORD = APPLICATION_ERROR_MASK | ERROR_SEVERITY_ERROR | 0x206;
pub const ERROR_DEVINST_ALREADY_EXISTS: DWORD = APPLICATION_ERROR_MASK | ERROR_SEVERITY_ERROR
    | 0x207;
pub const ERROR_DEVINFO_NOT_REGISTERED: DWORD = APPLICATION_ERROR_MASK | ERROR_SEVERITY_ERROR
    | 0x208;
pub const ERROR_INVALID_REG_PROPERTY: DWORD = APPLICATION_ERROR_MASK | ERROR_SEVERITY_ERROR
    | 0x209;
pub const ERROR_NO_INF: DWORD = APPLICATION_ERROR_MASK | ERROR_SEVERITY_ERROR | 0x20A;
pub const ERROR_NO_SUCH_DEVINST: DWORD = APPLICATION_ERROR_MASK | ERROR_SEVERITY_ERROR | 0x20B;
pub const ERROR_CANT_LOAD_CLASS_ICON: DWORD = APPLICATION_ERROR_MASK | ERROR_SEVERITY_ERROR
    | 0x20C;
pub const ERROR_INVALID_CLASS_INSTALLER: DWORD = APPLICATION_ERROR_MASK | ERROR_SEVERITY_ERROR
    | 0x20D;
pub const ERROR_DI_DO_DEFAULT: DWORD = APPLICATION_ERROR_MASK | ERROR_SEVERITY_ERROR | 0x20E;
pub const ERROR_DI_NOFILECOPY: DWORD = APPLICATION_ERROR_MASK | ERROR_SEVERITY_ERROR | 0x20F;
pub const ERROR_INVALID_HWPROFILE: DWORD = APPLICATION_ERROR_MASK | ERROR_SEVERITY_ERROR | 0x210;
pub const ERROR_NO_DEVICE_SELECTED: DWORD = APPLICATION_ERROR_MASK | ERROR_SEVERITY_ERROR | 0x211;
pub const ERROR_DEVINFO_LIST_LOCKED: DWORD = APPLICATION_ERROR_MASK | ERROR_SEVERITY_ERROR | 0x212;
pub const ERROR_DEVINFO_DATA_LOCKED: DWORD = APPLICATION_ERROR_MASK | ERROR_SEVERITY_ERROR | 0x213;
pub const ERROR_DI_BAD_PATH: DWORD = APPLICATION_ERROR_MASK | ERROR_SEVERITY_ERROR | 0x214;
pub const ERROR_NO_CLASSINSTALL_PARAMS: DWORD = APPLICATION_ERROR_MASK | ERROR_SEVERITY_ERROR
    | 0x215;
pub const ERROR_FILEQUEUE_LOCKED: DWORD = APPLICATION_ERROR_MASK | ERROR_SEVERITY_ERROR | 0x216;
pub const ERROR_BAD_SERVICE_INSTALLSECT: DWORD = APPLICATION_ERROR_MASK | ERROR_SEVERITY_ERROR
    | 0x217;
pub const ERROR_NO_CLASS_DRIVER_LIST: DWORD = APPLICATION_ERROR_MASK | ERROR_SEVERITY_ERROR
    | 0x218;
pub const ERROR_NO_ASSOCIATED_SERVICE: DWORD = APPLICATION_ERROR_MASK | ERROR_SEVERITY_ERROR
    | 0x219;
pub const ERROR_NO_DEFAULT_DEVICE_INTERFACE: DWORD = APPLICATION_ERROR_MASK | ERROR_SEVERITY_ERROR
    | 0x21A;
pub const ERROR_DEVICE_INTERFACE_ACTIVE: DWORD = APPLICATION_ERROR_MASK | ERROR_SEVERITY_ERROR
    | 0x21B;
pub const ERROR_DEVICE_INTERFACE_REMOVED: DWORD = APPLICATION_ERROR_MASK | ERROR_SEVERITY_ERROR
    | 0x21C;
pub const ERROR_BAD_INTERFACE_INSTALLSECT: DWORD = APPLICATION_ERROR_MASK | ERROR_SEVERITY_ERROR
    | 0x21D;
pub const ERROR_NO_SUCH_INTERFACE_CLASS: DWORD = APPLICATION_ERROR_MASK | ERROR_SEVERITY_ERROR
    | 0x21E;
pub const ERROR_INVALID_REFERENCE_STRING: DWORD = APPLICATION_ERROR_MASK | ERROR_SEVERITY_ERROR
    | 0x21F;
pub const ERROR_INVALID_MACHINENAME: DWORD = APPLICATION_ERROR_MASK | ERROR_SEVERITY_ERROR | 0x220;
pub const ERROR_REMOTE_COMM_FAILURE: DWORD = APPLICATION_ERROR_MASK | ERROR_SEVERITY_ERROR | 0x221;
pub const ERROR_MACHINE_UNAVAILABLE: DWORD = APPLICATION_ERROR_MASK | ERROR_SEVERITY_ERROR | 0x222;
pub const ERROR_NO_CONFIGMGR_SERVICES: DWORD = APPLICATION_ERROR_MASK | ERROR_SEVERITY_ERROR
    | 0x223;
pub const ERROR_INVALID_PROPPAGE_PROVIDER: DWORD = APPLICATION_ERROR_MASK | ERROR_SEVERITY_ERROR
    | 0x224;
pub const ERROR_NO_SUCH_DEVICE_INTERFACE: DWORD = APPLICATION_ERROR_MASK | ERROR_SEVERITY_ERROR
    | 0x225;
pub const ERROR_DI_POSTPROCESSING_REQUIRED: DWORD = APPLICATION_ERROR_MASK | ERROR_SEVERITY_ERROR
    | 0x226;
pub const ERROR_INVALID_COINSTALLER: DWORD = APPLICATION_ERROR_MASK | ERROR_SEVERITY_ERROR | 0x227;
pub const ERROR_NO_COMPAT_DRIVERS: DWORD = APPLICATION_ERROR_MASK | ERROR_SEVERITY_ERROR | 0x228;
pub const ERROR_NO_DEVICE_ICON: DWORD = APPLICATION_ERROR_MASK | ERROR_SEVERITY_ERROR | 0x229;
pub const ERROR_INVALID_INF_LOGCONFIG: DWORD = APPLICATION_ERROR_MASK | ERROR_SEVERITY_ERROR
    | 0x22A;
pub const ERROR_DI_DONT_INSTALL: DWORD = APPLICATION_ERROR_MASK | ERROR_SEVERITY_ERROR | 0x22B;
pub const ERROR_INVALID_FILTER_DRIVER: DWORD = APPLICATION_ERROR_MASK | ERROR_SEVERITY_ERROR
    | 0x22C;
pub const ERROR_NON_WINDOWS_NT_DRIVER: DWORD = APPLICATION_ERROR_MASK | ERROR_SEVERITY_ERROR
    | 0x22D;
pub const ERROR_NON_WINDOWS_DRIVER: DWORD = APPLICATION_ERROR_MASK | ERROR_SEVERITY_ERROR | 0x22E;
pub const ERROR_NO_CATALOG_FOR_OEM_INF: DWORD = APPLICATION_ERROR_MASK | ERROR_SEVERITY_ERROR
    | 0x22F;
pub const ERROR_DEVINSTALL_QUEUE_NONNATIVE: DWORD = APPLICATION_ERROR_MASK | ERROR_SEVERITY_ERROR
    | 0x230;
pub const ERROR_NOT_DISABLEABLE: DWORD = APPLICATION_ERROR_MASK | ERROR_SEVERITY_ERROR | 0x231;
pub const ERROR_CANT_REMOVE_DEVINST: DWORD = APPLICATION_ERROR_MASK | ERROR_SEVERITY_ERROR | 0x232;
pub const ERROR_INVALID_TARGET: DWORD = APPLICATION_ERROR_MASK | ERROR_SEVERITY_ERROR | 0x233;
pub const ERROR_DRIVER_NONNATIVE: DWORD = APPLICATION_ERROR_MASK | ERROR_SEVERITY_ERROR | 0x234;
pub const ERROR_IN_WOW64: DWORD = APPLICATION_ERROR_MASK | ERROR_SEVERITY_ERROR | 0x235;
pub const ERROR_SET_SYSTEM_RESTORE_POINT: DWORD = APPLICATION_ERROR_MASK | ERROR_SEVERITY_ERROR
    | 0x236;
pub const ERROR_SCE_DISABLED: DWORD = APPLICATION_ERROR_MASK | ERROR_SEVERITY_ERROR | 0x238;
pub const ERROR_UNKNOWN_EXCEPTION: DWORD = APPLICATION_ERROR_MASK | ERROR_SEVERITY_ERROR | 0x239;
pub const ERROR_PNP_REGISTRY_ERROR: DWORD = APPLICATION_ERROR_MASK | ERROR_SEVERITY_ERROR | 0x23A;
pub const ERROR_REMOTE_REQUEST_UNSUPPORTED: DWORD = APPLICATION_ERROR_MASK | ERROR_SEVERITY_ERROR
    | 0x23B;
pub const ERROR_NOT_AN_INSTALLED_OEM_INF: DWORD = APPLICATION_ERROR_MASK | ERROR_SEVERITY_ERROR
    | 0x23C;
pub const ERROR_INF_IN_USE_BY_DEVICES: DWORD = APPLICATION_ERROR_MASK | ERROR_SEVERITY_ERROR
    | 0x23D;
pub const ERROR_DI_FUNCTION_OBSOLETE: DWORD = APPLICATION_ERROR_MASK | ERROR_SEVERITY_ERROR
    | 0x23E;
pub const ERROR_NO_AUTHENTICODE_CATALOG: DWORD = APPLICATION_ERROR_MASK | ERROR_SEVERITY_ERROR
    | 0x23F;
pub const ERROR_AUTHENTICODE_DISALLOWED: DWORD = APPLICATION_ERROR_MASK | ERROR_SEVERITY_ERROR
    | 0x240;
pub const ERROR_AUTHENTICODE_TRUSTED_PUBLISHER: DWORD = APPLICATION_ERROR_MASK
    | ERROR_SEVERITY_ERROR | 0x241;
pub const ERROR_AUTHENTICODE_TRUST_NOT_ESTABLISHED: DWORD = APPLICATION_ERROR_MASK
    | ERROR_SEVERITY_ERROR | 0x242;
pub const ERROR_AUTHENTICODE_PUBLISHER_NOT_TRUSTED: DWORD = APPLICATION_ERROR_MASK
    | ERROR_SEVERITY_ERROR | 0x243;
pub const ERROR_SIGNATURE_OSATTRIBUTE_MISMATCH: DWORD = APPLICATION_ERROR_MASK
    | ERROR_SEVERITY_ERROR | 0x244;
pub const ERROR_ONLY_VALIDATE_VIA_AUTHENTICODE: DWORD = APPLICATION_ERROR_MASK
    | ERROR_SEVERITY_ERROR | 0x245;
pub const ERROR_DEVICE_INSTALLER_NOT_READY: DWORD = APPLICATION_ERROR_MASK | ERROR_SEVERITY_ERROR
    | 0x246;
pub const ERROR_DRIVER_STORE_ADD_FAILED: DWORD = APPLICATION_ERROR_MASK | ERROR_SEVERITY_ERROR
    | 0x247;
pub const ERROR_DEVICE_INSTALL_BLOCKED: DWORD = APPLICATION_ERROR_MASK | ERROR_SEVERITY_ERROR
    | 0x248;
pub const ERROR_DRIVER_INSTALL_BLOCKED: DWORD = APPLICATION_ERROR_MASK | ERROR_SEVERITY_ERROR
    | 0x249;
pub const ERROR_WRONG_INF_TYPE: DWORD = APPLICATION_ERROR_MASK | ERROR_SEVERITY_ERROR | 0x24A;
pub const ERROR_FILE_HASH_NOT_IN_CATALOG: DWORD = APPLICATION_ERROR_MASK | ERROR_SEVERITY_ERROR
    | 0x24B;
pub const ERROR_DRIVER_STORE_DELETE_FAILED: DWORD = APPLICATION_ERROR_MASK | ERROR_SEVERITY_ERROR
    | 0x24C;
pub const ERROR_UNRECOVERABLE_STACK_OVERFLOW: DWORD = APPLICATION_ERROR_MASK | ERROR_SEVERITY_ERROR
    | 0x300;
pub const EXCEPTION_SPAPI_UNRECOVERABLE_STACK_OVERFLOW: DWORD = ERROR_UNRECOVERABLE_STACK_OVERFLOW;
pub const ERROR_NO_DEFAULT_INTERFACE_DEVICE: DWORD = ERROR_NO_DEFAULT_DEVICE_INTERFACE;
pub const ERROR_INTERFACE_DEVICE_ACTIVE: DWORD = ERROR_DEVICE_INTERFACE_ACTIVE;
pub const ERROR_INTERFACE_DEVICE_REMOVED: DWORD = ERROR_DEVICE_INTERFACE_REMOVED;
pub const ERROR_NO_SUCH_INTERFACE_DEVICE: DWORD = ERROR_NO_SUCH_DEVICE_INTERFACE;
pub const ERROR_NOT_INSTALLED: DWORD = APPLICATION_ERROR_MASK | ERROR_SEVERITY_ERROR
    | 0x1000;
extern "system" {
    pub fn SetupGetInfInformationA(
        InfSpec: LPCVOID,
        SearchControl: DWORD,
        ReturnBuffer: PSP_INF_INFORMATION,
        ReturnBufferSize: DWORD,
        RequiredSize: PDWORD,
    ) -> BOOL;
    pub fn SetupGetInfInformationW(
        InfSpec: LPCVOID,
        SearchControl: DWORD,
        ReturnBuffer: PSP_INF_INFORMATION,
        ReturnBufferSize: DWORD,
        RequiredSize: PDWORD,
    ) -> BOOL;
}
pub const INFINFO_INF_SPEC_IS_HINF: DWORD = 1;
pub const INFINFO_INF_NAME_IS_ABSOLUTE: DWORD = 2;
pub const INFINFO_DEFAULT_SEARCH: DWORD = 3;
pub const INFINFO_REVERSE_DEFAULT_SEARCH: DWORD = 4;
pub const INFINFO_INF_PATH_LIST_SEARCH: DWORD = 5;
extern "system" {
    pub fn SetupQueryInfFileInformationA(
        InfInformation: PSP_INF_INFORMATION,
        InfIndex: UINT,
        ReturnBuffer: PSTR,
        ReturnBufferSize: DWORD,
        RequiredSize: PDWORD,
    ) -> BOOL;
    pub fn SetupQueryInfFileInformationW(
        InfInformation: PSP_INF_INFORMATION,
        InfIndex: UINT,
        ReturnBuffer: PWSTR,
        ReturnBufferSize: DWORD,
        RequiredSize: PDWORD,
    ) -> BOOL;
    pub fn SetupQueryInfOriginalFileInformationA(
        InfInformation: PSP_INF_INFORMATION,
        InfIndex: UINT,
        AlternatePlatformInfo: PSP_ALTPLATFORM_INFO,
        OriginalFileInfo: PSP_ORIGINAL_FILE_INFO_A,
    ) -> BOOL;
    pub fn SetupQueryInfOriginalFileInformationW(
        InfInformation: PSP_INF_INFORMATION,
        InfIndex: UINT,
        AlternatePlatformInfo: PSP_ALTPLATFORM_INFO,
        OriginalFileInfo: PSP_ORIGINAL_FILE_INFO_W,
    ) -> BOOL;
    pub fn SetupQueryInfVersionInformationA(
        InfInformation: PSP_INF_INFORMATION,
        InfIndex: UINT,
        Key: PCSTR,
        ReturnBuffer: PSTR,
        ReturnBufferSize: DWORD,
        RequiredSize: PDWORD,
    ) -> BOOL;
    pub fn SetupQueryInfVersionInformationW(
        InfInformation: PSP_INF_INFORMATION,
        InfIndex: UINT,
        Key: PCWSTR,
        ReturnBuffer: PWSTR,
        ReturnBufferSize: DWORD,
        RequiredSize: PDWORD,
    ) -> BOOL;
    pub fn SetupGetInfDriverStoreLocationA(
        FileName: PCSTR,
        AlternatePlatformInfo: PSP_ALTPLATFORM_INFO,
        LocaleName: PCSTR,
        ReturnBuffer: PSTR,
        ReturnBufferSize: DWORD,
        RequiredSize: PDWORD,
    ) -> BOOL;
    pub fn SetupGetInfDriverStoreLocationW(
        FileName: PCWSTR,
        AlternatePlatformInfo: PSP_ALTPLATFORM_INFO,
        LocaleName: PCWSTR,
        ReturnBuffer: PWSTR,
        ReturnBufferSize: DWORD,
        RequiredSize: PDWORD,
    ) -> BOOL;
    pub fn SetupGetInfPublishedNameA(
        DriverStoreLocation: PCSTR,
        ReturnBuffer: PSTR,
        ReturnBufferSize: DWORD,
        RequiredSize: PDWORD,
    ) -> BOOL;
    pub fn SetupGetInfPublishedNameW(
        DriverStoreLocation: PCWSTR,
        ReturnBuffer: PWSTR,
        ReturnBufferSize: DWORD,
        RequiredSize: PDWORD,
    ) -> BOOL;
    pub fn SetupGetInfFileListA(
        DirectoryPath: PCSTR,
        InfStyle: DWORD,
        ReturnBuffer: PSTR,
        ReturnBufferSize: DWORD,
        RequiredSize: PDWORD,
    ) -> BOOL;
    pub fn SetupGetInfFileListW(
        DirectoryPath: PCWSTR,
        InfStyle: DWORD,
        ReturnBuffer: PWSTR,
        ReturnBufferSize: DWORD,
        RequiredSize: PDWORD,
    ) -> BOOL;
    pub fn SetupOpenInfFileW(
        FileName: PCWSTR,
        InfClass: PCWSTR,
        InfStyle: DWORD,
        ErrorLine: PUINT,
    ) -> HINF;
    pub fn SetupOpenInfFileA(
        FileName: PCSTR,
        InfClass: PCSTR,
        InfStyle: DWORD,
        ErrorLine: PUINT,
    ) -> HINF;
    pub fn SetupOpenMasterInf() -> HINF;
    pub fn SetupOpenAppendInfFileW(
        FileName: PCWSTR,
        InfHandle: HINF,
        ErrorLine: PUINT,
    ) -> BOOL;
    pub fn SetupOpenAppendInfFileA(
        FileName: PCSTR,
        InfHandle: HINF,
        ErrorLine: PUINT,
    ) -> BOOL;
    pub fn SetupCloseInfFile(
        InfHandle: HINF,
    ) -> ();
    pub fn SetupFindFirstLineA(
        InfHandle: HINF,
        Section: PCSTR,
        Key: PCSTR,
        Context: PINFCONTEXT,
    ) -> BOOL;
    pub fn SetupFindFirstLineW(
        InfHandle: HINF,
        Section: PCWSTR,
        Key: PCWSTR,
        Context: PINFCONTEXT,
    ) -> BOOL;
    pub fn SetupFindNextLine(
        ContextIn: PINFCONTEXT,
        ContextOut: PINFCONTEXT,
    ) -> BOOL;
    pub fn SetupFindNextMatchLineA(
        ContextIn: PINFCONTEXT,
        Key: PCSTR,
        ContextOut: PINFCONTEXT,
    ) -> BOOL;
    pub fn SetupFindNextMatchLineW(
        ContextIn: PINFCONTEXT,
        Key: PCWSTR,
        ContextOut: PINFCONTEXT,
    ) -> BOOL;
    pub fn SetupGetLineByIndexA(
        InfHandle: HINF,
        Section: PCSTR,
        Index: DWORD,
        Context: PINFCONTEXT,
    ) -> BOOL;
    pub fn SetupGetLineByIndexW(
        InfHandle: HINF,
        Section: PCWSTR,
        Index: DWORD,
        Context: PINFCONTEXT,
    ) -> BOOL;
    pub fn SetupGetLineCountA(
        InfHandle: HINF,
        Section: PCSTR,
    ) -> LONG;
    pub fn SetupGetLineCountW(
        InfHandle: HINF,
        Section: PCWSTR,
    ) -> LONG;
    pub fn SetupGetLineTextA(
        Context: PINFCONTEXT,
        InfHandle: HINF,
        Section: PCSTR,
        Key: PCSTR,
        ReturnBuffer: PSTR,
        ReturnBufferSize: DWORD,
        ReturnBufferSize: PDWORD,
    ) -> BOOL;
    pub fn SetupGetLineTextW(
        Context: PINFCONTEXT,
        InfHandle: HINF,
        Section: PCWSTR,
        Key: PCWSTR,
        ReturnBuffer: PWSTR,
        ReturnBufferSize: DWORD,
        ReturnBufferSize: PDWORD,
    ) -> BOOL;
    pub fn SetupGetFieldCount(
        Context: PINFCONTEXT,
    ) -> DWORD;
    pub fn SetupGetStringFieldA(
        Context: PINFCONTEXT,
        FieldIndex: DWORD,
        ReturnBuffer: PSTR,
        ReturnBufferSize: DWORD,
        RequiredSize: PDWORD,
    ) -> BOOL;
    pub fn SetupGetStringFieldW(
        Context: PINFCONTEXT,
        FieldIndex: DWORD,
        ReturnBuffer: PWSTR,
        ReturnBufferSize: DWORD,
        RequiredSize: PDWORD,
    ) -> BOOL;
    pub fn SetupGetIntField(
        Context: PINFCONTEXT,
        FieldIndex: DWORD,
        IntegerValue: PINT,
    ) -> BOOL;
    pub fn SetupGetMultiSzFieldA(
        Context: PINFCONTEXT,
        FieldIndex: DWORD,
        ReturnBuffer: PSTR,
        ReturnBufferSize: DWORD,
        RequiredSize: LPDWORD,
    ) -> BOOL;
    pub fn SetupGetMultiSzFieldW(
        Context: PINFCONTEXT,
        FieldIndex: DWORD,
        ReturnBuffer: PWSTR,
        ReturnBufferSize: DWORD,
        RequiredSize: LPDWORD,
    ) -> BOOL;
    pub fn SetupGetBinaryField(
        Context: PINFCONTEXT,
        FieldIndex: DWORD,
        ReturnBuffer: PBYTE,
        ReturnBufferSize: DWORD,
        RequiredSize: LPDWORD,
    ) -> BOOL;
    pub fn SetupGetFileCompressionInfoA(
        SourceFileName: PCSTR,
        ActualSourceFileName: *mut PSTR,
        SourceFileSize: PDWORD,
        TargetFileSize: PDWORD,
        CompressionType: PUINT,
    ) -> DWORD;
    pub fn SetupGetFileCompressionInfoW(
        SourceFileName: PCWSTR,
        ActualSourceFileName: *mut PWSTR,
        SourceFileSize: PDWORD,
        TargetFileSize: PDWORD,
        CompressionType: PUINT,
    ) -> DWORD;
    pub fn SetupGetFileCompressionInfoExA(
        SourceFileName: PCSTR,
        ActualSourceFileNameBuffer: PSTR,
        ActualSourceFileNameBufferLen: DWORD,
        RequiredBufferLen: PDWORD,
        SourceFileSize: PDWORD,
        TargetFileSize: PDWORD,
        CompressionType: PUINT,
    ) -> BOOL;
    pub fn SetupGetFileCompressionInfoExW(
        SourceFileName: PCWSTR,
        ActualSourceFileNameBuffer: PWSTR,
        ActualSourceFileNameBufferLen: DWORD,
        RequiredBufferLen: PDWORD,
        SourceFileSize: PDWORD,
        TargetFileSize: PDWORD,
        CompressionType: PUINT,
    ) -> BOOL;
}
pub const FILE_COMPRESSION_NONE: UINT = 0;
pub const FILE_COMPRESSION_WINLZA: UINT = 1;
pub const FILE_COMPRESSION_MSZIP: UINT = 2;
pub const FILE_COMPRESSION_NTCAB: UINT = 3;
extern "system" {
    pub fn SetupDecompressOrCopyFileA(
        SourceFileName: PCSTR,
        TargetFileName: PCSTR,
        CompressionType: PUINT,
    ) -> DWORD;
    pub fn SetupDecompressOrCopyFileW(
        SourceFileName: PCWSTR,
        TargetFileName: PCWSTR,
        CompressionType: PUINT,
    ) -> DWORD;
    pub fn SetupGetSourceFileLocationA(
        InfHandle: HINF,
        InfContext: PINFCONTEXT,
        FileName: PCSTR,
        SourceId: PUINT,
        ReturnBuffer: PSTR,
        ReturnBufferSize: DWORD,
        RequiredSize: PDWORD,
    ) -> BOOL;
    pub fn SetupGetSourceFileLocationW(
        InfHandle: HINF,
        InfContext: PINFCONTEXT,
        FileName: PCWSTR,
        SourceId: PUINT,
        ReturnBuffer: PWSTR,
        ReturnBufferSize: DWORD,
        RequiredSize: PDWORD,
    ) -> BOOL;
    pub fn SetupGetSourceFileSizeA(
        InfHandle: HINF,
        InfContext: PINFCONTEXT,
        FileName: PCSTR,
        Section: PCSTR,
        FileSize: PDWORD,
        RoundingFactor: UINT,
    ) -> BOOL;
    pub fn SetupGetSourceFileSizeW(
        InfHandle: HINF,
        InfContext: PINFCONTEXT,
        FileName: PCWSTR,
        Section: PCWSTR,
        FileSize: PDWORD,
        RoundingFactor: UINT,
    ) -> BOOL;
    pub fn SetupGetTargetPathA(
        InfHandle: HINF,
        InfContext: PINFCONTEXT,
        Section: PCSTR,
        ReturnBuffer: PSTR,
        ReturnBufferSize: DWORD,
        RequiredSize: PDWORD,
    ) -> BOOL;
    pub fn SetupGetTargetPathW(
        InfHandle: HINF,
        InfContext: PINFCONTEXT,
        Section: PCWSTR,
        ReturnBuffer: PWSTR,
        ReturnBufferSize: DWORD,
        RequiredSize: PDWORD,
    ) -> BOOL;
}
pub const SRCLIST_TEMPORARY: DWORD = 0x00000001;
pub const SRCLIST_NOBROWSE: DWORD = 0x00000002;
pub const SRCLIST_SYSTEM: DWORD = 0x00000010;
pub const SRCLIST_USER: DWORD = 0x00000020;
pub const SRCLIST_SYSIFADMIN: DWORD = 0x00000040;
pub const SRCLIST_SUBDIRS: DWORD = 0x00000100;
pub const SRCLIST_APPEND: DWORD = 0x00000200;
pub const SRCLIST_NOSTRIPPLATFORM: DWORD = 0x00000400;
extern "system" {
    pub fn SetupSetSourceListA(
        Flags: DWORD,
        SourceList: *mut PCSTR,
        SourceCount: UINT,
    ) -> BOOL;
    pub fn SetupSetSourceListW(
        Flags: DWORD,
        SourceList: *mut PCWSTR,
        SourceCount: UINT,
    ) -> BOOL;
    pub fn SetupCancelTemporarySourceList() -> BOOL;
    pub fn SetupAddToSourceListA(
        Flags: DWORD,
        Source: PCSTR,
    ) -> BOOL;
    pub fn SetupAddToSourceListW(
        Flags: DWORD,
        Source: PCWSTR,
    ) -> BOOL;
    pub fn SetupRemoveFromSourceListA(
        Flags: DWORD,
        Source: PCSTR,
    ) -> BOOL;
    pub fn SetupRemoveFromSourceListW(
        Flags: DWORD,
        Source: PCWSTR,
    ) -> BOOL;
    pub fn SetupQuerySourceListA(
        Flags: DWORD,
        List: *mut *mut PCSTR,
        Count: PUINT,
    ) -> BOOL;
    pub fn SetupQuerySourceListW(
        Flags: DWORD,
        List: *mut *mut PCWSTR,
        Count: PUINT,
    ) -> BOOL;
    pub fn SetupFreeSourceListA(
        List: *mut *mut PCSTR,
        Count: UINT,
    ) -> BOOL;
    pub fn SetupFreeSourceListW(
        List: *mut *mut PCWSTR,
        Count: UINT,
    ) -> BOOL;
    pub fn SetupPromptForDiskA(
        hwndParent: HWND,
        DialogTitle: PCSTR,
        DiskName: PCSTR,
        PathToSource: PCSTR,
        FileSought: PCSTR,
        TagFile: PCSTR,
        DiskPromptStyle: DWORD,
        PathBuffer: PSTR,
        PathBufferSize: DWORD,
        PathRequiredSize: PDWORD,
    ) -> UINT;
    pub fn SetupPromptForDiskW(
        hwndParent: HWND,
        DialogTitle: PCWSTR,
        DiskName: PCWSTR,
        PathToSource: PCWSTR,
        FileSought: PCWSTR,
        TagFile: PCWSTR,
        DiskPromptStyle: DWORD,
        PathBuffer: PWSTR,
        PathBufferSize: DWORD,
        PathRequiredSize: PDWORD,
    ) -> UINT;
    pub fn SetupCopyErrorA(
        hwndParent: HWND,
        DialogTitle: PCSTR,
        DiskName: PCSTR,
        PathToSource: PCSTR,
        SourceFile: PCSTR,
        TargetPathFile: PCSTR,
        Win32ErrorCode: UINT,
        Style: DWORD,
        PathBuffer: PSTR,
        PathBufferSize: DWORD,
        PathRequiredSize: PDWORD,
    ) -> UINT;
    pub fn SetupCopyErrorW(
        hwndParent: HWND,
        DialogTitle: PCWSTR,
        DiskName: PCWSTR,
        PathToSource: PCWSTR,
        SourceFile: PCWSTR,
        TargetPathFile: PCWSTR,
        Win32ErrorCode: UINT,
        Style: DWORD,
        PathBuffer: PWSTR,
        PathBufferSize: DWORD,
        PathRequiredSize: PDWORD,
    ) -> UINT;
    pub fn SetupRenameErrorA(
        hwndParent: HWND,
        DialogTitle: PCSTR,
        SourceFile: PCSTR,
        TargetFile: PCSTR,
        Win32ErrorCode: UINT,
        Style: DWORD,
    ) -> UINT;
    pub fn SetupRenameErrorW(
        hwndParent: HWND,
        DialogTitle: PCWSTR,
        SourceFile: PCWSTR,
        TargetFile: PCWSTR,
        Win32ErrorCode: UINT,
        Style: DWORD,
    ) -> UINT;
    pub fn SetupDeleteErrorA(
        hwndParent: HWND,
        DialogTitle: PCSTR,
        File: PCSTR,
        Win32ErrorCode: UINT,
        Style: DWORD,
    ) -> UINT;
    pub fn SetupDeleteErrorW(
        hwndParent: HWND,
        DialogTitle: PCWSTR,
        File: PCWSTR,
        Win32ErrorCode: UINT,
        Style: DWORD,
    ) -> UINT;
    pub fn SetupBackupErrorA(
        hwndParent: HWND,
        DialogTitle: PCSTR,
        SourceFile: PCSTR,
        TargetFile: PCSTR,
        Win32ErrorCode: UINT,
        Style: DWORD,
    ) -> UINT;
    pub fn SetupBackupErrorW(
        hwndParent: HWND,
        DialogTitle: PCWSTR,
        SourceFile: PCWSTR,
        TargetFile: PCWSTR,
        Win32ErrorCode: UINT,
        Style: DWORD,
    ) -> UINT;
}
pub const IDF_NOBROWSE: DWORD = 0x00000001;
pub const IDF_NOSKIP: DWORD = 0x00000002;
pub const IDF_NODETAILS: DWORD = 0x00000004;
pub const IDF_NOCOMPRESSED: DWORD = 0x00000008;
pub const IDF_CHECKFIRST: DWORD = 0x00000100;
pub const IDF_NOBEEP: DWORD = 0x00000200;
pub const IDF_NOFOREGROUND: DWORD = 0x00000400;
pub const IDF_WARNIFSKIP: DWORD = 0x00000800;
pub const IDF_NOREMOVABLEMEDIAPROMPT: DWORD = 0x00001000;
pub const IDF_USEDISKNAMEASPROMPT: DWORD = 0x00002000;
pub const IDF_OEMDISK: DWORD = 0x80000000;
pub const DPROMPT_SUCCESS: UINT = 0;
pub const DPROMPT_CANCEL: UINT = 1;
pub const DPROMPT_SKIPFILE: UINT = 2;
pub const DPROMPT_BUFFERTOOSMALL: UINT = 3;
pub const DPROMPT_OUTOFMEMORY: UINT = 4;
extern "system" {
    pub fn SetupSetDirectoryIdA(
        InfHandle: HINF,
        Id: DWORD,
        Directory: PCSTR,
    ) -> BOOL;
    pub fn SetupSetDirectoryIdW(
        InfHandle: HINF,
        Id: DWORD,
        Directory: PCWSTR,
    ) -> BOOL;
    pub fn SetupSetDirectoryIdExA(
        InfHandle: HINF,
        Id: DWORD,
        Directory: PCSTR,
        Flags: DWORD,
        Reserved1: DWORD,
        Reserved2: PVOID,
    ) -> BOOL;
    pub fn SetupSetDirectoryIdExW(
        InfHandle: HINF,
        Id: DWORD,
        Directory: PCWSTR,
        Flags: DWORD,
        Reserved1: DWORD,
        Reserved2: PVOID,
    ) -> BOOL;
}
pub const SETDIRID_NOT_FULL_PATH: DWORD = 0x00000001;
extern "system" {
    pub fn SetupGetSourceInfoA(
        InfHandle: HINF,
        SourceId: UINT,
        InfoDesired: UINT,
        ReturnBuffer: PSTR,
        ReturnBufferSize: DWORD,
        RequiredSize: PDWORD,
    ) -> BOOL;
    pub fn SetupGetSourceInfoW(
        InfHandle: HINF,
        SourceId: UINT,
        InfoDesired: UINT,
        ReturnBuffer: PWSTR,
        ReturnBufferSize: DWORD,
        RequiredSize: PDWORD,
    ) -> BOOL;
}
pub const SRCINFO_PATH: UINT = 1;
pub const SRCINFO_TAGFILE: UINT = 2;
pub const SRCINFO_DESCRIPTION: UINT = 3;
pub const SRCINFO_FLAGS: UINT = 4;
pub const SRCINFO_TAGFILE2: UINT = 4;
pub const SRC_FLAGS_CABFILE: UINT = 0x0010;
extern "system" {
    pub fn SetupInstallFileA(
        InfHandle: HINF,
        InfContext: PINFCONTEXT,
        SourceFile: PCSTR,
        SourcePathRoot: PCSTR,
        DestinationName: PCSTR,
        CopyStyle: DWORD,
        CopyMsgHandler: PSP_FILE_CALLBACK_A,
        Context: PVOID,
    ) -> BOOL;
    pub fn SetupInstallFileW(
        InfHandle: HINF,
        InfContext: PINFCONTEXT,
        SourceFile: PCWSTR,
        SourcePathRoot: PCWSTR,
        DestinationName: PCWSTR,
        CopyStyle: DWORD,
        CopyMsgHandler: PSP_FILE_CALLBACK_W,
        Context: PVOID,
    ) -> BOOL;
    pub fn SetupInstallFileExA(
        InfHandle: HINF,
        InfContext: PINFCONTEXT,
        SourceFile: PCSTR,
        SourcePathRoot: PCSTR,
        DestinationName: PCSTR,
        CopyStyle: DWORD,
        CopyMsgHandler: PSP_FILE_CALLBACK_A,
        Context: PVOID,
        FileWasInUse: PBOOL,
    ) -> BOOL;
    pub fn SetupInstallFileExW(
        InfHandle: HINF,
        InfContext: PINFCONTEXT,
        SourceFile: PCWSTR,
        SourcePathRoot: PCWSTR,
        DestinationName: PCWSTR,
        CopyStyle: DWORD,
        CopyMsgHandler: PSP_FILE_CALLBACK_W,
        Context: PVOID,
        FileWasInUse: PBOOL,
    ) -> BOOL;
}
pub const SP_COPY_DELETESOURCE: DWORD = 0x0000001;
pub const SP_COPY_REPLACEONLY: DWORD = 0x0000002;
pub const SP_COPY_NEWER: DWORD = 0x0000004;
pub const SP_COPY_NEWER_OR_SAME: DWORD = SP_COPY_NEWER;
pub const SP_COPY_NOOVERWRITE: DWORD = 0x0000008;
pub const SP_COPY_NODECOMP: DWORD = 0x0000010;
pub const SP_COPY_LANGUAGEAWARE: DWORD = 0x0000020;
pub const SP_COPY_SOURCE_ABSOLUTE: DWORD = 0x0000040;
pub const SP_COPY_SOURCEPATH_ABSOLUTE: DWORD = 0x0000080;
pub const SP_COPY_IN_USE_NEEDS_REBOOT: DWORD = 0x0000100;
pub const SP_COPY_FORCE_IN_USE: DWORD = 0x0000200;
pub const SP_COPY_NOSKIP: DWORD = 0x0000400;
pub const SP_FLAG_CABINETCONTINUATION: DWORD = 0x0000800;
pub const SP_COPY_FORCE_NOOVERWRITE: DWORD = 0x0001000;
pub const SP_COPY_FORCE_NEWER: DWORD = 0x0002000;
pub const SP_COPY_WARNIFSKIP: DWORD = 0x0004000;
pub const SP_COPY_NOBROWSE: DWORD = 0x0008000;
pub const SP_COPY_NEWER_ONLY: DWORD = 0x0010000;
pub const SP_COPY_RESERVED: DWORD = 0x0020000;
pub const SP_COPY_OEMINF_CATALOG_ONLY: DWORD = 0x0040000;
pub const SP_COPY_REPLACE_BOOT_FILE: DWORD = 0x0080000;
pub const SP_COPY_NOPRUNE: DWORD = 0x0100000;
pub const SP_COPY_OEM_F6_INF: DWORD = 0x0200000;
pub const SP_COPY_ALREADYDECOMP: DWORD = 0x0400000;
pub const SP_COPY_WINDOWS_SIGNED: DWORD = 0x1000000;
pub const SP_COPY_PNPLOCKED: DWORD = 0x2000000;
pub const SP_COPY_IN_USE_TRY_RENAME: DWORD = 0x4000000;
pub const SP_COPY_INBOX_INF: DWORD = 0x8000000;
pub const SP_COPY_HARDLINK: DWORD = 0x10000000;
pub const SP_BACKUP_BACKUPPASS: DWORD = 0x00000001;
pub const SP_BACKUP_DEMANDPASS: DWORD = 0x00000002;
pub const SP_BACKUP_SPECIAL: DWORD = 0x00000004;
pub const SP_BACKUP_BOOTFILE: DWORD = 0x00000008;
extern "system" {
    pub fn SetupOpenFileQueue() -> HSPFILEQ;
    pub fn SetupCloseFileQueue(
        QueueHandle: HSPFILEQ,
    ) -> BOOL;
    pub fn SetupSetFileQueueAlternatePlatformA(
        QueueHandle: HSPFILEQ,
        AlternatePlatformInfo: PSP_ALTPLATFORM_INFO,
        AlternateDefaultCatalogFile: PCSTR,
    ) -> BOOL;
    pub fn SetupSetFileQueueAlternatePlatformW(
        QueueHandle: HSPFILEQ,
        AlternatePlatformInfo: PSP_ALTPLATFORM_INFO,
        AlternateDefaultCatalogFile: PCWSTR,
    ) -> BOOL;
    pub fn SetupSetPlatformPathOverrideA(
        Override: PCSTR,
    ) -> BOOL;
    pub fn SetupSetPlatformPathOverrideW(
        Override: PCWSTR,
    ) -> BOOL;
    pub fn SetupQueueCopyA(
        QueueHandle: HSPFILEQ,
        SourceRootPath: PCSTR,
        SourcePath: PCSTR,
        SourceFilename: PCSTR,
        SourceDescription: PCSTR,
        SourceTagfile: PCSTR,
        TargetDirectory: PCSTR,
        TargetFilename: PCSTR,
        CopyStyle: DWORD,
    ) -> BOOL;
    pub fn SetupQueueCopyW(
--> --------------------

--> maximum size reached

--> --------------------