unit Chilkat.Zip;

{
  Pascal wrapper for Chilkat Zip.
  Auto-generated by PascalWrapperGenerator -- do not edit manually.
}

{$IFDEF FPC}
  {$MODE DELPHI}
{$ENDIF}

interface

uses
  SysUtils,
  Chilkat.Base;

type

  { TZip wraps CkZip via the C bridge layer. }
  TZip = class(TChilkatBase)
  private
    FOnAbortCheck: TChilkatAbortCheckEvent;
    FOnPercentDone: TChilkatPercentDoneEvent;
    FOnProgressInfo: TChilkatProgressInfoEvent;
    function  GetLastErrorHtml: string;
    function  GetLastErrorText: string;
    function  GetLastErrorXml: string;
    function  GetVersion: string;
    function  GetDebugLogFilePath: string;
    procedure SetDebugLogFilePath(AValue: string);
    function  GetVerboseLogging: Boolean;
    procedure SetVerboseLogging(AValue: Boolean);
    function  GetLastMethodSuccess: Boolean;
    procedure SetLastMethodSuccess(AValue: Boolean);
    function  GetAbortCurrent: Boolean;
    procedure SetAbortCurrent(AValue: Boolean);
    function  GetAppendFromDir: string;
    procedure SetAppendFromDir(AValue: string);
    function  GetAutoRun: string;
    procedure SetAutoRun(AValue: string);
    function  GetAutoRunParams: string;
    procedure SetAutoRunParams(AValue: string);
    function  GetAutoTemp: Boolean;
    procedure SetAutoTemp(AValue: Boolean);
    function  GetCaseSensitive: Boolean;
    procedure SetCaseSensitive(AValue: Boolean);
    function  GetClearArchiveAttribute: Boolean;
    procedure SetClearArchiveAttribute(AValue: Boolean);
    function  GetClearReadOnlyAttr: Boolean;
    procedure SetClearReadOnlyAttr(AValue: Boolean);
    function  GetComment: string;
    procedure SetComment(AValue: string);
    function  GetDecryptPassword: string;
    procedure SetDecryptPassword(AValue: string);
    function  GetDiscardPaths: Boolean;
    procedure SetDiscardPaths(AValue: Boolean);
    function  GetEncryptKeyLength: Integer;
    procedure SetEncryptKeyLength(AValue: Integer);
    function  GetEncryptPassword: string;
    procedure SetEncryptPassword(AValue: string);
    function  GetEncryption: Integer;
    procedure SetEncryption(AValue: Integer);
    function  GetExeDefaultDir: string;
    procedure SetExeDefaultDir(AValue: string);
    function  GetExeFinishNotifier: Boolean;
    procedure SetExeFinishNotifier(AValue: Boolean);
    function  GetExeIconFile: string;
    procedure SetExeIconFile(AValue: string);
    function  GetExeNoInterface: Boolean;
    procedure SetExeNoInterface(AValue: Boolean);
    function  GetExeSilentProgress: Boolean;
    procedure SetExeSilentProgress(AValue: Boolean);
    function  GetExeTitle: string;
    procedure SetExeTitle(AValue: string);
    function  GetExeUnzipCaption: string;
    procedure SetExeUnzipCaption(AValue: string);
    function  GetExeUnzipDir: string;
    procedure SetExeUnzipDir(AValue: string);
    function  GetExeWaitForSetup: Boolean;
    procedure SetExeWaitForSetup(AValue: Boolean);
    function  GetExeXmlConfig: string;
    procedure SetExeXmlConfig(AValue: string);
    function  GetFileCount: Integer;
    function  GetFileName: string;
    procedure SetFileName(AValue: string);
    function  GetHasZipFormatErrors: Boolean;
    function  GetHeartbeatMs: Integer;
    procedure SetHeartbeatMs(AValue: Integer);
    function  GetIgnoreAccessDenied: Boolean;
    procedure SetIgnoreAccessDenied(AValue: Boolean);
    function  GetNumEntries: Integer;
    function  GetOemCodePage: Integer;
    procedure SetOemCodePage(AValue: Integer);
    function  GetOverwriteExisting: Boolean;
    procedure SetOverwriteExisting(AValue: Boolean);
    function  GetPasswordProtect: Boolean;
    procedure SetPasswordProtect(AValue: Boolean);
    function  GetPathPrefix: string;
    procedure SetPathPrefix(AValue: string);
    function  GetPercentDoneScale: Integer;
    procedure SetPercentDoneScale(AValue: Integer);
    function  GetTempDir: string;
    procedure SetTempDir(AValue: string);
    function  GetZipx: Boolean;
    procedure SetZipx(AValue: Boolean);
    function  GetZipxDefaultAlg: string;
    procedure SetZipxDefaultAlg(AValue: string);
    function  GetPwdProtCharset: string;
    procedure SetPwdProtCharset(AValue: string);
    function  GetUncommonOptions: string;
    procedure SetUncommonOptions(AValue: string);
    function  GetMaxUncompressSize: LongWord;
    procedure SetMaxUncompressSize(AValue: LongWord);
    function  GetMinDate: string;
    procedure SetMinDate(AValue: string);
    function  GetMaxDate: string;
    procedure SetMaxDate(AValue: string);
    procedure SetOnAbortCheck(AValue: TChilkatAbortCheckEvent);
    procedure SetOnPercentDone(AValue: TChilkatPercentDoneEvent);
    procedure SetOnProgressInfo(AValue: TChilkatProgressInfoEvent);
  public
    constructor Create;
    destructor  Destroy; override;

    property LastErrorHtml: string read GetLastErrorHtml;
    property LastErrorText: string read GetLastErrorText;
    property LastErrorXml: string read GetLastErrorXml;
    property Version: string read GetVersion;
    property DebugLogFilePath: string read GetDebugLogFilePath write SetDebugLogFilePath;
    property VerboseLogging: Boolean read GetVerboseLogging write SetVerboseLogging;
    property LastMethodSuccess: Boolean read GetLastMethodSuccess write SetLastMethodSuccess;
    property AbortCurrent: Boolean read GetAbortCurrent write SetAbortCurrent;
    property AppendFromDir: string read GetAppendFromDir write SetAppendFromDir;
    property AutoRun: string read GetAutoRun write SetAutoRun;
    property AutoRunParams: string read GetAutoRunParams write SetAutoRunParams;
    property AutoTemp: Boolean read GetAutoTemp write SetAutoTemp;
    property CaseSensitive: Boolean read GetCaseSensitive write SetCaseSensitive;
    property ClearArchiveAttribute: Boolean read GetClearArchiveAttribute write SetClearArchiveAttribute;
    property ClearReadOnlyAttr: Boolean read GetClearReadOnlyAttr write SetClearReadOnlyAttr;
    property Comment: string read GetComment write SetComment;
    property DecryptPassword: string read GetDecryptPassword write SetDecryptPassword;
    property DiscardPaths: Boolean read GetDiscardPaths write SetDiscardPaths;
    property EncryptKeyLength: Integer read GetEncryptKeyLength write SetEncryptKeyLength;
    property EncryptPassword: string read GetEncryptPassword write SetEncryptPassword;
    property Encryption: Integer read GetEncryption write SetEncryption;
    property ExeDefaultDir: string read GetExeDefaultDir write SetExeDefaultDir;
    property ExeFinishNotifier: Boolean read GetExeFinishNotifier write SetExeFinishNotifier;
    property ExeIconFile: string read GetExeIconFile write SetExeIconFile;
    property ExeNoInterface: Boolean read GetExeNoInterface write SetExeNoInterface;
    property ExeSilentProgress: Boolean read GetExeSilentProgress write SetExeSilentProgress;
    property ExeTitle: string read GetExeTitle write SetExeTitle;
    property ExeUnzipCaption: string read GetExeUnzipCaption write SetExeUnzipCaption;
    property ExeUnzipDir: string read GetExeUnzipDir write SetExeUnzipDir;
    property ExeWaitForSetup: Boolean read GetExeWaitForSetup write SetExeWaitForSetup;
    property ExeXmlConfig: string read GetExeXmlConfig write SetExeXmlConfig;
    property FileCount: Integer read GetFileCount;
    property FileName: string read GetFileName write SetFileName;
    property HasZipFormatErrors: Boolean read GetHasZipFormatErrors;
    property HeartbeatMs: Integer read GetHeartbeatMs write SetHeartbeatMs;
    property IgnoreAccessDenied: Boolean read GetIgnoreAccessDenied write SetIgnoreAccessDenied;
    property NumEntries: Integer read GetNumEntries;
    property OemCodePage: Integer read GetOemCodePage write SetOemCodePage;
    property OverwriteExisting: Boolean read GetOverwriteExisting write SetOverwriteExisting;
    property PasswordProtect: Boolean read GetPasswordProtect write SetPasswordProtect;
    property PathPrefix: string read GetPathPrefix write SetPathPrefix;
    property PercentDoneScale: Integer read GetPercentDoneScale write SetPercentDoneScale;
    property TempDir: string read GetTempDir write SetTempDir;
    property Zipx: Boolean read GetZipx write SetZipx;
    property ZipxDefaultAlg: string read GetZipxDefaultAlg write SetZipxDefaultAlg;
    property PwdProtCharset: string read GetPwdProtCharset write SetPwdProtCharset;
    property UncommonOptions: string read GetUncommonOptions write SetUncommonOptions;
    property MaxUncompressSize: LongWord read GetMaxUncompressSize write SetMaxUncompressSize;
    property MinDate: string read GetMinDate write SetMinDate;
    property MaxDate: string read GetMaxDate write SetMaxDate;

    { Event callbacks.  Return True from OnAbortCheck / OnPercentDone
      to abort the running method.  Callbacks are invoked on the
      thread that called the Chilkat method.  The HeartbeatMs
      property controls the AbortCheck frequency. }
    property OnAbortCheck: TChilkatAbortCheckEvent read FOnAbortCheck write SetOnAbortCheck;
    property OnPercentDone: TChilkatPercentDoneEvent read FOnPercentDone write SetOnPercentDone;
    property OnProgressInfo: TChilkatProgressInfoEvent read FOnProgressInfo write SetOnProgressInfo;

    procedure AddNoCompressExtension(const fileExtension: string);
    function  AppendFiles(const filePattern: string; recurse: Boolean): Boolean;
    function  AppendFilesEx(const filePattern: string; recurse: Boolean; saveExtraPath: Boolean; archiveOnly: Boolean; includeHidden: Boolean; includeSystem: Boolean): Boolean;
    function  AppendZip(const zipPath: string): Boolean;
    procedure CloseZip;
    function  DeleteEntry(entry: TChilkatBase): Boolean;
    procedure ExcludeDir(const dirName: string);
    function  ExtractExe(const exePath: string; const dirPath: string): Boolean;
    function  GetDirectoryAsXML: string;
    function  GetExeConfigParam(const name: string): string;
    function  IsNoCompressExtension(const fileExtension: string): Boolean;
    function  IsPasswordProtected(const zipPath: string): Boolean;
    function  NewZip(const zipPath: string): Boolean;
    function  OpenEmbedded(const exeFilename: string; const resourceName: string): Boolean;
    function  OpenZip(const zipPath: string): Boolean;
    function  QuickAppend(const zipPath: string): Boolean;
    procedure RemoveNoCompressExtension(const fileExtension: string);
    procedure SetCompressionLevel(level: Integer);
    procedure SetExclusions(excludePatterns: TChilkatBase);
    procedure SetExeConfigParam(const paramName: string; const paramValue: string);
    function  Unzip(const dirPath: string): Integer;
    function  UnzipInto(const dirPath: string): Integer;
    function  UnzipMatching(const dirPath: string; const pattern: string; verbose: Boolean): Integer;
    function  UnzipMatchingInto(const dirPath: string; const pattern: string; verbose: Boolean): Integer;
    function  UnzipNewer(const dirPath: string): Integer;
    function  VerifyPassword: Boolean;
    function  WriteExe(const exeFilename: string): Boolean;
    function  WriteExe2(const exePath: string; const destExePath: string; bAesEncrypt: Boolean; keyLength: Integer; const password: string): Boolean;
    function  WriteZip: Boolean;
    function  WriteZipAndClose: Boolean;
    function  WriteBd(binData: TChilkatBase): Boolean;
    function  OpenBd(binData: TChilkatBase): Boolean;
    function  GetMaxUncompressedSize: string;
    function  AddBd(const pathInZip: string; bd: TChilkatBase): Boolean;
    function  AddEncoded(const pathInZip: string; const encoding: string; const data: string): Boolean;
    function  AddEmpty(isDir: Boolean; const pathInZip: string): Boolean;
    function  AddString(const pathInZip: string; const content: string; const charset: string): Boolean;
    function  AddSb(const pathInZip: string; sb: TChilkatBase; const charset: string): Boolean;
    function  AddFile(const localPath: string; saveExtraPath: Boolean): Boolean;
    function  EntryAt(index: Integer; entry: TChilkatBase): Boolean;
    function  EntryMatching(const pattern: string; entry: TChilkatBase): Boolean;
    function  EntryOf(const pathInZip: string; entry: TChilkatBase): Boolean;
    function  EntryById(id: Integer; entry: TChilkatBase): Boolean;
  end;

implementation

uses
  CkDllLoader,
  Chilkat.Utils;

{ ---- C bridge function pointer types ---- }
type
  TCkZip_Create  = function(): Pointer; cdecl;
  TCkZip_Dispose = procedure(handle: Pointer); cdecl;
  TCkBridgeAbortCheckCb   = function(userData: Pointer): Integer; cdecl;
  TCkBridgePercentDoneCb  = function(pctDone: Integer; userData: Pointer): Integer; cdecl;
  TCkBridgeProgressInfoCb = procedure(name: PAnsiChar; value: PAnsiChar; userData: Pointer); cdecl;
  TCkZip_SetAbortCheckCallback   = procedure(handle: Pointer; cb: TCkBridgeAbortCheckCb; userData: Pointer); cdecl;
  TCkZip_SetPercentDoneCallback  = procedure(handle: Pointer; cb: TCkBridgePercentDoneCb; userData: Pointer); cdecl;
  TCkZip_SetProgressInfoCallback = procedure(handle: Pointer; cb: TCkBridgeProgressInfoCb; userData: Pointer); cdecl;
  TCkZip_get_LastErrorHtml = function(handle: Pointer): PAnsiChar; cdecl;
  TCkZip_get_LastErrorText = function(handle: Pointer): PAnsiChar; cdecl;
  TCkZip_get_LastErrorXml = function(handle: Pointer): PAnsiChar; cdecl;
  TCkZip_get_Version = function(handle: Pointer): PAnsiChar; cdecl;
  TCkZip_get_DebugLogFilePath = function(handle: Pointer): PAnsiChar; cdecl;
  TCkZip_put_DebugLogFilePath = procedure(handle: Pointer; value: PAnsiChar); cdecl;
  TCkZip_get_VerboseLogging = function(handle: Pointer): LongBool; cdecl;
  TCkZip_put_VerboseLogging = procedure(handle: Pointer; value: LongBool); cdecl;
  TCkZip_get_LastMethodSuccess = function(handle: Pointer): LongBool; cdecl;
  TCkZip_put_LastMethodSuccess = procedure(handle: Pointer; value: LongBool); cdecl;
  TCkZip_get_AbortCurrent = function(handle: Pointer): LongBool; cdecl;
  TCkZip_put_AbortCurrent = procedure(handle: Pointer; value: LongBool); cdecl;
  TCkZip_get_AppendFromDir = function(handle: Pointer): PAnsiChar; cdecl;
  TCkZip_put_AppendFromDir = procedure(handle: Pointer; value: PAnsiChar); cdecl;
  TCkZip_get_AutoRun = function(handle: Pointer): PAnsiChar; cdecl;
  TCkZip_put_AutoRun = procedure(handle: Pointer; value: PAnsiChar); cdecl;
  TCkZip_get_AutoRunParams = function(handle: Pointer): PAnsiChar; cdecl;
  TCkZip_put_AutoRunParams = procedure(handle: Pointer; value: PAnsiChar); cdecl;
  TCkZip_get_AutoTemp = function(handle: Pointer): LongBool; cdecl;
  TCkZip_put_AutoTemp = procedure(handle: Pointer; value: LongBool); cdecl;
  TCkZip_get_CaseSensitive = function(handle: Pointer): LongBool; cdecl;
  TCkZip_put_CaseSensitive = procedure(handle: Pointer; value: LongBool); cdecl;
  TCkZip_get_ClearArchiveAttribute = function(handle: Pointer): LongBool; cdecl;
  TCkZip_put_ClearArchiveAttribute = procedure(handle: Pointer; value: LongBool); cdecl;
  TCkZip_get_ClearReadOnlyAttr = function(handle: Pointer): LongBool; cdecl;
  TCkZip_put_ClearReadOnlyAttr = procedure(handle: Pointer; value: LongBool); cdecl;
  TCkZip_get_Comment = function(handle: Pointer): PAnsiChar; cdecl;
  TCkZip_put_Comment = procedure(handle: Pointer; value: PAnsiChar); cdecl;
  TCkZip_get_DecryptPassword = function(handle: Pointer): PAnsiChar; cdecl;
  TCkZip_put_DecryptPassword = procedure(handle: Pointer; value: PAnsiChar); cdecl;
  TCkZip_get_DiscardPaths = function(handle: Pointer): LongBool; cdecl;
  TCkZip_put_DiscardPaths = procedure(handle: Pointer; value: LongBool); cdecl;
  TCkZip_get_EncryptKeyLength = function(handle: Pointer): Integer; cdecl;
  TCkZip_put_EncryptKeyLength = procedure(handle: Pointer; value: Integer); cdecl;
  TCkZip_get_EncryptPassword = function(handle: Pointer): PAnsiChar; cdecl;
  TCkZip_put_EncryptPassword = procedure(handle: Pointer; value: PAnsiChar); cdecl;
  TCkZip_get_Encryption = function(handle: Pointer): Integer; cdecl;
  TCkZip_put_Encryption = procedure(handle: Pointer; value: Integer); cdecl;
  TCkZip_get_ExeDefaultDir = function(handle: Pointer): PAnsiChar; cdecl;
  TCkZip_put_ExeDefaultDir = procedure(handle: Pointer; value: PAnsiChar); cdecl;
  TCkZip_get_ExeFinishNotifier = function(handle: Pointer): LongBool; cdecl;
  TCkZip_put_ExeFinishNotifier = procedure(handle: Pointer; value: LongBool); cdecl;
  TCkZip_get_ExeIconFile = function(handle: Pointer): PAnsiChar; cdecl;
  TCkZip_put_ExeIconFile = procedure(handle: Pointer; value: PAnsiChar); cdecl;
  TCkZip_get_ExeNoInterface = function(handle: Pointer): LongBool; cdecl;
  TCkZip_put_ExeNoInterface = procedure(handle: Pointer; value: LongBool); cdecl;
  TCkZip_get_ExeSilentProgress = function(handle: Pointer): LongBool; cdecl;
  TCkZip_put_ExeSilentProgress = procedure(handle: Pointer; value: LongBool); cdecl;
  TCkZip_get_ExeTitle = function(handle: Pointer): PAnsiChar; cdecl;
  TCkZip_put_ExeTitle = procedure(handle: Pointer; value: PAnsiChar); cdecl;
  TCkZip_get_ExeUnzipCaption = function(handle: Pointer): PAnsiChar; cdecl;
  TCkZip_put_ExeUnzipCaption = procedure(handle: Pointer; value: PAnsiChar); cdecl;
  TCkZip_get_ExeUnzipDir = function(handle: Pointer): PAnsiChar; cdecl;
  TCkZip_put_ExeUnzipDir = procedure(handle: Pointer; value: PAnsiChar); cdecl;
  TCkZip_get_ExeWaitForSetup = function(handle: Pointer): LongBool; cdecl;
  TCkZip_put_ExeWaitForSetup = procedure(handle: Pointer; value: LongBool); cdecl;
  TCkZip_get_ExeXmlConfig = function(handle: Pointer): PAnsiChar; cdecl;
  TCkZip_put_ExeXmlConfig = procedure(handle: Pointer; value: PAnsiChar); cdecl;
  TCkZip_get_FileCount = function(handle: Pointer): Integer; cdecl;
  TCkZip_get_FileName = function(handle: Pointer): PAnsiChar; cdecl;
  TCkZip_put_FileName = procedure(handle: Pointer; value: PAnsiChar); cdecl;
  TCkZip_get_HasZipFormatErrors = function(handle: Pointer): LongBool; cdecl;
  TCkZip_get_HeartbeatMs = function(handle: Pointer): Integer; cdecl;
  TCkZip_put_HeartbeatMs = procedure(handle: Pointer; value: Integer); cdecl;
  TCkZip_get_IgnoreAccessDenied = function(handle: Pointer): LongBool; cdecl;
  TCkZip_put_IgnoreAccessDenied = procedure(handle: Pointer; value: LongBool); cdecl;
  TCkZip_get_NumEntries = function(handle: Pointer): Integer; cdecl;
  TCkZip_get_OemCodePage = function(handle: Pointer): Integer; cdecl;
  TCkZip_put_OemCodePage = procedure(handle: Pointer; value: Integer); cdecl;
  TCkZip_get_OverwriteExisting = function(handle: Pointer): LongBool; cdecl;
  TCkZip_put_OverwriteExisting = procedure(handle: Pointer; value: LongBool); cdecl;
  TCkZip_get_PasswordProtect = function(handle: Pointer): LongBool; cdecl;
  TCkZip_put_PasswordProtect = procedure(handle: Pointer; value: LongBool); cdecl;
  TCkZip_get_PathPrefix = function(handle: Pointer): PAnsiChar; cdecl;
  TCkZip_put_PathPrefix = procedure(handle: Pointer; value: PAnsiChar); cdecl;
  TCkZip_get_PercentDoneScale = function(handle: Pointer): Integer; cdecl;
  TCkZip_put_PercentDoneScale = procedure(handle: Pointer; value: Integer); cdecl;
  TCkZip_get_TempDir = function(handle: Pointer): PAnsiChar; cdecl;
  TCkZip_put_TempDir = procedure(handle: Pointer; value: PAnsiChar); cdecl;
  TCkZip_get_Zipx = function(handle: Pointer): LongBool; cdecl;
  TCkZip_put_Zipx = procedure(handle: Pointer; value: LongBool); cdecl;
  TCkZip_get_ZipxDefaultAlg = function(handle: Pointer): PAnsiChar; cdecl;
  TCkZip_put_ZipxDefaultAlg = procedure(handle: Pointer; value: PAnsiChar); cdecl;
  TCkZip_get_PwdProtCharset = function(handle: Pointer): PAnsiChar; cdecl;
  TCkZip_put_PwdProtCharset = procedure(handle: Pointer; value: PAnsiChar); cdecl;
  TCkZip_get_UncommonOptions = function(handle: Pointer): PAnsiChar; cdecl;
  TCkZip_put_UncommonOptions = procedure(handle: Pointer; value: PAnsiChar); cdecl;
  TCkZip_get_MaxUncompressSize = function(handle: Pointer): LongWord; cdecl;
  TCkZip_put_MaxUncompressSize = procedure(handle: Pointer; value: LongWord); cdecl;
  TCkZip_get_MinDate = function(handle: Pointer): PAnsiChar; cdecl;
  TCkZip_put_MinDate = procedure(handle: Pointer; value: PAnsiChar); cdecl;
  TCkZip_get_MaxDate = function(handle: Pointer): PAnsiChar; cdecl;
  TCkZip_put_MaxDate = procedure(handle: Pointer; value: PAnsiChar); cdecl;
  TCkZip_AddNoCompressExtension = procedure(handle: Pointer; fileExtension: PAnsiChar); cdecl;
  TCkZip_AppendFiles = function(handle: Pointer; filePattern: PAnsiChar; recurse: LongBool): LongBool; cdecl;
  TCkZip_AppendFilesEx = function(handle: Pointer; filePattern: PAnsiChar; recurse: LongBool; saveExtraPath: LongBool; archiveOnly: LongBool; includeHidden: LongBool; includeSystem: LongBool): LongBool; cdecl;
  TCkZip_AppendZip = function(handle: Pointer; zipPath: PAnsiChar): LongBool; cdecl;
  TCkZip_CloseZip = procedure(handle: Pointer); cdecl;
  TCkZip_DeleteEntry = function(handle: Pointer; entry: Pointer): LongBool; cdecl;
  TCkZip_ExcludeDir = procedure(handle: Pointer; dirName: PAnsiChar); cdecl;
  TCkZip_ExtractExe = function(handle: Pointer; exePath: PAnsiChar; dirPath: PAnsiChar): LongBool; cdecl;
  TCkZip_GetDirectoryAsXML = function(handle: Pointer): PAnsiChar; cdecl;
  TCkZip_GetExeConfigParam = function(handle: Pointer; name: PAnsiChar): PAnsiChar; cdecl;
  TCkZip_IsNoCompressExtension = function(handle: Pointer; fileExtension: PAnsiChar): LongBool; cdecl;
  TCkZip_IsPasswordProtected = function(handle: Pointer; zipPath: PAnsiChar): LongBool; cdecl;
  TCkZip_NewZip = function(handle: Pointer; zipPath: PAnsiChar): LongBool; cdecl;
  TCkZip_OpenEmbedded = function(handle: Pointer; exeFilename: PAnsiChar; resourceName: PAnsiChar): LongBool; cdecl;
  TCkZip_OpenZip = function(handle: Pointer; zipPath: PAnsiChar): LongBool; cdecl;
  TCkZip_QuickAppend = function(handle: Pointer; zipPath: PAnsiChar): LongBool; cdecl;
  TCkZip_RemoveNoCompressExtension = procedure(handle: Pointer; fileExtension: PAnsiChar); cdecl;
  TCkZip_SetCompressionLevel = procedure(handle: Pointer; level: Integer); cdecl;
  TCkZip_SetExclusions = procedure(handle: Pointer; excludePatterns: Pointer); cdecl;
  TCkZip_SetExeConfigParam = procedure(handle: Pointer; paramName: PAnsiChar; paramValue: PAnsiChar); cdecl;
  TCkZip_Unzip = function(handle: Pointer; dirPath: PAnsiChar): Integer; cdecl;
  TCkZip_UnzipInto = function(handle: Pointer; dirPath: PAnsiChar): Integer; cdecl;
  TCkZip_UnzipMatching = function(handle: Pointer; dirPath: PAnsiChar; pattern: PAnsiChar; verbose: LongBool): Integer; cdecl;
  TCkZip_UnzipMatchingInto = function(handle: Pointer; dirPath: PAnsiChar; pattern: PAnsiChar; verbose: LongBool): Integer; cdecl;
  TCkZip_UnzipNewer = function(handle: Pointer; dirPath: PAnsiChar): Integer; cdecl;
  TCkZip_VerifyPassword = function(handle: Pointer): LongBool; cdecl;
  TCkZip_WriteExe = function(handle: Pointer; exeFilename: PAnsiChar): LongBool; cdecl;
  TCkZip_WriteExe2 = function(handle: Pointer; exePath: PAnsiChar; destExePath: PAnsiChar; bAesEncrypt: LongBool; keyLength: Integer; password: PAnsiChar): LongBool; cdecl;
  TCkZip_WriteZip = function(handle: Pointer): LongBool; cdecl;
  TCkZip_WriteZipAndClose = function(handle: Pointer): LongBool; cdecl;
  TCkZip_WriteBd = function(handle: Pointer; binData: Pointer): LongBool; cdecl;
  TCkZip_OpenBd = function(handle: Pointer; binData: Pointer): LongBool; cdecl;
  TCkZip_GetMaxUncompressedSize = function(handle: Pointer): PAnsiChar; cdecl;
  TCkZip_AddBd = function(handle: Pointer; pathInZip: PAnsiChar; bd: Pointer): LongBool; cdecl;
  TCkZip_AddEncoded = function(handle: Pointer; pathInZip: PAnsiChar; encoding: PAnsiChar; data: PAnsiChar): LongBool; cdecl;
  TCkZip_AddEmpty = function(handle: Pointer; isDir: LongBool; pathInZip: PAnsiChar): LongBool; cdecl;
  TCkZip_AddString = function(handle: Pointer; pathInZip: PAnsiChar; content: PAnsiChar; charset: PAnsiChar): LongBool; cdecl;
  TCkZip_AddSb = function(handle: Pointer; pathInZip: PAnsiChar; sb: Pointer; charset: PAnsiChar): LongBool; cdecl;
  TCkZip_AddFile = function(handle: Pointer; localPath: PAnsiChar; saveExtraPath: LongBool): LongBool; cdecl;
  TCkZip_EntryAt = function(handle: Pointer; index: Integer; entry: Pointer): LongBool; cdecl;
  TCkZip_EntryMatching = function(handle: Pointer; pattern: PAnsiChar; entry: Pointer): LongBool; cdecl;
  TCkZip_EntryOf = function(handle: Pointer; pathInZip: PAnsiChar; entry: Pointer): LongBool; cdecl;
  TCkZip_EntryById = function(handle: Pointer; id: Integer; entry: Pointer): LongBool; cdecl;

{ ---- C bridge function pointer variables ---- }
var
  CkZip_Create:  TCkZip_Create  = nil;
  CkZip_Dispose: TCkZip_Dispose = nil;
  CkZip_SetAbortCheckCallback:   TCkZip_SetAbortCheckCallback   = nil;
  CkZip_SetPercentDoneCallback:  TCkZip_SetPercentDoneCallback  = nil;
  CkZip_SetProgressInfoCallback: TCkZip_SetProgressInfoCallback = nil;
  CkZip_get_LastErrorHtml: TCkZip_get_LastErrorHtml = nil;
  CkZip_get_LastErrorText: TCkZip_get_LastErrorText = nil;
  CkZip_get_LastErrorXml: TCkZip_get_LastErrorXml = nil;
  CkZip_get_Version: TCkZip_get_Version = nil;
  CkZip_get_DebugLogFilePath: TCkZip_get_DebugLogFilePath = nil;
  CkZip_put_DebugLogFilePath: TCkZip_put_DebugLogFilePath = nil;
  CkZip_get_VerboseLogging: TCkZip_get_VerboseLogging = nil;
  CkZip_put_VerboseLogging: TCkZip_put_VerboseLogging = nil;
  CkZip_get_LastMethodSuccess: TCkZip_get_LastMethodSuccess = nil;
  CkZip_put_LastMethodSuccess: TCkZip_put_LastMethodSuccess = nil;
  CkZip_get_AbortCurrent: TCkZip_get_AbortCurrent = nil;
  CkZip_put_AbortCurrent: TCkZip_put_AbortCurrent = nil;
  CkZip_get_AppendFromDir: TCkZip_get_AppendFromDir = nil;
  CkZip_put_AppendFromDir: TCkZip_put_AppendFromDir = nil;
  CkZip_get_AutoRun: TCkZip_get_AutoRun = nil;
  CkZip_put_AutoRun: TCkZip_put_AutoRun = nil;
  CkZip_get_AutoRunParams: TCkZip_get_AutoRunParams = nil;
  CkZip_put_AutoRunParams: TCkZip_put_AutoRunParams = nil;
  CkZip_get_AutoTemp: TCkZip_get_AutoTemp = nil;
  CkZip_put_AutoTemp: TCkZip_put_AutoTemp = nil;
  CkZip_get_CaseSensitive: TCkZip_get_CaseSensitive = nil;
  CkZip_put_CaseSensitive: TCkZip_put_CaseSensitive = nil;
  CkZip_get_ClearArchiveAttribute: TCkZip_get_ClearArchiveAttribute = nil;
  CkZip_put_ClearArchiveAttribute: TCkZip_put_ClearArchiveAttribute = nil;
  CkZip_get_ClearReadOnlyAttr: TCkZip_get_ClearReadOnlyAttr = nil;
  CkZip_put_ClearReadOnlyAttr: TCkZip_put_ClearReadOnlyAttr = nil;
  CkZip_get_Comment: TCkZip_get_Comment = nil;
  CkZip_put_Comment: TCkZip_put_Comment = nil;
  CkZip_get_DecryptPassword: TCkZip_get_DecryptPassword = nil;
  CkZip_put_DecryptPassword: TCkZip_put_DecryptPassword = nil;
  CkZip_get_DiscardPaths: TCkZip_get_DiscardPaths = nil;
  CkZip_put_DiscardPaths: TCkZip_put_DiscardPaths = nil;
  CkZip_get_EncryptKeyLength: TCkZip_get_EncryptKeyLength = nil;
  CkZip_put_EncryptKeyLength: TCkZip_put_EncryptKeyLength = nil;
  CkZip_get_EncryptPassword: TCkZip_get_EncryptPassword = nil;
  CkZip_put_EncryptPassword: TCkZip_put_EncryptPassword = nil;
  CkZip_get_Encryption: TCkZip_get_Encryption = nil;
  CkZip_put_Encryption: TCkZip_put_Encryption = nil;
  CkZip_get_ExeDefaultDir: TCkZip_get_ExeDefaultDir = nil;
  CkZip_put_ExeDefaultDir: TCkZip_put_ExeDefaultDir = nil;
  CkZip_get_ExeFinishNotifier: TCkZip_get_ExeFinishNotifier = nil;
  CkZip_put_ExeFinishNotifier: TCkZip_put_ExeFinishNotifier = nil;
  CkZip_get_ExeIconFile: TCkZip_get_ExeIconFile = nil;
  CkZip_put_ExeIconFile: TCkZip_put_ExeIconFile = nil;
  CkZip_get_ExeNoInterface: TCkZip_get_ExeNoInterface = nil;
  CkZip_put_ExeNoInterface: TCkZip_put_ExeNoInterface = nil;
  CkZip_get_ExeSilentProgress: TCkZip_get_ExeSilentProgress = nil;
  CkZip_put_ExeSilentProgress: TCkZip_put_ExeSilentProgress = nil;
  CkZip_get_ExeTitle: TCkZip_get_ExeTitle = nil;
  CkZip_put_ExeTitle: TCkZip_put_ExeTitle = nil;
  CkZip_get_ExeUnzipCaption: TCkZip_get_ExeUnzipCaption = nil;
  CkZip_put_ExeUnzipCaption: TCkZip_put_ExeUnzipCaption = nil;
  CkZip_get_ExeUnzipDir: TCkZip_get_ExeUnzipDir = nil;
  CkZip_put_ExeUnzipDir: TCkZip_put_ExeUnzipDir = nil;
  CkZip_get_ExeWaitForSetup: TCkZip_get_ExeWaitForSetup = nil;
  CkZip_put_ExeWaitForSetup: TCkZip_put_ExeWaitForSetup = nil;
  CkZip_get_ExeXmlConfig: TCkZip_get_ExeXmlConfig = nil;
  CkZip_put_ExeXmlConfig: TCkZip_put_ExeXmlConfig = nil;
  CkZip_get_FileCount: TCkZip_get_FileCount = nil;
  CkZip_get_FileName: TCkZip_get_FileName = nil;
  CkZip_put_FileName: TCkZip_put_FileName = nil;
  CkZip_get_HasZipFormatErrors: TCkZip_get_HasZipFormatErrors = nil;
  CkZip_get_HeartbeatMs: TCkZip_get_HeartbeatMs = nil;
  CkZip_put_HeartbeatMs: TCkZip_put_HeartbeatMs = nil;
  CkZip_get_IgnoreAccessDenied: TCkZip_get_IgnoreAccessDenied = nil;
  CkZip_put_IgnoreAccessDenied: TCkZip_put_IgnoreAccessDenied = nil;
  CkZip_get_NumEntries: TCkZip_get_NumEntries = nil;
  CkZip_get_OemCodePage: TCkZip_get_OemCodePage = nil;
  CkZip_put_OemCodePage: TCkZip_put_OemCodePage = nil;
  CkZip_get_OverwriteExisting: TCkZip_get_OverwriteExisting = nil;
  CkZip_put_OverwriteExisting: TCkZip_put_OverwriteExisting = nil;
  CkZip_get_PasswordProtect: TCkZip_get_PasswordProtect = nil;
  CkZip_put_PasswordProtect: TCkZip_put_PasswordProtect = nil;
  CkZip_get_PathPrefix: TCkZip_get_PathPrefix = nil;
  CkZip_put_PathPrefix: TCkZip_put_PathPrefix = nil;
  CkZip_get_PercentDoneScale: TCkZip_get_PercentDoneScale = nil;
  CkZip_put_PercentDoneScale: TCkZip_put_PercentDoneScale = nil;
  CkZip_get_TempDir: TCkZip_get_TempDir = nil;
  CkZip_put_TempDir: TCkZip_put_TempDir = nil;
  CkZip_get_Zipx: TCkZip_get_Zipx = nil;
  CkZip_put_Zipx: TCkZip_put_Zipx = nil;
  CkZip_get_ZipxDefaultAlg: TCkZip_get_ZipxDefaultAlg = nil;
  CkZip_put_ZipxDefaultAlg: TCkZip_put_ZipxDefaultAlg = nil;
  CkZip_get_PwdProtCharset: TCkZip_get_PwdProtCharset = nil;
  CkZip_put_PwdProtCharset: TCkZip_put_PwdProtCharset = nil;
  CkZip_get_UncommonOptions: TCkZip_get_UncommonOptions = nil;
  CkZip_put_UncommonOptions: TCkZip_put_UncommonOptions = nil;
  CkZip_get_MaxUncompressSize: TCkZip_get_MaxUncompressSize = nil;
  CkZip_put_MaxUncompressSize: TCkZip_put_MaxUncompressSize = nil;
  CkZip_get_MinDate: TCkZip_get_MinDate = nil;
  CkZip_put_MinDate: TCkZip_put_MinDate = nil;
  CkZip_get_MaxDate: TCkZip_get_MaxDate = nil;
  CkZip_put_MaxDate: TCkZip_put_MaxDate = nil;
  CkZip_AddNoCompressExtension: TCkZip_AddNoCompressExtension = nil;
  CkZip_AppendFiles: TCkZip_AppendFiles = nil;
  CkZip_AppendFilesEx: TCkZip_AppendFilesEx = nil;
  CkZip_AppendZip: TCkZip_AppendZip = nil;
  CkZip_CloseZip: TCkZip_CloseZip = nil;
  CkZip_DeleteEntry: TCkZip_DeleteEntry = nil;
  CkZip_ExcludeDir: TCkZip_ExcludeDir = nil;
  CkZip_ExtractExe: TCkZip_ExtractExe = nil;
  CkZip_GetDirectoryAsXML: TCkZip_GetDirectoryAsXML = nil;
  CkZip_GetExeConfigParam: TCkZip_GetExeConfigParam = nil;
  CkZip_IsNoCompressExtension: TCkZip_IsNoCompressExtension = nil;
  CkZip_IsPasswordProtected: TCkZip_IsPasswordProtected = nil;
  CkZip_NewZip: TCkZip_NewZip = nil;
  CkZip_OpenEmbedded: TCkZip_OpenEmbedded = nil;
  CkZip_OpenZip: TCkZip_OpenZip = nil;
  CkZip_QuickAppend: TCkZip_QuickAppend = nil;
  CkZip_RemoveNoCompressExtension: TCkZip_RemoveNoCompressExtension = nil;
  CkZip_SetCompressionLevel: TCkZip_SetCompressionLevel = nil;
  CkZip_SetExclusions: TCkZip_SetExclusions = nil;
  CkZip_SetExeConfigParam: TCkZip_SetExeConfigParam = nil;
  CkZip_Unzip: TCkZip_Unzip = nil;
  CkZip_UnzipInto: TCkZip_UnzipInto = nil;
  CkZip_UnzipMatching: TCkZip_UnzipMatching = nil;
  CkZip_UnzipMatchingInto: TCkZip_UnzipMatchingInto = nil;
  CkZip_UnzipNewer: TCkZip_UnzipNewer = nil;
  CkZip_VerifyPassword: TCkZip_VerifyPassword = nil;
  CkZip_WriteExe: TCkZip_WriteExe = nil;
  CkZip_WriteExe2: TCkZip_WriteExe2 = nil;
  CkZip_WriteZip: TCkZip_WriteZip = nil;
  CkZip_WriteZipAndClose: TCkZip_WriteZipAndClose = nil;
  CkZip_WriteBd: TCkZip_WriteBd = nil;
  CkZip_OpenBd: TCkZip_OpenBd = nil;
  CkZip_GetMaxUncompressedSize: TCkZip_GetMaxUncompressedSize = nil;
  CkZip_AddBd: TCkZip_AddBd = nil;
  CkZip_AddEncoded: TCkZip_AddEncoded = nil;
  CkZip_AddEmpty: TCkZip_AddEmpty = nil;
  CkZip_AddString: TCkZip_AddString = nil;
  CkZip_AddSb: TCkZip_AddSb = nil;
  CkZip_AddFile: TCkZip_AddFile = nil;
  CkZip_EntryAt: TCkZip_EntryAt = nil;
  CkZip_EntryMatching: TCkZip_EntryMatching = nil;
  CkZip_EntryOf: TCkZip_EntryOf = nil;
  CkZip_EntryById: TCkZip_EntryById = nil;

constructor TZip.Create;
begin
  inherited Create;
  FHandle := CkZip_Create();
end;

destructor TZip.Destroy;
begin
  if FHandle <> nil then
    CkZip_Dispose(FHandle);
  FHandle := nil;
  inherited;
end;

{ ---- Event callback thunks ---- }
{ Standalone cdecl functions registered with the C bridge.  The bridge
  passes back the userData pointer, which carries the Pascal object
  instance.  A non-zero return value aborts the running method. }

function TZip_AbortCheckThunk(userData: Pointer): Integer; cdecl;
var
  obj: TZip;
begin
  Result := 0;
  obj := TZip(userData);
  if Assigned(obj) and Assigned(obj.FOnAbortCheck) then
    if obj.FOnAbortCheck(obj) then Result := 1;
end;

function TZip_PercentDoneThunk(pctDone: Integer; userData: Pointer): Integer; cdecl;
var
  obj: TZip;
begin
  Result := 0;
  obj := TZip(userData);
  if Assigned(obj) and Assigned(obj.FOnPercentDone) then
    if obj.FOnPercentDone(obj, pctDone) then Result := 1;
end;

procedure TZip_ProgressInfoThunk(name: PAnsiChar; value: PAnsiChar; userData: Pointer); cdecl;
var
  obj: TZip;
begin
  obj := TZip(userData);
  if Assigned(obj) and Assigned(obj.FOnProgressInfo) then
    obj.FOnProgressInfo(obj, CkToStr(name), CkToStr(value));
end;

procedure TZip.SetOnAbortCheck(AValue: TChilkatAbortCheckEvent);
begin
  FOnAbortCheck := AValue;
  if Assigned(AValue) then
    CkZip_SetAbortCheckCallback(FHandle, @TZip_AbortCheckThunk, Self)
  else
    CkZip_SetAbortCheckCallback(FHandle, nil, nil);
end;

procedure TZip.SetOnPercentDone(AValue: TChilkatPercentDoneEvent);
begin
  FOnPercentDone := AValue;
  if Assigned(AValue) then
    CkZip_SetPercentDoneCallback(FHandle, @TZip_PercentDoneThunk, Self)
  else
    CkZip_SetPercentDoneCallback(FHandle, nil, nil);
end;

procedure TZip.SetOnProgressInfo(AValue: TChilkatProgressInfoEvent);
begin
  FOnProgressInfo := AValue;
  if Assigned(AValue) then
    CkZip_SetProgressInfoCallback(FHandle, @TZip_ProgressInfoThunk, Self)
  else
    CkZip_SetProgressInfoCallback(FHandle, nil, nil);
end;

function TZip.GetLastErrorHtml: string;
begin
  Result := CkToStr(CkZip_get_LastErrorHtml(FHandle));
end;

function TZip.GetLastErrorText: string;
begin
  Result := CkToStr(CkZip_get_LastErrorText(FHandle));
end;

function TZip.GetLastErrorXml: string;
begin
  Result := CkToStr(CkZip_get_LastErrorXml(FHandle));
end;

function TZip.GetVersion: string;
begin
  Result := CkToStr(CkZip_get_Version(FHandle));
end;

function TZip.GetDebugLogFilePath: string;
begin
  Result := CkToStr(CkZip_get_DebugLogFilePath(FHandle));
end;

procedure TZip.SetDebugLogFilePath(AValue: string);
begin
  CkZip_put_DebugLogFilePath(FHandle, PAnsiChar(StrToCk(AValue)));
end;

function TZip.GetVerboseLogging: Boolean;
begin
  Result := Boolean(CkZip_get_VerboseLogging(FHandle));
end;

procedure TZip.SetVerboseLogging(AValue: Boolean);
begin
  CkZip_put_VerboseLogging(FHandle, LongBool(AValue));
end;

function TZip.GetLastMethodSuccess: Boolean;
begin
  Result := Boolean(CkZip_get_LastMethodSuccess(FHandle));
end;

procedure TZip.SetLastMethodSuccess(AValue: Boolean);
begin
  CkZip_put_LastMethodSuccess(FHandle, LongBool(AValue));
end;

function TZip.GetAbortCurrent: Boolean;
begin
  Result := Boolean(CkZip_get_AbortCurrent(FHandle));
end;

procedure TZip.SetAbortCurrent(AValue: Boolean);
begin
  CkZip_put_AbortCurrent(FHandle, LongBool(AValue));
end;

function TZip.GetAppendFromDir: string;
begin
  Result := CkToStr(CkZip_get_AppendFromDir(FHandle));
end;

procedure TZip.SetAppendFromDir(AValue: string);
begin
  CkZip_put_AppendFromDir(FHandle, PAnsiChar(StrToCk(AValue)));
end;

function TZip.GetAutoRun: string;
begin
  Result := CkToStr(CkZip_get_AutoRun(FHandle));
end;

procedure TZip.SetAutoRun(AValue: string);
begin
  CkZip_put_AutoRun(FHandle, PAnsiChar(StrToCk(AValue)));
end;

function TZip.GetAutoRunParams: string;
begin
  Result := CkToStr(CkZip_get_AutoRunParams(FHandle));
end;

procedure TZip.SetAutoRunParams(AValue: string);
begin
  CkZip_put_AutoRunParams(FHandle, PAnsiChar(StrToCk(AValue)));
end;

function TZip.GetAutoTemp: Boolean;
begin
  Result := Boolean(CkZip_get_AutoTemp(FHandle));
end;

procedure TZip.SetAutoTemp(AValue: Boolean);
begin
  CkZip_put_AutoTemp(FHandle, LongBool(AValue));
end;

function TZip.GetCaseSensitive: Boolean;
begin
  Result := Boolean(CkZip_get_CaseSensitive(FHandle));
end;

procedure TZip.SetCaseSensitive(AValue: Boolean);
begin
  CkZip_put_CaseSensitive(FHandle, LongBool(AValue));
end;

function TZip.GetClearArchiveAttribute: Boolean;
begin
  Result := Boolean(CkZip_get_ClearArchiveAttribute(FHandle));
end;

procedure TZip.SetClearArchiveAttribute(AValue: Boolean);
begin
  CkZip_put_ClearArchiveAttribute(FHandle, LongBool(AValue));
end;

function TZip.GetClearReadOnlyAttr: Boolean;
begin
  Result := Boolean(CkZip_get_ClearReadOnlyAttr(FHandle));
end;

procedure TZip.SetClearReadOnlyAttr(AValue: Boolean);
begin
  CkZip_put_ClearReadOnlyAttr(FHandle, LongBool(AValue));
end;

function TZip.GetComment: string;
begin
  Result := CkToStr(CkZip_get_Comment(FHandle));
end;

procedure TZip.SetComment(AValue: string);
begin
  CkZip_put_Comment(FHandle, PAnsiChar(StrToCk(AValue)));
end;

function TZip.GetDecryptPassword: string;
begin
  Result := CkToStr(CkZip_get_DecryptPassword(FHandle));
end;

procedure TZip.SetDecryptPassword(AValue: string);
begin
  CkZip_put_DecryptPassword(FHandle, PAnsiChar(StrToCk(AValue)));
end;

function TZip.GetDiscardPaths: Boolean;
begin
  Result := Boolean(CkZip_get_DiscardPaths(FHandle));
end;

procedure TZip.SetDiscardPaths(AValue: Boolean);
begin
  CkZip_put_DiscardPaths(FHandle, LongBool(AValue));
end;

function TZip.GetEncryptKeyLength: Integer;
begin
  Result := CkZip_get_EncryptKeyLength(FHandle);
end;

procedure TZip.SetEncryptKeyLength(AValue: Integer);
begin
  CkZip_put_EncryptKeyLength(FHandle, AValue);
end;

function TZip.GetEncryptPassword: string;
begin
  Result := CkToStr(CkZip_get_EncryptPassword(FHandle));
end;

procedure TZip.SetEncryptPassword(AValue: string);
begin
  CkZip_put_EncryptPassword(FHandle, PAnsiChar(StrToCk(AValue)));
end;

function TZip.GetEncryption: Integer;
begin
  Result := CkZip_get_Encryption(FHandle);
end;

procedure TZip.SetEncryption(AValue: Integer);
begin
  CkZip_put_Encryption(FHandle, AValue);
end;

function TZip.GetExeDefaultDir: string;
begin
  Result := CkToStr(CkZip_get_ExeDefaultDir(FHandle));
end;

procedure TZip.SetExeDefaultDir(AValue: string);
begin
  CkZip_put_ExeDefaultDir(FHandle, PAnsiChar(StrToCk(AValue)));
end;

function TZip.GetExeFinishNotifier: Boolean;
begin
  Result := Boolean(CkZip_get_ExeFinishNotifier(FHandle));
end;

procedure TZip.SetExeFinishNotifier(AValue: Boolean);
begin
  CkZip_put_ExeFinishNotifier(FHandle, LongBool(AValue));
end;

function TZip.GetExeIconFile: string;
begin
  Result := CkToStr(CkZip_get_ExeIconFile(FHandle));
end;

procedure TZip.SetExeIconFile(AValue: string);
begin
  CkZip_put_ExeIconFile(FHandle, PAnsiChar(StrToCk(AValue)));
end;

function TZip.GetExeNoInterface: Boolean;
begin
  Result := Boolean(CkZip_get_ExeNoInterface(FHandle));
end;

procedure TZip.SetExeNoInterface(AValue: Boolean);
begin
  CkZip_put_ExeNoInterface(FHandle, LongBool(AValue));
end;

function TZip.GetExeSilentProgress: Boolean;
begin
  Result := Boolean(CkZip_get_ExeSilentProgress(FHandle));
end;

procedure TZip.SetExeSilentProgress(AValue: Boolean);
begin
  CkZip_put_ExeSilentProgress(FHandle, LongBool(AValue));
end;

function TZip.GetExeTitle: string;
begin
  Result := CkToStr(CkZip_get_ExeTitle(FHandle));
end;

procedure TZip.SetExeTitle(AValue: string);
begin
  CkZip_put_ExeTitle(FHandle, PAnsiChar(StrToCk(AValue)));
end;

function TZip.GetExeUnzipCaption: string;
begin
  Result := CkToStr(CkZip_get_ExeUnzipCaption(FHandle));
end;

procedure TZip.SetExeUnzipCaption(AValue: string);
begin
  CkZip_put_ExeUnzipCaption(FHandle, PAnsiChar(StrToCk(AValue)));
end;

function TZip.GetExeUnzipDir: string;
begin
  Result := CkToStr(CkZip_get_ExeUnzipDir(FHandle));
end;

procedure TZip.SetExeUnzipDir(AValue: string);
begin
  CkZip_put_ExeUnzipDir(FHandle, PAnsiChar(StrToCk(AValue)));
end;

function TZip.GetExeWaitForSetup: Boolean;
begin
  Result := Boolean(CkZip_get_ExeWaitForSetup(FHandle));
end;

procedure TZip.SetExeWaitForSetup(AValue: Boolean);
begin
  CkZip_put_ExeWaitForSetup(FHandle, LongBool(AValue));
end;

function TZip.GetExeXmlConfig: string;
begin
  Result := CkToStr(CkZip_get_ExeXmlConfig(FHandle));
end;

procedure TZip.SetExeXmlConfig(AValue: string);
begin
  CkZip_put_ExeXmlConfig(FHandle, PAnsiChar(StrToCk(AValue)));
end;

function TZip.GetFileCount: Integer;
begin
  Result := CkZip_get_FileCount(FHandle);
end;

function TZip.GetFileName: string;
begin
  Result := CkToStr(CkZip_get_FileName(FHandle));
end;

procedure TZip.SetFileName(AValue: string);
begin
  CkZip_put_FileName(FHandle, PAnsiChar(StrToCk(AValue)));
end;

function TZip.GetHasZipFormatErrors: Boolean;
begin
  Result := Boolean(CkZip_get_HasZipFormatErrors(FHandle));
end;

function TZip.GetHeartbeatMs: Integer;
begin
  Result := CkZip_get_HeartbeatMs(FHandle);
end;

procedure TZip.SetHeartbeatMs(AValue: Integer);
begin
  CkZip_put_HeartbeatMs(FHandle, AValue);
end;

function TZip.GetIgnoreAccessDenied: Boolean;
begin
  Result := Boolean(CkZip_get_IgnoreAccessDenied(FHandle));
end;

procedure TZip.SetIgnoreAccessDenied(AValue: Boolean);
begin
  CkZip_put_IgnoreAccessDenied(FHandle, LongBool(AValue));
end;

function TZip.GetNumEntries: Integer;
begin
  Result := CkZip_get_NumEntries(FHandle);
end;

function TZip.GetOemCodePage: Integer;
begin
  Result := CkZip_get_OemCodePage(FHandle);
end;

procedure TZip.SetOemCodePage(AValue: Integer);
begin
  CkZip_put_OemCodePage(FHandle, AValue);
end;

function TZip.GetOverwriteExisting: Boolean;
begin
  Result := Boolean(CkZip_get_OverwriteExisting(FHandle));
end;

procedure TZip.SetOverwriteExisting(AValue: Boolean);
begin
  CkZip_put_OverwriteExisting(FHandle, LongBool(AValue));
end;

function TZip.GetPasswordProtect: Boolean;
begin
  Result := Boolean(CkZip_get_PasswordProtect(FHandle));
end;

procedure TZip.SetPasswordProtect(AValue: Boolean);
begin
  CkZip_put_PasswordProtect(FHandle, LongBool(AValue));
end;

function TZip.GetPathPrefix: string;
begin
  Result := CkToStr(CkZip_get_PathPrefix(FHandle));
end;

procedure TZip.SetPathPrefix(AValue: string);
begin
  CkZip_put_PathPrefix(FHandle, PAnsiChar(StrToCk(AValue)));
end;

function TZip.GetPercentDoneScale: Integer;
begin
  Result := CkZip_get_PercentDoneScale(FHandle);
end;

procedure TZip.SetPercentDoneScale(AValue: Integer);
begin
  CkZip_put_PercentDoneScale(FHandle, AValue);
end;

function TZip.GetTempDir: string;
begin
  Result := CkToStr(CkZip_get_TempDir(FHandle));
end;

procedure TZip.SetTempDir(AValue: string);
begin
  CkZip_put_TempDir(FHandle, PAnsiChar(StrToCk(AValue)));
end;

function TZip.GetZipx: Boolean;
begin
  Result := Boolean(CkZip_get_Zipx(FHandle));
end;

procedure TZip.SetZipx(AValue: Boolean);
begin
  CkZip_put_Zipx(FHandle, LongBool(AValue));
end;

function TZip.GetZipxDefaultAlg: string;
begin
  Result := CkToStr(CkZip_get_ZipxDefaultAlg(FHandle));
end;

procedure TZip.SetZipxDefaultAlg(AValue: string);
begin
  CkZip_put_ZipxDefaultAlg(FHandle, PAnsiChar(StrToCk(AValue)));
end;

function TZip.GetPwdProtCharset: string;
begin
  Result := CkToStr(CkZip_get_PwdProtCharset(FHandle));
end;

procedure TZip.SetPwdProtCharset(AValue: string);
begin
  CkZip_put_PwdProtCharset(FHandle, PAnsiChar(StrToCk(AValue)));
end;

function TZip.GetUncommonOptions: string;
begin
  Result := CkToStr(CkZip_get_UncommonOptions(FHandle));
end;

procedure TZip.SetUncommonOptions(AValue: string);
begin
  CkZip_put_UncommonOptions(FHandle, PAnsiChar(StrToCk(AValue)));
end;

function TZip.GetMaxUncompressSize: LongWord;
begin
  Result := CkZip_get_MaxUncompressSize(FHandle);
end;

procedure TZip.SetMaxUncompressSize(AValue: LongWord);
begin
  CkZip_put_MaxUncompressSize(FHandle, AValue);
end;

function TZip.GetMinDate: string;
begin
  Result := CkToStr(CkZip_get_MinDate(FHandle));
end;

procedure TZip.SetMinDate(AValue: string);
begin
  CkZip_put_MinDate(FHandle, PAnsiChar(StrToCk(AValue)));
end;

function TZip.GetMaxDate: string;
begin
  Result := CkToStr(CkZip_get_MaxDate(FHandle));
end;

procedure TZip.SetMaxDate(AValue: string);
begin
  CkZip_put_MaxDate(FHandle, PAnsiChar(StrToCk(AValue)));
end;

procedure TZip.AddNoCompressExtension(const fileExtension: string);
begin
  CkZip_AddNoCompressExtension(FHandle, PAnsiChar(StrToCk(fileExtension)));
end;

function TZip.AppendFiles(const filePattern: string; recurse: Boolean): Boolean;
begin
  Result := Boolean(CkZip_AppendFiles(FHandle, PAnsiChar(StrToCk(filePattern)), LongBool(recurse)));
end;

function TZip.AppendFilesEx(const filePattern: string; recurse: Boolean; saveExtraPath: Boolean; archiveOnly: Boolean; includeHidden: Boolean; includeSystem: Boolean): Boolean;
begin
  Result := Boolean(CkZip_AppendFilesEx(FHandle, PAnsiChar(StrToCk(filePattern)), LongBool(recurse), LongBool(saveExtraPath), LongBool(archiveOnly), LongBool(includeHidden), LongBool(includeSystem)));
end;

function TZip.AppendZip(const zipPath: string): Boolean;
begin
  Result := Boolean(CkZip_AppendZip(FHandle, PAnsiChar(StrToCk(zipPath))));
end;

procedure TZip.CloseZip;
begin
  CkZip_CloseZip(FHandle);
end;

function TZip.DeleteEntry(entry: TChilkatBase): Boolean;
begin
  Result := Boolean(CkZip_DeleteEntry(FHandle, entry.Handle));
end;

procedure TZip.ExcludeDir(const dirName: string);
begin
  CkZip_ExcludeDir(FHandle, PAnsiChar(StrToCk(dirName)));
end;

function TZip.ExtractExe(const exePath: string; const dirPath: string): Boolean;
begin
  Result := Boolean(CkZip_ExtractExe(FHandle, PAnsiChar(StrToCk(exePath)), PAnsiChar(StrToCk(dirPath))));
end;

function TZip.GetDirectoryAsXML: string;
begin
  Result := CkToStr(CkZip_GetDirectoryAsXML(FHandle));
end;

function TZip.GetExeConfigParam(const name: string): string;
begin
  Result := CkToStr(CkZip_GetExeConfigParam(FHandle, PAnsiChar(StrToCk(name))));
end;

function TZip.IsNoCompressExtension(const fileExtension: string): Boolean;
begin
  Result := Boolean(CkZip_IsNoCompressExtension(FHandle, PAnsiChar(StrToCk(fileExtension))));
end;

function TZip.IsPasswordProtected(const zipPath: string): Boolean;
begin
  Result := Boolean(CkZip_IsPasswordProtected(FHandle, PAnsiChar(StrToCk(zipPath))));
end;

function TZip.NewZip(const zipPath: string): Boolean;
begin
  Result := Boolean(CkZip_NewZip(FHandle, PAnsiChar(StrToCk(zipPath))));
end;

function TZip.OpenEmbedded(const exeFilename: string; const resourceName: string): Boolean;
begin
  Result := Boolean(CkZip_OpenEmbedded(FHandle, PAnsiChar(StrToCk(exeFilename)), PAnsiChar(StrToCk(resourceName))));
end;

function TZip.OpenZip(const zipPath: string): Boolean;
begin
  Result := Boolean(CkZip_OpenZip(FHandle, PAnsiChar(StrToCk(zipPath))));
end;

function TZip.QuickAppend(const zipPath: string): Boolean;
begin
  Result := Boolean(CkZip_QuickAppend(FHandle, PAnsiChar(StrToCk(zipPath))));
end;

procedure TZip.RemoveNoCompressExtension(const fileExtension: string);
begin
  CkZip_RemoveNoCompressExtension(FHandle, PAnsiChar(StrToCk(fileExtension)));
end;

procedure TZip.SetCompressionLevel(level: Integer);
begin
  CkZip_SetCompressionLevel(FHandle, level);
end;

procedure TZip.SetExclusions(excludePatterns: TChilkatBase);
begin
  CkZip_SetExclusions(FHandle, excludePatterns.Handle);
end;

procedure TZip.SetExeConfigParam(const paramName: string; const paramValue: string);
begin
  CkZip_SetExeConfigParam(FHandle, PAnsiChar(StrToCk(paramName)), PAnsiChar(StrToCk(paramValue)));
end;

function TZip.Unzip(const dirPath: string): Integer;
begin
  Result := CkZip_Unzip(FHandle, PAnsiChar(StrToCk(dirPath)));
end;

function TZip.UnzipInto(const dirPath: string): Integer;
begin
  Result := CkZip_UnzipInto(FHandle, PAnsiChar(StrToCk(dirPath)));
end;

function TZip.UnzipMatching(const dirPath: string; const pattern: string; verbose: Boolean): Integer;
begin
  Result := CkZip_UnzipMatching(FHandle, PAnsiChar(StrToCk(dirPath)), PAnsiChar(StrToCk(pattern)), LongBool(verbose));
end;

function TZip.UnzipMatchingInto(const dirPath: string; const pattern: string; verbose: Boolean): Integer;
begin
  Result := CkZip_UnzipMatchingInto(FHandle, PAnsiChar(StrToCk(dirPath)), PAnsiChar(StrToCk(pattern)), LongBool(verbose));
end;

function TZip.UnzipNewer(const dirPath: string): Integer;
begin
  Result := CkZip_UnzipNewer(FHandle, PAnsiChar(StrToCk(dirPath)));
end;

function TZip.VerifyPassword: Boolean;
begin
  Result := Boolean(CkZip_VerifyPassword(FHandle));
end;

function TZip.WriteExe(const exeFilename: string): Boolean;
begin
  Result := Boolean(CkZip_WriteExe(FHandle, PAnsiChar(StrToCk(exeFilename))));
end;

function TZip.WriteExe2(const exePath: string; const destExePath: string; bAesEncrypt: Boolean; keyLength: Integer; const password: string): Boolean;
begin
  Result := Boolean(CkZip_WriteExe2(FHandle, PAnsiChar(StrToCk(exePath)), PAnsiChar(StrToCk(destExePath)), LongBool(bAesEncrypt), keyLength, PAnsiChar(StrToCk(password))));
end;

function TZip.WriteZip: Boolean;
begin
  Result := Boolean(CkZip_WriteZip(FHandle));
end;

function TZip.WriteZipAndClose: Boolean;
begin
  Result := Boolean(CkZip_WriteZipAndClose(FHandle));
end;

function TZip.WriteBd(binData: TChilkatBase): Boolean;
begin
  Result := Boolean(CkZip_WriteBd(FHandle, binData.Handle));
end;

function TZip.OpenBd(binData: TChilkatBase): Boolean;
begin
  Result := Boolean(CkZip_OpenBd(FHandle, binData.Handle));
end;

function TZip.GetMaxUncompressedSize: string;
begin
  Result := CkToStr(CkZip_GetMaxUncompressedSize(FHandle));
end;

function TZip.AddBd(const pathInZip: string; bd: TChilkatBase): Boolean;
begin
  Result := Boolean(CkZip_AddBd(FHandle, PAnsiChar(StrToCk(pathInZip)), bd.Handle));
end;

function TZip.AddEncoded(const pathInZip: string; const encoding: string; const data: string): Boolean;
begin
  Result := Boolean(CkZip_AddEncoded(FHandle, PAnsiChar(StrToCk(pathInZip)), PAnsiChar(StrToCk(encoding)), PAnsiChar(StrToCk(data))));
end;

function TZip.AddEmpty(isDir: Boolean; const pathInZip: string): Boolean;
begin
  Result := Boolean(CkZip_AddEmpty(FHandle, LongBool(isDir), PAnsiChar(StrToCk(pathInZip))));
end;

function TZip.AddString(const pathInZip: string; const content: string; const charset: string): Boolean;
begin
  Result := Boolean(CkZip_AddString(FHandle, PAnsiChar(StrToCk(pathInZip)), PAnsiChar(StrToCk(content)), PAnsiChar(StrToCk(charset))));
end;

function TZip.AddSb(const pathInZip: string; sb: TChilkatBase; const charset: string): Boolean;
begin
  Result := Boolean(CkZip_AddSb(FHandle, PAnsiChar(StrToCk(pathInZip)), sb.Handle, PAnsiChar(StrToCk(charset))));
end;

function TZip.AddFile(const localPath: string; saveExtraPath: Boolean): Boolean;
begin
  Result := Boolean(CkZip_AddFile(FHandle, PAnsiChar(StrToCk(localPath)), LongBool(saveExtraPath)));
end;

function TZip.EntryAt(index: Integer; entry: TChilkatBase): Boolean;
begin
  Result := Boolean(CkZip_EntryAt(FHandle, index, entry.Handle));
end;

function TZip.EntryMatching(const pattern: string; entry: TChilkatBase): Boolean;
begin
  Result := Boolean(CkZip_EntryMatching(FHandle, PAnsiChar(StrToCk(pattern)), entry.Handle));
end;

function TZip.EntryOf(const pathInZip: string; entry: TChilkatBase): Boolean;
begin
  Result := Boolean(CkZip_EntryOf(FHandle, PAnsiChar(StrToCk(pathInZip)), entry.Handle));
end;

function TZip.EntryById(id: Integer; entry: TChilkatBase): Boolean;
begin
  Result := Boolean(CkZip_EntryById(FHandle, id, entry.Handle));
end;

initialization
  Chilkat_GetProcedureAddress(CkZip_Create,  'CkZip_Create');
  Chilkat_GetProcedureAddress(CkZip_Dispose, 'CkZip_Dispose');
  Chilkat_GetProcedureAddress(CkZip_SetAbortCheckCallback, 'CkZip_SetAbortCheckCallback');
  Chilkat_GetProcedureAddress(CkZip_SetPercentDoneCallback, 'CkZip_SetPercentDoneCallback');
  Chilkat_GetProcedureAddress(CkZip_SetProgressInfoCallback, 'CkZip_SetProgressInfoCallback');
  Chilkat_GetProcedureAddress(CkZip_get_LastErrorHtml, 'CkZip_get_LastErrorHtml');
  Chilkat_GetProcedureAddress(CkZip_get_LastErrorText, 'CkZip_get_LastErrorText');
  Chilkat_GetProcedureAddress(CkZip_get_LastErrorXml, 'CkZip_get_LastErrorXml');
  Chilkat_GetProcedureAddress(CkZip_get_Version, 'CkZip_get_Version');
  Chilkat_GetProcedureAddress(CkZip_get_DebugLogFilePath, 'CkZip_get_DebugLogFilePath');
  Chilkat_GetProcedureAddress(CkZip_put_DebugLogFilePath, 'CkZip_put_DebugLogFilePath');
  Chilkat_GetProcedureAddress(CkZip_get_VerboseLogging, 'CkZip_get_VerboseLogging');
  Chilkat_GetProcedureAddress(CkZip_put_VerboseLogging, 'CkZip_put_VerboseLogging');
  Chilkat_GetProcedureAddress(CkZip_get_LastMethodSuccess, 'CkZip_get_LastMethodSuccess');
  Chilkat_GetProcedureAddress(CkZip_put_LastMethodSuccess, 'CkZip_put_LastMethodSuccess');
  Chilkat_GetProcedureAddress(CkZip_get_AbortCurrent, 'CkZip_get_AbortCurrent');
  Chilkat_GetProcedureAddress(CkZip_put_AbortCurrent, 'CkZip_put_AbortCurrent');
  Chilkat_GetProcedureAddress(CkZip_get_AppendFromDir, 'CkZip_get_AppendFromDir');
  Chilkat_GetProcedureAddress(CkZip_put_AppendFromDir, 'CkZip_put_AppendFromDir');
  Chilkat_GetProcedureAddress(CkZip_get_AutoRun, 'CkZip_get_AutoRun');
  Chilkat_GetProcedureAddress(CkZip_put_AutoRun, 'CkZip_put_AutoRun');
  Chilkat_GetProcedureAddress(CkZip_get_AutoRunParams, 'CkZip_get_AutoRunParams');
  Chilkat_GetProcedureAddress(CkZip_put_AutoRunParams, 'CkZip_put_AutoRunParams');
  Chilkat_GetProcedureAddress(CkZip_get_AutoTemp, 'CkZip_get_AutoTemp');
  Chilkat_GetProcedureAddress(CkZip_put_AutoTemp, 'CkZip_put_AutoTemp');
  Chilkat_GetProcedureAddress(CkZip_get_CaseSensitive, 'CkZip_get_CaseSensitive');
  Chilkat_GetProcedureAddress(CkZip_put_CaseSensitive, 'CkZip_put_CaseSensitive');
  Chilkat_GetProcedureAddress(CkZip_get_ClearArchiveAttribute, 'CkZip_get_ClearArchiveAttribute');
  Chilkat_GetProcedureAddress(CkZip_put_ClearArchiveAttribute, 'CkZip_put_ClearArchiveAttribute');
  Chilkat_GetProcedureAddress(CkZip_get_ClearReadOnlyAttr, 'CkZip_get_ClearReadOnlyAttr');
  Chilkat_GetProcedureAddress(CkZip_put_ClearReadOnlyAttr, 'CkZip_put_ClearReadOnlyAttr');
  Chilkat_GetProcedureAddress(CkZip_get_Comment, 'CkZip_get_Comment');
  Chilkat_GetProcedureAddress(CkZip_put_Comment, 'CkZip_put_Comment');
  Chilkat_GetProcedureAddress(CkZip_get_DecryptPassword, 'CkZip_get_DecryptPassword');
  Chilkat_GetProcedureAddress(CkZip_put_DecryptPassword, 'CkZip_put_DecryptPassword');
  Chilkat_GetProcedureAddress(CkZip_get_DiscardPaths, 'CkZip_get_DiscardPaths');
  Chilkat_GetProcedureAddress(CkZip_put_DiscardPaths, 'CkZip_put_DiscardPaths');
  Chilkat_GetProcedureAddress(CkZip_get_EncryptKeyLength, 'CkZip_get_EncryptKeyLength');
  Chilkat_GetProcedureAddress(CkZip_put_EncryptKeyLength, 'CkZip_put_EncryptKeyLength');
  Chilkat_GetProcedureAddress(CkZip_get_EncryptPassword, 'CkZip_get_EncryptPassword');
  Chilkat_GetProcedureAddress(CkZip_put_EncryptPassword, 'CkZip_put_EncryptPassword');
  Chilkat_GetProcedureAddress(CkZip_get_Encryption, 'CkZip_get_Encryption');
  Chilkat_GetProcedureAddress(CkZip_put_Encryption, 'CkZip_put_Encryption');
  Chilkat_GetProcedureAddress(CkZip_get_ExeDefaultDir, 'CkZip_get_ExeDefaultDir');
  Chilkat_GetProcedureAddress(CkZip_put_ExeDefaultDir, 'CkZip_put_ExeDefaultDir');
  Chilkat_GetProcedureAddress(CkZip_get_ExeFinishNotifier, 'CkZip_get_ExeFinishNotifier');
  Chilkat_GetProcedureAddress(CkZip_put_ExeFinishNotifier, 'CkZip_put_ExeFinishNotifier');
  Chilkat_GetProcedureAddress(CkZip_get_ExeIconFile, 'CkZip_get_ExeIconFile');
  Chilkat_GetProcedureAddress(CkZip_put_ExeIconFile, 'CkZip_put_ExeIconFile');
  Chilkat_GetProcedureAddress(CkZip_get_ExeNoInterface, 'CkZip_get_ExeNoInterface');
  Chilkat_GetProcedureAddress(CkZip_put_ExeNoInterface, 'CkZip_put_ExeNoInterface');
  Chilkat_GetProcedureAddress(CkZip_get_ExeSilentProgress, 'CkZip_get_ExeSilentProgress');
  Chilkat_GetProcedureAddress(CkZip_put_ExeSilentProgress, 'CkZip_put_ExeSilentProgress');
  Chilkat_GetProcedureAddress(CkZip_get_ExeTitle, 'CkZip_get_ExeTitle');
  Chilkat_GetProcedureAddress(CkZip_put_ExeTitle, 'CkZip_put_ExeTitle');
  Chilkat_GetProcedureAddress(CkZip_get_ExeUnzipCaption, 'CkZip_get_ExeUnzipCaption');
  Chilkat_GetProcedureAddress(CkZip_put_ExeUnzipCaption, 'CkZip_put_ExeUnzipCaption');
  Chilkat_GetProcedureAddress(CkZip_get_ExeUnzipDir, 'CkZip_get_ExeUnzipDir');
  Chilkat_GetProcedureAddress(CkZip_put_ExeUnzipDir, 'CkZip_put_ExeUnzipDir');
  Chilkat_GetProcedureAddress(CkZip_get_ExeWaitForSetup, 'CkZip_get_ExeWaitForSetup');
  Chilkat_GetProcedureAddress(CkZip_put_ExeWaitForSetup, 'CkZip_put_ExeWaitForSetup');
  Chilkat_GetProcedureAddress(CkZip_get_ExeXmlConfig, 'CkZip_get_ExeXmlConfig');
  Chilkat_GetProcedureAddress(CkZip_put_ExeXmlConfig, 'CkZip_put_ExeXmlConfig');
  Chilkat_GetProcedureAddress(CkZip_get_FileCount, 'CkZip_get_FileCount');
  Chilkat_GetProcedureAddress(CkZip_get_FileName, 'CkZip_get_FileName');
  Chilkat_GetProcedureAddress(CkZip_put_FileName, 'CkZip_put_FileName');
  Chilkat_GetProcedureAddress(CkZip_get_HasZipFormatErrors, 'CkZip_get_HasZipFormatErrors');
  Chilkat_GetProcedureAddress(CkZip_get_HeartbeatMs, 'CkZip_get_HeartbeatMs');
  Chilkat_GetProcedureAddress(CkZip_put_HeartbeatMs, 'CkZip_put_HeartbeatMs');
  Chilkat_GetProcedureAddress(CkZip_get_IgnoreAccessDenied, 'CkZip_get_IgnoreAccessDenied');
  Chilkat_GetProcedureAddress(CkZip_put_IgnoreAccessDenied, 'CkZip_put_IgnoreAccessDenied');
  Chilkat_GetProcedureAddress(CkZip_get_NumEntries, 'CkZip_get_NumEntries');
  Chilkat_GetProcedureAddress(CkZip_get_OemCodePage, 'CkZip_get_OemCodePage');
  Chilkat_GetProcedureAddress(CkZip_put_OemCodePage, 'CkZip_put_OemCodePage');
  Chilkat_GetProcedureAddress(CkZip_get_OverwriteExisting, 'CkZip_get_OverwriteExisting');
  Chilkat_GetProcedureAddress(CkZip_put_OverwriteExisting, 'CkZip_put_OverwriteExisting');
  Chilkat_GetProcedureAddress(CkZip_get_PasswordProtect, 'CkZip_get_PasswordProtect');
  Chilkat_GetProcedureAddress(CkZip_put_PasswordProtect, 'CkZip_put_PasswordProtect');
  Chilkat_GetProcedureAddress(CkZip_get_PathPrefix, 'CkZip_get_PathPrefix');
  Chilkat_GetProcedureAddress(CkZip_put_PathPrefix, 'CkZip_put_PathPrefix');
  Chilkat_GetProcedureAddress(CkZip_get_PercentDoneScale, 'CkZip_get_PercentDoneScale');
  Chilkat_GetProcedureAddress(CkZip_put_PercentDoneScale, 'CkZip_put_PercentDoneScale');
  Chilkat_GetProcedureAddress(CkZip_get_TempDir, 'CkZip_get_TempDir');
  Chilkat_GetProcedureAddress(CkZip_put_TempDir, 'CkZip_put_TempDir');
  Chilkat_GetProcedureAddress(CkZip_get_Zipx, 'CkZip_get_Zipx');
  Chilkat_GetProcedureAddress(CkZip_put_Zipx, 'CkZip_put_Zipx');
  Chilkat_GetProcedureAddress(CkZip_get_ZipxDefaultAlg, 'CkZip_get_ZipxDefaultAlg');
  Chilkat_GetProcedureAddress(CkZip_put_ZipxDefaultAlg, 'CkZip_put_ZipxDefaultAlg');
  Chilkat_GetProcedureAddress(CkZip_get_PwdProtCharset, 'CkZip_get_PwdProtCharset');
  Chilkat_GetProcedureAddress(CkZip_put_PwdProtCharset, 'CkZip_put_PwdProtCharset');
  Chilkat_GetProcedureAddress(CkZip_get_UncommonOptions, 'CkZip_get_UncommonOptions');
  Chilkat_GetProcedureAddress(CkZip_put_UncommonOptions, 'CkZip_put_UncommonOptions');
  Chilkat_GetProcedureAddress(CkZip_get_MaxUncompressSize, 'CkZip_get_MaxUncompressSize');
  Chilkat_GetProcedureAddress(CkZip_put_MaxUncompressSize, 'CkZip_put_MaxUncompressSize');
  Chilkat_GetProcedureAddress(CkZip_get_MinDate, 'CkZip_get_MinDate');
  Chilkat_GetProcedureAddress(CkZip_put_MinDate, 'CkZip_put_MinDate');
  Chilkat_GetProcedureAddress(CkZip_get_MaxDate, 'CkZip_get_MaxDate');
  Chilkat_GetProcedureAddress(CkZip_put_MaxDate, 'CkZip_put_MaxDate');
  Chilkat_GetProcedureAddress(CkZip_AddNoCompressExtension, 'CkZip_AddNoCompressExtension');
  Chilkat_GetProcedureAddress(CkZip_AppendFiles, 'CkZip_AppendFiles');
  Chilkat_GetProcedureAddress(CkZip_AppendFilesEx, 'CkZip_AppendFilesEx');
  Chilkat_GetProcedureAddress(CkZip_AppendZip, 'CkZip_AppendZip');
  Chilkat_GetProcedureAddress(CkZip_CloseZip, 'CkZip_CloseZip');
  Chilkat_GetProcedureAddress(CkZip_DeleteEntry, 'CkZip_DeleteEntry');
  Chilkat_GetProcedureAddress(CkZip_ExcludeDir, 'CkZip_ExcludeDir');
  Chilkat_GetProcedureAddress(CkZip_ExtractExe, 'CkZip_ExtractExe');
  Chilkat_GetProcedureAddress(CkZip_GetDirectoryAsXML, 'CkZip_GetDirectoryAsXML');
  Chilkat_GetProcedureAddress(CkZip_GetExeConfigParam, 'CkZip_GetExeConfigParam');
  Chilkat_GetProcedureAddress(CkZip_IsNoCompressExtension, 'CkZip_IsNoCompressExtension');
  Chilkat_GetProcedureAddress(CkZip_IsPasswordProtected, 'CkZip_IsPasswordProtected');
  Chilkat_GetProcedureAddress(CkZip_NewZip, 'CkZip_NewZip');
  Chilkat_GetProcedureAddress(CkZip_OpenEmbedded, 'CkZip_OpenEmbedded');
  Chilkat_GetProcedureAddress(CkZip_OpenZip, 'CkZip_OpenZip');
  Chilkat_GetProcedureAddress(CkZip_QuickAppend, 'CkZip_QuickAppend');
  Chilkat_GetProcedureAddress(CkZip_RemoveNoCompressExtension, 'CkZip_RemoveNoCompressExtension');
  Chilkat_GetProcedureAddress(CkZip_SetCompressionLevel, 'CkZip_SetCompressionLevel');
  Chilkat_GetProcedureAddress(CkZip_SetExclusions, 'CkZip_SetExclusions');
  Chilkat_GetProcedureAddress(CkZip_SetExeConfigParam, 'CkZip_SetExeConfigParam');
  Chilkat_GetProcedureAddress(CkZip_Unzip, 'CkZip_Unzip');
  Chilkat_GetProcedureAddress(CkZip_UnzipInto, 'CkZip_UnzipInto');
  Chilkat_GetProcedureAddress(CkZip_UnzipMatching, 'CkZip_UnzipMatching');
  Chilkat_GetProcedureAddress(CkZip_UnzipMatchingInto, 'CkZip_UnzipMatchingInto');
  Chilkat_GetProcedureAddress(CkZip_UnzipNewer, 'CkZip_UnzipNewer');
  Chilkat_GetProcedureAddress(CkZip_VerifyPassword, 'CkZip_VerifyPassword');
  Chilkat_GetProcedureAddress(CkZip_WriteExe, 'CkZip_WriteExe');
  Chilkat_GetProcedureAddress(CkZip_WriteExe2, 'CkZip_WriteExe2');
  Chilkat_GetProcedureAddress(CkZip_WriteZip, 'CkZip_WriteZip');
  Chilkat_GetProcedureAddress(CkZip_WriteZipAndClose, 'CkZip_WriteZipAndClose');
  Chilkat_GetProcedureAddress(CkZip_WriteBd, 'CkZip_WriteBd');
  Chilkat_GetProcedureAddress(CkZip_OpenBd, 'CkZip_OpenBd');
  Chilkat_GetProcedureAddress(CkZip_GetMaxUncompressedSize, 'CkZip_GetMaxUncompressedSize');
  Chilkat_GetProcedureAddress(CkZip_AddBd, 'CkZip_AddBd');
  Chilkat_GetProcedureAddress(CkZip_AddEncoded, 'CkZip_AddEncoded');
  Chilkat_GetProcedureAddress(CkZip_AddEmpty, 'CkZip_AddEmpty');
  Chilkat_GetProcedureAddress(CkZip_AddString, 'CkZip_AddString');
  Chilkat_GetProcedureAddress(CkZip_AddSb, 'CkZip_AddSb');
  Chilkat_GetProcedureAddress(CkZip_AddFile, 'CkZip_AddFile');
  Chilkat_GetProcedureAddress(CkZip_EntryAt, 'CkZip_EntryAt');
  Chilkat_GetProcedureAddress(CkZip_EntryMatching, 'CkZip_EntryMatching');
  Chilkat_GetProcedureAddress(CkZip_EntryOf, 'CkZip_EntryOf');
  Chilkat_GetProcedureAddress(CkZip_EntryById, 'CkZip_EntryById');

end.
