unit Chilkat.Dkim;

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

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

interface

uses
  SysUtils,
  Chilkat.Base;

type

  { TDkim wraps CkDkim via the C bridge layer. }
  TDkim = 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  GetDkimAlg: string;
    procedure SetDkimAlg(AValue: string);
    function  GetDkimBodyLengthCount: Integer;
    procedure SetDkimBodyLengthCount(AValue: Integer);
    function  GetDkimCanon: string;
    procedure SetDkimCanon(AValue: string);
    function  GetDkimDomain: string;
    procedure SetDkimDomain(AValue: string);
    function  GetDkimHeaders: string;
    procedure SetDkimHeaders(AValue: string);
    function  GetDkimSelector: string;
    procedure SetDkimSelector(AValue: string);
    function  GetHeartbeatMs: Integer;
    procedure SetHeartbeatMs(AValue: Integer);
    function  GetAbortCurrent: Boolean;
    procedure SetAbortCurrent(AValue: Boolean);
    function  GetVerifyInfo: 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 DkimAlg: string read GetDkimAlg write SetDkimAlg;
    property DkimBodyLengthCount: Integer read GetDkimBodyLengthCount write SetDkimBodyLengthCount;
    property DkimCanon: string read GetDkimCanon write SetDkimCanon;
    property DkimDomain: string read GetDkimDomain write SetDkimDomain;
    property DkimHeaders: string read GetDkimHeaders write SetDkimHeaders;
    property DkimSelector: string read GetDkimSelector write SetDkimSelector;
    property HeartbeatMs: Integer read GetHeartbeatMs write SetHeartbeatMs;
    property AbortCurrent: Boolean read GetAbortCurrent write SetAbortCurrent;
    property VerifyInfo: string read GetVerifyInfo;

    { 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;

    function  LoadPublicKey(const selector: string; const domain: string; const publicKey: string): Boolean;
    function  LoadPublicKeyFile(const selector: string; const domain: string; const publicKeyFilepath: string): Boolean;
    function  PrefetchPublicKey(const selector: string; const domain: string): Boolean;
    function  DkimSign(mimeData: TChilkatBase): Boolean;
    function  SetDkimPrivateKey(privateKey: TChilkatBase): Boolean;
    function  DkimVerify(sigIndex: Integer; mimeData: TChilkatBase): Boolean;
    function  NumDkimSigs(mimeData: TChilkatBase): Integer;
  end;

implementation

uses
  CkDllLoader,
  Chilkat.Utils;

{ ---- C bridge function pointer types ---- }
type
  TCkDkim_Create  = function(): Pointer; cdecl;
  TCkDkim_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;
  TCkDkim_SetAbortCheckCallback   = procedure(handle: Pointer; cb: TCkBridgeAbortCheckCb; userData: Pointer); cdecl;
  TCkDkim_SetPercentDoneCallback  = procedure(handle: Pointer; cb: TCkBridgePercentDoneCb; userData: Pointer); cdecl;
  TCkDkim_SetProgressInfoCallback = procedure(handle: Pointer; cb: TCkBridgeProgressInfoCb; userData: Pointer); cdecl;
  TCkDkim_get_LastErrorHtml = function(handle: Pointer): PAnsiChar; cdecl;
  TCkDkim_get_LastErrorText = function(handle: Pointer): PAnsiChar; cdecl;
  TCkDkim_get_LastErrorXml = function(handle: Pointer): PAnsiChar; cdecl;
  TCkDkim_get_Version = function(handle: Pointer): PAnsiChar; cdecl;
  TCkDkim_get_DebugLogFilePath = function(handle: Pointer): PAnsiChar; cdecl;
  TCkDkim_put_DebugLogFilePath = procedure(handle: Pointer; value: PAnsiChar); cdecl;
  TCkDkim_get_VerboseLogging = function(handle: Pointer): LongBool; cdecl;
  TCkDkim_put_VerboseLogging = procedure(handle: Pointer; value: LongBool); cdecl;
  TCkDkim_get_LastMethodSuccess = function(handle: Pointer): LongBool; cdecl;
  TCkDkim_put_LastMethodSuccess = procedure(handle: Pointer; value: LongBool); cdecl;
  TCkDkim_get_DkimAlg = function(handle: Pointer): PAnsiChar; cdecl;
  TCkDkim_put_DkimAlg = procedure(handle: Pointer; value: PAnsiChar); cdecl;
  TCkDkim_get_DkimBodyLengthCount = function(handle: Pointer): Integer; cdecl;
  TCkDkim_put_DkimBodyLengthCount = procedure(handle: Pointer; value: Integer); cdecl;
  TCkDkim_get_DkimCanon = function(handle: Pointer): PAnsiChar; cdecl;
  TCkDkim_put_DkimCanon = procedure(handle: Pointer; value: PAnsiChar); cdecl;
  TCkDkim_get_DkimDomain = function(handle: Pointer): PAnsiChar; cdecl;
  TCkDkim_put_DkimDomain = procedure(handle: Pointer; value: PAnsiChar); cdecl;
  TCkDkim_get_DkimHeaders = function(handle: Pointer): PAnsiChar; cdecl;
  TCkDkim_put_DkimHeaders = procedure(handle: Pointer; value: PAnsiChar); cdecl;
  TCkDkim_get_DkimSelector = function(handle: Pointer): PAnsiChar; cdecl;
  TCkDkim_put_DkimSelector = procedure(handle: Pointer; value: PAnsiChar); cdecl;
  TCkDkim_get_HeartbeatMs = function(handle: Pointer): Integer; cdecl;
  TCkDkim_put_HeartbeatMs = procedure(handle: Pointer; value: Integer); cdecl;
  TCkDkim_get_AbortCurrent = function(handle: Pointer): LongBool; cdecl;
  TCkDkim_put_AbortCurrent = procedure(handle: Pointer; value: LongBool); cdecl;
  TCkDkim_get_VerifyInfo = function(handle: Pointer): PAnsiChar; cdecl;
  TCkDkim_LoadPublicKey = function(handle: Pointer; selector: PAnsiChar; domain: PAnsiChar; publicKey: PAnsiChar): LongBool; cdecl;
  TCkDkim_LoadPublicKeyFile = function(handle: Pointer; selector: PAnsiChar; domain: PAnsiChar; publicKeyFilepath: PAnsiChar): LongBool; cdecl;
  TCkDkim_PrefetchPublicKey = function(handle: Pointer; selector: PAnsiChar; domain: PAnsiChar): LongBool; cdecl;
  TCkDkim_DkimSign = function(handle: Pointer; mimeData: Pointer): LongBool; cdecl;
  TCkDkim_SetDkimPrivateKey = function(handle: Pointer; privateKey: Pointer): LongBool; cdecl;
  TCkDkim_DkimVerify = function(handle: Pointer; sigIndex: Integer; mimeData: Pointer): LongBool; cdecl;
  TCkDkim_NumDkimSigs = function(handle: Pointer; mimeData: Pointer): Integer; cdecl;

{ ---- C bridge function pointer variables ---- }
var
  CkDkim_Create:  TCkDkim_Create  = nil;
  CkDkim_Dispose: TCkDkim_Dispose = nil;
  CkDkim_SetAbortCheckCallback:   TCkDkim_SetAbortCheckCallback   = nil;
  CkDkim_SetPercentDoneCallback:  TCkDkim_SetPercentDoneCallback  = nil;
  CkDkim_SetProgressInfoCallback: TCkDkim_SetProgressInfoCallback = nil;
  CkDkim_get_LastErrorHtml: TCkDkim_get_LastErrorHtml = nil;
  CkDkim_get_LastErrorText: TCkDkim_get_LastErrorText = nil;
  CkDkim_get_LastErrorXml: TCkDkim_get_LastErrorXml = nil;
  CkDkim_get_Version: TCkDkim_get_Version = nil;
  CkDkim_get_DebugLogFilePath: TCkDkim_get_DebugLogFilePath = nil;
  CkDkim_put_DebugLogFilePath: TCkDkim_put_DebugLogFilePath = nil;
  CkDkim_get_VerboseLogging: TCkDkim_get_VerboseLogging = nil;
  CkDkim_put_VerboseLogging: TCkDkim_put_VerboseLogging = nil;
  CkDkim_get_LastMethodSuccess: TCkDkim_get_LastMethodSuccess = nil;
  CkDkim_put_LastMethodSuccess: TCkDkim_put_LastMethodSuccess = nil;
  CkDkim_get_DkimAlg: TCkDkim_get_DkimAlg = nil;
  CkDkim_put_DkimAlg: TCkDkim_put_DkimAlg = nil;
  CkDkim_get_DkimBodyLengthCount: TCkDkim_get_DkimBodyLengthCount = nil;
  CkDkim_put_DkimBodyLengthCount: TCkDkim_put_DkimBodyLengthCount = nil;
  CkDkim_get_DkimCanon: TCkDkim_get_DkimCanon = nil;
  CkDkim_put_DkimCanon: TCkDkim_put_DkimCanon = nil;
  CkDkim_get_DkimDomain: TCkDkim_get_DkimDomain = nil;
  CkDkim_put_DkimDomain: TCkDkim_put_DkimDomain = nil;
  CkDkim_get_DkimHeaders: TCkDkim_get_DkimHeaders = nil;
  CkDkim_put_DkimHeaders: TCkDkim_put_DkimHeaders = nil;
  CkDkim_get_DkimSelector: TCkDkim_get_DkimSelector = nil;
  CkDkim_put_DkimSelector: TCkDkim_put_DkimSelector = nil;
  CkDkim_get_HeartbeatMs: TCkDkim_get_HeartbeatMs = nil;
  CkDkim_put_HeartbeatMs: TCkDkim_put_HeartbeatMs = nil;
  CkDkim_get_AbortCurrent: TCkDkim_get_AbortCurrent = nil;
  CkDkim_put_AbortCurrent: TCkDkim_put_AbortCurrent = nil;
  CkDkim_get_VerifyInfo: TCkDkim_get_VerifyInfo = nil;
  CkDkim_LoadPublicKey: TCkDkim_LoadPublicKey = nil;
  CkDkim_LoadPublicKeyFile: TCkDkim_LoadPublicKeyFile = nil;
  CkDkim_PrefetchPublicKey: TCkDkim_PrefetchPublicKey = nil;
  CkDkim_DkimSign: TCkDkim_DkimSign = nil;
  CkDkim_SetDkimPrivateKey: TCkDkim_SetDkimPrivateKey = nil;
  CkDkim_DkimVerify: TCkDkim_DkimVerify = nil;
  CkDkim_NumDkimSigs: TCkDkim_NumDkimSigs = nil;

constructor TDkim.Create;
begin
  inherited Create;
  FHandle := CkDkim_Create();
end;

destructor TDkim.Destroy;
begin
  if FHandle <> nil then
    CkDkim_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 TDkim_AbortCheckThunk(userData: Pointer): Integer; cdecl;
var
  obj: TDkim;
begin
  Result := 0;
  obj := TDkim(userData);
  if Assigned(obj) and Assigned(obj.FOnAbortCheck) then
    if obj.FOnAbortCheck(obj) then Result := 1;
end;

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

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

procedure TDkim.SetOnAbortCheck(AValue: TChilkatAbortCheckEvent);
begin
  FOnAbortCheck := AValue;
  if Assigned(AValue) then
    CkDkim_SetAbortCheckCallback(FHandle, @TDkim_AbortCheckThunk, Self)
  else
    CkDkim_SetAbortCheckCallback(FHandle, nil, nil);
end;

procedure TDkim.SetOnPercentDone(AValue: TChilkatPercentDoneEvent);
begin
  FOnPercentDone := AValue;
  if Assigned(AValue) then
    CkDkim_SetPercentDoneCallback(FHandle, @TDkim_PercentDoneThunk, Self)
  else
    CkDkim_SetPercentDoneCallback(FHandle, nil, nil);
end;

procedure TDkim.SetOnProgressInfo(AValue: TChilkatProgressInfoEvent);
begin
  FOnProgressInfo := AValue;
  if Assigned(AValue) then
    CkDkim_SetProgressInfoCallback(FHandle, @TDkim_ProgressInfoThunk, Self)
  else
    CkDkim_SetProgressInfoCallback(FHandle, nil, nil);
end;

function TDkim.GetLastErrorHtml: string;
begin
  Result := CkToStr(CkDkim_get_LastErrorHtml(FHandle));
end;

function TDkim.GetLastErrorText: string;
begin
  Result := CkToStr(CkDkim_get_LastErrorText(FHandle));
end;

function TDkim.GetLastErrorXml: string;
begin
  Result := CkToStr(CkDkim_get_LastErrorXml(FHandle));
end;

function TDkim.GetVersion: string;
begin
  Result := CkToStr(CkDkim_get_Version(FHandle));
end;

function TDkim.GetDebugLogFilePath: string;
begin
  Result := CkToStr(CkDkim_get_DebugLogFilePath(FHandle));
end;

procedure TDkim.SetDebugLogFilePath(AValue: string);
begin
  CkDkim_put_DebugLogFilePath(FHandle, PAnsiChar(StrToCk(AValue)));
end;

function TDkim.GetVerboseLogging: Boolean;
begin
  Result := Boolean(CkDkim_get_VerboseLogging(FHandle));
end;

procedure TDkim.SetVerboseLogging(AValue: Boolean);
begin
  CkDkim_put_VerboseLogging(FHandle, LongBool(AValue));
end;

function TDkim.GetLastMethodSuccess: Boolean;
begin
  Result := Boolean(CkDkim_get_LastMethodSuccess(FHandle));
end;

procedure TDkim.SetLastMethodSuccess(AValue: Boolean);
begin
  CkDkim_put_LastMethodSuccess(FHandle, LongBool(AValue));
end;

function TDkim.GetDkimAlg: string;
begin
  Result := CkToStr(CkDkim_get_DkimAlg(FHandle));
end;

procedure TDkim.SetDkimAlg(AValue: string);
begin
  CkDkim_put_DkimAlg(FHandle, PAnsiChar(StrToCk(AValue)));
end;

function TDkim.GetDkimBodyLengthCount: Integer;
begin
  Result := CkDkim_get_DkimBodyLengthCount(FHandle);
end;

procedure TDkim.SetDkimBodyLengthCount(AValue: Integer);
begin
  CkDkim_put_DkimBodyLengthCount(FHandle, AValue);
end;

function TDkim.GetDkimCanon: string;
begin
  Result := CkToStr(CkDkim_get_DkimCanon(FHandle));
end;

procedure TDkim.SetDkimCanon(AValue: string);
begin
  CkDkim_put_DkimCanon(FHandle, PAnsiChar(StrToCk(AValue)));
end;

function TDkim.GetDkimDomain: string;
begin
  Result := CkToStr(CkDkim_get_DkimDomain(FHandle));
end;

procedure TDkim.SetDkimDomain(AValue: string);
begin
  CkDkim_put_DkimDomain(FHandle, PAnsiChar(StrToCk(AValue)));
end;

function TDkim.GetDkimHeaders: string;
begin
  Result := CkToStr(CkDkim_get_DkimHeaders(FHandle));
end;

procedure TDkim.SetDkimHeaders(AValue: string);
begin
  CkDkim_put_DkimHeaders(FHandle, PAnsiChar(StrToCk(AValue)));
end;

function TDkim.GetDkimSelector: string;
begin
  Result := CkToStr(CkDkim_get_DkimSelector(FHandle));
end;

procedure TDkim.SetDkimSelector(AValue: string);
begin
  CkDkim_put_DkimSelector(FHandle, PAnsiChar(StrToCk(AValue)));
end;

function TDkim.GetHeartbeatMs: Integer;
begin
  Result := CkDkim_get_HeartbeatMs(FHandle);
end;

procedure TDkim.SetHeartbeatMs(AValue: Integer);
begin
  CkDkim_put_HeartbeatMs(FHandle, AValue);
end;

function TDkim.GetAbortCurrent: Boolean;
begin
  Result := Boolean(CkDkim_get_AbortCurrent(FHandle));
end;

procedure TDkim.SetAbortCurrent(AValue: Boolean);
begin
  CkDkim_put_AbortCurrent(FHandle, LongBool(AValue));
end;

function TDkim.GetVerifyInfo: string;
begin
  Result := CkToStr(CkDkim_get_VerifyInfo(FHandle));
end;

function TDkim.LoadPublicKey(const selector: string; const domain: string; const publicKey: string): Boolean;
begin
  Result := Boolean(CkDkim_LoadPublicKey(FHandle, PAnsiChar(StrToCk(selector)), PAnsiChar(StrToCk(domain)), PAnsiChar(StrToCk(publicKey))));
end;

function TDkim.LoadPublicKeyFile(const selector: string; const domain: string; const publicKeyFilepath: string): Boolean;
begin
  Result := Boolean(CkDkim_LoadPublicKeyFile(FHandle, PAnsiChar(StrToCk(selector)), PAnsiChar(StrToCk(domain)), PAnsiChar(StrToCk(publicKeyFilepath))));
end;

function TDkim.PrefetchPublicKey(const selector: string; const domain: string): Boolean;
begin
  Result := Boolean(CkDkim_PrefetchPublicKey(FHandle, PAnsiChar(StrToCk(selector)), PAnsiChar(StrToCk(domain))));
end;

function TDkim.DkimSign(mimeData: TChilkatBase): Boolean;
begin
  Result := Boolean(CkDkim_DkimSign(FHandle, mimeData.Handle));
end;

function TDkim.SetDkimPrivateKey(privateKey: TChilkatBase): Boolean;
begin
  Result := Boolean(CkDkim_SetDkimPrivateKey(FHandle, privateKey.Handle));
end;

function TDkim.DkimVerify(sigIndex: Integer; mimeData: TChilkatBase): Boolean;
begin
  Result := Boolean(CkDkim_DkimVerify(FHandle, sigIndex, mimeData.Handle));
end;

function TDkim.NumDkimSigs(mimeData: TChilkatBase): Integer;
begin
  Result := CkDkim_NumDkimSigs(FHandle, mimeData.Handle);
end;

initialization
  Chilkat_GetProcedureAddress(CkDkim_Create,  'CkDkim_Create');
  Chilkat_GetProcedureAddress(CkDkim_Dispose, 'CkDkim_Dispose');
  Chilkat_GetProcedureAddress(CkDkim_SetAbortCheckCallback, 'CkDkim_SetAbortCheckCallback');
  Chilkat_GetProcedureAddress(CkDkim_SetPercentDoneCallback, 'CkDkim_SetPercentDoneCallback');
  Chilkat_GetProcedureAddress(CkDkim_SetProgressInfoCallback, 'CkDkim_SetProgressInfoCallback');
  Chilkat_GetProcedureAddress(CkDkim_get_LastErrorHtml, 'CkDkim_get_LastErrorHtml');
  Chilkat_GetProcedureAddress(CkDkim_get_LastErrorText, 'CkDkim_get_LastErrorText');
  Chilkat_GetProcedureAddress(CkDkim_get_LastErrorXml, 'CkDkim_get_LastErrorXml');
  Chilkat_GetProcedureAddress(CkDkim_get_Version, 'CkDkim_get_Version');
  Chilkat_GetProcedureAddress(CkDkim_get_DebugLogFilePath, 'CkDkim_get_DebugLogFilePath');
  Chilkat_GetProcedureAddress(CkDkim_put_DebugLogFilePath, 'CkDkim_put_DebugLogFilePath');
  Chilkat_GetProcedureAddress(CkDkim_get_VerboseLogging, 'CkDkim_get_VerboseLogging');
  Chilkat_GetProcedureAddress(CkDkim_put_VerboseLogging, 'CkDkim_put_VerboseLogging');
  Chilkat_GetProcedureAddress(CkDkim_get_LastMethodSuccess, 'CkDkim_get_LastMethodSuccess');
  Chilkat_GetProcedureAddress(CkDkim_put_LastMethodSuccess, 'CkDkim_put_LastMethodSuccess');
  Chilkat_GetProcedureAddress(CkDkim_get_DkimAlg, 'CkDkim_get_DkimAlg');
  Chilkat_GetProcedureAddress(CkDkim_put_DkimAlg, 'CkDkim_put_DkimAlg');
  Chilkat_GetProcedureAddress(CkDkim_get_DkimBodyLengthCount, 'CkDkim_get_DkimBodyLengthCount');
  Chilkat_GetProcedureAddress(CkDkim_put_DkimBodyLengthCount, 'CkDkim_put_DkimBodyLengthCount');
  Chilkat_GetProcedureAddress(CkDkim_get_DkimCanon, 'CkDkim_get_DkimCanon');
  Chilkat_GetProcedureAddress(CkDkim_put_DkimCanon, 'CkDkim_put_DkimCanon');
  Chilkat_GetProcedureAddress(CkDkim_get_DkimDomain, 'CkDkim_get_DkimDomain');
  Chilkat_GetProcedureAddress(CkDkim_put_DkimDomain, 'CkDkim_put_DkimDomain');
  Chilkat_GetProcedureAddress(CkDkim_get_DkimHeaders, 'CkDkim_get_DkimHeaders');
  Chilkat_GetProcedureAddress(CkDkim_put_DkimHeaders, 'CkDkim_put_DkimHeaders');
  Chilkat_GetProcedureAddress(CkDkim_get_DkimSelector, 'CkDkim_get_DkimSelector');
  Chilkat_GetProcedureAddress(CkDkim_put_DkimSelector, 'CkDkim_put_DkimSelector');
  Chilkat_GetProcedureAddress(CkDkim_get_HeartbeatMs, 'CkDkim_get_HeartbeatMs');
  Chilkat_GetProcedureAddress(CkDkim_put_HeartbeatMs, 'CkDkim_put_HeartbeatMs');
  Chilkat_GetProcedureAddress(CkDkim_get_AbortCurrent, 'CkDkim_get_AbortCurrent');
  Chilkat_GetProcedureAddress(CkDkim_put_AbortCurrent, 'CkDkim_put_AbortCurrent');
  Chilkat_GetProcedureAddress(CkDkim_get_VerifyInfo, 'CkDkim_get_VerifyInfo');
  Chilkat_GetProcedureAddress(CkDkim_LoadPublicKey, 'CkDkim_LoadPublicKey');
  Chilkat_GetProcedureAddress(CkDkim_LoadPublicKeyFile, 'CkDkim_LoadPublicKeyFile');
  Chilkat_GetProcedureAddress(CkDkim_PrefetchPublicKey, 'CkDkim_PrefetchPublicKey');
  Chilkat_GetProcedureAddress(CkDkim_DkimSign, 'CkDkim_DkimSign');
  Chilkat_GetProcedureAddress(CkDkim_SetDkimPrivateKey, 'CkDkim_SetDkimPrivateKey');
  Chilkat_GetProcedureAddress(CkDkim_DkimVerify, 'CkDkim_DkimVerify');
  Chilkat_GetProcedureAddress(CkDkim_NumDkimSigs, 'CkDkim_NumDkimSigs');

end.
