path: root/packages/winunits-jedi/src/jwamsiquery.pas

{******************************************************************************}
{                                                                              }
{ Windows Installer API interface Unit for Object Pascal                       }
{                                                                              }
{ Portions created by Microsoft are Copyright (C) 1995-2001 Microsoft          }
{ Corporation. All Rights Reserved.                                            }
{                                                                              }
{ The original file is: msiquery.h, released June 2000. The original Pascal    }
{ code is: MsiQuery.pas, released June 2001. The initial developer of the      }
{ Pascal code is Marcel van Brakel (brakelm att chello dott nl).               }
{                                                                              }
{ Portions created by Marcel van Brakel are Copyright (C) 1999-2001            }
{ Marcel van Brakel. All Rights Reserved.                                      }
{                                                                              }
{ Obtained through: Joint Endeavour of Delphi Innovators (Project JEDI)        }
{                                                                              }
{ You may retrieve the latest version of this file at the Project JEDI         }
{ APILIB home page, located at http://jedi-apilib.sourceforge.net              }
{                                                                              }
{ 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.    }
{                                                                              }
{ Alternatively, the contents of this file may be used under the terms of the  }
{ GNU Lesser General Public License (the  "LGPL License"), in which case the   }
{ provisions of the LGPL License are applicable instead of those above.        }
{ If you wish to allow use of your version of this file only under the terms   }
{ of the LGPL License and not to allow others to use your version of this file }
{ under the MPL, indicate your decision by deleting  the provisions above and  }
{ replace  them with the notice and other provisions required by the LGPL      }
{ License.  If you do not delete the provisions above, a recipient may use     }
{ your version of this file under either the MPL or the LGPL License.          }
{                                                                              }
{ For more information about the LGPL: http://www.gnu.org/copyleft/lesser.html }
{                                                                              }
{******************************************************************************}

// $Id: JwaMsiQuery.pas,v 1.11 2007/09/05 11:58:51 dezipaitor Exp $
{$IFNDEF JWA_OMIT_SECTIONS}
unit JwaMsiQuery;

{$WEAKPACKAGEUNIT}
{$ENDIF JWA_OMIT_SECTIONS}

{$HPPEMIT ''}
{$HPPEMIT '#include "msiquery.h"'}
{$HPPEMIT ''}

{$IFNDEF JWA_OMIT_SECTIONS}
{$I jediapilib.inc}

interface

uses
  JwaMsi, JwaWinBase, JwaWinType;
{$ENDIF JWA_OMIT_SECTIONS}

{$IFNDEF JWA_IMPLEMENTATIONSECTION}
(*****************************************************************************\
*                                                                             *
* MsiQuery.h - Interface to running installer for custom actions and tools    *
*                                                                             *
* Version 1.0 - 1.2                                                           *
*                                                                             *
* NOTES:  All buffers sizes are TCHAR count, null included only on input      *
*         Return argument pointers may be null if not interested in value     *
*         Returned handles of all types must be closed: MsiCloseHandle(h)     *
*         Functions with UINT return type return a system error code          *
*         Designated functions will set or clear the last error record,       *
*         which is then accessible with MsiGetLastErrorRecord. However,       *
*         the following argument errors do not register an error record:      *
*         ERROR_INVALID_HANDLE, ERROR_INVALID_PARAMETER, ERROR_MORE_DATA.     *
*                                                                             *
* Copyright (c) 1999-2000, Microsoft Corp.      All rights reserved.          *
*                                                                             *
\*****************************************************************************)

const
  MSI_NULL_INTEGER = DWORD($80000000);  // integer value reserved for null
  {$EXTERNALSYM MSI_NULL_INTEGER}

// MsiOpenDatabase persist predefine values, otherwise output database path is used

  MSIDBOPEN_READONLY     = LPCTSTR(0);  // database open read-only, no persistent changes
  {$EXTERNALSYM MSIDBOPEN_READONLY}
  MSIDBOPEN_TRANSACT     = LPCTSTR(1);  // database read/write in transaction mode
  {$EXTERNALSYM MSIDBOPEN_TRANSACT}
  MSIDBOPEN_DIRECT       = LPCTSTR(2);  // database direct read/write without transaction
  {$EXTERNALSYM MSIDBOPEN_DIRECT}
  MSIDBOPEN_CREATE       = LPCTSTR(3);  // create new database, transact mode read/write
  {$EXTERNALSYM MSIDBOPEN_CREATE}
  MSIDBOPEN_CREATEDIRECT = LPCTSTR(4);  // create new database, direct mode read/write
  {$EXTERNALSYM MSIDBOPEN_CREATEDIRECT}

  MSIDBOPEN_PATCHFILE    = 32 div SizeOf(TCHAR); // add flag to indicate patch file

  MSIDBSTATE_ERROR    = DWORD(-1);  // invalid database handle
  {$EXTERNALSYM MSIDBSTATE_ERROR}
  MSIDBSTATE_READ     =  0;  // database open read-only, no persistent changes
  {$EXTERNALSYM MSIDBSTATE_READ}
  MSIDBSTATE_WRITE    =  1;  // database readable and updatable
  {$EXTERNALSYM MSIDBSTATE_WRITE}

type
  MSIDBSTATE = DWORD;
  {$EXTERNALSYM MSIDBSTATE}
  TMsiDbState = MSIDBSTATE;

const
  MSIMODIFY_SEEK             = DWORD(-1);  // reposition to current record primary key
  {$EXTERNALSYM MSIMODIFY_SEEK}
  MSIMODIFY_REFRESH          = 0;  // refetch current record data
  {$EXTERNALSYM MSIMODIFY_REFRESH}
  MSIMODIFY_INSERT           = 1;  // insert new record, fails if matching key exists
  {$EXTERNALSYM MSIMODIFY_INSERT}
  MSIMODIFY_UPDATE           = 2;  // update existing non-key data of fetched record
  {$EXTERNALSYM MSIMODIFY_UPDATE}
  MSIMODIFY_ASSIGN           = 3;  // insert record, replacing any existing record
  {$EXTERNALSYM MSIMODIFY_ASSIGN}
  MSIMODIFY_REPLACE          = 4;  // update record, delete old if primary key edit
  {$EXTERNALSYM MSIMODIFY_REPLACE}
  MSIMODIFY_MERGE            = 5;  // fails if record with duplicate key not identical
  {$EXTERNALSYM MSIMODIFY_MERGE}
  MSIMODIFY_DELETE           = 6;  // remove row referenced by this record from table
  {$EXTERNALSYM MSIMODIFY_DELETE}
  MSIMODIFY_INSERT_TEMPORARY = 7;  // insert a temporary record
  {$EXTERNALSYM MSIMODIFY_INSERT_TEMPORARY}
  MSIMODIFY_VALIDATE         = 8;  // validate a fetched record
  {$EXTERNALSYM MSIMODIFY_VALIDATE}
  MSIMODIFY_VALIDATE_NEW     = 9;  // validate a new record
  {$EXTERNALSYM MSIMODIFY_VALIDATE_NEW}
  MSIMODIFY_VALIDATE_FIELD   = 10; // validate field(s) of an incomplete record
  {$EXTERNALSYM MSIMODIFY_VALIDATE_FIELD}
  MSIMODIFY_VALIDATE_DELETE  = 11; // validate before deleting record
  {$EXTERNALSYM MSIMODIFY_VALIDATE_DELETE}

type
  MSIMODIFY = DWORD;
  {$EXTERNALSYM MSIMODIFY}
  TMsiModify = MSIMODIFY;

const
  MSICOLINFO_NAMES = 0;  // return column names
  {$EXTERNALSYM MSICOLINFO_NAMES}
  MSICOLINFO_TYPES = 1;  // return column definitions, datatype code followed by width
  {$EXTERNALSYM MSICOLINFO_TYPES}

type
  MSICOLINFO = DWORD;
  {$EXTERNALSYM MSICOLINFO}
  TMsiColInfo = MSICOLINFO;

const
  MSICONDITION_FALSE = 0;  // expression evaluates to False
  {$EXTERNALSYM MSICONDITION_FALSE}
  MSICONDITION_TRUE  = 1;  // expression evaluates to True
  {$EXTERNALSYM MSICONDITION_TRUE}
  MSICONDITION_NONE  = 2;  // no expression present
  {$EXTERNALSYM MSICONDITION_NONE}
  MSICONDITION_ERROR = 3;  // syntax error in expression
  {$EXTERNALSYM MSICONDITION_ERROR}

type
  MSICONDITION = DWORD;
  {$EXTERNALSYM MSICONDITION}
  TMsiCondition = MSICONDITION;

const
  MSICOSTTREE_SELFONLY = 0;
  {$EXTERNALSYM MSICOSTTREE_SELFONLY}
  MSICOSTTREE_CHILDREN = 1;
  {$EXTERNALSYM MSICOSTTREE_CHILDREN}
  MSICOSTTREE_PARENTS  = 2;
  {$EXTERNALSYM MSICOSTTREE_PARENTS}
  MSICOSTTREE_RESERVED = 3;  // Reserved for future use
  {$EXTERNALSYM MSICOSTTREE_RESERVED}

type
  MSICOSTTREE = DWORD;
  {$EXTERNALSYM MSICOSTTREE}
  TMsiCostTree = MSICOSTTREE;

const
  MSIDBERROR_INVALIDARG        = DWORD(-3); //  invalid argument
  {$EXTERNALSYM MSIDBERROR_INVALIDARG}
  MSIDBERROR_MOREDATA          = DWORD(-2); //  buffer too small
  {$EXTERNALSYM MSIDBERROR_MOREDATA}
  MSIDBERROR_FUNCTIONERROR     = DWORD(-1); //  function error
  {$EXTERNALSYM MSIDBERROR_FUNCTIONERROR}
  MSIDBERROR_NOERROR           = 0;  //  no error
  {$EXTERNALSYM MSIDBERROR_NOERROR}
  MSIDBERROR_DUPLICATEKEY      = 1;  //  new record duplicates primary keys of existing record in table
  {$EXTERNALSYM MSIDBERROR_DUPLICATEKEY}
  MSIDBERROR_REQUIRED          = 2;  //  non-nullable column, no null values allowed
  {$EXTERNALSYM MSIDBERROR_REQUIRED}
  MSIDBERROR_BADLINK           = 3;  //  corresponding record in foreign table not found
  {$EXTERNALSYM MSIDBERROR_BADLINK}
  MSIDBERROR_OVERFLOW          = 4;  //  data greater than maximum value allowed
  {$EXTERNALSYM MSIDBERROR_OVERFLOW}
  MSIDBERROR_UNDERFLOW         = 5;  //  data less than minimum value allowed
  {$EXTERNALSYM MSIDBERROR_UNDERFLOW}
  MSIDBERROR_NOTINSET          = 6;  //  data not a member of the values permitted in the set
  {$EXTERNALSYM MSIDBERROR_NOTINSET}
  MSIDBERROR_BADVERSION        = 7;  //  invalid version string
  {$EXTERNALSYM MSIDBERROR_BADVERSION}
  MSIDBERROR_BADCASE           = 8;  //  invalid case, must be all upper-case or all lower-case
  {$EXTERNALSYM MSIDBERROR_BADCASE}
  MSIDBERROR_BADGUID           = 9;  //  invalid GUID
  {$EXTERNALSYM MSIDBERROR_BADGUID}
  MSIDBERROR_BADWILDCARD       = 10; //  invalid wildcardfilename or use of wildcards
  {$EXTERNALSYM MSIDBERROR_BADWILDCARD}
  MSIDBERROR_BADIDENTIFIER     = 11; //  bad identifier
  {$EXTERNALSYM MSIDBERROR_BADIDENTIFIER}
  MSIDBERROR_BADLANGUAGE       = 12; //  bad language Id(s)
  {$EXTERNALSYM MSIDBERROR_BADLANGUAGE}
  MSIDBERROR_BADFILENAME       = 13; //  bad filename
  {$EXTERNALSYM MSIDBERROR_BADFILENAME}
  MSIDBERROR_BADPATH           = 14; //  bad path
  {$EXTERNALSYM MSIDBERROR_BADPATH}
  MSIDBERROR_BADCONDITION      = 15; //  bad conditional statement
  {$EXTERNALSYM MSIDBERROR_BADCONDITION}
  MSIDBERROR_BADFORMATTED      = 16; //  bad format string
  {$EXTERNALSYM MSIDBERROR_BADFORMATTED}
  MSIDBERROR_BADTEMPLATE       = 17; //  bad template string
  {$EXTERNALSYM MSIDBERROR_BADTEMPLATE}
  MSIDBERROR_BADDEFAULTDIR     = 18; //  bad string in DefaultDir column of Directory table
  {$EXTERNALSYM MSIDBERROR_BADDEFAULTDIR}
  MSIDBERROR_BADREGPATH        = 19; //  bad registry path string
  {$EXTERNALSYM MSIDBERROR_BADREGPATH}
  MSIDBERROR_BADCUSTOMSOURCE   = 20; //  bad string in CustomSource column of CustomAction table
  {$EXTERNALSYM MSIDBERROR_BADCUSTOMSOURCE}
  MSIDBERROR_BADPROPERTY       = 21; //  bad property string
  {$EXTERNALSYM MSIDBERROR_BADPROPERTY}
  MSIDBERROR_MISSINGDATA       = 22; //  _Validation table missing reference to column
  {$EXTERNALSYM MSIDBERROR_MISSINGDATA}
  MSIDBERROR_BADCATEGORY       = 23; //  Category column of _Validation table for column is invalid
  {$EXTERNALSYM MSIDBERROR_BADCATEGORY}
  MSIDBERROR_BADKEYTABLE       = 24; //  table in KeyTable column of _Validation table could not be found/loaded
  {$EXTERNALSYM MSIDBERROR_BADKEYTABLE}
  MSIDBERROR_BADMAXMINVALUES   = 25; //  value in MaxValue column of _Validation table is less than value in MinValue column
  {$EXTERNALSYM MSIDBERROR_BADMAXMINVALUES}
  MSIDBERROR_BADCABINET        = 26; //  bad cabinet name
  {$EXTERNALSYM MSIDBERROR_BADCABINET}
  MSIDBERROR_BADSHORTCUT       = 27; //  bad shortcut target
  {$EXTERNALSYM MSIDBERROR_BADSHORTCUT}
  MSIDBERROR_STRINGOVERFLOW    = 28; //  string overflow (greater than length allowed in column def)
  {$EXTERNALSYM MSIDBERROR_STRINGOVERFLOW}
  MSIDBERROR_BADLOCALIZEATTRIB = 29; //  invalid localization attribute (primary keys cannot be localized)
  {$EXTERNALSYM MSIDBERROR_BADLOCALIZEATTRIB}

type
  MSIDBERROR = DWORD;
  {$EXTERNALSYM MSIDBERROR}
  TMsiDbError = MSIDBERROR;

const
  MSIRUNMODE_ADMIN           =  0; // admin mode install, else product install
  {$EXTERNALSYM MSIRUNMODE_ADMIN}
  MSIRUNMODE_ADVERTISE       =  1; // installing advertisements, else installing or updating product
  {$EXTERNALSYM MSIRUNMODE_ADVERTISE}
  MSIRUNMODE_MAINTENANCE     =  2; // modifying an existing installation, else new installation
  {$EXTERNALSYM MSIRUNMODE_MAINTENANCE}
  MSIRUNMODE_ROLLBACKENABLED =  3; // rollback is enabled
  {$EXTERNALSYM MSIRUNMODE_ROLLBACKENABLED}
  MSIRUNMODE_LOGENABLED      =  4; // log file active, enabled prior to install session
  {$EXTERNALSYM MSIRUNMODE_LOGENABLED}
  MSIRUNMODE_OPERATIONS      =  5; // spooling execute operations, else in determination phase
  {$EXTERNALSYM MSIRUNMODE_OPERATIONS}
  MSIRUNMODE_REBOOTATEND     =  6; // reboot needed after successful installation (settable)
  {$EXTERNALSYM MSIRUNMODE_REBOOTATEND}
  MSIRUNMODE_REBOOTNOW       =  7; // reboot needed to continue installation (settable)
  {$EXTERNALSYM MSIRUNMODE_REBOOTNOW}
  MSIRUNMODE_CABINET         =  8; // installing files from cabinets and files using Media table
  {$EXTERNALSYM MSIRUNMODE_CABINET}
  MSIRUNMODE_SOURCESHORTNAMES=  9; // source LongFileNames suppressed via PID_MSISOURCE summary property
  {$EXTERNALSYM MSIRUNMODE_SOURCESHORTNAMES}
  MSIRUNMODE_TARGETSHORTNAMES= 10; // target LongFileNames suppressed via SHORTFILENAMES property
  {$EXTERNALSYM MSIRUNMODE_TARGETSHORTNAMES}
  MSIRUNMODE_RESERVED11      = 11; // future use
  {$EXTERNALSYM MSIRUNMODE_RESERVED11}
  MSIRUNMODE_WINDOWS9X       = 12; // operating systems is Windows9?, else Windows NT
  {$EXTERNALSYM MSIRUNMODE_WINDOWS9X}
  MSIRUNMODE_ZAWENABLED      = 13; // operating system supports demand installation
  {$EXTERNALSYM MSIRUNMODE_ZAWENABLED}
  MSIRUNMODE_RESERVED14      = 14; // future use
  {$EXTERNALSYM MSIRUNMODE_RESERVED14}
  MSIRUNMODE_RESERVED15      = 15; // future use
  {$EXTERNALSYM MSIRUNMODE_RESERVED15}
  MSIRUNMODE_SCHEDULED       = 16; // custom action call from install script execution
  {$EXTERNALSYM MSIRUNMODE_SCHEDULED}
  MSIRUNMODE_ROLLBACK        = 17; // custom action call from rollback execution script
  {$EXTERNALSYM MSIRUNMODE_ROLLBACK}
  MSIRUNMODE_COMMIT          = 18; // custom action call from commit execution script
  {$EXTERNALSYM MSIRUNMODE_COMMIT}

type
  MSIRUNMODE = DWORD;
  {$EXTERNALSYM MSIRUNMODE}
  TMsiRunMode = MSIRUNMODE;

const
  INSTALLMESSAGE_TYPEMASK = DWORD($FF000000);  // mask for type code
  {$EXTERNALSYM INSTALLMESSAGE_TYPEMASK}

// Note: INSTALLMESSAGE_ERROR, INSTALLMESSAGE_WARNING, INSTALLMESSAGE_USER are to or'd
// with a message box style to indicate the buttons to display and return:
// MB_OK,MB_OKCANCEL,MB_ABORTRETRYIGNORE,MB_YESNOCANCEL,MB_YESNO,MB_RETRYCANCEL
// the default button (MB_DEFBUTTON1 is normal default):
// MB_DEFBUTTON1, MB_DEFBUTTON2, MB_DEFBUTTON3
// and optionally an icon style:
// MB_ICONERROR, MB_ICONQUESTION, MB_ICONWARNING, MB_ICONINFORMATION

const
  MSITRANSFORM_ERROR_ADDEXISTINGROW   = $00000001;
  {$EXTERNALSYM MSITRANSFORM_ERROR_ADDEXISTINGROW}
  MSITRANSFORM_ERROR_DELMISSINGROW    = $00000002;
  {$EXTERNALSYM MSITRANSFORM_ERROR_DELMISSINGROW}
  MSITRANSFORM_ERROR_ADDEXISTINGTABLE = $00000004;
  {$EXTERNALSYM MSITRANSFORM_ERROR_ADDEXISTINGTABLE}
  MSITRANSFORM_ERROR_DELMISSINGTABLE  = $00000008;
  {$EXTERNALSYM MSITRANSFORM_ERROR_DELMISSINGTABLE}
  MSITRANSFORM_ERROR_UPDATEMISSINGROW = $00000010;
  {$EXTERNALSYM MSITRANSFORM_ERROR_UPDATEMISSINGROW}
  MSITRANSFORM_ERROR_CHANGECODEPAGE   = $00000020;
  {$EXTERNALSYM MSITRANSFORM_ERROR_CHANGECODEPAGE}
  MSITRANSFORM_ERROR_VIEWTRANSFORM    = $00000100;
  {$EXTERNALSYM MSITRANSFORM_ERROR_VIEWTRANSFORM}

type
  MSITRANSFORM_ERROR = DWORD;
  {$EXTERNALSYM MSITRANSFORM_ERROR}
  TMsiTransformError = MSITRANSFORM_ERROR;

const
  MSITRANSFORM_VALIDATE_LANGUAGE                   = $00000001;
  {$EXTERNALSYM MSITRANSFORM_VALIDATE_LANGUAGE}
  MSITRANSFORM_VALIDATE_PRODUCT                    = $00000002;
  {$EXTERNALSYM MSITRANSFORM_VALIDATE_PRODUCT}
  MSITRANSFORM_VALIDATE_PLATFORM                   = $00000004;
  {$EXTERNALSYM MSITRANSFORM_VALIDATE_PLATFORM}
  MSITRANSFORM_VALIDATE_MAJORVERSION               = $00000008;
  {$EXTERNALSYM MSITRANSFORM_VALIDATE_MAJORVERSION}
  MSITRANSFORM_VALIDATE_MINORVERSION               = $00000010;
  {$EXTERNALSYM MSITRANSFORM_VALIDATE_MINORVERSION}
  MSITRANSFORM_VALIDATE_UPDATEVERSION              = $00000020;
  {$EXTERNALSYM MSITRANSFORM_VALIDATE_UPDATEVERSION}
  MSITRANSFORM_VALIDATE_NEWLESSBASEVERSION         = $00000040;
  {$EXTERNALSYM MSITRANSFORM_VALIDATE_NEWLESSBASEVERSION}
  MSITRANSFORM_VALIDATE_NEWLESSEQUALBASEVERSION    = $00000080;
  {$EXTERNALSYM MSITRANSFORM_VALIDATE_NEWLESSEQUALBASEVERSION}
  MSITRANSFORM_VALIDATE_NEWEQUALBASEVERSION        = $00000100;
  {$EXTERNALSYM MSITRANSFORM_VALIDATE_NEWEQUALBASEVERSION}
  MSITRANSFORM_VALIDATE_NEWGREATEREQUALBASEVERSION = $00000200;
  {$EXTERNALSYM MSITRANSFORM_VALIDATE_NEWGREATEREQUALBASEVERSION}
  MSITRANSFORM_VALIDATE_NEWGREATERBASEVERSION      = $00000400;
  {$EXTERNALSYM MSITRANSFORM_VALIDATE_NEWGREATERBASEVERSION}
  MSITRANSFORM_VALIDATE_UPGRADECODE                = $00000800;
  {$EXTERNALSYM MSITRANSFORM_VALIDATE_UPGRADECODE}

type
  MSITRANSFORM_VALIDATE = DWORD;
  {$EXTERNALSYM MSITRANSFORM_VALIDATE}
  TMsiTransformValidate = MSITRANSFORM_VALIDATE;

// -----------------------------------------------------------------------------
// Installer database access functions
// -----------------------------------------------------------------------------

// Prepare a database query, creating a view object
// Returns ERROR_SUCCESS if successful, and the view handle is returned,
// else ERROR_INVALID_HANDLE, ERROR_INVALID_HANDLE_STATE, ERROR_BAD_QUERY_SYNTAX, ERROR_GEN_FAILURE
// Execution of this function sets the error record, accessible via MsiGetLastErrorRecord

function MsiDatabaseOpenViewA(hDatabase: MSIHANDLE; szQuery: LPCSTR; var phView: MSIHANDLE): UINT; stdcall;
{$EXTERNALSYM MsiDatabaseOpenViewA}
function MsiDatabaseOpenViewW(hDatabase: MSIHANDLE; szQuery: LPCWSTR; var phView: MSIHANDLE): UINT; stdcall;
{$EXTERNALSYM MsiDatabaseOpenViewW}
function MsiDatabaseOpenView(hDatabase: MSIHANDLE; szQuery: LPCTSTR; var phView: MSIHANDLE): UINT; stdcall;
{$EXTERNALSYM MsiDatabaseOpenView}

// Returns the MSIDBERROR enum and name of the column corresponding to the error
// Similar to a GetLastError function, but for the view. NOT the same as MsiGetLastErrorRecord
// Returns errors of MsiViewModify.

function MsiViewGetErrorA(hView: MSIHANDLE; szColumnNameBuffer: LPSTR;
  var pcchBuf: DWORD): MSIDBERROR; stdcall;
{$EXTERNALSYM MsiViewGetErrorA}
function MsiViewGetErrorW(hView: MSIHANDLE; szColumnNameBuffer: LPWSTR;
  var pcchBuf: DWORD): MSIDBERROR; stdcall;
{$EXTERNALSYM MsiViewGetErrorW}
function MsiViewGetError(hView: MSIHANDLE; szColumnNameBuffer: LPTSTR;
  var pcchBuf: DWORD): MSIDBERROR; stdcall;
{$EXTERNALSYM MsiViewGetError}

// Exectute the view query, supplying parameters as required
// Returns ERROR_SUCCESS, ERROR_INVALID_HANDLE, ERROR_INVALID_HANDLE_STATE, ERROR_GEN_FAILURE
// Execution of this function sets the error record, accessible via MsiGetLastErrorRecord

function MsiViewExecute(hView: MSIHANDLE; hRecord: MSIHANDLE): UINT; stdcall;
{$EXTERNALSYM MsiViewExecute}

// Fetch the next sequential record from the view
// Result is ERROR_SUCCESS if a row is found, and its handle is returned
// else ERROR_NO_MORE_ITEMS if no records remain, and a null handle is returned
// else result is error: ERROR_INVALID_HANDLE_STATE, ERROR_INVALID_HANDLE, ERROR_GEN_FAILURE

function MsiViewFetch(hView: MSIHANDLE; var phRecord: MSIHANDLE): UINT; stdcall;
{$EXTERNALSYM MsiViewFetch}

// Modify a database record, parameters must match types in query columns
// Returns ERROR_SUCCESS, ERROR_INVALID_HANDLE, ERROR_INVALID_HANDLE_STATE, ERROR_GEN_FAILURE, ERROR_ACCESS_DENIED
// Execution of this function sets the error record, accessible via MsiGetLastErrorRecord

function MsiViewModify(hView: MSIHANDLE; eModifyMode: MSIMODIFY; hRecord: MSIHANDLE): UINT; stdcall;
{$EXTERNALSYM MsiViewModify}

// Return the column names or specifications for the current view
// Returns ERROR_SUCCESS, ERROR_INVALID_HANDLE, ERROR_INVALID_PARAMETER, or ERROR_INVALID_HANDLE_STATE

function MsiViewGetColumnInfo(hView: MSIHANDLE; eColumnInfo: MSICOLINFO;
  var phRecord: MSIHANDLE): UINT; stdcall;
{$EXTERNALSYM MsiViewGetColumnInfo}

// Release the result set for an executed view, to allow re-execution
// Only needs to be called if not all records have been fetched
// Returns ERROR_SUCCESS, ERROR_INVALID_HANDLE, ERROR_INVALID_HANDLE_STATE

function MsiViewClose(hView: MSIHANDLE): UINT; stdcall;
{$EXTERNALSYM MsiViewClose}

// Return a record containing the names of all primary key columns for a given table
// Returns an MSIHANDLE for a record containing the name of each column.
// The field count of the record corresponds to the number of primary key columns.
// Field [0] of the record contains the table name.
// Returns ERROR_SUCCESS, ERROR_INVALID_HANDLE, ERROR_INVALID_TABLE

function MsiDatabaseGetPrimaryKeysA(hDatabase: MSIHANDLE; szTableName: LPCSTR;
  var phRecord: MSIHANDLE): UINT; stdcall;
{$EXTERNALSYM MsiDatabaseGetPrimaryKeysA}
function MsiDatabaseGetPrimaryKeysW(hDatabase: MSIHANDLE; szTableName: LPCWSTR;
  var phRecord: MSIHANDLE): UINT; stdcall;
{$EXTERNALSYM MsiDatabaseGetPrimaryKeysW}
function MsiDatabaseGetPrimaryKeys(hDatabase: MSIHANDLE; szTableName: LPCTSTR;
  var phRecord: MSIHANDLE): UINT; stdcall;
{$EXTERNALSYM MsiDatabaseGetPrimaryKeys}

// Return an enum defining the state of the table (temporary, unknown, or persistent).
// Returns MSICONDITION_ERROR, MSICONDITION_FALSE, MSICONDITION_TRUE, MSICONDITION_NONE

function MsiDatabaseIsTablePersistentA(hDatabase: MSIHANDLE; szTableName: LPCSTR): MSICONDITION; stdcall;
{$EXTERNALSYM MsiDatabaseIsTablePersistentA}
function MsiDatabaseIsTablePersistentW(hDatabase: MSIHANDLE; szTableName: LPCWSTR): MSICONDITION; stdcall;
{$EXTERNALSYM MsiDatabaseIsTablePersistentW}
function MsiDatabaseIsTablePersistent(hDatabase: MSIHANDLE; szTableName: LPCTSTR): MSICONDITION; stdcall;
{$EXTERNALSYM MsiDatabaseIsTablePersistent}

// --------------------------------------------------------------------------
// Summary information stream management functions
// --------------------------------------------------------------------------

// Integer Property IDs:    1, 14, 15, 16, 19
// DateTime Property IDs:   10, 11, 12, 13
// Text Property IDs:       2, 3, 4, 5, 6, 7, 8, 9, 18
// Unsupported Propery IDs: 0 (PID_DICTIONARY), 17 (PID_THUMBNAIL)

// Obtain a handle for the _SummaryInformation stream for an MSI database
// Execution of this function sets the error record, accessible via MsiGetLastErrorRecord

function MsiGetSummaryInformationA(hDatabase: MSIHANDLE; szDatabasePath: LPCSTR;
  uiUpdateCount: UINT; var phSummaryInfo: MSIHANDLE): UINT; stdcall;
{$EXTERNALSYM MsiGetSummaryInformationA}
function MsiGetSummaryInformationW(hDatabase: MSIHANDLE; szDatabasePath: LPCWSTR;
  uiUpdateCount: UINT; var phSummaryInfo: MSIHANDLE): UINT; stdcall;
{$EXTERNALSYM MsiGetSummaryInformationW}
function MsiGetSummaryInformation(hDatabase: MSIHANDLE; szDatabasePath: LPCTSTR;
  uiUpdateCount: UINT; var phSummaryInfo: MSIHANDLE): UINT; stdcall;
{$EXTERNALSYM MsiGetSummaryInformation}

// Obtain the number of existing properties in the SummaryInformation stream

function MsiSummaryInfoGetPropertyCount(hSummaryInfo: MSIHANDLE; var puiPropertyCount: UINT): UINT; stdcall;
{$EXTERNALSYM MsiSummaryInfoGetPropertyCount}

// Set a single summary information property
// Returns ERROR_SUCCESS, ERROR_INVALID_HANDLE, ERROR_UNKNOWN_PROPERTY

function MsiSummaryInfoSetPropertyA(hSummaryInfo: MSIHANDLE; uiProperty: UINT;
  uiDataType: UINT; iValue: Integer; const pftValue: FILETIME; szValue: LPCSTR): UINT; stdcall;
{$EXTERNALSYM MsiSummaryInfoSetPropertyA}
function MsiSummaryInfoSetPropertyW(hSummaryInfo: MSIHANDLE; uiProperty: UINT;
  uiDataType: UINT; iValue: Integer; const pftValue: FILETIME; szValue: LPCWSTR): UINT; stdcall;
{$EXTERNALSYM MsiSummaryInfoSetPropertyW}
function MsiSummaryInfoSetProperty(hSummaryInfo: MSIHANDLE; uiProperty: UINT;
  uiDataType: UINT; iValue: Integer; const pftValue: FILETIME; szValue: LPCTSTR): UINT; stdcall;
{$EXTERNALSYM MsiSummaryInfoSetProperty}

// Get a single property from the summary information
// Returns ERROR_SUCCESS, ERROR_INVALID_HANDLE, ERROR_UNKNOWN_PROPERTY

function MsiSummaryInfoGetPropertyA(hSummaryInfo: MSIHANDLE; uiProperty: UINT;
  var puiDataType: UINT; var piValue: Integer; var pftValue: FILETIME; szValueBuf: LPSTR;
  var pcchValueBuf: DWORD): UINT; stdcall;
{$EXTERNALSYM MsiSummaryInfoGetPropertyA}
function MsiSummaryInfoGetPropertyW(hSummaryInfo: MSIHANDLE; uiProperty: UINT;
  var puiDataType: UINT; var piValue: Integer; var pftValue: FILETIME; szValueBuf: LPWSTR;
  var pcchValueBuf: DWORD): UINT; stdcall;
{$EXTERNALSYM MsiSummaryInfoGetPropertyW}
function MsiSummaryInfoGetProperty(hSummaryInfo: MSIHANDLE; uiProperty: UINT;
  var puiDataType: UINT; var piValue: Integer; var pftValue: FILETIME; szValueBuf: LPTSTR;
  var pcchValueBuf: DWORD): UINT; stdcall;
{$EXTERNALSYM MsiSummaryInfoGetProperty}

// Write back changed information to summary information stream

function MsiSummaryInfoPersist(hSummaryInfo: MSIHANDLE): UINT; stdcall;
{$EXTERNALSYM MsiSummaryInfoPersist}

// --------------------------------------------------------------------------
// Installer database management functions - not used by custom actions
// --------------------------------------------------------------------------

// Open an installer database, specifying the persistance mode, which is a pointer.
// Predefined persist values are reserved pointer values, requiring pointer arithmetic.
// Execution of this function sets the error record, accessible via MsiGetLastErrorRecord

function MsiOpenDatabaseA(szDatabasePath: LPCSTR; szPersist: LPCSTR;
  var phDatabase: MSIHANDLE): UINT; stdcall;
{$EXTERNALSYM MsiOpenDatabaseA}
function MsiOpenDatabaseW(szDatabasePath: LPCWSTR; szPersist: LPCWSTR;
  var phDatabase: MSIHANDLE): UINT; stdcall;
{$EXTERNALSYM MsiOpenDatabaseW}
function MsiOpenDatabase(szDatabasePath: LPCTSTR; szPersist: LPCTSTR;
  var phDatabase: MSIHANDLE): UINT; stdcall;
{$EXTERNALSYM MsiOpenDatabase}

// Import an MSI text archive table into an open database
// Execution of this function sets the error record, accessible via MsiGetLastErrorRecord

function MsiDatabaseImportA(hDatabase: MSIHANDLE; szFolderPath: LPCSTR;
  szFileName: LPCSTR): UINT; stdcall;
{$EXTERNALSYM MsiDatabaseImportA}
function MsiDatabaseImportW(hDatabase: MSIHANDLE; szFolderPath: LPCWSTR;
  szFileName: LPCWSTR): UINT; stdcall;
{$EXTERNALSYM MsiDatabaseImportW}
function MsiDatabaseImport(hDatabase: MSIHANDLE; szFolderPath: LPCTSTR;
  szFileName: LPCTSTR): UINT; stdcall;
{$EXTERNALSYM MsiDatabaseImport}

// Export an MSI table from an open database to a text archive file
// Execution of this function sets the error record, accessible via MsiGetLastErrorRecord

function MsiDatabaseExportA(hDatabase: MSIHANDLE; szTableName: LPCSTR;
  szFolderPath: LPCSTR; szFileName: LPCSTR): UINT; stdcall;
{$EXTERNALSYM MsiDatabaseExportA}
function MsiDatabaseExportW(hDatabase: MSIHANDLE; szTableName: LPCWSTR;
  szFolderPath: LPCWSTR; szFileName: LPCWSTR): UINT; stdcall;
{$EXTERNALSYM MsiDatabaseExportW}
function MsiDatabaseExport(hDatabase: MSIHANDLE; szTableName: LPCTSTR;
  szFolderPath: LPCTSTR; szFileName: LPCTSTR): UINT; stdcall;
{$EXTERNALSYM MsiDatabaseExport}

// Merge two database together, allowing duplicate rows
// Execution of this function sets the error record, accessible via MsiGetLastErrorRecord

function MsiDatabaseMergeA(hDatabase: MSIHANDLE; hDatabaseMerge: MSIHANDLE;
  szTableName: LPCSTR): UINT; stdcall;
{$EXTERNALSYM MsiDatabaseMergeA}
function MsiDatabaseMergeW(hDatabase: MSIHANDLE; hDatabaseMerge: MSIHANDLE;
  szTableName: LPCWSTR): UINT; stdcall;
{$EXTERNALSYM MsiDatabaseMergeW}
function MsiDatabaseMerge(hDatabase: MSIHANDLE; hDatabaseMerge: MSIHANDLE;
  szTableName: LPCTSTR): UINT; stdcall;
{$EXTERNALSYM MsiDatabaseMerge}

// Generate a transform file of differences between two databases
// Execution of this function sets the error record, accessible via MsiGetLastErrorRecord

function MsiDatabaseGenerateTransformA(hDatabase: MSIHANDLE; hDatabaseReference: MSIHANDLE;
  szTransformFile: LPCSTR; iReserved1: Integer; iReserved2: Integer): UINT; stdcall;
{$EXTERNALSYM MsiDatabaseGenerateTransformA}
function MsiDatabaseGenerateTransformW(hDatabase: MSIHANDLE; hDatabaseReference: MSIHANDLE;
  szTransformFile: LPCWSTR; iReserved1: Integer; iReserved2: Integer): UINT; stdcall;
{$EXTERNALSYM MsiDatabaseGenerateTransformW}
function MsiDatabaseGenerateTransform(hDatabase: MSIHANDLE; hDatabaseReference: MSIHANDLE;
  szTransformFile: LPCTSTR; iReserved1: Integer; iReserved2: Integer): UINT; stdcall;
{$EXTERNALSYM MsiDatabaseGenerateTransform}

// Apply a transform file containing database difference
// Execution of this function sets the error record, accessible via MsiGetLastErrorRecord

function MsiDatabaseApplyTransformA(hDatabase: MSIHANDLE; szTransformFile: LPCSTR;
  iErrorConditions: Integer): UINT; stdcall;
{$EXTERNALSYM MsiDatabaseApplyTransformA}
function MsiDatabaseApplyTransformW(hDatabase: MSIHANDLE; szTransformFile: LPCWSTR;
  iErrorConditions: Integer): UINT; stdcall;
{$EXTERNALSYM MsiDatabaseApplyTransformW}
function MsiDatabaseApplyTransform(hDatabase: MSIHANDLE; szTransformFile: LPCTSTR;
  iErrorConditions: Integer): UINT; stdcall;
{$EXTERNALSYM MsiDatabaseApplyTransform}

// Create summary information of existing transform to include validation and error conditions
// Execution of this function sets the error record, accessible via MsiGetLastErrorRecord

function MsiCreateTransformSummaryInfoA(hDatabase: MSIHANDLE; hDatabaseReference: MSIHANDLE;
  szTransformFile: LPCSTR; iErrorConditions: Integer; iValidation: Integer): UINT; stdcall;
{$EXTERNALSYM MsiCreateTransformSummaryInfoA}
function MsiCreateTransformSummaryInfoW(hDatabase: MSIHANDLE; hDatabaseReference: MSIHANDLE;
  szTransformFile: LPCWSTR; iErrorConditions: Integer; iValidation: Integer): UINT; stdcall;
{$EXTERNALSYM MsiCreateTransformSummaryInfoW}
function MsiCreateTransformSummaryInfo(hDatabase: MSIHANDLE; hDatabaseReference: MSIHANDLE;
  szTransformFile: LPCTSTR; iErrorConditions: Integer; iValidation: Integer): UINT; stdcall;
{$EXTERNALSYM MsiCreateTransformSummaryInfo}

// Write out all persistent table data, ignored if database opened read-only
// Execution of this function sets the error record, accessible via MsiGetLastErrorRecord

function MsiDatabaseCommit(hDatabase: MSIHANDLE): UINT; stdcall;
{$EXTERNALSYM MsiDatabaseCommit}

// Return the update state of a database

function MsiGetDatabaseState(hDatabase: MSIHANDLE): MSIDBSTATE; stdcall;
{$EXTERNALSYM MsiGetDatabaseState}

// --------------------------------------------------------------------------
// Record object functions
// --------------------------------------------------------------------------

// Create a new record object with the requested number of fields
// Field 0, not included in count, is used for format strings and op codes
// All fields are initialized to null
// Returns a handle to the created record, or 0 if memory could not be allocated

function MsiCreateRecord(cParams: UINT): MSIHANDLE; stdcall;
{$EXTERNALSYM MsiCreateRecord}

// Report whether a record field is NULL
// Returns TRUE if the field is null or does not exist
// Returns FALSE if the field contains data, or the handle is invalid

function MsiRecordIsNull(hRecord: MSIHANDLE; iField: UINT): BOOL; stdcall;
{$EXTERNALSYM MsiRecordIsNull}

// Return the length of a record field
// Returns 0 if field is NULL or non-existent
// Returns sizeof(Integer) if integer data
// Returns character count if string data (not counting null terminator)
// Returns bytes count if stream data

function MsiRecordDataSize(hRecord: MSIHANDLE; iField: UINT): UINT; stdcall;
{$EXTERNALSYM MsiRecordDataSize}

// Set a record field to an integer value
// Returns ERROR_SUCCESS, ERROR_INVALID_HANDLE, ERROR_INVALID_FIELD

function MsiRecordSetInteger(hRecord: MSIHANDLE; iField: UINT; iValue: Integer): UINT; stdcall;
{$EXTERNALSYM MsiRecordSetInteger}

// Copy a string into the designated field
// A null string pointer and an empty string both set the field to null
// Returns ERROR_SUCCESS, ERROR_INVALID_HANDLE, ERROR_INVALID_FIELD

function MsiRecordSetStringA(hRecord: MSIHANDLE; iField: UINT; szValue: LPCSTR): UINT; stdcall;
{$EXTERNALSYM MsiRecordSetStringA}
function MsiRecordSetStringW(hRecord: MSIHANDLE; iField: UINT; szValue: LPCWSTR): UINT; stdcall;
{$EXTERNALSYM MsiRecordSetStringW}
function MsiRecordSetString(hRecord: MSIHANDLE; iField: UINT; szValue: LPCTSTR): UINT; stdcall;
{$EXTERNALSYM MsiRecordSetString}

// Return the integer value from a record field
// Returns the value MSI_NULL_INTEGER if the field is null
// or if the field is a string that cannot be converted to an integer

function MsiRecordGetInteger(hRecord: MSIHANDLE; iField: UINT): Integer; stdcall;
{$EXTERNALSYM MsiRecordGetInteger}

// Return the string value of a record field
// Integer fields will be converted to a string
// Null and non-existent fields will report a value of 0
// Fields containing stream data will return ERROR_INVALID_DATATYPE
// Returns ERROR_SUCCESS, ERROR_MORE_DATA,
//         ERROR_INVALID_HANDLE, ERROR_INVALID_FIELD, ERROR_BAD_ARGUMENTS

function MsiRecordGetStringA(hRecord: MSIHANDLE; iField: UINT; szValueBuf: LPSTR;
  var pcchValueBuf: DWORD): UINT; stdcall;
{$EXTERNALSYM MsiRecordGetStringA}
function MsiRecordGetStringW(hRecord: MSIHANDLE; iField: UINT; szValueBuf: LPWSTR;
  var pcchValueBuf: DWORD): UINT; stdcall;
{$EXTERNALSYM MsiRecordGetStringW}
function MsiRecordGetString(hRecord: MSIHANDLE; iField: UINT; szValueBuf: LPTSTR;
  var pcchValueBuf: DWORD): UINT; stdcall;
{$EXTERNALSYM MsiRecordGetString}

// Returns the number of fields allocated in the record
// Does not count field 0, used for formatting and op codes

function MsiRecordGetFieldCount(hRecord: MSIHANDLE): UINT; stdcall;
{$EXTERNALSYM MsiRecordGetFieldCount}

// Set a record stream field from a file
// The contents of the specified file will be read into a stream object
// The stream will be persisted if the record is inserted into the database
// Execution of this function sets the error record, accessible via MsiGetLastErrorRecord

function MsiRecordSetStreamA(hRecord: MSIHANDLE; iField: UINT; szFilePath: LPCSTR): UINT; stdcall;
{$EXTERNALSYM MsiRecordSetStreamA}
function MsiRecordSetStreamW(hRecord: MSIHANDLE; iField: UINT; szFilePath: LPCWSTR): UINT; stdcall;
{$EXTERNALSYM MsiRecordSetStreamW}
function MsiRecordSetStream(hRecord: MSIHANDLE; iField: UINT; szFilePath: LPCTSTR): UINT; stdcall;
{$EXTERNALSYM MsiRecordSetStream}

// Read bytes from a record stream field into a buffer
// Must set the in/out argument to the requested byte count to read
// The number of bytes transferred is returned through the argument
// If no more bytes are available, ERROR_SUCCESS is still returned

function MsiRecordReadStream(hRecord: MSIHANDLE; iField: UINT; szDataBuf: PChar;
  var pcbDataBuf: DWORD): UINT; stdcall;
{$EXTERNALSYM MsiRecordReadStream}

// Clears all data fields in a record to NULL

function MsiRecordClearData(hRecord: MSIHANDLE): UINT; stdcall;
{$EXTERNALSYM MsiRecordClearData}

// --------------------------------------------------------------------------
// Functions to access a running installation, called from custom actions
// The install handle is the single argument passed to custom actions
// --------------------------------------------------------------------------

// Return a handle to the database currently in use by this installer instance

function MsiGetActiveDatabase(hInstall: MSIHANDLE): MSIHANDLE; stdcall;
{$EXTERNALSYM MsiGetActiveDatabase}

// Set the value for an installer property
// If the property is not defined, it will be created
// If the value is null or an empty string, the property will be removed
// Returns ERROR_SUCCESS, ERROR_INVALID_HANDLE, ERROR_BAD_ARGUMENTS

function MsiSetPropertyA(hInstall: MSIHANDLE; szName: LPCSTR; szValue: LPCSTR): UINT; stdcall;
{$EXTERNALSYM MsiSetPropertyA}
function MsiSetPropertyW(hInstall: MSIHANDLE; szName: LPCWSTR; szValue: LPCWSTR): UINT; stdcall;
{$EXTERNALSYM MsiSetPropertyW}
function MsiSetProperty(hInstall: MSIHANDLE; szName: LPCTSTR; szValue: LPCTSTR): UINT; stdcall;
{$EXTERNALSYM MsiSetProperty}

// Get the value for an installer property
// If the property is not defined, it is equivalent to a 0-length value, not error
// Returns ERROR_SUCCESS, ERROR_MORE_DATA, ERROR_INVALID_HANDLE, ERROR_BAD_ARGUMENTS

function MsiGetPropertyA(hInstall: MSIHANDLE; szName: LPCSTR; szValueBuf: LPSTR;
  var pcchValueBuf: DWORD): UINT; stdcall;
{$EXTERNALSYM MsiGetPropertyA}
function MsiGetPropertyW(hInstall: MSIHANDLE; szName: LPCWSTR; szValueBuf: LPWSTR;
  var pcchValueBuf: DWORD): UINT; stdcall;
{$EXTERNALSYM MsiGetPropertyW}
function MsiGetProperty(hInstall: MSIHANDLE; szName: LPCTSTR; szValueBuf: LPTSTR;
  var pcchValueBuf: DWORD): UINT; stdcall;
{$EXTERNALSYM MsiGetProperty}

// Return the numeric language for the currently running install
// Returns 0 if an install not running

function MsiGetLanguage(hInstall: MSIHANDLE): LANGID; stdcall;
{$EXTERNALSYM MsiGetLanguage}

// Return one of the boolean internal installer states
// Returns FALSE if the handle is not active or if the mode is not implemented

function MsiGetMode(hInstall: MSIHANDLE; eRunMode: MSIRUNMODE): BOOL; stdcall;
{$EXTERNALSYM MsiGetMode}

// Set an internal install session boolean mode - Note: most modes are read-only
// Returns ERROR_SUCCESS if the mode can be set to the desired state
// Returns ERROR_ACCESS_DENIED if the mode is not settable
// Returns ERROR_INVALID_HANDLE if the handle is not an active install session

function MsiSetMode(hInstall: MSIHANDLE; eRunMode: MSIRUNMODE; fState: BOOL): UINT; stdcall;
{$EXTERNALSYM MsiSetMode}

// Format record data using a format string containing field markers and/or properties
// Record field 0 must contain the format string
// Other fields must contain data that may be referenced by the format string.

function MsiFormatRecordA(hInstall: MSIHANDLE; hRecord: MSIHANDLE; szResultBuf: LPSTR;
  var pcchResultBuf: DWORD): UINT; stdcall;
{$EXTERNALSYM MsiFormatRecordA}
function MsiFormatRecordW(hInstall: MSIHANDLE; hRecord: MSIHANDLE; szResultBuf: LPWSTR;
  var pcchResultBuf: DWORD): UINT; stdcall;
{$EXTERNALSYM MsiFormatRecordW}
function MsiFormatRecord(hInstall: MSIHANDLE; hRecord: MSIHANDLE; szResultBuf: LPTSTR;
  var pcchResultBuf: DWORD): UINT; stdcall;
{$EXTERNALSYM MsiFormatRecord}

// Execute another action, either built-in, custom, or UI wizard
// Returns ERROR_FUNCTION_NOT_CALLED if action not found
// Returns ERROR_SUCCESS if action completed succesfully
// Returns ERROR_INSTALL_USEREXIT if user cancelled during action
// Returns ERROR_INSTALL_FAILURE if action failed
// Returns ERROR_INSTALL_SUSPEND if user suspended installation
// Returns ERROR_MORE_DATA if action wishes to skip remaining actions
// Returns ERROR_INVALID_HANDLE_STATE if install session not active
// Returns ERROR_INVALID_DATA if failure calling custom action
// Returns ERROR_INVALID_HANDLE or ERROR_INVALID_PARAMETER if arguments invalid

function MsiDoActionA(hInstall: MSIHANDLE; szAction: LPCSTR): UINT; stdcall;
{$EXTERNALSYM MsiDoActionA}
function MsiDoActionW(hInstall: MSIHANDLE; szAction: LPCWSTR): UINT; stdcall;
{$EXTERNALSYM MsiDoActionW}
function MsiDoAction(hInstall: MSIHANDLE; szAction: LPCTSTR): UINT; stdcall;
{$EXTERNALSYM MsiDoAction}

// Execute another action sequence, as descibed in the specified table
// Returns the same error codes as MsiDoAction

function MsiSequenceA(hInstall: MSIHANDLE; szTable: LPCSTR; iSequenceMode: Integer): UINT; stdcall;
{$EXTERNALSYM MsiSequenceA}
function MsiSequenceW(hInstall: MSIHANDLE; szTable: LPCWSTR; iSequenceMode: Integer): UINT; stdcall;
{$EXTERNALSYM MsiSequenceW}
function MsiSequence(hInstall: MSIHANDLE; szTable: LPCTSTR; iSequenceMode: Integer): UINT; stdcall;
{$EXTERNALSYM MsiSequence}

// Send an error record to the installer for processing.
// If field 0 (template) is not set, field 1 must be set to the error code,
//   corresponding the the error message in the Error database table,
//   and the message will be formatted using the template from the Error table
//   before passing it to the UI handler for display.
// Returns Win32 button codes: IDOK IDCANCEL IDABORT IDRETRY IDIGNORE IDYES IDNO
//   or 0 if no action taken, or -1 if invalid argument or handle

function MsiProcessMessage(hInstall: MSIHANDLE; eMessageType: INSTALLMESSAGE;
  hRecord: MSIHANDLE): Integer; stdcall;
{$EXTERNALSYM MsiProcessMessage}

// Evaluate a conditional expression containing property names and values

function MsiEvaluateConditionA(hInstall: MSIHANDLE; szCondition: LPCSTR): MSICONDITION; stdcall;
{$EXTERNALSYM MsiEvaluateConditionA}
function MsiEvaluateConditionW(hInstall: MSIHANDLE; szCondition: LPCWSTR): MSICONDITION; stdcall;
{$EXTERNALSYM MsiEvaluateConditionW}
function MsiEvaluateCondition(hInstall: MSIHANDLE; szCondition: LPCTSTR): MSICONDITION; stdcall;
{$EXTERNALSYM MsiEvaluateCondition}

// Get the installed state and requested action state of a feature
// Execution of this function sets the error record, accessible via MsiGetLastErrorRecord

function MsiGetFeatureStateA(hInstall: MSIHANDLE; szFeature: LPCSTR;
  var piInstalled: INSTALLSTATE; var piAction: INSTALLSTATE): UINT; stdcall;
{$EXTERNALSYM MsiGetFeatureStateA}
function MsiGetFeatureStateW(hInstall: MSIHANDLE; szFeature: LPCWSTR;
  var piInstalled: INSTALLSTATE; var piAction: INSTALLSTATE): UINT; stdcall;
{$EXTERNALSYM MsiGetFeatureStateW}
function MsiGetFeatureState(hInstall: MSIHANDLE; szFeature: LPCTSTR;
  var piInstalled: INSTALLSTATE; var piAction: INSTALLSTATE): UINT; stdcall;
{$EXTERNALSYM MsiGetFeatureState}

// Request a feature to be set to a specified state
// Execution of this function sets the error record, accessible via MsiGetLastErrorRecord

function MsiSetFeatureStateA(hInstall: MSIHANDLE; szFeature: LPCSTR;
  iState: INSTALLSTATE): UINT; stdcall;
{$EXTERNALSYM MsiSetFeatureStateA}
function MsiSetFeatureStateW(hInstall: MSIHANDLE; szFeature: LPCWSTR;
  iState: INSTALLSTATE): UINT; stdcall;
{$EXTERNALSYM MsiSetFeatureStateW}
function MsiSetFeatureState(hInstall: MSIHANDLE; szFeature: LPCTSTR;
  iState: INSTALLSTATE): UINT; stdcall;
{$EXTERNALSYM MsiSetFeatureState}

// Set the attribute bits of a specified feature at runtime.
// Execution of this function sets the error record, accessible via MsiGetLastErrorRecord

function MsiSetFeatureAttributesA(hInstall: MSIHANDLE; szFeature: LPCSTR;
  dwAttributes: DWORD): UINT; stdcall;
{$EXTERNALSYM MsiSetFeatureAttributesA}
function MsiSetFeatureAttributesW(hInstall: MSIHANDLE; szFeature: LPCWSTR;
  dwAttributes: DWORD): UINT; stdcall;
{$EXTERNALSYM MsiSetFeatureAttributesW}
function MsiSetFeatureAttributes(hInstall: MSIHANDLE; szFeature: LPCTSTR;
  dwAttributes: DWORD): UINT; stdcall;
{$EXTERNALSYM MsiSetFeatureAttributes}

// Get the installed state and requested action state of a component
// Execution of this function sets the error record, accessible via MsiGetLastErrorRecord

function MsiGetComponentStateA(hInstall: MSIHANDLE; szComponent: LPCSTR;
  var piInstalled: INSTALLSTATE; var piAction: INSTALLSTATE): UINT; stdcall;
{$EXTERNALSYM MsiGetComponentStateA}
function MsiGetComponentStateW(hInstall: MSIHANDLE; szComponent: LPCWSTR;
  var piInstalled: INSTALLSTATE; var piAction: INSTALLSTATE): UINT; stdcall;
{$EXTERNALSYM MsiGetComponentStateW}
function MsiGetComponentState(hInstall: MSIHANDLE; szComponent: LPCTSTR;
  var piInstalled: INSTALLSTATE; var piAction: INSTALLSTATE): UINT; stdcall;
{$EXTERNALSYM MsiGetComponentState}

// Request a component to be set to a specified state
// Execution of this function sets the error record, accessible via MsiGetLastErrorRecord

function MsiSetComponentStateA(hInstall: MSIHANDLE; szComponent: LPCSTR;
  iState: INSTALLSTATE): UINT; stdcall;
{$EXTERNALSYM MsiSetComponentStateA}
function MsiSetComponentStateW(hInstall: MSIHANDLE; szComponent: LPCWSTR;
  iState: INSTALLSTATE): UINT; stdcall;
{$EXTERNALSYM MsiSetComponentStateW}
function MsiSetComponentState(hInstall: MSIHANDLE; szComponent: LPCTSTR;
  iState: INSTALLSTATE): UINT; stdcall;
{$EXTERNALSYM MsiSetComponentState}

// Return the disk cost for a feature and related features
// Can specify either current feature state or proposed state
// Can specify extent of related features to cost
// Note that adding costs for several features may produce an
// excessively large cost due to shared components and parents.
// Execution of this function sets the error record, accessible via MsiGetLastErrorRecord

function MsiGetFeatureCostA(hInstall: MSIHANDLE; szFeature: LPCSTR;
  iCostTree: MSICOSTTREE; iState: INSTALLSTATE; var piCost: Integer): UINT; stdcall;
{$EXTERNALSYM MsiGetFeatureCostA}
function MsiGetFeatureCostW(hInstall: MSIHANDLE; szFeature: LPCWSTR;
  iCostTree: MSICOSTTREE; iState: INSTALLSTATE; var piCost: Integer): UINT; stdcall;
{$EXTERNALSYM MsiGetFeatureCostW}
function MsiGetFeatureCost(hInstall: MSIHANDLE; szFeature: LPCTSTR;
  iCostTree: MSICOSTTREE; iState: INSTALLSTATE; var piCost: Integer): UINT; stdcall;
{$EXTERNALSYM MsiGetFeatureCost}

// Enumerates the costs and temporary costs per drives for
// szComponent. If szComponent is set to NULL, it enumerates
// the above costs for the engine, per drives.
//
// The enumeration is 0-based, i.e. it returns the data for
// the first drive when called w/ dwIndex set to 0.
//
// Can specify either current feature state or proposed state.
//
// Execution of this function sets the error record, accessible
// via MsiGetLastErrorRecord.

function MsiEnumComponentCostsA(hInstall: MSIHANDLE; szComponent: LPCSTR; dwIndex: DWORD; iState: INSTALLSTATE;
  szDriveBuf: LPSTR; var pcchDriveBuf: DWORD; var piCost: INT; piTempCost: INT): UINT; stdcall;
{$EXTERNALSYM MsiEnumComponentCostsA}
function MsiEnumComponentCostsW(hInstall: MSIHANDLE; szComponent: LPCWSTR; dwIndex: DWORD; iState: INSTALLSTATE;
  szDriveBuf: LPWSTR; var pcchDriveBuf: DWORD; var piCost: INT; var piTempCost: INT): UINT; stdcall;
{$EXTERNALSYM MsiEnumComponentCostsW}
function MsiEnumComponentCosts(hInstall: MSIHANDLE; szComponent: LPCTSTR; dwIndex: DWORD; iState: INSTALLSTATE;
  szDriveBuf: LPTSTR; var pcchDriveBuf: DWORD; var piCost: INT; var piTempCost: INT): UINT; stdcall;
{$EXTERNALSYM MsiEnumComponentCosts}

// Set the install level for a full product installation (not a feature request)
// Setting the value to 0 initialized components and features to the default level
// Execution of this function sets the error record, accessible via MsiGetLastErrorRecord

function MsiSetInstallLevel(hInstall: MSIHANDLE; iInstallLevel: Integer): UINT; stdcall;
{$EXTERNALSYM MsiSetInstallLevel}

// Get the valid install states for a feature, represented by bit flags
// For each valid install state, a bit is set of value: (1 << INSTALLSTATE)
// Execution of this function sets the error record, accessible via MsiGetLastErrorRecord

function MsiGetFeatureValidStatesA(hInstall: MSIHANDLE; szFeature: LPCSTR;
  var dwInstallStates: DWORD): UINT; stdcall;
{$EXTERNALSYM MsiGetFeatureValidStatesA}
function MsiGetFeatureValidStatesW(hInstall: MSIHANDLE; szFeature: LPCWSTR;
  var dwInstallStates: DWORD): UINT; stdcall;
{$EXTERNALSYM MsiGetFeatureValidStatesW}
function MsiGetFeatureValidStates(hInstall: MSIHANDLE; szFeature: LPCTSTR;
  var dwInstallStates: DWORD): UINT; stdcall;
{$EXTERNALSYM MsiGetFeatureValidStates}

// Return the full source path for a folder in the Directory table
// Execution of this function sets the error record, accessible via MsiGetLastErrorRecord

function MsiGetSourcePathA(hInstall: MSIHANDLE; szFolder: LPCSTR; szPathBuf: LPSTR;
  var pcchPathBuf: DWORD): UINT; stdcall;
{$EXTERNALSYM MsiGetSourcePathA}
function MsiGetSourcePathW(hInstall: MSIHANDLE; szFolder: LPCWSTR; szPathBuf: LPWSTR;
  var pcchPathBuf: DWORD): UINT; stdcall;
{$EXTERNALSYM MsiGetSourcePathW}
function MsiGetSourcePath(hInstall: MSIHANDLE; szFolder: LPCTSTR; szPathBuf: LPTSTR;
  var pcchPathBuf: DWORD): UINT; stdcall;
{$EXTERNALSYM MsiGetSourcePath}

// Return the full target path for a folder in the Directory table
// Execution of this function sets the error record, accessible via MsiGetLastErrorRecord

function MsiGetTargetPathA(hInstall: MSIHANDLE; szFolder: LPCSTR;
  szPathBuf: LPSTR; var pcchPathBuf: DWORD): UINT; stdcall;
{$EXTERNALSYM MsiGetTargetPathA}
function MsiGetTargetPathW(hInstall: MSIHANDLE; szFolder: LPCWSTR;
  szPathBuf: LPWSTR; var pcchPathBuf: DWORD): UINT; stdcall;
{$EXTERNALSYM MsiGetTargetPathW}
function MsiGetTargetPath(hInstall: MSIHANDLE; szFolder: LPCTSTR;
  szPathBuf: LPTSTR; var pcchPathBuf: DWORD): UINT; stdcall;
{$EXTERNALSYM MsiGetTargetPath}

// Set the full target path for a folder in the Directory table
// Execution of this function sets the error record, accessible via MsiGetLastErrorRecord

function MsiSetTargetPathA(hInstall: MSIHANDLE; szFolder: LPCSTR;
  szFolderPath: LPCSTR): UINT; stdcall;
{$EXTERNALSYM MsiSetTargetPathA}
function MsiSetTargetPathW(hInstall: MSIHANDLE; szFolder: LPCWSTR;
  szFolderPath: LPCWSTR): UINT; stdcall;
{$EXTERNALSYM MsiSetTargetPathW}
function MsiSetTargetPath(hInstall: MSIHANDLE; szFolder: LPCTSTR;
  szFolderPath: LPCTSTR): UINT; stdcall;
{$EXTERNALSYM MsiSetTargetPath}

// Check to see if sufficent disk space is present for the current installation
// Returns ERROR_SUCCESS, ERROR_DISK_FULL, ERROR_INVALID_HANDLE_STATE, or ERROR_INVALID_HANDLE

function MsiVerifyDiskSpace(hInstall: MSIHANDLE): UINT; stdcall;
{$EXTERNALSYM MsiVerifyDiskSpace}

// --------------------------------------------------------------------------
// Functions for rendering UI dialogs from the database representations.
// Purpose is for product development, not for use during installation.
// --------------------------------------------------------------------------

// Enable UI in preview mode to facilitate authoring of UI dialogs.
// The preview mode will end when the handle is closed.

function MsiEnableUIPreview(hDatabase: MSIHANDLE; var phPreview: MSIHANDLE): UINT; stdcall;
{$EXTERNALSYM MsiEnableUIPreview}

// Display any UI dialog as modeless and inactive.
// Supplying a null name will remove any current dialog.

function MsiPreviewDialogA(hPreview: MSIHANDLE; szDialogName: LPCSTR): UINT; stdcall;
{$EXTERNALSYM MsiPreviewDialogA}
function MsiPreviewDialogW(hPreview: MSIHANDLE; szDialogName: LPCWSTR): UINT; stdcall;
{$EXTERNALSYM MsiPreviewDialogW}
function MsiPreviewDialog(hPreview: MSIHANDLE; szDialogName: LPCTSTR): UINT; stdcall;
{$EXTERNALSYM MsiPreviewDialog}

// Display a billboard within a host control in the displayed dialog.
// Supplying a null billboard name will remove any billboard displayed.

function MsiPreviewBillboardA(hPreview: MSIHANDLE; szControlName: LPCSTR;
  szBillboard: LPCSTR): UINT; stdcall;
{$EXTERNALSYM MsiPreviewBillboardA}
function MsiPreviewBillboardW(hPreview: MSIHANDLE; szControlName: LPCWSTR;
  szBillboard: LPCWSTR): UINT; stdcall;
{$EXTERNALSYM MsiPreviewBillboardW}
function MsiPreviewBillboard(hPreview: MSIHANDLE; szControlName: LPCTSTR;
  szBillboard: LPCTSTR): UINT; stdcall;
{$EXTERNALSYM MsiPreviewBillboard}

// --------------------------------------------------------------------------
// Error handling not associated with any particular object
// --------------------------------------------------------------------------

// Return a record handle to the last function that generated an error record
// Only specified functions will set the error record, or clear it if success
// Field 1 of the record will contain the internal MSI error code
// Other fields will contain data specific to the particular error
// The error record is released internally after this function is executed

function MsiGetLastErrorRecord: MSIHANDLE; stdcall;
{$EXTERNALSYM MsiGetLastErrorRecord}

{$ENDIF JWA_IMPLEMENTATIONSECTION}

{$IFNDEF JWA_OMIT_SECTIONS}
implementation
//uses ...
{$ENDIF JWA_OMIT_SECTIONS}

{$IFNDEF JWA_INTERFACESECTION}

{$IFNDEF JWA_INCLUDEMODE}
const
  msilib = 'msi.dll';
  {$IFDEF UNICODE}
  AWSuffix = 'W';
  {$ELSE}
  AWSuffix = 'A';
  {$ENDIF UNICODE}
{$ENDIF JWA_INCLUDEMODE}


{$IFDEF DYNAMIC_LINK}

var
  _MsiDatabaseOpenViewA: Pointer;

function MsiDatabaseOpenViewA;
begin
  GetProcedureAddress(_MsiDatabaseOpenViewA, msilib, 'MsiDatabaseOpenViewA');
  asm
        MOV     ESP, EBP
        POP     EBP
        JMP     [_MsiDatabaseOpenViewA]
  end;
end;

var
  _MsiDatabaseOpenViewW: Pointer;

function MsiDatabaseOpenViewW;
begin
  GetProcedureAddress(_MsiDatabaseOpenViewW, msilib, 'MsiDatabaseOpenViewW');
  asm
        MOV     ESP, EBP
        POP     EBP
        JMP     [_MsiDatabaseOpenViewW]
  end;
end;

var
  _MsiDatabaseOpenView: Pointer;

function MsiDatabaseOpenView;
begin
  GetProcedureAddress(_MsiDatabaseOpenView, msilib, 'MsiDatabaseOpenView' + AWSuffix);
  asm
        MOV     ESP, EBP
        POP     EBP
        JMP     [_MsiDatabaseOpenView]
  end;
end;

var
  _MsiViewGetErrorA: Pointer;

function MsiViewGetErrorA;
begin
  GetProcedureAddress(_MsiViewGetErrorA, msilib, 'MsiViewGetErrorA');
  asm
        MOV     ESP, EBP
        POP     EBP
        JMP     [_MsiViewGetErrorA]
  end;
end;

var
  _MsiViewGetErrorW: Pointer;

function MsiViewGetErrorW;
begin
  GetProcedureAddress(_MsiViewGetErrorW, msilib, 'MsiViewGetErrorW');
  asm
        MOV     ESP, EBP
        POP     EBP
        JMP     [_MsiViewGetErrorW]
  end;
end;

var
  _MsiViewGetError: Pointer;

function MsiViewGetError;
begin
  GetProcedureAddress(_MsiViewGetError, msilib, 'MsiViewGetError' + AWSuffix);
  asm
        MOV     ESP, EBP
        POP     EBP
        JMP     [_MsiViewGetError]
  end;
end;

var
  _MsiViewExecute: Pointer;

function MsiViewExecute;
begin
  GetProcedureAddress(_MsiViewExecute, msilib, 'MsiViewExecute');
  asm
        MOV     ESP, EBP
        POP     EBP
        JMP     [_MsiViewExecute]
  end;
end;

var
  _MsiViewFetch: Pointer;

function MsiViewFetch;
begin
  GetProcedureAddress(_MsiViewFetch, msilib, 'MsiViewFetch');
  asm
        MOV     ESP, EBP
        POP     EBP
        JMP     [_MsiViewFetch]
  end;
end;

var
  _MsiViewModify: Pointer;

function MsiViewModify;
begin
  GetProcedureAddress(_MsiViewModify, msilib, 'MsiViewModify');
  asm
        MOV     ESP, EBP
        POP     EBP
        JMP     [_MsiViewModify]
  end;
end;

var
  _MsiViewGetColumnInfo: Pointer;

function MsiViewGetColumnInfo;
begin
  GetProcedureAddress(_MsiViewGetColumnInfo, msilib, 'MsiViewGetColumnInfo');
  asm
        MOV     ESP, EBP
        POP     EBP
        JMP     [_MsiViewGetColumnInfo]
  end;
end;

var
  _MsiViewClose: Pointer;

function MsiViewClose;
begin
  GetProcedureAddress(_MsiViewClose, msilib, 'MsiViewClose');
  asm
        MOV     ESP, EBP
        POP     EBP
        JMP     [_MsiViewClose]
  end;
end;

var
  _MsiDatabaseGetPrimaryKeysA: Pointer;

function MsiDatabaseGetPrimaryKeysA;
begin
  GetProcedureAddress(_MsiDatabaseGetPrimaryKeysA, msilib, 'MsiDatabaseGetPrimaryKeysA');
  asm
        MOV     ESP, EBP
        POP     EBP
        JMP     [_MsiDatabaseGetPrimaryKeysA]
  end;
end;

var
  _MsiDatabaseGetPrimaryKeysW: Pointer;

function MsiDatabaseGetPrimaryKeysW;
begin
  GetProcedureAddress(_MsiDatabaseGetPrimaryKeysW, msilib, 'MsiDatabaseGetPrimaryKeysW');
  asm
        MOV     ESP, EBP
        POP     EBP
        JMP     [_MsiDatabaseGetPrimaryKeysW]
  end;
end;

var
  _MsiDatabaseGetPrimaryKeys: Pointer;

function MsiDatabaseGetPrimaryKeys;
begin
  GetProcedureAddress(_MsiDatabaseGetPrimaryKeys, msilib, 'MsiDatabaseGetPrimaryKeys' + AWSuffix);
  asm
        MOV     ESP, EBP
        POP     EBP
        JMP     [_MsiDatabaseGetPrimaryKeys]
  end;
end;

var
  _MsiDatabaseIsTablePersistentA: Pointer;

function MsiDatabaseIsTablePersistentA;
begin
  GetProcedureAddress(_MsiDatabaseIsTablePersistentA, msilib, 'MsiDatabaseIsTablePersistentA');
  asm
        MOV     ESP, EBP
        POP     EBP
        JMP     [_MsiDatabaseIsTablePersistentA]
  end;
end;

var
  _MsiDatabaseIsTablePersistentW: Pointer;

function MsiDatabaseIsTablePersistentW;
begin
  GetProcedureAddress(_MsiDatabaseIsTablePersistentW, msilib, 'MsiDatabaseIsTablePersistentW');
  asm
        MOV     ESP, EBP
        POP     EBP
        JMP     [_MsiDatabaseIsTablePersistentW]
  end;
end;

var
  _MsiDatabaseIsTablePersistent: Pointer;

function MsiDatabaseIsTablePersistent;
begin
  GetProcedureAddress(_MsiDatabaseIsTablePersistent, msilib, 'MsiDatabaseIsTablePersistent' + AWSuffix);
  asm
        MOV     ESP, EBP
        POP     EBP
        JMP     [_MsiDatabaseIsTablePersistent]
  end;
end;

var
  _MsiGetSummaryInformationA: Pointer;

function MsiGetSummaryInformationA;
begin
  GetProcedureAddress(_MsiGetSummaryInformationA, msilib, 'MsiGetSummaryInformationA');
  asm
        MOV     ESP, EBP
        POP     EBP
        JMP     [_MsiGetSummaryInformationA]
  end;
end;

var
  _MsiGetSummaryInformationW: Pointer;

function MsiGetSummaryInformationW;
begin
  GetProcedureAddress(_MsiGetSummaryInformationW, msilib, 'MsiGetSummaryInformationW');
  asm
        MOV     ESP, EBP
        POP     EBP
        JMP     [_MsiGetSummaryInformationW]
  end;
end;

var
  _MsiGetSummaryInformation: Pointer;

function MsiGetSummaryInformation;
begin
  GetProcedureAddress(_MsiGetSummaryInformation, msilib, 'MsiGetSummaryInformation' + AWSuffix);
  asm
        MOV     ESP, EBP
        POP     EBP
        JMP     [_MsiGetSummaryInformation]
  end;
end;

var
  _MsiSummaryInfoGetPropertyCount: Pointer;

function MsiSummaryInfoGetPropertyCount;
begin
  GetProcedureAddress(_MsiSummaryInfoGetPropertyCount, msilib, 'MsiSummaryInfoGetPropertyCount');
  asm
        MOV     ESP, EBP
        POP     EBP
        JMP     [_MsiSummaryInfoGetPropertyCount]
  end;
end;

var
  _MsiSummaryInfoSetPropertyA: Pointer;

function MsiSummaryInfoSetPropertyA;
begin
  GetProcedureAddress(_MsiSummaryInfoSetPropertyA, msilib, 'MsiSummaryInfoSetPropertyA');
  asm
        MOV     ESP, EBP
        POP     EBP
        JMP     [_MsiSummaryInfoSetPropertyA]
  end;
end;

var
  _MsiSummaryInfoSetPropertyW: Pointer;

function MsiSummaryInfoSetPropertyW;
begin
  GetProcedureAddress(_MsiSummaryInfoSetPropertyW, msilib, 'MsiSummaryInfoSetPropertyW');
  asm
        MOV     ESP, EBP
        POP     EBP
        JMP     [_MsiSummaryInfoSetPropertyW]
  end;
end;

var
  _MsiSummaryInfoSetProperty: Pointer;

function MsiSummaryInfoSetProperty;
begin
  GetProcedureAddress(_MsiSummaryInfoSetProperty, msilib, 'MsiSummaryInfoSetProperty' + AWSuffix);
  asm
        MOV     ESP, EBP
        POP     EBP
        JMP     [_MsiSummaryInfoSetProperty]
  end;
end;

var
  _MsiSummaryInfoGetPropertyA: Pointer;

function MsiSummaryInfoGetPropertyA;
begin
  GetProcedureAddress(_MsiSummaryInfoGetPropertyA, msilib, 'MsiSummaryInfoGetPropertyA');
  asm
        MOV     ESP, EBP
        POP     EBP
        JMP     [_MsiSummaryInfoGetPropertyA]
  end;
end;

var
  _MsiSummaryInfoGetPropertyW: Pointer;

function MsiSummaryInfoGetPropertyW;
begin
  GetProcedureAddress(_MsiSummaryInfoGetPropertyW, msilib, 'MsiSummaryInfoGetPropertyW');
  asm
        MOV     ESP, EBP
        POP     EBP
        JMP     [_MsiSummaryInfoGetPropertyW]
  end;
end;

var
  _MsiSummaryInfoGetProperty: Pointer;

function MsiSummaryInfoGetProperty;
begin
  GetProcedureAddress(_MsiSummaryInfoGetProperty, msilib, 'MsiSummaryInfoGetProperty' + AWSuffix);
  asm
        MOV     ESP, EBP
        POP     EBP
        JMP     [_MsiSummaryInfoGetProperty]
  end;
end;

var
  _MsiSummaryInfoPersist: Pointer;

function MsiSummaryInfoPersist;
begin
  GetProcedureAddress(_MsiSummaryInfoPersist, msilib, 'MsiSummaryInfoPersist');
  asm
        MOV     ESP, EBP
        POP     EBP
        JMP     [_MsiSummaryInfoPersist]
  end;
end;

var
  _MsiOpenDatabaseA: Pointer;

function MsiOpenDatabaseA;
begin
  GetProcedureAddress(_MsiOpenDatabaseA, msilib, 'MsiOpenDatabaseA');
  asm
        MOV     ESP, EBP
        POP     EBP
        JMP     [_MsiOpenDatabaseA]
  end;
end;

var
  _MsiOpenDatabaseW: Pointer;

function MsiOpenDatabaseW;
begin
  GetProcedureAddress(_MsiOpenDatabaseW, msilib, 'MsiOpenDatabaseW');
  asm
        MOV     ESP, EBP
        POP     EBP
        JMP     [_MsiOpenDatabaseW]
  end;
end;

var
  _MsiOpenDatabase: Pointer;

function MsiOpenDatabase;
begin
  GetProcedureAddress(_MsiOpenDatabase, msilib, 'MsiOpenDatabase' + AWSuffix);
  asm
        MOV     ESP, EBP
        POP     EBP
        JMP     [_MsiOpenDatabase]
  end;
end;

var
  _MsiDatabaseImportA: Pointer;

function MsiDatabaseImportA;
begin
  GetProcedureAddress(_MsiDatabaseImportA, msilib, 'MsiDatabaseImportA');
  asm
        MOV     ESP, EBP
        POP     EBP
        JMP     [_MsiDatabaseImportA]
  end;
end;

var
  _MsiDatabaseImportW: Pointer;

function MsiDatabaseImportW;
begin
  GetProcedureAddress(_MsiDatabaseImportW, msilib, 'MsiDatabaseImportW');
  asm
        MOV     ESP, EBP
        POP     EBP
        JMP     [_MsiDatabaseImportW]
  end;
end;

var
  _MsiDatabaseImport: Pointer;

function MsiDatabaseImport;
begin
  GetProcedureAddress(_MsiDatabaseImport, msilib, 'MsiDatabaseImport' + AWSuffix);
  asm
        MOV     ESP, EBP
        POP     EBP
        JMP     [_MsiDatabaseImport]
  end;
end;

var
  _MsiDatabaseExportA: Pointer;

function MsiDatabaseExportA;
begin
  GetProcedureAddress(_MsiDatabaseExportA, msilib, 'MsiDatabaseExportA');
  asm
        MOV     ESP, EBP
        POP     EBP
        JMP     [_MsiDatabaseExportA]
  end;
end;

var
  _MsiDatabaseExportW: Pointer;

function MsiDatabaseExportW;
begin
  GetProcedureAddress(_MsiDatabaseExportW, msilib, 'MsiDatabaseExportW');
  asm
        MOV     ESP, EBP
        POP     EBP
        JMP     [_MsiDatabaseExportW]
  end;
end;

var
  _MsiDatabaseExport: Pointer;

function MsiDatabaseExport;
begin
  GetProcedureAddress(_MsiDatabaseExport, msilib, 'MsiDatabaseExport' + AWSuffix);
  asm
        MOV     ESP, EBP
        POP     EBP
        JMP     [_MsiDatabaseExport]
  end;
end;

var
  _MsiDatabaseMergeA: Pointer;

function MsiDatabaseMergeA;
begin
  GetProcedureAddress(_MsiDatabaseMergeA, msilib, 'MsiDatabaseMergeA');
  asm
        MOV     ESP, EBP
        POP     EBP
        JMP     [_MsiDatabaseMergeA]
  end;
end;

var
  _MsiDatabaseMergeW: Pointer;

function MsiDatabaseMergeW;
begin
  GetProcedureAddress(_MsiDatabaseMergeW, msilib, 'MsiDatabaseMergeW');
  asm
        MOV     ESP, EBP
        POP     EBP
        JMP     [_MsiDatabaseMergeW]
  end;
end;

var
  _MsiDatabaseMerge: Pointer;

function MsiDatabaseMerge;
begin
  GetProcedureAddress(_MsiDatabaseMerge, msilib, 'MsiDatabaseMerge' + AWSuffix);
  asm
        MOV     ESP, EBP
        POP     EBP
        JMP     [_MsiDatabaseMerge]
  end;
end;

var
  _MsiDatabaseGenerateTransformA: Pointer;

function MsiDatabaseGenerateTransformA;
begin
  GetProcedureAddress(_MsiDatabaseGenerateTransformA, msilib, 'MsiDatabaseGenerateTransformA');
  asm
        MOV     ESP, EBP
        POP     EBP
        JMP     [_MsiDatabaseGenerateTransformA]
  end;
end;

var
  _MsiDatabaseGenerateTransformW: Pointer;

function MsiDatabaseGenerateTransformW;
begin
  GetProcedureAddress(_MsiDatabaseGenerateTransformW, msilib, 'MsiDatabaseGenerateTransformW');
  asm
        MOV     ESP, EBP
        POP     EBP
        JMP     [_MsiDatabaseGenerateTransformW]
  end;
end;

var
  _MsiDatabaseGenerateTransform: Pointer;

function MsiDatabaseGenerateTransform;
begin
  GetProcedureAddress(_MsiDatabaseGenerateTransform, msilib, 'MsiDatabaseGenerateTransform' + AWSuffix);
  asm
        MOV     ESP, EBP
        POP     EBP
        JMP     [_MsiDatabaseGenerateTransform]
  end;
end;

var
  _MsiDatabaseApplyTransformA: Pointer;

function MsiDatabaseApplyTransformA;
begin
  GetProcedureAddress(_MsiDatabaseApplyTransformA, msilib, 'MsiDatabaseApplyTransformA');
  asm
        MOV     ESP, EBP
        POP     EBP
        JMP     [_MsiDatabaseApplyTransformA]
  end;
end;

var
  _MsiDatabaseApplyTransformW: Pointer;

function MsiDatabaseApplyTransformW;
begin
  GetProcedureAddress(_MsiDatabaseApplyTransformW, msilib, 'MsiDatabaseApplyTransformW');
  asm
        MOV     ESP, EBP
        POP     EBP
        JMP     [_MsiDatabaseApplyTransformW]
  end;
end;

var
  _MsiDatabaseApplyTransform: Pointer;

function MsiDatabaseApplyTransform;
begin
  GetProcedureAddress(_MsiDatabaseApplyTransform, msilib, 'MsiDatabaseApplyTransform' + AWSuffix);
  asm
        MOV     ESP, EBP
        POP     EBP
        JMP     [_MsiDatabaseApplyTransform]
  end;
end;

var
  _MsiCreateTransformSummaryInfoA: Pointer;

function MsiCreateTransformSummaryInfoA;
begin
  GetProcedureAddress(_MsiCreateTransformSummaryInfoA, msilib, 'MsiCreateTransformSummaryInfoA');
  asm
        MOV     ESP, EBP
        POP     EBP
        JMP     [_MsiCreateTransformSummaryInfoA]
  end;
end;

var
  _MsiCreateTransformSummaryInfoW: Pointer;

function MsiCreateTransformSummaryInfoW;
begin
  GetProcedureAddress(_MsiCreateTransformSummaryInfoW, msilib, 'MsiCreateTransformSummaryInfoW');
  asm
        MOV     ESP, EBP
        POP     EBP
        JMP     [_MsiCreateTransformSummaryInfoW]
  end;
end;

var
  _MsiCreateTransformSummaryInfo: Pointer;

function MsiCreateTransformSummaryInfo;
begin
  GetProcedureAddress(_MsiCreateTransformSummaryInfo, msilib, 'MsiCreateTransformSummaryInfo' + AWSuffix);
  asm
        MOV     ESP, EBP
        POP     EBP
        JMP     [_MsiCreateTransformSummaryInfo]
  end;
end;

var
  _MsiDatabaseCommit: Pointer;

function MsiDatabaseCommit;
begin
  GetProcedureAddress(_MsiDatabaseCommit, msilib, 'MsiDatabaseCommit');
  asm
        MOV     ESP, EBP
        POP     EBP
        JMP     [_MsiDatabaseCommit]
  end;
end;

var
  _MsiGetDatabaseState: Pointer;

function MsiGetDatabaseState;
begin
  GetProcedureAddress(_MsiGetDatabaseState, msilib, 'MsiGetDatabaseState');
  asm
        MOV     ESP, EBP
        POP     EBP
        JMP     [_MsiGetDatabaseState]
  end;
end;

var
  _MsiCreateRecord: Pointer;

function MsiCreateRecord;
begin
  GetProcedureAddress(_MsiCreateRecord, msilib, 'MsiCreateRecord');
  asm
        MOV     ESP, EBP
        POP     EBP
        JMP     [_MsiCreateRecord]
  end;
end;

var
  _MsiRecordIsNull: Pointer;

function MsiRecordIsNull;
begin
  GetProcedureAddress(_MsiRecordIsNull, msilib, 'MsiRecordIsNull');
  asm
        MOV     ESP, EBP
        POP     EBP
        JMP     [_MsiRecordIsNull]
  end;
end;

var
  _MsiRecordDataSize: Pointer;

function MsiRecordDataSize;
begin
  GetProcedureAddress(_MsiRecordDataSize, msilib, 'MsiRecordDataSize');
  asm
        MOV     ESP, EBP
        POP     EBP
        JMP     [_MsiRecordDataSize]
  end;
end;

var
  _MsiRecordSetInteger: Pointer;

function MsiRecordSetInteger;
begin
  GetProcedureAddress(_MsiRecordSetInteger, msilib, 'MsiRecordSetInteger');
  asm
        MOV     ESP, EBP
        POP     EBP
        JMP     [_MsiRecordSetInteger]
  end;
end;

var
  _MsiRecordSetStringA: Pointer;

function MsiRecordSetStringA;
begin
  GetProcedureAddress(_MsiRecordSetStringA, msilib, 'MsiRecordSetStringA');
  asm
        MOV     ESP, EBP
        POP     EBP
        JMP     [_MsiRecordSetStringA]
  end;
end;

var
  _MsiRecordSetStringW: Pointer;

function MsiRecordSetStringW;
begin
  GetProcedureAddress(_MsiRecordSetStringW, msilib, 'MsiRecordSetStringW');
  asm
        MOV     ESP, EBP
        POP     EBP
        JMP     [_MsiRecordSetStringW]
  end;
end;

var
  _MsiRecordSetString: Pointer;

function MsiRecordSetString;
begin
  GetProcedureAddress(_MsiRecordSetString, msilib, 'MsiRecordSetString' + AWSuffix);
  asm
        MOV     ESP, EBP
        POP     EBP
        JMP     [_MsiRecordSetString]
  end;
end;

var
  _MsiRecordGetInteger: Pointer;

function MsiRecordGetInteger;
begin
  GetProcedureAddress(_MsiRecordGetInteger, msilib, 'MsiRecordGetInteger');
  asm
        MOV     ESP, EBP
        POP     EBP
        JMP     [_MsiRecordGetInteger]
  end;
end;

var
  _MsiRecordGetStringA: Pointer;

function MsiRecordGetStringA;
begin
  GetProcedureAddress(_MsiRecordGetStringA, msilib, 'MsiRecordGetStringA');
  asm
        MOV     ESP, EBP
        POP     EBP
        JMP     [_MsiRecordGetStringA]
  end;
end;

var
  _MsiRecordGetStringW: Pointer;

function MsiRecordGetStringW;
begin
  GetProcedureAddress(_MsiRecordGetStringW, msilib, 'MsiRecordGetStringW');
  asm
        MOV     ESP, EBP
        POP     EBP
        JMP     [_MsiRecordGetStringW]
  end;
end;

var
  _MsiRecordGetString: Pointer;

function MsiRecordGetString;
begin
  GetProcedureAddress(_MsiRecordGetString, msilib, 'MsiRecordGetString' + AWSuffix);
  asm
        MOV     ESP, EBP
        POP     EBP
        JMP     [_MsiRecordGetString]
  end;
end;

var
  _MsiRecordGetFieldCount: Pointer;

function MsiRecordGetFieldCount;
begin
  GetProcedureAddress(_MsiRecordGetFieldCount, msilib, 'MsiRecordGetFieldCount');
  asm
        MOV     ESP, EBP
        POP     EBP
        JMP     [_MsiRecordGetFieldCount]
  end;
end;

var
  _MsiRecordSetStreamA: Pointer;

function MsiRecordSetStreamA;
begin
  GetProcedureAddress(_MsiRecordSetStreamA, msilib, 'MsiRecordSetStreamA');
  asm
        MOV     ESP, EBP
        POP     EBP
        JMP     [_MsiRecordSetStreamA]
  end;
end;

var
  _MsiRecordSetStreamW: Pointer;

function MsiRecordSetStreamW;
begin
  GetProcedureAddress(_MsiRecordSetStreamW, msilib, 'MsiRecordSetStreamW');
  asm
        MOV     ESP, EBP
        POP     EBP
        JMP     [_MsiRecordSetStreamW]
  end;
end;

var
  _MsiRecordSetStream: Pointer;

function MsiRecordSetStream;
begin
  GetProcedureAddress(_MsiRecordSetStream, msilib, 'MsiRecordSetStream' + AWSuffix);
  asm
        MOV     ESP, EBP
        POP     EBP
        JMP     [_MsiRecordSetStream]
  end;
end;

var
  _MsiRecordReadStream: Pointer;

function MsiRecordReadStream;
begin
  GetProcedureAddress(_MsiRecordReadStream, msilib, 'MsiRecordReadStream');
  asm
        MOV     ESP, EBP
        POP     EBP
        JMP     [_MsiRecordReadStream]
  end;
end;

var
  _MsiRecordClearData: Pointer;

function MsiRecordClearData;
begin
  GetProcedureAddress(_MsiRecordClearData, msilib, 'MsiRecordClearData');
  asm
        MOV     ESP, EBP
        POP     EBP
        JMP     [_MsiRecordClearData]
  end;
end;

var
  _MsiGetActiveDatabase: Pointer;

function MsiGetActiveDatabase;
begin
  GetProcedureAddress(_MsiGetActiveDatabase, msilib, 'MsiGetActiveDatabase');
  asm
        MOV     ESP, EBP
        POP     EBP
        JMP     [_MsiGetActiveDatabase]
  end;
end;

var
  _MsiSetPropertyA: Pointer;

function MsiSetPropertyA;
begin
  GetProcedureAddress(_MsiSetPropertyA, msilib, 'MsiSetPropertyA');
  asm
        MOV     ESP, EBP
        POP     EBP
        JMP     [_MsiSetPropertyA]
  end;
end;

var
  _MsiSetPropertyW: Pointer;

function MsiSetPropertyW;
begin
  GetProcedureAddress(_MsiSetPropertyW, msilib, 'MsiSetPropertyW');
  asm
        MOV     ESP, EBP
        POP     EBP
        JMP     [_MsiSetPropertyW]
  end;
end;

var
  _MsiSetProperty: Pointer;

function MsiSetProperty;
begin
  GetProcedureAddress(_MsiSetProperty, msilib, 'MsiSetProperty' + AWSuffix);
  asm
        MOV     ESP, EBP
        POP     EBP
        JMP     [_MsiSetProperty]
  end;
end;

var
  _MsiGetPropertyA: Pointer;

function MsiGetPropertyA;
begin
  GetProcedureAddress(_MsiGetPropertyA, msilib, 'MsiGetPropertyA');
  asm
        MOV     ESP, EBP
        POP     EBP
        JMP     [_MsiGetPropertyA]
  end;
end;

var
  _MsiGetPropertyW: Pointer;

function MsiGetPropertyW;
begin
  GetProcedureAddress(_MsiGetPropertyW, msilib, 'MsiGetPropertyW');
  asm
        MOV     ESP, EBP
        POP     EBP
        JMP     [_MsiGetPropertyW]
  end;
end;

var
  _MsiGetProperty: Pointer;

function MsiGetProperty;
begin
  GetProcedureAddress(_MsiGetProperty, msilib, 'MsiGetProperty' + AWSuffix);
  asm
        MOV     ESP, EBP
        POP     EBP
        JMP     [_MsiGetProperty]
  end;
end;

var
  _MsiGetLanguage: Pointer;

function MsiGetLanguage;
begin
  GetProcedureAddress(_MsiGetLanguage, msilib, 'MsiGetLanguage');
  asm
        MOV     ESP, EBP
        POP     EBP
        JMP     [_MsiGetLanguage]
  end;
end;

var
  _MsiGetMode: Pointer;

function MsiGetMode;
begin
  GetProcedureAddress(_MsiGetMode, msilib, 'MsiGetMode');
  asm
        MOV     ESP, EBP
        POP     EBP
        JMP     [_MsiGetMode]
  end;
end;

var
  _MsiSetMode: Pointer;

function MsiSetMode;
begin
  GetProcedureAddress(_MsiSetMode, msilib, 'MsiSetMode');
  asm
        MOV     ESP, EBP
        POP     EBP
        JMP     [_MsiSetMode]
  end;
end;

var
  _MsiFormatRecordA: Pointer;

function MsiFormatRecordA;
begin
  GetProcedureAddress(_MsiFormatRecordA, msilib, 'MsiFormatRecordA');
  asm
        MOV     ESP, EBP
        POP     EBP
        JMP     [_MsiFormatRecordA]
  end;
end;

var
  _MsiFormatRecordW: Pointer;

function MsiFormatRecordW;
begin
  GetProcedureAddress(_MsiFormatRecordW, msilib, 'MsiFormatRecordW');
  asm
        MOV     ESP, EBP
        POP     EBP
        JMP     [_MsiFormatRecordW]
  end;
end;

var
  _MsiFormatRecord: Pointer;

function MsiFormatRecord;
begin
  GetProcedureAddress(_MsiFormatRecord, msilib, 'MsiFormatRecord' + AWSuffix);
  asm
        MOV     ESP, EBP
        POP     EBP
        JMP     [_MsiFormatRecord]
  end;
end;

var
  _MsiDoActionA: Pointer;

function MsiDoActionA;
begin
  GetProcedureAddress(_MsiDoActionA, msilib, 'MsiDoActionA');
  asm
        MOV     ESP, EBP
        POP     EBP
        JMP     [_MsiDoActionA]
  end;
end;

var
  _MsiDoActionW: Pointer;

function MsiDoActionW;
begin
  GetProcedureAddress(_MsiDoActionW, msilib, 'MsiDoActionW');
  asm
        MOV     ESP, EBP
        POP     EBP
        JMP     [_MsiDoActionW]
  end;
end;

var
  _MsiDoAction: Pointer;

function MsiDoAction;
begin
  GetProcedureAddress(_MsiDoAction, msilib, 'MsiDoAction' + AWSuffix);
  asm
        MOV     ESP, EBP
        POP     EBP
        JMP     [_MsiDoAction]
  end;
end;

var
  _MsiSequenceA: Pointer;

function MsiSequenceA;
begin
  GetProcedureAddress(_MsiSequenceA, msilib, 'MsiSequenceA');
  asm
        MOV     ESP, EBP
        POP     EBP
        JMP     [_MsiSequenceA]
  end;
end;

var
  _MsiSequenceW: Pointer;

function MsiSequenceW;
begin
  GetProcedureAddress(_MsiSequenceW, msilib, 'MsiSequenceW');
  asm
        MOV     ESP, EBP
        POP     EBP
        JMP     [_MsiSequenceW]
  end;
end;

var
  _MsiSequence: Pointer;

function MsiSequence;
begin
  GetProcedureAddress(_MsiSequence, msilib, 'MsiSequence' + AWSuffix);
  asm
        MOV     ESP, EBP
        POP     EBP
        JMP     [_MsiSequence]
  end;
end;

var
  _MsiProcessMessage: Pointer;

function MsiProcessMessage;
begin
  GetProcedureAddress(_MsiProcessMessage, msilib, 'MsiProcessMessage');
  asm
        MOV     ESP, EBP
        POP     EBP
        JMP     [_MsiProcessMessage]
  end;
end;

var
  _MsiEvaluateConditionA: Pointer;

function MsiEvaluateConditionA;
begin
  GetProcedureAddress(_MsiEvaluateConditionA, msilib, 'MsiEvaluateConditionA');
  asm
        MOV     ESP, EBP
        POP     EBP
        JMP     [_MsiEvaluateConditionA]
  end;
end;

var
  _MsiEvaluateConditionW: Pointer;

function MsiEvaluateConditionW;
begin
  GetProcedureAddress(_MsiEvaluateConditionW, msilib, 'MsiEvaluateConditionW');
  asm
        MOV     ESP, EBP
        POP     EBP
        JMP     [_MsiEvaluateConditionW]
  end;
end;

var
  _MsiEvaluateCondition: Pointer;

function MsiEvaluateCondition;
begin
  GetProcedureAddress(_MsiEvaluateCondition, msilib, 'MsiEvaluateCondition' + AWSuffix);
  asm
        MOV     ESP, EBP
        POP     EBP
        JMP     [_MsiEvaluateCondition]
  end;
end;

var
  _MsiGetFeatureStateA: Pointer;

function MsiGetFeatureStateA;
begin
  GetProcedureAddress(_MsiGetFeatureStateA, msilib, 'MsiGetFeatureStateA');
  asm
        MOV     ESP, EBP
        POP     EBP
        JMP     [_MsiGetFeatureStateA]
  end;
end;

var
  _MsiGetFeatureStateW: Pointer;

function MsiGetFeatureStateW;
begin
  GetProcedureAddress(_MsiGetFeatureStateW, msilib, 'MsiGetFeatureStateW');
  asm
        MOV     ESP, EBP
        POP     EBP
        JMP     [_MsiGetFeatureStateW]
  end;
end;

var
  _MsiGetFeatureState: Pointer;

function MsiGetFeatureState;
begin
  GetProcedureAddress(_MsiGetFeatureState, msilib, 'MsiGetFeatureState' + AWSuffix);
  asm
        MOV     ESP, EBP
        POP     EBP
        JMP     [_MsiGetFeatureState]
  end;
end;

var
  _MsiSetFeatureStateA: Pointer;

function MsiSetFeatureStateA;
begin
  GetProcedureAddress(_MsiSetFeatureStateA, msilib, 'MsiSetFeatureStateA');
  asm
        MOV     ESP, EBP
        POP     EBP
        JMP     [_MsiSetFeatureStateA]
  end;
end;

var
  _MsiSetFeatureStateW: Pointer;

function MsiSetFeatureStateW;
begin
  GetProcedureAddress(_MsiSetFeatureStateW, msilib, 'MsiSetFeatureStateW');
  asm
        MOV     ESP, EBP
        POP     EBP
        JMP     [_MsiSetFeatureStateW]
  end;
end;

var
  _MsiSetFeatureState: Pointer;

function MsiSetFeatureState;
begin
  GetProcedureAddress(_MsiSetFeatureState, msilib, 'MsiSetFeatureState' + AWSuffix);
  asm
        MOV     ESP, EBP
        POP     EBP
        JMP     [_MsiSetFeatureState]
  end;
end;

var
  _MsiSetFeatureAttributesA: Pointer;

function MsiSetFeatureAttributesA;
begin
  GetProcedureAddress(_MsiSetFeatureAttributesA, msilib, 'MsiSetFeatureAttributesA');
  asm
        MOV     ESP, EBP
        POP     EBP
        JMP     [_MsiSetFeatureAttributesA]
  end;
end;

var
  _MsiSetFeatureAttributesW: Pointer;

function MsiSetFeatureAttributesW;
begin
  GetProcedureAddress(_MsiSetFeatureAttributesW, msilib, 'MsiSetFeatureAttributesW');
  asm
        MOV     ESP, EBP
        POP     EBP
        JMP     [_MsiSetFeatureAttributesW]
  end;
end;

var
  _MsiSetFeatureAttributes: Pointer;

function MsiSetFeatureAttributes;
begin
  GetProcedureAddress(_MsiSetFeatureAttributes, msilib, 'MsiSetFeatureAttributes' + AWSuffix);
  asm
        MOV     ESP, EBP
        POP     EBP
        JMP     [_MsiSetFeatureAttributes]
  end;
end;

var
  _MsiGetComponentStateA: Pointer;

function MsiGetComponentStateA;
begin
  GetProcedureAddress(_MsiGetComponentStateA, msilib, 'MsiGetComponentStateA');
  asm
        MOV     ESP, EBP
        POP     EBP
        JMP     [_MsiGetComponentStateA]
  end;
end;

var
  _MsiGetComponentStateW: Pointer;

function MsiGetComponentStateW;
begin
  GetProcedureAddress(_MsiGetComponentStateW, msilib, 'MsiGetComponentStateW');
  asm
        MOV     ESP, EBP
        POP     EBP
        JMP     [_MsiGetComponentStateW]
  end;
end;

var
  _MsiGetComponentState: Pointer;

function MsiGetComponentState;
begin
  GetProcedureAddress(_MsiGetComponentState, msilib, 'MsiGetComponentState' + AWSuffix);
  asm
        MOV     ESP, EBP
        POP     EBP
        JMP     [_MsiGetComponentState]
  end;
end;

var
  _MsiSetComponentStateA: Pointer;

function MsiSetComponentStateA;
begin
  GetProcedureAddress(_MsiSetComponentStateA, msilib, 'MsiSetComponentStateA');
  asm
        MOV     ESP, EBP
        POP     EBP
        JMP     [_MsiSetComponentStateA]
  end;
end;

var
  _MsiSetComponentStateW: Pointer;

function MsiSetComponentStateW;
begin
  GetProcedureAddress(_MsiSetComponentStateW, msilib, 'MsiSetComponentStateW');
  asm
        MOV     ESP, EBP
        POP     EBP
        JMP     [_MsiSetComponentStateW]
  end;
end;

var
  _MsiSetComponentState: Pointer;

function MsiSetComponentState;
begin
  GetProcedureAddress(_MsiSetComponentState, msilib, 'MsiSetComponentState' + AWSuffix);
  asm
        MOV     ESP, EBP
        POP     EBP
        JMP     [_MsiSetComponentState]
  end;
end;

var
  _MsiGetFeatureCostA: Pointer;

function MsiGetFeatureCostA;
begin
  GetProcedureAddress(_MsiGetFeatureCostA, msilib, 'MsiGetFeatureCostA');
  asm
        MOV     ESP, EBP
        POP     EBP
        JMP     [_MsiGetFeatureCostA]
  end;
end;

var
  _MsiGetFeatureCostW: Pointer;

function MsiGetFeatureCostW;
begin
  GetProcedureAddress(_MsiGetFeatureCostW, msilib, 'MsiGetFeatureCostW');
  asm
        MOV     ESP, EBP
        POP     EBP
        JMP     [_MsiGetFeatureCostW]
  end;
end;

var
  _MsiGetFeatureCost: Pointer;

function MsiGetFeatureCost;
begin
  GetProcedureAddress(_MsiGetFeatureCost, msilib, 'MsiGetFeatureCost' + AWSuffix);
  asm
        MOV     ESP, EBP
        POP     EBP
        JMP     [_MsiGetFeatureCost]
  end;
end;

var
  _MsiEnumComponentCostsA: Pointer;

function MsiEnumComponentCostsA;
begin
  GetProcedureAddress(_MsiEnumComponentCostsA, msilib, 'MsiEnumComponentCostsA');
  asm
        MOV     ESP, EBP
        POP     EBP
        JMP     [_MsiEnumComponentCostsA]
  end;
end;

var
  _MsiEnumComponentCostsW: Pointer;

function MsiEnumComponentCostsW;
begin
  GetProcedureAddress(_MsiEnumComponentCostsW, msilib, 'MsiEnumComponentCostsW');
  asm
        MOV     ESP, EBP
        POP     EBP
        JMP     [_MsiEnumComponentCostsW]
  end;
end;

var
  _MsiEnumComponentCosts: Pointer;

function MsiEnumComponentCosts;
begin
  GetProcedureAddress(_MsiEnumComponentCosts, msilib, 'MsiEnumComponentCosts' + AWSuffix);
  asm
        MOV     ESP, EBP
        POP     EBP
        JMP     [_MsiEnumComponentCosts]
  end;
end;

var
  _MsiSetInstallLevel: Pointer;

function MsiSetInstallLevel;
begin
  GetProcedureAddress(_MsiSetInstallLevel, msilib, 'MsiSetInstallLevel');
  asm
        MOV     ESP, EBP
        POP     EBP
        JMP     [_MsiSetInstallLevel]
  end;
end;

var
  _MsiGetFeatureValidStatesA: Pointer;

function MsiGetFeatureValidStatesA;
begin
  GetProcedureAddress(_MsiGetFeatureValidStatesA, msilib, 'MsiGetFeatureValidStatesA');
  asm
        MOV     ESP, EBP
        POP     EBP
        JMP     [_MsiGetFeatureValidStatesA]
  end;
end;

var
  _MsiGetFeatureValidStatesW: Pointer;

function MsiGetFeatureValidStatesW;
begin
  GetProcedureAddress(_MsiGetFeatureValidStatesW, msilib, 'MsiGetFeatureValidStatesW');
  asm
        MOV     ESP, EBP
        POP     EBP
        JMP     [_MsiGetFeatureValidStatesW]
  end;
end;

var
  _MsiGetFeatureValidStates: Pointer;

function MsiGetFeatureValidStates;
begin
  GetProcedureAddress(_MsiGetFeatureValidStates, msilib, 'MsiGetFeatureValidStates' + AWSuffix);
  asm
        MOV     ESP, EBP
        POP     EBP
        JMP     [_MsiGetFeatureValidStates]
  end;
end;

var
  _MsiGetSourcePathA: Pointer;

function MsiGetSourcePathA;
begin
  GetProcedureAddress(_MsiGetSourcePathA, msilib, 'MsiGetSourcePathA');
  asm
        MOV     ESP, EBP
        POP     EBP
        JMP     [_MsiGetSourcePathA]
  end;
end;

var
  _MsiGetSourcePathW: Pointer;

function MsiGetSourcePathW;
begin
  GetProcedureAddress(_MsiGetSourcePathW, msilib, 'MsiGetSourcePathW');
  asm
        MOV     ESP, EBP
        POP     EBP
        JMP     [_MsiGetSourcePathW]
  end;
end;

var
  _MsiGetSourcePath: Pointer;

function MsiGetSourcePath;
begin
  GetProcedureAddress(_MsiGetSourcePath, msilib, 'MsiGetSourcePath' + AWSuffix);
  asm
        MOV     ESP, EBP
        POP     EBP
        JMP     [_MsiGetSourcePath]
  end;
end;

var
  _MsiGetTargetPathA: Pointer;

function MsiGetTargetPathA;
begin
  GetProcedureAddress(_MsiGetTargetPathA, msilib, 'MsiGetTargetPathA');
  asm
        MOV     ESP, EBP
        POP     EBP
        JMP     [_MsiGetTargetPathA]
  end;
end;

var
  _MsiGetTargetPathW: Pointer;

function MsiGetTargetPathW;
begin
  GetProcedureAddress(_MsiGetTargetPathW, msilib, 'MsiGetTargetPathW');
  asm
        MOV     ESP, EBP
        POP     EBP
        JMP     [_MsiGetTargetPathW]
  end;
end;

var
  _MsiGetTargetPath: Pointer;

function MsiGetTargetPath;
begin
  GetProcedureAddress(_MsiGetTargetPath, msilib, 'MsiGetTargetPath' + AWSuffix);
  asm
        MOV     ESP, EBP
        POP     EBP
        JMP     [_MsiGetTargetPath]
  end;
end;

var
  _MsiSetTargetPathA: Pointer;

function MsiSetTargetPathA;
begin
  GetProcedureAddress(_MsiSetTargetPathA, msilib, 'MsiSetTargetPathA');
  asm
        MOV     ESP, EBP
        POP     EBP
        JMP     [_MsiSetTargetPathA]
  end;
end;

var
  _MsiSetTargetPathW: Pointer;

function MsiSetTargetPathW;
begin
  GetProcedureAddress(_MsiSetTargetPathW, msilib, 'MsiSetTargetPathW');
  asm
        MOV     ESP, EBP
        POP     EBP
        JMP     [_MsiSetTargetPathW]
  end;
end;

var
  _MsiSetTargetPath: Pointer;

function MsiSetTargetPath;
begin
  GetProcedureAddress(_MsiSetTargetPath, msilib, 'MsiSetTargetPath' + AWSuffix);
  asm
        MOV     ESP, EBP
        POP     EBP
        JMP     [_MsiSetTargetPath]
  end;
end;

var
  _MsiVerifyDiskSpace: Pointer;

function MsiVerifyDiskSpace;
begin
  GetProcedureAddress(_MsiVerifyDiskSpace, msilib, 'MsiVerifyDiskSpace');
  asm
        MOV     ESP, EBP
        POP     EBP
        JMP     [_MsiVerifyDiskSpace]
  end;
end;

var
  _MsiEnableUIPreview: Pointer;

function MsiEnableUIPreview;
begin
  GetProcedureAddress(_MsiEnableUIPreview, msilib, 'MsiEnableUIPreview');
  asm
        MOV     ESP, EBP
        POP     EBP
        JMP     [_MsiEnableUIPreview]
  end;
end;

var
  _MsiPreviewDialogA: Pointer;

function MsiPreviewDialogA;
begin
  GetProcedureAddress(_MsiPreviewDialogA, msilib, 'MsiPreviewDialogA');
  asm
        MOV     ESP, EBP
        POP     EBP
        JMP     [_MsiPreviewDialogA]
  end;
end;

var
  _MsiPreviewDialogW: Pointer;

function MsiPreviewDialogW;
begin
  GetProcedureAddress(_MsiPreviewDialogW, msilib, 'MsiPreviewDialogW');
  asm
        MOV     ESP, EBP
        POP     EBP
        JMP     [_MsiPreviewDialogW]
  end;
end;

var
  _MsiPreviewDialog: Pointer;

function MsiPreviewDialog;
begin
  GetProcedureAddress(_MsiPreviewDialog, msilib, 'MsiPreviewDialog' + AWSuffix);
  asm
        MOV     ESP, EBP
        POP     EBP
        JMP     [_MsiPreviewDialog]
  end;
end;

var
  _MsiPreviewBillboardA: Pointer;

function MsiPreviewBillboardA;
begin
  GetProcedureAddress(_MsiPreviewBillboardA, msilib, 'MsiPreviewBillboardA');
  asm
        MOV     ESP, EBP
        POP     EBP
        JMP     [_MsiPreviewBillboardA]
  end;
end;

var
  _MsiPreviewBillboardW: Pointer;

function MsiPreviewBillboardW;
begin
  GetProcedureAddress(_MsiPreviewBillboardW, msilib, 'MsiPreviewBillboardW');
  asm
        MOV     ESP, EBP
        POP     EBP
        JMP     [_MsiPreviewBillboardW]
  end;
end;

var
  _MsiPreviewBillboard: Pointer;

function MsiPreviewBillboard;
begin
  GetProcedureAddress(_MsiPreviewBillboard, msilib, 'MsiPreviewBillboard' + AWSuffix);
  asm
        MOV     ESP, EBP
        POP     EBP
        JMP     [_MsiPreviewBillboard]
  end;
end;

var
  _MsiGetLastErrorRecord: Pointer;

function MsiGetLastErrorRecord;
begin
  GetProcedureAddress(_MsiGetLastErrorRecord, msilib, 'MsiGetLastErrorRecord');
  asm
        MOV     ESP, EBP
        POP     EBP
        JMP     [_MsiGetLastErrorRecord]
  end;
end;

{$ELSE}

function MsiDatabaseOpenViewA; external msilib name 'MsiDatabaseOpenViewA';
function MsiDatabaseOpenViewW; external msilib name 'MsiDatabaseOpenViewW';
function MsiDatabaseOpenView; external msilib name 'MsiDatabaseOpenView' + AWSuffix;
function MsiViewGetErrorA; external msilib name 'MsiViewGetErrorA';
function MsiViewGetErrorW; external msilib name 'MsiViewGetErrorW';
function MsiViewGetError; external msilib name 'MsiViewGetError' + AWSuffix;
function MsiViewExecute; external msilib name 'MsiViewExecute';
function MsiViewFetch; external msilib name 'MsiViewFetch';
function MsiViewModify; external msilib name 'MsiViewModify';
function MsiViewGetColumnInfo; external msilib name 'MsiViewGetColumnInfo';
function MsiViewClose; external msilib name 'MsiViewClose';
function MsiDatabaseGetPrimaryKeysA; external msilib name 'MsiDatabaseGetPrimaryKeysA';
function MsiDatabaseGetPrimaryKeysW; external msilib name 'MsiDatabaseGetPrimaryKeysW';
function MsiDatabaseGetPrimaryKeys; external msilib name 'MsiDatabaseGetPrimaryKeys' + AWSuffix;
function MsiDatabaseIsTablePersistentA; external msilib name 'MsiDatabaseIsTablePersistentA';
function MsiDatabaseIsTablePersistentW; external msilib name 'MsiDatabaseIsTablePersistentW';
function MsiDatabaseIsTablePersistent; external msilib name 'MsiDatabaseIsTablePersistent' + AWSuffix;
function MsiGetSummaryInformationA; external msilib name 'MsiGetSummaryInformationA';
function MsiGetSummaryInformationW; external msilib name 'MsiGetSummaryInformationW';
function MsiGetSummaryInformation; external msilib name 'MsiGetSummaryInformation' + AWSuffix;
function MsiSummaryInfoGetPropertyCount; external msilib name 'MsiSummaryInfoGetPropertyCount';
function MsiSummaryInfoSetPropertyA; external msilib name 'MsiSummaryInfoSetPropertyA';
function MsiSummaryInfoSetPropertyW; external msilib name 'MsiSummaryInfoSetPropertyW';
function MsiSummaryInfoSetProperty; external msilib name 'MsiSummaryInfoSetProperty' + AWSuffix;
function MsiSummaryInfoGetPropertyA; external msilib name 'MsiSummaryInfoGetPropertyA';
function MsiSummaryInfoGetPropertyW; external msilib name 'MsiSummaryInfoGetPropertyW';
function MsiSummaryInfoGetProperty; external msilib name 'MsiSummaryInfoGetProperty' + AWSuffix;
function MsiSummaryInfoPersist; external msilib name 'MsiSummaryInfoPersist';
function MsiOpenDatabaseA; external msilib name 'MsiOpenDatabaseA';
function MsiOpenDatabaseW; external msilib name 'MsiOpenDatabaseW';
function MsiOpenDatabase; external msilib name 'MsiOpenDatabase' + AWSuffix;
function MsiDatabaseImportA; external msilib name 'MsiDatabaseImportA';
function MsiDatabaseImportW; external msilib name 'MsiDatabaseImportW';
function MsiDatabaseImport; external msilib name 'MsiDatabaseImport' + AWSuffix;
function MsiDatabaseExportA; external msilib name 'MsiDatabaseExportA';
function MsiDatabaseExportW; external msilib name 'MsiDatabaseExportW';
function MsiDatabaseExport; external msilib name 'MsiDatabaseExport' + AWSuffix;
function MsiDatabaseMergeA; external msilib name 'MsiDatabaseMergeA';
function MsiDatabaseMergeW; external msilib name 'MsiDatabaseMergeW';
function MsiDatabaseMerge; external msilib name 'MsiDatabaseMerge' + AWSuffix;
function MsiDatabaseGenerateTransformA; external msilib name 'MsiDatabaseGenerateTransformA';
function MsiDatabaseGenerateTransformW; external msilib name 'MsiDatabaseGenerateTransformW';
function MsiDatabaseGenerateTransform; external msilib name 'MsiDatabaseGenerateTransform' + AWSuffix;
function MsiDatabaseApplyTransformA; external msilib name 'MsiDatabaseApplyTransformA';
function MsiDatabaseApplyTransformW; external msilib name 'MsiDatabaseApplyTransformW';
function MsiDatabaseApplyTransform; external msilib name 'MsiDatabaseApplyTransform' + AWSuffix;
function MsiCreateTransformSummaryInfoA; external msilib name 'MsiCreateTransformSummaryInfoA';
function MsiCreateTransformSummaryInfoW; external msilib name 'MsiCreateTransformSummaryInfoW';
function MsiCreateTransformSummaryInfo; external msilib name 'MsiCreateTransformSummaryInfo' + AWSuffix;
function MsiDatabaseCommit; external msilib name 'MsiDatabaseCommit';
function MsiGetDatabaseState; external msilib name 'MsiGetDatabaseState';
function MsiCreateRecord; external msilib name 'MsiCreateRecord';
function MsiRecordIsNull; external msilib name 'MsiRecordIsNull';
function MsiRecordDataSize; external msilib name 'MsiRecordDataSize';
function MsiRecordSetInteger; external msilib name 'MsiRecordSetInteger';
function MsiRecordSetStringA; external msilib name 'MsiRecordSetStringA';
function MsiRecordSetStringW; external msilib name 'MsiRecordSetStringW';
function MsiRecordSetString; external msilib name 'MsiRecordSetString' + AWSuffix;
function MsiRecordGetInteger; external msilib name 'MsiRecordGetInteger';
function MsiRecordGetStringA; external msilib name 'MsiRecordGetStringA';
function MsiRecordGetStringW; external msilib name 'MsiRecordGetStringW';
function MsiRecordGetString; external msilib name 'MsiRecordGetString' + AWSuffix;
function MsiRecordGetFieldCount; external msilib name 'MsiRecordGetFieldCount';
function MsiRecordSetStreamA; external msilib name 'MsiRecordSetStreamA';
function MsiRecordSetStreamW; external msilib name 'MsiRecordSetStreamW';
function MsiRecordSetStream; external msilib name 'MsiRecordSetStream' + AWSuffix;
function MsiRecordReadStream; external msilib name 'MsiRecordReadStream';
function MsiRecordClearData; external msilib name 'MsiRecordClearData';
function MsiGetActiveDatabase; external msilib name 'MsiGetActiveDatabase';
function MsiSetPropertyA; external msilib name 'MsiSetPropertyA';
function MsiSetPropertyW; external msilib name 'MsiSetPropertyW';
function MsiSetProperty; external msilib name 'MsiSetProperty' + AWSuffix;
function MsiGetPropertyA; external msilib name 'MsiGetPropertyA';
function MsiGetPropertyW; external msilib name 'MsiGetPropertyW';
function MsiGetProperty; external msilib name 'MsiGetProperty' + AWSuffix;
function MsiGetLanguage; external msilib name 'MsiGetLanguage';
function MsiGetMode; external msilib name 'MsiGetMode';
function MsiSetMode; external msilib name 'MsiSetMode';
function MsiFormatRecordA; external msilib name 'MsiFormatRecordA';
function MsiFormatRecordW; external msilib name 'MsiFormatRecordW';
function MsiFormatRecord; external msilib name 'MsiFormatRecord' + AWSuffix;
function MsiDoActionA; external msilib name 'MsiDoActionA';
function MsiDoActionW; external msilib name 'MsiDoActionW';
function MsiDoAction; external msilib name 'MsiDoAction' + AWSuffix;
function MsiSequenceA; external msilib name 'MsiSequenceA';
function MsiSequenceW; external msilib name 'MsiSequenceW';
function MsiSequence; external msilib name 'MsiSequence' + AWSuffix;
function MsiProcessMessage; external msilib name 'MsiProcessMessage';
function MsiEvaluateConditionA; external msilib name 'MsiEvaluateConditionA';
function MsiEvaluateConditionW; external msilib name 'MsiEvaluateConditionW';
function MsiEvaluateCondition; external msilib name 'MsiEvaluateCondition' + AWSuffix;
function MsiGetFeatureStateA; external msilib name 'MsiGetFeatureStateA';
function MsiGetFeatureStateW; external msilib name 'MsiGetFeatureStateW';
function MsiGetFeatureState; external msilib name 'MsiGetFeatureState' + AWSuffix;
function MsiSetFeatureStateA; external msilib name 'MsiSetFeatureStateA';
function MsiSetFeatureStateW; external msilib name 'MsiSetFeatureStateW';
function MsiSetFeatureState; external msilib name 'MsiSetFeatureState' + AWSuffix;
function MsiSetFeatureAttributesA; external msilib name 'MsiSetFeatureAttributesA';
function MsiSetFeatureAttributesW; external msilib name 'MsiSetFeatureAttributesW';
function MsiSetFeatureAttributes; external msilib name 'MsiSetFeatureAttributes' + AWSuffix;
function MsiGetComponentStateA; external msilib name 'MsiGetComponentStateA';
function MsiGetComponentStateW; external msilib name 'MsiGetComponentStateW';
function MsiGetComponentState; external msilib name 'MsiGetComponentState' + AWSuffix;
function MsiSetComponentStateA; external msilib name 'MsiSetComponentStateA';
function MsiSetComponentStateW; external msilib name 'MsiSetComponentStateW';
function MsiSetComponentState; external msilib name 'MsiSetComponentState' + AWSuffix;
function MsiGetFeatureCostA; external msilib name 'MsiGetFeatureCostA';
function MsiGetFeatureCostW; external msilib name 'MsiGetFeatureCostW';
function MsiGetFeatureCost; external msilib name 'MsiGetFeatureCost' + AWSuffix;
function MsiEnumComponentCostsA; external msilib name 'MsiEnumComponentCostsA';
function MsiEnumComponentCostsW; external msilib name 'MsiEnumComponentCostsW';
function MsiEnumComponentCosts; external msilib name 'MsiEnumComponentCosts' + AWSuffix;
function MsiSetInstallLevel; external msilib name 'MsiSetInstallLevel';
function MsiGetFeatureValidStatesA; external msilib name 'MsiGetFeatureValidStatesA';
function MsiGetFeatureValidStatesW; external msilib name 'MsiGetFeatureValidStatesW';
function MsiGetFeatureValidStates; external msilib name 'MsiGetFeatureValidStates' + AWSuffix;
function MsiGetSourcePathA; external msilib name 'MsiGetSourcePathA';
function MsiGetSourcePathW; external msilib name 'MsiGetSourcePathW';
function MsiGetSourcePath; external msilib name 'MsiGetSourcePath' + AWSuffix;
function MsiGetTargetPathA; external msilib name 'MsiGetTargetPathA';
function MsiGetTargetPathW; external msilib name 'MsiGetTargetPathW';
function MsiGetTargetPath; external msilib name 'MsiGetTargetPath' + AWSuffix;
function MsiSetTargetPathA; external msilib name 'MsiSetTargetPathA';
function MsiSetTargetPathW; external msilib name 'MsiSetTargetPathW';
function MsiSetTargetPath; external msilib name 'MsiSetTargetPath' + AWSuffix;
function MsiVerifyDiskSpace; external msilib name 'MsiVerifyDiskSpace';
function MsiEnableUIPreview; external msilib name 'MsiEnableUIPreview';
function MsiPreviewDialogA; external msilib name 'MsiPreviewDialogA';
function MsiPreviewDialogW; external msilib name 'MsiPreviewDialogW';
function MsiPreviewDialog; external msilib name 'MsiPreviewDialog' + AWSuffix;
function MsiPreviewBillboardA; external msilib name 'MsiPreviewBillboardA';
function MsiPreviewBillboardW; external msilib name 'MsiPreviewBillboardW';
function MsiPreviewBillboard; external msilib name 'MsiPreviewBillboard' + AWSuffix;
function MsiGetLastErrorRecord; external msilib name 'MsiGetLastErrorRecord';

{$ENDIF DYNAMIC_LINK}

{$ENDIF JWA_INTERFACESECTION}


{$IFNDEF JWA_OMIT_SECTIONS}
end.
{$ENDIF JWA_OMIT_SECTIONS}