{******************************************************************}
{                                                                  }
{       Borland Delphi Runtime Library                             }
{       Setup and Device Installer API interface unit              }
{                                                                  }
{ Portions created by Microsoft are                                }
{ Copyright (C) 1995-1999 Microsoft Corporation.                   }
{ All Rights Reserved.                                             }
{                                                                  }
{ The original file is: setupapi.h, released March 1999.           }
{ The original Pascal code is: SetupApi.pas, released 29 Jan 2000. }
{ The initial developer of the Pascal code is Robert Marquardt     }
{ (robert_marquardt att gmx dott de)                               }
{                                                                  }
{ Portions created by Robert Marquardt are                         }
{ Copyright (C) 1999 Robert Marquardt.                             }
{                                                                  }
{ Contributor(s): Marcel van Brakel (brakelm att bart dott nl)     }
{                                                                  }
{ Obtained through:                                                }
{ Joint Endeavour of Delphi Innovators (Project JEDI)              }
{                                                                  }
{ You may retrieve the latest version of this file at the Project  }
{ JEDI home page, located at http://delphi-jedi.org                }
{                                                                  }
{ The contents of this file are used with permission, subject to   }
{ the Mozilla Public License Version 1.1 (the "License"); you may  }
{ not use this file except in compliance with the License. You may }
{ obtain a copy of the License at                                  }
{ http://www.mozilla.org/MPL/MPL-1.1.html                          }
{                                                                  }
{ Software distributed under the License is distributed on an      }
{ "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or   }
{ implied. See the License for the specific language governing     }
{ rights and limitations under the License.                        }
{                                                                  }
{******************************************************************}

{* ----------------------------------------------------------------
                     NOTES ON INTEGRATION
                     
 This file is specific to the JVCL and works well with the current
 version of the library.
 Note however that is not complete and might well be out of date
 with respect to the official windows API.
 If you want a more up to date version, you should look for 
 SetupApi.pas inside the JEDI WinAPI project at this address:
 
 http://blog.delphi-jedi.net/jedi-api-headers/                    
---------------------------------------------------------------- *}

unit JvSetupApi;

{$I jvcl.inc}
{$I windowsversion.inc}

interface

{$WEAKPACKAGEUNIT ON}

// (rom) this is the switch to change between static and dynamic linking.
// (rom) it is enabled by default here.
// (rom) To disable simply change the '$' to a '.'.
{$DEFINE SETUPAPI_LINKONREQUEST}

(*$HPPEMIT '#include "setupapi.h"'*)

uses
  Windows, CommCtrl,
  {$IFDEF SETUPAPI_LINKONREQUEST}
  ModuleLoader,
  {$ENDIF SETUPAPI_LINKONREQUEST}
  WinConvTypes;

const
  ANYSIZE_ARRAY = 1;
  {$EXTERNALSYM ANYSIZE_ARRAY}

//
// Define maximum string length constants as specified by
// Windows 95.
//
const
  LINE_LEN = 256;                 // Win95-compatible maximum for displayable
  {$EXTERNALSYM LINE_LEN}
                                  // strings coming from a device INF.
  MAX_INF_STRING_LENGTH = 4096;   // Actual maximum size of an INF string
  {$EXTERNALSYM MAX_INF_STRING_LENGTH}
                                  // (including string substitutions).
  MAX_TITLE_LEN         = 60;
  {$EXTERNALSYM MAX_TITLE_LEN}
  MAX_INSTRUCTION_LEN   = 256;
  {$EXTERNALSYM MAX_INSTRUCTION_LEN}
  MAX_LABEL_LEN         = 30;
  {$EXTERNALSYM MAX_LABEL_LEN}
  MAX_SERVICE_NAME_LEN  = 256;
  {$EXTERNALSYM MAX_SERVICE_NAME_LEN}
  MAX_SUBTITLE_LEN      = 256;
  {$EXTERNALSYM MAX_SUBTITLE_LEN}

//
// Define maximum length of a machine name in the format expected by ConfigMgr32
// CM_Connect_Machine (i.e., "\\\\MachineName\0").
//

  SP_MAX_MACHINENAME_LENGTH = MAX_PATH + 3;
  {$EXTERNALSYM SP_MAX_MACHINENAME_LENGTH}

//
// Define type for reference to loaded inf file
//

type
  HINF = Pointer;
  {$EXTERNALSYM HINF}

//
// Inf context structure. Applications must not interpret or
// overwrite values in these structures.
//
  PInfContext = ^TInfContext;
  INFCONTEXT = record
    Inf: HINF;
    CurrentInf: HINF;
    Section: UINT;
    Line: UINT;
  end;
  {$EXTERNALSYM INFCONTEXT}
  TInfContext = INFCONTEXT;

//
// Inf file information structure.
//
  PSPInfInformation = ^TSPInfInformation;
  SP_INF_INFORMATION = record
    InfStyle: DWORD;
    InfCount: DWORD;
    VersionData: array [0..ANYSIZE_ARRAY - 1] of Byte;
  end;
  {$EXTERNALSYM SP_INF_INFORMATION}
  TSPInfInformation = SP_INF_INFORMATION;

//
// Define structure for passing alternate platform info into
// SetupSetFileQueueAlternatePlatform and SetupQueryInfOriginalFileInformation.
//
  PSPAltPlatformInfoV2 = ^SP_ALTPLATFORM_INFO_V2;
  SP_ALTPLATFORM_INFO_V2 = record
    cbSize: DWORD;
    //
    // platform to use (VER_PLATFORM_WIN32_WINDOWS or VER_PLATFORM_WIN32_NT)
    //
    Platform: DWORD;
    //
    // major and minor version numbers to use
    //
    MajorVersion: DWORD;
    MinorVersion: DWORD;
    //
    // processor architecture to use (PROCESSOR_ARCHITECTURE_INTEL,
    // PROCESSOR_ARCHITECTURE_ALPHA, PROCESSOR_ARCHITECTURE_IA64, or
    // PROCESSOR_ARCHITECTURE_ALPHA64)
    //
    ProcessorArchitecture: WORD;

    Flags: WORD;
    (*
    union {
        WORD  Reserved; // for compatibility with V1 structure
        WORD  Flags;    // indicates validity of non V1 fields
    };
    *)

    //
    // specify SP_ALTPLATFORM_FLAGS_VERSION_RANGE in Flags
    // to use FirstValidatedMajorVersion and FirstValidatedMinorVersion
    //
    // Major and minor versions of the oldest previous OS for which this
    // package's digital signature may be considered valid.  For example, say
    // the alternate platform is VER_PLATFORM_WIN32_NT, version 5.1.  However,
    // it is wished that driver packages signed with a 5.0 osattr also be
    // considered valid.  In this case, you'd have a  MajorVersion/MinorVersion
    // of 5.1, and a FirstValidatedMajorVersion/FirstValidatedMinorVersion of
    // 5.0.  To validate packages signed for any previous OS release, specify
    // 0 for these fields.  To only validate against the target alternate
    // platform, specify the same values as those in the MajorVersion and
    // MinorVersion fields.
    //
    FirstValidatedMajorVersion: DWORD;
    FirstValidatedMinorVersion: DWORD;
  end;
  {$EXTERNALSYM SP_ALTPLATFORM_INFO_V2}
  TSPAltPlatformInfoV2 = SP_ALTPLATFORM_INFO_V2;

  PSPAltPlatformInfoV1 = ^TSPAltPlatformInfoV1;
  SP_ALTPLATFORM_INFO_V1 = record
    cbSize: DWORD;
    //
    // platform to use (VER_PLATFORM_WIN32_WINDOWS or VER_PLATFORM_WIN32_NT)
    //
    Platform: DWORD;
    //
    // major and minor version numbers to use
    //
    MajorVersion: DWORD;
    MinorVersion: DWORD;
    //
    // processor architecture to use (PROCESSOR_ARCHITECTURE_INTEL,
    // PROCESSOR_ARCHITECTURE_ALPHA, PROCESSOR_ARCHITECTURE_IA64, or
    // PROCESSOR_ARCHITECTURE_ALPHA64)
    //
    ProcessorArchitecture: Word;
    Reserved: Word; // must be zero.
  end;
  {$EXTERNALSYM SP_ALTPLATFORM_INFO_V1}
  TSPAltPlatformInfoV1 = SP_ALTPLATFORM_INFO_V1;

  {$IFDEF WINXP_UP}
  PSPAltPlatformInfo = PSPAltPlatformInfoV2;
  TSPAltPlatformInfo = TSPAltPlatformInfoV2;
  {$ELSE}
  PSPAltPlatformInfo = PSPAltPlatformInfoV1;
  TSPAltPlatformInfo = TSPAltPlatformInfoV1;
  {$ENDIF WINXP_UP}

//
// the following flags are available to SP_ALTPLATFORM_INFO_V2
//
const
  SP_ALTPLATFORM_FLAGS_VERSION_RANGE = $0001;  // FirstValidatedMajor/MinorVersion
  {$EXTERNALSYM SP_ALTPLATFORM_FLAGS_VERSION_RANGE}

//
// Define structure that is filled in by SetupQueryInfOriginalFileInformation
// to indicate the INF's original name and the original name of the (potentially
// platform-specific) catalog file specified by that INF.
//
type
  PSPOriginalFileInfoA = ^TSPOriginalFileInfoA;
  PSPOriginalFileInfoW = ^TSPOriginalFileInfoW;
  SP_ORIGINAL_FILE_INFO_A = record
    cbSize: DWORD;
    OriginalInfName: array [0..MAX_PATH - 1] of AnsiChar;
    OriginalCatalogName: array [0..MAX_PATH - 1] of AnsiChar;
  end;
  {$EXTERNALSYM SP_ORIGINAL_FILE_INFO_A}
  SP_ORIGINAL_FILE_INFO_W = record
    cbSize: DWORD;
    OriginalInfName: array [0..MAX_PATH - 1] of WideChar;
    OriginalCatalogName: array [0..MAX_PATH - 1] of WideChar;
  end;
  {$EXTERNALSYM SP_ORIGINAL_FILE_INFO_W}
  TSPOriginalFileInfoA = SP_ORIGINAL_FILE_INFO_A;
  TSPOriginalFileInfoW = SP_ORIGINAL_FILE_INFO_W;
  {$IFDEF UNICODE}
  PSPOriginalFileInfo = PSPOriginalFileInfoW;
  TSPOriginalFileInfo = TSPOriginalFileInfoW;
  {$ELSE}
  TSPOriginalFileInfo = TSPOriginalFileInfoA;
  PSPOriginalFileInfo = PSPOriginalFileInfoA;
  {$ENDIF UNICODE}

//
// SP_INF_INFORMATION.InfStyle values
//
const
  INF_STYLE_NONE  = $00000000; // unrecognized or non-existent
  {$EXTERNALSYM INF_STYLE_NONE}
  INF_STYLE_OLDNT = $00000001; // winnt 3.x
  {$EXTERNALSYM INF_STYLE_OLDNT}
  INF_STYLE_WIN4  = $00000002; // Win95
  {$EXTERNALSYM INF_STYLE_WIN4}

//
// Additional InfStyle flags that may be specified when calling SetupOpenInfFile.
//
//
  INF_STYLE_CACHE_ENABLE  = $00000010; // always cache INF, even outside of %windir%\Inf
  {$EXTERNALSYM INF_STYLE_CACHE_ENABLE}
  INF_STYLE_CACHE_DISABLE = $00000020; // delete cached INF information
  {$EXTERNALSYM INF_STYLE_CACHE_DISABLE}

//
// Target directory specs.
//
  DIRID_ABSOLUTE       = DWORD(-1); // real 32-bit -1
  {$EXTERNALSYM DIRID_ABSOLUTE}
  DIRID_ABSOLUTE_16BIT = $FFFF; // 16-bit -1 for compat w/setupx
  {$EXTERNALSYM DIRID_ABSOLUTE_16BIT}
  DIRID_NULL           = 0;
  {$EXTERNALSYM DIRID_NULL}
  DIRID_SRCPATH        = 1;
  {$EXTERNALSYM DIRID_SRCPATH}
  DIRID_WINDOWS        = 10;
  {$EXTERNALSYM DIRID_WINDOWS}
  DIRID_SYSTEM         = 11; // system32
  {$EXTERNALSYM DIRID_SYSTEM}
  DIRID_DRIVERS        = 12;
  {$EXTERNALSYM DIRID_DRIVERS}
  DIRID_IOSUBSYS       = DIRID_DRIVERS;
  {$EXTERNALSYM DIRID_IOSUBSYS}
  DIRID_INF            = 17;
  {$EXTERNALSYM DIRID_INF}
  DIRID_HELP           = 18;
  {$EXTERNALSYM DIRID_HELP}
  DIRID_FONTS          = 20;
  {$EXTERNALSYM DIRID_FONTS}
  DIRID_VIEWERS        = 21;
  {$EXTERNALSYM DIRID_VIEWERS}
  DIRID_COLOR          = 23;
  {$EXTERNALSYM DIRID_COLOR}
  DIRID_APPS           = 24;
  {$EXTERNALSYM DIRID_APPS}
  DIRID_SHARED         = 25;
  {$EXTERNALSYM DIRID_SHARED}
  DIRID_BOOT           = 30;
  {$EXTERNALSYM DIRID_BOOT}

  DIRID_SYSTEM16       = 50;
  {$EXTERNALSYM DIRID_SYSTEM16}
  DIRID_SPOOL          = 51;
  {$EXTERNALSYM DIRID_SPOOL}
  DIRID_SPOOLDRIVERS   = 52;
  {$EXTERNALSYM DIRID_SPOOLDRIVERS}
  DIRID_USERPROFILE    = 53;
  {$EXTERNALSYM DIRID_USERPROFILE}
  DIRID_LOADER         = 54;
  {$EXTERNALSYM DIRID_LOADER}
  DIRID_PRINTPROCESSOR = 55;
  {$EXTERNALSYM DIRID_PRINTPROCESSOR}

  DIRID_DEFAULT        = DIRID_SYSTEM;
  {$EXTERNALSYM DIRID_DEFAULT}

//
// The following DIRIDs are for commonly-used shell "special folders".  The
// complete list of such folders is contained in shlobj.h.  In that headerfile,
// each folder is assigned a CSIDL_* value.  The DIRID values below are created
// by taking the CSIDL value in shlobj.h and OR'ing it with 0x4000.  Thus, if
// an INF needs to reference other special folders not defined below, it may
// generate one using the above mechanism, and setupapi will automatically deal
// with it and use the corresponding shell's path where appropriate.  (Remember
// that DIRIDs must be specified in decimal, not hex, in an INF when used for
// string substitution.)
//
  DIRID_COMMON_STARTMENU        = 16406; // All Users\Start Menu
  {$EXTERNALSYM DIRID_COMMON_STARTMENU}
  DIRID_COMMON_PROGRAMS         = 16407; // All Users\Start Menu\Programs
  {$EXTERNALSYM DIRID_COMMON_PROGRAMS}
  DIRID_COMMON_STARTUP          = 16408; // All Users\Start Menu\Programs\Startup
  {$EXTERNALSYM DIRID_COMMON_STARTUP}
  DIRID_COMMON_DESKTOPDIRECTORY = 16409; // All Users\Desktop
  {$EXTERNALSYM DIRID_COMMON_DESKTOPDIRECTORY}
  DIRID_COMMON_FAVORITES        = 16415; // All Users\Favorites
  {$EXTERNALSYM DIRID_COMMON_FAVORITES}
  DIRID_COMMON_APPDATA          = 16419; // All Users\Application Data
  {$EXTERNALSYM DIRID_COMMON_APPDATA}

  DIRID_PROGRAM_FILES           = 16422; // Program Files
  {$EXTERNALSYM DIRID_PROGRAM_FILES}
  DIRID_SYSTEM_X86              = 16425; // system32 on RISC
  {$EXTERNALSYM DIRID_SYSTEM_X86}
  DIRID_PROGRAM_FILES_X86       = 16426; // Program Files on RISC
  {$EXTERNALSYM DIRID_PROGRAM_FILES_X86}
  DIRID_PROGRAM_FILES_COMMON    = 16427; // Program Files\Common
  {$EXTERNALSYM DIRID_PROGRAM_FILES_COMMON}
  DIRID_PROGRAM_FILES_COMMONX86 = 16428; // x86 Program Files\Common on RISC
  {$EXTERNALSYM DIRID_PROGRAM_FILES_COMMONX86}

  DIRID_COMMON_TEMPLATES        = 16429; // All Users\Templates
  {$EXTERNALSYM DIRID_COMMON_TEMPLATES}
  DIRID_COMMON_DOCUMENTS        = 16430; // All Users\Documents
  {$EXTERNALSYM DIRID_COMMON_DOCUMENTS}

//
// First user-definable dirid. See SetupSetDirectoryId().
//
  DIRID_USER = $8000;
  {$EXTERNALSYM DIRID_USER}

//
// Setup callback notification routine type
//
type
  TSPFileCallbackA = function(Context: Pointer; Notification: UINT;
    Param1, Param2: UINT_PTR): UINT; stdcall;
  TSPFileCallbackW = function(Context: Pointer; Notification: UINT;
    Param1, Param2: UINT_PTR): UINT; stdcall;
  {$IFDEF UNICODE}
  TSPFileCallback = TSPFileCallbackW;
  {$ELSE}
  TSPFileCallback = TSPFileCallbackA;
  {$ENDIF UNICODE}

//
// Operation/queue start/end notification. These are ordinal values.
//
const
  SPFILENOTIFY_STARTQUEUE    = $00000001;
  {$EXTERNALSYM SPFILENOTIFY_STARTQUEUE}
  SPFILENOTIFY_ENDQUEUE      = $00000002;
  {$EXTERNALSYM SPFILENOTIFY_ENDQUEUE}
  SPFILENOTIFY_STARTSUBQUEUE = $00000003;
  {$EXTERNALSYM SPFILENOTIFY_STARTSUBQUEUE}
  SPFILENOTIFY_ENDSUBQUEUE   = $00000004;
  {$EXTERNALSYM SPFILENOTIFY_ENDSUBQUEUE}
  SPFILENOTIFY_STARTDELETE   = $00000005;
  {$EXTERNALSYM SPFILENOTIFY_STARTDELETE}
  SPFILENOTIFY_ENDDELETE     = $00000006;
  {$EXTERNALSYM SPFILENOTIFY_ENDDELETE}
  SPFILENOTIFY_DELETEERROR   = $00000007;
  {$EXTERNALSYM SPFILENOTIFY_DELETEERROR}
  SPFILENOTIFY_STARTRENAME   = $00000008;
  {$EXTERNALSYM SPFILENOTIFY_STARTRENAME}
  SPFILENOTIFY_ENDRENAME     = $00000009;
  {$EXTERNALSYM SPFILENOTIFY_ENDRENAME}
  SPFILENOTIFY_RENAMEERROR   = $0000000a;
  {$EXTERNALSYM SPFILENOTIFY_RENAMEERROR}
  SPFILENOTIFY_STARTCOPY     = $0000000b;
  {$EXTERNALSYM SPFILENOTIFY_STARTCOPY}
  SPFILENOTIFY_ENDCOPY       = $0000000c;
  {$EXTERNALSYM SPFILENOTIFY_ENDCOPY}
  SPFILENOTIFY_COPYERROR     = $0000000d;
  {$EXTERNALSYM SPFILENOTIFY_COPYERROR}
  SPFILENOTIFY_NEEDMEDIA     = $0000000e;
  {$EXTERNALSYM SPFILENOTIFY_NEEDMEDIA}
  SPFILENOTIFY_QUEUESCAN     = $0000000f;
  {$EXTERNALSYM SPFILENOTIFY_QUEUESCAN}

//
// These are used with SetupIterateCabinet().
//
  SPFILENOTIFY_CABINETINFO    = $00000010;
  {$EXTERNALSYM SPFILENOTIFY_CABINETINFO}
  SPFILENOTIFY_FILEINCABINET  = $00000011;
  {$EXTERNALSYM SPFILENOTIFY_FILEINCABINET}
  SPFILENOTIFY_NEEDNEWCABINET = $00000012;
  {$EXTERNALSYM SPFILENOTIFY_NEEDNEWCABINET}
  SPFILENOTIFY_FILEEXTRACTED  = $00000013;
  {$EXTERNALSYM SPFILENOTIFY_FILEEXTRACTED}
  SPFILENOTIFY_FILEOPDELAYED  = $00000014;
  {$EXTERNALSYM SPFILENOTIFY_FILEOPDELAYED}

//
// These are used for backup operations
//
  SPFILENOTIFY_STARTBACKUP = $00000015;
  {$EXTERNALSYM SPFILENOTIFY_STARTBACKUP}
  SPFILENOTIFY_BACKUPERROR = $00000016;
  {$EXTERNALSYM SPFILENOTIFY_BACKUPERROR}
  SPFILENOTIFY_ENDBACKUP   = $00000017;
  {$EXTERNALSYM SPFILENOTIFY_ENDBACKUP}

//
// Extended notification for SetupScanFileQueue(Flags=SPQ_SCAN_USE_CALLBACKEX)
//
  SPFILENOTIFY_QUEUESCAN_EX = $00000018;
  {$EXTERNALSYM SPFILENOTIFY_QUEUESCAN_EX}

  SPFILENOTIFY_STARTREGISTRATION = $00000019;
  SPFILENOTIFY_ENDREGISTRATION   = $00000020;
  {$IFDEF COMPILER11_UP}
  {$EXTERNALSYM SPFILENOTIFY_STARTREGISTRATION}
  {$EXTERNALSYM SPFILENOTIFY_ENDREGISTRATION}
  {$ENDIF COMPILER11_UP}

//
// Extended notification for SetupScanFileQueue(Flags=SPQ_SCAN_USE_CALLBACK_SIGNERINFO)
//
  SPFILENOTIFY_QUEUESCAN_SIGNERINFO = $00000040;
  {$IFDEF COMPILER11_UP}
  {$EXTERNALSYM SPFILENOTIFY_QUEUESCAN_SIGNERINFO}
  {$ENDIF COMPILER11_UP}

//
// Copy notification. These are bit flags that may be combined.
//
  SPFILENOTIFY_LANGMISMATCH = $00010000;
  {$EXTERNALSYM SPFILENOTIFY_LANGMISMATCH}
  SPFILENOTIFY_TARGETEXISTS = $00020000;
  {$EXTERNALSYM SPFILENOTIFY_TARGETEXISTS}
  SPFILENOTIFY_TARGETNEWER  = $00040000;
  {$EXTERNALSYM SPFILENOTIFY_TARGETNEWER}

//
// File operation codes and callback outcomes.
//
  FILEOP_COPY   = 0;
  {$EXTERNALSYM FILEOP_COPY}
  FILEOP_RENAME = 1;
  {$EXTERNALSYM FILEOP_RENAME}
  FILEOP_DELETE = 2;
  {$EXTERNALSYM FILEOP_DELETE}
  FILEOP_BACKUP = 3;
  {$EXTERNALSYM FILEOP_BACKUP}

  FILEOP_ABORT   = 0;
  {$EXTERNALSYM FILEOP_ABORT}
  FILEOP_DOIT    = 1;
  {$EXTERNALSYM FILEOP_DOIT}
  FILEOP_SKIP    = 2;
  {$EXTERNALSYM FILEOP_SKIP}
  FILEOP_RETRY   = FILEOP_DOIT;
  {$EXTERNALSYM FILEOP_RETRY}
  FILEOP_NEWPATH = 4;
  {$EXTERNALSYM FILEOP_NEWPATH}

//
// Flags in inf copy sections
//
  COPYFLG_WARN_IF_SKIP         = $00000001; // warn if user tries to skip file
  {$EXTERNALSYM COPYFLG_WARN_IF_SKIP}
  COPYFLG_NOSKIP               = $00000002; // disallow skipping this file
  {$EXTERNALSYM COPYFLG_NOSKIP}
  COPYFLG_NOVERSIONCHECK       = $00000004; // ignore versions and overwrite target
  {$EXTERNALSYM COPYFLG_NOVERSIONCHECK}
  COPYFLG_FORCE_FILE_IN_USE    = $00000008; // force file-in-use behavior
  {$EXTERNALSYM COPYFLG_FORCE_FILE_IN_USE}
  COPYFLG_NO_OVERWRITE         = $00000010; // do not copy if file exists on target
  {$EXTERNALSYM COPYFLG_NO_OVERWRITE}
  COPYFLG_NO_VERSION_DIALOG    = $00000020; // do not copy if target is newer
  {$EXTERNALSYM COPYFLG_NO_VERSION_DIALOG}
  COPYFLG_OVERWRITE_OLDER_ONLY = $00000040; // leave target alone if version same as source
  {$EXTERNALSYM COPYFLG_OVERWRITE_OLDER_ONLY}
  COPYFLG_REPLACEONLY          = $00000400; // copy only if file exists on target
  {$EXTERNALSYM COPYFLG_REPLACEONLY}
  COPYFLG_NODECOMP             = $00000800; // don't attempt to decompress file; copy as-is
  {$EXTERNALSYM COPYFLG_NODECOMP}
  COPYFLG_REPLACE_BOOT_FILE    = $00001000; // file must be present upon reboot (i.e., it's
  {$EXTERNALSYM COPYFLG_REPLACE_BOOT_FILE}  // needed by the loader); this flag implies a reboot
  COPYFLG_NOPRUNE              = $00002000; // never prune this file
  {$EXTERNALSYM COPYFLG_NOPRUNE}

//
// Flags in inf delete sections
// New flags go in high word
//
  DELFLG_IN_USE  = $00000001; // queue in-use file for delete
  {$EXTERNALSYM DELFLG_IN_USE}
  DELFLG_IN_USE1 = $00010000; // high-word version of DELFLG_IN_USE
  {$EXTERNALSYM DELFLG_IN_USE1}

//
// Source and file paths. Used when notifying queue callback
// of SPFILENOTIFY_STARTxxx, SPFILENOTIFY_ENDxxx, and SPFILENOTIFY_xxxERROR.
//
type
  PFilePathsA = ^TFilePathsA;
  PFilePathsW = ^TFilePathsW;
  FILEPATHS_A = packed record
    Target: PAnsiChar;
    Source: PAnsiChar; // not used for delete operations
    Win32Error: UINT;
    Flags: DWORD; // such as SP_COPY_NOSKIP for copy errors
  end;
  {$EXTERNALSYM FILEPATHS_A}
  FILEPATHS_W = packed record
    Target: PWideChar;
    Source: PWideChar; // not used for delete operations
    Win32Error: UINT;
    Flags: DWORD; // such as SP_COPY_NOSKIP for copy errors
  end;
  {$EXTERNALSYM FILEPATHS_W}
  TFilePathsA = FILEPATHS_A;
  TFilePathsW = FILEPATHS_W;
  {$IFDEF UNICODE}
  TFilePaths = TFilePathsW;
  PFilePaths = PFilePathsW;
  {$ELSE}
  TFilePaths = TFilePathsA;
  PFilePaths = PFilePathsA;
  {$ENDIF UNICODE}

  {$IFDEF WINXP_UP}
  PFilePathsSignerInfoA = ^TFilePathsSignerInfoA;
  PFilePathsSignerInfoW = ^TFilePathsSignerInfoW;
  FILEPATHS_SIGNERINFO_A = packed record
    Target: PAnsiChar;
    Source: PAnsiChar;  // not used for delete operations
    Win32Error: UINT;
    Flags: DWORD;   // such as SP_COPY_NOSKIP for copy errors
    DigitalSigner: PAnsiChar;
    Version: PAnsiChar;
    CatalogFile: PAnsiChar;
  end;
  {$EXTERNALSYM FILEPATHS_SIGNERINFO_A}
  FILEPATHS_SIGNERINFO_W = packed record
    Target: PWideChar;
    Source: PWideChar;  // not used for delete operations
    Win32Error: UINT;
    Flags: DWORD;   // such as SP_COPY_NOSKIP for copy errors
    DigitalSigner: PWideChar;
    Version: PWideChar;
    CatalogFile: PWideChar;
  end;
  {$EXTERNALSYM FILEPATHS_SIGNERINFO_W}
  TFilePathsSignerInfoA = FILEPATHS_SIGNERINFO_A;
  TFilePathsSignerInfoW = FILEPATHS_SIGNERINFO_W;
  {$IFDEF UNICODE}
  TFilePathsSignerInfo = TFilePathsSignerInfoA;
  PFilePathsSignerInfo = PFilePathsSignerInfoW;
  {$ELSE}
  TFilePathsSignerInfo = TFilePathsSignerInfoA;
  PFilePathsSignerInfo = PFilePathsSignerInfoA;
  {$ENDIF UNICODE}
  {$ENDIF WINXP_UP}

//
// Structure used with SPFILENOTIFY_NEEDMEDIA
//
  PSourceMediaA = ^TSourceMediaA;
  PSourceMediaW = ^TSourceMediaW;
  SOURCE_MEDIA_A = packed record
    Reserved: PAnsiChar;
    Tagfile: PAnsiChar; // may be NULL
    Description: PAnsiChar;
    //
    // Pathname part and filename part of source file
    // that caused us to need the media.
    //
    SourcePath: PAnsiChar;
    SourceFile: PAnsiChar;
    Flags: DWORD; // subset of SP_COPY_xxx
  end;
  {$EXTERNALSYM SOURCE_MEDIA_A}
  SOURCE_MEDIA_W = packed record
    Reserved: PWideChar;
    Tagfile: PWideChar; // may be NULL
    Description: PWideChar;
    //
    // Pathname part and filename part of source file
    // that caused us to need the media.
    //
    SourcePath: PWideChar;
    SourceFile: PWideChar;
    Flags: DWORD; // subset of SP_COPY_xxx
  end;
  {$EXTERNALSYM SOURCE_MEDIA_W}
  TSourceMediaA = SOURCE_MEDIA_A;
  TSourceMediaW = SOURCE_MEDIA_W;
  {$IFDEF UNICODE}
  TSourceMedia = TSourceMediaW;
  PSourceMedia = PSourceMediaW;
  {$ELSE}
  TSourceMedia = TSourceMediaA;
  PSourceMedia = PSourceMediaA;
  {$ENDIF UNICODE}

//
// Structure used with SPFILENOTIFY_CABINETINFO and
// SPFILENOTIFY_NEEDNEWCABINET
//
  PCabinetInfoA = ^TCabinetInfoA;
  PCabinetInfoW = ^TCabinetInfoW;
  CABINET_INFO_A = packed record
    CabinetPath: PAnsiChar;
    CabinetFile: PAnsiChar;
    DiskName: PAnsiChar;
    SetId: Word;
    CabinetNumber: Word;
  end;
  {$EXTERNALSYM CABINET_INFO_A}
  CABINET_INFO_W = packed record
    CabinetPath: PWideChar;
    CabinetFile: PWideChar;
    DiskName: PWideChar;
    SetId: Word;
    CabinetNumber: Word;
  end;
  {$EXTERNALSYM CABINET_INFO_W}
  TCabinetInfoA = CABINET_INFO_A;
  TCabinetInfoW = CABINET_INFO_W;
  {$IFDEF UNICODE}
  TCabinetInfo = TCabinetInfoW;
  PCabinetInfo = PCabinetInfoW;
  {$ELSE}
  TCabinetInfo = TCabinetInfoA;
  PCabinetInfo = PCabinetInfoA;
  {$ENDIF UNICODE}

//
// Structure used with SPFILENOTIFY_FILEINCABINET
//
  PFileInCabinetInfoA = ^TFileInCabinetInfoA;
  PFileInCabinetInfoW = ^TFileInCabinetInfoW;
  FILE_IN_CABINET_INFO_A = packed record
    NameInCabinet: PAnsiChar;
    FileSize: DWORD;
    Win32Error: DWORD;
    DosDate: Word;
    DosTime: Word;
    DosAttribs: Word;
    FullTargetName: array [0..MAX_PATH - 1] of AnsiChar;
  end;
  {$EXTERNALSYM FILE_IN_CABINET_INFO_A}
  FILE_IN_CABINET_INFO_W = packed record
    NameInCabinet: PWideChar;
    FileSize: DWORD;
    Win32Error: DWORD;
    DosDate: Word;
    DosTime: Word;
    DosAttribs: Word;
    FullTargetName: array [0..MAX_PATH - 1] of WideChar;
  end;
  {$EXTERNALSYM FILE_IN_CABINET_INFO_W}
  TFileInCabinetInfoA = FILE_IN_CABINET_INFO_A;
  TFileInCabinetInfoW = FILE_IN_CABINET_INFO_W;
  {$IFDEF UNICODE}
  TFileInCabinetInfo = TFileInCabinetInfoW;
  PFileInCabinetInfo = PFileInCabinetInfoW;
  {$ELSE}
  TFileInCabinetInfo = TFileInCabinetInfoA;
  PFileInCabinetInfo = PFileInCabinetInfoA;
  {$ENDIF UNICODE}

  //
  // Structure used for SPFILENOTIFY_***REGISTRATION
  // callback
  //
  {$IFDEF WINXP_UP}
  PSPRegisterControlStatusA = ^TSPRegisterControlStatusA;
  PSPRegisterControlStatusW = ^TSPRegisterControlStatusW;
  SP_REGISTER_CONTROL_STATUSA = packed record
    cbSize: DWORD;
    FileName: PAnsiChar;
    Win32Error: DWORD;
    FailureCode: DWORD;
  end;
  {$EXTERNALSYM SP_REGISTER_CONTROL_STATUSA}
  SP_REGISTER_CONTROL_STATUSW = packed record
    cbSize: DWORD;
    FileName: PWideChar;
    Win32Error: DWORD;
    FailureCode: DWORD;
  end;
  {$EXTERNALSYM SP_REGISTER_CONTROL_STATUSW}
  TSPRegisterControlStatusA = SP_REGISTER_CONTROL_STATUSA;
  TSPRegisterControlStatusW = SP_REGISTER_CONTROL_STATUSW;
  {$IFDEF UNICODE}
  TSPRegisterControlStatus = TSPRegisterControlStatusW;
  PSPRegisterControlStatus = PSPRegisterControlStatusW;
  {$ELSE}
  TSPRegisterControlStatus = TSPRegisterControlStatusA;
  PSPRegisterControlStatus = PSPRegisterControlStatusA;
  {$ENDIF UNICODE}
  {$ENDIF WINXP_UP}

//
// valid values for SP_REGISTER_CONTROL_STATUS.FailureCode field
//
const
  SPREG_SUCCESS     = $00000000;
  {$EXTERNALSYM SPREG_SUCCESS}
  SPREG_LOADLIBRARY = $00000001;
  {$EXTERNALSYM SPREG_LOADLIBRARY}
  SPREG_GETPROCADDR = $00000002;
  {$EXTERNALSYM SPREG_GETPROCADDR}
  SPREG_REGSVR      = $00000003;
  {$EXTERNALSYM SPREG_REGSVR}
  SPREG_DLLINSTALL  = $00000004;
  {$EXTERNALSYM SPREG_DLLINSTALL}
  SPREG_TIMEOUT     = $00000005;
  {$EXTERNALSYM SPREG_TIMEOUT}
  SPREG_UNKNOWN     = $FFFFFFFF;
  {$EXTERNALSYM SPREG_UNKNOWN}

//
// Define type for setup file queue
//
type
  HSPFILEQ = Pointer;
  {$EXTERNALSYM HSPFILEQ}

//
// Structure used with SetupQueueCopyIndirect
//
  PSPFileCopyParamsA = ^TSPFileCopyParamsA;
  PSPFileCopyParamsW = ^TSPFileCopyParamsW;
  SP_FILE_COPY_PARAMS_A = packed record
    cbSize: DWORD;
    QueueHandle: HSPFILEQ;
    SourceRootPath: PAnsiChar;
    SourcePath: PAnsiChar;
    SourceFilename: PAnsiChar;
    SourceDescription: PAnsiChar;
    SourceTagfile: PAnsiChar;
    TargetDirectory: PAnsiChar;
    TargetFilename: PAnsiChar;
    CopyStyle: DWORD;
    LayoutInf: HINF;
    SecurityDescriptor: PAnsiChar;
  end;
  {$EXTERNALSYM SP_FILE_COPY_PARAMS_A}
  SP_FILE_COPY_PARAMS_W = packed record
    cbSize: DWORD;
    QueueHandle: HSPFILEQ;
    SourceRootPath: PWideChar;
    SourcePath: PWideChar;
    SourceFilename: PWideChar;
    SourceDescription: PWideChar;
    SourceTagfile: PWideChar;
    TargetDirectory: PWideChar;
    TargetFilename: PWideChar;
    CopyStyle: DWORD;
    LayoutInf: HINF;
    SecurityDescriptor: PWideChar;
  end;
  {$EXTERNALSYM SP_FILE_COPY_PARAMS_W}
  TSPFileCopyParamsA = SP_FILE_COPY_PARAMS_A;
  TSPFileCopyParamsW = SP_FILE_COPY_PARAMS_W;
  {$IFDEF UNICODE}
  TSPFileCopyParams = TSPFileCopyParamsW;
  PSPFileCopyParams = PSPFileCopyParamsW;
  {$ELSE}
  TSPFileCopyParams = TSPFileCopyParamsA;
  PSPFileCopyParams = PSPFileCopyParamsA;
  {$ENDIF UNICODE}

//
// Define type for setup disk space list
//
  HDSKSPC = Pointer;
  {$EXTERNALSYM HDSKSPC}

//
// Define type for reference to device information set
//
  HDEVINFO = Pointer;
  {$EXTERNALSYM HDEVINFO}

//
// Device information structure (references a device instance
// that is a member of a device information set)
//
  PSPDevInfoData = ^TSPDevInfoData;
  SP_DEVINFO_DATA = packed record
    cbSize: DWORD;
    ClassGuid: TGUID;
    DevInst: DWORD; // DEVINST handle
    Reserved: ULONG_PTR;
  end;
  {$EXTERNALSYM SP_DEVINFO_DATA}
  TSPDevInfoData = SP_DEVINFO_DATA;

//
// Device interface information structure (references a device
// interface that is associated with the device information
// element that owns it).
//
  PSPDeviceInterfaceData = ^TSPDeviceInterfaceData;
  SP_DEVICE_INTERFACE_DATA = packed record
    cbSize: DWORD;
    InterfaceClassGuid: TGUID;
    Flags: DWORD;
    Reserved: ULONG_PTR;
  end;
  {$EXTERNALSYM SP_DEVICE_INTERFACE_DATA}
  TSPDeviceInterfaceData = SP_DEVICE_INTERFACE_DATA;

//
// Flags for SP_DEVICE_INTERFACE_DATA.Flags field.
//
const
  SPINT_ACTIVE  = $00000001;
  {$EXTERNALSYM SPINT_ACTIVE}
  SPINT_DEFAULT = $00000002;
  {$EXTERNALSYM SPINT_DEFAULT}
  SPINT_REMOVED = $00000004;
  {$EXTERNALSYM SPINT_REMOVED}

//
// Backward compatibility--do not use.
//

type
  TSPInterfaceDeviceData = TSPDeviceInterfaceData;
  PSPInterfaceDeviceData = PSPDeviceInterfaceData;

const
  SPID_ACTIVE  = SPINT_ACTIVE;
  {$EXTERNALSYM SPID_ACTIVE}
  SPID_DEFAULT = SPINT_DEFAULT;
  {$EXTERNALSYM SPID_DEFAULT}
  SPID_REMOVED = SPINT_REMOVED;
  {$EXTERNALSYM SPID_REMOVED}

type
  TFiller = record
    {$IFDEF CPU64}
    Fill: array[0..1] of Byte;
    {$ENDIF CPU64}
  end;

  PSPDeviceInterfaceDetailDataA = ^TSPDeviceInterfaceDetailDataA;
  PSPDeviceInterfaceDetailDataW = ^TSPDeviceInterfaceDetailDataW;
  SP_DEVICE_INTERFACE_DETAIL_DATA_A = packed record
    cbSize: DWORD;
    DevicePath: array [0..ANYSIZE_ARRAY - 1] of AnsiChar;
    Filler: TFiller;
  end;
  {$EXTERNALSYM SP_DEVICE_INTERFACE_DETAIL_DATA_A}
  SP_DEVICE_INTERFACE_DETAIL_DATA_W = packed record
    cbSize: DWORD;
    DevicePath: array [0..ANYSIZE_ARRAY - 1] of WideChar;
    Filler: TFiller;
  end;
  {$EXTERNALSYM SP_DEVICE_INTERFACE_DETAIL_DATA_W}
  TSPDeviceInterfaceDetailDataA = SP_DEVICE_INTERFACE_DETAIL_DATA_A;
  TSPDeviceInterfaceDetailDataW = SP_DEVICE_INTERFACE_DETAIL_DATA_W;
  {$IFDEF UNICODE}
  TSPDeviceInterfaceDetailData = TSPDeviceInterfaceDetailDataW;
  PSPDeviceInterfaceDetailData = PSPDeviceInterfaceDetailDataW;
  SP_DEVICE_INTERFACE_DETAIL_DATA = SP_DEVICE_INTERFACE_DETAIL_DATA_W;
  {$ELSE}
  TSPDeviceInterfaceDetailData = TSPDeviceInterfaceDetailDataA;
  PSPDeviceInterfaceDetailData = PSPDeviceInterfaceDetailDataA;
  SP_DEVICE_INTERFACE_DETAIL_DATA = SP_DEVICE_INTERFACE_DETAIL_DATA_A;
  {$ENDIF UNICODE}
  {$EXTERNALSYM SP_DEVICE_INTERFACE_DETAIL_DATA}

//
// Backward compatibility--do not use.
//

  TSPInterfaceDeviceDetailDataA = TSPDeviceInterfaceDetailDataA;
  TSPInterfaceDeviceDetailDataW = TSPDeviceInterfaceDetailDataW;
  PSPInterfaceDeviceDetailDataA = PSPDeviceInterfaceDetailDataA;
  PSPInterfaceDeviceDetailDataW = PSPDeviceInterfaceDetailDataW;
  {$IFDEF UNICODE}
  TSPInterfaceDeviceDetailData = TSPInterfaceDeviceDetailDataW;
  PSPInterfaceDeviceDetailData = PSPInterfaceDeviceDetailDataW;
  {$ELSE}
  TSPInterfaceDeviceDetailData = TSPInterfaceDeviceDetailDataA;
  PSPInterfaceDeviceDetailData = PSPInterfaceDeviceDetailDataA;
  {$ENDIF UNICODE}

//
// Structure for detailed information on a device information set (used for
// SetupDiGetDeviceInfoListDetail which supercedes the functionality of
// SetupDiGetDeviceInfoListClass).
//
  PSPDevInfoListDetailDataA = ^TSPDevInfoListDetailDataA;
  PSPDevInfoListDetailDataW = ^TSPDevInfoListDetailDataW;
  SP_DEVINFO_LIST_DETAIL_DATA_A = packed record
    cbSize: DWORD;
    ClassGuid: TGUID;
    RemoteMachineHandle: THandle;
    RemoteMachineName: array [0..SP_MAX_MACHINENAME_LENGTH - 1] of AnsiChar;
  end;
  {$EXTERNALSYM SP_DEVINFO_LIST_DETAIL_DATA_A}
  SP_DEVINFO_LIST_DETAIL_DATA_W = packed record
    cbSize: DWORD;
    ClassGuid: TGUID;
    RemoteMachineHandle: THandle;
    RemoteMachineName: array [0..SP_MAX_MACHINENAME_LENGTH - 1] of WideChar;
  end;
  {$EXTERNALSYM SP_DEVINFO_LIST_DETAIL_DATA_W}
  TSPDevInfoListDetailDataA = SP_DEVINFO_LIST_DETAIL_DATA_A;
  TSPDevInfoListDetailDataW = SP_DEVINFO_LIST_DETAIL_DATA_W;
  {$IFDEF UNICODE}
  TSPDevInfoListDetailData = TSPDevInfoListDetailDataW;
  PSPDevInfoListDetailData = PSPDevInfoListDetailDataW;
  {$ELSE}
  TSPDevInfoListDetailData = TSPDevInfoListDetailDataA;
  PSPDevInfoListDetailData = PSPDevInfoListDetailDataA;
  {$ENDIF UNICODE}

//
// Class installer function codes
//
const
  DIF_SELECTDEVICE                  = $00000001;
  {$EXTERNALSYM DIF_SELECTDEVICE}
  DIF_INSTALLDEVICE                 = $00000002;
  {$EXTERNALSYM DIF_INSTALLDEVICE}
  DIF_ASSIGNRESOURCES               = $00000003;
  {$EXTERNALSYM DIF_ASSIGNRESOURCES}
  DIF_PROPERTIES                    = $00000004;
  {$EXTERNALSYM DIF_PROPERTIES}
  DIF_REMOVE                        = $00000005;
  {$EXTERNALSYM DIF_REMOVE}
  DIF_FIRSTTIMESETUP                = $00000006;
  {$EXTERNALSYM DIF_FIRSTTIMESETUP}
  DIF_FOUNDDEVICE                   = $00000007;
  {$EXTERNALSYM DIF_FOUNDDEVICE}
  DIF_SELECTCLASSDRIVERS            = $00000008;
  {$EXTERNALSYM DIF_SELECTCLASSDRIVERS}
  DIF_VALIDATECLASSDRIVERS          = $00000009;
  {$EXTERNALSYM DIF_VALIDATECLASSDRIVERS}
  DIF_INSTALLCLASSDRIVERS           = $0000000A;
  {$EXTERNALSYM DIF_INSTALLCLASSDRIVERS}
  DIF_CALCDISKSPACE                 = $0000000B;
  {$EXTERNALSYM DIF_CALCDISKSPACE}
  DIF_DESTROYPRIVATEDATA            = $0000000C;
  {$EXTERNALSYM DIF_DESTROYPRIVATEDATA}
  DIF_VALIDATEDRIVER                = $0000000D;
  {$EXTERNALSYM DIF_VALIDATEDRIVER}
  DIF_MOVEDEVICE                    = $0000000E;
  {$EXTERNALSYM DIF_MOVEDEVICE}
  DIF_DETECT                        = $0000000F;
  {$EXTERNALSYM DIF_DETECT}
  DIF_INSTALLWIZARD                 = $00000010;
  {$EXTERNALSYM DIF_INSTALLWIZARD}
  DIF_DESTROYWIZARDDATA             = $00000011;
  {$EXTERNALSYM DIF_DESTROYWIZARDDATA}
  DIF_PROPERTYCHANGE                = $00000012;
  {$EXTERNALSYM DIF_PROPERTYCHANGE}
  DIF_ENABLECLASS                   = $00000013;
  {$EXTERNALSYM DIF_ENABLECLASS}
  DIF_DETECTVERIFY                  = $00000014;
  {$EXTERNALSYM DIF_DETECTVERIFY}
  DIF_INSTALLDEVICEFILES            = $00000015;
  {$EXTERNALSYM DIF_INSTALLDEVICEFILES}
  DIF_UNREMOVE                      = $00000016;
  {$EXTERNALSYM DIF_UNREMOVE}
  DIF_SELECTBESTCOMPATDRV           = $00000017;
  {$EXTERNALSYM DIF_SELECTBESTCOMPATDRV}
  DIF_ALLOW_INSTALL                 = $00000018;
  {$EXTERNALSYM DIF_ALLOW_INSTALL}
  DIF_REGISTERDEVICE                = $00000019;
  {$EXTERNALSYM DIF_REGISTERDEVICE}
  DIF_NEWDEVICEWIZARD_PRESELECT     = $0000001A;
  {$EXTERNALSYM DIF_NEWDEVICEWIZARD_PRESELECT}
  DIF_NEWDEVICEWIZARD_SELECT        = $0000001B;
  {$EXTERNALSYM DIF_NEWDEVICEWIZARD_SELECT}
  DIF_NEWDEVICEWIZARD_PREANALYZE    = $0000001C;
  {$EXTERNALSYM DIF_NEWDEVICEWIZARD_PREANALYZE}
  DIF_NEWDEVICEWIZARD_POSTANALYZE   = $0000001D;
  {$EXTERNALSYM DIF_NEWDEVICEWIZARD_POSTANALYZE}
  DIF_NEWDEVICEWIZARD_FINISHINSTALL = $0000001E;
  {$EXTERNALSYM DIF_NEWDEVICEWIZARD_FINISHINSTALL}
  DIF_UNUSED1                       = $0000001F;
  {$EXTERNALSYM DIF_UNUSED1}
  DIF_INSTALLINTERFACES             = $00000020;
  {$EXTERNALSYM DIF_INSTALLINTERFACES}
  DIF_DETECTCANCEL                  = $00000021;
  {$EXTERNALSYM DIF_DETECTCANCEL}
  DIF_REGISTER_COINSTALLERS         = $00000022;
  {$EXTERNALSYM DIF_REGISTER_COINSTALLERS}
  DIF_ADDPROPERTYPAGE_ADVANCED      = $00000023;
  {$EXTERNALSYM DIF_ADDPROPERTYPAGE_ADVANCED}
  DIF_ADDPROPERTYPAGE_BASIC         = $00000024;
  {$EXTERNALSYM DIF_ADDPROPERTYPAGE_BASIC}
  DIF_RESERVED1                     = $00000025;
  {$EXTERNALSYM DIF_RESERVED1}
  DIF_TROUBLESHOOTER                = $00000026;
  {$EXTERNALSYM DIF_TROUBLESHOOTER}
  DIF_POWERMESSAGEWAKE              = $00000027;
  {$EXTERNALSYM DIF_POWERMESSAGEWAKE}
  DIF_ADDREMOTEPROPERTYPAGE_ADVANCED = $00000028;
  {$EXTERNALSYM DIF_ADDREMOTEPROPERTYPAGE_ADVANCED}
  DIF_UPDATEDRIVER_UI                = $00000029;
  {$EXTERNALSYM DIF_UPDATEDRIVER_UI}
  DIF_RESERVED2                      = $00000030;
  {$EXTERNALSYM DIF_RESERVED2}

type
  DI_FUNCTION = UINT;    // Function type for device installer
  {$EXTERNALSYM DI_FUNCTION}

//
// Device installation parameters structure (associated with a
// particular device information element, or globally with a device
// information set)
//
  PSPDevInstallParamsA = ^TSPDevInstallParamsA;
  PSPDevInstallParamsW = ^TSPDevInstallParamsW;
  SP_DEVINSTALL_PARAMS_A = packed record
    cbSize: DWORD;
    Flags: DWORD;
    FlagsEx: DWORD;
    hwndParent: HWND;
    InstallMsgHandler: TSPFileCallback;
    InstallMsgHandlerContext: Pointer;
    FileQueue: HSPFILEQ;
    ClassInstallReserved: ULONG_PTR;
    Reserved: DWORD;
    DriverPath: array [0..MAX_PATH - 1] of AnsiChar;
  end;
  {$EXTERNALSYM SP_DEVINSTALL_PARAMS_A}
  SP_DEVINSTALL_PARAMS_W = packed record
    cbSize: DWORD;
    Flags: DWORD;
    FlagsEx: DWORD;
    hwndParent: HWND;
    InstallMsgHandler: TSPFileCallback;
    InstallMsgHandlerContext: Pointer;
    FileQueue: HSPFILEQ;
    ClassInstallReserved: ULONG_PTR;
    Reserved: DWORD;
    DriverPath: array [0..MAX_PATH - 1] of WideChar;
  end;
  {$EXTERNALSYM SP_DEVINSTALL_PARAMS_W}
  TSPDevInstallParamsA = SP_DEVINSTALL_PARAMS_A;
  TSPDevInstallParamsW = SP_DEVINSTALL_PARAMS_W;
  {$IFDEF UNICODE}
  TSPDevInstallParams = TSPDevInstallParamsW;
  PSPDevInstallParams = PSPDevInstallParamsW;
  {$ELSE}
  TSPDevInstallParams = TSPDevInstallParamsA;
  PSPDevInstallParams = PSPDevInstallParamsA;
  {$ENDIF UNICODE}

//
// SP_DEVINSTALL_PARAMS.Flags values
//
// Flags for choosing a device
//
const
  DI_SHOWOEM       = $00000001; // support Other... button
  {$EXTERNALSYM DI_SHOWOEM}
  DI_SHOWCOMPAT    = $00000002; // show compatibility list
  {$EXTERNALSYM DI_SHOWCOMPAT}
  DI_SHOWCLASS     = $00000004; // show class list
  {$EXTERNALSYM DI_SHOWCLASS}
  DI_SHOWALL       = $00000007; // both class & compat list shown
  {$EXTERNALSYM DI_SHOWALL}
  DI_NOVCP         = $00000008; // don't create a new copy queue--use
  {$EXTERNALSYM DI_NOVCP}     // caller-supplied FileQueue
  DI_DIDCOMPAT     = $00000010; // Searched for compatible devices
  {$EXTERNALSYM DI_DIDCOMPAT}
  DI_DIDCLASS      = $00000020; // Searched for class devices
  {$EXTERNALSYM DI_DIDCLASS}
  DI_AUTOASSIGNRES = $00000040; // No UI for resources if possible
  {$EXTERNALSYM DI_AUTOASSIGNRES}

// flags returned by DiInstallDevice to indicate need to reboot/restart
  DI_NEEDRESTART = $00000080; // Reboot required to take effect
  {$EXTERNALSYM DI_NEEDRESTART}
  DI_NEEDREBOOT  = $00000100; // ""
  {$EXTERNALSYM DI_NEEDREBOOT}

// flags for device installation
  DI_NOBROWSE = $00000200; // no Browse... in InsertDisk
  {$EXTERNALSYM DI_NOBROWSE}

// Flags set by DiBuildDriverInfoList
  DI_MULTMFGS = $00000400;   // Set if multiple manufacturers in
  {$EXTERNALSYM DI_MULTMFGS} // class driver list

// Flag indicates that device is disabled
  DI_DISABLED = $00000800; // Set if device disabled
  {$EXTERNALSYM DI_DISABLED}

// Flags for Device/Class Properties
  DI_GENERALPAGE_ADDED  = $00001000;
  {$EXTERNALSYM DI_GENERALPAGE_ADDED}
  DI_RESOURCEPAGE_ADDED = $00002000;
  {$EXTERNALSYM DI_RESOURCEPAGE_ADDED}

// Flag to indicate the setting properties for this Device (or class) caused a change
// so the Dev Mgr UI probably needs to be updatd.
  DI_PROPERTIES_CHANGE = $00004000;
  {$EXTERNALSYM DI_PROPERTIES_CHANGE}

// Flag to indicate that the sorting from the INF file should be used.
  DI_INF_IS_SORTED = $00008000;
  {$EXTERNALSYM DI_INF_IS_SORTED}

// Flag to indicate that only the the INF specified by SP_DEVINSTALL_PARAMS.DriverPath
// should be searched.
  DI_ENUMSINGLEINF = $00010000;
  {$EXTERNALSYM DI_ENUMSINGLEINF}

// Flag that prevents ConfigMgr from removing/re-enumerating devices during device
// registration, installation, and deletion.
  DI_DONOTCALLCONFIGMG = $00020000;
  {$EXTERNALSYM DI_DONOTCALLCONFIGMG}

// The following flag can be used to install a device disabled
  DI_INSTALLDISABLED = $00040000;
  {$EXTERNALSYM DI_INSTALLDISABLED}

// Flag that causes SetupDiBuildDriverInfoList to build a device's compatible driver
// list from its existing class driver list, instead of the normal INF search.
  DI_COMPAT_FROM_CLASS = $00080000;
  {$EXTERNALSYM DI_COMPAT_FROM_CLASS}

// This flag is set if the Class Install params should be used.
  DI_CLASSINSTALLPARAMS = $00100000;
  {$EXTERNALSYM DI_CLASSINSTALLPARAMS}

// This flag is set if the caller of DiCallClassInstaller does NOT
// want the internal default action performed if the Class installer
// returns ERROR_DI_DO_DEFAULT.
  DI_NODI_DEFAULTACTION = $00200000;
  {$EXTERNALSYM DI_NODI_DEFAULTACTION}

// The setupx flag, DI_NOSYNCPROCESSING (0x00400000L) is not support in the Setup APIs.

// flags for device installation
  DI_QUIETINSTALL        = $00800000; // don't confuse the user with
  {$EXTERNALSYM DI_QUIETINSTALL}      // questions or excess info
  DI_NOFILECOPY          = $01000000; // No file Copy necessary
  {$EXTERNALSYM DI_NOFILECOPY}
  DI_FORCECOPY           = $02000000; // Force files to be copied from install path
  {$EXTERNALSYM DI_FORCECOPY}
  DI_DRIVERPAGE_ADDED    = $04000000; // Prop provider added Driver page.
  {$EXTERNALSYM DI_DRIVERPAGE_ADDED}
  DI_USECI_SELECTSTRINGS = $08000000; // Use Class Installer Provided strings in the Select Device Dlg
  {$EXTERNALSYM DI_USECI_SELECTSTRINGS}
  DI_OVERRIDE_INFFLAGS   = $10000000; // Override INF flags
  {$EXTERNALSYM DI_OVERRIDE_INFFLAGS}
  DI_PROPS_NOCHANGEUSAGE = $20000000; // No Enable/Disable in General Props
  {$EXTERNALSYM DI_PROPS_NOCHANGEUSAGE}

  DI_NOSELECTICONS       = $40000000; // No small icons in select device dialogs
  {$EXTERNALSYM DI_NOSELECTICONS}

  DI_NOWRITE_IDS         = DWORD($80000000); // Don't write HW & Compat IDs on install
  {$EXTERNALSYM DI_NOWRITE_IDS}

//
// SP_DEVINSTALL_PARAMS.FlagsEx values
//
  DI_FLAGSEX_USEOLDINFSEARCH          = $00000001; // Inf Search functions should not use Index Search
  {$EXTERNALSYM DI_FLAGSEX_USEOLDINFSEARCH}
  DI_FLAGSEX_AUTOSELECTRANK0          = $00000002; // SetupDiSelectDevice doesn't prompt user if rank 0 match
  {$EXTERNALSYM DI_FLAGSEX_AUTOSELECTRANK0}
  DI_FLAGSEX_CI_FAILED                = $00000004; // Failed to Load/Call class installer
  {$EXTERNALSYM DI_FLAGSEX_CI_FAILED}

  DI_FLAGSEX_DIDINFOLIST              = $00000010; // Did the Class Info List
  {$EXTERNALSYM DI_FLAGSEX_DIDINFOLIST}
  DI_FLAGSEX_DIDCOMPATINFO            = $00000020; // Did the Compat Info List
  {$EXTERNALSYM DI_FLAGSEX_DIDCOMPATINFO}

  DI_FLAGSEX_FILTERCLASSES            = $00000040;
  {$EXTERNALSYM DI_FLAGSEX_FILTERCLASSES}
  DI_FLAGSEX_SETFAILEDINSTALL         = $00000080;
  {$EXTERNALSYM DI_FLAGSEX_SETFAILEDINSTALL}
  DI_FLAGSEX_DEVICECHANGE             = $00000100;
  {$EXTERNALSYM DI_FLAGSEX_DEVICECHANGE}
  DI_FLAGSEX_ALWAYSWRITEIDS           = $00000200;
  {$EXTERNALSYM DI_FLAGSEX_ALWAYSWRITEIDS}
  DI_FLAGSEX_PROPCHANGE_PENDING       = $00000400; // One or more device property sheets have had changes made
  {$EXTERNALSYM DI_FLAGSEX_PROPCHANGE_PENDING}     // to them, and need to have a DIF_PROPERTYCHANGE occur.

  DI_FLAGSEX_ALLOWEXCLUDEDDRVS        = $00000800;
  {$EXTERNALSYM DI_FLAGSEX_ALLOWEXCLUDEDDRVS}
  DI_FLAGSEX_NOUIONQUERYREMOVE        = $00001000;
  {$EXTERNALSYM DI_FLAGSEX_NOUIONQUERYREMOVE}
  DI_FLAGSEX_USECLASSFORCOMPAT        = $00002000; // Use the device's class when building compat drv list.
  {$EXTERNALSYM DI_FLAGSEX_USECLASSFORCOMPAT}      // (Ignored if DI_COMPAT_FROM_CLASS flag is specified.)
  DI_FLAGSEX_OLDINF_IN_CLASSLIST      = $00004000; // Search legacy INFs when building class driver list.
  {$EXTERNALSYM DI_FLAGSEX_OLDINF_IN_CLASSLIST}
  DI_FLAGSEX_NO_DRVREG_MODIFY         = $00008000; // Don't run AddReg and DelReg for device's software (driver) key.
  {$EXTERNALSYM DI_FLAGSEX_NO_DRVREG_MODIFY}
  DI_FLAGSEX_IN_SYSTEM_SETUP          = $00010000; // Installation is occurring during initial system setup.
  {$EXTERNALSYM DI_FLAGSEX_IN_SYSTEM_SETUP}
  DI_FLAGSEX_INET_DRIVER              = $00020000; // Driver came from Windows Update
  {$EXTERNALSYM DI_FLAGSEX_INET_DRIVER}
  DI_FLAGSEX_APPENDDRIVERLIST         = $00040000; // Cause SetupDiBuildDriverInfoList to append
  {$EXTERNALSYM DI_FLAGSEX_APPENDDRIVERLIST}       // a new driver list to an existing list.
  DI_FLAGSEX_PREINSTALLBACKUP         = $00080000; // backup all files required by old inf before install
  {$EXTERNALSYM DI_FLAGSEX_PREINSTALLBACKUP}
  DI_FLAGSEX_BACKUPONREPLACE          = $00100000; // backup files required by old inf as they are replaced
  {$EXTERNALSYM DI_FLAGSEX_BACKUPONREPLACE}
  DI_FLAGSEX_DRIVERLIST_FROM_URL      = $00200000; // build driver list from INF(s) retrieved from URL specified
  {$EXTERNALSYM DI_FLAGSEX_DRIVERLIST_FROM_URL}
                                                   // in SP_DEVINSTALL_PARAMS.DriverPath (empty string means
                                                   // Windows Update website)
  DI_FLAGSEX_RESERVED1                = $00400000;
  {$EXTERNALSYM DI_FLAGSEX_RESERVED1}
  DI_FLAGSEX_EXCLUDE_OLD_INET_DRIVERS = $00800000; // Don't include old Internet drivers when building
  {$EXTERNALSYM DI_FLAGSEX_EXCLUDE_OLD_INET_DRIVERS}
                                                   // a driver list.
  DI_FLAGSEX_POWERPAGE_ADDED          = $01000000; // class installer added their own power page
  {$EXTERNALSYM DI_FLAGSEX_POWERPAGE_ADDED}

  DI_FLAGSEX_FILTERSIMILARDRIVERS     = $02000000;  // only include similar drivers in class list
  {$EXTERNALSYM DI_FLAGSEX_FILTERSIMILARDRIVERS}
  DI_FLAGSEX_INSTALLEDDRIVER          = $04000000;  // only add the installed driver to the class or compat
  {$EXTERNALSYM DI_FLAGSEX_INSTALLEDDRIVER}
                                                    // driver list.  Used in calls to SetupDiBuildDriverInfoList
  DI_FLAGSEX_NO_CLASSLIST_NODE_MERGE  = $08000000;  // Don't remove identical driver nodes from the class list
  {$EXTERNALSYM DI_FLAGSEX_NO_CLASSLIST_NODE_MERGE}
  DI_FLAGSEX_ALTPLATFORM_DRVSEARCH    = $10000000;  // Build driver list based on alternate platform information
  {$EXTERNALSYM DI_FLAGSEX_ALTPLATFORM_DRVSEARCH}
                                                    // specified in associated file queue
  DI_FLAGSEX_RESTART_DEVICE_ONLY      = $20000000;  // only restart the device drivers are being installed on as
  {$EXTERNALSYM DI_FLAGSEX_RESTART_DEVICE_ONLY}

//
// Class installation parameters header.  This must be the first field of any
// class install parameter structure.  The InstallFunction field must be set to
// the function code corresponding to the structure, and the cbSize field must
// be set to the size of the header structure.  E.g.,
//
// SP_ENABLECLASS_PARAMS EnableClassParams;
//
// EnableClassParams.ClassInstallHeader.cbSize = sizeof(SP_CLASSINSTALL_HEADER);
// EnableClassParams.ClassInstallHeader.InstallFunction = DIF_ENABLECLASS;
//
type
  PSPClassInstallHeader = ^TSPClassInstallHeader;
  SP_CLASSINSTALL_HEADER = packed record
    cbSize: DWORD;
    InstallFunction: DI_FUNCTION;
  end;
  {$EXTERNALSYM SP_CLASSINSTALL_HEADER}
  TSPClassInstallHeader = SP_CLASSINSTALL_HEADER;

//
// Structure corresponding to a DIF_ENABLECLASS install function.
//
  PSPEnableClassParams = ^TSPEnableClassParams;
  SP_ENABLECLASS_PARAMS = packed record
    ClassInstallHeader: TSPClassInstallHeader;
    ClassGuid: TGUID;
    EnableMessage: DWORD;
  end;
  {$EXTERNALSYM SP_ENABLECLASS_PARAMS}
  TSPEnableClassParams = SP_ENABLECLASS_PARAMS;

const
  ENABLECLASS_QUERY   = 0;
  {$EXTERNALSYM ENABLECLASS_QUERY}
  ENABLECLASS_SUCCESS = 1;
  {$EXTERNALSYM ENABLECLASS_SUCCESS}
  ENABLECLASS_FAILURE = 2;
  {$EXTERNALSYM ENABLECLASS_FAILURE}

//
// Structure corresponding to a DIF_MOVEDEVICE install function.
//
type
  PSPMoveDevParams = ^TSPMoveDevParams;
  SP_MOVEDEV_PARAMS = packed record
    ClassInstallHeader: TSPClassInstallHeader;
    SourceDeviceInfoData: TSPDevInfoData;
  end;
  {$EXTERNALSYM SP_MOVEDEV_PARAMS}
  TSPMoveDevParams = SP_MOVEDEV_PARAMS;
  {$IFDEF COMPILER11_UP}
  {$EXTERNALSYM PSPMoveDevParams}
  {$EXTERNALSYM TSPMoveDevParams}
  {$ENDIF COMPILER11_UP}

//
// Values indicating a change in a device's state
//
const
  DICS_ENABLE     = $00000001;
  {$EXTERNALSYM DICS_ENABLE}
  DICS_DISABLE    = $00000002;
  {$EXTERNALSYM DICS_DISABLE}
  DICS_PROPCHANGE = $00000003;
  {$EXTERNALSYM DICS_PROPCHANGE}
  DICS_START      = $00000004;
  {$EXTERNALSYM DICS_START}
  DICS_STOP       = $00000005;
  {$EXTERNALSYM DICS_STOP}

//
// Values specifying the scope of a device property change
//
  DICS_FLAG_GLOBAL         = $00000001;  // make change in all hardware profiles
  {$EXTERNALSYM DICS_FLAG_GLOBAL}
  DICS_FLAG_CONFIGSPECIFIC = $00000002;  // make change in specified profile only
  {$EXTERNALSYM DICS_FLAG_CONFIGSPECIFIC}
  DICS_FLAG_CONFIGGENERAL  = $00000004;  // 1 or more hardware profile-specific
  {$EXTERNALSYM DICS_FLAG_CONFIGGENERAL} // changes to follow.

//
// Structure corresponding to a DIF_PROPERTYCHANGE install function.
//
type
  PSPPropChangeParams = ^TSPPropChangeParams;
  SP_PROPCHANGE_PARAMS = packed record
    ClassInstallHeader: TSPClassInstallHeader;
    StateChange: DWORD;
    Scope: DWORD;
    HwProfile: DWORD;
  end;
  {$EXTERNALSYM SP_PROPCHANGE_PARAMS}
  TSPPropChangeParams = SP_PROPCHANGE_PARAMS;

//
// Structure corresponding to a DIF_REMOVE install function.
//
  PSPRemoveDeviceParams = ^TSPRemoveDeviceParams;
  SP_REMOVEDEVICE_PARAMS = packed record
    ClassInstallHeader: TSPClassInstallHeader;
    Scope: DWORD;
    HwProfile: DWORD;
  end;
  {$EXTERNALSYM SP_REMOVEDEVICE_PARAMS}
  TSPRemoveDeviceParams = SP_REMOVEDEVICE_PARAMS;

const
  DI_REMOVEDEVICE_GLOBAL         = $00000001;
  {$EXTERNALSYM DI_REMOVEDEVICE_GLOBAL}
  DI_REMOVEDEVICE_CONFIGSPECIFIC = $00000002;
  {$EXTERNALSYM DI_REMOVEDEVICE_CONFIGSPECIFIC}

//
// Structure corresponding to a DIF_UNREMOVE install function.
//
type
  PSPUnremoveDeviceParams = ^TSPUnremoveDeviceParams;
  SP_UNREMOVEDEVICE_PARAMS = packed record
    ClassInstallHeader: TSPClassInstallHeader;
    Scope: DWORD;
    HwProfile: DWORD;
  end;
  {$EXTERNALSYM SP_UNREMOVEDEVICE_PARAMS}
  TSPUnremoveDeviceParams = SP_UNREMOVEDEVICE_PARAMS;

const
  DI_UNREMOVEDEVICE_CONFIGSPECIFIC = $00000002;
  {$EXTERNALSYM DI_UNREMOVEDEVICE_CONFIGSPECIFIC}

//
// Structure corresponding to a DIF_SELECTDEVICE install function.
//
type
  PSPSelectDeviceParamsA = ^TSPSelectDeviceParamsA;
  PSPSelectDeviceParamsW = ^TSPSelectDeviceParamsW;
  SP_SELECTDEVICE_PARAMS_A = packed record
    ClassInstallHeader: TSPClassInstallHeader;
    Title: array [0..MAX_TITLE_LEN - 1] of AnsiChar;
    Instructions: array [0..MAX_INSTRUCTION_LEN - 1] of AnsiChar;
    ListLabel: array [0..MAX_LABEL_LEN - 1] of AnsiChar;
    SubTitle: array [0..MAX_SUBTITLE_LEN - 1] of AnsiChar;
    Reserved: array [0..1] of Byte; // DWORD size alignment
  end;
  {$EXTERNALSYM SP_SELECTDEVICE_PARAMS_A}
  SP_SELECTDEVICE_PARAMS_W = packed record
    ClassInstallHeader: TSPClassInstallHeader;
    Title: array [0..MAX_TITLE_LEN - 1] of WideChar;
    Instructions: array [0..MAX_INSTRUCTION_LEN - 1] of WideChar;
    ListLabel: array [0..MAX_LABEL_LEN - 1] of WideChar;
    SubTitle: array [0..MAX_SUBTITLE_LEN - 1] of WideChar;
    Reserved: array [0..1] of Byte; // DWORD size alignment
  end;
  {$EXTERNALSYM SP_SELECTDEVICE_PARAMS_W}
  TSPSelectdeviceParamsA = SP_SELECTDEVICE_PARAMS_A;
  TSPSelectdeviceParamsW = SP_SELECTDEVICE_PARAMS_W;
  {$IFDEF UNICODE}
  TSPSelectdeviceParams = TSPSelectdeviceParamsW;
  PSPSelectDeviceParams = PSPSelectDeviceParamsW;
  {$ELSE}
  TSPSelectdeviceParams = TSPSelectdeviceParamsA;
  PSPSelectDeviceParams = PSPSelectDeviceParamsA;
  {$ENDIF UNICODE}

//
// Callback routine for giving progress notification during detection
//
  PDetectProgressNotify = function(ProgressNotifyParam: Pointer; DetectComplete: DWORD): BOOL; stdcall;

// where:
//     ProgressNotifyParam - value supplied by caller requesting detection.
//     DetectComplete - Percent completion, to be incremented by class
//                      installer, as it steps thru its detection.
//
// Return Value - If TRUE, then detection is cancelled.  Allows caller
//                requesting detection to stop detection asap.
//

//
// Structure corresponding to a DIF_DETECT install function.
//
  PSPDetectDeviceParams = ^TSPDetectDeviceParams;
  SP_DETECTDEVICE_PARAMS = packed record
    ClassInstallHeader: TSPClassInstallHeader;
    DetectProgressNotify: PDetectProgressNotify;
    ProgressNotifyParam: Pointer;
  end;
  {$EXTERNALSYM SP_DETECTDEVICE_PARAMS}
  TSPDetectDeviceParams = SP_DETECTDEVICE_PARAMS;

//
// 'Add New Device' installation wizard structure (backward-compatibility
// only--respond to DIF_NEWDEVICEWIZARD_* requests instead).
//
// Structure corresponding to a DIF_INSTALLWIZARD install function.
// (NOTE: This structure is also applicable for DIF_DESTROYWIZARDDATA,
// but DIF_INSTALLWIZARD is the associated function code in the class
// installation parameter structure in both cases.)
//
// Define maximum number of dynamic wizard pages that can be added to
// hardware install wizard.
//
const
  MAX_INSTALLWIZARD_DYNAPAGES = 20;
  {$EXTERNALSYM MAX_INSTALLWIZARD_DYNAPAGES}

type
  PSPInstallWizardData = ^TSPInstallWizardData;
  SP_INSTALLWIZARD_DATA = packed record
    ClassInstallHeader: TSPClassInstallHeader;
    Flags: DWORD;
    DynamicPages: array [0..MAX_INSTALLWIZARD_DYNAPAGES - 1] of HPROPSHEETPAGE;
    NumDynamicPages: DWORD;
    DynamicPageFlags: DWORD;
    PrivateFlags: DWORD;
    PrivateData: LPARAM;
    hwndWizardDlg: HWND;
  end;
  {$EXTERNALSYM SP_INSTALLWIZARD_DATA}
  TSPInstallWizardData = SP_INSTALLWIZARD_DATA;

//
// SP_INSTALLWIZARD_DATA.Flags values
//
const
  NDW_INSTALLFLAG_DIDFACTDEFS        = $00000001;
  {$EXTERNALSYM NDW_INSTALLFLAG_DIDFACTDEFS}
  NDW_INSTALLFLAG_HARDWAREALLREADYIN = $00000002;
  {$EXTERNALSYM NDW_INSTALLFLAG_HARDWAREALLREADYIN}
  NDW_INSTALLFLAG_NEEDRESTART        = DI_NEEDRESTART;
  {$EXTERNALSYM NDW_INSTALLFLAG_NEEDRESTART}
  NDW_INSTALLFLAG_NEEDREBOOT         = DI_NEEDREBOOT;
  {$EXTERNALSYM NDW_INSTALLFLAG_NEEDREBOOT}
  NDW_INSTALLFLAG_NEEDSHUTDOWN       = $00000200;
  {$EXTERNALSYM NDW_INSTALLFLAG_NEEDSHUTDOWN}
  NDW_INSTALLFLAG_EXPRESSINTRO       = $00000400;
  {$EXTERNALSYM NDW_INSTALLFLAG_EXPRESSINTRO}
  NDW_INSTALLFLAG_SKIPISDEVINSTALLED = $00000800;
  {$EXTERNALSYM NDW_INSTALLFLAG_SKIPISDEVINSTALLED}
  NDW_INSTALLFLAG_NODETECTEDDEVS     = $00001000;
  {$EXTERNALSYM NDW_INSTALLFLAG_NODETECTEDDEVS}
  NDW_INSTALLFLAG_INSTALLSPECIFIC    = $00002000;
  {$EXTERNALSYM NDW_INSTALLFLAG_INSTALLSPECIFIC}
  NDW_INSTALLFLAG_SKIPCLASSLIST      = $00004000;
  {$EXTERNALSYM NDW_INSTALLFLAG_SKIPCLASSLIST}
  NDW_INSTALLFLAG_CI_PICKED_OEM      = $00008000;
  {$EXTERNALSYM NDW_INSTALLFLAG_CI_PICKED_OEM}
  NDW_INSTALLFLAG_PCMCIAMODE         = $00010000;
  {$EXTERNALSYM NDW_INSTALLFLAG_PCMCIAMODE}
  NDW_INSTALLFLAG_PCMCIADEVICE       = $00020000;
  {$EXTERNALSYM NDW_INSTALLFLAG_PCMCIADEVICE}
  NDW_INSTALLFLAG_USERCANCEL         = $00040000;
  {$EXTERNALSYM NDW_INSTALLFLAG_USERCANCEL}
  NDW_INSTALLFLAG_KNOWNCLASS         = $00080000;
  {$EXTERNALSYM NDW_INSTALLFLAG_KNOWNCLASS}

//
// SP_INSTALLWIZARD_DATA.DynamicPageFlags values
//
// This flag is set if a Class installer has added pages to the install wizard.
//
  DYNAWIZ_FLAG_PAGESADDED = $00000001;
  {$EXTERNALSYM DYNAWIZ_FLAG_PAGESADDED}

//
// Set this flag if you jump to the analyze page, and want it to
// handle conflicts for you.  NOTE.  You will not get control back
// in the event of a conflict if you set this flag.
//
  DYNAWIZ_FLAG_ANALYZE_HANDLECONFLICT = $00000008;
  {$EXTERNALSYM DYNAWIZ_FLAG_ANALYZE_HANDLECONFLICT}

//
// The following flags are not used by the Windows NT hardware wizard.
//
  DYNAWIZ_FLAG_INSTALLDET_NEXT = $00000002;
  {$EXTERNALSYM DYNAWIZ_FLAG_INSTALLDET_NEXT}
  DYNAWIZ_FLAG_INSTALLDET_PREV = $00000004;
  {$EXTERNALSYM DYNAWIZ_FLAG_INSTALLDET_PREV}

//
// Reserve a range of wizard page resource IDs for internal use.  Some of
// these IDs are for use by class installers that respond to the obsolete
// DIF_INSTALLWIZARD/DIF_DESTROYWIZARDDATA messages.  These IDs are listed
// below.
//
  MIN_IDD_DYNAWIZ_RESOURCE_ID = 10000;
  {$EXTERNALSYM MIN_IDD_DYNAWIZ_RESOURCE_ID}
  MAX_IDD_DYNAWIZ_RESOURCE_ID = 11000;
  {$EXTERNALSYM MAX_IDD_DYNAWIZ_RESOURCE_ID}

//
// Define wizard page resource IDs to be used when adding custom pages to the
// hardware install wizard via DIF_INSTALLWIZARD.  Pages marked with
// (CLASS INSTALLER PROVIDED) _must_ be supplied by the class installer if it
// responds to the DIF_INSTALLWIZARD request.
//

//
// Resource ID for the first page that the install wizard will go to after
// adding the class installer pages.  (CLASS INSTALLER PROVIDED)
//
  IDD_DYNAWIZ_FIRSTPAGE = 10000;
  {$EXTERNALSYM IDD_DYNAWIZ_FIRSTPAGE}

//
// Resource ID for the page that the Select Device page will go back to.
// (CLASS INSTALLER PROVIDED)
//
  IDD_DYNAWIZ_SELECT_PREVPAGE = 10001;
  {$EXTERNALSYM IDD_DYNAWIZ_SELECT_PREVPAGE}

//
// Resource ID for the page that the Select Device page will go forward to.
// (CLASS INSTALLER PROVIDED)
//
  IDD_DYNAWIZ_SELECT_NEXTPAGE = 10002;
  {$EXTERNALSYM IDD_DYNAWIZ_SELECT_NEXTPAGE}

//
// Resource ID for the page that the Analyze dialog should go back to
// This will only be used in the event that there is a problem, and the user
// selects Back from the analyze proc. (CLASS INSTALLER PROVIDED)
//
  IDD_DYNAWIZ_ANALYZE_PREVPAGE = 10003;
  {$EXTERNALSYM IDD_DYNAWIZ_ANALYZE_PREVPAGE}

//
// Resource ID for the page that the Analyze dialog should go to if it
// continues from the analyze proc. (CLASS INSTALLER PROVIDED)
//
  IDD_DYNAWIZ_ANALYZE_NEXTPAGE = 10004;
  {$EXTERNALSYM IDD_DYNAWIZ_ANALYZE_NEXTPAGE}

//
// Resource ID of the hardware install wizard's select device page.
// This ID can be used to go directly to the hardware install wizard's select
// device page.  (This is the resource ID of the Select Device wizard page
// retrieved via SetupDiGetWizardPage when SPWPT_SELECTDEVICE is the requested
// PageType.)
//
  IDD_DYNAWIZ_SELECTDEV_PAGE = 10009;
  {$EXTERNALSYM IDD_DYNAWIZ_SELECTDEV_PAGE}

//
// Resource ID of the hardware install wizard's device analysis page.
// This ID can be use to go directly to the hardware install wizard's analysis
// page.
//
  IDD_DYNAWIZ_ANALYZEDEV_PAGE = 10010;
  {$EXTERNALSYM IDD_DYNAWIZ_ANALYZEDEV_PAGE}

//
// Resource ID of the hardware install wizard's install detected devices page.
// This ID can be use to go directly to the hardware install wizard's install
// detected devices page.
//
  IDD_DYNAWIZ_INSTALLDETECTEDDEVS_PAGE = 10011;
  {$EXTERNALSYM IDD_DYNAWIZ_INSTALLDETECTEDDEVS_PAGE}

//
// Resource ID of the hardware install wizard's select class page.
// This ID can be use to go directly to the hardware install wizard's select
// class page.
//
  IDD_DYNAWIZ_SELECTCLASS_PAGE = 10012;
  {$EXTERNALSYM IDD_DYNAWIZ_SELECTCLASS_PAGE}

//
// The following class installer-provided wizard page resource IDs are not used
// by the Windows NT hardware wizard.
//
  IDD_DYNAWIZ_INSTALLDETECTED_PREVPAGE = 10006;
  {$EXTERNALSYM IDD_DYNAWIZ_INSTALLDETECTED_PREVPAGE}
  IDD_DYNAWIZ_INSTALLDETECTED_NEXTPAGE = 10007;
  {$EXTERNALSYM IDD_DYNAWIZ_INSTALLDETECTED_NEXTPAGE}
  IDD_DYNAWIZ_INSTALLDETECTED_NODEVS   = 10008;
  {$EXTERNALSYM IDD_DYNAWIZ_INSTALLDETECTED_NODEVS}

//
// Structure corresponding to the following DIF_NEWDEVICEWIZARD_* install
// functions:
//
//     DIF_NEWDEVICEWIZARD_PRESELECT
//     DIF_NEWDEVICEWIZARD_SELECT
//     DIF_NEWDEVICEWIZARD_PREANALYZE
//     DIF_NEWDEVICEWIZARD_POSTANALYZE
//     DIF_NEWDEVICEWIZARD_FINISHINSTALL
//
type
  PSPNewDeviceWizardData = ^TSPNewDeviceWizardData;
  SP_NEWDEVICEWIZARD_DATA = packed record
    ClassInstallHeader: TSPClassInstallHeader;
    Flags: DWORD; // presently unused--must be zero.
    DynamicPages: array [0..MAX_INSTALLWIZARD_DYNAPAGES - 1] of HPROPSHEETPAGE;
    NumDynamicPages: DWORD;
    hwndWizardDlg: HWND;
  end;
  {$EXTERNALSYM SP_NEWDEVICEWIZARD_DATA}
  TSPNewDeviceWizardData = SP_NEWDEVICEWIZARD_DATA;

//
// Structure corresponding to the DIF_TROUBLESHOOTER install function
//
  PSPTroubleShooterParamsA = ^TSPTroubleShooterParamsA;
  PSPTroubleShooterParamsW = ^TSPTroubleShooterParamsW;
  SP_TROUBLESHOOTER_PARAMS_A = packed record
    ClassInstallHeader: TSPClassInstallHeader;
    ChmFile: array [0..MAX_PATH - 1] of AnsiChar;
    HtmlTroubleShooter: array [0..MAX_PATH - 1] of AnsiChar;
  end;
  {$EXTERNALSYM SP_TROUBLESHOOTER_PARAMS_A}
  SP_TROUBLESHOOTER_PARAMS_W = packed record
    ClassInstallHeader: TSPClassInstallHeader;
    ChmFile: array [0..MAX_PATH - 1] of WideChar;
    HtmlTroubleShooter: array [0..MAX_PATH - 1] of WideChar;
  end;
  {$EXTERNALSYM SP_TROUBLESHOOTER_PARAMS_W}
  TSPTroubleShooterParamsA = SP_TROUBLESHOOTER_PARAMS_A;
  TSPTroubleShooterParamsW = SP_TROUBLESHOOTER_PARAMS_W;
  {$IFDEF UNICODE}
  TSPTroubleShooterParams = TSPTroubleShooterParamsW;
  PSPTroubleShooterParams = PSPTroubleShooterParamsW;
  {$ELSE}
  TSPTroubleShooterParams = TSPTroubleShooterParamsA;
  PSPTroubleShooterParams = PSPTroubleShooterParamsA;
  {$ENDIF UNICODE}

//
// Structure corresponding to the DIF_POWERMESSAGEWAKE install function
//
  PSPPowerMessageWakeParamsA = ^TSPPowerMessageWakeParamsA;
  PSPPowerMessageWakeParamsW = ^TSPPowerMessageWakeParamsW;
  SP_POWERMESSAGEWAKE_PARAMS_A = packed record
    ClassInstallHeader: TSPClassInstallHeader;
    PowerMessageWake: array [0..(LINE_LEN * 2) - 1] of AnsiChar;
  end;
  {$EXTERNALSYM SP_POWERMESSAGEWAKE_PARAMS_A}
  SP_POWERMESSAGEWAKE_PARAMS_W = packed record
    ClassInstallHeader: TSPClassInstallHeader;
    PowerMessageWake: array [0..(LINE_LEN * 2) - 1] of WideChar;
  end;
  {$EXTERNALSYM SP_POWERMESSAGEWAKE_PARAMS_W}
  TSPPowerMessageWakeParamsA = SP_POWERMESSAGEWAKE_PARAMS_A;
  TSPPowerMessageWakeParamsW = SP_POWERMESSAGEWAKE_PARAMS_W;
  {$IFDEF UNICODE}
  TSPPowerMessageWakeParams = TSPPowerMessageWakeParamsW;
  PSPPowerMessageWakeParams = PSPPowerMessageWakeParamsW;
  {$ELSE}
  TSPPowerMessageWakeParams = TSPPowerMessageWakeParamsA;
  PSPPowerMessageWakeParams = PSPPowerMessageWakeParamsA;
  {$ENDIF UNICODE}

//
// Driver information structure (member of a driver info list that may be associated
// with a particular device instance, or (globally) with a device information set)
//
  PSPDrvInfoDataV2A = ^TSPDrvInfoDataV2A;
  PSPDrvInfoDataV2W = ^TSPDrvInfoDataV2W;
  SP_DRVINFO_DATA_V2_A = packed record
    cbSize: DWORD;
    DriverType: DWORD;
    Reserved: ULONG_PTR;
    Description: array [0..LINE_LEN - 1] of AnsiChar;
    MfgName: array [0..LINE_LEN - 1] of AnsiChar;
    ProviderName: array [0..LINE_LEN - 1] of AnsiChar;
    DriverDate: TFileTime;
    DriverVersion: Int64;
  end;
  {$EXTERNALSYM SP_DRVINFO_DATA_V2_A}
  SP_DRVINFO_DATA_V2_W = packed record
    cbSize: DWORD;
    DriverType: DWORD;
    Reserved: ULONG_PTR;
    Description: array [0..LINE_LEN - 1] of WideChar;
    MfgName: array [0..LINE_LEN - 1] of WideChar;
    ProviderName: array [0..LINE_LEN - 1] of WideChar;
    DriverDate: TFileTime;
    DriverVersion: Int64;
  end;
  {$EXTERNALSYM SP_DRVINFO_DATA_V2_W}
  TSPDrvInfoDataV2A = SP_DRVINFO_DATA_V2_A;
  TSPDrvInfoDataV2W = SP_DRVINFO_DATA_V2_W;
  {$IFDEF UNICODE}
  TSPDrvInfoDataV2 = TSPDrvInfoDataV2W;
  PSPDrvInfoDataV2 = PSPDrvInfoDataV2W;
  {$ELSE}
  TSPDrvInfoDataV2 = TSPDrvInfoDataV2A;
  PSPDrvInfoDataV2 = PSPDrvInfoDataV2A;
  {$ENDIF UNICODE}

//
// Version 1 of the SP_DRVINFO_DATA structures, used only for compatibility
// with Windows NT 4.0/Windows 95/98 SETUPAPI.DLL
//
  PSPDrvInfoDataV1A = ^TSPDrvInfoDataV1A;
  PSPDrvInfoDataV1W = ^TSPDrvInfoDataV1W;
  SP_DRVINFO_DATA_V1_A = packed record
    cbSize: DWORD;
    DriverType: DWORD;
    Reserved: ULONG_PTR;
    Description: array [0..LINE_LEN - 1] of AnsiChar;
    MfgName: array [0..LINE_LEN - 1] of AnsiChar;
    ProviderName: array [0..LINE_LEN - 1] of AnsiChar;
  end;
  {$EXTERNALSYM SP_DRVINFO_DATA_V1_A}
  SP_DRVINFO_DATA_V1_W = packed record
    cbSize: DWORD;
    DriverType: DWORD;
    Reserved: ULONG_PTR;
    Description: array [0..LINE_LEN - 1] of WideChar;
    MfgName: array [0..LINE_LEN - 1] of WideChar;
    ProviderName: array [0..LINE_LEN - 1] of WideChar;
  end;
  {$EXTERNALSYM SP_DRVINFO_DATA_V1_W}
  TSPDrvInfoDataV1A = SP_DRVINFO_DATA_V1_A;
  TSPDrvInfoDataV1W = SP_DRVINFO_DATA_V1_W;
  {$IFDEF UNICODE}
  TSPDrvInfoDataV1 = TSPDrvInfoDataV1W;
  PSPDrvInfoDataV1 = PSPDrvInfoDataV1W;
  {$ELSE}
  TSPDrvInfoDataV1 = TSPDrvInfoDataV1A;
  PSPDrvInfoDataV1 = PSPDrvInfoDataV1A;
  {$ENDIF UNICODE}

  {$IFDEF WIN2000_UP}
  TSPDrvInfoDataA = TSPDrvInfoDataV2A;
  TSPDrvInfoDataW = TSPDrvInfoDataV2W;
  PSPDrvInfoDataA = PSPDrvInfoDataV2A;
  PSPDrvInfoDataW = PSPDrvInfoDataV2W;
  {$IFDEF UNICODE}
  TSPDrvInfoData = TSPDrvInfoDataW;
  PSPDrvInfoData = PSPDrvInfoDataW;
  {$ELSE}
  TSPDrvInfoData = TSPDrvInfoDataA;
  PSPDrvInfoData = PSPDrvInfoDataA;
  {$ENDIF UNICODE}
  {$ELSE}
  TSPDrvInfoDataA = TSPDrvInfoDataV1A;
  TSPDrvInfoDataW = TSPDrvInfoDataV1W;
  PSPDrvInfoDataA = PSPDrvInfoDataV1A;
  PSPDrvInfoDataW = PSPDrvInfoDataV1W;
  {$IFDEF UNICODE}
  TSPDrvInfoData = TSPDrvInfoDataW;
  PSPDrvInfoData = PSPDrvInfoDataW;
  {$ELSE}
  TSPDrvInfoData = TSPDrvInfoDataA;
  PSPDrvInfoData = PSPDrvInfoDataA;
  {$ENDIF UNICODE}
  {$ENDIF WIN2000_UP}

//
// Driver information details structure (provides detailed information about a
// particular driver information structure)
//
  PSPDrvInfoDetailDataA = ^TSPDrvInfoDetailDataA;
  PSPDrvInfoDetailDataW = ^TSPDrvInfoDetailDataW;
  SP_DRVINFO_DETAIL_DATA_A = packed record
    cbSize: DWORD;
    InfDate: TFileTime;
    CompatIDsOffset: DWORD;
    CompatIDsLength: DWORD;
    Reserved: ULONG_PTR;
    SectionName: array [0..LINE_LEN - 1] of AnsiChar;
    InfFileName: array [0..MAX_PATH - 1] of AnsiChar;
    DrvDescription: array [0..LINE_LEN - 1] of AnsiChar;
    HardwareID: array [0..ANYSIZE_ARRAY - 1] of AnsiChar;
  end;
  {$EXTERNALSYM SP_DRVINFO_DETAIL_DATA_A}
  SP_DRVINFO_DETAIL_DATA_W = packed record
    cbSize: DWORD;
    InfDate: TFileTime;
    CompatIDsOffset: DWORD;
    CompatIDsLength: DWORD;
    Reserved: ULONG_PTR;
    SectionName: array [0..LINE_LEN - 1] of WideChar;
    InfFileName: array [0..MAX_PATH - 1] of WideChar;
    DrvDescription: array [0..LINE_LEN - 1] of WideChar;
    HardwareID: array [0..ANYSIZE_ARRAY - 1] of WideChar;
  end;
  {$EXTERNALSYM SP_DRVINFO_DETAIL_DATA_W}
  TSPDrvInfoDetailDataA = SP_DRVINFO_DETAIL_DATA_A;
  TSPDrvInfoDetailDataW = SP_DRVINFO_DETAIL_DATA_W;
  {$IFDEF UNICODE}
  TSPDrvInfoDetailData = TSPDrvInfoDetailDataW;
  PSPDrvInfoDetailData = PSPDrvInfoDetailDataW;
  {$ELSE}
  TSPDrvInfoDetailData = TSPDrvInfoDetailDataA;
  PSPDrvInfoDetailData = PSPDrvInfoDetailDataA;
  {$ENDIF UNICODE}

//
// Driver installation parameters (associated with a particular driver
// information element)
//
  PSPDrvInstallParams = ^TSPDrvInstallParams;
  SP_DRVINSTALL_PARAMS = packed record
    cbSize: DWORD;
    Rank: DWORD;
    Flags: DWORD;
    PrivateData: DWORD_PTR;
    Reserved: DWORD;
  end;
  {$EXTERNALSYM SP_DRVINSTALL_PARAMS}
  TSPDrvInstallParams = SP_DRVINSTALL_PARAMS;

//
// SP_DRVINSTALL_PARAMS.Flags values
//
const
  DNF_DUPDESC           = $00000001; // Multiple providers have same desc
  {$EXTERNALSYM DNF_DUPDESC}
  DNF_OLDDRIVER         = $00000002; // Driver node specifies old/current driver
  {$EXTERNALSYM DNF_OLDDRIVER}
  DNF_EXCLUDEFROMLIST   = $00000004; // If set, this driver node will not be
  {$EXTERNALSYM DNF_EXCLUDEFROMLIST} // displayed in any driver select dialogs.
  DNF_NODRIVER          = $00000008; // if we want to install no driver
  {$EXTERNALSYM DNF_NODRIVER}        // (e.g no mouse drv)
  DNF_LEGACYINF         = $00000010; // this driver node comes from an old-style INF
  {$EXTERNALSYM DNF_LEGACYINF}
  DNF_CLASS_DRIVER      = $00000020; // Driver node represents a class driver
  {$EXTERNALSYM DNF_CLASS_DRIVER}
  DNF_COMPATIBLE_DRIVER = $00000040; // Driver node represents a compatible driver
  {$EXTERNALSYM DNF_COMPATIBLE_DRIVER}
  DNF_INET_DRIVER       = $00000080; // Driver comes from an internet source
  {$EXTERNALSYM DNF_INET_DRIVER}
  DNF_UNUSED1           = $00000100;
  {$EXTERNALSYM DNF_UNUSED1}
  DNF_INDEXED_DRIVER    = $00000200; // Driver is contained in the Windows Driver Index
  {$EXTERNALSYM DNF_INDEXED_DRIVER}
  DNF_OLD_INET_DRIVER   = $00000400; // Driver came from the Internet, but we don't currently
  {$EXTERNALSYM DNF_OLD_INET_DRIVER} // have access to it's source files.  Never attempt to
                                     // install a driver with this flag!
  DNF_BAD_DRIVER        = $00000800; // Driver node should not be used at all
  {$EXTERNALSYM DNF_BAD_DRIVER}
  DNF_DUPPROVIDER       = $00001000; // Multiple drivers have the same provider and desc
  {$EXTERNALSYM DNF_DUPPROVIDER}

  DNF_INF_IS_SIGNED     = $00002000;  // If file is digitally signed
  {$EXTERNALSYM DNF_INF_IS_SIGNED}
  DNF_OEM_F6_INF        = $00004000;  // INF specified from F6 during textmode setup.
  {$EXTERNALSYM DNF_OEM_F6_INF}
  DNF_DUPDRIVERVER      = $00008000;  // Multipe drivers have the same desc, provider, and DriverVer values
  {$EXTERNALSYM DNF_DUPDRIVERVER}
  DNF_BASIC_DRIVER      = $00010000;  // Driver provides basic functionality, but should
  {$EXTERNALSYM DNF_BASIC_DRIVER}
                                      // not be chosen if other signed drivers exist.
//
// Rank values (the lower the Rank number, the better the Rank)
//
  DRIVER_HARDWAREID_RANK = $00000FFF;   // Any rank less than or equal to
  {$EXTERNALSYM DRIVER_HARDWAREID_RANK} // this value is a trusted
                                        // HardwareID match

  DRIVER_COMPATID_RANK   = $00003FFF;  // Any rank less than or equal to
  {$EXTERNALSYM DRIVER_COMPATID_RANK}  // this (and greater than
                                       // DRIVER_HARDWAREID_RANK) is a
                                       // trusted CompatibleID match

  DRIVER_UNTRUSTED_RANK  = $00008000;  // Any rank with this bit set is an
  {$EXTERNALSYM DRIVER_UNTRUSTED_RANK} // "untrusted" rank, meaning that
                                       // the INF was unsigned.

  DRIVER_UNTRUSTED_HARDWAREID_RANK   = $00008FFF;  // Any rank less than or equal to
  {$EXTERNALSYM DRIVER_UNTRUSTED_HARDWAREID_RANK}  // this value (and greater than
                                                   // or equal to DRIVER_UNTRUSTED_RANK)
                                                   // is an untrusted HardwareID match

  DRIVER_UNTRUSTED_COMPATID_RANK     = $0000BFFF;  // Any rank less than or equal to
  {$EXTERNALSYM DRIVER_UNTRUSTED_COMPATID_RANK}    // this value (and greater than
                                                   // DRIVER_UNTRUSTED_HARDWAREID_RANK)
                                                   // is an untrusted CompatibleID match

  DRIVER_W9X_SUSPECT_RANK            = $0000C000; // Any rank that is greater than
  {$EXTERNALSYM DRIVER_W9X_SUSPECT_RANK}          // or equal to this value, and lesser
                                                  // than or equal to 0xFFFF is suspected
                                                  // to be a Win9x-only driver, because
                                                  // (a) it isn't signed, and (b) there
                                                  // is no NT-specific decoration to
                                                  // explicitly indicate that the INF
                                                  // supports Windows NT/200x

  DRIVER_W9X_SUSPECT_HARDWAREID_RANK = $0000CFFF; // Any rank less than or equal to this
  {$EXTERNALSYM DRIVER_W9X_SUSPECT_HARDWAREID_RANK} // (and greater than or equal to
                                                  // DRIVER_W9X_SUSPECT_RANK) is a
                                                  // hardware ID match suspected of being
                                                  // only for Windows 9x platforms.

  DRIVER_W9X_SUSPECT_COMPATID_RANK   = $0000FFFF; // Any rank less than or equal to
  {$EXTERNALSYM DRIVER_W9X_SUSPECT_COMPATID_RANK} // this (and greater than
                                                  // DRIVER_W9X_SUSPECT_HARDWAREID_RANK)
                                                  // is a compatible ID match suspected
                                                  // of being only for Windows 9x
                                                  // platforms.

//
// Setup callback routine for comparing detection signatures
//
type
  TSPDetsigCmpProc = function(DeviceInfoSet: HDEVINFO; NewDeviceData,
    ExistingDeviceData: PSPDevInfoData; CompareContext: Pointer): DWORD; stdcall;

//
// Define context structure handed to co-installers
//
  PCoInstallerContextData = ^TCoInstallerContextData;
  COINSTALLER_CONTEXT_DATA = packed record
    PostProcessing: BOOL;
    InstallResult: DWORD;
    PrivateData: Pointer;
  end;
  {$EXTERNALSYM COINSTALLER_CONTEXT_DATA}
  TCoInstallerContextData = COINSTALLER_CONTEXT_DATA;

//
// Structure containing class image list information.
//
  PSPClassImageListData = ^TSPClassImageListData;
  SP_CLASSIMAGELIST_DATA = packed record
    cbSize: DWORD;
    ImageList: HIMAGELIST;
    Reserved: ULONG_PTR;
  end;
  {$EXTERNALSYM SP_CLASSIMAGELIST_DATA}
  TSPClassImageListData = SP_CLASSIMAGELIST_DATA;

//
// Structure to be passed as first parameter (LPVOID lpv) to ExtensionPropSheetPageProc
// entry point in setupapi.dll or to "EnumPropPages32" or "BasicProperties32" entry
// points provided by class/device property page providers.  Used to retrieve a handle
// (or, potentially, multiple handles) to property pages for a specified property page type.
//
  PSPPropSheetPageRequest = ^TSPPropSheetPageRequest;
  SP_PROPSHEETPAGE_REQUEST = packed record
    cbSize: DWORD;
    PageRequested: DWORD;
    DeviceInfoSet: HDEVINFO;
    DeviceInfoData: PSPDevInfoData;
  end;
  {$EXTERNALSYM SP_PROPSHEETPAGE_REQUEST}
  TSPPropSheetPageRequest = SP_PROPSHEETPAGE_REQUEST;

//
// Property sheet codes used in SP_PROPSHEETPAGE_REQUEST.PageRequested
//
const
  SPPSR_SELECT_DEVICE_RESOURCES      = 1; // supplied by setupapi.dll
  {$EXTERNALSYM SPPSR_SELECT_DEVICE_RESOURCES}
  SPPSR_ENUM_BASIC_DEVICE_PROPERTIES = 2; // supplied by device's BasicProperties32 provider
  {$EXTERNALSYM SPPSR_ENUM_BASIC_DEVICE_PROPERTIES}
  SPPSR_ENUM_ADV_DEVICE_PROPERTIES   = 3; // supplied by class and/or device's EnumPropPages32 provider
  {$EXTERNALSYM SPPSR_ENUM_ADV_DEVICE_PROPERTIES}

//
// Structure used with SetupGetBackupInformation/SetupSetBackupInformation
//
type
  PSPBackupQueueParamsV2A = ^TSPBackupQueueParamsV2A;
  PSPBackupQueueParamsV2W = ^TSPBackupQueueParamsV2W;
  SP_BACKUP_QUEUE_PARAMS_V2_A = packed record
    cbSize: DWORD;
    FullInfPath: array [0..MAX_PATH - 1] of AnsiChar; // buffer to hold ANSI pathname of INF file
    FilenameOffset: Integer; // offset in CHAR's of filename part (after '\')
    ReinstallInstance: array [0..MAX_PATH - 1] of AnsiChar;  // Instance ID (if present)
  end;
  {$EXTERNALSYM SP_BACKUP_QUEUE_PARAMS_V2_A}
  SP_BACKUP_QUEUE_PARAMS_V2_W = packed record
    cbSize: DWORD;
    FullInfPath: array [0..MAX_PATH - 1] of WideChar;  // buffer to hold ANSI pathname of INF file
    FilenameOffset: Integer; // offset in CHAR's of filename part (after '\')
    ReinstallInstance: array [0..MAX_PATH - 1] of WideChar;  // Instance ID (if present)
  end;
  {$EXTERNALSYM SP_BACKUP_QUEUE_PARAMS_V2_W}
  TSPBackupQueueParamsV2A = SP_BACKUP_QUEUE_PARAMS_V2_A;
  TSPBackupQueueParamsV2W = SP_BACKUP_QUEUE_PARAMS_V2_W;
  {$IFDEF UNICODE}
  TSPBackupQueueParamsV2 = TSPBackupQueueParamsV2W;
  PSPBackupQueueParamsV2 = PSPBackupQueueParamsV2W;
  {$ELSE}
  TSPBackupQueueParamsV2 = TSPBackupQueueParamsV2A;
  PSPBackupQueueParamsV2 = PSPBackupQueueParamsV2A;
  {$ENDIF UNICODE}

  PSPBackupQueueParamsV1A = ^TSPBackupQueueParamsV1A;
  PSPBackupQueueParamsV1W = ^TSPBackupQueueParamsV1W;
  SP_BACKUP_QUEUE_PARAMS_V1_A = packed record
    cbSize: DWORD;
    FullInfPath: array [0..MAX_PATH - 1] of AnsiChar; // buffer to hold ANSI pathname of INF file
    FilenameOffset: Integer; // offset in CHAR's of filename part (after '\')
  end;
  {$EXTERNALSYM SP_BACKUP_QUEUE_PARAMS_V1_A}
  SP_BACKUP_QUEUE_PARAMS_V1_W = packed record
    cbSize: DWORD;
    FullInfPath: array [0..MAX_PATH - 1] of WideChar; // buffer to hold ANSI pathname of INF file
    FilenameOffset: Integer; // offset in CHAR's of filename part (after '\')
  end;
  {$EXTERNALSYM SP_BACKUP_QUEUE_PARAMS_V1_W}
  TSPBackupQueueParamsV1A = SP_BACKUP_QUEUE_PARAMS_V1_A;
  TSPBackupQueueParamsV1W = SP_BACKUP_QUEUE_PARAMS_V1_W;
  {$IFDEF UNICODE}
  TSPBackupQueueParamsV1 = TSPBackupQueueParamsV1W;
  PSPBackupQueueParamsV1 = PSPBackupQueueParamsV1W;
  {$ELSE}
  TSPBackupQueueParamsV1 = TSPBackupQueueParamsV1A;
  PSPBackupQueueParamsV1 = PSPBackupQueueParamsV1A;
  {$ENDIF UNICODE}

  {$IFDEF USE_SP_BACKUP_QUEUE_PARAMS_V1}
  TSPBackupQueueParamsA = TSPBackupQueueParamsV1A;
  TSPBackupQueueParamsW = TSPBackupQueueParamsV1W;
  TSPBackupQueueParams = TSPBackupQueueParamsV1;
  PSPBackupQueueParamsA = PSPBackupQueueParamsV1A;
  PSPBackupQueueParamsW = PSPBackupQueueParamsV1W;
  PSPBackupQueueParams = PSPBackupQueueParamsV1;
  {$ELSE}
  TSPBackupQueueParamsA = TSPBackupQueueParamsV2A;
  TSPBackupQueueParamsW = TSPBackupQueueParamsV2W;
  TSPBackupQueueParams = TSPBackupQueueParamsV2;
  PSPBackupQueueParamsA = PSPBackupQueueParamsV2A;
  PSPBackupQueueParamsW = PSPBackupQueueParamsV2W;
  PSPBackupQueueParams = PSPBackupQueueParamsV2;
  {$ENDIF USE_SP_BACKUP_QUEUE_PARAMS_V1}

//
// Setupapi-specific error codes
//
// Inf parse outcomes
//
const
  APPLICATION_ERROR_MASK = DWORD($20000000); // from WINNT.h
  {$EXTERNALSYM APPLICATION_ERROR_MASK}
  ERROR_SEVERITY_ERROR   = DWORD($C0000000); // from WINNT.h
  {$EXTERNALSYM ERROR_SEVERITY_ERROR}

  ERROR_EXPECTED_SECTION_NAME       = DWORD(APPLICATION_ERROR_MASK or ERROR_SEVERITY_ERROR or 0);
  {$EXTERNALSYM ERROR_EXPECTED_SECTION_NAME}
  ERROR_BAD_SECTION_NAME_LINE       = DWORD(APPLICATION_ERROR_MASK or ERROR_SEVERITY_ERROR or 1);
  {$EXTERNALSYM ERROR_BAD_SECTION_NAME_LINE}
  ERROR_SECTION_NAME_TOO_LONG       = DWORD(APPLICATION_ERROR_MASK or ERROR_SEVERITY_ERROR or 2);
  {$EXTERNALSYM ERROR_SECTION_NAME_TOO_LONG}
  ERROR_GENERAL_SYNTAX              = DWORD(APPLICATION_ERROR_MASK or ERROR_SEVERITY_ERROR or 3);
  {$EXTERNALSYM ERROR_GENERAL_SYNTAX}

//
// Inf runtime errors
//
  ERROR_WRONG_INF_STYLE             = DWORD(APPLICATION_ERROR_MASK or ERROR_SEVERITY_ERROR or $100);
  {$EXTERNALSYM ERROR_WRONG_INF_STYLE}
  ERROR_SECTION_NOT_FOUND           = DWORD(APPLICATION_ERROR_MASK or ERROR_SEVERITY_ERROR or $101);
  {$EXTERNALSYM ERROR_SECTION_NOT_FOUND}
  ERROR_LINE_NOT_FOUND              = DWORD(APPLICATION_ERROR_MASK or ERROR_SEVERITY_ERROR or $102);
  {$EXTERNALSYM ERROR_LINE_NOT_FOUND}
  ERROR_NO_BACKUP                   = DWORD(APPLICATION_ERROR_MASK or ERROR_SEVERITY_ERROR or $103);
  {$EXTERNALSYM ERROR_NO_BACKUP}

//
// Device Installer/other errors
//
  ERROR_NO_ASSOCIATED_CLASS         = DWORD(APPLICATION_ERROR_MASK or ERROR_SEVERITY_ERROR or $200);
  {$EXTERNALSYM ERROR_NO_ASSOCIATED_CLASS}
  ERROR_CLASS_MISMATCH              = DWORD(APPLICATION_ERROR_MASK or ERROR_SEVERITY_ERROR or $201);
  {$EXTERNALSYM ERROR_CLASS_MISMATCH}
  ERROR_DUPLICATE_FOUND             = DWORD(APPLICATION_ERROR_MASK or ERROR_SEVERITY_ERROR or $202);
  {$EXTERNALSYM ERROR_DUPLICATE_FOUND}
  ERROR_NO_DRIVER_SELECTED          = DWORD(APPLICATION_ERROR_MASK or ERROR_SEVERITY_ERROR or $203);
  {$EXTERNALSYM ERROR_NO_DRIVER_SELECTED}
  ERROR_KEY_DOES_NOT_EXIST          = DWORD(APPLICATION_ERROR_MASK or ERROR_SEVERITY_ERROR or $204);
  {$EXTERNALSYM ERROR_KEY_DOES_NOT_EXIST}
  ERROR_INVALID_DEVINST_NAME        = DWORD(APPLICATION_ERROR_MASK or ERROR_SEVERITY_ERROR or $205);
  {$EXTERNALSYM ERROR_INVALID_DEVINST_NAME}
  ERROR_INVALID_CLASS               = DWORD(APPLICATION_ERROR_MASK or ERROR_SEVERITY_ERROR or $206);
  {$EXTERNALSYM ERROR_INVALID_CLASS}
  ERROR_DEVINST_ALREADY_EXISTS      = DWORD(APPLICATION_ERROR_MASK or ERROR_SEVERITY_ERROR or $207);
  {$EXTERNALSYM ERROR_DEVINST_ALREADY_EXISTS}
  ERROR_DEVINFO_NOT_REGISTERED      = DWORD(APPLICATION_ERROR_MASK or ERROR_SEVERITY_ERROR or $208);
  {$EXTERNALSYM ERROR_DEVINFO_NOT_REGISTERED}
  ERROR_INVALID_REG_PROPERTY        = DWORD(APPLICATION_ERROR_MASK or ERROR_SEVERITY_ERROR or $209);
  {$EXTERNALSYM ERROR_INVALID_REG_PROPERTY}
  ERROR_NO_INF                      = DWORD(APPLICATION_ERROR_MASK or ERROR_SEVERITY_ERROR or $20A);
  {$EXTERNALSYM ERROR_NO_INF}
  ERROR_NO_SUCH_DEVINST             = DWORD(APPLICATION_ERROR_MASK or ERROR_SEVERITY_ERROR or $20B);
  {$EXTERNALSYM ERROR_NO_SUCH_DEVINST}
  ERROR_CANT_LOAD_CLASS_ICON        = DWORD(APPLICATION_ERROR_MASK or ERROR_SEVERITY_ERROR or $20C);
  {$EXTERNALSYM ERROR_CANT_LOAD_CLASS_ICON}
  ERROR_INVALID_CLASS_INSTALLER     = DWORD(APPLICATION_ERROR_MASK or ERROR_SEVERITY_ERROR or $20D);
  {$EXTERNALSYM ERROR_INVALID_CLASS_INSTALLER}
  ERROR_DI_DO_DEFAULT               = DWORD(APPLICATION_ERROR_MASK or ERROR_SEVERITY_ERROR or $20E);
  {$EXTERNALSYM ERROR_DI_DO_DEFAULT}
  ERROR_DI_NOFILECOPY               = DWORD(APPLICATION_ERROR_MASK or ERROR_SEVERITY_ERROR or $20F);
  {$EXTERNALSYM ERROR_DI_NOFILECOPY}
  ERROR_INVALID_HWPROFILE           = DWORD(APPLICATION_ERROR_MASK or ERROR_SEVERITY_ERROR or $210);
  {$EXTERNALSYM ERROR_INVALID_HWPROFILE}
  ERROR_NO_DEVICE_SELECTED          = DWORD(APPLICATION_ERROR_MASK or ERROR_SEVERITY_ERROR or $211);
  {$EXTERNALSYM ERROR_NO_DEVICE_SELECTED}
  ERROR_DEVINFO_LIST_LOCKED         = DWORD(APPLICATION_ERROR_MASK or ERROR_SEVERITY_ERROR or $212);
  {$EXTERNALSYM ERROR_DEVINFO_LIST_LOCKED}
  ERROR_DEVINFO_DATA_LOCKED         = DWORD(APPLICATION_ERROR_MASK or ERROR_SEVERITY_ERROR or $213);
  {$EXTERNALSYM ERROR_DEVINFO_DATA_LOCKED}
  ERROR_DI_BAD_PATH                 = DWORD(APPLICATION_ERROR_MASK or ERROR_SEVERITY_ERROR or $214);
  {$EXTERNALSYM ERROR_DI_BAD_PATH}
  ERROR_NO_CLASSINSTALL_PARAMS      = DWORD(APPLICATION_ERROR_MASK or ERROR_SEVERITY_ERROR or $215);
  {$EXTERNALSYM ERROR_NO_CLASSINSTALL_PARAMS}
  ERROR_FILEQUEUE_LOCKED            = DWORD(APPLICATION_ERROR_MASK or ERROR_SEVERITY_ERROR or $216);
  {$EXTERNALSYM ERROR_FILEQUEUE_LOCKED}
  ERROR_BAD_SERVICE_INSTALLSECT     = DWORD(APPLICATION_ERROR_MASK or ERROR_SEVERITY_ERROR or $217);
  {$EXTERNALSYM ERROR_BAD_SERVICE_INSTALLSECT}
  ERROR_NO_CLASS_DRIVER_LIST        = DWORD(APPLICATION_ERROR_MASK or ERROR_SEVERITY_ERROR or $218);
  {$EXTERNALSYM ERROR_NO_CLASS_DRIVER_LIST}
  ERROR_NO_ASSOCIATED_SERVICE       = DWORD(APPLICATION_ERROR_MASK or ERROR_SEVERITY_ERROR or $219);
  {$EXTERNALSYM ERROR_NO_ASSOCIATED_SERVICE}
  ERROR_NO_DEFAULT_DEVICE_INTERFACE = DWORD(APPLICATION_ERROR_MASK or ERROR_SEVERITY_ERROR or $21A);
  {$EXTERNALSYM ERROR_NO_DEFAULT_DEVICE_INTERFACE}
  ERROR_DEVICE_INTERFACE_ACTIVE     = DWORD(APPLICATION_ERROR_MASK or ERROR_SEVERITY_ERROR or $21B);
  {$EXTERNALSYM ERROR_DEVICE_INTERFACE_ACTIVE}
  ERROR_DEVICE_INTERFACE_REMOVED    = DWORD(APPLICATION_ERROR_MASK or ERROR_SEVERITY_ERROR or $21C);
  {$EXTERNALSYM ERROR_DEVICE_INTERFACE_REMOVED}
  ERROR_BAD_INTERFACE_INSTALLSECT   = DWORD(APPLICATION_ERROR_MASK or ERROR_SEVERITY_ERROR or $21D);
  {$EXTERNALSYM ERROR_BAD_INTERFACE_INSTALLSECT}
  ERROR_NO_SUCH_INTERFACE_CLASS     = DWORD(APPLICATION_ERROR_MASK or ERROR_SEVERITY_ERROR or $21E);
  {$EXTERNALSYM ERROR_NO_SUCH_INTERFACE_CLASS}
  ERROR_INVALID_REFERENCE_STRING    = DWORD(APPLICATION_ERROR_MASK or ERROR_SEVERITY_ERROR or $21F);
  {$EXTERNALSYM ERROR_INVALID_REFERENCE_STRING}
  ERROR_INVALID_MACHINENAME         = DWORD(APPLICATION_ERROR_MASK or ERROR_SEVERITY_ERROR or $220);
  {$EXTERNALSYM ERROR_INVALID_MACHINENAME}
  ERROR_REMOTE_COMM_FAILURE         = DWORD(APPLICATION_ERROR_MASK or ERROR_SEVERITY_ERROR or $221);
  {$EXTERNALSYM ERROR_REMOTE_COMM_FAILURE}
  ERROR_MACHINE_UNAVAILABLE         = DWORD(APPLICATION_ERROR_MASK or ERROR_SEVERITY_ERROR or $222);
  {$EXTERNALSYM ERROR_MACHINE_UNAVAILABLE}
  ERROR_NO_CONFIGMGR_SERVICES       = DWORD(APPLICATION_ERROR_MASK or ERROR_SEVERITY_ERROR or $223);
  {$EXTERNALSYM ERROR_NO_CONFIGMGR_SERVICES}
  ERROR_INVALID_PROPPAGE_PROVIDER   = DWORD(APPLICATION_ERROR_MASK or ERROR_SEVERITY_ERROR or $224);
  {$EXTERNALSYM ERROR_INVALID_PROPPAGE_PROVIDER}
  ERROR_NO_SUCH_DEVICE_INTERFACE    = DWORD(APPLICATION_ERROR_MASK or ERROR_SEVERITY_ERROR or $225);
  {$EXTERNALSYM ERROR_NO_SUCH_DEVICE_INTERFACE}
  ERROR_DI_POSTPROCESSING_REQUIRED  = DWORD(APPLICATION_ERROR_MASK or ERROR_SEVERITY_ERROR or $226);
  {$EXTERNALSYM ERROR_DI_POSTPROCESSING_REQUIRED}
  ERROR_INVALID_COINSTALLER         = DWORD(APPLICATION_ERROR_MASK or ERROR_SEVERITY_ERROR or $227);
  {$EXTERNALSYM ERROR_INVALID_COINSTALLER}
  ERROR_NO_COMPAT_DRIVERS           = DWORD(APPLICATION_ERROR_MASK or ERROR_SEVERITY_ERROR or $228);
  {$EXTERNALSYM ERROR_NO_COMPAT_DRIVERS}
  ERROR_NO_DEVICE_ICON              = DWORD(APPLICATION_ERROR_MASK or ERROR_SEVERITY_ERROR or $229);
  {$EXTERNALSYM ERROR_NO_DEVICE_ICON}
  ERROR_INVALID_INF_LOGCONFIG       = DWORD(APPLICATION_ERROR_MASK or ERROR_SEVERITY_ERROR or $22A);
  {$EXTERNALSYM ERROR_INVALID_INF_LOGCONFIG}
  ERROR_DI_DONT_INSTALL             = DWORD(APPLICATION_ERROR_MASK or ERROR_SEVERITY_ERROR or $22B);
  {$EXTERNALSYM ERROR_DI_DONT_INSTALL}
  ERROR_INVALID_FILTER_DRIVER       = DWORD(APPLICATION_ERROR_MASK or ERROR_SEVERITY_ERROR or $22C);
  {$EXTERNALSYM ERROR_INVALID_FILTER_DRIVER}
  ERROR_NON_WINDOWS_NT_DRIVER       = DWORD(APPLICATION_ERROR_MASK or ERROR_SEVERITY_ERROR or $22D);
  {$EXTERNALSYM ERROR_NON_WINDOWS_NT_DRIVER}
  ERROR_NON_WINDOWS_DRIVER          = DWORD(APPLICATION_ERROR_MASK or ERROR_SEVERITY_ERROR or $22E);
  {$EXTERNALSYM ERROR_NON_WINDOWS_DRIVER}
  ERROR_NO_CATALOG_FOR_OEM_INF      = DWORD(APPLICATION_ERROR_MASK or ERROR_SEVERITY_ERROR or $22F);
  {$EXTERNALSYM ERROR_NO_CATALOG_FOR_OEM_INF}
  ERROR_DEVINSTALL_QUEUE_NONNATIVE  = DWORD(APPLICATION_ERROR_MASK or ERROR_SEVERITY_ERROR or $230);
  {$EXTERNALSYM ERROR_DEVINSTALL_QUEUE_NONNATIVE}
  ERROR_NOT_DISABLEABLE             = DWORD(APPLICATION_ERROR_MASK or ERROR_SEVERITY_ERROR or $231);
  {$EXTERNALSYM ERROR_NOT_DISABLEABLE}
  ERROR_CANT_REMOVE_DEVINST         = DWORD(APPLICATION_ERROR_MASK or ERROR_SEVERITY_ERROR or $232);
  {$EXTERNALSYM ERROR_CANT_REMOVE_DEVINST}
  ERROR_INVALID_TARGET              = DWORD(APPLICATION_ERROR_MASK or ERROR_SEVERITY_ERROR or $233);
  {$EXTERNALSYM ERROR_INVALID_TARGET}
  ERROR_DRIVER_NONNATIVE            = DWORD(APPLICATION_ERROR_MASK or ERROR_SEVERITY_ERROR or $234);
  {$EXTERNALSYM ERROR_DRIVER_NONNATIVE}
  ERROR_IN_WOW64                    = DWORD(APPLICATION_ERROR_MASK or ERROR_SEVERITY_ERROR or $235);
  {$EXTERNALSYM ERROR_IN_WOW64}
  ERROR_SET_SYSTEM_RESTORE_POINT    = DWORD(APPLICATION_ERROR_MASK or ERROR_SEVERITY_ERROR or $236);
  {$EXTERNALSYM ERROR_SET_SYSTEM_RESTORE_POINT}
  ERROR_INCORRECTLY_COPIED_INF      = DWORD(APPLICATION_ERROR_MASK or ERROR_SEVERITY_ERROR or $237);
  {$EXTERNALSYM ERROR_INCORRECTLY_COPIED_INF}
  ERROR_SCE_DISABLED                = DWORD(APPLICATION_ERROR_MASK or ERROR_SEVERITY_ERROR or $238);
  {$EXTERNALSYM ERROR_SCE_DISABLED}

//
// Backward compatibility--do not use.
//
  ERROR_NO_DEFAULT_INTERFACE_DEVICE = ERROR_NO_DEFAULT_DEVICE_INTERFACE;
  {$EXTERNALSYM ERROR_NO_DEFAULT_INTERFACE_DEVICE}
  ERROR_INTERFACE_DEVICE_ACTIVE     = ERROR_DEVICE_INTERFACE_ACTIVE;
  {$EXTERNALSYM ERROR_INTERFACE_DEVICE_ACTIVE}
  ERROR_INTERFACE_DEVICE_REMOVED    = ERROR_DEVICE_INTERFACE_REMOVED;
  {$EXTERNALSYM ERROR_INTERFACE_DEVICE_REMOVED}
  ERROR_NO_SUCH_INTERFACE_DEVICE    = ERROR_NO_SUCH_DEVICE_INTERFACE;
  {$EXTERNALSYM ERROR_NO_SUCH_INTERFACE_DEVICE}

//
// Win9x migration DLL error code
//
  ERROR_NOT_INSTALLED = DWORD(APPLICATION_ERROR_MASK or ERROR_SEVERITY_ERROR or $1000);
  {$EXTERNALSYM ERROR_NOT_INSTALLED}

// (rom) moved may consts here to allow for dynamic linking

//
// SearchControl flags for SetupGetInfInformation
//
const
  INFINFO_INF_SPEC_IS_HINF       = 1;
  {$EXTERNALSYM INFINFO_INF_SPEC_IS_HINF}
  INFINFO_INF_NAME_IS_ABSOLUTE   = 2;
  {$EXTERNALSYM INFINFO_INF_NAME_IS_ABSOLUTE}
  INFINFO_DEFAULT_SEARCH         = 3;
  {$EXTERNALSYM INFINFO_DEFAULT_SEARCH}
  INFINFO_REVERSE_DEFAULT_SEARCH = 4;
  {$EXTERNALSYM INFINFO_REVERSE_DEFAULT_SEARCH}
  INFINFO_INF_PATH_LIST_SEARCH   = 5;
  {$EXTERNALSYM INFINFO_INF_PATH_LIST_SEARCH}

//
// Compression types
//
const
  FILE_COMPRESSION_NONE   = 0;
  {$EXTERNALSYM FILE_COMPRESSION_NONE}
  FILE_COMPRESSION_WINLZA = 1;
  {$EXTERNALSYM FILE_COMPRESSION_WINLZA}
  FILE_COMPRESSION_MSZIP  = 2;
  {$EXTERNALSYM FILE_COMPRESSION_MSZIP}
  FILE_COMPRESSION_NTCAB  = 3;
  {$EXTERNALSYM FILE_COMPRESSION_NTCAB}

//
// Define flags for SourceList APIs.
//
const
  SRCLIST_TEMPORARY       = $00000001;
  {$EXTERNALSYM SRCLIST_TEMPORARY}
  SRCLIST_NOBROWSE        = $00000002;
  {$EXTERNALSYM SRCLIST_NOBROWSE}
  SRCLIST_SYSTEM          = $00000010;
  {$EXTERNALSYM SRCLIST_SYSTEM}
  SRCLIST_USER            = $00000020;
  {$EXTERNALSYM SRCLIST_USER}
  SRCLIST_SYSIFADMIN      = $00000040;
  {$EXTERNALSYM SRCLIST_SYSIFADMIN}
  SRCLIST_SUBDIRS         = $00000100;
  {$EXTERNALSYM SRCLIST_SUBDIRS}
  SRCLIST_APPEND          = $00000200;
  {$EXTERNALSYM SRCLIST_APPEND}
  SRCLIST_NOSTRIPPLATFORM = $00000400;
  {$EXTERNALSYM SRCLIST_NOSTRIPPLATFORM}

//
// Styles for SetupPromptForDisk, SetupCopyError,
// SetupRenameError, SetupDeleteError
//
const
  IDF_NOBROWSE               = $00000001;
  {$EXTERNALSYM IDF_NOBROWSE}
  IDF_NOSKIP                 = $00000002;
  {$EXTERNALSYM IDF_NOSKIP}
  IDF_NODETAILS              = $00000004;
  {$EXTERNALSYM IDF_NODETAILS}
  IDF_NOCOMPRESSED           = $00000008;
  {$EXTERNALSYM IDF_NOCOMPRESSED}
  IDF_CHECKFIRST             = $00000100;
  {$EXTERNALSYM IDF_CHECKFIRST}
  IDF_NOBEEP                 = $00000200;
  {$EXTERNALSYM IDF_NOBEEP}
  IDF_NOFOREGROUND           = $00000400;
  {$EXTERNALSYM IDF_NOFOREGROUND}
  IDF_WARNIFSKIP             = $00000800;
  {$EXTERNALSYM IDF_WARNIFSKIP}
  IDF_NOREMOVABLEMEDIAPROMPT = $00001000;
  {$EXTERNALSYM IDF_NOREMOVABLEMEDIAPROMPT}
  IDF_USEDISKNAMEASPROMPT    = $00002000;
  {$EXTERNALSYM IDF_USEDISKNAMEASPROMPT}
  IDF_OEMDISK                = DWORD($80000000);
  {$EXTERNALSYM IDF_OEMDISK}

//
// Return values for SetupPromptForDisk, SetupCopyError,
// SetupRenameError, SetupDeleteError, SetupBackupError
//
const
  DPROMPT_SUCCESS        = 0;
  {$EXTERNALSYM DPROMPT_SUCCESS}
  DPROMPT_CANCEL         = 1;
  {$EXTERNALSYM DPROMPT_CANCEL}
  DPROMPT_SKIPFILE       = 2;
  {$EXTERNALSYM DPROMPT_SKIPFILE}
  DPROMPT_BUFFERTOOSMALL = 3;
  {$EXTERNALSYM DPROMPT_BUFFERTOOSMALL}
  DPROMPT_OUTOFMEMORY    = 4;
  {$EXTERNALSYM DPROMPT_OUTOFMEMORY}

//
// Flags for SetupSetDirectoryIdEx
//
const
  SETDIRID_NOT_FULL_PATH = $00000001;
  {$EXTERNALSYM SETDIRID_NOT_FULL_PATH}

//
// InfoDesired values for SetupGetSourceInfo
//
const
  SRCINFO_PATH        = 1;
  {$EXTERNALSYM SRCINFO_PATH}
  SRCINFO_TAGFILE     = 2;
  {$EXTERNALSYM SRCINFO_TAGFILE}
  SRCINFO_DESCRIPTION = 3;
  {$EXTERNALSYM SRCINFO_DESCRIPTION}
  SRCINFO_FLAGS       = 4;
  {$EXTERNALSYM SRCINFO_FLAGS}
  // SRC_FLAGS allow special treatment of source
  // lower 4 bits are reserved for OS use
  // the flags may determine what other parameters exist
  //
  SRCINFO_TAGFILE2    = 5;  // alternate tagfile, when SRCINFO_TAGFILE is a cabfile
  {$EXTERNALSYM SRCINFO_TAGFILE2}
  SRC_FLAGS_CABFILE   = $0010; // if set, treat SRCINFO_TAGFILE as a cabfile and specify alternate tagfile
  {$EXTERNALSYM SRC_FLAGS_CABFILE}

//
// CopyStyle values for copy and queue-related APIs
//
const
  SP_COPY_DELETESOURCE        = $0000001; // delete source file on successful copy
  {$EXTERNALSYM SP_COPY_DELETESOURCE}
  SP_COPY_REPLACEONLY         = $0000002; // copy only if target file already present
  {$EXTERNALSYM SP_COPY_REPLACEONLY}
  SP_COPY_NEWER               = $0000004; // copy only if source newer than or same as target
  {$EXTERNALSYM SP_COPY_NEWER}
  SP_COPY_NEWER_OR_SAME       = SP_COPY_NEWER;
  {$EXTERNALSYM SP_COPY_NEWER_OR_SAME}
  SP_COPY_NOOVERWRITE         = $0000008; // copy only if target doesn't exist
  {$EXTERNALSYM SP_COPY_NOOVERWRITE}
  SP_COPY_NODECOMP            = $0000010; // don't decompress source file while copying
  {$EXTERNALSYM SP_COPY_NODECOMP}
  SP_COPY_LANGUAGEAWARE       = $0000020; // don't overwrite file of different language
  {$EXTERNALSYM SP_COPY_LANGUAGEAWARE}
  SP_COPY_SOURCE_ABSOLUTE     = $0000040; // SourceFile is a full source path
  {$EXTERNALSYM SP_COPY_SOURCE_ABSOLUTE}
  SP_COPY_SOURCEPATH_ABSOLUTE = $0000080; // SourcePathRoot is the full path
  {$EXTERNALSYM SP_COPY_SOURCEPATH_ABSOLUTE}
  SP_COPY_IN_USE_NEEDS_REBOOT = $0000100; // System needs reboot if file in use
  {$EXTERNALSYM SP_COPY_IN_USE_NEEDS_REBOOT}
  SP_COPY_FORCE_IN_USE        = $0000200; // Force target-in-use behavior
  {$EXTERNALSYM SP_COPY_FORCE_IN_USE}
  SP_COPY_NOSKIP              = $0000400; // Skip is disallowed for this file or section
  {$EXTERNALSYM SP_COPY_NOSKIP}
  SP_FLAG_CABINETCONTINUATION = $0000800; // Used with need media notification
  {$EXTERNALSYM SP_FLAG_CABINETCONTINUATION}
  SP_COPY_FORCE_NOOVERWRITE   = $0001000; // like NOOVERWRITE but no callback nofitication
  {$EXTERNALSYM SP_COPY_FORCE_NOOVERWRITE}
  SP_COPY_FORCE_NEWER         = $0002000; // like NEWER but no callback nofitication
  {$EXTERNALSYM SP_COPY_FORCE_NEWER}
  SP_COPY_WARNIFSKIP          = $0004000; // system critical file: warn if user tries to skip
  {$EXTERNALSYM SP_COPY_WARNIFSKIP}
  SP_COPY_NOBROWSE            = $0008000; // Browsing is disallowed for this file or section
  {$EXTERNALSYM SP_COPY_NOBROWSE}
  SP_COPY_NEWER_ONLY          = $0010000; // copy only if source file newer than target
  {$EXTERNALSYM SP_COPY_NEWER_ONLY}
  SP_COPY_SOURCE_SIS_MASTER   = $0020000; // source is single-instance store master
  {$EXTERNALSYM SP_COPY_SOURCE_SIS_MASTER}
  SP_COPY_OEMINF_CATALOG_ONLY = $0040000; // (SetupCopyOEMInf only) don't copy INF--just catalog
  {$EXTERNALSYM SP_COPY_OEMINF_CATALOG_ONLY}
  SP_COPY_REPLACE_BOOT_FILE   = $0080000; // file must be present upon reboot (i.e., it's
  {$EXTERNALSYM SP_COPY_REPLACE_BOOT_FILE}// needed by the loader); this flag implies a reboot
  SP_COPY_NOPRUNE             = $0100000; // never prune this file
  {$EXTERNALSYM SP_COPY_NOPRUNE}
  SP_COPY_OEM_F6_INF           = $0200000;   // Used when calling SetupCopyOemInf
  {$EXTERNALSYM SP_COPY_OEM_F6_INF}
  //
  // Flags passed to Backup notification
  //
  SP_BACKUP_BACKUPPASS          = $00000001;  // file backed up during backup pass
  {$EXTERNALSYM SP_BACKUP_BACKUPPASS}
  SP_BACKUP_DEMANDPASS          = $00000002;  // file backed up on demand
  {$EXTERNALSYM SP_BACKUP_DEMANDPASS}
  SP_BACKUP_SPECIAL             = $00000004;  // if set, special type of backup
  {$EXTERNALSYM SP_BACKUP_SPECIAL}
  SP_BACKUP_BOOTFILE            = $00000008;  // file marked with COPYFLG_REPLACE_BOOT_FILE
  {$EXTERNALSYM SP_BACKUP_BOOTFILE}

//
// Define flags for SetupScanFileQueue.
//
const
  SPQ_SCAN_FILE_PRESENCE           = $00000001;
  {$EXTERNALSYM SPQ_SCAN_FILE_PRESENCE}
  SPQ_SCAN_FILE_VALIDITY           = $00000002;
  {$EXTERNALSYM SPQ_SCAN_FILE_VALIDITY}
  SPQ_SCAN_USE_CALLBACK            = $00000004;
  {$EXTERNALSYM SPQ_SCAN_USE_CALLBACK}
  SPQ_SCAN_USE_CALLBACKEX          = $00000008;
  {$EXTERNALSYM SPQ_SCAN_USE_CALLBACKEX}
  SPQ_SCAN_INFORM_USER             = $00000010;
  {$EXTERNALSYM SPQ_SCAN_INFORM_USER}
  SPQ_SCAN_PRUNE_COPY_QUEUE        = $00000020;
  {$EXTERNALSYM SPQ_SCAN_PRUNE_COPY_QUEUE}
  SPQ_SCAN_USE_CALLBACK_SIGNERINFO = $00000040;
  {$EXTERNALSYM SPQ_SCAN_USE_CALLBACK_SIGNERINFO}
  SPQ_SCAN_PRUNE_DELREN            = $00000080; // remote Delete/Rename queue
  {$EXTERNALSYM SPQ_SCAN_PRUNE_DELREN}

//
// Define flags used with Param2 for SPFILENOTIFY_QUEUESCAN
//
  SPQ_DELAYED_COPY                 = $00000001; // file was in use; registered for delayed copy
  {$EXTERNALSYM SPQ_DELAYED_COPY}

//
// Flags/FlagMask for use with SetupSetFileQueueFlags and returned by SetupGetFileQueueFlags
//
const
  SPQ_FLAG_BACKUP_AWARE      = $00000001;  // If set, SetupCommitFileQueue will
  {$EXTERNALSYM SPQ_FLAG_BACKUP_AWARE}     // issue backup notifications.

  SPQ_FLAG_ABORT_IF_UNSIGNED = $00000002;  // If set, SetupCommitFileQueue will
  {$EXTERNALSYM SPQ_FLAG_ABORT_IF_UNSIGNED}// fail with ERROR_SET_SYSTEM_RESTORE_POINT
                                           // if the user elects to proceed with an
                                           // unsigned queue committal.  This allows
                                           // the caller to set a system restore point,
                                           // then re-commit the file queue.

  SPQ_FLAG_FILES_MODIFIED    = $00000004;  // If set, at least one file was
  {$EXTERNALSYM SPQ_FLAG_FILES_MODIFIED}   // replaced by a different version

  SPQ_FLAG_VALID             = $00000007;  // mask of valid flags (can be passed as FlagMask)
  {$EXTERNALSYM SPQ_FLAG_VALID}

//
// Define OEM Source Type values for use in SetupCopyOEMInf.
//
  SPOST_NONE = 0;
  {$EXTERNALSYM SPOST_NONE}
  SPOST_PATH = 1;
  {$EXTERNALSYM SPOST_PATH}
  SPOST_URL  = 2;
  {$EXTERNALSYM SPOST_URL}
  SPOST_MAX  = 3;
  {$EXTERNALSYM SPOST_MAX}

//
// Flags used by SetupUninstallOEMInf
//
  SUOI_FORCEDELETE = $00000001;
  {$IFDEF COMPILER11_UP}
  {$EXTERNALSYM SUOI_FORCEDELETE}
  {$ENDIF COMPILER11_UP}
//
// Flags for SetupCreateDiskSpaceList
//
const
  SPDSL_IGNORE_DISK              = $00000001; // ignore deletes and on-disk files in copies
  {$EXTERNALSYM SPDSL_IGNORE_DISK}
  SPDSL_DISALLOW_NEGATIVE_ADJUST = $00000002;
  {$EXTERNALSYM SPDSL_DISALLOW_NEGATIVE_ADJUST}

//
// Define flags that are returned by SetupPromptReboot
//
const
  SPFILEQ_FILE_IN_USE        = $00000001;
  {$EXTERNALSYM SPFILEQ_FILE_IN_USE}
  SPFILEQ_REBOOT_RECOMMENDED = $00000002;
  {$EXTERNALSYM SPFILEQ_REBOOT_RECOMMENDED}
  SPFILEQ_REBOOT_IN_PROGRESS = $00000004;
  {$EXTERNALSYM SPFILEQ_REBOOT_IN_PROGRESS}

//
// Flags for AddReg section lines in INF.  The corresponding value
// is <ValueType> in the AddReg line format given below:
//
// <RegRootString>,<SubKey>,<ValueName>,<ValueType>,<Value>...
//
// The low word contains basic flags concerning the general data type
// and AddReg action. The high word contains values that more specifically
// identify the data type of the registry value.  The high word is ignored
// by the 16-bit Windows 95 SETUPX APIs.
//
// If <ValueType> has FLG_ADDREG_DELREG_BIT set, it will be ignored by AddReg
// (not supported by SetupX).
//
const
  FLG_ADDREG_DELREG_BIT     = $00008000;   // if set, interpret as DELREG, see below
  {$EXTERNALSYM FLG_ADDREG_DELREG_BIT}
  FLG_ADDREG_BINVALUETYPE   = $00000001;
  {$EXTERNALSYM FLG_ADDREG_BINVALUETYPE}
  FLG_ADDREG_NOCLOBBER      = $00000002;
  {$EXTERNALSYM FLG_ADDREG_NOCLOBBER}
  FLG_ADDREG_DELVAL         = $00000004;
  {$EXTERNALSYM FLG_ADDREG_DELVAL}
  FLG_ADDREG_APPEND         = $00000008;   // Currently supported only
  {$EXTERNALSYM FLG_ADDREG_APPEND}         // for REG_MULTI_SZ values.
  FLG_ADDREG_KEYONLY        = $00000010;   // Just create the key, ignore value
  {$EXTERNALSYM FLG_ADDREG_KEYONLY}
  FLG_ADDREG_OVERWRITEONLY  = $00000020;   // Set only if value already exists
  {$EXTERNALSYM FLG_ADDREG_OVERWRITEONLY}
  FLG_ADDREG_64BITKEY       = $00001000;   // make this change in the 64 bit registry.
  {$EXTERNALSYM FLG_ADDREG_64BITKEY}
  FLG_ADDREG_KEYONLY_COMMON = $00002000;   // same as FLG_ADDREG_KEYONLY but also works for DELREG
  {$EXTERNALSYM FLG_ADDREG_KEYONLY_COMMON}
  FLG_ADDREG_32BITKEY       = $00004000;   // make this change in the 32 bit registry.
  {$EXTERNALSYM FLG_ADDREG_32BITKEY}
  //
  // The INF may supply any arbitrary data type ordinal in the highword except
  // for the following: REG_NONE, REG_SZ, REG_EXPAND_SZ, REG_MULTI_SZ.  If this
  // technique is used, then the data is given in binary format, one byte per
  // field.
  //
  FLG_ADDREG_TYPE_MASK      = DWORD($FFFF0000 or FLG_ADDREG_BINVALUETYPE);
  {$EXTERNALSYM FLG_ADDREG_TYPE_MASK}
  FLG_ADDREG_TYPE_SZ        = $00000000;
  {$EXTERNALSYM FLG_ADDREG_TYPE_SZ}
  FLG_ADDREG_TYPE_MULTI_SZ  = $00010000;
  {$EXTERNALSYM FLG_ADDREG_TYPE_MULTI_SZ}
  FLG_ADDREG_TYPE_EXPAND_SZ = $00020000;
  {$EXTERNALSYM FLG_ADDREG_TYPE_EXPAND_SZ}
  FLG_ADDREG_TYPE_BINARY    = $00000000 or FLG_ADDREG_BINVALUETYPE;
  {$EXTERNALSYM FLG_ADDREG_TYPE_BINARY}
  FLG_ADDREG_TYPE_DWORD     = $00010000 or FLG_ADDREG_BINVALUETYPE;
  {$EXTERNALSYM FLG_ADDREG_TYPE_DWORD}
  FLG_ADDREG_TYPE_NONE      = $00020000 or FLG_ADDREG_BINVALUETYPE;
  {$EXTERNALSYM FLG_ADDREG_TYPE_NONE}

  //
  // Flags for DelReg section lines in INF.  The corresponding value
  // is <Operation> in the extended DelReg line format given below:
  //
  // <RegRootString>,<SubKey>,<ValueName>,<Operation>[,...]
  //
  // In SetupX and some versions of SetupAPI, <Operation> will be ignored and <ValueName> will
  // be deleted. Use with care.
  //
  // The bits determined by mask FLG_DELREG_TYPE_MASK indicates type of data expected.
  // <Operation> must have FLG_ADDREG_DELREG_BIT set, otherwise it is ignored and specified
  // value will be deleted (allowing an AddReg section to also be used as a DelReg section)
  // if <Operation> is not specified, <ValueName> will be deleted (if specified) otherwise
  // <SubKey> will be deleted.
  //
  // the compatability flag
  //
  FLG_DELREG_VALUE            = $00000000;
  {$EXTERNALSYM FLG_DELREG_VALUE}

  FLG_DELREG_TYPE_MASK        = FLG_ADDREG_TYPE_MASK;        // 0xFFFF0001
  {$EXTERNALSYM FLG_DELREG_TYPE_MASK}
  FLG_DELREG_TYPE_SZ          = FLG_ADDREG_TYPE_SZ;          // 0x00000000
  {$EXTERNALSYM FLG_DELREG_TYPE_SZ}
  FLG_DELREG_TYPE_MULTI_SZ    = FLG_ADDREG_TYPE_MULTI_SZ;    // 0x00010000
  {$EXTERNALSYM FLG_DELREG_TYPE_MULTI_SZ}
  FLG_DELREG_TYPE_EXPAND_SZ   = FLG_ADDREG_TYPE_EXPAND_SZ;   // 0x00020000
  {$EXTERNALSYM FLG_DELREG_TYPE_EXPAND_SZ}
  FLG_DELREG_TYPE_BINARY      = FLG_ADDREG_TYPE_BINARY;      // 0x00000001
  {$EXTERNALSYM FLG_DELREG_TYPE_BINARY}
  FLG_DELREG_TYPE_DWORD       = FLG_ADDREG_TYPE_DWORD;       // 0x00010001
  {$EXTERNALSYM FLG_DELREG_TYPE_DWORD}
  FLG_DELREG_TYPE_NONE        = FLG_ADDREG_TYPE_NONE;        // 0x00020001
  {$EXTERNALSYM FLG_DELREG_TYPE_NONE}
  FLG_DELREG_64BITKEY         = FLG_ADDREG_64BITKEY;         // 0x00001000
  {$EXTERNALSYM FLG_DELREG_64BITKEY}
  FLG_DELREG_KEYONLY_COMMON   = FLG_ADDREG_KEYONLY_COMMON;   // 0x00002000
  {$EXTERNALSYM FLG_DELREG_KEYONLY_COMMON}
  FLG_DELREG_32BITKEY         = FLG_ADDREG_32BITKEY;         // 0x00004000
  {$EXTERNALSYM FLG_DELREG_32BITKEY}

  //
  // <Operation> = FLG_DELREG_MULTI_SZ_DELSTRING
  //               <RegRootString>,<SubKey>,<ValueName>,0x00018002,<String>
  //               removes all entries matching <String> (case ignored) from multi-sz registry value
  //
  FLG_DELREG_OPERATION_MASK = $000000FE;
  {$EXTERNALSYM FLG_DELREG_OPERATION_MASK}
  FLG_DELREG_MULTI_SZ_DELSTRING = FLG_DELREG_TYPE_MULTI_SZ or FLG_ADDREG_DELREG_BIT or $00000002;  // 0x00018002
  {$EXTERNALSYM FLG_DELREG_MULTI_SZ_DELSTRING}

//
// Flags for BitReg section lines in INF.
//
  FLG_BITREG_CLEARBITS = $00000000;
  {$EXTERNALSYM FLG_BITREG_CLEARBITS}
  FLG_BITREG_SETBITS   = $00000001;
  {$EXTERNALSYM FLG_BITREG_SETBITS}
  FLG_BITREG_64BITKEY  = $00001000;
  {$EXTERNALSYM FLG_BITREG_64BITKEY}
  FLG_BITREG_32BITKEY  = $00004000;
  {$EXTERNALSYM FLG_BITREG_32BITKEY}

//
// Flags for Ini2Reg section lines in INF.
//
  FLG_INI2REG_64BITKEY = $00001000;
  {$EXTERNALSYM FLG_INI2REG_64BITKEY}
  FLG_INI2REG_32BITKEY = $00004000;
  {$EXTERNALSYM FLG_INI2REG_32BITKEY}

//
// Flags for RegSvr section lines in INF
//
  FLG_REGSVR_DLLREGISTER = $00000001;
  {$EXTERNALSYM FLG_REGSVR_DLLREGISTER}
  FLG_REGSVR_DLLINSTALL  = $00000002;
  {$EXTERNALSYM FLG_REGSVR_DLLINSTALL}

// Flags for RegSvr section lines in INF
//
  FLG_PROFITEM_CURRENTUSER = $00000001;
  {$EXTERNALSYM FLG_PROFITEM_CURRENTUSER}
  FLG_PROFITEM_DELETE      = $00000002;
  {$EXTERNALSYM FLG_PROFITEM_DELETE}
  FLG_PROFITEM_GROUP       = $00000004;
  {$EXTERNALSYM FLG_PROFITEM_GROUP}
  FLG_PROFITEM_CSIDL       = $00000008;
  {$EXTERNALSYM FLG_PROFITEM_CSIDL}

//
// Flags for SetupInstallFromInfSection
//
const
  SPINST_LOGCONFIG                = $00000001;
  {$EXTERNALSYM SPINST_LOGCONFIG}
  SPINST_INIFILES                 = $00000002;
  {$EXTERNALSYM SPINST_INIFILES}
  SPINST_REGISTRY                 = $00000004;
  {$EXTERNALSYM SPINST_REGISTRY}
  SPINST_INI2REG                  = $00000008;
  {$EXTERNALSYM SPINST_INI2REG}
  SPINST_FILES                    = $00000010;
  {$EXTERNALSYM SPINST_FILES}
  SPINST_BITREG                   = $00000020;
  {$EXTERNALSYM SPINST_BITREG}
  SPINST_REGSVR                   = $00000040;
  {$EXTERNALSYM SPINST_REGSVR}
  SPINST_UNREGSVR                 = $00000080;
  {$EXTERNALSYM SPINST_UNREGSVR}
  SPINST_PROFILEITEMS             = $00000100;
  {$EXTERNALSYM SPINST_PROFILEITEMS}
  {$IFDEF WINXP_UP}
  SPINST_COPYINF                  = $00000200;
  {$EXTERNALSYM SPINST_COPYINF}
  SPINST_ALL                      = $000003ff;
  {$EXTERNALSYM SPINST_ALL}
  {$ELSE}
  SPINST_ALL                      = $000001ff;
  {$EXTERNALSYM SPINST_ALL}
  {$ENDIF WINXP_UP}
  SPINST_SINGLESECTION            = $00010000;
  {$EXTERNALSYM SPINST_SINGLESECTION}
  SPINST_LOGCONFIG_IS_FORCED      = $00020000;
  {$EXTERNALSYM SPINST_LOGCONFIG_IS_FORCED}
  SPINST_LOGCONFIGS_ARE_OVERRIDES = $00040000;
  {$EXTERNALSYM SPINST_LOGCONFIGS_ARE_OVERRIDES}
  SPINST_REGISTERCALLBACKAWARE    = $00080000;
  {$EXTERNALSYM SPINST_REGISTERCALLBACKAWARE}

//
// Flags for SetupInstallServicesFromInfSection(Ex).  These flags are also used
// in the flags field of AddService or DelService lines in a device INF.  Some
// of these flags are not permitted in the non-Ex API.  These flags are marked
// as such below.
//

//
// (AddService) move service's tag to front of its group order list
//
const
  SPSVCINST_TAGTOFRONT = $00000001;
  {$EXTERNALSYM SPSVCINST_TAGTOFRONT}

//
// (AddService) **Ex API only** mark this service as the function driver for the
// device being installed
//
  SPSVCINST_ASSOCSERVICE = $00000002;
  {$EXTERNALSYM SPSVCINST_ASSOCSERVICE}

//
// (DelService) delete the associated event log entry for a service specified in
// a DelService entry
//
  SPSVCINST_DELETEEVENTLOGENTRY = $00000004;
  {$EXTERNALSYM SPSVCINST_DELETEEVENTLOGENTRY}

//
// (AddService) don't overwrite display name if it already exists
//
  SPSVCINST_NOCLOBBER_DISPLAYNAME = $00000008;
  {$EXTERNALSYM SPSVCINST_NOCLOBBER_DISPLAYNAME}

//
// (AddService) don't overwrite start type value if service already exists
//
  SPSVCINST_NOCLOBBER_STARTTYPE = $00000010;
  {$EXTERNALSYM SPSVCINST_NOCLOBBER_STARTTYPE}

//
// (AddService) don't overwrite error control value if service already exists
//
  SPSVCINST_NOCLOBBER_ERRORCONTROL = $00000020;
  {$EXTERNALSYM SPSVCINST_NOCLOBBER_ERRORCONTROL}

//
// (AddService) don't overwrite load order group if it already exists
//
  SPSVCINST_NOCLOBBER_LOADORDERGROUP = $00000040;
  {$EXTERNALSYM SPSVCINST_NOCLOBBER_LOADORDERGROUP}

//
// (AddService) don't overwrite dependencies list if it already exists
//
  SPSVCINST_NOCLOBBER_DEPENDENCIES = $00000080;
  {$EXTERNALSYM SPSVCINST_NOCLOBBER_DEPENDENCIES}

//
// (AddService) don't overwrite description if it already exists
//
  SPSVCINST_NOCLOBBER_DESCRIPTION = $00000100;
  {$EXTERNALSYM SPSVCINST_NOCLOBBER_DESCRIPTION}

//
// (DelService) stop the associated service specified in
// a DelService entry before deleting the service
//
  SPSVCINST_STOPSERVICE = $00000200;
  {$EXTERNALSYM SPSVCINST_STOPSERVICE}

//
// (AddService) force overwrite of security settings
//
  SPSVCINST_CLOBBER_SECURITY = $00000400;
  {$EXTERNALSYM SPSVCINST_CLOBBER_SECURITY}

//
// Flags for SetupInitializeFileLog
//
const
  SPFILELOG_SYSTEMLOG = $00000001; // use system log -- must be Administrator
  {$EXTERNALSYM SPFILELOG_SYSTEMLOG}
  SPFILELOG_FORCENEW  = $00000002; // not valid with SPFILELOG_SYSTEMLOG
  {$EXTERNALSYM SPFILELOG_FORCENEW}
  SPFILELOG_QUERYONLY = $00000004; // allows non-administrators to read system log
  {$EXTERNALSYM SPFILELOG_QUERYONLY}

//
// Flags for SetupLogFile
//
const
  SPFILELOG_OEMFILE = $00000001;
  {$EXTERNALSYM SPFILELOG_OEMFILE}

//
// Items retrievable from SetupQueryFileLog()
//
const
  SetupFileLogSourceFilename  = $00000000;
  {$EXTERNALSYM SetupFileLogSourceFilename}
  SetupFileLogChecksum        = $00000001;
  {$EXTERNALSYM SetupFileLogChecksum}
  SetupFileLogDiskTagfile     = $00000002;
  {$EXTERNALSYM SetupFileLogDiskTagfile}
  SetupFileLogDiskDescription = $00000003;
  {$EXTERNALSYM SetupFileLogDiskDescription}
  SetupFileLogOtherInfo       = $00000004;
  {$EXTERNALSYM SetupFileLogOtherInfo}
  SetupFileLogMax             = $00000005;
  {$EXTERNALSYM SetupFileLogMax}
type
  SetupFileLogInfo = DWORD;
  {$EXTERNALSYM SetupFileLogInfo}

const
  LogSevInformation = $00000000;
  {$EXTERNALSYM LogSevInformation}
  LogSevWarning     = $00000001;
  {$EXTERNALSYM LogSevWarning}
  LogSevError       = $00000002;
  {$EXTERNALSYM LogSevError}
  LogSevFatalError  = $00000003;
  {$EXTERNALSYM LogSevFatalError}
  LogSevMaximum     = $00000004;
  {$EXTERNALSYM LogSevMaximum}
type
  LogSeverity = DWORD;
  {$EXTERNALSYM LogSeverity}

//
// Flags for SetupDiCreateDeviceInfo
//
const
  DICD_GENERATE_ID       = $00000001;
  {$EXTERNALSYM DICD_GENERATE_ID}
  DICD_INHERIT_CLASSDRVS = $00000002;
  {$EXTERNALSYM DICD_INHERIT_CLASSDRVS}

//
// Flags for SetupDiOpenDeviceInfo
//
const
  DIOD_INHERIT_CLASSDRVS = $00000002;
  {$EXTERNALSYM DIOD_INHERIT_CLASSDRVS}
  DIOD_CANCEL_REMOVE     = $00000004;
  {$EXTERNALSYM DIOD_CANCEL_REMOVE}

//
// Flags for SetupDiOpenDeviceInterface
//
const
  DIODI_NO_ADD = $00000001;
  {$EXTERNALSYM DIODI_NO_ADD}

//
// Flags for SetupDiRegisterDeviceInfo
//
const
  SPRDI_FIND_DUPS = $00000001;
  {$EXTERNALSYM SPRDI_FIND_DUPS}

//
// Ordinal values distinguishing between class drivers and
// device drivers.
// (Passed in 'DriverType' parameter of driver information list APIs)
//
const
  SPDIT_NODRIVER     = $00000000;
  {$EXTERNALSYM SPDIT_NODRIVER}
  SPDIT_CLASSDRIVER  = $00000001;
  {$EXTERNALSYM SPDIT_CLASSDRIVER}
  SPDIT_COMPATDRIVER = $00000002;
  {$EXTERNALSYM SPDIT_COMPATDRIVER}

//
// Flags controlling what is included in the device information set built
// by SetupDiGetClassDevs
//
const
  DIGCF_DEFAULT         = $00000001; // only valid with DIGCF_DEVICEINTERFACE
  {$EXTERNALSYM DIGCF_DEFAULT}
  DIGCF_PRESENT         = $00000002;
  {$EXTERNALSYM DIGCF_PRESENT}
  DIGCF_ALLCLASSES      = $00000004;
  {$EXTERNALSYM DIGCF_ALLCLASSES}
  DIGCF_PROFILE         = $00000008;
  {$EXTERNALSYM DIGCF_PROFILE}
  DIGCF_DEVICEINTERFACE = $00000010;
  {$EXTERNALSYM DIGCF_DEVICEINTERFACE}

//
// Backward compatibility--do not use.
//

const
  DIGCF_INTERFACEDEVICE = DIGCF_DEVICEINTERFACE;
{$EXTERNALSYM DIGCF_INTERFACEDEVICE}

//
// Flags controlling exclusion from the class information list built
// by SetupDiBuildClassInfoList(Ex)
//
const
  DIBCI_NOINSTALLCLASS = $00000001;
  {$EXTERNALSYM DIBCI_NOINSTALLCLASS}
  DIBCI_NODISPLAYCLASS = $00000002;
  {$EXTERNALSYM DIBCI_NODISPLAYCLASS}

//
// Flags for SetupDiOpenClassRegKeyEx
//
const
  DIOCR_INSTALLER = $00000001; // class installer registry branch
  {$EXTERNALSYM DIOCR_INSTALLER}
  DIOCR_INTERFACE = $00000002; // interface class registry branch
  {$EXTERNALSYM DIOCR_INTERFACE}

//
// KeyType values for SetupDiCreateDevRegKey, SetupDiOpenDevRegKey, and
// SetupDiDeleteDevRegKey.
//
const
  DIREG_DEV  = $00000001; // Open/Create/Delete device key
  {$EXTERNALSYM DIREG_DEV}
  DIREG_DRV  = $00000002; // Open/Create/Delete driver key
  {$EXTERNALSYM DIREG_DRV}
  DIREG_BOTH = $00000004; // Delete both driver and Device key
  {$EXTERNALSYM DIREG_BOTH}

//
// Device registry property codes
// (Codes marked as read-only (R) may only be used for
// SetupDiGetDeviceRegistryProperty)
//
// These values should cover the same set of registry properties
// as defined by the CM_DRP codes in cfgmgr32.h.
//
// Note that SPDRP codes are zero based while CM_DRP codes are one based!
//
const
  SPDRP_DEVICEDESC                  = $00000000; // DeviceDesc (R/W)
  {$EXTERNALSYM SPDRP_DEVICEDESC}
  SPDRP_HARDWAREID                  = $00000001; // HardwareID (R/W)
  {$EXTERNALSYM SPDRP_HARDWAREID}
  SPDRP_COMPATIBLEIDS               = $00000002; // CompatibleIDs (R/W)
  {$EXTERNALSYM SPDRP_COMPATIBLEIDS}
  SPDRP_UNUSED0                     = $00000003; // unused
  {$EXTERNALSYM SPDRP_UNUSED0}
  SPDRP_SERVICE                     = $00000004; // Service (R/W)
  {$EXTERNALSYM SPDRP_SERVICE}
  SPDRP_UNUSED1                     = $00000005; // unused
  {$EXTERNALSYM SPDRP_UNUSED1}
  SPDRP_UNUSED2                     = $00000006; // unused
  {$EXTERNALSYM SPDRP_UNUSED2}
  SPDRP_CLASS                       = $00000007; // Class (R--tied to ClassGUID)
  {$EXTERNALSYM SPDRP_CLASS}
  SPDRP_CLASSGUID                   = $00000008; // ClassGUID (R/W)
  {$EXTERNALSYM SPDRP_CLASSGUID}
  SPDRP_DRIVER                      = $00000009; // Driver (R/W)
  {$EXTERNALSYM SPDRP_DRIVER}
  SPDRP_CONFIGFLAGS                 = $0000000A; // ConfigFlags (R/W)
  {$EXTERNALSYM SPDRP_CONFIGFLAGS}
  SPDRP_MFG                         = $0000000B; // Mfg (R/W)
  {$EXTERNALSYM SPDRP_MFG}
  SPDRP_FRIENDLYNAME                = $0000000C; // FriendlyName (R/W)
  {$EXTERNALSYM SPDRP_FRIENDLYNAME}
  SPDRP_LOCATION_INFORMATION        = $0000000D; // LocationInformation (R/W)
  {$EXTERNALSYM SPDRP_LOCATION_INFORMATION}
  SPDRP_PHYSICAL_DEVICE_OBJECT_NAME = $0000000E; // PhysicalDeviceObjectName (R)
  {$EXTERNALSYM SPDRP_PHYSICAL_DEVICE_OBJECT_NAME}
  SPDRP_CAPABILITIES                = $0000000F; // Capabilities (R)
  {$EXTERNALSYM SPDRP_CAPABILITIES}
  SPDRP_UI_NUMBER                   = $00000010; // UiNumber (R)
  {$EXTERNALSYM SPDRP_UI_NUMBER}
  SPDRP_UPPERFILTERS                = $00000011; // UpperFilters (R/W)
  {$EXTERNALSYM SPDRP_UPPERFILTERS}
  SPDRP_LOWERFILTERS                = $00000012; // LowerFilters (R/W)
  {$EXTERNALSYM SPDRP_LOWERFILTERS}
  SPDRP_BUSTYPEGUID                 = $00000013; // BusTypeGUID (R)
  {$EXTERNALSYM SPDRP_BUSTYPEGUID}
  SPDRP_LEGACYBUSTYPE               = $00000014; // LegacyBusType (R)
  {$EXTERNALSYM SPDRP_LEGACYBUSTYPE}
  SPDRP_BUSNUMBER                   = $00000015; // BusNumber (R)
  {$EXTERNALSYM SPDRP_BUSNUMBER}
  SPDRP_ENUMERATOR_NAME             = $00000016; // Enumerator Name (R)
  {$EXTERNALSYM SPDRP_ENUMERATOR_NAME}
  SPDRP_SECURITY                    = $00000017; // Security (R/W, binary form)
  {$EXTERNALSYM SPDRP_SECURITY}
  SPDRP_SECURITY_SDS                = $00000018; // Security (W, SDS form)
  {$EXTERNALSYM SPDRP_SECURITY_SDS}
  SPDRP_DEVTYPE                     = $00000019; // Device Type (R/W)
  {$EXTERNALSYM SPDRP_DEVTYPE}
  SPDRP_EXCLUSIVE                   = $0000001A; // Device is exclusive-access (R/W)
  {$EXTERNALSYM SPDRP_EXCLUSIVE}
  SPDRP_CHARACTERISTICS             = $0000001B; // Device Characteristics (R/W)
  {$EXTERNALSYM SPDRP_CHARACTERISTICS}
  SPDRP_ADDRESS                     = $0000001C; // Device Address (R)
  {$EXTERNALSYM SPDRP_ADDRESS}
  {$IFDEF WINXP_UP}
  SPDRP_UI_NUMBER_DESC_FORMAT       = $0000001D;  // UiNumberDescFormat (R/W)
  {$EXTERNALSYM SPDRP_UI_NUMBER_DESC_FORMAT}
  SPDRP_DEVICE_POWER_DATA           = $0000001E;  // Device Power Data (R)
  {$EXTERNALSYM SPDRP_DEVICE_POWER_DATA}
  SPDRP_REMOVAL_POLICY              = $0000001F;  // Removal Policy (R)
  {$EXTERNALSYM SPDRP_REMOVAL_POLICY}
  SPDRP_REMOVAL_POLICY_HW_DEFAULT   = $00000020;  // Hardware Removal Policy (R)
  {$EXTERNALSYM SPDRP_REMOVAL_POLICY_HW_DEFAULT}
  SPDRP_REMOVAL_POLICY_OVERRIDE     = $00000021;  // Removal Policy Override (RW)
  {$EXTERNALSYM SPDRP_REMOVAL_POLICY_OVERRIDE}
  SPDRP_INSTALL_STATE               = $00000022;  // Device Install State (R)
  {$EXTERNALSYM SPDRP_INSTALL_STATE}

  SPDRP_MAXIMUM_PROPERTY            = $00000023;  // Upper bound on ordinals
  {$EXTERNALSYM SPDRP_MAXIMUM_PROPERTY}
  {$ELSE}
  SPDRP_UI_NUMBER_DESC_FORMAT       = $0000001E; // UiNumberDescFormat (R/W)
  {$EXTERNALSYM SPDRP_UI_NUMBER_DESC_FORMAT}
  SPDRP_MAXIMUM_PROPERTY            = $0000001F; // Upper bound on ordinals
  {$EXTERNALSYM SPDRP_MAXIMUM_PROPERTY}
  {$ENDIF WINXP_UP}
//
// Class registry property codes
// (Codes marked as read-only (R) may only be used for
// SetupDiGetClassRegistryProperty)
//
// These values should cover the same set of registry properties
// as defined by the CM_CRP codes in cfgmgr32.h.
// they should also have a 1:1 correspondence with Device registers, where applicable
// but no overlap otherwise
//
  SPCRP_SECURITY         = $00000017; // Security (R/W, binary form)
  {$EXTERNALSYM SPCRP_SECURITY}
  SPCRP_SECURITY_SDS     = $00000018; // Security (W, SDS form)
  {$EXTERNALSYM SPCRP_SECURITY_SDS}
  SPCRP_DEVTYPE          = $00000019; // Device Type (R/W)
  {$EXTERNALSYM SPCRP_DEVTYPE}
  SPCRP_EXCLUSIVE        = $0000001A; // Device is exclusive-access (R/W)
  {$EXTERNALSYM SPCRP_EXCLUSIVE}
  SPCRP_CHARACTERISTICS  = $0000001B; // Device Characteristics (R/W)
  {$EXTERNALSYM SPCRP_CHARACTERISTICS}
  SPCRP_MAXIMUM_PROPERTY = $0000001C; // Upper bound on ordinals
  {$EXTERNALSYM SPCRP_MAXIMUM_PROPERTY}

//
// Flags controlling the drawing of mini-icons
//
const
  DMI_MASK    = $00000001;
  {$EXTERNALSYM DMI_MASK}
  DMI_BKCOLOR = $00000002;
  {$EXTERNALSYM DMI_BKCOLOR}
  DMI_USERECT = $00000004;
  {$EXTERNALSYM DMI_USERECT}

//
// PropertySheetType values for the SetupDiGetClassDevPropertySheets API
//
const
  DIGCDP_FLAG_BASIC           = $00000001;
  {$EXTERNALSYM DIGCDP_FLAG_BASIC}
  DIGCDP_FLAG_ADVANCED        = $00000002;
  {$EXTERNALSYM DIGCDP_FLAG_ADVANCED}
  DIGCDP_FLAG_REMOTE_BASIC    = $00000003;
  {$EXTERNALSYM DIGCDP_FLAG_REMOTE_BASIC}
  DIGCDP_FLAG_REMOTE_ADVANCED = $00000004;
  {$EXTERNALSYM DIGCDP_FLAG_REMOTE_ADVANCED}

//
// Define ICON IDs publicly exposed from setupapi.
//
const
  IDI_RESOURCEFIRST        = 159;
  {$EXTERNALSYM IDI_RESOURCEFIRST}
  IDI_RESOURCE             = 159;
  {$EXTERNALSYM IDI_RESOURCE}
  IDI_RESOURCELAST         = 161;
  {$EXTERNALSYM IDI_RESOURCELAST}
  IDI_RESOURCEOVERLAYFIRST = 161;
  {$EXTERNALSYM IDI_RESOURCEOVERLAYFIRST}
  IDI_RESOURCEOVERLAYLAST  = 161;
  {$EXTERNALSYM IDI_RESOURCEOVERLAYLAST}
  IDI_CONFLICT             = 161;
  {$EXTERNALSYM IDI_CONFLICT}

  IDI_CLASSICON_OVERLAYFIRST = 500;
  {$EXTERNALSYM IDI_CLASSICON_OVERLAYFIRST}
  IDI_CLASSICON_OVERLAYLAST  = 502;
  {$EXTERNALSYM IDI_CLASSICON_OVERLAYLAST}
  IDI_PROBLEM_OVL            = 500;
  {$EXTERNALSYM IDI_PROBLEM_OVL}
  IDI_DISABLED_OVL           = 501;
  {$EXTERNALSYM IDI_DISABLED_OVL}
  IDI_FORCED_OVL             = 502;
  {$EXTERNALSYM IDI_FORCED_OVL}

//
// PageType values for SetupDiGetWizardPage API
//
const
  SPWPT_SELECTDEVICE = $00000001;
  {$EXTERNALSYM SPWPT_SELECTDEVICE}

//
// Flags for SetupDiGetWizardPage API
//
  SPWP_USE_DEVINFO_DATA = $00000001;
{$EXTERNALSYM SPWP_USE_DEVINFO_DATA}

{$IFDEF WINXP_UP}
type
  PSP_INF_SIGNER_INFO_A = ^SP_INF_SIGNER_INFO_A;
  {$EXTERNALSYM PSP_INF_SIGNER_INFO_A}
  SP_INF_SIGNER_INFO_A = packed record
    cbSize: DWORD;
    CatalogFile: array [0..MAX_PATH - 1] of Char;
    DigitalSigner: array [0..MAX_PATH - 1] of Char;
    DigitalSignerVersion: array [0..MAX_PATH - 1] of Char;
  end;
  {$EXTERNALSYM SP_INF_SIGNER_INFO_A}

  PSP_INF_SIGNER_INFO_W = ^SP_INF_SIGNER_INFO_W;
  {$EXTERNALSYM PSP_INF_SIGNER_INFO_A}
  SP_INF_SIGNER_INFO_W = packed record
    cbSize: DWORD;
    CatalogFile: array [0..MAX_PATH - 1] of WideChar;
    DigitalSigner: array [0..MAX_PATH - 1] of WideChar;
    DigitalSignerVersion: array [0..MAX_PATH - 1] of WideChar;
  end;
  {$EXTERNALSYM SP_INF_SIGNER_INFO_W}

  TSPInfSignerInfoA = SP_INF_SIGNER_INFO_A;
  TSPInfSignerInfoW = SP_INF_SIGNER_INFO_W;
  PSPInfSignerInfoA = ^TSPInfSignerInfoA;
  PSPInfSignerInfoW = ^TSPInfSignerInfoW;
  {$IFDEF UNICODE}
  TSPInfSignerInfo = TSPInfSignerInfoW;
  PSPInfSignerInfo = PSPInfSignerInfoW;
  SP_INF_SIGNER_INFO = SP_INF_SIGNER_INFO_W;
  {$EXTERNALSYM SP_INF_SIGNER_INFO}
  PSP_INF_SIGNER_INFO = PSP_INF_SIGNER_INFO_W;
  {$EXTERNALSYM PSP_INF_SIGNER_INFO}
  {$ELSE}
  TSPInfSignerInfo = TSPInfSignerInfoA;
  PSPInfSignerInfo = PSPInfSignerInfoA;
  SP_INF_SIGNER_INFO = SP_INF_SIGNER_INFO_A;
  {$EXTERNALSYM SP_INF_SIGNER_INFO}
  PSP_INF_SIGNER_INFO = PSP_INF_SIGNER_INFO_A;
  {$EXTERNALSYM PSP_INF_SIGNER_INFO}
  {$ENDIF UNICODE}

//
// Flags for use by SetupDiGetCustomDeviceProperty
//
const
  DICUSTOMDEVPROP_MERGE_MULTISZ = $00000001;
{$ENDIF WINXP_UP}

{$IFNDEF SETUPAPI_LINKONREQUEST}

{$IFDEF WINXP_UP}
function SetupGetFileQueueCount(FileQueue: HSPFILEQ; SubQueueFileOp: UINT; var NumOperations: UINT): BOOL; stdcall;
{$EXTERNALSYM SetupGetFileQueueCount}
function SetupGetFileQueueFlags(FileQueue: HSPFILEQ; var Flags: DWORD): BOOL; stdcall;
{$EXTERNALSYM SetupGetFileQueueFlags}
function SetupSetFileQueueFlags(FileQueue: HSPFILEQ; FlagMask: DWORD; Flags: DWORD): BOOL; stdcall;
{$EXTERNALSYM SetupSetFileQueueFlags}
{$ENDIF WINXP_UP}
function SetupGetInfInformationA(InfSpec: Pointer; SearchControl: DWORD;
  ReturnBuffer: PSPInfInformation; ReturnBufferSize: DWORD; RequiredSize: PDWORD): BOOL; stdcall;
{$EXTERNALSYM SetupGetInfInformationA}
function SetupGetInfInformationW(InfSpec: Pointer; SearchControl: DWORD;
  ReturnBuffer: PSPInfInformation; ReturnBufferSize: DWORD; RequiredSize: PDWORD): BOOL; stdcall;
{$EXTERNALSYM SetupGetInfInformationW}
function SetupGetInfInformation(InfSpec: Pointer; SearchControl: DWORD;
  ReturnBuffer: PSPInfInformation; ReturnBufferSize: DWORD; RequiredSize: PDWORD): BOOL; stdcall;
{$EXTERNALSYM SetupGetInfInformation}

function SetupQueryInfFileInformationA(var InfInformation: TSPInfInformation;
  InfIndex: UINT; ReturnBuffer: PAnsiChar; ReturnBufferSize: DWORD;
  RequiredSize: PDWORD): BOOL; stdcall;
{$EXTERNALSYM SetupQueryInfFileInformationA}
function SetupQueryInfFileInformationW(var InfInformation: TSPInfInformation;
  InfIndex: UINT; ReturnBuffer: PWideChar; ReturnBufferSize: DWORD;
  RequiredSize: PDWORD): BOOL; stdcall;
{$EXTERNALSYM SetupQueryInfFileInformationW}
function SetupQueryInfFileInformation(var InfInformation: TSPInfInformation;
  InfIndex: UINT; ReturnBuffer: PTSTR; ReturnBufferSize: DWORD;
  RequiredSize: PDWORD): BOOL; stdcall;
{$EXTERNALSYM SetupQueryInfFileInformation}

{$IFDEF WIN2000_UP}
function SetupQueryInfOriginalFileInformationA(var InfInformation: TSPInfInformation;
  InfIndex: UINT; AlternatePlatformInfo: PSPAltPlatformInfo;
  var OriginalFileInfo: TSPOriginalFileInfoA): BOOL; stdcall;
{$EXTERNALSYM SetupQueryInfOriginalFileInformationA}
function SetupQueryInfOriginalFileInformationW(var InfInformation: TSPInfInformation;
  InfIndex: UINT; AlternatePlatformInfo: PSPAltPlatformInfo;
  var OriginalFileInfo: TSPOriginalFileInfoW): BOOL; stdcall;
{$EXTERNALSYM SetupQueryInfOriginalFileInformationW}
function SetupQueryInfOriginalFileInformation(var InfInformation: TSPInfInformation;
  InfIndex: UINT; AlternatePlatformInfo: PSPAltPlatformInfo;
  var OriginalFileInfo: TSPOriginalFileInfo): BOOL; stdcall;
{$EXTERNALSYM SetupQueryInfOriginalFileInformation}
{$ENDIF WIN2000_UP}

function SetupQueryInfVersionInformationA(var InfInformation: TSPInfInformation;
  InfIndex: UINT; const Key, ReturnBuffer: PAnsiChar; ReturnBufferSize: DWORD;
  RequiredSize: PDWORD): BOOL; stdcall;
{$EXTERNALSYM SetupQueryInfVersionInformationA}
function SetupQueryInfVersionInformationW(var InfInformation: TSPInfInformation;
  InfIndex: UINT; const Key, ReturnBuffer: PWideChar; ReturnBufferSize: DWORD;
  RequiredSize: PDWORD): BOOL; stdcall;
{$EXTERNALSYM SetupQueryInfVersionInformationW}
function SetupQueryInfVersionInformation(var InfInformation: TSPInfInformation;
  InfIndex: UINT; const Key, ReturnBuffer: PTSTR; ReturnBufferSize: DWORD;
  RequiredSize: PDWORD): BOOL; stdcall;
{$EXTERNALSYM SetupQueryInfVersionInformation}

function SetupGetInfFileListA(const DirectoryPath: PAnsiChar; InfStyle: DWORD;
  ReturnBuffer: PAnsiChar; ReturnBufferSize: DWORD; RequiredSize: PDWORD): BOOL; stdcall;
{$EXTERNALSYM SetupGetInfFileListA}
function SetupGetInfFileListW(const DirectoryPath: PWideChar; InfStyle: DWORD;
  ReturnBuffer: PWideChar; ReturnBufferSize: DWORD; RequiredSize: PDWORD): BOOL; stdcall;
{$EXTERNALSYM SetupGetInfFileListW}
function SetupGetInfFileList(const DirectoryPath: PTSTR; InfStyle: DWORD;
  ReturnBuffer: PTSTR; ReturnBufferSize: DWORD; RequiredSize: PDWORD): BOOL; stdcall;
{$EXTERNALSYM SetupGetInfFileList}

function SetupOpenInfFileA(const FileName: PAnsiChar; const InfClass: PAnsiChar;
  InfStyle: DWORD; ErrorLine: PUINT): HINF; stdcall;
{$EXTERNALSYM SetupOpenInfFileA}
function SetupOpenInfFileW(const FileName: PWideChar; const InfClass: PWideChar;
  InfStyle: DWORD; ErrorLine: PUINT): HINF; stdcall;
{$EXTERNALSYM SetupOpenInfFileW}
function SetupOpenInfFile(const FileName: PTSTR; const InfClass: PTSTR;
  InfStyle: DWORD; ErrorLine: PUINT): HINF; stdcall;
{$EXTERNALSYM SetupOpenInfFile}

function SetupOpenMasterInf: HINF; stdcall;
{$EXTERNALSYM SetupOpenMasterInf}

function SetupOpenAppendInfFileA(const FileName: PAnsiChar; InfHandle: HINF;
  ErrorLine: PUINT): BOOL; stdcall;
{$EXTERNALSYM SetupOpenAppendInfFileA}
function SetupOpenAppendInfFileW(const FileName: PWideChar; InfHandle: HINF;
  ErrorLine: PUINT): BOOL; stdcall;
{$EXTERNALSYM SetupOpenAppendInfFileW}
function SetupOpenAppendInfFile(const FileName: PTSTR; InfHandle: HINF;
  ErrorLine: PUINT): BOOL; stdcall;
{$EXTERNALSYM SetupOpenAppendInfFile}

procedure SetupCloseInfFile(InfHandle: HINF); stdcall;
{$EXTERNALSYM SetupCloseInfFile}

function SetupFindFirstLineA(InfHandle: HINF; Section, Key: PAnsiChar;
  var Context: TInfContext): BOOL; stdcall;
{$EXTERNALSYM SetupFindFirstLineA}
function SetupFindFirstLineW(InfHandle: HINF; Section, Key: PWideChar;
  var Context: TInfContext): BOOL; stdcall;
{$EXTERNALSYM SetupFindFirstLineW}
function SetupFindFirstLine(InfHandle: HINF; Section, Key: PTSTR;
  var Context: TInfContext): BOOL; stdcall;
{$EXTERNALSYM SetupFindFirstLine}

function SetupFindNextLine(var ContextIn, ContextOut: TInfContext): BOOL; stdcall;
{$EXTERNALSYM SetupFindNextLine}

function SetupFindNextMatchLineA(var ContextIn: TInfContext; Key: PAnsiChar;
  var ContextOut: TInfContext): BOOL; stdcall;
{$EXTERNALSYM SetupFindNextMatchLineA}
function SetupFindNextMatchLineW(var ContextIn: TInfContext; Key: PWideChar;
  var ContextOut: TInfContext): BOOL; stdcall;
{$EXTERNALSYM SetupFindNextMatchLineW}
function SetupFindNextMatchLine(var ContextIn: TInfContext; Key: PTSTR;
  var ContextOut: TInfContext): BOOL; stdcall;
{$EXTERNALSYM SetupFindNextMatchLine}

function SetupGetLineByIndexA(InfHandle: HINF; Section: PAnsiChar; Index: DWORD;
  var Context: TInfContext): BOOL; stdcall;
{$EXTERNALSYM SetupGetLineByIndexA}
function SetupGetLineByIndexW(InfHandle: HINF; Section: PWideChar; Index: DWORD;
  var Context: TInfContext): BOOL; stdcall;
{$EXTERNALSYM SetupGetLineByIndexW}
function SetupGetLineByIndex(InfHandle: HINF; Section: PTSTR; Index: DWORD;
  var Context: TInfContext): BOOL; stdcall;
{$EXTERNALSYM SetupGetLineByIndex}

function SetupGetLineCountA(InfHandle: HINF; Section: PAnsiChar): Integer; stdcall;
{$EXTERNALSYM SetupGetLineCountA}
function SetupGetLineCountW(InfHandle: HINF; Section: PWideChar): Integer; stdcall;
{$EXTERNALSYM SetupGetLineCountW}
function SetupGetLineCount(InfHandle: HINF; Section: PTSTR): Integer; stdcall;
{$EXTERNALSYM SetupGetLineCount}

function SetupGetLineTextA(Context: PInfContext; InfHandle: HINF; Section,
  Key, ReturnBuffer: PAnsiChar; ReturnBufferSize: DWORD; RequiredSize: PDWORD): BOOL; stdcall;
{$EXTERNALSYM SetupGetLineTextA}
function SetupGetLineTextW(Context: PInfContext; InfHandle: HINF; Section,
  Key, ReturnBuffer: PWideChar; ReturnBufferSize: DWORD; RequiredSize: PDWORD): BOOL; stdcall;
{$EXTERNALSYM SetupGetLineTextW}
function SetupGetLineText(Context: PInfContext; InfHandle: HINF; Section,
  Key, ReturnBuffer: PTSTR; ReturnBufferSize: DWORD; RequiredSize: PDWORD): BOOL; stdcall;
{$EXTERNALSYM SetupGetLineText}

function SetupGetFieldCount(var Context: TInfContext): DWORD; stdcall;
{$EXTERNALSYM SetupGetFieldCount}

function SetupGetStringFieldA(var Context: TInfContext; FieldIndex: DWORD;
  ReturnBuffer: PAnsiChar; ReturnBufferSize: DWORD; RequiredSize: PDWORD): BOOL; stdcall;
{$EXTERNALSYM SetupGetStringFieldA}
function SetupGetStringFieldW(var Context: TInfContext; FieldIndex: DWORD;
  ReturnBuffer: PWideChar; ReturnBufferSize: DWORD; RequiredSize: PDWORD): BOOL; stdcall;
{$EXTERNALSYM SetupGetStringFieldW}
function SetupGetStringField(var Context: TInfContext; FieldIndex: DWORD;
  ReturnBuffer: PTSTR; ReturnBufferSize: DWORD; RequiredSize: PDWORD): BOOL; stdcall;
{$EXTERNALSYM SetupGetStringField}

function SetupGetIntField(var Context: TInfContext; FieldIndex: DWORD;
  var IntegerValue: Integer): BOOL; stdcall;
{$EXTERNALSYM SetupGetIntField}

function SetupGetMultiSzFieldA(var Context: TInfContext; FieldIndex: DWORD;
  ReturnBuffer: PAnsiChar; ReturnBufferSize: DWORD; RequiredSize: PDWORD): BOOL; stdcall;
{$EXTERNALSYM SetupGetMultiSzFieldA}
function SetupGetMultiSzFieldW(var Context: TInfContext; FieldIndex: DWORD;
  ReturnBuffer: PWideChar; ReturnBufferSize: DWORD; RequiredSize: PDWORD): BOOL; stdcall;
{$EXTERNALSYM SetupGetMultiSzFieldW}
function SetupGetMultiSzField(var Context: TInfContext; FieldIndex: DWORD;
  ReturnBuffer: PTSTR; ReturnBufferSize: DWORD; RequiredSize: PDWORD): BOOL; stdcall;
{$EXTERNALSYM SetupGetMultiSzField}

function SetupGetBinaryField(var Context: TInfContext; FieldIndex: DWORD;
  ReturnBuffer: PBYTE; ReturnBufferSize: DWORD; RequiredSize: PDWORD): BOOL; stdcall;
{$EXTERNALSYM SetupGetBinaryField}

//
// SetupGetFileCompressionInfo is depreciated
// use SetupGetFileCompressionInfoEx instead
//
// ActualSourceFileName returned by SetupGetFileCompressionInfo
// must be freed by the export setupapi!MyFree (NT4+ Win95+)
// or LocalFree (Win2k+)
//
function SetupGetFileCompressionInfoA(const SourceFileName: PAnsiChar;
  var ActualSourceFileName: PAnsiChar; var SourceFileSize: DWORD;
  var TargetFileSize: DWORD; var CompressionType: UINT): DWORD; stdcall;
{$EXTERNALSYM SetupGetFileCompressionInfoA}
function SetupGetFileCompressionInfoW(const SourceFileName: PWideChar;
  var ActualSourceFileName: PWideChar; var SourceFileSize: DWORD;
  var TargetFileSize: DWORD; var CompressionType: UINT): DWORD; stdcall;
{$EXTERNALSYM SetupGetFileCompressionInfoW}
function SetupGetFileCompressionInfo(const SourceFileName: PTSTR;
  var ActualSourceFileName: PTSTR; var SourceFileSize: DWORD;
  var TargetFileSize: DWORD; var CompressionType: UINT): DWORD; stdcall;
{$EXTERNALSYM SetupGetFileCompressionInfo}

{$IFDEF WINXP_UP}
//
// SetupGetFileCompressionInfoEx is the preferred API over
// SetupGetFileCompressionInfo. It follows the normal
// conventions of returning BOOL and writing to user-supplied
// buffer.
//
function SetupGetFileCompressionInfoExA(const SourceFileName: PAnsiChar;
  ActualSourceFileNameBuffer: PAnsiChar; var ActualSourceFileNameBufferLen: DWORD;
  RequiredBufferLen: PDWORD; var SourceFileSize: DWORD;
  var TargetFileSize: DWORD; var CompressionType: UINT): BOOL; stdcall;
{$EXTERNALSYM SetupGetFileCompressionInfoExA}
function SetupGetFileCompressionInfoExW(const SourceFileName: PWideChar;
  ActualSourceFileNameBuffer: PWideChar; var ActualSourceFileNameBufferLen: DWORD;
  RequiredBufferLen: PDWORD; var SourceFileSize: DWORD;
  var TargetFileSize: DWORD; var CompressionType: UINT): BOOL; stdcall;
{$EXTERNALSYM SetupGetFileCompressionInfoExW}
function SetupGetFileCompressionInfoEx(const SourceFileName: PTSTR;
  ActualSourceFileNameBuffer: PTSTR; var ActualSourceFileNameBufferLen: DWORD;
  RequiredBufferLen: PDWORD; var SourceFileSize: DWORD;
  var TargetFileSize: DWORD; var CompressionType: UINT): BOOL; stdcall;
{$EXTERNALSYM SetupGetFileCompressionInfoEx}
{$ENDIF WINXP_UP}

function SetupDecompressOrCopyFileA(const SourceFileName, TargetFileName: PAnsiChar;
  var CompressionType: UINT): DWORD; stdcall;
{$EXTERNALSYM SetupDecompressOrCopyFileA}
function SetupDecompressOrCopyFileW(const SourceFileName, TargetFileName: PWideChar;
  var CompressionType: UINT): DWORD; stdcall;
{$EXTERNALSYM SetupDecompressOrCopyFileW}
function SetupDecompressOrCopyFile(const SourceFileName, TargetFileName: PTSTR;
  var CompressionType: UINT): DWORD; stdcall;
{$EXTERNALSYM SetupDecompressOrCopyFile}

function SetupGetSourceFileLocationA(InfHandle: HINF; InfContext: PInfContext;
  const FileName: PAnsiChar; var SourceId: UINT; ReturnBuffer: PAnsiChar;
  ReturnBufferSize: DWORD; RequiredSize: PDWORD): BOOL; stdcall;
{$EXTERNALSYM SetupGetSourceFileLocationA}
function SetupGetSourceFileLocationW(InfHandle: HINF; InfContext: PInfContext;
  const FileName: PWideChar; var SourceId: UINT; ReturnBuffer: PWideChar;
  ReturnBufferSize: DWORD; RequiredSize: PDWORD): BOOL; stdcall;
{$EXTERNALSYM SetupGetSourceFileLocationW}
function SetupGetSourceFileLocation(InfHandle: HINF; InfContext: PInfContext;
  const FileName: PTSTR; var SourceId: UINT; ReturnBuffer: PTSTR;
  ReturnBufferSize: DWORD; RequiredSize: PDWORD): BOOL; stdcall;
{$EXTERNALSYM SetupGetSourceFileLocation}

function SetupGetSourceFileSizeA(InfHandle: HINF; InfContext: PInfContext;
  const FileName: PAnsiChar; const Section: PAnsiChar; var FileSize: DWORD;
  RoundingFactor: UINT): BOOL; stdcall;
{$EXTERNALSYM SetupGetSourceFileSizeA}
function SetupGetSourceFileSizeW(InfHandle: HINF; InfContext: PInfContext;
  const FileName: PWideChar; const Section: PWideChar; var FileSize: DWORD;
  RoundingFactor: UINT): BOOL; stdcall;
{$EXTERNALSYM SetupGetSourceFileSizeW}
function SetupGetSourceFileSize(InfHandle: HINF; InfContext: PInfContext;
  const FileName: PTSTR; const Section: PTSTR; var FileSize: DWORD;
  RoundingFactor: UINT): BOOL; stdcall;
{$EXTERNALSYM SetupGetSourceFileSize}

function SetupGetTargetPathA(InfHandle: HINF; InfContext: PInfContext;
  const Section: PAnsiChar; ReturnBuffer: PAnsiChar; ReturnBufferSize: DWORD;
  RequiredSize: PDWORD): BOOL; stdcall;
{$EXTERNALSYM SetupGetTargetPathA}
function SetupGetTargetPathW(InfHandle: HINF; InfContext: PInfContext;
  const Section: PWideChar; ReturnBuffer: PWideChar; ReturnBufferSize: DWORD;
  RequiredSize: PDWORD): BOOL; stdcall;
{$EXTERNALSYM SetupGetTargetPathW}
function SetupGetTargetPath(InfHandle: HINF; InfContext: PInfContext;
  const Section: PTSTR; ReturnBuffer: PTSTR; ReturnBufferSize: DWORD;
  RequiredSize: PDWORD): BOOL; stdcall;
{$EXTERNALSYM SetupGetTargetPath}

function SetupSetSourceListA(Flags: DWORD; SourceList: PPASTR;
  SourceCount: UINT): BOOL; stdcall;
{$EXTERNALSYM SetupSetSourceListA}
function SetupSetSourceListW(Flags: DWORD; SourceList: PPWSTR;
  SourceCount: UINT): BOOL; stdcall;
{$EXTERNALSYM SetupSetSourceListW}
function SetupSetSourceList(Flags: DWORD; SourceList: PPSTR;
  SourceCount: UINT): BOOL; stdcall;
{$EXTERNALSYM SetupSetSourceList}

function SetupCancelTemporarySourceList: BOOL; stdcall;
{$EXTERNALSYM SetupCancelTemporarySourceList}

function SetupAddToSourceListA(Flags: DWORD; const Source: PAnsiChar): BOOL; stdcall;
{$EXTERNALSYM SetupAddToSourceListA}
function SetupAddToSourceListW(Flags: DWORD; const Source: PWideChar): BOOL; stdcall;
{$EXTERNALSYM SetupAddToSourceListW}
function SetupAddToSourceList(Flags: DWORD; const Source: PTSTR): BOOL; stdcall;
{$EXTERNALSYM SetupAddToSourceList}

function SetupRemoveFromSourceListA(Flags: DWORD; const Source: PAnsiChar): BOOL; stdcall;
{$EXTERNALSYM SetupRemoveFromSourceListA}
function SetupRemoveFromSourceListW(Flags: DWORD; const Source: PWideChar): BOOL; stdcall;
{$EXTERNALSYM SetupRemoveFromSourceListW}
function SetupRemoveFromSourceList(Flags: DWORD; const Source: PTSTR): BOOL; stdcall;
{$EXTERNALSYM SetupRemoveFromSourceList}

function SetupQuerySourceListA(Flags: DWORD; var List: PPASTR;
  var Count: UINT): BOOL; stdcall;
{$EXTERNALSYM SetupQuerySourceListA}
function SetupQuerySourceListW(Flags: DWORD; var List: PPWSTR;
  var Count: UINT): BOOL; stdcall;
{$EXTERNALSYM SetupQuerySourceListW}
function SetupQuerySourceList(Flags: DWORD; var List: PPSTR;
  var Count: UINT): BOOL; stdcall;
{$EXTERNALSYM SetupQuerySourceList}

function SetupFreeSourceListA(var List: PPASTR; Count: UINT): BOOL; stdcall;
{$EXTERNALSYM SetupFreeSourceListA}
function SetupFreeSourceListW(var List: PPWSTR; Count: UINT): BOOL; stdcall;
{$EXTERNALSYM SetupFreeSourceListW}
function SetupFreeSourceList(var List: PPSTR; Count: UINT): BOOL; stdcall;
{$EXTERNALSYM SetupFreeSourceList}

function SetupPromptForDiskA(hwndParent: HWND; const DialogTitle, DiskName,
  PathToSource, FileSought, TagFile: PAnsiChar; DiskPromptStyle: DWORD;
  PathBuffer: PAnsiChar; PathBufferSize: DWORD; var PathRequiredSize: DWORD): UINT; stdcall;
{$EXTERNALSYM SetupPromptForDiskA}
function SetupPromptForDiskW(hwndParent: HWND; const DialogTitle, DiskName,
  PathToSource, FileSought, TagFile: PWideChar; DiskPromptStyle: DWORD;
  PathBuffer: PWideChar; PathBufferSize: DWORD; var PathRequiredSize: DWORD): UINT; stdcall;
{$EXTERNALSYM SetupPromptForDiskW}
function SetupPromptForDisk(hwndParent: HWND; const DialogTitle, DiskName,
  PathToSource, FileSought, TagFile: PTSTR; DiskPromptStyle: DWORD;
  PathBuffer: PTSTR; PathBufferSize: DWORD; var PathRequiredSize: DWORD): UINT; stdcall;
{$EXTERNALSYM SetupPromptForDisk}

function SetupCopyErrorA(hwndParent: HWND; const DialogTitle, DiskName,
  PathToSource, SourceFile, TargetPathFile: PAnsiChar; Win32ErrorCode: UINT; Style: DWORD;
  PathBuffer: PAnsiChar; PathBufferSize: DWORD; PathRequiredSize: PDWORD): UINT; stdcall;
{$EXTERNALSYM SetupCopyErrorA}
function SetupCopyErrorW(hwndParent: HWND; const DialogTitle, DiskName,
  PathToSource, SourceFile, TargetPathFile: PWideChar; Win32ErrorCode: UINT; Style: DWORD;
  PathBuffer: PWideChar; PathBufferSize: DWORD; PathRequiredSize: PDWORD): UINT; stdcall;
{$EXTERNALSYM SetupCopyErrorW}
function SetupCopyError(hwndParent: HWND; const DialogTitle, DiskName,
  PathToSource, SourceFile, TargetPathFile: PTSTR; Win32ErrorCode: UINT; Style: DWORD;
  PathBuffer: PTSTR; PathBufferSize: DWORD; PathRequiredSize: PDWORD): UINT; stdcall;
{$EXTERNALSYM SetupCopyError}

function SetupRenameErrorA(hwndParent: HWND; const DialogTitle, SourceFile,
  TargetFile: PAnsiChar; Win32ErrorCode: UINT; Style: DWORD): UINT; stdcall;
{$EXTERNALSYM SetupRenameErrorA}
function SetupRenameErrorW(hwndParent: HWND; const DialogTitle, SourceFile,
  TargetFile: PWideChar; Win32ErrorCode: UINT; Style: DWORD): UINT; stdcall;
{$EXTERNALSYM SetupRenameErrorW}
function SetupRenameError(hwndParent: HWND; const DialogTitle, SourceFile,
  TargetFile: PTSTR; Win32ErrorCode: UINT; Style: DWORD): UINT; stdcall;
{$EXTERNALSYM SetupRenameError}

function SetupDeleteErrorA(hwndParent: HWND; const DialogTitle, File_: PAnsiChar;
  Win32ErrorCode: UINT; Style: DWORD): UINT; stdcall;
{$EXTERNALSYM SetupDeleteErrorA}
function SetupDeleteErrorW(hwndParent: HWND; const DialogTitle, File_: PWideChar;
  Win32ErrorCode: UINT; Style: DWORD): UINT; stdcall;
{$EXTERNALSYM SetupDeleteErrorW}
function SetupDeleteError(hwndParent: HWND; const DialogTitle, File_: PTSTR;
  Win32ErrorCode: UINT; Style: DWORD): UINT; stdcall;
{$EXTERNALSYM SetupDeleteError}

{$IFDEF WIN2000_UP}
function SetupBackupErrorA(hwndParent: HWND; const DialogTitle, SourceFile,
  TargetFile: PAnsiChar; Win32ErrorCode: UINT; Style: DWORD): UINT; stdcall;
{$EXTERNALSYM SetupBackupErrorA}
function SetupBackupErrorW(hwndParent: HWND; const DialogTitle, SourceFile,
  TargetFile: PWideChar; Win32ErrorCode: UINT; Style: DWORD): UINT; stdcall;
{$EXTERNALSYM SetupBackupErrorW}
function SetupBackupError(hwndParent: HWND; const DialogTitle, SourceFile,
  TargetFile: PTSTR; Win32ErrorCode: UINT; Style: DWORD): UINT; stdcall;
{$EXTERNALSYM SetupBackupError}
{$ENDIF WIN2000_UP}

function SetupSetDirectoryIdA(InfHandle: HINF; Id: DWORD; const Directory: PAnsiChar): BOOL; stdcall;
{$EXTERNALSYM SetupSetDirectoryIdA}
function SetupSetDirectoryIdW(InfHandle: HINF; Id: DWORD; const Directory: PWideChar): BOOL; stdcall;
{$EXTERNALSYM SetupSetDirectoryIdW}
function SetupSetDirectoryId(InfHandle: HINF; Id: DWORD; const Directory: PTSTR): BOOL; stdcall;
{$EXTERNALSYM SetupSetDirectoryId}

function SetupSetDirectoryIdExA(InfHandle: HINF; Id: DWORD; const Directory: PAnsiChar;
  Flags: DWORD; Reserved1: DWORD; Reserved2: Pointer): BOOL; stdcall;
{$EXTERNALSYM SetupSetDirectoryIdExA}
function SetupSetDirectoryIdExW(InfHandle: HINF; Id: DWORD; const Directory: PWideChar;
  Flags: DWORD; Reserved1: DWORD; Reserved2: Pointer): BOOL; stdcall;
{$EXTERNALSYM SetupSetDirectoryIdExW}
function SetupSetDirectoryIdEx(InfHandle: HINF; Id: DWORD; const Directory: PTSTR;
  Flags: DWORD; Reserved1: DWORD; Reserved2: Pointer): BOOL; stdcall;
{$EXTERNALSYM SetupSetDirectoryIdEx}

function SetupGetSourceInfoA(InfHandle: HINF; SourceId, InfoDesired: UINT;
  ReturnBuffer: PAnsiChar; ReturnBufferSize: DWORD; RequiredSize: PDWORD): BOOL; stdcall;
{$EXTERNALSYM SetupGetSourceInfoA}
function SetupGetSourceInfoW(InfHandle: HINF; SourceId, InfoDesired: UINT;
  ReturnBuffer: PWideChar; ReturnBufferSize: DWORD; RequiredSize: PDWORD): BOOL; stdcall;
{$EXTERNALSYM SetupGetSourceInfoW}
function SetupGetSourceInfo(InfHandle: HINF; SourceId, InfoDesired: UINT;
  ReturnBuffer: PTSTR; ReturnBufferSize: DWORD; RequiredSize: PDWORD): BOOL; stdcall;
{$EXTERNALSYM SetupGetSourceInfo}

function SetupInstallFileA(InfHandle: HINF; InfContext: PInfContext;
  const SourceFile, SourcePathRoot, DestinationName: PAnsiChar; CopyStyle: DWORD;
  CopyMsgHandler: TSPFileCallbackA; Context: Pointer): BOOL; stdcall;
{$EXTERNALSYM SetupInstallFileA}
function SetupInstallFileW(InfHandle: HINF; InfContext: PInfContext;
  const SourceFile, SourcePathRoot, DestinationName: PWideChar; CopyStyle: DWORD;
  CopyMsgHandler: TSPFileCallbackW; Context: Pointer): BOOL; stdcall;
{$EXTERNALSYM SetupInstallFileW}
function SetupInstallFile(InfHandle: HINF; InfContext: PInfContext;
  const SourceFile, SourcePathRoot, DestinationName: PTSTR; CopyStyle: DWORD;
  CopyMsgHandler: TSPFileCallback; Context: Pointer): BOOL; stdcall;
{$EXTERNALSYM SetupInstallFile}

function SetupInstallFileExA(InfHandle: HINF; InfContext: PInfContext;
  const SourceFile, SourcePathRoot, DestinationName: PAnsiChar; CopyStyle: DWORD;
  CopyMsgHandler: TSPFileCallbackA; Context: Pointer; var FileWasInUse: BOOL): BOOL; stdcall;
{$EXTERNALSYM SetupInstallFileExA}
function SetupInstallFileExW(InfHandle: HINF; InfContext: PInfContext;
  const SourceFile, SourcePathRoot, DestinationName: PWideChar; CopyStyle: DWORD;
  CopyMsgHandler: TSPFileCallbackW; Context: Pointer; var FileWasInUse: BOOL): BOOL; stdcall;
{$EXTERNALSYM SetupInstallFileExW}
function SetupInstallFileEx(InfHandle: HINF; InfContext: PInfContext;
  const SourceFile, SourcePathRoot, DestinationName: PTSTR; CopyStyle: DWORD;
  CopyMsgHandler: TSPFileCallback; Context: Pointer; var FileWasInUse: BOOL): BOOL; stdcall;
{$EXTERNALSYM SetupInstallFileEx}

function SetupOpenFileQueue: HSPFILEQ; stdcall;
{$EXTERNALSYM SetupOpenFileQueue}

function SetupCloseFileQueue(QueueHandle: HSPFILEQ): BOOL; stdcall;
{$EXTERNALSYM SetupCloseFileQueue}

{$IFDEF WIN2000_UP}
function SetupSetFileQueueAlternatePlatformA(QueueHandle: HSPFILEQ;
  AlternatePlatformInfo: PSPAltPlatformInfo;
  const AlternateDefaultCatalogFile: PAnsiChar): BOOL; stdcall;
{$EXTERNALSYM SetupSetFileQueueAlternatePlatformA}
function SetupSetFileQueueAlternatePlatformW(QueueHandle: HSPFILEQ;
  AlternatePlatformInfo: PSPAltPlatformInfo;
  const AlternateDefaultCatalogFile: PWideChar): BOOL; stdcall;
{$EXTERNALSYM SetupSetFileQueueAlternatePlatformW}
function SetupSetFileQueueAlternatePlatform(QueueHandle: HSPFILEQ;
  AlternatePlatformInfo: PSPAltPlatformInfo;
  const AlternateDefaultCatalogFile: PTSTR): BOOL; stdcall;
{$EXTERNALSYM SetupSetFileQueueAlternatePlatform}
{$ENDIF WIN2000_UP}

function SetupSetPlatformPathOverrideA(const Override_: PAnsiChar): BOOL; stdcall;
{$EXTERNALSYM SetupSetPlatformPathOverrideA}
function SetupSetPlatformPathOverrideW(const Override_: PWideChar): BOOL; stdcall;
{$EXTERNALSYM SetupSetPlatformPathOverrideW}
function SetupSetPlatformPathOverride(const Override_: PTSTR): BOOL; stdcall;
{$EXTERNALSYM SetupSetPlatformPathOverride}

function SetupQueueCopyA(QueueHandle: HSPFILEQ; const SourceRootPath, SourcePath,
  SourceFilename, SourceDescription, SourceTagfile, TargetDirectory,
  TargetFilename: PAnsiChar; CopyStyle: DWORD): BOOL; stdcall;
{$EXTERNALSYM SetupQueueCopyA}
function SetupQueueCopyW(QueueHandle: HSPFILEQ; const SourceRootPath, SourcePath,
  SourceFilename, SourceDescription, SourceTagfile, TargetDirectory,
  TargetFilename: PWideChar; CopyStyle: DWORD): BOOL; stdcall;
{$EXTERNALSYM SetupQueueCopyW}
function SetupQueueCopy(QueueHandle: HSPFILEQ; const SourceRootPath, SourcePath,
  SourceFilename, SourceDescription, SourceTagfile, TargetDirectory,
  TargetFilename: PTSTR; CopyStyle: DWORD): BOOL; stdcall;
{$EXTERNALSYM SetupQueueCopy}

{$IFDEF WIN2000_UP}
function SetupQueueCopyIndirectA(var CopyParams: TSPFileCopyParamsA): BOOL; stdcall;
{$EXTERNALSYM SetupQueueCopyIndirectA}
function SetupQueueCopyIndirectW(var CopyParams: TSPFileCopyParamsW): BOOL; stdcall;
{$EXTERNALSYM SetupQueueCopyIndirectW}
function SetupQueueCopyIndirect(var CopyParams: TSPFileCopyParams): BOOL; stdcall;
{$EXTERNALSYM SetupQueueCopyIndirect}
{$ENDIF WIN2000_UP}

function SetupQueueDefaultCopyA(QueueHandle: HSPFILEQ; InfHandle: HINF;
  const SourceRootPath, SourceFilename, TargetFilename: PAnsiChar;
  CopyStyle: DWORD): BOOL; stdcall;
{$EXTERNALSYM SetupQueueDefaultCopyA}
function SetupQueueDefaultCopyW(QueueHandle: HSPFILEQ; InfHandle: HINF;
  const SourceRootPath, SourceFilename, TargetFilename: PWideChar;
  CopyStyle: DWORD): BOOL; stdcall;
{$EXTERNALSYM SetupQueueDefaultCopyW}
function SetupQueueDefaultCopy(QueueHandle: HSPFILEQ; InfHandle: HINF;
  const SourceRootPath, SourceFilename, TargetFilename: PTSTR;
  CopyStyle: DWORD): BOOL; stdcall;
{$EXTERNALSYM SetupQueueDefaultCopy}

function SetupQueueCopySectionA(QueueHandle: HSPFILEQ; const SourceRootPath: PAnsiChar;
  InfHandle: HINF; ListInfHandle: HINF; const Section: PAnsiChar; CopyStyle: DWORD): BOOL; stdcall;
{$EXTERNALSYM SetupQueueCopySectionA}
function SetupQueueCopySectionW(QueueHandle: HSPFILEQ; const SourceRootPath: PWideChar;
  InfHandle: HINF; ListInfHandle: HINF; const Section: PWideChar; CopyStyle: DWORD): BOOL; stdcall;
{$EXTERNALSYM SetupQueueCopySectionW}
function SetupQueueCopySection(QueueHandle: HSPFILEQ; const SourceRootPath: PTSTR;
  InfHandle: HINF; ListInfHandle: HINF; const Section: PTSTR; CopyStyle: DWORD): BOOL; stdcall;
{$EXTERNALSYM SetupQueueCopySection}

function SetupQueueDeleteA(QueueHandle: HSPFILEQ; const PathPart1, PathPart2: PAnsiChar): BOOL; stdcall;
{$EXTERNALSYM SetupQueueDeleteA}
function SetupQueueDeleteW(QueueHandle: HSPFILEQ; const PathPart1, PathPart2: PWideChar): BOOL; stdcall;
{$EXTERNALSYM SetupQueueDeleteW}
function SetupQueueDelete(QueueHandle: HSPFILEQ; const PathPart1, PathPart2: PTSTR): BOOL; stdcall;
{$EXTERNALSYM SetupQueueDelete}

function SetupQueueDeleteSectionA(QueueHandle: HSPFILEQ; InfHandle: HINF;
  ListInfHandle: HINF; const Section: PAnsiChar): BOOL; stdcall;
{$EXTERNALSYM SetupQueueDeleteSectionA}
function SetupQueueDeleteSectionW(QueueHandle: HSPFILEQ; InfHandle: HINF;
  ListInfHandle: HINF; const Section: PWideChar): BOOL; stdcall;
{$EXTERNALSYM SetupQueueDeleteSectionW}
function SetupQueueDeleteSection(QueueHandle: HSPFILEQ; InfHandle: HINF;
  ListInfHandle: HINF; const Section: PTSTR): BOOL; stdcall;
{$EXTERNALSYM SetupQueueDeleteSection}

function SetupQueueRenameA(QueueHandle: HSPFILEQ; const SourcePath,
  SourceFilename, TargetPath, TargetFilename: PAnsiChar): BOOL; stdcall;
{$EXTERNALSYM SetupQueueRenameA}
function SetupQueueRenameW(QueueHandle: HSPFILEQ; const SourcePath,
  SourceFilename, TargetPath, TargetFilename: PWideChar): BOOL; stdcall;
{$EXTERNALSYM SetupQueueRenameW}
function SetupQueueRename(QueueHandle: HSPFILEQ; const SourcePath,
  SourceFilename, TargetPath, TargetFilename: PTSTR): BOOL; stdcall;
{$EXTERNALSYM SetupQueueRename}

function SetupQueueRenameSectionA(QueueHandle: HSPFILEQ; InfHandle: HINF;
  ListInfHandle: HINF; const Section: PAnsiChar): BOOL; stdcall;
{$EXTERNALSYM SetupQueueRenameSectionA}
function SetupQueueRenameSectionW(QueueHandle: HSPFILEQ; InfHandle: HINF;
  ListInfHandle: HINF; const Section: PWideChar): BOOL; stdcall;
{$EXTERNALSYM SetupQueueRenameSectionW}
function SetupQueueRenameSection(QueueHandle: HSPFILEQ; InfHandle: HINF;
  ListInfHandle: HINF; const Section: PTSTR): BOOL; stdcall;
{$EXTERNALSYM SetupQueueRenameSection}

function SetupCommitFileQueueA(Owner: HWND; QueueHandle: HSPFILEQ;
  MsgHandler: TSPFileCallbackA; Context: Pointer): BOOL; stdcall;
{$EXTERNALSYM SetupCommitFileQueueA}
function SetupCommitFileQueueW(Owner: HWND; QueueHandle: HSPFILEQ;
  MsgHandler: TSPFileCallbackW; Context: Pointer): BOOL; stdcall;
{$EXTERNALSYM SetupCommitFileQueueW}
function SetupCommitFileQueue(Owner: HWND; QueueHandle: HSPFILEQ;
  MsgHandler: TSPFileCallback; Context: Pointer): BOOL; stdcall;
{$EXTERNALSYM SetupCommitFileQueue}

function SetupScanFileQueueA(FileQueue: HSPFILEQ; Flags: DWORD; Window: HWND;
  CallbackRoutine: TSPFileCallbackA; CallbackContext: Pointer; var Result: DWORD): BOOL; stdcall;
{$EXTERNALSYM SetupScanFileQueueA}
function SetupScanFileQueueW(FileQueue: HSPFILEQ; Flags: DWORD; Window: HWND;
  CallbackRoutine: TSPFileCallbackW; CallbackContext: Pointer; var Result: DWORD): BOOL; stdcall;
{$EXTERNALSYM SetupScanFileQueueW}
function SetupScanFileQueue(FileQueue: HSPFILEQ; Flags: DWORD; Window: HWND;
  CallbackRoutine: TSPFileCallback; CallbackContext: Pointer; var Result: DWORD): BOOL; stdcall;
{$EXTERNALSYM SetupScanFileQueue}

function SetupCopyOEMInfA(const SourceInfFileName, OEMSourceMediaLocation: PAnsiChar;
  OEMSourceMediaType, CopyStyle: DWORD; DestinationInfFileName: PAnsiChar;
  DestinationInfFileNameSize: DWORD; RequiredSize: PDWORD;
  DestinationInfFileNameComponent: PPASTR): BOOL; stdcall;
{$EXTERNALSYM SetupCopyOEMInfA}
function SetupCopyOEMInfW(const SourceInfFileName, OEMSourceMediaLocation: PWideChar;
  OEMSourceMediaType, CopyStyle: DWORD; DestinationInfFileName: PWideChar;
  DestinationInfFileNameSize: DWORD; RequiredSize: PDWORD;
  DestinationInfFileNameComponent: PPWSTR): BOOL; stdcall;
{$EXTERNALSYM SetupCopyOEMInfW}
function SetupCopyOEMInf(const SourceInfFileName, OEMSourceMediaLocation: PTSTR;
  OEMSourceMediaType, CopyStyle: DWORD; DestinationInfFileName: PTSTR;
  DestinationInfFileNameSize: DWORD; RequiredSize: PDWORD;
  DestinationInfFileNameComponent: PPSTR): BOOL; stdcall;
{$EXTERNALSYM SetupCopyOEMInf}

{$IFDEF WINXP_UP}
function SetupUninstallOEMInfA(const InfFileName: PAnsiChar; Flags: DWORD; Reserved: Pointer): BOOL; stdcall;
{$EXTERNALSYM SetupUninstallOEMInfA}
function SetupUninstallOEMInfW(const InfFileName: PWideChar; Flags: DWORD; Reserved: Pointer): BOOL; stdcall;
{$EXTERNALSYM SetupUninstallOEMInfW}
function SetupUninstallOEMInf(const InfFileName: PTSTR; Flags: DWORD; Reserved: Pointer): BOOL; stdcall;
{$EXTERNALSYM SetupUninstallOEMInf}

function SetupUninstallNewlyCopiedInfs(FileQueue: HSPFILEQ; Flags: DWORD; Reserved: Pointer): BOOL; stdcall;
{$EXTERNALSYM SetupUninstallNewlyCopiedInfs}
{$ENDIF WINXP_UP}

//
// Disk space list APIs
//
function SetupCreateDiskSpaceListA(Reserved1: Pointer; Reserved2: DWORD;
  Flags: UINT): HDSKSPC; stdcall;
{$EXTERNALSYM SetupCreateDiskSpaceListA}
function SetupCreateDiskSpaceListW(Reserved1: Pointer; Reserved2: DWORD;
  Flags: UINT): HDSKSPC; stdcall;
{$EXTERNALSYM SetupCreateDiskSpaceListW}
function SetupCreateDiskSpaceList(Reserved1: Pointer; Reserved2: DWORD;
  Flags: UINT): HDSKSPC; stdcall;
{$EXTERNALSYM SetupCreateDiskSpaceList}

function SetupDuplicateDiskSpaceListA(DiskSpace: HDSKSPC; Reserved1: Pointer;
  Reserved2: DWORD; Flags: UINT): HDSKSPC; stdcall;
{$EXTERNALSYM SetupDuplicateDiskSpaceListA}
function SetupDuplicateDiskSpaceListW(DiskSpace: HDSKSPC; Reserved1: Pointer;
  Reserved2: DWORD; Flags: UINT): HDSKSPC; stdcall;
{$EXTERNALSYM SetupDuplicateDiskSpaceListW}
function SetupDuplicateDiskSpaceList(DiskSpace: HDSKSPC; Reserved1: Pointer;
  Reserved2: DWORD; Flags: UINT): HDSKSPC; stdcall;
{$EXTERNALSYM SetupDuplicateDiskSpaceList}

function SetupDestroyDiskSpaceList(DiskSpace: HDSKSPC): BOOL; stdcall;
{$EXTERNALSYM SetupDestroyDiskSpaceList}

function SetupQueryDrivesInDiskSpaceListA(DiskSpace: HDSKSPC; ReturnBuffer: PAnsiChar;
  ReturnBufferSize: DWORD; RequiredSize: PDWORD): BOOL; stdcall;
{$EXTERNALSYM SetupQueryDrivesInDiskSpaceListA}
function SetupQueryDrivesInDiskSpaceListW(DiskSpace: HDSKSPC; ReturnBuffer: PWideChar;
  ReturnBufferSize: DWORD; RequiredSize: PDWORD): BOOL; stdcall;
{$EXTERNALSYM SetupQueryDrivesInDiskSpaceListW}
function SetupQueryDrivesInDiskSpaceList(DiskSpace: HDSKSPC; ReturnBuffer: PTSTR;
  ReturnBufferSize: DWORD; RequiredSize: PDWORD): BOOL; stdcall;
{$EXTERNALSYM SetupQueryDrivesInDiskSpaceList}

function SetupQuerySpaceRequiredOnDriveA(DiskSpace: HDSKSPC; const DriveSpec: PAnsiChar;
  var SpaceRequired: Int64; Reserved1: Pointer; Reserved2: UINT): BOOL; stdcall;
{$EXTERNALSYM SetupQuerySpaceRequiredOnDriveA}
function SetupQuerySpaceRequiredOnDriveW(DiskSpace: HDSKSPC; const DriveSpec: PWideChar;
  var SpaceRequired: Int64; Reserved1: Pointer; Reserved2: UINT): BOOL; stdcall;
{$EXTERNALSYM SetupQuerySpaceRequiredOnDriveW}
function SetupQuerySpaceRequiredOnDrive(DiskSpace: HDSKSPC; const DriveSpec: PTSTR;
  var SpaceRequired: Int64; Reserved1: Pointer; Reserved2: UINT): BOOL; stdcall;
{$EXTERNALSYM SetupQuerySpaceRequiredOnDrive}

function SetupAdjustDiskSpaceListA(DiskSpace: HDSKSPC; const DriveRoot: PAnsiChar;
  Amount: Int64; Reserved1: Pointer; Reserved2: UINT): BOOL; stdcall;
{$EXTERNALSYM SetupAdjustDiskSpaceListA}
function SetupAdjustDiskSpaceListW(DiskSpace: HDSKSPC; const DriveRoot: PWideChar;
  Amount: Int64; Reserved1: Pointer; Reserved2: UINT): BOOL; stdcall;
{$EXTERNALSYM SetupAdjustDiskSpaceListW}
function SetupAdjustDiskSpaceList(DiskSpace: HDSKSPC; const DriveRoot: PTSTR;
  Amount: Int64; Reserved1: Pointer; Reserved2: UINT): BOOL; stdcall;
{$EXTERNALSYM SetupAdjustDiskSpaceList}

function SetupAddToDiskSpaceListA(DiskSpace: HDSKSPC; const TargetFilespec: PAnsiChar;
  FileSize: Int64; Operation: UINT; Reserved1: Pointer; Reserved2: UINT): BOOL; stdcall;
{$EXTERNALSYM SetupAddToDiskSpaceListA}
function SetupAddToDiskSpaceListW(DiskSpace: HDSKSPC; const TargetFilespec: PWideChar;
  FileSize: Int64; Operation: UINT; Reserved1: Pointer; Reserved2: UINT): BOOL; stdcall;
{$EXTERNALSYM SetupAddToDiskSpaceListW}
function SetupAddToDiskSpaceList(DiskSpace: HDSKSPC; const TargetFilespec: PTSTR;
  FileSize: Int64; Operation: UINT; Reserved1: Pointer; Reserved2: UINT): BOOL; stdcall;
{$EXTERNALSYM SetupAddToDiskSpaceList}

function SetupAddSectionToDiskSpaceListA(DiskSpace: HDSKSPC; InfHandle: HINF;
  ListInfHandle: HINF; const SectionName: PAnsiChar; Operation: UINT;
  Reserved1: Pointer; Reserved2: UINT): BOOL; stdcall;
{$EXTERNALSYM SetupAddSectionToDiskSpaceListA}
function SetupAddSectionToDiskSpaceListW(DiskSpace: HDSKSPC; InfHandle: HINF;
  ListInfHandle: HINF; const SectionName: PWideChar; Operation: UINT;
  Reserved1: Pointer; Reserved2: UINT): BOOL; stdcall;
{$EXTERNALSYM SetupAddSectionToDiskSpaceListW}
function SetupAddSectionToDiskSpaceList(DiskSpace: HDSKSPC; InfHandle: HINF;
  ListInfHandle: HINF; const SectionName: PTSTR; Operation: UINT;
  Reserved1: Pointer; Reserved2: UINT): BOOL; stdcall;
{$EXTERNALSYM SetupAddSectionToDiskSpaceList}

function SetupAddInstallSectionToDiskSpaceListA(DiskSpace: HDSKSPC;
  InfHandle: HINF; LayoutInfHandle: HINF; const SectionName: PAnsiChar;
  Reserved1: Pointer; Reserved2: UINT): BOOL; stdcall;
{$EXTERNALSYM SetupAddInstallSectionToDiskSpaceListA}
function SetupAddInstallSectionToDiskSpaceListW(DiskSpace: HDSKSPC;
  InfHandle: HINF; LayoutInfHandle: HINF; const SectionName: PWideChar;
  Reserved1: Pointer; Reserved2: UINT): BOOL; stdcall;
{$EXTERNALSYM SetupAddInstallSectionToDiskSpaceListW}
function SetupAddInstallSectionToDiskSpaceList(DiskSpace: HDSKSPC;
  InfHandle: HINF; LayoutInfHandle: HINF; const SectionName: PTSTR;
  Reserved1: Pointer; Reserved2: UINT): BOOL; stdcall;
{$EXTERNALSYM SetupAddInstallSectionToDiskSpaceList}

function SetupRemoveFromDiskSpaceListA(DiskSpace: HDSKSPC; const TargetFilespec: PAnsiChar;
  Operation: UINT; Reserved1: Pointer; Reserved2: UINT): BOOL; stdcall;
{$EXTERNALSYM SetupRemoveFromDiskSpaceListA}
function SetupRemoveFromDiskSpaceListW(DiskSpace: HDSKSPC; const TargetFilespec: PWideChar;
  Operation: UINT; Reserved1: Pointer; Reserved2: UINT): BOOL; stdcall;
{$EXTERNALSYM SetupRemoveFromDiskSpaceListW}
function SetupRemoveFromDiskSpaceList(DiskSpace: HDSKSPC; const TargetFilespec: PTSTR;
  Operation: UINT; Reserved1: Pointer; Reserved2: UINT): BOOL; stdcall;
{$EXTERNALSYM SetupRemoveFromDiskSpaceList}

function SetupRemoveSectionFromDiskSpaceListA(DiskSpace: HDSKSPC; InfHandle: HINF;
  ListInfHandle: HINF; const SectionName: PAnsiChar; Operation: UINT; Reserved1: Pointer;
  Reserved2: UINT): BOOL; stdcall;
{$EXTERNALSYM SetupRemoveSectionFromDiskSpaceListA}
function SetupRemoveSectionFromDiskSpaceListW(DiskSpace: HDSKSPC; InfHandle: HINF;
  ListInfHandle: HINF; const SectionName: PWideChar; Operation: UINT; Reserved1: Pointer;
  Reserved2: UINT): BOOL; stdcall;
{$EXTERNALSYM SetupRemoveSectionFromDiskSpaceListW}
function SetupRemoveSectionFromDiskSpaceList(DiskSpace: HDSKSPC; InfHandle: HINF;
  ListInfHandle: HINF; const SectionName: PTSTR; Operation: UINT; Reserved1: Pointer;
  Reserved2: UINT): BOOL; stdcall;
{$EXTERNALSYM SetupRemoveSectionFromDiskSpaceList}

function SetupRemoveInstallSectionFromDiskSpaceListA(DiskSpace: HDSKSPC;
  InfHandle: HINF; LayoutInfHandle: HINF; const SectionName: PAnsiChar;
  Reserved1: Pointer; Reserved2: UINT): BOOL; stdcall;
{$EXTERNALSYM SetupRemoveInstallSectionFromDiskSpaceListA}
function SetupRemoveInstallSectionFromDiskSpaceListW(DiskSpace: HDSKSPC;
  InfHandle: HINF; LayoutInfHandle: HINF; const SectionName: PWideChar;
  Reserved1: Pointer; Reserved2: UINT): BOOL; stdcall;
{$EXTERNALSYM SetupRemoveInstallSectionFromDiskSpaceListW}
function SetupRemoveInstallSectionFromDiskSpaceList(DiskSpace: HDSKSPC;
  InfHandle: HINF; LayoutInfHandle: HINF; const SectionName: PTSTR;
  Reserved1: Pointer; Reserved2: UINT): BOOL; stdcall;
{$EXTERNALSYM SetupRemoveInstallSectionFromDiskSpaceList}

//
// Cabinet APIs
//

function SetupIterateCabinetA(const CabinetFile: PAnsiChar; Reserved: DWORD;
  MsgHandler: TSPFileCallbackA; Context: Pointer): BOOL; stdcall;
{$EXTERNALSYM SetupIterateCabinetA}
function SetupIterateCabinetW(const CabinetFile: PWideChar; Reserved: DWORD;
  MsgHandler: TSPFileCallbackW; Context: Pointer): BOOL; stdcall;
{$EXTERNALSYM SetupIterateCabinetW}
function SetupIterateCabinet(const CabinetFile: PTSTR; Reserved: DWORD;
  MsgHandler: TSPFileCallback; Context: Pointer): BOOL; stdcall;
{$EXTERNALSYM SetupIterateCabinet}

function SetupPromptReboot(FileQueue: HSPFILEQ; Owner: HWND; ScanOnly: BOOL): Integer; stdcall;
{$EXTERNALSYM SetupPromptReboot}

function SetupInitDefaultQueueCallback(OwnerWindow: HWND): Pointer; stdcall;
{$EXTERNALSYM SetupInitDefaultQueueCallback}

function SetupInitDefaultQueueCallbackEx(OwnerWindow: HWND; AlternateProgressWindow: HWND;
  ProgressMessage: UINT; Reserved1: DWORD; Reserved2: Pointer): Pointer; stdcall;
{$EXTERNALSYM SetupInitDefaultQueueCallbackEx}

procedure SetupTermDefaultQueueCallback(Context: Pointer); stdcall;
{$EXTERNALSYM SetupTermDefaultQueueCallback}

function SetupDefaultQueueCallbackA(Context: Pointer; Notification: UINT;
  Param1, Param2: UINT_PTR): UINT; stdcall;
{$EXTERNALSYM SetupDefaultQueueCallbackA}
function SetupDefaultQueueCallbackW(Context: Pointer; Notification: UINT;
  Param1, Param2: UINT_PTR): UINT; stdcall;
{$EXTERNALSYM SetupDefaultQueueCallbackW}
function SetupDefaultQueueCallback(Context: Pointer; Notification: UINT;
  Param1, Param2: UINT_PTR): UINT; stdcall;
{$EXTERNALSYM SetupDefaultQueueCallback}

//
// The INF may supply any arbitrary data type ordinal in the highword except
// for the following: REG_NONE, REG_SZ, REG_EXPAND_SZ, REG_MULTI_SZ.  If this
// technique is used, then the data is given in binary format, one byte per
// field.
//

function SetupInstallFromInfSectionA(Owner: HWND; InfHandle: HINF;
  const SectionName: PAnsiChar; Flags: UINT; RelativeKeyRoot: HKEY;
  const SourceRootPath: PAnsiChar; CopyFlags: UINT; MsgHandler: TSPFileCallbackA;
  Context: Pointer; DeviceInfoSet: HDEVINFO; DeviceIn: PSPDevInfoData): BOOL; stdcall;
{$EXTERNALSYM SetupInstallFromInfSectionA}
function SetupInstallFromInfSectionW(Owner: HWND; InfHandle: HINF;
  const SectionName: PWideChar; Flags: UINT; RelativeKeyRoot: HKEY;
  const SourceRootPath: PWideChar; CopyFlags: UINT; MsgHandler: TSPFileCallbackW;
  Context: Pointer; DeviceInfoSet: HDEVINFO; DeviceIn: PSPDevInfoData): BOOL; stdcall;
{$EXTERNALSYM SetupInstallFromInfSectionW}
function SetupInstallFromInfSection(Owner: HWND; InfHandle: HINF;
  const SectionName: PTSTR; Flags: UINT; RelativeKeyRoot: HKEY;
  const SourceRootPath: PTSTR; CopyFlags: UINT; MsgHandler: TSPFileCallback;
  Context: Pointer; DeviceInfoSet: HDEVINFO; DeviceIn: PSPDevInfoData): BOOL; stdcall;
{$EXTERNALSYM SetupInstallFromInfSection}

function SetupInstallFilesFromInfSectionA(InfHandle: HINF; LayoutInfHandle: HINF;
  FileQueue: HSPFILEQ; const SectionName, SourceRootPath: PAnsiChar;
  CopyFlags: UINT): BOOL; stdcall;
{$EXTERNALSYM SetupInstallFilesFromInfSectionA}
function SetupInstallFilesFromInfSectionW(InfHandle: HINF; LayoutInfHandle: HINF;
  FileQueue: HSPFILEQ; const SectionName, SourceRootPath: PWideChar;
  CopyFlags: UINT): BOOL; stdcall;
{$EXTERNALSYM SetupInstallFilesFromInfSectionW}
function SetupInstallFilesFromInfSection(InfHandle: HINF; LayoutInfHandle: HINF;
  FileQueue: HSPFILEQ; const SectionName, SourceRootPath: PTSTR;
  CopyFlags: UINT): BOOL; stdcall;
{$EXTERNALSYM SetupInstallFilesFromInfSection}

function SetupInstallServicesFromInfSectionA(InfHandle: HINF;
  const SectionName: PAnsiChar; Flags: DWORD): BOOL; stdcall;
{$EXTERNALSYM SetupInstallServicesFromInfSectionA}
function SetupInstallServicesFromInfSectionW(InfHandle: HINF;
  const SectionName: PWideChar; Flags: DWORD): BOOL; stdcall;
{$EXTERNALSYM SetupInstallServicesFromInfSectionW}
function SetupInstallServicesFromInfSection(InfHandle: HINF;
  const SectionName: PTSTR; Flags: DWORD): BOOL; stdcall;
{$EXTERNALSYM SetupInstallServicesFromInfSection}

function SetupInstallServicesFromInfSectionExA(InfHandle: HINF;
  const SectionName: PAnsiChar; Flags: DWORD; DeviceInfoSet: HDEVINFO;
  DeviceInfoData: TSPDevInfoData; Reserved1, Reserved2: Pointer): BOOL; stdcall;
{$EXTERNALSYM SetupInstallServicesFromInfSectionExA}
function SetupInstallServicesFromInfSectionExW(InfHandle: HINF;
  const SectionName: PWideChar; Flags: DWORD; DeviceInfoSet: HDEVINFO;
  DeviceInfoData: TSPDevInfoData; Reserved1, Reserved2: Pointer): BOOL; stdcall;
{$EXTERNALSYM SetupInstallServicesFromInfSectionExW}
function SetupInstallServicesFromInfSectionEx(InfHandle: HINF;
  const SectionName: PTSTR; Flags: DWORD; DeviceInfoSet: HDEVINFO;
  DeviceInfoData: TSPDevInfoData; Reserved1, Reserved2: Pointer): BOOL; stdcall;
{$EXTERNALSYM SetupInstallServicesFromInfSectionEx}

{$IFDEF WINXP_UP}
//
// High level routine, usually used via rundll32.dll
// to perform right-click install action on INFs
// May be called directly:
//
// wsprintf(CmdLineBuffer,TEXT("DefaultInstall 132 %s"),InfPath);
// InstallHinfSection(NULL,NULL,CmdLineBuffer,0);
//
procedure InstallHinfSectionA(Window: HWND; ModuleHandle: HINST;
  CommandLine: PAnsiChar; ShowCommand: Integer); stdcall;
{$EXTERNALSYM InstallHinfSectionA}
procedure InstallHinfSectionW(Window: HWND; ModuleHandle: HINST;
  CommandLine: PWideChar; ShowCommand: Integer); stdcall;
{$EXTERNALSYM InstallHinfSectionW}
procedure InstallHinfSection(Window: HWND; ModuleHandle: HINST;
  CommandLine: PTSTR; ShowCommand: Integer); stdcall;
{$EXTERNALSYM InstallHinfSection}
{$ENDIF WINXP_UP}

//
// Define handle type for Setup file log.
//

type
  HSPFILELOG = Pointer;
  {$EXTERNALSYM HSPFILELOG}

function SetupInitializeFileLogA(const LogFileName: PAnsiChar; Flags: DWORD): HSPFILELOG; stdcall;
{$EXTERNALSYM SetupInitializeFileLogA}
function SetupInitializeFileLogW(const LogFileName: PWideChar; Flags: DWORD): HSPFILELOG; stdcall;
{$EXTERNALSYM SetupInitializeFileLogW}
function SetupInitializeFileLog(const LogFileName: PTSTR; Flags: DWORD): HSPFILELOG; stdcall;
{$EXTERNALSYM SetupInitializeFileLog}

function SetupTerminateFileLog(FileLogHandle: HSPFILELOG): BOOL; stdcall;
{$EXTERNALSYM SetupTerminateFileLog}

function SetupLogFileA(FileLogHandle: HSPFILELOG; const LogSectionName,
  SourceFilename, TargetFilename: PAnsiChar; Checksum: DWORD; DiskTagfile,
  DiskDescription, OtherInfo: PAnsiChar; Flags: DWORD): BOOL; stdcall;
{$EXTERNALSYM SetupLogFileA}
function SetupLogFileW(FileLogHandle: HSPFILELOG; const LogSectionName,
  SourceFilename, TargetFilename: PWideChar; Checksum: DWORD; DiskTagfile,
  DiskDescription, OtherInfo: PWideChar; Flags: DWORD): BOOL; stdcall;
{$EXTERNALSYM SetupLogFileW}
function SetupLogFile(FileLogHandle: HSPFILELOG; const LogSectionName,
  SourceFilename, TargetFilename: PTSTR; Checksum: DWORD; DiskTagfile,
  DiskDescription, OtherInfo: PTSTR; Flags: DWORD): BOOL; stdcall;
{$EXTERNALSYM SetupLogFile}

function SetupRemoveFileLogEntryA(FileLogHandle: HSPFILELOG;
  const LogSectionName: PAnsiChar; const TargetFilename: PAnsiChar): BOOL; stdcall;
{$EXTERNALSYM SetupRemoveFileLogEntryA}
function SetupRemoveFileLogEntryW(FileLogHandle: HSPFILELOG;
  const LogSectionName: PWideChar; const TargetFilename: PWideChar): BOOL; stdcall;
{$EXTERNALSYM SetupRemoveFileLogEntryW}
function SetupRemoveFileLogEntry(FileLogHandle: HSPFILELOG;
  const LogSectionName: PTSTR; const TargetFilename: PTSTR): BOOL; stdcall;
{$EXTERNALSYM SetupRemoveFileLogEntry}

function SetupQueryFileLogA(FileLogHandle: HSPFILELOG; const LogSectionName,
  TargetFilename: PAnsiChar; DesiredInfo: SetupFileLogInfo; DataOut: PAnsiChar;
  ReturnBufferSize: DWORD; RequiredSize: PDWORD): BOOL; stdcall;
{$EXTERNALSYM SetupQueryFileLogA}
function SetupQueryFileLogW(FileLogHandle: HSPFILELOG; const LogSectionName,
  TargetFilename: PWideChar; DesiredInfo: SetupFileLogInfo; DataOut: PWideChar;
  ReturnBufferSize: DWORD; RequiredSize: PDWORD): BOOL; stdcall;
{$EXTERNALSYM SetupQueryFileLogW}
function SetupQueryFileLog(FileLogHandle: HSPFILELOG; const LogSectionName,
  TargetFilename: PTSTR; DesiredInfo: SetupFileLogInfo; DataOut: PTSTR;
  ReturnBufferSize: DWORD; RequiredSize: PDWORD): BOOL; stdcall;
{$EXTERNALSYM SetupQueryFileLog}

//
// Text logging APIs
//

function SetupOpenLog(Erase: BOOL): BOOL; stdcall;
{$EXTERNALSYM SetupOpenLog}

function SetupLogErrorA(const MessageString: PAnsiChar; Severity: LOGSEVERITY): BOOL; stdcall;
{$EXTERNALSYM SetupLogErrorA}
function SetupLogErrorW(const MessageString: PWideChar; Severity: LOGSEVERITY): BOOL; stdcall;
{$EXTERNALSYM SetupLogErrorW}
function SetupLogError(const MessageString: PTSTR; Severity: LOGSEVERITY): BOOL; stdcall;
{$EXTERNALSYM SetupLogError}

procedure SetupCloseLog; stdcall;
{$EXTERNALSYM SetupCloseLog}

//
// Backup Information API's
//

{$IFDEF WIN2000_UP}
function SetupGetBackupInformationA(QueueHandle: HSPFILEQ;
  var BackupParams: TSPBackupQueueParamsA): BOOL; stdcall;
{$EXTERNALSYM SetupGetBackupInformationA}
function SetupGetBackupInformationW(QueueHandle: HSPFILEQ;
  var BackupParams: TSPBackupQueueParamsW): BOOL; stdcall;
{$EXTERNALSYM SetupGetBackupInformationW}
function SetupGetBackupInformation(QueueHandle: HSPFILEQ;
  var BackupParams: TSPBackupQueueParams): BOOL; stdcall;
{$EXTERNALSYM SetupGetBackupInformation}
{$ENDIF WIN2000_UP}

{$IFDEF WINXP_UP}

function SetupPrepareQueueForRestoreA(QueueHandle: HSPFILEQ;
  BackupPath: PAnsiChar; RestoreFlags: DWORD): BOOL; stdcall;
{$EXTERNALSYM SetupPrepareQueueForRestoreA}
function SetupPrepareQueueForRestoreW(QueueHandle: HSPFILEQ;
  BackupPath: PWideChar; RestoreFlags: DWORD): BOOL; stdcall;
{$EXTERNALSYM SetupPrepareQueueForRestoreW}
function SetupPrepareQueueForRestore(QueueHandle: HSPFILEQ;
  BackupPath: PTSTR; RestoreFlags: DWORD): BOOL; stdcall;
{$EXTERNALSYM SetupPrepareQueueForRestore}

//
// Control forcing of Non-Interactive Mode
// Overridden if SetupAPI is run in non-interactive window session
//

function SetupSetNonInteractiveMode(NonInteractiveFlag: BOOL): BOOL; stdcall;
{$EXTERNALSYM SetupSetNonInteractiveMode}
function SetupGetNonInteractiveMode: BOOL; stdcall;
{$EXTERNALSYM SetupGetNonInteractiveMode}

{$ENDIF WINXP_UP}

//
// Device Installer APIs
//

function SetupDiCreateDeviceInfoList(ClassGuid: PGUID; hwndParent: HWND): HDEVINFO; stdcall;
{$EXTERNALSYM SetupDiCreateDeviceInfoList}

function SetupDiCreateDeviceInfoListExA(ClassGuid: PGUID; hwndParent: HWND;
  const MachineName: PAnsiChar; Reserved: Pointer): HDEVINFO; stdcall;
{$EXTERNALSYM SetupDiCreateDeviceInfoListExA}
function SetupDiCreateDeviceInfoListExW(ClassGuid: PGUID; hwndParent: HWND;
  const MachineName: PWideChar; Reserved: Pointer): HDEVINFO; stdcall;
{$EXTERNALSYM SetupDiCreateDeviceInfoListExW}
function SetupDiCreateDeviceInfoListEx(ClassGuid: PGUID; hwndParent: HWND;
  const MachineName: PTSTR; Reserved: Pointer): HDEVINFO; stdcall;
{$EXTERNALSYM SetupDiCreateDeviceInfoListEx}

function SetupDiGetDeviceInfoListClass(DeviceInfoSet: HDEVINFO;
  var ClassGuid: TGUID): BOOL; stdcall;
{$EXTERNALSYM SetupDiGetDeviceInfoListClass}

function SetupDiGetDeviceInfoListDetailA(DeviceInfoSet: HDEVINFO;
  var DeviceInfoSetDetailData: TSPDevInfoListDetailDataA): BOOL; stdcall;
{$EXTERNALSYM SetupDiGetDeviceInfoListDetailA}
function SetupDiGetDeviceInfoListDetailW(DeviceInfoSet: HDEVINFO;
  var DeviceInfoSetDetailData: TSPDevInfoListDetailDataW): BOOL; stdcall;
{$EXTERNALSYM SetupDiGetDeviceInfoListDetailW}
function SetupDiGetDeviceInfoListDetail(DeviceInfoSet: HDEVINFO;
  var DeviceInfoSetDetailData: TSPDevInfoListDetailData): BOOL; stdcall;
{$EXTERNALSYM SetupDiGetDeviceInfoListDetail}

function SetupDiCreateDeviceInfoA(DeviceInfoSet: HDEVINFO; const DeviceName: PAnsiChar;
  var ClassGuid: TGUID; const DeviceDescription: PAnsiChar; hwndParent: HWND;
  CreationFlags: DWORD; DeviceInfoData: PSPDevInfoData): BOOL; stdcall;
{$EXTERNALSYM SetupDiCreateDeviceInfoA}
function SetupDiCreateDeviceInfoW(DeviceInfoSet: HDEVINFO; const DeviceName: PWideChar;
  var ClassGuid: TGUID; const DeviceDescription: PWideChar; hwndParent: HWND;
  CreationFlags: DWORD; DeviceInfoData: PSPDevInfoData): BOOL; stdcall;
{$EXTERNALSYM SetupDiCreateDeviceInfoW}
function SetupDiCreateDeviceInfo(DeviceInfoSet: HDEVINFO; const DeviceName: PTSTR;
  var ClassGuid: TGUID; const DeviceDescription: PTSTR; hwndParent: HWND;
  CreationFlags: DWORD; DeviceInfoData: PSPDevInfoData): BOOL; stdcall;
{$EXTERNALSYM SetupDiCreateDeviceInfo}


function SetupDiOpenDeviceInfoA(DeviceInfoSet: HDEVINFO;
  const DeviceInstanceId: PAnsiChar; hwndParent: HWND; OpenFlags: DWORD;
  DeviceInfoData: PSPDevInfoData): BOOL; stdcall;
{$EXTERNALSYM SetupDiOpenDeviceInfoA}
function SetupDiOpenDeviceInfoW(DeviceInfoSet: HDEVINFO;
  const DeviceInstanceId: PWideChar; hwndParent: HWND; OpenFlags: DWORD;
  DeviceInfoData: PSPDevInfoData): BOOL; stdcall;
{$EXTERNALSYM SetupDiOpenDeviceInfoW}
function SetupDiOpenDeviceInfo(DeviceInfoSet: HDEVINFO;
  const DeviceInstanceId: PTSTR; hwndParent: HWND; OpenFlags: DWORD;
  DeviceInfoData: PSPDevInfoData): BOOL; stdcall;
{$EXTERNALSYM SetupDiOpenDeviceInfo}

function SetupDiGetDeviceInstanceIdA(DeviceInfoSet: HDEVINFO;
  DeviceInfoData: PSPDevInfoData; DeviceInstanceId: PAnsiChar;
  DeviceInstanceIdSize: DWORD; RequiredSize: PDWORD): BOOL; stdcall;
{$EXTERNALSYM SetupDiGetDeviceInstanceIdA}
function SetupDiGetDeviceInstanceIdW(DeviceInfoSet: HDEVINFO;
  DeviceInfoData: PSPDevInfoData; DeviceInstanceId: PWideChar;
  DeviceInstanceIdSize: DWORD; RequiredSize: PDWORD): BOOL; stdcall;
{$EXTERNALSYM SetupDiGetDeviceInstanceIdW}
function SetupDiGetDeviceInstanceId(DeviceInfoSet: HDEVINFO;
  DeviceInfoData: PSPDevInfoData; DeviceInstanceId: PTSTR;
  DeviceInstanceIdSize: DWORD; RequiredSize: PDWORD): BOOL; stdcall;
{$EXTERNALSYM SetupDiGetDeviceInstanceId}

function SetupDiDeleteDeviceInfo(DeviceInfoSet: HDEVINFO;
  DeviceInfoData: PSPDevInfoData): BOOL; stdcall;
{$EXTERNALSYM SetupDiDeleteDeviceInfo}

function SetupDiEnumDeviceInfo(DeviceInfoSet: HDEVINFO;
  MemberIndex: DWORD; var DeviceInfoData: TSPDevInfoData): BOOL; stdcall;
{$EXTERNALSYM SetupDiEnumDeviceInfo}

function SetupDiDestroyDeviceInfoList(DeviceInfoSet: HDEVINFO): BOOL; stdcall;
{$EXTERNALSYM SetupDiDestroyDeviceInfoList}

function SetupDiEnumDeviceInterfaces(DeviceInfoSet: HDEVINFO;
  DeviceInfoData: PSPDevInfoData; const InterfaceClassGuid: TGUID;
  MemberIndex: DWORD; var DeviceInterfaceData: TSPDeviceInterfaceData): BOOL; stdcall;
{$EXTERNALSYM SetupDiEnumDeviceInterfaces}

//
// Backward compatibility--do not use
//

function SetupDiEnumInterfaceDevice(DeviceInfoSet: HDEVINFO;
  DeviceInfoData: PSPDevInfoData; const InterfaceClassGuid: TGUID;
  MemberIndex: DWORD; var DeviceInterfaceData: TSPDeviceInterfaceData): BOOL; stdcall;
{$EXTERNALSYM SetupDiEnumDeviceInterfaces}

function SetupDiCreateDeviceInterfaceA(DeviceInfoSet: HDEVINFO;
  var DeviceInfoData: TSPDevInfoData; var InterfaceClassGuid: TGUID;
  const ReferenceString: PAnsiChar; CreationFlags: DWORD;
  DeviceInterfaceData: PSPDeviceInterfaceData): BOOL; stdcall;
{$EXTERNALSYM SetupDiCreateDeviceInterfaceA}
function SetupDiCreateDeviceInterfaceW(DeviceInfoSet: HDEVINFO;
  var DeviceInfoData: TSPDevInfoData; var InterfaceClassGuid: TGUID;
  const ReferenceString: PWideChar; CreationFlags: DWORD;
  DeviceInterfaceData: PSPDeviceInterfaceData): BOOL; stdcall;
{$EXTERNALSYM SetupDiCreateDeviceInterfaceW}
function SetupDiCreateDeviceInterface(DeviceInfoSet: HDEVINFO;
  var DeviceInfoData: TSPDevInfoData; var InterfaceClassGuid: TGUID;
  const ReferenceString: PTSTR; CreationFlags: DWORD;
  DeviceInterfaceData: PSPDeviceInterfaceData): BOOL; stdcall;
{$EXTERNALSYM SetupDiCreateDeviceInterface}

//
// Backward compatibility--do not use.
//

function SetupDiCreateInterfaceDeviceA(DeviceInfoSet: HDEVINFO;
  var DeviceInfoData: TSPDevInfoData; var InterfaceClassGuid: TGUID;
  const ReferenceString: PAnsiChar; CreationFlags: DWORD;
  DeviceInterfaceData: PSPDeviceInterfaceData): BOOL; stdcall;
{$EXTERNALSYM SetupDiCreateInterfaceDeviceA}
function SetupDiCreateInterfaceDeviceW(DeviceInfoSet: HDEVINFO;
  var DeviceInfoData: TSPDevInfoData; var InterfaceClassGuid: TGUID;
  const ReferenceString: PWideChar; CreationFlags: DWORD;
  DeviceInterfaceData: PSPDeviceInterfaceData): BOOL; stdcall;
{$EXTERNALSYM SetupDiCreateInterfaceDeviceW}
function SetupDiCreateInterfaceDevice(DeviceInfoSet: HDEVINFO;
  var DeviceInfoData: TSPDevInfoData; var InterfaceClassGuid: TGUID;
  const ReferenceString: PTSTR; CreationFlags: DWORD;
  DeviceInterfaceData: PSPDeviceInterfaceData): BOOL; stdcall;
{$EXTERNALSYM SetupDiCreateInterfaceDevice}

function SetupDiOpenDeviceInterfaceA(DeviceInfoSet: HDEVINFO;
  const DevicePath: PAnsiChar; OpenFlags: DWORD;
  DeviceInterfaceData: PSPDeviceInterfaceData): BOOL; stdcall;
{$EXTERNALSYM SetupDiOpenDeviceInterfaceA}
function SetupDiOpenDeviceInterfaceW(DeviceInfoSet: HDEVINFO;
  const DevicePath: PWideChar; OpenFlags: DWORD;
  DeviceInterfaceData: PSPDeviceInterfaceData): BOOL; stdcall;
{$EXTERNALSYM SetupDiOpenDeviceInterfaceW}
function SetupDiOpenDeviceInterface(DeviceInfoSet: HDEVINFO;
  const DevicePath: PTSTR; OpenFlags: DWORD;
  DeviceInterfaceData: PSPDeviceInterfaceData): BOOL; stdcall;
{$EXTERNALSYM SetupDiOpenDeviceInterface}

//
// Backward compatibility--do not use
//

function SetupDiOpenInterfaceDeviceA(DeviceInfoSet: HDEVINFO;
  const DevicePath: PAnsiChar; OpenFlags: DWORD;
  DeviceInterfaceData: PSPDeviceInterfaceData): BOOL; stdcall;
{$EXTERNALSYM SetupDiOpenInterfaceDeviceA}
function SetupDiOpenInterfaceDeviceW(DeviceInfoSet: HDEVINFO;
  const DevicePath: PWideChar; OpenFlags: DWORD;
  DeviceInterfaceData: PSPDeviceInterfaceData): BOOL; stdcall;
{$EXTERNALSYM SetupDiOpenInterfaceDeviceW}
function SetupDiOpenInterfaceDevice(DeviceInfoSet: HDEVINFO;
  const DevicePath: PTSTR; OpenFlags: DWORD;
  DeviceInterfaceData: PSPDeviceInterfaceData): BOOL; stdcall;
{$EXTERNALSYM SetupDiOpenInterfaceDevice}

function SetupDiGetDeviceInterfaceAlias(DeviceInfoSet: HDEVINFO;
  var DeviceInterfaceData: TSPDeviceInterfaceData; var AliasInterfaceClassGuid: TGUID;
  var AliasDeviceInterfaceData: TSPDeviceInterfaceData): BOOL; stdcall;
{$EXTERNALSYM SetupDiGetDeviceInterfaceAlias}

//
// Backward compatibility--do not use.
//

function SetupDiGetInterfaceDeviceAlias(DeviceInfoSet: HDEVINFO;
  var DeviceInterfaceData: TSPDeviceInterfaceData;
  var AliasInterfaceClassGuid: TGUID;
  var AliasDeviceInterfaceData: TSPDeviceInterfaceData): BOOL; stdcall;
{$EXTERNALSYM SetupDiGetInterfaceDeviceAlias}

function SetupDiDeleteDeviceInterfaceData(DeviceInfoSet: HDEVINFO;
  var DeviceInterfaceData: TSPDeviceInterfaceData): BOOL; stdcall;
{$EXTERNALSYM SetupDiDeleteDeviceInterfaceData}

//
// Backward compatibility--do not use.
//

function SetupDiDeleteInterfaceDeviceData(DeviceInfoSet: HDEVINFO;
  var DeviceInterfaceData: TSPDeviceInterfaceData): BOOL; stdcall;
{$EXTERNALSYM SetupDiDeleteInterfaceDeviceData}

function SetupDiRemoveDeviceInterface(DeviceInfoSet: HDEVINFO;
  var DeviceInterfaceData: TSPDeviceInterfaceData): BOOL; stdcall;
{$EXTERNALSYM SetupDiRemoveDeviceInterface}

//
// Backward compatibility--do not use.
//

function SetupDiRemoveInterfaceDevice(DeviceInfoSet: HDEVINFO;
  var DeviceInterfaceData: TSPDeviceInterfaceData): BOOL; stdcall;
{$EXTERNALSYM SetupDiRemoveInterfaceDevice}

function SetupDiGetDeviceInterfaceDetailA(DeviceInfoSet: HDEVINFO;
  DeviceInterfaceData: PSPDeviceInterfaceData;
  DeviceInterfaceDetailData: PSPDeviceInterfaceDetailDataA;
  DeviceInterfaceDetailDataSize: DWORD; var RequiredSize: DWORD;
  Device: PSPDevInfoData): BOOL; stdcall;
{$EXTERNALSYM SetupDiGetDeviceInterfaceDetailA}
function SetupDiGetDeviceInterfaceDetailW(DeviceInfoSet: HDEVINFO;
  DeviceInterfaceData: PSPDeviceInterfaceData;
  DeviceInterfaceDetailData: PSPDeviceInterfaceDetailDataW;
  DeviceInterfaceDetailDataSize: DWORD; var RequiredSize: DWORD;
  Device: PSPDevInfoData): BOOL; stdcall;
{$EXTERNALSYM SetupDiGetDeviceInterfaceDetailW}
function SetupDiGetDeviceInterfaceDetail(DeviceInfoSet: HDEVINFO;
  DeviceInterfaceData: PSPDeviceInterfaceData;
  DeviceInterfaceDetailData: PSPDeviceInterfaceDetailData;
  DeviceInterfaceDetailDataSize: DWORD; var RequiredSize: DWORD;
  Device: PSPDevInfoData): BOOL; stdcall;
{$EXTERNALSYM SetupDiGetDeviceInterfaceDetail}

//
// Backward compatibility--do not use.
//

function SetupDiGetInterfaceDeviceDetailA(DeviceInfoSet: HDEVINFO;
  DeviceInterfaceData: PSPDeviceInterfaceData;
  DeviceInterfaceDetailData: PSPDeviceInterfaceDetailDataA;
  DeviceInterfaceDetailDataSize: DWORD; RequiredSize: PDWORD;
  Device: PSPDevInfoData): BOOL; stdcall;
{$EXTERNALSYM SetupDiGetInterfaceDeviceDetailA}
function SetupDiGetInterfaceDeviceDetailW(DeviceInfoSet: HDEVINFO;
  DeviceInterfaceData: PSPDeviceInterfaceData;
  DeviceInterfaceDetailData: PSPDeviceInterfaceDetailDataW;
  DeviceInterfaceDetailDataSize: DWORD; RequiredSize: PDWORD;
  Device: PSPDevInfoData): BOOL; stdcall;
{$EXTERNALSYM SetupDiGetInterfaceDeviceDetailW}
function SetupDiGetInterfaceDeviceDetail(DeviceInfoSet: HDEVINFO;
  DeviceInterfaceData: PSPDeviceInterfaceData;
  DeviceInterfaceDetailData: PSPDeviceInterfaceDetailData;
  DeviceInterfaceDetailDataSize: DWORD; RequiredSize: PDWORD;
  Device: PSPDevInfoData): BOOL; stdcall;
{$EXTERNALSYM SetupDiGetInterfaceDeviceDetail}

//
// Default install handler for DIF_INSTALLINTERFACES.
//

function SetupDiInstallDeviceInterfaces(DeviceInfoSet: HDEVINFO;
  var DeviceInfoData: TSPDevInfoData): BOOL; stdcall;
{$EXTERNALSYM SetupDiInstallDeviceInterfaces}

//
// Backward compatibility--do not use.
//

function SetupDiInstallInterfaceDevices(DeviceInfoSet: HDEVINFO;
  var DeviceInfoData: TSPDevInfoData): BOOL; stdcall;
{$EXTERNALSYM SetupDiInstallInterfaceDevices}

{$IFDEF WINXP_UP}
function SetupDiSetDeviceInterfaceDefault(DeviceInfoSet: HDEVINFO;
  var DeviceInterfaceData: TSPDeviceInterfaceData; Flags: DWORD;
  Reserved: Pointer): BOOL; stdcall;
{$EXTERNALSYM SetupDiSetDeviceInterfaceDefault}
{$ENDIF WINXP_UP}

//
// Default install handler for DIF_REGISTERDEVICE
//

function SetupDiRegisterDeviceInfo(DeviceInfoSet: HDEVINFO;
  var DeviceInfoData: TSPDevInfoData; Flags: DWORD; CompareProc: TSPDetSigCmpProc;
  CompareContext: Pointer; DupDeviceInfoData: PSPDevInfoData): BOOL; stdcall;
{$EXTERNALSYM SetupDiRegisterDeviceInfo}

function SetupDiBuildDriverInfoList(DeviceInfoSet: HDEVINFO;
  DeviceInfoData: PSPDevInfoData; DriverType: DWORD): BOOL; stdcall;
{$EXTERNALSYM SetupDiBuildDriverInfoList}

function SetupDiCancelDriverInfoSearch(DeviceInfoSet: HDEVINFO): BOOL; stdcall;
{$EXTERNALSYM SetupDiCancelDriverInfoSearch}

function SetupDiEnumDriverInfoA(DeviceInfoSet: HDEVINFO;
  DeviceInfoData: PSPDevInfoData; DriverType: DWORD; MemberIndex: DWORD;
  var DriverInfoData: TSPDrvInfoDataA): BOOL; stdcall;
{$EXTERNALSYM SetupDiEnumDriverInfoA}
function SetupDiEnumDriverInfoW(DeviceInfoSet: HDEVINFO;
  DeviceInfoData: PSPDevInfoData; DriverType: DWORD; MemberIndex: DWORD;
  var DriverInfoData: TSPDrvInfoDataW): BOOL; stdcall;
{$EXTERNALSYM SetupDiEnumDriverInfoW}
function SetupDiEnumDriverInfo(DeviceInfoSet: HDEVINFO;
  DeviceInfoData: PSPDevInfoData; DriverType: DWORD; MemberIndex: DWORD;
  var DriverInfoData: TSPDrvInfoData): BOOL; stdcall;
{$EXTERNALSYM SetupDiEnumDriverInfo}

function SetupDiGetSelectedDriverA(DeviceInfoSet: HDEVINFO;
  DeviceInfoData: PSPDevInfoData; var DriverInfoData: TSPDrvInfoDataA): BOOL; stdcall;
{$EXTERNALSYM SetupDiGetSelectedDriverA}
function SetupDiGetSelectedDriverW(DeviceInfoSet: HDEVINFO;
  DeviceInfoData: PSPDevInfoData; var DriverInfoData: TSPDrvInfoDataW): BOOL; stdcall;
{$EXTERNALSYM SetupDiGetSelectedDriverW}
function SetupDiGetSelectedDriver(DeviceInfoSet: HDEVINFO;
  DeviceInfoData: PSPDevInfoData; var DriverInfoData: TSPDrvInfoData): BOOL; stdcall;
{$EXTERNALSYM SetupDiGetSelectedDriver}

function SetupDiSetSelectedDriverA(DeviceInfoSet: HDEVINFO;
  DeviceInfoData: PSPDevInfoData; DriverInfoData: PSPDrvInfoDataA): BOOL; stdcall;
{$EXTERNALSYM SetupDiSetSelectedDriverA}
function SetupDiSetSelectedDriverW(DeviceInfoSet: HDEVINFO;
  DeviceInfoData: PSPDevInfoData; DriverInfoData: PSPDrvInfoDataW): BOOL; stdcall;
{$EXTERNALSYM SetupDiSetSelectedDriverW}
function SetupDiSetSelectedDriver(DeviceInfoSet: HDEVINFO;
  DeviceInfoData: PSPDevInfoData; DriverInfoData: PSPDrvInfoData): BOOL; stdcall;
{$EXTERNALSYM SetupDiSetSelectedDriver}

function SetupDiGetDriverInfoDetailA(DeviceInfoSet: HDEVINFO;
  DeviceInfoData: PSPDevInfoData; var DriverInfoData: TSPDrvInfoDataA;
  DriverInfoDetailData: PSPDrvInfoDetailDataA; DriverInfoDetailDataSize: DWORD;
  RequiredSize: PDWORD): BOOL; stdcall;
{$EXTERNALSYM SetupDiGetDriverInfoDetailA}
function SetupDiGetDriverInfoDetailW(DeviceInfoSet: HDEVINFO;
  DeviceInfoData: PSPDevInfoData; var DriverInfoData: TSPDrvInfoDataW;
  DriverInfoDetailData: PSPDrvInfoDetailDataW; DriverInfoDetailDataSize: DWORD;
  RequiredSize: PDWORD): BOOL; stdcall;
{$EXTERNALSYM SetupDiGetDriverInfoDetailW}
function SetupDiGetDriverInfoDetail(DeviceInfoSet: HDEVINFO;
  DeviceInfoData: PSPDevInfoData; var DriverInfoData: TSPDrvInfoData;
  DriverInfoDetailData: PSPDrvInfoDetailData; DriverInfoDetailDataSize: DWORD;
  RequiredSize: PDWORD): BOOL; stdcall;
{$EXTERNALSYM SetupDiGetDriverInfoDetail}

function SetupDiDestroyDriverInfoList(DeviceInfoSet: HDEVINFO;
  DeviceInfoData: PSPDevInfoData; DriverType: DWORD): BOOL; stdcall;
{$EXTERNALSYM SetupDiDestroyDriverInfoList}

function SetupDiGetClassDevsA(ClassGuid: PGUID; const Enumerator: PAnsiChar;
  hwndParent: HWND; Flags: DWORD): HDEVINFO; stdcall;
{$EXTERNALSYM SetupDiGetClassDevsA}
function SetupDiGetClassDevsW(ClassGuid: PGUID; const Enumerator: PWideChar;
  hwndParent: HWND; Flags: DWORD): HDEVINFO; stdcall;
{$EXTERNALSYM SetupDiGetClassDevsW}
function SetupDiGetClassDevs(ClassGuid: PGUID; const Enumerator: PTSTR;
  hwndParent: HWND; Flags: DWORD): HDEVINFO; stdcall;
{$EXTERNALSYM SetupDiGetClassDevs}

function SetupDiGetClassDevsExA(ClassGuid: PGUID; const Enumerator: PAnsiChar;
  hwndParent: HWND; Flags: DWORD; DeviceInfoSet: HDEVINFO; const MachineName: PAnsiChar;
  Reserved: Pointer): HDEVINFO; stdcall;
{$EXTERNALSYM SetupDiGetClassDevsExA}
function SetupDiGetClassDevsExW(ClassGuid: PGUID; const Enumerator: PWideChar;
  hwndParent: HWND; Flags: DWORD; DeviceInfoSet: HDEVINFO; const MachineName: PWideChar;
  Reserved: Pointer): HDEVINFO; stdcall;
{$EXTERNALSYM SetupDiGetClassDevsExW}
function SetupDiGetClassDevsEx(ClassGuid: PGUID; const Enumerator: PTSTR;
  hwndParent: HWND; Flags: DWORD; DeviceInfoSet: HDEVINFO; const MachineName: PTSTR;
  Reserved: Pointer): HDEVINFO; stdcall;
{$EXTERNALSYM SetupDiGetClassDevsEx}

function SetupDiGetINFClassA(const InfName: PAnsiChar; var ClassGuid: TGUID;
  ClassName: PAnsiChar; ClassNameSize: DWORD; RequiredSize: PDWORD): BOOL; stdcall;
{$EXTERNALSYM SetupDiGetINFClassA}
function SetupDiGetINFClassW(const InfName: PWideChar; var ClassGuid: TGUID;
  ClassName: PWideChar; ClassNameSize: DWORD; RequiredSize: PDWORD): BOOL; stdcall;
{$EXTERNALSYM SetupDiGetINFClassW}
function SetupDiGetINFClass(const InfName: PTSTR; var ClassGuid: TGUID;
  ClassName: PTSTR; ClassNameSize: DWORD; RequiredSize: PDWORD): BOOL; stdcall;
{$EXTERNALSYM SetupDiGetINFClass}

function SetupDiBuildClassInfoList(Flags: DWORD; ClassGuidList: PGUID;
  ClassGuidListSize: DWORD; var RequiredSize: DWORD): BOOL; stdcall;
{$EXTERNALSYM SetupDiBuildClassInfoList}

function SetupDiBuildClassInfoListExA(Flags: DWORD; ClassGuidList: PGUID;
  ClassGuidListSize: DWORD; var RequiredSize: DWORD; const MachineName: PAnsiChar;
  Reserved: Pointer): BOOL; stdcall;
{$EXTERNALSYM SetupDiBuildClassInfoListExA}
function SetupDiBuildClassInfoListExW(Flags: DWORD; ClassGuidList: PGUID;
  ClassGuidListSize: DWORD; var RequiredSize: DWORD; const MachineName: PWideChar;
  Reserved: Pointer): BOOL; stdcall;
{$EXTERNALSYM SetupDiBuildClassInfoListExW}
function SetupDiBuildClassInfoListEx(Flags: DWORD; ClassGuidList: PGUID;
  ClassGuidListSize: DWORD; var RequiredSize: DWORD; const MachineName: PTSTR;
  Reserved: Pointer): BOOL; stdcall;
{$EXTERNALSYM SetupDiBuildClassInfoListEx}

function SetupDiGetClassDescriptionA(var ClassGuid: TGUID; ClassDescription: PAnsiChar;
  ClassDescriptionSize: DWORD; var RequiredSize: DWORD): BOOL; stdcall;
{$EXTERNALSYM SetupDiGetClassDescriptionA}
function SetupDiGetClassDescriptionW(var ClassGuid: TGUID; ClassDescription: PWideChar;
  ClassDescriptionSize: DWORD; var RequiredSize: DWORD): BOOL; stdcall;
{$EXTERNALSYM SetupDiGetClassDescriptionW}
function SetupDiGetClassDescription(var ClassGuid: TGUID; ClassDescription: PTSTR;
  ClassDescriptionSize: DWORD; var RequiredSize: DWORD): BOOL; stdcall;
{$EXTERNALSYM SetupDiGetClassDescription}

function SetupDiGetClassDescriptionExA(var ClassGuid: TGUID;
  ClassDescription: PAnsiChar; ClassDescriptionSize: DWORD; var RequiredSize: DWORD;
  const MachineName: PAnsiChar; Reserved: Pointer): BOOL; stdcall;
{$EXTERNALSYM SetupDiGetClassDescriptionExA}
function SetupDiGetClassDescriptionExW(var ClassGuid: TGUID;
  ClassDescription: PWideChar; ClassDescriptionSize: DWORD; var RequiredSize: DWORD;
  const MachineName: PWideChar; Reserved: Pointer): BOOL; stdcall;
{$EXTERNALSYM SetupDiGetClassDescriptionExW}
function SetupDiGetClassDescriptionEx(var ClassGuid: TGUID;
  ClassDescription: PTSTR; ClassDescriptionSize: DWORD; var RequiredSize: DWORD;
  const MachineName: PTSTR; Reserved: Pointer): BOOL; stdcall;
{$EXTERNALSYM SetupDiGetClassDescriptionEx}

function SetupDiCallClassInstaller(InstallFunction: DI_FUNCTION;
  DeviceInfoSet: HDEVINFO; DeviceInfoData: PSPDevInfoData): BOOL; stdcall;
{$EXTERNALSYM SetupDiCallClassInstaller}

//
// Default install handler for DIF_SELECTDEVICE
//

function SetupDiSelectDevice(DeviceInfoSet:  HDEVINFO;
  DeviceInfoData: PSPDevInfoData): BOOL; stdcall;
{$EXTERNALSYM SetupDiSelectDevice}

//
// Default install handler for DIF_SELECTBESTCOMPATDRV
//

function SetupDiSelectBestCompatDrv(DeviceInfoSet: HDEVINFO;
  DeviceInfoData: PSPDevInfoData): BOOL; stdcall;
{$EXTERNALSYM SetupDiSelectBestCompatDrv}

//
// Default install handler for DIF_INSTALLDEVICE
//
function SetupDiInstallDevice(DeviceInfoSet: HDEVINFO;
  var DeviceInfoData: TSPDevInfoData): BOOL; stdcall;
{$EXTERNALSYM SetupDiInstallDevice}

//
// Default install handler for DIF_INSTALLDEVICEFILES
//

function SetupDiInstallDriverFiles(DeviceInfoSet: HDEVINFO;
  var DeviceInfoData: TSPDevInfoData): BOOL; stdcall;
{$EXTERNALSYM SetupDiInstallDriverFiles}

//
// Default install handler for DIF_REGISTER_COINSTALLERS
//
function SetupDiRegisterCoDeviceInstallers(DeviceInfoSet: HDEVINFO;
  var DeviceInfoData: TSPDevInfoData): BOOL; stdcall;
{$EXTERNALSYM SetupDiRegisterCoDeviceInstallers}

//
// Default install handler for DIF_REMOVE
//

function SetupDiRemoveDevice(DeviceInfoSet: HDEVINFO;
  var DeviceInfoData: TSPDevInfoData): BOOL; stdcall;
{$EXTERNALSYM SetupDiRemoveDevice}

//
// Default install handler for DIF_UNREMOVE
//

function SetupDiUnremoveDevice(DeviceInfoSet: HDEVINFO;
  var DeviceInfoData: TSPDevInfoData): BOOL; stdcall;
{$EXTERNALSYM SetupDiUnremoveDevice}

//
// Default install handler for DIF_MOVEDEVICE
//
function SetupDiMoveDuplicateDevice(DeviceInfoSet: HDEVINFO;
  var DestinationDeviceInfoData: TSPDevInfoData): BOOL; stdcall;
{$EXTERNALSYM SetupDiMoveDuplicateDevice}

//
// Default install handler for DIF_PROPERTYCHANGE
//
function SetupDiChangeState(DeviceInfoSet: HDEVINFO;
  var DeviceInfoData: TSPDevInfoData): BOOL; stdcall;
{$EXTERNALSYM SetupDiChangeState}

function SetupDiInstallClassA(hwndParent: HWND; const InfFileName: PAnsiChar;
  Flags: DWORD; FileQueue: HSPFILEQ): BOOL; stdcall;
{$EXTERNALSYM SetupDiInstallClassA}
function SetupDiInstallClassW(hwndParent: HWND; const InfFileName: PWideChar;
  Flags: DWORD; FileQueue: HSPFILEQ): BOOL; stdcall;
{$EXTERNALSYM SetupDiInstallClassW}
function SetupDiInstallClass(hwndParent: HWND; const InfFileName: PTSTR;
  Flags: DWORD; FileQueue: HSPFILEQ): BOOL; stdcall;
{$EXTERNALSYM SetupDiInstallClass}

function SetupDiInstallClassExA(hwndParent: HWND; const InfFileName: PAnsiChar;
  Flags: DWORD; FileQueue: HSPFILEQ; InterfaceClassGuid: PGUID; Reserved1,
  Reserved2: Pointer): BOOL; stdcall;
{$EXTERNALSYM SetupDiInstallClassExA}
function SetupDiInstallClassExW(hwndParent: HWND; const InfFileName: PWideChar;
  Flags: DWORD; FileQueue: HSPFILEQ; InterfaceClassGuid: PGUID; Reserved1,
  Reserved2: Pointer): BOOL; stdcall;
{$EXTERNALSYM SetupDiInstallClassExW}
function SetupDiInstallClassEx(hwndParent: HWND; const InfFileName: PTSTR;
  Flags: DWORD; FileQueue: HSPFILEQ; InterfaceClassGuid: PGUID; Reserved1,
  Reserved2: Pointer): BOOL; stdcall;
{$EXTERNALSYM SetupDiInstallClassEx}

function SetupDiOpenClassRegKey(ClassGuid: PGUID; samDesired: REGSAM): HKEY; stdcall;
{$EXTERNALSYM SetupDiOpenClassRegKey}

function SetupDiOpenClassRegKeyExA(ClassGuid: PGUID; samDesired: REGSAM;
  Flags: DWORD; const MachineName: PAnsiChar; Reserved: Pointer): HKEY; stdcall;
{$EXTERNALSYM SetupDiOpenClassRegKeyExA}
function SetupDiOpenClassRegKeyExW(ClassGuid: PGUID; samDesired: REGSAM;
  Flags: DWORD; const MachineName: PWideChar; Reserved: Pointer): HKEY; stdcall;
{$EXTERNALSYM SetupDiOpenClassRegKeyExW}
function SetupDiOpenClassRegKeyEx(ClassGuid: PGUID; samDesired: REGSAM;
  Flags: DWORD; const MachineName: PTSTR; Reserved: Pointer): HKEY; stdcall;
{$EXTERNALSYM SetupDiOpenClassRegKeyEx}

function SetupDiCreateDeviceInterfaceRegKeyA(DeviceInfoSet: HDEVINFO;
  var DeviceInterfaceData: TSPDeviceInterfaceData; Reserved: DWORD;
  samDesired: REGSAM; InfHandle: HINF; const InfSectionName: PAnsiChar): HKEY; stdcall;
{$EXTERNALSYM SetupDiCreateDeviceInterfaceRegKeyA}
function SetupDiCreateDeviceInterfaceRegKeyW(DeviceInfoSet: HDEVINFO;
  var DeviceInterfaceData: TSPDeviceInterfaceData; Reserved: DWORD;
  samDesired: REGSAM; InfHandle: HINF; const InfSectionName: PWideChar): HKEY; stdcall;
{$EXTERNALSYM SetupDiCreateDeviceInterfaceRegKeyW}
function SetupDiCreateDeviceInterfaceRegKey(DeviceInfoSet: HDEVINFO;
  var DeviceInterfaceData: TSPDeviceInterfaceData; Reserved: DWORD;
  samDesired: REGSAM; InfHandle: HINF; const InfSectionName: PTSTR): HKEY; stdcall;
{$EXTERNALSYM SetupDiCreateDeviceInterfaceRegKey}

//
// Backward compatibility--do not use.
//

function SetupDiCreateInterfaceDeviceRegKeyA(DeviceInfoSet: HDEVINFO;
  var DeviceInterfaceData: TSPDeviceInterfaceData; Reserved: DWORD;
  samDesired: REGSAM; InfHandle: HINF; const InfSectionName: PAnsiChar): HKEY; stdcall;
{$EXTERNALSYM SetupDiCreateInterfaceDeviceRegKeyA}
function SetupDiCreateInterfaceDeviceRegKeyW(DeviceInfoSet: HDEVINFO;
  var DeviceInterfaceData: TSPDeviceInterfaceData; Reserved: DWORD;
  samDesired: REGSAM; InfHandle: HINF; const InfSectionName: PWideChar): HKEY; stdcall;
{$EXTERNALSYM SetupDiCreateInterfaceDeviceRegKeyW}
function SetupDiCreateInterfaceDeviceRegKey(DeviceInfoSet: HDEVINFO;
  var DeviceInterfaceData: TSPDeviceInterfaceData; Reserved: DWORD;
  samDesired: REGSAM; InfHandle: HINF; const InfSectionName: PTSTR): HKEY; stdcall;
{$EXTERNALSYM SetupDiCreateInterfaceDeviceRegKey}

function SetupDiOpenDeviceInterfaceRegKey(DeviceInfoSet: HDEVINFO;
  var DeviceInterfaceData: TSPDeviceInterfaceData; Reserved: DWORD;
  samDesired: REGSAM): HKEY; stdcall;
{$EXTERNALSYM SetupDiOpenDeviceInterfaceRegKey}

//
// Backward compatibility--do not use.
//

function SetupDiOpenInterfaceDeviceRegKey(DeviceInfoSet: HDEVINFO;
  var DeviceInterfaceData: TSPDeviceInterfaceData; Reserved: DWORD;
  samDesired: REGSAM): HKEY; stdcall;
{$EXTERNALSYM SetupDiOpenInterfaceDeviceRegKey}

function SetupDiDeleteDeviceInterfaceRegKey(DeviceInfoSet: HDEVINFO;
  var DeviceInterfaceData: TSPDeviceInterfaceData; Reserved: DWORD): BOOL; stdcall;
{$EXTERNALSYM SetupDiDeleteDeviceInterfaceRegKey}

//
// Backward compatibility--do not use.
//

function SetupDiDeleteInterfaceDeviceRegKey(DeviceInfoSet: HDEVINFO;
  var DeviceInterfaceData: TSPDeviceInterfaceData; Reserved: DWORD): BOOL; stdcall;
{$EXTERNALSYM SetupDiDeleteInterfaceDeviceRegKey}

function SetupDiCreateDevRegKeyA(DeviceInfoSet: HDEVINFO;
  var DeviceInfoData: TSPDevInfoData; Scope, HwProfile, KeyType: DWORD;
  InfHandle: HINF; const InfSectionName: PAnsiChar): HKEY; stdcall;
{$EXTERNALSYM SetupDiCreateDevRegKeyA}
function SetupDiCreateDevRegKeyW(DeviceInfoSet: HDEVINFO;
  var DeviceInfoData: TSPDevInfoData; Scope, HwProfile, KeyType: DWORD;
  InfHandle: HINF; const InfSectionName: PWideChar): HKEY; stdcall;
{$EXTERNALSYM SetupDiCreateDevRegKeyW}
function SetupDiCreateDevRegKey(DeviceInfoSet: HDEVINFO;
  var DeviceInfoData: TSPDevInfoData; Scope, HwProfile, KeyType: DWORD;
  InfHandle: HINF; const InfSectionName: PTSTR): HKEY; stdcall;
{$EXTERNALSYM SetupDiCreateDevRegKey}


function SetupDiOpenDevRegKey(DeviceInfoSet: HDEVINFO;
  var DeviceInfoData: TSPDevInfoData; Scope, HwProfile, KeyType: DWORD;
  samDesired: REGSAM): HKEY; stdcall;
{$EXTERNALSYM SetupDiOpenDevRegKey}

function SetupDiDeleteDevRegKey(DeviceInfoSet: HDEVINFO;
  var DeviceInfoData: TSPDevInfoData; Scope, HwProfile,
  KeyType: DWORD): BOOL; stdcall;
{$EXTERNALSYM SetupDiDeleteDevRegKey}

function SetupDiGetHwProfileList(HwProfileList: PDWORD; HwProfileListSize: DWORD;
  var RequiredSize: DWORD; CurrentlyActiveIndex: PDWORD): BOOL; stdcall;
{$EXTERNALSYM SetupDiGetHwProfileList}

function SetupDiGetHwProfileListExA(HwProfileList: PDWORD;
  HwProfileListSize: DWORD; var RequiredSize: DWORD; CurrentlyActiveIndex: PDWORD;
  const MachineName: PAnsiChar; Reserved: Pointer): BOOL; stdcall;
{$EXTERNALSYM SetupDiGetHwProfileListExA}
function SetupDiGetHwProfileListExW(HwProfileList: PDWORD;
  HwProfileListSize: DWORD; var RequiredSize: DWORD; CurrentlyActiveIndex: PDWORD;
  const MachineName: PWideChar; Reserved: Pointer): BOOL; stdcall;
{$EXTERNALSYM SetupDiGetHwProfileListExW}
function SetupDiGetHwProfileListEx(HwProfileList: PDWORD;
  HwProfileListSize: DWORD; var RequiredSize: DWORD; CurrentlyActiveIndex: PDWORD;
  const MachineName: PTSTR; Reserved: Pointer): BOOL; stdcall;
{$EXTERNALSYM SetupDiGetHwProfileListEx}

function SetupDiGetDeviceRegistryPropertyA(DeviceInfoSet: HDEVINFO;
  const DeviceInfoData: TSPDevInfoData; Property_: DWORD;
  var PropertyRegDataType: DWORD; PropertyBuffer: PBYTE; PropertyBufferSize: DWORD;
  var RequiredSize: DWORD): BOOL; stdcall;
{$EXTERNALSYM SetupDiGetDeviceRegistryPropertyA}
function SetupDiGetDeviceRegistryPropertyW(DeviceInfoSet: HDEVINFO;
  const DeviceInfoData: TSPDevInfoData; Property_: DWORD;
  var PropertyRegDataType: DWORD; PropertyBuffer: PBYTE; PropertyBufferSize: DWORD;
  var RequiredSize: DWORD): BOOL; stdcall;
{$EXTERNALSYM SetupDiGetDeviceRegistryPropertyW}
function SetupDiGetDeviceRegistryProperty(DeviceInfoSet: HDEVINFO;
  const DeviceInfoData: TSPDevInfoData; Property_: DWORD;
  var PropertyRegDataType: DWORD; PropertyBuffer: PBYTE; PropertyBufferSize: DWORD;
  var RequiredSize: DWORD): BOOL; stdcall;
{$EXTERNALSYM SetupDiGetDeviceRegistryProperty}

{$IFDEF WINXP_UP}
function SetupDiGetClassRegistryPropertyA(const ClassGuid: TGUID;
  Property_: DWORD; PropertyRegDataType: PDWORD; PropertyBuffer: PBYTE;
  PropertyBufferSize: DWORD; RequiredSize: PDWORD; const MachineName: PAnsiChar;
  Reserved: Pointer): BOOL; stdcall;
{$EXTERNALSYM SetupDiGetClassRegistryPropertyA}
function SetupDiGetClassRegistryPropertyW(const ClassGuid: TGUID;
  Property_: DWORD; PropertyRegDataType: PDWORD; PropertyBuffer: PBYTE;
  PropertyBufferSize: DWORD; RequiredSize: PDWORD; const MachineName: PWideChar;
  Reserved: Pointer): BOOL; stdcall;
{$EXTERNALSYM SetupDiGetClassRegistryPropertyW}
function SetupDiGetClassRegistryProperty(const ClassGuid: TGUID;
  Property_: DWORD; PropertyRegDataType: PDWORD; PropertyBuffer: PBYTE;
  PropertyBufferSize: DWORD; RequiredSize: PDWORD; const MachineName: PTSTR;
  Reserved: Pointer): BOOL; stdcall;
{$EXTERNALSYM SetupDiGetClassRegistryProperty}
{$ENDIF WINXP_UP}

function SetupDiSetDeviceRegistryPropertyA(DeviceInfoSet: HDEVINFO;
  var DeviceInfoData: TSPDevInfoData; Property_: DWORD;
  const PropertyBuffer: PBYTE; PropertyBufferSize: DWORD): BOOL; stdcall;
{$EXTERNALSYM SetupDiSetDeviceRegistryPropertyA}
function SetupDiSetDeviceRegistryPropertyW(DeviceInfoSet: HDEVINFO;
  var DeviceInfoData: TSPDevInfoData; Property_: DWORD;
  const PropertyBuffer: PBYTE; PropertyBufferSize: DWORD): BOOL; stdcall;
{$EXTERNALSYM SetupDiSetDeviceRegistryPropertyW}
function SetupDiSetDeviceRegistryProperty(DeviceInfoSet: HDEVINFO;
  var DeviceInfoData: TSPDevInfoData; Property_: DWORD;
  const PropertyBuffer: PBYTE; PropertyBufferSize: DWORD): BOOL; stdcall;
{$EXTERNALSYM SetupDiSetDeviceRegistryProperty}

{$IFDEF WINXP_UP}
function SetupDiSetClassRegistryPropertyA(const ClassGuid: TGUID;
  Property_: DWORD; const PropertyBuffer: PBYTE; PropertyBufferSize: DWORD;
  const MachineName: PAnsiChar; Reserved: Pointer): BOOL; stdcall;
{$EXTERNALSYM SetupDiSetClassRegistryPropertyA}
function SetupDiSetClassRegistryPropertyW(const ClassGuid: TGUID;
  Property_: DWORD; const PropertyBuffer: PBYTE; PropertyBufferSize: DWORD;
  const MachineName: PWideChar; Reserved: Pointer): BOOL; stdcall;
{$EXTERNALSYM SetupDiSetClassRegistryPropertyW}
function SetupDiSetClassRegistryProperty(const ClassGuid: TGUID;
  Property_: DWORD; const PropertyBuffer: PBYTE; PropertyBufferSize: DWORD;
  const MachineName: PTSTR; Reserved: Pointer): BOOL; stdcall;
{$EXTERNALSYM SetupDiSetClassRegistryProperty}
{$ENDIF WINXP_UP}

function SetupDiGetDeviceInstallParamsA(DeviceInfoSet: HDEVINFO;
  DeviceInfoData: PSPDevInfoData;
  var DeviceInstallParams: TSPDevInstallParamsA): BOOL; stdcall;
{$EXTERNALSYM SetupDiGetDeviceInstallParamsA}
function SetupDiGetDeviceInstallParamsW(DeviceInfoSet: HDEVINFO;
  DeviceInfoData: PSPDevInfoData;
  var DeviceInstallParams: TSPDevInstallParamsW): BOOL; stdcall;
{$EXTERNALSYM SetupDiGetDeviceInstallParamsW}
function SetupDiGetDeviceInstallParams(DeviceInfoSet: HDEVINFO;
  DeviceInfoData: PSPDevInfoData;
  var DeviceInstallParams: TSPDevInstallParams): BOOL; stdcall;
{$EXTERNALSYM SetupDiGetDeviceInstallParams}


function SetupDiGetClassInstallParamsA(DeviceInfoSet: HDEVINFO;
  DeviceInfoData: PSPDevInfoData; ClassInstallParams: PSPClassInstallHeader;
  ClassInstallParamsSize: DWORD; RequiredSize: PDWORD): BOOL; stdcall;
{$EXTERNALSYM SetupDiGetClassInstallParamsA}
function SetupDiGetClassInstallParamsW(DeviceInfoSet: HDEVINFO;
  DeviceInfoData: PSPDevInfoData; ClassInstallParams: PSPClassInstallHeader;
  ClassInstallParamsSize: DWORD; RequiredSize: PDWORD): BOOL; stdcall;
{$EXTERNALSYM SetupDiGetClassInstallParamsW}
function SetupDiGetClassInstallParams(DeviceInfoSet: HDEVINFO;
  DeviceInfoData: PSPDevInfoData; ClassInstallParams: PSPClassInstallHeader;
  ClassInstallParamsSize: DWORD; RequiredSize: PDWORD): BOOL; stdcall;
{$EXTERNALSYM SetupDiGetClassInstallParams}

function SetupDiSetDeviceInstallParamsA(DeviceInfoSet: HDEVINFO;
  DeviceInfoData: PSPDevInfoData;
  var DeviceInstallParams: TSPDevInstallParamsA): BOOL; stdcall;
{$EXTERNALSYM SetupDiSetDeviceInstallParamsA}
function SetupDiSetDeviceInstallParamsW(DeviceInfoSet: HDEVINFO;
  DeviceInfoData: PSPDevInfoData;
  var DeviceInstallParams: TSPDevInstallParamsW): BOOL; stdcall;
{$EXTERNALSYM SetupDiSetDeviceInstallParamsW}
function SetupDiSetDeviceInstallParams(DeviceInfoSet: HDEVINFO;
  DeviceInfoData: PSPDevInfoData;
  var DeviceInstallParams: TSPDevInstallParams): BOOL; stdcall;
{$EXTERNALSYM SetupDiSetDeviceInstallParams}

function SetupDiSetClassInstallParamsA(DeviceInfoSet: HDEVINFO;
  DeviceInfoData: PSPDevInfoData; ClassInstallParams: PSPClassInstallHeader;
  ClassInstallParamsSize: DWORD): BOOL; stdcall;
{$EXTERNALSYM SetupDiSetClassInstallParamsA}
function SetupDiSetClassInstallParamsW(DeviceInfoSet: HDEVINFO;
  DeviceInfoData: PSPDevInfoData; ClassInstallParams: PSPClassInstallHeader;
  ClassInstallParamsSize: DWORD): BOOL; stdcall;
{$EXTERNALSYM SetupDiSetClassInstallParamsW}
function SetupDiSetClassInstallParams(DeviceInfoSet: HDEVINFO;
  DeviceInfoData: PSPDevInfoData; ClassInstallParams: PSPClassInstallHeader;
  ClassInstallParamsSize: DWORD): BOOL; stdcall;
{$EXTERNALSYM SetupDiSetClassInstallParams}

function SetupDiGetDriverInstallParamsA(DeviceInfoSet: HDEVINFO;
  DeviceInfoData: PSPDevInfoData; var DriverInfoData: TSPDrvInfoDataA;
  var DriverInstallParams: TSPDrvInstallParams): BOOL; stdcall;
{$EXTERNALSYM SetupDiGetDriverInstallParamsA}
function SetupDiGetDriverInstallParamsW(DeviceInfoSet: HDEVINFO;
  DeviceInfoData: PSPDevInfoData; var DriverInfoData: TSPDrvInfoDataW;
  var DriverInstallParams: TSPDrvInstallParams): BOOL; stdcall;
{$EXTERNALSYM SetupDiGetDriverInstallParamsW}
function SetupDiGetDriverInstallParams(DeviceInfoSet: HDEVINFO;
  DeviceInfoData: PSPDevInfoData; var DriverInfoData: TSPDrvInfoData;
  var DriverInstallParams: TSPDrvInstallParams): BOOL; stdcall;
{$EXTERNALSYM SetupDiGetDriverInstallParams}

function SetupDiSetDriverInstallParamsA(DeviceInfoSet: HDEVINFO;
  DeviceInfoData: PSPDevInfoData; var DriverInfoData: TSPDrvInfoDataA;
  var DriverInstallParams: TSPDrvInstallParams): BOOL; stdcall;
{$EXTERNALSYM SetupDiSetDriverInstallParamsA}
function SetupDiSetDriverInstallParamsW(DeviceInfoSet: HDEVINFO;
  DeviceInfoData: PSPDevInfoData; var DriverInfoData: TSPDrvInfoDataW;
  var DriverInstallParams: TSPDrvInstallParams): BOOL; stdcall;
{$EXTERNALSYM SetupDiSetDriverInstallParamsW}
function SetupDiSetDriverInstallParams(DeviceInfoSet: HDEVINFO;
  DeviceInfoData: PSPDevInfoData; var DriverInfoData: TSPDrvInfoData;
  var DriverInstallParams: TSPDrvInstallParams): BOOL; stdcall;
{$EXTERNALSYM SetupDiSetDriverInstallParams}

function SetupDiLoadClassIcon(var ClassGuid: TGUID; LargeIcon: PHICON;
  MiniIconIndex: PINT): BOOL; stdcall;
{$EXTERNALSYM SetupDiLoadClassIcon}

function SetupDiDrawMiniIcon(hdc: HDC; rc: TRect; MiniIconIndex: Integer;
  Flags: DWORD): Integer; stdcall;
{$EXTERNALSYM SetupDiDrawMiniIcon}

function SetupDiGetClassBitmapIndex(ClassGuid: PGUID;
  var MiniIconIndex: Integer): BOOL; stdcall;
{$EXTERNALSYM SetupDiGetClassBitmapIndex}

function SetupDiGetClassImageList(
  var ClassImageListData: TSPClassImageListData): BOOL; stdcall;
{$EXTERNALSYM SetupDiGetClassImageList}

function SetupDiGetClassImageListExA(var ClassImageListData: TSPClassImageListData;
  const MachineName: PAnsiChar; Reserved: Pointer): BOOL; stdcall;
{$EXTERNALSYM SetupDiGetClassImageListExA}
function SetupDiGetClassImageListExW(var ClassImageListData: TSPClassImageListData;
  const MachineName: PWideChar; Reserved: Pointer): BOOL; stdcall;
{$EXTERNALSYM SetupDiGetClassImageListExW}
function SetupDiGetClassImageListEx(var ClassImageListData: TSPClassImageListData;
  const MachineName: PTSTR; Reserved: Pointer): BOOL; stdcall;
{$EXTERNALSYM SetupDiGetClassImageListEx}

function SetupDiGetClassImageIndex(var ClassImageListData: TSPClassImageListData;
  var ClassGuid: TGUID; var ImageIndex: Integer): BOOL; stdcall;
{$EXTERNALSYM SetupDiGetClassImageIndex}

function SetupDiDestroyClassImageList(
  var ClassImageListData: TSPClassImageListData): BOOL; stdcall;
{$EXTERNALSYM SetupDiDestroyClassImageList}

function SetupDiGetClassDevPropertySheetsA(DeviceInfoSet: HDEVINFO;
  DeviceInfoData: PSPDevInfoData; var PropertySheetHeader: TPropSheetHeaderA;
  PropertySheetHeaderPageListSize: DWORD; RequiredSize: PDWORD;
  PropertySheetType: DWORD): BOOL; stdcall;
{$EXTERNALSYM SetupDiGetClassDevPropertySheetsA}
function SetupDiGetClassDevPropertySheetsW(DeviceInfoSet: HDEVINFO;
  DeviceInfoData: PSPDevInfoData; var PropertySheetHeader: TPropSheetHeaderW;
  PropertySheetHeaderPageListSize: DWORD; RequiredSize: PDWORD;
  PropertySheetType: DWORD): BOOL; stdcall;
{$EXTERNALSYM SetupDiGetClassDevPropertySheetsW}
function SetupDiGetClassDevPropertySheets(DeviceInfoSet: HDEVINFO;
  DeviceInfoData: PSPDevInfoData; var PropertySheetHeader: TPropSheetHeader;
  PropertySheetHeaderPageListSize: DWORD; RequiredSize: PDWORD;
  PropertySheetType: DWORD): BOOL; stdcall;
{$EXTERNALSYM SetupDiGetClassDevPropertySheets}

function SetupDiAskForOEMDisk(DeviceInfoSet: HDEVINFO; DeviceInfoData: PSPDevInfoData): BOOL; stdcall;
{$EXTERNALSYM SetupDiAskForOEMDisk}

function SetupDiSelectOEMDrv(hwndParent: HWND; DeviceInfoSet: HDEVINFO;
  DeviceInfoData: PSPDevInfoData): BOOL; stdcall;
{$EXTERNALSYM SetupDiSelectOEMDrv}

function SetupDiClassNameFromGuidA(var ClassGuid: TGUID; ClassName: PAnsiChar;
  ClassNameSize: DWORD; RequiredSize: PDWORD): BOOL; stdcall;
{$EXTERNALSYM SetupDiClassNameFromGuidA}
function SetupDiClassNameFromGuidW(var ClassGuid: TGUID; ClassName: PWideChar;
  ClassNameSize: DWORD; RequiredSize: PDWORD): BOOL; stdcall;
{$EXTERNALSYM SetupDiClassNameFromGuidW}
function SetupDiClassNameFromGuid(var ClassGuid: TGUID; ClassName: PTSTR;
  ClassNameSize: DWORD; RequiredSize: PDWORD): BOOL; stdcall;
{$EXTERNALSYM SetupDiClassNameFromGuid}

function SetupDiClassNameFromGuidExA(var ClassGuid: TGUID; ClassName: PAnsiChar;
  ClassNameSize: DWORD; RequiredSize: PDWORD; const MachineName: PAnsiChar;
  Reserved: Pointer): BOOL; stdcall;
{$EXTERNALSYM SetupDiClassNameFromGuidExA}
function SetupDiClassNameFromGuidExW(var ClassGuid: TGUID; ClassName: PWideChar;
  ClassNameSize: DWORD; RequiredSize: PDWORD; const MachineName: PWideChar;
  Reserved: Pointer): BOOL; stdcall;
{$EXTERNALSYM SetupDiClassNameFromGuidExW}
function SetupDiClassNameFromGuidEx(var ClassGuid: TGUID; ClassName: PTSTR;
  ClassNameSize: DWORD; RequiredSize: PDWORD; const MachineName: PTSTR;
  Reserved: Pointer): BOOL; stdcall;
{$EXTERNALSYM SetupDiClassNameFromGuidEx}

function SetupDiClassGuidsFromNameA(const ClassName: PAnsiChar; ClassGuidList: PGUID;
  ClassGuidListSize: DWORD; var RequiredSize: DWORD): BOOL; stdcall;
{$EXTERNALSYM SetupDiClassGuidsFromNameA}
function SetupDiClassGuidsFromNameW(const ClassName: PWideChar; ClassGuidList: PGUID;
  ClassGuidListSize: DWORD; var RequiredSize: DWORD): BOOL; stdcall;
{$EXTERNALSYM SetupDiClassGuidsFromNameW}
function SetupDiClassGuidsFromName(const ClassName: PTSTR; ClassGuidList: PGUID;
  ClassGuidListSize: DWORD; var RequiredSize: DWORD): BOOL; stdcall;
{$EXTERNALSYM SetupDiClassGuidsFromName}

function SetupDiClassGuidsFromNameExA(const ClassName: PAnsiChar; ClassGuidList: PGUID;
  ClassGuidListSize: DWORD; var RequiredSize: DWORD; const MachineName: PAnsiChar;
  Reserved: Pointer): BOOL; stdcall;
{$EXTERNALSYM SetupDiClassGuidsFromNameExA}
function SetupDiClassGuidsFromNameExW(const ClassName: PWideChar; ClassGuidList: PGUID;
  ClassGuidListSize: DWORD; var RequiredSize: DWORD; const MachineName: PWideChar;
  Reserved: Pointer): BOOL; stdcall;
{$EXTERNALSYM SetupDiClassGuidsFromNameExW}
function SetupDiClassGuidsFromNameEx(const ClassName: PTSTR; ClassGuidList: PGUID;
  ClassGuidListSize: DWORD; var RequiredSize: DWORD; const MachineName: PTSTR;
  Reserved: Pointer): BOOL; stdcall;
{$EXTERNALSYM SetupDiClassGuidsFromNameEx}

function SetupDiGetHwProfileFriendlyNameA(HwProfile: DWORD; FriendlyName: PAnsiChar;
  FriendlyNameSize: DWORD; RequiredSize: PDWORD): BOOL; stdcall;
{$EXTERNALSYM SetupDiGetHwProfileFriendlyNameA}
function SetupDiGetHwProfileFriendlyNameW(HwProfile: DWORD; FriendlyName: PWideChar;
  FriendlyNameSize: DWORD; RequiredSize: PDWORD): BOOL; stdcall;
{$EXTERNALSYM SetupDiGetHwProfileFriendlyNameW}
function SetupDiGetHwProfileFriendlyName(HwProfile: DWORD; FriendlyName: PTSTR;
  FriendlyNameSize: DWORD; RequiredSize: PDWORD): BOOL; stdcall;
{$EXTERNALSYM SetupDiGetHwProfileFriendlyName}

function SetupDiGetHwProfileFriendlyNameExA(HwProfile: DWORD; FriendlyName: PAnsiChar;
  FriendlyNameSize: DWORD; RequiredSize: PDWORD; const MachineName: PAnsiChar;
  Reserved: Pointer): BOOL; stdcall;
{$EXTERNALSYM SetupDiGetHwProfileFriendlyNameExA}
function SetupDiGetHwProfileFriendlyNameExW(HwProfile: DWORD; FriendlyName: PWideChar;
  FriendlyNameSize: DWORD; RequiredSize: PDWORD; const MachineName: PWideChar;
  Reserved: Pointer): BOOL; stdcall;
{$EXTERNALSYM SetupDiGetHwProfileFriendlyNameExW}
function SetupDiGetHwProfileFriendlyNameEx(HwProfile: DWORD; FriendlyName: PTSTR;
  FriendlyNameSize: DWORD; RequiredSize: PDWORD; const MachineName: PTSTR;
  Reserved: Pointer): BOOL; stdcall;
{$EXTERNALSYM SetupDiGetHwProfileFriendlyNameEx}

function SetupDiGetWizardPage(DeviceInfoSet: HDEVINFO;
  DeviceInfoData: PSPDevInfoData; var InstallWizardData: TSPInstallWizardData;
  PageType: DWORD; Flags: DWORD): HPROPSHEETPAGE; stdcall;
{$EXTERNALSYM SetupDiGetWizardPage}

function SetupDiGetSelectedDevice(DeviceInfoSet: HDEVINFO;
  var DeviceInfoData: TSPDevInfoData): BOOL; stdcall;
{$EXTERNALSYM SetupDiGetSelectedDevice}

function SetupDiSetSelectedDevice(DeviceInfoSet: HDEVINFO;
  var DeviceInfoData: TSPDevInfoData): BOOL; stdcall;
{$EXTERNALSYM SetupDiSetSelectedDevice}

function SetupDiGetActualSectionToInstallA(InfHandle: HINF;
  const InfSectionName: PAnsiChar; InfSectionWithExt: PAnsiChar; InfSectionWithExtSize: DWORD;
  RequiredSize: PDWORD; Extension: PPASTR): BOOL; stdcall;
{$EXTERNALSYM SetupDiGetActualSectionToInstallA}
function SetupDiGetActualSectionToInstallW(InfHandle: HINF;
  const InfSectionName: PWideChar; InfSectionWithExt: PWideChar; InfSectionWithExtSize: DWORD;
  RequiredSize: PDWORD; Extension: PPWSTR): BOOL; stdcall;
{$EXTERNALSYM SetupDiGetActualSectionToInstallW}
function SetupDiGetActualSectionToInstall(InfHandle: HINF;
  const InfSectionName: PTSTR; InfSectionWithExt: PTSTR; InfSectionWithExtSize: DWORD;
  RequiredSize: PDWORD; Extension: PPSTR): BOOL; stdcall;
{$EXTERNALSYM SetupDiGetActualSectionToInstall}

{$IFDEF WINXP_UP}

function SetupDiGetActualSectionToInstallExA(InfHandle: HINF;
  InfSectionName: PAnsiChar; AlternatePlatformInfo: PSPAltPlatformInfo;
  InfSectionWithExt: PAnsiChar; InfSectionWithExtSize: DWORD;
  RequiredSize: PDWORD; Extension: PPASTR; Reserved: Pointer): BOOL; stdcall;
function SetupDiGetActualSectionToInstallExW(InfHandle: HINF;
  InfSectionName: PWideChar; AlternatePlatformInfo: PSPAltPlatformInfo;
  InfSectionWithExt: PWideChar; InfSectionWithExtSize: DWORD;
  RequiredSize: PDWORD; Extension: PPWSTR; Reserved: Pointer): BOOL; stdcall;
function SetupDiGetActualSectionToInstallEx(InfHandle: HINF;
  InfSectionName: PTSTR; AlternatePlatformInfo: PSPAltPlatformInfo;
  InfSectionWithExt: PTSTR; InfSectionWithExtSize: DWORD;
  RequiredSize: PDWORD; Extension: PPSTR; Reserved: Pointer): BOOL; stdcall;

//
// SetupEnumInfSections is for low-level parsing of an INF
//
function SetupEnumInfSectionsA(InfHandle: HINF; Index: UINT;
  Buffer: PAnsiChar; Size: UINT; SizeNeeded: PUINT): BOOL; stdcall;
function SetupEnumInfSectionsW(InfHandle: HINF; Index: UINT;
  Buffer: PWideChar; Size: UINT; SizeNeeded: PUINT): BOOL; stdcall;
function SetupEnumInfSections(InfHandle: HINF; Index: UINT;
  Buffer: PAnsiChar; Size: UINT; SizeNeeded: PUINT): BOOL; stdcall;

function SetupVerifyInfFileA(InfName: PAnsiChar; AltPlatformInfo: PSPAltPlatformInfo;
  var InfSignerInfo: TSPInfSignerInfoA): BOOL; stdcall;
function SetupVerifyInfFileW(InfName: PWideChar; AltPlatformInfo: PSPAltPlatformInfo;
  var InfSignerInfo: TSPInfSignerInfoW): BOOL; stdcall;
function SetupVerifyInfFile(InfName: PAnsiChar; AltPlatformInfo: PSPAltPlatformInfo;
  var InfSignerInfo: TSPInfSignerInfo): BOOL; stdcall;

function SetupDiGetCustomDevicePropertyA(DeviceInfoSet: HDEVINFO;
  const DeviceInfoData: TSPDevInfoData; CustomPropertyName: PAnsiChar;
  Flags: DWORD; PropertyRegDataType: PDWORD; PropertyBuffer: PBYTE;
  PropertyBufferSize: DWORD; RequiredSize: PDWORD): BOOL; stdcall;
function SetupDiGetCustomDevicePropertyW(DeviceInfoSet: HDEVINFO;
  const DeviceInfoData: TSPDevInfoData; CustomPropertyName: PWideChar;
  Flags: DWORD; PropertyRegDataType: PDWORD; PropertyBuffer: PBYTE;
  PropertyBufferSize: DWORD; RequiredSize: PDWORD): BOOL; stdcall;
function SetupDiGetCustomDeviceProperty(DeviceInfoSet: HDEVINFO;
  const DeviceInfoData: TSPDevInfoData; CustomPropertyName: PAnsiChar;
  Flags: DWORD; PropertyRegDataType: PDWORD; PropertyBuffer: PBYTE;
  PropertyBufferSize: DWORD; RequiredSize: PDWORD): BOOL; stdcall;
  
{$ENDIF WINXP_UP}

{$ELSE}

// (rom) remove all #defines Microsoft generated in SetupApi.h
// (rom) to handle A/W functions

(*$HPPEMIT '#undef SetupGetInfInformation'*)
(*$HPPEMIT '#undef SetupQueryInfFileInformation'*)
(*$HPPEMIT '#undef SetupQueryInfOriginalFileInformation'*)
(*$HPPEMIT '#undef SetupQueryInfVersionInformation'*)
(*$HPPEMIT '#undef SetupGetInfFileList'*)
(*$HPPEMIT '#undef SetupOpenInfFile'*)
(*$HPPEMIT '#undef SetupOpenAppendInfFile'*)
(*$HPPEMIT '#undef SetupFindFirstLine'*)
(*$HPPEMIT '#undef SetupFindNextMatchLine'*)
(*$HPPEMIT '#undef SetupGetLineByIndex'*)
(*$HPPEMIT '#undef SetupGetLineCount'*)
(*$HPPEMIT '#undef SetupGetLineText'*)
(*$HPPEMIT '#undef SetupGetStringField'*)
(*$HPPEMIT '#undef SetupGetMultiSzField'*)
(*$HPPEMIT '#undef SetupGetFileCompressionInfo'*)
{$IFDEF WINXP_UP}
(*$HPPEMIT '#undef SetupGetFileCompressionInfoEx'*)
{$ENDIF WINXP_UP}
(*$HPPEMIT '#undef SetupDecompressOrCopyFile'*)
(*$HPPEMIT '#undef SetupGetSourceFileLocation'*)
(*$HPPEMIT '#undef SetupGetSourceFileSize'*)
(*$HPPEMIT '#undef SetupGetTargetPath'*)
(*$HPPEMIT '#undef SetupSetSourceList'*)
(*$HPPEMIT '#undef SetupAddToSourceList'*)
(*$HPPEMIT '#undef SetupRemoveFromSourceList'*)
(*$HPPEMIT '#undef SetupQuerySourceList'*)
(*$HPPEMIT '#undef SetupFreeSourceList'*)
(*$HPPEMIT '#undef SetupPromptForDisk'*)
(*$HPPEMIT '#undef SetupCopyError'*)
(*$HPPEMIT '#undef SetupRenameError'*)
(*$HPPEMIT '#undef SetupDeleteError'*)
(*$HPPEMIT '#undef SetupBackupError'*)
(*$HPPEMIT '#undef SetupSetDirectoryId'*)
(*$HPPEMIT '#undef SetupSetDirectoryIdEx'*)
(*$HPPEMIT '#undef SetupGetSourceInfo'*)
(*$HPPEMIT '#undef SetupInstallFile'*)
(*$HPPEMIT '#undef SetupInstallFileEx'*)
(*$HPPEMIT '#undef SetupSetFileQueueAlternatePlatform'*)
(*$HPPEMIT '#undef SetupSetPlatformPathOverride'*)
(*$HPPEMIT '#undef SetupQueueCopy'*)
(*$HPPEMIT '#undef SetupQueueCopyIndirect'*)
(*$HPPEMIT '#undef SetupQueueDefaultCopy'*)
(*$HPPEMIT '#undef SetupQueueCopySection'*)
(*$HPPEMIT '#undef SetupQueueDelete'*)
(*$HPPEMIT '#undef SetupQueueDeleteSection'*)
(*$HPPEMIT '#undef SetupQueueRename'*)
(*$HPPEMIT '#undef SetupQueueRenameSection'*)
(*$HPPEMIT '#undef SetupCommitFileQueue'*)
(*$HPPEMIT '#undef SetupScanFileQueue'*)
(*$HPPEMIT '#undef SetupCopyOEMInf'*)
{$IFDEF WINXP_UP}
(*$HPPEMIT '#undef SetupUninstallOEMInf'*)
{$ENDIF WINXP_UP}
(*$HPPEMIT '#undef SetupCreateDiskSpaceList'*)
(*$HPPEMIT '#undef SetupDuplicateDiskSpaceList'*)
(*$HPPEMIT '#undef SetupQueryDrivesInDiskSpaceList'*)
(*$HPPEMIT '#undef SetupQuerySpaceRequiredOnDrive'*)
(*$HPPEMIT '#undef SetupAdjustDiskSpaceList'*)
(*$HPPEMIT '#undef SetupAddToDiskSpaceList'*)
(*$HPPEMIT '#undef SetupAddSectionToDiskSpaceList'*)
(*$HPPEMIT '#undef SetupAddInstallSectionToDiskSpaceList'*)
(*$HPPEMIT '#undef SetupRemoveFromDiskSpaceList'*)
(*$HPPEMIT '#undef SetupRemoveSectionFromDiskSpaceList'*)
(*$HPPEMIT '#undef SetupRemoveInstallSectionFromDiskSpaceList'*)
(*$HPPEMIT '#undef SetupIterateCabinet'*)
(*$HPPEMIT '#undef SetupDefaultQueueCallback'*)
(*$HPPEMIT '#undef SetupInstallFromInfSection'*)
(*$HPPEMIT '#undef SetupInstallFilesFromInfSection'*)
(*$HPPEMIT '#undef SetupInstallServicesFromInfSection'*)
(*$HPPEMIT '#undef SetupInstallServicesFromInfSectionEx'*)
{$IFDEF WINXP_UP}
(*$HPPEMIT '#undef InstallHinfSection'*)
{$ENDIF WINXP_UP}
(*$HPPEMIT '#undef SetupInitializeFileLog'*)
(*$HPPEMIT '#undef SetupLogFile'*)
(*$HPPEMIT '#undef SetupRemoveFileLogEntry'*)
(*$HPPEMIT '#undef SetupQueryFileLog'*)
(*$HPPEMIT '#undef SetupLogError'*)
(*$HPPEMIT '#undef SetupGetBackupInformation'*)
{$IFDEF WINXP_UP}
(*$HPPEMIT '#undef SetupPrepareQueueForRestore'*)
{$ENDIF WINXP_UP}
(*$HPPEMIT '#undef SetupDiCreateDeviceInfoListEx'*)
(*$HPPEMIT '#undef SetupDiGetDeviceInfoListDetail'*)
(*$HPPEMIT '#undef SetupDiCreateDeviceInfo'*)
(*$HPPEMIT '#undef SetupDiOpenDeviceInfo'*)
(*$HPPEMIT '#undef SetupDiGetDeviceInstanceId'*)
(*$HPPEMIT '#undef SetupDiEnumInterfaceDevice'*)
(*$HPPEMIT '#undef SetupDiCreateDeviceInterface'*)
(*$HPPEMIT '#undef SetupDiCreateInterfaceDeviceA'*)
(*$HPPEMIT '#undef SetupDiCreateInterfaceDeviceW'*)
(*$HPPEMIT '#undef SetupDiCreateInterfaceDevice'*)
(*$HPPEMIT '#undef SetupDiOpenDeviceInterface'*)
(*$HPPEMIT '#undef SetupDiOpenInterfaceDeviceA'*)
(*$HPPEMIT '#undef SetupDiOpenInterfaceDeviceW'*)
(*$HPPEMIT '#undef SetupDiOpenInterfaceDevice'*)
(*$HPPEMIT '#undef SetupDiGetInterfaceDeviceAlias'*)
(*$HPPEMIT '#undef SetupDiDeleteInterfaceDeviceData'*)
(*$HPPEMIT '#undef SetupDiRemoveInterfaceDevice'*)
(*$HPPEMIT '#undef SetupDiGetDeviceInterfaceDetail'*)
(*$HPPEMIT '#undef SetupDiGetInterfaceDeviceDetailA'*)
(*$HPPEMIT '#undef SetupDiGetInterfaceDeviceDetailW'*)
(*$HPPEMIT '#undef SetupDiGetInterfaceDeviceDetail'*)
(*$HPPEMIT '#undef SetupDiInstallInterfaceDevices'*)
(*$HPPEMIT '#undef SetupDiEnumDriverInfo'*)
(*$HPPEMIT '#undef SetupDiGetSelectedDriver'*)
(*$HPPEMIT '#undef SetupDiSetSelectedDriver'*)
(*$HPPEMIT '#undef SetupDiGetDriverInfoDetail'*)
(*$HPPEMIT '#undef SetupDiGetClassDevs'*)
(*$HPPEMIT '#undef SetupDiGetClassDevsEx'*)
(*$HPPEMIT '#undef SetupDiGetINFClass'*)
(*$HPPEMIT '#undef SetupDiBuildClassInfoListEx'*)
(*$HPPEMIT '#undef SetupDiGetClassDescription'*)
(*$HPPEMIT '#undef SetupDiGetClassDescriptionEx'*)
(*$HPPEMIT '#undef SetupDiInstallClass'*)
(*$HPPEMIT '#undef SetupDiInstallClassEx'*)
(*$HPPEMIT '#undef SetupDiOpenClassRegKeyEx'*)
(*$HPPEMIT '#undef SetupDiCreateDeviceInterfaceRegKey'*)
(*$HPPEMIT '#undef SetupDiCreateInterfaceDeviceRegKeyA'*)
(*$HPPEMIT '#undef SetupDiCreateInterfaceDeviceRegKeyW'*)
(*$HPPEMIT '#undef SetupDiCreateInterfaceDeviceRegKey'*)
(*$HPPEMIT '#undef SetupDiOpenInterfaceDeviceRegKey'*)
(*$HPPEMIT '#undef SetupDiDeleteInterfaceDeviceRegKey'*)
(*$HPPEMIT '#undef SetupDiCreateDevRegKey'*)
(*$HPPEMIT '#undef SetupDiGetHwProfileListEx'*)
(*$HPPEMIT '#undef SetupDiGetDeviceRegistryProperty'*)
(*$HPPEMIT '#undef SetupDiGetClassRegistryProperty'*)
(*$HPPEMIT '#undef SetupDiSetDeviceRegistryProperty'*)
(*$HPPEMIT '#undef SetupDiSetClassRegistryProperty'*)
(*$HPPEMIT '#undef SetupDiGetDeviceInstallParams'*)
(*$HPPEMIT '#undef SetupDiGetClassInstallParams'*)
(*$HPPEMIT '#undef SetupDiSetDeviceInstallParams'*)
(*$HPPEMIT '#undef SetupDiSetClassInstallParams'*)
(*$HPPEMIT '#undef SetupDiGetDriverInstallParams'*)
(*$HPPEMIT '#undef SetupDiSetDriverInstallParams'*)
(*$HPPEMIT '#undef SetupDiGetClassImageListEx'*)
(*$HPPEMIT '#undef SetupDiGetClassDevPropertySheets'*)
(*$HPPEMIT '#undef SetupDiClassNameFromGuid'*)
(*$HPPEMIT '#undef SetupDiClassNameFromGuidEx'*)
(*$HPPEMIT '#undef SetupDiClassGuidsFromName'*)
(*$HPPEMIT '#undef SetupDiClassGuidsFromNameEx'*)
(*$HPPEMIT '#undef SetupDiGetHwProfileFriendlyName'*)
(*$HPPEMIT '#undef SetupDiGetHwProfileFriendlyNameEx'*)
(*$HPPEMIT '#undef SetupDiGetActualSectionToInstall'*)
{$IFDEF WINXP_UP}
(*$HPPEMIT '#undef SetupDiGetActualSectionToInstallEx'*)
(*$HPPEMIT '#undef SetupEnumInfSections'*)
(*$HPPEMIT '#undef SetupVerifyInfFile'*)
(*$HPPEMIT '#undef SetupDiGetCustomDeviceProperty'*)
{$ENDIF WINXP_UP}

type
  {$IFDEF WINXP_UP}
  TSetupGetFileQueueCount = function(FileQueue: HSPFILEQ; SubQueueFileOp: UINT; var NumOperations: UINT): BOOL; stdcall;
  TSetupGetFileQueueFlags = function(FileQueue: HSPFILEQ; var Flags: DWORD): BOOL; stdcall;
  TSetupSetFileQueueFlags = function(FileQueue: HSPFILEQ; FlagMask: DWORD; Flags: DWORD): BOOL; stdcall;
  {$ENDIF WINXP_UP}
  TSetupGetInfInformationA = function(InfSpec: Pointer; SearchControl: DWORD;
    ReturnBuffer: PSPInfInformation; ReturnBufferSize: DWORD; RequiredSize: PDWORD): BOOL; stdcall;
  TSetupGetInfInformationW = function(InfSpec: Pointer; SearchControl: DWORD;
    ReturnBuffer: PSPInfInformation; ReturnBufferSize: DWORD; RequiredSize: PDWORD): BOOL; stdcall;
  {$IFDEF UNICODE}
  TSetupGetInfInformation = TSetupGetInfInformationW;
  {$ELSE}
  TSetupGetInfInformation = TSetupGetInfInformationA;
  {$ENDIF UNICODE}

  TSetupQueryInfFileInformationA = function(var InfInformation: TSPInfInformation;
    InfIndex: UINT; ReturnBuffer: PAnsiChar; ReturnBufferSize: DWORD;
    RequiredSize: PDWORD): BOOL; stdcall;
  TSetupQueryInfFileInformationW = function(var InfInformation: TSPInfInformation;
    InfIndex: UINT; ReturnBuffer: PWideChar; ReturnBufferSize: DWORD;
    RequiredSize: PDWORD): BOOL; stdcall;
  TSetupQueryInfFileInformation = function(var InfInformation: TSPInfInformation;
    InfIndex: UINT; ReturnBuffer: PTSTR; ReturnBufferSize: DWORD;
    RequiredSize: PDWORD): BOOL; stdcall;

  {$IFDEF WIN2000_UP}
  TSetupQueryInfOriginalFileInformationA = function(var InfInformation: TSPInfInformation;
    InfIndex: UINT; AlternatePlatformInfo: PSPAltPlatformInfo;
    var OriginalFileInfo: TSPOriginalFileInfoA): BOOL; stdcall;
  TSetupQueryInfOriginalFileInformationW = function(var InfInformation: TSPInfInformation;
    InfIndex: UINT; AlternatePlatformInfo: PSPAltPlatformInfo;
    var OriginalFileInfo: TSPOriginalFileInfoW): BOOL; stdcall;
  TSetupQueryInfOriginalFileInformation = function(var InfInformation: TSPInfInformation;
    InfIndex: UINT; AlternatePlatformInfo: PSPAltPlatformInfo;
    var OriginalFileInfo: TSPOriginalFileInfo): BOOL; stdcall;
  {$ENDIF WIN2000_UP}

  TSetupQueryInfVersionInformationA = function(var InfInformation: TSPInfInformation;
    InfIndex: UINT; const Key, ReturnBuffer: PAnsiChar; ReturnBufferSize: DWORD;
    RequiredSize: PDWORD): BOOL; stdcall;
  TSetupQueryInfVersionInformationW = function(var InfInformation: TSPInfInformation;
    InfIndex: UINT; const Key, ReturnBuffer: PWideChar; ReturnBufferSize: DWORD;
    RequiredSize: PDWORD): BOOL; stdcall;
  TSetupQueryInfVersionInformation = function(var InfInformation: TSPInfInformation;
    InfIndex: UINT; const Key, ReturnBuffer: PTSTR; ReturnBufferSize: DWORD;
    RequiredSize: PDWORD): BOOL; stdcall;

  TSetupGetInfFileListA = function(const DirectoryPath: PAnsiChar; InfStyle: DWORD;
    ReturnBuffer: PAnsiChar; ReturnBufferSize: DWORD; RequiredSize: PDWORD): BOOL; stdcall;
  TSetupGetInfFileListW = function(const DirectoryPath: PWideChar; InfStyle: DWORD;
    ReturnBuffer: PWideChar; ReturnBufferSize: DWORD; RequiredSize: PDWORD): BOOL; stdcall;
  TSetupGetInfFileList = function(const DirectoryPath: PTSTR; InfStyle: DWORD;
    ReturnBuffer: PTSTR; ReturnBufferSize: DWORD; RequiredSize: PDWORD): BOOL; stdcall;

  TSetupOpenInfFileA = function(const FileName: PAnsiChar; const InfClass: PAnsiChar;
    InfStyle: DWORD; ErrorLine: PUINT): HINF; stdcall;
  TSetupOpenInfFileW = function(const FileName: PWideChar; const InfClass: PWideChar;
    InfStyle: DWORD; ErrorLine: PUINT): HINF; stdcall;
  TSetupOpenInfFile = function(const FileName: PTSTR; const InfClass: PTSTR;
    InfStyle: DWORD; ErrorLine: PUINT): HINF; stdcall;

  TSetupOpenMasterInf = function: HINF; stdcall;

  TSetupOpenAppendInfFileA = function(const FileName: PAnsiChar; InfHandle: HINF;
    ErrorLine: PUINT): BOOL; stdcall;
  TSetupOpenAppendInfFileW = function(const FileName: PWideChar; InfHandle: HINF;
    ErrorLine: PUINT): BOOL; stdcall;
  TSetupOpenAppendInfFile = function(const FileName: PTSTR; InfHandle: HINF;
    ErrorLine: PUINT): BOOL; stdcall;

  TSetupCloseInfFile = procedure(InfHandle: HINF); stdcall;

  TSetupFindFirstLineA = function(InfHandle: HINF; Section, Key: PAnsiChar;
    var Context: TInfContext): BOOL; stdcall;
  TSetupFindFirstLineW = function(InfHandle: HINF; Section, Key: PWideChar;
    var Context: TInfContext): BOOL; stdcall;
  TSetupFindFirstLine = function(InfHandle: HINF; Section, Key: PTSTR;
    var Context: TInfContext): BOOL; stdcall;

  TSetupFindNextLine = function(var ContextIn, ContextOut: TInfContext): BOOL; stdcall;

  TSetupFindNextMatchLineA = function(var ContextIn: TInfContext; Key: PAnsiChar;
    var ContextOut: TInfContext): BOOL; stdcall;
  TSetupFindNextMatchLineW = function(var ContextIn: TInfContext; Key: PWideChar;
    var ContextOut: TInfContext): BOOL; stdcall;
  TSetupFindNextMatchLine = function(var ContextIn: TInfContext; Key: PTSTR;
    var ContextOut: TInfContext): BOOL; stdcall;

  TSetupGetLineByIndexA = function(InfHandle: HINF; Section: PAnsiChar; Index: DWORD;
    var Context: TInfContext): BOOL; stdcall;
  TSetupGetLineByIndexW = function(InfHandle: HINF; Section: PWideChar; Index: DWORD;
    var Context: TInfContext): BOOL; stdcall;
  TSetupGetLineByIndex = function(InfHandle: HINF; Section: PTSTR; Index: DWORD;
    var Context: TInfContext): BOOL; stdcall;

  TSetupGetLineCountA = function(InfHandle: HINF; Section: PAnsiChar): Integer; stdcall;
  TSetupGetLineCountW = function(InfHandle: HINF; Section: PWideChar): Integer; stdcall;
  TSetupGetLineCount = function(InfHandle: HINF; Section: PTSTR): Integer; stdcall;

  TSetupGetLineTextA = function(Context: PInfContext; InfHandle: HINF; Section,
    Key, ReturnBuffer: PAnsiChar; ReturnBufferSize: DWORD; RequiredSize: PDWORD): BOOL; stdcall;
  TSetupGetLineTextW = function(Context: PInfContext; InfHandle: HINF; Section,
    Key, ReturnBuffer: PWideChar; ReturnBufferSize: DWORD; RequiredSize: PDWORD): BOOL; stdcall;
  TSetupGetLineText = function(Context: PInfContext; InfHandle: HINF; Section,
    Key, ReturnBuffer: PTSTR; ReturnBufferSize: DWORD; RequiredSize: PDWORD): BOOL; stdcall;

  TSetupGetFieldCount = function(var Context: TInfContext): DWORD; stdcall;

  TSetupGetStringFieldA = function(var Context: TInfContext; FieldIndex: DWORD;
    ReturnBuffer: PAnsiChar; ReturnBufferSize: DWORD; RequiredSize: PDWORD): BOOL; stdcall;
  TSetupGetStringFieldW = function(var Context: TInfContext; FieldIndex: DWORD;
    ReturnBuffer: PWideChar; ReturnBufferSize: DWORD; RequiredSize: PDWORD): BOOL; stdcall;
  TSetupGetStringField = function(var Context: TInfContext; FieldIndex: DWORD;
    ReturnBuffer: PTSTR; ReturnBufferSize: DWORD; RequiredSize: PDWORD): BOOL; stdcall;

  TSetupGetIntField = function(var Context: TInfContext; FieldIndex: DWORD;
    var IntegerValue: Integer): BOOL; stdcall;

  TSetupGetMultiSzFieldA = function(var Context: TInfContext; FieldIndex: DWORD;
    ReturnBuffer: PAnsiChar; ReturnBufferSize: DWORD; RequiredSize: PDWORD): BOOL; stdcall;
  TSetupGetMultiSzFieldW = function(var Context: TInfContext; FieldIndex: DWORD;
    ReturnBuffer: PWideChar; ReturnBufferSize: DWORD; RequiredSize: PDWORD): BOOL; stdcall;
  TSetupGetMultiSzField = function(var Context: TInfContext; FieldIndex: DWORD;
    ReturnBuffer: PTSTR; ReturnBufferSize: DWORD; RequiredSize: PDWORD): BOOL; stdcall;

  TSetupGetBinaryField = function(var Context: TInfContext; FieldIndex: DWORD;
    ReturnBuffer: PBYTE; ReturnBufferSize: DWORD; RequiredSize: PDWORD): BOOL; stdcall;

  TSetupGetFileCompressionInfoA = function(const SourceFileName: PAnsiChar;
    var ActualSourceFileName: PAnsiChar; var SourceFileSize: DWORD;
    var TargetFileSize: DWORD; var CompressionType: UINT): DWORD; stdcall;
  TSetupGetFileCompressionInfoW = function(const SourceFileName: PWideChar;
    var ActualSourceFileName: PWideChar; var SourceFileSize: DWORD;
    var TargetFileSize: DWORD; var CompressionType: UINT): DWORD; stdcall;
  TSetupGetFileCompressionInfo = function(const SourceFileName: PTSTR;
    var ActualSourceFileName: PTSTR; var SourceFileSize: DWORD;
    var TargetFileSize: DWORD; var CompressionType: UINT): DWORD; stdcall;

  {$IFDEF WINXP_UP}
  TSetupGetFileCompressionInfoExA = function(const SourceFileName: PAnsiChar;
    ActualSourceFileNameBuffer: PAnsiChar; var ActualSourceFileNameBufferLen: DWORD;
    RequiredBufferLen: PDWORD; var SourceFileSize: DWORD;
    var TargetFileSize: DWORD; var CompressionType: UINT): BOOL; stdcall;
  TSetupGetFileCompressionInfoExW = function(const SourceFileName: PWideChar;
    ActualSourceFileNameBuffer: PWideChar; var ActualSourceFileNameBufferLen: DWORD;
    RequiredBufferLen: PDWORD; var SourceFileSize: DWORD;
    var TargetFileSize: DWORD; var CompressionType: UINT): BOOL; stdcall;
  TSetupGetFileCompressionInfoEx = function(const SourceFileName: PTSTR;
    ActualSourceFileNameBuffer: PTSTR; var ActualSourceFileNameBufferLen: DWORD;
    RequiredBufferLen: PDWORD; var SourceFileSize: DWORD;
    var TargetFileSize: DWORD; var CompressionType: UINT): BOOL; stdcall;
  {$ENDIF WINXP_UP}

  TSetupDecompressOrCopyFileA = function(const SourceFileName, TargetFileName: PAnsiChar;
    var CompressionType: UINT): DWORD; stdcall;
  TSetupDecompressOrCopyFileW = function(const SourceFileName, TargetFileName: PWideChar;
    var CompressionType: UINT): DWORD; stdcall;
  TSetupDecompressOrCopyFile = function(const SourceFileName, TargetFileName: PTSTR;
    var CompressionType: UINT): DWORD; stdcall;

  TSetupGetSourceFileLocationA = function(InfHandle: HINF; InfContext: PInfContext;
    const FileName: PAnsiChar; var SourceId: UINT; ReturnBuffer: PAnsiChar;
    ReturnBufferSize: DWORD; RequiredSize: PDWORD): BOOL; stdcall;
  TSetupGetSourceFileLocationW = function(InfHandle: HINF; InfContext: PInfContext;
    const FileName: PWideChar; var SourceId: UINT; ReturnBuffer: PWideChar;
    ReturnBufferSize: DWORD; RequiredSize: PDWORD): BOOL; stdcall;
  TSetupGetSourceFileLocation = function(InfHandle: HINF; InfContext: PInfContext;
    const FileName: PTSTR; var SourceId: UINT; ReturnBuffer: PTSTR;
    ReturnBufferSize: DWORD; RequiredSize: PDWORD): BOOL; stdcall;

  TSetupGetSourceFileSizeA = function(InfHandle: HINF; InfContext: PInfContext;
    const FileName: PAnsiChar; const Section: PAnsiChar; var FileSize: DWORD;
    RoundingFactor: UINT): BOOL; stdcall;
  TSetupGetSourceFileSizeW = function(InfHandle: HINF; InfContext: PInfContext;
    const FileName: PWideChar; const Section: PWideChar; var FileSize: DWORD;
    RoundingFactor: UINT): BOOL; stdcall;
  TSetupGetSourceFileSize = function(InfHandle: HINF; InfContext: PInfContext;
    const FileName: PTSTR; const Section: PTSTR; var FileSize: DWORD;
    RoundingFactor: UINT): BOOL; stdcall;

  TSetupGetTargetPathA = function(InfHandle: HINF; InfContext: PInfContext;
    const Section: PAnsiChar; ReturnBuffer: PAnsiChar; ReturnBufferSize: DWORD;
    RequiredSize: PDWORD): BOOL; stdcall;
  TSetupGetTargetPathW = function(InfHandle: HINF; InfContext: PInfContext;
    const Section: PWideChar; ReturnBuffer: PWideChar; ReturnBufferSize: DWORD;
    RequiredSize: PDWORD): BOOL; stdcall;
  TSetupGetTargetPath = function(InfHandle: HINF; InfContext: PInfContext;
    const Section: PTSTR; ReturnBuffer: PTSTR; ReturnBufferSize: DWORD;
    RequiredSize: PDWORD): BOOL; stdcall;

  TSetupSetSourceListA = function(Flags: DWORD; SourceList: PPASTR;
    SourceCount: UINT): BOOL; stdcall;
  TSetupSetSourceListW = function(Flags: DWORD; SourceList: PPWSTR;
    SourceCount: UINT): BOOL; stdcall;
  TSetupSetSourceList = function(Flags: DWORD; SourceList: PPSTR;
    SourceCount: UINT): BOOL; stdcall;

  TSetupCancelTemporarySourceList = function: BOOL; stdcall;

  TSetupAddToSourceListA = function(Flags: DWORD; const Source: PAnsiChar): BOOL; stdcall;
  TSetupAddToSourceListW = function(Flags: DWORD; const Source: PWideChar): BOOL; stdcall;
  TSetupAddToSourceList = function(Flags: DWORD; const Source: PTSTR): BOOL; stdcall;

  TSetupRemoveFromSourceListA = function(Flags: DWORD; const Source: PAnsiChar): BOOL; stdcall;
  TSetupRemoveFromSourceListW = function(Flags: DWORD; const Source: PWideChar): BOOL; stdcall;
  TSetupRemoveFromSourceList = function(Flags: DWORD; const Source: PTSTR): BOOL; stdcall;

  TSetupQuerySourceListA = function(Flags: DWORD; var List: PPASTR;
    var Count: UINT): BOOL; stdcall;
  TSetupQuerySourceListW = function(Flags: DWORD; var List: PPWSTR;
    var Count: UINT): BOOL; stdcall;
  TSetupQuerySourceList = function(Flags: DWORD; var List: PPSTR;
    var Count: UINT): BOOL; stdcall;

  TSetupFreeSourceListA = function(var List: PPASTR; Count: UINT): BOOL; stdcall;
  TSetupFreeSourceListW = function(var List: PPWSTR; Count: UINT): BOOL; stdcall;
  TSetupFreeSourceList = function(var List: PPSTR; Count: UINT): BOOL; stdcall;

  TSetupPromptForDiskA = function(hwndParent: HWND; const DialogTitle, DiskName,
    PathToSource, FileSought, TagFile: PAnsiChar; DiskPromptStyle: DWORD;
    PathBuffer: PAnsiChar; PathBufferSize: DWORD; var PathRequiredSize: DWORD): UINT; stdcall;
  TSetupPromptForDiskW = function(hwndParent: HWND; const DialogTitle, DiskName,
    PathToSource, FileSought, TagFile: PWideChar; DiskPromptStyle: DWORD;
    PathBuffer: PWideChar; PathBufferSize: DWORD; var PathRequiredSize: DWORD): UINT; stdcall;
  TSetupPromptForDisk = function(hwndParent: HWND; const DialogTitle, DiskName,
    PathToSource, FileSought, TagFile: PTSTR; DiskPromptStyle: DWORD;
    PathBuffer: PTSTR; PathBufferSize: DWORD; var PathRequiredSize: DWORD): UINT; stdcall;

  TSetupCopyErrorA = function(hwndParent: HWND; const DialogTitle, DiskName,
    PathToSource, SourceFile, TargetPathFile: PAnsiChar; Win32ErrorCode: UINT; Style: DWORD;
    PathBuffer: PAnsiChar; PathBufferSize: DWORD; PathRequiredSize: PDWORD): UINT; stdcall;
  TSetupCopyErrorW = function(hwndParent: HWND; const DialogTitle, DiskName,
    PathToSource, SourceFile, TargetPathFile: PWideChar; Win32ErrorCode: UINT; Style: DWORD;
    PathBuffer: PWideChar; PathBufferSize: DWORD; PathRequiredSize: PDWORD): UINT; stdcall;
  TSetupCopyError = function(hwndParent: HWND; const DialogTitle, DiskName,
    PathToSource, SourceFile, TargetPathFile: PTSTR; Win32ErrorCode: UINT; Style: DWORD;
    PathBuffer: PTSTR; PathBufferSize: DWORD; PathRequiredSize: PDWORD): UINT; stdcall;

  TSetupRenameErrorA = function(hwndParent: HWND; const DialogTitle, SourceFile,
    TargetFile: PAnsiChar; Win32ErrorCode: UINT; Style: DWORD): UINT; stdcall;
  TSetupRenameErrorW = function(hwndParent: HWND; const DialogTitle, SourceFile,
    TargetFile: PWideChar; Win32ErrorCode: UINT; Style: DWORD): UINT; stdcall;
  TSetupRenameError = function(hwndParent: HWND; const DialogTitle, SourceFile,
    TargetFile: PTSTR; Win32ErrorCode: UINT; Style: DWORD): UINT; stdcall;

  TSetupDeleteErrorA = function(hwndParent: HWND; const DialogTitle, File_: PAnsiChar;
    Win32ErrorCode: UINT; Style: DWORD): UINT; stdcall;
  TSetupDeleteErrorW = function(hwndParent: HWND; const DialogTitle, File_: PWideChar;
    Win32ErrorCode: UINT; Style: DWORD): UINT; stdcall;
  TSetupDeleteError = function(hwndParent: HWND; const DialogTitle, File_: PTSTR;
    Win32ErrorCode: UINT; Style: DWORD): UINT; stdcall;

  {$IFDEF WIN2000_UP}
  TSetupBackupErrorA = function(hwndParent: HWND; const DialogTitle, BackupFile,
    TargetFile: PAnsiChar; Win32ErrorCode: UINT; Style: DWORD): UINT; stdcall;
  TSetupBackupErrorW = function(hwndParent: HWND; const DialogTitle, BackupFile,
    TargetFile: PWideChar; Win32ErrorCode: UINT; Style: DWORD): UINT; stdcall;
  TSetupBackupError = function(hwndParent: HWND; const DialogTitle, BackupFile,
    TargetFile: PTSTR; Win32ErrorCode: UINT; Style: DWORD): UINT; stdcall;
  {$ENDIF WIN2000_UP}

  TSetupSetDirectoryIdA = function(InfHandle: HINF; Id: DWORD; const Directory: PAnsiChar): BOOL; stdcall;
  TSetupSetDirectoryIdW = function(InfHandle: HINF; Id: DWORD; const Directory: PWideChar): BOOL; stdcall;
  TSetupSetDirectoryId = function(InfHandle: HINF; Id: DWORD; const Directory: PTSTR): BOOL; stdcall;

  TSetupSetDirectoryIdExA = function(InfHandle: HINF; Id: DWORD; const Directory: PAnsiChar;
    Flags: DWORD; Reserved1: DWORD; Reserved2: Pointer): BOOL; stdcall;
  TSetupSetDirectoryIdExW = function(InfHandle: HINF; Id: DWORD; const Directory: PWideChar;
    Flags: DWORD; Reserved1: DWORD; Reserved2: Pointer): BOOL; stdcall;
  TSetupSetDirectoryIdEx = function(InfHandle: HINF; Id: DWORD; const Directory: PTSTR;
    Flags: DWORD; Reserved1: DWORD; Reserved2: Pointer): BOOL; stdcall;

  TSetupGetSourceInfoA = function(InfHandle: HINF; SourceId, InfoDesired: UINT;
    ReturnBuffer: PAnsiChar; ReturnBufferSize: DWORD; RequiredSize: PDWORD): BOOL; stdcall;
  TSetupGetSourceInfoW = function(InfHandle: HINF; SourceId, InfoDesired: UINT;
    ReturnBuffer: PWideChar; ReturnBufferSize: DWORD; RequiredSize: PDWORD): BOOL; stdcall;
  TSetupGetSourceInfo = function(InfHandle: HINF; SourceId, InfoDesired: UINT;
    ReturnBuffer: PTSTR; ReturnBufferSize: DWORD; RequiredSize: PDWORD): BOOL; stdcall;

  TSetupInstallFileA = function(InfHandle: HINF; InfContext: PInfContext;
    const SourceFile, SourcePathRoot, DestinationName: PAnsiChar; CopyStyle: DWORD;
    CopyMsgHandler: TSPFileCallbackA; Context: Pointer): BOOL; stdcall;
  TSetupInstallFileW = function(InfHandle: HINF; InfContext: PInfContext;
    const SourceFile, SourcePathRoot, DestinationName: PWideChar; CopyStyle: DWORD;
    CopyMsgHandler: TSPFileCallbackW; Context: Pointer): BOOL; stdcall;
  TSetupInstallFile = function(InfHandle: HINF; InfContext: PInfContext;
    const SourceFile, SourcePathRoot, DestinationName: PTSTR; CopyStyle: DWORD;
    CopyMsgHandler: TSPFileCallback; Context: Pointer): BOOL; stdcall;

  TSetupInstallFileExA = function(InfHandle: HINF; InfContext: PInfContext;
    const SourceFile, SourcePathRoot, DestinationName: PAnsiChar; CopyStyle: DWORD;
    CopyMsgHandler: TSPFileCallbackA; Context: Pointer; var FileWasInUse: BOOL): BOOL; stdcall;
  TSetupInstallFileExW = function(InfHandle: HINF; InfContext: PInfContext;
    const SourceFile, SourcePathRoot, DestinationName: PWideChar; CopyStyle: DWORD;
    CopyMsgHandler: TSPFileCallbackW; Context: Pointer; var FileWasInUse: BOOL): BOOL; stdcall;
  TSetupInstallFileEx = function(InfHandle: HINF; InfContext: PInfContext;
    const SourceFile, SourcePathRoot, DestinationName: PTSTR; CopyStyle: DWORD;
    CopyMsgHandler: TSPFileCallback; Context: Pointer; var FileWasInUse: BOOL): BOOL; stdcall;

  TSetupOpenFileQueue = function: HSPFILEQ; stdcall;

  TSetupCloseFileQueue = function(QueueHandle: HSPFILEQ): BOOL; stdcall;

  {$IFDEF WIN2000_UP}
  TSetupSetFileQueueAlternatePlatformA = function(QueueHandle: HSPFILEQ;
    AlternatePlatformInfo: PSPAltPlatformInfo;
    const AlternateDefaultCatalogFile: PAnsiChar): BOOL; stdcall;
  TSetupSetFileQueueAlternatePlatformW = function(QueueHandle: HSPFILEQ;
    AlternatePlatformInfo: PSPAltPlatformInfo;
    const AlternateDefaultCatalogFile: PWideChar): BOOL; stdcall;
  TSetupSetFileQueueAlternatePlatform = function(QueueHandle: HSPFILEQ;
    AlternatePlatformInfo: PSPAltPlatformInfo;
    const AlternateDefaultCatalogFile: PTSTR): BOOL; stdcall;
  {$ENDIF WIN2000_UP}

  TSetupSetPlatformPathOverrideA = function(const Override_: PAnsiChar): BOOL; stdcall;
  TSetupSetPlatformPathOverrideW = function(const Override_: PWideChar): BOOL; stdcall;
  TSetupSetPlatformPathOverride = function(const Override_: PTSTR): BOOL; stdcall;

  TSetupQueueCopyA = function(QueueHandle: HSPFILEQ; const SourceRootPath, SourcePath,
    SourceFilename, SourceDescription, SourceTagfile, TargetDirectory,
    TargetFilename: PAnsiChar; CopyStyle: DWORD): BOOL; stdcall;
  TSetupQueueCopyW = function(QueueHandle: HSPFILEQ; const SourceRootPath, SourcePath,
    SourceFilename, SourceDescription, SourceTagfile, TargetDirectory,
    TargetFilename: PWideChar; CopyStyle: DWORD): BOOL; stdcall;
  TSetupQueueCopy = function(QueueHandle: HSPFILEQ; const SourceRootPath, SourcePath,
    SourceFilename, SourceDescription, SourceTagfile, TargetDirectory,
    TargetFilename: PTSTR; CopyStyle: DWORD): BOOL; stdcall;

  {$IFDEF WIN2000_UP}
  TSetupQueueCopyIndirectA = function(var CopyParams: TSPFileCopyParamsA): BOOL; stdcall;
  TSetupQueueCopyIndirectW = function(var CopyParams: TSPFileCopyParamsW): BOOL; stdcall;
  TSetupQueueCopyIndirect = function(var CopyParams: TSPFileCopyParams): BOOL; stdcall;
  {$ENDIF WIN2000_UP}

  TSetupQueueDefaultCopyA = function(QueueHandle: HSPFILEQ; InfHandle: HINF;
    const SourceRootPath, SourceFilename, TargetFilename: PAnsiChar;
    CopyStyle: DWORD): BOOL; stdcall;
  TSetupQueueDefaultCopyW = function(QueueHandle: HSPFILEQ; InfHandle: HINF;
    const SourceRootPath, SourceFilename, TargetFilename: PWideChar;
    CopyStyle: DWORD): BOOL; stdcall;
  TSetupQueueDefaultCopy = function(QueueHandle: HSPFILEQ; InfHandle: HINF;
    const SourceRootPath, SourceFilename, TargetFilename: PTSTR;
    CopyStyle: DWORD): BOOL; stdcall;

  TSetupQueueCopySectionA = function(QueueHandle: HSPFILEQ; const SourceRootPath: PAnsiChar;
    InfHandle: HINF; ListInfHandle: HINF; const Section: PAnsiChar; CopyStyle: DWORD): BOOL; stdcall;
  TSetupQueueCopySectionW = function(QueueHandle: HSPFILEQ; const SourceRootPath: PWideChar;
    InfHandle: HINF; ListInfHandle: HINF; const Section: PWideChar; CopyStyle: DWORD): BOOL; stdcall;
  TSetupQueueCopySection = function(QueueHandle: HSPFILEQ; const SourceRootPath: PTSTR;
    InfHandle: HINF; ListInfHandle: HINF; const Section: PTSTR; CopyStyle: DWORD): BOOL; stdcall;

  TSetupQueueDeleteA = function(QueueHandle: HSPFILEQ; const PathPart1, PathPart2: PAnsiChar): BOOL; stdcall;
  TSetupQueueDeleteW = function(QueueHandle: HSPFILEQ; const PathPart1, PathPart2: PWideChar): BOOL; stdcall;
  TSetupQueueDelete = function(QueueHandle: HSPFILEQ; const PathPart1, PathPart2: PTSTR): BOOL; stdcall;

  TSetupQueueDeleteSectionA = function(QueueHandle: HSPFILEQ; InfHandle: HINF;
    ListInfHandle: HINF; const Section: PAnsiChar): BOOL; stdcall;
  TSetupQueueDeleteSectionW = function(QueueHandle: HSPFILEQ; InfHandle: HINF;
    ListInfHandle: HINF; const Section: PWideChar): BOOL; stdcall;
  TSetupQueueDeleteSection = function(QueueHandle: HSPFILEQ; InfHandle: HINF;
    ListInfHandle: HINF; const Section: PTSTR): BOOL; stdcall;

  TSetupQueueRenameA = function(QueueHandle: HSPFILEQ; const SourcePath,
    SourceFilename, TargetPath, TargetFilename: PAnsiChar): BOOL; stdcall;
  TSetupQueueRenameW = function(QueueHandle: HSPFILEQ; const SourcePath,
    SourceFilename, TargetPath, TargetFilename: PWideChar): BOOL; stdcall;
  TSetupQueueRename = function(QueueHandle: HSPFILEQ; const SourcePath,
    SourceFilename, TargetPath, TargetFilename: PTSTR): BOOL; stdcall;

  TSetupQueueRenameSectionA = function(QueueHandle: HSPFILEQ; InfHandle: HINF;
    ListInfHandle: HINF; const Section: PAnsiChar): BOOL; stdcall;
  TSetupQueueRenameSectionW = function(QueueHandle: HSPFILEQ; InfHandle: HINF;
    ListInfHandle: HINF; const Section: PWideChar): BOOL; stdcall;
  TSetupQueueRenameSection = function(QueueHandle: HSPFILEQ; InfHandle: HINF;
    ListInfHandle: HINF; const Section: PTSTR): BOOL; stdcall;

  TSetupCommitFileQueueA = function(Owner: HWND; QueueHandle: HSPFILEQ;
    MsgHandler: TSPFileCallbackA; Context: Pointer): BOOL; stdcall;
  TSetupCommitFileQueueW = function(Owner: HWND; QueueHandle: HSPFILEQ;
    MsgHandler: TSPFileCallbackW; Context: Pointer): BOOL; stdcall;
  TSetupCommitFileQueue = function(Owner: HWND; QueueHandle: HSPFILEQ;
    MsgHandler: TSPFileCallback; Context: Pointer): BOOL; stdcall;

  TSetupScanFileQueueA = function(FileQueue: HSPFILEQ; Flags: DWORD; Window: HWND;
    CallbackRoutine: TSPFileCallbackA; CallbackContext: Pointer; var Result: DWORD): BOOL; stdcall;
  TSetupScanFileQueueW = function(FileQueue: HSPFILEQ; Flags: DWORD; Window: HWND;
    CallbackRoutine: TSPFileCallbackW; CallbackContext: Pointer; var Result: DWORD): BOOL; stdcall;
  TSetupScanFileQueue = function(FileQueue: HSPFILEQ; Flags: DWORD; Window: HWND;
    CallbackRoutine: TSPFileCallback; CallbackContext: Pointer; var Result: DWORD): BOOL; stdcall;

  TSetupCopyOEMInfA = function(const SourceInfFileName, OEMSourceMediaLocation: PAnsiChar;
    OEMSourceMediaType, CopyStyle: DWORD; DestinationInfFileName: PAnsiChar;
    DestinationInfFileNameSize: DWORD; RequiredSize: PDWORD;
    DestinationInfFileNameComponent: PPASTR): BOOL; stdcall;
  TSetupCopyOEMInfW = function(const SourceInfFileName, OEMSourceMediaLocation: PWideChar;
    OEMSourceMediaType, CopyStyle: DWORD; DestinationInfFileName: PWideChar;
    DestinationInfFileNameSize: DWORD; RequiredSize: PDWORD;
    DestinationInfFileNameComponent: PPWSTR): BOOL; stdcall;
  TSetupCopyOEMInf = function(const SourceInfFileName, OEMSourceMediaLocation: PTSTR;
    OEMSourceMediaType, CopyStyle: DWORD; DestinationInfFileName: PTSTR;
    DestinationInfFileNameSize: DWORD; RequiredSize: PDWORD;
    DestinationInfFileNameComponent: PPSTR): BOOL; stdcall;

  {$IFDEF WINXP_UP}
  TSetupUninstallOEMInfA = function(const InfFileName: PAnsiChar; Flags: DWORD; Reserved: Pointer): BOOL; stdcall;
  TSetupUninstallOEMInfW = function(const InfFileName: PWideChar; Flags: DWORD; Reserved: Pointer): BOOL; stdcall;
  TSetupUninstallOEMInf = function(const InfFileName: PTSTR; Flags: DWORD; Reserved: Pointer): BOOL; stdcall;

  TSetupUninstallNewlyCopiedInfs = function(FileQueue: HSPFILEQ; Flags: DWORD; Reserved: Pointer): BOOL; stdcall;
  {$ENDIF WINXP_UP}

//
// Disk space list APIs
//
  TSetupCreateDiskSpaceListA = function(Reserved1: Pointer; Reserved2: DWORD;
    Flags: UINT): HDSKSPC; stdcall;
  TSetupCreateDiskSpaceListW = function(Reserved1: Pointer; Reserved2: DWORD;
    Flags: UINT): HDSKSPC; stdcall;
  {$IFDEF UNICODE}
  TSetupCreateDiskSpaceList = TSetupCreateDiskSpaceListW;
  {$ELSE}
  TSetupCreateDiskSpaceList = TSetupCreateDiskSpaceListA;
  {$ENDIF UNICODE}

  TSetupDuplicateDiskSpaceListA = function(DiskSpace: HDSKSPC; Reserved1: Pointer;
    Reserved2: DWORD; Flags: UINT): HDSKSPC; stdcall;
  TSetupDuplicateDiskSpaceListW = function(DiskSpace: HDSKSPC; Reserved1: Pointer;
    Reserved2: DWORD; Flags: UINT): HDSKSPC; stdcall;
  {$IFDEF UNICODE}
  TSetupDuplicateDiskSpaceList = TSetupDuplicateDiskSpaceListW;
  {$ELSE}
  TSetupDuplicateDiskSpaceList = TSetupDuplicateDiskSpaceListA;
  {$ENDIF UNICODE}

  TSetupDestroyDiskSpaceList = function(DiskSpace: HDSKSPC): BOOL; stdcall;

  TSetupQueryDrivesInDiskSpaceListA = function(DiskSpace: HDSKSPC; ReturnBuffer: PAnsiChar;
    ReturnBufferSize: DWORD; RequiredSize: PDWORD): BOOL; stdcall;
  TSetupQueryDrivesInDiskSpaceListW = function(DiskSpace: HDSKSPC; ReturnBuffer: PWideChar;
    ReturnBufferSize: DWORD; RequiredSize: PDWORD): BOOL; stdcall;
  TSetupQueryDrivesInDiskSpaceList = function(DiskSpace: HDSKSPC; ReturnBuffer: PTSTR;
    ReturnBufferSize: DWORD; RequiredSize: PDWORD): BOOL; stdcall;

  TSetupQuerySpaceRequiredOnDriveA = function(DiskSpace: HDSKSPC; const DriveSpec: PAnsiChar;
    var SpaceRequired: Int64; Reserved1: Pointer; Reserved2: UINT): BOOL; stdcall;
  TSetupQuerySpaceRequiredOnDriveW = function(DiskSpace: HDSKSPC; const DriveSpec: PWideChar;
    var SpaceRequired: Int64; Reserved1: Pointer; Reserved2: UINT): BOOL; stdcall;
  TSetupQuerySpaceRequiredOnDrive = function(DiskSpace: HDSKSPC; const DriveSpec: PTSTR;
    var SpaceRequired: Int64; Reserved1: Pointer; Reserved2: UINT): BOOL; stdcall;

  TSetupAdjustDiskSpaceListA = function(DiskSpace: HDSKSPC; const DriveRoot: PAnsiChar;
    Amount: Int64; Reserved1: Pointer; Reserved2: UINT): BOOL; stdcall;
  TSetupAdjustDiskSpaceListW = function(DiskSpace: HDSKSPC; const DriveRoot: PWideChar;
    Amount: Int64; Reserved1: Pointer; Reserved2: UINT): BOOL; stdcall;
  TSetupAdjustDiskSpaceList = function(DiskSpace: HDSKSPC; const DriveRoot: PTSTR;
    Amount: Int64; Reserved1: Pointer; Reserved2: UINT): BOOL; stdcall;

  TSetupAddToDiskSpaceListA = function(DiskSpace: HDSKSPC; const TargetFilespec: PAnsiChar;
    FileSize: Int64; Operation: UINT; Reserved1: Pointer; Reserved2: UINT): BOOL; stdcall;
  TSetupAddToDiskSpaceListW = function(DiskSpace: HDSKSPC; const TargetFilespec: PWideChar;
    FileSize: Int64; Operation: UINT; Reserved1: Pointer; Reserved2: UINT): BOOL; stdcall;
  TSetupAddToDiskSpaceList = function(DiskSpace: HDSKSPC; const TargetFilespec: PTSTR;
    FileSize: Int64; Operation: UINT; Reserved1: Pointer; Reserved2: UINT): BOOL; stdcall;

  TSetupAddSectionToDiskSpaceListA = function(DiskSpace: HDSKSPC; InfHandle: HINF;
    ListInfHandle: HINF; const SectionName: PAnsiChar; Operation: UINT;
    Reserved1: Pointer; Reserved2: UINT): BOOL; stdcall;
  TSetupAddSectionToDiskSpaceListW = function(DiskSpace: HDSKSPC; InfHandle: HINF;
    ListInfHandle: HINF; const SectionName: PWideChar; Operation: UINT;
    Reserved1: Pointer; Reserved2: UINT): BOOL; stdcall;
  TSetupAddSectionToDiskSpaceList = function(DiskSpace: HDSKSPC; InfHandle: HINF;
    ListInfHandle: HINF; const SectionName: PTSTR; Operation: UINT;
    Reserved1: Pointer; Reserved2: UINT): BOOL; stdcall;

  TSetupAddInstallSectionToDiskSpaceListA = function(DiskSpace: HDSKSPC;
    InfHandle: HINF; LayoutInfHandle: HINF; const SectionName: PAnsiChar;
    Reserved1: Pointer; Reserved2: UINT): BOOL; stdcall;
  TSetupAddInstallSectionToDiskSpaceListW = function(DiskSpace: HDSKSPC;
    InfHandle: HINF; LayoutInfHandle: HINF; const SectionName: PWideChar;
    Reserved1: Pointer; Reserved2: UINT): BOOL; stdcall;
  TSetupAddInstallSectionToDiskSpaceList = function(DiskSpace: HDSKSPC;
    InfHandle: HINF; LayoutInfHandle: HINF; const SectionName: PTSTR;
    Reserved1: Pointer; Reserved2: UINT): BOOL; stdcall;

  TSetupRemoveFromDiskSpaceListA = function(DiskSpace: HDSKSPC; const TargetFilespec: PAnsiChar;
    Operation: UINT; Reserved1: Pointer; Reserved2: UINT): BOOL; stdcall;
  TSetupRemoveFromDiskSpaceListW = function(DiskSpace: HDSKSPC; const TargetFilespec: PWideChar;
    Operation: UINT; Reserved1: Pointer; Reserved2: UINT): BOOL; stdcall;
  TSetupRemoveFromDiskSpaceList = function(DiskSpace: HDSKSPC; const TargetFilespec: PTSTR;
    Operation: UINT; Reserved1: Pointer; Reserved2: UINT): BOOL; stdcall;

  TSetupRemoveSectionFromDiskSpaceListA = function(DiskSpace: HDSKSPC; InfHandle: HINF;
    ListInfHandle: HINF; const SectionName: PAnsiChar; Operation: UINT; Reserved1: Pointer;
    Reserved2: UINT): BOOL; stdcall;
  TSetupRemoveSectionFromDiskSpaceListW = function(DiskSpace: HDSKSPC; InfHandle: HINF;
    ListInfHandle: HINF; const SectionName: PWideChar; Operation: UINT; Reserved1: Pointer;
    Reserved2: UINT): BOOL; stdcall;
  TSetupRemoveSectionFromDiskSpaceList = function(DiskSpace: HDSKSPC; InfHandle: HINF;
    ListInfHandle: HINF; const SectionName: PTSTR; Operation: UINT; Reserved1: Pointer;
    Reserved2: UINT): BOOL; stdcall;

  TSetupRemoveInstallSectionFromDiskSpaceListA = function(DiskSpace: HDSKSPC;
    InfHandle: HINF; LayoutInfHandle: HINF; const SectionName: PAnsiChar;
    Reserved1: Pointer; Reserved2: UINT): BOOL; stdcall;
  TSetupRemoveInstallSectionFromDiskSpaceListW = function(DiskSpace: HDSKSPC;
    InfHandle: HINF; LayoutInfHandle: HINF; const SectionName: PWideChar;
    Reserved1: Pointer; Reserved2: UINT): BOOL; stdcall;
  TSetupRemoveInstallSectionFromDiskSpaceList = function(DiskSpace: HDSKSPC;
    InfHandle: HINF; LayoutInfHandle: HINF; const SectionName: PTSTR;
    Reserved1: Pointer; Reserved2: UINT): BOOL; stdcall;

//
// Cabinet APIs
//

  TSetupIterateCabinetA = function(const CabinetFile: PAnsiChar; Reserved: DWORD;
    MsgHandler: TSPFileCallbackA; Context: Pointer): BOOL; stdcall;
  TSetupIterateCabinetW = function(const CabinetFile: PWideChar; Reserved: DWORD;
    MsgHandler: TSPFileCallbackW; Context: Pointer): BOOL; stdcall;
  TSetupIterateCabinet = function(const CabinetFile: PTSTR; Reserved: DWORD;
    MsgHandler: TSPFileCallback; Context: Pointer): BOOL; stdcall;

  TSetupPromptReboot = function(FileQueue: HSPFILEQ; Owner: HWND; ScanOnly: BOOL): Integer; stdcall;

  TSetupInitDefaultQueueCallback = function(OwnerWindow: HWND): Pointer; stdcall;

  TSetupInitDefaultQueueCallbackEx = function(OwnerWindow: HWND; AlternateProgressWindow: HWND;
    ProgressMessage: UINT; Reserved1: DWORD; Reserved2: Pointer): Pointer; stdcall;

  TSetupTermDefaultQueueCallback = procedure(Context: Pointer); stdcall;

  TSetupDefaultQueueCallbackA = function(Context: Pointer; Notification: UINT;
    Param1, Param2: UINT_PTR): UINT; stdcall;
  TSetupDefaultQueueCallbackW = function(Context: Pointer; Notification: UINT;
    Param1, Param2: UINT_PTR): UINT; stdcall;
  {$IFDEF UNICODE}
  TSetupDefaultQueueCallback = TSetupDefaultQueueCallbackW;
  {$ELSE}
  TSetupDefaultQueueCallback = TSetupDefaultQueueCallbackA;
  {$ENDIF UNICODE}

//
// The INF may supply any arbitrary data type ordinal in the highword except
// for the following: REG_NONE, REG_SZ, REG_EXPAND_SZ, REG_MULTI_SZ.  If this
// technique is used, then the data is given in binary format, one byte per
// field.
//

  TSetupInstallFromInfSectionA = function(Owner: HWND; InfHandle: HINF;
    const SectionName: PAnsiChar; Flags: UINT; RelativeKeyRoot: HKEY;
    const SourceRootPath: PAnsiChar; CopyFlags: UINT; MsgHandler: TSPFileCallbackA;
    Context: Pointer; DeviceInfoSet: HDEVINFO; DeviceIn: PSPDevInfoData): BOOL; stdcall;
  TSetupInstallFromInfSectionW = function(Owner: HWND; InfHandle: HINF;
    const SectionName: PWideChar; Flags: UINT; RelativeKeyRoot: HKEY;
    const SourceRootPath: PWideChar; CopyFlags: UINT; MsgHandler: TSPFileCallbackW;
    Context: Pointer; DeviceInfoSet: HDEVINFO; DeviceIn: PSPDevInfoData): BOOL; stdcall;
  TSetupInstallFromInfSection = function(Owner: HWND; InfHandle: HINF;
    const SectionName: PTSTR; Flags: UINT; RelativeKeyRoot: HKEY;
    const SourceRootPath: PTSTR; CopyFlags: UINT; MsgHandler: TSPFileCallback;
    Context: Pointer; DeviceInfoSet: HDEVINFO; DeviceIn: PSPDevInfoData): BOOL; stdcall;

  TSetupInstallFilesFromInfSectionA = function(InfHandle: HINF; LayoutInfHandle: HINF;
    FileQueue: HSPFILEQ; const SectionName, SourceRootPath: PAnsiChar;
    CopyFlags: UINT): BOOL; stdcall;
  TSetupInstallFilesFromInfSectionW = function(InfHandle: HINF; LayoutInfHandle: HINF;
    FileQueue: HSPFILEQ; const SectionName, SourceRootPath: PWideChar;
    CopyFlags: UINT): BOOL; stdcall;
  TSetupInstallFilesFromInfSection = function(InfHandle: HINF; LayoutInfHandle: HINF;
    FileQueue: HSPFILEQ; const SectionName, SourceRootPath: PTSTR;
    CopyFlags: UINT): BOOL; stdcall;

  TSetupInstallServicesFromInfSectionA = function(InfHandle: HINF;
    const SectionName: PAnsiChar; Flags: DWORD): BOOL; stdcall;
  TSetupInstallServicesFromInfSectionW = function(InfHandle: HINF;
    const SectionName: PWideChar; Flags: DWORD): BOOL; stdcall;
  TSetupInstallServicesFromInfSection = function(InfHandle: HINF;
    const SectionName: PTSTR; Flags: DWORD): BOOL; stdcall;

  TSetupInstallServicesFromInfSectionExA = function(InfHandle: HINF;
    const SectionName: PAnsiChar; Flags: DWORD; DeviceInfoSet: HDEVINFO;
    DeviceInfoData: TSPDevInfoData; Reserved1, Reserved2: Pointer): BOOL; stdcall;
  TSetupInstallServicesFromInfSectionExW = function(InfHandle: HINF;
    const SectionName: PWideChar; Flags: DWORD; DeviceInfoSet: HDEVINFO;
    DeviceInfoData: TSPDevInfoData; Reserved1, Reserved2: Pointer): BOOL; stdcall;
  TSetupInstallServicesFromInfSectionEx = function(InfHandle: HINF;
    const SectionName: PTSTR; Flags: DWORD; DeviceInfoSet: HDEVINFO;
    DeviceInfoData: TSPDevInfoData; Reserved1, Reserved2: Pointer): BOOL; stdcall;

  {$IFDEF WINXP_UP}
  TInstallHinfSectionA = procedure(Window: HWND; ModuleHandle: HINST;
    CommandLine: PAnsiChar; ShowCommand: Integer); stdcall;
  TInstallHinfSectionW = procedure(Window: HWND; ModuleHandle: HINST;
    CommandLine: PWideChar; ShowCommand: Integer); stdcall;
  TInstallHinfSection = procedure (Window: HWND; ModuleHandle: HINST;
    CommandLine: PTSTR; ShowCommand: Integer); stdcall;
  {$ENDIF WINXP_UP}

//
// Define handle type for Setup file log.
//

type
  HSPFILELOG = Pointer;
  {$EXTERNALSYM HSPFILELOG}

  TSetupInitializeFileLogA = function(const LogFileName: PAnsiChar; Flags: DWORD): HSPFILELOG; stdcall;
  TSetupInitializeFileLogW = function(const LogFileName: PWideChar; Flags: DWORD): HSPFILELOG; stdcall;
  TSetupInitializeFileLog = function(const LogFileName: PTSTR; Flags: DWORD): HSPFILELOG; stdcall;

  TSetupTerminateFileLog = function(FileLogHandle: HSPFILELOG): BOOL; stdcall;

  TSetupLogFileA = function(FileLogHandle: HSPFILELOG; const LogSectionName,
    SourceFilename, TargetFilename: PAnsiChar; Checksum: DWORD; DiskTagfile,
    DiskDescription, OtherInfo: PAnsiChar; Flags: DWORD): BOOL; stdcall;
  TSetupLogFileW = function(FileLogHandle: HSPFILELOG; const LogSectionName,
    SourceFilename, TargetFilename: PWideChar; Checksum: DWORD; DiskTagfile,
    DiskDescription, OtherInfo: PWideChar; Flags: DWORD): BOOL; stdcall;
  TSetupLogFile = function(FileLogHandle: HSPFILELOG; const LogSectionName,
    SourceFilename, TargetFilename: PTSTR; Checksum: DWORD; DiskTagfile,
    DiskDescription, OtherInfo: PTSTR; Flags: DWORD): BOOL; stdcall;

  TSetupRemoveFileLogEntryA = function(FileLogHandle: HSPFILELOG;
    const LogSectionName: PAnsiChar; const TargetFilename: PAnsiChar): BOOL; stdcall;
  TSetupRemoveFileLogEntryW = function(FileLogHandle: HSPFILELOG;
    const LogSectionName: PWideChar; const TargetFilename: PWideChar): BOOL; stdcall;
  TSetupRemoveFileLogEntry = function(FileLogHandle: HSPFILELOG;
    const LogSectionName: PTSTR; const TargetFilename: PTSTR): BOOL; stdcall;

  TSetupQueryFileLogA = function(FileLogHandle: HSPFILELOG; const LogSectionName,
    TargetFilename: PAnsiChar; DesiredInfo: SetupFileLogInfo; DataOut: PAnsiChar;
    ReturnBufferSize: DWORD; RequiredSize: PDWORD): BOOL; stdcall;
  TSetupQueryFileLogW = function(FileLogHandle: HSPFILELOG; const LogSectionName,
    TargetFilename: PWideChar; DesiredInfo: SetupFileLogInfo; DataOut: PWideChar;
    ReturnBufferSize: DWORD; RequiredSize: PDWORD): BOOL; stdcall;
  TSetupQueryFileLog = function(FileLogHandle: HSPFILELOG; const LogSectionName,
    TargetFilename: PTSTR; DesiredInfo: SetupFileLogInfo; DataOut: PTSTR;
    ReturnBufferSize: DWORD; RequiredSize: PDWORD): BOOL; stdcall;

//
// Text logging APIs
//

  TSetupOpenLog = function(Erase: BOOL): BOOL; stdcall;

  TSetupLogErrorA = function(const MessageString: PAnsiChar; Severity: LOGSEVERITY): BOOL; stdcall;
  TSetupLogErrorW = function(const MessageString: PWideChar; Severity: LOGSEVERITY): BOOL; stdcall;
  TSetupLogError = function(const MessageString: PTSTR; Severity: LOGSEVERITY): BOOL; stdcall;

  TSetupCloseLog = procedure; stdcall;

//
// Backup Information API
//

  {$IFDEF WIN2000_UP}
  TSetupGetBackupInformationA = function(QueueHandle: HSPFILEQ;
    var BackupParams: TSPBackupQueueParamsA): BOOL; stdcall;
  TSetupGetBackupInformationW = function(QueueHandle: HSPFILEQ;
    var BackupParams: TSPBackupQueueParamsW): BOOL; stdcall;
  TSetupGetBackupInformation = function(QueueHandle: HSPFILEQ;
    var BackupParams: TSPBackupQueueParams): BOOL; stdcall;
  {$ENDIF WIN2000_UP}

  {$IFDEF WINXP_UP}
  TSetupPrepareQueueForRestoreA = function(QueueHandle: HSPFILEQ;
    BackupPath: PAnsiChar; RestoreFlags: DWORD): BOOL; stdcall;
  TSetupPrepareQueueForRestoreW = function(QueueHandle: HSPFILEQ;
    BackupPath: PWideChar; RestoreFlags: DWORD): BOOL; stdcall;
  TSetupPrepareQueueForRestore = function(QueueHandle: HSPFILEQ;
    BackupPath: PTSTR; RestoreFlags: DWORD): BOOL; stdcall;

  TSetupSetNonInteractiveMode = function(NonInteractiveFlag: BOOL): BOOL; stdcall;
  TSetupGetNonInteractiveMode = function: BOOL; stdcall;
  {$ENDIF WINXP_UP}

//
// Device Installer APIs
//

  TSetupDiCreateDeviceInfoList = function(ClassGuid: PGUID; hwndParent: HWND): HDEVINFO; stdcall;

  TSetupDiCreateDeviceInfoListExA = function(ClassGuid: PGUID; hwndParent: HWND;
    const MachineName: PAnsiChar; Reserved: Pointer): HDEVINFO; stdcall;
  TSetupDiCreateDeviceInfoListExW = function(ClassGuid: PGUID; hwndParent: HWND;
    const MachineName: PWideChar; Reserved: Pointer): HDEVINFO; stdcall;
  TSetupDiCreateDeviceInfoListEx = function(ClassGuid: PGUID; hwndParent: HWND;
    const MachineName: PTSTR; Reserved: Pointer): HDEVINFO; stdcall;

  TSetupDiGetDeviceInfoListClass = function(DeviceInfoSet: HDEVINFO;
    var ClassGuid: TGUID): BOOL; stdcall;

  TSetupDiGetDeviceInfoListDetailA = function(DeviceInfoSet: HDEVINFO;
    var DeviceInfoSetDetailData: TSPDevInfoListDetailDataA): BOOL; stdcall;
  TSetupDiGetDeviceInfoListDetailW = function(DeviceInfoSet: HDEVINFO;
    var DeviceInfoSetDetailData: TSPDevInfoListDetailDataW): BOOL; stdcall;
  TSetupDiGetDeviceInfoListDetail = function(DeviceInfoSet: HDEVINFO;
    var DeviceInfoSetDetailData: TSPDevInfoListDetailData): BOOL; stdcall;

  TSetupDiCreateDeviceInfoA = function(DeviceInfoSet: HDEVINFO; const DeviceName: PAnsiChar;
    var ClassGuid: TGUID; const DeviceDescription: PAnsiChar; hwndParent: HWND;
    CreationFlags: DWORD; DeviceInfoData: PSPDevInfoData): BOOL; stdcall;
  TSetupDiCreateDeviceInfoW = function(DeviceInfoSet: HDEVINFO; const DeviceName: PWideChar;
    var ClassGuid: TGUID; const DeviceDescription: PWideChar; hwndParent: HWND;
    CreationFlags: DWORD; DeviceInfoData: PSPDevInfoData): BOOL; stdcall;
  TSetupDiCreateDeviceInfo = function(DeviceInfoSet: HDEVINFO; const DeviceName: PTSTR;
    var ClassGuid: TGUID; const DeviceDescription: PTSTR; hwndParent: HWND;
    CreationFlags: DWORD; DeviceInfoData: PSPDevInfoData): BOOL; stdcall;

  TSetupDiOpenDeviceInfoA = function(DeviceInfoSet: HDEVINFO;
    const DeviceInstanceId: PAnsiChar; hwndParent: HWND; OpenFlags: DWORD;
    var DeviceInfoData: TSPDevInfoData): BOOL; stdcall;
  TSetupDiOpenDeviceInfoW = function(DeviceInfoSet: HDEVINFO;
    const DeviceInstanceId: PWideChar; hwndParent: HWND; OpenFlags: DWORD;
    var DeviceInfoData: TSPDevInfoData): BOOL; stdcall;
  TSetupDiOpenDeviceInfo = function(DeviceInfoSet: HDEVINFO;
    const DeviceInstanceId: PTSTR; hwndParent: HWND; OpenFlags: DWORD;
    var DeviceInfoData: TSPDevInfoData): BOOL; stdcall;

  TSetupDiGetDeviceInstanceIdA = function(DeviceInfoSet: HDEVINFO;
    DeviceInfoData: PSPDevInfoData; DeviceInstanceId: PAnsiChar;
    DeviceInstanceIdSize: DWORD; RequiredSize: PDWORD): BOOL; stdcall;
  TSetupDiGetDeviceInstanceIdW = function(DeviceInfoSet: HDEVINFO;
    DeviceInfoData: PSPDevInfoData; DeviceInstanceId: PWideChar;
    DeviceInstanceIdSize: DWORD; RequiredSize: PDWORD): BOOL; stdcall;
  TSetupDiGetDeviceInstanceId = function(DeviceInfoSet: HDEVINFO;
    DeviceInfoData: PSPDevInfoData; DeviceInstanceId: PTSTR;
    DeviceInstanceIdSize: DWORD; RequiredSize: PDWORD): BOOL; stdcall;

  TSetupDiDeleteDeviceInfo = function(DeviceInfoSet: HDEVINFO;
    DeviceInfoData: PSPDevInfoData): BOOL; stdcall;

  TSetupDiEnumDeviceInfo = function(DeviceInfoSet: HDEVINFO;
    MemberIndex: DWORD; var DeviceInfoData: TSPDevInfoData): BOOL; stdcall;

  TSetupDiDestroyDeviceInfoList = function(DeviceInfoSet: HDEVINFO): BOOL; stdcall;

  TSetupDiEnumDeviceInterfaces = function(DeviceInfoSet: HDEVINFO;
    DeviceInfoData: PSPDevInfoData; const InterfaceClassGuid: TGUID;
    MemberIndex: DWORD; var DeviceInterfaceData: TSPDeviceInterfaceData): BOOL; stdcall;

//
// Backward compatibility--do not use
//

  TSetupDiEnumInterfaceDevice = function(DeviceInfoSet: HDEVINFO;
    DeviceInfoData: PSPDevInfoData; var InterfaceClassGuid: TGUID;
    MemberIndex: DWORD; var DeviceInterfaceData: TSPDeviceInterfaceData): BOOL; stdcall;

  TSetupDiCreateDeviceInterfaceA = function(DeviceInfoSet: HDEVINFO;
    var DeviceInfoData: TSPDevInfoData; var InterfaceClassGuid: TGUID;
    const ReferenceString: PAnsiChar; CreationFlags: DWORD;
    DeviceInterfaceData: PSPDeviceInterfaceData): BOOL; stdcall;
  TSetupDiCreateDeviceInterfaceW = function(DeviceInfoSet: HDEVINFO;
    var DeviceInfoData: TSPDevInfoData; var InterfaceClassGuid: TGUID;
    const ReferenceString: PWideChar; CreationFlags: DWORD;
    DeviceInterfaceData: PSPDeviceInterfaceData): BOOL; stdcall;
  TSetupDiCreateDeviceInterface = function(DeviceInfoSet: HDEVINFO;
    var DeviceInfoData: TSPDevInfoData; var InterfaceClassGuid: TGUID;
    const ReferenceString: PTSTR; CreationFlags: DWORD;
    DeviceInterfaceData: PSPDeviceInterfaceData): BOOL; stdcall;

//
// Backward compatibility--do not use.
//

  TSetupDiCreateInterfaceDeviceA = function(DeviceInfoSet: HDEVINFO;
    var DeviceInfoData: TSPDevInfoData; var InterfaceClassGuid: TGUID;
    const ReferenceString: PAnsiChar; CreationFlags: DWORD;
    DeviceInterfaceData: PSPDeviceInterfaceData): BOOL; stdcall;
  TSetupDiCreateInterfaceDeviceW = function(DeviceInfoSet: HDEVINFO;
    var DeviceInfoData: TSPDevInfoData; var InterfaceClassGuid: TGUID;
    const ReferenceString: PWideChar; CreationFlags: DWORD;
    DeviceInterfaceData: PSPDeviceInterfaceData): BOOL; stdcall;
  TSetupDiCreateInterfaceDevice = function(DeviceInfoSet: HDEVINFO;
    var DeviceInfoData: TSPDevInfoData; var InterfaceClassGuid: TGUID;
    const ReferenceString: PTSTR; CreationFlags: DWORD;
    DeviceInterfaceData: PSPDeviceInterfaceData): BOOL; stdcall;

  TSetupDiOpenDeviceInterfaceA = function(DeviceInfoSet: HDEVINFO;
    const DevicePath: PAnsiChar; OpenFlags: DWORD;
    DeviceInterfaceData: PSPDeviceInterfaceData): BOOL; stdcall;
  TSetupDiOpenDeviceInterfaceW = function(DeviceInfoSet: HDEVINFO;
    const DevicePath: PWideChar; OpenFlags: DWORD;
    DeviceInterfaceData: PSPDeviceInterfaceData): BOOL; stdcall;
  TSetupDiOpenDeviceInterface = function(DeviceInfoSet: HDEVINFO;
    const DevicePath: PTSTR; OpenFlags: DWORD;
    DeviceInterfaceData: PSPDeviceInterfaceData): BOOL; stdcall;

//
// Backward compatibility--do not use
//

  TSetupDiOpenInterfaceDeviceA = function(DeviceInfoSet: HDEVINFO;
    const DevicePath: PAnsiChar; OpenFlags: DWORD;
    DeviceInterfaceData: PSPDeviceInterfaceData): BOOL; stdcall;
  TSetupDiOpenInterfaceDeviceW = function(DeviceInfoSet: HDEVINFO;
    const DevicePath: PWideChar; OpenFlags: DWORD;
    DeviceInterfaceData: PSPDeviceInterfaceData): BOOL; stdcall;
  TSetupDiOpenInterfaceDevice = function(DeviceInfoSet: HDEVINFO;
    const DevicePath: PTSTR; OpenFlags: DWORD;
    DeviceInterfaceData: PSPDeviceInterfaceData): BOOL; stdcall;

  TSetupDiGetDeviceInterfaceAlias = function(DeviceInfoSet: HDEVINFO;
    var DeviceInterfaceData: TSPDeviceInterfaceData; var AliasInterfaceClassGuid: TGUID;
    var AliasDeviceInterfaceData: TSPDeviceInterfaceData): BOOL; stdcall;

//
// Backward compatibility--do not use.
//

  TSetupDiGetInterfaceDeviceAlias = function(DeviceInfoSet: HDEVINFO;
    var DeviceInterfaceData: TSPDeviceInterfaceData;
    var AliasInterfaceClassGuid: TGUID;
    var AliasDeviceInterfaceData: TSPDeviceInterfaceData): BOOL; stdcall;

  TSetupDiDeleteDeviceInterfaceData = function(DeviceInfoSet: HDEVINFO;
    var DeviceInterfaceData: TSPDeviceInterfaceData): BOOL; stdcall;

//
// Backward compatibility--do not use.
//

  TSetupDiDeleteInterfaceDeviceData = function(DeviceInfoSet: HDEVINFO;
    var DeviceInterfaceData: TSPDeviceInterfaceData): BOOL; stdcall;

  TSetupDiRemoveDeviceInterface = function(DeviceInfoSet: HDEVINFO;
    var DeviceInterfaceData: TSPDeviceInterfaceData): BOOL; stdcall;

//
// Backward compatibility--do not use.
//

  TSetupDiRemoveInterfaceDevice = function(DeviceInfoSet: HDEVINFO;
    var DeviceInterfaceData: TSPDeviceInterfaceData): BOOL; stdcall;

  TSetupDiGetDeviceInterfaceDetailA = function(DeviceInfoSet: HDEVINFO;
    DeviceInterfaceData: PSPDeviceInterfaceData;
    DeviceInterfaceDetailData: PSPDeviceInterfaceDetailDataA;
    DeviceInterfaceDetailDataSize: DWORD; var RequiredSize: DWORD;
    Device: PSPDevInfoData): BOOL; stdcall;
  TSetupDiGetDeviceInterfaceDetailW = function(DeviceInfoSet: HDEVINFO;
    DeviceInterfaceData: PSPDeviceInterfaceData;
    DeviceInterfaceDetailData: PSPDeviceInterfaceDetailDataW;
    DeviceInterfaceDetailDataSize: DWORD; var RequiredSize: DWORD;
    Device: PSPDevInfoData): BOOL; stdcall;
  TSetupDiGetDeviceInterfaceDetail = function(DeviceInfoSet: HDEVINFO;
    DeviceInterfaceData: PSPDeviceInterfaceData;
    DeviceInterfaceDetailData: PSPDeviceInterfaceDetailData;
    DeviceInterfaceDetailDataSize: DWORD; var RequiredSize: DWORD;
    Device: PSPDevInfoData): BOOL; stdcall;

//
// Backward compatibility--do not use.
//

  TSetupDiGetInterfaceDeviceDetailA = function(DeviceInfoSet: HDEVINFO;
    DeviceInterfaceData: PSPDeviceInterfaceData;
    DeviceInterfaceDetailData: PSPDeviceInterfaceDetailDataA;
    DeviceInterfaceDetailDataSize: DWORD; RequiredSize: PDWORD;
    Device: PSPDevInfoData): BOOL; stdcall;
  TSetupDiGetInterfaceDeviceDetailW = function(DeviceInfoSet: HDEVINFO;
    DeviceInterfaceData: PSPDeviceInterfaceData;
    DeviceInterfaceDetailData: PSPDeviceInterfaceDetailDataW;
    DeviceInterfaceDetailDataSize: DWORD; RequiredSize: PDWORD;
    Device: PSPDevInfoData): BOOL; stdcall;
  TSetupDiGetInterfaceDeviceDetail = function(DeviceInfoSet: HDEVINFO;
    DeviceInterfaceData: PSPDeviceInterfaceData;
    DeviceInterfaceDetailData: PSPDeviceInterfaceDetailData;
    DeviceInterfaceDetailDataSize: DWORD; RequiredSize: PDWORD;
    Device: PSPDevInfoData): BOOL; stdcall;

//
// Default install handler for DIF_INSTALLINTERFACES.
//

  TSetupDiInstallDeviceInterfaces = function(DeviceInfoSet: HDEVINFO;
    var DeviceInfoData: TSPDevInfoData): BOOL; stdcall;

//
// Backward compatibility--do not use.
//

  TSetupDiInstallInterfaceDevices = function(DeviceInfoSet: HDEVINFO;
    var DeviceInfoData: TSPDevInfoData): BOOL; stdcall;

  {$IFDEF WINXP_UP}
  TSetupDiSetDeviceInterfaceDefault = function(DeviceInfoSet: HDEVINFO;
    var DeviceInterfaceData: TSPDeviceInterfaceData; Flags: DWORD;
    Reserved: Pointer): BOOL; stdcall;
  {$ENDIF WINXP_UP}

//
// Default install handler for DIF_REGISTERDEVICE
//

  TSetupDiRegisterDeviceInfo = function(DeviceInfoSet: HDEVINFO;
    var DeviceInfoData: TSPDevInfoData; Flags: DWORD; CompareProc: TSPDetSigCmpProc;
    CompareContext: Pointer; DupDeviceInfoData: PSPDevInfoData): BOOL; stdcall;

  TSetupDiBuildDriverInfoList = function(DeviceInfoSet: HDEVINFO;
    DeviceInfoData: PSPDevInfoData; DriverType: DWORD): BOOL; stdcall;

  TSetupDiCancelDriverInfoSearch = function(DeviceInfoSet: HDEVINFO): BOOL; stdcall;

  TSetupDiEnumDriverInfoA = function(DeviceInfoSet: HDEVINFO;
    DeviceInfoData: PSPDevInfoData; DriverType: DWORD; MemberIndex: DWORD;
    var DriverInfoData: TSPDrvInfoDataA): BOOL; stdcall;
  TSetupDiEnumDriverInfoW = function(DeviceInfoSet: HDEVINFO;
    DeviceInfoData: PSPDevInfoData; DriverType: DWORD; MemberIndex: DWORD;
    var DriverInfoData: TSPDrvInfoDataW): BOOL; stdcall;
  TSetupDiEnumDriverInfo = function(DeviceInfoSet: HDEVINFO;
    DeviceInfoData: PSPDevInfoData; DriverType: DWORD; MemberIndex: DWORD;
    var DriverInfoData: TSPDrvInfoData): BOOL; stdcall;

  TSetupDiGetSelectedDriverA = function(DeviceInfoSet: HDEVINFO;
    DeviceInfoData: PSPDevInfoData; var DriverInfoData: TSPDrvInfoDataA): BOOL; stdcall;
  TSetupDiGetSelectedDriverW = function(DeviceInfoSet: HDEVINFO;
    DeviceInfoData: PSPDevInfoData; var DriverInfoData: TSPDrvInfoDataW): BOOL; stdcall;
  TSetupDiGetSelectedDriver = function(DeviceInfoSet: HDEVINFO;
    DeviceInfoData: PSPDevInfoData; var DriverInfoData: TSPDrvInfoData): BOOL; stdcall;

  TSetupDiSetSelectedDriverA = function(DeviceInfoSet: HDEVINFO;
    DeviceInfoData: PSPDevInfoData; DriverInfoData: PSPDrvInfoDataA): BOOL; stdcall;
  TSetupDiSetSelectedDriverW = function(DeviceInfoSet: HDEVINFO;
    DeviceInfoData: PSPDevInfoData; DriverInfoData: PSPDrvInfoDataW): BOOL; stdcall;
  TSetupDiSetSelectedDriver = function(DeviceInfoSet: HDEVINFO;
    DeviceInfoData: PSPDevInfoData; DriverInfoData: PSPDrvInfoData): BOOL; stdcall;

  TSetupDiGetDriverInfoDetailA = function(DeviceInfoSet: HDEVINFO;
    DeviceInfoData: PSPDevInfoData; var DriverInfoData: TSPDrvInfoDataA;
    DriverInfoDetailData: PSPDrvInfoDetailDataA; DriverInfoDetailDataSize: DWORD;
    RequiredSize: PDWORD): BOOL; stdcall;
  TSetupDiGetDriverInfoDetailW = function(DeviceInfoSet: HDEVINFO;
    DeviceInfoData: PSPDevInfoData; var DriverInfoData: TSPDrvInfoDataW;
    DriverInfoDetailData: PSPDrvInfoDetailDataW; DriverInfoDetailDataSize: DWORD;
    RequiredSize: PDWORD): BOOL; stdcall;
  TSetupDiGetDriverInfoDetail = function(DeviceInfoSet: HDEVINFO;
    DeviceInfoData: PSPDevInfoData; var DriverInfoData: TSPDrvInfoData;
    DriverInfoDetailData: PSPDrvInfoDetailData; DriverInfoDetailDataSize: DWORD;
    RequiredSize: PDWORD): BOOL; stdcall;

  TSetupDiDestroyDriverInfoList = function(DeviceInfoSet: HDEVINFO;
    DeviceInfoData: PSPDevInfoData; DriverType: DWORD): BOOL; stdcall;

  TSetupDiGetClassDevsA = function(ClassGuid: PGUID; const Enumerator: PAnsiChar;
    hwndParent: HWND; Flags: DWORD): HDEVINFO; stdcall;
  TSetupDiGetClassDevsW = function(ClassGuid: PGUID; const Enumerator: PWideChar;
    hwndParent: HWND; Flags: DWORD): HDEVINFO; stdcall;
  TSetupDiGetClassDevs = function(ClassGuid: PGUID; const Enumerator: PTSTR;
    hwndParent: HWND; Flags: DWORD): HDEVINFO; stdcall;

  TSetupDiGetClassDevsExA = function(ClassGuid: PGUID; const Enumerator: PAnsiChar;
    hwndParent: HWND; Flags: DWORD; DeviceInfoSet: HDEVINFO; const MachineName: PAnsiChar;
    Reserved: Pointer): HDEVINFO; stdcall;
  TSetupDiGetClassDevsExW = function(ClassGuid: PGUID; const Enumerator: PWideChar;
    hwndParent: HWND; Flags: DWORD; DeviceInfoSet: HDEVINFO; const MachineName: PWideChar;
    Reserved: Pointer): HDEVINFO; stdcall;
  TSetupDiGetClassDevsEx = function(ClassGuid: PGUID; const Enumerator: PTSTR;
    hwndParent: HWND; Flags: DWORD; DeviceInfoSet: HDEVINFO; const MachineName: PTSTR;
    Reserved: Pointer): HDEVINFO; stdcall;

  TSetupDiGetINFClassA = function(const InfName: PAnsiChar; var ClassGuid: TGUID;
    ClassName: PAnsiChar; ClassNameSize: DWORD; RequiredSize: PDWORD): BOOL; stdcall;
  TSetupDiGetINFClassW = function(const InfName: PWideChar; var ClassGuid: TGUID;
    ClassName: PWideChar; ClassNameSize: DWORD; RequiredSize: PDWORD): BOOL; stdcall;
  TSetupDiGetINFClass = function(const InfName: PTSTR; var ClassGuid: TGUID;
    ClassName: PTSTR; ClassNameSize: DWORD; RequiredSize: PDWORD): BOOL; stdcall;

  TSetupDiBuildClassInfoList = function(Flags: DWORD; ClassGuidList: PGUID;
    ClassGuidListSize: DWORD; var RequiredSize: DWORD): BOOL; stdcall;

  TSetupDiBuildClassInfoListExA = function(Flags: DWORD; ClassGuidList: PGUID;
    ClassGuidListSize: DWORD; var RequiredSize: DWORD; const MachineName: PAnsiChar;
    Reserved: Pointer): BOOL; stdcall;
  TSetupDiBuildClassInfoListExW = function(Flags: DWORD; ClassGuidList: PGUID;
    ClassGuidListSize: DWORD; var RequiredSize: DWORD; const MachineName: PWideChar;
    Reserved: Pointer): BOOL; stdcall;
  TSetupDiBuildClassInfoListEx = function(Flags: DWORD; ClassGuidList: PGUID;
    ClassGuidListSize: DWORD; var RequiredSize: DWORD; const MachineName: PTSTR;
    Reserved: Pointer): BOOL; stdcall;

  TSetupDiGetClassDescriptionA = function(var ClassGuid: TGUID; ClassDescription: PAnsiChar;
    ClassDescriptionSize: DWORD; var RequiredSize: DWORD): BOOL; stdcall;
  TSetupDiGetClassDescriptionW = function(var ClassGuid: TGUID; ClassDescription: PWideChar;
    ClassDescriptionSize: DWORD; var RequiredSize: DWORD): BOOL; stdcall;
  TSetupDiGetClassDescription = function(var ClassGuid: TGUID; ClassDescription: PTSTR;
    ClassDescriptionSize: DWORD; var RequiredSize: DWORD): BOOL; stdcall;

  TSetupDiGetClassDescriptionExA = function(var ClassGuid: TGUID;
    ClassDescription: PAnsiChar; ClassDescriptionSize: DWORD; var RequiredSize: DWORD;
    const MachineName: PAnsiChar; Reserved: Pointer): BOOL; stdcall;
  TSetupDiGetClassDescriptionExW = function(var ClassGuid: TGUID;
    ClassDescription: PWideChar; ClassDescriptionSize: DWORD; var RequiredSize: DWORD;
    const MachineName: PWideChar; Reserved: Pointer): BOOL; stdcall;
  TSetupDiGetClassDescriptionEx = function(var ClassGuid: TGUID;
    ClassDescription: PTSTR; ClassDescriptionSize: DWORD; var RequiredSize: DWORD;
    const MachineName: PTSTR; Reserved: Pointer): BOOL; stdcall;

  TSetupDiCallClassInstaller = function(InstallFunction: DI_FUNCTION;
    DeviceInfoSet: HDEVINFO; DeviceInfoData: PSPDevInfoData): BOOL; stdcall;

//
// Default install handler for DIF_SELECTDEVICE
//

  TSetupDiSelectDevice = function(DeviceInfoSet:  HDEVINFO;
    DeviceInfoData: PSPDevInfoData): BOOL; stdcall;

//
// Default install handler for DIF_SELECTBESTCOMPATDRV
//

  TSetupDiSelectBestCompatDrv = function(DeviceInfoSet: HDEVINFO;
    DeviceInfoData: PSPDevInfoData): BOOL; stdcall;

//
// Default install handler for DIF_INSTALLDEVICE
//
  TSetupDiInstallDevice = function(DeviceInfoSet: HDEVINFO;
    var DeviceInfoData: TSPDevInfoData): BOOL; stdcall;

//
// Default install handler for DIF_INSTALLDEVICEFILES
//

  TSetupDiInstallDriverFiles = function(DeviceInfoSet: HDEVINFO;
    var DeviceInfoData: TSPDevInfoData): BOOL; stdcall;

//
// Default install handler for DIF_REGISTER_COINSTALLERS
//
  TSetupDiRegisterCoDeviceInstallers = function(DeviceInfoSet: HDEVINFO;
    var DeviceInfoData: TSPDevInfoData): BOOL; stdcall;

//
// Default install handler for DIF_REMOVE
//

  TSetupDiRemoveDevice = function(DeviceInfoSet: HDEVINFO;
    var DeviceInfoData: TSPDevInfoData): BOOL; stdcall;

//
// Default install handler for DIF_UNREMOVE
//

  TSetupDiUnremoveDevice = function(DeviceInfoSet: HDEVINFO;
    var DeviceInfoData: TSPDevInfoData): BOOL; stdcall;

//
// Default install handler for DIF_MOVEDEVICE
//
  TSetupDiMoveDuplicateDevice = function(DeviceInfoSet: HDEVINFO;
    var DestinationDeviceInfoData: TSPDevInfoData): BOOL; stdcall;

//
// Default install handler for DIF_PROPERTYCHANGE
//
  TSetupDiChangeState = function(DeviceInfoSet: HDEVINFO;
    var DeviceInfoData: TSPDevInfoData): BOOL; stdcall;

  TSetupDiInstallClassA = function(hwndParent: HWND; const InfFileName: PAnsiChar;
    Flags: DWORD; FileQueue: HSPFILEQ): BOOL; stdcall;
  TSetupDiInstallClassW = function(hwndParent: HWND; const InfFileName: PWideChar;
    Flags: DWORD; FileQueue: HSPFILEQ): BOOL; stdcall;
  TSetupDiInstallClass = function(hwndParent: HWND; const InfFileName: PTSTR;
    Flags: DWORD; FileQueue: HSPFILEQ): BOOL; stdcall;

  TSetupDiInstallClassExA = function(hwndParent: HWND; const InfFileName: PAnsiChar;
    Flags: DWORD; FileQueue: HSPFILEQ; InterfaceClassGuid: PGUID; Reserved1,
    Reserved2: Pointer): BOOL; stdcall;
  TSetupDiInstallClassExW = function(hwndParent: HWND; const InfFileName: PWideChar;
    Flags: DWORD; FileQueue: HSPFILEQ; InterfaceClassGuid: PGUID; Reserved1,
    Reserved2: Pointer): BOOL; stdcall;
  TSetupDiInstallClassEx = function(hwndParent: HWND; const InfFileName: PTSTR;
    Flags: DWORD; FileQueue: HSPFILEQ; InterfaceClassGuid: PGUID; Reserved1,
    Reserved2: Pointer): BOOL; stdcall;

  TSetupDiOpenClassRegKey = function(ClassGuid: PGUID; samDesired: REGSAM): HKEY; stdcall;

  TSetupDiOpenClassRegKeyExA = function(ClassGuid: PGUID; samDesired: REGSAM;
    Flags: DWORD; const MachineName: PAnsiChar; Reserved: Pointer): HKEY; stdcall;
  TSetupDiOpenClassRegKeyExW = function(ClassGuid: PGUID; samDesired: REGSAM;
    Flags: DWORD; const MachineName: PWideChar; Reserved: Pointer): HKEY; stdcall;
  TSetupDiOpenClassRegKeyEx = function(ClassGuid: PGUID; samDesired: REGSAM;
    Flags: DWORD; const MachineName: PTSTR; Reserved: Pointer): HKEY; stdcall;

  TSetupDiCreateDeviceInterfaceRegKeyA = function(DeviceInfoSet: HDEVINFO;
    var DeviceInterfaceData: TSPDeviceInterfaceData; Reserved: DWORD;
    samDesired: REGSAM; InfHandle: HINF; const InfSectionName: PAnsiChar): HKEY; stdcall;
  TSetupDiCreateDeviceInterfaceRegKeyW = function(DeviceInfoSet: HDEVINFO;
    var DeviceInterfaceData: TSPDeviceInterfaceData; Reserved: DWORD;
    samDesired: REGSAM; InfHandle: HINF; const InfSectionName: PWideChar): HKEY; stdcall;
  TSetupDiCreateDeviceInterfaceRegKey = function(DeviceInfoSet: HDEVINFO;
    var DeviceInterfaceData: TSPDeviceInterfaceData; Reserved: DWORD;
    samDesired: REGSAM; InfHandle: HINF; const InfSectionName: PTSTR): HKEY; stdcall;

//
// Backward compatibility--do not use.
//

  TSetupDiCreateInterfaceDeviceRegKeyA = function(DeviceInfoSet: HDEVINFO;
    var DeviceInterfaceData: TSPDeviceInterfaceData; Reserved: DWORD;
    samDesired: REGSAM; InfHandle: HINF; const InfSectionName: PAnsiChar): HKEY; stdcall;
  TSetupDiCreateInterfaceDeviceRegKeyW = function(DeviceInfoSet: HDEVINFO;
    var DeviceInterfaceData: TSPDeviceInterfaceData; Reserved: DWORD;
    samDesired: REGSAM; InfHandle: HINF; const InfSectionName: PWideChar): HKEY; stdcall;
  TSetupDiCreateInterfaceDeviceRegKey = function(DeviceInfoSet: HDEVINFO;
    var DeviceInterfaceData: TSPDeviceInterfaceData; Reserved: DWORD;
    samDesired: REGSAM; InfHandle: HINF; const InfSectionName: PTSTR): HKEY; stdcall;

  TSetupDiOpenDeviceInterfaceRegKey = function(DeviceInfoSet: HDEVINFO;
    var DeviceInterfaceData: TSPDeviceInterfaceData; Reserved: DWORD;
    samDesired: REGSAM): HKEY; stdcall;

//
// Backward compatibility--do not use.
//

  TSetupDiOpenInterfaceDeviceRegKey = function(DeviceInfoSet: HDEVINFO;
    var DeviceInterfaceData: TSPDeviceInterfaceData; Reserved: DWORD;
    samDesired: REGSAM): HKEY; stdcall;

  TSetupDiDeleteDeviceInterfaceRegKey = function(DeviceInfoSet: HDEVINFO;
    var DeviceInterfaceData: TSPDeviceInterfaceData; Reserved: DWORD): BOOL; stdcall;

//
// Backward compatibility--do not use.
//

  TSetupDiDeleteInterfaceDeviceRegKey = function(DeviceInfoSet: HDEVINFO;
    var DeviceInterfaceData: TSPDeviceInterfaceData; Reserved: DWORD): BOOL; stdcall;

  TSetupDiCreateDevRegKeyA = function(DeviceInfoSet: HDEVINFO;
    var DeviceInfoData: TSPDevInfoData; Scope, HwProfile, KeyType: DWORD;
    InfHandle: HINF; const InfSectionName: PAnsiChar): HKEY; stdcall;
  TSetupDiCreateDevRegKeyW = function(DeviceInfoSet: HDEVINFO;
    var DeviceInfoData: TSPDevInfoData; Scope, HwProfile, KeyType: DWORD;
    InfHandle: HINF; const InfSectionName: PWideChar): HKEY; stdcall;
  TSetupDiCreateDevRegKey = function(DeviceInfoSet: HDEVINFO;
    var DeviceInfoData: TSPDevInfoData; Scope, HwProfile, KeyType: DWORD;
    InfHandle: HINF; const InfSectionName: PTSTR): HKEY; stdcall;

  TSetupDiOpenDevRegKey = function(DeviceInfoSet: HDEVINFO;
    var DeviceInfoData: TSPDevInfoData; Scope, HwProfile, KeyType: DWORD;
    samDesired: REGSAM): HKEY; stdcall;

  TSetupDiDeleteDevRegKey = function(DeviceInfoSet: HDEVINFO;
    var DeviceInfoData: TSPDevInfoData; Scope, HwProfile,
    KeyType: DWORD): BOOL; stdcall;

  TSetupDiGetHwProfileList = function(HwProfileList: PDWORD; HwProfileListSize: DWORD;
    var RequiredSize: DWORD; CurrentlyActiveIndex: PDWORD): BOOL; stdcall;

  TSetupDiGetHwProfileListExA = function(HwProfileList: PDWORD;
    HwProfileListSize: DWORD; var RequiredSize: DWORD; CurrentlyActiveIndex: PDWORD;
    const MachineName: PAnsiChar; Reserved: Pointer): BOOL; stdcall;
  TSetupDiGetHwProfileListExW = function(HwProfileList: PDWORD;
    HwProfileListSize: DWORD; var RequiredSize: DWORD; CurrentlyActiveIndex: PDWORD;
    const MachineName: PWideChar; Reserved: Pointer): BOOL; stdcall;
  TSetupDiGetHwProfileListEx = function(HwProfileList: PDWORD;
    HwProfileListSize: DWORD; var RequiredSize: DWORD; CurrentlyActiveIndex: PDWORD;
    const MachineName: PTSTR; Reserved: Pointer): BOOL; stdcall;

  TSetupDiGetDeviceRegistryPropertyA = function(DeviceInfoSet: HDEVINFO;
    const DeviceInfoData: TSPDevInfoData; Property_: DWORD;
    var PropertyRegDataType: DWORD; PropertyBuffer: PBYTE; PropertyBufferSize: DWORD;
    var RequiredSize: DWORD): BOOL; stdcall;
  TSetupDiGetDeviceRegistryPropertyW = function(DeviceInfoSet: HDEVINFO;
    const DeviceInfoData: TSPDevInfoData; Property_: DWORD;
    var PropertyRegDataType: DWORD; PropertyBuffer: PBYTE; PropertyBufferSize: DWORD;
    var RequiredSize: DWORD): BOOL; stdcall;
  {$IFDEF UNICODE}
  TSetupDiGetDeviceRegistryProperty = TSetupDiGetDeviceRegistryPropertyW;
  {$ELSE}
  TSetupDiGetDeviceRegistryProperty = TSetupDiGetDeviceRegistryPropertyA;
  {$ENDIF UNICODE}

  {$IFDEF WINXP_UP}
  TSetupDiGetClassRegistryPropertyA = function(var ClassGuid: TGUID;
    Property_: DWORD; PropertyRegDataType: PDWORD; PropertyBuffer: PBYTE;
    PropertyBufferSize: DWORD; RequiredSize: PDWORD; const MachineName: PAnsiChar;
    Reserved: Pointer): BOOL; stdcall;
  TSetupDiGetClassRegistryPropertyW = function(var ClassGuid: TGUID;
    Property_: DWORD; PropertyRegDataType: PDWORD; PropertyBuffer: PBYTE;
    PropertyBufferSize: DWORD; RequiredSize: PDWORD; const MachineName: PWideChar;
    Reserved: Pointer): BOOL; stdcall;
  TSetupDiGetClassRegistryProperty = function(var ClassGuid: TGUID;
    Property_: DWORD; PropertyRegDataType: PDWORD; PropertyBuffer: PBYTE;
    PropertyBufferSize: DWORD; RequiredSize: PDWORD; const MachineName: PTSTR;
    Reserved: Pointer): BOOL; stdcall;
  {$ENDIF WINXP_UP}

  TSetupDiSetDeviceRegistryPropertyA = function(DeviceInfoSet: HDEVINFO;
    var DeviceInfoData: TSPDevInfoData; Property_: DWORD;
    const PropertyBuffer: PBYTE; PropertyBufferSize: DWORD): BOOL; stdcall;
  TSetupDiSetDeviceRegistryPropertyW = function(DeviceInfoSet: HDEVINFO;
    var DeviceInfoData: TSPDevInfoData; Property_: DWORD;
    const PropertyBuffer: PBYTE; PropertyBufferSize: DWORD): BOOL; stdcall;
  {$IFDEF UNICODE}
  TSetupDiSetDeviceRegistryProperty = TSetupDiSetDeviceRegistryPropertyW;
  {$ELSE}
  TSetupDiSetDeviceRegistryProperty = TSetupDiSetDeviceRegistryPropertyA;
  {$ENDIF UNICODE}

  {$IFDEF WINXP_UP}
  TSetupDiSetClassRegistryPropertyA = function(var ClassGuid: TGUID;
    Property_: DWORD; const PropertyBuffer: PBYTE; PropertyBufferSize: DWORD;
    const MachineName: PAnsiChar; Reserved: Pointer): BOOL; stdcall;
  TSetupDiSetClassRegistryPropertyW = function(var ClassGuid: TGUID;
    Property_: DWORD; const PropertyBuffer: PBYTE; PropertyBufferSize: DWORD;
    const MachineName: PWideChar; Reserved: Pointer): BOOL; stdcall;
  TSetupDiSetClassRegistryProperty = function(var ClassGuid: TGUID;
    Property_: DWORD; const PropertyBuffer: PBYTE; PropertyBufferSize: DWORD;
    const MachineName: PTSTR; Reserved: Pointer): BOOL; stdcall;
  {$ENDIF WINXP_UP}

  TSetupDiGetDeviceInstallParamsA = function(DeviceInfoSet: HDEVINFO;
    DeviceInfoData: PSPDevInfoData;
    var DeviceInstallParams: TSPDevInstallParamsA): BOOL; stdcall;
  TSetupDiGetDeviceInstallParamsW = function(DeviceInfoSet: HDEVINFO;
    DeviceInfoData: PSPDevInfoData;
    var DeviceInstallParams: TSPDevInstallParamsW): BOOL; stdcall;
  TSetupDiGetDeviceInstallParams = function(DeviceInfoSet: HDEVINFO;
    DeviceInfoData: PSPDevInfoData;
    var DeviceInstallParams: TSPDevInstallParams): BOOL; stdcall;

  TSetupDiGetClassInstallParamsA = function(DeviceInfoSet: HDEVINFO;
    DeviceInfoData: PSPDevInfoData; ClassInstallParams: PSPClassInstallHeader;
    ClassInstallParamsSize: DWORD; RequiredSize: PDWORD): BOOL; stdcall;
  TSetupDiGetClassInstallParamsW = function(DeviceInfoSet: HDEVINFO;
    DeviceInfoData: PSPDevInfoData; ClassInstallParams: PSPClassInstallHeader;
    ClassInstallParamsSize: DWORD; RequiredSize: PDWORD): BOOL; stdcall;
  {$IFDEF UNICODE}
  TSetupDiGetClassInstallParams = TSetupDiGetClassInstallParamsW;
  {$ELSE}
  TSetupDiGetClassInstallParams = TSetupDiGetClassInstallParamsA;
  {$ENDIF UNICODE}

  TSetupDiSetDeviceInstallParamsA = function(DeviceInfoSet: HDEVINFO;
    DeviceInfoData: PSPDevInfoData;
    var DeviceInstallParams: TSPDevInstallParamsA): BOOL; stdcall;
  TSetupDiSetDeviceInstallParamsW = function(DeviceInfoSet: HDEVINFO;
    DeviceInfoData: PSPDevInfoData;
    var DeviceInstallParams: TSPDevInstallParamsW): BOOL; stdcall;
  TSetupDiSetDeviceInstallParams = function(DeviceInfoSet: HDEVINFO;
    DeviceInfoData: PSPDevInfoData;
    var DeviceInstallParams: TSPDevInstallParams): BOOL; stdcall;

  TSetupDiSetClassInstallParamsA = function(DeviceInfoSet: HDEVINFO;
    DeviceInfoData: PSPDevInfoData; ClassInstallParams: PSPClassInstallHeader;
    ClassInstallParamsSize: DWORD): BOOL; stdcall;
  TSetupDiSetClassInstallParamsW = function(DeviceInfoSet: HDEVINFO;
    DeviceInfoData: PSPDevInfoData; ClassInstallParams: PSPClassInstallHeader;
    ClassInstallParamsSize: DWORD): BOOL; stdcall;
  {$IFDEF UNICODE}
  TSetupDiSetClassInstallParams = TSetupDiSetClassInstallParamsW;
  {$ELSE}
  TSetupDiSetClassInstallParams = TSetupDiSetClassInstallParamsA;
  {$ENDIF UNICODE}

  TSetupDiGetDriverInstallParamsA = function(DeviceInfoSet: HDEVINFO;
    DeviceInfoData: PSPDevInfoData; var DriverInfoData: TSPDrvInfoDataA;
    var DriverInstallParams: TSPDrvInstallParams): BOOL; stdcall;
  TSetupDiGetDriverInstallParamsW = function(DeviceInfoSet: HDEVINFO;
    DeviceInfoData: PSPDevInfoData; var DriverInfoData: TSPDrvInfoDataW;
    var DriverInstallParams: TSPDrvInstallParams): BOOL; stdcall;
  TSetupDiGetDriverInstallParams = function(DeviceInfoSet: HDEVINFO;
    DeviceInfoData: PSPDevInfoData; var DriverInfoData: TSPDrvInfoData;
    var DriverInstallParams: TSPDrvInstallParams): BOOL; stdcall;

  TSetupDiSetDriverInstallParamsA = function(DeviceInfoSet: HDEVINFO;
    DeviceInfoData: PSPDevInfoData; var DriverInfoData: TSPDrvInfoDataA;
    var DriverInstallParams: TSPDrvInstallParams): BOOL; stdcall;
  TSetupDiSetDriverInstallParamsW = function(DeviceInfoSet: HDEVINFO;
    DeviceInfoData: PSPDevInfoData; var DriverInfoData: TSPDrvInfoDataW;
    var DriverInstallParams: TSPDrvInstallParams): BOOL; stdcall;
  TSetupDiSetDriverInstallParams = function(DeviceInfoSet: HDEVINFO;
    DeviceInfoData: PSPDevInfoData; var DriverInfoData: TSPDrvInfoData;
    var DriverInstallParams: TSPDrvInstallParams): BOOL; stdcall;

  TSetupDiLoadClassIcon = function(var ClassGuid: TGUID; LargeIcon: PHICON;
    MiniIconIndex: PINT): BOOL; stdcall;

  TSetupDiDrawMiniIcon = function(hdc: HDC; rc: TRect; MiniIconIndex: Integer;
    Flags: DWORD): Integer; stdcall;

  TSetupDiGetClassBitmapIndex = function(ClassGuid: PGUID;
    var MiniIconIndex: Integer): BOOL; stdcall;

  TSetupDiGetClassImageList = function(
    var ClassImageListData: TSPClassImageListData): BOOL; stdcall;

  TSetupDiGetClassImageListExA = function(var ClassImageListData: TSPClassImageListData;
    const MachineName: PAnsiChar; Reserved: Pointer): BOOL; stdcall;
  TSetupDiGetClassImageListExW = function(var ClassImageListData: TSPClassImageListData;
    const MachineName: PWideChar; Reserved: Pointer): BOOL; stdcall;
  TSetupDiGetClassImageListEx = function(var ClassImageListData: TSPClassImageListData;
    const MachineName: PTSTR; Reserved: Pointer): BOOL; stdcall;

  TSetupDiGetClassImageIndex = function(var ClassImageListData: TSPClassImageListData;
    var ClassGuid: TGUID; var ImageIndex: Integer): BOOL; stdcall;

  TSetupDiDestroyClassImageList = function(
    var ClassImageListData: TSPClassImageListData): BOOL; stdcall;

  TSetupDiGetClassDevPropertySheetsA = function(DeviceInfoSet: HDEVINFO;
    DeviceInfoData: PSPDevInfoData; var PropertySheetHeader: TPropSheetHeaderA;
    PropertySheetHeaderPageListSize: DWORD; RequiredSize: PDWORD;
    PropertySheetType: DWORD): BOOL; stdcall;
  TSetupDiGetClassDevPropertySheetsW = function(DeviceInfoSet: HDEVINFO;
    DeviceInfoData: PSPDevInfoData; var PropertySheetHeader: TPropSheetHeaderW;
    PropertySheetHeaderPageListSize: DWORD; RequiredSize: PDWORD;
    PropertySheetType: DWORD): BOOL; stdcall;
  TSetupDiGetClassDevPropertySheets = function(DeviceInfoSet: HDEVINFO;
    DeviceInfoData: PSPDevInfoData; var PropertySheetHeader: TPropSheetHeader;
    PropertySheetHeaderPageListSize: DWORD; RequiredSize: PDWORD;
    PropertySheetType: DWORD): BOOL; stdcall;

  TSetupDiAskForOEMDisk = function(DeviceInfoSet: HDEVINFO; DeviceInfoData: PSPDevInfoData): BOOL; stdcall;

  TSetupDiSelectOEMDrv = function(hwndParent: HWND; DeviceInfoSet: HDEVINFO;
    DeviceInfoData: PSPDevInfoData): BOOL; stdcall;

  TSetupDiClassNameFromGuidA = function(var ClassGuid: TGUID; ClassName: PAnsiChar;
    ClassNameSize: DWORD; RequiredSize: PDWORD): BOOL; stdcall;
  TSetupDiClassNameFromGuidW = function(var ClassGuid: TGUID; ClassName: PWideChar;
    ClassNameSize: DWORD; RequiredSize: PDWORD): BOOL; stdcall;
  TSetupDiClassNameFromGuid = function(var ClassGuid: TGUID; ClassName: PTSTR;
    ClassNameSize: DWORD; RequiredSize: PDWORD): BOOL; stdcall;

  TSetupDiClassNameFromGuidExA = function(var ClassGuid: TGUID; ClassName: PAnsiChar;
    ClassNameSize: DWORD; RequiredSize: PDWORD; const MachineName: PAnsiChar;
    Reserved: Pointer): BOOL; stdcall;
  TSetupDiClassNameFromGuidExW = function(var ClassGuid: TGUID; ClassName: PWideChar;
    ClassNameSize: DWORD; RequiredSize: PDWORD; const MachineName: PWideChar;
    Reserved: Pointer): BOOL; stdcall;
  TSetupDiClassNameFromGuidEx = function(var ClassGuid: TGUID; ClassName: PTSTR;
    ClassNameSize: DWORD; RequiredSize: PDWORD; const MachineName: PTSTR;
    Reserved: Pointer): BOOL; stdcall;

  TSetupDiClassGuidsFromNameA = function(const ClassName: PAnsiChar; ClassGuidList: PGUID;
    ClassGuidListSize: DWORD; var RequiredSize: DWORD): BOOL; stdcall;
  TSetupDiClassGuidsFromNameW = function(const ClassName: PWideChar; ClassGuidList: PGUID;
    ClassGuidListSize: DWORD; var RequiredSize: DWORD): BOOL; stdcall;
  TSetupDiClassGuidsFromName = function(const ClassName: PTSTR; ClassGuidList: PGUID;
    ClassGuidListSize: DWORD; var RequiredSize: DWORD): BOOL; stdcall;

  TSetupDiClassGuidsFromNameExA = function(const ClassName: PAnsiChar; ClassGuidList: PGUID;
    ClassGuidListSize: DWORD; var RequiredSize: DWORD; const MachineName: PAnsiChar;
    Reserved: Pointer): BOOL; stdcall;
  TSetupDiClassGuidsFromNameExW = function(const ClassName: PWideChar; ClassGuidList: PGUID;
    ClassGuidListSize: DWORD; var RequiredSize: DWORD; const MachineName: PWideChar;
    Reserved: Pointer): BOOL; stdcall;
  TSetupDiClassGuidsFromNameEx = function(const ClassName: PTSTR; ClassGuidList: PGUID;
    ClassGuidListSize: DWORD; var RequiredSize: DWORD; const MachineName: PTSTR;
    Reserved: Pointer): BOOL; stdcall;

  TSetupDiGetHwProfileFriendlyNameA = function(HwProfile: DWORD; FriendlyName: PAnsiChar;
    FriendlyNameSize: DWORD; RequiredSize: PDWORD): BOOL; stdcall;
  TSetupDiGetHwProfileFriendlyNameW = function(HwProfile: DWORD; FriendlyName: PWideChar;
    FriendlyNameSize: DWORD; RequiredSize: PDWORD): BOOL; stdcall;
  TSetupDiGetHwProfileFriendlyName = function(HwProfile: DWORD; FriendlyName: PTSTR;
    FriendlyNameSize: DWORD; RequiredSize: PDWORD): BOOL; stdcall;

  TSetupDiGetHwProfileFriendlyNameExA = function(HwProfile: DWORD; FriendlyName: PAnsiChar;
    FriendlyNameSize: DWORD; RequiredSize: PDWORD; const MachineName: PAnsiChar;
    Reserved: Pointer): BOOL; stdcall;
  TSetupDiGetHwProfileFriendlyNameExW = function(HwProfile: DWORD; FriendlyName: PWideChar;
    FriendlyNameSize: DWORD; RequiredSize: PDWORD; const MachineName: PWideChar;
    Reserved: Pointer): BOOL; stdcall;
  TSetupDiGetHwProfileFriendlyNameEx = function(HwProfile: DWORD; FriendlyName: PTSTR;
    FriendlyNameSize: DWORD; RequiredSize: PDWORD; const MachineName: PTSTR;
    Reserved: Pointer): BOOL; stdcall;

  TSetupDiGetWizardPage = function(DeviceInfoSet: HDEVINFO;
    DeviceInfoData: PSPDevInfoData; var InstallWizardData: TSPInstallWizardData;
    PageType: DWORD; Flags: DWORD): HPROPSHEETPAGE; stdcall;

  TSetupDiGetSelectedDevice = function(DeviceInfoSet: HDEVINFO;
    var DeviceInfoData: TSPDevInfoData): BOOL; stdcall;

  TSetupDiSetSelectedDevice = function(DeviceInfoSet: HDEVINFO;
    var DeviceInfoData: TSPDevInfoData): BOOL; stdcall;

  TSetupDiGetActualSectionToInstallA = function(InfHandle: HINF;
    const InfSectionName: PAnsiChar; InfSectionWithExt: PAnsiChar; InfSectionWithExtSize: DWORD;
    RequiredSize: PDWORD; Extension: PPASTR): BOOL; stdcall;
  TSetupDiGetActualSectionToInstallW = function(InfHandle: HINF;
    const InfSectionName: PWideChar; InfSectionWithExt: PWideChar; InfSectionWithExtSize: DWORD;
    RequiredSize: PDWORD; Extension: PPWSTR): BOOL; stdcall;
  TSetupDiGetActualSectionToInstall = function(InfHandle: HINF;
    const InfSectionName: PTSTR; InfSectionWithExt: PTSTR; InfSectionWithExtSize: DWORD;
    RequiredSize: PDWORD; Extension: PPWSTR): BOOL; stdcall;

  {$IFDEF WINXP_UP}
  TSetupDiGetActualSectionToInstallExA = function(InfHandle: HINF;
    InfSectionName: PAnsiChar; AlternatePlatformInfo: PSPAltPlatformInfo;
    InfSectionWithExt: PAnsiChar; InfSectionWithExtSize: DWORD;
    RequiredSize: PDWORD; Extension: PPASTR; Reserved: Pointer): BOOL; stdcall;
  TSetupDiGetActualSectionToInstallExW = function(InfHandle: HINF;
    InfSectionName: PWideChar; AlternatePlatformInfo: PSPAltPlatformInfo;
    InfSectionWithExt: PWideChar; InfSectionWithExtSize: DWORD;
    RequiredSize: PDWORD; Extension: PPWSTR; Reserved: Pointer): BOOL; stdcall;
  TSetupDiGetActualSectionToInstallEx = function(InfHandle: HINF;
    InfSectionName: PTSTR; AlternatePlatformInfo: PSPAltPlatformInfo;
    InfSectionWithExt: PTSTR; InfSectionWithExtSize: DWORD;
    RequiredSize: PDWORD; Extension: PPSTR; Reserved: Pointer): BOOL; stdcall;

  TSetupEnumInfSectionsA = function(InfHandle: HINF; Index: UINT;
    Buffer: PAnsiChar; Size: UINT; SizeNeeded: PUINT): BOOL; stdcall;
  TSetupEnumInfSectionsW = function(InfHandle: HINF; Index: UINT;
    Buffer: PWideChar; Size: UINT; SizeNeeded: PUINT): BOOL; stdcall;
  TSetupEnumInfSections = function(InfHandle: HINF; Index: UINT;
    Buffer: PTSTR; Size: UINT; SizeNeeded: PUINT): BOOL; stdcall;

  TSetupVerifyInfFileA = function(InfName: PAnsiChar; AltPlatformInfo: PSPAltPlatformInfo;
    var InfSignerInfo: TSPInfSignerInfoA): BOOL; stdcall;
  TSetupVerifyInfFileW = function(InfName: PWideChar; AltPlatformInfo: PSPAltPlatformInfo;
    var InfSignerInfo: TSPInfSignerInfoW): BOOL; stdcall;
  TSetupVerifyInfFile = function(InfName: PTSTR; AltPlatformInfo: PSPAltPlatformInfo;
    var InfSignerInfo: TSPInfSignerInfo): BOOL; stdcall;

  TSetupDiGetCustomDevicePropertyA = function(DeviceInfoSet: HDEVINFO;
    const DeviceInfoData: TSPDevInfoData; CustomPropertyName: PAnsiChar;
    Flags: DWORD; PropertyRegDataType: PDWORD; PropertyBuffer: PBYTE;
    PropertyBufferSize: DWORD; RequiredSize: PDWORD): BOOL; stdcall;
  TSetupDiGetCustomDevicePropertyW = function(DeviceInfoSet: HDEVINFO;
    const DeviceInfoData: TSPDevInfoData; CustomPropertyName: PWideChar;
    Flags: DWORD; PropertyRegDataType: PDWORD; PropertyBuffer: PBYTE;
    PropertyBufferSize: DWORD; RequiredSize: PDWORD): BOOL; stdcall;
  TSetupDiGetCustomDeviceProperty = function(DeviceInfoSet: HDEVINFO;
    const DeviceInfoData: TSPDevInfoData; CustomPropertyName: PTSTR;
    Flags: DWORD; PropertyRegDataType: PDWORD; PropertyBuffer: PBYTE;
    PropertyBufferSize: DWORD; RequiredSize: PDWORD): BOOL; stdcall;
  {$ENDIF WINXP_UP}

var
  {$IFDEF WINXP_UP}
  SetupGetFileQueueCount: TSetupGetFileQueueCount;
  SetupGetFileQueueFlags: TSetupGetFileQueueFlags;
  SetupSetFileQueueFlags: TSetupSetFileQueueFlags;
  {$ENDIF WINXP_UP}
  SetupGetInfInformationA: TSetupGetInfInformationA;
  SetupGetInfInformationW: TSetupGetInfInformationW;
  SetupGetInfInformation: TSetupGetInfInformation;
  SetupQueryInfFileInformationA: TSetupQueryInfFileInformationA;
  SetupQueryInfFileInformationW: TSetupQueryInfFileInformationW;
  SetupQueryInfFileInformation: TSetupQueryInfFileInformation;
  {$IFDEF WIN2000_UP}
  SetupQueryInfOriginalFileInformationA: TSetupQueryInfOriginalFileInformationA;
  SetupQueryInfOriginalFileInformationW: TSetupQueryInfOriginalFileInformationW;
  SetupQueryInfOriginalFileInformation: TSetupQueryInfOriginalFileInformation;
  {$ENDIF WIN2000_UP}
  SetupQueryInfVersionInformationA: TSetupQueryInfVersionInformationA;
  SetupQueryInfVersionInformationW: TSetupQueryInfVersionInformationW;
  SetupQueryInfVersionInformation: TSetupQueryInfVersionInformation;
  SetupGetInfFileListA: TSetupGetInfFileListA;
  SetupGetInfFileListW: TSetupGetInfFileListW;
  SetupGetInfFileList: TSetupGetInfFileList;
  SetupOpenInfFileA: TSetupOpenInfFileA;
  SetupOpenInfFileW: TSetupOpenInfFileW;
  SetupOpenInfFile: TSetupOpenInfFile;
  SetupOpenMasterInf: TSetupOpenMasterInf;
  SetupOpenAppendInfFileA: TSetupOpenAppendInfFileA;
  SetupOpenAppendInfFileW: TSetupOpenAppendInfFileW;
  SetupOpenAppendInfFile: TSetupOpenAppendInfFile;
  SetupCloseInfFile: TSetupCloseInfFile;
  SetupFindFirstLineA: TSetupFindFirstLineA;
  SetupFindFirstLineW: TSetupFindFirstLineW;
  SetupFindFirstLine: TSetupFindFirstLine;
  SetupFindNextLine: TSetupFindNextLine;
  SetupFindNextMatchLineA: TSetupFindNextMatchLineA;
  SetupFindNextMatchLineW: TSetupFindNextMatchLineW;
  SetupFindNextMatchLine: TSetupFindNextMatchLine;
  SetupGetLineByIndexA: TSetupGetLineByIndexA;
  SetupGetLineByIndexW: TSetupGetLineByIndexW;
  SetupGetLineByIndex: TSetupGetLineByIndex;
  SetupGetLineCountA: TSetupGetLineCountA;
  SetupGetLineCountW: TSetupGetLineCountW;
  SetupGetLineCount: TSetupGetLineCount;
  SetupGetLineTextA: TSetupGetLineTextA;
  SetupGetLineTextW: TSetupGetLineTextW;
  SetupGetLineText: TSetupGetLineText;
  SetupGetFieldCount: TSetupGetFieldCount;
  SetupGetStringFieldA: TSetupGetStringFieldA;
  SetupGetStringFieldW: TSetupGetStringFieldW;
  SetupGetStringField: TSetupGetStringField;
  SetupGetIntField: TSetupGetIntField;
  SetupGetMultiSzFieldA: TSetupGetMultiSzFieldA;
  SetupGetMultiSzFieldW: TSetupGetMultiSzFieldW;
  SetupGetMultiSzField: TSetupGetMultiSzField;
  SetupGetBinaryField: TSetupGetBinaryField;
  SetupGetFileCompressionInfoA: TSetupGetFileCompressionInfoA;
  SetupGetFileCompressionInfoW: TSetupGetFileCompressionInfoW;
  SetupGetFileCompressionInfo: TSetupGetFileCompressionInfo;
  {$IFDEF WINXP_UP}
  SetupGetFileCompressionInfoExA: TSetupGetFileCompressionInfoExA;
  SetupGetFileCompressionInfoExW: TSetupGetFileCompressionInfoExW;
  SetupGetFileCompressionInfoEx: TSetupGetFileCompressionInfoEx;
  {$ENDIF WINXP_UP}
  SetupDecompressOrCopyFileA: TSetupDecompressOrCopyFileA;
  SetupDecompressOrCopyFileW: TSetupDecompressOrCopyFileW;
  SetupDecompressOrCopyFile: TSetupDecompressOrCopyFile;
  SetupGetSourceFileLocationA: TSetupGetSourceFileLocationA;
  SetupGetSourceFileLocationW: TSetupGetSourceFileLocationW;
  SetupGetSourceFileLocation: TSetupGetSourceFileLocation;
  SetupGetSourceFileSizeA: TSetupGetSourceFileSizeA;
  SetupGetSourceFileSizeW: TSetupGetSourceFileSizeW;
  SetupGetSourceFileSize: TSetupGetSourceFileSize;
  SetupGetTargetPathA: TSetupGetTargetPathA;
  SetupGetTargetPathW: TSetupGetTargetPathW;
  SetupGetTargetPath: TSetupGetTargetPath;
  SetupSetSourceListA: TSetupSetSourceListA;
  SetupSetSourceListW: TSetupSetSourceListW;
  SetupSetSourceList: TSetupSetSourceList;
  SetupCancelTemporarySourceList: TSetupCancelTemporarySourceList;
  SetupAddToSourceListA: TSetupAddToSourceListA;
  SetupAddToSourceListW: TSetupAddToSourceListW;
  SetupAddToSourceList: TSetupAddToSourceList;
  SetupRemoveFromSourceListA: TSetupRemoveFromSourceListA;
  SetupRemoveFromSourceListW: TSetupRemoveFromSourceListW;
  SetupRemoveFromSourceList: TSetupRemoveFromSourceList;
  SetupQuerySourceListA: TSetupQuerySourceListA;
  SetupQuerySourceListW: TSetupQuerySourceListW;
  SetupQuerySourceList: TSetupQuerySourceList;
  SetupFreeSourceListA: TSetupFreeSourceListA;
  SetupFreeSourceListW: TSetupFreeSourceListW;
  SetupFreeSourceList: TSetupFreeSourceList;
  SetupPromptForDiskA: TSetupPromptForDiskA;
  SetupPromptForDiskW: TSetupPromptForDiskW;
  SetupPromptForDisk: TSetupPromptForDisk;
  SetupCopyErrorA: TSetupCopyErrorA;
  SetupCopyErrorW: TSetupCopyErrorW;
  SetupCopyError: TSetupCopyError;
  SetupRenameErrorA: TSetupRenameErrorA;
  SetupRenameErrorW: TSetupRenameErrorW;
  SetupRenameError: TSetupRenameError;
  SetupDeleteErrorA: TSetupDeleteErrorA;
  SetupDeleteErrorW: TSetupDeleteErrorW;
  SetupDeleteError: TSetupDeleteError;
  {$IFDEF WIN2000_UP}
  SetupBackupErrorA: TSetupBackupErrorA;
  SetupBackupErrorW: TSetupBackupErrorW;
  SetupBackupError: TSetupBackupError;
  {$ENDIF WIN2000_UP}
  SetupSetDirectoryIdA: TSetupSetDirectoryIdA;
  SetupSetDirectoryIdW: TSetupSetDirectoryIdW;
  SetupSetDirectoryId: TSetupSetDirectoryId;
  SetupSetDirectoryIdExA: TSetupSetDirectoryIdExA;
  SetupSetDirectoryIdExW: TSetupSetDirectoryIdExW;
  SetupSetDirectoryIdEx: TSetupSetDirectoryIdEx;
  SetupGetSourceInfoA: TSetupGetSourceInfoA;
  SetupGetSourceInfoW: TSetupGetSourceInfoW;
  SetupGetSourceInfo: TSetupGetSourceInfo;
  SetupInstallFileA: TSetupInstallFileA;
  SetupInstallFileW: TSetupInstallFileW;
  SetupInstallFile: TSetupInstallFile;
  SetupInstallFileExA: TSetupInstallFileExA;
  SetupInstallFileExW: TSetupInstallFileExW;
  SetupInstallFileEx: TSetupInstallFileEx;
  SetupOpenFileQueue: TSetupOpenFileQueue;
  SetupCloseFileQueue: TSetupCloseFileQueue;
  {$IFDEF WIN2000_UP}
  SetupSetFileQueueAlternatePlatformA: TSetupSetFileQueueAlternatePlatformA;
  SetupSetFileQueueAlternatePlatformW: TSetupSetFileQueueAlternatePlatformW;
  SetupSetFileQueueAlternatePlatform: TSetupSetFileQueueAlternatePlatform;
  {$ENDIF WIN2000_UP}
  SetupSetPlatformPathOverrideA: TSetupSetPlatformPathOverrideA;
  SetupSetPlatformPathOverrideW: TSetupSetPlatformPathOverrideW;
  SetupSetPlatformPathOverride: TSetupSetPlatformPathOverride;
  SetupQueueCopyA: TSetupQueueCopyA;
  SetupQueueCopyW: TSetupQueueCopyW;
  SetupQueueCopy: TSetupQueueCopy;
  {$IFDEF WIN2000_UP}
  SetupQueueCopyIndirectA: TSetupQueueCopyIndirectA;
  SetupQueueCopyIndirectW: TSetupQueueCopyIndirectW;
  SetupQueueCopyIndirect: TSetupQueueCopyIndirect;
  {$ENDIF WIN2000_UP}
  SetupQueueDefaultCopyA: TSetupQueueDefaultCopyA;
  SetupQueueDefaultCopyW: TSetupQueueDefaultCopyW;
  SetupQueueDefaultCopy: TSetupQueueDefaultCopy;
  SetupQueueCopySectionA: TSetupQueueCopySectionA;
  SetupQueueCopySectionW: TSetupQueueCopySectionW;
  SetupQueueCopySection: TSetupQueueCopySection;
  SetupQueueDeleteA: TSetupQueueDeleteA;
  SetupQueueDeleteW: TSetupQueueDeleteW;
  SetupQueueDelete: TSetupQueueDelete;
  SetupQueueDeleteSectionA: TSetupQueueDeleteSectionA;
  SetupQueueDeleteSectionW: TSetupQueueDeleteSectionW;
  SetupQueueDeleteSection: TSetupQueueDeleteSection;
  SetupQueueRenameA: TSetupQueueRenameA;
  SetupQueueRenameW: TSetupQueueRenameW;
  SetupQueueRename: TSetupQueueRename;
  SetupQueueRenameSectionA: TSetupQueueRenameSectionA;
  SetupQueueRenameSectionW: TSetupQueueRenameSectionW;
  SetupQueueRenameSection: TSetupQueueRenameSection;
  SetupCommitFileQueueA: TSetupCommitFileQueueA;
  SetupCommitFileQueueW: TSetupCommitFileQueueW;
  SetupCommitFileQueue: TSetupCommitFileQueue;
  SetupScanFileQueueA: TSetupScanFileQueueA;
  SetupScanFileQueueW: TSetupScanFileQueueW;
  SetupScanFileQueue: TSetupScanFileQueue;
  SetupCopyOEMInfA: TSetupCopyOEMInfA;
  SetupCopyOEMInfW: TSetupCopyOEMInfW;
  SetupCopyOEMInf: TSetupCopyOEMInf;
  {$IFDEF WINXP_UP}
  SetupUninstallOEMInfA: TSetupUninstallOEMInfA;
  SetupUninstallOEMInfW: TSetupUninstallOEMInfW;
  SetupUninstallOEMInf: TSetupUninstallOEMInf;
  SetupUninstallNewlyCopiedInfs: TSetupUninstallNewlyCopiedInfs;
  {$ENDIF WINXP_UP}
  SetupCreateDiskSpaceListA: TSetupCreateDiskSpaceListA;
  SetupCreateDiskSpaceListW: TSetupCreateDiskSpaceListW;
  SetupCreateDiskSpaceList: TSetupCreateDiskSpaceList;
  SetupDuplicateDiskSpaceListA: TSetupDuplicateDiskSpaceListA;
  SetupDuplicateDiskSpaceListW: TSetupDuplicateDiskSpaceListW;
  SetupDuplicateDiskSpaceList: TSetupDuplicateDiskSpaceList;
  SetupDestroyDiskSpaceList: TSetupDestroyDiskSpaceList;
  SetupQueryDrivesInDiskSpaceListA: TSetupQueryDrivesInDiskSpaceListA;
  SetupQueryDrivesInDiskSpaceListW: TSetupQueryDrivesInDiskSpaceListW;
  SetupQueryDrivesInDiskSpaceList: TSetupQueryDrivesInDiskSpaceList;
  SetupQuerySpaceRequiredOnDriveA: TSetupQuerySpaceRequiredOnDriveA;
  SetupQuerySpaceRequiredOnDriveW: TSetupQuerySpaceRequiredOnDriveW;
  SetupQuerySpaceRequiredOnDrive: TSetupQuerySpaceRequiredOnDrive;
  SetupAdjustDiskSpaceListA: TSetupAdjustDiskSpaceListA;
  SetupAdjustDiskSpaceListW: TSetupAdjustDiskSpaceListW;
  SetupAdjustDiskSpaceList: TSetupAdjustDiskSpaceList;
  SetupAddToDiskSpaceListA: TSetupAddToDiskSpaceListA;
  SetupAddToDiskSpaceListW: TSetupAddToDiskSpaceListW;
  SetupAddToDiskSpaceList: TSetupAddToDiskSpaceList;
  SetupAddSectionToDiskSpaceListA: TSetupAddSectionToDiskSpaceListA;
  SetupAddSectionToDiskSpaceListW: TSetupAddSectionToDiskSpaceListW;
  SetupAddSectionToDiskSpaceList: TSetupAddSectionToDiskSpaceList;
  SetupAddInstallSectionToDiskSpaceListA: TSetupAddInstallSectionToDiskSpaceListA;
  SetupAddInstallSectionToDiskSpaceListW: TSetupAddInstallSectionToDiskSpaceListW;
  SetupAddInstallSectionToDiskSpaceList: TSetupAddInstallSectionToDiskSpaceList;
  SetupRemoveFromDiskSpaceListA: TSetupRemoveFromDiskSpaceListA;
  SetupRemoveFromDiskSpaceListW: TSetupRemoveFromDiskSpaceListW;
  SetupRemoveFromDiskSpaceList: TSetupRemoveFromDiskSpaceList;
  SetupRemoveSectionFromDiskSpaceListA: TSetupRemoveSectionFromDiskSpaceListA;
  SetupRemoveSectionFromDiskSpaceListW: TSetupRemoveSectionFromDiskSpaceListW;
  SetupRemoveSectionFromDiskSpaceList: TSetupRemoveSectionFromDiskSpaceList;
  SetupRemoveInstallSectionFromDiskSpaceListA: TSetupRemoveInstallSectionFromDiskSpaceListA;
  SetupRemoveInstallSectionFromDiskSpaceListW: TSetupRemoveInstallSectionFromDiskSpaceListW;
  SetupRemoveInstallSectionFromDiskSpaceList: TSetupRemoveInstallSectionFromDiskSpaceList;
  SetupIterateCabinetA: TSetupIterateCabinetA;
  SetupIterateCabinetW: TSetupIterateCabinetW;
  SetupIterateCabinet: TSetupIterateCabinet;
  SetupPromptReboot: TSetupPromptReboot;
  SetupInitDefaultQueueCallback: TSetupInitDefaultQueueCallback;
  SetupInitDefaultQueueCallbackEx: TSetupInitDefaultQueueCallbackEx;
  SetupTermDefaultQueueCallback: TSetupTermDefaultQueueCallback;
  SetupDefaultQueueCallbackA: TSetupDefaultQueueCallbackA;
  SetupDefaultQueueCallbackW: TSetupDefaultQueueCallbackW;
  SetupDefaultQueueCallback: TSetupDefaultQueueCallback;
  SetupInstallFromInfSectionA: TSetupInstallFromInfSectionA;
  SetupInstallFromInfSectionW: TSetupInstallFromInfSectionW;
  SetupInstallFromInfSection: TSetupInstallFromInfSection;
  SetupInstallFilesFromInfSectionA: TSetupInstallFilesFromInfSectionA;
  SetupInstallFilesFromInfSectionW: TSetupInstallFilesFromInfSectionW;
  SetupInstallFilesFromInfSection: TSetupInstallFilesFromInfSection;
  SetupInstallServicesFromInfSectionA: TSetupInstallServicesFromInfSectionA;
  SetupInstallServicesFromInfSectionW: TSetupInstallServicesFromInfSectionW;
  SetupInstallServicesFromInfSection: TSetupInstallServicesFromInfSection;
  SetupInstallServicesFromInfSectionExA: TSetupInstallServicesFromInfSectionExA;
  SetupInstallServicesFromInfSectionExW: TSetupInstallServicesFromInfSectionExW;
  SetupInstallServicesFromInfSectionEx: TSetupInstallServicesFromInfSectionEx;
  {$IFDEF WINXP_UP}
  InstallHinfSectionA: TInstallHinfSectionA;
  InstallHinfSectionW: TInstallHinfSectionW;
  InstallHinfSection: TInstallHinfSection;
  {$ENDIF WINXP_UP}
  SetupInitializeFileLogA: TSetupInitializeFileLogA;
  SetupInitializeFileLogW: TSetupInitializeFileLogW;
  SetupInitializeFileLog: TSetupInitializeFileLog;
  SetupTerminateFileLog: TSetupTerminateFileLog;
  SetupLogFileA: TSetupLogFileA;
  SetupLogFileW: TSetupLogFileW;
  SetupLogFile: TSetupLogFile;
  SetupRemoveFileLogEntryA: TSetupRemoveFileLogEntryA;
  SetupRemoveFileLogEntryW: TSetupRemoveFileLogEntryW;
  SetupRemoveFileLogEntry: TSetupRemoveFileLogEntry;
  SetupQueryFileLogA: TSetupQueryFileLogA;
  SetupQueryFileLogW: TSetupQueryFileLogW;
  SetupQueryFileLog: TSetupQueryFileLog;
  SetupOpenLog: TSetupOpenLog;
  SetupLogErrorA: TSetupLogErrorA;
  SetupLogErrorW: TSetupLogErrorW;
  SetupLogError: TSetupLogError;
  SetupCloseLog: TSetupCloseLog;
  {$IFDEF WIN2000_UP}
  SetupGetBackupInformationA: TSetupGetBackupInformationA;
  SetupGetBackupInformationW: TSetupGetBackupInformationW;
  SetupGetBackupInformation: TSetupGetBackupInformation;
  {$ENDIF WIN2000_UP}
  {$IFDEF WINXP_UP}
  SetupPrepareQueueForRestoreA: TSetupPrepareQueueForRestoreA;
  SetupPrepareQueueForRestoreW: TSetupPrepareQueueForRestoreW;
  SetupPrepareQueueForRestore: TSetupPrepareQueueForRestore;
  SetupSetNonInteractiveMode: TSetupSetNonInteractiveMode;
  SetupGetNonInteractiveMode: TSetupGetNonInteractiveMode;
  {$ENDIF WINXP_UP}
  SetupDiCreateDeviceInfoList: TSetupDiCreateDeviceInfoList;
  SetupDiCreateDeviceInfoListExA: TSetupDiCreateDeviceInfoListExA;
  SetupDiCreateDeviceInfoListExW: TSetupDiCreateDeviceInfoListExW;
  SetupDiCreateDeviceInfoListEx: TSetupDiCreateDeviceInfoListEx;
  SetupDiGetDeviceInfoListClass: TSetupDiGetDeviceInfoListClass;
  SetupDiGetDeviceInfoListDetailA: TSetupDiGetDeviceInfoListDetailA;
  SetupDiGetDeviceInfoListDetailW: TSetupDiGetDeviceInfoListDetailW;
  SetupDiGetDeviceInfoListDetail: TSetupDiGetDeviceInfoListDetail;
  SetupDiCreateDeviceInfoA: TSetupDiCreateDeviceInfoA;
  SetupDiCreateDeviceInfoW: TSetupDiCreateDeviceInfoW;
  SetupDiCreateDeviceInfo: TSetupDiCreateDeviceInfo;
  SetupDiOpenDeviceInfoA: TSetupDiOpenDeviceInfoA;
  SetupDiOpenDeviceInfoW: TSetupDiOpenDeviceInfoW;
  SetupDiOpenDeviceInfo: TSetupDiOpenDeviceInfo;
  SetupDiGetDeviceInstanceIdA: TSetupDiGetDeviceInstanceIdA;
  SetupDiGetDeviceInstanceIdW: TSetupDiGetDeviceInstanceIdW;
  SetupDiGetDeviceInstanceId: TSetupDiGetDeviceInstanceId;
  SetupDiDeleteDeviceInfo: TSetupDiDeleteDeviceInfo;
  SetupDiEnumDeviceInfo: TSetupDiEnumDeviceInfo;
  SetupDiDestroyDeviceInfoList: TSetupDiDestroyDeviceInfoList;
  SetupDiEnumDeviceInterfaces: TSetupDiEnumDeviceInterfaces;
  SetupDiEnumInterfaceDevice: TSetupDiEnumDeviceInterfaces;
  SetupDiCreateDeviceInterfaceA: TSetupDiCreateDeviceInterfaceA;
  SetupDiCreateInterfaceDeviceA: TSetupDiCreateDeviceInterfaceA;
  SetupDiCreateDeviceInterfaceW: TSetupDiCreateDeviceInterfaceW;
  SetupDiCreateInterfaceDeviceW: TSetupDiCreateDeviceInterfaceW;
  SetupDiCreateDeviceInterface: TSetupDiCreateDeviceInterface;
  SetupDiCreateInterfaceDevice: TSetupDiCreateInterfaceDevice;
  SetupDiOpenDeviceInterfaceA: TSetupDiOpenDeviceInterfaceA;
  SetupDiOpenInterfaceDeviceA: TSetupDiOpenDeviceInterfaceA;
  SetupDiOpenDeviceInterfaceW: TSetupDiOpenDeviceInterfaceW;
  SetupDiOpenInterfaceDeviceW: TSetupDiOpenDeviceInterfaceW;
  SetupDiOpenDeviceInterface: TSetupDiOpenDeviceInterface;
  SetupDiOpenInterfaceDevice: TSetupDiOpenInterfaceDevice;
  SetupDiGetDeviceInterfaceAlias: TSetupDiGetDeviceInterfaceAlias;
  SetupDiGetInterfaceDeviceAlias: TSetupDiGetDeviceInterfaceAlias;
  SetupDiDeleteDeviceInterfaceData: TSetupDiDeleteDeviceInterfaceData;
  SetupDiDeleteInterfaceDeviceData: TSetupDiDeleteDeviceInterfaceData;
  SetupDiRemoveDeviceInterface: TSetupDiRemoveDeviceInterface;
  SetupDiRemoveInterfaceDevice: TSetupDiRemoveDeviceInterface;
  SetupDiGetDeviceInterfaceDetailA: TSetupDiGetDeviceInterfaceDetailA;
  SetupDiGetInterfaceDeviceDetailA: TSetupDiGetDeviceInterfaceDetailA;
  SetupDiGetDeviceInterfaceDetailW: TSetupDiGetDeviceInterfaceDetailW;
  SetupDiGetInterfaceDeviceDetailW: TSetupDiGetDeviceInterfaceDetailW;
  SetupDiGetDeviceInterfaceDetail: TSetupDiGetDeviceInterfaceDetail;
  SetupDiGetInterfaceDeviceDetail: TSetupDiGetInterfaceDeviceDetail;
  SetupDiInstallDeviceInterfaces: TSetupDiInstallDeviceInterfaces;
  SetupDiInstallInterfaceDevices: TSetupDiInstallDeviceInterfaces;
  {$IFDEF WINXP_UP}
  SetupDiSetDeviceInterfaceDefault: TSetupDiSetDeviceInterfaceDefault;
  {$ENDIF WINXP_UP}
  SetupDiRegisterDeviceInfo: TSetupDiRegisterDeviceInfo;
  SetupDiBuildDriverInfoList: TSetupDiBuildDriverInfoList;
  SetupDiCancelDriverInfoSearch: TSetupDiCancelDriverInfoSearch;
  SetupDiEnumDriverInfoA: TSetupDiEnumDriverInfoA;
  SetupDiEnumDriverInfoW: TSetupDiEnumDriverInfoW;
  SetupDiEnumDriverInfo: TSetupDiEnumDriverInfo;
  SetupDiGetSelectedDriverA: TSetupDiGetSelectedDriverA;
  SetupDiGetSelectedDriverW: TSetupDiGetSelectedDriverW;
  SetupDiGetSelectedDriver: TSetupDiGetSelectedDriver;
  SetupDiSetSelectedDriverA: TSetupDiSetSelectedDriverA;
  SetupDiSetSelectedDriverW: TSetupDiSetSelectedDriverW;
  SetupDiSetSelectedDriver: TSetupDiSetSelectedDriver;
  SetupDiGetDriverInfoDetailA: TSetupDiGetDriverInfoDetailA;
  SetupDiGetDriverInfoDetailW: TSetupDiGetDriverInfoDetailW;
  SetupDiGetDriverInfoDetail: TSetupDiGetDriverInfoDetail;
  SetupDiDestroyDriverInfoList: TSetupDiDestroyDriverInfoList;
  SetupDiGetClassDevsA: TSetupDiGetClassDevsA;
  SetupDiGetClassDevsW: TSetupDiGetClassDevsW;
  SetupDiGetClassDevs: TSetupDiGetClassDevs;
  SetupDiGetClassDevsExA: TSetupDiGetClassDevsExA;
  SetupDiGetClassDevsExW: TSetupDiGetClassDevsExW;
  SetupDiGetClassDevsEx: TSetupDiGetClassDevsEx;
  SetupDiGetINFClassA: TSetupDiGetINFClassA;
  SetupDiGetINFClassW: TSetupDiGetINFClassW;
  SetupDiGetINFClass: TSetupDiGetINFClass;
  SetupDiBuildClassInfoList: TSetupDiBuildClassInfoList;
  SetupDiBuildClassInfoListExA: TSetupDiBuildClassInfoListExA;
  SetupDiBuildClassInfoListExW: TSetupDiBuildClassInfoListExW;
  SetupDiBuildClassInfoListEx: TSetupDiBuildClassInfoListEx;
  SetupDiGetClassDescriptionA: TSetupDiGetClassDescriptionA;
  SetupDiGetClassDescriptionW: TSetupDiGetClassDescriptionW;
  SetupDiGetClassDescription: TSetupDiGetClassDescription;
  SetupDiGetClassDescriptionExA: TSetupDiGetClassDescriptionExA;
  SetupDiGetClassDescriptionExW: TSetupDiGetClassDescriptionExW;
  SetupDiGetClassDescriptionEx: TSetupDiGetClassDescriptionEx;
  SetupDiCallClassInstaller: TSetupDiCallClassInstaller;
  SetupDiSelectDevice: TSetupDiSelectDevice;
  SetupDiSelectBestCompatDrv: TSetupDiSelectBestCompatDrv;
  SetupDiInstallDevice: TSetupDiInstallDevice;
  SetupDiInstallDriverFiles: TSetupDiInstallDriverFiles;
  SetupDiRegisterCoDeviceInstallers: TSetupDiRegisterCoDeviceInstallers;
  SetupDiRemoveDevice: TSetupDiRemoveDevice;
  SetupDiUnremoveDevice: TSetupDiUnremoveDevice;
  SetupDiMoveDuplicateDevice: TSetupDiMoveDuplicateDevice;
  SetupDiChangeState: TSetupDiChangeState;
  SetupDiInstallClassA: TSetupDiInstallClassA;
  SetupDiInstallClassW: TSetupDiInstallClassW;
  SetupDiInstallClass: TSetupDiInstallClass;
  SetupDiInstallClassExA: TSetupDiInstallClassExA;
  SetupDiInstallClassExW: TSetupDiInstallClassExW;
  SetupDiInstallClassEx: TSetupDiInstallClassEx;
  SetupDiOpenClassRegKey: TSetupDiOpenClassRegKey;
  SetupDiOpenClassRegKeyExA: TSetupDiOpenClassRegKeyExA;
  SetupDiOpenClassRegKeyExW: TSetupDiOpenClassRegKeyExW;
  SetupDiOpenClassRegKeyEx: TSetupDiOpenClassRegKeyEx;
  SetupDiCreateDeviceInterfaceRegKeyA: TSetupDiCreateDeviceInterfaceRegKeyA;
  SetupDiCreateInterfaceDeviceRegKeyA: TSetupDiCreateDeviceInterfaceRegKeyA;
  SetupDiCreateDeviceInterfaceRegKeyW: TSetupDiCreateDeviceInterfaceRegKeyW;
  SetupDiCreateInterfaceDeviceRegKeyW: TSetupDiCreateDeviceInterfaceRegKeyW;
  SetupDiCreateDeviceInterfaceRegKey: TSetupDiCreateDeviceInterfaceRegKey;
  SetupDiCreateInterfaceDeviceRegKey: TSetupDiCreateInterfaceDeviceRegKey;
  SetupDiOpenDeviceInterfaceRegKey: TSetupDiOpenDeviceInterfaceRegKey;
  SetupDiOpenInterfaceDeviceRegKey: TSetupDiOpenDeviceInterfaceRegKey;
  SetupDiDeleteDeviceInterfaceRegKey: TSetupDiDeleteDeviceInterfaceRegKey;
  SetupDiDeleteInterfaceDeviceRegKey: TSetupDiDeleteDeviceInterfaceRegKey;
  SetupDiCreateDevRegKeyA: TSetupDiCreateDevRegKeyA;
  SetupDiCreateDevRegKeyW: TSetupDiCreateDevRegKeyW;
  SetupDiCreateDevRegKey: TSetupDiCreateDevRegKey;
  SetupDiOpenDevRegKey: TSetupDiOpenDevRegKey;
  SetupDiDeleteDevRegKey: TSetupDiDeleteDevRegKey;
  SetupDiGetHwProfileList: TSetupDiGetHwProfileList;
  SetupDiGetHwProfileListExA: TSetupDiGetHwProfileListExA;
  SetupDiGetHwProfileListExW: TSetupDiGetHwProfileListExW;
  SetupDiGetHwProfileListEx: TSetupDiGetHwProfileListEx;
  SetupDiGetDeviceRegistryPropertyA: TSetupDiGetDeviceRegistryPropertyA;
  SetupDiGetDeviceRegistryPropertyW: TSetupDiGetDeviceRegistryPropertyW;
  SetupDiGetDeviceRegistryProperty: TSetupDiGetDeviceRegistryProperty;
  {$IFDEF WINXP_UP}
  SetupDiGetClassRegistryPropertyA: TSetupDiGetClassRegistryPropertyA;
  SetupDiGetClassRegistryPropertyW: TSetupDiGetClassRegistryPropertyW;
  SetupDiGetClassRegistryProperty: TSetupDiGetClassRegistryProperty;
  {$ENDIF WINXP_UP}
  SetupDiSetDeviceRegistryPropertyA: TSetupDiSetDeviceRegistryPropertyA;
  SetupDiSetDeviceRegistryPropertyW: TSetupDiSetDeviceRegistryPropertyW;
  SetupDiSetDeviceRegistryProperty: TSetupDiSetDeviceRegistryProperty;
  {$IFDEF WINXP_UP}
  SetupDiSetClassRegistryPropertyA: TSetupDiSetClassRegistryPropertyA;
  SetupDiSetClassRegistryPropertyW: TSetupDiSetClassRegistryPropertyW;
  SetupDiSetClassRegistryProperty: TSetupDiSetClassRegistryProperty;
  {$ENDIF WINXP_UP}
  SetupDiGetDeviceInstallParamsA: TSetupDiGetDeviceInstallParamsA;
  SetupDiGetDeviceInstallParamsW: TSetupDiGetDeviceInstallParamsW;
  SetupDiGetDeviceInstallParams: TSetupDiGetDeviceInstallParams;
  SetupDiGetClassInstallParamsA: TSetupDiGetClassInstallParamsA;
  SetupDiGetClassInstallParamsW: TSetupDiGetClassInstallParamsW;
  SetupDiGetClassInstallParams: TSetupDiGetClassInstallParams;
  SetupDiSetDeviceInstallParamsA: TSetupDiSetDeviceInstallParamsA;
  SetupDiSetDeviceInstallParamsW: TSetupDiSetDeviceInstallParamsW;
  SetupDiSetDeviceInstallParams: TSetupDiSetDeviceInstallParams;
  SetupDiSetClassInstallParamsA: TSetupDiSetClassInstallParamsA;
  SetupDiSetClassInstallParamsW: TSetupDiSetClassInstallParamsW;
  SetupDiSetClassInstallParams: TSetupDiSetClassInstallParams;
  SetupDiGetDriverInstallParamsA: TSetupDiGetDriverInstallParamsA;
  SetupDiGetDriverInstallParamsW: TSetupDiGetDriverInstallParamsW;
  SetupDiGetDriverInstallParams: TSetupDiGetDriverInstallParams;
  SetupDiSetDriverInstallParamsA: TSetupDiSetDriverInstallParamsA;
  SetupDiSetDriverInstallParamsW: TSetupDiSetDriverInstallParamsW;
  SetupDiSetDriverInstallParams: TSetupDiSetDriverInstallParams;
  SetupDiLoadClassIcon: TSetupDiLoadClassIcon;
  SetupDiDrawMiniIcon: TSetupDiDrawMiniIcon;
  SetupDiGetClassBitmapIndex: TSetupDiGetClassBitmapIndex;
  SetupDiGetClassImageList: TSetupDiGetClassImageList;
  SetupDiGetClassImageListExA: TSetupDiGetClassImageListExA;
  SetupDiGetClassImageListExW: TSetupDiGetClassImageListExW;
  SetupDiGetClassImageListEx: TSetupDiGetClassImageListEx;
  SetupDiGetClassImageIndex: TSetupDiGetClassImageIndex;
  SetupDiDestroyClassImageList: TSetupDiDestroyClassImageList;
  SetupDiGetClassDevPropertySheetsA: TSetupDiGetClassDevPropertySheetsA;
  SetupDiGetClassDevPropertySheetsW: TSetupDiGetClassDevPropertySheetsW;
  SetupDiGetClassDevPropertySheets: TSetupDiGetClassDevPropertySheets;
  SetupDiAskForOEMDisk: TSetupDiAskForOEMDisk;
  SetupDiSelectOEMDrv: TSetupDiSelectOEMDrv;
  SetupDiClassNameFromGuidA: TSetupDiClassNameFromGuidA;
  SetupDiClassNameFromGuidW: TSetupDiClassNameFromGuidW;
  SetupDiClassNameFromGuid: TSetupDiClassNameFromGuid;
  SetupDiClassNameFromGuidExA: TSetupDiClassNameFromGuidExA;
  SetupDiClassNameFromGuidExW: TSetupDiClassNameFromGuidExW;
  SetupDiClassNameFromGuidEx: TSetupDiClassNameFromGuidEx;
  SetupDiClassGuidsFromNameA: TSetupDiClassGuidsFromNameA;
  SetupDiClassGuidsFromNameW: TSetupDiClassGuidsFromNameW;
  SetupDiClassGuidsFromName: TSetupDiClassGuidsFromName;
  SetupDiClassGuidsFromNameExA: TSetupDiClassGuidsFromNameExA;
  SetupDiClassGuidsFromNameExW: TSetupDiClassGuidsFromNameExW;
  SetupDiClassGuidsFromNameEx: TSetupDiClassGuidsFromNameEx;
  SetupDiGetHwProfileFriendlyNameA: TSetupDiGetHwProfileFriendlyNameA;
  SetupDiGetHwProfileFriendlyNameW: TSetupDiGetHwProfileFriendlyNameW;
  SetupDiGetHwProfileFriendlyName: TSetupDiGetHwProfileFriendlyName;
  SetupDiGetHwProfileFriendlyNameExA: TSetupDiGetHwProfileFriendlyNameExA;
  SetupDiGetHwProfileFriendlyNameExW: TSetupDiGetHwProfileFriendlyNameExW;
  SetupDiGetHwProfileFriendlyNameEx: TSetupDiGetHwProfileFriendlyNameEx;
  SetupDiGetWizardPage: TSetupDiGetWizardPage;
  SetupDiGetSelectedDevice: TSetupDiGetSelectedDevice;
  SetupDiSetSelectedDevice: TSetupDiSetSelectedDevice;
  SetupDiGetActualSectionToInstallA: TSetupDiGetActualSectionToInstallA;
  SetupDiGetActualSectionToInstallW: TSetupDiGetActualSectionToInstallW;
  SetupDiGetActualSectionToInstall: TSetupDiGetActualSectionToInstall;
  {$IFDEF WINXP_UP}
  SetupDiGetActualSectionToInstallExA: TSetupDiGetActualSectionToInstallExA;
  SetupDiGetActualSectionToInstallExW: TSetupDiGetActualSectionToInstallExW;
  SetupDiGetActualSectionToInstallEx: TSetupDiGetActualSectionToInstallEx;
  SetupEnumInfSectionsA: TSetupEnumInfSectionsA;
  SetupEnumInfSectionsW: TSetupEnumInfSectionsW;
  SetupEnumInfSections: TSetupEnumInfSections;
  SetupVerifyInfFileA: TSetupVerifyInfFileA;
  SetupVerifyInfFileW: TSetupVerifyInfFileW;
  SetupVerifyInfFile: TSetupVerifyInfFile;
  SetupDiGetCustomDevicePropertyA: TSetupDiGetCustomDevicePropertyA;
  SetupDiGetCustomDevicePropertyW: TSetupDiGetCustomDevicePropertyW;
  SetupDiGetCustomDeviceProperty: TSetupDiGetCustomDeviceProperty;
  {$ENDIF WINXP_UP}

{$ENDIF !SETUPAPI_LINKONREQUEST}

{$IFNDEF SETUPAPI_LINKONREQUEST}
type
  TModuleHandle = HINST;
{$ENDIF !SETUPAPI_LINKONREQUEST}

function IsSetupApiLoaded: Boolean;
function GetSetupApiModuleHandle: TModuleHandle;
function LoadSetupApi: Boolean;
procedure UnloadSetupApi;

implementation

const
  SetupApiModuleName = 'SetupApi.dll';
  {$IFDEF UNICODE}
  NameSuffix = 'W';
  {$ELSE}
  NameSuffix = 'A';
  {$ENDIF UNICODE}

{$IFDEF SETUPAPI_LINKONREQUEST}
var
  SetupApiLib: TModuleHandle = INVALID_MODULEHANDLE_VALUE;
  SetupApiLoadCount: Integer = 0;
{$ENDIF SETUPAPI_LINKONREQUEST}

function IsSetupApiLoaded: Boolean;
begin
  {$IFDEF SETUPAPI_LINKONREQUEST}
  Result := SetupApiLib <> INVALID_MODULEHANDLE_VALUE;
  {$ELSE}
  Result := True;
  {$ENDIF SETUPAPI_LINKONREQUEST}
end;

function GetSetupApiModuleHandle: TModuleHandle;
begin
  {$IFDEF SETUPAPI_LINKONREQUEST}
  Result := SetupApiLib;
  {$ELSE}
  Result := TModuleHandle(0);
  {$ENDIF SETUPAPI_LINKONREQUEST}
end;

function LoadSetupApi: Boolean;
begin
  {$IFDEF SETUPAPI_LINKONREQUEST}
  Result := True;
  Inc(SetupApiLoadCount);
  if SetupApiLoadCount > 1 then
    Exit;
  Result := ModuleLoader.LoadModule(SetupApiLib, SetupApiModuleName);
  if Result then
  begin
    {$IFDEF WINXP_UP}
    @SetupGetFileQueueCount := GetModuleSymbolEx(SetupApiLib, 'SetupGetFileQueueCount', Result);
    @SetupGetFileQueueFlags := GetModuleSymbolEx(SetupApiLib, 'SetupGetFileQueueFlags', Result);
    @SetupSetFileQueueFlags := GetModuleSymbolEx(SetupApiLib, 'SetupSetFileQueueFlags', Result);
    {$ENDIF WINXP_UP}
    @SetupGetInfInformationA := GetModuleSymbolEx(SetupApiLib, 'SetupGetInfInformationA', Result);
    @SetupGetInfInformationW := GetModuleSymbolEx(SetupApiLib, 'SetupGetInfInformationW', Result);
    @SetupGetInfInformation := GetModuleSymbolEx(SetupApiLib, 'SetupGetInfInformation' + NameSuffix, Result);
    @SetupQueryInfFileInformationA := GetModuleSymbolEx(SetupApiLib, 'SetupQueryInfFileInformationA', Result);
    @SetupQueryInfFileInformationW := GetModuleSymbolEx(SetupApiLib, 'SetupQueryInfFileInformationW', Result);
    @SetupQueryInfFileInformation := GetModuleSymbolEx(SetupApiLib, 'SetupQueryInfFileInformation' + NameSuffix, Result);
    {$IFDEF WIN2000_UP}
    @SetupQueryInfOriginalFileInformationA := GetModuleSymbolEx(SetupApiLib, 'SetupQueryInfOriginalFileInformationA', Result);
    @SetupQueryInfOriginalFileInformationW := GetModuleSymbolEx(SetupApiLib, 'SetupQueryInfOriginalFileInformationW', Result);
    @SetupQueryInfOriginalFileInformation := GetModuleSymbolEx(SetupApiLib, 'SetupQueryInfOriginalFileInformation' + NameSuffix, Result);
    {$ENDIF WIN2000_UP}
    @SetupQueryInfVersionInformationA := GetModuleSymbolEx(SetupApiLib, 'SetupQueryInfVersionInformationA', Result);
    @SetupQueryInfVersionInformationW := GetModuleSymbolEx(SetupApiLib, 'SetupQueryInfVersionInformationW', Result);
    @SetupQueryInfVersionInformation := GetModuleSymbolEx(SetupApiLib, 'SetupQueryInfVersionInformation' + NameSuffix, Result);
    @SetupGetInfFileListA := GetModuleSymbolEx(SetupApiLib, 'SetupGetInfFileListA', Result);
    @SetupGetInfFileListW := GetModuleSymbolEx(SetupApiLib, 'SetupGetInfFileListW', Result);
    @SetupGetInfFileList := GetModuleSymbolEx(SetupApiLib, 'SetupGetInfFileList' + NameSuffix, Result);
    @SetupOpenInfFileA := GetModuleSymbolEx(SetupApiLib, 'SetupOpenInfFileA', Result);
    @SetupOpenInfFileW := GetModuleSymbolEx(SetupApiLib, 'SetupOpenInfFileW', Result);
    @SetupOpenInfFile := GetModuleSymbolEx(SetupApiLib, 'SetupOpenInfFile' + NameSuffix, Result);
    @SetupOpenMasterInf := GetModuleSymbolEx(SetupApiLib, 'SetupOpenMasterInf', Result);
    @SetupOpenAppendInfFileA := GetModuleSymbolEx(SetupApiLib, 'SetupOpenAppendInfFileA', Result);
    @SetupOpenAppendInfFileW := GetModuleSymbolEx(SetupApiLib, 'SetupOpenAppendInfFileW', Result);
    @SetupOpenAppendInfFile := GetModuleSymbolEx(SetupApiLib, 'SetupOpenAppendInfFile' + NameSuffix, Result);
    @SetupCloseInfFile := GetModuleSymbolEx(SetupApiLib, 'SetupCloseInfFile', Result);
    @SetupFindFirstLineA := GetModuleSymbolEx(SetupApiLib, 'SetupFindFirstLineA', Result);
    @SetupFindFirstLineW := GetModuleSymbolEx(SetupApiLib, 'SetupFindFirstLineW', Result);
    @SetupFindFirstLine := GetModuleSymbolEx(SetupApiLib, 'SetupFindFirstLine' + NameSuffix, Result);
    @SetupFindNextLine := GetModuleSymbolEx(SetupApiLib, 'SetupFindNextLine', Result);
    @SetupFindNextMatchLineA := GetModuleSymbolEx(SetupApiLib, 'SetupFindNextMatchLineA', Result);
    @SetupFindNextMatchLineW := GetModuleSymbolEx(SetupApiLib, 'SetupFindNextMatchLineW', Result);
    @SetupFindNextMatchLine := GetModuleSymbolEx(SetupApiLib, 'SetupFindNextMatchLine' + NameSuffix, Result);
    @SetupGetLineByIndexA := GetModuleSymbolEx(SetupApiLib, 'SetupGetLineByIndexA', Result);
    @SetupGetLineByIndexW := GetModuleSymbolEx(SetupApiLib, 'SetupGetLineByIndexW', Result);
    @SetupGetLineByIndex := GetModuleSymbolEx(SetupApiLib, 'SetupGetLineByIndex' + NameSuffix, Result);
    @SetupGetLineCountA := GetModuleSymbolEx(SetupApiLib, 'SetupGetLineCountA', Result);
    @SetupGetLineCountW := GetModuleSymbolEx(SetupApiLib, 'SetupGetLineCountW', Result);
    @SetupGetLineCount := GetModuleSymbolEx(SetupApiLib, 'SetupGetLineCount' + NameSuffix, Result);
    @SetupGetLineTextA := GetModuleSymbolEx(SetupApiLib, 'SetupGetLineTextA', Result);
    @SetupGetLineTextW := GetModuleSymbolEx(SetupApiLib, 'SetupGetLineTextW', Result);
    @SetupGetLineText := GetModuleSymbolEx(SetupApiLib, 'SetupGetLineText' + NameSuffix, Result);
    @SetupGetFieldCount := GetModuleSymbolEx(SetupApiLib, 'SetupGetFieldCount', Result);
    @SetupGetStringFieldA := GetModuleSymbolEx(SetupApiLib, 'SetupGetStringFieldA', Result);
    @SetupGetStringFieldW := GetModuleSymbolEx(SetupApiLib, 'SetupGetStringFieldW', Result);
    @SetupGetStringField := GetModuleSymbolEx(SetupApiLib, 'SetupGetStringField' + NameSuffix, Result);
    @SetupGetIntField := GetModuleSymbolEx(SetupApiLib, 'SetupGetIntField', Result);
    @SetupGetMultiSzFieldA := GetModuleSymbolEx(SetupApiLib, 'SetupGetMultiSzFieldA', Result);
    @SetupGetMultiSzFieldW := GetModuleSymbolEx(SetupApiLib, 'SetupGetMultiSzFieldW', Result);
    @SetupGetMultiSzField := GetModuleSymbolEx(SetupApiLib, 'SetupGetMultiSzField' + NameSuffix, Result);
    @SetupGetBinaryField := GetModuleSymbolEx(SetupApiLib, 'SetupGetBinaryField', Result);
    @SetupGetFileCompressionInfoA := GetModuleSymbolEx(SetupApiLib, 'SetupGetFileCompressionInfoA', Result);
    @SetupGetFileCompressionInfoW := GetModuleSymbolEx(SetupApiLib, 'SetupGetFileCompressionInfoW', Result);
    @SetupGetFileCompressionInfo := GetModuleSymbolEx(SetupApiLib, 'SetupGetFileCompressionInfo' + NameSuffix, Result);
    {$IFDEF WINXP_UP}
    @SetupGetFileCompressionInfoExA := GetModuleSymbolEx(SetupApiLib, 'SetupGetFileCompressionInfoExA', Result);
    @SetupGetFileCompressionInfoExW := GetModuleSymbolEx(SetupApiLib, 'SetupGetFileCompressionInfoExW', Result);
    @SetupGetFileCompressionInfoEx := GetModuleSymbolEx(SetupApiLib, 'SetupGetFileCompressionInfoEx' + NameSuffix, Result);
    {$ENDIF WINXP_UP}
    @SetupDecompressOrCopyFileA := GetModuleSymbolEx(SetupApiLib, 'SetupDecompressOrCopyFileA', Result);
    @SetupDecompressOrCopyFileW := GetModuleSymbolEx(SetupApiLib, 'SetupDecompressOrCopyFileW', Result);
    @SetupDecompressOrCopyFile := GetModuleSymbolEx(SetupApiLib, 'SetupDecompressOrCopyFile' + NameSuffix, Result);
    @SetupGetSourceFileLocationA := GetModuleSymbolEx(SetupApiLib, 'SetupGetSourceFileLocationA', Result);
    @SetupGetSourceFileLocationW := GetModuleSymbolEx(SetupApiLib, 'SetupGetSourceFileLocationW', Result);
    @SetupGetSourceFileLocation := GetModuleSymbolEx(SetupApiLib, 'SetupGetSourceFileLocation' + NameSuffix, Result);
    @SetupGetSourceFileSizeA := GetModuleSymbolEx(SetupApiLib, 'SetupGetSourceFileSizeA', Result);
    @SetupGetSourceFileSizeW := GetModuleSymbolEx(SetupApiLib, 'SetupGetSourceFileSizeW', Result);
    @SetupGetSourceFileSize := GetModuleSymbolEx(SetupApiLib, 'SetupGetSourceFileSize' + NameSuffix, Result);
    @SetupGetTargetPathA := GetModuleSymbolEx(SetupApiLib, 'SetupGetTargetPathA', Result);
    @SetupGetTargetPathW := GetModuleSymbolEx(SetupApiLib, 'SetupGetTargetPathW', Result);
    @SetupGetTargetPath := GetModuleSymbolEx(SetupApiLib, 'SetupGetTargetPath' + NameSuffix, Result);
    @SetupSetSourceListA := GetModuleSymbolEx(SetupApiLib, 'SetupSetSourceListA', Result);
    @SetupSetSourceListW := GetModuleSymbolEx(SetupApiLib, 'SetupSetSourceListW', Result);
    @SetupSetSourceList := GetModuleSymbolEx(SetupApiLib, 'SetupSetSourceList' + NameSuffix, Result);
    @SetupCancelTemporarySourceList := GetModuleSymbolEx(SetupApiLib, 'SetupCancelTemporarySourceList', Result);
    @SetupAddToSourceListA := GetModuleSymbolEx(SetupApiLib, 'SetupAddToSourceListA', Result);
    @SetupAddToSourceListW := GetModuleSymbolEx(SetupApiLib, 'SetupAddToSourceListW', Result);
    @SetupAddToSourceList := GetModuleSymbolEx(SetupApiLib, 'SetupAddToSourceList' + NameSuffix, Result);
    @SetupRemoveFromSourceListA := GetModuleSymbolEx(SetupApiLib, 'SetupRemoveFromSourceListA', Result);
    @SetupRemoveFromSourceListW := GetModuleSymbolEx(SetupApiLib, 'SetupRemoveFromSourceListW', Result);
    @SetupRemoveFromSourceList := GetModuleSymbolEx(SetupApiLib, 'SetupRemoveFromSourceList' + NameSuffix, Result);
    @SetupQuerySourceListA := GetModuleSymbolEx(SetupApiLib, 'SetupQuerySourceListA', Result);
    @SetupQuerySourceListW := GetModuleSymbolEx(SetupApiLib, 'SetupQuerySourceListW', Result);
    @SetupQuerySourceList := GetModuleSymbolEx(SetupApiLib, 'SetupQuerySourceList' + NameSuffix, Result);
    @SetupFreeSourceListA := GetModuleSymbolEx(SetupApiLib, 'SetupFreeSourceListA', Result);
    @SetupFreeSourceListW := GetModuleSymbolEx(SetupApiLib, 'SetupFreeSourceListW', Result);
    @SetupFreeSourceList := GetModuleSymbolEx(SetupApiLib, 'SetupFreeSourceList' + NameSuffix, Result);
    @SetupPromptForDiskA := GetModuleSymbolEx(SetupApiLib, 'SetupPromptForDiskA', Result);
    @SetupPromptForDiskW := GetModuleSymbolEx(SetupApiLib, 'SetupPromptForDiskW', Result);
    @SetupPromptForDisk := GetModuleSymbolEx(SetupApiLib, 'SetupPromptForDisk' + NameSuffix, Result);
    @SetupCopyErrorA := GetModuleSymbolEx(SetupApiLib, 'SetupCopyErrorA', Result);
    @SetupCopyErrorW := GetModuleSymbolEx(SetupApiLib, 'SetupCopyErrorW', Result);
    @SetupCopyError := GetModuleSymbolEx(SetupApiLib, 'SetupCopyError' + NameSuffix, Result);
    @SetupRenameErrorA := GetModuleSymbolEx(SetupApiLib, 'SetupRenameErrorA', Result);
    @SetupRenameErrorW := GetModuleSymbolEx(SetupApiLib, 'SetupRenameErrorW', Result);
    @SetupRenameError := GetModuleSymbolEx(SetupApiLib, 'SetupRenameError' + NameSuffix, Result);
    @SetupDeleteErrorA := GetModuleSymbolEx(SetupApiLib, 'SetupDeleteErrorA', Result);
    @SetupDeleteErrorW := GetModuleSymbolEx(SetupApiLib, 'SetupDeleteErrorW', Result);
    @SetupDeleteError := GetModuleSymbolEx(SetupApiLib, 'SetupDeleteError' + NameSuffix, Result);
    {$IFDEF WIN2000_UP}
    @SetupBackupErrorA := GetModuleSymbolEx(SetupApiLib, 'SetupBackupErrorA', Result);
    @SetupBackupErrorW := GetModuleSymbolEx(SetupApiLib, 'SetupBackupErrorW', Result);
    @SetupBackupError := GetModuleSymbolEx(SetupApiLib, 'SetupBackupError' + NameSuffix, Result);
    {$ENDIF WIN2000_UP}
    @SetupSetDirectoryIdA := GetModuleSymbolEx(SetupApiLib, 'SetupSetDirectoryIdA', Result);
    @SetupSetDirectoryIdW := GetModuleSymbolEx(SetupApiLib, 'SetupSetDirectoryIdW', Result);
    @SetupSetDirectoryId := GetModuleSymbolEx(SetupApiLib, 'SetupSetDirectoryId' + NameSuffix, Result);
    @SetupSetDirectoryIdExA := GetModuleSymbolEx(SetupApiLib, 'SetupSetDirectoryIdExA', Result);
    @SetupSetDirectoryIdExW := GetModuleSymbolEx(SetupApiLib, 'SetupSetDirectoryIdExW', Result);
    @SetupSetDirectoryIdEx := GetModuleSymbolEx(SetupApiLib, 'SetupSetDirectoryIdEx' + NameSuffix, Result);
    @SetupGetSourceInfoA := GetModuleSymbolEx(SetupApiLib, 'SetupGetSourceInfoA', Result);
    @SetupGetSourceInfoW := GetModuleSymbolEx(SetupApiLib, 'SetupGetSourceInfoW', Result);
    @SetupGetSourceInfo := GetModuleSymbolEx(SetupApiLib, 'SetupGetSourceInfo' + NameSuffix, Result);
    @SetupInstallFileA := GetModuleSymbolEx(SetupApiLib, 'SetupInstallFileA', Result);
    @SetupInstallFileW := GetModuleSymbolEx(SetupApiLib, 'SetupInstallFileW', Result);
    @SetupInstallFile := GetModuleSymbolEx(SetupApiLib, 'SetupInstallFile' + NameSuffix, Result);
    @SetupInstallFileExA := GetModuleSymbolEx(SetupApiLib, 'SetupInstallFileExA', Result);
    @SetupInstallFileExW := GetModuleSymbolEx(SetupApiLib, 'SetupInstallFileExW', Result);
    @SetupInstallFileEx := GetModuleSymbolEx(SetupApiLib, 'SetupInstallFileEx' + NameSuffix, Result);
    @SetupOpenFileQueue := GetModuleSymbolEx(SetupApiLib, 'SetupOpenFileQueue', Result);
    @SetupCloseFileQueue := GetModuleSymbolEx(SetupApiLib, 'SetupCloseFileQueue', Result);
    {$IFDEF WIN2000_UP}
    @SetupSetFileQueueAlternatePlatformA := GetModuleSymbolEx(SetupApiLib, 'SetupSetFileQueueAlternatePlatformA', Result);
    @SetupSetFileQueueAlternatePlatformW := GetModuleSymbolEx(SetupApiLib, 'SetupSetFileQueueAlternatePlatformW', Result);
    @SetupSetFileQueueAlternatePlatform := GetModuleSymbolEx(SetupApiLib, 'SetupSetFileQueueAlternatePlatform' + NameSuffix, Result);
    {$ENDIF WIN2000_UP}
    @SetupSetPlatformPathOverrideA := GetModuleSymbolEx(SetupApiLib, 'SetupSetPlatformPathOverrideA', Result);
    @SetupSetPlatformPathOverrideW := GetModuleSymbolEx(SetupApiLib, 'SetupSetPlatformPathOverrideW', Result);
    @SetupSetPlatformPathOverride := GetModuleSymbolEx(SetupApiLib, 'SetupSetPlatformPathOverride' + NameSuffix, Result);
    @SetupQueueCopyA := GetModuleSymbolEx(SetupApiLib, 'SetupQueueCopyA', Result);
    @SetupQueueCopyW := GetModuleSymbolEx(SetupApiLib, 'SetupQueueCopyW', Result);
    @SetupQueueCopy := GetModuleSymbolEx(SetupApiLib, 'SetupQueueCopy' + NameSuffix, Result);
    {$IFDEF WIN2000_UP}
    @SetupQueueCopyIndirectA := GetModuleSymbolEx(SetupApiLib, 'SetupQueueCopyIndirectA', Result);
    @SetupQueueCopyIndirectW := GetModuleSymbolEx(SetupApiLib, 'SetupQueueCopyIndirectW', Result);
    @SetupQueueCopyIndirect := GetModuleSymbolEx(SetupApiLib, 'SetupQueueCopyIndirect' + NameSuffix, Result);
    {$ENDIF WIN2000_UP}
    @SetupQueueDefaultCopyA := GetModuleSymbolEx(SetupApiLib, 'SetupQueueDefaultCopyA', Result);
    @SetupQueueDefaultCopyW := GetModuleSymbolEx(SetupApiLib, 'SetupQueueDefaultCopyW', Result);
    @SetupQueueDefaultCopy := GetModuleSymbolEx(SetupApiLib, 'SetupQueueDefaultCopy' + NameSuffix, Result);
    @SetupQueueCopySectionA := GetModuleSymbolEx(SetupApiLib, 'SetupQueueCopySectionA', Result);
    @SetupQueueCopySectionW := GetModuleSymbolEx(SetupApiLib, 'SetupQueueCopySectionW', Result);
    @SetupQueueCopySection := GetModuleSymbolEx(SetupApiLib, 'SetupQueueCopySection' + NameSuffix, Result);
    @SetupQueueDeleteA := GetModuleSymbolEx(SetupApiLib, 'SetupQueueDeleteA', Result);
    @SetupQueueDeleteW := GetModuleSymbolEx(SetupApiLib, 'SetupQueueDeleteW', Result);
    @SetupQueueDelete := GetModuleSymbolEx(SetupApiLib, 'SetupQueueDelete' + NameSuffix, Result);
    @SetupQueueDeleteSectionA := GetModuleSymbolEx(SetupApiLib, 'SetupQueueDeleteSectionA', Result);
    @SetupQueueDeleteSectionW := GetModuleSymbolEx(SetupApiLib, 'SetupQueueDeleteSectionW', Result);
    @SetupQueueDeleteSection := GetModuleSymbolEx(SetupApiLib, 'SetupQueueDeleteSection' + NameSuffix, Result);
    @SetupQueueRenameA := GetModuleSymbolEx(SetupApiLib, 'SetupQueueRenameA', Result);
    @SetupQueueRenameW := GetModuleSymbolEx(SetupApiLib, 'SetupQueueRenameW', Result);
    @SetupQueueRename := GetModuleSymbolEx(SetupApiLib, 'SetupQueueRename' + NameSuffix, Result);
    @SetupQueueRenameSectionA := GetModuleSymbolEx(SetupApiLib, 'SetupQueueRenameSectionA', Result);
    @SetupQueueRenameSectionW := GetModuleSymbolEx(SetupApiLib, 'SetupQueueRenameSectionW', Result);
    @SetupQueueRenameSection := GetModuleSymbolEx(SetupApiLib, 'SetupQueueRenameSection' + NameSuffix, Result);
    @SetupCommitFileQueueA := GetModuleSymbolEx(SetupApiLib, 'SetupCommitFileQueueA', Result);
    @SetupCommitFileQueueW := GetModuleSymbolEx(SetupApiLib, 'SetupCommitFileQueueW', Result);
    @SetupCommitFileQueue := GetModuleSymbolEx(SetupApiLib, 'SetupCommitFileQueue' + NameSuffix, Result);
    @SetupScanFileQueueA := GetModuleSymbolEx(SetupApiLib, 'SetupScanFileQueueA', Result);
    @SetupScanFileQueueW := GetModuleSymbolEx(SetupApiLib, 'SetupScanFileQueueW', Result);
    @SetupScanFileQueue := GetModuleSymbolEx(SetupApiLib, 'SetupScanFileQueue' + NameSuffix, Result);
    @SetupCopyOEMInfA := GetModuleSymbolEx(SetupApiLib, 'SetupCopyOEMInfA', Result);
    @SetupCopyOEMInfW := GetModuleSymbolEx(SetupApiLib, 'SetupCopyOEMInfW', Result);
    @SetupCopyOEMInf := GetModuleSymbolEx(SetupApiLib, 'SetupCopyOEMInf' + NameSuffix, Result);
    {$IFDEF WINXP_UP}
    @SetupUninstallOEMInfA := GetModuleSymbolEx(SetupApiLib, 'SetupUninstallOEMInfA', Result);
    @SetupUninstallOEMInfW := GetModuleSymbolEx(SetupApiLib, 'SetupUninstallOEMInfW', Result);
    @SetupUninstallOEMInf := GetModuleSymbolEx(SetupApiLib, 'SetupUninstallOEMInf' + NameSuffix, Result);
    @SetupUninstallNewlyCopiedInfs := GetModuleSymbolEx(SetupApiLib, 'SetupUninstallNewlyCopiedInfs', Result);
    {$ENDIF WINXP_UP}
    @SetupCreateDiskSpaceListA := GetModuleSymbolEx(SetupApiLib, 'SetupCreateDiskSpaceListA', Result);
    @SetupCreateDiskSpaceListW := GetModuleSymbolEx(SetupApiLib, 'SetupCreateDiskSpaceListW', Result);
    @SetupCreateDiskSpaceList := GetModuleSymbolEx(SetupApiLib, 'SetupCreateDiskSpaceList' + NameSuffix, Result);
    @SetupDuplicateDiskSpaceListA := GetModuleSymbolEx(SetupApiLib, 'SetupDuplicateDiskSpaceListA', Result);
    @SetupDuplicateDiskSpaceListW := GetModuleSymbolEx(SetupApiLib, 'SetupDuplicateDiskSpaceListW', Result);
    @SetupDuplicateDiskSpaceList := GetModuleSymbolEx(SetupApiLib, 'SetupDuplicateDiskSpaceList' + NameSuffix, Result);
    @SetupDestroyDiskSpaceList := GetModuleSymbolEx(SetupApiLib, 'SetupDestroyDiskSpaceList', Result);
    @SetupQueryDrivesInDiskSpaceListA := GetModuleSymbolEx(SetupApiLib, 'SetupQueryDrivesInDiskSpaceListA', Result);
    @SetupQueryDrivesInDiskSpaceListW := GetModuleSymbolEx(SetupApiLib, 'SetupQueryDrivesInDiskSpaceListW', Result);
    @SetupQueryDrivesInDiskSpaceList := GetModuleSymbolEx(SetupApiLib, 'SetupQueryDrivesInDiskSpaceList' + NameSuffix, Result);
    @SetupQuerySpaceRequiredOnDriveA := GetModuleSymbolEx(SetupApiLib, 'SetupQuerySpaceRequiredOnDriveA', Result);
    @SetupQuerySpaceRequiredOnDriveW := GetModuleSymbolEx(SetupApiLib, 'SetupQuerySpaceRequiredOnDriveW', Result);
    @SetupQuerySpaceRequiredOnDrive := GetModuleSymbolEx(SetupApiLib, 'SetupQuerySpaceRequiredOnDrive' + NameSuffix, Result);
    @SetupAdjustDiskSpaceListA := GetModuleSymbolEx(SetupApiLib, 'SetupAdjustDiskSpaceListA', Result);
    @SetupAdjustDiskSpaceListW := GetModuleSymbolEx(SetupApiLib, 'SetupAdjustDiskSpaceListW', Result);
    @SetupAdjustDiskSpaceList := GetModuleSymbolEx(SetupApiLib, 'SetupAdjustDiskSpaceList' + NameSuffix, Result);
    @SetupAddToDiskSpaceListA := GetModuleSymbolEx(SetupApiLib, 'SetupAddToDiskSpaceListA', Result);
    @SetupAddToDiskSpaceListW := GetModuleSymbolEx(SetupApiLib, 'SetupAddToDiskSpaceListW', Result);
    @SetupAddToDiskSpaceList := GetModuleSymbolEx(SetupApiLib, 'SetupAddToDiskSpaceList' + NameSuffix, Result);
    @SetupAddSectionToDiskSpaceListA := GetModuleSymbolEx(SetupApiLib, 'SetupAddSectionToDiskSpaceListA', Result);
    @SetupAddSectionToDiskSpaceListW := GetModuleSymbolEx(SetupApiLib, 'SetupAddSectionToDiskSpaceListW', Result);
    @SetupAddSectionToDiskSpaceList := GetModuleSymbolEx(SetupApiLib, 'SetupAddSectionToDiskSpaceList' + NameSuffix, Result);
    @SetupAddInstallSectionToDiskSpaceListA := GetModuleSymbolEx(SetupApiLib, 'SetupAddInstallSectionToDiskSpaceListA', Result);
    @SetupAddInstallSectionToDiskSpaceListW := GetModuleSymbolEx(SetupApiLib, 'SetupAddInstallSectionToDiskSpaceListW', Result);
    @SetupAddInstallSectionToDiskSpaceList := GetModuleSymbolEx(SetupApiLib, 'SetupAddInstallSectionToDiskSpaceList' + NameSuffix, Result);
    @SetupRemoveFromDiskSpaceListA := GetModuleSymbolEx(SetupApiLib, 'SetupRemoveFromDiskSpaceListA', Result);
    @SetupRemoveFromDiskSpaceListW := GetModuleSymbolEx(SetupApiLib, 'SetupRemoveFromDiskSpaceListW', Result);
    @SetupRemoveFromDiskSpaceList := GetModuleSymbolEx(SetupApiLib, 'SetupRemoveFromDiskSpaceList' + NameSuffix, Result);
    @SetupRemoveSectionFromDiskSpaceListA := GetModuleSymbolEx(SetupApiLib, 'SetupRemoveSectionFromDiskSpaceListA', Result);
    @SetupRemoveSectionFromDiskSpaceListW := GetModuleSymbolEx(SetupApiLib, 'SetupRemoveSectionFromDiskSpaceListW', Result);
    @SetupRemoveSectionFromDiskSpaceList := GetModuleSymbolEx(SetupApiLib, 'SetupRemoveSectionFromDiskSpaceList' + NameSuffix, Result);
    @SetupRemoveInstallSectionFromDiskSpaceListA := GetModuleSymbolEx(SetupApiLib, 'SetupRemoveInstallSectionFromDiskSpaceListA', Result);
    @SetupRemoveInstallSectionFromDiskSpaceListW := GetModuleSymbolEx(SetupApiLib, 'SetupRemoveInstallSectionFromDiskSpaceListW', Result);
    @SetupRemoveInstallSectionFromDiskSpaceList := GetModuleSymbolEx(SetupApiLib, 'SetupRemoveInstallSectionFromDiskSpaceList' + NameSuffix, Result);
    @SetupIterateCabinetA := GetModuleSymbolEx(SetupApiLib, 'SetupIterateCabinetA', Result);
    @SetupIterateCabinetW := GetModuleSymbolEx(SetupApiLib, 'SetupIterateCabinetW', Result);
    @SetupIterateCabinet := GetModuleSymbolEx(SetupApiLib, 'SetupIterateCabinet' + NameSuffix, Result);
    @SetupPromptReboot := GetModuleSymbolEx(SetupApiLib, 'SetupPromptReboot', Result);
    @SetupInitDefaultQueueCallback := GetModuleSymbolEx(SetupApiLib, 'SetupInitDefaultQueueCallback', Result);
    @SetupInitDefaultQueueCallbackEx := GetModuleSymbolEx(SetupApiLib, 'SetupInitDefaultQueueCallbackEx', Result);
    @SetupTermDefaultQueueCallback := GetModuleSymbolEx(SetupApiLib, 'SetupTermDefaultQueueCallback', Result);
    @SetupDefaultQueueCallbackA := GetModuleSymbolEx(SetupApiLib, 'SetupDefaultQueueCallbackA', Result);
    @SetupDefaultQueueCallbackW := GetModuleSymbolEx(SetupApiLib, 'SetupDefaultQueueCallbackW', Result);
    @SetupDefaultQueueCallback := GetModuleSymbolEx(SetupApiLib, 'SetupDefaultQueueCallback' + NameSuffix, Result);
    @SetupInstallFromInfSectionA := GetModuleSymbolEx(SetupApiLib, 'SetupInstallFromInfSectionA', Result);
    @SetupInstallFromInfSectionW := GetModuleSymbolEx(SetupApiLib, 'SetupInstallFromInfSectionW', Result);
    @SetupInstallFromInfSection := GetModuleSymbolEx(SetupApiLib, 'SetupInstallFromInfSection' + NameSuffix, Result);
    @SetupInstallFilesFromInfSectionA := GetModuleSymbolEx(SetupApiLib, 'SetupInstallFilesFromInfSectionA', Result);
    @SetupInstallFilesFromInfSectionW := GetModuleSymbolEx(SetupApiLib, 'SetupInstallFilesFromInfSectionW', Result);
    @SetupInstallFilesFromInfSection := GetModuleSymbolEx(SetupApiLib, 'SetupInstallFilesFromInfSection' + NameSuffix, Result);
    @SetupInstallServicesFromInfSectionA := GetModuleSymbolEx(SetupApiLib, 'SetupInstallServicesFromInfSectionA', Result);
    @SetupInstallServicesFromInfSectionW := GetModuleSymbolEx(SetupApiLib, 'SetupInstallServicesFromInfSectionW', Result);
    @SetupInstallServicesFromInfSection := GetModuleSymbolEx(SetupApiLib, 'SetupInstallServicesFromInfSection' + NameSuffix, Result);
    @SetupInstallServicesFromInfSectionExA := GetModuleSymbolEx(SetupApiLib, 'SetupInstallServicesFromInfSectionExA', Result);
    @SetupInstallServicesFromInfSectionExW := GetModuleSymbolEx(SetupApiLib, 'SetupInstallServicesFromInfSectionExW', Result);
    @SetupInstallServicesFromInfSectionEx := GetModuleSymbolEx(SetupApiLib, 'SetupInstallServicesFromInfSectionEx' + NameSuffix, Result);
    {$IFDEF WINXP_UP}
    @InstallHinfSectionA := GetModuleSymbolEx(SetupApiLib, 'InstallHinfSectionA', Result);
    @InstallHinfSectionW := GetModuleSymbolEx(SetupApiLib, 'InstallHinfSectionW', Result);
    @InstallHinfSection := GetModuleSymbolEx(SetupApiLib, 'InstallHinfSection' + NameSuffix, Result);
    {$ENDIF WINXP_UP}
    @SetupInitializeFileLogA := GetModuleSymbolEx(SetupApiLib, 'SetupInitializeFileLogA', Result);
    @SetupInitializeFileLogW := GetModuleSymbolEx(SetupApiLib, 'SetupInitializeFileLogW', Result);
    @SetupInitializeFileLog := GetModuleSymbolEx(SetupApiLib, 'SetupInitializeFileLog' + NameSuffix, Result);
    @SetupTerminateFileLog := GetModuleSymbolEx(SetupApiLib, 'SetupTerminateFileLog', Result);
    @SetupLogFileA := GetModuleSymbolEx(SetupApiLib, 'SetupLogFileA', Result);
    @SetupLogFileW := GetModuleSymbolEx(SetupApiLib, 'SetupLogFileW', Result);
    @SetupLogFile := GetModuleSymbolEx(SetupApiLib, 'SetupLogFile' + NameSuffix, Result);
    @SetupRemoveFileLogEntryA := GetModuleSymbolEx(SetupApiLib, 'SetupRemoveFileLogEntryA', Result);
    @SetupRemoveFileLogEntryW := GetModuleSymbolEx(SetupApiLib, 'SetupRemoveFileLogEntryW', Result);
    @SetupRemoveFileLogEntry := GetModuleSymbolEx(SetupApiLib, 'SetupRemoveFileLogEntry' + NameSuffix, Result);
    @SetupQueryFileLogA := GetModuleSymbolEx(SetupApiLib, 'SetupQueryFileLogA', Result);
    @SetupQueryFileLogW := GetModuleSymbolEx(SetupApiLib, 'SetupQueryFileLogW', Result);
    @SetupQueryFileLog := GetModuleSymbolEx(SetupApiLib, 'SetupQueryFileLog' + NameSuffix, Result);
    @SetupOpenLog := GetModuleSymbolEx(SetupApiLib, 'SetupOpenLog', Result);
    @SetupLogErrorA := GetModuleSymbolEx(SetupApiLib, 'SetupLogErrorA', Result);
    @SetupLogErrorW := GetModuleSymbolEx(SetupApiLib, 'SetupLogErrorW', Result);
    @SetupLogError := GetModuleSymbolEx(SetupApiLib, 'SetupLogError' + NameSuffix, Result);
    @SetupCloseLog := GetModuleSymbolEx(SetupApiLib, 'SetupCloseLog', Result);
    {$IFDEF WIN2000_UP}
    @SetupGetBackupInformationA := GetModuleSymbolEx(SetupApiLib, 'SetupGetBackupInformationA', Result);
    @SetupGetBackupInformationW := GetModuleSymbolEx(SetupApiLib, 'SetupGetBackupInformationW', Result);
    @SetupGetBackupInformation := GetModuleSymbolEx(SetupApiLib, 'SetupGetBackupInformation' + NameSuffix, Result);
    {$ENDIF WIN2000_UP}
    {$IFDEF WINXP_UP}
    @SetupPrepareQueueForRestoreA := GetModuleSymbolEx(SetupApiLib, 'SetupPrepareQueueForRestoreA', Result);
    @SetupPrepareQueueForRestoreW := GetModuleSymbolEx(SetupApiLib, 'SetupPrepareQueueForRestoreW', Result);
    @SetupPrepareQueueForRestore := GetModuleSymbolEx(SetupApiLib, 'SetupPrepareQueueForRestore' + NameSuffix, Result);
    @SetupSetNonInteractiveMode := GetModuleSymbolEx(SetupApiLib, 'SetupSetNonInteractiveMode', Result);
    @SetupGetNonInteractiveMode := GetModuleSymbolEx(SetupApiLib, 'SetupGetNonInteractiveMode', Result);
    {$ENDIF WINXP_UP}
    @SetupDiCreateDeviceInfoList := GetModuleSymbolEx(SetupApiLib, 'SetupDiCreateDeviceInfoList', Result);
    @SetupDiCreateDeviceInfoListExA := GetModuleSymbolEx(SetupApiLib, 'SetupDiCreateDeviceInfoListExA', Result);
    @SetupDiCreateDeviceInfoListExW := GetModuleSymbolEx(SetupApiLib, 'SetupDiCreateDeviceInfoListExW', Result);
    @SetupDiCreateDeviceInfoListEx := GetModuleSymbolEx(SetupApiLib, 'SetupDiCreateDeviceInfoListEx' + NameSuffix, Result);
    @SetupDiGetDeviceInfoListClass := GetModuleSymbolEx(SetupApiLib, 'SetupDiGetDeviceInfoListClass', Result);
    @SetupDiGetDeviceInfoListDetailA := GetModuleSymbolEx(SetupApiLib, 'SetupDiGetDeviceInfoListDetailA', Result);
    @SetupDiGetDeviceInfoListDetailW := GetModuleSymbolEx(SetupApiLib, 'SetupDiGetDeviceInfoListDetailW', Result);
    @SetupDiGetDeviceInfoListDetail := GetModuleSymbolEx(SetupApiLib, 'SetupDiGetDeviceInfoListDetail' + NameSuffix, Result);
    @SetupDiCreateDeviceInfoA := GetModuleSymbolEx(SetupApiLib, 'SetupDiCreateDeviceInfoA', Result);
    @SetupDiCreateDeviceInfoW := GetModuleSymbolEx(SetupApiLib, 'SetupDiCreateDeviceInfoW', Result);
    @SetupDiCreateDeviceInfo := GetModuleSymbolEx(SetupApiLib, 'SetupDiCreateDeviceInfo' + NameSuffix, Result);
    @SetupDiOpenDeviceInfoA := GetModuleSymbolEx(SetupApiLib, 'SetupDiOpenDeviceInfoA', Result);
    @SetupDiOpenDeviceInfoW := GetModuleSymbolEx(SetupApiLib, 'SetupDiOpenDeviceInfoW', Result);
    @SetupDiOpenDeviceInfo := GetModuleSymbolEx(SetupApiLib, 'SetupDiOpenDeviceInfo' + NameSuffix, Result);
    @SetupDiGetDeviceInstanceIdA := GetModuleSymbolEx(SetupApiLib, 'SetupDiGetDeviceInstanceIdA', Result);
    @SetupDiGetDeviceInstanceIdW := GetModuleSymbolEx(SetupApiLib, 'SetupDiGetDeviceInstanceIdW', Result);
    @SetupDiGetDeviceInstanceId := GetModuleSymbolEx(SetupApiLib, 'SetupDiGetDeviceInstanceId' + NameSuffix, Result);
    @SetupDiDeleteDeviceInfo := GetModuleSymbolEx(SetupApiLib, 'SetupDiDeleteDeviceInfo', Result);
    @SetupDiEnumDeviceInfo := GetModuleSymbolEx(SetupApiLib, 'SetupDiEnumDeviceInfo', Result);
    @SetupDiDestroyDeviceInfoList := GetModuleSymbolEx(SetupApiLib, 'SetupDiDestroyDeviceInfoList', Result);
    @SetupDiEnumDeviceInterfaces := GetModuleSymbolEx(SetupApiLib, 'SetupDiEnumDeviceInterfaces', Result);
    @SetupDiEnumInterfaceDevice := GetModuleSymbolEx(SetupApiLib, 'SetupDiEnumDeviceInterfaces', Result);
    @SetupDiCreateDeviceInterfaceA := GetModuleSymbolEx(SetupApiLib, 'SetupDiCreateDeviceInterfaceA', Result);
    @SetupDiCreateInterfaceDeviceA := GetModuleSymbolEx(SetupApiLib, 'SetupDiCreateDeviceInterfaceA', Result);
    @SetupDiCreateDeviceInterfaceW := GetModuleSymbolEx(SetupApiLib, 'SetupDiCreateDeviceInterfaceW', Result);
    @SetupDiCreateInterfaceDeviceW := GetModuleSymbolEx(SetupApiLib, 'SetupDiCreateDeviceInterfaceW', Result);
    @SetupDiCreateDeviceInterface := GetModuleSymbolEx(SetupApiLib, 'SetupDiCreateDeviceInterface' + NameSuffix, Result);
    @SetupDiCreateInterfaceDevice := GetModuleSymbolEx(SetupApiLib, 'SetupDiCreateDeviceInterface' + NameSuffix, Result);
    @SetupDiOpenDeviceInterfaceA := GetModuleSymbolEx(SetupApiLib, 'SetupDiOpenDeviceInterfaceA', Result);
    @SetupDiOpenInterfaceDeviceA := GetModuleSymbolEx(SetupApiLib, 'SetupDiOpenDeviceInterfaceA', Result);
    @SetupDiOpenDeviceInterfaceW := GetModuleSymbolEx(SetupApiLib, 'SetupDiOpenDeviceInterfaceW', Result);
    @SetupDiOpenInterfaceDeviceW := GetModuleSymbolEx(SetupApiLib, 'SetupDiOpenDeviceInterfaceW', Result);
    @SetupDiOpenDeviceInterface := GetModuleSymbolEx(SetupApiLib, 'SetupDiOpenDeviceInterface' + NameSuffix, Result);
    @SetupDiOpenInterfaceDevice := GetModuleSymbolEx(SetupApiLib, 'SetupDiOpenDeviceInterface' + NameSuffix, Result);
    @SetupDiGetDeviceInterfaceAlias := GetModuleSymbolEx(SetupApiLib, 'SetupDiGetDeviceInterfaceAlias', Result);
    @SetupDiGetInterfaceDeviceAlias := GetModuleSymbolEx(SetupApiLib, 'SetupDiGetDeviceInterfaceAlias', Result);
    @SetupDiDeleteDeviceInterfaceData := GetModuleSymbolEx(SetupApiLib, 'SetupDiDeleteDeviceInterfaceData', Result);
    @SetupDiDeleteInterfaceDeviceData := GetModuleSymbolEx(SetupApiLib, 'SetupDiDeleteDeviceInterfaceData', Result);
    @SetupDiRemoveDeviceInterface := GetModuleSymbolEx(SetupApiLib, 'SetupDiRemoveDeviceInterface', Result);
    @SetupDiRemoveInterfaceDevice := GetModuleSymbolEx(SetupApiLib, 'SetupDiRemoveDeviceInterface', Result);
    @SetupDiGetDeviceInterfaceDetailA := GetModuleSymbolEx(SetupApiLib, 'SetupDiGetDeviceInterfaceDetailA', Result);
    @SetupDiGetInterfaceDeviceDetailA := GetModuleSymbolEx(SetupApiLib, 'SetupDiGetDeviceInterfaceDetailA', Result);
    @SetupDiGetDeviceInterfaceDetailW := GetModuleSymbolEx(SetupApiLib, 'SetupDiGetDeviceInterfaceDetailW', Result);
    @SetupDiGetInterfaceDeviceDetailW := GetModuleSymbolEx(SetupApiLib, 'SetupDiGetDeviceInterfaceDetailW', Result);
    @SetupDiGetDeviceInterfaceDetail := GetModuleSymbolEx(SetupApiLib, 'SetupDiGetDeviceInterfaceDetail' + NameSuffix, Result);
    @SetupDiGetInterfaceDeviceDetail := GetModuleSymbolEx(SetupApiLib, 'SetupDiGetDeviceInterfaceDetail' + NameSuffix, Result);
    @SetupDiInstallDeviceInterfaces := GetModuleSymbolEx(SetupApiLib, 'SetupDiInstallDeviceInterfaces', Result);
    @SetupDiInstallInterfaceDevices := GetModuleSymbolEx(SetupApiLib, 'SetupDiInstallDeviceInterfaces', Result);
    {$IFDEF WINXP_UP}
    @SetupDiSetDeviceInterfaceDefault := GetModuleSymbolEx(SetupApiLib, 'SetupDiSetDeviceInterfaceDefault', Result);
    {$ENDIF WINXP_UP}
    @SetupDiRegisterDeviceInfo := GetModuleSymbolEx(SetupApiLib, 'SetupDiRegisterDeviceInfo', Result);
    @SetupDiBuildDriverInfoList := GetModuleSymbolEx(SetupApiLib, 'SetupDiBuildDriverInfoList', Result);
    @SetupDiCancelDriverInfoSearch := GetModuleSymbolEx(SetupApiLib, 'SetupDiCancelDriverInfoSearch', Result);
    @SetupDiEnumDriverInfoA := GetModuleSymbolEx(SetupApiLib, 'SetupDiEnumDriverInfoA', Result);
    @SetupDiEnumDriverInfoW := GetModuleSymbolEx(SetupApiLib, 'SetupDiEnumDriverInfoW', Result);
    @SetupDiEnumDriverInfo := GetModuleSymbolEx(SetupApiLib, 'SetupDiEnumDriverInfo' + NameSuffix, Result);
    @SetupDiGetSelectedDriverA := GetModuleSymbolEx(SetupApiLib, 'SetupDiGetSelectedDriverA', Result);
    @SetupDiGetSelectedDriverW := GetModuleSymbolEx(SetupApiLib, 'SetupDiGetSelectedDriverW', Result);
    @SetupDiGetSelectedDriver := GetModuleSymbolEx(SetupApiLib, 'SetupDiGetSelectedDriver' + NameSuffix, Result);
    @SetupDiSetSelectedDriverA := GetModuleSymbolEx(SetupApiLib, 'SetupDiSetSelectedDriverA', Result);
    @SetupDiSetSelectedDriverW := GetModuleSymbolEx(SetupApiLib, 'SetupDiSetSelectedDriverW', Result);
    @SetupDiSetSelectedDriver := GetModuleSymbolEx(SetupApiLib, 'SetupDiSetSelectedDriver' + NameSuffix, Result);
    @SetupDiGetDriverInfoDetailA := GetModuleSymbolEx(SetupApiLib, 'SetupDiGetDriverInfoDetailA', Result);
    @SetupDiGetDriverInfoDetailW := GetModuleSymbolEx(SetupApiLib, 'SetupDiGetDriverInfoDetailW', Result);
    @SetupDiGetDriverInfoDetail := GetModuleSymbolEx(SetupApiLib, 'SetupDiGetDriverInfoDetail' + NameSuffix, Result);
    @SetupDiDestroyDriverInfoList := GetModuleSymbolEx(SetupApiLib, 'SetupDiDestroyDriverInfoList', Result);
    @SetupDiGetClassDevsA := GetModuleSymbolEx(SetupApiLib, 'SetupDiGetClassDevsA', Result);
    @SetupDiGetClassDevsW := GetModuleSymbolEx(SetupApiLib, 'SetupDiGetClassDevsW', Result);
    @SetupDiGetClassDevs := GetModuleSymbolEx(SetupApiLib, 'SetupDiGetClassDevs' + NameSuffix, Result);
    @SetupDiGetClassDevsExA := GetModuleSymbolEx(SetupApiLib, 'SetupDiGetClassDevsExA', Result);
    @SetupDiGetClassDevsExW := GetModuleSymbolEx(SetupApiLib, 'SetupDiGetClassDevsExW', Result);
    @SetupDiGetClassDevsEx := GetModuleSymbolEx(SetupApiLib, 'SetupDiGetClassDevsEx' + NameSuffix, Result);
    @SetupDiGetINFClassA := GetModuleSymbolEx(SetupApiLib, 'SetupDiGetINFClassA', Result);
    @SetupDiGetINFClassW := GetModuleSymbolEx(SetupApiLib, 'SetupDiGetINFClassW', Result);
    @SetupDiGetINFClass := GetModuleSymbolEx(SetupApiLib, 'SetupDiGetINFClass' + NameSuffix, Result);
    @SetupDiBuildClassInfoList := GetModuleSymbolEx(SetupApiLib, 'SetupDiBuildClassInfoList', Result);
    @SetupDiBuildClassInfoListExA := GetModuleSymbolEx(SetupApiLib, 'SetupDiBuildClassInfoListExA', Result);
    @SetupDiBuildClassInfoListExW := GetModuleSymbolEx(SetupApiLib, 'SetupDiBuildClassInfoListExW', Result);
    @SetupDiBuildClassInfoListEx := GetModuleSymbolEx(SetupApiLib, 'SetupDiBuildClassInfoListEx' + NameSuffix, Result);
    @SetupDiGetClassDescriptionA := GetModuleSymbolEx(SetupApiLib, 'SetupDiGetClassDescriptionA', Result);
    @SetupDiGetClassDescriptionW := GetModuleSymbolEx(SetupApiLib, 'SetupDiGetClassDescriptionW', Result);
    @SetupDiGetClassDescription := GetModuleSymbolEx(SetupApiLib, 'SetupDiGetClassDescription' + NameSuffix, Result);
    @SetupDiGetClassDescriptionExA := GetModuleSymbolEx(SetupApiLib, 'SetupDiGetClassDescriptionExA', Result);
    @SetupDiGetClassDescriptionExW := GetModuleSymbolEx(SetupApiLib, 'SetupDiGetClassDescriptionExW', Result);
    @SetupDiGetClassDescriptionEx := GetModuleSymbolEx(SetupApiLib, 'SetupDiGetClassDescriptionEx' + NameSuffix, Result);
    @SetupDiCallClassInstaller := GetModuleSymbolEx(SetupApiLib, 'SetupDiCallClassInstaller', Result);
    @SetupDiSelectDevice := GetModuleSymbolEx(SetupApiLib, 'SetupDiSelectDevice', Result);
    @SetupDiSelectBestCompatDrv := GetModuleSymbolEx(SetupApiLib, 'SetupDiSelectBestCompatDrv', Result);
    @SetupDiInstallDevice := GetModuleSymbolEx(SetupApiLib, 'SetupDiInstallDevice', Result);
    @SetupDiInstallDriverFiles := GetModuleSymbolEx(SetupApiLib, 'SetupDiInstallDriverFiles', Result);
    @SetupDiRegisterCoDeviceInstallers := GetModuleSymbolEx(SetupApiLib, 'SetupDiRegisterCoDeviceInstallers', Result);
    @SetupDiRemoveDevice := GetModuleSymbolEx(SetupApiLib, 'SetupDiRemoveDevice', Result);
    @SetupDiUnremoveDevice := GetModuleSymbolEx(SetupApiLib, 'SetupDiUnremoveDevice', Result);
    @SetupDiMoveDuplicateDevice := GetModuleSymbolEx(SetupApiLib, 'SetupDiMoveDuplicateDevice', Result);
    @SetupDiChangeState := GetModuleSymbolEx(SetupApiLib, 'SetupDiChangeState', Result);
    @SetupDiInstallClassA := GetModuleSymbolEx(SetupApiLib, 'SetupDiInstallClassA', Result);
    @SetupDiInstallClassW := GetModuleSymbolEx(SetupApiLib, 'SetupDiInstallClassW', Result);
    @SetupDiInstallClass := GetModuleSymbolEx(SetupApiLib, 'SetupDiInstallClass' + NameSuffix, Result);
    @SetupDiInstallClassExA := GetModuleSymbolEx(SetupApiLib, 'SetupDiInstallClassExA', Result);
    @SetupDiInstallClassExW := GetModuleSymbolEx(SetupApiLib, 'SetupDiInstallClassExW', Result);
    @SetupDiInstallClassEx := GetModuleSymbolEx(SetupApiLib, 'SetupDiInstallClassEx' + NameSuffix, Result);
    @SetupDiOpenClassRegKey := GetModuleSymbolEx(SetupApiLib, 'SetupDiOpenClassRegKey', Result);
    @SetupDiOpenClassRegKeyExA := GetModuleSymbolEx(SetupApiLib, 'SetupDiOpenClassRegKeyExA', Result);
    @SetupDiOpenClassRegKeyExW := GetModuleSymbolEx(SetupApiLib, 'SetupDiOpenClassRegKeyExW', Result);
    @SetupDiOpenClassRegKeyEx := GetModuleSymbolEx(SetupApiLib, 'SetupDiOpenClassRegKeyEx' + NameSuffix, Result);
    @SetupDiCreateDeviceInterfaceRegKeyA := GetModuleSymbolEx(SetupApiLib, 'SetupDiCreateDeviceInterfaceRegKeyA', Result);
    @SetupDiCreateInterfaceDeviceRegKeyA := GetModuleSymbolEx(SetupApiLib, 'SetupDiCreateDeviceInterfaceRegKeyA', Result);
    @SetupDiCreateDeviceInterfaceRegKeyW := GetModuleSymbolEx(SetupApiLib, 'SetupDiCreateDeviceInterfaceRegKeyW', Result);
    @SetupDiCreateInterfaceDeviceRegKeyW := GetModuleSymbolEx(SetupApiLib, 'SetupDiCreateDeviceInterfaceRegKeyW', Result);
    @SetupDiCreateDeviceInterfaceRegKey := GetModuleSymbolEx(SetupApiLib, 'SetupDiCreateDeviceInterfaceRegKey' + NameSuffix, Result);
    @SetupDiCreateInterfaceDeviceRegKey := GetModuleSymbolEx(SetupApiLib, 'SetupDiCreateDeviceInterfaceRegKey' + NameSuffix, Result);
    @SetupDiOpenDeviceInterfaceRegKey := GetModuleSymbolEx(SetupApiLib, 'SetupDiOpenDeviceInterfaceRegKey', Result);
    @SetupDiOpenInterfaceDeviceRegKey := GetModuleSymbolEx(SetupApiLib, 'SetupDiOpenDeviceInterfaceRegKey', Result);
    @SetupDiDeleteDeviceInterfaceRegKey := GetModuleSymbolEx(SetupApiLib, 'SetupDiDeleteDeviceInterfaceRegKey', Result);
    @SetupDiDeleteInterfaceDeviceRegKey := GetModuleSymbolEx(SetupApiLib, 'SetupDiDeleteDeviceInterfaceRegKey', Result);
    @SetupDiCreateDevRegKeyA := GetModuleSymbolEx(SetupApiLib, 'SetupDiCreateDevRegKeyA', Result);
    @SetupDiCreateDevRegKeyW := GetModuleSymbolEx(SetupApiLib, 'SetupDiCreateDevRegKeyW', Result);
    @SetupDiCreateDevRegKey := GetModuleSymbolEx(SetupApiLib, 'SetupDiCreateDevRegKey' + NameSuffix, Result);
    @SetupDiOpenDevRegKey := GetModuleSymbolEx(SetupApiLib, 'SetupDiOpenDevRegKey', Result);
    @SetupDiDeleteDevRegKey := GetModuleSymbolEx(SetupApiLib, 'SetupDiDeleteDevRegKey', Result);
    @SetupDiGetHwProfileList := GetModuleSymbolEx(SetupApiLib, 'SetupDiGetHwProfileList', Result);
    @SetupDiGetHwProfileListExA := GetModuleSymbolEx(SetupApiLib, 'SetupDiGetHwProfileListExA', Result);
    @SetupDiGetHwProfileListExW := GetModuleSymbolEx(SetupApiLib, 'SetupDiGetHwProfileListExW', Result);
    @SetupDiGetHwProfileListEx := GetModuleSymbolEx(SetupApiLib, 'SetupDiGetHwProfileListEx' + NameSuffix, Result);
    @SetupDiGetDeviceRegistryPropertyA := GetModuleSymbolEx(SetupApiLib, 'SetupDiGetDeviceRegistryPropertyA', Result);
    @SetupDiGetDeviceRegistryPropertyW := GetModuleSymbolEx(SetupApiLib, 'SetupDiGetDeviceRegistryPropertyW', Result);
    @SetupDiGetDeviceRegistryProperty := GetModuleSymbolEx(SetupApiLib, 'SetupDiGetDeviceRegistryProperty' + NameSuffix, Result);
    {$IFDEF WINXP_UP}
    @SetupDiGetClassRegistryPropertyA := GetModuleSymbolEx(SetupApiLib, 'SetupDiGetClassRegistryPropertyA', Result);
    @SetupDiGetClassRegistryPropertyW := GetModuleSymbolEx(SetupApiLib, 'SetupDiGetClassRegistryPropertyW', Result);
    @SetupDiGetClassRegistryProperty := GetModuleSymbolEx(SetupApiLib, 'SetupDiGetClassRegistryProperty' + NameSuffix, Result);
    {$ENDIF WINXP_UP}
    @SetupDiSetDeviceRegistryPropertyA := GetModuleSymbolEx(SetupApiLib, 'SetupDiSetDeviceRegistryPropertyA', Result);
    @SetupDiSetDeviceRegistryPropertyW := GetModuleSymbolEx(SetupApiLib, 'SetupDiSetDeviceRegistryPropertyW', Result);
    @SetupDiSetDeviceRegistryProperty := GetModuleSymbolEx(SetupApiLib, 'SetupDiSetDeviceRegistryProperty' + NameSuffix, Result);
    {$IFDEF WINXP_UP}
    @SetupDiSetClassRegistryPropertyA := GetModuleSymbolEx(SetupApiLib, 'SetupDiSetClassRegistryPropertyA', Result);
    @SetupDiSetClassRegistryPropertyW := GetModuleSymbolEx(SetupApiLib, 'SetupDiSetClassRegistryPropertyW', Result);
    @SetupDiSetClassRegistryProperty := GetModuleSymbolEx(SetupApiLib, 'SetupDiSetClassRegistryProperty' + NameSuffix, Result);
    {$ENDIF WINXP_UP}
    @SetupDiGetDeviceInstallParamsA := GetModuleSymbolEx(SetupApiLib, 'SetupDiGetDeviceInstallParamsA', Result);
    @SetupDiGetDeviceInstallParamsW := GetModuleSymbolEx(SetupApiLib, 'SetupDiGetDeviceInstallParamsW', Result);
    @SetupDiGetDeviceInstallParams := GetModuleSymbolEx(SetupApiLib, 'SetupDiGetDeviceInstallParams' + NameSuffix, Result);
    @SetupDiGetClassInstallParamsA := GetModuleSymbolEx(SetupApiLib, 'SetupDiGetClassInstallParamsA', Result);
    @SetupDiGetClassInstallParamsW := GetModuleSymbolEx(SetupApiLib, 'SetupDiGetClassInstallParamsW', Result);
    @SetupDiGetClassInstallParams := GetModuleSymbolEx(SetupApiLib, 'SetupDiGetClassInstallParams' + NameSuffix, Result);
    @SetupDiSetDeviceInstallParamsA := GetModuleSymbolEx(SetupApiLib, 'SetupDiSetDeviceInstallParamsA', Result);
    @SetupDiSetDeviceInstallParamsW := GetModuleSymbolEx(SetupApiLib, 'SetupDiSetDeviceInstallParamsW', Result);
    @SetupDiSetDeviceInstallParams := GetModuleSymbolEx(SetupApiLib, 'SetupDiSetDeviceInstallParams' + NameSuffix, Result);
    @SetupDiSetClassInstallParamsA := GetModuleSymbolEx(SetupApiLib, 'SetupDiSetClassInstallParamsA', Result);
    @SetupDiSetClassInstallParamsW := GetModuleSymbolEx(SetupApiLib, 'SetupDiSetClassInstallParamsW', Result);
    @SetupDiSetClassInstallParams := GetModuleSymbolEx(SetupApiLib, 'SetupDiSetClassInstallParams' + NameSuffix, Result);
    @SetupDiGetDriverInstallParamsA := GetModuleSymbolEx(SetupApiLib, 'SetupDiGetDriverInstallParamsA', Result);
    @SetupDiGetDriverInstallParamsW := GetModuleSymbolEx(SetupApiLib, 'SetupDiGetDriverInstallParamsW', Result);
    @SetupDiGetDriverInstallParams := GetModuleSymbolEx(SetupApiLib, 'SetupDiGetDriverInstallParams' + NameSuffix, Result);
    @SetupDiSetDriverInstallParamsA := GetModuleSymbolEx(SetupApiLib, 'SetupDiSetDriverInstallParamsA', Result);
    @SetupDiSetDriverInstallParamsW := GetModuleSymbolEx(SetupApiLib, 'SetupDiSetDriverInstallParamsW', Result);
    @SetupDiSetDriverInstallParams := GetModuleSymbolEx(SetupApiLib, 'SetupDiSetDriverInstallParams' + NameSuffix, Result);
    @SetupDiLoadClassIcon := GetModuleSymbolEx(SetupApiLib, 'SetupDiLoadClassIcon', Result);
    @SetupDiDrawMiniIcon := GetModuleSymbolEx(SetupApiLib, 'SetupDiDrawMiniIcon', Result);
    @SetupDiGetClassBitmapIndex := GetModuleSymbolEx(SetupApiLib, 'SetupDiGetClassBitmapIndex', Result);
    @SetupDiGetClassImageList := GetModuleSymbolEx(SetupApiLib, 'SetupDiGetClassImageList', Result);
    @SetupDiGetClassImageListExA := GetModuleSymbolEx(SetupApiLib, 'SetupDiGetClassImageListExA', Result);
    @SetupDiGetClassImageListExW := GetModuleSymbolEx(SetupApiLib, 'SetupDiGetClassImageListExW', Result);
    @SetupDiGetClassImageListEx := GetModuleSymbolEx(SetupApiLib, 'SetupDiGetClassImageListEx' + NameSuffix, Result);
    @SetupDiGetClassImageIndex := GetModuleSymbolEx(SetupApiLib, 'SetupDiGetClassImageIndex', Result);
    @SetupDiDestroyClassImageList := GetModuleSymbolEx(SetupApiLib, 'SetupDiDestroyClassImageList', Result);
    @SetupDiGetClassDevPropertySheetsA := GetModuleSymbolEx(SetupApiLib, 'SetupDiGetClassDevPropertySheetsA', Result);
    @SetupDiGetClassDevPropertySheetsW := GetModuleSymbolEx(SetupApiLib, 'SetupDiGetClassDevPropertySheetsW', Result);
    @SetupDiGetClassDevPropertySheets := GetModuleSymbolEx(SetupApiLib, 'SetupDiGetClassDevPropertySheets' + NameSuffix, Result);
    @SetupDiAskForOEMDisk := GetModuleSymbolEx(SetupApiLib, 'SetupDiAskForOEMDisk', Result);
    @SetupDiSelectOEMDrv := GetModuleSymbolEx(SetupApiLib, 'SetupDiSelectOEMDrv', Result);
    @SetupDiClassNameFromGuidA := GetModuleSymbolEx(SetupApiLib, 'SetupDiClassNameFromGuidA', Result);
    @SetupDiClassNameFromGuidW := GetModuleSymbolEx(SetupApiLib, 'SetupDiClassNameFromGuidW', Result);
    @SetupDiClassNameFromGuid := GetModuleSymbolEx(SetupApiLib, 'SetupDiClassNameFromGuid' + NameSuffix, Result);
    @SetupDiClassNameFromGuidExA := GetModuleSymbolEx(SetupApiLib, 'SetupDiClassNameFromGuidExA', Result);
    @SetupDiClassNameFromGuidExW := GetModuleSymbolEx(SetupApiLib, 'SetupDiClassNameFromGuidExW', Result);
    @SetupDiClassNameFromGuidEx := GetModuleSymbolEx(SetupApiLib, 'SetupDiClassNameFromGuidEx' + NameSuffix, Result);
    @SetupDiClassGuidsFromNameA := GetModuleSymbolEx(SetupApiLib, 'SetupDiClassGuidsFromNameA', Result);
    @SetupDiClassGuidsFromNameW := GetModuleSymbolEx(SetupApiLib, 'SetupDiClassGuidsFromNameW', Result);
    @SetupDiClassGuidsFromName := GetModuleSymbolEx(SetupApiLib, 'SetupDiClassGuidsFromName' + NameSuffix, Result);
    @SetupDiClassGuidsFromNameExA := GetModuleSymbolEx(SetupApiLib, 'SetupDiClassGuidsFromNameExA', Result);
    @SetupDiClassGuidsFromNameExW := GetModuleSymbolEx(SetupApiLib, 'SetupDiClassGuidsFromNameExW', Result);
    @SetupDiClassGuidsFromNameEx := GetModuleSymbolEx(SetupApiLib, 'SetupDiClassGuidsFromNameEx' + NameSuffix, Result);
    @SetupDiGetHwProfileFriendlyNameA := GetModuleSymbolEx(SetupApiLib, 'SetupDiGetHwProfileFriendlyNameA', Result);
    @SetupDiGetHwProfileFriendlyNameW := GetModuleSymbolEx(SetupApiLib, 'SetupDiGetHwProfileFriendlyNameW', Result);
    @SetupDiGetHwProfileFriendlyName := GetModuleSymbolEx(SetupApiLib, 'SetupDiGetHwProfileFriendlyName' + NameSuffix, Result);
    @SetupDiGetHwProfileFriendlyNameExA := GetModuleSymbolEx(SetupApiLib, 'SetupDiGetHwProfileFriendlyNameExA', Result);
    @SetupDiGetHwProfileFriendlyNameExW := GetModuleSymbolEx(SetupApiLib, 'SetupDiGetHwProfileFriendlyNameExW', Result);
    @SetupDiGetHwProfileFriendlyNameEx := GetModuleSymbolEx(SetupApiLib, 'SetupDiGetHwProfileFriendlyNameEx' + NameSuffix, Result);
    @SetupDiGetWizardPage := GetModuleSymbolEx(SetupApiLib, 'SetupDiGetWizardPage', Result);
    @SetupDiGetSelectedDevice := GetModuleSymbolEx(SetupApiLib, 'SetupDiGetSelectedDevice', Result);
    @SetupDiSetSelectedDevice := GetModuleSymbolEx(SetupApiLib, 'SetupDiSetSelectedDevice', Result);
    @SetupDiGetActualSectionToInstallA := GetModuleSymbolEx(SetupApiLib, 'SetupDiGetActualSectionToInstallA', Result);
    @SetupDiGetActualSectionToInstallW := GetModuleSymbolEx(SetupApiLib, 'SetupDiGetActualSectionToInstallW', Result);
    @SetupDiGetActualSectionToInstall := GetModuleSymbolEx(SetupApiLib, 'SetupDiGetActualSectionToInstall' + NameSuffix, Result);
    {$IFDEF WINXP_UP}
    @SetupDiGetActualSectionToInstallExA := GetModuleSymbolEx(SetupApiLib, 'SetupDiGetActualSectionToInstallExA', Result);
    @SetupDiGetActualSectionToInstallExW := GetModuleSymbolEx(SetupApiLib, 'SetupDiGetActualSectionToInstallExW', Result);
    @SetupDiGetActualSectionToInstallEx := GetModuleSymbolEx(SetupApiLib, 'SetupDiGetActualSectionToInstallEx' + NameSuffix, Result);
    @SetupEnumInfSectionsA := GetModuleSymbolEx(SetupApiLib, 'SetupEnumInfSectionsA', Result);
    @SetupEnumInfSectionsW := GetModuleSymbolEx(SetupApiLib, 'SetupEnumInfSectionsW', Result);
    @SetupEnumInfSections := GetModuleSymbolEx(SetupApiLib, 'SetupEnumInfSections' + NameSuffix, Result);
    @SetupVerifyInfFileA := GetModuleSymbolEx(SetupApiLib, 'SetupVerifyInfFileA', Result);
    @SetupVerifyInfFileW := GetModuleSymbolEx(SetupApiLib, 'SetupVerifyInfFileW', Result);
    @SetupVerifyInfFile := GetModuleSymbolEx(SetupApiLib, 'SetupVerifyInfFile' + NameSuffix, Result);
    @SetupDiGetCustomDevicePropertyA := GetModuleSymbolEx(SetupApiLib, 'SetupDiGetCustomDevicePropertyA', Result);
    @SetupDiGetCustomDevicePropertyW := GetModuleSymbolEx(SetupApiLib, 'SetupDiGetCustomDevicePropertyW', Result);
    @SetupDiGetCustomDeviceProperty := GetModuleSymbolEx(SetupApiLib, 'SetupDiGetCustomDeviceProperty' + NameSuffix, Result);
    {$ENDIF WINXP_UP}
    if not Result then
      UnloadSetupApi;
  end;
  {$ELSE}
  Result := True;
  {$ENDIF SETUPAPI_LINKONREQUEST}
end;

procedure UnloadSetupApi;
begin
  {$IFDEF SETUPAPI_LINKONREQUEST}
  Dec(SetupApiLoadCount);
  if SetupApiLoadCount > 0 then
    Exit;
  ModuleLoader.UnloadModule(SetupApiLib);
  {$IFDEF WINXP_UP}
  SetupGetFileQueueCount := nil;
  SetupGetFileQueueFlags := nil;
  SetupSetFileQueueFlags := nil;
  {$ENDIF WINXP_UP}
  SetupGetInfInformationA := nil;
  SetupGetInfInformationW := nil;
  SetupGetInfInformation := nil;
  SetupQueryInfFileInformationA := nil;
  SetupQueryInfFileInformationW := nil;
  SetupQueryInfFileInformation := nil;
  {$IFDEF WIN2000_UP}
  SetupQueryInfOriginalFileInformationA := nil;
  SetupQueryInfOriginalFileInformationW := nil;
  SetupQueryInfOriginalFileInformation := nil;
  {$ENDIF WIN2000_UP}
  SetupQueryInfVersionInformationA := nil;
  SetupQueryInfVersionInformationW := nil;
  SetupQueryInfVersionInformation := nil;
  SetupGetInfFileListA := nil;
  SetupGetInfFileListW := nil;
  SetupGetInfFileList := nil;
  SetupOpenInfFileA := nil;
  SetupOpenInfFileW := nil;
  SetupOpenInfFile := nil;
  SetupOpenMasterInf := nil;
  SetupOpenAppendInfFileA := nil;
  SetupOpenAppendInfFileW := nil;
  SetupOpenAppendInfFile := nil;
  SetupCloseInfFile := nil;
  SetupFindFirstLineA := nil;
  SetupFindFirstLineW := nil;
  SetupFindFirstLine := nil;
  SetupFindNextLine := nil;
  SetupFindNextMatchLineA := nil;
  SetupFindNextMatchLineW := nil;
  SetupFindNextMatchLine := nil;
  SetupGetLineByIndexA := nil;
  SetupGetLineByIndexW := nil;
  SetupGetLineByIndex := nil;
  SetupGetLineCountA := nil;
  SetupGetLineCountW := nil;
  SetupGetLineCount := nil;
  SetupGetLineTextA := nil;
  SetupGetLineTextW := nil;
  SetupGetLineText := nil;
  SetupGetFieldCount := nil;
  SetupGetStringFieldA := nil;
  SetupGetStringFieldW := nil;
  SetupGetStringField := nil;
  SetupGetIntField := nil;
  SetupGetMultiSzFieldA := nil;
  SetupGetMultiSzFieldW := nil;
  SetupGetMultiSzField := nil;
  SetupGetBinaryField := nil;
  SetupGetFileCompressionInfoA := nil;
  SetupGetFileCompressionInfoW := nil;
  SetupGetFileCompressionInfo := nil;
  {$IFDEF WINXP_UP}
  SetupGetFileCompressionInfoExA := nil;
  SetupGetFileCompressionInfoExW := nil;
  SetupGetFileCompressionInfoEx := nil;
  {$ENDIF WINXP_UP}
  SetupDecompressOrCopyFileA := nil;
  SetupDecompressOrCopyFileW := nil;
  SetupDecompressOrCopyFile := nil;
  SetupGetSourceFileLocationA := nil;
  SetupGetSourceFileLocationW := nil;
  SetupGetSourceFileLocation := nil;
  SetupGetSourceFileSizeA := nil;
  SetupGetSourceFileSizeW := nil;
  SetupGetSourceFileSize := nil;
  SetupGetTargetPathA := nil;
  SetupGetTargetPathW := nil;
  SetupGetTargetPath := nil;
  SetupSetSourceListA := nil;
  SetupSetSourceListW := nil;
  SetupSetSourceList := nil;
  SetupCancelTemporarySourceList := nil;
  SetupAddToSourceListA := nil;
  SetupAddToSourceListW := nil;
  SetupAddToSourceList := nil;
  SetupRemoveFromSourceListA := nil;
  SetupRemoveFromSourceListW := nil;
  SetupRemoveFromSourceList := nil;
  SetupQuerySourceListA := nil;
  SetupQuerySourceListW := nil;
  SetupQuerySourceList := nil;
  SetupFreeSourceListA := nil;
  SetupFreeSourceListW := nil;
  SetupFreeSourceList := nil;
  SetupPromptForDiskA := nil;
  SetupPromptForDiskW := nil;
  SetupPromptForDisk := nil;
  SetupCopyErrorA := nil;
  SetupCopyErrorW := nil;
  SetupCopyError := nil;
  SetupRenameErrorA := nil;
  SetupRenameErrorW := nil;
  SetupRenameError := nil;
  SetupDeleteErrorA := nil;
  SetupDeleteErrorW := nil;
  SetupDeleteError := nil;
  {$IFDEF WIN2000_UP}
  SetupBackupErrorA := nil;
  SetupBackupErrorW := nil;
  SetupBackupError := nil;
  {$ENDIF WIN2000_UP}
  SetupSetDirectoryIdA := nil;
  SetupSetDirectoryIdW := nil;
  SetupSetDirectoryId := nil;
  SetupSetDirectoryIdExA := nil;
  SetupSetDirectoryIdExW := nil;
  SetupSetDirectoryIdEx := nil;
  SetupGetSourceInfoA := nil;
  SetupGetSourceInfoW := nil;
  SetupGetSourceInfo := nil;
  SetupInstallFileA := nil;
  SetupInstallFileW := nil;
  SetupInstallFile := nil;
  SetupInstallFileExA := nil;
  SetupInstallFileExW := nil;
  SetupInstallFileEx := nil;
  SetupOpenFileQueue := nil;
  SetupCloseFileQueue := nil;
  {$IFDEF WIN2000_UP}
  SetupSetFileQueueAlternatePlatformA := nil;
  SetupSetFileQueueAlternatePlatformW := nil;
  SetupSetFileQueueAlternatePlatform := nil;
  {$ENDIF WIN2000_UP}
  SetupSetPlatformPathOverrideA := nil;
  SetupSetPlatformPathOverrideW := nil;
  SetupSetPlatformPathOverride := nil;
  SetupQueueCopyA := nil;
  SetupQueueCopyW := nil;
  SetupQueueCopy := nil;
  {$IFDEF WIN2000_UP}
  SetupQueueCopyIndirectA := nil;
  SetupQueueCopyIndirectW := nil;
  SetupQueueCopyIndirect := nil;
  {$ENDIF WIN2000_UP}
  SetupQueueDefaultCopyA := nil;
  SetupQueueDefaultCopyW := nil;
  SetupQueueDefaultCopy := nil;
  SetupQueueCopySectionA := nil;
  SetupQueueCopySectionW := nil;
  SetupQueueCopySection := nil;
  SetupQueueDeleteA := nil;
  SetupQueueDeleteW := nil;
  SetupQueueDelete := nil;
  SetupQueueDeleteSectionA := nil;
  SetupQueueDeleteSectionW := nil;
  SetupQueueDeleteSection := nil;
  SetupQueueRenameA := nil;
  SetupQueueRenameW := nil;
  SetupQueueRename := nil;
  SetupQueueRenameSectionA := nil;
  SetupQueueRenameSectionW := nil;
  SetupQueueRenameSection := nil;
  SetupCommitFileQueueA := nil;
  SetupCommitFileQueueW := nil;
  SetupCommitFileQueue := nil;
  SetupScanFileQueueA := nil;
  SetupScanFileQueueW := nil;
  SetupScanFileQueue := nil;
  SetupCopyOEMInfA := nil;
  SetupCopyOEMInfW := nil;
  SetupCopyOEMInf := nil;
  {$IFDEF WINXP_UP}
  SetupUninstallOEMInfA := nil;
  SetupUninstallOEMInfW := nil;
  SetupUninstallOEMInf := nil;
  SetupUninstallNewlyCopiedInfs := nil;
  {$ENDIF WINXP_UP}
  SetupCreateDiskSpaceListA := nil;
  SetupCreateDiskSpaceListW := nil;
  SetupCreateDiskSpaceList := nil;
  SetupDuplicateDiskSpaceListA := nil;
  SetupDuplicateDiskSpaceListW := nil;
  SetupDuplicateDiskSpaceList := nil;
  SetupDestroyDiskSpaceList := nil;
  SetupQueryDrivesInDiskSpaceListA := nil;
  SetupQueryDrivesInDiskSpaceListW := nil;
  SetupQueryDrivesInDiskSpaceList := nil;
  SetupQuerySpaceRequiredOnDriveA := nil;
  SetupQuerySpaceRequiredOnDriveW := nil;
  SetupQuerySpaceRequiredOnDrive := nil;
  SetupAdjustDiskSpaceListA := nil;
  SetupAdjustDiskSpaceListW := nil;
  SetupAdjustDiskSpaceList := nil;
  SetupAddToDiskSpaceListA := nil;
  SetupAddToDiskSpaceListW := nil;
  SetupAddToDiskSpaceList := nil;
  SetupAddSectionToDiskSpaceListA := nil;
  SetupAddSectionToDiskSpaceListW := nil;
  SetupAddSectionToDiskSpaceList := nil;
  SetupAddInstallSectionToDiskSpaceListA := nil;
  SetupAddInstallSectionToDiskSpaceListW := nil;
  SetupAddInstallSectionToDiskSpaceList := nil;
  SetupRemoveFromDiskSpaceListA := nil;
  SetupRemoveFromDiskSpaceListW := nil;
  SetupRemoveFromDiskSpaceList := nil;
  SetupRemoveSectionFromDiskSpaceListA := nil;
  SetupRemoveSectionFromDiskSpaceListW := nil;
  SetupRemoveSectionFromDiskSpaceList := nil;
  SetupRemoveInstallSectionFromDiskSpaceListA := nil;
  SetupRemoveInstallSectionFromDiskSpaceListW := nil;
  SetupRemoveInstallSectionFromDiskSpaceList := nil;
  SetupIterateCabinetA := nil;
  SetupIterateCabinetW := nil;
  SetupIterateCabinet := nil;
  SetupPromptReboot := nil;
  SetupInitDefaultQueueCallback := nil;
  SetupInitDefaultQueueCallbackEx := nil;
  SetupTermDefaultQueueCallback := nil;
  SetupDefaultQueueCallbackA := nil;
  SetupDefaultQueueCallbackW := nil;
  SetupDefaultQueueCallback := nil;
  SetupInstallFromInfSectionA := nil;
  SetupInstallFromInfSectionW := nil;
  SetupInstallFromInfSection := nil;
  SetupInstallFilesFromInfSectionA := nil;
  SetupInstallFilesFromInfSectionW := nil;
  SetupInstallFilesFromInfSection := nil;
  SetupInstallServicesFromInfSectionA := nil;
  SetupInstallServicesFromInfSectionW := nil;
  SetupInstallServicesFromInfSection := nil;
  SetupInstallServicesFromInfSectionExA := nil;
  SetupInstallServicesFromInfSectionExW := nil;
  SetupInstallServicesFromInfSectionEx := nil;
  {$IFDEF WINXP_UP}
  InstallHinfSectionA := nil;
  InstallHinfSectionW := nil;
  InstallHinfSection := nil;
  {$ENDIF WINXP_UP}
  SetupInitializeFileLogA := nil;
  SetupInitializeFileLogW := nil;
  SetupInitializeFileLog := nil;
  SetupTerminateFileLog := nil;
  SetupLogFileA := nil;
  SetupLogFileW := nil;
  SetupLogFile := nil;
  SetupRemoveFileLogEntryA := nil;
  SetupRemoveFileLogEntryW := nil;
  SetupRemoveFileLogEntry := nil;
  SetupQueryFileLogA := nil;
  SetupQueryFileLogW := nil;
  SetupQueryFileLog := nil;
  SetupOpenLog := nil;
  SetupLogErrorA := nil;
  SetupLogErrorW := nil;
  SetupLogError := nil;
  SetupCloseLog := nil;
  {$IFDEF WIN2000_UP}
  SetupGetBackupInformationA := nil;
  SetupGetBackupInformationW := nil;
  SetupGetBackupInformation := nil;
  {$ENDIF WIN2000_UP}
  {$IFDEF WINXP_UP}
  SetupPrepareQueueForRestoreA := nil;
  SetupPrepareQueueForRestoreW := nil;
  SetupPrepareQueueForRestore := nil;
  SetupSetNonInteractiveMode := nil;
  SetupGetNonInteractiveMode := nil;
  {$ENDIF WINXP_UP}
  SetupDiCreateDeviceInfoList := nil;
  SetupDiCreateDeviceInfoListExA := nil;
  SetupDiCreateDeviceInfoListExW := nil;
  SetupDiCreateDeviceInfoListEx := nil;
  SetupDiGetDeviceInfoListClass := nil;
  SetupDiGetDeviceInfoListDetailA := nil;
  SetupDiGetDeviceInfoListDetailW := nil;
  SetupDiGetDeviceInfoListDetail := nil;
  SetupDiCreateDeviceInfoA := nil;
  SetupDiCreateDeviceInfoW := nil;
  SetupDiCreateDeviceInfo := nil;
  SetupDiOpenDeviceInfoA := nil;
  SetupDiOpenDeviceInfoW := nil;
  SetupDiOpenDeviceInfo := nil;
  SetupDiGetDeviceInstanceIdA := nil;
  SetupDiGetDeviceInstanceIdW := nil;
  SetupDiGetDeviceInstanceId := nil;
  SetupDiDeleteDeviceInfo := nil;
  SetupDiEnumDeviceInfo := nil;
  SetupDiDestroyDeviceInfoList := nil;
  SetupDiEnumDeviceInterfaces := nil;
  SetupDiEnumInterfaceDevice := nil;
  SetupDiCreateDeviceInterfaceA := nil;
  SetupDiCreateInterfaceDeviceA := nil;
  SetupDiCreateDeviceInterfaceW := nil;
  SetupDiCreateInterfaceDeviceW := nil;
  SetupDiCreateDeviceInterface := nil;
  SetupDiCreateInterfaceDevice := nil;
  SetupDiOpenDeviceInterfaceA := nil;
  SetupDiOpenInterfaceDeviceA := nil;
  SetupDiOpenDeviceInterfaceW := nil;
  SetupDiOpenInterfaceDeviceW := nil;
  SetupDiOpenDeviceInterface := nil;
  SetupDiOpenInterfaceDevice := nil;
  SetupDiGetDeviceInterfaceAlias := nil;
  SetupDiGetInterfaceDeviceAlias := nil;
  SetupDiDeleteDeviceInterfaceData := nil;
  SetupDiDeleteInterfaceDeviceData := nil;
  SetupDiRemoveDeviceInterface := nil;
  SetupDiRemoveInterfaceDevice := nil;
  SetupDiGetDeviceInterfaceDetailA := nil;
  SetupDiGetInterfaceDeviceDetailA := nil;
  SetupDiGetDeviceInterfaceDetailW := nil;
  SetupDiGetInterfaceDeviceDetailW := nil;
  SetupDiGetDeviceInterfaceDetail := nil;
  SetupDiGetInterfaceDeviceDetail := nil;
  SetupDiInstallDeviceInterfaces := nil;
  SetupDiInstallInterfaceDevices := nil;
  {$IFDEF WINXP_UP}
  SetupDiSetDeviceInterfaceDefault := nil;
  {$ENDIF WINXP_UP}
  SetupDiRegisterDeviceInfo := nil;
  SetupDiBuildDriverInfoList := nil;
  SetupDiCancelDriverInfoSearch := nil;
  SetupDiEnumDriverInfoA := nil;
  SetupDiEnumDriverInfoW := nil;
  SetupDiEnumDriverInfo := nil;
  SetupDiGetSelectedDriverA := nil;
  SetupDiGetSelectedDriverW := nil;
  SetupDiGetSelectedDriver := nil;
  SetupDiSetSelectedDriverA := nil;
  SetupDiSetSelectedDriverW := nil;
  SetupDiSetSelectedDriver := nil;
  SetupDiGetDriverInfoDetailA := nil;
  SetupDiGetDriverInfoDetailW := nil;
  SetupDiGetDriverInfoDetail := nil;
  SetupDiDestroyDriverInfoList := nil;
  SetupDiGetClassDevsA := nil;
  SetupDiGetClassDevsW := nil;
  SetupDiGetClassDevs := nil;
  SetupDiGetClassDevsExA := nil;
  SetupDiGetClassDevsExW := nil;
  SetupDiGetClassDevsEx := nil;
  SetupDiGetINFClassA := nil;
  SetupDiGetINFClassW := nil;
  SetupDiGetINFClass := nil;
  SetupDiBuildClassInfoList := nil;
  SetupDiBuildClassInfoListExA := nil;
  SetupDiBuildClassInfoListExW := nil;
  SetupDiBuildClassInfoListEx := nil;
  SetupDiGetClassDescriptionA := nil;
  SetupDiGetClassDescriptionW := nil;
  SetupDiGetClassDescription := nil;
  SetupDiGetClassDescriptionExA := nil;
  SetupDiGetClassDescriptionExW := nil;
  SetupDiGetClassDescriptionEx := nil;
  SetupDiCallClassInstaller := nil;
  SetupDiSelectDevice := nil;
  SetupDiSelectBestCompatDrv := nil;
  SetupDiInstallDevice := nil;
  SetupDiInstallDriverFiles := nil;
  SetupDiRegisterCoDeviceInstallers := nil;
  SetupDiRemoveDevice := nil;
  SetupDiUnremoveDevice := nil;
  SetupDiMoveDuplicateDevice := nil;
  SetupDiChangeState := nil;
  SetupDiInstallClassA := nil;
  SetupDiInstallClassW := nil;
  SetupDiInstallClass := nil;
  SetupDiInstallClassExA := nil;
  SetupDiInstallClassExW := nil;
  SetupDiInstallClassEx := nil;
  SetupDiOpenClassRegKey := nil;
  SetupDiOpenClassRegKeyExA := nil;
  SetupDiOpenClassRegKeyExW := nil;
  SetupDiOpenClassRegKeyEx := nil;
  SetupDiCreateDeviceInterfaceRegKeyA := nil;
  SetupDiCreateInterfaceDeviceRegKeyA := nil;
  SetupDiCreateDeviceInterfaceRegKeyW := nil;
  SetupDiCreateInterfaceDeviceRegKeyW := nil;
  SetupDiCreateDeviceInterfaceRegKey := nil;
  SetupDiCreateInterfaceDeviceRegKey := nil;
  SetupDiOpenDeviceInterfaceRegKey := nil;
  SetupDiOpenInterfaceDeviceRegKey := nil;
  SetupDiDeleteDeviceInterfaceRegKey := nil;
  SetupDiDeleteInterfaceDeviceRegKey := nil;
  SetupDiCreateDevRegKeyA := nil;
  SetupDiCreateDevRegKeyW := nil;
  SetupDiCreateDevRegKey := nil;
  SetupDiOpenDevRegKey := nil;
  SetupDiDeleteDevRegKey := nil;
  SetupDiGetHwProfileList := nil;
  SetupDiGetHwProfileListExA := nil;
  SetupDiGetHwProfileListExW := nil;
  SetupDiGetHwProfileListEx := nil;
  SetupDiGetDeviceRegistryPropertyA := nil;
  SetupDiGetDeviceRegistryPropertyW := nil;
  SetupDiGetDeviceRegistryProperty := nil;
  {$IFDEF WINXP_UP}
  SetupDiGetClassRegistryPropertyA := nil;
  SetupDiGetClassRegistryPropertyW := nil;
  SetupDiGetClassRegistryProperty := nil;
  {$ENDIF WINXP_UP}
  SetupDiSetDeviceRegistryPropertyA := nil;
  SetupDiSetDeviceRegistryPropertyW := nil;
  SetupDiSetDeviceRegistryProperty := nil;
  {$IFDEF WINXP_UP}
  SetupDiSetClassRegistryPropertyA := nil;
  SetupDiSetClassRegistryPropertyW := nil;
  SetupDiSetClassRegistryProperty := nil;
  {$ENDIF WINXP_UP}
  SetupDiGetDeviceInstallParamsA := nil;
  SetupDiGetDeviceInstallParamsW := nil;
  SetupDiGetDeviceInstallParams := nil;
  SetupDiGetClassInstallParamsA := nil;
  SetupDiGetClassInstallParamsW := nil;
  SetupDiGetClassInstallParams := nil;
  SetupDiSetDeviceInstallParamsA := nil;
  SetupDiSetDeviceInstallParamsW := nil;
  SetupDiSetDeviceInstallParams := nil;
  SetupDiSetClassInstallParamsA := nil;
  SetupDiSetClassInstallParamsW := nil;
  SetupDiSetClassInstallParams := nil;
  SetupDiGetDriverInstallParamsA := nil;
  SetupDiGetDriverInstallParamsW := nil;
  SetupDiGetDriverInstallParams := nil;
  SetupDiSetDriverInstallParamsA := nil;
  SetupDiSetDriverInstallParamsW := nil;
  SetupDiSetDriverInstallParams := nil;
  SetupDiLoadClassIcon := nil;
  SetupDiDrawMiniIcon := nil;
  SetupDiGetClassBitmapIndex := nil;
  SetupDiGetClassImageList := nil;
  SetupDiGetClassImageListExA := nil;
  SetupDiGetClassImageListExW := nil;
  SetupDiGetClassImageListEx := nil;
  SetupDiGetClassImageIndex := nil;
  SetupDiDestroyClassImageList := nil;
  SetupDiGetClassDevPropertySheetsA := nil;
  SetupDiGetClassDevPropertySheetsW := nil;
  SetupDiGetClassDevPropertySheets := nil;
  SetupDiAskForOEMDisk := nil;
  SetupDiSelectOEMDrv := nil;
  SetupDiClassNameFromGuidA := nil;
  SetupDiClassNameFromGuidW := nil;
  SetupDiClassNameFromGuid := nil;
  SetupDiClassNameFromGuidExA := nil;
  SetupDiClassNameFromGuidExW := nil;
  SetupDiClassNameFromGuidEx := nil;
  SetupDiClassGuidsFromNameA := nil;
  SetupDiClassGuidsFromNameW := nil;
  SetupDiClassGuidsFromName := nil;
  SetupDiClassGuidsFromNameExA := nil;
  SetupDiClassGuidsFromNameExW := nil;
  SetupDiClassGuidsFromNameEx := nil;
  SetupDiGetHwProfileFriendlyNameA := nil;
  SetupDiGetHwProfileFriendlyNameW := nil;
  SetupDiGetHwProfileFriendlyName := nil;
  SetupDiGetHwProfileFriendlyNameExA := nil;
  SetupDiGetHwProfileFriendlyNameExW := nil;
  SetupDiGetHwProfileFriendlyNameEx := nil;
  SetupDiGetWizardPage := nil;
  SetupDiGetSelectedDevice := nil;
  SetupDiSetSelectedDevice := nil;
  SetupDiGetActualSectionToInstallA := nil;
  SetupDiGetActualSectionToInstallW := nil;
  SetupDiGetActualSectionToInstall := nil;
  {$IFDEF WINXP_UP}
  SetupDiGetActualSectionToInstallExA := nil;
  SetupDiGetActualSectionToInstallExW := nil;
  SetupDiGetActualSectionToInstallEx := nil;
  SetupEnumInfSectionsA := nil;
  SetupEnumInfSectionsW := nil;
  SetupEnumInfSections := nil;
  SetupVerifyInfFileA := nil;
  SetupVerifyInfFileW := nil;
  SetupVerifyInfFile := nil;
  SetupDiGetCustomDevicePropertyA := nil;
  SetupDiGetCustomDevicePropertyW := nil;
  SetupDiGetCustomDeviceProperty := nil;
  {$ENDIF WINXP_UP}
  {$ENDIF SETUPAPI_LINKONREQUEST}
end;

{$IFNDEF SETUPAPI_LINKONREQUEST}

{$IFDEF WINXP_UP}
function SetupGetFileQueueCount; external SetupApiModuleName name 'SetupGetFileQueueCount';
function SetupGetFileQueueFlags; external SetupApiModuleName name 'SetupGetFileQueueFlags';
function SetupSetFileQueueFlags; external SetupApiModuleName name 'SetupSetFileQueueFlags';
{$ENDIF WINXP_UP}
function SetupGetInfInformationA; external SetupApiModuleName name 'SetupGetInfInformationA';
function SetupGetInfInformationW; external SetupApiModuleName name 'SetupGetInfInformationW';
function SetupGetInfInformation; external SetupApiModuleName name 'SetupGetInfInformation' + NameSuffix;
function SetupQueryInfFileInformationA; external SetupApiModuleName name 'SetupQueryInfFileInformationA';
function SetupQueryInfFileInformationW; external SetupApiModuleName name 'SetupQueryInfFileInformationW';
function SetupQueryInfFileInformation; external SetupApiModuleName name 'SetupQueryInfFileInformation' + NameSuffix;
{$IFDEF WIN2000_UP}
function SetupQueryInfOriginalFileInformationA; external SetupApiModuleName name 'SetupQueryInfOriginalFileInformationA';
function SetupQueryInfOriginalFileInformationW; external SetupApiModuleName name 'SetupQueryInfOriginalFileInformationW';
function SetupQueryInfOriginalFileInformation; external SetupApiModuleName name 'SetupQueryInfOriginalFileInformation' + NameSuffix;
{$ENDIF WIN2000_UP}
function SetupQueryInfVersionInformationA; external SetupApiModuleName name 'SetupQueryInfVersionInformationA';
function SetupQueryInfVersionInformationW; external SetupApiModuleName name 'SetupQueryInfVersionInformationW';
function SetupQueryInfVersionInformation; external SetupApiModuleName name 'SetupQueryInfVersionInformation' + NameSuffix;
function SetupGetInfFileListA; external SetupApiModuleName name 'SetupGetInfFileListA';
function SetupGetInfFileListW; external SetupApiModuleName name 'SetupGetInfFileListW';
function SetupGetInfFileList; external SetupApiModuleName name 'SetupGetInfFileList' + NameSuffix;
function SetupOpenInfFileA; external SetupApiModuleName name 'SetupOpenInfFileA';
function SetupOpenInfFileW; external SetupApiModuleName name 'SetupOpenInfFileW';
function SetupOpenInfFile; external SetupApiModuleName name 'SetupOpenInfFile' + NameSuffix;
function SetupOpenMasterInf; external SetupApiModuleName name 'SetupOpenMasterInf';
function SetupOpenAppendInfFileA; external SetupApiModuleName name 'SetupOpenAppendInfFileA';
function SetupOpenAppendInfFileW; external SetupApiModuleName name 'SetupOpenAppendInfFileW';
function SetupOpenAppendInfFile; external SetupApiModuleName name 'SetupOpenAppendInfFile' + NameSuffix;
procedure SetupCloseInfFile; external SetupApiModuleName name 'SetupCloseInfFile';
function SetupFindFirstLineA; external SetupApiModuleName name 'SetupFindFirstLineA';
function SetupFindFirstLineW; external SetupApiModuleName name 'SetupFindFirstLineW';
function SetupFindFirstLine; external SetupApiModuleName name 'SetupFindFirstLine' + NameSuffix;
function SetupFindNextLine; external SetupApiModuleName name 'SetupFindNextLine';
function SetupFindNextMatchLineA; external SetupApiModuleName name 'SetupFindNextMatchLineA';
function SetupFindNextMatchLineW; external SetupApiModuleName name 'SetupFindNextMatchLineW';
function SetupFindNextMatchLine; external SetupApiModuleName name 'SetupFindNextMatchLine' + NameSuffix;
function SetupGetLineByIndexA; external SetupApiModuleName name 'SetupGetLineByIndexA';
function SetupGetLineByIndexW; external SetupApiModuleName name 'SetupGetLineByIndexW';
function SetupGetLineByIndex; external SetupApiModuleName name 'SetupGetLineByIndex' + NameSuffix;
function SetupGetLineCountA; external SetupApiModuleName name 'SetupGetLineCountA';
function SetupGetLineCountW; external SetupApiModuleName name 'SetupGetLineCountW';
function SetupGetLineCount; external SetupApiModuleName name 'SetupGetLineCount' + NameSuffix;
function SetupGetLineTextA; external SetupApiModuleName name 'SetupGetLineTextA';
function SetupGetLineTextW; external SetupApiModuleName name 'SetupGetLineTextW';
function SetupGetLineText; external SetupApiModuleName name 'SetupGetLineText' + NameSuffix;
function SetupGetFieldCount; external SetupApiModuleName name 'SetupGetFieldCount';
function SetupGetStringFieldA; external SetupApiModuleName name 'SetupGetStringFieldA';
function SetupGetStringFieldW; external SetupApiModuleName name 'SetupGetStringFieldW';
function SetupGetStringField; external SetupApiModuleName name 'SetupGetStringField' + NameSuffix;
function SetupGetIntField; external SetupApiModuleName name 'SetupGetIntField';
function SetupGetMultiSzFieldA; external SetupApiModuleName name 'SetupGetMultiSzFieldA';
function SetupGetMultiSzFieldW; external SetupApiModuleName name 'SetupGetMultiSzFieldW';
function SetupGetMultiSzField; external SetupApiModuleName name 'SetupGetMultiSzField' + NameSuffix;
function SetupGetBinaryField; external SetupApiModuleName name 'SetupGetBinaryField';
function SetupGetFileCompressionInfoA; external SetupApiModuleName name 'SetupGetFileCompressionInfoA';
function SetupGetFileCompressionInfoW; external SetupApiModuleName name 'SetupGetFileCompressionInfoW';
function SetupGetFileCompressionInfo; external SetupApiModuleName name 'SetupGetFileCompressionInfo' + NameSuffix;
{$IFDEF WINXP_UP}
function SetupGetFileCompressionInfoExA; external SetupApiModuleName name 'SetupGetFileCompressionInfoExA';
function SetupGetFileCompressionInfoExW; external SetupApiModuleName name 'SetupGetFileCompressionInfoExW';
function SetupGetFileCompressionInfoEx; external SetupApiModuleName name 'SetupGetFileCompressionInfoEx' + NameSuffix;
{$ENDIF WINXP_UP}
function SetupDecompressOrCopyFileA; external SetupApiModuleName name 'SetupDecompressOrCopyFileA';
function SetupDecompressOrCopyFileW; external SetupApiModuleName name 'SetupDecompressOrCopyFileW';
function SetupDecompressOrCopyFile; external SetupApiModuleName name 'SetupDecompressOrCopyFile' + NameSuffix;
function SetupGetSourceFileLocationA; external SetupApiModuleName name 'SetupGetSourceFileLocationA';
function SetupGetSourceFileLocationW; external SetupApiModuleName name 'SetupGetSourceFileLocationW';
function SetupGetSourceFileLocation; external SetupApiModuleName name 'SetupGetSourceFileLocation' + NameSuffix;
function SetupGetSourceFileSizeA; external SetupApiModuleName name 'SetupGetSourceFileSizeA';
function SetupGetSourceFileSizeW; external SetupApiModuleName name 'SetupGetSourceFileSizeW';
function SetupGetSourceFileSize; external SetupApiModuleName name 'SetupGetSourceFileSize' + NameSuffix;
function SetupGetTargetPathA; external SetupApiModuleName name 'SetupGetTargetPathA';
function SetupGetTargetPathW; external SetupApiModuleName name 'SetupGetTargetPathW';
function SetupGetTargetPath; external SetupApiModuleName name 'SetupGetTargetPath' + NameSuffix;
function SetupSetSourceListA; external SetupApiModuleName name 'SetupSetSourceListA';
function SetupSetSourceListW; external SetupApiModuleName name 'SetupSetSourceListW';
function SetupSetSourceList; external SetupApiModuleName name 'SetupSetSourceList' + NameSuffix;
function SetupCancelTemporarySourceList; external SetupApiModuleName name 'SetupCancelTemporarySourceList';
function SetupAddToSourceListA; external SetupApiModuleName name 'SetupAddToSourceListA';
function SetupAddToSourceListW; external SetupApiModuleName name 'SetupAddToSourceListW';
function SetupAddToSourceList; external SetupApiModuleName name 'SetupAddToSourceList' + NameSuffix;
function SetupRemoveFromSourceListA; external SetupApiModuleName name 'SetupRemoveFromSourceListA';
function SetupRemoveFromSourceListW; external SetupApiModuleName name 'SetupRemoveFromSourceListW';
function SetupRemoveFromSourceList; external SetupApiModuleName name 'SetupRemoveFromSourceList' + NameSuffix;
function SetupQuerySourceListA; external SetupApiModuleName name 'SetupQuerySourceListA';
function SetupQuerySourceListW; external SetupApiModuleName name 'SetupQuerySourceListW';
function SetupQuerySourceList; external SetupApiModuleName name 'SetupQuerySourceList' + NameSuffix;
function SetupFreeSourceListA; external SetupApiModuleName name 'SetupFreeSourceListA';
function SetupFreeSourceListW; external SetupApiModuleName name 'SetupFreeSourceListW';
function SetupFreeSourceList; external SetupApiModuleName name 'SetupFreeSourceList' + NameSuffix;
function SetupPromptForDiskA; external SetupApiModuleName name 'SetupPromptForDiskA';
function SetupPromptForDiskW; external SetupApiModuleName name 'SetupPromptForDiskW';
function SetupPromptForDisk; external SetupApiModuleName name 'SetupPromptForDisk' + NameSuffix;
function SetupCopyErrorA; external SetupApiModuleName name 'SetupCopyErrorA';
function SetupCopyErrorW; external SetupApiModuleName name 'SetupCopyErrorW';
function SetupCopyError; external SetupApiModuleName name 'SetupCopyError' + NameSuffix;
function SetupRenameErrorA; external SetupApiModuleName name 'SetupRenameErrorA';
function SetupRenameErrorW; external SetupApiModuleName name 'SetupRenameErrorW';
function SetupRenameError; external SetupApiModuleName name 'SetupRenameError' + NameSuffix;
function SetupDeleteErrorA; external SetupApiModuleName name 'SetupDeleteErrorA';
function SetupDeleteErrorW; external SetupApiModuleName name 'SetupDeleteErrorW';
function SetupDeleteError; external SetupApiModuleName name 'SetupDeleteError' + NameSuffix;
{$IFDEF WIN2000_UP}
function SetupBackupErrorA; external SetupApiModuleName name 'SetupBackupErrorA';
function SetupBackupErrorW; external SetupApiModuleName name 'SetupBackupErrorW';
function SetupBackupError; external SetupApiModuleName name 'SetupBackupError' + NameSuffix;
{$ENDIF WIN2000_UP}
function SetupSetDirectoryIdA; external SetupApiModuleName name 'SetupSetDirectoryIdA';
function SetupSetDirectoryIdW; external SetupApiModuleName name 'SetupSetDirectoryIdW';
function SetupSetDirectoryId; external SetupApiModuleName name 'SetupSetDirectoryId' + NameSuffix;
function SetupSetDirectoryIdExA; external SetupApiModuleName name 'SetupSetDirectoryIdExA';
function SetupSetDirectoryIdExW; external SetupApiModuleName name 'SetupSetDirectoryIdExW';
function SetupSetDirectoryIdEx; external SetupApiModuleName name 'SetupSetDirectoryIdEx' + NameSuffix;
function SetupGetSourceInfoA; external SetupApiModuleName name 'SetupGetSourceInfoA';
function SetupGetSourceInfoW; external SetupApiModuleName name 'SetupGetSourceInfoW';
function SetupGetSourceInfo; external SetupApiModuleName name 'SetupGetSourceInfo' + NameSuffix;
function SetupInstallFileA; external SetupApiModuleName name 'SetupInstallFileA';
function SetupInstallFileW; external SetupApiModuleName name 'SetupInstallFileW';
function SetupInstallFile; external SetupApiModuleName name 'SetupInstallFile' + NameSuffix;
function SetupInstallFileExA; external SetupApiModuleName name 'SetupInstallFileExA';
function SetupInstallFileExW; external SetupApiModuleName name 'SetupInstallFileExW';
function SetupInstallFileEx; external SetupApiModuleName name 'SetupInstallFileEx' + NameSuffix;
function SetupOpenFileQueue; external SetupApiModuleName name 'SetupOpenFileQueue';
function SetupCloseFileQueue; external SetupApiModuleName name 'SetupCloseFileQueue';
{$IFDEF WIN2000_UP}
function SetupSetFileQueueAlternatePlatformA; external SetupApiModuleName name 'SetupSetFileQueueAlternatePlatformA';
function SetupSetFileQueueAlternatePlatformW; external SetupApiModuleName name 'SetupSetFileQueueAlternatePlatformW';
function SetupSetFileQueueAlternatePlatform; external SetupApiModuleName name 'SetupSetFileQueueAlternatePlatform' + NameSuffix;
{$ENDIF WIN2000_UP}
function SetupSetPlatformPathOverrideA; external SetupApiModuleName name 'SetupSetPlatformPathOverrideA';
function SetupSetPlatformPathOverrideW; external SetupApiModuleName name 'SetupSetPlatformPathOverrideW';
function SetupSetPlatformPathOverride; external SetupApiModuleName name 'SetupSetPlatformPathOverride' + NameSuffix;
function SetupQueueCopyA; external SetupApiModuleName name 'SetupQueueCopyA';
function SetupQueueCopyW; external SetupApiModuleName name 'SetupQueueCopyW';
function SetupQueueCopy; external SetupApiModuleName name 'SetupQueueCopy' + NameSuffix;
{$IFDEF WIN2000_UP}
function SetupQueueCopyIndirectA; external SetupApiModuleName name 'SetupQueueCopyIndirectA';
function SetupQueueCopyIndirectW; external SetupApiModuleName name 'SetupQueueCopyIndirectW';
function SetupQueueCopyIndirect; external SetupApiModuleName name 'SetupQueueCopyIndirect' + NameSuffix;
{$ENDIF WIN2000_UP}
function SetupQueueDefaultCopyA; external SetupApiModuleName name 'SetupQueueDefaultCopyA';
function SetupQueueDefaultCopyW; external SetupApiModuleName name 'SetupQueueDefaultCopyW';
function SetupQueueDefaultCopy; external SetupApiModuleName name 'SetupQueueDefaultCopy' + NameSuffix;
function SetupQueueCopySectionA; external SetupApiModuleName name 'SetupQueueCopySectionA';
function SetupQueueCopySectionW; external SetupApiModuleName name 'SetupQueueCopySectionW';
function SetupQueueCopySection; external SetupApiModuleName name 'SetupQueueCopySection' + NameSuffix;
function SetupQueueDeleteA; external SetupApiModuleName name 'SetupQueueDeleteA';
function SetupQueueDeleteW; external SetupApiModuleName name 'SetupQueueDeleteW';
function SetupQueueDelete; external SetupApiModuleName name 'SetupQueueDelete' + NameSuffix;
function SetupQueueDeleteSectionA; external SetupApiModuleName name 'SetupQueueDeleteSectionA';
function SetupQueueDeleteSectionW; external SetupApiModuleName name 'SetupQueueDeleteSectionW';
function SetupQueueDeleteSection; external SetupApiModuleName name 'SetupQueueDeleteSection' + NameSuffix;
function SetupQueueRenameA; external SetupApiModuleName name 'SetupQueueRenameA';
function SetupQueueRenameW; external SetupApiModuleName name 'SetupQueueRenameW';
function SetupQueueRename; external SetupApiModuleName name 'SetupQueueRename' + NameSuffix;
function SetupQueueRenameSectionA; external SetupApiModuleName name 'SetupQueueRenameSectionA';
function SetupQueueRenameSectionW; external SetupApiModuleName name 'SetupQueueRenameSectionW';
function SetupQueueRenameSection; external SetupApiModuleName name 'SetupQueueRenameSection' + NameSuffix;
function SetupCommitFileQueueA; external SetupApiModuleName name 'SetupCommitFileQueueA';
function SetupCommitFileQueueW; external SetupApiModuleName name 'SetupCommitFileQueueW';
function SetupCommitFileQueue; external SetupApiModuleName name 'SetupCommitFileQueue' + NameSuffix;
function SetupScanFileQueueA; external SetupApiModuleName name 'SetupScanFileQueueA';
function SetupScanFileQueueW; external SetupApiModuleName name 'SetupScanFileQueueW';
function SetupScanFileQueue; external SetupApiModuleName name 'SetupScanFileQueue' + NameSuffix;
function SetupCopyOEMInfA; external SetupApiModuleName name 'SetupCopyOEMInfA';
function SetupCopyOEMInfW; external SetupApiModuleName name 'SetupCopyOEMInfW';
function SetupCopyOEMInf; external SetupApiModuleName name 'SetupCopyOEMInf' + NameSuffix;
{$IFDEF WINXP_UP}
function SetupUninstallOEMInfA; external SetupApiModuleName name 'SetupUninstallOEMInfA';
function SetupUninstallOEMInfW; external SetupApiModuleName name 'SetupUninstallOEMInfW';
function SetupUninstallOEMInf; external SetupApiModuleName name 'SetupUninstallOEMInf' + NameSuffix;
function SetupUninstallNewlyCopiedInfs; external SetupApiModuleName name 'SetupUninstallNewlyCopiedInfs';
{$ENDIF WINXP_UP}
function SetupCreateDiskSpaceListA; external SetupApiModuleName name 'SetupCreateDiskSpaceListA';
function SetupCreateDiskSpaceListW; external SetupApiModuleName name 'SetupCreateDiskSpaceListW';
function SetupCreateDiskSpaceList; external SetupApiModuleName name 'SetupCreateDiskSpaceList' + NameSuffix;
function SetupDuplicateDiskSpaceListA; external SetupApiModuleName name 'SetupDuplicateDiskSpaceListA';
function SetupDuplicateDiskSpaceListW; external SetupApiModuleName name 'SetupDuplicateDiskSpaceListW';
function SetupDuplicateDiskSpaceList; external SetupApiModuleName name 'SetupDuplicateDiskSpaceList' + NameSuffix;
function SetupDestroyDiskSpaceList; external SetupApiModuleName name 'SetupDestroyDiskSpaceList';
function SetupQueryDrivesInDiskSpaceListA; external SetupApiModuleName name 'SetupQueryDrivesInDiskSpaceListA';
function SetupQueryDrivesInDiskSpaceListW; external SetupApiModuleName name 'SetupQueryDrivesInDiskSpaceListW';
function SetupQueryDrivesInDiskSpaceList; external SetupApiModuleName name 'SetupQueryDrivesInDiskSpaceList' + NameSuffix;
function SetupQuerySpaceRequiredOnDriveA; external SetupApiModuleName name 'SetupQuerySpaceRequiredOnDriveA';
function SetupQuerySpaceRequiredOnDriveW; external SetupApiModuleName name 'SetupQuerySpaceRequiredOnDriveW';
function SetupQuerySpaceRequiredOnDrive; external SetupApiModuleName name 'SetupQuerySpaceRequiredOnDrive' + NameSuffix;
function SetupAdjustDiskSpaceListA; external SetupApiModuleName name 'SetupAdjustDiskSpaceListA';
function SetupAdjustDiskSpaceListW; external SetupApiModuleName name 'SetupAdjustDiskSpaceListW';
function SetupAdjustDiskSpaceList; external SetupApiModuleName name 'SetupAdjustDiskSpaceList' + NameSuffix;
function SetupAddToDiskSpaceListA; external SetupApiModuleName name 'SetupAddToDiskSpaceListA';
function SetupAddToDiskSpaceListW; external SetupApiModuleName name 'SetupAddToDiskSpaceListW';
function SetupAddToDiskSpaceList; external SetupApiModuleName name 'SetupAddToDiskSpaceList' + NameSuffix;
function SetupAddSectionToDiskSpaceListA; external SetupApiModuleName name 'SetupAddSectionToDiskSpaceListA';
function SetupAddSectionToDiskSpaceListW; external SetupApiModuleName name 'SetupAddSectionToDiskSpaceListW';
function SetupAddSectionToDiskSpaceList; external SetupApiModuleName name 'SetupAddSectionToDiskSpaceList' + NameSuffix;
function SetupAddInstallSectionToDiskSpaceListA; external SetupApiModuleName name 'SetupAddInstallSectionToDiskSpaceListA';
function SetupAddInstallSectionToDiskSpaceListW; external SetupApiModuleName name 'SetupAddInstallSectionToDiskSpaceListW';
function SetupAddInstallSectionToDiskSpaceList; external SetupApiModuleName name 'SetupAddInstallSectionToDiskSpaceList' + NameSuffix;
function SetupRemoveFromDiskSpaceListA; external SetupApiModuleName name 'SetupRemoveFromDiskSpaceListA';
function SetupRemoveFromDiskSpaceListW; external SetupApiModuleName name 'SetupRemoveFromDiskSpaceListW';
function SetupRemoveFromDiskSpaceList; external SetupApiModuleName name 'SetupRemoveFromDiskSpaceList' + NameSuffix;
function SetupRemoveSectionFromDiskSpaceListA; external SetupApiModuleName name 'SetupRemoveSectionFromDiskSpaceListA';
function SetupRemoveSectionFromDiskSpaceListW; external SetupApiModuleName name 'SetupRemoveSectionFromDiskSpaceListW';
function SetupRemoveSectionFromDiskSpaceList; external SetupApiModuleName name 'SetupRemoveSectionFromDiskSpaceList' + NameSuffix;
function SetupRemoveInstallSectionFromDiskSpaceListA; external SetupApiModuleName name 'SetupRemoveInstallSectionFromDiskSpaceListA';
function SetupRemoveInstallSectionFromDiskSpaceListW; external SetupApiModuleName name 'SetupRemoveInstallSectionFromDiskSpaceListW';
function SetupRemoveInstallSectionFromDiskSpaceList; external SetupApiModuleName name 'SetupRemoveInstallSectionFromDiskSpaceList' + NameSuffix;
function SetupIterateCabinetA; external SetupApiModuleName name 'SetupIterateCabinetA';
function SetupIterateCabinetW; external SetupApiModuleName name 'SetupIterateCabinetW';
function SetupIterateCabinet; external SetupApiModuleName name 'SetupIterateCabinet' + NameSuffix;
function SetupPromptReboot; external SetupApiModuleName name 'SetupPromptReboot';
function SetupInitDefaultQueueCallback; external SetupApiModuleName name 'SetupInitDefaultQueueCallback';
function SetupInitDefaultQueueCallbackEx; external SetupApiModuleName name 'SetupInitDefaultQueueCallbackEx';
procedure SetupTermDefaultQueueCallback; external SetupApiModuleName name 'SetupTermDefaultQueueCallback';
function SetupDefaultQueueCallbackA; external SetupApiModuleName name 'SetupDefaultQueueCallbackA';
function SetupDefaultQueueCallbackW; external SetupApiModuleName name 'SetupDefaultQueueCallbackW';
function SetupDefaultQueueCallback; external SetupApiModuleName name 'SetupDefaultQueueCallback' + NameSuffix;
function SetupInstallFromInfSectionA; external SetupApiModuleName name 'SetupInstallFromInfSectionA';
function SetupInstallFromInfSectionW; external SetupApiModuleName name 'SetupInstallFromInfSectionW';
function SetupInstallFromInfSection; external SetupApiModuleName name 'SetupInstallFromInfSection' + NameSuffix;
function SetupInstallFilesFromInfSectionA; external SetupApiModuleName name 'SetupInstallFilesFromInfSectionA';
function SetupInstallFilesFromInfSectionW; external SetupApiModuleName name 'SetupInstallFilesFromInfSectionW';
function SetupInstallFilesFromInfSection; external SetupApiModuleName name 'SetupInstallFilesFromInfSection' + NameSuffix;
function SetupInstallServicesFromInfSectionA; external SetupApiModuleName name 'SetupInstallServicesFromInfSectionA';
function SetupInstallServicesFromInfSectionW; external SetupApiModuleName name 'SetupInstallServicesFromInfSectionW';
function SetupInstallServicesFromInfSection; external SetupApiModuleName name 'SetupInstallServicesFromInfSection' + NameSuffix;
function SetupInstallServicesFromInfSectionExA; external SetupApiModuleName name 'SetupInstallServicesFromInfSectionExA';
function SetupInstallServicesFromInfSectionExW; external SetupApiModuleName name 'SetupInstallServicesFromInfSectionExW';
function SetupInstallServicesFromInfSectionEx; external SetupApiModuleName name 'SetupInstallServicesFromInfSectionEx' + NameSuffix;
{$IFDEF WINXP_UP}
function InstallHinfSectionA; external SetupApiModuleName name 'InstallHinfSectionA';
function InstallHinfSectionW; external SetupApiModuleName name 'InstallHinfSectionW';
function InstallHinfSection; external SetupApiModuleName name 'InstallHinfSection' + NameSuffix;
{$ENDIF WINXP_UP}
function SetupInitializeFileLogA; external SetupApiModuleName name 'SetupInitializeFileLogA';
function SetupInitializeFileLogW; external SetupApiModuleName name 'SetupInitializeFileLogW';
function SetupInitializeFileLog; external SetupApiModuleName name 'SetupInitializeFileLog' + NameSuffix;
function SetupTerminateFileLog; external SetupApiModuleName name 'SetupTerminateFileLog';
function SetupLogFileA; external SetupApiModuleName name 'SetupLogFileA';
function SetupLogFileW; external SetupApiModuleName name 'SetupLogFileW';
function SetupLogFile; external SetupApiModuleName name 'SetupLogFile' + NameSuffix;
function SetupRemoveFileLogEntryA; external SetupApiModuleName name 'SetupRemoveFileLogEntryA';
function SetupRemoveFileLogEntryW; external SetupApiModuleName name 'SetupRemoveFileLogEntryW';
function SetupRemoveFileLogEntry; external SetupApiModuleName name 'SetupRemoveFileLogEntry' + NameSuffix;
function SetupQueryFileLogA; external SetupApiModuleName name 'SetupQueryFileLogA';
function SetupQueryFileLogW; external SetupApiModuleName name 'SetupQueryFileLogW';
function SetupQueryFileLog; external SetupApiModuleName name 'SetupQueryFileLog' + NameSuffix;
function SetupOpenLog; external SetupApiModuleName name 'SetupOpenLog';
function SetupLogErrorA; external SetupApiModuleName name 'SetupLogErrorA';
function SetupLogErrorW; external SetupApiModuleName name 'SetupLogErrorW';
function SetupLogError; external SetupApiModuleName name 'SetupLogError' + NameSuffix;
procedure SetupCloseLog; external SetupApiModuleName name 'SetupCloseLog';
{$IFDEF WIN2000_UP}
function SetupGetBackupInformationA; external SetupApiModuleName name 'SetupGetBackupInformationA';
function SetupGetBackupInformationW; external SetupApiModuleName name 'SetupGetBackupInformationW';
function SetupGetBackupInformation; external SetupApiModuleName name 'SetupGetBackupInformation' + NameSuffix;
{$ENDIF WIN2000_UP}
{$IFDEF WINXP_UP}
function SetupPrepareQueueForRestoreA; external SetupApiModuleName name 'SetupPrepareQueueForRestoreA';
function SetupPrepareQueueForRestoreW; external SetupApiModuleName name 'SetupPrepareQueueForRestoreW';
function SetupPrepareQueueForRestore; external SetupApiModuleName name 'SetupPrepareQueueForRestore' + NameSuffix;
function SetupSetNonInteractiveMode; external SetupApiModuleName name 'SetupSetNonInteractiveMode';
function SetupGetNonInteractiveMode; external SetupApiModuleName name 'SetupGetNonInteractiveMode';
{$ENDIF WINXP_UP}
function SetupDiCreateDeviceInfoList; external SetupApiModuleName name 'SetupDiCreateDeviceInfoList';
function SetupDiCreateDeviceInfoListExA; external SetupApiModuleName name 'SetupDiCreateDeviceInfoListExA';
function SetupDiCreateDeviceInfoListExW; external SetupApiModuleName name 'SetupDiCreateDeviceInfoListExW';
function SetupDiCreateDeviceInfoListEx; external SetupApiModuleName name 'SetupDiCreateDeviceInfoListEx' + NameSuffix;
function SetupDiGetDeviceInfoListClass; external SetupApiModuleName name 'SetupDiGetDeviceInfoListClass';
function SetupDiGetDeviceInfoListDetailA; external SetupApiModuleName name 'SetupDiGetDeviceInfoListDetailA';
function SetupDiGetDeviceInfoListDetailW; external SetupApiModuleName name 'SetupDiGetDeviceInfoListDetailW';
function SetupDiGetDeviceInfoListDetail; external SetupApiModuleName name 'SetupDiGetDeviceInfoListDetail' + NameSuffix;
function SetupDiCreateDeviceInfoA; external SetupApiModuleName name 'SetupDiCreateDeviceInfoA';
function SetupDiCreateDeviceInfoW; external SetupApiModuleName name 'SetupDiCreateDeviceInfoW';
function SetupDiCreateDeviceInfo; external SetupApiModuleName name 'SetupDiCreateDeviceInfo' + NameSuffix;
function SetupDiOpenDeviceInfoA; external SetupApiModuleName name 'SetupDiOpenDeviceInfoA';
function SetupDiOpenDeviceInfoW; external SetupApiModuleName name 'SetupDiOpenDeviceInfoW';
function SetupDiOpenDeviceInfo; external SetupApiModuleName name 'SetupDiOpenDeviceInfo' + NameSuffix;
function SetupDiGetDeviceInstanceIdA; external SetupApiModuleName name 'SetupDiGetDeviceInstanceIdA';
function SetupDiGetDeviceInstanceIdW; external SetupApiModuleName name 'SetupDiGetDeviceInstanceIdW';
function SetupDiGetDeviceInstanceId; external SetupApiModuleName name 'SetupDiGetDeviceInstanceId' + NameSuffix;
function SetupDiDeleteDeviceInfo; external SetupApiModuleName name 'SetupDiDeleteDeviceInfo';
function SetupDiEnumDeviceInfo; external SetupApiModuleName name 'SetupDiEnumDeviceInfo';
function SetupDiDestroyDeviceInfoList; external SetupApiModuleName name 'SetupDiDestroyDeviceInfoList';
function SetupDiEnumDeviceInterfaces; external SetupApiModuleName name 'SetupDiEnumDeviceInterfaces';
function SetupDiEnumInterfaceDevice; external SetupApiModuleName name 'SetupDiEnumDeviceInterfaces';
function SetupDiCreateDeviceInterfaceA; external SetupApiModuleName name 'SetupDiCreateDeviceInterfaceA';
function SetupDiCreateInterfaceDeviceA; external SetupApiModuleName name 'SetupDiCreateDeviceInterfaceA';
function SetupDiCreateDeviceInterfaceW; external SetupApiModuleName name 'SetupDiCreateDeviceInterfaceW';
function SetupDiCreateInterfaceDeviceW; external SetupApiModuleName name 'SetupDiCreateDeviceInterfaceW';
function SetupDiCreateDeviceInterface; external SetupApiModuleName name 'SetupDiCreateDeviceInterface' + NameSuffix;
function SetupDiCreateInterfaceDevice; external SetupApiModuleName name 'SetupDiCreateDeviceInterface' + NameSuffix;
function SetupDiOpenDeviceInterfaceA; external SetupApiModuleName name 'SetupDiOpenDeviceInterfaceA';
function SetupDiOpenInterfaceDeviceA; external SetupApiModuleName name 'SetupDiOpenDeviceInterfaceA';
function SetupDiOpenDeviceInterfaceW; external SetupApiModuleName name 'SetupDiOpenDeviceInterfaceW';
function SetupDiOpenInterfaceDeviceW; external SetupApiModuleName name 'SetupDiOpenDeviceInterfaceW';
function SetupDiOpenDeviceInterface; external SetupApiModuleName name 'SetupDiOpenDeviceInterface' + NameSuffix;
function SetupDiOpenInterfaceDevice; external SetupApiModuleName name 'SetupDiOpenDeviceInterface' + NameSuffix;
function SetupDiGetDeviceInterfaceAlias; external SetupApiModuleName name 'SetupDiGetDeviceInterfaceAlias';
function SetupDiGetInterfaceDeviceAlias; external SetupApiModuleName name 'SetupDiGetDeviceInterfaceAlias';
function SetupDiDeleteDeviceInterfaceData; external SetupApiModuleName name 'SetupDiDeleteDeviceInterfaceData';
function SetupDiDeleteInterfaceDeviceData; external SetupApiModuleName name 'SetupDiDeleteDeviceInterfaceData';
function SetupDiRemoveDeviceInterface; external SetupApiModuleName name 'SetupDiRemoveDeviceInterface';
function SetupDiRemoveInterfaceDevice; external SetupApiModuleName name 'SetupDiRemoveDeviceInterface';
function SetupDiGetDeviceInterfaceDetailA; external SetupApiModuleName name 'SetupDiGetDeviceInterfaceDetailA';
function SetupDiGetInterfaceDeviceDetailA; external SetupApiModuleName name 'SetupDiGetDeviceInterfaceDetailA';
function SetupDiGetDeviceInterfaceDetailW; external SetupApiModuleName name 'SetupDiGetDeviceInterfaceDetailW';
function SetupDiGetInterfaceDeviceDetailW; external SetupApiModuleName name 'SetupDiGetDeviceInterfaceDetailW';
function SetupDiGetDeviceInterfaceDetail; external SetupApiModuleName name 'SetupDiGetDeviceInterfaceDetail' + NameSuffix;
function SetupDiGetInterfaceDeviceDetail; external SetupApiModuleName name 'SetupDiGetDeviceInterfaceDetail' + NameSuffix;
function SetupDiInstallDeviceInterfaces; external SetupApiModuleName name 'SetupDiInstallDeviceInterfaces';
function SetupDiInstallInterfaceDevices; external SetupApiModuleName name 'SetupDiInstallDeviceInterfaces';
{$IFDEF WINXP_UP}
function SetupDiSetDeviceInterfaceDefault; external SetupApiModuleName name 'SetupDiSetDeviceInterfaceDefault';
{$ENDIF WINXP_UP}
function SetupDiRegisterDeviceInfo; external SetupApiModuleName name 'SetupDiRegisterDeviceInfo';
function SetupDiBuildDriverInfoList; external SetupApiModuleName name 'SetupDiBuildDriverInfoList';
function SetupDiCancelDriverInfoSearch; external SetupApiModuleName name 'SetupDiCancelDriverInfoSearch';
function SetupDiEnumDriverInfoA; external SetupApiModuleName name 'SetupDiEnumDriverInfoA';
function SetupDiEnumDriverInfoW; external SetupApiModuleName name 'SetupDiEnumDriverInfoW';
function SetupDiEnumDriverInfo; external SetupApiModuleName name 'SetupDiEnumDriverInfo' + NameSuffix;
function SetupDiGetSelectedDriverA; external SetupApiModuleName name 'SetupDiGetSelectedDriverA';
function SetupDiGetSelectedDriverW; external SetupApiModuleName name 'SetupDiGetSelectedDriverW';
function SetupDiGetSelectedDriver; external SetupApiModuleName name 'SetupDiGetSelectedDriver' + NameSuffix;
function SetupDiSetSelectedDriverA; external SetupApiModuleName name 'SetupDiSetSelectedDriverA';
function SetupDiSetSelectedDriverW; external SetupApiModuleName name 'SetupDiSetSelectedDriverW';
function SetupDiSetSelectedDriver; external SetupApiModuleName name 'SetupDiSetSelectedDriver' + NameSuffix;
function SetupDiGetDriverInfoDetailA; external SetupApiModuleName name 'SetupDiGetDriverInfoDetailA';
function SetupDiGetDriverInfoDetailW; external SetupApiModuleName name 'SetupDiGetDriverInfoDetailW';
function SetupDiGetDriverInfoDetail; external SetupApiModuleName name 'SetupDiGetDriverInfoDetail' + NameSuffix;
function SetupDiDestroyDriverInfoList; external SetupApiModuleName name 'SetupDiDestroyDriverInfoList';
function SetupDiGetClassDevsA; external SetupApiModuleName name 'SetupDiGetClassDevsA';
function SetupDiGetClassDevsW; external SetupApiModuleName name 'SetupDiGetClassDevsW';
function SetupDiGetClassDevs; external SetupApiModuleName name 'SetupDiGetClassDevs' + NameSuffix;
function SetupDiGetClassDevsExA; external SetupApiModuleName name 'SetupDiGetClassDevsExA';
function SetupDiGetClassDevsExW; external SetupApiModuleName name 'SetupDiGetClassDevsExW';
function SetupDiGetClassDevsEx; external SetupApiModuleName name 'SetupDiGetClassDevsEx' + NameSuffix;
function SetupDiGetINFClassA; external SetupApiModuleName name 'SetupDiGetINFClassA';
function SetupDiGetINFClassW; external SetupApiModuleName name 'SetupDiGetINFClassW';
function SetupDiGetINFClass; external SetupApiModuleName name 'SetupDiGetINFClass' + NameSuffix;
function SetupDiBuildClassInfoList; external SetupApiModuleName name 'SetupDiBuildClassInfoList';
function SetupDiBuildClassInfoListExA; external SetupApiModuleName name 'SetupDiBuildClassInfoListExA';
function SetupDiBuildClassInfoListExW; external SetupApiModuleName name 'SetupDiBuildClassInfoListExW';
function SetupDiBuildClassInfoListEx; external SetupApiModuleName name 'SetupDiBuildClassInfoListEx' + NameSuffix;
function SetupDiGetClassDescriptionA; external SetupApiModuleName name 'SetupDiGetClassDescriptionA';
function SetupDiGetClassDescriptionW; external SetupApiModuleName name 'SetupDiGetClassDescriptionW';
function SetupDiGetClassDescription; external SetupApiModuleName name 'SetupDiGetClassDescription' + NameSuffix;
function SetupDiGetClassDescriptionExA; external SetupApiModuleName name 'SetupDiGetClassDescriptionExA';
function SetupDiGetClassDescriptionExW; external SetupApiModuleName name 'SetupDiGetClassDescriptionExW';
function SetupDiGetClassDescriptionEx; external SetupApiModuleName name 'SetupDiGetClassDescriptionEx' + NameSuffix;
function SetupDiCallClassInstaller; external SetupApiModuleName name 'SetupDiCallClassInstaller';
function SetupDiSelectDevice; external SetupApiModuleName name 'SetupDiSelectDevice';
function SetupDiSelectBestCompatDrv; external SetupApiModuleName name 'SetupDiSelectBestCompatDrv';
function SetupDiInstallDevice; external SetupApiModuleName name 'SetupDiInstallDevice';
function SetupDiInstallDriverFiles; external SetupApiModuleName name 'SetupDiInstallDriverFiles';
function SetupDiRegisterCoDeviceInstallers; external SetupApiModuleName name 'SetupDiRegisterCoDeviceInstallers';
function SetupDiRemoveDevice; external SetupApiModuleName name 'SetupDiRemoveDevice';
function SetupDiUnremoveDevice; external SetupApiModuleName name 'SetupDiUnremoveDevice';
function SetupDiMoveDuplicateDevice; external SetupApiModuleName name 'SetupDiMoveDuplicateDevice';
function SetupDiChangeState; external SetupApiModuleName name 'SetupDiChangeState';
function SetupDiInstallClassA; external SetupApiModuleName name 'SetupDiInstallClassA';
function SetupDiInstallClassW; external SetupApiModuleName name 'SetupDiInstallClassW';
function SetupDiInstallClass; external SetupApiModuleName name 'SetupDiInstallClass' + NameSuffix;
function SetupDiInstallClassExA; external SetupApiModuleName name 'SetupDiInstallClassExA';
function SetupDiInstallClassExW; external SetupApiModuleName name 'SetupDiInstallClassExW';
function SetupDiInstallClassEx; external SetupApiModuleName name 'SetupDiInstallClassEx' + NameSuffix;
function SetupDiOpenClassRegKey; external SetupApiModuleName name 'SetupDiOpenClassRegKey';
function SetupDiOpenClassRegKeyExA; external SetupApiModuleName name 'SetupDiOpenClassRegKeyExA';
function SetupDiOpenClassRegKeyExW; external SetupApiModuleName name 'SetupDiOpenClassRegKeyExW';
function SetupDiOpenClassRegKeyEx; external SetupApiModuleName name 'SetupDiOpenClassRegKeyEx' + NameSuffix;
function SetupDiCreateDeviceInterfaceRegKeyA; external SetupApiModuleName name 'SetupDiCreateDeviceInterfaceRegKeyA';
function SetupDiCreateInterfaceDeviceRegKeyA; external SetupApiModuleName name 'SetupDiCreateDeviceInterfaceRegKeyA';
function SetupDiCreateDeviceInterfaceRegKeyW; external SetupApiModuleName name 'SetupDiCreateDeviceInterfaceRegKeyW';
function SetupDiCreateInterfaceDeviceRegKeyW; external SetupApiModuleName name 'SetupDiCreateDeviceInterfaceRegKeyW';
function SetupDiCreateDeviceInterfaceRegKey; external SetupApiModuleName name 'SetupDiCreateDeviceInterfaceRegKey' + NameSuffix;
function SetupDiCreateInterfaceDeviceRegKey; external SetupApiModuleName name 'SetupDiCreateDeviceInterfaceRegKey' + NameSuffix;
function SetupDiOpenDeviceInterfaceRegKey; external SetupApiModuleName name 'SetupDiOpenDeviceInterfaceRegKey';
function SetupDiOpenInterfaceDeviceRegKey; external SetupApiModuleName name 'SetupDiOpenDeviceInterfaceRegKey';
function SetupDiDeleteDeviceInterfaceRegKey; external SetupApiModuleName name 'SetupDiDeleteDeviceInterfaceRegKey';
function SetupDiDeleteInterfaceDeviceRegKey; external SetupApiModuleName name 'SetupDiDeleteDeviceInterfaceRegKey';
function SetupDiCreateDevRegKeyA; external SetupApiModuleName name 'SetupDiCreateDevRegKeyA';
function SetupDiCreateDevRegKeyW; external SetupApiModuleName name 'SetupDiCreateDevRegKeyW';
function SetupDiCreateDevRegKey; external SetupApiModuleName name 'SetupDiCreateDevRegKey' + NameSuffix;
function SetupDiOpenDevRegKey; external SetupApiModuleName name 'SetupDiOpenDevRegKey';
function SetupDiDeleteDevRegKey; external SetupApiModuleName name 'SetupDiDeleteDevRegKey';
function SetupDiGetHwProfileList; external SetupApiModuleName name 'SetupDiGetHwProfileList';
function SetupDiGetHwProfileListExA; external SetupApiModuleName name 'SetupDiGetHwProfileListExA';
function SetupDiGetHwProfileListExW; external SetupApiModuleName name 'SetupDiGetHwProfileListExW';
function SetupDiGetHwProfileListEx; external SetupApiModuleName name 'SetupDiGetHwProfileListEx' + NameSuffix;
function SetupDiGetDeviceRegistryPropertyA; external SetupApiModuleName name 'SetupDiGetDeviceRegistryPropertyA';
function SetupDiGetDeviceRegistryPropertyW; external SetupApiModuleName name 'SetupDiGetDeviceRegistryPropertyW';
function SetupDiGetDeviceRegistryProperty; external SetupApiModuleName name 'SetupDiGetDeviceRegistryProperty' + NameSuffix;
{$IFDEF WINXP_UP}
function SetupDiGetClassRegistryPropertyA; external SetupApiModuleName name 'SetupDiGetClassRegistryPropertyA';
function SetupDiGetClassRegistryPropertyW; external SetupApiModuleName name 'SetupDiGetClassRegistryPropertyW';
function SetupDiGetClassRegistryProperty; external SetupApiModuleName name 'SetupDiGetClassRegistryProperty' + NameSuffix;
{$ENDIF WINXP_UP}
function SetupDiSetDeviceRegistryPropertyA; external SetupApiModuleName name 'SetupDiSetDeviceRegistryPropertyA';
function SetupDiSetDeviceRegistryPropertyW; external SetupApiModuleName name 'SetupDiSetDeviceRegistryPropertyW';
function SetupDiSetDeviceRegistryProperty; external SetupApiModuleName name 'SetupDiSetDeviceRegistryProperty' + NameSuffix;
{$IFDEF WINXP_UP}
function SetupDiSetClassRegistryPropertyA; external SetupApiModuleName name 'SetupDiSetClassRegistryPropertyA';
function SetupDiSetClassRegistryPropertyW; external SetupApiModuleName name 'SetupDiSetClassRegistryPropertyW';
function SetupDiSetClassRegistryProperty; external SetupApiModuleName name 'SetupDiSetClassRegistryProperty' + NameSuffix;
{$ENDIF WINXP_UP}
function SetupDiGetDeviceInstallParamsA; external SetupApiModuleName name 'SetupDiGetDeviceInstallParamsA';
function SetupDiGetDeviceInstallParamsW; external SetupApiModuleName name 'SetupDiGetDeviceInstallParamsW';
function SetupDiGetDeviceInstallParams; external SetupApiModuleName name 'SetupDiGetDeviceInstallParams' + NameSuffix;
function SetupDiGetClassInstallParamsA; external SetupApiModuleName name 'SetupDiGetClassInstallParamsA';
function SetupDiGetClassInstallParamsW; external SetupApiModuleName name 'SetupDiGetClassInstallParamsW';
function SetupDiGetClassInstallParams; external SetupApiModuleName name 'SetupDiGetClassInstallParams' + NameSuffix;
function SetupDiSetDeviceInstallParamsA; external SetupApiModuleName name 'SetupDiSetDeviceInstallParamsA';
function SetupDiSetDeviceInstallParamsW; external SetupApiModuleName name 'SetupDiSetDeviceInstallParamsW';
function SetupDiSetDeviceInstallParams; external SetupApiModuleName name 'SetupDiSetDeviceInstallParams' + NameSuffix;
function SetupDiSetClassInstallParamsA; external SetupApiModuleName name 'SetupDiSetClassInstallParamsA';
function SetupDiSetClassInstallParamsW; external SetupApiModuleName name 'SetupDiSetClassInstallParamsW';
function SetupDiSetClassInstallParams; external SetupApiModuleName name 'SetupDiSetClassInstallParams' + NameSuffix;
function SetupDiGetDriverInstallParamsA; external SetupApiModuleName name 'SetupDiGetDriverInstallParamsA';
function SetupDiGetDriverInstallParamsW; external SetupApiModuleName name 'SetupDiGetDriverInstallParamsW';
function SetupDiGetDriverInstallParams; external SetupApiModuleName name 'SetupDiGetDriverInstallParams' + NameSuffix;
function SetupDiSetDriverInstallParamsA; external SetupApiModuleName name 'SetupDiSetDriverInstallParamsA';
function SetupDiSetDriverInstallParamsW; external SetupApiModuleName name 'SetupDiSetDriverInstallParamsW';
function SetupDiSetDriverInstallParams; external SetupApiModuleName name 'SetupDiSetDriverInstallParams' + NameSuffix;
function SetupDiLoadClassIcon; external SetupApiModuleName name 'SetupDiLoadClassIcon';
function SetupDiDrawMiniIcon; external SetupApiModuleName name 'SetupDiDrawMiniIcon';
function SetupDiGetClassBitmapIndex; external SetupApiModuleName name 'SetupDiGetClassBitmapIndex';
function SetupDiGetClassImageList; external SetupApiModuleName name 'SetupDiGetClassImageList';
function SetupDiGetClassImageListExA; external SetupApiModuleName name 'SetupDiGetClassImageListExA';
function SetupDiGetClassImageListExW; external SetupApiModuleName name 'SetupDiGetClassImageListExW';
function SetupDiGetClassImageListEx; external SetupApiModuleName name 'SetupDiGetClassImageListEx' + NameSuffix;
function SetupDiGetClassImageIndex; external SetupApiModuleName name 'SetupDiGetClassImageIndex';
function SetupDiDestroyClassImageList; external SetupApiModuleName name 'SetupDiDestroyClassImageList';
function SetupDiGetClassDevPropertySheetsA; external SetupApiModuleName name 'SetupDiGetClassDevPropertySheetsA';
function SetupDiGetClassDevPropertySheetsW; external SetupApiModuleName name 'SetupDiGetClassDevPropertySheetsW';
function SetupDiGetClassDevPropertySheets; external SetupApiModuleName name 'SetupDiGetClassDevPropertySheets' + NameSuffix;
function SetupDiAskForOEMDisk; external SetupApiModuleName name 'SetupDiAskForOEMDisk';
function SetupDiSelectOEMDrv; external SetupApiModuleName name 'SetupDiSelectOEMDrv';
function SetupDiClassNameFromGuidA; external SetupApiModuleName name 'SetupDiClassNameFromGuidA';
function SetupDiClassNameFromGuidW; external SetupApiModuleName name 'SetupDiClassNameFromGuidW';
function SetupDiClassNameFromGuid; external SetupApiModuleName name 'SetupDiClassNameFromGuid' + NameSuffix;
function SetupDiClassNameFromGuidExA; external SetupApiModuleName name 'SetupDiClassNameFromGuidExA';
function SetupDiClassNameFromGuidExW; external SetupApiModuleName name 'SetupDiClassNameFromGuidExW';
function SetupDiClassNameFromGuidEx; external SetupApiModuleName name 'SetupDiClassNameFromGuidEx' + NameSuffix;
function SetupDiClassGuidsFromNameA; external SetupApiModuleName name 'SetupDiClassGuidsFromNameA';
function SetupDiClassGuidsFromNameW; external SetupApiModuleName name 'SetupDiClassGuidsFromNameW';
function SetupDiClassGuidsFromName; external SetupApiModuleName name 'SetupDiClassGuidsFromName' + NameSuffix;
function SetupDiClassGuidsFromNameExA; external SetupApiModuleName name 'SetupDiClassGuidsFromNameExA';
function SetupDiClassGuidsFromNameExW; external SetupApiModuleName name 'SetupDiClassGuidsFromNameExW';
function SetupDiClassGuidsFromNameEx; external SetupApiModuleName name 'SetupDiClassGuidsFromNameEx' + NameSuffix;
function SetupDiGetHwProfileFriendlyNameA; external SetupApiModuleName name 'SetupDiGetHwProfileFriendlyNameA';
function SetupDiGetHwProfileFriendlyNameW; external SetupApiModuleName name 'SetupDiGetHwProfileFriendlyNameW';
function SetupDiGetHwProfileFriendlyName; external SetupApiModuleName name 'SetupDiGetHwProfileFriendlyName' + NameSuffix;
function SetupDiGetHwProfileFriendlyNameExA; external SetupApiModuleName name 'SetupDiGetHwProfileFriendlyNameExA';
function SetupDiGetHwProfileFriendlyNameExW; external SetupApiModuleName name 'SetupDiGetHwProfileFriendlyNameExW';
function SetupDiGetHwProfileFriendlyNameEx; external SetupApiModuleName name 'SetupDiGetHwProfileFriendlyNameEx' + NameSuffix;
function SetupDiGetWizardPage; external SetupApiModuleName name 'SetupDiGetWizardPage';
function SetupDiGetSelectedDevice; external SetupApiModuleName name 'SetupDiGetSelectedDevice';
function SetupDiSetSelectedDevice; external SetupApiModuleName name 'SetupDiSetSelectedDevice';
function SetupDiGetActualSectionToInstallA; external SetupApiModuleName name 'SetupDiGetActualSectionToInstallA';
function SetupDiGetActualSectionToInstallW; external SetupApiModuleName name 'SetupDiGetActualSectionToInstallW';
function SetupDiGetActualSectionToInstall; external SetupApiModuleName name 'SetupDiGetActualSectionToInstall' + NameSuffix;
{$IFDEF WINXP_UP}
function SetupDiGetActualSectionToInstallExA; external SetupApiModuleName name 'SetupDiGetActualSectionToInstallExA';
function SetupDiGetActualSectionToInstallExW; external SetupApiModuleName name 'SetupDiGetActualSectionToInstallExW';
function SetupDiGetActualSectionToInstallEx; external SetupApiModuleName name 'SetupDiGetActualSectionToInstallEx' + NameSuffix;
function SetupEnumInfSectionsA; external SetupApiModuleName name 'SetupEnumInfSectionsA';
function SetupEnumInfSectionsW; external SetupApiModuleName name 'SetupEnumInfSectionsW';
function SetupEnumInfSections; external SetupApiModuleName name 'SetupEnumInfSections' + NameSuffix;
function SetupVerifyInfFileA; external SetupApiModuleName name 'SetupVerifyInfFileA';
function SetupVerifyInfFileW; external SetupApiModuleName name 'SetupVerifyInfFileW';;
function SetupVerifyInfFile; external SetupApiModuleName name 'SetupVerifyInfFile' + NameSuffix;
function SetupDiGetCustomDevicePropertyA; external SetupApiModuleName name 'SetupDiGetCustomDevicePropertyA';
function SetupDiGetCustomDevicePropertyW; external SetupApiModuleName name 'SetupDiGetCustomDevicePropertyW';
function SetupDiGetCustomDeviceProperty; external SetupApiModuleName name 'SetupDiGetCustomDeviceProperty' + NameSuffix;
{$ENDIF WINXP_UP}

{$ENDIF !SETUPAPI_LINKONREQUEST}

end.

