# This file was automatically generated by SWIG (http://www.swig.org).
# Version 3.0.12
#
# Do not make changes to this file unless you know what you are doing--modify
# the SWIG interface file instead.

package chilkat;
use base qw(Exporter);
use base qw(DynaLoader);
package chilkatc;
bootstrap chilkat;
package chilkat;
@EXPORT = qw();

# ---------- BASE METHODS -------------

package chilkat;

sub TIEHASH {
    my ($classname,$obj) = @_;
    return bless $obj, $classname;
}

sub CLEAR { }

sub FIRSTKEY { }

sub NEXTKEY { }

sub FETCH {
    my ($self,$field) = @_;
    my $member_func = "swig_${field}_get";
    $self->$member_func();
}

sub STORE {
    my ($self,$field,$newval) = @_;
    my $member_func = "swig_${field}_set";
    $self->$member_func($newval);
}

sub this {
    my $ptr = shift;
    return tied(%$ptr);
}


# ------- FUNCTION WRAPPERS --------

package chilkat;

*SWIG_FromCharPtrAndSize2 = *chilkatc::SWIG_FromCharPtrAndSize2;

############# Class : chilkat::CkBaseProgress ##############

package chilkat::CkBaseProgress;
use vars qw(@ISA %OWNER %ITERATORS %BLESSEDMEMBERS);
@ISA = qw( chilkat );
%OWNER = ();
%ITERATORS = ();
sub new {
    my $pkg = $_[0];
    my $self = chilkatc::new_CkBaseProgress(@_);
    bless $self, $pkg if defined($self);
}

sub DESTROY {
    return unless $_[0]->isa('HASH');
    my $self = tied(%{$_[0]});
    return unless defined $self;
    delete $ITERATORS{$self};
    if (exists $OWNER{$self}) {
        chilkatc::delete_CkBaseProgress($self);
        delete $OWNER{$self};
    }
}

*AbortCheck = *chilkatc::CkBaseProgress_AbortCheck;
*PercentDone = *chilkatc::CkBaseProgress_PercentDone;
*ProgressInfo = *chilkatc::CkBaseProgress_ProgressInfo;
*TaskCompleted = *chilkatc::CkBaseProgress_TaskCompleted;
*TextData = *chilkatc::CkBaseProgress_TextData;
sub DISOWN {
    my $self = shift;
    chilkatc::disown_CkBaseProgress($self);
    my $ptr = tied(%$self);
    delete $OWNER{$ptr};
}

sub ACQUIRE {
    my $self = shift;
    my $ptr = tied(%$self);
    $OWNER{$ptr} = 1;
}

sub FETCH {
    my ($self,$field) = @_;
    my $member_func = "swig_${field}_get";
    if (not $self->can($member_func)) {
        my $h = chilkatc::swig_get_attr_CkBaseProgress($self);
        return $h->{$field} if $h;
    }
    return $self->$member_func;
}

sub STORE {
    my ($self,$field,$newval) = @_;
    my $member_func = "swig_${field}_set";
    if (not $self->can($member_func)) {
        my $h = chilkatc::swig_get_attr_CkBaseProgress($self);
        return $h->{$field} = $newval if $h;
    }
    return $self->$member_func($newval);
}

############# Class : chilkat::CkSFtpProgress ##############

package chilkat::CkSFtpProgress;
use vars qw(@ISA %OWNER %ITERATORS %BLESSEDMEMBERS);
@ISA = qw( chilkat::CkBaseProgress chilkat );
%OWNER = ();
%ITERATORS = ();
sub new {
    my $pkg = $_[0];
    my $self = chilkatc::new_CkSFtpProgress(@_);
    bless $self, $pkg if defined($self);
}

sub DESTROY {
    return unless $_[0]->isa('HASH');
    my $self = tied(%{$_[0]});
    return unless defined $self;
    delete $ITERATORS{$self};
    if (exists $OWNER{$self}) {
        chilkatc::delete_CkSFtpProgress($self);
        delete $OWNER{$self};
    }
}

*UploadRate = *chilkatc::CkSFtpProgress_UploadRate;
*DownloadRate = *chilkatc::CkSFtpProgress_DownloadRate;
sub DISOWN {
    my $self = shift;
    chilkatc::disown_CkSFtpProgress($self);
    my $ptr = tied(%$self);
    delete $OWNER{$ptr};
}

sub ACQUIRE {
    my $self = shift;
    my $ptr = tied(%$self);
    $OWNER{$ptr} = 1;
}

sub FETCH {
    my ($self,$field) = @_;
    my $member_func = "swig_${field}_get";
    if (not $self->can($member_func)) {
        my $h = chilkatc::swig_get_attr_CkSFtpProgress($self);
        return $h->{$field} if $h;
    }
    return $self->$member_func;
}

sub STORE {
    my ($self,$field,$newval) = @_;
    my $member_func = "swig_${field}_set";
    if (not $self->can($member_func)) {
        my $h = chilkatc::swig_get_attr_CkSFtpProgress($self);
        return $h->{$field} = $newval if $h;
    }
    return $self->$member_func($newval);
}

############# Class : chilkat::CkMailManProgress ##############

package chilkat::CkMailManProgress;
use vars qw(@ISA %OWNER %ITERATORS %BLESSEDMEMBERS);
@ISA = qw( chilkat::CkBaseProgress chilkat );
%OWNER = ();
%ITERATORS = ();
sub new {
    my $pkg = $_[0];
    my $self = chilkatc::new_CkMailManProgress(@_);
    bless $self, $pkg if defined($self);
}

sub DESTROY {
    return unless $_[0]->isa('HASH');
    my $self = tied(%{$_[0]});
    return unless defined $self;
    delete $ITERATORS{$self};
    if (exists $OWNER{$self}) {
        chilkatc::delete_CkMailManProgress($self);
        delete $OWNER{$self};
    }
}

*EmailReceived = *chilkatc::CkMailManProgress_EmailReceived;
sub DISOWN {
    my $self = shift;
    chilkatc::disown_CkMailManProgress($self);
    my $ptr = tied(%$self);
    delete $OWNER{$ptr};
}

sub ACQUIRE {
    my $self = shift;
    my $ptr = tied(%$self);
    $OWNER{$ptr} = 1;
}

sub FETCH {
    my ($self,$field) = @_;
    my $member_func = "swig_${field}_get";
    if (not $self->can($member_func)) {
        my $h = chilkatc::swig_get_attr_CkMailManProgress($self);
        return $h->{$field} if $h;
    }
    return $self->$member_func;
}

sub STORE {
    my ($self,$field,$newval) = @_;
    my $member_func = "swig_${field}_set";
    if (not $self->can($member_func)) {
        my $h = chilkatc::swig_get_attr_CkMailManProgress($self);
        return $h->{$field} = $newval if $h;
    }
    return $self->$member_func($newval);
}

############# Class : chilkat::CkHttpProgress ##############

package chilkat::CkHttpProgress;
use vars qw(@ISA %OWNER %ITERATORS %BLESSEDMEMBERS);
@ISA = qw( chilkat::CkBaseProgress chilkat );
%OWNER = ();
%ITERATORS = ();
sub new {
    my $pkg = $_[0];
    my $self = chilkatc::new_CkHttpProgress(@_);
    bless $self, $pkg if defined($self);
}

sub DESTROY {
    return unless $_[0]->isa('HASH');
    my $self = tied(%{$_[0]});
    return unless defined $self;
    delete $ITERATORS{$self};
    if (exists $OWNER{$self}) {
        chilkatc::delete_CkHttpProgress($self);
        delete $OWNER{$self};
    }
}

*HttpRedirect = *chilkatc::CkHttpProgress_HttpRedirect;
*HttpChunked = *chilkatc::CkHttpProgress_HttpChunked;
*HttpBeginReceive = *chilkatc::CkHttpProgress_HttpBeginReceive;
*HttpEndReceive = *chilkatc::CkHttpProgress_HttpEndReceive;
*HttpBeginSend = *chilkatc::CkHttpProgress_HttpBeginSend;
*HttpEndSend = *chilkatc::CkHttpProgress_HttpEndSend;
*ReceiveRate = *chilkatc::CkHttpProgress_ReceiveRate;
*SendRate = *chilkatc::CkHttpProgress_SendRate;
sub DISOWN {
    my $self = shift;
    chilkatc::disown_CkHttpProgress($self);
    my $ptr = tied(%$self);
    delete $OWNER{$ptr};
}

sub ACQUIRE {
    my $self = shift;
    my $ptr = tied(%$self);
    $OWNER{$ptr} = 1;
}

sub FETCH {
    my ($self,$field) = @_;
    my $member_func = "swig_${field}_get";
    if (not $self->can($member_func)) {
        my $h = chilkatc::swig_get_attr_CkHttpProgress($self);
        return $h->{$field} if $h;
    }
    return $self->$member_func;
}

sub STORE {
    my ($self,$field,$newval) = @_;
    my $member_func = "swig_${field}_set";
    if (not $self->can($member_func)) {
        my $h = chilkatc::swig_get_attr_CkHttpProgress($self);
        return $h->{$field} = $newval if $h;
    }
    return $self->$member_func($newval);
}

############# Class : chilkat::CkFtp2Progress ##############

package chilkat::CkFtp2Progress;
use vars qw(@ISA %OWNER %ITERATORS %BLESSEDMEMBERS);
@ISA = qw( chilkat::CkBaseProgress chilkat );
%OWNER = ();
%ITERATORS = ();
sub new {
    my $pkg = $_[0];
    my $self = chilkatc::new_CkFtp2Progress(@_);
    bless $self, $pkg if defined($self);
}

sub DESTROY {
    return unless $_[0]->isa('HASH');
    my $self = tied(%{$_[0]});
    return unless defined $self;
    delete $ITERATORS{$self};
    if (exists $OWNER{$self}) {
        chilkatc::delete_CkFtp2Progress($self);
        delete $OWNER{$self};
    }
}

*BeginDownloadFile = *chilkatc::CkFtp2Progress_BeginDownloadFile;
*VerifyDownloadDir = *chilkatc::CkFtp2Progress_VerifyDownloadDir;
*BeginUploadFile = *chilkatc::CkFtp2Progress_BeginUploadFile;
*VerifyUploadDir = *chilkatc::CkFtp2Progress_VerifyUploadDir;
*VerifyDeleteDir = *chilkatc::CkFtp2Progress_VerifyDeleteDir;
*VerifyDeleteFile = *chilkatc::CkFtp2Progress_VerifyDeleteFile;
*EndUploadFile = *chilkatc::CkFtp2Progress_EndUploadFile;
*EndDownloadFile = *chilkatc::CkFtp2Progress_EndDownloadFile;
*UploadRate = *chilkatc::CkFtp2Progress_UploadRate;
*DownloadRate = *chilkatc::CkFtp2Progress_DownloadRate;
sub DISOWN {
    my $self = shift;
    chilkatc::disown_CkFtp2Progress($self);
    my $ptr = tied(%$self);
    delete $OWNER{$ptr};
}

sub ACQUIRE {
    my $self = shift;
    my $ptr = tied(%$self);
    $OWNER{$ptr} = 1;
}

sub FETCH {
    my ($self,$field) = @_;
    my $member_func = "swig_${field}_get";
    if (not $self->can($member_func)) {
        my $h = chilkatc::swig_get_attr_CkFtp2Progress($self);
        return $h->{$field} if $h;
    }
    return $self->$member_func;
}

sub STORE {
    my ($self,$field,$newval) = @_;
    my $member_func = "swig_${field}_set";
    if (not $self->can($member_func)) {
        my $h = chilkatc::swig_get_attr_CkFtp2Progress($self);
        return $h->{$field} = $newval if $h;
    }
    return $self->$member_func($newval);
}

############# Class : chilkat::CkZipProgress ##############

package chilkat::CkZipProgress;
use vars qw(@ISA %OWNER %ITERATORS %BLESSEDMEMBERS);
@ISA = qw( chilkat::CkBaseProgress chilkat );
%OWNER = ();
%ITERATORS = ();
sub new {
    my $pkg = $_[0];
    my $self = chilkatc::new_CkZipProgress(@_);
    bless $self, $pkg if defined($self);
}

sub DESTROY {
    return unless $_[0]->isa('HASH');
    my $self = tied(%{$_[0]});
    return unless defined $self;
    delete $ITERATORS{$self};
    if (exists $OWNER{$self}) {
        chilkatc::delete_CkZipProgress($self);
        delete $OWNER{$self};
    }
}

*DirToBeAdded = *chilkatc::CkZipProgress_DirToBeAdded;
*ToBeAdded = *chilkatc::CkZipProgress_ToBeAdded;
*FileAdded = *chilkatc::CkZipProgress_FileAdded;
*ToBeZipped = *chilkatc::CkZipProgress_ToBeZipped;
*FileZipped = *chilkatc::CkZipProgress_FileZipped;
*ToBeUnzipped = *chilkatc::CkZipProgress_ToBeUnzipped;
*FileUnzipped = *chilkatc::CkZipProgress_FileUnzipped;
*SkippedForUnzip = *chilkatc::CkZipProgress_SkippedForUnzip;
*AddFilesBegin = *chilkatc::CkZipProgress_AddFilesBegin;
*AddFilesEnd = *chilkatc::CkZipProgress_AddFilesEnd;
*WriteZipBegin = *chilkatc::CkZipProgress_WriteZipBegin;
*WriteZipEnd = *chilkatc::CkZipProgress_WriteZipEnd;
*UnzipBegin = *chilkatc::CkZipProgress_UnzipBegin;
*UnzipEnd = *chilkatc::CkZipProgress_UnzipEnd;
sub DISOWN {
    my $self = shift;
    chilkatc::disown_CkZipProgress($self);
    my $ptr = tied(%$self);
    delete $OWNER{$ptr};
}

sub ACQUIRE {
    my $self = shift;
    my $ptr = tied(%$self);
    $OWNER{$ptr} = 1;
}

sub FETCH {
    my ($self,$field) = @_;
    my $member_func = "swig_${field}_get";
    if (not $self->can($member_func)) {
        my $h = chilkatc::swig_get_attr_CkZipProgress($self);
        return $h->{$field} if $h;
    }
    return $self->$member_func;
}

sub STORE {
    my ($self,$field,$newval) = @_;
    my $member_func = "swig_${field}_set";
    if (not $self->can($member_func)) {
        my $h = chilkatc::swig_get_attr_CkZipProgress($self);
        return $h->{$field} = $newval if $h;
    }
    return $self->$member_func($newval);
}

############# Class : chilkat::CkTarProgress ##############

package chilkat::CkTarProgress;
use vars qw(@ISA %OWNER %ITERATORS %BLESSEDMEMBERS);
@ISA = qw( chilkat::CkBaseProgress chilkat );
%OWNER = ();
%ITERATORS = ();
sub new {
    my $pkg = $_[0];
    my $self = chilkatc::new_CkTarProgress(@_);
    bless $self, $pkg if defined($self);
}

sub DESTROY {
    return unless $_[0]->isa('HASH');
    my $self = tied(%{$_[0]});
    return unless defined $self;
    delete $ITERATORS{$self};
    if (exists $OWNER{$self}) {
        chilkatc::delete_CkTarProgress($self);
        delete $OWNER{$self};
    }
}

*NextTarFile = *chilkatc::CkTarProgress_NextTarFile;
sub DISOWN {
    my $self = shift;
    chilkatc::disown_CkTarProgress($self);
    my $ptr = tied(%$self);
    delete $OWNER{$ptr};
}

sub ACQUIRE {
    my $self = shift;
    my $ptr = tied(%$self);
    $OWNER{$ptr} = 1;
}

sub FETCH {
    my ($self,$field) = @_;
    my $member_func = "swig_${field}_get";
    if (not $self->can($member_func)) {
        my $h = chilkatc::swig_get_attr_CkTarProgress($self);
        return $h->{$field} if $h;
    }
    return $self->$member_func;
}

sub STORE {
    my ($self,$field,$newval) = @_;
    my $member_func = "swig_${field}_set";
    if (not $self->can($member_func)) {
        my $h = chilkatc::swig_get_attr_CkTarProgress($self);
        return $h->{$field} = $newval if $h;
    }
    return $self->$member_func($newval);
}

############# Class : chilkat::CkString ##############

package chilkat::CkString;
use vars qw(@ISA %OWNER %ITERATORS %BLESSEDMEMBERS);
@ISA = qw( chilkat );
%OWNER = ();
%ITERATORS = ();
sub new {
    my $pkg = shift;
    my $self = chilkatc::new_CkString(@_);
    bless $self, $pkg if defined($self);
}

sub DESTROY {
    return unless $_[0]->isa('HASH');
    my $self = tied(%{$_[0]});
    return unless defined $self;
    delete $ITERATORS{$self};
    if (exists $OWNER{$self}) {
        chilkatc::delete_CkString($self);
        delete $OWNER{$self};
    }
}

*get_Utf8 = *chilkatc::CkString_get_Utf8;
*put_Utf8 = *chilkatc::CkString_put_Utf8;
*get_NumArabic = *chilkatc::CkString_get_NumArabic;
*get_NumAscii = *chilkatc::CkString_get_NumAscii;
*get_NumCentralEuro = *chilkatc::CkString_get_NumCentralEuro;
*get_NumChinese = *chilkatc::CkString_get_NumChinese;
*get_NumCyrillic = *chilkatc::CkString_get_NumCyrillic;
*get_NumGreek = *chilkatc::CkString_get_NumGreek;
*get_NumHebrew = *chilkatc::CkString_get_NumHebrew;
*get_NumJapanese = *chilkatc::CkString_get_NumJapanese;
*get_NumKorean = *chilkatc::CkString_get_NumKorean;
*get_NumLatin = *chilkatc::CkString_get_NumLatin;
*get_NumThai = *chilkatc::CkString_get_NumThai;
*loadFile = *chilkatc::CkString_loadFile;
*charAt = *chilkatc::CkString_charAt;
*intValue = *chilkatc::CkString_intValue;
*doubleValue = *chilkatc::CkString_doubleValue;
*clone = *chilkatc::CkString_clone;
*countCharOccurances = *chilkatc::CkString_countCharOccurances;
*appendCurrentDateRfc822 = *chilkatc::CkString_appendCurrentDateRfc822;
*removeDelimited = *chilkatc::CkString_removeDelimited;
*setStr = *chilkatc::CkString_setStr;
*endsWith = *chilkatc::CkString_endsWith;
*endsWithStr = *chilkatc::CkString_endsWithStr;
*beginsWithStr = *chilkatc::CkString_beginsWithStr;
*indexOf = *chilkatc::CkString_indexOf;
*indexOfStr = *chilkatc::CkString_indexOfStr;
*replaceAll = *chilkatc::CkString_replaceAll;
*replaceFirst = *chilkatc::CkString_replaceFirst;
*substring = *chilkatc::CkString_substring;
*matchesStr = *chilkatc::CkString_matchesStr;
*matches = *chilkatc::CkString_matches;
*getChar = *chilkatc::CkString_getChar;
*removeAll = *chilkatc::CkString_removeAll;
*removeFirst = *chilkatc::CkString_removeFirst;
*chopAtStr = *chilkatc::CkString_chopAtStr;
*urlDecode = *chilkatc::CkString_urlDecode;
*urlEncode = *chilkatc::CkString_urlEncode;
*base64Decode = *chilkatc::CkString_base64Decode;
*base64Encode = *chilkatc::CkString_base64Encode;
*qpDecode = *chilkatc::CkString_qpDecode;
*qpEncode = *chilkatc::CkString_qpEncode;
*hexDecode = *chilkatc::CkString_hexDecode;
*hexEncode = *chilkatc::CkString_hexEncode;
*entityDecode = *chilkatc::CkString_entityDecode;
*entityEncode = *chilkatc::CkString_entityEncode;
*appendUtf8 = *chilkatc::CkString_appendUtf8;
*appendAnsi = *chilkatc::CkString_appendAnsi;
*clear = *chilkatc::CkString_clear;
*prepend = *chilkatc::CkString_prepend;
*appendInt = *chilkatc::CkString_appendInt;
*append = *chilkatc::CkString_append;
*appendChar = *chilkatc::CkString_appendChar;
*appendN = *chilkatc::CkString_appendN;
*appendStr = *chilkatc::CkString_appendStr;
*appendEnc = *chilkatc::CkString_appendEnc;
*getEnc = *chilkatc::CkString_getEnc;
*setString = *chilkatc::CkString_setString;
*setStringAnsi = *chilkatc::CkString_setStringAnsi;
*setStringUtf8 = *chilkatc::CkString_setStringUtf8;
*getAnsi = *chilkatc::CkString_getAnsi;
*getUtf8 = *chilkatc::CkString_getUtf8;
*compareStr = *chilkatc::CkString_compareStr;
*getString = *chilkatc::CkString_getString;
*getSizeUtf8 = *chilkatc::CkString_getSizeUtf8;
*getSizeAnsi = *chilkatc::CkString_getSizeAnsi;
*getNumChars = *chilkatc::CkString_getNumChars;
*trim = *chilkatc::CkString_trim;
*trim2 = *chilkatc::CkString_trim2;
*trimInsideSpaces = *chilkatc::CkString_trimInsideSpaces;
*replaceAllOccurances = *chilkatc::CkString_replaceAllOccurances;
*replaceFirstOccurance = *chilkatc::CkString_replaceFirstOccurance;
*toCRLF = *chilkatc::CkString_toCRLF;
*toLF = *chilkatc::CkString_toLF;
*eliminateChar = *chilkatc::CkString_eliminateChar;
*lastChar = *chilkatc::CkString_lastChar;
*shorten = *chilkatc::CkString_shorten;
*toLowerCase = *chilkatc::CkString_toLowerCase;
*toUpperCase = *chilkatc::CkString_toUpperCase;
*encodeXMLSpecial = *chilkatc::CkString_encodeXMLSpecial;
*decodeXMLSpecial = *chilkatc::CkString_decodeXMLSpecial;
*containsSubstring = *chilkatc::CkString_containsSubstring;
*containsSubstringNoCase = *chilkatc::CkString_containsSubstringNoCase;
*equals = *chilkatc::CkString_equals;
*equalsStr = *chilkatc::CkString_equalsStr;
*equalsIgnoreCase = *chilkatc::CkString_equalsIgnoreCase;
*equalsIgnoreCaseStr = *chilkatc::CkString_equalsIgnoreCaseStr;
*removeChunk = *chilkatc::CkString_removeChunk;
*removeCharOccurances = *chilkatc::CkString_removeCharOccurances;
*replaceChar = *chilkatc::CkString_replaceChar;
*chopAtFirstChar = *chilkatc::CkString_chopAtFirstChar;
*saveToFile = *chilkatc::CkString_saveToFile;
*split = *chilkatc::CkString_split;
*split2 = *chilkatc::CkString_split2;
*tokenize = *chilkatc::CkString_tokenize;
*splitAtWS = *chilkatc::CkString_splitAtWS;
*beginsWith = *chilkatc::CkString_beginsWith;
*appendHexData = *chilkatc::CkString_appendHexData;
sub DISOWN {
    my $self = shift;
    my $ptr = tied(%$self);
    delete $OWNER{$ptr};
}

sub ACQUIRE {
    my $self = shift;
    my $ptr = tied(%$self);
    $OWNER{$ptr} = 1;
}


############# Class : chilkat::CkDateTime ##############

package chilkat::CkDateTime;
use vars qw(@ISA %OWNER %ITERATORS %BLESSEDMEMBERS);
@ISA = qw( chilkat );
%OWNER = ();
%ITERATORS = ();
sub new {
    my $pkg = shift;
    my $self = chilkatc::new_CkDateTime(@_);
    bless $self, $pkg if defined($self);
}

sub DESTROY {
    return unless $_[0]->isa('HASH');
    my $self = tied(%{$_[0]});
    return unless defined $self;
    delete $ITERATORS{$self};
    if (exists $OWNER{$self}) {
        chilkatc::delete_CkDateTime($self);
        delete $OWNER{$self};
    }
}

*get_Utf8 = *chilkatc::CkDateTime_get_Utf8;
*put_Utf8 = *chilkatc::CkDateTime_put_Utf8;
*get_IsDst = *chilkatc::CkDateTime_get_IsDst;
*get_UtcOffset = *chilkatc::CkDateTime_get_UtcOffset;
*SetFromCurrentSystemTime = *chilkatc::CkDateTime_SetFromCurrentSystemTime;
*SetFromRfc822 = *chilkatc::CkDateTime_SetFromRfc822;
*GetAsUnixTime = *chilkatc::CkDateTime_GetAsUnixTime;
*GetAsUnixTime64 = *chilkatc::CkDateTime_GetAsUnixTime64;
*GetAsOleDate = *chilkatc::CkDateTime_GetAsOleDate;
*GetAsDosDate = *chilkatc::CkDateTime_GetAsDosDate;
*GetAsDateTimeTicks = *chilkatc::CkDateTime_GetAsDateTimeTicks;
*SetFromUnixTime = *chilkatc::CkDateTime_SetFromUnixTime;
*SetFromUnixTime64 = *chilkatc::CkDateTime_SetFromUnixTime64;
*SetFromOleDate = *chilkatc::CkDateTime_SetFromOleDate;
*SetFromDosDate = *chilkatc::CkDateTime_SetFromDosDate;
*SetFromDateTimeTicks = *chilkatc::CkDateTime_SetFromDateTimeTicks;
*Serialize = *chilkatc::CkDateTime_Serialize;
*serialize = *chilkatc::CkDateTime_serialize;
*DeSerialize = *chilkatc::CkDateTime_DeSerialize;
*AddDays = *chilkatc::CkDateTime_AddDays;
*GetAsRfc822 = *chilkatc::CkDateTime_GetAsRfc822;
*getAsRfc822 = *chilkatc::CkDateTime_getAsRfc822;
*get_LastMethodSuccess = *chilkatc::CkDateTime_get_LastMethodSuccess;
*put_LastMethodSuccess = *chilkatc::CkDateTime_put_LastMethodSuccess;
*AddSeconds = *chilkatc::CkDateTime_AddSeconds;
*DiffSeconds = *chilkatc::CkDateTime_DiffSeconds;
*GetAsUnixTimeStr = *chilkatc::CkDateTime_GetAsUnixTimeStr;
*GetAsIso8601 = *chilkatc::CkDateTime_GetAsIso8601;
*GetAsTimestamp = *chilkatc::CkDateTime_GetAsTimestamp;
*getAsUnixTimeStr = *chilkatc::CkDateTime_getAsUnixTimeStr;
*getAsIso8601 = *chilkatc::CkDateTime_getAsIso8601;
*getAsTimestamp = *chilkatc::CkDateTime_getAsTimestamp;
*ExpiresWithin = *chilkatc::CkDateTime_ExpiresWithin;
*OlderThan = *chilkatc::CkDateTime_OlderThan;
*GetDtObj = *chilkatc::CkDateTime_GetDtObj;
*SetFromDtObj = *chilkatc::CkDateTime_SetFromDtObj;
*LoadTaskResult = *chilkatc::CkDateTime_LoadTaskResult;
*SetFromNtpTime = *chilkatc::CkDateTime_SetFromNtpTime;
*SetFromTimestamp = *chilkatc::CkDateTime_SetFromTimestamp;
*SetFromNtpServer = *chilkatc::CkDateTime_SetFromNtpServer;
sub DISOWN {
    my $self = shift;
    my $ptr = tied(%$self);
    delete $OWNER{$ptr};
}

sub ACQUIRE {
    my $self = shift;
    my $ptr = tied(%$self);
    $OWNER{$ptr} = 1;
}


############# Class : chilkat::CkDtObj ##############

package chilkat::CkDtObj;
use vars qw(@ISA %OWNER %ITERATORS %BLESSEDMEMBERS);
@ISA = qw( chilkat );
%OWNER = ();
%ITERATORS = ();
sub new {
    my $pkg = shift;
    my $self = chilkatc::new_CkDtObj(@_);
    bless $self, $pkg if defined($self);
}

sub DESTROY {
    return unless $_[0]->isa('HASH');
    my $self = tied(%{$_[0]});
    return unless defined $self;
    delete $ITERATORS{$self};
    if (exists $OWNER{$self}) {
        chilkatc::delete_CkDtObj($self);
        delete $OWNER{$self};
    }
}

*get_Utf8 = *chilkatc::CkDtObj_get_Utf8;
*put_Utf8 = *chilkatc::CkDtObj_put_Utf8;
*get_Utc = *chilkatc::CkDtObj_get_Utc;
*put_Utc = *chilkatc::CkDtObj_put_Utc;
*get_Year = *chilkatc::CkDtObj_get_Year;
*put_Year = *chilkatc::CkDtObj_put_Year;
*get_Month = *chilkatc::CkDtObj_get_Month;
*put_Month = *chilkatc::CkDtObj_put_Month;
*get_Day = *chilkatc::CkDtObj_get_Day;
*put_Day = *chilkatc::CkDtObj_put_Day;
*get_Hour = *chilkatc::CkDtObj_get_Hour;
*put_Hour = *chilkatc::CkDtObj_put_Hour;
*get_Minute = *chilkatc::CkDtObj_get_Minute;
*put_Minute = *chilkatc::CkDtObj_put_Minute;
*get_Second = *chilkatc::CkDtObj_get_Second;
*put_Second = *chilkatc::CkDtObj_put_Second;
*get_StructTmYear = *chilkatc::CkDtObj_get_StructTmYear;
*put_StructTmYear = *chilkatc::CkDtObj_put_StructTmYear;
*get_StructTmMonth = *chilkatc::CkDtObj_get_StructTmMonth;
*put_StructTmMonth = *chilkatc::CkDtObj_put_StructTmMonth;
*Serialize = *chilkatc::CkDtObj_Serialize;
*serialize = *chilkatc::CkDtObj_serialize;
*DeSerialize = *chilkatc::CkDtObj_DeSerialize;
sub DISOWN {
    my $self = shift;
    my $ptr = tied(%$self);
    delete $OWNER{$ptr};
}

sub ACQUIRE {
    my $self = shift;
    my $ptr = tied(%$self);
    $OWNER{$ptr} = 1;
}


############# Class : chilkat::CkByteData ##############

package chilkat::CkByteData;
use vars qw(@ISA %OWNER %ITERATORS %BLESSEDMEMBERS);
@ISA = qw( chilkat );
%OWNER = ();
%ITERATORS = ();
sub new {
    my $pkg = shift;
    my $self = chilkatc::new_CkByteData(@_);
    bless $self, $pkg if defined($self);
}

sub DESTROY {
    return unless $_[0]->isa('HASH');
    my $self = tied(%{$_[0]});
    return unless defined $self;
    delete $ITERATORS{$self};
    if (exists $OWNER{$self}) {
        chilkatc::delete_CkByteData($self);
        delete $OWNER{$self};
    }
}

*get_Utf8 = *chilkatc::CkByteData_get_Utf8;
*put_Utf8 = *chilkatc::CkByteData_put_Utf8;
*to_s = *chilkatc::CkByteData_to_s;
*appendRandom = *chilkatc::CkByteData_appendRandom;
*appendInt = *chilkatc::CkByteData_appendInt;
*appendShort = *chilkatc::CkByteData_appendShort;
*getEncodedRange = *chilkatc::CkByteData_getEncodedRange;
*appendRange = *chilkatc::CkByteData_appendRange;
*ensureBuffer = *chilkatc::CkByteData_ensureBuffer;
*findBytes2 = *chilkatc::CkByteData_findBytes2;
*findBytes = *chilkatc::CkByteData_findBytes;
*beginsWith2 = *chilkatc::CkByteData_beginsWith2;
*beginsWith = *chilkatc::CkByteData_beginsWith;
*removeChunk = *chilkatc::CkByteData_removeChunk;
*byteSwap4321 = *chilkatc::CkByteData_byteSwap4321;
*pad = *chilkatc::CkByteData_pad;
*unpad = *chilkatc::CkByteData_unpad;
*is7bit = *chilkatc::CkByteData_is7bit;
*clear = *chilkatc::CkByteData_clear;
*getSize = *chilkatc::CkByteData_getSize;
*appendEncoded = *chilkatc::CkByteData_appendEncoded;
*encode = *chilkatc::CkByteData_encode;
*getData = *chilkatc::CkByteData_getData;
*getBytes = *chilkatc::CkByteData_getBytes;
*getEncoded = *chilkatc::CkByteData_getEncoded;
*getRange = *chilkatc::CkByteData_getRange;
*getRangeStr = *chilkatc::CkByteData_getRangeStr;
*append2 = *chilkatc::CkByteData_append2;
*equals2 = *chilkatc::CkByteData_equals2;
*equals = *chilkatc::CkByteData_equals;
*appendStr = *chilkatc::CkByteData_appendStr;
*appendChar = *chilkatc::CkByteData_appendChar;
*getByte = *chilkatc::CkByteData_getByte;
*getChar = *chilkatc::CkByteData_getChar;
*getUInt = *chilkatc::CkByteData_getUInt;
*getInt = *chilkatc::CkByteData_getInt;
*getUShort = *chilkatc::CkByteData_getUShort;
*getShort = *chilkatc::CkByteData_getShort;
*loadFile = *chilkatc::CkByteData_loadFile;
*saveFile = *chilkatc::CkByteData_saveFile;
*appendFile = *chilkatc::CkByteData_appendFile;
*shorten = *chilkatc::CkByteData_shorten;
sub DISOWN {
    my $self = shift;
    my $ptr = tied(%$self);
    delete $OWNER{$ptr};
}

sub ACQUIRE {
    my $self = shift;
    my $ptr = tied(%$self);
    $OWNER{$ptr} = 1;
}


############# Class : chilkat::CkAi ##############

package chilkat::CkAi;
use vars qw(@ISA %OWNER %ITERATORS %BLESSEDMEMBERS);
@ISA = qw( chilkat );
%OWNER = ();
%ITERATORS = ();
sub new {
    my $pkg = shift;
    my $self = chilkatc::new_CkAi(@_);
    bless $self, $pkg if defined($self);
}

sub DESTROY {
    return unless $_[0]->isa('HASH');
    my $self = tied(%{$_[0]});
    return unless defined $self;
    delete $ITERATORS{$self};
    if (exists $OWNER{$self}) {
        chilkatc::delete_CkAi($self);
        delete $OWNER{$self};
    }
}

*get_Utf8 = *chilkatc::CkAi_get_Utf8;
*put_Utf8 = *chilkatc::CkAi_put_Utf8;
*LastErrorXml = *chilkatc::CkAi_LastErrorXml;
*LastErrorHtml = *chilkatc::CkAi_LastErrorHtml;
*LastErrorText = *chilkatc::CkAi_LastErrorText;
*put_EventCallbackObject = *chilkatc::CkAi_put_EventCallbackObject;
*get_ApiKey = *chilkatc::CkAi_get_ApiKey;
*apiKey = *chilkatc::CkAi_apiKey;
*put_ApiKey = *chilkatc::CkAi_put_ApiKey;
*get_ApiKeyHeader = *chilkatc::CkAi_get_ApiKeyHeader;
*apiKeyHeader = *chilkatc::CkAi_apiKeyHeader;
*put_ApiKeyHeader = *chilkatc::CkAi_put_ApiKeyHeader;
*get_ApiSpec = *chilkatc::CkAi_get_ApiSpec;
*apiSpec = *chilkatc::CkAi_apiSpec;
*put_ApiSpec = *chilkatc::CkAi_put_ApiSpec;
*get_BaseUrl = *chilkatc::CkAi_get_BaseUrl;
*baseUrl = *chilkatc::CkAi_baseUrl;
*put_BaseUrl = *chilkatc::CkAi_put_BaseUrl;
*get_DebugLogFilePath = *chilkatc::CkAi_get_DebugLogFilePath;
*debugLogFilePath = *chilkatc::CkAi_debugLogFilePath;
*put_DebugLogFilePath = *chilkatc::CkAi_put_DebugLogFilePath;
*get_FullTranscript = *chilkatc::CkAi_get_FullTranscript;
*put_FullTranscript = *chilkatc::CkAi_put_FullTranscript;
*get_HeartbeatMs = *chilkatc::CkAi_get_HeartbeatMs;
*put_HeartbeatMs = *chilkatc::CkAi_put_HeartbeatMs;
*get_HostedConvo = *chilkatc::CkAi_get_HostedConvo;
*put_HostedConvo = *chilkatc::CkAi_put_HostedConvo;
*get_IdleTimeoutMs = *chilkatc::CkAi_get_IdleTimeoutMs;
*put_IdleTimeoutMs = *chilkatc::CkAi_put_IdleTimeoutMs;
*get_LastErrorHtml = *chilkatc::CkAi_get_LastErrorHtml;
*lastErrorHtml = *chilkatc::CkAi_lastErrorHtml;
*get_LastErrorText = *chilkatc::CkAi_get_LastErrorText;
*lastErrorText = *chilkatc::CkAi_lastErrorText;
*get_LastErrorXml = *chilkatc::CkAi_get_LastErrorXml;
*lastErrorXml = *chilkatc::CkAi_lastErrorXml;
*get_LastMethodSuccess = *chilkatc::CkAi_get_LastMethodSuccess;
*put_LastMethodSuccess = *chilkatc::CkAi_put_LastMethodSuccess;
*get_Model = *chilkatc::CkAi_get_Model;
*model = *chilkatc::CkAi_model;
*put_Model = *chilkatc::CkAi_put_Model;
*get_Provider = *chilkatc::CkAi_get_Provider;
*provider = *chilkatc::CkAi_provider;
*put_Provider = *chilkatc::CkAi_put_Provider;
*get_ResponseStatusCode = *chilkatc::CkAi_get_ResponseStatusCode;
*get_SelectedConvo = *chilkatc::CkAi_get_SelectedConvo;
*selectedConvo = *chilkatc::CkAi_selectedConvo;
*put_SelectedConvo = *chilkatc::CkAi_put_SelectedConvo;
*get_Streaming = *chilkatc::CkAi_get_Streaming;
*put_Streaming = *chilkatc::CkAi_put_Streaming;
*get_UncommonOptions = *chilkatc::CkAi_get_UncommonOptions;
*uncommonOptions = *chilkatc::CkAi_uncommonOptions;
*put_UncommonOptions = *chilkatc::CkAi_put_UncommonOptions;
*get_VerboseLogging = *chilkatc::CkAi_get_VerboseLogging;
*put_VerboseLogging = *chilkatc::CkAi_put_VerboseLogging;
*get_Version = *chilkatc::CkAi_get_Version;
*version = *chilkatc::CkAi_version;
*Ask = *chilkatc::CkAi_Ask;
*AskAsync = *chilkatc::CkAi_AskAsync;
*DeleteConvo = *chilkatc::CkAi_DeleteConvo;
*ExportConvo = *chilkatc::CkAi_ExportConvo;
*GetLastJsonData = *chilkatc::CkAi_GetLastJsonData;
*GetModels = *chilkatc::CkAi_GetModels;
*GetModelsAsync = *chilkatc::CkAi_GetModelsAsync;
*GetOutputText = *chilkatc::CkAi_GetOutputText;
*getOutputText = *chilkatc::CkAi_getOutputText;
*outputText = *chilkatc::CkAi_outputText;
*GetOutputTextSb = *chilkatc::CkAi_GetOutputTextSb;
*ImportConvo = *chilkatc::CkAi_ImportConvo;
*InputAddFileData = *chilkatc::CkAi_InputAddFileData;
*InputAddFileUrl = *chilkatc::CkAi_InputAddFileUrl;
*InputAddImageData = *chilkatc::CkAi_InputAddImageData;
*InputAddImageUrl = *chilkatc::CkAi_InputAddImageUrl;
*InputAddText = *chilkatc::CkAi_InputAddText;
*InputAddTextSb = *chilkatc::CkAi_InputAddTextSb;
*InputClear = *chilkatc::CkAi_InputClear;
*ListConvos = *chilkatc::CkAi_ListConvos;
*NewConvo = *chilkatc::CkAi_NewConvo;
*NextAiEvent = *chilkatc::CkAi_NextAiEvent;
*PollAi = *chilkatc::CkAi_PollAi;
*SetAskParams = *chilkatc::CkAi_SetAskParams;
*SetConnectionSettings = *chilkatc::CkAi_SetConnectionSettings;
*SetProviderParams = *chilkatc::CkAi_SetProviderParams;
*SleepMs = *chilkatc::CkAi_SleepMs;
sub DISOWN {
    my $self = shift;
    my $ptr = tied(%$self);
    delete $OWNER{$ptr};
}

sub ACQUIRE {
    my $self = shift;
    my $ptr = tied(%$self);
    $OWNER{$ptr} = 1;
}


############# Class : chilkat::CkAsn ##############

package chilkat::CkAsn;
use vars qw(@ISA %OWNER %ITERATORS %BLESSEDMEMBERS);
@ISA = qw( chilkat );
%OWNER = ();
%ITERATORS = ();
sub new {
    my $pkg = shift;
    my $self = chilkatc::new_CkAsn(@_);
    bless $self, $pkg if defined($self);
}

sub DESTROY {
    return unless $_[0]->isa('HASH');
    my $self = tied(%{$_[0]});
    return unless defined $self;
    delete $ITERATORS{$self};
    if (exists $OWNER{$self}) {
        chilkatc::delete_CkAsn($self);
        delete $OWNER{$self};
    }
}

*get_Utf8 = *chilkatc::CkAsn_get_Utf8;
*put_Utf8 = *chilkatc::CkAsn_put_Utf8;
*LastErrorXml = *chilkatc::CkAsn_LastErrorXml;
*LastErrorHtml = *chilkatc::CkAsn_LastErrorHtml;
*LastErrorText = *chilkatc::CkAsn_LastErrorText;
*get_BoolValue = *chilkatc::CkAsn_get_BoolValue;
*put_BoolValue = *chilkatc::CkAsn_put_BoolValue;
*get_Constructed = *chilkatc::CkAsn_get_Constructed;
*get_ContentStr = *chilkatc::CkAsn_get_ContentStr;
*contentStr = *chilkatc::CkAsn_contentStr;
*put_ContentStr = *chilkatc::CkAsn_put_ContentStr;
*get_DebugLogFilePath = *chilkatc::CkAsn_get_DebugLogFilePath;
*debugLogFilePath = *chilkatc::CkAsn_debugLogFilePath;
*put_DebugLogFilePath = *chilkatc::CkAsn_put_DebugLogFilePath;
*get_IntValue = *chilkatc::CkAsn_get_IntValue;
*put_IntValue = *chilkatc::CkAsn_put_IntValue;
*get_LastErrorHtml = *chilkatc::CkAsn_get_LastErrorHtml;
*lastErrorHtml = *chilkatc::CkAsn_lastErrorHtml;
*get_LastErrorText = *chilkatc::CkAsn_get_LastErrorText;
*lastErrorText = *chilkatc::CkAsn_lastErrorText;
*get_LastErrorXml = *chilkatc::CkAsn_get_LastErrorXml;
*lastErrorXml = *chilkatc::CkAsn_lastErrorXml;
*get_LastMethodSuccess = *chilkatc::CkAsn_get_LastMethodSuccess;
*put_LastMethodSuccess = *chilkatc::CkAsn_put_LastMethodSuccess;
*get_NumSubItems = *chilkatc::CkAsn_get_NumSubItems;
*get_Tag = *chilkatc::CkAsn_get_Tag;
*tag = *chilkatc::CkAsn_tag;
*get_TagValue = *chilkatc::CkAsn_get_TagValue;
*get_VerboseLogging = *chilkatc::CkAsn_get_VerboseLogging;
*put_VerboseLogging = *chilkatc::CkAsn_put_VerboseLogging;
*get_Version = *chilkatc::CkAsn_get_Version;
*version = *chilkatc::CkAsn_version;
*AppendBigInt = *chilkatc::CkAsn_AppendBigInt;
*AppendBits = *chilkatc::CkAsn_AppendBits;
*AppendBool = *chilkatc::CkAsn_AppendBool;
*AppendContextConstructed = *chilkatc::CkAsn_AppendContextConstructed;
*AppendContextPrimitive = *chilkatc::CkAsn_AppendContextPrimitive;
*AppendInt = *chilkatc::CkAsn_AppendInt;
*AppendNull = *chilkatc::CkAsn_AppendNull;
*AppendOctets = *chilkatc::CkAsn_AppendOctets;
*AppendOid = *chilkatc::CkAsn_AppendOid;
*AppendSequence = *chilkatc::CkAsn_AppendSequence;
*AppendSequence2 = *chilkatc::CkAsn_AppendSequence2;
*AppendSequenceR = *chilkatc::CkAsn_AppendSequenceR;
*AppendSet = *chilkatc::CkAsn_AppendSet;
*AppendSet2 = *chilkatc::CkAsn_AppendSet2;
*AppendSetR = *chilkatc::CkAsn_AppendSetR;
*AppendString = *chilkatc::CkAsn_AppendString;
*AppendTime = *chilkatc::CkAsn_AppendTime;
*AsnToXml = *chilkatc::CkAsn_AsnToXml;
*asnToXml = *chilkatc::CkAsn_asnToXml;
*DeleteSubItem = *chilkatc::CkAsn_DeleteSubItem;
*GetBinaryDer = *chilkatc::CkAsn_GetBinaryDer;
*GetEncodedContent = *chilkatc::CkAsn_GetEncodedContent;
*getEncodedContent = *chilkatc::CkAsn_getEncodedContent;
*encodedContent = *chilkatc::CkAsn_encodedContent;
*GetEncodedDer = *chilkatc::CkAsn_GetEncodedDer;
*getEncodedDer = *chilkatc::CkAsn_getEncodedDer;
*encodedDer = *chilkatc::CkAsn_encodedDer;
*GetLastSubItem = *chilkatc::CkAsn_GetLastSubItem;
*GetSubItem = *chilkatc::CkAsn_GetSubItem;
*LoadAsnXml = *chilkatc::CkAsn_LoadAsnXml;
*LoadBd = *chilkatc::CkAsn_LoadBd;
*LoadBinary = *chilkatc::CkAsn_LoadBinary;
*LoadBinaryFile = *chilkatc::CkAsn_LoadBinaryFile;
*LoadEncoded = *chilkatc::CkAsn_LoadEncoded;
*SetEncodedContent = *chilkatc::CkAsn_SetEncodedContent;
*WriteBd = *chilkatc::CkAsn_WriteBd;
*WriteBinaryDer = *chilkatc::CkAsn_WriteBinaryDer;
sub DISOWN {
    my $self = shift;
    my $ptr = tied(%$self);
    delete $OWNER{$ptr};
}

sub ACQUIRE {
    my $self = shift;
    my $ptr = tied(%$self);
    $OWNER{$ptr} = 1;
}


############# Class : chilkat::CkAuthAws ##############

package chilkat::CkAuthAws;
use vars qw(@ISA %OWNER %ITERATORS %BLESSEDMEMBERS);
@ISA = qw( chilkat );
%OWNER = ();
%ITERATORS = ();
sub new {
    my $pkg = shift;
    my $self = chilkatc::new_CkAuthAws(@_);
    bless $self, $pkg if defined($self);
}

sub DESTROY {
    return unless $_[0]->isa('HASH');
    my $self = tied(%{$_[0]});
    return unless defined $self;
    delete $ITERATORS{$self};
    if (exists $OWNER{$self}) {
        chilkatc::delete_CkAuthAws($self);
        delete $OWNER{$self};
    }
}

*get_Utf8 = *chilkatc::CkAuthAws_get_Utf8;
*put_Utf8 = *chilkatc::CkAuthAws_put_Utf8;
*LastErrorXml = *chilkatc::CkAuthAws_LastErrorXml;
*LastErrorHtml = *chilkatc::CkAuthAws_LastErrorHtml;
*LastErrorText = *chilkatc::CkAuthAws_LastErrorText;
*get_AccessKey = *chilkatc::CkAuthAws_get_AccessKey;
*accessKey = *chilkatc::CkAuthAws_accessKey;
*put_AccessKey = *chilkatc::CkAuthAws_put_AccessKey;
*get_CanonicalizedResourceV2 = *chilkatc::CkAuthAws_get_CanonicalizedResourceV2;
*canonicalizedResourceV2 = *chilkatc::CkAuthAws_canonicalizedResourceV2;
*put_CanonicalizedResourceV2 = *chilkatc::CkAuthAws_put_CanonicalizedResourceV2;
*get_DebugLogFilePath = *chilkatc::CkAuthAws_get_DebugLogFilePath;
*debugLogFilePath = *chilkatc::CkAuthAws_debugLogFilePath;
*put_DebugLogFilePath = *chilkatc::CkAuthAws_put_DebugLogFilePath;
*get_LastErrorHtml = *chilkatc::CkAuthAws_get_LastErrorHtml;
*lastErrorHtml = *chilkatc::CkAuthAws_lastErrorHtml;
*get_LastErrorText = *chilkatc::CkAuthAws_get_LastErrorText;
*lastErrorText = *chilkatc::CkAuthAws_lastErrorText;
*get_LastErrorXml = *chilkatc::CkAuthAws_get_LastErrorXml;
*lastErrorXml = *chilkatc::CkAuthAws_lastErrorXml;
*get_LastMethodSuccess = *chilkatc::CkAuthAws_get_LastMethodSuccess;
*put_LastMethodSuccess = *chilkatc::CkAuthAws_put_LastMethodSuccess;
*get_PrecomputedMd5 = *chilkatc::CkAuthAws_get_PrecomputedMd5;
*precomputedMd5 = *chilkatc::CkAuthAws_precomputedMd5;
*put_PrecomputedMd5 = *chilkatc::CkAuthAws_put_PrecomputedMd5;
*get_PrecomputedSha256 = *chilkatc::CkAuthAws_get_PrecomputedSha256;
*precomputedSha256 = *chilkatc::CkAuthAws_precomputedSha256;
*put_PrecomputedSha256 = *chilkatc::CkAuthAws_put_PrecomputedSha256;
*get_Region = *chilkatc::CkAuthAws_get_Region;
*region = *chilkatc::CkAuthAws_region;
*put_Region = *chilkatc::CkAuthAws_put_Region;
*get_SecretKey = *chilkatc::CkAuthAws_get_SecretKey;
*secretKey = *chilkatc::CkAuthAws_secretKey;
*put_SecretKey = *chilkatc::CkAuthAws_put_SecretKey;
*get_ServiceName = *chilkatc::CkAuthAws_get_ServiceName;
*serviceName = *chilkatc::CkAuthAws_serviceName;
*put_ServiceName = *chilkatc::CkAuthAws_put_ServiceName;
*get_SignatureVersion = *chilkatc::CkAuthAws_get_SignatureVersion;
*put_SignatureVersion = *chilkatc::CkAuthAws_put_SignatureVersion;
*get_VerboseLogging = *chilkatc::CkAuthAws_get_VerboseLogging;
*put_VerboseLogging = *chilkatc::CkAuthAws_put_VerboseLogging;
*get_Version = *chilkatc::CkAuthAws_get_Version;
*version = *chilkatc::CkAuthAws_version;
*GenPresignedUrl = *chilkatc::CkAuthAws_GenPresignedUrl;
*genPresignedUrl = *chilkatc::CkAuthAws_genPresignedUrl;
sub DISOWN {
    my $self = shift;
    my $ptr = tied(%$self);
    delete $OWNER{$ptr};
}

sub ACQUIRE {
    my $self = shift;
    my $ptr = tied(%$self);
    $OWNER{$ptr} = 1;
}


############# Class : chilkat::CkAuthAzureSAS ##############

package chilkat::CkAuthAzureSAS;
use vars qw(@ISA %OWNER %ITERATORS %BLESSEDMEMBERS);
@ISA = qw( chilkat );
%OWNER = ();
%ITERATORS = ();
sub new {
    my $pkg = shift;
    my $self = chilkatc::new_CkAuthAzureSAS(@_);
    bless $self, $pkg if defined($self);
}

sub DESTROY {
    return unless $_[0]->isa('HASH');
    my $self = tied(%{$_[0]});
    return unless defined $self;
    delete $ITERATORS{$self};
    if (exists $OWNER{$self}) {
        chilkatc::delete_CkAuthAzureSAS($self);
        delete $OWNER{$self};
    }
}

*get_Utf8 = *chilkatc::CkAuthAzureSAS_get_Utf8;
*put_Utf8 = *chilkatc::CkAuthAzureSAS_put_Utf8;
*LastErrorXml = *chilkatc::CkAuthAzureSAS_LastErrorXml;
*LastErrorHtml = *chilkatc::CkAuthAzureSAS_LastErrorHtml;
*LastErrorText = *chilkatc::CkAuthAzureSAS_LastErrorText;
*get_AccessKey = *chilkatc::CkAuthAzureSAS_get_AccessKey;
*accessKey = *chilkatc::CkAuthAzureSAS_accessKey;
*put_AccessKey = *chilkatc::CkAuthAzureSAS_put_AccessKey;
*get_DebugLogFilePath = *chilkatc::CkAuthAzureSAS_get_DebugLogFilePath;
*debugLogFilePath = *chilkatc::CkAuthAzureSAS_debugLogFilePath;
*put_DebugLogFilePath = *chilkatc::CkAuthAzureSAS_put_DebugLogFilePath;
*get_LastErrorHtml = *chilkatc::CkAuthAzureSAS_get_LastErrorHtml;
*lastErrorHtml = *chilkatc::CkAuthAzureSAS_lastErrorHtml;
*get_LastErrorText = *chilkatc::CkAuthAzureSAS_get_LastErrorText;
*lastErrorText = *chilkatc::CkAuthAzureSAS_lastErrorText;
*get_LastErrorXml = *chilkatc::CkAuthAzureSAS_get_LastErrorXml;
*lastErrorXml = *chilkatc::CkAuthAzureSAS_lastErrorXml;
*get_LastMethodSuccess = *chilkatc::CkAuthAzureSAS_get_LastMethodSuccess;
*put_LastMethodSuccess = *chilkatc::CkAuthAzureSAS_put_LastMethodSuccess;
*get_StringToSign = *chilkatc::CkAuthAzureSAS_get_StringToSign;
*stringToSign = *chilkatc::CkAuthAzureSAS_stringToSign;
*put_StringToSign = *chilkatc::CkAuthAzureSAS_put_StringToSign;
*get_VerboseLogging = *chilkatc::CkAuthAzureSAS_get_VerboseLogging;
*put_VerboseLogging = *chilkatc::CkAuthAzureSAS_put_VerboseLogging;
*get_Version = *chilkatc::CkAuthAzureSAS_get_Version;
*version = *chilkatc::CkAuthAzureSAS_version;
*Clear = *chilkatc::CkAuthAzureSAS_Clear;
*GenerateToken = *chilkatc::CkAuthAzureSAS_GenerateToken;
*generateToken = *chilkatc::CkAuthAzureSAS_generateToken;
*SetNonTokenParam = *chilkatc::CkAuthAzureSAS_SetNonTokenParam;
*SetTokenParam = *chilkatc::CkAuthAzureSAS_SetTokenParam;
sub DISOWN {
    my $self = shift;
    my $ptr = tied(%$self);
    delete $OWNER{$ptr};
}

sub ACQUIRE {
    my $self = shift;
    my $ptr = tied(%$self);
    $OWNER{$ptr} = 1;
}


############# Class : chilkat::CkAuthAzureStorage ##############

package chilkat::CkAuthAzureStorage;
use vars qw(@ISA %OWNER %ITERATORS %BLESSEDMEMBERS);
@ISA = qw( chilkat );
%OWNER = ();
%ITERATORS = ();
sub new {
    my $pkg = shift;
    my $self = chilkatc::new_CkAuthAzureStorage(@_);
    bless $self, $pkg if defined($self);
}

sub DESTROY {
    return unless $_[0]->isa('HASH');
    my $self = tied(%{$_[0]});
    return unless defined $self;
    delete $ITERATORS{$self};
    if (exists $OWNER{$self}) {
        chilkatc::delete_CkAuthAzureStorage($self);
        delete $OWNER{$self};
    }
}

*get_Utf8 = *chilkatc::CkAuthAzureStorage_get_Utf8;
*put_Utf8 = *chilkatc::CkAuthAzureStorage_put_Utf8;
*LastErrorXml = *chilkatc::CkAuthAzureStorage_LastErrorXml;
*LastErrorHtml = *chilkatc::CkAuthAzureStorage_LastErrorHtml;
*LastErrorText = *chilkatc::CkAuthAzureStorage_LastErrorText;
*get_AccessKey = *chilkatc::CkAuthAzureStorage_get_AccessKey;
*accessKey = *chilkatc::CkAuthAzureStorage_accessKey;
*put_AccessKey = *chilkatc::CkAuthAzureStorage_put_AccessKey;
*get_Account = *chilkatc::CkAuthAzureStorage_get_Account;
*account = *chilkatc::CkAuthAzureStorage_account;
*put_Account = *chilkatc::CkAuthAzureStorage_put_Account;
*get_DebugLogFilePath = *chilkatc::CkAuthAzureStorage_get_DebugLogFilePath;
*debugLogFilePath = *chilkatc::CkAuthAzureStorage_debugLogFilePath;
*put_DebugLogFilePath = *chilkatc::CkAuthAzureStorage_put_DebugLogFilePath;
*get_LastErrorHtml = *chilkatc::CkAuthAzureStorage_get_LastErrorHtml;
*lastErrorHtml = *chilkatc::CkAuthAzureStorage_lastErrorHtml;
*get_LastErrorText = *chilkatc::CkAuthAzureStorage_get_LastErrorText;
*lastErrorText = *chilkatc::CkAuthAzureStorage_lastErrorText;
*get_LastErrorXml = *chilkatc::CkAuthAzureStorage_get_LastErrorXml;
*lastErrorXml = *chilkatc::CkAuthAzureStorage_lastErrorXml;
*get_LastMethodSuccess = *chilkatc::CkAuthAzureStorage_get_LastMethodSuccess;
*put_LastMethodSuccess = *chilkatc::CkAuthAzureStorage_put_LastMethodSuccess;
*get_Scheme = *chilkatc::CkAuthAzureStorage_get_Scheme;
*scheme = *chilkatc::CkAuthAzureStorage_scheme;
*put_Scheme = *chilkatc::CkAuthAzureStorage_put_Scheme;
*get_Service = *chilkatc::CkAuthAzureStorage_get_Service;
*service = *chilkatc::CkAuthAzureStorage_service;
*put_Service = *chilkatc::CkAuthAzureStorage_put_Service;
*get_VerboseLogging = *chilkatc::CkAuthAzureStorage_get_VerboseLogging;
*put_VerboseLogging = *chilkatc::CkAuthAzureStorage_put_VerboseLogging;
*get_Version = *chilkatc::CkAuthAzureStorage_get_Version;
*version = *chilkatc::CkAuthAzureStorage_version;
*get_XMsVersion = *chilkatc::CkAuthAzureStorage_get_XMsVersion;
*xMsVersion = *chilkatc::CkAuthAzureStorage_xMsVersion;
*put_XMsVersion = *chilkatc::CkAuthAzureStorage_put_XMsVersion;
*Noop = *chilkatc::CkAuthAzureStorage_Noop;
sub DISOWN {
    my $self = shift;
    my $ptr = tied(%$self);
    delete $OWNER{$ptr};
}

sub ACQUIRE {
    my $self = shift;
    my $ptr = tied(%$self);
    $OWNER{$ptr} = 1;
}


############# Class : chilkat::CkAuthGoogle ##############

package chilkat::CkAuthGoogle;
use vars qw(@ISA %OWNER %ITERATORS %BLESSEDMEMBERS);
@ISA = qw( chilkat );
%OWNER = ();
%ITERATORS = ();
sub new {
    my $pkg = shift;
    my $self = chilkatc::new_CkAuthGoogle(@_);
    bless $self, $pkg if defined($self);
}

sub DESTROY {
    return unless $_[0]->isa('HASH');
    my $self = tied(%{$_[0]});
    return unless defined $self;
    delete $ITERATORS{$self};
    if (exists $OWNER{$self}) {
        chilkatc::delete_CkAuthGoogle($self);
        delete $OWNER{$self};
    }
}

*get_Utf8 = *chilkatc::CkAuthGoogle_get_Utf8;
*put_Utf8 = *chilkatc::CkAuthGoogle_put_Utf8;
*LastErrorXml = *chilkatc::CkAuthGoogle_LastErrorXml;
*LastErrorHtml = *chilkatc::CkAuthGoogle_LastErrorHtml;
*LastErrorText = *chilkatc::CkAuthGoogle_LastErrorText;
*put_EventCallbackObject = *chilkatc::CkAuthGoogle_put_EventCallbackObject;
*get_AccessToken = *chilkatc::CkAuthGoogle_get_AccessToken;
*accessToken = *chilkatc::CkAuthGoogle_accessToken;
*put_AccessToken = *chilkatc::CkAuthGoogle_put_AccessToken;
*get_DebugLogFilePath = *chilkatc::CkAuthGoogle_get_DebugLogFilePath;
*debugLogFilePath = *chilkatc::CkAuthGoogle_debugLogFilePath;
*put_DebugLogFilePath = *chilkatc::CkAuthGoogle_put_DebugLogFilePath;
*get_EmailAddress = *chilkatc::CkAuthGoogle_get_EmailAddress;
*emailAddress = *chilkatc::CkAuthGoogle_emailAddress;
*put_EmailAddress = *chilkatc::CkAuthGoogle_put_EmailAddress;
*get_ExpireNumSeconds = *chilkatc::CkAuthGoogle_get_ExpireNumSeconds;
*put_ExpireNumSeconds = *chilkatc::CkAuthGoogle_put_ExpireNumSeconds;
*get_Iat = *chilkatc::CkAuthGoogle_get_Iat;
*put_Iat = *chilkatc::CkAuthGoogle_put_Iat;
*get_JsonKey = *chilkatc::CkAuthGoogle_get_JsonKey;
*jsonKey = *chilkatc::CkAuthGoogle_jsonKey;
*put_JsonKey = *chilkatc::CkAuthGoogle_put_JsonKey;
*get_LastErrorHtml = *chilkatc::CkAuthGoogle_get_LastErrorHtml;
*lastErrorHtml = *chilkatc::CkAuthGoogle_lastErrorHtml;
*get_LastErrorText = *chilkatc::CkAuthGoogle_get_LastErrorText;
*lastErrorText = *chilkatc::CkAuthGoogle_lastErrorText;
*get_LastErrorXml = *chilkatc::CkAuthGoogle_get_LastErrorXml;
*lastErrorXml = *chilkatc::CkAuthGoogle_lastErrorXml;
*get_LastMethodSuccess = *chilkatc::CkAuthGoogle_get_LastMethodSuccess;
*put_LastMethodSuccess = *chilkatc::CkAuthGoogle_put_LastMethodSuccess;
*get_NumSecondsRemaining = *chilkatc::CkAuthGoogle_get_NumSecondsRemaining;
*get_Scope = *chilkatc::CkAuthGoogle_get_Scope;
*scope = *chilkatc::CkAuthGoogle_scope;
*put_Scope = *chilkatc::CkAuthGoogle_put_Scope;
*get_SubEmailAddress = *chilkatc::CkAuthGoogle_get_SubEmailAddress;
*subEmailAddress = *chilkatc::CkAuthGoogle_subEmailAddress;
*put_SubEmailAddress = *chilkatc::CkAuthGoogle_put_SubEmailAddress;
*get_Valid = *chilkatc::CkAuthGoogle_get_Valid;
*get_VerboseLogging = *chilkatc::CkAuthGoogle_get_VerboseLogging;
*put_VerboseLogging = *chilkatc::CkAuthGoogle_put_VerboseLogging;
*get_Version = *chilkatc::CkAuthGoogle_get_Version;
*version = *chilkatc::CkAuthGoogle_version;
*AddClaims = *chilkatc::CkAuthGoogle_AddClaims;
*GetP12 = *chilkatc::CkAuthGoogle_GetP12;
*LoadTaskCaller = *chilkatc::CkAuthGoogle_LoadTaskCaller;
*ObtainAccessToken = *chilkatc::CkAuthGoogle_ObtainAccessToken;
*ObtainAccessTokenAsync = *chilkatc::CkAuthGoogle_ObtainAccessTokenAsync;
*SetP12 = *chilkatc::CkAuthGoogle_SetP12;
sub DISOWN {
    my $self = shift;
    my $ptr = tied(%$self);
    delete $OWNER{$ptr};
}

sub ACQUIRE {
    my $self = shift;
    my $ptr = tied(%$self);
    $OWNER{$ptr} = 1;
}


############# Class : chilkat::CkBinData ##############

package chilkat::CkBinData;
use vars qw(@ISA %OWNER %ITERATORS %BLESSEDMEMBERS);
@ISA = qw( chilkat );
%OWNER = ();
%ITERATORS = ();
sub new {
    my $pkg = shift;
    my $self = chilkatc::new_CkBinData(@_);
    bless $self, $pkg if defined($self);
}

sub DESTROY {
    return unless $_[0]->isa('HASH');
    my $self = tied(%{$_[0]});
    return unless defined $self;
    delete $ITERATORS{$self};
    if (exists $OWNER{$self}) {
        chilkatc::delete_CkBinData($self);
        delete $OWNER{$self};
    }
}

*get_Utf8 = *chilkatc::CkBinData_get_Utf8;
*put_Utf8 = *chilkatc::CkBinData_put_Utf8;
*LastErrorXml = *chilkatc::CkBinData_LastErrorXml;
*LastErrorHtml = *chilkatc::CkBinData_LastErrorHtml;
*LastErrorText = *chilkatc::CkBinData_LastErrorText;
*get_DebugLogFilePath = *chilkatc::CkBinData_get_DebugLogFilePath;
*debugLogFilePath = *chilkatc::CkBinData_debugLogFilePath;
*put_DebugLogFilePath = *chilkatc::CkBinData_put_DebugLogFilePath;
*get_LastErrorHtml = *chilkatc::CkBinData_get_LastErrorHtml;
*lastErrorHtml = *chilkatc::CkBinData_lastErrorHtml;
*get_LastErrorText = *chilkatc::CkBinData_get_LastErrorText;
*lastErrorText = *chilkatc::CkBinData_lastErrorText;
*get_LastErrorXml = *chilkatc::CkBinData_get_LastErrorXml;
*lastErrorXml = *chilkatc::CkBinData_lastErrorXml;
*get_LastMethodSuccess = *chilkatc::CkBinData_get_LastMethodSuccess;
*put_LastMethodSuccess = *chilkatc::CkBinData_put_LastMethodSuccess;
*get_NumBytes = *chilkatc::CkBinData_get_NumBytes;
*get_VerboseLogging = *chilkatc::CkBinData_get_VerboseLogging;
*put_VerboseLogging = *chilkatc::CkBinData_put_VerboseLogging;
*get_Version = *chilkatc::CkBinData_get_Version;
*version = *chilkatc::CkBinData_version;
*AppendBd = *chilkatc::CkBinData_AppendBd;
*AppendBinary = *chilkatc::CkBinData_AppendBinary;
*AppendBom = *chilkatc::CkBinData_AppendBom;
*AppendByte = *chilkatc::CkBinData_AppendByte;
*AppendCountedString = *chilkatc::CkBinData_AppendCountedString;
*AppendData = *chilkatc::CkBinData_AppendData;
*AppendEncoded = *chilkatc::CkBinData_AppendEncoded;
*AppendEncodedSb = *chilkatc::CkBinData_AppendEncodedSb;
*AppendInt2 = *chilkatc::CkBinData_AppendInt2;
*AppendInt4 = *chilkatc::CkBinData_AppendInt4;
*AppendPadded = *chilkatc::CkBinData_AppendPadded;
*AppendSb = *chilkatc::CkBinData_AppendSb;
*AppendString = *chilkatc::CkBinData_AppendString;
*ByteSwap = *chilkatc::CkBinData_ByteSwap;
*CharsetConvert = *chilkatc::CkBinData_CharsetConvert;
*Clear = *chilkatc::CkBinData_Clear;
*ContentsEqual = *chilkatc::CkBinData_ContentsEqual;
*FindString = *chilkatc::CkBinData_FindString;
*GetBinary = *chilkatc::CkBinData_GetBinary;
*GetBinaryChunk = *chilkatc::CkBinData_GetBinaryChunk;
*GetByte = *chilkatc::CkBinData_GetByte;
*GetData = *chilkatc::CkBinData_GetData;
*GetDataChunk = *chilkatc::CkBinData_GetDataChunk;
*GetEncoded = *chilkatc::CkBinData_GetEncoded;
*getEncoded = *chilkatc::CkBinData_getEncoded;
*encoded = *chilkatc::CkBinData_encoded;
*GetEncodedChunk = *chilkatc::CkBinData_GetEncodedChunk;
*getEncodedChunk = *chilkatc::CkBinData_getEncodedChunk;
*encodedChunk = *chilkatc::CkBinData_encodedChunk;
*GetEncodedSb = *chilkatc::CkBinData_GetEncodedSb;
*GetHash = *chilkatc::CkBinData_GetHash;
*getHash = *chilkatc::CkBinData_getHash;
*hash = *chilkatc::CkBinData_hash;
*GetInt2 = *chilkatc::CkBinData_GetInt2;
*GetInt4 = *chilkatc::CkBinData_GetInt4;
*GetString = *chilkatc::CkBinData_GetString;
*getString = *chilkatc::CkBinData_getString;
*string = *chilkatc::CkBinData_string;
*GetTextChunk = *chilkatc::CkBinData_GetTextChunk;
*getTextChunk = *chilkatc::CkBinData_getTextChunk;
*textChunk = *chilkatc::CkBinData_textChunk;
*GetUInt2 = *chilkatc::CkBinData_GetUInt2;
*GetUInt4 = *chilkatc::CkBinData_GetUInt4;
*IsValidUtf8 = *chilkatc::CkBinData_IsValidUtf8;
*LoadBinary = *chilkatc::CkBinData_LoadBinary;
*LoadEncoded = *chilkatc::CkBinData_LoadEncoded;
*LoadFile = *chilkatc::CkBinData_LoadFile;
*RemoveByteVal = *chilkatc::CkBinData_RemoveByteVal;
*RemoveChunk = *chilkatc::CkBinData_RemoveChunk;
*SecureClear = *chilkatc::CkBinData_SecureClear;
*WriteAppendFile = *chilkatc::CkBinData_WriteAppendFile;
*WriteFile = *chilkatc::CkBinData_WriteFile;
sub DISOWN {
    my $self = shift;
    my $ptr = tied(%$self);
    delete $OWNER{$ptr};
}

sub ACQUIRE {
    my $self = shift;
    my $ptr = tied(%$self);
    $OWNER{$ptr} = 1;
}


############# Class : chilkat::CkBz2 ##############

package chilkat::CkBz2;
use vars qw(@ISA %OWNER %ITERATORS %BLESSEDMEMBERS);
@ISA = qw( chilkat );
%OWNER = ();
%ITERATORS = ();
sub new {
    my $pkg = shift;
    my $self = chilkatc::new_CkBz2(@_);
    bless $self, $pkg if defined($self);
}

sub DESTROY {
    return unless $_[0]->isa('HASH');
    my $self = tied(%{$_[0]});
    return unless defined $self;
    delete $ITERATORS{$self};
    if (exists $OWNER{$self}) {
        chilkatc::delete_CkBz2($self);
        delete $OWNER{$self};
    }
}

*get_Utf8 = *chilkatc::CkBz2_get_Utf8;
*put_Utf8 = *chilkatc::CkBz2_put_Utf8;
*LastErrorXml = *chilkatc::CkBz2_LastErrorXml;
*LastErrorHtml = *chilkatc::CkBz2_LastErrorHtml;
*LastErrorText = *chilkatc::CkBz2_LastErrorText;
*put_EventCallbackObject = *chilkatc::CkBz2_put_EventCallbackObject;
*get_AbortCurrent = *chilkatc::CkBz2_get_AbortCurrent;
*put_AbortCurrent = *chilkatc::CkBz2_put_AbortCurrent;
*get_DebugLogFilePath = *chilkatc::CkBz2_get_DebugLogFilePath;
*debugLogFilePath = *chilkatc::CkBz2_debugLogFilePath;
*put_DebugLogFilePath = *chilkatc::CkBz2_put_DebugLogFilePath;
*get_HeartbeatMs = *chilkatc::CkBz2_get_HeartbeatMs;
*put_HeartbeatMs = *chilkatc::CkBz2_put_HeartbeatMs;
*get_LastErrorHtml = *chilkatc::CkBz2_get_LastErrorHtml;
*lastErrorHtml = *chilkatc::CkBz2_lastErrorHtml;
*get_LastErrorText = *chilkatc::CkBz2_get_LastErrorText;
*lastErrorText = *chilkatc::CkBz2_lastErrorText;
*get_LastErrorXml = *chilkatc::CkBz2_get_LastErrorXml;
*lastErrorXml = *chilkatc::CkBz2_lastErrorXml;
*get_LastMethodSuccess = *chilkatc::CkBz2_get_LastMethodSuccess;
*put_LastMethodSuccess = *chilkatc::CkBz2_put_LastMethodSuccess;
*get_VerboseLogging = *chilkatc::CkBz2_get_VerboseLogging;
*put_VerboseLogging = *chilkatc::CkBz2_put_VerboseLogging;
*get_Version = *chilkatc::CkBz2_get_Version;
*version = *chilkatc::CkBz2_version;
*CompressBd = *chilkatc::CkBz2_CompressBd;
*CompressBdAsync = *chilkatc::CkBz2_CompressBdAsync;
*CompressFile = *chilkatc::CkBz2_CompressFile;
*CompressFileAsync = *chilkatc::CkBz2_CompressFileAsync;
*CompressFileToMem = *chilkatc::CkBz2_CompressFileToMem;
*CompressFileToMemAsync = *chilkatc::CkBz2_CompressFileToMemAsync;
*CompressMemory = *chilkatc::CkBz2_CompressMemory;
*CompressMemoryAsync = *chilkatc::CkBz2_CompressMemoryAsync;
*CompressMemToFile = *chilkatc::CkBz2_CompressMemToFile;
*CompressMemToFileAsync = *chilkatc::CkBz2_CompressMemToFileAsync;
*LoadTaskCaller = *chilkatc::CkBz2_LoadTaskCaller;
*UncompressBd = *chilkatc::CkBz2_UncompressBd;
*UncompressBdAsync = *chilkatc::CkBz2_UncompressBdAsync;
*UncompressFile = *chilkatc::CkBz2_UncompressFile;
*UncompressFileAsync = *chilkatc::CkBz2_UncompressFileAsync;
*UncompressFileToMem = *chilkatc::CkBz2_UncompressFileToMem;
*UncompressFileToMemAsync = *chilkatc::CkBz2_UncompressFileToMemAsync;
*UncompressMemory = *chilkatc::CkBz2_UncompressMemory;
*UncompressMemoryAsync = *chilkatc::CkBz2_UncompressMemoryAsync;
*UncompressMemToFile = *chilkatc::CkBz2_UncompressMemToFile;
*UncompressMemToFileAsync = *chilkatc::CkBz2_UncompressMemToFileAsync;
sub DISOWN {
    my $self = shift;
    my $ptr = tied(%$self);
    delete $OWNER{$ptr};
}

sub ACQUIRE {
    my $self = shift;
    my $ptr = tied(%$self);
    $OWNER{$ptr} = 1;
}


############# Class : chilkat::CkCache ##############

package chilkat::CkCache;
use vars qw(@ISA %OWNER %ITERATORS %BLESSEDMEMBERS);
@ISA = qw( chilkat );
%OWNER = ();
%ITERATORS = ();
sub new {
    my $pkg = shift;
    my $self = chilkatc::new_CkCache(@_);
    bless $self, $pkg if defined($self);
}

sub DESTROY {
    return unless $_[0]->isa('HASH');
    my $self = tied(%{$_[0]});
    return unless defined $self;
    delete $ITERATORS{$self};
    if (exists $OWNER{$self}) {
        chilkatc::delete_CkCache($self);
        delete $OWNER{$self};
    }
}

*get_Utf8 = *chilkatc::CkCache_get_Utf8;
*put_Utf8 = *chilkatc::CkCache_put_Utf8;
*LastErrorXml = *chilkatc::CkCache_LastErrorXml;
*LastErrorHtml = *chilkatc::CkCache_LastErrorHtml;
*LastErrorText = *chilkatc::CkCache_LastErrorText;
*get_DebugLogFilePath = *chilkatc::CkCache_get_DebugLogFilePath;
*debugLogFilePath = *chilkatc::CkCache_debugLogFilePath;
*put_DebugLogFilePath = *chilkatc::CkCache_put_DebugLogFilePath;
*get_LastErrorHtml = *chilkatc::CkCache_get_LastErrorHtml;
*lastErrorHtml = *chilkatc::CkCache_lastErrorHtml;
*get_LastErrorText = *chilkatc::CkCache_get_LastErrorText;
*lastErrorText = *chilkatc::CkCache_lastErrorText;
*get_LastErrorXml = *chilkatc::CkCache_get_LastErrorXml;
*lastErrorXml = *chilkatc::CkCache_lastErrorXml;
*get_LastEtagFetched = *chilkatc::CkCache_get_LastEtagFetched;
*lastEtagFetched = *chilkatc::CkCache_lastEtagFetched;
*get_LastExpirationFetchedStr = *chilkatc::CkCache_get_LastExpirationFetchedStr;
*lastExpirationFetchedStr = *chilkatc::CkCache_lastExpirationFetchedStr;
*get_LastHitExpired = *chilkatc::CkCache_get_LastHitExpired;
*get_LastKeyFetched = *chilkatc::CkCache_get_LastKeyFetched;
*lastKeyFetched = *chilkatc::CkCache_lastKeyFetched;
*get_LastMethodSuccess = *chilkatc::CkCache_get_LastMethodSuccess;
*put_LastMethodSuccess = *chilkatc::CkCache_put_LastMethodSuccess;
*get_Level = *chilkatc::CkCache_get_Level;
*put_Level = *chilkatc::CkCache_put_Level;
*get_NumRoots = *chilkatc::CkCache_get_NumRoots;
*get_VerboseLogging = *chilkatc::CkCache_get_VerboseLogging;
*put_VerboseLogging = *chilkatc::CkCache_put_VerboseLogging;
*get_Version = *chilkatc::CkCache_get_Version;
*version = *chilkatc::CkCache_version;
*AddRoot = *chilkatc::CkCache_AddRoot;
*DeleteAll = *chilkatc::CkCache_DeleteAll;
*DeleteAllExpired = *chilkatc::CkCache_DeleteAllExpired;
*DeleteFromCache = *chilkatc::CkCache_DeleteFromCache;
*DeleteOlderDt = *chilkatc::CkCache_DeleteOlderDt;
*DeleteOlderStr = *chilkatc::CkCache_DeleteOlderStr;
*FetchBd = *chilkatc::CkCache_FetchBd;
*FetchFromCache = *chilkatc::CkCache_FetchFromCache;
*FetchSb = *chilkatc::CkCache_FetchSb;
*FetchText = *chilkatc::CkCache_FetchText;
*fetchText = *chilkatc::CkCache_fetchText;
*GetEtag = *chilkatc::CkCache_GetEtag;
*getEtag = *chilkatc::CkCache_getEtag;
*etag = *chilkatc::CkCache_etag;
*GetExpirationDt = *chilkatc::CkCache_GetExpirationDt;
*GetExpirationStr = *chilkatc::CkCache_GetExpirationStr;
*getExpirationStr = *chilkatc::CkCache_getExpirationStr;
*expirationStr = *chilkatc::CkCache_expirationStr;
*GetFilename = *chilkatc::CkCache_GetFilename;
*getFilename = *chilkatc::CkCache_getFilename;
*filename = *chilkatc::CkCache_filename;
*GetRoot = *chilkatc::CkCache_GetRoot;
*getRoot = *chilkatc::CkCache_getRoot;
*root = *chilkatc::CkCache_root;
*IsCached = *chilkatc::CkCache_IsCached;
*SaveBd = *chilkatc::CkCache_SaveBd;
*SaveTextDt = *chilkatc::CkCache_SaveTextDt;
*SaveTextNoExpire = *chilkatc::CkCache_SaveTextNoExpire;
*SaveTextStr = *chilkatc::CkCache_SaveTextStr;
*SaveToCacheDt = *chilkatc::CkCache_SaveToCacheDt;
*SaveToCacheNoExpire = *chilkatc::CkCache_SaveToCacheNoExpire;
*SaveToCacheStr = *chilkatc::CkCache_SaveToCacheStr;
*UpdateExpirationDt = *chilkatc::CkCache_UpdateExpirationDt;
*UpdateExpirationStr = *chilkatc::CkCache_UpdateExpirationStr;
sub DISOWN {
    my $self = shift;
    my $ptr = tied(%$self);
    delete $OWNER{$ptr};
}

sub ACQUIRE {
    my $self = shift;
    my $ptr = tied(%$self);
    $OWNER{$ptr} = 1;
}


############# Class : chilkat::CkCert ##############

package chilkat::CkCert;
use vars qw(@ISA %OWNER %ITERATORS %BLESSEDMEMBERS);
@ISA = qw( chilkat );
%OWNER = ();
%ITERATORS = ();
sub new {
    my $pkg = shift;
    my $self = chilkatc::new_CkCert(@_);
    bless $self, $pkg if defined($self);
}

sub DESTROY {
    return unless $_[0]->isa('HASH');
    my $self = tied(%{$_[0]});
    return unless defined $self;
    delete $ITERATORS{$self};
    if (exists $OWNER{$self}) {
        chilkatc::delete_CkCert($self);
        delete $OWNER{$self};
    }
}

*get_Utf8 = *chilkatc::CkCert_get_Utf8;
*put_Utf8 = *chilkatc::CkCert_put_Utf8;
*LastErrorXml = *chilkatc::CkCert_LastErrorXml;
*LastErrorHtml = *chilkatc::CkCert_LastErrorHtml;
*LastErrorText = *chilkatc::CkCert_LastErrorText;
*put_EventCallbackObject = *chilkatc::CkCert_put_EventCallbackObject;
*get_AuthorityKeyId = *chilkatc::CkCert_get_AuthorityKeyId;
*authorityKeyId = *chilkatc::CkCert_authorityKeyId;
*get_AvoidWindowsPkAccess = *chilkatc::CkCert_get_AvoidWindowsPkAccess;
*put_AvoidWindowsPkAccess = *chilkatc::CkCert_put_AvoidWindowsPkAccess;
*get_CertVersion = *chilkatc::CkCert_get_CertVersion;
*get_DebugLogFilePath = *chilkatc::CkCert_get_DebugLogFilePath;
*debugLogFilePath = *chilkatc::CkCert_debugLogFilePath;
*put_DebugLogFilePath = *chilkatc::CkCert_put_DebugLogFilePath;
*get_Expired = *chilkatc::CkCert_get_Expired;
*get_ExtendedKeyUsage = *chilkatc::CkCert_get_ExtendedKeyUsage;
*extendedKeyUsage = *chilkatc::CkCert_extendedKeyUsage;
*get_ForClientAuthentication = *chilkatc::CkCert_get_ForClientAuthentication;
*get_ForCodeSigning = *chilkatc::CkCert_get_ForCodeSigning;
*get_ForSecureEmail = *chilkatc::CkCert_get_ForSecureEmail;
*get_ForServerAuthentication = *chilkatc::CkCert_get_ForServerAuthentication;
*get_ForTimeStamping = *chilkatc::CkCert_get_ForTimeStamping;
*get_IntendedKeyUsage = *chilkatc::CkCert_get_IntendedKeyUsage;
*get_IsRoot = *chilkatc::CkCert_get_IsRoot;
*get_IssuerC = *chilkatc::CkCert_get_IssuerC;
*issuerC = *chilkatc::CkCert_issuerC;
*get_IssuerCN = *chilkatc::CkCert_get_IssuerCN;
*issuerCN = *chilkatc::CkCert_issuerCN;
*get_IssuerDN = *chilkatc::CkCert_get_IssuerDN;
*issuerDN = *chilkatc::CkCert_issuerDN;
*get_IssuerE = *chilkatc::CkCert_get_IssuerE;
*issuerE = *chilkatc::CkCert_issuerE;
*get_IssuerL = *chilkatc::CkCert_get_IssuerL;
*issuerL = *chilkatc::CkCert_issuerL;
*get_IssuerO = *chilkatc::CkCert_get_IssuerO;
*issuerO = *chilkatc::CkCert_issuerO;
*get_IssuerOU = *chilkatc::CkCert_get_IssuerOU;
*issuerOU = *chilkatc::CkCert_issuerOU;
*get_IssuerS = *chilkatc::CkCert_get_IssuerS;
*issuerS = *chilkatc::CkCert_issuerS;
*get_LastErrorHtml = *chilkatc::CkCert_get_LastErrorHtml;
*lastErrorHtml = *chilkatc::CkCert_lastErrorHtml;
*get_LastErrorText = *chilkatc::CkCert_get_LastErrorText;
*lastErrorText = *chilkatc::CkCert_lastErrorText;
*get_LastErrorXml = *chilkatc::CkCert_get_LastErrorXml;
*lastErrorXml = *chilkatc::CkCert_lastErrorXml;
*get_LastMethodSuccess = *chilkatc::CkCert_get_LastMethodSuccess;
*put_LastMethodSuccess = *chilkatc::CkCert_put_LastMethodSuccess;
*get_OcspUrl = *chilkatc::CkCert_get_OcspUrl;
*ocspUrl = *chilkatc::CkCert_ocspUrl;
*get_PrivateKeyExportable = *chilkatc::CkCert_get_PrivateKeyExportable;
*get_Revoked = *chilkatc::CkCert_get_Revoked;
*get_Rfc822Name = *chilkatc::CkCert_get_Rfc822Name;
*rfc822Name = *chilkatc::CkCert_rfc822Name;
*get_SelfSigned = *chilkatc::CkCert_get_SelfSigned;
*get_SerialDecimal = *chilkatc::CkCert_get_SerialDecimal;
*serialDecimal = *chilkatc::CkCert_serialDecimal;
*get_SerialNumber = *chilkatc::CkCert_get_SerialNumber;
*serialNumber = *chilkatc::CkCert_serialNumber;
*get_Sha1Thumbprint = *chilkatc::CkCert_get_Sha1Thumbprint;
*sha1Thumbprint = *chilkatc::CkCert_sha1Thumbprint;
*get_SignatureVerified = *chilkatc::CkCert_get_SignatureVerified;
*get_SmartCardFailReason = *chilkatc::CkCert_get_SmartCardFailReason;
*get_SmartCardNoDialog = *chilkatc::CkCert_get_SmartCardNoDialog;
*put_SmartCardNoDialog = *chilkatc::CkCert_put_SmartCardNoDialog;
*get_SmartCardPin = *chilkatc::CkCert_get_SmartCardPin;
*smartCardPin = *chilkatc::CkCert_smartCardPin;
*put_SmartCardPin = *chilkatc::CkCert_put_SmartCardPin;
*get_SubjectAlternativeName = *chilkatc::CkCert_get_SubjectAlternativeName;
*subjectAlternativeName = *chilkatc::CkCert_subjectAlternativeName;
*get_SubjectC = *chilkatc::CkCert_get_SubjectC;
*subjectC = *chilkatc::CkCert_subjectC;
*get_SubjectCN = *chilkatc::CkCert_get_SubjectCN;
*subjectCN = *chilkatc::CkCert_subjectCN;
*get_SubjectDN = *chilkatc::CkCert_get_SubjectDN;
*subjectDN = *chilkatc::CkCert_subjectDN;
*get_SubjectE = *chilkatc::CkCert_get_SubjectE;
*subjectE = *chilkatc::CkCert_subjectE;
*get_SubjectKeyId = *chilkatc::CkCert_get_SubjectKeyId;
*subjectKeyId = *chilkatc::CkCert_subjectKeyId;
*get_SubjectL = *chilkatc::CkCert_get_SubjectL;
*subjectL = *chilkatc::CkCert_subjectL;
*get_SubjectO = *chilkatc::CkCert_get_SubjectO;
*subjectO = *chilkatc::CkCert_subjectO;
*get_SubjectOU = *chilkatc::CkCert_get_SubjectOU;
*subjectOU = *chilkatc::CkCert_subjectOU;
*get_SubjectS = *chilkatc::CkCert_get_SubjectS;
*subjectS = *chilkatc::CkCert_subjectS;
*get_TrustedRoot = *chilkatc::CkCert_get_TrustedRoot;
*get_UncommonOptions = *chilkatc::CkCert_get_UncommonOptions;
*uncommonOptions = *chilkatc::CkCert_uncommonOptions;
*put_UncommonOptions = *chilkatc::CkCert_put_UncommonOptions;
*get_ValidFromStr = *chilkatc::CkCert_get_ValidFromStr;
*validFromStr = *chilkatc::CkCert_validFromStr;
*get_ValidToStr = *chilkatc::CkCert_get_ValidToStr;
*validToStr = *chilkatc::CkCert_validToStr;
*get_VerboseLogging = *chilkatc::CkCert_get_VerboseLogging;
*put_VerboseLogging = *chilkatc::CkCert_put_VerboseLogging;
*get_Version = *chilkatc::CkCert_get_Version;
*version = *chilkatc::CkCert_version;
*BuildCertChain = *chilkatc::CkCert_BuildCertChain;
*CheckRevoked = *chilkatc::CkCert_CheckRevoked;
*CheckSmartCardPin = *chilkatc::CkCert_CheckSmartCardPin;
*ExportCertDer = *chilkatc::CkCert_ExportCertDer;
*ExportCertDerBd = *chilkatc::CkCert_ExportCertDerBd;
*ExportCertDerFile = *chilkatc::CkCert_ExportCertDerFile;
*ExportCertPem = *chilkatc::CkCert_ExportCertPem;
*exportCertPem = *chilkatc::CkCert_exportCertPem;
*ExportCertPemFile = *chilkatc::CkCert_ExportCertPemFile;
*ExportCertXml = *chilkatc::CkCert_ExportCertXml;
*exportCertXml = *chilkatc::CkCert_exportCertXml;
*ExportPrivateKey = *chilkatc::CkCert_ExportPrivateKey;
*ExportPublicKey = *chilkatc::CkCert_ExportPublicKey;
*ExportToPfxBd = *chilkatc::CkCert_ExportToPfxBd;
*ExportToPfxData = *chilkatc::CkCert_ExportToPfxData;
*ExportToPfxFile = *chilkatc::CkCert_ExportToPfxFile;
*FindIssuer = *chilkatc::CkCert_FindIssuer;
*GetCertChain = *chilkatc::CkCert_GetCertChain;
*GetEncoded = *chilkatc::CkCert_GetEncoded;
*getEncoded = *chilkatc::CkCert_getEncoded;
*encoded = *chilkatc::CkCert_encoded;
*GetExtensionAsText = *chilkatc::CkCert_GetExtensionAsText;
*getExtensionAsText = *chilkatc::CkCert_getExtensionAsText;
*extensionAsText = *chilkatc::CkCert_extensionAsText;
*GetExtensionAsXml = *chilkatc::CkCert_GetExtensionAsXml;
*getExtensionAsXml = *chilkatc::CkCert_getExtensionAsXml;
*extensionAsXml = *chilkatc::CkCert_extensionAsXml;
*GetExtensionBd = *chilkatc::CkCert_GetExtensionBd;
*GetIssuer = *chilkatc::CkCert_GetIssuer;
*GetPrivateKey = *chilkatc::CkCert_GetPrivateKey;
*GetPrivateKeyPem = *chilkatc::CkCert_GetPrivateKeyPem;
*getPrivateKeyPem = *chilkatc::CkCert_getPrivateKeyPem;
*privateKeyPem = *chilkatc::CkCert_privateKeyPem;
*GetPubKeyDer = *chilkatc::CkCert_GetPubKeyDer;
*GetPublicKey = *chilkatc::CkCert_GetPublicKey;
*GetSignature = *chilkatc::CkCert_GetSignature;
*GetSpkiFingerprint = *chilkatc::CkCert_GetSpkiFingerprint;
*getSpkiFingerprint = *chilkatc::CkCert_getSpkiFingerprint;
*spkiFingerprint = *chilkatc::CkCert_spkiFingerprint;
*GetSubjectPart = *chilkatc::CkCert_GetSubjectPart;
*getSubjectPart = *chilkatc::CkCert_getSubjectPart;
*subjectPart = *chilkatc::CkCert_subjectPart;
*GetValidFromDt = *chilkatc::CkCert_GetValidFromDt;
*GetValidToDt = *chilkatc::CkCert_GetValidToDt;
*HashOf = *chilkatc::CkCert_HashOf;
*hashOf = *chilkatc::CkCert_hashOf;
*HasPrivateKey = *chilkatc::CkCert_HasPrivateKey;
*IsEcdsa = *chilkatc::CkCert_IsEcdsa;
*IsRsa = *chilkatc::CkCert_IsRsa;
*LinkPkcs11 = *chilkatc::CkCert_LinkPkcs11;
*LoadByCommonName = *chilkatc::CkCert_LoadByCommonName;
*LoadByEmailAddress = *chilkatc::CkCert_LoadByEmailAddress;
*LoadByIssuerAndSerialNumber = *chilkatc::CkCert_LoadByIssuerAndSerialNumber;
*LoadBySubjectOid = *chilkatc::CkCert_LoadBySubjectOid;
*LoadByThumbprint = *chilkatc::CkCert_LoadByThumbprint;
*LoadFromBase64 = *chilkatc::CkCert_LoadFromBase64;
*LoadFromBd = *chilkatc::CkCert_LoadFromBd;
*LoadFromBinary = *chilkatc::CkCert_LoadFromBinary;
*LoadFromFile = *chilkatc::CkCert_LoadFromFile;
*LoadFromSmartcard = *chilkatc::CkCert_LoadFromSmartcard;
*LoadPem = *chilkatc::CkCert_LoadPem;
*LoadPfxBd = *chilkatc::CkCert_LoadPfxBd;
*LoadPfxData = *chilkatc::CkCert_LoadPfxData;
*LoadPfxFile = *chilkatc::CkCert_LoadPfxFile;
*LoadTaskResult = *chilkatc::CkCert_LoadTaskResult;
*PemFileToDerFile = *chilkatc::CkCert_PemFileToDerFile;
*SaveToFile = *chilkatc::CkCert_SaveToFile;
*SetCloudSigner = *chilkatc::CkCert_SetCloudSigner;
*SetCloudSignerAsync = *chilkatc::CkCert_SetCloudSignerAsync;
*SetFromEncoded = *chilkatc::CkCert_SetFromEncoded;
*SetPrivateKey = *chilkatc::CkCert_SetPrivateKey;
*SetPrivateKeyPem = *chilkatc::CkCert_SetPrivateKeyPem;
*Unload = *chilkatc::CkCert_Unload;
*UploadToCloud = *chilkatc::CkCert_UploadToCloud;
*UploadToCloudAsync = *chilkatc::CkCert_UploadToCloudAsync;
*UseCertVault = *chilkatc::CkCert_UseCertVault;
*VerifySignature = *chilkatc::CkCert_VerifySignature;
*X509PKIPathv1 = *chilkatc::CkCert_X509PKIPathv1;
*x509PKIPathv1 = *chilkatc::CkCert_x509PKIPathv1;
sub DISOWN {
    my $self = shift;
    my $ptr = tied(%$self);
    delete $OWNER{$ptr};
}

sub ACQUIRE {
    my $self = shift;
    my $ptr = tied(%$self);
    $OWNER{$ptr} = 1;
}


############# Class : chilkat::CkCertChain ##############

package chilkat::CkCertChain;
use vars qw(@ISA %OWNER %ITERATORS %BLESSEDMEMBERS);
@ISA = qw( chilkat );
%OWNER = ();
%ITERATORS = ();
sub new {
    my $pkg = shift;
    my $self = chilkatc::new_CkCertChain(@_);
    bless $self, $pkg if defined($self);
}

sub DESTROY {
    return unless $_[0]->isa('HASH');
    my $self = tied(%{$_[0]});
    return unless defined $self;
    delete $ITERATORS{$self};
    if (exists $OWNER{$self}) {
        chilkatc::delete_CkCertChain($self);
        delete $OWNER{$self};
    }
}

*get_Utf8 = *chilkatc::CkCertChain_get_Utf8;
*put_Utf8 = *chilkatc::CkCertChain_put_Utf8;
*LastErrorXml = *chilkatc::CkCertChain_LastErrorXml;
*LastErrorHtml = *chilkatc::CkCertChain_LastErrorHtml;
*LastErrorText = *chilkatc::CkCertChain_LastErrorText;
*get_DebugLogFilePath = *chilkatc::CkCertChain_get_DebugLogFilePath;
*debugLogFilePath = *chilkatc::CkCertChain_debugLogFilePath;
*put_DebugLogFilePath = *chilkatc::CkCertChain_put_DebugLogFilePath;
*get_LastErrorHtml = *chilkatc::CkCertChain_get_LastErrorHtml;
*lastErrorHtml = *chilkatc::CkCertChain_lastErrorHtml;
*get_LastErrorText = *chilkatc::CkCertChain_get_LastErrorText;
*lastErrorText = *chilkatc::CkCertChain_lastErrorText;
*get_LastErrorXml = *chilkatc::CkCertChain_get_LastErrorXml;
*lastErrorXml = *chilkatc::CkCertChain_lastErrorXml;
*get_LastMethodSuccess = *chilkatc::CkCertChain_get_LastMethodSuccess;
*put_LastMethodSuccess = *chilkatc::CkCertChain_put_LastMethodSuccess;
*get_NumCerts = *chilkatc::CkCertChain_get_NumCerts;
*get_NumExpiredCerts = *chilkatc::CkCertChain_get_NumExpiredCerts;
*get_ReachesRoot = *chilkatc::CkCertChain_get_ReachesRoot;
*get_UncommonOptions = *chilkatc::CkCertChain_get_UncommonOptions;
*uncommonOptions = *chilkatc::CkCertChain_uncommonOptions;
*put_UncommonOptions = *chilkatc::CkCertChain_put_UncommonOptions;
*get_VerboseLogging = *chilkatc::CkCertChain_get_VerboseLogging;
*put_VerboseLogging = *chilkatc::CkCertChain_put_VerboseLogging;
*get_Version = *chilkatc::CkCertChain_get_Version;
*version = *chilkatc::CkCertChain_version;
*CertAt = *chilkatc::CkCertChain_CertAt;
*GetCert = *chilkatc::CkCertChain_GetCert;
*IsRootTrusted = *chilkatc::CkCertChain_IsRootTrusted;
*LoadX5C = *chilkatc::CkCertChain_LoadX5C;
*VerifyCertSignatures = *chilkatc::CkCertChain_VerifyCertSignatures;
*X509PKIPathv1 = *chilkatc::CkCertChain_X509PKIPathv1;
*x509PKIPathv1 = *chilkatc::CkCertChain_x509PKIPathv1;
sub DISOWN {
    my $self = shift;
    my $ptr = tied(%$self);
    delete $OWNER{$ptr};
}

sub ACQUIRE {
    my $self = shift;
    my $ptr = tied(%$self);
    $OWNER{$ptr} = 1;
}


############# Class : chilkat::CkCertStore ##############

package chilkat::CkCertStore;
use vars qw(@ISA %OWNER %ITERATORS %BLESSEDMEMBERS);
@ISA = qw( chilkat );
%OWNER = ();
%ITERATORS = ();
sub new {
    my $pkg = shift;
    my $self = chilkatc::new_CkCertStore(@_);
    bless $self, $pkg if defined($self);
}

sub DESTROY {
    return unless $_[0]->isa('HASH');
    my $self = tied(%{$_[0]});
    return unless defined $self;
    delete $ITERATORS{$self};
    if (exists $OWNER{$self}) {
        chilkatc::delete_CkCertStore($self);
        delete $OWNER{$self};
    }
}

*get_Utf8 = *chilkatc::CkCertStore_get_Utf8;
*put_Utf8 = *chilkatc::CkCertStore_put_Utf8;
*LastErrorXml = *chilkatc::CkCertStore_LastErrorXml;
*LastErrorHtml = *chilkatc::CkCertStore_LastErrorHtml;
*LastErrorText = *chilkatc::CkCertStore_LastErrorText;
*get_AvoidWindowsPkAccess = *chilkatc::CkCertStore_get_AvoidWindowsPkAccess;
*put_AvoidWindowsPkAccess = *chilkatc::CkCertStore_put_AvoidWindowsPkAccess;
*get_DebugLogFilePath = *chilkatc::CkCertStore_get_DebugLogFilePath;
*debugLogFilePath = *chilkatc::CkCertStore_debugLogFilePath;
*put_DebugLogFilePath = *chilkatc::CkCertStore_put_DebugLogFilePath;
*get_LastErrorHtml = *chilkatc::CkCertStore_get_LastErrorHtml;
*lastErrorHtml = *chilkatc::CkCertStore_lastErrorHtml;
*get_LastErrorText = *chilkatc::CkCertStore_get_LastErrorText;
*lastErrorText = *chilkatc::CkCertStore_lastErrorText;
*get_LastErrorXml = *chilkatc::CkCertStore_get_LastErrorXml;
*lastErrorXml = *chilkatc::CkCertStore_lastErrorXml;
*get_LastMethodSuccess = *chilkatc::CkCertStore_get_LastMethodSuccess;
*put_LastMethodSuccess = *chilkatc::CkCertStore_put_LastMethodSuccess;
*get_NumCertificates = *chilkatc::CkCertStore_get_NumCertificates;
*get_SmartCardPin = *chilkatc::CkCertStore_get_SmartCardPin;
*smartCardPin = *chilkatc::CkCertStore_smartCardPin;
*put_SmartCardPin = *chilkatc::CkCertStore_put_SmartCardPin;
*get_UncommonOptions = *chilkatc::CkCertStore_get_UncommonOptions;
*uncommonOptions = *chilkatc::CkCertStore_uncommonOptions;
*put_UncommonOptions = *chilkatc::CkCertStore_put_UncommonOptions;
*get_VerboseLogging = *chilkatc::CkCertStore_get_VerboseLogging;
*put_VerboseLogging = *chilkatc::CkCertStore_put_VerboseLogging;
*get_Version = *chilkatc::CkCertStore_get_Version;
*version = *chilkatc::CkCertStore_version;
*AddCertificate = *chilkatc::CkCertStore_AddCertificate;
*CloseCertStore = *chilkatc::CkCertStore_CloseCertStore;
*CreateFileStore = *chilkatc::CkCertStore_CreateFileStore;
*CreateMemoryStore = *chilkatc::CkCertStore_CreateMemoryStore;
*CreateRegistryStore = *chilkatc::CkCertStore_CreateRegistryStore;
*FindCert = *chilkatc::CkCertStore_FindCert;
*GetCert = *chilkatc::CkCertStore_GetCert;
*LoadPemFile = *chilkatc::CkCertStore_LoadPemFile;
*LoadPemStr = *chilkatc::CkCertStore_LoadPemStr;
*LoadPfxBd = *chilkatc::CkCertStore_LoadPfxBd;
*LoadPfxFile = *chilkatc::CkCertStore_LoadPfxFile;
*OpenCurrentUserStore = *chilkatc::CkCertStore_OpenCurrentUserStore;
*OpenFileStore = *chilkatc::CkCertStore_OpenFileStore;
*OpenLocalSystemStore = *chilkatc::CkCertStore_OpenLocalSystemStore;
*OpenRegistryStore = *chilkatc::CkCertStore_OpenRegistryStore;
*OpenSmartcard = *chilkatc::CkCertStore_OpenSmartcard;
*OpenWindowsStore = *chilkatc::CkCertStore_OpenWindowsStore;
*RemoveCertificate = *chilkatc::CkCertStore_RemoveCertificate;
sub DISOWN {
    my $self = shift;
    my $ptr = tied(%$self);
    delete $OWNER{$ptr};
}

sub ACQUIRE {
    my $self = shift;
    my $ptr = tied(%$self);
    $OWNER{$ptr} = 1;
}


############# Class : chilkat::CkCharset ##############

package chilkat::CkCharset;
use vars qw(@ISA %OWNER %ITERATORS %BLESSEDMEMBERS);
@ISA = qw( chilkat );
%OWNER = ();
%ITERATORS = ();
sub new {
    my $pkg = shift;
    my $self = chilkatc::new_CkCharset(@_);
    bless $self, $pkg if defined($self);
}

sub DESTROY {
    return unless $_[0]->isa('HASH');
    my $self = tied(%{$_[0]});
    return unless defined $self;
    delete $ITERATORS{$self};
    if (exists $OWNER{$self}) {
        chilkatc::delete_CkCharset($self);
        delete $OWNER{$self};
    }
}

*get_Utf8 = *chilkatc::CkCharset_get_Utf8;
*put_Utf8 = *chilkatc::CkCharset_put_Utf8;
*LastErrorXml = *chilkatc::CkCharset_LastErrorXml;
*LastErrorHtml = *chilkatc::CkCharset_LastErrorHtml;
*LastErrorText = *chilkatc::CkCharset_LastErrorText;
*get_AltToCharset = *chilkatc::CkCharset_get_AltToCharset;
*altToCharset = *chilkatc::CkCharset_altToCharset;
*put_AltToCharset = *chilkatc::CkCharset_put_AltToCharset;
*get_DebugLogFilePath = *chilkatc::CkCharset_get_DebugLogFilePath;
*debugLogFilePath = *chilkatc::CkCharset_debugLogFilePath;
*put_DebugLogFilePath = *chilkatc::CkCharset_put_DebugLogFilePath;
*get_ErrorAction = *chilkatc::CkCharset_get_ErrorAction;
*put_ErrorAction = *chilkatc::CkCharset_put_ErrorAction;
*get_FromCharset = *chilkatc::CkCharset_get_FromCharset;
*fromCharset = *chilkatc::CkCharset_fromCharset;
*put_FromCharset = *chilkatc::CkCharset_put_FromCharset;
*get_LastErrorHtml = *chilkatc::CkCharset_get_LastErrorHtml;
*lastErrorHtml = *chilkatc::CkCharset_lastErrorHtml;
*get_LastErrorText = *chilkatc::CkCharset_get_LastErrorText;
*lastErrorText = *chilkatc::CkCharset_lastErrorText;
*get_LastErrorXml = *chilkatc::CkCharset_get_LastErrorXml;
*lastErrorXml = *chilkatc::CkCharset_lastErrorXml;
*get_LastInputAsHex = *chilkatc::CkCharset_get_LastInputAsHex;
*lastInputAsHex = *chilkatc::CkCharset_lastInputAsHex;
*get_LastInputAsQP = *chilkatc::CkCharset_get_LastInputAsQP;
*lastInputAsQP = *chilkatc::CkCharset_lastInputAsQP;
*get_LastMethodSuccess = *chilkatc::CkCharset_get_LastMethodSuccess;
*put_LastMethodSuccess = *chilkatc::CkCharset_put_LastMethodSuccess;
*get_LastOutputAsHex = *chilkatc::CkCharset_get_LastOutputAsHex;
*lastOutputAsHex = *chilkatc::CkCharset_lastOutputAsHex;
*get_LastOutputAsQP = *chilkatc::CkCharset_get_LastOutputAsQP;
*lastOutputAsQP = *chilkatc::CkCharset_lastOutputAsQP;
*get_SaveLast = *chilkatc::CkCharset_get_SaveLast;
*put_SaveLast = *chilkatc::CkCharset_put_SaveLast;
*get_ToCharset = *chilkatc::CkCharset_get_ToCharset;
*toCharset = *chilkatc::CkCharset_toCharset;
*put_ToCharset = *chilkatc::CkCharset_put_ToCharset;
*get_VerboseLogging = *chilkatc::CkCharset_get_VerboseLogging;
*put_VerboseLogging = *chilkatc::CkCharset_put_VerboseLogging;
*get_Version = *chilkatc::CkCharset_get_Version;
*version = *chilkatc::CkCharset_version;
*CharsetToCodePage = *chilkatc::CkCharset_CharsetToCodePage;
*CodePageToCharset = *chilkatc::CkCharset_CodePageToCharset;
*codePageToCharset = *chilkatc::CkCharset_codePageToCharset;
*ConvertData = *chilkatc::CkCharset_ConvertData;
*ConvertFile = *chilkatc::CkCharset_ConvertFile;
*ConvertFileNoPreamble = *chilkatc::CkCharset_ConvertFileNoPreamble;
*ConvertFromUnicode = *chilkatc::CkCharset_ConvertFromUnicode;
*ConvertFromUtf16 = *chilkatc::CkCharset_ConvertFromUtf16;
*ConvertHtml = *chilkatc::CkCharset_ConvertHtml;
*ConvertHtmlFile = *chilkatc::CkCharset_ConvertHtmlFile;
*ConvertToUnicode = *chilkatc::CkCharset_ConvertToUnicode;
*convertToUnicode = *chilkatc::CkCharset_convertToUnicode;
*ConvertToUtf16 = *chilkatc::CkCharset_ConvertToUtf16;
*EntityEncodeDec = *chilkatc::CkCharset_EntityEncodeDec;
*entityEncodeDec = *chilkatc::CkCharset_entityEncodeDec;
*EntityEncodeHex = *chilkatc::CkCharset_EntityEncodeHex;
*entityEncodeHex = *chilkatc::CkCharset_entityEncodeHex;
*GetHtmlCharset = *chilkatc::CkCharset_GetHtmlCharset;
*getHtmlCharset = *chilkatc::CkCharset_getHtmlCharset;
*htmlCharset = *chilkatc::CkCharset_htmlCharset;
*GetHtmlFileCharset = *chilkatc::CkCharset_GetHtmlFileCharset;
*getHtmlFileCharset = *chilkatc::CkCharset_getHtmlFileCharset;
*htmlFileCharset = *chilkatc::CkCharset_htmlFileCharset;
*HtmlDecodeToStr = *chilkatc::CkCharset_HtmlDecodeToStr;
*htmlDecodeToStr = *chilkatc::CkCharset_htmlDecodeToStr;
*HtmlEntityDecode = *chilkatc::CkCharset_HtmlEntityDecode;
*HtmlEntityDecodeFile = *chilkatc::CkCharset_HtmlEntityDecodeFile;
*LowerCase = *chilkatc::CkCharset_LowerCase;
*lowerCase = *chilkatc::CkCharset_lowerCase;
*ReadFile = *chilkatc::CkCharset_ReadFile;
*ReadFileToString = *chilkatc::CkCharset_ReadFileToString;
*readFileToString = *chilkatc::CkCharset_readFileToString;
*SetErrorString = *chilkatc::CkCharset_SetErrorString;
*UpperCase = *chilkatc::CkCharset_UpperCase;
*upperCase = *chilkatc::CkCharset_upperCase;
*UrlDecodeStr = *chilkatc::CkCharset_UrlDecodeStr;
*urlDecodeStr = *chilkatc::CkCharset_urlDecodeStr;
*VerifyData = *chilkatc::CkCharset_VerifyData;
*VerifyFile = *chilkatc::CkCharset_VerifyFile;
*WriteFile = *chilkatc::CkCharset_WriteFile;
*WriteStringToFile = *chilkatc::CkCharset_WriteStringToFile;
sub DISOWN {
    my $self = shift;
    my $ptr = tied(%$self);
    delete $OWNER{$ptr};
}

sub ACQUIRE {
    my $self = shift;
    my $ptr = tied(%$self);
    $OWNER{$ptr} = 1;
}


############# Class : chilkat::CkCodeSign ##############

package chilkat::CkCodeSign;
use vars qw(@ISA %OWNER %ITERATORS %BLESSEDMEMBERS);
@ISA = qw( chilkat );
%OWNER = ();
%ITERATORS = ();
sub new {
    my $pkg = shift;
    my $self = chilkatc::new_CkCodeSign(@_);
    bless $self, $pkg if defined($self);
}

sub DESTROY {
    return unless $_[0]->isa('HASH');
    my $self = tied(%{$_[0]});
    return unless defined $self;
    delete $ITERATORS{$self};
    if (exists $OWNER{$self}) {
        chilkatc::delete_CkCodeSign($self);
        delete $OWNER{$self};
    }
}

*get_Utf8 = *chilkatc::CkCodeSign_get_Utf8;
*put_Utf8 = *chilkatc::CkCodeSign_put_Utf8;
*LastErrorXml = *chilkatc::CkCodeSign_LastErrorXml;
*LastErrorHtml = *chilkatc::CkCodeSign_LastErrorHtml;
*LastErrorText = *chilkatc::CkCodeSign_LastErrorText;
*put_EventCallbackObject = *chilkatc::CkCodeSign_put_EventCallbackObject;
*get_DebugLogFilePath = *chilkatc::CkCodeSign_get_DebugLogFilePath;
*debugLogFilePath = *chilkatc::CkCodeSign_debugLogFilePath;
*put_DebugLogFilePath = *chilkatc::CkCodeSign_put_DebugLogFilePath;
*get_HeartbeatMs = *chilkatc::CkCodeSign_get_HeartbeatMs;
*put_HeartbeatMs = *chilkatc::CkCodeSign_put_HeartbeatMs;
*get_LastErrorHtml = *chilkatc::CkCodeSign_get_LastErrorHtml;
*lastErrorHtml = *chilkatc::CkCodeSign_lastErrorHtml;
*get_LastErrorText = *chilkatc::CkCodeSign_get_LastErrorText;
*lastErrorText = *chilkatc::CkCodeSign_lastErrorText;
*get_LastErrorXml = *chilkatc::CkCodeSign_get_LastErrorXml;
*lastErrorXml = *chilkatc::CkCodeSign_lastErrorXml;
*get_LastMethodSuccess = *chilkatc::CkCodeSign_get_LastMethodSuccess;
*put_LastMethodSuccess = *chilkatc::CkCodeSign_put_LastMethodSuccess;
*get_UncommonOptions = *chilkatc::CkCodeSign_get_UncommonOptions;
*uncommonOptions = *chilkatc::CkCodeSign_uncommonOptions;
*put_UncommonOptions = *chilkatc::CkCodeSign_put_UncommonOptions;
*get_VerboseLogging = *chilkatc::CkCodeSign_get_VerboseLogging;
*put_VerboseLogging = *chilkatc::CkCodeSign_put_VerboseLogging;
*get_Version = *chilkatc::CkCodeSign_get_Version;
*version = *chilkatc::CkCodeSign_version;
*AddSignature = *chilkatc::CkCodeSign_AddSignature;
*AddSignatureAsync = *chilkatc::CkCodeSign_AddSignatureAsync;
*GetSignerCert = *chilkatc::CkCodeSign_GetSignerCert;
*RemoveSignature = *chilkatc::CkCodeSign_RemoveSignature;
*VerifySignature = *chilkatc::CkCodeSign_VerifySignature;
sub DISOWN {
    my $self = shift;
    my $ptr = tied(%$self);
    delete $OWNER{$ptr};
}

sub ACQUIRE {
    my $self = shift;
    my $ptr = tied(%$self);
    $OWNER{$ptr} = 1;
}


############# Class : chilkat::CkCompression ##############

package chilkat::CkCompression;
use vars qw(@ISA %OWNER %ITERATORS %BLESSEDMEMBERS);
@ISA = qw( chilkat );
%OWNER = ();
%ITERATORS = ();
sub new {
    my $pkg = shift;
    my $self = chilkatc::new_CkCompression(@_);
    bless $self, $pkg if defined($self);
}

sub DESTROY {
    return unless $_[0]->isa('HASH');
    my $self = tied(%{$_[0]});
    return unless defined $self;
    delete $ITERATORS{$self};
    if (exists $OWNER{$self}) {
        chilkatc::delete_CkCompression($self);
        delete $OWNER{$self};
    }
}

*get_Utf8 = *chilkatc::CkCompression_get_Utf8;
*put_Utf8 = *chilkatc::CkCompression_put_Utf8;
*LastErrorXml = *chilkatc::CkCompression_LastErrorXml;
*LastErrorHtml = *chilkatc::CkCompression_LastErrorHtml;
*LastErrorText = *chilkatc::CkCompression_LastErrorText;
*put_EventCallbackObject = *chilkatc::CkCompression_put_EventCallbackObject;
*get_Algorithm = *chilkatc::CkCompression_get_Algorithm;
*algorithm = *chilkatc::CkCompression_algorithm;
*put_Algorithm = *chilkatc::CkCompression_put_Algorithm;
*get_Charset = *chilkatc::CkCompression_get_Charset;
*charset = *chilkatc::CkCompression_charset;
*put_Charset = *chilkatc::CkCompression_put_Charset;
*get_DebugLogFilePath = *chilkatc::CkCompression_get_DebugLogFilePath;
*debugLogFilePath = *chilkatc::CkCompression_debugLogFilePath;
*put_DebugLogFilePath = *chilkatc::CkCompression_put_DebugLogFilePath;
*get_DeflateLevel = *chilkatc::CkCompression_get_DeflateLevel;
*put_DeflateLevel = *chilkatc::CkCompression_put_DeflateLevel;
*get_EncodingMode = *chilkatc::CkCompression_get_EncodingMode;
*encodingMode = *chilkatc::CkCompression_encodingMode;
*put_EncodingMode = *chilkatc::CkCompression_put_EncodingMode;
*get_FirstChunk = *chilkatc::CkCompression_get_FirstChunk;
*put_FirstChunk = *chilkatc::CkCompression_put_FirstChunk;
*get_HeartbeatMs = *chilkatc::CkCompression_get_HeartbeatMs;
*put_HeartbeatMs = *chilkatc::CkCompression_put_HeartbeatMs;
*get_LastChunk = *chilkatc::CkCompression_get_LastChunk;
*put_LastChunk = *chilkatc::CkCompression_put_LastChunk;
*get_LastErrorHtml = *chilkatc::CkCompression_get_LastErrorHtml;
*lastErrorHtml = *chilkatc::CkCompression_lastErrorHtml;
*get_LastErrorText = *chilkatc::CkCompression_get_LastErrorText;
*lastErrorText = *chilkatc::CkCompression_lastErrorText;
*get_LastErrorXml = *chilkatc::CkCompression_get_LastErrorXml;
*lastErrorXml = *chilkatc::CkCompression_lastErrorXml;
*get_LastMethodSuccess = *chilkatc::CkCompression_get_LastMethodSuccess;
*put_LastMethodSuccess = *chilkatc::CkCompression_put_LastMethodSuccess;
*get_UncommonOptions = *chilkatc::CkCompression_get_UncommonOptions;
*uncommonOptions = *chilkatc::CkCompression_uncommonOptions;
*put_UncommonOptions = *chilkatc::CkCompression_put_UncommonOptions;
*get_VerboseLogging = *chilkatc::CkCompression_get_VerboseLogging;
*put_VerboseLogging = *chilkatc::CkCompression_put_VerboseLogging;
*get_Version = *chilkatc::CkCompression_get_Version;
*version = *chilkatc::CkCompression_version;
*BeginCompressBytes = *chilkatc::CkCompression_BeginCompressBytes;
*BeginCompressBytesENC = *chilkatc::CkCompression_BeginCompressBytesENC;
*beginCompressBytesENC = *chilkatc::CkCompression_beginCompressBytesENC;
*BeginCompressString = *chilkatc::CkCompression_BeginCompressString;
*BeginCompressStringENC = *chilkatc::CkCompression_BeginCompressStringENC;
*beginCompressStringENC = *chilkatc::CkCompression_beginCompressStringENC;
*BeginDecompressBytes = *chilkatc::CkCompression_BeginDecompressBytes;
*BeginDecompressBytesENC = *chilkatc::CkCompression_BeginDecompressBytesENC;
*BeginDecompressString = *chilkatc::CkCompression_BeginDecompressString;
*beginDecompressString = *chilkatc::CkCompression_beginDecompressString;
*BeginDecompressStringENC = *chilkatc::CkCompression_BeginDecompressStringENC;
*beginDecompressStringENC = *chilkatc::CkCompression_beginDecompressStringENC;
*CompressBd = *chilkatc::CkCompression_CompressBd;
*CompressBdAsync = *chilkatc::CkCompression_CompressBdAsync;
*CompressBd2 = *chilkatc::CkCompression_CompressBd2;
*CompressBd2Async = *chilkatc::CkCompression_CompressBd2Async;
*CompressBytes = *chilkatc::CkCompression_CompressBytes;
*CompressBytesAsync = *chilkatc::CkCompression_CompressBytesAsync;
*CompressBytesENC = *chilkatc::CkCompression_CompressBytesENC;
*compressBytesENC = *chilkatc::CkCompression_compressBytesENC;
*CompressBytesENCAsync = *chilkatc::CkCompression_CompressBytesENCAsync;
*CompressEncryptFile = *chilkatc::CkCompression_CompressEncryptFile;
*CompressEncryptFileAsync = *chilkatc::CkCompression_CompressEncryptFileAsync;
*CompressFile = *chilkatc::CkCompression_CompressFile;
*CompressFileAsync = *chilkatc::CkCompression_CompressFileAsync;
*CompressSb = *chilkatc::CkCompression_CompressSb;
*CompressSbAsync = *chilkatc::CkCompression_CompressSbAsync;
*CompressStr = *chilkatc::CkCompression_CompressStr;
*CompressStrAsync = *chilkatc::CkCompression_CompressStrAsync;
*CompressStream = *chilkatc::CkCompression_CompressStream;
*CompressStreamAsync = *chilkatc::CkCompression_CompressStreamAsync;
*CompressString = *chilkatc::CkCompression_CompressString;
*CompressStringAsync = *chilkatc::CkCompression_CompressStringAsync;
*CompressStringENC = *chilkatc::CkCompression_CompressStringENC;
*compressStringENC = *chilkatc::CkCompression_compressStringENC;
*CompressStringENCAsync = *chilkatc::CkCompression_CompressStringENCAsync;
*DecompressBd = *chilkatc::CkCompression_DecompressBd;
*DecompressBdAsync = *chilkatc::CkCompression_DecompressBdAsync;
*DecompressBd2 = *chilkatc::CkCompression_DecompressBd2;
*DecompressBd2Async = *chilkatc::CkCompression_DecompressBd2Async;
*DecompressBytes = *chilkatc::CkCompression_DecompressBytes;
*DecompressBytesAsync = *chilkatc::CkCompression_DecompressBytesAsync;
*DecompressBytesENC = *chilkatc::CkCompression_DecompressBytesENC;
*DecompressBytesENCAsync = *chilkatc::CkCompression_DecompressBytesENCAsync;
*DecompressFile = *chilkatc::CkCompression_DecompressFile;
*DecompressFileAsync = *chilkatc::CkCompression_DecompressFileAsync;
*DecompressSb = *chilkatc::CkCompression_DecompressSb;
*DecompressSbAsync = *chilkatc::CkCompression_DecompressSbAsync;
*DecompressStream = *chilkatc::CkCompression_DecompressStream;
*DecompressStreamAsync = *chilkatc::CkCompression_DecompressStreamAsync;
*DecompressString = *chilkatc::CkCompression_DecompressString;
*decompressString = *chilkatc::CkCompression_decompressString;
*DecompressStringENC = *chilkatc::CkCompression_DecompressStringENC;
*decompressStringENC = *chilkatc::CkCompression_decompressStringENC;
*DecompressStringENCAsync = *chilkatc::CkCompression_DecompressStringENCAsync;
*DecryptDecompressFile = *chilkatc::CkCompression_DecryptDecompressFile;
*DecryptDecompressFileAsync = *chilkatc::CkCompression_DecryptDecompressFileAsync;
*EndCompressBytes = *chilkatc::CkCompression_EndCompressBytes;
*EndCompressBytesENC = *chilkatc::CkCompression_EndCompressBytesENC;
*endCompressBytesENC = *chilkatc::CkCompression_endCompressBytesENC;
*EndCompressString = *chilkatc::CkCompression_EndCompressString;
*EndCompressStringENC = *chilkatc::CkCompression_EndCompressStringENC;
*endCompressStringENC = *chilkatc::CkCompression_endCompressStringENC;
*EndDecompressBytes = *chilkatc::CkCompression_EndDecompressBytes;
*EndDecompressBytesENC = *chilkatc::CkCompression_EndDecompressBytesENC;
*EndDecompressString = *chilkatc::CkCompression_EndDecompressString;
*endDecompressString = *chilkatc::CkCompression_endDecompressString;
*EndDecompressStringENC = *chilkatc::CkCompression_EndDecompressStringENC;
*endDecompressStringENC = *chilkatc::CkCompression_endDecompressStringENC;
*LoadTaskCaller = *chilkatc::CkCompression_LoadTaskCaller;
*MoreCompressBytes = *chilkatc::CkCompression_MoreCompressBytes;
*MoreCompressBytesENC = *chilkatc::CkCompression_MoreCompressBytesENC;
*moreCompressBytesENC = *chilkatc::CkCompression_moreCompressBytesENC;
*MoreCompressString = *chilkatc::CkCompression_MoreCompressString;
*MoreCompressStringENC = *chilkatc::CkCompression_MoreCompressStringENC;
*moreCompressStringENC = *chilkatc::CkCompression_moreCompressStringENC;
*MoreDecompressBytes = *chilkatc::CkCompression_MoreDecompressBytes;
*MoreDecompressBytesENC = *chilkatc::CkCompression_MoreDecompressBytesENC;
*MoreDecompressString = *chilkatc::CkCompression_MoreDecompressString;
*moreDecompressString = *chilkatc::CkCompression_moreDecompressString;
*MoreDecompressStringENC = *chilkatc::CkCompression_MoreDecompressStringENC;
*moreDecompressStringENC = *chilkatc::CkCompression_moreDecompressStringENC;
sub DISOWN {
    my $self = shift;
    my $ptr = tied(%$self);
    delete $OWNER{$ptr};
}

sub ACQUIRE {
    my $self = shift;
    my $ptr = tied(%$self);
    $OWNER{$ptr} = 1;
}


############# Class : chilkat::CkCrypt2 ##############

package chilkat::CkCrypt2;
use vars qw(@ISA %OWNER %ITERATORS %BLESSEDMEMBERS);
@ISA = qw( chilkat );
%OWNER = ();
%ITERATORS = ();
sub new {
    my $pkg = shift;
    my $self = chilkatc::new_CkCrypt2(@_);
    bless $self, $pkg if defined($self);
}

sub DESTROY {
    return unless $_[0]->isa('HASH');
    my $self = tied(%{$_[0]});
    return unless defined $self;
    delete $ITERATORS{$self};
    if (exists $OWNER{$self}) {
        chilkatc::delete_CkCrypt2($self);
        delete $OWNER{$self};
    }
}

*get_Utf8 = *chilkatc::CkCrypt2_get_Utf8;
*put_Utf8 = *chilkatc::CkCrypt2_put_Utf8;
*LastErrorXml = *chilkatc::CkCrypt2_LastErrorXml;
*LastErrorHtml = *chilkatc::CkCrypt2_LastErrorHtml;
*LastErrorText = *chilkatc::CkCrypt2_LastErrorText;
*put_EventCallbackObject = *chilkatc::CkCrypt2_put_EventCallbackObject;
*get_AbortCurrent = *chilkatc::CkCrypt2_get_AbortCurrent;
*put_AbortCurrent = *chilkatc::CkCrypt2_put_AbortCurrent;
*get_BCryptWorkFactor = *chilkatc::CkCrypt2_get_BCryptWorkFactor;
*put_BCryptWorkFactor = *chilkatc::CkCrypt2_put_BCryptWorkFactor;
*get_BlockSize = *chilkatc::CkCrypt2_get_BlockSize;
*get_CadesEnabled = *chilkatc::CkCrypt2_get_CadesEnabled;
*put_CadesEnabled = *chilkatc::CkCrypt2_put_CadesEnabled;
*get_CadesSigPolicyHash = *chilkatc::CkCrypt2_get_CadesSigPolicyHash;
*cadesSigPolicyHash = *chilkatc::CkCrypt2_cadesSigPolicyHash;
*put_CadesSigPolicyHash = *chilkatc::CkCrypt2_put_CadesSigPolicyHash;
*get_CadesSigPolicyId = *chilkatc::CkCrypt2_get_CadesSigPolicyId;
*cadesSigPolicyId = *chilkatc::CkCrypt2_cadesSigPolicyId;
*put_CadesSigPolicyId = *chilkatc::CkCrypt2_put_CadesSigPolicyId;
*get_CadesSigPolicyUri = *chilkatc::CkCrypt2_get_CadesSigPolicyUri;
*cadesSigPolicyUri = *chilkatc::CkCrypt2_cadesSigPolicyUri;
*put_CadesSigPolicyUri = *chilkatc::CkCrypt2_put_CadesSigPolicyUri;
*get_Charset = *chilkatc::CkCrypt2_get_Charset;
*charset = *chilkatc::CkCrypt2_charset;
*put_Charset = *chilkatc::CkCrypt2_put_Charset;
*get_CipherMode = *chilkatc::CkCrypt2_get_CipherMode;
*cipherMode = *chilkatc::CkCrypt2_cipherMode;
*put_CipherMode = *chilkatc::CkCrypt2_put_CipherMode;
*get_CmsOptions = *chilkatc::CkCrypt2_get_CmsOptions;
*cmsOptions = *chilkatc::CkCrypt2_cmsOptions;
*put_CmsOptions = *chilkatc::CkCrypt2_put_CmsOptions;
*get_CryptAlgorithm = *chilkatc::CkCrypt2_get_CryptAlgorithm;
*cryptAlgorithm = *chilkatc::CkCrypt2_cryptAlgorithm;
*put_CryptAlgorithm = *chilkatc::CkCrypt2_put_CryptAlgorithm;
*get_DebugLogFilePath = *chilkatc::CkCrypt2_get_DebugLogFilePath;
*debugLogFilePath = *chilkatc::CkCrypt2_debugLogFilePath;
*put_DebugLogFilePath = *chilkatc::CkCrypt2_put_DebugLogFilePath;
*get_EncodingMode = *chilkatc::CkCrypt2_get_EncodingMode;
*encodingMode = *chilkatc::CkCrypt2_encodingMode;
*put_EncodingMode = *chilkatc::CkCrypt2_put_EncodingMode;
*get_FirstChunk = *chilkatc::CkCrypt2_get_FirstChunk;
*put_FirstChunk = *chilkatc::CkCrypt2_put_FirstChunk;
*get_HashAlgorithm = *chilkatc::CkCrypt2_get_HashAlgorithm;
*hashAlgorithm = *chilkatc::CkCrypt2_hashAlgorithm;
*put_HashAlgorithm = *chilkatc::CkCrypt2_put_HashAlgorithm;
*get_HavalRounds = *chilkatc::CkCrypt2_get_HavalRounds;
*put_HavalRounds = *chilkatc::CkCrypt2_put_HavalRounds;
*get_HeartbeatMs = *chilkatc::CkCrypt2_get_HeartbeatMs;
*put_HeartbeatMs = *chilkatc::CkCrypt2_put_HeartbeatMs;
*get_IncludeCertChain = *chilkatc::CkCrypt2_get_IncludeCertChain;
*put_IncludeCertChain = *chilkatc::CkCrypt2_put_IncludeCertChain;
*get_InitialCount = *chilkatc::CkCrypt2_get_InitialCount;
*put_InitialCount = *chilkatc::CkCrypt2_put_InitialCount;
*get_IterationCount = *chilkatc::CkCrypt2_get_IterationCount;
*put_IterationCount = *chilkatc::CkCrypt2_put_IterationCount;
*get_KeyLength = *chilkatc::CkCrypt2_get_KeyLength;
*put_KeyLength = *chilkatc::CkCrypt2_put_KeyLength;
*get_LastChunk = *chilkatc::CkCrypt2_get_LastChunk;
*put_LastChunk = *chilkatc::CkCrypt2_put_LastChunk;
*get_LastErrorHtml = *chilkatc::CkCrypt2_get_LastErrorHtml;
*lastErrorHtml = *chilkatc::CkCrypt2_lastErrorHtml;
*get_LastErrorText = *chilkatc::CkCrypt2_get_LastErrorText;
*lastErrorText = *chilkatc::CkCrypt2_lastErrorText;
*get_LastErrorXml = *chilkatc::CkCrypt2_get_LastErrorXml;
*lastErrorXml = *chilkatc::CkCrypt2_lastErrorXml;
*get_LastMethodSuccess = *chilkatc::CkCrypt2_get_LastMethodSuccess;
*put_LastMethodSuccess = *chilkatc::CkCrypt2_put_LastMethodSuccess;
*get_MacAlgorithm = *chilkatc::CkCrypt2_get_MacAlgorithm;
*macAlgorithm = *chilkatc::CkCrypt2_macAlgorithm;
*put_MacAlgorithm = *chilkatc::CkCrypt2_put_MacAlgorithm;
*get_NumSignerCerts = *chilkatc::CkCrypt2_get_NumSignerCerts;
*get_OaepHash = *chilkatc::CkCrypt2_get_OaepHash;
*oaepHash = *chilkatc::CkCrypt2_oaepHash;
*put_OaepHash = *chilkatc::CkCrypt2_put_OaepHash;
*get_OaepMgfHash = *chilkatc::CkCrypt2_get_OaepMgfHash;
*oaepMgfHash = *chilkatc::CkCrypt2_oaepMgfHash;
*put_OaepMgfHash = *chilkatc::CkCrypt2_put_OaepMgfHash;
*get_OaepPadding = *chilkatc::CkCrypt2_get_OaepPadding;
*put_OaepPadding = *chilkatc::CkCrypt2_put_OaepPadding;
*get_PaddingScheme = *chilkatc::CkCrypt2_get_PaddingScheme;
*put_PaddingScheme = *chilkatc::CkCrypt2_put_PaddingScheme;
*get_PbesAlgorithm = *chilkatc::CkCrypt2_get_PbesAlgorithm;
*pbesAlgorithm = *chilkatc::CkCrypt2_pbesAlgorithm;
*put_PbesAlgorithm = *chilkatc::CkCrypt2_put_PbesAlgorithm;
*get_PbesPassword = *chilkatc::CkCrypt2_get_PbesPassword;
*pbesPassword = *chilkatc::CkCrypt2_pbesPassword;
*put_PbesPassword = *chilkatc::CkCrypt2_put_PbesPassword;
*get_Pkcs7CryptAlg = *chilkatc::CkCrypt2_get_Pkcs7CryptAlg;
*pkcs7CryptAlg = *chilkatc::CkCrypt2_pkcs7CryptAlg;
*put_Pkcs7CryptAlg = *chilkatc::CkCrypt2_put_Pkcs7CryptAlg;
*get_Rc2EffectiveKeyLength = *chilkatc::CkCrypt2_get_Rc2EffectiveKeyLength;
*put_Rc2EffectiveKeyLength = *chilkatc::CkCrypt2_put_Rc2EffectiveKeyLength;
*get_SigningAlg = *chilkatc::CkCrypt2_get_SigningAlg;
*signingAlg = *chilkatc::CkCrypt2_signingAlg;
*put_SigningAlg = *chilkatc::CkCrypt2_put_SigningAlg;
*get_SigningAttributes = *chilkatc::CkCrypt2_get_SigningAttributes;
*signingAttributes = *chilkatc::CkCrypt2_signingAttributes;
*put_SigningAttributes = *chilkatc::CkCrypt2_put_SigningAttributes;
*get_UncommonOptions = *chilkatc::CkCrypt2_get_UncommonOptions;
*uncommonOptions = *chilkatc::CkCrypt2_uncommonOptions;
*put_UncommonOptions = *chilkatc::CkCrypt2_put_UncommonOptions;
*get_UuFilename = *chilkatc::CkCrypt2_get_UuFilename;
*uuFilename = *chilkatc::CkCrypt2_uuFilename;
*put_UuFilename = *chilkatc::CkCrypt2_put_UuFilename;
*get_UuMode = *chilkatc::CkCrypt2_get_UuMode;
*uuMode = *chilkatc::CkCrypt2_uuMode;
*put_UuMode = *chilkatc::CkCrypt2_put_UuMode;
*get_VerboseLogging = *chilkatc::CkCrypt2_get_VerboseLogging;
*put_VerboseLogging = *chilkatc::CkCrypt2_put_VerboseLogging;
*get_Version = *chilkatc::CkCrypt2_get_Version;
*version = *chilkatc::CkCrypt2_version;
*AddEncryptCert = *chilkatc::CkCrypt2_AddEncryptCert;
*AddPfxSourceBd = *chilkatc::CkCrypt2_AddPfxSourceBd;
*AddPfxSourceData = *chilkatc::CkCrypt2_AddPfxSourceData;
*AddPfxSourceFile = *chilkatc::CkCrypt2_AddPfxSourceFile;
*AddSigningCert = *chilkatc::CkCrypt2_AddSigningCert;
*AesKeyUnwrap = *chilkatc::CkCrypt2_AesKeyUnwrap;
*aesKeyUnwrap = *chilkatc::CkCrypt2_aesKeyUnwrap;
*AesKeyUnwrapWithPadding = *chilkatc::CkCrypt2_AesKeyUnwrapWithPadding;
*aesKeyUnwrapWithPadding = *chilkatc::CkCrypt2_aesKeyUnwrapWithPadding;
*AesKeyWrap = *chilkatc::CkCrypt2_AesKeyWrap;
*aesKeyWrap = *chilkatc::CkCrypt2_aesKeyWrap;
*AesKeyWrapWithPadding = *chilkatc::CkCrypt2_AesKeyWrapWithPadding;
*aesKeyWrapWithPadding = *chilkatc::CkCrypt2_aesKeyWrapWithPadding;
*BCryptHash = *chilkatc::CkCrypt2_BCryptHash;
*bCryptHash = *chilkatc::CkCrypt2_bCryptHash;
*BCryptVerify = *chilkatc::CkCrypt2_BCryptVerify;
*CkDecryptFile = *chilkatc::CkCrypt2_CkDecryptFile;
*CkDecryptFileAsync = *chilkatc::CkCrypt2_CkDecryptFileAsync;
*CkEncryptFile = *chilkatc::CkCrypt2_CkEncryptFile;
*CkEncryptFileAsync = *chilkatc::CkCrypt2_CkEncryptFileAsync;
*ClearEncryptCerts = *chilkatc::CkCrypt2_ClearEncryptCerts;
*ClearSigningCerts = *chilkatc::CkCrypt2_ClearSigningCerts;
*CoSign = *chilkatc::CkCrypt2_CoSign;
*CrcBd = *chilkatc::CkCrypt2_CrcBd;
*CrcBytes = *chilkatc::CkCrypt2_CrcBytes;
*CrcFile = *chilkatc::CkCrypt2_CrcFile;
*CrcFileAsync = *chilkatc::CkCrypt2_CrcFileAsync;
*CreateDetachedSignature = *chilkatc::CkCrypt2_CreateDetachedSignature;
*CreateP7M = *chilkatc::CkCrypt2_CreateP7M;
*CreateP7MAsync = *chilkatc::CkCrypt2_CreateP7MAsync;
*CreateP7S = *chilkatc::CkCrypt2_CreateP7S;
*CreateP7SAsync = *chilkatc::CkCrypt2_CreateP7SAsync;
*Decode = *chilkatc::CkCrypt2_Decode;
*DecodeString = *chilkatc::CkCrypt2_DecodeString;
*decodeString = *chilkatc::CkCrypt2_decodeString;
*DecryptBd = *chilkatc::CkCrypt2_DecryptBd;
*DecryptBytes = *chilkatc::CkCrypt2_DecryptBytes;
*DecryptBytesENC = *chilkatc::CkCrypt2_DecryptBytesENC;
*DecryptEncoded = *chilkatc::CkCrypt2_DecryptEncoded;
*decryptEncoded = *chilkatc::CkCrypt2_decryptEncoded;
*DecryptSb = *chilkatc::CkCrypt2_DecryptSb;
*DecryptSecureENC = *chilkatc::CkCrypt2_DecryptSecureENC;
*DecryptStream = *chilkatc::CkCrypt2_DecryptStream;
*DecryptStreamAsync = *chilkatc::CkCrypt2_DecryptStreamAsync;
*DecryptString = *chilkatc::CkCrypt2_DecryptString;
*decryptString = *chilkatc::CkCrypt2_decryptString;
*DecryptStringENC = *chilkatc::CkCrypt2_DecryptStringENC;
*decryptStringENC = *chilkatc::CkCrypt2_decryptStringENC;
*Encode = *chilkatc::CkCrypt2_Encode;
*encode = *chilkatc::CkCrypt2_encode;
*EncodeInt = *chilkatc::CkCrypt2_EncodeInt;
*encodeInt = *chilkatc::CkCrypt2_encodeInt;
*EncodeString = *chilkatc::CkCrypt2_EncodeString;
*encodeString = *chilkatc::CkCrypt2_encodeString;
*EncryptBd = *chilkatc::CkCrypt2_EncryptBd;
*EncryptBytes = *chilkatc::CkCrypt2_EncryptBytes;
*EncryptBytesENC = *chilkatc::CkCrypt2_EncryptBytesENC;
*encryptBytesENC = *chilkatc::CkCrypt2_encryptBytesENC;
*EncryptEncoded = *chilkatc::CkCrypt2_EncryptEncoded;
*encryptEncoded = *chilkatc::CkCrypt2_encryptEncoded;
*EncryptSb = *chilkatc::CkCrypt2_EncryptSb;
*EncryptSecureENC = *chilkatc::CkCrypt2_EncryptSecureENC;
*encryptSecureENC = *chilkatc::CkCrypt2_encryptSecureENC;
*EncryptStream = *chilkatc::CkCrypt2_EncryptStream;
*EncryptStreamAsync = *chilkatc::CkCrypt2_EncryptStreamAsync;
*EncryptString = *chilkatc::CkCrypt2_EncryptString;
*EncryptStringENC = *chilkatc::CkCrypt2_EncryptStringENC;
*encryptStringENC = *chilkatc::CkCrypt2_encryptStringENC;
*GenEncodedSecretKey = *chilkatc::CkCrypt2_GenEncodedSecretKey;
*genEncodedSecretKey = *chilkatc::CkCrypt2_genEncodedSecretKey;
*GenerateSecretKey = *chilkatc::CkCrypt2_GenerateSecretKey;
*GenerateUuid = *chilkatc::CkCrypt2_GenerateUuid;
*generateUuid = *chilkatc::CkCrypt2_generateUuid;
*GenRandomBytesENC = *chilkatc::CkCrypt2_GenRandomBytesENC;
*genRandomBytesENC = *chilkatc::CkCrypt2_genRandomBytesENC;
*GetDecryptCert = *chilkatc::CkCrypt2_GetDecryptCert;
*GetEncodedAad = *chilkatc::CkCrypt2_GetEncodedAad;
*getEncodedAad = *chilkatc::CkCrypt2_getEncodedAad;
*encodedAad = *chilkatc::CkCrypt2_encodedAad;
*GetEncodedAuthTag = *chilkatc::CkCrypt2_GetEncodedAuthTag;
*getEncodedAuthTag = *chilkatc::CkCrypt2_getEncodedAuthTag;
*encodedAuthTag = *chilkatc::CkCrypt2_encodedAuthTag;
*GetEncodedIV = *chilkatc::CkCrypt2_GetEncodedIV;
*getEncodedIV = *chilkatc::CkCrypt2_getEncodedIV;
*encodedIV = *chilkatc::CkCrypt2_encodedIV;
*GetEncodedKey = *chilkatc::CkCrypt2_GetEncodedKey;
*getEncodedKey = *chilkatc::CkCrypt2_getEncodedKey;
*encodedKey = *chilkatc::CkCrypt2_encodedKey;
*GetEncodedSalt = *chilkatc::CkCrypt2_GetEncodedSalt;
*getEncodedSalt = *chilkatc::CkCrypt2_getEncodedSalt;
*encodedSalt = *chilkatc::CkCrypt2_encodedSalt;
*GetLastJsonData = *chilkatc::CkCrypt2_GetLastJsonData;
*GetSignatureSigningTimeStr = *chilkatc::CkCrypt2_GetSignatureSigningTimeStr;
*getSignatureSigningTimeStr = *chilkatc::CkCrypt2_getSignatureSigningTimeStr;
*signatureSigningTimeStr = *chilkatc::CkCrypt2_signatureSigningTimeStr;
*GetSignedAttributes = *chilkatc::CkCrypt2_GetSignedAttributes;
*GetSignerCert = *chilkatc::CkCrypt2_GetSignerCert;
*GetSignerCertChain = *chilkatc::CkCrypt2_GetSignerCertChain;
*HashBdENC = *chilkatc::CkCrypt2_HashBdENC;
*hashBdENC = *chilkatc::CkCrypt2_hashBdENC;
*HashBeginBytes = *chilkatc::CkCrypt2_HashBeginBytes;
*HashBeginString = *chilkatc::CkCrypt2_HashBeginString;
*HashBytes = *chilkatc::CkCrypt2_HashBytes;
*HashBytesENC = *chilkatc::CkCrypt2_HashBytesENC;
*hashBytesENC = *chilkatc::CkCrypt2_hashBytesENC;
*HashChunkBd = *chilkatc::CkCrypt2_HashChunkBd;
*HashFile = *chilkatc::CkCrypt2_HashFile;
*HashFileAsync = *chilkatc::CkCrypt2_HashFileAsync;
*HashFileENC = *chilkatc::CkCrypt2_HashFileENC;
*hashFileENC = *chilkatc::CkCrypt2_hashFileENC;
*HashFileENCAsync = *chilkatc::CkCrypt2_HashFileENCAsync;
*HashFinal = *chilkatc::CkCrypt2_HashFinal;
*HashFinalENC = *chilkatc::CkCrypt2_HashFinalENC;
*hashFinalENC = *chilkatc::CkCrypt2_hashFinalENC;
*HashMoreBytes = *chilkatc::CkCrypt2_HashMoreBytes;
*HashMoreString = *chilkatc::CkCrypt2_HashMoreString;
*HashString = *chilkatc::CkCrypt2_HashString;
*HashStringENC = *chilkatc::CkCrypt2_HashStringENC;
*hashStringENC = *chilkatc::CkCrypt2_hashStringENC;
*HasSignatureSigningTime = *chilkatc::CkCrypt2_HasSignatureSigningTime;
*Hotp = *chilkatc::CkCrypt2_Hotp;
*hotp = *chilkatc::CkCrypt2_hotp;
*LastDecryptCert = *chilkatc::CkCrypt2_LastDecryptCert;
*LastJsonData = *chilkatc::CkCrypt2_LastJsonData;
*LastSignerCert = *chilkatc::CkCrypt2_LastSignerCert;
*LoadTaskCaller = *chilkatc::CkCrypt2_LoadTaskCaller;
*MacBdENC = *chilkatc::CkCrypt2_MacBdENC;
*macBdENC = *chilkatc::CkCrypt2_macBdENC;
*MacBytes = *chilkatc::CkCrypt2_MacBytes;
*MacBytesENC = *chilkatc::CkCrypt2_MacBytesENC;
*macBytesENC = *chilkatc::CkCrypt2_macBytesENC;
*MacString = *chilkatc::CkCrypt2_MacString;
*MacStringENC = *chilkatc::CkCrypt2_MacStringENC;
*macStringENC = *chilkatc::CkCrypt2_macStringENC;
*MySqlAesDecrypt = *chilkatc::CkCrypt2_MySqlAesDecrypt;
*mySqlAesDecrypt = *chilkatc::CkCrypt2_mySqlAesDecrypt;
*MySqlAesEncrypt = *chilkatc::CkCrypt2_MySqlAesEncrypt;
*mySqlAesEncrypt = *chilkatc::CkCrypt2_mySqlAesEncrypt;
*OpaqueSignBd = *chilkatc::CkCrypt2_OpaqueSignBd;
*OpaqueSignBdAsync = *chilkatc::CkCrypt2_OpaqueSignBdAsync;
*OpaqueSignBytes = *chilkatc::CkCrypt2_OpaqueSignBytes;
*OpaqueSignBytesAsync = *chilkatc::CkCrypt2_OpaqueSignBytesAsync;
*OpaqueSignBytesENC = *chilkatc::CkCrypt2_OpaqueSignBytesENC;
*opaqueSignBytesENC = *chilkatc::CkCrypt2_opaqueSignBytesENC;
*OpaqueSignBytesENCAsync = *chilkatc::CkCrypt2_OpaqueSignBytesENCAsync;
*OpaqueSignString = *chilkatc::CkCrypt2_OpaqueSignString;
*OpaqueSignStringAsync = *chilkatc::CkCrypt2_OpaqueSignStringAsync;
*OpaqueSignStringENC = *chilkatc::CkCrypt2_OpaqueSignStringENC;
*opaqueSignStringENC = *chilkatc::CkCrypt2_opaqueSignStringENC;
*OpaqueSignStringENCAsync = *chilkatc::CkCrypt2_OpaqueSignStringENCAsync;
*OpaqueVerifyBd = *chilkatc::CkCrypt2_OpaqueVerifyBd;
*OpaqueVerifyBytes = *chilkatc::CkCrypt2_OpaqueVerifyBytes;
*OpaqueVerifyBytesENC = *chilkatc::CkCrypt2_OpaqueVerifyBytesENC;
*OpaqueVerifyString = *chilkatc::CkCrypt2_OpaqueVerifyString;
*opaqueVerifyString = *chilkatc::CkCrypt2_opaqueVerifyString;
*OpaqueVerifyStringENC = *chilkatc::CkCrypt2_OpaqueVerifyStringENC;
*opaqueVerifyStringENC = *chilkatc::CkCrypt2_opaqueVerifyStringENC;
*Pbkdf1 = *chilkatc::CkCrypt2_Pbkdf1;
*pbkdf1 = *chilkatc::CkCrypt2_pbkdf1;
*Pbkdf2 = *chilkatc::CkCrypt2_Pbkdf2;
*pbkdf2 = *chilkatc::CkCrypt2_pbkdf2;
*RandomizeIV = *chilkatc::CkCrypt2_RandomizeIV;
*RandomizeKey = *chilkatc::CkCrypt2_RandomizeKey;
*ReEncode = *chilkatc::CkCrypt2_ReEncode;
*reEncode = *chilkatc::CkCrypt2_reEncode;
*SetDecryptCert = *chilkatc::CkCrypt2_SetDecryptCert;
*SetDecryptCert2 = *chilkatc::CkCrypt2_SetDecryptCert2;
*SetEncodedAad = *chilkatc::CkCrypt2_SetEncodedAad;
*SetEncodedAuthTag = *chilkatc::CkCrypt2_SetEncodedAuthTag;
*SetEncodedIV = *chilkatc::CkCrypt2_SetEncodedIV;
*SetEncodedKey = *chilkatc::CkCrypt2_SetEncodedKey;
*SetEncodedSalt = *chilkatc::CkCrypt2_SetEncodedSalt;
*SetEncryptCert = *chilkatc::CkCrypt2_SetEncryptCert;
*SetMacKeyBytes = *chilkatc::CkCrypt2_SetMacKeyBytes;
*SetMacKeyEncoded = *chilkatc::CkCrypt2_SetMacKeyEncoded;
*SetMacKeyString = *chilkatc::CkCrypt2_SetMacKeyString;
*SetSecretKeyViaPassword = *chilkatc::CkCrypt2_SetSecretKeyViaPassword;
*SetSigningCert = *chilkatc::CkCrypt2_SetSigningCert;
*SetSigningCert2 = *chilkatc::CkCrypt2_SetSigningCert2;
*SetTsaHttpObj = *chilkatc::CkCrypt2_SetTsaHttpObj;
*SetVerifyCert = *chilkatc::CkCrypt2_SetVerifyCert;
*SignBdENC = *chilkatc::CkCrypt2_SignBdENC;
*signBdENC = *chilkatc::CkCrypt2_signBdENC;
*SignBdENCAsync = *chilkatc::CkCrypt2_SignBdENCAsync;
*SignBytes = *chilkatc::CkCrypt2_SignBytes;
*SignBytesAsync = *chilkatc::CkCrypt2_SignBytesAsync;
*SignBytesENC = *chilkatc::CkCrypt2_SignBytesENC;
*signBytesENC = *chilkatc::CkCrypt2_signBytesENC;
*SignBytesENCAsync = *chilkatc::CkCrypt2_SignBytesENCAsync;
*SignHashENC = *chilkatc::CkCrypt2_SignHashENC;
*signHashENC = *chilkatc::CkCrypt2_signHashENC;
*SignHashENCAsync = *chilkatc::CkCrypt2_SignHashENCAsync;
*SignSbENC = *chilkatc::CkCrypt2_SignSbENC;
*signSbENC = *chilkatc::CkCrypt2_signSbENC;
*SignSbENCAsync = *chilkatc::CkCrypt2_SignSbENCAsync;
*SignString = *chilkatc::CkCrypt2_SignString;
*SignStringAsync = *chilkatc::CkCrypt2_SignStringAsync;
*SignStringENC = *chilkatc::CkCrypt2_SignStringENC;
*signStringENC = *chilkatc::CkCrypt2_signStringENC;
*SignStringENCAsync = *chilkatc::CkCrypt2_SignStringENCAsync;
*Totp = *chilkatc::CkCrypt2_Totp;
*totp = *chilkatc::CkCrypt2_totp;
*UseCertVault = *chilkatc::CkCrypt2_UseCertVault;
*VerifyBdENC = *chilkatc::CkCrypt2_VerifyBdENC;
*VerifyBytes = *chilkatc::CkCrypt2_VerifyBytes;
*VerifyBytesENC = *chilkatc::CkCrypt2_VerifyBytesENC;
*VerifyDetachedSignature = *chilkatc::CkCrypt2_VerifyDetachedSignature;
*VerifyP7M = *chilkatc::CkCrypt2_VerifyP7M;
*VerifyP7S = *chilkatc::CkCrypt2_VerifyP7S;
*VerifySbENC = *chilkatc::CkCrypt2_VerifySbENC;
*VerifyString = *chilkatc::CkCrypt2_VerifyString;
*VerifyStringENC = *chilkatc::CkCrypt2_VerifyStringENC;
*XtsSetDataUnitNumber = *chilkatc::CkCrypt2_XtsSetDataUnitNumber;
*XtsSetEncodedTweakKey = *chilkatc::CkCrypt2_XtsSetEncodedTweakKey;
*XtsSetEncodedTweakValue = *chilkatc::CkCrypt2_XtsSetEncodedTweakValue;
sub DISOWN {
    my $self = shift;
    my $ptr = tied(%$self);
    delete $OWNER{$ptr};
}

sub ACQUIRE {
    my $self = shift;
    my $ptr = tied(%$self);
    $OWNER{$ptr} = 1;
}


############# Class : chilkat::CkCsr ##############

package chilkat::CkCsr;
use vars qw(@ISA %OWNER %ITERATORS %BLESSEDMEMBERS);
@ISA = qw( chilkat );
%OWNER = ();
%ITERATORS = ();
sub new {
    my $pkg = shift;
    my $self = chilkatc::new_CkCsr(@_);
    bless $self, $pkg if defined($self);
}

sub DESTROY {
    return unless $_[0]->isa('HASH');
    my $self = tied(%{$_[0]});
    return unless defined $self;
    delete $ITERATORS{$self};
    if (exists $OWNER{$self}) {
        chilkatc::delete_CkCsr($self);
        delete $OWNER{$self};
    }
}

*get_Utf8 = *chilkatc::CkCsr_get_Utf8;
*put_Utf8 = *chilkatc::CkCsr_put_Utf8;
*LastErrorXml = *chilkatc::CkCsr_LastErrorXml;
*LastErrorHtml = *chilkatc::CkCsr_LastErrorHtml;
*LastErrorText = *chilkatc::CkCsr_LastErrorText;
*get_CommonName = *chilkatc::CkCsr_get_CommonName;
*commonName = *chilkatc::CkCsr_commonName;
*put_CommonName = *chilkatc::CkCsr_put_CommonName;
*get_Company = *chilkatc::CkCsr_get_Company;
*company = *chilkatc::CkCsr_company;
*put_Company = *chilkatc::CkCsr_put_Company;
*get_CompanyDivision = *chilkatc::CkCsr_get_CompanyDivision;
*companyDivision = *chilkatc::CkCsr_companyDivision;
*put_CompanyDivision = *chilkatc::CkCsr_put_CompanyDivision;
*get_Country = *chilkatc::CkCsr_get_Country;
*country = *chilkatc::CkCsr_country;
*put_Country = *chilkatc::CkCsr_put_Country;
*get_DebugLogFilePath = *chilkatc::CkCsr_get_DebugLogFilePath;
*debugLogFilePath = *chilkatc::CkCsr_debugLogFilePath;
*put_DebugLogFilePath = *chilkatc::CkCsr_put_DebugLogFilePath;
*get_EmailAddress = *chilkatc::CkCsr_get_EmailAddress;
*emailAddress = *chilkatc::CkCsr_emailAddress;
*put_EmailAddress = *chilkatc::CkCsr_put_EmailAddress;
*get_HashAlgorithm = *chilkatc::CkCsr_get_HashAlgorithm;
*hashAlgorithm = *chilkatc::CkCsr_hashAlgorithm;
*put_HashAlgorithm = *chilkatc::CkCsr_put_HashAlgorithm;
*get_LastErrorHtml = *chilkatc::CkCsr_get_LastErrorHtml;
*lastErrorHtml = *chilkatc::CkCsr_lastErrorHtml;
*get_LastErrorText = *chilkatc::CkCsr_get_LastErrorText;
*lastErrorText = *chilkatc::CkCsr_lastErrorText;
*get_LastErrorXml = *chilkatc::CkCsr_get_LastErrorXml;
*lastErrorXml = *chilkatc::CkCsr_lastErrorXml;
*get_LastMethodSuccess = *chilkatc::CkCsr_get_LastMethodSuccess;
*put_LastMethodSuccess = *chilkatc::CkCsr_put_LastMethodSuccess;
*get_Locality = *chilkatc::CkCsr_get_Locality;
*locality = *chilkatc::CkCsr_locality;
*put_Locality = *chilkatc::CkCsr_put_Locality;
*get_MgfHashAlg = *chilkatc::CkCsr_get_MgfHashAlg;
*mgfHashAlg = *chilkatc::CkCsr_mgfHashAlg;
*put_MgfHashAlg = *chilkatc::CkCsr_put_MgfHashAlg;
*get_PssPadding = *chilkatc::CkCsr_get_PssPadding;
*put_PssPadding = *chilkatc::CkCsr_put_PssPadding;
*get_State = *chilkatc::CkCsr_get_State;
*state = *chilkatc::CkCsr_state;
*put_State = *chilkatc::CkCsr_put_State;
*get_VerboseLogging = *chilkatc::CkCsr_get_VerboseLogging;
*put_VerboseLogging = *chilkatc::CkCsr_put_VerboseLogging;
*get_Version = *chilkatc::CkCsr_get_Version;
*version = *chilkatc::CkCsr_version;
*AddSan = *chilkatc::CkCsr_AddSan;
*GenCsrBd = *chilkatc::CkCsr_GenCsrBd;
*GenCsrPem = *chilkatc::CkCsr_GenCsrPem;
*genCsrPem = *chilkatc::CkCsr_genCsrPem;
*GetExtensionRequest = *chilkatc::CkCsr_GetExtensionRequest;
*GetPublicKey = *chilkatc::CkCsr_GetPublicKey;
*GetSans = *chilkatc::CkCsr_GetSans;
*GetSubjectField = *chilkatc::CkCsr_GetSubjectField;
*getSubjectField = *chilkatc::CkCsr_getSubjectField;
*subjectField = *chilkatc::CkCsr_subjectField;
*LoadCsrPem = *chilkatc::CkCsr_LoadCsrPem;
*SetExtensionRequest = *chilkatc::CkCsr_SetExtensionRequest;
*SetSubjectField = *chilkatc::CkCsr_SetSubjectField;
*VerifyCsr = *chilkatc::CkCsr_VerifyCsr;
sub DISOWN {
    my $self = shift;
    my $ptr = tied(%$self);
    delete $OWNER{$ptr};
}

sub ACQUIRE {
    my $self = shift;
    my $ptr = tied(%$self);
    $OWNER{$ptr} = 1;
}


############# Class : chilkat::CkCsv ##############

package chilkat::CkCsv;
use vars qw(@ISA %OWNER %ITERATORS %BLESSEDMEMBERS);
@ISA = qw( chilkat );
%OWNER = ();
%ITERATORS = ();
sub new {
    my $pkg = shift;
    my $self = chilkatc::new_CkCsv(@_);
    bless $self, $pkg if defined($self);
}

sub DESTROY {
    return unless $_[0]->isa('HASH');
    my $self = tied(%{$_[0]});
    return unless defined $self;
    delete $ITERATORS{$self};
    if (exists $OWNER{$self}) {
        chilkatc::delete_CkCsv($self);
        delete $OWNER{$self};
    }
}

*get_Utf8 = *chilkatc::CkCsv_get_Utf8;
*put_Utf8 = *chilkatc::CkCsv_put_Utf8;
*LastErrorXml = *chilkatc::CkCsv_LastErrorXml;
*LastErrorHtml = *chilkatc::CkCsv_LastErrorHtml;
*LastErrorText = *chilkatc::CkCsv_LastErrorText;
*get_AutoTrim = *chilkatc::CkCsv_get_AutoTrim;
*put_AutoTrim = *chilkatc::CkCsv_put_AutoTrim;
*get_Crlf = *chilkatc::CkCsv_get_Crlf;
*put_Crlf = *chilkatc::CkCsv_put_Crlf;
*get_DebugLogFilePath = *chilkatc::CkCsv_get_DebugLogFilePath;
*debugLogFilePath = *chilkatc::CkCsv_debugLogFilePath;
*put_DebugLogFilePath = *chilkatc::CkCsv_put_DebugLogFilePath;
*get_Delimiter = *chilkatc::CkCsv_get_Delimiter;
*delimiter = *chilkatc::CkCsv_delimiter;
*put_Delimiter = *chilkatc::CkCsv_put_Delimiter;
*get_EnableQuotes = *chilkatc::CkCsv_get_EnableQuotes;
*put_EnableQuotes = *chilkatc::CkCsv_put_EnableQuotes;
*get_EscapeBackslash = *chilkatc::CkCsv_get_EscapeBackslash;
*put_EscapeBackslash = *chilkatc::CkCsv_put_EscapeBackslash;
*get_HasColumnNames = *chilkatc::CkCsv_get_HasColumnNames;
*put_HasColumnNames = *chilkatc::CkCsv_put_HasColumnNames;
*get_LastErrorHtml = *chilkatc::CkCsv_get_LastErrorHtml;
*lastErrorHtml = *chilkatc::CkCsv_lastErrorHtml;
*get_LastErrorText = *chilkatc::CkCsv_get_LastErrorText;
*lastErrorText = *chilkatc::CkCsv_lastErrorText;
*get_LastErrorXml = *chilkatc::CkCsv_get_LastErrorXml;
*lastErrorXml = *chilkatc::CkCsv_lastErrorXml;
*get_LastMethodSuccess = *chilkatc::CkCsv_get_LastMethodSuccess;
*put_LastMethodSuccess = *chilkatc::CkCsv_put_LastMethodSuccess;
*get_NumColumns = *chilkatc::CkCsv_get_NumColumns;
*get_NumRows = *chilkatc::CkCsv_get_NumRows;
*get_UncommonOptions = *chilkatc::CkCsv_get_UncommonOptions;
*uncommonOptions = *chilkatc::CkCsv_uncommonOptions;
*put_UncommonOptions = *chilkatc::CkCsv_put_UncommonOptions;
*get_VerboseLogging = *chilkatc::CkCsv_get_VerboseLogging;
*put_VerboseLogging = *chilkatc::CkCsv_put_VerboseLogging;
*get_Version = *chilkatc::CkCsv_get_Version;
*version = *chilkatc::CkCsv_version;
*get_XlsxDateFormat = *chilkatc::CkCsv_get_XlsxDateFormat;
*xlsxDateFormat = *chilkatc::CkCsv_xlsxDateFormat;
*put_XlsxDateFormat = *chilkatc::CkCsv_put_XlsxDateFormat;
*DeleteColumn = *chilkatc::CkCsv_DeleteColumn;
*DeleteColumnByName = *chilkatc::CkCsv_DeleteColumnByName;
*DeleteRow = *chilkatc::CkCsv_DeleteRow;
*GetCell = *chilkatc::CkCsv_GetCell;
*getCell = *chilkatc::CkCsv_getCell;
*cell = *chilkatc::CkCsv_cell;
*GetCellByName = *chilkatc::CkCsv_GetCellByName;
*getCellByName = *chilkatc::CkCsv_getCellByName;
*cellByName = *chilkatc::CkCsv_cellByName;
*GetColumnName = *chilkatc::CkCsv_GetColumnName;
*getColumnName = *chilkatc::CkCsv_getColumnName;
*columnName = *chilkatc::CkCsv_columnName;
*GetIndex = *chilkatc::CkCsv_GetIndex;
*GetNumCols = *chilkatc::CkCsv_GetNumCols;
*InsertColumn = *chilkatc::CkCsv_InsertColumn;
*LoadFile = *chilkatc::CkCsv_LoadFile;
*LoadFile2 = *chilkatc::CkCsv_LoadFile2;
*LoadFromString = *chilkatc::CkCsv_LoadFromString;
*RowMatches = *chilkatc::CkCsv_RowMatches;
*SaveFile = *chilkatc::CkCsv_SaveFile;
*SaveFile2 = *chilkatc::CkCsv_SaveFile2;
*SaveToSb = *chilkatc::CkCsv_SaveToSb;
*SaveToString = *chilkatc::CkCsv_SaveToString;
*saveToString = *chilkatc::CkCsv_saveToString;
*SetCell = *chilkatc::CkCsv_SetCell;
*SetCellByName = *chilkatc::CkCsv_SetCellByName;
*SetColumnName = *chilkatc::CkCsv_SetColumnName;
*SortByColumn = *chilkatc::CkCsv_SortByColumn;
*SortByColumnIndex = *chilkatc::CkCsv_SortByColumnIndex;
*XlsxGetSheets = *chilkatc::CkCsv_XlsxGetSheets;
*XlsxLoadSheet = *chilkatc::CkCsv_XlsxLoadSheet;
sub DISOWN {
    my $self = shift;
    my $ptr = tied(%$self);
    delete $OWNER{$ptr};
}

sub ACQUIRE {
    my $self = shift;
    my $ptr = tied(%$self);
    $OWNER{$ptr} = 1;
}


############# Class : chilkat::CkDh ##############

package chilkat::CkDh;
use vars qw(@ISA %OWNER %ITERATORS %BLESSEDMEMBERS);
@ISA = qw( chilkat );
%OWNER = ();
%ITERATORS = ();
sub new {
    my $pkg = shift;
    my $self = chilkatc::new_CkDh(@_);
    bless $self, $pkg if defined($self);
}

sub DESTROY {
    return unless $_[0]->isa('HASH');
    my $self = tied(%{$_[0]});
    return unless defined $self;
    delete $ITERATORS{$self};
    if (exists $OWNER{$self}) {
        chilkatc::delete_CkDh($self);
        delete $OWNER{$self};
    }
}

*get_Utf8 = *chilkatc::CkDh_get_Utf8;
*put_Utf8 = *chilkatc::CkDh_put_Utf8;
*LastErrorXml = *chilkatc::CkDh_LastErrorXml;
*LastErrorHtml = *chilkatc::CkDh_LastErrorHtml;
*LastErrorText = *chilkatc::CkDh_LastErrorText;
*get_DebugLogFilePath = *chilkatc::CkDh_get_DebugLogFilePath;
*debugLogFilePath = *chilkatc::CkDh_debugLogFilePath;
*put_DebugLogFilePath = *chilkatc::CkDh_put_DebugLogFilePath;
*get_G = *chilkatc::CkDh_get_G;
*get_LastErrorHtml = *chilkatc::CkDh_get_LastErrorHtml;
*lastErrorHtml = *chilkatc::CkDh_lastErrorHtml;
*get_LastErrorText = *chilkatc::CkDh_get_LastErrorText;
*lastErrorText = *chilkatc::CkDh_lastErrorText;
*get_LastErrorXml = *chilkatc::CkDh_get_LastErrorXml;
*lastErrorXml = *chilkatc::CkDh_lastErrorXml;
*get_LastMethodSuccess = *chilkatc::CkDh_get_LastMethodSuccess;
*put_LastMethodSuccess = *chilkatc::CkDh_put_LastMethodSuccess;
*get_P = *chilkatc::CkDh_get_P;
*p = *chilkatc::CkDh_p;
*get_VerboseLogging = *chilkatc::CkDh_get_VerboseLogging;
*put_VerboseLogging = *chilkatc::CkDh_put_VerboseLogging;
*get_Version = *chilkatc::CkDh_get_Version;
*version = *chilkatc::CkDh_version;
*CreateE = *chilkatc::CkDh_CreateE;
*createE = *chilkatc::CkDh_createE;
*FindK = *chilkatc::CkDh_FindK;
*findK = *chilkatc::CkDh_findK;
*GenPG = *chilkatc::CkDh_GenPG;
*SetPG = *chilkatc::CkDh_SetPG;
*UseKnownPrime = *chilkatc::CkDh_UseKnownPrime;
sub DISOWN {
    my $self = shift;
    my $ptr = tied(%$self);
    delete $OWNER{$ptr};
}

sub ACQUIRE {
    my $self = shift;
    my $ptr = tied(%$self);
    $OWNER{$ptr} = 1;
}


############# Class : chilkat::CkDirTree ##############

package chilkat::CkDirTree;
use vars qw(@ISA %OWNER %ITERATORS %BLESSEDMEMBERS);
@ISA = qw( chilkat );
%OWNER = ();
%ITERATORS = ();
sub new {
    my $pkg = shift;
    my $self = chilkatc::new_CkDirTree(@_);
    bless $self, $pkg if defined($self);
}

sub DESTROY {
    return unless $_[0]->isa('HASH');
    my $self = tied(%{$_[0]});
    return unless defined $self;
    delete $ITERATORS{$self};
    if (exists $OWNER{$self}) {
        chilkatc::delete_CkDirTree($self);
        delete $OWNER{$self};
    }
}

*get_Utf8 = *chilkatc::CkDirTree_get_Utf8;
*put_Utf8 = *chilkatc::CkDirTree_put_Utf8;
*LastErrorXml = *chilkatc::CkDirTree_LastErrorXml;
*LastErrorHtml = *chilkatc::CkDirTree_LastErrorHtml;
*LastErrorText = *chilkatc::CkDirTree_LastErrorText;
*get_BaseDir = *chilkatc::CkDirTree_get_BaseDir;
*baseDir = *chilkatc::CkDirTree_baseDir;
*put_BaseDir = *chilkatc::CkDirTree_put_BaseDir;
*get_DebugLogFilePath = *chilkatc::CkDirTree_get_DebugLogFilePath;
*debugLogFilePath = *chilkatc::CkDirTree_debugLogFilePath;
*put_DebugLogFilePath = *chilkatc::CkDirTree_put_DebugLogFilePath;
*get_DoneIterating = *chilkatc::CkDirTree_get_DoneIterating;
*get_FileSize32 = *chilkatc::CkDirTree_get_FileSize32;
*get_FileSize64 = *chilkatc::CkDirTree_get_FileSize64;
*get_FileSizeStr = *chilkatc::CkDirTree_get_FileSizeStr;
*fileSizeStr = *chilkatc::CkDirTree_fileSizeStr;
*get_FullPath = *chilkatc::CkDirTree_get_FullPath;
*fullPath = *chilkatc::CkDirTree_fullPath;
*get_FullUncPath = *chilkatc::CkDirTree_get_FullUncPath;
*fullUncPath = *chilkatc::CkDirTree_fullUncPath;
*get_IsDirectory = *chilkatc::CkDirTree_get_IsDirectory;
*get_LastErrorHtml = *chilkatc::CkDirTree_get_LastErrorHtml;
*lastErrorHtml = *chilkatc::CkDirTree_lastErrorHtml;
*get_LastErrorText = *chilkatc::CkDirTree_get_LastErrorText;
*lastErrorText = *chilkatc::CkDirTree_lastErrorText;
*get_LastErrorXml = *chilkatc::CkDirTree_get_LastErrorXml;
*lastErrorXml = *chilkatc::CkDirTree_lastErrorXml;
*get_LastMethodSuccess = *chilkatc::CkDirTree_get_LastMethodSuccess;
*put_LastMethodSuccess = *chilkatc::CkDirTree_put_LastMethodSuccess;
*get_Recurse = *chilkatc::CkDirTree_get_Recurse;
*put_Recurse = *chilkatc::CkDirTree_put_Recurse;
*get_RelativePath = *chilkatc::CkDirTree_get_RelativePath;
*relativePath = *chilkatc::CkDirTree_relativePath;
*get_UncommonOptions = *chilkatc::CkDirTree_get_UncommonOptions;
*uncommonOptions = *chilkatc::CkDirTree_uncommonOptions;
*put_UncommonOptions = *chilkatc::CkDirTree_put_UncommonOptions;
*get_VerboseLogging = *chilkatc::CkDirTree_get_VerboseLogging;
*put_VerboseLogging = *chilkatc::CkDirTree_put_VerboseLogging;
*get_Version = *chilkatc::CkDirTree_get_Version;
*version = *chilkatc::CkDirTree_version;
*AdvancePosition = *chilkatc::CkDirTree_AdvancePosition;
*BeginIterate = *chilkatc::CkDirTree_BeginIterate;
sub DISOWN {
    my $self = shift;
    my $ptr = tied(%$self);
    delete $OWNER{$ptr};
}

sub ACQUIRE {
    my $self = shift;
    my $ptr = tied(%$self);
    $OWNER{$ptr} = 1;
}


############# Class : chilkat::CkDkim ##############

package chilkat::CkDkim;
use vars qw(@ISA %OWNER %ITERATORS %BLESSEDMEMBERS);
@ISA = qw( chilkat );
%OWNER = ();
%ITERATORS = ();
sub new {
    my $pkg = shift;
    my $self = chilkatc::new_CkDkim(@_);
    bless $self, $pkg if defined($self);
}

sub DESTROY {
    return unless $_[0]->isa('HASH');
    my $self = tied(%{$_[0]});
    return unless defined $self;
    delete $ITERATORS{$self};
    if (exists $OWNER{$self}) {
        chilkatc::delete_CkDkim($self);
        delete $OWNER{$self};
    }
}

*get_Utf8 = *chilkatc::CkDkim_get_Utf8;
*put_Utf8 = *chilkatc::CkDkim_put_Utf8;
*LastErrorXml = *chilkatc::CkDkim_LastErrorXml;
*LastErrorHtml = *chilkatc::CkDkim_LastErrorHtml;
*LastErrorText = *chilkatc::CkDkim_LastErrorText;
*put_EventCallbackObject = *chilkatc::CkDkim_put_EventCallbackObject;
*get_AbortCurrent = *chilkatc::CkDkim_get_AbortCurrent;
*put_AbortCurrent = *chilkatc::CkDkim_put_AbortCurrent;
*get_DebugLogFilePath = *chilkatc::CkDkim_get_DebugLogFilePath;
*debugLogFilePath = *chilkatc::CkDkim_debugLogFilePath;
*put_DebugLogFilePath = *chilkatc::CkDkim_put_DebugLogFilePath;
*get_DkimAlg = *chilkatc::CkDkim_get_DkimAlg;
*dkimAlg = *chilkatc::CkDkim_dkimAlg;
*put_DkimAlg = *chilkatc::CkDkim_put_DkimAlg;
*get_DkimBodyLengthCount = *chilkatc::CkDkim_get_DkimBodyLengthCount;
*put_DkimBodyLengthCount = *chilkatc::CkDkim_put_DkimBodyLengthCount;
*get_DkimCanon = *chilkatc::CkDkim_get_DkimCanon;
*dkimCanon = *chilkatc::CkDkim_dkimCanon;
*put_DkimCanon = *chilkatc::CkDkim_put_DkimCanon;
*get_DkimDomain = *chilkatc::CkDkim_get_DkimDomain;
*dkimDomain = *chilkatc::CkDkim_dkimDomain;
*put_DkimDomain = *chilkatc::CkDkim_put_DkimDomain;
*get_DkimHeaders = *chilkatc::CkDkim_get_DkimHeaders;
*dkimHeaders = *chilkatc::CkDkim_dkimHeaders;
*put_DkimHeaders = *chilkatc::CkDkim_put_DkimHeaders;
*get_DkimSelector = *chilkatc::CkDkim_get_DkimSelector;
*dkimSelector = *chilkatc::CkDkim_dkimSelector;
*put_DkimSelector = *chilkatc::CkDkim_put_DkimSelector;
*get_DomainKeyAlg = *chilkatc::CkDkim_get_DomainKeyAlg;
*domainKeyAlg = *chilkatc::CkDkim_domainKeyAlg;
*put_DomainKeyAlg = *chilkatc::CkDkim_put_DomainKeyAlg;
*get_DomainKeyCanon = *chilkatc::CkDkim_get_DomainKeyCanon;
*domainKeyCanon = *chilkatc::CkDkim_domainKeyCanon;
*put_DomainKeyCanon = *chilkatc::CkDkim_put_DomainKeyCanon;
*get_DomainKeyDomain = *chilkatc::CkDkim_get_DomainKeyDomain;
*domainKeyDomain = *chilkatc::CkDkim_domainKeyDomain;
*put_DomainKeyDomain = *chilkatc::CkDkim_put_DomainKeyDomain;
*get_DomainKeyHeaders = *chilkatc::CkDkim_get_DomainKeyHeaders;
*domainKeyHeaders = *chilkatc::CkDkim_domainKeyHeaders;
*put_DomainKeyHeaders = *chilkatc::CkDkim_put_DomainKeyHeaders;
*get_DomainKeySelector = *chilkatc::CkDkim_get_DomainKeySelector;
*domainKeySelector = *chilkatc::CkDkim_domainKeySelector;
*put_DomainKeySelector = *chilkatc::CkDkim_put_DomainKeySelector;
*get_HeartbeatMs = *chilkatc::CkDkim_get_HeartbeatMs;
*put_HeartbeatMs = *chilkatc::CkDkim_put_HeartbeatMs;
*get_LastErrorHtml = *chilkatc::CkDkim_get_LastErrorHtml;
*lastErrorHtml = *chilkatc::CkDkim_lastErrorHtml;
*get_LastErrorText = *chilkatc::CkDkim_get_LastErrorText;
*lastErrorText = *chilkatc::CkDkim_lastErrorText;
*get_LastErrorXml = *chilkatc::CkDkim_get_LastErrorXml;
*lastErrorXml = *chilkatc::CkDkim_lastErrorXml;
*get_LastMethodSuccess = *chilkatc::CkDkim_get_LastMethodSuccess;
*put_LastMethodSuccess = *chilkatc::CkDkim_put_LastMethodSuccess;
*get_VerboseLogging = *chilkatc::CkDkim_get_VerboseLogging;
*put_VerboseLogging = *chilkatc::CkDkim_put_VerboseLogging;
*get_VerifyInfo = *chilkatc::CkDkim_get_VerifyInfo;
*verifyInfo = *chilkatc::CkDkim_verifyInfo;
*get_Version = *chilkatc::CkDkim_get_Version;
*version = *chilkatc::CkDkim_version;
*DkimSign = *chilkatc::CkDkim_DkimSign;
*DkimVerify = *chilkatc::CkDkim_DkimVerify;
*DomainKeySign = *chilkatc::CkDkim_DomainKeySign;
*DomainKeyVerify = *chilkatc::CkDkim_DomainKeyVerify;
*LoadPublicKey = *chilkatc::CkDkim_LoadPublicKey;
*LoadPublicKeyFile = *chilkatc::CkDkim_LoadPublicKeyFile;
*LoadTaskCaller = *chilkatc::CkDkim_LoadTaskCaller;
*NumDkimSigs = *chilkatc::CkDkim_NumDkimSigs;
*NumDomainKeySigs = *chilkatc::CkDkim_NumDomainKeySigs;
*PrefetchPublicKey = *chilkatc::CkDkim_PrefetchPublicKey;
*PrefetchPublicKeyAsync = *chilkatc::CkDkim_PrefetchPublicKeyAsync;
*SetDkimPrivateKey = *chilkatc::CkDkim_SetDkimPrivateKey;
*SetDomainKeyPrivateKey = *chilkatc::CkDkim_SetDomainKeyPrivateKey;
sub DISOWN {
    my $self = shift;
    my $ptr = tied(%$self);
    delete $OWNER{$ptr};
}

sub ACQUIRE {
    my $self = shift;
    my $ptr = tied(%$self);
    $OWNER{$ptr} = 1;
}


############# Class : chilkat::CkDns ##############

package chilkat::CkDns;
use vars qw(@ISA %OWNER %ITERATORS %BLESSEDMEMBERS);
@ISA = qw( chilkat );
%OWNER = ();
%ITERATORS = ();
sub new {
    my $pkg = shift;
    my $self = chilkatc::new_CkDns(@_);
    bless $self, $pkg if defined($self);
}

sub DESTROY {
    return unless $_[0]->isa('HASH');
    my $self = tied(%{$_[0]});
    return unless defined $self;
    delete $ITERATORS{$self};
    if (exists $OWNER{$self}) {
        chilkatc::delete_CkDns($self);
        delete $OWNER{$self};
    }
}

*get_Utf8 = *chilkatc::CkDns_get_Utf8;
*put_Utf8 = *chilkatc::CkDns_put_Utf8;
*LastErrorXml = *chilkatc::CkDns_LastErrorXml;
*LastErrorHtml = *chilkatc::CkDns_LastErrorHtml;
*LastErrorText = *chilkatc::CkDns_LastErrorText;
*put_EventCallbackObject = *chilkatc::CkDns_put_EventCallbackObject;
*get_DebugLogFilePath = *chilkatc::CkDns_get_DebugLogFilePath;
*debugLogFilePath = *chilkatc::CkDns_debugLogFilePath;
*put_DebugLogFilePath = *chilkatc::CkDns_put_DebugLogFilePath;
*get_HeartbeatMs = *chilkatc::CkDns_get_HeartbeatMs;
*put_HeartbeatMs = *chilkatc::CkDns_put_HeartbeatMs;
*get_LastErrorHtml = *chilkatc::CkDns_get_LastErrorHtml;
*lastErrorHtml = *chilkatc::CkDns_lastErrorHtml;
*get_LastErrorText = *chilkatc::CkDns_get_LastErrorText;
*lastErrorText = *chilkatc::CkDns_lastErrorText;
*get_LastErrorXml = *chilkatc::CkDns_get_LastErrorXml;
*lastErrorXml = *chilkatc::CkDns_lastErrorXml;
*get_LastMethodSuccess = *chilkatc::CkDns_get_LastMethodSuccess;
*put_LastMethodSuccess = *chilkatc::CkDns_put_LastMethodSuccess;
*get_MaxWaitMs = *chilkatc::CkDns_get_MaxWaitMs;
*put_MaxWaitMs = *chilkatc::CkDns_put_MaxWaitMs;
*get_NumNameservers = *chilkatc::CkDns_get_NumNameservers;
*get_TlsPref = *chilkatc::CkDns_get_TlsPref;
*put_TlsPref = *chilkatc::CkDns_put_TlsPref;
*get_VerboseLogging = *chilkatc::CkDns_get_VerboseLogging;
*put_VerboseLogging = *chilkatc::CkDns_put_VerboseLogging;
*get_Version = *chilkatc::CkDns_get_Version;
*version = *chilkatc::CkDns_version;
*AddDefaultNameservers = *chilkatc::CkDns_AddDefaultNameservers;
*AddNameserver = *chilkatc::CkDns_AddNameserver;
*GetNameserver = *chilkatc::CkDns_GetNameserver;
*getNameserver = *chilkatc::CkDns_getNameserver;
*nameserver = *chilkatc::CkDns_nameserver;
*Query = *chilkatc::CkDns_Query;
*QueryAsync = *chilkatc::CkDns_QueryAsync;
*RemoveAllNameservers = *chilkatc::CkDns_RemoveAllNameservers;
*RemoveNameserver = *chilkatc::CkDns_RemoveNameserver;
sub DISOWN {
    my $self = shift;
    my $ptr = tied(%$self);
    delete $OWNER{$ptr};
}

sub ACQUIRE {
    my $self = shift;
    my $ptr = tied(%$self);
    $OWNER{$ptr} = 1;
}


############# Class : chilkat::CkDsa ##############

package chilkat::CkDsa;
use vars qw(@ISA %OWNER %ITERATORS %BLESSEDMEMBERS);
@ISA = qw( chilkat );
%OWNER = ();
%ITERATORS = ();
sub new {
    my $pkg = shift;
    my $self = chilkatc::new_CkDsa(@_);
    bless $self, $pkg if defined($self);
}

sub DESTROY {
    return unless $_[0]->isa('HASH');
    my $self = tied(%{$_[0]});
    return unless defined $self;
    delete $ITERATORS{$self};
    if (exists $OWNER{$self}) {
        chilkatc::delete_CkDsa($self);
        delete $OWNER{$self};
    }
}

*get_Utf8 = *chilkatc::CkDsa_get_Utf8;
*put_Utf8 = *chilkatc::CkDsa_put_Utf8;
*LastErrorXml = *chilkatc::CkDsa_LastErrorXml;
*LastErrorHtml = *chilkatc::CkDsa_LastErrorHtml;
*LastErrorText = *chilkatc::CkDsa_LastErrorText;
*get_DebugLogFilePath = *chilkatc::CkDsa_get_DebugLogFilePath;
*debugLogFilePath = *chilkatc::CkDsa_debugLogFilePath;
*put_DebugLogFilePath = *chilkatc::CkDsa_put_DebugLogFilePath;
*get_GroupSize = *chilkatc::CkDsa_get_GroupSize;
*put_GroupSize = *chilkatc::CkDsa_put_GroupSize;
*get_HexG = *chilkatc::CkDsa_get_HexG;
*hexG = *chilkatc::CkDsa_hexG;
*get_HexP = *chilkatc::CkDsa_get_HexP;
*hexP = *chilkatc::CkDsa_hexP;
*get_HexQ = *chilkatc::CkDsa_get_HexQ;
*hexQ = *chilkatc::CkDsa_hexQ;
*get_HexX = *chilkatc::CkDsa_get_HexX;
*hexX = *chilkatc::CkDsa_hexX;
*get_HexY = *chilkatc::CkDsa_get_HexY;
*hexY = *chilkatc::CkDsa_hexY;
*get_LastErrorHtml = *chilkatc::CkDsa_get_LastErrorHtml;
*lastErrorHtml = *chilkatc::CkDsa_lastErrorHtml;
*get_LastErrorText = *chilkatc::CkDsa_get_LastErrorText;
*lastErrorText = *chilkatc::CkDsa_lastErrorText;
*get_LastErrorXml = *chilkatc::CkDsa_get_LastErrorXml;
*lastErrorXml = *chilkatc::CkDsa_lastErrorXml;
*get_LastMethodSuccess = *chilkatc::CkDsa_get_LastMethodSuccess;
*put_LastMethodSuccess = *chilkatc::CkDsa_put_LastMethodSuccess;
*get_UncommonOptions = *chilkatc::CkDsa_get_UncommonOptions;
*uncommonOptions = *chilkatc::CkDsa_uncommonOptions;
*put_UncommonOptions = *chilkatc::CkDsa_put_UncommonOptions;
*get_VerboseLogging = *chilkatc::CkDsa_get_VerboseLogging;
*put_VerboseLogging = *chilkatc::CkDsa_put_VerboseLogging;
*get_Version = *chilkatc::CkDsa_get_Version;
*version = *chilkatc::CkDsa_version;
*FromDer = *chilkatc::CkDsa_FromDer;
*FromDerBd = *chilkatc::CkDsa_FromDerBd;
*FromDerFile = *chilkatc::CkDsa_FromDerFile;
*FromEncryptedPem = *chilkatc::CkDsa_FromEncryptedPem;
*FromPem = *chilkatc::CkDsa_FromPem;
*FromPublicDer = *chilkatc::CkDsa_FromPublicDer;
*FromPublicDerBd = *chilkatc::CkDsa_FromPublicDerBd;
*FromPublicDerFile = *chilkatc::CkDsa_FromPublicDerFile;
*FromPublicPem = *chilkatc::CkDsa_FromPublicPem;
*FromXml = *chilkatc::CkDsa_FromXml;
*GenKey = *chilkatc::CkDsa_GenKey;
*GenKey2 = *chilkatc::CkDsa_GenKey2;
*GenKeyFromParamsDer = *chilkatc::CkDsa_GenKeyFromParamsDer;
*GenKeyFromParamsDerBd = *chilkatc::CkDsa_GenKeyFromParamsDerBd;
*GenKeyFromParamsDerFile = *chilkatc::CkDsa_GenKeyFromParamsDerFile;
*GenKeyFromParamsPem = *chilkatc::CkDsa_GenKeyFromParamsPem;
*GenKeyFromParamsPemFile = *chilkatc::CkDsa_GenKeyFromParamsPemFile;
*GenKeyFromPQG = *chilkatc::CkDsa_GenKeyFromPQG;
*GetEncodedHash = *chilkatc::CkDsa_GetEncodedHash;
*getEncodedHash = *chilkatc::CkDsa_getEncodedHash;
*encodedHash = *chilkatc::CkDsa_encodedHash;
*GetEncodedSignature = *chilkatc::CkDsa_GetEncodedSignature;
*getEncodedSignature = *chilkatc::CkDsa_getEncodedSignature;
*encodedSignature = *chilkatc::CkDsa_encodedSignature;
*LoadText = *chilkatc::CkDsa_LoadText;
*loadText = *chilkatc::CkDsa_loadText;
*SaveText = *chilkatc::CkDsa_SaveText;
*SetEncodedHash = *chilkatc::CkDsa_SetEncodedHash;
*SetEncodedSignature = *chilkatc::CkDsa_SetEncodedSignature;
*SetEncodedSignatureRS = *chilkatc::CkDsa_SetEncodedSignatureRS;
*SetKeyExplicit = *chilkatc::CkDsa_SetKeyExplicit;
*SetPubKeyExplicit = *chilkatc::CkDsa_SetPubKeyExplicit;
*SignHash = *chilkatc::CkDsa_SignHash;
*ToDer = *chilkatc::CkDsa_ToDer;
*ToDerBd = *chilkatc::CkDsa_ToDerBd;
*ToDerFile = *chilkatc::CkDsa_ToDerFile;
*ToEncryptedPem = *chilkatc::CkDsa_ToEncryptedPem;
*toEncryptedPem = *chilkatc::CkDsa_toEncryptedPem;
*ToPem = *chilkatc::CkDsa_ToPem;
*toPem = *chilkatc::CkDsa_toPem;
*ToPublicDer = *chilkatc::CkDsa_ToPublicDer;
*ToPublicDerBd = *chilkatc::CkDsa_ToPublicDerBd;
*ToPublicDerFile = *chilkatc::CkDsa_ToPublicDerFile;
*ToPublicPem = *chilkatc::CkDsa_ToPublicPem;
*toPublicPem = *chilkatc::CkDsa_toPublicPem;
*ToXml = *chilkatc::CkDsa_ToXml;
*toXml = *chilkatc::CkDsa_toXml;
*Verify = *chilkatc::CkDsa_Verify;
*VerifyKey = *chilkatc::CkDsa_VerifyKey;
sub DISOWN {
    my $self = shift;
    my $ptr = tied(%$self);
    delete $OWNER{$ptr};
}

sub ACQUIRE {
    my $self = shift;
    my $ptr = tied(%$self);
    $OWNER{$ptr} = 1;
}


############# Class : chilkat::CkEcc ##############

package chilkat::CkEcc;
use vars qw(@ISA %OWNER %ITERATORS %BLESSEDMEMBERS);
@ISA = qw( chilkat );
%OWNER = ();
%ITERATORS = ();
sub new {
    my $pkg = shift;
    my $self = chilkatc::new_CkEcc(@_);
    bless $self, $pkg if defined($self);
}

sub DESTROY {
    return unless $_[0]->isa('HASH');
    my $self = tied(%{$_[0]});
    return unless defined $self;
    delete $ITERATORS{$self};
    if (exists $OWNER{$self}) {
        chilkatc::delete_CkEcc($self);
        delete $OWNER{$self};
    }
}

*get_Utf8 = *chilkatc::CkEcc_get_Utf8;
*put_Utf8 = *chilkatc::CkEcc_put_Utf8;
*LastErrorXml = *chilkatc::CkEcc_LastErrorXml;
*LastErrorHtml = *chilkatc::CkEcc_LastErrorHtml;
*LastErrorText = *chilkatc::CkEcc_LastErrorText;
*get_AsnFormat = *chilkatc::CkEcc_get_AsnFormat;
*put_AsnFormat = *chilkatc::CkEcc_put_AsnFormat;
*get_DebugLogFilePath = *chilkatc::CkEcc_get_DebugLogFilePath;
*debugLogFilePath = *chilkatc::CkEcc_debugLogFilePath;
*put_DebugLogFilePath = *chilkatc::CkEcc_put_DebugLogFilePath;
*get_LastErrorHtml = *chilkatc::CkEcc_get_LastErrorHtml;
*lastErrorHtml = *chilkatc::CkEcc_lastErrorHtml;
*get_LastErrorText = *chilkatc::CkEcc_get_LastErrorText;
*lastErrorText = *chilkatc::CkEcc_lastErrorText;
*get_LastErrorXml = *chilkatc::CkEcc_get_LastErrorXml;
*lastErrorXml = *chilkatc::CkEcc_lastErrorXml;
*get_LastMethodSuccess = *chilkatc::CkEcc_get_LastMethodSuccess;
*put_LastMethodSuccess = *chilkatc::CkEcc_put_LastMethodSuccess;
*get_VerboseLogging = *chilkatc::CkEcc_get_VerboseLogging;
*put_VerboseLogging = *chilkatc::CkEcc_put_VerboseLogging;
*get_Version = *chilkatc::CkEcc_get_Version;
*version = *chilkatc::CkEcc_version;
*GenEccKey = *chilkatc::CkEcc_GenEccKey;
*GenEccKey2 = *chilkatc::CkEcc_GenEccKey2;
*GenKey = *chilkatc::CkEcc_GenKey;
*GenKey2 = *chilkatc::CkEcc_GenKey2;
*SharedSecretENC = *chilkatc::CkEcc_SharedSecretENC;
*sharedSecretENC = *chilkatc::CkEcc_sharedSecretENC;
*SignBd = *chilkatc::CkEcc_SignBd;
*signBd = *chilkatc::CkEcc_signBd;
*SignBdUsingCert = *chilkatc::CkEcc_SignBdUsingCert;
*signBdUsingCert = *chilkatc::CkEcc_signBdUsingCert;
*SignHashENC = *chilkatc::CkEcc_SignHashENC;
*signHashENC = *chilkatc::CkEcc_signHashENC;
*SignHashUsingCert = *chilkatc::CkEcc_SignHashUsingCert;
*signHashUsingCert = *chilkatc::CkEcc_signHashUsingCert;
*VerifyBd = *chilkatc::CkEcc_VerifyBd;
*VerifyHashENC = *chilkatc::CkEcc_VerifyHashENC;
sub DISOWN {
    my $self = shift;
    my $ptr = tied(%$self);
    delete $OWNER{$ptr};
}

sub ACQUIRE {
    my $self = shift;
    my $ptr = tied(%$self);
    $OWNER{$ptr} = 1;
}


############# Class : chilkat::CkEdDSA ##############

package chilkat::CkEdDSA;
use vars qw(@ISA %OWNER %ITERATORS %BLESSEDMEMBERS);
@ISA = qw( chilkat );
%OWNER = ();
%ITERATORS = ();
sub new {
    my $pkg = shift;
    my $self = chilkatc::new_CkEdDSA(@_);
    bless $self, $pkg if defined($self);
}

sub DESTROY {
    return unless $_[0]->isa('HASH');
    my $self = tied(%{$_[0]});
    return unless defined $self;
    delete $ITERATORS{$self};
    if (exists $OWNER{$self}) {
        chilkatc::delete_CkEdDSA($self);
        delete $OWNER{$self};
    }
}

*get_Utf8 = *chilkatc::CkEdDSA_get_Utf8;
*put_Utf8 = *chilkatc::CkEdDSA_put_Utf8;
*LastErrorXml = *chilkatc::CkEdDSA_LastErrorXml;
*LastErrorHtml = *chilkatc::CkEdDSA_LastErrorHtml;
*LastErrorText = *chilkatc::CkEdDSA_LastErrorText;
*get_Algorithm = *chilkatc::CkEdDSA_get_Algorithm;
*algorithm = *chilkatc::CkEdDSA_algorithm;
*put_Algorithm = *chilkatc::CkEdDSA_put_Algorithm;
*get_Context = *chilkatc::CkEdDSA_get_Context;
*context = *chilkatc::CkEdDSA_context;
*put_Context = *chilkatc::CkEdDSA_put_Context;
*get_DebugLogFilePath = *chilkatc::CkEdDSA_get_DebugLogFilePath;
*debugLogFilePath = *chilkatc::CkEdDSA_debugLogFilePath;
*put_DebugLogFilePath = *chilkatc::CkEdDSA_put_DebugLogFilePath;
*get_LastErrorHtml = *chilkatc::CkEdDSA_get_LastErrorHtml;
*lastErrorHtml = *chilkatc::CkEdDSA_lastErrorHtml;
*get_LastErrorText = *chilkatc::CkEdDSA_get_LastErrorText;
*lastErrorText = *chilkatc::CkEdDSA_lastErrorText;
*get_LastErrorXml = *chilkatc::CkEdDSA_get_LastErrorXml;
*lastErrorXml = *chilkatc::CkEdDSA_lastErrorXml;
*get_LastMethodSuccess = *chilkatc::CkEdDSA_get_LastMethodSuccess;
*put_LastMethodSuccess = *chilkatc::CkEdDSA_put_LastMethodSuccess;
*get_VerboseLogging = *chilkatc::CkEdDSA_get_VerboseLogging;
*put_VerboseLogging = *chilkatc::CkEdDSA_put_VerboseLogging;
*get_Version = *chilkatc::CkEdDSA_get_Version;
*version = *chilkatc::CkEdDSA_version;
*GenEd25519Key = *chilkatc::CkEdDSA_GenEd25519Key;
*SharedSecretENC = *chilkatc::CkEdDSA_SharedSecretENC;
*sharedSecretENC = *chilkatc::CkEdDSA_sharedSecretENC;
*SignBdENC = *chilkatc::CkEdDSA_SignBdENC;
*signBdENC = *chilkatc::CkEdDSA_signBdENC;
*VerifyBdENC = *chilkatc::CkEdDSA_VerifyBdENC;
sub DISOWN {
    my $self = shift;
    my $ptr = tied(%$self);
    delete $OWNER{$ptr};
}

sub ACQUIRE {
    my $self = shift;
    my $ptr = tied(%$self);
    $OWNER{$ptr} = 1;
}


############# Class : chilkat::CkEmail ##############

package chilkat::CkEmail;
use vars qw(@ISA %OWNER %ITERATORS %BLESSEDMEMBERS);
@ISA = qw( chilkat );
%OWNER = ();
%ITERATORS = ();
sub new {
    my $pkg = shift;
    my $self = chilkatc::new_CkEmail(@_);
    bless $self, $pkg if defined($self);
}

sub DESTROY {
    return unless $_[0]->isa('HASH');
    my $self = tied(%{$_[0]});
    return unless defined $self;
    delete $ITERATORS{$self};
    if (exists $OWNER{$self}) {
        chilkatc::delete_CkEmail($self);
        delete $OWNER{$self};
    }
}

*get_Utf8 = *chilkatc::CkEmail_get_Utf8;
*put_Utf8 = *chilkatc::CkEmail_put_Utf8;
*LastErrorXml = *chilkatc::CkEmail_LastErrorXml;
*LastErrorHtml = *chilkatc::CkEmail_LastErrorHtml;
*LastErrorText = *chilkatc::CkEmail_LastErrorText;
*get_Body = *chilkatc::CkEmail_get_Body;
*body = *chilkatc::CkEmail_body;
*put_Body = *chilkatc::CkEmail_put_Body;
*get_BounceAddress = *chilkatc::CkEmail_get_BounceAddress;
*bounceAddress = *chilkatc::CkEmail_bounceAddress;
*put_BounceAddress = *chilkatc::CkEmail_put_BounceAddress;
*get_Charset = *chilkatc::CkEmail_get_Charset;
*charset = *chilkatc::CkEmail_charset;
*put_Charset = *chilkatc::CkEmail_put_Charset;
*get_DebugLogFilePath = *chilkatc::CkEmail_get_DebugLogFilePath;
*debugLogFilePath = *chilkatc::CkEmail_debugLogFilePath;
*put_DebugLogFilePath = *chilkatc::CkEmail_put_DebugLogFilePath;
*get_Decrypted = *chilkatc::CkEmail_get_Decrypted;
*get_EmailDateStr = *chilkatc::CkEmail_get_EmailDateStr;
*emailDateStr = *chilkatc::CkEmail_emailDateStr;
*put_EmailDateStr = *chilkatc::CkEmail_put_EmailDateStr;
*get_EncryptedBy = *chilkatc::CkEmail_get_EncryptedBy;
*encryptedBy = *chilkatc::CkEmail_encryptedBy;
*get_FileDistList = *chilkatc::CkEmail_get_FileDistList;
*fileDistList = *chilkatc::CkEmail_fileDistList;
*put_FileDistList = *chilkatc::CkEmail_put_FileDistList;
*get_From = *chilkatc::CkEmail_get_From;
*ck_from = *chilkatc::CkEmail_ck_from;
*put_From = *chilkatc::CkEmail_put_From;
*get_FromAddress = *chilkatc::CkEmail_get_FromAddress;
*fromAddress = *chilkatc::CkEmail_fromAddress;
*put_FromAddress = *chilkatc::CkEmail_put_FromAddress;
*get_FromName = *chilkatc::CkEmail_get_FromName;
*fromName = *chilkatc::CkEmail_fromName;
*put_FromName = *chilkatc::CkEmail_put_FromName;
*get_Header = *chilkatc::CkEmail_get_Header;
*header = *chilkatc::CkEmail_header;
*get_Language = *chilkatc::CkEmail_get_Language;
*language = *chilkatc::CkEmail_language;
*get_LastErrorHtml = *chilkatc::CkEmail_get_LastErrorHtml;
*lastErrorHtml = *chilkatc::CkEmail_lastErrorHtml;
*get_LastErrorText = *chilkatc::CkEmail_get_LastErrorText;
*lastErrorText = *chilkatc::CkEmail_lastErrorText;
*get_LastErrorXml = *chilkatc::CkEmail_get_LastErrorXml;
*lastErrorXml = *chilkatc::CkEmail_lastErrorXml;
*get_LastMethodSuccess = *chilkatc::CkEmail_get_LastMethodSuccess;
*put_LastMethodSuccess = *chilkatc::CkEmail_put_LastMethodSuccess;
*get_LocalDateStr = *chilkatc::CkEmail_get_LocalDateStr;
*localDateStr = *chilkatc::CkEmail_localDateStr;
*put_LocalDateStr = *chilkatc::CkEmail_put_LocalDateStr;
*get_Mailer = *chilkatc::CkEmail_get_Mailer;
*mailer = *chilkatc::CkEmail_mailer;
*put_Mailer = *chilkatc::CkEmail_put_Mailer;
*get_NumAlternatives = *chilkatc::CkEmail_get_NumAlternatives;
*get_NumAttachedMessages = *chilkatc::CkEmail_get_NumAttachedMessages;
*get_NumAttachments = *chilkatc::CkEmail_get_NumAttachments;
*get_NumBcc = *chilkatc::CkEmail_get_NumBcc;
*get_NumCC = *chilkatc::CkEmail_get_NumCC;
*get_NumDaysOld = *chilkatc::CkEmail_get_NumDaysOld;
*get_NumDigests = *chilkatc::CkEmail_get_NumDigests;
*get_NumHeaderFields = *chilkatc::CkEmail_get_NumHeaderFields;
*get_NumRelatedItems = *chilkatc::CkEmail_get_NumRelatedItems;
*get_NumReplacePatterns = *chilkatc::CkEmail_get_NumReplacePatterns;
*get_NumReports = *chilkatc::CkEmail_get_NumReports;
*get_NumTo = *chilkatc::CkEmail_get_NumTo;
*get_OaepHash = *chilkatc::CkEmail_get_OaepHash;
*oaepHash = *chilkatc::CkEmail_oaepHash;
*put_OaepHash = *chilkatc::CkEmail_put_OaepHash;
*get_OaepMgfHash = *chilkatc::CkEmail_get_OaepMgfHash;
*oaepMgfHash = *chilkatc::CkEmail_oaepMgfHash;
*put_OaepMgfHash = *chilkatc::CkEmail_put_OaepMgfHash;
*get_OaepPadding = *chilkatc::CkEmail_get_OaepPadding;
*put_OaepPadding = *chilkatc::CkEmail_put_OaepPadding;
*get_OverwriteExisting = *chilkatc::CkEmail_get_OverwriteExisting;
*put_OverwriteExisting = *chilkatc::CkEmail_put_OverwriteExisting;
*get_Pkcs7CryptAlg = *chilkatc::CkEmail_get_Pkcs7CryptAlg;
*pkcs7CryptAlg = *chilkatc::CkEmail_pkcs7CryptAlg;
*put_Pkcs7CryptAlg = *chilkatc::CkEmail_put_Pkcs7CryptAlg;
*get_Pkcs7KeyLength = *chilkatc::CkEmail_get_Pkcs7KeyLength;
*put_Pkcs7KeyLength = *chilkatc::CkEmail_put_Pkcs7KeyLength;
*get_PreferredCharset = *chilkatc::CkEmail_get_PreferredCharset;
*preferredCharset = *chilkatc::CkEmail_preferredCharset;
*put_PreferredCharset = *chilkatc::CkEmail_put_PreferredCharset;
*get_PrependHeaders = *chilkatc::CkEmail_get_PrependHeaders;
*put_PrependHeaders = *chilkatc::CkEmail_put_PrependHeaders;
*get_ReceivedEncrypted = *chilkatc::CkEmail_get_ReceivedEncrypted;
*get_ReceivedSigned = *chilkatc::CkEmail_get_ReceivedSigned;
*get_ReplyTo = *chilkatc::CkEmail_get_ReplyTo;
*replyTo = *chilkatc::CkEmail_replyTo;
*put_ReplyTo = *chilkatc::CkEmail_put_ReplyTo;
*get_ReturnReceipt = *chilkatc::CkEmail_get_ReturnReceipt;
*put_ReturnReceipt = *chilkatc::CkEmail_put_ReturnReceipt;
*get_SendEncrypted = *chilkatc::CkEmail_get_SendEncrypted;
*put_SendEncrypted = *chilkatc::CkEmail_put_SendEncrypted;
*get_SendSigned = *chilkatc::CkEmail_get_SendSigned;
*put_SendSigned = *chilkatc::CkEmail_put_SendSigned;
*get_SignaturesValid = *chilkatc::CkEmail_get_SignaturesValid;
*get_SignedBy = *chilkatc::CkEmail_get_SignedBy;
*signedBy = *chilkatc::CkEmail_signedBy;
*get_SigningAlg = *chilkatc::CkEmail_get_SigningAlg;
*signingAlg = *chilkatc::CkEmail_signingAlg;
*put_SigningAlg = *chilkatc::CkEmail_put_SigningAlg;
*get_SigningHashAlg = *chilkatc::CkEmail_get_SigningHashAlg;
*signingHashAlg = *chilkatc::CkEmail_signingHashAlg;
*put_SigningHashAlg = *chilkatc::CkEmail_put_SigningHashAlg;
*get_Size = *chilkatc::CkEmail_get_Size;
*get_Subject = *chilkatc::CkEmail_get_Subject;
*subject = *chilkatc::CkEmail_subject;
*put_Subject = *chilkatc::CkEmail_put_Subject;
*get_Uidl = *chilkatc::CkEmail_get_Uidl;
*uidl = *chilkatc::CkEmail_uidl;
*get_UncommonOptions = *chilkatc::CkEmail_get_UncommonOptions;
*uncommonOptions = *chilkatc::CkEmail_uncommonOptions;
*put_UncommonOptions = *chilkatc::CkEmail_put_UncommonOptions;
*get_UnpackUseRelPaths = *chilkatc::CkEmail_get_UnpackUseRelPaths;
*put_UnpackUseRelPaths = *chilkatc::CkEmail_put_UnpackUseRelPaths;
*get_VerboseLogging = *chilkatc::CkEmail_get_VerboseLogging;
*put_VerboseLogging = *chilkatc::CkEmail_put_VerboseLogging;
*get_Version = *chilkatc::CkEmail_get_Version;
*version = *chilkatc::CkEmail_version;
*AddAttachmentBd = *chilkatc::CkEmail_AddAttachmentBd;
*AddAttachmentHeader = *chilkatc::CkEmail_AddAttachmentHeader;
*AddBcc = *chilkatc::CkEmail_AddBcc;
*AddCC = *chilkatc::CkEmail_AddCC;
*AddDataAttachment = *chilkatc::CkEmail_AddDataAttachment;
*AddDataAttachment2 = *chilkatc::CkEmail_AddDataAttachment2;
*AddEncryptCert = *chilkatc::CkEmail_AddEncryptCert;
*AddFileAttachment = *chilkatc::CkEmail_AddFileAttachment;
*addFileAttachment = *chilkatc::CkEmail_addFileAttachment;
*AddFileAttachment2 = *chilkatc::CkEmail_AddFileAttachment2;
*AddHeaderField = *chilkatc::CkEmail_AddHeaderField;
*AddHeaderField2 = *chilkatc::CkEmail_AddHeaderField2;
*AddHtmlAlternativeBody = *chilkatc::CkEmail_AddHtmlAlternativeBody;
*AddiCalendarAlternativeBody = *chilkatc::CkEmail_AddiCalendarAlternativeBody;
*AddMultipleBcc = *chilkatc::CkEmail_AddMultipleBcc;
*AddMultipleCC = *chilkatc::CkEmail_AddMultipleCC;
*AddMultipleTo = *chilkatc::CkEmail_AddMultipleTo;
*AddPfxSourceBd = *chilkatc::CkEmail_AddPfxSourceBd;
*AddPfxSourceData = *chilkatc::CkEmail_AddPfxSourceData;
*AddPfxSourceFile = *chilkatc::CkEmail_AddPfxSourceFile;
*AddPlainTextAlternativeBody = *chilkatc::CkEmail_AddPlainTextAlternativeBody;
*AddRelatedBd = *chilkatc::CkEmail_AddRelatedBd;
*addRelatedBd = *chilkatc::CkEmail_addRelatedBd;
*AddRelatedBd2 = *chilkatc::CkEmail_AddRelatedBd2;
*AddRelatedData = *chilkatc::CkEmail_AddRelatedData;
*addRelatedData = *chilkatc::CkEmail_addRelatedData;
*AddRelatedData2 = *chilkatc::CkEmail_AddRelatedData2;
*AddRelatedFile = *chilkatc::CkEmail_AddRelatedFile;
*addRelatedFile = *chilkatc::CkEmail_addRelatedFile;
*AddRelatedFile2 = *chilkatc::CkEmail_AddRelatedFile2;
*AddRelatedHeader = *chilkatc::CkEmail_AddRelatedHeader;
*AddRelatedString = *chilkatc::CkEmail_AddRelatedString;
*addRelatedString = *chilkatc::CkEmail_addRelatedString;
*AddRelatedString2 = *chilkatc::CkEmail_AddRelatedString2;
*AddStringAttachment = *chilkatc::CkEmail_AddStringAttachment;
*AddStringAttachment2 = *chilkatc::CkEmail_AddStringAttachment2;
*AddTo = *chilkatc::CkEmail_AddTo;
*AesDecrypt = *chilkatc::CkEmail_AesDecrypt;
*AesEncrypt = *chilkatc::CkEmail_AesEncrypt;
*AppendToBody = *chilkatc::CkEmail_AppendToBody;
*ApplyFixups = *chilkatc::CkEmail_ApplyFixups;
*AspUnpack = *chilkatc::CkEmail_AspUnpack;
*AspUnpack2 = *chilkatc::CkEmail_AspUnpack2;
*AttachEmail = *chilkatc::CkEmail_AttachEmail;
*AttachMessage = *chilkatc::CkEmail_AttachMessage;
*BEncodeBytes = *chilkatc::CkEmail_BEncodeBytes;
*bEncodeBytes = *chilkatc::CkEmail_bEncodeBytes;
*BEncodeString = *chilkatc::CkEmail_BEncodeString;
*bEncodeString = *chilkatc::CkEmail_bEncodeString;
*Clear = *chilkatc::CkEmail_Clear;
*ClearBcc = *chilkatc::CkEmail_ClearBcc;
*ClearCC = *chilkatc::CkEmail_ClearCC;
*ClearEncryptCerts = *chilkatc::CkEmail_ClearEncryptCerts;
*ClearTo = *chilkatc::CkEmail_ClearTo;
*Clone = *chilkatc::CkEmail_Clone;
*ComputeGlobalKey2 = *chilkatc::CkEmail_ComputeGlobalKey2;
*computeGlobalKey2 = *chilkatc::CkEmail_computeGlobalKey2;
*ConvertInlineImages = *chilkatc::CkEmail_ConvertInlineImages;
*CreateDsn = *chilkatc::CkEmail_CreateDsn;
*CreateForward = *chilkatc::CkEmail_CreateForward;
*CreateMdn = *chilkatc::CkEmail_CreateMdn;
*CreateReply = *chilkatc::CkEmail_CreateReply;
*CreateTempMht = *chilkatc::CkEmail_CreateTempMht;
*createTempMht = *chilkatc::CkEmail_createTempMht;
*DropAttachments = *chilkatc::CkEmail_DropAttachments;
*DropRelatedItem = *chilkatc::CkEmail_DropRelatedItem;
*DropRelatedItems = *chilkatc::CkEmail_DropRelatedItems;
*DropSingleAttachment = *chilkatc::CkEmail_DropSingleAttachment;
*FindIssuer = *chilkatc::CkEmail_FindIssuer;
*GenerateFilename = *chilkatc::CkEmail_GenerateFilename;
*generateFilename = *chilkatc::CkEmail_generateFilename;
*GetAlternativeBody = *chilkatc::CkEmail_GetAlternativeBody;
*getAlternativeBody = *chilkatc::CkEmail_getAlternativeBody;
*alternativeBody = *chilkatc::CkEmail_alternativeBody;
*GetAlternativeBodyBd = *chilkatc::CkEmail_GetAlternativeBodyBd;
*GetAlternativeBodyByContentType = *chilkatc::CkEmail_GetAlternativeBodyByContentType;
*getAlternativeBodyByContentType = *chilkatc::CkEmail_getAlternativeBodyByContentType;
*alternativeBodyByContentType = *chilkatc::CkEmail_alternativeBodyByContentType;
*GetAlternativeContentType = *chilkatc::CkEmail_GetAlternativeContentType;
*getAlternativeContentType = *chilkatc::CkEmail_getAlternativeContentType;
*alternativeContentType = *chilkatc::CkEmail_alternativeContentType;
*GetAltHeaderField = *chilkatc::CkEmail_GetAltHeaderField;
*getAltHeaderField = *chilkatc::CkEmail_getAltHeaderField;
*altHeaderField = *chilkatc::CkEmail_altHeaderField;
*GetAttachedEmail = *chilkatc::CkEmail_GetAttachedEmail;
*GetAttachedMessage = *chilkatc::CkEmail_GetAttachedMessage;
*GetAttachedMessageAttr = *chilkatc::CkEmail_GetAttachedMessageAttr;
*getAttachedMessageAttr = *chilkatc::CkEmail_getAttachedMessageAttr;
*attachedMessageAttr = *chilkatc::CkEmail_attachedMessageAttr;
*GetAttachedMessageFilename = *chilkatc::CkEmail_GetAttachedMessageFilename;
*getAttachedMessageFilename = *chilkatc::CkEmail_getAttachedMessageFilename;
*attachedMessageFilename = *chilkatc::CkEmail_attachedMessageFilename;
*GetAttachmentAttr = *chilkatc::CkEmail_GetAttachmentAttr;
*getAttachmentAttr = *chilkatc::CkEmail_getAttachmentAttr;
*attachmentAttr = *chilkatc::CkEmail_attachmentAttr;
*GetAttachmentBd = *chilkatc::CkEmail_GetAttachmentBd;
*GetAttachmentContentID = *chilkatc::CkEmail_GetAttachmentContentID;
*getAttachmentContentID = *chilkatc::CkEmail_getAttachmentContentID;
*attachmentContentID = *chilkatc::CkEmail_attachmentContentID;
*GetAttachmentContentType = *chilkatc::CkEmail_GetAttachmentContentType;
*getAttachmentContentType = *chilkatc::CkEmail_getAttachmentContentType;
*attachmentContentType = *chilkatc::CkEmail_attachmentContentType;
*GetAttachmentData = *chilkatc::CkEmail_GetAttachmentData;
*GetAttachmentFilename = *chilkatc::CkEmail_GetAttachmentFilename;
*getAttachmentFilename = *chilkatc::CkEmail_getAttachmentFilename;
*attachmentFilename = *chilkatc::CkEmail_attachmentFilename;
*GetAttachmentHeader = *chilkatc::CkEmail_GetAttachmentHeader;
*getAttachmentHeader = *chilkatc::CkEmail_getAttachmentHeader;
*attachmentHeader = *chilkatc::CkEmail_attachmentHeader;
*GetAttachmentSize = *chilkatc::CkEmail_GetAttachmentSize;
*GetAttachmentString = *chilkatc::CkEmail_GetAttachmentString;
*getAttachmentString = *chilkatc::CkEmail_getAttachmentString;
*attachmentString = *chilkatc::CkEmail_attachmentString;
*GetAttachmentStringCrLf = *chilkatc::CkEmail_GetAttachmentStringCrLf;
*getAttachmentStringCrLf = *chilkatc::CkEmail_getAttachmentStringCrLf;
*attachmentStringCrLf = *chilkatc::CkEmail_attachmentStringCrLf;
*GetBcc = *chilkatc::CkEmail_GetBcc;
*getBcc = *chilkatc::CkEmail_getBcc;
*bcc = *chilkatc::CkEmail_bcc;
*GetBccAddr = *chilkatc::CkEmail_GetBccAddr;
*getBccAddr = *chilkatc::CkEmail_getBccAddr;
*bccAddr = *chilkatc::CkEmail_bccAddr;
*GetBccName = *chilkatc::CkEmail_GetBccName;
*getBccName = *chilkatc::CkEmail_getBccName;
*bccName = *chilkatc::CkEmail_bccName;
*GetCC = *chilkatc::CkEmail_GetCC;
*getCC = *chilkatc::CkEmail_getCC;
*cC = *chilkatc::CkEmail_cC;
*GetCcAddr = *chilkatc::CkEmail_GetCcAddr;
*getCcAddr = *chilkatc::CkEmail_getCcAddr;
*ccAddr = *chilkatc::CkEmail_ccAddr;
*GetCcName = *chilkatc::CkEmail_GetCcName;
*getCcName = *chilkatc::CkEmail_getCcName;
*ccName = *chilkatc::CkEmail_ccName;
*GetDeliveryStatusInfo = *chilkatc::CkEmail_GetDeliveryStatusInfo;
*getDeliveryStatusInfo = *chilkatc::CkEmail_getDeliveryStatusInfo;
*deliveryStatusInfo = *chilkatc::CkEmail_deliveryStatusInfo;
*GetDigest = *chilkatc::CkEmail_GetDigest;
*GetDigestEmail = *chilkatc::CkEmail_GetDigestEmail;
*GetDsnFinalRecipients = *chilkatc::CkEmail_GetDsnFinalRecipients;
*GetDsnInfo = *chilkatc::CkEmail_GetDsnInfo;
*GetDt = *chilkatc::CkEmail_GetDt;
*GetEncryptCert = *chilkatc::CkEmail_GetEncryptCert;
*GetEncryptedByCert = *chilkatc::CkEmail_GetEncryptedByCert;
*GetFileContent = *chilkatc::CkEmail_GetFileContent;
*GetHeaderField = *chilkatc::CkEmail_GetHeaderField;
*getHeaderField = *chilkatc::CkEmail_getHeaderField;
*headerField = *chilkatc::CkEmail_headerField;
*GetHeaderFieldName = *chilkatc::CkEmail_GetHeaderFieldName;
*getHeaderFieldName = *chilkatc::CkEmail_getHeaderFieldName;
*headerFieldName = *chilkatc::CkEmail_headerFieldName;
*GetHeaderFieldValue = *chilkatc::CkEmail_GetHeaderFieldValue;
*getHeaderFieldValue = *chilkatc::CkEmail_getHeaderFieldValue;
*headerFieldValue = *chilkatc::CkEmail_headerFieldValue;
*GetHtmlBody = *chilkatc::CkEmail_GetHtmlBody;
*getHtmlBody = *chilkatc::CkEmail_getHtmlBody;
*htmlBody = *chilkatc::CkEmail_htmlBody;
*GetHtmlBodySb = *chilkatc::CkEmail_GetHtmlBodySb;
*GetImapUid = *chilkatc::CkEmail_GetImapUid;
*GetLinkedDomains = *chilkatc::CkEmail_GetLinkedDomains;
*GetMime = *chilkatc::CkEmail_GetMime;
*getMime = *chilkatc::CkEmail_getMime;
*mime = *chilkatc::CkEmail_mime;
*GetMimeBd = *chilkatc::CkEmail_GetMimeBd;
*GetMimeBinary = *chilkatc::CkEmail_GetMimeBinary;
*GetMimeSb = *chilkatc::CkEmail_GetMimeSb;
*GetNthBinaryPartOfType = *chilkatc::CkEmail_GetNthBinaryPartOfType;
*GetNthBinaryPartOfTypeBd = *chilkatc::CkEmail_GetNthBinaryPartOfTypeBd;
*GetNthContentType = *chilkatc::CkEmail_GetNthContentType;
*getNthContentType = *chilkatc::CkEmail_getNthContentType;
*nthContentType = *chilkatc::CkEmail_nthContentType;
*GetNthTextPartOfType = *chilkatc::CkEmail_GetNthTextPartOfType;
*getNthTextPartOfType = *chilkatc::CkEmail_getNthTextPartOfType;
*nthTextPartOfType = *chilkatc::CkEmail_nthTextPartOfType;
*GetNumPartsOfType = *chilkatc::CkEmail_GetNumPartsOfType;
*GetPlainTextBody = *chilkatc::CkEmail_GetPlainTextBody;
*getPlainTextBody = *chilkatc::CkEmail_getPlainTextBody;
*plainTextBody = *chilkatc::CkEmail_plainTextBody;
*GetRelatedAttr = *chilkatc::CkEmail_GetRelatedAttr;
*getRelatedAttr = *chilkatc::CkEmail_getRelatedAttr;
*relatedAttr = *chilkatc::CkEmail_relatedAttr;
*GetRelatedContentID = *chilkatc::CkEmail_GetRelatedContentID;
*getRelatedContentID = *chilkatc::CkEmail_getRelatedContentID;
*relatedContentID = *chilkatc::CkEmail_relatedContentID;
*GetRelatedContentLocation = *chilkatc::CkEmail_GetRelatedContentLocation;
*getRelatedContentLocation = *chilkatc::CkEmail_getRelatedContentLocation;
*relatedContentLocation = *chilkatc::CkEmail_relatedContentLocation;
*GetRelatedContentType = *chilkatc::CkEmail_GetRelatedContentType;
*getRelatedContentType = *chilkatc::CkEmail_getRelatedContentType;
*relatedContentType = *chilkatc::CkEmail_relatedContentType;
*GetRelatedData = *chilkatc::CkEmail_GetRelatedData;
*GetRelatedFilename = *chilkatc::CkEmail_GetRelatedFilename;
*getRelatedFilename = *chilkatc::CkEmail_getRelatedFilename;
*relatedFilename = *chilkatc::CkEmail_relatedFilename;
*GetRelatedHeader = *chilkatc::CkEmail_GetRelatedHeader;
*getRelatedHeader = *chilkatc::CkEmail_getRelatedHeader;
*relatedHeader = *chilkatc::CkEmail_relatedHeader;
*GetRelatedString = *chilkatc::CkEmail_GetRelatedString;
*getRelatedString = *chilkatc::CkEmail_getRelatedString;
*relatedString = *chilkatc::CkEmail_relatedString;
*GetRelatedStringCrLf = *chilkatc::CkEmail_GetRelatedStringCrLf;
*getRelatedStringCrLf = *chilkatc::CkEmail_getRelatedStringCrLf;
*relatedStringCrLf = *chilkatc::CkEmail_relatedStringCrLf;
*GetReplacePattern = *chilkatc::CkEmail_GetReplacePattern;
*getReplacePattern = *chilkatc::CkEmail_getReplacePattern;
*replacePattern = *chilkatc::CkEmail_replacePattern;
*GetReplaceString = *chilkatc::CkEmail_GetReplaceString;
*getReplaceString = *chilkatc::CkEmail_getReplaceString;
*replaceString = *chilkatc::CkEmail_replaceString;
*GetReplaceString2 = *chilkatc::CkEmail_GetReplaceString2;
*getReplaceString2 = *chilkatc::CkEmail_getReplaceString2;
*replaceString2 = *chilkatc::CkEmail_replaceString2;
*GetReport = *chilkatc::CkEmail_GetReport;
*getReport = *chilkatc::CkEmail_getReport;
*report = *chilkatc::CkEmail_report;
*GetSignedByCert = *chilkatc::CkEmail_GetSignedByCert;
*GetSignedByCertChain = *chilkatc::CkEmail_GetSignedByCertChain;
*GetSigningCert = *chilkatc::CkEmail_GetSigningCert;
*GetTo = *chilkatc::CkEmail_GetTo;
*getTo = *chilkatc::CkEmail_getTo;
*to = *chilkatc::CkEmail_to;
*GetToAddr = *chilkatc::CkEmail_GetToAddr;
*getToAddr = *chilkatc::CkEmail_getToAddr;
*toAddr = *chilkatc::CkEmail_toAddr;
*GetToName = *chilkatc::CkEmail_GetToName;
*getToName = *chilkatc::CkEmail_getToName;
*toName = *chilkatc::CkEmail_toName;
*GetXml = *chilkatc::CkEmail_GetXml;
*getXml = *chilkatc::CkEmail_getXml;
*xml = *chilkatc::CkEmail_xml;
*HasHeaderMatching = *chilkatc::CkEmail_HasHeaderMatching;
*HasHtmlBody = *chilkatc::CkEmail_HasHtmlBody;
*HasPlainTextBody = *chilkatc::CkEmail_HasPlainTextBody;
*IsMultipartReport = *chilkatc::CkEmail_IsMultipartReport;
*LastDecryptCert = *chilkatc::CkEmail_LastDecryptCert;
*LastSignerCert = *chilkatc::CkEmail_LastSignerCert;
*LinkedDomains = *chilkatc::CkEmail_LinkedDomains;
*LoadEml = *chilkatc::CkEmail_LoadEml;
*LoadTaskResult = *chilkatc::CkEmail_LoadTaskResult;
*LoadXml = *chilkatc::CkEmail_LoadXml;
*LoadXmlString = *chilkatc::CkEmail_LoadXmlString;
*MakeCopy = *chilkatc::CkEmail_MakeCopy;
*QEncodeBytes = *chilkatc::CkEmail_QEncodeBytes;
*qEncodeBytes = *chilkatc::CkEmail_qEncodeBytes;
*QEncodeString = *chilkatc::CkEmail_QEncodeString;
*qEncodeString = *chilkatc::CkEmail_qEncodeString;
*RemoveAttachedMessage = *chilkatc::CkEmail_RemoveAttachedMessage;
*RemoveAttachedMessages = *chilkatc::CkEmail_RemoveAttachedMessages;
*RemoveAttachmentPaths = *chilkatc::CkEmail_RemoveAttachmentPaths;
*RemoveHeaderField = *chilkatc::CkEmail_RemoveHeaderField;
*RemoveHtmlAlternative = *chilkatc::CkEmail_RemoveHtmlAlternative;
*RemovePlainTextAlternative = *chilkatc::CkEmail_RemovePlainTextAlternative;
*SaveAllAttachments = *chilkatc::CkEmail_SaveAllAttachments;
*SaveAttachedFile = *chilkatc::CkEmail_SaveAttachedFile;
*SaveEml = *chilkatc::CkEmail_SaveEml;
*SaveRelatedItem = *chilkatc::CkEmail_SaveRelatedItem;
*SaveXml = *chilkatc::CkEmail_SaveXml;
*SetAttachmentCharset = *chilkatc::CkEmail_SetAttachmentCharset;
*SetAttachmentDisposition = *chilkatc::CkEmail_SetAttachmentDisposition;
*SetAttachmentFilename = *chilkatc::CkEmail_SetAttachmentFilename;
*SetBinaryBody = *chilkatc::CkEmail_SetBinaryBody;
*SetBodyBd = *chilkatc::CkEmail_SetBodyBd;
*SetDecryptCert = *chilkatc::CkEmail_SetDecryptCert;
*SetDecryptCert2 = *chilkatc::CkEmail_SetDecryptCert2;
*SetDt = *chilkatc::CkEmail_SetDt;
*SetEdifactBody = *chilkatc::CkEmail_SetEdifactBody;
*SetEncryptCert = *chilkatc::CkEmail_SetEncryptCert;
*SetFromMimeBd = *chilkatc::CkEmail_SetFromMimeBd;
*SetFromMimeBytes = *chilkatc::CkEmail_SetFromMimeBytes;
*SetFromMimeBytes2 = *chilkatc::CkEmail_SetFromMimeBytes2;
*SetFromMimeSb = *chilkatc::CkEmail_SetFromMimeSb;
*SetFromMimeText = *chilkatc::CkEmail_SetFromMimeText;
*SetFromXmlText = *chilkatc::CkEmail_SetFromXmlText;
*SetHtmlBody = *chilkatc::CkEmail_SetHtmlBody;
*SetMbHtmlBody = *chilkatc::CkEmail_SetMbHtmlBody;
*SetMbPlainTextBody = *chilkatc::CkEmail_SetMbPlainTextBody;
*SetRelatedFilename = *chilkatc::CkEmail_SetRelatedFilename;
*SetReplacePattern = *chilkatc::CkEmail_SetReplacePattern;
*SetSigningCert = *chilkatc::CkEmail_SetSigningCert;
*SetSigningCert2 = *chilkatc::CkEmail_SetSigningCert2;
*SetTextBody = *chilkatc::CkEmail_SetTextBody;
*ToDsn = *chilkatc::CkEmail_ToDsn;
*ToForward = *chilkatc::CkEmail_ToForward;
*ToMdn = *chilkatc::CkEmail_ToMdn;
*ToReply = *chilkatc::CkEmail_ToReply;
*UidlEquals = *chilkatc::CkEmail_UidlEquals;
*UnpackHtml = *chilkatc::CkEmail_UnpackHtml;
*UnSpamify = *chilkatc::CkEmail_UnSpamify;
*UnzipAttachments = *chilkatc::CkEmail_UnzipAttachments;
*UseCertVault = *chilkatc::CkEmail_UseCertVault;
*ZipAttachments = *chilkatc::CkEmail_ZipAttachments;
sub DISOWN {
    my $self = shift;
    my $ptr = tied(%$self);
    delete $OWNER{$ptr};
}

sub ACQUIRE {
    my $self = shift;
    my $ptr = tied(%$self);
    $OWNER{$ptr} = 1;
}


############# Class : chilkat::CkEmailBundle ##############

package chilkat::CkEmailBundle;
use vars qw(@ISA %OWNER %ITERATORS %BLESSEDMEMBERS);
@ISA = qw( chilkat );
%OWNER = ();
%ITERATORS = ();
sub new {
    my $pkg = shift;
    my $self = chilkatc::new_CkEmailBundle(@_);
    bless $self, $pkg if defined($self);
}

sub DESTROY {
    return unless $_[0]->isa('HASH');
    my $self = tied(%{$_[0]});
    return unless defined $self;
    delete $ITERATORS{$self};
    if (exists $OWNER{$self}) {
        chilkatc::delete_CkEmailBundle($self);
        delete $OWNER{$self};
    }
}

*get_Utf8 = *chilkatc::CkEmailBundle_get_Utf8;
*put_Utf8 = *chilkatc::CkEmailBundle_put_Utf8;
*LastErrorXml = *chilkatc::CkEmailBundle_LastErrorXml;
*LastErrorHtml = *chilkatc::CkEmailBundle_LastErrorHtml;
*LastErrorText = *chilkatc::CkEmailBundle_LastErrorText;
*get_DebugLogFilePath = *chilkatc::CkEmailBundle_get_DebugLogFilePath;
*debugLogFilePath = *chilkatc::CkEmailBundle_debugLogFilePath;
*put_DebugLogFilePath = *chilkatc::CkEmailBundle_put_DebugLogFilePath;
*get_LastErrorHtml = *chilkatc::CkEmailBundle_get_LastErrorHtml;
*lastErrorHtml = *chilkatc::CkEmailBundle_lastErrorHtml;
*get_LastErrorText = *chilkatc::CkEmailBundle_get_LastErrorText;
*lastErrorText = *chilkatc::CkEmailBundle_lastErrorText;
*get_LastErrorXml = *chilkatc::CkEmailBundle_get_LastErrorXml;
*lastErrorXml = *chilkatc::CkEmailBundle_lastErrorXml;
*get_LastMethodSuccess = *chilkatc::CkEmailBundle_get_LastMethodSuccess;
*put_LastMethodSuccess = *chilkatc::CkEmailBundle_put_LastMethodSuccess;
*get_MessageCount = *chilkatc::CkEmailBundle_get_MessageCount;
*get_VerboseLogging = *chilkatc::CkEmailBundle_get_VerboseLogging;
*put_VerboseLogging = *chilkatc::CkEmailBundle_put_VerboseLogging;
*get_Version = *chilkatc::CkEmailBundle_get_Version;
*version = *chilkatc::CkEmailBundle_version;
*AddEmail = *chilkatc::CkEmailBundle_AddEmail;
*Clear = *chilkatc::CkEmailBundle_Clear;
*EmailAt = *chilkatc::CkEmailBundle_EmailAt;
*FindByHeader = *chilkatc::CkEmailBundle_FindByHeader;
*FindEmail = *chilkatc::CkEmailBundle_FindEmail;
*GetEmail = *chilkatc::CkEmailBundle_GetEmail;
*GetUidls = *chilkatc::CkEmailBundle_GetUidls;
*GetXml = *chilkatc::CkEmailBundle_GetXml;
*getXml = *chilkatc::CkEmailBundle_getXml;
*xml = *chilkatc::CkEmailBundle_xml;
*LoadTaskResult = *chilkatc::CkEmailBundle_LoadTaskResult;
*LoadXml = *chilkatc::CkEmailBundle_LoadXml;
*LoadXmlString = *chilkatc::CkEmailBundle_LoadXmlString;
*RemoveEmail = *chilkatc::CkEmailBundle_RemoveEmail;
*RemoveEmailByIndex = *chilkatc::CkEmailBundle_RemoveEmailByIndex;
*SaveXml = *chilkatc::CkEmailBundle_SaveXml;
*SortByDate = *chilkatc::CkEmailBundle_SortByDate;
*SortByRecipient = *chilkatc::CkEmailBundle_SortByRecipient;
*SortBySender = *chilkatc::CkEmailBundle_SortBySender;
*SortBySubject = *chilkatc::CkEmailBundle_SortBySubject;
sub DISOWN {
    my $self = shift;
    my $ptr = tied(%$self);
    delete $OWNER{$ptr};
}

sub ACQUIRE {
    my $self = shift;
    my $ptr = tied(%$self);
    $OWNER{$ptr} = 1;
}


############# Class : chilkat::CkFileAccess ##############

package chilkat::CkFileAccess;
use vars qw(@ISA %OWNER %ITERATORS %BLESSEDMEMBERS);
@ISA = qw( chilkat );
%OWNER = ();
%ITERATORS = ();
sub new {
    my $pkg = shift;
    my $self = chilkatc::new_CkFileAccess(@_);
    bless $self, $pkg if defined($self);
}

sub DESTROY {
    return unless $_[0]->isa('HASH');
    my $self = tied(%{$_[0]});
    return unless defined $self;
    delete $ITERATORS{$self};
    if (exists $OWNER{$self}) {
        chilkatc::delete_CkFileAccess($self);
        delete $OWNER{$self};
    }
}

*get_Utf8 = *chilkatc::CkFileAccess_get_Utf8;
*put_Utf8 = *chilkatc::CkFileAccess_put_Utf8;
*LastErrorXml = *chilkatc::CkFileAccess_LastErrorXml;
*LastErrorHtml = *chilkatc::CkFileAccess_LastErrorHtml;
*LastErrorText = *chilkatc::CkFileAccess_LastErrorText;
*get_CurrentDir = *chilkatc::CkFileAccess_get_CurrentDir;
*currentDir = *chilkatc::CkFileAccess_currentDir;
*get_DebugLogFilePath = *chilkatc::CkFileAccess_get_DebugLogFilePath;
*debugLogFilePath = *chilkatc::CkFileAccess_debugLogFilePath;
*put_DebugLogFilePath = *chilkatc::CkFileAccess_put_DebugLogFilePath;
*get_EndOfFile = *chilkatc::CkFileAccess_get_EndOfFile;
*get_FileOpenError = *chilkatc::CkFileAccess_get_FileOpenError;
*get_FileOpenErrorMsg = *chilkatc::CkFileAccess_get_FileOpenErrorMsg;
*fileOpenErrorMsg = *chilkatc::CkFileAccess_fileOpenErrorMsg;
*get_LastErrorHtml = *chilkatc::CkFileAccess_get_LastErrorHtml;
*lastErrorHtml = *chilkatc::CkFileAccess_lastErrorHtml;
*get_LastErrorText = *chilkatc::CkFileAccess_get_LastErrorText;
*lastErrorText = *chilkatc::CkFileAccess_lastErrorText;
*get_LastErrorXml = *chilkatc::CkFileAccess_get_LastErrorXml;
*lastErrorXml = *chilkatc::CkFileAccess_lastErrorXml;
*get_LastMethodSuccess = *chilkatc::CkFileAccess_get_LastMethodSuccess;
*put_LastMethodSuccess = *chilkatc::CkFileAccess_put_LastMethodSuccess;
*get_LockFileOnOpen = *chilkatc::CkFileAccess_get_LockFileOnOpen;
*put_LockFileOnOpen = *chilkatc::CkFileAccess_put_LockFileOnOpen;
*get_VerboseLogging = *chilkatc::CkFileAccess_get_VerboseLogging;
*put_VerboseLogging = *chilkatc::CkFileAccess_put_VerboseLogging;
*get_Version = *chilkatc::CkFileAccess_get_Version;
*version = *chilkatc::CkFileAccess_version;
*AppendAnsi = *chilkatc::CkFileAccess_AppendAnsi;
*AppendBd = *chilkatc::CkFileAccess_AppendBd;
*AppendSb = *chilkatc::CkFileAccess_AppendSb;
*AppendText = *chilkatc::CkFileAccess_AppendText;
*AppendUnicodeBOM = *chilkatc::CkFileAccess_AppendUnicodeBOM;
*AppendUtf8BOM = *chilkatc::CkFileAccess_AppendUtf8BOM;
*DirAutoCreate = *chilkatc::CkFileAccess_DirAutoCreate;
*DirCreate = *chilkatc::CkFileAccess_DirCreate;
*DirDelete = *chilkatc::CkFileAccess_DirDelete;
*DirEnsureExists = *chilkatc::CkFileAccess_DirEnsureExists;
*DirExists = *chilkatc::CkFileAccess_DirExists;
*FileClose = *chilkatc::CkFileAccess_FileClose;
*FileContentsEqual = *chilkatc::CkFileAccess_FileContentsEqual;
*FileCopy = *chilkatc::CkFileAccess_FileCopy;
*FileDelete = *chilkatc::CkFileAccess_FileDelete;
*FileExists = *chilkatc::CkFileAccess_FileExists;
*FileExists3 = *chilkatc::CkFileAccess_FileExists3;
*FileOpen = *chilkatc::CkFileAccess_FileOpen;
*FileRead = *chilkatc::CkFileAccess_FileRead;
*FileReadBd = *chilkatc::CkFileAccess_FileReadBd;
*FileRename = *chilkatc::CkFileAccess_FileRename;
*FileSeek = *chilkatc::CkFileAccess_FileSeek;
*FileSize = *chilkatc::CkFileAccess_FileSize;
*FileSize64 = *chilkatc::CkFileAccess_FileSize64;
*FileSizeStr = *chilkatc::CkFileAccess_FileSizeStr;
*fileSizeStr = *chilkatc::CkFileAccess_fileSizeStr;
*FileType = *chilkatc::CkFileAccess_FileType;
*FileWrite = *chilkatc::CkFileAccess_FileWrite;
*FileWriteBd = *chilkatc::CkFileAccess_FileWriteBd;
*GenBlockId = *chilkatc::CkFileAccess_GenBlockId;
*genBlockId = *chilkatc::CkFileAccess_genBlockId;
*GetDirectoryName = *chilkatc::CkFileAccess_GetDirectoryName;
*getDirectoryName = *chilkatc::CkFileAccess_getDirectoryName;
*directoryName = *chilkatc::CkFileAccess_directoryName;
*GetExtension = *chilkatc::CkFileAccess_GetExtension;
*getExtension = *chilkatc::CkFileAccess_getExtension;
*extension = *chilkatc::CkFileAccess_extension;
*GetFileName = *chilkatc::CkFileAccess_GetFileName;
*getFileName = *chilkatc::CkFileAccess_getFileName;
*fileName = *chilkatc::CkFileAccess_fileName;
*GetFileNameWithoutExtension = *chilkatc::CkFileAccess_GetFileNameWithoutExtension;
*getFileNameWithoutExtension = *chilkatc::CkFileAccess_getFileNameWithoutExtension;
*fileNameWithoutExtension = *chilkatc::CkFileAccess_fileNameWithoutExtension;
*GetFileTime = *chilkatc::CkFileAccess_GetFileTime;
*GetFileTimeStr = *chilkatc::CkFileAccess_GetFileTimeStr;
*getFileTimeStr = *chilkatc::CkFileAccess_getFileTimeStr;
*fileTimeStr = *chilkatc::CkFileAccess_fileTimeStr;
*GetLastModified = *chilkatc::CkFileAccess_GetLastModified;
*GetNumBlocks = *chilkatc::CkFileAccess_GetNumBlocks;
*GetTempFilename = *chilkatc::CkFileAccess_GetTempFilename;
*getTempFilename = *chilkatc::CkFileAccess_getTempFilename;
*tempFilename = *chilkatc::CkFileAccess_tempFilename;
*OpenForAppend = *chilkatc::CkFileAccess_OpenForAppend;
*OpenForRead = *chilkatc::CkFileAccess_OpenForRead;
*OpenForReadWrite = *chilkatc::CkFileAccess_OpenForReadWrite;
*OpenForWrite = *chilkatc::CkFileAccess_OpenForWrite;
*ReadBinaryToEncoded = *chilkatc::CkFileAccess_ReadBinaryToEncoded;
*readBinaryToEncoded = *chilkatc::CkFileAccess_readBinaryToEncoded;
*ReadBlock = *chilkatc::CkFileAccess_ReadBlock;
*ReadBlockBd = *chilkatc::CkFileAccess_ReadBlockBd;
*ReadEntireFile = *chilkatc::CkFileAccess_ReadEntireFile;
*ReadEntireTextFile = *chilkatc::CkFileAccess_ReadEntireTextFile;
*readEntireTextFile = *chilkatc::CkFileAccess_readEntireTextFile;
*ReadNextFragment = *chilkatc::CkFileAccess_ReadNextFragment;
*ReassembleFile = *chilkatc::CkFileAccess_ReassembleFile;
*ReplaceStrings = *chilkatc::CkFileAccess_ReplaceStrings;
*SetCurrentDir = *chilkatc::CkFileAccess_SetCurrentDir;
*SetFileTimes = *chilkatc::CkFileAccess_SetFileTimes;
*SetLastModified = *chilkatc::CkFileAccess_SetLastModified;
*SplitFile = *chilkatc::CkFileAccess_SplitFile;
*SymlinkCreate = *chilkatc::CkFileAccess_SymlinkCreate;
*SymlinkTarget = *chilkatc::CkFileAccess_SymlinkTarget;
*symlinkTarget = *chilkatc::CkFileAccess_symlinkTarget;
*TreeDelete = *chilkatc::CkFileAccess_TreeDelete;
*Truncate = *chilkatc::CkFileAccess_Truncate;
*WriteEntireFile = *chilkatc::CkFileAccess_WriteEntireFile;
*WriteEntireTextFile = *chilkatc::CkFileAccess_WriteEntireTextFile;
sub DISOWN {
    my $self = shift;
    my $ptr = tied(%$self);
    delete $OWNER{$ptr};
}

sub ACQUIRE {
    my $self = shift;
    my $ptr = tied(%$self);
    $OWNER{$ptr} = 1;
}


############# Class : chilkat::CkFtp2 ##############

package chilkat::CkFtp2;
use vars qw(@ISA %OWNER %ITERATORS %BLESSEDMEMBERS);
@ISA = qw( chilkat );
%OWNER = ();
%ITERATORS = ();
sub new {
    my $pkg = shift;
    my $self = chilkatc::new_CkFtp2(@_);
    bless $self, $pkg if defined($self);
}

sub DESTROY {
    return unless $_[0]->isa('HASH');
    my $self = tied(%{$_[0]});
    return unless defined $self;
    delete $ITERATORS{$self};
    if (exists $OWNER{$self}) {
        chilkatc::delete_CkFtp2($self);
        delete $OWNER{$self};
    }
}

*get_Utf8 = *chilkatc::CkFtp2_get_Utf8;
*put_Utf8 = *chilkatc::CkFtp2_put_Utf8;
*LastErrorXml = *chilkatc::CkFtp2_LastErrorXml;
*LastErrorHtml = *chilkatc::CkFtp2_LastErrorHtml;
*LastErrorText = *chilkatc::CkFtp2_LastErrorText;
*put_EventCallbackObject = *chilkatc::CkFtp2_put_EventCallbackObject;
*get_AbortCurrent = *chilkatc::CkFtp2_get_AbortCurrent;
*put_AbortCurrent = *chilkatc::CkFtp2_put_AbortCurrent;
*get_Account = *chilkatc::CkFtp2_get_Account;
*account = *chilkatc::CkFtp2_account;
*put_Account = *chilkatc::CkFtp2_put_Account;
*get_ActivePortRangeEnd = *chilkatc::CkFtp2_get_ActivePortRangeEnd;
*put_ActivePortRangeEnd = *chilkatc::CkFtp2_put_ActivePortRangeEnd;
*get_ActivePortRangeStart = *chilkatc::CkFtp2_get_ActivePortRangeStart;
*put_ActivePortRangeStart = *chilkatc::CkFtp2_put_ActivePortRangeStart;
*get_AllocateSize = *chilkatc::CkFtp2_get_AllocateSize;
*put_AllocateSize = *chilkatc::CkFtp2_put_AllocateSize;
*get_AllowMlsd = *chilkatc::CkFtp2_get_AllowMlsd;
*put_AllowMlsd = *chilkatc::CkFtp2_put_AllowMlsd;
*get_AsyncBytesReceived = *chilkatc::CkFtp2_get_AsyncBytesReceived;
*get_AsyncBytesReceived64 = *chilkatc::CkFtp2_get_AsyncBytesReceived64;
*get_AsyncBytesReceivedStr = *chilkatc::CkFtp2_get_AsyncBytesReceivedStr;
*asyncBytesReceivedStr = *chilkatc::CkFtp2_asyncBytesReceivedStr;
*get_AsyncBytesSent = *chilkatc::CkFtp2_get_AsyncBytesSent;
*get_AsyncBytesSent64 = *chilkatc::CkFtp2_get_AsyncBytesSent64;
*get_AsyncBytesSentStr = *chilkatc::CkFtp2_get_AsyncBytesSentStr;
*asyncBytesSentStr = *chilkatc::CkFtp2_asyncBytesSentStr;
*get_AuthSsl = *chilkatc::CkFtp2_get_AuthSsl;
*put_AuthSsl = *chilkatc::CkFtp2_put_AuthSsl;
*get_AuthTls = *chilkatc::CkFtp2_get_AuthTls;
*put_AuthTls = *chilkatc::CkFtp2_put_AuthTls;
*get_AutoFeat = *chilkatc::CkFtp2_get_AutoFeat;
*put_AutoFeat = *chilkatc::CkFtp2_put_AutoFeat;
*get_AutoFix = *chilkatc::CkFtp2_get_AutoFix;
*put_AutoFix = *chilkatc::CkFtp2_put_AutoFix;
*get_AutoGetSizeForProgress = *chilkatc::CkFtp2_get_AutoGetSizeForProgress;
*put_AutoGetSizeForProgress = *chilkatc::CkFtp2_put_AutoGetSizeForProgress;
*get_AutoOptsUtf8 = *chilkatc::CkFtp2_get_AutoOptsUtf8;
*put_AutoOptsUtf8 = *chilkatc::CkFtp2_put_AutoOptsUtf8;
*get_AutoSetUseEpsv = *chilkatc::CkFtp2_get_AutoSetUseEpsv;
*put_AutoSetUseEpsv = *chilkatc::CkFtp2_put_AutoSetUseEpsv;
*get_AutoSyst = *chilkatc::CkFtp2_get_AutoSyst;
*put_AutoSyst = *chilkatc::CkFtp2_put_AutoSyst;
*get_AutoXcrc = *chilkatc::CkFtp2_get_AutoXcrc;
*put_AutoXcrc = *chilkatc::CkFtp2_put_AutoXcrc;
*get_BandwidthThrottleDown = *chilkatc::CkFtp2_get_BandwidthThrottleDown;
*put_BandwidthThrottleDown = *chilkatc::CkFtp2_put_BandwidthThrottleDown;
*get_BandwidthThrottleUp = *chilkatc::CkFtp2_get_BandwidthThrottleUp;
*put_BandwidthThrottleUp = *chilkatc::CkFtp2_put_BandwidthThrottleUp;
*get_ClientIpAddress = *chilkatc::CkFtp2_get_ClientIpAddress;
*clientIpAddress = *chilkatc::CkFtp2_clientIpAddress;
*put_ClientIpAddress = *chilkatc::CkFtp2_put_ClientIpAddress;
*get_CommandCharset = *chilkatc::CkFtp2_get_CommandCharset;
*commandCharset = *chilkatc::CkFtp2_commandCharset;
*put_CommandCharset = *chilkatc::CkFtp2_put_CommandCharset;
*get_ConnectFailReason = *chilkatc::CkFtp2_get_ConnectFailReason;
*get_ConnectTimeout = *chilkatc::CkFtp2_get_ConnectTimeout;
*put_ConnectTimeout = *chilkatc::CkFtp2_put_ConnectTimeout;
*get_ConnectVerified = *chilkatc::CkFtp2_get_ConnectVerified;
*get_CrlfMode = *chilkatc::CkFtp2_get_CrlfMode;
*put_CrlfMode = *chilkatc::CkFtp2_put_CrlfMode;
*get_CurBytesReceived = *chilkatc::CkFtp2_get_CurBytesReceived;
*get_CurBytesReceived64 = *chilkatc::CkFtp2_get_CurBytesReceived64;
*get_CurBytesReceivedStr = *chilkatc::CkFtp2_get_CurBytesReceivedStr;
*curBytesReceivedStr = *chilkatc::CkFtp2_curBytesReceivedStr;
*get_CurBytesSent = *chilkatc::CkFtp2_get_CurBytesSent;
*get_CurBytesSent64 = *chilkatc::CkFtp2_get_CurBytesSent64;
*get_CurBytesSentStr = *chilkatc::CkFtp2_get_CurBytesSentStr;
*curBytesSentStr = *chilkatc::CkFtp2_curBytesSentStr;
*get_DataProtection = *chilkatc::CkFtp2_get_DataProtection;
*dataProtection = *chilkatc::CkFtp2_dataProtection;
*put_DataProtection = *chilkatc::CkFtp2_put_DataProtection;
*get_DebugLogFilePath = *chilkatc::CkFtp2_get_DebugLogFilePath;
*debugLogFilePath = *chilkatc::CkFtp2_debugLogFilePath;
*put_DebugLogFilePath = *chilkatc::CkFtp2_put_DebugLogFilePath;
*get_DirListingCharset = *chilkatc::CkFtp2_get_DirListingCharset;
*dirListingCharset = *chilkatc::CkFtp2_dirListingCharset;
*put_DirListingCharset = *chilkatc::CkFtp2_put_DirListingCharset;
*get_DownloadTransferRate = *chilkatc::CkFtp2_get_DownloadTransferRate;
*get_ForcePortIpAddress = *chilkatc::CkFtp2_get_ForcePortIpAddress;
*forcePortIpAddress = *chilkatc::CkFtp2_forcePortIpAddress;
*put_ForcePortIpAddress = *chilkatc::CkFtp2_put_ForcePortIpAddress;
*get_Greeting = *chilkatc::CkFtp2_get_Greeting;
*greeting = *chilkatc::CkFtp2_greeting;
*get_HasModeZ = *chilkatc::CkFtp2_get_HasModeZ;
*get_HeartbeatMs = *chilkatc::CkFtp2_get_HeartbeatMs;
*put_HeartbeatMs = *chilkatc::CkFtp2_put_HeartbeatMs;
*get_Hostname = *chilkatc::CkFtp2_get_Hostname;
*hostname = *chilkatc::CkFtp2_hostname;
*put_Hostname = *chilkatc::CkFtp2_put_Hostname;
*get_HttpProxyAuthMethod = *chilkatc::CkFtp2_get_HttpProxyAuthMethod;
*httpProxyAuthMethod = *chilkatc::CkFtp2_httpProxyAuthMethod;
*put_HttpProxyAuthMethod = *chilkatc::CkFtp2_put_HttpProxyAuthMethod;
*get_HttpProxyDomain = *chilkatc::CkFtp2_get_HttpProxyDomain;
*httpProxyDomain = *chilkatc::CkFtp2_httpProxyDomain;
*put_HttpProxyDomain = *chilkatc::CkFtp2_put_HttpProxyDomain;
*get_HttpProxyHostname = *chilkatc::CkFtp2_get_HttpProxyHostname;
*httpProxyHostname = *chilkatc::CkFtp2_httpProxyHostname;
*put_HttpProxyHostname = *chilkatc::CkFtp2_put_HttpProxyHostname;
*get_HttpProxyPassword = *chilkatc::CkFtp2_get_HttpProxyPassword;
*httpProxyPassword = *chilkatc::CkFtp2_httpProxyPassword;
*put_HttpProxyPassword = *chilkatc::CkFtp2_put_HttpProxyPassword;
*get_HttpProxyPort = *chilkatc::CkFtp2_get_HttpProxyPort;
*put_HttpProxyPort = *chilkatc::CkFtp2_put_HttpProxyPort;
*get_HttpProxyUsername = *chilkatc::CkFtp2_get_HttpProxyUsername;
*httpProxyUsername = *chilkatc::CkFtp2_httpProxyUsername;
*put_HttpProxyUsername = *chilkatc::CkFtp2_put_HttpProxyUsername;
*get_IdleTimeoutMs = *chilkatc::CkFtp2_get_IdleTimeoutMs;
*put_IdleTimeoutMs = *chilkatc::CkFtp2_put_IdleTimeoutMs;
*get_IsConnected = *chilkatc::CkFtp2_get_IsConnected;
*get_KeepSessionLog = *chilkatc::CkFtp2_get_KeepSessionLog;
*put_KeepSessionLog = *chilkatc::CkFtp2_put_KeepSessionLog;
*get_LargeFileMeasures = *chilkatc::CkFtp2_get_LargeFileMeasures;
*put_LargeFileMeasures = *chilkatc::CkFtp2_put_LargeFileMeasures;
*get_LastErrorHtml = *chilkatc::CkFtp2_get_LastErrorHtml;
*lastErrorHtml = *chilkatc::CkFtp2_lastErrorHtml;
*get_LastErrorText = *chilkatc::CkFtp2_get_LastErrorText;
*lastErrorText = *chilkatc::CkFtp2_lastErrorText;
*get_LastErrorXml = *chilkatc::CkFtp2_get_LastErrorXml;
*lastErrorXml = *chilkatc::CkFtp2_lastErrorXml;
*get_LastMethodSuccess = *chilkatc::CkFtp2_get_LastMethodSuccess;
*put_LastMethodSuccess = *chilkatc::CkFtp2_put_LastMethodSuccess;
*get_LastReply = *chilkatc::CkFtp2_get_LastReply;
*lastReply = *chilkatc::CkFtp2_lastReply;
*get_ListPattern = *chilkatc::CkFtp2_get_ListPattern;
*listPattern = *chilkatc::CkFtp2_listPattern;
*put_ListPattern = *chilkatc::CkFtp2_put_ListPattern;
*get_LoginVerified = *chilkatc::CkFtp2_get_LoginVerified;
*get_PartialTransfer = *chilkatc::CkFtp2_get_PartialTransfer;
*get_Passive = *chilkatc::CkFtp2_get_Passive;
*put_Passive = *chilkatc::CkFtp2_put_Passive;
*get_PassiveUseHostAddr = *chilkatc::CkFtp2_get_PassiveUseHostAddr;
*put_PassiveUseHostAddr = *chilkatc::CkFtp2_put_PassiveUseHostAddr;
*get_Password = *chilkatc::CkFtp2_get_Password;
*password = *chilkatc::CkFtp2_password;
*put_Password = *chilkatc::CkFtp2_put_Password;
*get_PercentDoneScale = *chilkatc::CkFtp2_get_PercentDoneScale;
*put_PercentDoneScale = *chilkatc::CkFtp2_put_PercentDoneScale;
*get_Port = *chilkatc::CkFtp2_get_Port;
*put_Port = *chilkatc::CkFtp2_put_Port;
*get_PreferIpv6 = *chilkatc::CkFtp2_get_PreferIpv6;
*put_PreferIpv6 = *chilkatc::CkFtp2_put_PreferIpv6;
*get_PreferNlst = *chilkatc::CkFtp2_get_PreferNlst;
*put_PreferNlst = *chilkatc::CkFtp2_put_PreferNlst;
*get_ProgressMonSize = *chilkatc::CkFtp2_get_ProgressMonSize;
*put_ProgressMonSize = *chilkatc::CkFtp2_put_ProgressMonSize;
*get_ProgressMonSize64 = *chilkatc::CkFtp2_get_ProgressMonSize64;
*put_ProgressMonSize64 = *chilkatc::CkFtp2_put_ProgressMonSize64;
*get_ProxyHostname = *chilkatc::CkFtp2_get_ProxyHostname;
*proxyHostname = *chilkatc::CkFtp2_proxyHostname;
*put_ProxyHostname = *chilkatc::CkFtp2_put_ProxyHostname;
*get_ProxyMethod = *chilkatc::CkFtp2_get_ProxyMethod;
*put_ProxyMethod = *chilkatc::CkFtp2_put_ProxyMethod;
*get_ProxyPassword = *chilkatc::CkFtp2_get_ProxyPassword;
*proxyPassword = *chilkatc::CkFtp2_proxyPassword;
*put_ProxyPassword = *chilkatc::CkFtp2_put_ProxyPassword;
*get_ProxyPort = *chilkatc::CkFtp2_get_ProxyPort;
*put_ProxyPort = *chilkatc::CkFtp2_put_ProxyPort;
*get_ProxyUsername = *chilkatc::CkFtp2_get_ProxyUsername;
*proxyUsername = *chilkatc::CkFtp2_proxyUsername;
*put_ProxyUsername = *chilkatc::CkFtp2_put_ProxyUsername;
*get_ReadTimeout = *chilkatc::CkFtp2_get_ReadTimeout;
*put_ReadTimeout = *chilkatc::CkFtp2_put_ReadTimeout;
*get_RequireSslCertVerify = *chilkatc::CkFtp2_get_RequireSslCertVerify;
*put_RequireSslCertVerify = *chilkatc::CkFtp2_put_RequireSslCertVerify;
*get_RestartNext = *chilkatc::CkFtp2_get_RestartNext;
*put_RestartNext = *chilkatc::CkFtp2_put_RestartNext;
*get_SessionLog = *chilkatc::CkFtp2_get_SessionLog;
*sessionLog = *chilkatc::CkFtp2_sessionLog;
*get_SocksHostname = *chilkatc::CkFtp2_get_SocksHostname;
*socksHostname = *chilkatc::CkFtp2_socksHostname;
*put_SocksHostname = *chilkatc::CkFtp2_put_SocksHostname;
*get_SocksPassword = *chilkatc::CkFtp2_get_SocksPassword;
*socksPassword = *chilkatc::CkFtp2_socksPassword;
*put_SocksPassword = *chilkatc::CkFtp2_put_SocksPassword;
*get_SocksPort = *chilkatc::CkFtp2_get_SocksPort;
*put_SocksPort = *chilkatc::CkFtp2_put_SocksPort;
*get_SocksUsername = *chilkatc::CkFtp2_get_SocksUsername;
*socksUsername = *chilkatc::CkFtp2_socksUsername;
*put_SocksUsername = *chilkatc::CkFtp2_put_SocksUsername;
*get_SocksVersion = *chilkatc::CkFtp2_get_SocksVersion;
*put_SocksVersion = *chilkatc::CkFtp2_put_SocksVersion;
*get_SoRcvBuf = *chilkatc::CkFtp2_get_SoRcvBuf;
*put_SoRcvBuf = *chilkatc::CkFtp2_put_SoRcvBuf;
*get_SoSndBuf = *chilkatc::CkFtp2_get_SoSndBuf;
*put_SoSndBuf = *chilkatc::CkFtp2_put_SoSndBuf;
*get_Ssl = *chilkatc::CkFtp2_get_Ssl;
*put_Ssl = *chilkatc::CkFtp2_put_Ssl;
*get_SslAllowedCiphers = *chilkatc::CkFtp2_get_SslAllowedCiphers;
*sslAllowedCiphers = *chilkatc::CkFtp2_sslAllowedCiphers;
*put_SslAllowedCiphers = *chilkatc::CkFtp2_put_SslAllowedCiphers;
*get_SslProtocol = *chilkatc::CkFtp2_get_SslProtocol;
*sslProtocol = *chilkatc::CkFtp2_sslProtocol;
*put_SslProtocol = *chilkatc::CkFtp2_put_SslProtocol;
*get_SslServerCertVerified = *chilkatc::CkFtp2_get_SslServerCertVerified;
*get_SyncCreateAllLocalDirs = *chilkatc::CkFtp2_get_SyncCreateAllLocalDirs;
*put_SyncCreateAllLocalDirs = *chilkatc::CkFtp2_put_SyncCreateAllLocalDirs;
*get_SyncMustMatch = *chilkatc::CkFtp2_get_SyncMustMatch;
*syncMustMatch = *chilkatc::CkFtp2_syncMustMatch;
*put_SyncMustMatch = *chilkatc::CkFtp2_put_SyncMustMatch;
*get_SyncMustMatchDir = *chilkatc::CkFtp2_get_SyncMustMatchDir;
*syncMustMatchDir = *chilkatc::CkFtp2_syncMustMatchDir;
*put_SyncMustMatchDir = *chilkatc::CkFtp2_put_SyncMustMatchDir;
*get_SyncMustNotMatch = *chilkatc::CkFtp2_get_SyncMustNotMatch;
*syncMustNotMatch = *chilkatc::CkFtp2_syncMustNotMatch;
*put_SyncMustNotMatch = *chilkatc::CkFtp2_put_SyncMustNotMatch;
*get_SyncMustNotMatchDir = *chilkatc::CkFtp2_get_SyncMustNotMatchDir;
*syncMustNotMatchDir = *chilkatc::CkFtp2_syncMustNotMatchDir;
*put_SyncMustNotMatchDir = *chilkatc::CkFtp2_put_SyncMustNotMatchDir;
*get_SyncPreview = *chilkatc::CkFtp2_get_SyncPreview;
*syncPreview = *chilkatc::CkFtp2_syncPreview;
*get_TlsCipherSuite = *chilkatc::CkFtp2_get_TlsCipherSuite;
*tlsCipherSuite = *chilkatc::CkFtp2_tlsCipherSuite;
*get_TlsPinSet = *chilkatc::CkFtp2_get_TlsPinSet;
*tlsPinSet = *chilkatc::CkFtp2_tlsPinSet;
*put_TlsPinSet = *chilkatc::CkFtp2_put_TlsPinSet;
*get_TlsVersion = *chilkatc::CkFtp2_get_TlsVersion;
*tlsVersion = *chilkatc::CkFtp2_tlsVersion;
*get_UncommonOptions = *chilkatc::CkFtp2_get_UncommonOptions;
*uncommonOptions = *chilkatc::CkFtp2_uncommonOptions;
*put_UncommonOptions = *chilkatc::CkFtp2_put_UncommonOptions;
*get_UploadTransferRate = *chilkatc::CkFtp2_get_UploadTransferRate;
*get_UseEpsv = *chilkatc::CkFtp2_get_UseEpsv;
*put_UseEpsv = *chilkatc::CkFtp2_put_UseEpsv;
*get_Username = *chilkatc::CkFtp2_get_Username;
*username = *chilkatc::CkFtp2_username;
*put_Username = *chilkatc::CkFtp2_put_Username;
*get_VerboseLogging = *chilkatc::CkFtp2_get_VerboseLogging;
*put_VerboseLogging = *chilkatc::CkFtp2_put_VerboseLogging;
*get_Version = *chilkatc::CkFtp2_get_Version;
*version = *chilkatc::CkFtp2_version;
*AppendFile = *chilkatc::CkFtp2_AppendFile;
*AppendFileAsync = *chilkatc::CkFtp2_AppendFileAsync;
*AppendFileBd = *chilkatc::CkFtp2_AppendFileBd;
*AppendFileBdAsync = *chilkatc::CkFtp2_AppendFileBdAsync;
*AppendFileFromBinaryData = *chilkatc::CkFtp2_AppendFileFromBinaryData;
*AppendFileFromBinaryDataAsync = *chilkatc::CkFtp2_AppendFileFromBinaryDataAsync;
*AppendFileFromTextData = *chilkatc::CkFtp2_AppendFileFromTextData;
*AppendFileFromTextDataAsync = *chilkatc::CkFtp2_AppendFileFromTextDataAsync;
*AppendFileSb = *chilkatc::CkFtp2_AppendFileSb;
*AppendFileSbAsync = *chilkatc::CkFtp2_AppendFileSbAsync;
*ChangeRemoteDir = *chilkatc::CkFtp2_ChangeRemoteDir;
*ChangeRemoteDirAsync = *chilkatc::CkFtp2_ChangeRemoteDirAsync;
*CheckConnection = *chilkatc::CkFtp2_CheckConnection;
*CheckConnectionAsync = *chilkatc::CkFtp2_CheckConnectionAsync;
*ClearControlChannel = *chilkatc::CkFtp2_ClearControlChannel;
*ClearControlChannelAsync = *chilkatc::CkFtp2_ClearControlChannelAsync;
*ClearDirCache = *chilkatc::CkFtp2_ClearDirCache;
*ClearSessionLog = *chilkatc::CkFtp2_ClearSessionLog;
*Connect = *chilkatc::CkFtp2_Connect;
*ConnectAsync = *chilkatc::CkFtp2_ConnectAsync;
*ConnectOnly = *chilkatc::CkFtp2_ConnectOnly;
*ConnectOnlyAsync = *chilkatc::CkFtp2_ConnectOnlyAsync;
*ConvertToTls = *chilkatc::CkFtp2_ConvertToTls;
*ConvertToTlsAsync = *chilkatc::CkFtp2_ConvertToTlsAsync;
*CreatePlan = *chilkatc::CkFtp2_CreatePlan;
*createPlan = *chilkatc::CkFtp2_createPlan;
*CreatePlanAsync = *chilkatc::CkFtp2_CreatePlanAsync;
*CreateRemoteDir = *chilkatc::CkFtp2_CreateRemoteDir;
*CreateRemoteDirAsync = *chilkatc::CkFtp2_CreateRemoteDirAsync;
*DeleteMatching = *chilkatc::CkFtp2_DeleteMatching;
*DeleteMatchingAsync = *chilkatc::CkFtp2_DeleteMatchingAsync;
*DeleteRemoteFile = *chilkatc::CkFtp2_DeleteRemoteFile;
*DeleteRemoteFileAsync = *chilkatc::CkFtp2_DeleteRemoteFileAsync;
*DeleteTree = *chilkatc::CkFtp2_DeleteTree;
*DeleteTreeAsync = *chilkatc::CkFtp2_DeleteTreeAsync;
*DetermineProxyMethod = *chilkatc::CkFtp2_DetermineProxyMethod;
*DetermineProxyMethodAsync = *chilkatc::CkFtp2_DetermineProxyMethodAsync;
*DetermineSettings = *chilkatc::CkFtp2_DetermineSettings;
*determineSettings = *chilkatc::CkFtp2_determineSettings;
*DetermineSettingsAsync = *chilkatc::CkFtp2_DetermineSettingsAsync;
*DirTreeXml = *chilkatc::CkFtp2_DirTreeXml;
*dirTreeXml = *chilkatc::CkFtp2_dirTreeXml;
*DirTreeXmlAsync = *chilkatc::CkFtp2_DirTreeXmlAsync;
*Disconnect = *chilkatc::CkFtp2_Disconnect;
*DisconnectAsync = *chilkatc::CkFtp2_DisconnectAsync;
*DownloadTree = *chilkatc::CkFtp2_DownloadTree;
*DownloadTreeAsync = *chilkatc::CkFtp2_DownloadTreeAsync;
*Feat = *chilkatc::CkFtp2_Feat;
*feat = *chilkatc::CkFtp2_feat;
*FeatAsync = *chilkatc::CkFtp2_FeatAsync;
*GetCreateDt = *chilkatc::CkFtp2_GetCreateDt;
*GetCreateDtAsync = *chilkatc::CkFtp2_GetCreateDtAsync;
*GetCreateDtByName = *chilkatc::CkFtp2_GetCreateDtByName;
*GetCreateDtByNameAsync = *chilkatc::CkFtp2_GetCreateDtByNameAsync;
*GetCreateTimeByNameStr = *chilkatc::CkFtp2_GetCreateTimeByNameStr;
*getCreateTimeByNameStr = *chilkatc::CkFtp2_getCreateTimeByNameStr;
*createTimeByNameStr = *chilkatc::CkFtp2_createTimeByNameStr;
*GetCreateTimeByNameStrAsync = *chilkatc::CkFtp2_GetCreateTimeByNameStrAsync;
*GetCreateTimeStr = *chilkatc::CkFtp2_GetCreateTimeStr;
*getCreateTimeStr = *chilkatc::CkFtp2_getCreateTimeStr;
*createTimeStr = *chilkatc::CkFtp2_createTimeStr;
*GetCreateTimeStrAsync = *chilkatc::CkFtp2_GetCreateTimeStrAsync;
*GetCurrentRemoteDir = *chilkatc::CkFtp2_GetCurrentRemoteDir;
*getCurrentRemoteDir = *chilkatc::CkFtp2_getCurrentRemoteDir;
*currentRemoteDir = *chilkatc::CkFtp2_currentRemoteDir;
*GetCurrentRemoteDirAsync = *chilkatc::CkFtp2_GetCurrentRemoteDirAsync;
*GetDirCount = *chilkatc::CkFtp2_GetDirCount;
*GetDirCountAsync = *chilkatc::CkFtp2_GetDirCountAsync;
*GetFile = *chilkatc::CkFtp2_GetFile;
*GetFileAsync = *chilkatc::CkFtp2_GetFileAsync;
*GetFileBd = *chilkatc::CkFtp2_GetFileBd;
*GetFileBdAsync = *chilkatc::CkFtp2_GetFileBdAsync;
*GetFilename = *chilkatc::CkFtp2_GetFilename;
*getFilename = *chilkatc::CkFtp2_getFilename;
*filename = *chilkatc::CkFtp2_filename;
*GetFilenameAsync = *chilkatc::CkFtp2_GetFilenameAsync;
*GetFileSb = *chilkatc::CkFtp2_GetFileSb;
*GetFileSbAsync = *chilkatc::CkFtp2_GetFileSbAsync;
*GetFileToStream = *chilkatc::CkFtp2_GetFileToStream;
*GetFileToStreamAsync = *chilkatc::CkFtp2_GetFileToStreamAsync;
*GetGroup = *chilkatc::CkFtp2_GetGroup;
*getGroup = *chilkatc::CkFtp2_getGroup;
*group = *chilkatc::CkFtp2_group;
*GetGroupAsync = *chilkatc::CkFtp2_GetGroupAsync;
*GetIsDirectory = *chilkatc::CkFtp2_GetIsDirectory;
*GetIsDirectoryAsync = *chilkatc::CkFtp2_GetIsDirectoryAsync;
*GetIsSymbolicLink = *chilkatc::CkFtp2_GetIsSymbolicLink;
*GetIsSymbolicLinkAsync = *chilkatc::CkFtp2_GetIsSymbolicLinkAsync;
*GetLastModDt = *chilkatc::CkFtp2_GetLastModDt;
*GetLastModDtAsync = *chilkatc::CkFtp2_GetLastModDtAsync;
*GetLastModDtByName = *chilkatc::CkFtp2_GetLastModDtByName;
*GetLastModDtByNameAsync = *chilkatc::CkFtp2_GetLastModDtByNameAsync;
*GetLastModifiedTimeByNameStr = *chilkatc::CkFtp2_GetLastModifiedTimeByNameStr;
*getLastModifiedTimeByNameStr = *chilkatc::CkFtp2_getLastModifiedTimeByNameStr;
*lastModifiedTimeByNameStr = *chilkatc::CkFtp2_lastModifiedTimeByNameStr;
*GetLastModifiedTimeByNameStrAsync = *chilkatc::CkFtp2_GetLastModifiedTimeByNameStrAsync;
*GetLastModifiedTimeStr = *chilkatc::CkFtp2_GetLastModifiedTimeStr;
*getLastModifiedTimeStr = *chilkatc::CkFtp2_getLastModifiedTimeStr;
*lastModifiedTimeStr = *chilkatc::CkFtp2_lastModifiedTimeStr;
*GetLastModifiedTimeStrAsync = *chilkatc::CkFtp2_GetLastModifiedTimeStrAsync;
*GetOwner = *chilkatc::CkFtp2_GetOwner;
*getOwner = *chilkatc::CkFtp2_getOwner;
*owner = *chilkatc::CkFtp2_owner;
*GetOwnerAsync = *chilkatc::CkFtp2_GetOwnerAsync;
*GetPermissions = *chilkatc::CkFtp2_GetPermissions;
*getPermissions = *chilkatc::CkFtp2_getPermissions;
*permissions = *chilkatc::CkFtp2_permissions;
*GetPermissionsAsync = *chilkatc::CkFtp2_GetPermissionsAsync;
*GetPermType = *chilkatc::CkFtp2_GetPermType;
*getPermType = *chilkatc::CkFtp2_getPermType;
*permType = *chilkatc::CkFtp2_permType;
*GetPermTypeAsync = *chilkatc::CkFtp2_GetPermTypeAsync;
*GetRemoteFileBinaryData = *chilkatc::CkFtp2_GetRemoteFileBinaryData;
*GetRemoteFileBinaryDataAsync = *chilkatc::CkFtp2_GetRemoteFileBinaryDataAsync;
*GetRemoteFileTextC = *chilkatc::CkFtp2_GetRemoteFileTextC;
*getRemoteFileTextC = *chilkatc::CkFtp2_getRemoteFileTextC;
*remoteFileTextC = *chilkatc::CkFtp2_remoteFileTextC;
*GetRemoteFileTextCAsync = *chilkatc::CkFtp2_GetRemoteFileTextCAsync;
*GetRemoteFileTextData = *chilkatc::CkFtp2_GetRemoteFileTextData;
*getRemoteFileTextData = *chilkatc::CkFtp2_getRemoteFileTextData;
*remoteFileTextData = *chilkatc::CkFtp2_remoteFileTextData;
*GetRemoteFileTextDataAsync = *chilkatc::CkFtp2_GetRemoteFileTextDataAsync;
*GetServerCert = *chilkatc::CkFtp2_GetServerCert;
*GetSize = *chilkatc::CkFtp2_GetSize;
*GetSizeAsync = *chilkatc::CkFtp2_GetSizeAsync;
*GetSize64 = *chilkatc::CkFtp2_GetSize64;
*GetSize64Async = *chilkatc::CkFtp2_GetSize64Async;
*GetSizeByName = *chilkatc::CkFtp2_GetSizeByName;
*GetSizeByNameAsync = *chilkatc::CkFtp2_GetSizeByNameAsync;
*GetSizeByName64 = *chilkatc::CkFtp2_GetSizeByName64;
*GetSizeByName64Async = *chilkatc::CkFtp2_GetSizeByName64Async;
*GetSizeStr = *chilkatc::CkFtp2_GetSizeStr;
*getSizeStr = *chilkatc::CkFtp2_getSizeStr;
*sizeStr = *chilkatc::CkFtp2_sizeStr;
*GetSizeStrAsync = *chilkatc::CkFtp2_GetSizeStrAsync;
*GetSizeStrByName = *chilkatc::CkFtp2_GetSizeStrByName;
*getSizeStrByName = *chilkatc::CkFtp2_getSizeStrByName;
*sizeStrByName = *chilkatc::CkFtp2_sizeStrByName;
*GetSizeStrByNameAsync = *chilkatc::CkFtp2_GetSizeStrByNameAsync;
*GetSslServerCert = *chilkatc::CkFtp2_GetSslServerCert;
*GetSyncedFiles = *chilkatc::CkFtp2_GetSyncedFiles;
*GetTextDirListing = *chilkatc::CkFtp2_GetTextDirListing;
*getTextDirListing = *chilkatc::CkFtp2_getTextDirListing;
*textDirListing = *chilkatc::CkFtp2_textDirListing;
*GetTextDirListingAsync = *chilkatc::CkFtp2_GetTextDirListingAsync;
*GetXmlDirListing = *chilkatc::CkFtp2_GetXmlDirListing;
*getXmlDirListing = *chilkatc::CkFtp2_getXmlDirListing;
*xmlDirListing = *chilkatc::CkFtp2_xmlDirListing;
*GetXmlDirListingAsync = *chilkatc::CkFtp2_GetXmlDirListingAsync;
*LargeFileUpload = *chilkatc::CkFtp2_LargeFileUpload;
*LargeFileUploadAsync = *chilkatc::CkFtp2_LargeFileUploadAsync;
*LoadTaskCaller = *chilkatc::CkFtp2_LoadTaskCaller;
*LoginAfterConnectOnly = *chilkatc::CkFtp2_LoginAfterConnectOnly;
*LoginAfterConnectOnlyAsync = *chilkatc::CkFtp2_LoginAfterConnectOnlyAsync;
*MGetFiles = *chilkatc::CkFtp2_MGetFiles;
*MGetFilesAsync = *chilkatc::CkFtp2_MGetFilesAsync;
*MPutFiles = *chilkatc::CkFtp2_MPutFiles;
*MPutFilesAsync = *chilkatc::CkFtp2_MPutFilesAsync;
*NlstXml = *chilkatc::CkFtp2_NlstXml;
*nlstXml = *chilkatc::CkFtp2_nlstXml;
*NlstXmlAsync = *chilkatc::CkFtp2_NlstXmlAsync;
*Noop = *chilkatc::CkFtp2_Noop;
*NoopAsync = *chilkatc::CkFtp2_NoopAsync;
*PutFile = *chilkatc::CkFtp2_PutFile;
*PutFileAsync = *chilkatc::CkFtp2_PutFileAsync;
*PutFileBd = *chilkatc::CkFtp2_PutFileBd;
*PutFileBdAsync = *chilkatc::CkFtp2_PutFileBdAsync;
*PutFileFromBinaryData = *chilkatc::CkFtp2_PutFileFromBinaryData;
*PutFileFromBinaryDataAsync = *chilkatc::CkFtp2_PutFileFromBinaryDataAsync;
*PutFileFromTextData = *chilkatc::CkFtp2_PutFileFromTextData;
*PutFileFromTextDataAsync = *chilkatc::CkFtp2_PutFileFromTextDataAsync;
*PutFileSb = *chilkatc::CkFtp2_PutFileSb;
*PutFileSbAsync = *chilkatc::CkFtp2_PutFileSbAsync;
*PutPlan = *chilkatc::CkFtp2_PutPlan;
*PutPlanAsync = *chilkatc::CkFtp2_PutPlanAsync;
*PutTree = *chilkatc::CkFtp2_PutTree;
*PutTreeAsync = *chilkatc::CkFtp2_PutTreeAsync;
*Quote = *chilkatc::CkFtp2_Quote;
*QuoteAsync = *chilkatc::CkFtp2_QuoteAsync;
*RemoveRemoteDir = *chilkatc::CkFtp2_RemoveRemoteDir;
*RemoveRemoteDirAsync = *chilkatc::CkFtp2_RemoveRemoteDirAsync;
*RenameRemoteFile = *chilkatc::CkFtp2_RenameRemoteFile;
*RenameRemoteFileAsync = *chilkatc::CkFtp2_RenameRemoteFileAsync;
*SendCommand = *chilkatc::CkFtp2_SendCommand;
*sendCommand = *chilkatc::CkFtp2_sendCommand;
*SendCommandAsync = *chilkatc::CkFtp2_SendCommandAsync;
*SetModeZ = *chilkatc::CkFtp2_SetModeZ;
*SetModeZAsync = *chilkatc::CkFtp2_SetModeZAsync;
*SetOldestDateStr = *chilkatc::CkFtp2_SetOldestDateStr;
*SetOption = *chilkatc::CkFtp2_SetOption;
*SetPassword = *chilkatc::CkFtp2_SetPassword;
*SetRemoteFileDateTimeStr = *chilkatc::CkFtp2_SetRemoteFileDateTimeStr;
*SetRemoteFileDateTimeStrAsync = *chilkatc::CkFtp2_SetRemoteFileDateTimeStrAsync;
*SetRemoteFileDt = *chilkatc::CkFtp2_SetRemoteFileDt;
*SetRemoteFileDtAsync = *chilkatc::CkFtp2_SetRemoteFileDtAsync;
*SetSecurePassword = *chilkatc::CkFtp2_SetSecurePassword;
*SetSslCertRequirement = *chilkatc::CkFtp2_SetSslCertRequirement;
*SetSslClientCert = *chilkatc::CkFtp2_SetSslClientCert;
*SetSslClientCertPem = *chilkatc::CkFtp2_SetSslClientCertPem;
*SetSslClientCertPfx = *chilkatc::CkFtp2_SetSslClientCertPfx;
*SetTypeAscii = *chilkatc::CkFtp2_SetTypeAscii;
*SetTypeAsciiAsync = *chilkatc::CkFtp2_SetTypeAsciiAsync;
*SetTypeBinary = *chilkatc::CkFtp2_SetTypeBinary;
*SetTypeBinaryAsync = *chilkatc::CkFtp2_SetTypeBinaryAsync;
*Site = *chilkatc::CkFtp2_Site;
*SiteAsync = *chilkatc::CkFtp2_SiteAsync;
*SleepMs = *chilkatc::CkFtp2_SleepMs;
*Stat = *chilkatc::CkFtp2_Stat;
*ck_stat = *chilkatc::CkFtp2_ck_stat;
*StatAsync = *chilkatc::CkFtp2_StatAsync;
*SyncDeleteRemote = *chilkatc::CkFtp2_SyncDeleteRemote;
*SyncDeleteRemoteAsync = *chilkatc::CkFtp2_SyncDeleteRemoteAsync;
*SyncLocalDir = *chilkatc::CkFtp2_SyncLocalDir;
*SyncLocalDirAsync = *chilkatc::CkFtp2_SyncLocalDirAsync;
*SyncLocalTree = *chilkatc::CkFtp2_SyncLocalTree;
*SyncLocalTreeAsync = *chilkatc::CkFtp2_SyncLocalTreeAsync;
*SyncRemoteTree = *chilkatc::CkFtp2_SyncRemoteTree;
*SyncRemoteTreeAsync = *chilkatc::CkFtp2_SyncRemoteTreeAsync;
*SyncRemoteTree2 = *chilkatc::CkFtp2_SyncRemoteTree2;
*SyncRemoteTree2Async = *chilkatc::CkFtp2_SyncRemoteTree2Async;
*Syst = *chilkatc::CkFtp2_Syst;
*syst = *chilkatc::CkFtp2_syst;
*SystAsync = *chilkatc::CkFtp2_SystAsync;
sub DISOWN {
    my $self = shift;
    my $ptr = tied(%$self);
    delete $OWNER{$ptr};
}

sub ACQUIRE {
    my $self = shift;
    my $ptr = tied(%$self);
    $OWNER{$ptr} = 1;
}


############# Class : chilkat::CkGlobal ##############

package chilkat::CkGlobal;
use vars qw(@ISA %OWNER %ITERATORS %BLESSEDMEMBERS);
@ISA = qw( chilkat );
%OWNER = ();
%ITERATORS = ();
sub new {
    my $pkg = shift;
    my $self = chilkatc::new_CkGlobal(@_);
    bless $self, $pkg if defined($self);
}

sub DESTROY {
    return unless $_[0]->isa('HASH');
    my $self = tied(%{$_[0]});
    return unless defined $self;
    delete $ITERATORS{$self};
    if (exists $OWNER{$self}) {
        chilkatc::delete_CkGlobal($self);
        delete $OWNER{$self};
    }
}

*get_Utf8 = *chilkatc::CkGlobal_get_Utf8;
*put_Utf8 = *chilkatc::CkGlobal_put_Utf8;
*LastErrorXml = *chilkatc::CkGlobal_LastErrorXml;
*LastErrorHtml = *chilkatc::CkGlobal_LastErrorHtml;
*LastErrorText = *chilkatc::CkGlobal_LastErrorText;
*get_AnsiCodePage = *chilkatc::CkGlobal_get_AnsiCodePage;
*put_AnsiCodePage = *chilkatc::CkGlobal_put_AnsiCodePage;
*get_AutoQBDecode = *chilkatc::CkGlobal_get_AutoQBDecode;
*put_AutoQBDecode = *chilkatc::CkGlobal_put_AutoQBDecode;
*get_DebugLogFilePath = *chilkatc::CkGlobal_get_DebugLogFilePath;
*debugLogFilePath = *chilkatc::CkGlobal_debugLogFilePath;
*put_DebugLogFilePath = *chilkatc::CkGlobal_put_DebugLogFilePath;
*get_DefaultNtlmVersion = *chilkatc::CkGlobal_get_DefaultNtlmVersion;
*put_DefaultNtlmVersion = *chilkatc::CkGlobal_put_DefaultNtlmVersion;
*get_DefaultUtf8 = *chilkatc::CkGlobal_get_DefaultUtf8;
*put_DefaultUtf8 = *chilkatc::CkGlobal_put_DefaultUtf8;
*get_DnsTimeToLive = *chilkatc::CkGlobal_get_DnsTimeToLive;
*put_DnsTimeToLive = *chilkatc::CkGlobal_put_DnsTimeToLive;
*get_EnableDnsCaching = *chilkatc::CkGlobal_get_EnableDnsCaching;
*put_EnableDnsCaching = *chilkatc::CkGlobal_put_EnableDnsCaching;
*get_LastErrorHtml = *chilkatc::CkGlobal_get_LastErrorHtml;
*lastErrorHtml = *chilkatc::CkGlobal_lastErrorHtml;
*get_LastErrorText = *chilkatc::CkGlobal_get_LastErrorText;
*lastErrorText = *chilkatc::CkGlobal_lastErrorText;
*get_LastErrorXml = *chilkatc::CkGlobal_get_LastErrorXml;
*lastErrorXml = *chilkatc::CkGlobal_lastErrorXml;
*get_LastMethodSuccess = *chilkatc::CkGlobal_get_LastMethodSuccess;
*put_LastMethodSuccess = *chilkatc::CkGlobal_put_LastMethodSuccess;
*get_MaxThreads = *chilkatc::CkGlobal_get_MaxThreads;
*put_MaxThreads = *chilkatc::CkGlobal_put_MaxThreads;
*get_PreferIpv6 = *chilkatc::CkGlobal_get_PreferIpv6;
*put_PreferIpv6 = *chilkatc::CkGlobal_put_PreferIpv6;
*get_ThreadPoolLogPath = *chilkatc::CkGlobal_get_ThreadPoolLogPath;
*threadPoolLogPath = *chilkatc::CkGlobal_threadPoolLogPath;
*put_ThreadPoolLogPath = *chilkatc::CkGlobal_put_ThreadPoolLogPath;
*get_UncommonOptions = *chilkatc::CkGlobal_get_UncommonOptions;
*uncommonOptions = *chilkatc::CkGlobal_uncommonOptions;
*put_UncommonOptions = *chilkatc::CkGlobal_put_UncommonOptions;
*get_UnlockStatus = *chilkatc::CkGlobal_get_UnlockStatus;
*get_UsePkcsConstructedEncoding = *chilkatc::CkGlobal_get_UsePkcsConstructedEncoding;
*put_UsePkcsConstructedEncoding = *chilkatc::CkGlobal_put_UsePkcsConstructedEncoding;
*get_VerboseLogging = *chilkatc::CkGlobal_get_VerboseLogging;
*put_VerboseLogging = *chilkatc::CkGlobal_put_VerboseLogging;
*get_VerboseTls = *chilkatc::CkGlobal_get_VerboseTls;
*put_VerboseTls = *chilkatc::CkGlobal_put_VerboseTls;
*get_Version = *chilkatc::CkGlobal_get_Version;
*version = *chilkatc::CkGlobal_version;
*DnsClearCache = *chilkatc::CkGlobal_DnsClearCache;
*FinalizeThreadPool = *chilkatc::CkGlobal_FinalizeThreadPool;
*ThreadPoolLogLine = *chilkatc::CkGlobal_ThreadPoolLogLine;
*UnlockBundle = *chilkatc::CkGlobal_UnlockBundle;
sub DISOWN {
    my $self = shift;
    my $ptr = tied(%$self);
    delete $OWNER{$ptr};
}

sub ACQUIRE {
    my $self = shift;
    my $ptr = tied(%$self);
    $OWNER{$ptr} = 1;
}


############# Class : chilkat::CkGzip ##############

package chilkat::CkGzip;
use vars qw(@ISA %OWNER %ITERATORS %BLESSEDMEMBERS);
@ISA = qw( chilkat );
%OWNER = ();
%ITERATORS = ();
sub new {
    my $pkg = shift;
    my $self = chilkatc::new_CkGzip(@_);
    bless $self, $pkg if defined($self);
}

sub DESTROY {
    return unless $_[0]->isa('HASH');
    my $self = tied(%{$_[0]});
    return unless defined $self;
    delete $ITERATORS{$self};
    if (exists $OWNER{$self}) {
        chilkatc::delete_CkGzip($self);
        delete $OWNER{$self};
    }
}

*get_Utf8 = *chilkatc::CkGzip_get_Utf8;
*put_Utf8 = *chilkatc::CkGzip_put_Utf8;
*LastErrorXml = *chilkatc::CkGzip_LastErrorXml;
*LastErrorHtml = *chilkatc::CkGzip_LastErrorHtml;
*LastErrorText = *chilkatc::CkGzip_LastErrorText;
*put_EventCallbackObject = *chilkatc::CkGzip_put_EventCallbackObject;
*get_AbortCurrent = *chilkatc::CkGzip_get_AbortCurrent;
*put_AbortCurrent = *chilkatc::CkGzip_put_AbortCurrent;
*get_Comment = *chilkatc::CkGzip_get_Comment;
*comment = *chilkatc::CkGzip_comment;
*put_Comment = *chilkatc::CkGzip_put_Comment;
*get_CompressionLevel = *chilkatc::CkGzip_get_CompressionLevel;
*put_CompressionLevel = *chilkatc::CkGzip_put_CompressionLevel;
*get_DebugLogFilePath = *chilkatc::CkGzip_get_DebugLogFilePath;
*debugLogFilePath = *chilkatc::CkGzip_debugLogFilePath;
*put_DebugLogFilePath = *chilkatc::CkGzip_put_DebugLogFilePath;
*get_Filename = *chilkatc::CkGzip_get_Filename;
*filename = *chilkatc::CkGzip_filename;
*put_Filename = *chilkatc::CkGzip_put_Filename;
*get_HeartbeatMs = *chilkatc::CkGzip_get_HeartbeatMs;
*put_HeartbeatMs = *chilkatc::CkGzip_put_HeartbeatMs;
*get_LastErrorHtml = *chilkatc::CkGzip_get_LastErrorHtml;
*lastErrorHtml = *chilkatc::CkGzip_lastErrorHtml;
*get_LastErrorText = *chilkatc::CkGzip_get_LastErrorText;
*lastErrorText = *chilkatc::CkGzip_lastErrorText;
*get_LastErrorXml = *chilkatc::CkGzip_get_LastErrorXml;
*lastErrorXml = *chilkatc::CkGzip_lastErrorXml;
*get_LastMethodSuccess = *chilkatc::CkGzip_get_LastMethodSuccess;
*put_LastMethodSuccess = *chilkatc::CkGzip_put_LastMethodSuccess;
*get_LastModStr = *chilkatc::CkGzip_get_LastModStr;
*lastModStr = *chilkatc::CkGzip_lastModStr;
*put_LastModStr = *chilkatc::CkGzip_put_LastModStr;
*get_UseCurrentDate = *chilkatc::CkGzip_get_UseCurrentDate;
*put_UseCurrentDate = *chilkatc::CkGzip_put_UseCurrentDate;
*get_VerboseLogging = *chilkatc::CkGzip_get_VerboseLogging;
*put_VerboseLogging = *chilkatc::CkGzip_put_VerboseLogging;
*get_Version = *chilkatc::CkGzip_get_Version;
*version = *chilkatc::CkGzip_version;
*CompressBd = *chilkatc::CkGzip_CompressBd;
*CompressBdAsync = *chilkatc::CkGzip_CompressBdAsync;
*CompressFile = *chilkatc::CkGzip_CompressFile;
*CompressFileAsync = *chilkatc::CkGzip_CompressFileAsync;
*CompressFile2 = *chilkatc::CkGzip_CompressFile2;
*CompressFile2Async = *chilkatc::CkGzip_CompressFile2Async;
*CompressFileBd = *chilkatc::CkGzip_CompressFileBd;
*CompressFileBdAsync = *chilkatc::CkGzip_CompressFileBdAsync;
*CompressFileToMem = *chilkatc::CkGzip_CompressFileToMem;
*CompressFileToMemAsync = *chilkatc::CkGzip_CompressFileToMemAsync;
*CompressMemory = *chilkatc::CkGzip_CompressMemory;
*CompressMemoryAsync = *chilkatc::CkGzip_CompressMemoryAsync;
*CompressMemToFile = *chilkatc::CkGzip_CompressMemToFile;
*CompressMemToFileAsync = *chilkatc::CkGzip_CompressMemToFileAsync;
*CompressSb = *chilkatc::CkGzip_CompressSb;
*CompressSbAsync = *chilkatc::CkGzip_CompressSbAsync;
*CompressString = *chilkatc::CkGzip_CompressString;
*CompressStringAsync = *chilkatc::CkGzip_CompressStringAsync;
*CompressStringENC = *chilkatc::CkGzip_CompressStringENC;
*compressStringENC = *chilkatc::CkGzip_compressStringENC;
*CompressStringToFile = *chilkatc::CkGzip_CompressStringToFile;
*CompressStringToFileAsync = *chilkatc::CkGzip_CompressStringToFileAsync;
*Decode = *chilkatc::CkGzip_Decode;
*DeflateStringENC = *chilkatc::CkGzip_DeflateStringENC;
*deflateStringENC = *chilkatc::CkGzip_deflateStringENC;
*Encode = *chilkatc::CkGzip_Encode;
*encode = *chilkatc::CkGzip_encode;
*ExamineFile = *chilkatc::CkGzip_ExamineFile;
*ExamineMemory = *chilkatc::CkGzip_ExamineMemory;
*GetDt = *chilkatc::CkGzip_GetDt;
*InflateStringENC = *chilkatc::CkGzip_InflateStringENC;
*inflateStringENC = *chilkatc::CkGzip_inflateStringENC;
*IsGzip = *chilkatc::CkGzip_IsGzip;
*LoadTaskCaller = *chilkatc::CkGzip_LoadTaskCaller;
*ReadFile = *chilkatc::CkGzip_ReadFile;
*SetDt = *chilkatc::CkGzip_SetDt;
*SetExtraData = *chilkatc::CkGzip_SetExtraData;
*UncompressBd = *chilkatc::CkGzip_UncompressBd;
*UncompressBdAsync = *chilkatc::CkGzip_UncompressBdAsync;
*UncompressBdToFile = *chilkatc::CkGzip_UncompressBdToFile;
*UncompressBdToFileAsync = *chilkatc::CkGzip_UncompressBdToFileAsync;
*UncompressFile = *chilkatc::CkGzip_UncompressFile;
*UncompressFileAsync = *chilkatc::CkGzip_UncompressFileAsync;
*UncompressFileToMem = *chilkatc::CkGzip_UncompressFileToMem;
*UncompressFileToMemAsync = *chilkatc::CkGzip_UncompressFileToMemAsync;
*UncompressFileToString = *chilkatc::CkGzip_UncompressFileToString;
*uncompressFileToString = *chilkatc::CkGzip_uncompressFileToString;
*UncompressFileToStringAsync = *chilkatc::CkGzip_UncompressFileToStringAsync;
*UncompressMemory = *chilkatc::CkGzip_UncompressMemory;
*UncompressMemoryAsync = *chilkatc::CkGzip_UncompressMemoryAsync;
*UncompressMemToFile = *chilkatc::CkGzip_UncompressMemToFile;
*UncompressMemToFileAsync = *chilkatc::CkGzip_UncompressMemToFileAsync;
*UncompressString = *chilkatc::CkGzip_UncompressString;
*uncompressString = *chilkatc::CkGzip_uncompressString;
*UncompressStringAsync = *chilkatc::CkGzip_UncompressStringAsync;
*UncompressStringENC = *chilkatc::CkGzip_UncompressStringENC;
*uncompressStringENC = *chilkatc::CkGzip_uncompressStringENC;
*UnTarGz = *chilkatc::CkGzip_UnTarGz;
*UnTarGzAsync = *chilkatc::CkGzip_UnTarGzAsync;
*WriteFile = *chilkatc::CkGzip_WriteFile;
*XfdlToXml = *chilkatc::CkGzip_XfdlToXml;
*xfdlToXml = *chilkatc::CkGzip_xfdlToXml;
sub DISOWN {
    my $self = shift;
    my $ptr = tied(%$self);
    delete $OWNER{$ptr};
}

sub ACQUIRE {
    my $self = shift;
    my $ptr = tied(%$self);
    $OWNER{$ptr} = 1;
}


############# Class : chilkat::CkHashtable ##############

package chilkat::CkHashtable;
use vars qw(@ISA %OWNER %ITERATORS %BLESSEDMEMBERS);
@ISA = qw( chilkat );
%OWNER = ();
%ITERATORS = ();
sub new {
    my $pkg = shift;
    my $self = chilkatc::new_CkHashtable(@_);
    bless $self, $pkg if defined($self);
}

sub DESTROY {
    return unless $_[0]->isa('HASH');
    my $self = tied(%{$_[0]});
    return unless defined $self;
    delete $ITERATORS{$self};
    if (exists $OWNER{$self}) {
        chilkatc::delete_CkHashtable($self);
        delete $OWNER{$self};
    }
}

*get_Utf8 = *chilkatc::CkHashtable_get_Utf8;
*put_Utf8 = *chilkatc::CkHashtable_put_Utf8;
*get_Count = *chilkatc::CkHashtable_get_Count;
*get_DebugLogFilePath = *chilkatc::CkHashtable_get_DebugLogFilePath;
*debugLogFilePath = *chilkatc::CkHashtable_debugLogFilePath;
*put_DebugLogFilePath = *chilkatc::CkHashtable_put_DebugLogFilePath;
*get_LastErrorHtml = *chilkatc::CkHashtable_get_LastErrorHtml;
*lastErrorHtml = *chilkatc::CkHashtable_lastErrorHtml;
*get_LastErrorText = *chilkatc::CkHashtable_get_LastErrorText;
*lastErrorText = *chilkatc::CkHashtable_lastErrorText;
*get_LastErrorXml = *chilkatc::CkHashtable_get_LastErrorXml;
*lastErrorXml = *chilkatc::CkHashtable_lastErrorXml;
*get_LastMethodSuccess = *chilkatc::CkHashtable_get_LastMethodSuccess;
*put_LastMethodSuccess = *chilkatc::CkHashtable_put_LastMethodSuccess;
*get_VerboseLogging = *chilkatc::CkHashtable_get_VerboseLogging;
*put_VerboseLogging = *chilkatc::CkHashtable_put_VerboseLogging;
*get_Version = *chilkatc::CkHashtable_get_Version;
*version = *chilkatc::CkHashtable_version;
*AddFromXmlSb = *chilkatc::CkHashtable_AddFromXmlSb;
*AddInt = *chilkatc::CkHashtable_AddInt;
*AddQueryParams = *chilkatc::CkHashtable_AddQueryParams;
*AddStr = *chilkatc::CkHashtable_AddStr;
*Clear = *chilkatc::CkHashtable_Clear;
*ClearWithNewCapacity = *chilkatc::CkHashtable_ClearWithNewCapacity;
*Contains = *chilkatc::CkHashtable_Contains;
*ContainsIntKey = *chilkatc::CkHashtable_ContainsIntKey;
*GetKeys = *chilkatc::CkHashtable_GetKeys;
*LookupInt = *chilkatc::CkHashtable_LookupInt;
*LookupStr = *chilkatc::CkHashtable_LookupStr;
*lookupStr = *chilkatc::CkHashtable_lookupStr;
*Remove = *chilkatc::CkHashtable_Remove;
*ToQueryString = *chilkatc::CkHashtable_ToQueryString;
*toQueryString = *chilkatc::CkHashtable_toQueryString;
*ToXmlSb = *chilkatc::CkHashtable_ToXmlSb;
sub DISOWN {
    my $self = shift;
    my $ptr = tied(%$self);
    delete $OWNER{$ptr};
}

sub ACQUIRE {
    my $self = shift;
    my $ptr = tied(%$self);
    $OWNER{$ptr} = 1;
}


############# Class : chilkat::CkHtmlToText ##############

package chilkat::CkHtmlToText;
use vars qw(@ISA %OWNER %ITERATORS %BLESSEDMEMBERS);
@ISA = qw( chilkat );
%OWNER = ();
%ITERATORS = ();
sub new {
    my $pkg = shift;
    my $self = chilkatc::new_CkHtmlToText(@_);
    bless $self, $pkg if defined($self);
}

sub DESTROY {
    return unless $_[0]->isa('HASH');
    my $self = tied(%{$_[0]});
    return unless defined $self;
    delete $ITERATORS{$self};
    if (exists $OWNER{$self}) {
        chilkatc::delete_CkHtmlToText($self);
        delete $OWNER{$self};
    }
}

*get_Utf8 = *chilkatc::CkHtmlToText_get_Utf8;
*put_Utf8 = *chilkatc::CkHtmlToText_put_Utf8;
*LastErrorXml = *chilkatc::CkHtmlToText_LastErrorXml;
*LastErrorHtml = *chilkatc::CkHtmlToText_LastErrorHtml;
*LastErrorText = *chilkatc::CkHtmlToText_LastErrorText;
*get_DebugLogFilePath = *chilkatc::CkHtmlToText_get_DebugLogFilePath;
*debugLogFilePath = *chilkatc::CkHtmlToText_debugLogFilePath;
*put_DebugLogFilePath = *chilkatc::CkHtmlToText_put_DebugLogFilePath;
*get_DecodeHtmlEntities = *chilkatc::CkHtmlToText_get_DecodeHtmlEntities;
*put_DecodeHtmlEntities = *chilkatc::CkHtmlToText_put_DecodeHtmlEntities;
*get_LastErrorHtml = *chilkatc::CkHtmlToText_get_LastErrorHtml;
*lastErrorHtml = *chilkatc::CkHtmlToText_lastErrorHtml;
*get_LastErrorText = *chilkatc::CkHtmlToText_get_LastErrorText;
*lastErrorText = *chilkatc::CkHtmlToText_lastErrorText;
*get_LastErrorXml = *chilkatc::CkHtmlToText_get_LastErrorXml;
*lastErrorXml = *chilkatc::CkHtmlToText_lastErrorXml;
*get_LastMethodSuccess = *chilkatc::CkHtmlToText_get_LastMethodSuccess;
*put_LastMethodSuccess = *chilkatc::CkHtmlToText_put_LastMethodSuccess;
*get_RightMargin = *chilkatc::CkHtmlToText_get_RightMargin;
*put_RightMargin = *chilkatc::CkHtmlToText_put_RightMargin;
*get_SuppressLinks = *chilkatc::CkHtmlToText_get_SuppressLinks;
*put_SuppressLinks = *chilkatc::CkHtmlToText_put_SuppressLinks;
*get_UncommonOptions = *chilkatc::CkHtmlToText_get_UncommonOptions;
*uncommonOptions = *chilkatc::CkHtmlToText_uncommonOptions;
*put_UncommonOptions = *chilkatc::CkHtmlToText_put_UncommonOptions;
*get_VerboseLogging = *chilkatc::CkHtmlToText_get_VerboseLogging;
*put_VerboseLogging = *chilkatc::CkHtmlToText_put_VerboseLogging;
*get_Version = *chilkatc::CkHtmlToText_get_Version;
*version = *chilkatc::CkHtmlToText_version;
*ReadFileToString = *chilkatc::CkHtmlToText_ReadFileToString;
*readFileToString = *chilkatc::CkHtmlToText_readFileToString;
*ToText = *chilkatc::CkHtmlToText_ToText;
*toText = *chilkatc::CkHtmlToText_toText;
*ToTextSb = *chilkatc::CkHtmlToText_ToTextSb;
*WriteStringToFile = *chilkatc::CkHtmlToText_WriteStringToFile;
sub DISOWN {
    my $self = shift;
    my $ptr = tied(%$self);
    delete $OWNER{$ptr};
}

sub ACQUIRE {
    my $self = shift;
    my $ptr = tied(%$self);
    $OWNER{$ptr} = 1;
}


############# Class : chilkat::CkHtmlToXml ##############

package chilkat::CkHtmlToXml;
use vars qw(@ISA %OWNER %ITERATORS %BLESSEDMEMBERS);
@ISA = qw( chilkat );
%OWNER = ();
%ITERATORS = ();
sub new {
    my $pkg = shift;
    my $self = chilkatc::new_CkHtmlToXml(@_);
    bless $self, $pkg if defined($self);
}

sub DESTROY {
    return unless $_[0]->isa('HASH');
    my $self = tied(%{$_[0]});
    return unless defined $self;
    delete $ITERATORS{$self};
    if (exists $OWNER{$self}) {
        chilkatc::delete_CkHtmlToXml($self);
        delete $OWNER{$self};
    }
}

*get_Utf8 = *chilkatc::CkHtmlToXml_get_Utf8;
*put_Utf8 = *chilkatc::CkHtmlToXml_put_Utf8;
*LastErrorXml = *chilkatc::CkHtmlToXml_LastErrorXml;
*LastErrorHtml = *chilkatc::CkHtmlToXml_LastErrorHtml;
*LastErrorText = *chilkatc::CkHtmlToXml_LastErrorText;
*get_DebugLogFilePath = *chilkatc::CkHtmlToXml_get_DebugLogFilePath;
*debugLogFilePath = *chilkatc::CkHtmlToXml_debugLogFilePath;
*put_DebugLogFilePath = *chilkatc::CkHtmlToXml_put_DebugLogFilePath;
*get_DropCustomTags = *chilkatc::CkHtmlToXml_get_DropCustomTags;
*put_DropCustomTags = *chilkatc::CkHtmlToXml_put_DropCustomTags;
*get_Html = *chilkatc::CkHtmlToXml_get_Html;
*html = *chilkatc::CkHtmlToXml_html;
*put_Html = *chilkatc::CkHtmlToXml_put_Html;
*get_LastErrorHtml = *chilkatc::CkHtmlToXml_get_LastErrorHtml;
*lastErrorHtml = *chilkatc::CkHtmlToXml_lastErrorHtml;
*get_LastErrorText = *chilkatc::CkHtmlToXml_get_LastErrorText;
*lastErrorText = *chilkatc::CkHtmlToXml_lastErrorText;
*get_LastErrorXml = *chilkatc::CkHtmlToXml_get_LastErrorXml;
*lastErrorXml = *chilkatc::CkHtmlToXml_lastErrorXml;
*get_LastMethodSuccess = *chilkatc::CkHtmlToXml_get_LastMethodSuccess;
*put_LastMethodSuccess = *chilkatc::CkHtmlToXml_put_LastMethodSuccess;
*get_Nbsp = *chilkatc::CkHtmlToXml_get_Nbsp;
*put_Nbsp = *chilkatc::CkHtmlToXml_put_Nbsp;
*get_VerboseLogging = *chilkatc::CkHtmlToXml_get_VerboseLogging;
*put_VerboseLogging = *chilkatc::CkHtmlToXml_put_VerboseLogging;
*get_Version = *chilkatc::CkHtmlToXml_get_Version;
*version = *chilkatc::CkHtmlToXml_version;
*get_XmlCharset = *chilkatc::CkHtmlToXml_get_XmlCharset;
*xmlCharset = *chilkatc::CkHtmlToXml_xmlCharset;
*put_XmlCharset = *chilkatc::CkHtmlToXml_put_XmlCharset;
*ConvertFile = *chilkatc::CkHtmlToXml_ConvertFile;
*DropTagType = *chilkatc::CkHtmlToXml_DropTagType;
*DropTextFormattingTags = *chilkatc::CkHtmlToXml_DropTextFormattingTags;
*ReadFile = *chilkatc::CkHtmlToXml_ReadFile;
*ReadFileToString = *chilkatc::CkHtmlToXml_ReadFileToString;
*readFileToString = *chilkatc::CkHtmlToXml_readFileToString;
*SetHtmlBd = *chilkatc::CkHtmlToXml_SetHtmlBd;
*SetHtmlBytes = *chilkatc::CkHtmlToXml_SetHtmlBytes;
*SetHtmlFromFile = *chilkatc::CkHtmlToXml_SetHtmlFromFile;
*SetHtmlSb = *chilkatc::CkHtmlToXml_SetHtmlSb;
*ToXml = *chilkatc::CkHtmlToXml_ToXml;
*toXml = *chilkatc::CkHtmlToXml_toXml;
*ToXmlSb = *chilkatc::CkHtmlToXml_ToXmlSb;
*UndropTagType = *chilkatc::CkHtmlToXml_UndropTagType;
*UndropTextFormattingTags = *chilkatc::CkHtmlToXml_UndropTextFormattingTags;
*WriteFile = *chilkatc::CkHtmlToXml_WriteFile;
*WriteStringToFile = *chilkatc::CkHtmlToXml_WriteStringToFile;
*Xml = *chilkatc::CkHtmlToXml_Xml;
*xml = *chilkatc::CkHtmlToXml_xml;
sub DISOWN {
    my $self = shift;
    my $ptr = tied(%$self);
    delete $OWNER{$ptr};
}

sub ACQUIRE {
    my $self = shift;
    my $ptr = tied(%$self);
    $OWNER{$ptr} = 1;
}


############# Class : chilkat::CkHttp ##############

package chilkat::CkHttp;
use vars qw(@ISA %OWNER %ITERATORS %BLESSEDMEMBERS);
@ISA = qw( chilkat );
%OWNER = ();
%ITERATORS = ();
sub new {
    my $pkg = shift;
    my $self = chilkatc::new_CkHttp(@_);
    bless $self, $pkg if defined($self);
}

sub DESTROY {
    return unless $_[0]->isa('HASH');
    my $self = tied(%{$_[0]});
    return unless defined $self;
    delete $ITERATORS{$self};
    if (exists $OWNER{$self}) {
        chilkatc::delete_CkHttp($self);
        delete $OWNER{$self};
    }
}

*get_Utf8 = *chilkatc::CkHttp_get_Utf8;
*put_Utf8 = *chilkatc::CkHttp_put_Utf8;
*LastErrorXml = *chilkatc::CkHttp_LastErrorXml;
*LastErrorHtml = *chilkatc::CkHttp_LastErrorHtml;
*LastErrorText = *chilkatc::CkHttp_LastErrorText;
*put_EventCallbackObject = *chilkatc::CkHttp_put_EventCallbackObject;
*get_AbortCurrent = *chilkatc::CkHttp_get_AbortCurrent;
*put_AbortCurrent = *chilkatc::CkHttp_put_AbortCurrent;
*get_Accept = *chilkatc::CkHttp_get_Accept;
*ck_accept = *chilkatc::CkHttp_ck_accept;
*put_Accept = *chilkatc::CkHttp_put_Accept;
*get_AcceptCharset = *chilkatc::CkHttp_get_AcceptCharset;
*acceptCharset = *chilkatc::CkHttp_acceptCharset;
*put_AcceptCharset = *chilkatc::CkHttp_put_AcceptCharset;
*get_AcceptLanguage = *chilkatc::CkHttp_get_AcceptLanguage;
*acceptLanguage = *chilkatc::CkHttp_acceptLanguage;
*put_AcceptLanguage = *chilkatc::CkHttp_put_AcceptLanguage;
*get_AllowGzip = *chilkatc::CkHttp_get_AllowGzip;
*put_AllowGzip = *chilkatc::CkHttp_put_AllowGzip;
*get_AllowHeaderFolding = *chilkatc::CkHttp_get_AllowHeaderFolding;
*put_AllowHeaderFolding = *chilkatc::CkHttp_put_AllowHeaderFolding;
*get_AuthSignature = *chilkatc::CkHttp_get_AuthSignature;
*authSignature = *chilkatc::CkHttp_authSignature;
*put_AuthSignature = *chilkatc::CkHttp_put_AuthSignature;
*get_AuthToken = *chilkatc::CkHttp_get_AuthToken;
*authToken = *chilkatc::CkHttp_authToken;
*put_AuthToken = *chilkatc::CkHttp_put_AuthToken;
*get_AutoAddHostHeader = *chilkatc::CkHttp_get_AutoAddHostHeader;
*put_AutoAddHostHeader = *chilkatc::CkHttp_put_AutoAddHostHeader;
*get_AwsAccessKey = *chilkatc::CkHttp_get_AwsAccessKey;
*awsAccessKey = *chilkatc::CkHttp_awsAccessKey;
*put_AwsAccessKey = *chilkatc::CkHttp_put_AwsAccessKey;
*get_AwsEndpoint = *chilkatc::CkHttp_get_AwsEndpoint;
*awsEndpoint = *chilkatc::CkHttp_awsEndpoint;
*put_AwsEndpoint = *chilkatc::CkHttp_put_AwsEndpoint;
*get_AwsRegion = *chilkatc::CkHttp_get_AwsRegion;
*awsRegion = *chilkatc::CkHttp_awsRegion;
*put_AwsRegion = *chilkatc::CkHttp_put_AwsRegion;
*get_AwsSecretKey = *chilkatc::CkHttp_get_AwsSecretKey;
*awsSecretKey = *chilkatc::CkHttp_awsSecretKey;
*put_AwsSecretKey = *chilkatc::CkHttp_put_AwsSecretKey;
*get_AwsSessionToken = *chilkatc::CkHttp_get_AwsSessionToken;
*awsSessionToken = *chilkatc::CkHttp_awsSessionToken;
*put_AwsSessionToken = *chilkatc::CkHttp_put_AwsSessionToken;
*get_AwsSignatureVersion = *chilkatc::CkHttp_get_AwsSignatureVersion;
*put_AwsSignatureVersion = *chilkatc::CkHttp_put_AwsSignatureVersion;
*get_AwsSubResources = *chilkatc::CkHttp_get_AwsSubResources;
*awsSubResources = *chilkatc::CkHttp_awsSubResources;
*put_AwsSubResources = *chilkatc::CkHttp_put_AwsSubResources;
*get_BandwidthThrottleDown = *chilkatc::CkHttp_get_BandwidthThrottleDown;
*put_BandwidthThrottleDown = *chilkatc::CkHttp_put_BandwidthThrottleDown;
*get_BandwidthThrottleUp = *chilkatc::CkHttp_get_BandwidthThrottleUp;
*put_BandwidthThrottleUp = *chilkatc::CkHttp_put_BandwidthThrottleUp;
*get_BasicAuth = *chilkatc::CkHttp_get_BasicAuth;
*put_BasicAuth = *chilkatc::CkHttp_put_BasicAuth;
*get_ClientIpAddress = *chilkatc::CkHttp_get_ClientIpAddress;
*clientIpAddress = *chilkatc::CkHttp_clientIpAddress;
*put_ClientIpAddress = *chilkatc::CkHttp_put_ClientIpAddress;
*get_ConnectFailReason = *chilkatc::CkHttp_get_ConnectFailReason;
*get_Connection = *chilkatc::CkHttp_get_Connection;
*connection = *chilkatc::CkHttp_connection;
*put_Connection = *chilkatc::CkHttp_put_Connection;
*get_ConnectTimeout = *chilkatc::CkHttp_get_ConnectTimeout;
*put_ConnectTimeout = *chilkatc::CkHttp_put_ConnectTimeout;
*get_CookieDir = *chilkatc::CkHttp_get_CookieDir;
*cookieDir = *chilkatc::CkHttp_cookieDir;
*put_CookieDir = *chilkatc::CkHttp_put_CookieDir;
*get_DebugLogFilePath = *chilkatc::CkHttp_get_DebugLogFilePath;
*debugLogFilePath = *chilkatc::CkHttp_debugLogFilePath;
*put_DebugLogFilePath = *chilkatc::CkHttp_put_DebugLogFilePath;
*get_DefaultFreshPeriod = *chilkatc::CkHttp_get_DefaultFreshPeriod;
*put_DefaultFreshPeriod = *chilkatc::CkHttp_put_DefaultFreshPeriod;
*get_DigestAuth = *chilkatc::CkHttp_get_DigestAuth;
*put_DigestAuth = *chilkatc::CkHttp_put_DigestAuth;
*get_FetchFromCache = *chilkatc::CkHttp_get_FetchFromCache;
*put_FetchFromCache = *chilkatc::CkHttp_put_FetchFromCache;
*get_FinalRedirectUrl = *chilkatc::CkHttp_get_FinalRedirectUrl;
*finalRedirectUrl = *chilkatc::CkHttp_finalRedirectUrl;
*get_FollowRedirects = *chilkatc::CkHttp_get_FollowRedirects;
*put_FollowRedirects = *chilkatc::CkHttp_put_FollowRedirects;
*get_FreshnessAlgorithm = *chilkatc::CkHttp_get_FreshnessAlgorithm;
*put_FreshnessAlgorithm = *chilkatc::CkHttp_put_FreshnessAlgorithm;
*get_HeartbeatMs = *chilkatc::CkHttp_get_HeartbeatMs;
*put_HeartbeatMs = *chilkatc::CkHttp_put_HeartbeatMs;
*get_IgnoreMustRevalidate = *chilkatc::CkHttp_get_IgnoreMustRevalidate;
*put_IgnoreMustRevalidate = *chilkatc::CkHttp_put_IgnoreMustRevalidate;
*get_IgnoreNoCache = *chilkatc::CkHttp_get_IgnoreNoCache;
*put_IgnoreNoCache = *chilkatc::CkHttp_put_IgnoreNoCache;
*get_KeepResponseBody = *chilkatc::CkHttp_get_KeepResponseBody;
*put_KeepResponseBody = *chilkatc::CkHttp_put_KeepResponseBody;
*get_LastContentType = *chilkatc::CkHttp_get_LastContentType;
*lastContentType = *chilkatc::CkHttp_lastContentType;
*get_LastErrorHtml = *chilkatc::CkHttp_get_LastErrorHtml;
*lastErrorHtml = *chilkatc::CkHttp_lastErrorHtml;
*get_LastErrorText = *chilkatc::CkHttp_get_LastErrorText;
*lastErrorText = *chilkatc::CkHttp_lastErrorText;
*get_LastErrorXml = *chilkatc::CkHttp_get_LastErrorXml;
*lastErrorXml = *chilkatc::CkHttp_lastErrorXml;
*get_LastFromCache = *chilkatc::CkHttp_get_LastFromCache;
*get_LastHeader = *chilkatc::CkHttp_get_LastHeader;
*lastHeader = *chilkatc::CkHttp_lastHeader;
*get_LastMethodSuccess = *chilkatc::CkHttp_get_LastMethodSuccess;
*put_LastMethodSuccess = *chilkatc::CkHttp_put_LastMethodSuccess;
*get_LastModDate = *chilkatc::CkHttp_get_LastModDate;
*lastModDate = *chilkatc::CkHttp_lastModDate;
*get_LastResponseBody = *chilkatc::CkHttp_get_LastResponseBody;
*lastResponseBody = *chilkatc::CkHttp_lastResponseBody;
*get_LastResponseHeader = *chilkatc::CkHttp_get_LastResponseHeader;
*lastResponseHeader = *chilkatc::CkHttp_lastResponseHeader;
*get_LastStatus = *chilkatc::CkHttp_get_LastStatus;
*get_LastStatusText = *chilkatc::CkHttp_get_LastStatusText;
*lastStatusText = *chilkatc::CkHttp_lastStatusText;
*get_LMFactor = *chilkatc::CkHttp_get_LMFactor;
*put_LMFactor = *chilkatc::CkHttp_put_LMFactor;
*get_Login = *chilkatc::CkHttp_get_Login;
*login = *chilkatc::CkHttp_login;
*put_Login = *chilkatc::CkHttp_put_Login;
*get_LoginDomain = *chilkatc::CkHttp_get_LoginDomain;
*loginDomain = *chilkatc::CkHttp_loginDomain;
*put_LoginDomain = *chilkatc::CkHttp_put_LoginDomain;
*get_MaxConnections = *chilkatc::CkHttp_get_MaxConnections;
*put_MaxConnections = *chilkatc::CkHttp_put_MaxConnections;
*get_MaxFreshPeriod = *chilkatc::CkHttp_get_MaxFreshPeriod;
*put_MaxFreshPeriod = *chilkatc::CkHttp_put_MaxFreshPeriod;
*get_MaxResponseSize = *chilkatc::CkHttp_get_MaxResponseSize;
*put_MaxResponseSize = *chilkatc::CkHttp_put_MaxResponseSize;
*get_MaxUrlLen = *chilkatc::CkHttp_get_MaxUrlLen;
*put_MaxUrlLen = *chilkatc::CkHttp_put_MaxUrlLen;
*get_MimicFireFox = *chilkatc::CkHttp_get_MimicFireFox;
*put_MimicFireFox = *chilkatc::CkHttp_put_MimicFireFox;
*get_MimicIE = *chilkatc::CkHttp_get_MimicIE;
*put_MimicIE = *chilkatc::CkHttp_put_MimicIE;
*get_MinFreshPeriod = *chilkatc::CkHttp_get_MinFreshPeriod;
*put_MinFreshPeriod = *chilkatc::CkHttp_put_MinFreshPeriod;
*get_NegotiateAuth = *chilkatc::CkHttp_get_NegotiateAuth;
*put_NegotiateAuth = *chilkatc::CkHttp_put_NegotiateAuth;
*get_NtlmAuth = *chilkatc::CkHttp_get_NtlmAuth;
*put_NtlmAuth = *chilkatc::CkHttp_put_NtlmAuth;
*get_NumCacheLevels = *chilkatc::CkHttp_get_NumCacheLevels;
*put_NumCacheLevels = *chilkatc::CkHttp_put_NumCacheLevels;
*get_NumCacheRoots = *chilkatc::CkHttp_get_NumCacheRoots;
*get_OAuth1 = *chilkatc::CkHttp_get_OAuth1;
*put_OAuth1 = *chilkatc::CkHttp_put_OAuth1;
*get_OAuthBodyHash = *chilkatc::CkHttp_get_OAuthBodyHash;
*put_OAuthBodyHash = *chilkatc::CkHttp_put_OAuthBodyHash;
*get_OAuthCallback = *chilkatc::CkHttp_get_OAuthCallback;
*oAuthCallback = *chilkatc::CkHttp_oAuthCallback;
*put_OAuthCallback = *chilkatc::CkHttp_put_OAuthCallback;
*get_OAuthConsumerKey = *chilkatc::CkHttp_get_OAuthConsumerKey;
*oAuthConsumerKey = *chilkatc::CkHttp_oAuthConsumerKey;
*put_OAuthConsumerKey = *chilkatc::CkHttp_put_OAuthConsumerKey;
*get_OAuthConsumerSecret = *chilkatc::CkHttp_get_OAuthConsumerSecret;
*oAuthConsumerSecret = *chilkatc::CkHttp_oAuthConsumerSecret;
*put_OAuthConsumerSecret = *chilkatc::CkHttp_put_OAuthConsumerSecret;
*get_OAuthRealm = *chilkatc::CkHttp_get_OAuthRealm;
*oAuthRealm = *chilkatc::CkHttp_oAuthRealm;
*put_OAuthRealm = *chilkatc::CkHttp_put_OAuthRealm;
*get_OAuthSigMethod = *chilkatc::CkHttp_get_OAuthSigMethod;
*oAuthSigMethod = *chilkatc::CkHttp_oAuthSigMethod;
*put_OAuthSigMethod = *chilkatc::CkHttp_put_OAuthSigMethod;
*get_OAuthToken = *chilkatc::CkHttp_get_OAuthToken;
*oAuthToken = *chilkatc::CkHttp_oAuthToken;
*put_OAuthToken = *chilkatc::CkHttp_put_OAuthToken;
*get_OAuthTokenSecret = *chilkatc::CkHttp_get_OAuthTokenSecret;
*oAuthTokenSecret = *chilkatc::CkHttp_oAuthTokenSecret;
*put_OAuthTokenSecret = *chilkatc::CkHttp_put_OAuthTokenSecret;
*get_OAuthVerifier = *chilkatc::CkHttp_get_OAuthVerifier;
*oAuthVerifier = *chilkatc::CkHttp_oAuthVerifier;
*put_OAuthVerifier = *chilkatc::CkHttp_put_OAuthVerifier;
*get_Password = *chilkatc::CkHttp_get_Password;
*password = *chilkatc::CkHttp_password;
*put_Password = *chilkatc::CkHttp_put_Password;
*get_PercentDoneScale = *chilkatc::CkHttp_get_PercentDoneScale;
*put_PercentDoneScale = *chilkatc::CkHttp_put_PercentDoneScale;
*get_PreferIpv6 = *chilkatc::CkHttp_get_PreferIpv6;
*put_PreferIpv6 = *chilkatc::CkHttp_put_PreferIpv6;
*get_ProxyAuthMethod = *chilkatc::CkHttp_get_ProxyAuthMethod;
*proxyAuthMethod = *chilkatc::CkHttp_proxyAuthMethod;
*put_ProxyAuthMethod = *chilkatc::CkHttp_put_ProxyAuthMethod;
*get_ProxyDirectTls = *chilkatc::CkHttp_get_ProxyDirectTls;
*put_ProxyDirectTls = *chilkatc::CkHttp_put_ProxyDirectTls;
*get_ProxyDomain = *chilkatc::CkHttp_get_ProxyDomain;
*proxyDomain = *chilkatc::CkHttp_proxyDomain;
*put_ProxyDomain = *chilkatc::CkHttp_put_ProxyDomain;
*get_ProxyLogin = *chilkatc::CkHttp_get_ProxyLogin;
*proxyLogin = *chilkatc::CkHttp_proxyLogin;
*put_ProxyLogin = *chilkatc::CkHttp_put_ProxyLogin;
*get_ProxyLoginDomain = *chilkatc::CkHttp_get_ProxyLoginDomain;
*proxyLoginDomain = *chilkatc::CkHttp_proxyLoginDomain;
*put_ProxyLoginDomain = *chilkatc::CkHttp_put_ProxyLoginDomain;
*get_ProxyPassword = *chilkatc::CkHttp_get_ProxyPassword;
*proxyPassword = *chilkatc::CkHttp_proxyPassword;
*put_ProxyPassword = *chilkatc::CkHttp_put_ProxyPassword;
*get_ProxyPort = *chilkatc::CkHttp_get_ProxyPort;
*put_ProxyPort = *chilkatc::CkHttp_put_ProxyPort;
*get_ReadTimeout = *chilkatc::CkHttp_get_ReadTimeout;
*put_ReadTimeout = *chilkatc::CkHttp_put_ReadTimeout;
*get_ReceivedCertReq = *chilkatc::CkHttp_get_ReceivedCertReq;
*get_RedirectVerb = *chilkatc::CkHttp_get_RedirectVerb;
*redirectVerb = *chilkatc::CkHttp_redirectVerb;
*put_RedirectVerb = *chilkatc::CkHttp_put_RedirectVerb;
*get_Referer = *chilkatc::CkHttp_get_Referer;
*referer = *chilkatc::CkHttp_referer;
*put_Referer = *chilkatc::CkHttp_put_Referer;
*get_RequiredContentType = *chilkatc::CkHttp_get_RequiredContentType;
*requiredContentType = *chilkatc::CkHttp_requiredContentType;
*put_RequiredContentType = *chilkatc::CkHttp_put_RequiredContentType;
*get_RequireHostnameMatch = *chilkatc::CkHttp_get_RequireHostnameMatch;
*put_RequireHostnameMatch = *chilkatc::CkHttp_put_RequireHostnameMatch;
*get_RequireSslCertVerify = *chilkatc::CkHttp_get_RequireSslCertVerify;
*put_RequireSslCertVerify = *chilkatc::CkHttp_put_RequireSslCertVerify;
*get_SaveCookies = *chilkatc::CkHttp_get_SaveCookies;
*put_SaveCookies = *chilkatc::CkHttp_put_SaveCookies;
*get_SendBufferSize = *chilkatc::CkHttp_get_SendBufferSize;
*put_SendBufferSize = *chilkatc::CkHttp_put_SendBufferSize;
*get_SendCookies = *chilkatc::CkHttp_get_SendCookies;
*put_SendCookies = *chilkatc::CkHttp_put_SendCookies;
*get_SessionLogFilename = *chilkatc::CkHttp_get_SessionLogFilename;
*sessionLogFilename = *chilkatc::CkHttp_sessionLogFilename;
*put_SessionLogFilename = *chilkatc::CkHttp_put_SessionLogFilename;
*get_SniHostname = *chilkatc::CkHttp_get_SniHostname;
*sniHostname = *chilkatc::CkHttp_sniHostname;
*put_SniHostname = *chilkatc::CkHttp_put_SniHostname;
*get_SocksHostname = *chilkatc::CkHttp_get_SocksHostname;
*socksHostname = *chilkatc::CkHttp_socksHostname;
*put_SocksHostname = *chilkatc::CkHttp_put_SocksHostname;
*get_SocksPassword = *chilkatc::CkHttp_get_SocksPassword;
*socksPassword = *chilkatc::CkHttp_socksPassword;
*put_SocksPassword = *chilkatc::CkHttp_put_SocksPassword;
*get_SocksPort = *chilkatc::CkHttp_get_SocksPort;
*put_SocksPort = *chilkatc::CkHttp_put_SocksPort;
*get_SocksUsername = *chilkatc::CkHttp_get_SocksUsername;
*socksUsername = *chilkatc::CkHttp_socksUsername;
*put_SocksUsername = *chilkatc::CkHttp_put_SocksUsername;
*get_SocksVersion = *chilkatc::CkHttp_get_SocksVersion;
*put_SocksVersion = *chilkatc::CkHttp_put_SocksVersion;
*get_SoRcvBuf = *chilkatc::CkHttp_get_SoRcvBuf;
*put_SoRcvBuf = *chilkatc::CkHttp_put_SoRcvBuf;
*get_SoSndBuf = *chilkatc::CkHttp_get_SoSndBuf;
*put_SoSndBuf = *chilkatc::CkHttp_put_SoSndBuf;
*get_SslAllowedCiphers = *chilkatc::CkHttp_get_SslAllowedCiphers;
*sslAllowedCiphers = *chilkatc::CkHttp_sslAllowedCiphers;
*put_SslAllowedCiphers = *chilkatc::CkHttp_put_SslAllowedCiphers;
*get_SslProtocol = *chilkatc::CkHttp_get_SslProtocol;
*sslProtocol = *chilkatc::CkHttp_sslProtocol;
*put_SslProtocol = *chilkatc::CkHttp_put_SslProtocol;
*get_StreamResponseBodyPath = *chilkatc::CkHttp_get_StreamResponseBodyPath;
*streamResponseBodyPath = *chilkatc::CkHttp_streamResponseBodyPath;
*put_StreamResponseBodyPath = *chilkatc::CkHttp_put_StreamResponseBodyPath;
*get_TlsCipherSuite = *chilkatc::CkHttp_get_TlsCipherSuite;
*tlsCipherSuite = *chilkatc::CkHttp_tlsCipherSuite;
*get_TlsPinSet = *chilkatc::CkHttp_get_TlsPinSet;
*tlsPinSet = *chilkatc::CkHttp_tlsPinSet;
*put_TlsPinSet = *chilkatc::CkHttp_put_TlsPinSet;
*get_TlsVersion = *chilkatc::CkHttp_get_TlsVersion;
*tlsVersion = *chilkatc::CkHttp_tlsVersion;
*get_UncommonOptions = *chilkatc::CkHttp_get_UncommonOptions;
*uncommonOptions = *chilkatc::CkHttp_uncommonOptions;
*put_UncommonOptions = *chilkatc::CkHttp_put_UncommonOptions;
*get_UpdateCache = *chilkatc::CkHttp_get_UpdateCache;
*put_UpdateCache = *chilkatc::CkHttp_put_UpdateCache;
*get_UseIEProxy = *chilkatc::CkHttp_get_UseIEProxy;
*put_UseIEProxy = *chilkatc::CkHttp_put_UseIEProxy;
*get_UserAgent = *chilkatc::CkHttp_get_UserAgent;
*userAgent = *chilkatc::CkHttp_userAgent;
*put_UserAgent = *chilkatc::CkHttp_put_UserAgent;
*get_VerboseLogging = *chilkatc::CkHttp_get_VerboseLogging;
*put_VerboseLogging = *chilkatc::CkHttp_put_VerboseLogging;
*get_Version = *chilkatc::CkHttp_get_Version;
*version = *chilkatc::CkHttp_version;
*get_WasRedirected = *chilkatc::CkHttp_get_WasRedirected;
*AddCacheRoot = *chilkatc::CkHttp_AddCacheRoot;
*ClearHeaders = *chilkatc::CkHttp_ClearHeaders;
*ClearInMemoryCookies = *chilkatc::CkHttp_ClearInMemoryCookies;
*ClearUrlVars = *chilkatc::CkHttp_ClearUrlVars;
*CloseAllConnections = *chilkatc::CkHttp_CloseAllConnections;
*CloseAllConnectionsAsync = *chilkatc::CkHttp_CloseAllConnectionsAsync;
*CreateOcspRequest = *chilkatc::CkHttp_CreateOcspRequest;
*CreateTimestampRequest = *chilkatc::CkHttp_CreateTimestampRequest;
*DnsCacheClear = *chilkatc::CkHttp_DnsCacheClear;
*Download = *chilkatc::CkHttp_Download;
*DownloadAsync = *chilkatc::CkHttp_DownloadAsync;
*DownloadAppend = *chilkatc::CkHttp_DownloadAppend;
*DownloadAppendAsync = *chilkatc::CkHttp_DownloadAppendAsync;
*DownloadBd = *chilkatc::CkHttp_DownloadBd;
*DownloadBdAsync = *chilkatc::CkHttp_DownloadBdAsync;
*DownloadHash = *chilkatc::CkHttp_DownloadHash;
*downloadHash = *chilkatc::CkHttp_downloadHash;
*DownloadHashAsync = *chilkatc::CkHttp_DownloadHashAsync;
*DownloadSb = *chilkatc::CkHttp_DownloadSb;
*DownloadSbAsync = *chilkatc::CkHttp_DownloadSbAsync;
*ExtractMetaRefreshUrl = *chilkatc::CkHttp_ExtractMetaRefreshUrl;
*extractMetaRefreshUrl = *chilkatc::CkHttp_extractMetaRefreshUrl;
*G_SvcOauthAccessToken = *chilkatc::CkHttp_G_SvcOauthAccessToken;
*g_SvcOauthAccessToken = *chilkatc::CkHttp_g_SvcOauthAccessToken;
*G_SvcOauthAccessTokenAsync = *chilkatc::CkHttp_G_SvcOauthAccessTokenAsync;
*G_SvcOauthAccessToken2 = *chilkatc::CkHttp_G_SvcOauthAccessToken2;
*g_SvcOauthAccessToken2 = *chilkatc::CkHttp_g_SvcOauthAccessToken2;
*G_SvcOauthAccessToken2Async = *chilkatc::CkHttp_G_SvcOauthAccessToken2Async;
*GenTimeStamp = *chilkatc::CkHttp_GenTimeStamp;
*genTimeStamp = *chilkatc::CkHttp_genTimeStamp;
*GetCacheRoot = *chilkatc::CkHttp_GetCacheRoot;
*getCacheRoot = *chilkatc::CkHttp_getCacheRoot;
*cacheRoot = *chilkatc::CkHttp_cacheRoot;
*GetCookieXml = *chilkatc::CkHttp_GetCookieXml;
*getCookieXml = *chilkatc::CkHttp_getCookieXml;
*cookieXml = *chilkatc::CkHttp_cookieXml;
*GetDomain = *chilkatc::CkHttp_GetDomain;
*getDomain = *chilkatc::CkHttp_getDomain;
*domain = *chilkatc::CkHttp_domain;
*GetHead = *chilkatc::CkHttp_GetHead;
*GetHeadAsync = *chilkatc::CkHttp_GetHeadAsync;
*GetLastJsonData = *chilkatc::CkHttp_GetLastJsonData;
*GetRequestHeader = *chilkatc::CkHttp_GetRequestHeader;
*getRequestHeader = *chilkatc::CkHttp_getRequestHeader;
*requestHeader = *chilkatc::CkHttp_requestHeader;
*GetServerCert = *chilkatc::CkHttp_GetServerCert;
*GetServerCertAsync = *chilkatc::CkHttp_GetServerCertAsync;
*GetServerSslCert = *chilkatc::CkHttp_GetServerSslCert;
*GetServerSslCertAsync = *chilkatc::CkHttp_GetServerSslCertAsync;
*GetUrlPath = *chilkatc::CkHttp_GetUrlPath;
*getUrlPath = *chilkatc::CkHttp_getUrlPath;
*urlPath = *chilkatc::CkHttp_urlPath;
*HasRequestHeader = *chilkatc::CkHttp_HasRequestHeader;
*HttpBd = *chilkatc::CkHttp_HttpBd;
*HttpBdAsync = *chilkatc::CkHttp_HttpBdAsync;
*HttpBinary = *chilkatc::CkHttp_HttpBinary;
*HttpBinaryAsync = *chilkatc::CkHttp_HttpBinaryAsync;
*HttpFile = *chilkatc::CkHttp_HttpFile;
*HttpFileAsync = *chilkatc::CkHttp_HttpFileAsync;
*HttpJson = *chilkatc::CkHttp_HttpJson;
*HttpJsonAsync = *chilkatc::CkHttp_HttpJsonAsync;
*HttpNoBody = *chilkatc::CkHttp_HttpNoBody;
*HttpNoBodyAsync = *chilkatc::CkHttp_HttpNoBodyAsync;
*HttpParams = *chilkatc::CkHttp_HttpParams;
*HttpParamsAsync = *chilkatc::CkHttp_HttpParamsAsync;
*HttpReq = *chilkatc::CkHttp_HttpReq;
*HttpReqAsync = *chilkatc::CkHttp_HttpReqAsync;
*HttpSb = *chilkatc::CkHttp_HttpSb;
*HttpSbAsync = *chilkatc::CkHttp_HttpSbAsync;
*HttpSReq = *chilkatc::CkHttp_HttpSReq;
*HttpSReqAsync = *chilkatc::CkHttp_HttpSReqAsync;
*HttpStr = *chilkatc::CkHttp_HttpStr;
*HttpStrAsync = *chilkatc::CkHttp_HttpStrAsync;
*LastJsonData = *chilkatc::CkHttp_LastJsonData;
*LoadTaskCaller = *chilkatc::CkHttp_LoadTaskCaller;
*OcspCheck = *chilkatc::CkHttp_OcspCheck;
*OcspCheckAsync = *chilkatc::CkHttp_OcspCheckAsync;
*ParseOcspReply = *chilkatc::CkHttp_ParseOcspReply;
*PBinary = *chilkatc::CkHttp_PBinary;
*PBinaryAsync = *chilkatc::CkHttp_PBinaryAsync;
*PBinaryBd = *chilkatc::CkHttp_PBinaryBd;
*PBinaryBdAsync = *chilkatc::CkHttp_PBinaryBdAsync;
*PFile = *chilkatc::CkHttp_PFile;
*PFileAsync = *chilkatc::CkHttp_PFileAsync;
*PostBinary = *chilkatc::CkHttp_PostBinary;
*postBinary = *chilkatc::CkHttp_postBinary;
*PostBinaryAsync = *chilkatc::CkHttp_PostBinaryAsync;
*PostJson = *chilkatc::CkHttp_PostJson;
*PostJsonAsync = *chilkatc::CkHttp_PostJsonAsync;
*PostJson2 = *chilkatc::CkHttp_PostJson2;
*PostJson2Async = *chilkatc::CkHttp_PostJson2Async;
*PostJson3 = *chilkatc::CkHttp_PostJson3;
*PostJson3Async = *chilkatc::CkHttp_PostJson3Async;
*PostUrlEncoded = *chilkatc::CkHttp_PostUrlEncoded;
*PostUrlEncodedAsync = *chilkatc::CkHttp_PostUrlEncodedAsync;
*PostXml = *chilkatc::CkHttp_PostXml;
*PostXmlAsync = *chilkatc::CkHttp_PostXmlAsync;
*PText = *chilkatc::CkHttp_PText;
*PTextAsync = *chilkatc::CkHttp_PTextAsync;
*PTextSb = *chilkatc::CkHttp_PTextSb;
*PTextSbAsync = *chilkatc::CkHttp_PTextSbAsync;
*PutBinary = *chilkatc::CkHttp_PutBinary;
*putBinary = *chilkatc::CkHttp_putBinary;
*PutBinaryAsync = *chilkatc::CkHttp_PutBinaryAsync;
*PutText = *chilkatc::CkHttp_PutText;
*putText = *chilkatc::CkHttp_putText;
*PutTextAsync = *chilkatc::CkHttp_PutTextAsync;
*QuickDeleteStr = *chilkatc::CkHttp_QuickDeleteStr;
*quickDeleteStr = *chilkatc::CkHttp_quickDeleteStr;
*QuickDeleteStrAsync = *chilkatc::CkHttp_QuickDeleteStrAsync;
*QuickGet = *chilkatc::CkHttp_QuickGet;
*QuickGetAsync = *chilkatc::CkHttp_QuickGetAsync;
*QuickGetBd = *chilkatc::CkHttp_QuickGetBd;
*QuickGetBdAsync = *chilkatc::CkHttp_QuickGetBdAsync;
*QuickGetObj = *chilkatc::CkHttp_QuickGetObj;
*QuickGetObjAsync = *chilkatc::CkHttp_QuickGetObjAsync;
*QuickGetSb = *chilkatc::CkHttp_QuickGetSb;
*QuickGetSbAsync = *chilkatc::CkHttp_QuickGetSbAsync;
*QuickGetStr = *chilkatc::CkHttp_QuickGetStr;
*quickGetStr = *chilkatc::CkHttp_quickGetStr;
*QuickGetStrAsync = *chilkatc::CkHttp_QuickGetStrAsync;
*QuickPutStr = *chilkatc::CkHttp_QuickPutStr;
*quickPutStr = *chilkatc::CkHttp_quickPutStr;
*QuickPutStrAsync = *chilkatc::CkHttp_QuickPutStrAsync;
*QuickRequest = *chilkatc::CkHttp_QuickRequest;
*QuickRequestAsync = *chilkatc::CkHttp_QuickRequestAsync;
*QuickRequestParams = *chilkatc::CkHttp_QuickRequestParams;
*QuickRequestParamsAsync = *chilkatc::CkHttp_QuickRequestParamsAsync;
*RemoveRequestHeader = *chilkatc::CkHttp_RemoveRequestHeader;
*RenderGet = *chilkatc::CkHttp_RenderGet;
*renderGet = *chilkatc::CkHttp_renderGet;
*ResumeDownload = *chilkatc::CkHttp_ResumeDownload;
*ResumeDownloadAsync = *chilkatc::CkHttp_ResumeDownloadAsync;
*ResumeDownloadBd = *chilkatc::CkHttp_ResumeDownloadBd;
*ResumeDownloadBdAsync = *chilkatc::CkHttp_ResumeDownloadBdAsync;
*S3_CreateBucket = *chilkatc::CkHttp_S3_CreateBucket;
*S3_CreateBucketAsync = *chilkatc::CkHttp_S3_CreateBucketAsync;
*S3_DeleteBucket = *chilkatc::CkHttp_S3_DeleteBucket;
*S3_DeleteBucketAsync = *chilkatc::CkHttp_S3_DeleteBucketAsync;
*S3_DeleteMultipleObjects = *chilkatc::CkHttp_S3_DeleteMultipleObjects;
*S3_DeleteMultipleObjectsAsync = *chilkatc::CkHttp_S3_DeleteMultipleObjectsAsync;
*S3_DeleteObject = *chilkatc::CkHttp_S3_DeleteObject;
*S3_DeleteObjectAsync = *chilkatc::CkHttp_S3_DeleteObjectAsync;
*S3_DeleteObjects = *chilkatc::CkHttp_S3_DeleteObjects;
*S3_DeleteObjectsAsync = *chilkatc::CkHttp_S3_DeleteObjectsAsync;
*S3_DownloadBd = *chilkatc::CkHttp_S3_DownloadBd;
*S3_DownloadBdAsync = *chilkatc::CkHttp_S3_DownloadBdAsync;
*S3_DownloadBytes = *chilkatc::CkHttp_S3_DownloadBytes;
*S3_DownloadBytesAsync = *chilkatc::CkHttp_S3_DownloadBytesAsync;
*S3_DownloadFile = *chilkatc::CkHttp_S3_DownloadFile;
*S3_DownloadFileAsync = *chilkatc::CkHttp_S3_DownloadFileAsync;
*S3_DownloadString = *chilkatc::CkHttp_S3_DownloadString;
*s3_DownloadString = *chilkatc::CkHttp_s3_DownloadString;
*S3_DownloadStringAsync = *chilkatc::CkHttp_S3_DownloadStringAsync;
*S3_FileExists = *chilkatc::CkHttp_S3_FileExists;
*S3_FileExistsAsync = *chilkatc::CkHttp_S3_FileExistsAsync;
*S3_GenerateUrl = *chilkatc::CkHttp_S3_GenerateUrl;
*s3_GenerateUrl = *chilkatc::CkHttp_s3_GenerateUrl;
*S3_GenerateUrlV4 = *chilkatc::CkHttp_S3_GenerateUrlV4;
*s3_GenerateUrlV4 = *chilkatc::CkHttp_s3_GenerateUrlV4;
*S3_GenPresignedUrl = *chilkatc::CkHttp_S3_GenPresignedUrl;
*s3_GenPresignedUrl = *chilkatc::CkHttp_s3_GenPresignedUrl;
*S3_ListBucketObjects = *chilkatc::CkHttp_S3_ListBucketObjects;
*s3_ListBucketObjects = *chilkatc::CkHttp_s3_ListBucketObjects;
*S3_ListBucketObjectsAsync = *chilkatc::CkHttp_S3_ListBucketObjectsAsync;
*S3_ListBuckets = *chilkatc::CkHttp_S3_ListBuckets;
*s3_ListBuckets = *chilkatc::CkHttp_s3_ListBuckets;
*S3_ListBucketsAsync = *chilkatc::CkHttp_S3_ListBucketsAsync;
*S3_UploadBd = *chilkatc::CkHttp_S3_UploadBd;
*S3_UploadBdAsync = *chilkatc::CkHttp_S3_UploadBdAsync;
*S3_UploadBytes = *chilkatc::CkHttp_S3_UploadBytes;
*S3_UploadBytesAsync = *chilkatc::CkHttp_S3_UploadBytesAsync;
*S3_UploadFile = *chilkatc::CkHttp_S3_UploadFile;
*S3_UploadFileAsync = *chilkatc::CkHttp_S3_UploadFileAsync;
*S3_UploadString = *chilkatc::CkHttp_S3_UploadString;
*S3_UploadStringAsync = *chilkatc::CkHttp_S3_UploadStringAsync;
*SetAuthPrivateKey = *chilkatc::CkHttp_SetAuthPrivateKey;
*SetAuthTokenSb = *chilkatc::CkHttp_SetAuthTokenSb;
*SetCookieXml = *chilkatc::CkHttp_SetCookieXml;
*SetOAuthRsaKey = *chilkatc::CkHttp_SetOAuthRsaKey;
*SetRequestHeader = *chilkatc::CkHttp_SetRequestHeader;
*SetSecurePassword = *chilkatc::CkHttp_SetSecurePassword;
*SetSslCertRequirement = *chilkatc::CkHttp_SetSslCertRequirement;
*SetSslClientCert = *chilkatc::CkHttp_SetSslClientCert;
*SetSslClientCertPem = *chilkatc::CkHttp_SetSslClientCertPem;
*SetSslClientCertPfx = *chilkatc::CkHttp_SetSslClientCertPfx;
*SetUrlVar = *chilkatc::CkHttp_SetUrlVar;
*SharePointOnlineAuth = *chilkatc::CkHttp_SharePointOnlineAuth;
*SharePointOnlineAuthAsync = *chilkatc::CkHttp_SharePointOnlineAuthAsync;
*SleepMs = *chilkatc::CkHttp_SleepMs;
*SynchronousRequest = *chilkatc::CkHttp_SynchronousRequest;
*SynchronousRequestAsync = *chilkatc::CkHttp_SynchronousRequestAsync;
*UrlDecode = *chilkatc::CkHttp_UrlDecode;
*urlDecode = *chilkatc::CkHttp_urlDecode;
*UrlEncode = *chilkatc::CkHttp_UrlEncode;
*urlEncode = *chilkatc::CkHttp_urlEncode;
*VerifyTimestampReply = *chilkatc::CkHttp_VerifyTimestampReply;
*XmlRpc = *chilkatc::CkHttp_XmlRpc;
*xmlRpc = *chilkatc::CkHttp_xmlRpc;
*XmlRpcAsync = *chilkatc::CkHttp_XmlRpcAsync;
*XmlRpcPut = *chilkatc::CkHttp_XmlRpcPut;
*xmlRpcPut = *chilkatc::CkHttp_xmlRpcPut;
*XmlRpcPutAsync = *chilkatc::CkHttp_XmlRpcPutAsync;
sub DISOWN {
    my $self = shift;
    my $ptr = tied(%$self);
    delete $OWNER{$ptr};
}

sub ACQUIRE {
    my $self = shift;
    my $ptr = tied(%$self);
    $OWNER{$ptr} = 1;
}


############# Class : chilkat::CkHttpRequest ##############

package chilkat::CkHttpRequest;
use vars qw(@ISA %OWNER %ITERATORS %BLESSEDMEMBERS);
@ISA = qw( chilkat );
%OWNER = ();
%ITERATORS = ();
sub new {
    my $pkg = shift;
    my $self = chilkatc::new_CkHttpRequest(@_);
    bless $self, $pkg if defined($self);
}

sub DESTROY {
    return unless $_[0]->isa('HASH');
    my $self = tied(%{$_[0]});
    return unless defined $self;
    delete $ITERATORS{$self};
    if (exists $OWNER{$self}) {
        chilkatc::delete_CkHttpRequest($self);
        delete $OWNER{$self};
    }
}

*get_Utf8 = *chilkatc::CkHttpRequest_get_Utf8;
*put_Utf8 = *chilkatc::CkHttpRequest_put_Utf8;
*LastErrorXml = *chilkatc::CkHttpRequest_LastErrorXml;
*LastErrorHtml = *chilkatc::CkHttpRequest_LastErrorHtml;
*LastErrorText = *chilkatc::CkHttpRequest_LastErrorText;
*get_Boundary = *chilkatc::CkHttpRequest_get_Boundary;
*boundary = *chilkatc::CkHttpRequest_boundary;
*put_Boundary = *chilkatc::CkHttpRequest_put_Boundary;
*get_Charset = *chilkatc::CkHttpRequest_get_Charset;
*charset = *chilkatc::CkHttpRequest_charset;
*put_Charset = *chilkatc::CkHttpRequest_put_Charset;
*get_ContentType = *chilkatc::CkHttpRequest_get_ContentType;
*contentType = *chilkatc::CkHttpRequest_contentType;
*put_ContentType = *chilkatc::CkHttpRequest_put_ContentType;
*get_DebugLogFilePath = *chilkatc::CkHttpRequest_get_DebugLogFilePath;
*debugLogFilePath = *chilkatc::CkHttpRequest_debugLogFilePath;
*put_DebugLogFilePath = *chilkatc::CkHttpRequest_put_DebugLogFilePath;
*get_EntireHeader = *chilkatc::CkHttpRequest_get_EntireHeader;
*entireHeader = *chilkatc::CkHttpRequest_entireHeader;
*put_EntireHeader = *chilkatc::CkHttpRequest_put_EntireHeader;
*get_HttpVerb = *chilkatc::CkHttpRequest_get_HttpVerb;
*httpVerb = *chilkatc::CkHttpRequest_httpVerb;
*put_HttpVerb = *chilkatc::CkHttpRequest_put_HttpVerb;
*get_HttpVersion = *chilkatc::CkHttpRequest_get_HttpVersion;
*httpVersion = *chilkatc::CkHttpRequest_httpVersion;
*put_HttpVersion = *chilkatc::CkHttpRequest_put_HttpVersion;
*get_LastErrorHtml = *chilkatc::CkHttpRequest_get_LastErrorHtml;
*lastErrorHtml = *chilkatc::CkHttpRequest_lastErrorHtml;
*get_LastErrorText = *chilkatc::CkHttpRequest_get_LastErrorText;
*lastErrorText = *chilkatc::CkHttpRequest_lastErrorText;
*get_LastErrorXml = *chilkatc::CkHttpRequest_get_LastErrorXml;
*lastErrorXml = *chilkatc::CkHttpRequest_lastErrorXml;
*get_LastMethodSuccess = *chilkatc::CkHttpRequest_get_LastMethodSuccess;
*put_LastMethodSuccess = *chilkatc::CkHttpRequest_put_LastMethodSuccess;
*get_NumHeaderFields = *chilkatc::CkHttpRequest_get_NumHeaderFields;
*get_NumParams = *chilkatc::CkHttpRequest_get_NumParams;
*get_Path = *chilkatc::CkHttpRequest_get_Path;
*path = *chilkatc::CkHttpRequest_path;
*put_Path = *chilkatc::CkHttpRequest_put_Path;
*get_SendCharset = *chilkatc::CkHttpRequest_get_SendCharset;
*put_SendCharset = *chilkatc::CkHttpRequest_put_SendCharset;
*get_VerboseLogging = *chilkatc::CkHttpRequest_get_VerboseLogging;
*put_VerboseLogging = *chilkatc::CkHttpRequest_put_VerboseLogging;
*get_Version = *chilkatc::CkHttpRequest_get_Version;
*version = *chilkatc::CkHttpRequest_version;
*AddBdForUpload = *chilkatc::CkHttpRequest_AddBdForUpload;
*AddBytesForUpload = *chilkatc::CkHttpRequest_AddBytesForUpload;
*AddBytesForUpload2 = *chilkatc::CkHttpRequest_AddBytesForUpload2;
*AddFileForUpload = *chilkatc::CkHttpRequest_AddFileForUpload;
*AddFileForUpload2 = *chilkatc::CkHttpRequest_AddFileForUpload2;
*AddHeader = *chilkatc::CkHttpRequest_AddHeader;
*AddMwsSignature = *chilkatc::CkHttpRequest_AddMwsSignature;
*AddParam = *chilkatc::CkHttpRequest_AddParam;
*AddStringForUpload = *chilkatc::CkHttpRequest_AddStringForUpload;
*AddStringForUpload2 = *chilkatc::CkHttpRequest_AddStringForUpload2;
*AddSubHeader = *chilkatc::CkHttpRequest_AddSubHeader;
*GenerateRequestFile = *chilkatc::CkHttpRequest_GenerateRequestFile;
*GenerateRequestText = *chilkatc::CkHttpRequest_GenerateRequestText;
*generateRequestText = *chilkatc::CkHttpRequest_generateRequestText;
*GetHeaderField = *chilkatc::CkHttpRequest_GetHeaderField;
*getHeaderField = *chilkatc::CkHttpRequest_getHeaderField;
*headerField = *chilkatc::CkHttpRequest_headerField;
*GetHeaderName = *chilkatc::CkHttpRequest_GetHeaderName;
*getHeaderName = *chilkatc::CkHttpRequest_getHeaderName;
*headerName = *chilkatc::CkHttpRequest_headerName;
*GetHeaderValue = *chilkatc::CkHttpRequest_GetHeaderValue;
*getHeaderValue = *chilkatc::CkHttpRequest_getHeaderValue;
*headerValue = *chilkatc::CkHttpRequest_headerValue;
*GetParam = *chilkatc::CkHttpRequest_GetParam;
*getParam = *chilkatc::CkHttpRequest_getParam;
*param = *chilkatc::CkHttpRequest_param;
*GetParamName = *chilkatc::CkHttpRequest_GetParamName;
*getParamName = *chilkatc::CkHttpRequest_getParamName;
*paramName = *chilkatc::CkHttpRequest_paramName;
*GetParamValue = *chilkatc::CkHttpRequest_GetParamValue;
*getParamValue = *chilkatc::CkHttpRequest_getParamValue;
*paramValue = *chilkatc::CkHttpRequest_paramValue;
*GetUrlEncodedParams = *chilkatc::CkHttpRequest_GetUrlEncodedParams;
*getUrlEncodedParams = *chilkatc::CkHttpRequest_getUrlEncodedParams;
*urlEncodedParams = *chilkatc::CkHttpRequest_urlEncodedParams;
*LoadBodyFromBd = *chilkatc::CkHttpRequest_LoadBodyFromBd;
*LoadBodyFromBytes = *chilkatc::CkHttpRequest_LoadBodyFromBytes;
*LoadBodyFromFile = *chilkatc::CkHttpRequest_LoadBodyFromFile;
*LoadBodyFromSb = *chilkatc::CkHttpRequest_LoadBodyFromSb;
*LoadBodyFromString = *chilkatc::CkHttpRequest_LoadBodyFromString;
*RemoveAllParams = *chilkatc::CkHttpRequest_RemoveAllParams;
*RemoveHeader = *chilkatc::CkHttpRequest_RemoveHeader;
*RemoveParam = *chilkatc::CkHttpRequest_RemoveParam;
*SetFromUrl = *chilkatc::CkHttpRequest_SetFromUrl;
*StreamBodyFromFile = *chilkatc::CkHttpRequest_StreamBodyFromFile;
*StreamChunkFromFile = *chilkatc::CkHttpRequest_StreamChunkFromFile;
sub DISOWN {
    my $self = shift;
    my $ptr = tied(%$self);
    delete $OWNER{$ptr};
}

sub ACQUIRE {
    my $self = shift;
    my $ptr = tied(%$self);
    $OWNER{$ptr} = 1;
}


############# Class : chilkat::CkHttpResponse ##############

package chilkat::CkHttpResponse;
use vars qw(@ISA %OWNER %ITERATORS %BLESSEDMEMBERS);
@ISA = qw( chilkat );
%OWNER = ();
%ITERATORS = ();
sub new {
    my $pkg = shift;
    my $self = chilkatc::new_CkHttpResponse(@_);
    bless $self, $pkg if defined($self);
}

sub DESTROY {
    return unless $_[0]->isa('HASH');
    my $self = tied(%{$_[0]});
    return unless defined $self;
    delete $ITERATORS{$self};
    if (exists $OWNER{$self}) {
        chilkatc::delete_CkHttpResponse($self);
        delete $OWNER{$self};
    }
}

*get_Utf8 = *chilkatc::CkHttpResponse_get_Utf8;
*put_Utf8 = *chilkatc::CkHttpResponse_put_Utf8;
*LastErrorXml = *chilkatc::CkHttpResponse_LastErrorXml;
*LastErrorHtml = *chilkatc::CkHttpResponse_LastErrorHtml;
*LastErrorText = *chilkatc::CkHttpResponse_LastErrorText;
*get_BodyQP = *chilkatc::CkHttpResponse_get_BodyQP;
*bodyQP = *chilkatc::CkHttpResponse_bodyQP;
*get_BodyStr = *chilkatc::CkHttpResponse_get_BodyStr;
*bodyStr = *chilkatc::CkHttpResponse_bodyStr;
*get_Charset = *chilkatc::CkHttpResponse_get_Charset;
*charset = *chilkatc::CkHttpResponse_charset;
*get_ContentLength = *chilkatc::CkHttpResponse_get_ContentLength;
*get_ContentLength64 = *chilkatc::CkHttpResponse_get_ContentLength64;
*get_DateStr = *chilkatc::CkHttpResponse_get_DateStr;
*dateStr = *chilkatc::CkHttpResponse_dateStr;
*get_DebugLogFilePath = *chilkatc::CkHttpResponse_get_DebugLogFilePath;
*debugLogFilePath = *chilkatc::CkHttpResponse_debugLogFilePath;
*put_DebugLogFilePath = *chilkatc::CkHttpResponse_put_DebugLogFilePath;
*get_Domain = *chilkatc::CkHttpResponse_get_Domain;
*domain = *chilkatc::CkHttpResponse_domain;
*get_FinalRedirectUrl = *chilkatc::CkHttpResponse_get_FinalRedirectUrl;
*finalRedirectUrl = *chilkatc::CkHttpResponse_finalRedirectUrl;
*get_FullMime = *chilkatc::CkHttpResponse_get_FullMime;
*fullMime = *chilkatc::CkHttpResponse_fullMime;
*get_Header = *chilkatc::CkHttpResponse_get_Header;
*header = *chilkatc::CkHttpResponse_header;
*get_LastErrorHtml = *chilkatc::CkHttpResponse_get_LastErrorHtml;
*lastErrorHtml = *chilkatc::CkHttpResponse_lastErrorHtml;
*get_LastErrorText = *chilkatc::CkHttpResponse_get_LastErrorText;
*lastErrorText = *chilkatc::CkHttpResponse_lastErrorText;
*get_LastErrorXml = *chilkatc::CkHttpResponse_get_LastErrorXml;
*lastErrorXml = *chilkatc::CkHttpResponse_lastErrorXml;
*get_LastMethodSuccess = *chilkatc::CkHttpResponse_get_LastMethodSuccess;
*put_LastMethodSuccess = *chilkatc::CkHttpResponse_put_LastMethodSuccess;
*get_NumCookies = *chilkatc::CkHttpResponse_get_NumCookies;
*get_NumHeaderFields = *chilkatc::CkHttpResponse_get_NumHeaderFields;
*get_StatusCode = *chilkatc::CkHttpResponse_get_StatusCode;
*get_StatusLine = *chilkatc::CkHttpResponse_get_StatusLine;
*statusLine = *chilkatc::CkHttpResponse_statusLine;
*get_StatusText = *chilkatc::CkHttpResponse_get_StatusText;
*statusText = *chilkatc::CkHttpResponse_statusText;
*get_UncommonOptions = *chilkatc::CkHttpResponse_get_UncommonOptions;
*uncommonOptions = *chilkatc::CkHttpResponse_uncommonOptions;
*put_UncommonOptions = *chilkatc::CkHttpResponse_put_UncommonOptions;
*get_VerboseLogging = *chilkatc::CkHttpResponse_get_VerboseLogging;
*put_VerboseLogging = *chilkatc::CkHttpResponse_put_VerboseLogging;
*get_Version = *chilkatc::CkHttpResponse_get_Version;
*version = *chilkatc::CkHttpResponse_version;
*GetBodyBd = *chilkatc::CkHttpResponse_GetBodyBd;
*GetBodyJarr = *chilkatc::CkHttpResponse_GetBodyJarr;
*GetBodyJson = *chilkatc::CkHttpResponse_GetBodyJson;
*GetBodySb = *chilkatc::CkHttpResponse_GetBodySb;
*GetBodyXml = *chilkatc::CkHttpResponse_GetBodyXml;
*GetCookieDomain = *chilkatc::CkHttpResponse_GetCookieDomain;
*getCookieDomain = *chilkatc::CkHttpResponse_getCookieDomain;
*cookieDomain = *chilkatc::CkHttpResponse_cookieDomain;
*GetCookieExpiresStr = *chilkatc::CkHttpResponse_GetCookieExpiresStr;
*getCookieExpiresStr = *chilkatc::CkHttpResponse_getCookieExpiresStr;
*cookieExpiresStr = *chilkatc::CkHttpResponse_cookieExpiresStr;
*GetCookieName = *chilkatc::CkHttpResponse_GetCookieName;
*getCookieName = *chilkatc::CkHttpResponse_getCookieName;
*cookieName = *chilkatc::CkHttpResponse_cookieName;
*GetCookiePath = *chilkatc::CkHttpResponse_GetCookiePath;
*getCookiePath = *chilkatc::CkHttpResponse_getCookiePath;
*cookiePath = *chilkatc::CkHttpResponse_cookiePath;
*GetCookieValue = *chilkatc::CkHttpResponse_GetCookieValue;
*getCookieValue = *chilkatc::CkHttpResponse_getCookieValue;
*cookieValue = *chilkatc::CkHttpResponse_cookieValue;
*GetHeaderField = *chilkatc::CkHttpResponse_GetHeaderField;
*getHeaderField = *chilkatc::CkHttpResponse_getHeaderField;
*headerField = *chilkatc::CkHttpResponse_headerField;
*GetHeaderFieldAttr = *chilkatc::CkHttpResponse_GetHeaderFieldAttr;
*getHeaderFieldAttr = *chilkatc::CkHttpResponse_getHeaderFieldAttr;
*headerFieldAttr = *chilkatc::CkHttpResponse_headerFieldAttr;
*GetHeaderName = *chilkatc::CkHttpResponse_GetHeaderName;
*getHeaderName = *chilkatc::CkHttpResponse_getHeaderName;
*headerName = *chilkatc::CkHttpResponse_headerName;
*GetHeaderValue = *chilkatc::CkHttpResponse_GetHeaderValue;
*getHeaderValue = *chilkatc::CkHttpResponse_getHeaderValue;
*headerValue = *chilkatc::CkHttpResponse_headerValue;
*LoadTaskResult = *chilkatc::CkHttpResponse_LoadTaskResult;
*SaveBodyBinary = *chilkatc::CkHttpResponse_SaveBodyBinary;
*SaveBodyText = *chilkatc::CkHttpResponse_SaveBodyText;
*UrlEncParamValue = *chilkatc::CkHttpResponse_UrlEncParamValue;
*urlEncParamValue = *chilkatc::CkHttpResponse_urlEncParamValue;
sub DISOWN {
    my $self = shift;
    my $ptr = tied(%$self);
    delete $OWNER{$ptr};
}

sub ACQUIRE {
    my $self = shift;
    my $ptr = tied(%$self);
    $OWNER{$ptr} = 1;
}


############# Class : chilkat::CkImap ##############

package chilkat::CkImap;
use vars qw(@ISA %OWNER %ITERATORS %BLESSEDMEMBERS);
@ISA = qw( chilkat );
%OWNER = ();
%ITERATORS = ();
sub new {
    my $pkg = shift;
    my $self = chilkatc::new_CkImap(@_);
    bless $self, $pkg if defined($self);
}

sub DESTROY {
    return unless $_[0]->isa('HASH');
    my $self = tied(%{$_[0]});
    return unless defined $self;
    delete $ITERATORS{$self};
    if (exists $OWNER{$self}) {
        chilkatc::delete_CkImap($self);
        delete $OWNER{$self};
    }
}

*get_Utf8 = *chilkatc::CkImap_get_Utf8;
*put_Utf8 = *chilkatc::CkImap_put_Utf8;
*LastErrorXml = *chilkatc::CkImap_LastErrorXml;
*LastErrorHtml = *chilkatc::CkImap_LastErrorHtml;
*LastErrorText = *chilkatc::CkImap_LastErrorText;
*put_EventCallbackObject = *chilkatc::CkImap_put_EventCallbackObject;
*get_AbortCurrent = *chilkatc::CkImap_get_AbortCurrent;
*put_AbortCurrent = *chilkatc::CkImap_put_AbortCurrent;
*get_AppendSeen = *chilkatc::CkImap_get_AppendSeen;
*put_AppendSeen = *chilkatc::CkImap_put_AppendSeen;
*get_AppendUid = *chilkatc::CkImap_get_AppendUid;
*get_AuthMethod = *chilkatc::CkImap_get_AuthMethod;
*authMethod = *chilkatc::CkImap_authMethod;
*put_AuthMethod = *chilkatc::CkImap_put_AuthMethod;
*get_AuthzId = *chilkatc::CkImap_get_AuthzId;
*authzId = *chilkatc::CkImap_authzId;
*put_AuthzId = *chilkatc::CkImap_put_AuthzId;
*get_AutoDownloadAttachments = *chilkatc::CkImap_get_AutoDownloadAttachments;
*put_AutoDownloadAttachments = *chilkatc::CkImap_put_AutoDownloadAttachments;
*get_AutoFix = *chilkatc::CkImap_get_AutoFix;
*put_AutoFix = *chilkatc::CkImap_put_AutoFix;
*get_ClientIpAddress = *chilkatc::CkImap_get_ClientIpAddress;
*clientIpAddress = *chilkatc::CkImap_clientIpAddress;
*put_ClientIpAddress = *chilkatc::CkImap_put_ClientIpAddress;
*get_ConnectedToHost = *chilkatc::CkImap_get_ConnectedToHost;
*connectedToHost = *chilkatc::CkImap_connectedToHost;
*get_ConnectTimeout = *chilkatc::CkImap_get_ConnectTimeout;
*put_ConnectTimeout = *chilkatc::CkImap_put_ConnectTimeout;
*get_DebugLogFilePath = *chilkatc::CkImap_get_DebugLogFilePath;
*debugLogFilePath = *chilkatc::CkImap_debugLogFilePath;
*put_DebugLogFilePath = *chilkatc::CkImap_put_DebugLogFilePath;
*get_Domain = *chilkatc::CkImap_get_Domain;
*domain = *chilkatc::CkImap_domain;
*put_Domain = *chilkatc::CkImap_put_Domain;
*get_HeartbeatMs = *chilkatc::CkImap_get_HeartbeatMs;
*put_HeartbeatMs = *chilkatc::CkImap_put_HeartbeatMs;
*get_HighestModSeq = *chilkatc::CkImap_get_HighestModSeq;
*highestModSeq = *chilkatc::CkImap_highestModSeq;
*get_HttpProxyAuthMethod = *chilkatc::CkImap_get_HttpProxyAuthMethod;
*httpProxyAuthMethod = *chilkatc::CkImap_httpProxyAuthMethod;
*put_HttpProxyAuthMethod = *chilkatc::CkImap_put_HttpProxyAuthMethod;
*get_HttpProxyDomain = *chilkatc::CkImap_get_HttpProxyDomain;
*httpProxyDomain = *chilkatc::CkImap_httpProxyDomain;
*put_HttpProxyDomain = *chilkatc::CkImap_put_HttpProxyDomain;
*get_HttpProxyHostname = *chilkatc::CkImap_get_HttpProxyHostname;
*httpProxyHostname = *chilkatc::CkImap_httpProxyHostname;
*put_HttpProxyHostname = *chilkatc::CkImap_put_HttpProxyHostname;
*get_HttpProxyPassword = *chilkatc::CkImap_get_HttpProxyPassword;
*httpProxyPassword = *chilkatc::CkImap_httpProxyPassword;
*put_HttpProxyPassword = *chilkatc::CkImap_put_HttpProxyPassword;
*get_HttpProxyPort = *chilkatc::CkImap_get_HttpProxyPort;
*put_HttpProxyPort = *chilkatc::CkImap_put_HttpProxyPort;
*get_HttpProxyUsername = *chilkatc::CkImap_get_HttpProxyUsername;
*httpProxyUsername = *chilkatc::CkImap_httpProxyUsername;
*put_HttpProxyUsername = *chilkatc::CkImap_put_HttpProxyUsername;
*get_KeepSessionLog = *chilkatc::CkImap_get_KeepSessionLog;
*put_KeepSessionLog = *chilkatc::CkImap_put_KeepSessionLog;
*get_LastAppendedMime = *chilkatc::CkImap_get_LastAppendedMime;
*lastAppendedMime = *chilkatc::CkImap_lastAppendedMime;
*get_LastCommand = *chilkatc::CkImap_get_LastCommand;
*lastCommand = *chilkatc::CkImap_lastCommand;
*get_LastErrorHtml = *chilkatc::CkImap_get_LastErrorHtml;
*lastErrorHtml = *chilkatc::CkImap_lastErrorHtml;
*get_LastErrorText = *chilkatc::CkImap_get_LastErrorText;
*lastErrorText = *chilkatc::CkImap_lastErrorText;
*get_LastErrorXml = *chilkatc::CkImap_get_LastErrorXml;
*lastErrorXml = *chilkatc::CkImap_lastErrorXml;
*get_LastIntermediateResponse = *chilkatc::CkImap_get_LastIntermediateResponse;
*lastIntermediateResponse = *chilkatc::CkImap_lastIntermediateResponse;
*get_LastMethodSuccess = *chilkatc::CkImap_get_LastMethodSuccess;
*put_LastMethodSuccess = *chilkatc::CkImap_put_LastMethodSuccess;
*get_LastResponse = *chilkatc::CkImap_get_LastResponse;
*lastResponse = *chilkatc::CkImap_lastResponse;
*get_LastResponseCode = *chilkatc::CkImap_get_LastResponseCode;
*lastResponseCode = *chilkatc::CkImap_lastResponseCode;
*get_LoggedInUser = *chilkatc::CkImap_get_LoggedInUser;
*loggedInUser = *chilkatc::CkImap_loggedInUser;
*get_NumMessages = *chilkatc::CkImap_get_NumMessages;
*get_PeekMode = *chilkatc::CkImap_get_PeekMode;
*put_PeekMode = *chilkatc::CkImap_put_PeekMode;
*get_PercentDoneScale = *chilkatc::CkImap_get_PercentDoneScale;
*put_PercentDoneScale = *chilkatc::CkImap_put_PercentDoneScale;
*get_Port = *chilkatc::CkImap_get_Port;
*put_Port = *chilkatc::CkImap_put_Port;
*get_PreferIpv6 = *chilkatc::CkImap_get_PreferIpv6;
*put_PreferIpv6 = *chilkatc::CkImap_put_PreferIpv6;
*get_ReadTimeout = *chilkatc::CkImap_get_ReadTimeout;
*put_ReadTimeout = *chilkatc::CkImap_put_ReadTimeout;
*get_RequireSslCertVerify = *chilkatc::CkImap_get_RequireSslCertVerify;
*put_RequireSslCertVerify = *chilkatc::CkImap_put_RequireSslCertVerify;
*get_SearchCharset = *chilkatc::CkImap_get_SearchCharset;
*searchCharset = *chilkatc::CkImap_searchCharset;
*put_SearchCharset = *chilkatc::CkImap_put_SearchCharset;
*get_SelectedMailbox = *chilkatc::CkImap_get_SelectedMailbox;
*selectedMailbox = *chilkatc::CkImap_selectedMailbox;
*get_SendBufferSize = *chilkatc::CkImap_get_SendBufferSize;
*put_SendBufferSize = *chilkatc::CkImap_put_SendBufferSize;
*get_SeparatorChar = *chilkatc::CkImap_get_SeparatorChar;
*separatorChar = *chilkatc::CkImap_separatorChar;
*put_SeparatorChar = *chilkatc::CkImap_put_SeparatorChar;
*get_SessionLog = *chilkatc::CkImap_get_SessionLog;
*sessionLog = *chilkatc::CkImap_sessionLog;
*get_SocksHostname = *chilkatc::CkImap_get_SocksHostname;
*socksHostname = *chilkatc::CkImap_socksHostname;
*put_SocksHostname = *chilkatc::CkImap_put_SocksHostname;
*get_SocksPassword = *chilkatc::CkImap_get_SocksPassword;
*socksPassword = *chilkatc::CkImap_socksPassword;
*put_SocksPassword = *chilkatc::CkImap_put_SocksPassword;
*get_SocksPort = *chilkatc::CkImap_get_SocksPort;
*put_SocksPort = *chilkatc::CkImap_put_SocksPort;
*get_SocksUsername = *chilkatc::CkImap_get_SocksUsername;
*socksUsername = *chilkatc::CkImap_socksUsername;
*put_SocksUsername = *chilkatc::CkImap_put_SocksUsername;
*get_SocksVersion = *chilkatc::CkImap_get_SocksVersion;
*put_SocksVersion = *chilkatc::CkImap_put_SocksVersion;
*get_SoRcvBuf = *chilkatc::CkImap_get_SoRcvBuf;
*put_SoRcvBuf = *chilkatc::CkImap_put_SoRcvBuf;
*get_SortCriteria = *chilkatc::CkImap_get_SortCriteria;
*sortCriteria = *chilkatc::CkImap_sortCriteria;
*put_SortCriteria = *chilkatc::CkImap_put_SortCriteria;
*get_SoSndBuf = *chilkatc::CkImap_get_SoSndBuf;
*put_SoSndBuf = *chilkatc::CkImap_put_SoSndBuf;
*get_Ssl = *chilkatc::CkImap_get_Ssl;
*put_Ssl = *chilkatc::CkImap_put_Ssl;
*get_SslAllowedCiphers = *chilkatc::CkImap_get_SslAllowedCiphers;
*sslAllowedCiphers = *chilkatc::CkImap_sslAllowedCiphers;
*put_SslAllowedCiphers = *chilkatc::CkImap_put_SslAllowedCiphers;
*get_SslProtocol = *chilkatc::CkImap_get_SslProtocol;
*sslProtocol = *chilkatc::CkImap_sslProtocol;
*put_SslProtocol = *chilkatc::CkImap_put_SslProtocol;
*get_SslServerCertVerified = *chilkatc::CkImap_get_SslServerCertVerified;
*get_StartTls = *chilkatc::CkImap_get_StartTls;
*put_StartTls = *chilkatc::CkImap_put_StartTls;
*get_TlsCipherSuite = *chilkatc::CkImap_get_TlsCipherSuite;
*tlsCipherSuite = *chilkatc::CkImap_tlsCipherSuite;
*get_TlsPinSet = *chilkatc::CkImap_get_TlsPinSet;
*tlsPinSet = *chilkatc::CkImap_tlsPinSet;
*put_TlsPinSet = *chilkatc::CkImap_put_TlsPinSet;
*get_TlsVersion = *chilkatc::CkImap_get_TlsVersion;
*tlsVersion = *chilkatc::CkImap_tlsVersion;
*get_UidNext = *chilkatc::CkImap_get_UidNext;
*get_UidValidity = *chilkatc::CkImap_get_UidValidity;
*get_UncommonOptions = *chilkatc::CkImap_get_UncommonOptions;
*uncommonOptions = *chilkatc::CkImap_uncommonOptions;
*put_UncommonOptions = *chilkatc::CkImap_put_UncommonOptions;
*get_VerboseLogging = *chilkatc::CkImap_get_VerboseLogging;
*put_VerboseLogging = *chilkatc::CkImap_put_VerboseLogging;
*get_Version = *chilkatc::CkImap_get_Version;
*version = *chilkatc::CkImap_version;
*AddPfxSourceBd = *chilkatc::CkImap_AddPfxSourceBd;
*AddPfxSourceData = *chilkatc::CkImap_AddPfxSourceData;
*AddPfxSourceFile = *chilkatc::CkImap_AddPfxSourceFile;
*AppendMail = *chilkatc::CkImap_AppendMail;
*AppendMailAsync = *chilkatc::CkImap_AppendMailAsync;
*AppendMime = *chilkatc::CkImap_AppendMime;
*AppendMimeAsync = *chilkatc::CkImap_AppendMimeAsync;
*AppendMimeWithDateStr = *chilkatc::CkImap_AppendMimeWithDateStr;
*AppendMimeWithDateStrAsync = *chilkatc::CkImap_AppendMimeWithDateStrAsync;
*AppendMimeWithFlags = *chilkatc::CkImap_AppendMimeWithFlags;
*AppendMimeWithFlagsAsync = *chilkatc::CkImap_AppendMimeWithFlagsAsync;
*AppendMimeWithFlagsSb = *chilkatc::CkImap_AppendMimeWithFlagsSb;
*AppendMimeWithFlagsSbAsync = *chilkatc::CkImap_AppendMimeWithFlagsSbAsync;
*Capability = *chilkatc::CkImap_Capability;
*capability = *chilkatc::CkImap_capability;
*CapabilityAsync = *chilkatc::CkImap_CapabilityAsync;
*CheckConnection = *chilkatc::CkImap_CheckConnection;
*CheckForNewEmail = *chilkatc::CkImap_CheckForNewEmail;
*CheckForNewEmailAsync = *chilkatc::CkImap_CheckForNewEmailAsync;
*ClearSessionLog = *chilkatc::CkImap_ClearSessionLog;
*CloseMailbox = *chilkatc::CkImap_CloseMailbox;
*CloseMailboxAsync = *chilkatc::CkImap_CloseMailboxAsync;
*Connect = *chilkatc::CkImap_Connect;
*ConnectAsync = *chilkatc::CkImap_ConnectAsync;
*Copy = *chilkatc::CkImap_Copy;
*CopyAsync = *chilkatc::CkImap_CopyAsync;
*CopyMultiple = *chilkatc::CkImap_CopyMultiple;
*CopyMultipleAsync = *chilkatc::CkImap_CopyMultipleAsync;
*CopySequence = *chilkatc::CkImap_CopySequence;
*CopySequenceAsync = *chilkatc::CkImap_CopySequenceAsync;
*CreateMailbox = *chilkatc::CkImap_CreateMailbox;
*CreateMailboxAsync = *chilkatc::CkImap_CreateMailboxAsync;
*DeleteMailbox = *chilkatc::CkImap_DeleteMailbox;
*DeleteMailboxAsync = *chilkatc::CkImap_DeleteMailboxAsync;
*Disconnect = *chilkatc::CkImap_Disconnect;
*DisconnectAsync = *chilkatc::CkImap_DisconnectAsync;
*ExamineMailbox = *chilkatc::CkImap_ExamineMailbox;
*ExamineMailboxAsync = *chilkatc::CkImap_ExamineMailboxAsync;
*Expunge = *chilkatc::CkImap_Expunge;
*ExpungeAsync = *chilkatc::CkImap_ExpungeAsync;
*ExpungeAndClose = *chilkatc::CkImap_ExpungeAndClose;
*ExpungeAndCloseAsync = *chilkatc::CkImap_ExpungeAndCloseAsync;
*FetchAttachment = *chilkatc::CkImap_FetchAttachment;
*FetchAttachmentAsync = *chilkatc::CkImap_FetchAttachmentAsync;
*FetchAttachmentBd = *chilkatc::CkImap_FetchAttachmentBd;
*FetchAttachmentBdAsync = *chilkatc::CkImap_FetchAttachmentBdAsync;
*FetchAttachmentBytes = *chilkatc::CkImap_FetchAttachmentBytes;
*FetchAttachmentBytesAsync = *chilkatc::CkImap_FetchAttachmentBytesAsync;
*FetchAttachmentSb = *chilkatc::CkImap_FetchAttachmentSb;
*FetchAttachmentSbAsync = *chilkatc::CkImap_FetchAttachmentSbAsync;
*FetchAttachmentString = *chilkatc::CkImap_FetchAttachmentString;
*fetchAttachmentString = *chilkatc::CkImap_fetchAttachmentString;
*FetchAttachmentStringAsync = *chilkatc::CkImap_FetchAttachmentStringAsync;
*FetchBundle = *chilkatc::CkImap_FetchBundle;
*FetchBundleAsync = *chilkatc::CkImap_FetchBundleAsync;
*FetchBundleAsMime = *chilkatc::CkImap_FetchBundleAsMime;
*FetchBundleAsMimeAsync = *chilkatc::CkImap_FetchBundleAsMimeAsync;
*FetchChunk = *chilkatc::CkImap_FetchChunk;
*FetchChunkAsync = *chilkatc::CkImap_FetchChunkAsync;
*FetchChunk2 = *chilkatc::CkImap_FetchChunk2;
*FetchChunk2Async = *chilkatc::CkImap_FetchChunk2Async;
*FetchEmail = *chilkatc::CkImap_FetchEmail;
*FetchEmailAsync = *chilkatc::CkImap_FetchEmailAsync;
*FetchFlags = *chilkatc::CkImap_FetchFlags;
*fetchFlags = *chilkatc::CkImap_fetchFlags;
*FetchFlagsAsync = *chilkatc::CkImap_FetchFlagsAsync;
*FetchHeaders = *chilkatc::CkImap_FetchHeaders;
*FetchHeadersAsync = *chilkatc::CkImap_FetchHeadersAsync;
*FetchMsgSet = *chilkatc::CkImap_FetchMsgSet;
*FetchMsgSetAsync = *chilkatc::CkImap_FetchMsgSetAsync;
*FetchRange = *chilkatc::CkImap_FetchRange;
*FetchRangeAsync = *chilkatc::CkImap_FetchRangeAsync;
*FetchSequence = *chilkatc::CkImap_FetchSequence;
*FetchSequenceAsync = *chilkatc::CkImap_FetchSequenceAsync;
*FetchSequenceAsMime = *chilkatc::CkImap_FetchSequenceAsMime;
*FetchSequenceAsMimeAsync = *chilkatc::CkImap_FetchSequenceAsMimeAsync;
*FetchSequenceHeaders = *chilkatc::CkImap_FetchSequenceHeaders;
*FetchSequenceHeadersAsync = *chilkatc::CkImap_FetchSequenceHeadersAsync;
*FetchSingle = *chilkatc::CkImap_FetchSingle;
*FetchSingleAsync = *chilkatc::CkImap_FetchSingleAsync;
*FetchSingleAsMime = *chilkatc::CkImap_FetchSingleAsMime;
*fetchSingleAsMime = *chilkatc::CkImap_fetchSingleAsMime;
*FetchSingleAsMimeAsync = *chilkatc::CkImap_FetchSingleAsMimeAsync;
*FetchSingleAsMimeSb = *chilkatc::CkImap_FetchSingleAsMimeSb;
*FetchSingleAsMimeSbAsync = *chilkatc::CkImap_FetchSingleAsMimeSbAsync;
*FetchSingleBd = *chilkatc::CkImap_FetchSingleBd;
*FetchSingleBdAsync = *chilkatc::CkImap_FetchSingleBdAsync;
*FetchSingleHeader = *chilkatc::CkImap_FetchSingleHeader;
*FetchSingleHeaderAsync = *chilkatc::CkImap_FetchSingleHeaderAsync;
*FetchSingleHeaderAsMime = *chilkatc::CkImap_FetchSingleHeaderAsMime;
*fetchSingleHeaderAsMime = *chilkatc::CkImap_fetchSingleHeaderAsMime;
*FetchSingleHeaderAsMimeAsync = *chilkatc::CkImap_FetchSingleHeaderAsMimeAsync;
*GetAllUids = *chilkatc::CkImap_GetAllUids;
*GetAllUidsAsync = *chilkatc::CkImap_GetAllUidsAsync;
*GetMailAttachFilename = *chilkatc::CkImap_GetMailAttachFilename;
*getMailAttachFilename = *chilkatc::CkImap_getMailAttachFilename;
*mailAttachFilename = *chilkatc::CkImap_mailAttachFilename;
*GetMailAttachSize = *chilkatc::CkImap_GetMailAttachSize;
*GetMailboxStatus = *chilkatc::CkImap_GetMailboxStatus;
*getMailboxStatus = *chilkatc::CkImap_getMailboxStatus;
*mailboxStatus = *chilkatc::CkImap_mailboxStatus;
*GetMailboxStatusAsync = *chilkatc::CkImap_GetMailboxStatusAsync;
*GetMailFlag = *chilkatc::CkImap_GetMailFlag;
*GetMailNumAttach = *chilkatc::CkImap_GetMailNumAttach;
*GetMailSize = *chilkatc::CkImap_GetMailSize;
*GetQuota = *chilkatc::CkImap_GetQuota;
*getQuota = *chilkatc::CkImap_getQuota;
*quota = *chilkatc::CkImap_quota;
*GetQuotaAsync = *chilkatc::CkImap_GetQuotaAsync;
*GetQuotaRoot = *chilkatc::CkImap_GetQuotaRoot;
*getQuotaRoot = *chilkatc::CkImap_getQuotaRoot;
*quotaRoot = *chilkatc::CkImap_quotaRoot;
*GetQuotaRootAsync = *chilkatc::CkImap_GetQuotaRootAsync;
*GetServerCert = *chilkatc::CkImap_GetServerCert;
*GetSslServerCert = *chilkatc::CkImap_GetSslServerCert;
*HasCapability = *chilkatc::CkImap_HasCapability;
*IdleCheck = *chilkatc::CkImap_IdleCheck;
*idleCheck = *chilkatc::CkImap_idleCheck;
*IdleCheckAsync = *chilkatc::CkImap_IdleCheckAsync;
*IdleDone = *chilkatc::CkImap_IdleDone;
*IdleDoneAsync = *chilkatc::CkImap_IdleDoneAsync;
*IdleStart = *chilkatc::CkImap_IdleStart;
*IdleStartAsync = *chilkatc::CkImap_IdleStartAsync;
*IsConnected = *chilkatc::CkImap_IsConnected;
*IsLoggedIn = *chilkatc::CkImap_IsLoggedIn;
*ListMailboxes = *chilkatc::CkImap_ListMailboxes;
*ListMailboxesAsync = *chilkatc::CkImap_ListMailboxesAsync;
*ListSubscribed = *chilkatc::CkImap_ListSubscribed;
*ListSubscribedAsync = *chilkatc::CkImap_ListSubscribedAsync;
*LoadTaskCaller = *chilkatc::CkImap_LoadTaskCaller;
*Login = *chilkatc::CkImap_Login;
*LoginAsync = *chilkatc::CkImap_LoginAsync;
*LoginSecure = *chilkatc::CkImap_LoginSecure;
*LoginSecureAsync = *chilkatc::CkImap_LoginSecureAsync;
*Logout = *chilkatc::CkImap_Logout;
*LogoutAsync = *chilkatc::CkImap_LogoutAsync;
*MbxList = *chilkatc::CkImap_MbxList;
*MbxListAsync = *chilkatc::CkImap_MbxListAsync;
*MoveMessages = *chilkatc::CkImap_MoveMessages;
*MoveMessagesAsync = *chilkatc::CkImap_MoveMessagesAsync;
*Noop = *chilkatc::CkImap_Noop;
*NoopAsync = *chilkatc::CkImap_NoopAsync;
*QueryMbx = *chilkatc::CkImap_QueryMbx;
*QueryMbxAsync = *chilkatc::CkImap_QueryMbxAsync;
*QueryThread = *chilkatc::CkImap_QueryThread;
*QueryThreadAsync = *chilkatc::CkImap_QueryThreadAsync;
*RawCommandBd = *chilkatc::CkImap_RawCommandBd;
*RawCommandBdAsync = *chilkatc::CkImap_RawCommandBdAsync;
*RefetchMailFlags = *chilkatc::CkImap_RefetchMailFlags;
*RefetchMailFlagsAsync = *chilkatc::CkImap_RefetchMailFlagsAsync;
*RenameMailbox = *chilkatc::CkImap_RenameMailbox;
*RenameMailboxAsync = *chilkatc::CkImap_RenameMailboxAsync;
*Search = *chilkatc::CkImap_Search;
*SearchAsync = *chilkatc::CkImap_SearchAsync;
*SelectMailbox = *chilkatc::CkImap_SelectMailbox;
*SelectMailboxAsync = *chilkatc::CkImap_SelectMailboxAsync;
*SendRawCommand = *chilkatc::CkImap_SendRawCommand;
*sendRawCommand = *chilkatc::CkImap_sendRawCommand;
*SendRawCommandAsync = *chilkatc::CkImap_SendRawCommandAsync;
*SendRawCommandB = *chilkatc::CkImap_SendRawCommandB;
*SendRawCommandBAsync = *chilkatc::CkImap_SendRawCommandBAsync;
*SendRawCommandC = *chilkatc::CkImap_SendRawCommandC;
*SendRawCommandCAsync = *chilkatc::CkImap_SendRawCommandCAsync;
*SetDecryptCert = *chilkatc::CkImap_SetDecryptCert;
*SetDecryptCert2 = *chilkatc::CkImap_SetDecryptCert2;
*SetFlag = *chilkatc::CkImap_SetFlag;
*SetFlagAsync = *chilkatc::CkImap_SetFlagAsync;
*SetFlags = *chilkatc::CkImap_SetFlags;
*SetFlagsAsync = *chilkatc::CkImap_SetFlagsAsync;
*SetMailFlag = *chilkatc::CkImap_SetMailFlag;
*SetMailFlagAsync = *chilkatc::CkImap_SetMailFlagAsync;
*SetQuota = *chilkatc::CkImap_SetQuota;
*SetQuotaAsync = *chilkatc::CkImap_SetQuotaAsync;
*SetSslClientCert = *chilkatc::CkImap_SetSslClientCert;
*SetSslClientCertPem = *chilkatc::CkImap_SetSslClientCertPem;
*SetSslClientCertPfx = *chilkatc::CkImap_SetSslClientCertPfx;
*Sort = *chilkatc::CkImap_Sort;
*SortAsync = *chilkatc::CkImap_SortAsync;
*SshAuthenticatePk = *chilkatc::CkImap_SshAuthenticatePk;
*SshAuthenticatePkAsync = *chilkatc::CkImap_SshAuthenticatePkAsync;
*SshAuthenticatePw = *chilkatc::CkImap_SshAuthenticatePw;
*SshAuthenticatePwAsync = *chilkatc::CkImap_SshAuthenticatePwAsync;
*SshCloseTunnel = *chilkatc::CkImap_SshCloseTunnel;
*SshCloseTunnelAsync = *chilkatc::CkImap_SshCloseTunnelAsync;
*SshOpenTunnel = *chilkatc::CkImap_SshOpenTunnel;
*SshOpenTunnelAsync = *chilkatc::CkImap_SshOpenTunnelAsync;
*StoreFlags = *chilkatc::CkImap_StoreFlags;
*StoreFlagsAsync = *chilkatc::CkImap_StoreFlagsAsync;
*Subscribe = *chilkatc::CkImap_Subscribe;
*SubscribeAsync = *chilkatc::CkImap_SubscribeAsync;
*ThreadCmd = *chilkatc::CkImap_ThreadCmd;
*ThreadCmdAsync = *chilkatc::CkImap_ThreadCmdAsync;
*Unsubscribe = *chilkatc::CkImap_Unsubscribe;
*UnsubscribeAsync = *chilkatc::CkImap_UnsubscribeAsync;
*UseCertVault = *chilkatc::CkImap_UseCertVault;
*UseSsh = *chilkatc::CkImap_UseSsh;
*UseSshTunnel = *chilkatc::CkImap_UseSshTunnel;
sub DISOWN {
    my $self = shift;
    my $ptr = tied(%$self);
    delete $OWNER{$ptr};
}

sub ACQUIRE {
    my $self = shift;
    my $ptr = tied(%$self);
    $OWNER{$ptr} = 1;
}


############# Class : chilkat::CkJavaKeyStore ##############

package chilkat::CkJavaKeyStore;
use vars qw(@ISA %OWNER %ITERATORS %BLESSEDMEMBERS);
@ISA = qw( chilkat );
%OWNER = ();
%ITERATORS = ();
sub new {
    my $pkg = shift;
    my $self = chilkatc::new_CkJavaKeyStore(@_);
    bless $self, $pkg if defined($self);
}

sub DESTROY {
    return unless $_[0]->isa('HASH');
    my $self = tied(%{$_[0]});
    return unless defined $self;
    delete $ITERATORS{$self};
    if (exists $OWNER{$self}) {
        chilkatc::delete_CkJavaKeyStore($self);
        delete $OWNER{$self};
    }
}

*get_Utf8 = *chilkatc::CkJavaKeyStore_get_Utf8;
*put_Utf8 = *chilkatc::CkJavaKeyStore_put_Utf8;
*LastErrorXml = *chilkatc::CkJavaKeyStore_LastErrorXml;
*LastErrorHtml = *chilkatc::CkJavaKeyStore_LastErrorHtml;
*LastErrorText = *chilkatc::CkJavaKeyStore_LastErrorText;
*get_DebugLogFilePath = *chilkatc::CkJavaKeyStore_get_DebugLogFilePath;
*debugLogFilePath = *chilkatc::CkJavaKeyStore_debugLogFilePath;
*put_DebugLogFilePath = *chilkatc::CkJavaKeyStore_put_DebugLogFilePath;
*get_LastErrorHtml = *chilkatc::CkJavaKeyStore_get_LastErrorHtml;
*lastErrorHtml = *chilkatc::CkJavaKeyStore_lastErrorHtml;
*get_LastErrorText = *chilkatc::CkJavaKeyStore_get_LastErrorText;
*lastErrorText = *chilkatc::CkJavaKeyStore_lastErrorText;
*get_LastErrorXml = *chilkatc::CkJavaKeyStore_get_LastErrorXml;
*lastErrorXml = *chilkatc::CkJavaKeyStore_lastErrorXml;
*get_LastMethodSuccess = *chilkatc::CkJavaKeyStore_get_LastMethodSuccess;
*put_LastMethodSuccess = *chilkatc::CkJavaKeyStore_put_LastMethodSuccess;
*get_NumPrivateKeys = *chilkatc::CkJavaKeyStore_get_NumPrivateKeys;
*get_NumSecretKeys = *chilkatc::CkJavaKeyStore_get_NumSecretKeys;
*get_NumTrustedCerts = *chilkatc::CkJavaKeyStore_get_NumTrustedCerts;
*get_RequireCompleteChain = *chilkatc::CkJavaKeyStore_get_RequireCompleteChain;
*put_RequireCompleteChain = *chilkatc::CkJavaKeyStore_put_RequireCompleteChain;
*get_VerboseLogging = *chilkatc::CkJavaKeyStore_get_VerboseLogging;
*put_VerboseLogging = *chilkatc::CkJavaKeyStore_put_VerboseLogging;
*get_VerifyKeyedDigest = *chilkatc::CkJavaKeyStore_get_VerifyKeyedDigest;
*put_VerifyKeyedDigest = *chilkatc::CkJavaKeyStore_put_VerifyKeyedDigest;
*get_Version = *chilkatc::CkJavaKeyStore_get_Version;
*version = *chilkatc::CkJavaKeyStore_version;
*AddPfx = *chilkatc::CkJavaKeyStore_AddPfx;
*AddPrivateKey = *chilkatc::CkJavaKeyStore_AddPrivateKey;
*AddSecretKey = *chilkatc::CkJavaKeyStore_AddSecretKey;
*AddTrustedCert = *chilkatc::CkJavaKeyStore_AddTrustedCert;
*CertChainAt = *chilkatc::CkJavaKeyStore_CertChainAt;
*CertChainOf = *chilkatc::CkJavaKeyStore_CertChainOf;
*ChangePassword = *chilkatc::CkJavaKeyStore_ChangePassword;
*FindCertChain = *chilkatc::CkJavaKeyStore_FindCertChain;
*FindPrivateKey = *chilkatc::CkJavaKeyStore_FindPrivateKey;
*FindTrustedCert = *chilkatc::CkJavaKeyStore_FindTrustedCert;
*GetCertChain = *chilkatc::CkJavaKeyStore_GetCertChain;
*GetPrivateKey = *chilkatc::CkJavaKeyStore_GetPrivateKey;
*GetPrivateKeyAlias = *chilkatc::CkJavaKeyStore_GetPrivateKeyAlias;
*getPrivateKeyAlias = *chilkatc::CkJavaKeyStore_getPrivateKeyAlias;
*privateKeyAlias = *chilkatc::CkJavaKeyStore_privateKeyAlias;
*GetSecretKey = *chilkatc::CkJavaKeyStore_GetSecretKey;
*getSecretKey = *chilkatc::CkJavaKeyStore_getSecretKey;
*secretKey = *chilkatc::CkJavaKeyStore_secretKey;
*GetSecretKeyAlias = *chilkatc::CkJavaKeyStore_GetSecretKeyAlias;
*getSecretKeyAlias = *chilkatc::CkJavaKeyStore_getSecretKeyAlias;
*secretKeyAlias = *chilkatc::CkJavaKeyStore_secretKeyAlias;
*GetTrustedCert = *chilkatc::CkJavaKeyStore_GetTrustedCert;
*GetTrustedCertAlias = *chilkatc::CkJavaKeyStore_GetTrustedCertAlias;
*getTrustedCertAlias = *chilkatc::CkJavaKeyStore_getTrustedCertAlias;
*trustedCertAlias = *chilkatc::CkJavaKeyStore_trustedCertAlias;
*LoadBd = *chilkatc::CkJavaKeyStore_LoadBd;
*LoadBinary = *chilkatc::CkJavaKeyStore_LoadBinary;
*LoadEncoded = *chilkatc::CkJavaKeyStore_LoadEncoded;
*LoadFile = *chilkatc::CkJavaKeyStore_LoadFile;
*LoadJwkSet = *chilkatc::CkJavaKeyStore_LoadJwkSet;
*PrivateKeyAt = *chilkatc::CkJavaKeyStore_PrivateKeyAt;
*PrivateKeyOf = *chilkatc::CkJavaKeyStore_PrivateKeyOf;
*RemoveEntry = *chilkatc::CkJavaKeyStore_RemoveEntry;
*SetAlias = *chilkatc::CkJavaKeyStore_SetAlias;
*ToBd = *chilkatc::CkJavaKeyStore_ToBd;
*ToBinary = *chilkatc::CkJavaKeyStore_ToBinary;
*ToEncodedString = *chilkatc::CkJavaKeyStore_ToEncodedString;
*toEncodedString = *chilkatc::CkJavaKeyStore_toEncodedString;
*ToFile = *chilkatc::CkJavaKeyStore_ToFile;
*ToJwkSet = *chilkatc::CkJavaKeyStore_ToJwkSet;
*ToPem = *chilkatc::CkJavaKeyStore_ToPem;
*ToPemObj = *chilkatc::CkJavaKeyStore_ToPemObj;
*ToPfx = *chilkatc::CkJavaKeyStore_ToPfx;
*ToPfxObj = *chilkatc::CkJavaKeyStore_ToPfxObj;
*TrustedCertAt = *chilkatc::CkJavaKeyStore_TrustedCertAt;
*TrustedCertOf = *chilkatc::CkJavaKeyStore_TrustedCertOf;
*UseCertVault = *chilkatc::CkJavaKeyStore_UseCertVault;
sub DISOWN {
    my $self = shift;
    my $ptr = tied(%$self);
    delete $OWNER{$ptr};
}

sub ACQUIRE {
    my $self = shift;
    my $ptr = tied(%$self);
    $OWNER{$ptr} = 1;
}


############# Class : chilkat::CkJsonArray ##############

package chilkat::CkJsonArray;
use vars qw(@ISA %OWNER %ITERATORS %BLESSEDMEMBERS);
@ISA = qw( chilkat );
%OWNER = ();
%ITERATORS = ();
sub new {
    my $pkg = shift;
    my $self = chilkatc::new_CkJsonArray(@_);
    bless $self, $pkg if defined($self);
}

sub DESTROY {
    return unless $_[0]->isa('HASH');
    my $self = tied(%{$_[0]});
    return unless defined $self;
    delete $ITERATORS{$self};
    if (exists $OWNER{$self}) {
        chilkatc::delete_CkJsonArray($self);
        delete $OWNER{$self};
    }
}

*get_Utf8 = *chilkatc::CkJsonArray_get_Utf8;
*put_Utf8 = *chilkatc::CkJsonArray_put_Utf8;
*LastErrorXml = *chilkatc::CkJsonArray_LastErrorXml;
*LastErrorHtml = *chilkatc::CkJsonArray_LastErrorHtml;
*LastErrorText = *chilkatc::CkJsonArray_LastErrorText;
*get_DebugLogFilePath = *chilkatc::CkJsonArray_get_DebugLogFilePath;
*debugLogFilePath = *chilkatc::CkJsonArray_debugLogFilePath;
*put_DebugLogFilePath = *chilkatc::CkJsonArray_put_DebugLogFilePath;
*get_EmitCompact = *chilkatc::CkJsonArray_get_EmitCompact;
*put_EmitCompact = *chilkatc::CkJsonArray_put_EmitCompact;
*get_EmitCrlf = *chilkatc::CkJsonArray_get_EmitCrlf;
*put_EmitCrlf = *chilkatc::CkJsonArray_put_EmitCrlf;
*get_LastErrorHtml = *chilkatc::CkJsonArray_get_LastErrorHtml;
*lastErrorHtml = *chilkatc::CkJsonArray_lastErrorHtml;
*get_LastErrorText = *chilkatc::CkJsonArray_get_LastErrorText;
*lastErrorText = *chilkatc::CkJsonArray_lastErrorText;
*get_LastErrorXml = *chilkatc::CkJsonArray_get_LastErrorXml;
*lastErrorXml = *chilkatc::CkJsonArray_lastErrorXml;
*get_LastMethodSuccess = *chilkatc::CkJsonArray_get_LastMethodSuccess;
*put_LastMethodSuccess = *chilkatc::CkJsonArray_put_LastMethodSuccess;
*get_Size = *chilkatc::CkJsonArray_get_Size;
*get_VerboseLogging = *chilkatc::CkJsonArray_get_VerboseLogging;
*put_VerboseLogging = *chilkatc::CkJsonArray_put_VerboseLogging;
*get_Version = *chilkatc::CkJsonArray_get_Version;
*version = *chilkatc::CkJsonArray_version;
*AddArrayAt = *chilkatc::CkJsonArray_AddArrayAt;
*AddArrayAt2 = *chilkatc::CkJsonArray_AddArrayAt2;
*AddBoolAt = *chilkatc::CkJsonArray_AddBoolAt;
*AddIntAt = *chilkatc::CkJsonArray_AddIntAt;
*AddNullAt = *chilkatc::CkJsonArray_AddNullAt;
*AddNumberAt = *chilkatc::CkJsonArray_AddNumberAt;
*AddObjectAt = *chilkatc::CkJsonArray_AddObjectAt;
*AddObjectAt2 = *chilkatc::CkJsonArray_AddObjectAt2;
*AddObjectCopyAt = *chilkatc::CkJsonArray_AddObjectCopyAt;
*AddStringAt = *chilkatc::CkJsonArray_AddStringAt;
*AddUIntAt = *chilkatc::CkJsonArray_AddUIntAt;
*AppendArrayItems = *chilkatc::CkJsonArray_AppendArrayItems;
*ArrayAt = *chilkatc::CkJsonArray_ArrayAt;
*ArrayAt2 = *chilkatc::CkJsonArray_ArrayAt2;
*BoolAt = *chilkatc::CkJsonArray_BoolAt;
*Clear = *chilkatc::CkJsonArray_Clear;
*DateAt = *chilkatc::CkJsonArray_DateAt;
*DeleteAt = *chilkatc::CkJsonArray_DeleteAt;
*DtAt = *chilkatc::CkJsonArray_DtAt;
*Emit = *chilkatc::CkJsonArray_Emit;
*emit = *chilkatc::CkJsonArray_emit;
*EmitSb = *chilkatc::CkJsonArray_EmitSb;
*FindObject = *chilkatc::CkJsonArray_FindObject;
*FindString = *chilkatc::CkJsonArray_FindString;
*IntAt = *chilkatc::CkJsonArray_IntAt;
*IsNullAt = *chilkatc::CkJsonArray_IsNullAt;
*Load = *chilkatc::CkJsonArray_Load;
*LoadSb = *chilkatc::CkJsonArray_LoadSb;
*ObjectAt = *chilkatc::CkJsonArray_ObjectAt;
*ObjectAt2 = *chilkatc::CkJsonArray_ObjectAt2;
*SetBoolAt = *chilkatc::CkJsonArray_SetBoolAt;
*SetIntAt = *chilkatc::CkJsonArray_SetIntAt;
*SetNullAt = *chilkatc::CkJsonArray_SetNullAt;
*SetNumberAt = *chilkatc::CkJsonArray_SetNumberAt;
*SetStringAt = *chilkatc::CkJsonArray_SetStringAt;
*SetUIntAt = *chilkatc::CkJsonArray_SetUIntAt;
*StringAt = *chilkatc::CkJsonArray_StringAt;
*stringAt = *chilkatc::CkJsonArray_stringAt;
*Swap = *chilkatc::CkJsonArray_Swap;
*TypeAt = *chilkatc::CkJsonArray_TypeAt;
*UIntAt = *chilkatc::CkJsonArray_UIntAt;
sub DISOWN {
    my $self = shift;
    my $ptr = tied(%$self);
    delete $OWNER{$ptr};
}

sub ACQUIRE {
    my $self = shift;
    my $ptr = tied(%$self);
    $OWNER{$ptr} = 1;
}


############# Class : chilkat::CkJsonObject ##############

package chilkat::CkJsonObject;
use vars qw(@ISA %OWNER %ITERATORS %BLESSEDMEMBERS);
@ISA = qw( chilkat );
%OWNER = ();
%ITERATORS = ();
sub new {
    my $pkg = shift;
    my $self = chilkatc::new_CkJsonObject(@_);
    bless $self, $pkg if defined($self);
}

sub DESTROY {
    return unless $_[0]->isa('HASH');
    my $self = tied(%{$_[0]});
    return unless defined $self;
    delete $ITERATORS{$self};
    if (exists $OWNER{$self}) {
        chilkatc::delete_CkJsonObject($self);
        delete $OWNER{$self};
    }
}

*get_Utf8 = *chilkatc::CkJsonObject_get_Utf8;
*put_Utf8 = *chilkatc::CkJsonObject_put_Utf8;
*LastErrorXml = *chilkatc::CkJsonObject_LastErrorXml;
*LastErrorHtml = *chilkatc::CkJsonObject_LastErrorHtml;
*LastErrorText = *chilkatc::CkJsonObject_LastErrorText;
*get_DebugLogFilePath = *chilkatc::CkJsonObject_get_DebugLogFilePath;
*debugLogFilePath = *chilkatc::CkJsonObject_debugLogFilePath;
*put_DebugLogFilePath = *chilkatc::CkJsonObject_put_DebugLogFilePath;
*get_DelimiterChar = *chilkatc::CkJsonObject_get_DelimiterChar;
*delimiterChar = *chilkatc::CkJsonObject_delimiterChar;
*put_DelimiterChar = *chilkatc::CkJsonObject_put_DelimiterChar;
*get_EmitCompact = *chilkatc::CkJsonObject_get_EmitCompact;
*put_EmitCompact = *chilkatc::CkJsonObject_put_EmitCompact;
*get_EmitCrLf = *chilkatc::CkJsonObject_get_EmitCrLf;
*put_EmitCrLf = *chilkatc::CkJsonObject_put_EmitCrLf;
*get_I = *chilkatc::CkJsonObject_get_I;
*put_I = *chilkatc::CkJsonObject_put_I;
*get_J = *chilkatc::CkJsonObject_get_J;
*put_J = *chilkatc::CkJsonObject_put_J;
*get_K = *chilkatc::CkJsonObject_get_K;
*put_K = *chilkatc::CkJsonObject_put_K;
*get_LastErrorHtml = *chilkatc::CkJsonObject_get_LastErrorHtml;
*lastErrorHtml = *chilkatc::CkJsonObject_lastErrorHtml;
*get_LastErrorText = *chilkatc::CkJsonObject_get_LastErrorText;
*lastErrorText = *chilkatc::CkJsonObject_lastErrorText;
*get_LastErrorXml = *chilkatc::CkJsonObject_get_LastErrorXml;
*lastErrorXml = *chilkatc::CkJsonObject_lastErrorXml;
*get_LastMethodSuccess = *chilkatc::CkJsonObject_get_LastMethodSuccess;
*put_LastMethodSuccess = *chilkatc::CkJsonObject_put_LastMethodSuccess;
*get_LowerCaseNames = *chilkatc::CkJsonObject_get_LowerCaseNames;
*put_LowerCaseNames = *chilkatc::CkJsonObject_put_LowerCaseNames;
*get_PathPrefix = *chilkatc::CkJsonObject_get_PathPrefix;
*pathPrefix = *chilkatc::CkJsonObject_pathPrefix;
*put_PathPrefix = *chilkatc::CkJsonObject_put_PathPrefix;
*get_Size = *chilkatc::CkJsonObject_get_Size;
*get_UncommonOptions = *chilkatc::CkJsonObject_get_UncommonOptions;
*uncommonOptions = *chilkatc::CkJsonObject_uncommonOptions;
*put_UncommonOptions = *chilkatc::CkJsonObject_put_UncommonOptions;
*get_VerboseLogging = *chilkatc::CkJsonObject_get_VerboseLogging;
*put_VerboseLogging = *chilkatc::CkJsonObject_put_VerboseLogging;
*get_Version = *chilkatc::CkJsonObject_get_Version;
*version = *chilkatc::CkJsonObject_version;
*AddArrayAt = *chilkatc::CkJsonObject_AddArrayAt;
*AddArrayCopyAt = *chilkatc::CkJsonObject_AddArrayCopyAt;
*AddBoolAt = *chilkatc::CkJsonObject_AddBoolAt;
*AddIntAt = *chilkatc::CkJsonObject_AddIntAt;
*AddNullAt = *chilkatc::CkJsonObject_AddNullAt;
*AddNumberAt = *chilkatc::CkJsonObject_AddNumberAt;
*AddObjectAt = *chilkatc::CkJsonObject_AddObjectAt;
*AddObjectCopyAt = *chilkatc::CkJsonObject_AddObjectCopyAt;
*AddStringAt = *chilkatc::CkJsonObject_AddStringAt;
*AppendArray = *chilkatc::CkJsonObject_AppendArray;
*AppendArray2 = *chilkatc::CkJsonObject_AppendArray2;
*AppendArrayCopy = *chilkatc::CkJsonObject_AppendArrayCopy;
*AppendBool = *chilkatc::CkJsonObject_AppendBool;
*AppendInt = *chilkatc::CkJsonObject_AppendInt;
*AppendObject = *chilkatc::CkJsonObject_AppendObject;
*AppendObject2 = *chilkatc::CkJsonObject_AppendObject2;
*AppendObjectCopy = *chilkatc::CkJsonObject_AppendObjectCopy;
*AppendString = *chilkatc::CkJsonObject_AppendString;
*AppendStringArray = *chilkatc::CkJsonObject_AppendStringArray;
*ArrayAt = *chilkatc::CkJsonObject_ArrayAt;
*ArrayAt2 = *chilkatc::CkJsonObject_ArrayAt2;
*ArrayOf = *chilkatc::CkJsonObject_ArrayOf;
*ArrayOf2 = *chilkatc::CkJsonObject_ArrayOf2;
*BoolAt = *chilkatc::CkJsonObject_BoolAt;
*BoolOf = *chilkatc::CkJsonObject_BoolOf;
*BytesOf = *chilkatc::CkJsonObject_BytesOf;
*Clear = *chilkatc::CkJsonObject_Clear;
*Clone = *chilkatc::CkJsonObject_Clone;
*CopyRef = *chilkatc::CkJsonObject_CopyRef;
*DateOf = *chilkatc::CkJsonObject_DateOf;
*Delete = *chilkatc::CkJsonObject_Delete;
*DeleteAt = *chilkatc::CkJsonObject_DeleteAt;
*DeleteRecords = *chilkatc::CkJsonObject_DeleteRecords;
*DtOf = *chilkatc::CkJsonObject_DtOf;
*Emit = *chilkatc::CkJsonObject_Emit;
*emit = *chilkatc::CkJsonObject_emit;
*EmitBd = *chilkatc::CkJsonObject_EmitBd;
*EmitSb = *chilkatc::CkJsonObject_EmitSb;
*EmitWithSubs = *chilkatc::CkJsonObject_EmitWithSubs;
*emitWithSubs = *chilkatc::CkJsonObject_emitWithSubs;
*FindObjectWithMember = *chilkatc::CkJsonObject_FindObjectWithMember;
*FindObjectWithMember2 = *chilkatc::CkJsonObject_FindObjectWithMember2;
*FindRecord = *chilkatc::CkJsonObject_FindRecord;
*FindRecord2 = *chilkatc::CkJsonObject_FindRecord2;
*FindRecordString = *chilkatc::CkJsonObject_FindRecordString;
*findRecordString = *chilkatc::CkJsonObject_findRecordString;
*FirebaseApplyEvent = *chilkatc::CkJsonObject_FirebaseApplyEvent;
*FirebasePatch = *chilkatc::CkJsonObject_FirebasePatch;
*FirebasePut = *chilkatc::CkJsonObject_FirebasePut;
*GetDocRoot = *chilkatc::CkJsonObject_GetDocRoot;
*GetDocRoot2 = *chilkatc::CkJsonObject_GetDocRoot2;
*HasMember = *chilkatc::CkJsonObject_HasMember;
*IndexOf = *chilkatc::CkJsonObject_IndexOf;
*IntAt = *chilkatc::CkJsonObject_IntAt;
*IntOf = *chilkatc::CkJsonObject_IntOf;
*IsNullAt = *chilkatc::CkJsonObject_IsNullAt;
*IsNullOf = *chilkatc::CkJsonObject_IsNullOf;
*JsonTypeOf = *chilkatc::CkJsonObject_JsonTypeOf;
*Load = *chilkatc::CkJsonObject_Load;
*LoadBd = *chilkatc::CkJsonObject_LoadBd;
*LoadFile = *chilkatc::CkJsonObject_LoadFile;
*LoadPredefined = *chilkatc::CkJsonObject_LoadPredefined;
*LoadSb = *chilkatc::CkJsonObject_LoadSb;
*MakeCopy = *chilkatc::CkJsonObject_MakeCopy;
*MoveMember = *chilkatc::CkJsonObject_MoveMember;
*NameAt = *chilkatc::CkJsonObject_NameAt;
*nameAt = *chilkatc::CkJsonObject_nameAt;
*ObjectAt = *chilkatc::CkJsonObject_ObjectAt;
*ObjectAt2 = *chilkatc::CkJsonObject_ObjectAt2;
*ObjectOf = *chilkatc::CkJsonObject_ObjectOf;
*ObjectOf2 = *chilkatc::CkJsonObject_ObjectOf2;
*Predefine = *chilkatc::CkJsonObject_Predefine;
*Rename = *chilkatc::CkJsonObject_Rename;
*RenameAt = *chilkatc::CkJsonObject_RenameAt;
*SetBoolAt = *chilkatc::CkJsonObject_SetBoolAt;
*SetBoolOf = *chilkatc::CkJsonObject_SetBoolOf;
*SetIntAt = *chilkatc::CkJsonObject_SetIntAt;
*SetIntOf = *chilkatc::CkJsonObject_SetIntOf;
*SetNullAt = *chilkatc::CkJsonObject_SetNullAt;
*SetNullOf = *chilkatc::CkJsonObject_SetNullOf;
*SetNumberAt = *chilkatc::CkJsonObject_SetNumberAt;
*SetNumberOf = *chilkatc::CkJsonObject_SetNumberOf;
*SetStringAt = *chilkatc::CkJsonObject_SetStringAt;
*SetStringOf = *chilkatc::CkJsonObject_SetStringOf;
*SizeOfArray = *chilkatc::CkJsonObject_SizeOfArray;
*Sort = *chilkatc::CkJsonObject_Sort;
*StringAt = *chilkatc::CkJsonObject_StringAt;
*stringAt = *chilkatc::CkJsonObject_stringAt;
*StringOf = *chilkatc::CkJsonObject_StringOf;
*stringOf = *chilkatc::CkJsonObject_stringOf;
*StringOfEquals = *chilkatc::CkJsonObject_StringOfEquals;
*StringOfSb = *chilkatc::CkJsonObject_StringOfSb;
*Swap = *chilkatc::CkJsonObject_Swap;
*TypeAt = *chilkatc::CkJsonObject_TypeAt;
*UIntOf = *chilkatc::CkJsonObject_UIntOf;
*UpdateBd = *chilkatc::CkJsonObject_UpdateBd;
*UpdateBool = *chilkatc::CkJsonObject_UpdateBool;
*UpdateInt = *chilkatc::CkJsonObject_UpdateInt;
*UpdateNewArray = *chilkatc::CkJsonObject_UpdateNewArray;
*UpdateNewObject = *chilkatc::CkJsonObject_UpdateNewObject;
*UpdateNull = *chilkatc::CkJsonObject_UpdateNull;
*UpdateNumber = *chilkatc::CkJsonObject_UpdateNumber;
*UpdateSb = *chilkatc::CkJsonObject_UpdateSb;
*UpdateString = *chilkatc::CkJsonObject_UpdateString;
*UpdateUInt = *chilkatc::CkJsonObject_UpdateUInt;
*WriteFile = *chilkatc::CkJsonObject_WriteFile;
sub DISOWN {
    my $self = shift;
    my $ptr = tied(%$self);
    delete $OWNER{$ptr};
}

sub ACQUIRE {
    my $self = shift;
    my $ptr = tied(%$self);
    $OWNER{$ptr} = 1;
}


############# Class : chilkat::CkJwe ##############

package chilkat::CkJwe;
use vars qw(@ISA %OWNER %ITERATORS %BLESSEDMEMBERS);
@ISA = qw( chilkat );
%OWNER = ();
%ITERATORS = ();
sub new {
    my $pkg = shift;
    my $self = chilkatc::new_CkJwe(@_);
    bless $self, $pkg if defined($self);
}

sub DESTROY {
    return unless $_[0]->isa('HASH');
    my $self = tied(%{$_[0]});
    return unless defined $self;
    delete $ITERATORS{$self};
    if (exists $OWNER{$self}) {
        chilkatc::delete_CkJwe($self);
        delete $OWNER{$self};
    }
}

*get_Utf8 = *chilkatc::CkJwe_get_Utf8;
*put_Utf8 = *chilkatc::CkJwe_put_Utf8;
*LastErrorXml = *chilkatc::CkJwe_LastErrorXml;
*LastErrorHtml = *chilkatc::CkJwe_LastErrorHtml;
*LastErrorText = *chilkatc::CkJwe_LastErrorText;
*get_DebugLogFilePath = *chilkatc::CkJwe_get_DebugLogFilePath;
*debugLogFilePath = *chilkatc::CkJwe_debugLogFilePath;
*put_DebugLogFilePath = *chilkatc::CkJwe_put_DebugLogFilePath;
*get_LastErrorHtml = *chilkatc::CkJwe_get_LastErrorHtml;
*lastErrorHtml = *chilkatc::CkJwe_lastErrorHtml;
*get_LastErrorText = *chilkatc::CkJwe_get_LastErrorText;
*lastErrorText = *chilkatc::CkJwe_lastErrorText;
*get_LastErrorXml = *chilkatc::CkJwe_get_LastErrorXml;
*lastErrorXml = *chilkatc::CkJwe_lastErrorXml;
*get_LastMethodSuccess = *chilkatc::CkJwe_get_LastMethodSuccess;
*put_LastMethodSuccess = *chilkatc::CkJwe_put_LastMethodSuccess;
*get_NumRecipients = *chilkatc::CkJwe_get_NumRecipients;
*get_PreferCompact = *chilkatc::CkJwe_get_PreferCompact;
*put_PreferCompact = *chilkatc::CkJwe_put_PreferCompact;
*get_PreferFlattened = *chilkatc::CkJwe_get_PreferFlattened;
*put_PreferFlattened = *chilkatc::CkJwe_put_PreferFlattened;
*get_UncommonOptions = *chilkatc::CkJwe_get_UncommonOptions;
*uncommonOptions = *chilkatc::CkJwe_uncommonOptions;
*put_UncommonOptions = *chilkatc::CkJwe_put_UncommonOptions;
*get_VerboseLogging = *chilkatc::CkJwe_get_VerboseLogging;
*put_VerboseLogging = *chilkatc::CkJwe_put_VerboseLogging;
*get_Version = *chilkatc::CkJwe_get_Version;
*version = *chilkatc::CkJwe_version;
*Decrypt = *chilkatc::CkJwe_Decrypt;
*decrypt = *chilkatc::CkJwe_decrypt;
*DecryptBd = *chilkatc::CkJwe_DecryptBd;
*DecryptSb = *chilkatc::CkJwe_DecryptSb;
*Encrypt = *chilkatc::CkJwe_Encrypt;
*encrypt = *chilkatc::CkJwe_encrypt;
*EncryptBd = *chilkatc::CkJwe_EncryptBd;
*EncryptSb = *chilkatc::CkJwe_EncryptSb;
*FindRecipient = *chilkatc::CkJwe_FindRecipient;
*GetHeader = *chilkatc::CkJwe_GetHeader;
*GetProtectedHeader = *chilkatc::CkJwe_GetProtectedHeader;
*LoadJwe = *chilkatc::CkJwe_LoadJwe;
*LoadJweSb = *chilkatc::CkJwe_LoadJweSb;
*SetAad = *chilkatc::CkJwe_SetAad;
*SetAadBd = *chilkatc::CkJwe_SetAadBd;
*SetPassword = *chilkatc::CkJwe_SetPassword;
*SetPrivateKey = *chilkatc::CkJwe_SetPrivateKey;
*SetProtectedHeader = *chilkatc::CkJwe_SetProtectedHeader;
*SetPublicKey = *chilkatc::CkJwe_SetPublicKey;
*SetRecipientHeader = *chilkatc::CkJwe_SetRecipientHeader;
*SetUnprotectedHeader = *chilkatc::CkJwe_SetUnprotectedHeader;
*SetWrappingKey = *chilkatc::CkJwe_SetWrappingKey;
sub DISOWN {
    my $self = shift;
    my $ptr = tied(%$self);
    delete $OWNER{$ptr};
}

sub ACQUIRE {
    my $self = shift;
    my $ptr = tied(%$self);
    $OWNER{$ptr} = 1;
}


############# Class : chilkat::CkJws ##############

package chilkat::CkJws;
use vars qw(@ISA %OWNER %ITERATORS %BLESSEDMEMBERS);
@ISA = qw( chilkat );
%OWNER = ();
%ITERATORS = ();
sub new {
    my $pkg = shift;
    my $self = chilkatc::new_CkJws(@_);
    bless $self, $pkg if defined($self);
}

sub DESTROY {
    return unless $_[0]->isa('HASH');
    my $self = tied(%{$_[0]});
    return unless defined $self;
    delete $ITERATORS{$self};
    if (exists $OWNER{$self}) {
        chilkatc::delete_CkJws($self);
        delete $OWNER{$self};
    }
}

*get_Utf8 = *chilkatc::CkJws_get_Utf8;
*put_Utf8 = *chilkatc::CkJws_put_Utf8;
*LastErrorXml = *chilkatc::CkJws_LastErrorXml;
*LastErrorHtml = *chilkatc::CkJws_LastErrorHtml;
*LastErrorText = *chilkatc::CkJws_LastErrorText;
*get_DebugLogFilePath = *chilkatc::CkJws_get_DebugLogFilePath;
*debugLogFilePath = *chilkatc::CkJws_debugLogFilePath;
*put_DebugLogFilePath = *chilkatc::CkJws_put_DebugLogFilePath;
*get_LastErrorHtml = *chilkatc::CkJws_get_LastErrorHtml;
*lastErrorHtml = *chilkatc::CkJws_lastErrorHtml;
*get_LastErrorText = *chilkatc::CkJws_get_LastErrorText;
*lastErrorText = *chilkatc::CkJws_lastErrorText;
*get_LastErrorXml = *chilkatc::CkJws_get_LastErrorXml;
*lastErrorXml = *chilkatc::CkJws_lastErrorXml;
*get_LastMethodSuccess = *chilkatc::CkJws_get_LastMethodSuccess;
*put_LastMethodSuccess = *chilkatc::CkJws_put_LastMethodSuccess;
*get_NumSignatures = *chilkatc::CkJws_get_NumSignatures;
*get_PreferCompact = *chilkatc::CkJws_get_PreferCompact;
*put_PreferCompact = *chilkatc::CkJws_put_PreferCompact;
*get_PreferFlattened = *chilkatc::CkJws_get_PreferFlattened;
*put_PreferFlattened = *chilkatc::CkJws_put_PreferFlattened;
*get_UncommonOptions = *chilkatc::CkJws_get_UncommonOptions;
*uncommonOptions = *chilkatc::CkJws_uncommonOptions;
*put_UncommonOptions = *chilkatc::CkJws_put_UncommonOptions;
*get_VerboseLogging = *chilkatc::CkJws_get_VerboseLogging;
*put_VerboseLogging = *chilkatc::CkJws_put_VerboseLogging;
*get_Version = *chilkatc::CkJws_get_Version;
*version = *chilkatc::CkJws_version;
*CreateJws = *chilkatc::CkJws_CreateJws;
*createJws = *chilkatc::CkJws_createJws;
*CreateJwsSb = *chilkatc::CkJws_CreateJwsSb;
*GetPayload = *chilkatc::CkJws_GetPayload;
*getPayload = *chilkatc::CkJws_getPayload;
*payload = *chilkatc::CkJws_payload;
*GetPayloadBd = *chilkatc::CkJws_GetPayloadBd;
*GetPayloadSb = *chilkatc::CkJws_GetPayloadSb;
*GetProtectedH = *chilkatc::CkJws_GetProtectedH;
*GetProtectedHeader = *chilkatc::CkJws_GetProtectedHeader;
*GetUnprotectedH = *chilkatc::CkJws_GetUnprotectedH;
*GetUnprotectedHeader = *chilkatc::CkJws_GetUnprotectedHeader;
*LoadJws = *chilkatc::CkJws_LoadJws;
*LoadJwsSb = *chilkatc::CkJws_LoadJwsSb;
*SetMacKey = *chilkatc::CkJws_SetMacKey;
*SetMacKeyBd = *chilkatc::CkJws_SetMacKeyBd;
*SetPayload = *chilkatc::CkJws_SetPayload;
*SetPayloadBd = *chilkatc::CkJws_SetPayloadBd;
*SetPayloadSb = *chilkatc::CkJws_SetPayloadSb;
*SetPrivateKey = *chilkatc::CkJws_SetPrivateKey;
*SetProtectedHeader = *chilkatc::CkJws_SetProtectedHeader;
*SetPublicKey = *chilkatc::CkJws_SetPublicKey;
*SetUnprotectedHeader = *chilkatc::CkJws_SetUnprotectedHeader;
*Validate = *chilkatc::CkJws_Validate;
sub DISOWN {
    my $self = shift;
    my $ptr = tied(%$self);
    delete $OWNER{$ptr};
}

sub ACQUIRE {
    my $self = shift;
    my $ptr = tied(%$self);
    $OWNER{$ptr} = 1;
}


############# Class : chilkat::CkJwt ##############

package chilkat::CkJwt;
use vars qw(@ISA %OWNER %ITERATORS %BLESSEDMEMBERS);
@ISA = qw( chilkat );
%OWNER = ();
%ITERATORS = ();
sub new {
    my $pkg = shift;
    my $self = chilkatc::new_CkJwt(@_);
    bless $self, $pkg if defined($self);
}

sub DESTROY {
    return unless $_[0]->isa('HASH');
    my $self = tied(%{$_[0]});
    return unless defined $self;
    delete $ITERATORS{$self};
    if (exists $OWNER{$self}) {
        chilkatc::delete_CkJwt($self);
        delete $OWNER{$self};
    }
}

*get_Utf8 = *chilkatc::CkJwt_get_Utf8;
*put_Utf8 = *chilkatc::CkJwt_put_Utf8;
*LastErrorXml = *chilkatc::CkJwt_LastErrorXml;
*LastErrorHtml = *chilkatc::CkJwt_LastErrorHtml;
*LastErrorText = *chilkatc::CkJwt_LastErrorText;
*get_AutoCompact = *chilkatc::CkJwt_get_AutoCompact;
*put_AutoCompact = *chilkatc::CkJwt_put_AutoCompact;
*get_DebugLogFilePath = *chilkatc::CkJwt_get_DebugLogFilePath;
*debugLogFilePath = *chilkatc::CkJwt_debugLogFilePath;
*put_DebugLogFilePath = *chilkatc::CkJwt_put_DebugLogFilePath;
*get_LastErrorHtml = *chilkatc::CkJwt_get_LastErrorHtml;
*lastErrorHtml = *chilkatc::CkJwt_lastErrorHtml;
*get_LastErrorText = *chilkatc::CkJwt_get_LastErrorText;
*lastErrorText = *chilkatc::CkJwt_lastErrorText;
*get_LastErrorXml = *chilkatc::CkJwt_get_LastErrorXml;
*lastErrorXml = *chilkatc::CkJwt_lastErrorXml;
*get_LastMethodSuccess = *chilkatc::CkJwt_get_LastMethodSuccess;
*put_LastMethodSuccess = *chilkatc::CkJwt_put_LastMethodSuccess;
*get_UncommonOptions = *chilkatc::CkJwt_get_UncommonOptions;
*uncommonOptions = *chilkatc::CkJwt_uncommonOptions;
*put_UncommonOptions = *chilkatc::CkJwt_put_UncommonOptions;
*get_VerboseLogging = *chilkatc::CkJwt_get_VerboseLogging;
*put_VerboseLogging = *chilkatc::CkJwt_put_VerboseLogging;
*get_Version = *chilkatc::CkJwt_get_Version;
*version = *chilkatc::CkJwt_version;
*CreateJwt = *chilkatc::CkJwt_CreateJwt;
*createJwt = *chilkatc::CkJwt_createJwt;
*CreateJwtCert = *chilkatc::CkJwt_CreateJwtCert;
*createJwtCert = *chilkatc::CkJwt_createJwtCert;
*CreateJwtPk = *chilkatc::CkJwt_CreateJwtPk;
*createJwtPk = *chilkatc::CkJwt_createJwtPk;
*GenNumericDate = *chilkatc::CkJwt_GenNumericDate;
*GetHeader = *chilkatc::CkJwt_GetHeader;
*getHeader = *chilkatc::CkJwt_getHeader;
*header = *chilkatc::CkJwt_header;
*GetPayload = *chilkatc::CkJwt_GetPayload;
*getPayload = *chilkatc::CkJwt_getPayload;
*payload = *chilkatc::CkJwt_payload;
*IsTimeValid = *chilkatc::CkJwt_IsTimeValid;
*VerifyJwt = *chilkatc::CkJwt_VerifyJwt;
*VerifyJwtPk = *chilkatc::CkJwt_VerifyJwtPk;
sub DISOWN {
    my $self = shift;
    my $ptr = tied(%$self);
    delete $OWNER{$ptr};
}

sub ACQUIRE {
    my $self = shift;
    my $ptr = tied(%$self);
    $OWNER{$ptr} = 1;
}


############# Class : chilkat::CkLog ##############

package chilkat::CkLog;
use vars qw(@ISA %OWNER %ITERATORS %BLESSEDMEMBERS);
@ISA = qw( chilkat );
%OWNER = ();
%ITERATORS = ();
sub new {
    my $pkg = shift;
    my $self = chilkatc::new_CkLog(@_);
    bless $self, $pkg if defined($self);
}

sub DESTROY {
    return unless $_[0]->isa('HASH');
    my $self = tied(%{$_[0]});
    return unless defined $self;
    delete $ITERATORS{$self};
    if (exists $OWNER{$self}) {
        chilkatc::delete_CkLog($self);
        delete $OWNER{$self};
    }
}

*get_Utf8 = *chilkatc::CkLog_get_Utf8;
*put_Utf8 = *chilkatc::CkLog_put_Utf8;
*LastErrorXml = *chilkatc::CkLog_LastErrorXml;
*LastErrorHtml = *chilkatc::CkLog_LastErrorHtml;
*LastErrorText = *chilkatc::CkLog_LastErrorText;
*get_DebugLogFilePath = *chilkatc::CkLog_get_DebugLogFilePath;
*debugLogFilePath = *chilkatc::CkLog_debugLogFilePath;
*put_DebugLogFilePath = *chilkatc::CkLog_put_DebugLogFilePath;
*get_LastErrorHtml = *chilkatc::CkLog_get_LastErrorHtml;
*lastErrorHtml = *chilkatc::CkLog_lastErrorHtml;
*get_LastErrorText = *chilkatc::CkLog_get_LastErrorText;
*lastErrorText = *chilkatc::CkLog_lastErrorText;
*get_LastErrorXml = *chilkatc::CkLog_get_LastErrorXml;
*lastErrorXml = *chilkatc::CkLog_lastErrorXml;
*get_LastMethodSuccess = *chilkatc::CkLog_get_LastMethodSuccess;
*put_LastMethodSuccess = *chilkatc::CkLog_put_LastMethodSuccess;
*get_VerboseLogging = *chilkatc::CkLog_get_VerboseLogging;
*put_VerboseLogging = *chilkatc::CkLog_put_VerboseLogging;
*get_Version = *chilkatc::CkLog_get_Version;
*version = *chilkatc::CkLog_version;
*Clear = *chilkatc::CkLog_Clear;
*EnterContext = *chilkatc::CkLog_EnterContext;
*LeaveContext = *chilkatc::CkLog_LeaveContext;
*LogData = *chilkatc::CkLog_LogData;
*LogDataBase64 = *chilkatc::CkLog_LogDataBase64;
*LogDataHex = *chilkatc::CkLog_LogDataHex;
*LogDataMax = *chilkatc::CkLog_LogDataMax;
*LogDateTime = *chilkatc::CkLog_LogDateTime;
*LogError = *chilkatc::CkLog_LogError;
*LogInfo = *chilkatc::CkLog_LogInfo;
*LogInt = *chilkatc::CkLog_LogInt;
*LogInt64 = *chilkatc::CkLog_LogInt64;
*LogTimestamp = *chilkatc::CkLog_LogTimestamp;
sub DISOWN {
    my $self = shift;
    my $ptr = tied(%$self);
    delete $OWNER{$ptr};
}

sub ACQUIRE {
    my $self = shift;
    my $ptr = tied(%$self);
    $OWNER{$ptr} = 1;
}


############# Class : chilkat::CkMailMan ##############

package chilkat::CkMailMan;
use vars qw(@ISA %OWNER %ITERATORS %BLESSEDMEMBERS);
@ISA = qw( chilkat );
%OWNER = ();
%ITERATORS = ();
sub new {
    my $pkg = shift;
    my $self = chilkatc::new_CkMailMan(@_);
    bless $self, $pkg if defined($self);
}

sub DESTROY {
    return unless $_[0]->isa('HASH');
    my $self = tied(%{$_[0]});
    return unless defined $self;
    delete $ITERATORS{$self};
    if (exists $OWNER{$self}) {
        chilkatc::delete_CkMailMan($self);
        delete $OWNER{$self};
    }
}

*get_Utf8 = *chilkatc::CkMailMan_get_Utf8;
*put_Utf8 = *chilkatc::CkMailMan_put_Utf8;
*LastErrorXml = *chilkatc::CkMailMan_LastErrorXml;
*LastErrorHtml = *chilkatc::CkMailMan_LastErrorHtml;
*LastErrorText = *chilkatc::CkMailMan_LastErrorText;
*put_EventCallbackObject = *chilkatc::CkMailMan_put_EventCallbackObject;
*get_AbortCurrent = *chilkatc::CkMailMan_get_AbortCurrent;
*put_AbortCurrent = *chilkatc::CkMailMan_put_AbortCurrent;
*get_AllOrNone = *chilkatc::CkMailMan_get_AllOrNone;
*put_AllOrNone = *chilkatc::CkMailMan_put_AllOrNone;
*get_AutoFix = *chilkatc::CkMailMan_get_AutoFix;
*put_AutoFix = *chilkatc::CkMailMan_put_AutoFix;
*get_AutoGenMessageId = *chilkatc::CkMailMan_get_AutoGenMessageId;
*put_AutoGenMessageId = *chilkatc::CkMailMan_put_AutoGenMessageId;
*get_AutoSmtpRset = *chilkatc::CkMailMan_get_AutoSmtpRset;
*put_AutoSmtpRset = *chilkatc::CkMailMan_put_AutoSmtpRset;
*get_AutoUnwrapSecurity = *chilkatc::CkMailMan_get_AutoUnwrapSecurity;
*put_AutoUnwrapSecurity = *chilkatc::CkMailMan_put_AutoUnwrapSecurity;
*get_ClientIpAddress = *chilkatc::CkMailMan_get_ClientIpAddress;
*clientIpAddress = *chilkatc::CkMailMan_clientIpAddress;
*put_ClientIpAddress = *chilkatc::CkMailMan_put_ClientIpAddress;
*get_ConnectFailReason = *chilkatc::CkMailMan_get_ConnectFailReason;
*get_ConnectTimeout = *chilkatc::CkMailMan_get_ConnectTimeout;
*put_ConnectTimeout = *chilkatc::CkMailMan_put_ConnectTimeout;
*get_DebugLogFilePath = *chilkatc::CkMailMan_get_DebugLogFilePath;
*debugLogFilePath = *chilkatc::CkMailMan_debugLogFilePath;
*put_DebugLogFilePath = *chilkatc::CkMailMan_put_DebugLogFilePath;
*get_DsnEnvid = *chilkatc::CkMailMan_get_DsnEnvid;
*dsnEnvid = *chilkatc::CkMailMan_dsnEnvid;
*put_DsnEnvid = *chilkatc::CkMailMan_put_DsnEnvid;
*get_DsnNotify = *chilkatc::CkMailMan_get_DsnNotify;
*dsnNotify = *chilkatc::CkMailMan_dsnNotify;
*put_DsnNotify = *chilkatc::CkMailMan_put_DsnNotify;
*get_DsnRet = *chilkatc::CkMailMan_get_DsnRet;
*dsnRet = *chilkatc::CkMailMan_dsnRet;
*put_DsnRet = *chilkatc::CkMailMan_put_DsnRet;
*get_EmbedCertChain = *chilkatc::CkMailMan_get_EmbedCertChain;
*put_EmbedCertChain = *chilkatc::CkMailMan_put_EmbedCertChain;
*get_Filter = *chilkatc::CkMailMan_get_Filter;
*filter = *chilkatc::CkMailMan_filter;
*put_Filter = *chilkatc::CkMailMan_put_Filter;
*get_HeartbeatMs = *chilkatc::CkMailMan_get_HeartbeatMs;
*put_HeartbeatMs = *chilkatc::CkMailMan_put_HeartbeatMs;
*get_HeloHostname = *chilkatc::CkMailMan_get_HeloHostname;
*heloHostname = *chilkatc::CkMailMan_heloHostname;
*put_HeloHostname = *chilkatc::CkMailMan_put_HeloHostname;
*get_HttpProxyAuthMethod = *chilkatc::CkMailMan_get_HttpProxyAuthMethod;
*httpProxyAuthMethod = *chilkatc::CkMailMan_httpProxyAuthMethod;
*put_HttpProxyAuthMethod = *chilkatc::CkMailMan_put_HttpProxyAuthMethod;
*get_HttpProxyDomain = *chilkatc::CkMailMan_get_HttpProxyDomain;
*httpProxyDomain = *chilkatc::CkMailMan_httpProxyDomain;
*put_HttpProxyDomain = *chilkatc::CkMailMan_put_HttpProxyDomain;
*get_HttpProxyHostname = *chilkatc::CkMailMan_get_HttpProxyHostname;
*httpProxyHostname = *chilkatc::CkMailMan_httpProxyHostname;
*put_HttpProxyHostname = *chilkatc::CkMailMan_put_HttpProxyHostname;
*get_HttpProxyPassword = *chilkatc::CkMailMan_get_HttpProxyPassword;
*httpProxyPassword = *chilkatc::CkMailMan_httpProxyPassword;
*put_HttpProxyPassword = *chilkatc::CkMailMan_put_HttpProxyPassword;
*get_HttpProxyPort = *chilkatc::CkMailMan_get_HttpProxyPort;
*put_HttpProxyPort = *chilkatc::CkMailMan_put_HttpProxyPort;
*get_HttpProxyUsername = *chilkatc::CkMailMan_get_HttpProxyUsername;
*httpProxyUsername = *chilkatc::CkMailMan_httpProxyUsername;
*put_HttpProxyUsername = *chilkatc::CkMailMan_put_HttpProxyUsername;
*get_ImmediateDelete = *chilkatc::CkMailMan_get_ImmediateDelete;
*put_ImmediateDelete = *chilkatc::CkMailMan_put_ImmediateDelete;
*get_IncludeRootCert = *chilkatc::CkMailMan_get_IncludeRootCert;
*put_IncludeRootCert = *chilkatc::CkMailMan_put_IncludeRootCert;
*get_IsPop3Connected = *chilkatc::CkMailMan_get_IsPop3Connected;
*get_IsSmtpConnected = *chilkatc::CkMailMan_get_IsSmtpConnected;
*get_LastErrorHtml = *chilkatc::CkMailMan_get_LastErrorHtml;
*lastErrorHtml = *chilkatc::CkMailMan_lastErrorHtml;
*get_LastErrorText = *chilkatc::CkMailMan_get_LastErrorText;
*lastErrorText = *chilkatc::CkMailMan_lastErrorText;
*get_LastErrorXml = *chilkatc::CkMailMan_get_LastErrorXml;
*lastErrorXml = *chilkatc::CkMailMan_lastErrorXml;
*get_LastMethodSuccess = *chilkatc::CkMailMan_get_LastMethodSuccess;
*put_LastMethodSuccess = *chilkatc::CkMailMan_put_LastMethodSuccess;
*get_LastSmtpStatus = *chilkatc::CkMailMan_get_LastSmtpStatus;
*get_LastSmtpStatusMsg = *chilkatc::CkMailMan_get_LastSmtpStatusMsg;
*lastSmtpStatusMsg = *chilkatc::CkMailMan_lastSmtpStatusMsg;
*get_LogMailReceivedFilename = *chilkatc::CkMailMan_get_LogMailReceivedFilename;
*logMailReceivedFilename = *chilkatc::CkMailMan_logMailReceivedFilename;
*put_LogMailReceivedFilename = *chilkatc::CkMailMan_put_LogMailReceivedFilename;
*get_LogMailSentFilename = *chilkatc::CkMailMan_get_LogMailSentFilename;
*logMailSentFilename = *chilkatc::CkMailMan_logMailSentFilename;
*put_LogMailSentFilename = *chilkatc::CkMailMan_put_LogMailSentFilename;
*get_MailHost = *chilkatc::CkMailMan_get_MailHost;
*mailHost = *chilkatc::CkMailMan_mailHost;
*put_MailHost = *chilkatc::CkMailMan_put_MailHost;
*get_MailPort = *chilkatc::CkMailMan_get_MailPort;
*put_MailPort = *chilkatc::CkMailMan_put_MailPort;
*get_MaxCount = *chilkatc::CkMailMan_get_MaxCount;
*put_MaxCount = *chilkatc::CkMailMan_put_MaxCount;
*get_OAuth2AccessToken = *chilkatc::CkMailMan_get_OAuth2AccessToken;
*oAuth2AccessToken = *chilkatc::CkMailMan_oAuth2AccessToken;
*put_OAuth2AccessToken = *chilkatc::CkMailMan_put_OAuth2AccessToken;
*get_OpaqueSigning = *chilkatc::CkMailMan_get_OpaqueSigning;
*put_OpaqueSigning = *chilkatc::CkMailMan_put_OpaqueSigning;
*get_P7mEncryptAttachFilename = *chilkatc::CkMailMan_get_P7mEncryptAttachFilename;
*p7mEncryptAttachFilename = *chilkatc::CkMailMan_p7mEncryptAttachFilename;
*put_P7mEncryptAttachFilename = *chilkatc::CkMailMan_put_P7mEncryptAttachFilename;
*get_P7mSigAttachFilename = *chilkatc::CkMailMan_get_P7mSigAttachFilename;
*p7mSigAttachFilename = *chilkatc::CkMailMan_p7mSigAttachFilename;
*put_P7mSigAttachFilename = *chilkatc::CkMailMan_put_P7mSigAttachFilename;
*get_P7sSigAttachFilename = *chilkatc::CkMailMan_get_P7sSigAttachFilename;
*p7sSigAttachFilename = *chilkatc::CkMailMan_p7sSigAttachFilename;
*put_P7sSigAttachFilename = *chilkatc::CkMailMan_put_P7sSigAttachFilename;
*get_PercentDoneScale = *chilkatc::CkMailMan_get_PercentDoneScale;
*put_PercentDoneScale = *chilkatc::CkMailMan_put_PercentDoneScale;
*get_Pop3SessionId = *chilkatc::CkMailMan_get_Pop3SessionId;
*get_Pop3SessionLog = *chilkatc::CkMailMan_get_Pop3SessionLog;
*pop3SessionLog = *chilkatc::CkMailMan_pop3SessionLog;
*get_Pop3SPA = *chilkatc::CkMailMan_get_Pop3SPA;
*put_Pop3SPA = *chilkatc::CkMailMan_put_Pop3SPA;
*get_Pop3SslServerCertVerified = *chilkatc::CkMailMan_get_Pop3SslServerCertVerified;
*get_Pop3Stls = *chilkatc::CkMailMan_get_Pop3Stls;
*put_Pop3Stls = *chilkatc::CkMailMan_put_Pop3Stls;
*get_Pop3StlsIfPossible = *chilkatc::CkMailMan_get_Pop3StlsIfPossible;
*put_Pop3StlsIfPossible = *chilkatc::CkMailMan_put_Pop3StlsIfPossible;
*get_PopPassword = *chilkatc::CkMailMan_get_PopPassword;
*popPassword = *chilkatc::CkMailMan_popPassword;
*put_PopPassword = *chilkatc::CkMailMan_put_PopPassword;
*get_PopPasswordBase64 = *chilkatc::CkMailMan_get_PopPasswordBase64;
*popPasswordBase64 = *chilkatc::CkMailMan_popPasswordBase64;
*put_PopPasswordBase64 = *chilkatc::CkMailMan_put_PopPasswordBase64;
*get_PopSsl = *chilkatc::CkMailMan_get_PopSsl;
*put_PopSsl = *chilkatc::CkMailMan_put_PopSsl;
*get_PopUsername = *chilkatc::CkMailMan_get_PopUsername;
*popUsername = *chilkatc::CkMailMan_popUsername;
*put_PopUsername = *chilkatc::CkMailMan_put_PopUsername;
*get_PreferIpv6 = *chilkatc::CkMailMan_get_PreferIpv6;
*put_PreferIpv6 = *chilkatc::CkMailMan_put_PreferIpv6;
*get_ReadTimeout = *chilkatc::CkMailMan_get_ReadTimeout;
*put_ReadTimeout = *chilkatc::CkMailMan_put_ReadTimeout;
*get_RequireSslCertVerify = *chilkatc::CkMailMan_get_RequireSslCertVerify;
*put_RequireSslCertVerify = *chilkatc::CkMailMan_put_RequireSslCertVerify;
*get_ResetDateOnLoad = *chilkatc::CkMailMan_get_ResetDateOnLoad;
*put_ResetDateOnLoad = *chilkatc::CkMailMan_put_ResetDateOnLoad;
*get_SendBufferSize = *chilkatc::CkMailMan_get_SendBufferSize;
*put_SendBufferSize = *chilkatc::CkMailMan_put_SendBufferSize;
*get_SendIndividual = *chilkatc::CkMailMan_get_SendIndividual;
*put_SendIndividual = *chilkatc::CkMailMan_put_SendIndividual;
*get_SizeLimit = *chilkatc::CkMailMan_get_SizeLimit;
*put_SizeLimit = *chilkatc::CkMailMan_put_SizeLimit;
*get_SmtpAuthMethod = *chilkatc::CkMailMan_get_SmtpAuthMethod;
*smtpAuthMethod = *chilkatc::CkMailMan_smtpAuthMethod;
*put_SmtpAuthMethod = *chilkatc::CkMailMan_put_SmtpAuthMethod;
*get_SmtpFailReason = *chilkatc::CkMailMan_get_SmtpFailReason;
*smtpFailReason = *chilkatc::CkMailMan_smtpFailReason;
*get_SmtpHost = *chilkatc::CkMailMan_get_SmtpHost;
*smtpHost = *chilkatc::CkMailMan_smtpHost;
*put_SmtpHost = *chilkatc::CkMailMan_put_SmtpHost;
*get_SmtpLoginDomain = *chilkatc::CkMailMan_get_SmtpLoginDomain;
*smtpLoginDomain = *chilkatc::CkMailMan_smtpLoginDomain;
*put_SmtpLoginDomain = *chilkatc::CkMailMan_put_SmtpLoginDomain;
*get_SmtpMailFrom = *chilkatc::CkMailMan_get_SmtpMailFrom;
*smtpMailFrom = *chilkatc::CkMailMan_smtpMailFrom;
*put_SmtpMailFrom = *chilkatc::CkMailMan_put_SmtpMailFrom;
*get_SmtpPassword = *chilkatc::CkMailMan_get_SmtpPassword;
*smtpPassword = *chilkatc::CkMailMan_smtpPassword;
*put_SmtpPassword = *chilkatc::CkMailMan_put_SmtpPassword;
*get_SmtpPipelining = *chilkatc::CkMailMan_get_SmtpPipelining;
*put_SmtpPipelining = *chilkatc::CkMailMan_put_SmtpPipelining;
*get_SmtpPort = *chilkatc::CkMailMan_get_SmtpPort;
*put_SmtpPort = *chilkatc::CkMailMan_put_SmtpPort;
*get_SmtpSessionLog = *chilkatc::CkMailMan_get_SmtpSessionLog;
*smtpSessionLog = *chilkatc::CkMailMan_smtpSessionLog;
*get_SmtpSsl = *chilkatc::CkMailMan_get_SmtpSsl;
*put_SmtpSsl = *chilkatc::CkMailMan_put_SmtpSsl;
*get_SmtpSslServerCertVerified = *chilkatc::CkMailMan_get_SmtpSslServerCertVerified;
*get_SmtpUsername = *chilkatc::CkMailMan_get_SmtpUsername;
*smtpUsername = *chilkatc::CkMailMan_smtpUsername;
*put_SmtpUsername = *chilkatc::CkMailMan_put_SmtpUsername;
*get_SocksHostname = *chilkatc::CkMailMan_get_SocksHostname;
*socksHostname = *chilkatc::CkMailMan_socksHostname;
*put_SocksHostname = *chilkatc::CkMailMan_put_SocksHostname;
*get_SocksPassword = *chilkatc::CkMailMan_get_SocksPassword;
*socksPassword = *chilkatc::CkMailMan_socksPassword;
*put_SocksPassword = *chilkatc::CkMailMan_put_SocksPassword;
*get_SocksPort = *chilkatc::CkMailMan_get_SocksPort;
*put_SocksPort = *chilkatc::CkMailMan_put_SocksPort;
*get_SocksUsername = *chilkatc::CkMailMan_get_SocksUsername;
*socksUsername = *chilkatc::CkMailMan_socksUsername;
*put_SocksUsername = *chilkatc::CkMailMan_put_SocksUsername;
*get_SocksVersion = *chilkatc::CkMailMan_get_SocksVersion;
*put_SocksVersion = *chilkatc::CkMailMan_put_SocksVersion;
*get_SoRcvBuf = *chilkatc::CkMailMan_get_SoRcvBuf;
*put_SoRcvBuf = *chilkatc::CkMailMan_put_SoRcvBuf;
*get_SoSndBuf = *chilkatc::CkMailMan_get_SoSndBuf;
*put_SoSndBuf = *chilkatc::CkMailMan_put_SoSndBuf;
*get_SslAllowedCiphers = *chilkatc::CkMailMan_get_SslAllowedCiphers;
*sslAllowedCiphers = *chilkatc::CkMailMan_sslAllowedCiphers;
*put_SslAllowedCiphers = *chilkatc::CkMailMan_put_SslAllowedCiphers;
*get_SslProtocol = *chilkatc::CkMailMan_get_SslProtocol;
*sslProtocol = *chilkatc::CkMailMan_sslProtocol;
*put_SslProtocol = *chilkatc::CkMailMan_put_SslProtocol;
*get_StartTLS = *chilkatc::CkMailMan_get_StartTLS;
*put_StartTLS = *chilkatc::CkMailMan_put_StartTLS;
*get_StartTLSifPossible = *chilkatc::CkMailMan_get_StartTLSifPossible;
*put_StartTLSifPossible = *chilkatc::CkMailMan_put_StartTLSifPossible;
*get_TlsCipherSuite = *chilkatc::CkMailMan_get_TlsCipherSuite;
*tlsCipherSuite = *chilkatc::CkMailMan_tlsCipherSuite;
*get_TlsPinSet = *chilkatc::CkMailMan_get_TlsPinSet;
*tlsPinSet = *chilkatc::CkMailMan_tlsPinSet;
*put_TlsPinSet = *chilkatc::CkMailMan_put_TlsPinSet;
*get_TlsVersion = *chilkatc::CkMailMan_get_TlsVersion;
*tlsVersion = *chilkatc::CkMailMan_tlsVersion;
*get_UncommonOptions = *chilkatc::CkMailMan_get_UncommonOptions;
*uncommonOptions = *chilkatc::CkMailMan_uncommonOptions;
*put_UncommonOptions = *chilkatc::CkMailMan_put_UncommonOptions;
*get_UseApop = *chilkatc::CkMailMan_get_UseApop;
*put_UseApop = *chilkatc::CkMailMan_put_UseApop;
*get_VerboseLogging = *chilkatc::CkMailMan_get_VerboseLogging;
*put_VerboseLogging = *chilkatc::CkMailMan_put_VerboseLogging;
*get_Version = *chilkatc::CkMailMan_get_Version;
*version = *chilkatc::CkMailMan_version;
*AddPfxSourceBd = *chilkatc::CkMailMan_AddPfxSourceBd;
*AddPfxSourceData = *chilkatc::CkMailMan_AddPfxSourceData;
*AddPfxSourceFile = *chilkatc::CkMailMan_AddPfxSourceFile;
*CheckMail = *chilkatc::CkMailMan_CheckMail;
*CheckMailAsync = *chilkatc::CkMailMan_CheckMailAsync;
*ClearBadEmailAddresses = *chilkatc::CkMailMan_ClearBadEmailAddresses;
*ClearPop3SessionLog = *chilkatc::CkMailMan_ClearPop3SessionLog;
*ClearSmtpSessionLog = *chilkatc::CkMailMan_ClearSmtpSessionLog;
*CloseSmtpConnection = *chilkatc::CkMailMan_CloseSmtpConnection;
*CloseSmtpConnectionAsync = *chilkatc::CkMailMan_CloseSmtpConnectionAsync;
*CopyMail = *chilkatc::CkMailMan_CopyMail;
*CopyMailAsync = *chilkatc::CkMailMan_CopyMailAsync;
*DeleteBundle = *chilkatc::CkMailMan_DeleteBundle;
*DeleteBundleAsync = *chilkatc::CkMailMan_DeleteBundleAsync;
*DeleteByMsgnum = *chilkatc::CkMailMan_DeleteByMsgnum;
*DeleteByMsgnumAsync = *chilkatc::CkMailMan_DeleteByMsgnumAsync;
*DeleteByUidl = *chilkatc::CkMailMan_DeleteByUidl;
*DeleteByUidlAsync = *chilkatc::CkMailMan_DeleteByUidlAsync;
*DeleteEmail = *chilkatc::CkMailMan_DeleteEmail;
*DeleteEmailAsync = *chilkatc::CkMailMan_DeleteEmailAsync;
*DeleteMultiple = *chilkatc::CkMailMan_DeleteMultiple;
*DeleteMultipleAsync = *chilkatc::CkMailMan_DeleteMultipleAsync;
*DeleteUidlSet = *chilkatc::CkMailMan_DeleteUidlSet;
*DeleteUidlSetAsync = *chilkatc::CkMailMan_DeleteUidlSetAsync;
*FetchAll = *chilkatc::CkMailMan_FetchAll;
*FetchAllAsync = *chilkatc::CkMailMan_FetchAllAsync;
*FetchByMsgnum = *chilkatc::CkMailMan_FetchByMsgnum;
*FetchByMsgnumAsync = *chilkatc::CkMailMan_FetchByMsgnumAsync;
*FetchByUidl = *chilkatc::CkMailMan_FetchByUidl;
*FetchByUidlAsync = *chilkatc::CkMailMan_FetchByUidlAsync;
*FetchEmail = *chilkatc::CkMailMan_FetchEmail;
*FetchEmailAsync = *chilkatc::CkMailMan_FetchEmailAsync;
*FetchFull = *chilkatc::CkMailMan_FetchFull;
*FetchFullAsync = *chilkatc::CkMailMan_FetchFullAsync;
*FetchMime = *chilkatc::CkMailMan_FetchMime;
*FetchMimeAsync = *chilkatc::CkMailMan_FetchMimeAsync;
*FetchMimeBd = *chilkatc::CkMailMan_FetchMimeBd;
*FetchMimeBdAsync = *chilkatc::CkMailMan_FetchMimeBdAsync;
*FetchMimeByMsgnum = *chilkatc::CkMailMan_FetchMimeByMsgnum;
*FetchMimeByMsgnumAsync = *chilkatc::CkMailMan_FetchMimeByMsgnumAsync;
*FetchMimeByMsgnumBd = *chilkatc::CkMailMan_FetchMimeByMsgnumBd;
*FetchMimeByMsgnumBdAsync = *chilkatc::CkMailMan_FetchMimeByMsgnumBdAsync;
*FetchMultiple = *chilkatc::CkMailMan_FetchMultiple;
*FetchMultipleAsync = *chilkatc::CkMailMan_FetchMultipleAsync;
*FetchMultipleHeaders = *chilkatc::CkMailMan_FetchMultipleHeaders;
*FetchMultipleHeadersAsync = *chilkatc::CkMailMan_FetchMultipleHeadersAsync;
*FetchMultipleMime = *chilkatc::CkMailMan_FetchMultipleMime;
*FetchMultipleMimeAsync = *chilkatc::CkMailMan_FetchMultipleMimeAsync;
*FetchOne = *chilkatc::CkMailMan_FetchOne;
*FetchOneAsync = *chilkatc::CkMailMan_FetchOneAsync;
*FetchRange = *chilkatc::CkMailMan_FetchRange;
*FetchRangeAsync = *chilkatc::CkMailMan_FetchRangeAsync;
*FetchSingleHeader = *chilkatc::CkMailMan_FetchSingleHeader;
*FetchSingleHeaderAsync = *chilkatc::CkMailMan_FetchSingleHeaderAsync;
*FetchSingleHeaderByUidl = *chilkatc::CkMailMan_FetchSingleHeaderByUidl;
*FetchSingleHeaderByUidlAsync = *chilkatc::CkMailMan_FetchSingleHeaderByUidlAsync;
*FetchUidls = *chilkatc::CkMailMan_FetchUidls;
*FetchUidlsAsync = *chilkatc::CkMailMan_FetchUidlsAsync;
*FetchUidlSet = *chilkatc::CkMailMan_FetchUidlSet;
*FetchUidlSetAsync = *chilkatc::CkMailMan_FetchUidlSetAsync;
*GetAllHeaders = *chilkatc::CkMailMan_GetAllHeaders;
*GetAllHeadersAsync = *chilkatc::CkMailMan_GetAllHeadersAsync;
*GetBadEmailAddrs = *chilkatc::CkMailMan_GetBadEmailAddrs;
*GetFullEmail = *chilkatc::CkMailMan_GetFullEmail;
*GetFullEmailAsync = *chilkatc::CkMailMan_GetFullEmailAsync;
*GetHeaders = *chilkatc::CkMailMan_GetHeaders;
*GetHeadersAsync = *chilkatc::CkMailMan_GetHeadersAsync;
*GetLastJsonData = *chilkatc::CkMailMan_GetLastJsonData;
*GetMailboxCount = *chilkatc::CkMailMan_GetMailboxCount;
*GetMailboxCountAsync = *chilkatc::CkMailMan_GetMailboxCountAsync;
*GetMailboxInfoXml = *chilkatc::CkMailMan_GetMailboxInfoXml;
*getMailboxInfoXml = *chilkatc::CkMailMan_getMailboxInfoXml;
*mailboxInfoXml = *chilkatc::CkMailMan_mailboxInfoXml;
*GetMailboxInfoXmlAsync = *chilkatc::CkMailMan_GetMailboxInfoXmlAsync;
*GetMailboxSize = *chilkatc::CkMailMan_GetMailboxSize;
*GetMailboxSizeAsync = *chilkatc::CkMailMan_GetMailboxSizeAsync;
*GetPop3SslServerCert = *chilkatc::CkMailMan_GetPop3SslServerCert;
*GetSentToEmailAddrs = *chilkatc::CkMailMan_GetSentToEmailAddrs;
*GetServerCert = *chilkatc::CkMailMan_GetServerCert;
*GetSizeByUidl = *chilkatc::CkMailMan_GetSizeByUidl;
*GetSizeByUidlAsync = *chilkatc::CkMailMan_GetSizeByUidlAsync;
*GetSmtpSslServerCert = *chilkatc::CkMailMan_GetSmtpSslServerCert;
*GetUidls = *chilkatc::CkMailMan_GetUidls;
*GetUidlsAsync = *chilkatc::CkMailMan_GetUidlsAsync;
*IsSmtpDsnCapable = *chilkatc::CkMailMan_IsSmtpDsnCapable;
*IsSmtpDsnCapableAsync = *chilkatc::CkMailMan_IsSmtpDsnCapableAsync;
*LastJsonData = *chilkatc::CkMailMan_LastJsonData;
*LoadEml = *chilkatc::CkMailMan_LoadEml;
*LoadMbx = *chilkatc::CkMailMan_LoadMbx;
*LoadMbxFile = *chilkatc::CkMailMan_LoadMbxFile;
*LoadMime = *chilkatc::CkMailMan_LoadMime;
*LoadTaskCaller = *chilkatc::CkMailMan_LoadTaskCaller;
*LoadXmlEmail = *chilkatc::CkMailMan_LoadXmlEmail;
*LoadXmlEmailString = *chilkatc::CkMailMan_LoadXmlEmailString;
*LoadXmlFile = *chilkatc::CkMailMan_LoadXmlFile;
*LoadXmlString = *chilkatc::CkMailMan_LoadXmlString;
*MxLookup = *chilkatc::CkMailMan_MxLookup;
*mxLookup = *chilkatc::CkMailMan_mxLookup;
*MxLookupAll = *chilkatc::CkMailMan_MxLookupAll;
*OpenSmtpConnection = *chilkatc::CkMailMan_OpenSmtpConnection;
*OpenSmtpConnectionAsync = *chilkatc::CkMailMan_OpenSmtpConnectionAsync;
*Pop3Authenticate = *chilkatc::CkMailMan_Pop3Authenticate;
*Pop3AuthenticateAsync = *chilkatc::CkMailMan_Pop3AuthenticateAsync;
*Pop3BeginSession = *chilkatc::CkMailMan_Pop3BeginSession;
*Pop3BeginSessionAsync = *chilkatc::CkMailMan_Pop3BeginSessionAsync;
*Pop3Connect = *chilkatc::CkMailMan_Pop3Connect;
*Pop3ConnectAsync = *chilkatc::CkMailMan_Pop3ConnectAsync;
*Pop3EndSession = *chilkatc::CkMailMan_Pop3EndSession;
*Pop3EndSessionAsync = *chilkatc::CkMailMan_Pop3EndSessionAsync;
*Pop3EndSessionNoQuit = *chilkatc::CkMailMan_Pop3EndSessionNoQuit;
*Pop3EndSessionNoQuitAsync = *chilkatc::CkMailMan_Pop3EndSessionNoQuitAsync;
*Pop3Noop = *chilkatc::CkMailMan_Pop3Noop;
*Pop3NoopAsync = *chilkatc::CkMailMan_Pop3NoopAsync;
*Pop3Reset = *chilkatc::CkMailMan_Pop3Reset;
*Pop3ResetAsync = *chilkatc::CkMailMan_Pop3ResetAsync;
*Pop3SendRawCommand = *chilkatc::CkMailMan_Pop3SendRawCommand;
*pop3SendRawCommand = *chilkatc::CkMailMan_pop3SendRawCommand;
*Pop3SendRawCommandAsync = *chilkatc::CkMailMan_Pop3SendRawCommandAsync;
*QuickSend = *chilkatc::CkMailMan_QuickSend;
*QuickSendAsync = *chilkatc::CkMailMan_QuickSendAsync;
*RenderToMime = *chilkatc::CkMailMan_RenderToMime;
*renderToMime = *chilkatc::CkMailMan_renderToMime;
*RenderToMimeBd = *chilkatc::CkMailMan_RenderToMimeBd;
*RenderToMimeBytes = *chilkatc::CkMailMan_RenderToMimeBytes;
*RenderToMimeSb = *chilkatc::CkMailMan_RenderToMimeSb;
*SendBundle = *chilkatc::CkMailMan_SendBundle;
*SendBundleAsync = *chilkatc::CkMailMan_SendBundleAsync;
*SendEmail = *chilkatc::CkMailMan_SendEmail;
*SendEmailAsync = *chilkatc::CkMailMan_SendEmailAsync;
*SendMime = *chilkatc::CkMailMan_SendMime;
*SendMimeAsync = *chilkatc::CkMailMan_SendMimeAsync;
*SendMimeBd = *chilkatc::CkMailMan_SendMimeBd;
*SendMimeBdAsync = *chilkatc::CkMailMan_SendMimeBdAsync;
*SendMimeBytes = *chilkatc::CkMailMan_SendMimeBytes;
*SendMimeBytesAsync = *chilkatc::CkMailMan_SendMimeBytesAsync;
*SendMimeToList = *chilkatc::CkMailMan_SendMimeToList;
*SendMimeToListAsync = *chilkatc::CkMailMan_SendMimeToListAsync;
*SetDecryptCert = *chilkatc::CkMailMan_SetDecryptCert;
*SetDecryptCert2 = *chilkatc::CkMailMan_SetDecryptCert2;
*SetPassword = *chilkatc::CkMailMan_SetPassword;
*SetSslClientCert = *chilkatc::CkMailMan_SetSslClientCert;
*SetSslClientCertPem = *chilkatc::CkMailMan_SetSslClientCertPem;
*SetSslClientCertPfx = *chilkatc::CkMailMan_SetSslClientCertPfx;
*SmtpAuthenticate = *chilkatc::CkMailMan_SmtpAuthenticate;
*SmtpAuthenticateAsync = *chilkatc::CkMailMan_SmtpAuthenticateAsync;
*SmtpConnect = *chilkatc::CkMailMan_SmtpConnect;
*SmtpConnectAsync = *chilkatc::CkMailMan_SmtpConnectAsync;
*SmtpNoop = *chilkatc::CkMailMan_SmtpNoop;
*SmtpNoopAsync = *chilkatc::CkMailMan_SmtpNoopAsync;
*SmtpReset = *chilkatc::CkMailMan_SmtpReset;
*SmtpResetAsync = *chilkatc::CkMailMan_SmtpResetAsync;
*SmtpSendRawCommand = *chilkatc::CkMailMan_SmtpSendRawCommand;
*smtpSendRawCommand = *chilkatc::CkMailMan_smtpSendRawCommand;
*SmtpSendRawCommandAsync = *chilkatc::CkMailMan_SmtpSendRawCommandAsync;
*SshAuthenticatePk = *chilkatc::CkMailMan_SshAuthenticatePk;
*SshAuthenticatePkAsync = *chilkatc::CkMailMan_SshAuthenticatePkAsync;
*SshAuthenticatePw = *chilkatc::CkMailMan_SshAuthenticatePw;
*SshAuthenticatePwAsync = *chilkatc::CkMailMan_SshAuthenticatePwAsync;
*SshCloseTunnel = *chilkatc::CkMailMan_SshCloseTunnel;
*SshCloseTunnelAsync = *chilkatc::CkMailMan_SshCloseTunnelAsync;
*SshOpenTunnel = *chilkatc::CkMailMan_SshOpenTunnel;
*SshOpenTunnelAsync = *chilkatc::CkMailMan_SshOpenTunnelAsync;
*TransferMail = *chilkatc::CkMailMan_TransferMail;
*TransferMailAsync = *chilkatc::CkMailMan_TransferMailAsync;
*TransferMultipleMime = *chilkatc::CkMailMan_TransferMultipleMime;
*TransferMultipleMimeAsync = *chilkatc::CkMailMan_TransferMultipleMimeAsync;
*UseCertVault = *chilkatc::CkMailMan_UseCertVault;
*UseSsh = *chilkatc::CkMailMan_UseSsh;
*UseSshTunnel = *chilkatc::CkMailMan_UseSshTunnel;
*VerifyPopConnection = *chilkatc::CkMailMan_VerifyPopConnection;
*VerifyPopConnectionAsync = *chilkatc::CkMailMan_VerifyPopConnectionAsync;
*VerifyPopLogin = *chilkatc::CkMailMan_VerifyPopLogin;
*VerifyPopLoginAsync = *chilkatc::CkMailMan_VerifyPopLoginAsync;
*VerifyRecips = *chilkatc::CkMailMan_VerifyRecips;
*VerifyRecipsAsync = *chilkatc::CkMailMan_VerifyRecipsAsync;
*VerifySmtpConnection = *chilkatc::CkMailMan_VerifySmtpConnection;
*VerifySmtpConnectionAsync = *chilkatc::CkMailMan_VerifySmtpConnectionAsync;
*VerifySmtpLogin = *chilkatc::CkMailMan_VerifySmtpLogin;
*VerifySmtpLoginAsync = *chilkatc::CkMailMan_VerifySmtpLoginAsync;
sub DISOWN {
    my $self = shift;
    my $ptr = tied(%$self);
    delete $OWNER{$ptr};
}

sub ACQUIRE {
    my $self = shift;
    my $ptr = tied(%$self);
    $OWNER{$ptr} = 1;
}


############# Class : chilkat::CkMailboxes ##############

package chilkat::CkMailboxes;
use vars qw(@ISA %OWNER %ITERATORS %BLESSEDMEMBERS);
@ISA = qw( chilkat );
%OWNER = ();
%ITERATORS = ();
sub new {
    my $pkg = shift;
    my $self = chilkatc::new_CkMailboxes(@_);
    bless $self, $pkg if defined($self);
}

sub DESTROY {
    return unless $_[0]->isa('HASH');
    my $self = tied(%{$_[0]});
    return unless defined $self;
    delete $ITERATORS{$self};
    if (exists $OWNER{$self}) {
        chilkatc::delete_CkMailboxes($self);
        delete $OWNER{$self};
    }
}

*get_Utf8 = *chilkatc::CkMailboxes_get_Utf8;
*put_Utf8 = *chilkatc::CkMailboxes_put_Utf8;
*get_Count = *chilkatc::CkMailboxes_get_Count;
*get_DebugLogFilePath = *chilkatc::CkMailboxes_get_DebugLogFilePath;
*debugLogFilePath = *chilkatc::CkMailboxes_debugLogFilePath;
*put_DebugLogFilePath = *chilkatc::CkMailboxes_put_DebugLogFilePath;
*get_LastErrorHtml = *chilkatc::CkMailboxes_get_LastErrorHtml;
*lastErrorHtml = *chilkatc::CkMailboxes_lastErrorHtml;
*get_LastErrorText = *chilkatc::CkMailboxes_get_LastErrorText;
*lastErrorText = *chilkatc::CkMailboxes_lastErrorText;
*get_LastErrorXml = *chilkatc::CkMailboxes_get_LastErrorXml;
*lastErrorXml = *chilkatc::CkMailboxes_lastErrorXml;
*get_LastMethodSuccess = *chilkatc::CkMailboxes_get_LastMethodSuccess;
*put_LastMethodSuccess = *chilkatc::CkMailboxes_put_LastMethodSuccess;
*get_VerboseLogging = *chilkatc::CkMailboxes_get_VerboseLogging;
*put_VerboseLogging = *chilkatc::CkMailboxes_put_VerboseLogging;
*get_Version = *chilkatc::CkMailboxes_get_Version;
*version = *chilkatc::CkMailboxes_version;
*GetFlags = *chilkatc::CkMailboxes_GetFlags;
*getFlags = *chilkatc::CkMailboxes_getFlags;
*flags = *chilkatc::CkMailboxes_flags;
*GetMailboxIndex = *chilkatc::CkMailboxes_GetMailboxIndex;
*GetName = *chilkatc::CkMailboxes_GetName;
*getName = *chilkatc::CkMailboxes_getName;
*name = *chilkatc::CkMailboxes_name;
*GetNthFlag = *chilkatc::CkMailboxes_GetNthFlag;
*getNthFlag = *chilkatc::CkMailboxes_getNthFlag;
*nthFlag = *chilkatc::CkMailboxes_nthFlag;
*GetNumFlags = *chilkatc::CkMailboxes_GetNumFlags;
*HasFlag = *chilkatc::CkMailboxes_HasFlag;
*HasInferiors = *chilkatc::CkMailboxes_HasInferiors;
*IsMarked = *chilkatc::CkMailboxes_IsMarked;
*IsSelectable = *chilkatc::CkMailboxes_IsSelectable;
*LoadTaskResult = *chilkatc::CkMailboxes_LoadTaskResult;
sub DISOWN {
    my $self = shift;
    my $ptr = tied(%$self);
    delete $OWNER{$ptr};
}

sub ACQUIRE {
    my $self = shift;
    my $ptr = tied(%$self);
    $OWNER{$ptr} = 1;
}


############# Class : chilkat::CkMessageSet ##############

package chilkat::CkMessageSet;
use vars qw(@ISA %OWNER %ITERATORS %BLESSEDMEMBERS);
@ISA = qw( chilkat );
%OWNER = ();
%ITERATORS = ();
sub new {
    my $pkg = shift;
    my $self = chilkatc::new_CkMessageSet(@_);
    bless $self, $pkg if defined($self);
}

sub DESTROY {
    return unless $_[0]->isa('HASH');
    my $self = tied(%{$_[0]});
    return unless defined $self;
    delete $ITERATORS{$self};
    if (exists $OWNER{$self}) {
        chilkatc::delete_CkMessageSet($self);
        delete $OWNER{$self};
    }
}

*get_Utf8 = *chilkatc::CkMessageSet_get_Utf8;
*put_Utf8 = *chilkatc::CkMessageSet_put_Utf8;
*get_Count = *chilkatc::CkMessageSet_get_Count;
*get_DebugLogFilePath = *chilkatc::CkMessageSet_get_DebugLogFilePath;
*debugLogFilePath = *chilkatc::CkMessageSet_debugLogFilePath;
*put_DebugLogFilePath = *chilkatc::CkMessageSet_put_DebugLogFilePath;
*get_HasUids = *chilkatc::CkMessageSet_get_HasUids;
*put_HasUids = *chilkatc::CkMessageSet_put_HasUids;
*get_LastErrorHtml = *chilkatc::CkMessageSet_get_LastErrorHtml;
*lastErrorHtml = *chilkatc::CkMessageSet_lastErrorHtml;
*get_LastErrorText = *chilkatc::CkMessageSet_get_LastErrorText;
*lastErrorText = *chilkatc::CkMessageSet_lastErrorText;
*get_LastErrorXml = *chilkatc::CkMessageSet_get_LastErrorXml;
*lastErrorXml = *chilkatc::CkMessageSet_lastErrorXml;
*get_LastMethodSuccess = *chilkatc::CkMessageSet_get_LastMethodSuccess;
*put_LastMethodSuccess = *chilkatc::CkMessageSet_put_LastMethodSuccess;
*get_VerboseLogging = *chilkatc::CkMessageSet_get_VerboseLogging;
*put_VerboseLogging = *chilkatc::CkMessageSet_put_VerboseLogging;
*get_Version = *chilkatc::CkMessageSet_get_Version;
*version = *chilkatc::CkMessageSet_version;
*ContainsId = *chilkatc::CkMessageSet_ContainsId;
*FromCompactString = *chilkatc::CkMessageSet_FromCompactString;
*GetId = *chilkatc::CkMessageSet_GetId;
*InsertId = *chilkatc::CkMessageSet_InsertId;
*LoadTaskResult = *chilkatc::CkMessageSet_LoadTaskResult;
*RemoveId = *chilkatc::CkMessageSet_RemoveId;
*Subtract = *chilkatc::CkMessageSet_Subtract;
*ToCommaSeparatedStr = *chilkatc::CkMessageSet_ToCommaSeparatedStr;
*toCommaSeparatedStr = *chilkatc::CkMessageSet_toCommaSeparatedStr;
*ToCompactString = *chilkatc::CkMessageSet_ToCompactString;
*toCompactString = *chilkatc::CkMessageSet_toCompactString;
sub DISOWN {
    my $self = shift;
    my $ptr = tied(%$self);
    delete $OWNER{$ptr};
}

sub ACQUIRE {
    my $self = shift;
    my $ptr = tied(%$self);
    $OWNER{$ptr} = 1;
}


############# Class : chilkat::CkMht ##############

package chilkat::CkMht;
use vars qw(@ISA %OWNER %ITERATORS %BLESSEDMEMBERS);
@ISA = qw( chilkat );
%OWNER = ();
%ITERATORS = ();
sub new {
    my $pkg = shift;
    my $self = chilkatc::new_CkMht(@_);
    bless $self, $pkg if defined($self);
}

sub DESTROY {
    return unless $_[0]->isa('HASH');
    my $self = tied(%{$_[0]});
    return unless defined $self;
    delete $ITERATORS{$self};
    if (exists $OWNER{$self}) {
        chilkatc::delete_CkMht($self);
        delete $OWNER{$self};
    }
}

*get_Utf8 = *chilkatc::CkMht_get_Utf8;
*put_Utf8 = *chilkatc::CkMht_put_Utf8;
*LastErrorXml = *chilkatc::CkMht_LastErrorXml;
*LastErrorHtml = *chilkatc::CkMht_LastErrorHtml;
*LastErrorText = *chilkatc::CkMht_LastErrorText;
*put_EventCallbackObject = *chilkatc::CkMht_put_EventCallbackObject;
*get_AbortCurrent = *chilkatc::CkMht_get_AbortCurrent;
*put_AbortCurrent = *chilkatc::CkMht_put_AbortCurrent;
*get_BaseUrl = *chilkatc::CkMht_get_BaseUrl;
*baseUrl = *chilkatc::CkMht_baseUrl;
*put_BaseUrl = *chilkatc::CkMht_put_BaseUrl;
*get_ConnectTimeout = *chilkatc::CkMht_get_ConnectTimeout;
*put_ConnectTimeout = *chilkatc::CkMht_put_ConnectTimeout;
*get_DebugHtmlAfter = *chilkatc::CkMht_get_DebugHtmlAfter;
*debugHtmlAfter = *chilkatc::CkMht_debugHtmlAfter;
*put_DebugHtmlAfter = *chilkatc::CkMht_put_DebugHtmlAfter;
*get_DebugHtmlBefore = *chilkatc::CkMht_get_DebugHtmlBefore;
*debugHtmlBefore = *chilkatc::CkMht_debugHtmlBefore;
*put_DebugHtmlBefore = *chilkatc::CkMht_put_DebugHtmlBefore;
*get_DebugLogFilePath = *chilkatc::CkMht_get_DebugLogFilePath;
*debugLogFilePath = *chilkatc::CkMht_debugLogFilePath;
*put_DebugLogFilePath = *chilkatc::CkMht_put_DebugLogFilePath;
*get_EmbedImages = *chilkatc::CkMht_get_EmbedImages;
*put_EmbedImages = *chilkatc::CkMht_put_EmbedImages;
*get_EmbedLocalOnly = *chilkatc::CkMht_get_EmbedLocalOnly;
*put_EmbedLocalOnly = *chilkatc::CkMht_put_EmbedLocalOnly;
*get_FetchFromCache = *chilkatc::CkMht_get_FetchFromCache;
*put_FetchFromCache = *chilkatc::CkMht_put_FetchFromCache;
*get_HeartbeatMs = *chilkatc::CkMht_get_HeartbeatMs;
*put_HeartbeatMs = *chilkatc::CkMht_put_HeartbeatMs;
*get_IgnoreMustRevalidate = *chilkatc::CkMht_get_IgnoreMustRevalidate;
*put_IgnoreMustRevalidate = *chilkatc::CkMht_put_IgnoreMustRevalidate;
*get_IgnoreNoCache = *chilkatc::CkMht_get_IgnoreNoCache;
*put_IgnoreNoCache = *chilkatc::CkMht_put_IgnoreNoCache;
*get_LastErrorHtml = *chilkatc::CkMht_get_LastErrorHtml;
*lastErrorHtml = *chilkatc::CkMht_lastErrorHtml;
*get_LastErrorText = *chilkatc::CkMht_get_LastErrorText;
*lastErrorText = *chilkatc::CkMht_lastErrorText;
*get_LastErrorXml = *chilkatc::CkMht_get_LastErrorXml;
*lastErrorXml = *chilkatc::CkMht_lastErrorXml;
*get_LastMethodSuccess = *chilkatc::CkMht_get_LastMethodSuccess;
*put_LastMethodSuccess = *chilkatc::CkMht_put_LastMethodSuccess;
*get_NoScripts = *chilkatc::CkMht_get_NoScripts;
*put_NoScripts = *chilkatc::CkMht_put_NoScripts;
*get_NtlmAuth = *chilkatc::CkMht_get_NtlmAuth;
*put_NtlmAuth = *chilkatc::CkMht_put_NtlmAuth;
*get_NumCacheLevels = *chilkatc::CkMht_get_NumCacheLevels;
*put_NumCacheLevels = *chilkatc::CkMht_put_NumCacheLevels;
*get_NumCacheRoots = *chilkatc::CkMht_get_NumCacheRoots;
*get_PreferIpv6 = *chilkatc::CkMht_get_PreferIpv6;
*put_PreferIpv6 = *chilkatc::CkMht_put_PreferIpv6;
*get_PreferMHTScripts = *chilkatc::CkMht_get_PreferMHTScripts;
*put_PreferMHTScripts = *chilkatc::CkMht_put_PreferMHTScripts;
*get_Proxy = *chilkatc::CkMht_get_Proxy;
*proxy = *chilkatc::CkMht_proxy;
*put_Proxy = *chilkatc::CkMht_put_Proxy;
*get_ProxyLogin = *chilkatc::CkMht_get_ProxyLogin;
*proxyLogin = *chilkatc::CkMht_proxyLogin;
*put_ProxyLogin = *chilkatc::CkMht_put_ProxyLogin;
*get_ProxyPassword = *chilkatc::CkMht_get_ProxyPassword;
*proxyPassword = *chilkatc::CkMht_proxyPassword;
*put_ProxyPassword = *chilkatc::CkMht_put_ProxyPassword;
*get_ReadTimeout = *chilkatc::CkMht_get_ReadTimeout;
*put_ReadTimeout = *chilkatc::CkMht_put_ReadTimeout;
*get_RequireSslCertVerify = *chilkatc::CkMht_get_RequireSslCertVerify;
*put_RequireSslCertVerify = *chilkatc::CkMht_put_RequireSslCertVerify;
*get_SocksHostname = *chilkatc::CkMht_get_SocksHostname;
*socksHostname = *chilkatc::CkMht_socksHostname;
*put_SocksHostname = *chilkatc::CkMht_put_SocksHostname;
*get_SocksPassword = *chilkatc::CkMht_get_SocksPassword;
*socksPassword = *chilkatc::CkMht_socksPassword;
*put_SocksPassword = *chilkatc::CkMht_put_SocksPassword;
*get_SocksPort = *chilkatc::CkMht_get_SocksPort;
*put_SocksPort = *chilkatc::CkMht_put_SocksPort;
*get_SocksUsername = *chilkatc::CkMht_get_SocksUsername;
*socksUsername = *chilkatc::CkMht_socksUsername;
*put_SocksUsername = *chilkatc::CkMht_put_SocksUsername;
*get_SocksVersion = *chilkatc::CkMht_get_SocksVersion;
*put_SocksVersion = *chilkatc::CkMht_put_SocksVersion;
*get_UnpackDirect = *chilkatc::CkMht_get_UnpackDirect;
*put_UnpackDirect = *chilkatc::CkMht_put_UnpackDirect;
*get_UnpackUseRelPaths = *chilkatc::CkMht_get_UnpackUseRelPaths;
*put_UnpackUseRelPaths = *chilkatc::CkMht_put_UnpackUseRelPaths;
*get_UpdateCache = *chilkatc::CkMht_get_UpdateCache;
*put_UpdateCache = *chilkatc::CkMht_put_UpdateCache;
*get_UseCids = *chilkatc::CkMht_get_UseCids;
*put_UseCids = *chilkatc::CkMht_put_UseCids;
*get_UseFilename = *chilkatc::CkMht_get_UseFilename;
*put_UseFilename = *chilkatc::CkMht_put_UseFilename;
*get_UseIEProxy = *chilkatc::CkMht_get_UseIEProxy;
*put_UseIEProxy = *chilkatc::CkMht_put_UseIEProxy;
*get_UseInline = *chilkatc::CkMht_get_UseInline;
*put_UseInline = *chilkatc::CkMht_put_UseInline;
*get_VerboseLogging = *chilkatc::CkMht_get_VerboseLogging;
*put_VerboseLogging = *chilkatc::CkMht_put_VerboseLogging;
*get_Version = *chilkatc::CkMht_get_Version;
*version = *chilkatc::CkMht_version;
*get_WebSiteLogin = *chilkatc::CkMht_get_WebSiteLogin;
*webSiteLogin = *chilkatc::CkMht_webSiteLogin;
*put_WebSiteLogin = *chilkatc::CkMht_put_WebSiteLogin;
*get_WebSiteLoginDomain = *chilkatc::CkMht_get_WebSiteLoginDomain;
*webSiteLoginDomain = *chilkatc::CkMht_webSiteLoginDomain;
*put_WebSiteLoginDomain = *chilkatc::CkMht_put_WebSiteLoginDomain;
*get_WebSitePassword = *chilkatc::CkMht_get_WebSitePassword;
*webSitePassword = *chilkatc::CkMht_webSitePassword;
*put_WebSitePassword = *chilkatc::CkMht_put_WebSitePassword;
*AddCacheRoot = *chilkatc::CkMht_AddCacheRoot;
*AddCustomHeader = *chilkatc::CkMht_AddCustomHeader;
*AddExternalStyleSheet = *chilkatc::CkMht_AddExternalStyleSheet;
*ClearCustomHeaders = *chilkatc::CkMht_ClearCustomHeaders;
*ExcludeImagesMatching = *chilkatc::CkMht_ExcludeImagesMatching;
*GetAndSaveEML = *chilkatc::CkMht_GetAndSaveEML;
*GetAndSaveEMLAsync = *chilkatc::CkMht_GetAndSaveEMLAsync;
*GetAndSaveMHT = *chilkatc::CkMht_GetAndSaveMHT;
*GetAndSaveMHTAsync = *chilkatc::CkMht_GetAndSaveMHTAsync;
*GetAndZipEML = *chilkatc::CkMht_GetAndZipEML;
*GetAndZipEMLAsync = *chilkatc::CkMht_GetAndZipEMLAsync;
*GetAndZipMHT = *chilkatc::CkMht_GetAndZipMHT;
*GetAndZipMHTAsync = *chilkatc::CkMht_GetAndZipMHTAsync;
*GetCacheRoot = *chilkatc::CkMht_GetCacheRoot;
*getCacheRoot = *chilkatc::CkMht_getCacheRoot;
*cacheRoot = *chilkatc::CkMht_cacheRoot;
*GetEML = *chilkatc::CkMht_GetEML;
*getEML = *chilkatc::CkMht_getEML;
*eML = *chilkatc::CkMht_eML;
*GetEMLAsync = *chilkatc::CkMht_GetEMLAsync;
*GetMHT = *chilkatc::CkMht_GetMHT;
*getMHT = *chilkatc::CkMht_getMHT;
*mHT = *chilkatc::CkMht_mHT;
*GetMHTAsync = *chilkatc::CkMht_GetMHTAsync;
*HtmlToEML = *chilkatc::CkMht_HtmlToEML;
*htmlToEML = *chilkatc::CkMht_htmlToEML;
*HtmlToEMLAsync = *chilkatc::CkMht_HtmlToEMLAsync;
*HtmlToEMLFile = *chilkatc::CkMht_HtmlToEMLFile;
*HtmlToEMLFileAsync = *chilkatc::CkMht_HtmlToEMLFileAsync;
*HtmlToMHT = *chilkatc::CkMht_HtmlToMHT;
*htmlToMHT = *chilkatc::CkMht_htmlToMHT;
*HtmlToMHTAsync = *chilkatc::CkMht_HtmlToMHTAsync;
*HtmlToMHTFile = *chilkatc::CkMht_HtmlToMHTFile;
*HtmlToMHTFileAsync = *chilkatc::CkMht_HtmlToMHTFileAsync;
*LoadTaskCaller = *chilkatc::CkMht_LoadTaskCaller;
*RemoveCustomHeader = *chilkatc::CkMht_RemoveCustomHeader;
*RestoreDefaults = *chilkatc::CkMht_RestoreDefaults;
*UnpackMHT = *chilkatc::CkMht_UnpackMHT;
*UnpackMHTString = *chilkatc::CkMht_UnpackMHTString;
sub DISOWN {
    my $self = shift;
    my $ptr = tied(%$self);
    delete $OWNER{$ptr};
}

sub ACQUIRE {
    my $self = shift;
    my $ptr = tied(%$self);
    $OWNER{$ptr} = 1;
}


############# Class : chilkat::CkMime ##############

package chilkat::CkMime;
use vars qw(@ISA %OWNER %ITERATORS %BLESSEDMEMBERS);
@ISA = qw( chilkat );
%OWNER = ();
%ITERATORS = ();
sub new {
    my $pkg = shift;
    my $self = chilkatc::new_CkMime(@_);
    bless $self, $pkg if defined($self);
}

sub DESTROY {
    return unless $_[0]->isa('HASH');
    my $self = tied(%{$_[0]});
    return unless defined $self;
    delete $ITERATORS{$self};
    if (exists $OWNER{$self}) {
        chilkatc::delete_CkMime($self);
        delete $OWNER{$self};
    }
}

*get_Utf8 = *chilkatc::CkMime_get_Utf8;
*put_Utf8 = *chilkatc::CkMime_put_Utf8;
*LastErrorXml = *chilkatc::CkMime_LastErrorXml;
*LastErrorHtml = *chilkatc::CkMime_LastErrorHtml;
*LastErrorText = *chilkatc::CkMime_LastErrorText;
*get_Boundary = *chilkatc::CkMime_get_Boundary;
*boundary = *chilkatc::CkMime_boundary;
*put_Boundary = *chilkatc::CkMime_put_Boundary;
*get_Charset = *chilkatc::CkMime_get_Charset;
*charset = *chilkatc::CkMime_charset;
*put_Charset = *chilkatc::CkMime_put_Charset;
*get_CmsOptions = *chilkatc::CkMime_get_CmsOptions;
*cmsOptions = *chilkatc::CkMime_cmsOptions;
*put_CmsOptions = *chilkatc::CkMime_put_CmsOptions;
*get_ContentType = *chilkatc::CkMime_get_ContentType;
*contentType = *chilkatc::CkMime_contentType;
*put_ContentType = *chilkatc::CkMime_put_ContentType;
*get_CurrentDateTime = *chilkatc::CkMime_get_CurrentDateTime;
*currentDateTime = *chilkatc::CkMime_currentDateTime;
*get_DebugLogFilePath = *chilkatc::CkMime_get_DebugLogFilePath;
*debugLogFilePath = *chilkatc::CkMime_debugLogFilePath;
*put_DebugLogFilePath = *chilkatc::CkMime_put_DebugLogFilePath;
*get_Disposition = *chilkatc::CkMime_get_Disposition;
*disposition = *chilkatc::CkMime_disposition;
*put_Disposition = *chilkatc::CkMime_put_Disposition;
*get_Encoding = *chilkatc::CkMime_get_Encoding;
*encoding = *chilkatc::CkMime_encoding;
*put_Encoding = *chilkatc::CkMime_put_Encoding;
*get_Filename = *chilkatc::CkMime_get_Filename;
*filename = *chilkatc::CkMime_filename;
*put_Filename = *chilkatc::CkMime_put_Filename;
*get_LastErrorHtml = *chilkatc::CkMime_get_LastErrorHtml;
*lastErrorHtml = *chilkatc::CkMime_lastErrorHtml;
*get_LastErrorText = *chilkatc::CkMime_get_LastErrorText;
*lastErrorText = *chilkatc::CkMime_lastErrorText;
*get_LastErrorXml = *chilkatc::CkMime_get_LastErrorXml;
*lastErrorXml = *chilkatc::CkMime_lastErrorXml;
*get_LastMethodSuccess = *chilkatc::CkMime_get_LastMethodSuccess;
*put_LastMethodSuccess = *chilkatc::CkMime_put_LastMethodSuccess;
*get_Micalg = *chilkatc::CkMime_get_Micalg;
*micalg = *chilkatc::CkMime_micalg;
*put_Micalg = *chilkatc::CkMime_put_Micalg;
*get_Name = *chilkatc::CkMime_get_Name;
*name = *chilkatc::CkMime_name;
*put_Name = *chilkatc::CkMime_put_Name;
*get_NumDecryptCerts = *chilkatc::CkMime_get_NumDecryptCerts;
*get_NumEncryptCerts = *chilkatc::CkMime_get_NumEncryptCerts;
*get_NumHeaderFields = *chilkatc::CkMime_get_NumHeaderFields;
*get_NumParts = *chilkatc::CkMime_get_NumParts;
*get_NumSignerCerts = *chilkatc::CkMime_get_NumSignerCerts;
*get_OaepHash = *chilkatc::CkMime_get_OaepHash;
*oaepHash = *chilkatc::CkMime_oaepHash;
*put_OaepHash = *chilkatc::CkMime_put_OaepHash;
*get_OaepMgfHash = *chilkatc::CkMime_get_OaepMgfHash;
*oaepMgfHash = *chilkatc::CkMime_oaepMgfHash;
*put_OaepMgfHash = *chilkatc::CkMime_put_OaepMgfHash;
*get_OaepPadding = *chilkatc::CkMime_get_OaepPadding;
*put_OaepPadding = *chilkatc::CkMime_put_OaepPadding;
*get_Pkcs7CryptAlg = *chilkatc::CkMime_get_Pkcs7CryptAlg;
*pkcs7CryptAlg = *chilkatc::CkMime_pkcs7CryptAlg;
*put_Pkcs7CryptAlg = *chilkatc::CkMime_put_Pkcs7CryptAlg;
*get_Pkcs7KeyLength = *chilkatc::CkMime_get_Pkcs7KeyLength;
*put_Pkcs7KeyLength = *chilkatc::CkMime_put_Pkcs7KeyLength;
*get_Protocol = *chilkatc::CkMime_get_Protocol;
*protocol = *chilkatc::CkMime_protocol;
*put_Protocol = *chilkatc::CkMime_put_Protocol;
*get_SigningAlg = *chilkatc::CkMime_get_SigningAlg;
*signingAlg = *chilkatc::CkMime_signingAlg;
*put_SigningAlg = *chilkatc::CkMime_put_SigningAlg;
*get_SigningHashAlg = *chilkatc::CkMime_get_SigningHashAlg;
*signingHashAlg = *chilkatc::CkMime_signingHashAlg;
*put_SigningHashAlg = *chilkatc::CkMime_put_SigningHashAlg;
*get_UncommonOptions = *chilkatc::CkMime_get_UncommonOptions;
*uncommonOptions = *chilkatc::CkMime_uncommonOptions;
*put_UncommonOptions = *chilkatc::CkMime_put_UncommonOptions;
*get_UnwrapExtras = *chilkatc::CkMime_get_UnwrapExtras;
*put_UnwrapExtras = *chilkatc::CkMime_put_UnwrapExtras;
*get_UseMmDescription = *chilkatc::CkMime_get_UseMmDescription;
*put_UseMmDescription = *chilkatc::CkMime_put_UseMmDescription;
*get_UseXPkcs7 = *chilkatc::CkMime_get_UseXPkcs7;
*put_UseXPkcs7 = *chilkatc::CkMime_put_UseXPkcs7;
*get_VerboseLogging = *chilkatc::CkMime_get_VerboseLogging;
*put_VerboseLogging = *chilkatc::CkMime_put_VerboseLogging;
*get_Version = *chilkatc::CkMime_get_Version;
*version = *chilkatc::CkMime_version;
*AddContentLength = *chilkatc::CkMime_AddContentLength;
*AddDecryptCert = *chilkatc::CkMime_AddDecryptCert;
*AddDetachedSignature = *chilkatc::CkMime_AddDetachedSignature;
*AddDetachedSignature2 = *chilkatc::CkMime_AddDetachedSignature2;
*AddDetachedSignaturePk = *chilkatc::CkMime_AddDetachedSignaturePk;
*AddDetachedSignaturePk2 = *chilkatc::CkMime_AddDetachedSignaturePk2;
*AddEncryptCert = *chilkatc::CkMime_AddEncryptCert;
*AddHeaderField = *chilkatc::CkMime_AddHeaderField;
*AddPfxSourceBd = *chilkatc::CkMime_AddPfxSourceBd;
*AddPfxSourceData = *chilkatc::CkMime_AddPfxSourceData;
*AddPfxSourceFile = *chilkatc::CkMime_AddPfxSourceFile;
*AppendPart = *chilkatc::CkMime_AppendPart;
*AppendPartFromFile = *chilkatc::CkMime_AppendPartFromFile;
*AsnBodyToXml = *chilkatc::CkMime_AsnBodyToXml;
*asnBodyToXml = *chilkatc::CkMime_asnBodyToXml;
*ClearEncryptCerts = *chilkatc::CkMime_ClearEncryptCerts;
*ContainsEncryptedParts = *chilkatc::CkMime_ContainsEncryptedParts;
*ContainsSignedParts = *chilkatc::CkMime_ContainsSignedParts;
*Convert8Bit = *chilkatc::CkMime_Convert8Bit;
*ConvertToMultipartAlt = *chilkatc::CkMime_ConvertToMultipartAlt;
*ConvertToMultipartMixed = *chilkatc::CkMime_ConvertToMultipartMixed;
*ConvertToSigned = *chilkatc::CkMime_ConvertToSigned;
*ConvertToSignedPk = *chilkatc::CkMime_ConvertToSignedPk;
*Decrypt = *chilkatc::CkMime_Decrypt;
*Decrypt2 = *chilkatc::CkMime_Decrypt2;
*DecryptUsingCert = *chilkatc::CkMime_DecryptUsingCert;
*DecryptUsingPfxData = *chilkatc::CkMime_DecryptUsingPfxData;
*DecryptUsingPfxFile = *chilkatc::CkMime_DecryptUsingPfxFile;
*Encrypt = *chilkatc::CkMime_Encrypt;
*EncryptN = *chilkatc::CkMime_EncryptN;
*ExtractPartsToFiles = *chilkatc::CkMime_ExtractPartsToFiles;
*FindIssuer = *chilkatc::CkMime_FindIssuer;
*GetBodyBd = *chilkatc::CkMime_GetBodyBd;
*GetBodyBinary = *chilkatc::CkMime_GetBodyBinary;
*GetBodyDecoded = *chilkatc::CkMime_GetBodyDecoded;
*getBodyDecoded = *chilkatc::CkMime_getBodyDecoded;
*bodyDecoded = *chilkatc::CkMime_bodyDecoded;
*GetBodyEncoded = *chilkatc::CkMime_GetBodyEncoded;
*getBodyEncoded = *chilkatc::CkMime_getBodyEncoded;
*bodyEncoded = *chilkatc::CkMime_bodyEncoded;
*GetEncryptCert = *chilkatc::CkMime_GetEncryptCert;
*GetEntireBody = *chilkatc::CkMime_GetEntireBody;
*getEntireBody = *chilkatc::CkMime_getEntireBody;
*entireBody = *chilkatc::CkMime_entireBody;
*GetEntireHead = *chilkatc::CkMime_GetEntireHead;
*getEntireHead = *chilkatc::CkMime_getEntireHead;
*entireHead = *chilkatc::CkMime_entireHead;
*GetHeaderField = *chilkatc::CkMime_GetHeaderField;
*getHeaderField = *chilkatc::CkMime_getHeaderField;
*headerField = *chilkatc::CkMime_headerField;
*GetHeaderFieldAttribute = *chilkatc::CkMime_GetHeaderFieldAttribute;
*getHeaderFieldAttribute = *chilkatc::CkMime_getHeaderFieldAttribute;
*headerFieldAttribute = *chilkatc::CkMime_headerFieldAttribute;
*GetHeaderFieldName = *chilkatc::CkMime_GetHeaderFieldName;
*getHeaderFieldName = *chilkatc::CkMime_getHeaderFieldName;
*headerFieldName = *chilkatc::CkMime_headerFieldName;
*GetHeaderFieldValue = *chilkatc::CkMime_GetHeaderFieldValue;
*getHeaderFieldValue = *chilkatc::CkMime_getHeaderFieldValue;
*headerFieldValue = *chilkatc::CkMime_headerFieldValue;
*GetLastJsonData = *chilkatc::CkMime_GetLastJsonData;
*GetMime = *chilkatc::CkMime_GetMime;
*getMime = *chilkatc::CkMime_getMime;
*mime = *chilkatc::CkMime_mime;
*GetMimeBd = *chilkatc::CkMime_GetMimeBd;
*GetMimeBytes = *chilkatc::CkMime_GetMimeBytes;
*GetMimeSb = *chilkatc::CkMime_GetMimeSb;
*GetPart = *chilkatc::CkMime_GetPart;
*GetSignatureSigningTimeStr = *chilkatc::CkMime_GetSignatureSigningTimeStr;
*getSignatureSigningTimeStr = *chilkatc::CkMime_getSignatureSigningTimeStr;
*signatureSigningTimeStr = *chilkatc::CkMime_signatureSigningTimeStr;
*GetSignerCert = *chilkatc::CkMime_GetSignerCert;
*GetSignerCertChain = *chilkatc::CkMime_GetSignerCertChain;
*GetStructure = *chilkatc::CkMime_GetStructure;
*getStructure = *chilkatc::CkMime_getStructure;
*structure = *chilkatc::CkMime_structure;
*GetXml = *chilkatc::CkMime_GetXml;
*getXml = *chilkatc::CkMime_getXml;
*xml = *chilkatc::CkMime_xml;
*HasSignatureSigningTime = *chilkatc::CkMime_HasSignatureSigningTime;
*IsApplicationData = *chilkatc::CkMime_IsApplicationData;
*IsAttachment = *chilkatc::CkMime_IsAttachment;
*IsAudio = *chilkatc::CkMime_IsAudio;
*IsEncrypted = *chilkatc::CkMime_IsEncrypted;
*IsHtml = *chilkatc::CkMime_IsHtml;
*IsImage = *chilkatc::CkMime_IsImage;
*IsMultipart = *chilkatc::CkMime_IsMultipart;
*IsMultipartAlternative = *chilkatc::CkMime_IsMultipartAlternative;
*IsMultipartMixed = *chilkatc::CkMime_IsMultipartMixed;
*IsMultipartRelated = *chilkatc::CkMime_IsMultipartRelated;
*IsPlainText = *chilkatc::CkMime_IsPlainText;
*IsSigned = *chilkatc::CkMime_IsSigned;
*IsText = *chilkatc::CkMime_IsText;
*IsVideo = *chilkatc::CkMime_IsVideo;
*IsXml = *chilkatc::CkMime_IsXml;
*LastDecryptCert = *chilkatc::CkMime_LastDecryptCert;
*LastJsonData = *chilkatc::CkMime_LastJsonData;
*LastSignerCert = *chilkatc::CkMime_LastSignerCert;
*LoadMime = *chilkatc::CkMime_LoadMime;
*LoadMimeBd = *chilkatc::CkMime_LoadMimeBd;
*LoadMimeBytes = *chilkatc::CkMime_LoadMimeBytes;
*LoadMimeFile = *chilkatc::CkMime_LoadMimeFile;
*LoadMimeSb = *chilkatc::CkMime_LoadMimeSb;
*LoadXml = *chilkatc::CkMime_LoadXml;
*LoadXmlFile = *chilkatc::CkMime_LoadXmlFile;
*NewMessageRfc822 = *chilkatc::CkMime_NewMessageRfc822;
*NewMultipartAlternative = *chilkatc::CkMime_NewMultipartAlternative;
*NewMultipartMixed = *chilkatc::CkMime_NewMultipartMixed;
*NewMultipartRelated = *chilkatc::CkMime_NewMultipartRelated;
*PartAt = *chilkatc::CkMime_PartAt;
*PartsToFiles = *chilkatc::CkMime_PartsToFiles;
*RemoveHeaderField = *chilkatc::CkMime_RemoveHeaderField;
*RemovePart = *chilkatc::CkMime_RemovePart;
*SaveBody = *chilkatc::CkMime_SaveBody;
*SaveMime = *chilkatc::CkMime_SaveMime;
*SaveXml = *chilkatc::CkMime_SaveXml;
*SetBody = *chilkatc::CkMime_SetBody;
*SetBodyBd = *chilkatc::CkMime_SetBodyBd;
*SetBodyFromBinary = *chilkatc::CkMime_SetBodyFromBinary;
*SetBodyFromEncoded = *chilkatc::CkMime_SetBodyFromEncoded;
*SetBodyFromFile = *chilkatc::CkMime_SetBodyFromFile;
*SetBodyFromHtml = *chilkatc::CkMime_SetBodyFromHtml;
*SetBodyFromPlainText = *chilkatc::CkMime_SetBodyFromPlainText;
*SetBodyFromXml = *chilkatc::CkMime_SetBodyFromXml;
*SetHeaderField = *chilkatc::CkMime_SetHeaderField;
*SetVerifyCert = *chilkatc::CkMime_SetVerifyCert;
*UnwrapSecurity = *chilkatc::CkMime_UnwrapSecurity;
*UrlEncodeBody = *chilkatc::CkMime_UrlEncodeBody;
*UseCertVault = *chilkatc::CkMime_UseCertVault;
*Verify = *chilkatc::CkMime_Verify;
sub DISOWN {
    my $self = shift;
    my $ptr = tied(%$self);
    delete $OWNER{$ptr};
}

sub ACQUIRE {
    my $self = shift;
    my $ptr = tied(%$self);
    $OWNER{$ptr} = 1;
}


############# Class : chilkat::CkNtlm ##############

package chilkat::CkNtlm;
use vars qw(@ISA %OWNER %ITERATORS %BLESSEDMEMBERS);
@ISA = qw( chilkat );
%OWNER = ();
%ITERATORS = ();
sub new {
    my $pkg = shift;
    my $self = chilkatc::new_CkNtlm(@_);
    bless $self, $pkg if defined($self);
}

sub DESTROY {
    return unless $_[0]->isa('HASH');
    my $self = tied(%{$_[0]});
    return unless defined $self;
    delete $ITERATORS{$self};
    if (exists $OWNER{$self}) {
        chilkatc::delete_CkNtlm($self);
        delete $OWNER{$self};
    }
}

*get_Utf8 = *chilkatc::CkNtlm_get_Utf8;
*put_Utf8 = *chilkatc::CkNtlm_put_Utf8;
*LastErrorXml = *chilkatc::CkNtlm_LastErrorXml;
*LastErrorHtml = *chilkatc::CkNtlm_LastErrorHtml;
*LastErrorText = *chilkatc::CkNtlm_LastErrorText;
*get_ClientChallenge = *chilkatc::CkNtlm_get_ClientChallenge;
*clientChallenge = *chilkatc::CkNtlm_clientChallenge;
*put_ClientChallenge = *chilkatc::CkNtlm_put_ClientChallenge;
*get_DebugLogFilePath = *chilkatc::CkNtlm_get_DebugLogFilePath;
*debugLogFilePath = *chilkatc::CkNtlm_debugLogFilePath;
*put_DebugLogFilePath = *chilkatc::CkNtlm_put_DebugLogFilePath;
*get_DnsComputerName = *chilkatc::CkNtlm_get_DnsComputerName;
*dnsComputerName = *chilkatc::CkNtlm_dnsComputerName;
*put_DnsComputerName = *chilkatc::CkNtlm_put_DnsComputerName;
*get_DnsDomainName = *chilkatc::CkNtlm_get_DnsDomainName;
*dnsDomainName = *chilkatc::CkNtlm_dnsDomainName;
*put_DnsDomainName = *chilkatc::CkNtlm_put_DnsDomainName;
*get_Domain = *chilkatc::CkNtlm_get_Domain;
*domain = *chilkatc::CkNtlm_domain;
*put_Domain = *chilkatc::CkNtlm_put_Domain;
*get_EncodingMode = *chilkatc::CkNtlm_get_EncodingMode;
*encodingMode = *chilkatc::CkNtlm_encodingMode;
*put_EncodingMode = *chilkatc::CkNtlm_put_EncodingMode;
*get_Flags = *chilkatc::CkNtlm_get_Flags;
*flags = *chilkatc::CkNtlm_flags;
*put_Flags = *chilkatc::CkNtlm_put_Flags;
*get_LastErrorHtml = *chilkatc::CkNtlm_get_LastErrorHtml;
*lastErrorHtml = *chilkatc::CkNtlm_lastErrorHtml;
*get_LastErrorText = *chilkatc::CkNtlm_get_LastErrorText;
*lastErrorText = *chilkatc::CkNtlm_lastErrorText;
*get_LastErrorXml = *chilkatc::CkNtlm_get_LastErrorXml;
*lastErrorXml = *chilkatc::CkNtlm_lastErrorXml;
*get_LastMethodSuccess = *chilkatc::CkNtlm_get_LastMethodSuccess;
*put_LastMethodSuccess = *chilkatc::CkNtlm_put_LastMethodSuccess;
*get_NetBiosComputerName = *chilkatc::CkNtlm_get_NetBiosComputerName;
*netBiosComputerName = *chilkatc::CkNtlm_netBiosComputerName;
*put_NetBiosComputerName = *chilkatc::CkNtlm_put_NetBiosComputerName;
*get_NetBiosDomainName = *chilkatc::CkNtlm_get_NetBiosDomainName;
*netBiosDomainName = *chilkatc::CkNtlm_netBiosDomainName;
*put_NetBiosDomainName = *chilkatc::CkNtlm_put_NetBiosDomainName;
*get_NtlmVersion = *chilkatc::CkNtlm_get_NtlmVersion;
*put_NtlmVersion = *chilkatc::CkNtlm_put_NtlmVersion;
*get_OemCodePage = *chilkatc::CkNtlm_get_OemCodePage;
*put_OemCodePage = *chilkatc::CkNtlm_put_OemCodePage;
*get_Password = *chilkatc::CkNtlm_get_Password;
*password = *chilkatc::CkNtlm_password;
*put_Password = *chilkatc::CkNtlm_put_Password;
*get_ServerChallenge = *chilkatc::CkNtlm_get_ServerChallenge;
*serverChallenge = *chilkatc::CkNtlm_serverChallenge;
*put_ServerChallenge = *chilkatc::CkNtlm_put_ServerChallenge;
*get_TargetName = *chilkatc::CkNtlm_get_TargetName;
*targetName = *chilkatc::CkNtlm_targetName;
*put_TargetName = *chilkatc::CkNtlm_put_TargetName;
*get_UserName = *chilkatc::CkNtlm_get_UserName;
*userName = *chilkatc::CkNtlm_userName;
*put_UserName = *chilkatc::CkNtlm_put_UserName;
*get_VerboseLogging = *chilkatc::CkNtlm_get_VerboseLogging;
*put_VerboseLogging = *chilkatc::CkNtlm_put_VerboseLogging;
*get_Version = *chilkatc::CkNtlm_get_Version;
*version = *chilkatc::CkNtlm_version;
*get_Workstation = *chilkatc::CkNtlm_get_Workstation;
*workstation = *chilkatc::CkNtlm_workstation;
*put_Workstation = *chilkatc::CkNtlm_put_Workstation;
*CompareType3 = *chilkatc::CkNtlm_CompareType3;
*GenType1 = *chilkatc::CkNtlm_GenType1;
*genType1 = *chilkatc::CkNtlm_genType1;
*GenType2 = *chilkatc::CkNtlm_GenType2;
*genType2 = *chilkatc::CkNtlm_genType2;
*GenType3 = *chilkatc::CkNtlm_GenType3;
*genType3 = *chilkatc::CkNtlm_genType3;
*LoadType3 = *chilkatc::CkNtlm_LoadType3;
*ParseType1 = *chilkatc::CkNtlm_ParseType1;
*parseType1 = *chilkatc::CkNtlm_parseType1;
*ParseType2 = *chilkatc::CkNtlm_ParseType2;
*parseType2 = *chilkatc::CkNtlm_parseType2;
*ParseType3 = *chilkatc::CkNtlm_ParseType3;
*parseType3 = *chilkatc::CkNtlm_parseType3;
*SetFlag = *chilkatc::CkNtlm_SetFlag;
sub DISOWN {
    my $self = shift;
    my $ptr = tied(%$self);
    delete $OWNER{$ptr};
}

sub ACQUIRE {
    my $self = shift;
    my $ptr = tied(%$self);
    $OWNER{$ptr} = 1;
}


############# Class : chilkat::CkOAuth1 ##############

package chilkat::CkOAuth1;
use vars qw(@ISA %OWNER %ITERATORS %BLESSEDMEMBERS);
@ISA = qw( chilkat );
%OWNER = ();
%ITERATORS = ();
sub new {
    my $pkg = shift;
    my $self = chilkatc::new_CkOAuth1(@_);
    bless $self, $pkg if defined($self);
}

sub DESTROY {
    return unless $_[0]->isa('HASH');
    my $self = tied(%{$_[0]});
    return unless defined $self;
    delete $ITERATORS{$self};
    if (exists $OWNER{$self}) {
        chilkatc::delete_CkOAuth1($self);
        delete $OWNER{$self};
    }
}

*get_Utf8 = *chilkatc::CkOAuth1_get_Utf8;
*put_Utf8 = *chilkatc::CkOAuth1_put_Utf8;
*LastErrorXml = *chilkatc::CkOAuth1_LastErrorXml;
*LastErrorHtml = *chilkatc::CkOAuth1_LastErrorHtml;
*LastErrorText = *chilkatc::CkOAuth1_LastErrorText;
*get_AuthorizationHeader = *chilkatc::CkOAuth1_get_AuthorizationHeader;
*authorizationHeader = *chilkatc::CkOAuth1_authorizationHeader;
*get_BaseString = *chilkatc::CkOAuth1_get_BaseString;
*baseString = *chilkatc::CkOAuth1_baseString;
*get_ConsumerKey = *chilkatc::CkOAuth1_get_ConsumerKey;
*consumerKey = *chilkatc::CkOAuth1_consumerKey;
*put_ConsumerKey = *chilkatc::CkOAuth1_put_ConsumerKey;
*get_ConsumerSecret = *chilkatc::CkOAuth1_get_ConsumerSecret;
*consumerSecret = *chilkatc::CkOAuth1_consumerSecret;
*put_ConsumerSecret = *chilkatc::CkOAuth1_put_ConsumerSecret;
*get_DebugLogFilePath = *chilkatc::CkOAuth1_get_DebugLogFilePath;
*debugLogFilePath = *chilkatc::CkOAuth1_debugLogFilePath;
*put_DebugLogFilePath = *chilkatc::CkOAuth1_put_DebugLogFilePath;
*get_EncodedSignature = *chilkatc::CkOAuth1_get_EncodedSignature;
*encodedSignature = *chilkatc::CkOAuth1_encodedSignature;
*get_GeneratedUrl = *chilkatc::CkOAuth1_get_GeneratedUrl;
*generatedUrl = *chilkatc::CkOAuth1_generatedUrl;
*get_HmacKey = *chilkatc::CkOAuth1_get_HmacKey;
*hmacKey = *chilkatc::CkOAuth1_hmacKey;
*get_LastErrorHtml = *chilkatc::CkOAuth1_get_LastErrorHtml;
*lastErrorHtml = *chilkatc::CkOAuth1_lastErrorHtml;
*get_LastErrorText = *chilkatc::CkOAuth1_get_LastErrorText;
*lastErrorText = *chilkatc::CkOAuth1_lastErrorText;
*get_LastErrorXml = *chilkatc::CkOAuth1_get_LastErrorXml;
*lastErrorXml = *chilkatc::CkOAuth1_lastErrorXml;
*get_LastMethodSuccess = *chilkatc::CkOAuth1_get_LastMethodSuccess;
*put_LastMethodSuccess = *chilkatc::CkOAuth1_put_LastMethodSuccess;
*get_Nonce = *chilkatc::CkOAuth1_get_Nonce;
*nonce = *chilkatc::CkOAuth1_nonce;
*put_Nonce = *chilkatc::CkOAuth1_put_Nonce;
*get_OauthMethod = *chilkatc::CkOAuth1_get_OauthMethod;
*oauthMethod = *chilkatc::CkOAuth1_oauthMethod;
*put_OauthMethod = *chilkatc::CkOAuth1_put_OauthMethod;
*get_OauthUrl = *chilkatc::CkOAuth1_get_OauthUrl;
*oauthUrl = *chilkatc::CkOAuth1_oauthUrl;
*put_OauthUrl = *chilkatc::CkOAuth1_put_OauthUrl;
*get_OauthVersion = *chilkatc::CkOAuth1_get_OauthVersion;
*oauthVersion = *chilkatc::CkOAuth1_oauthVersion;
*put_OauthVersion = *chilkatc::CkOAuth1_put_OauthVersion;
*get_QueryString = *chilkatc::CkOAuth1_get_QueryString;
*queryString = *chilkatc::CkOAuth1_queryString;
*get_Realm = *chilkatc::CkOAuth1_get_Realm;
*realm = *chilkatc::CkOAuth1_realm;
*put_Realm = *chilkatc::CkOAuth1_put_Realm;
*get_Signature = *chilkatc::CkOAuth1_get_Signature;
*signature = *chilkatc::CkOAuth1_signature;
*get_SignatureMethod = *chilkatc::CkOAuth1_get_SignatureMethod;
*signatureMethod = *chilkatc::CkOAuth1_signatureMethod;
*put_SignatureMethod = *chilkatc::CkOAuth1_put_SignatureMethod;
*get_Timestamp = *chilkatc::CkOAuth1_get_Timestamp;
*timestamp = *chilkatc::CkOAuth1_timestamp;
*put_Timestamp = *chilkatc::CkOAuth1_put_Timestamp;
*get_Token = *chilkatc::CkOAuth1_get_Token;
*token = *chilkatc::CkOAuth1_token;
*put_Token = *chilkatc::CkOAuth1_put_Token;
*get_TokenSecret = *chilkatc::CkOAuth1_get_TokenSecret;
*tokenSecret = *chilkatc::CkOAuth1_tokenSecret;
*put_TokenSecret = *chilkatc::CkOAuth1_put_TokenSecret;
*get_UncommonOptions = *chilkatc::CkOAuth1_get_UncommonOptions;
*uncommonOptions = *chilkatc::CkOAuth1_uncommonOptions;
*put_UncommonOptions = *chilkatc::CkOAuth1_put_UncommonOptions;
*get_VerboseLogging = *chilkatc::CkOAuth1_get_VerboseLogging;
*put_VerboseLogging = *chilkatc::CkOAuth1_put_VerboseLogging;
*get_Version = *chilkatc::CkOAuth1_get_Version;
*version = *chilkatc::CkOAuth1_version;
*AddParam = *chilkatc::CkOAuth1_AddParam;
*Generate = *chilkatc::CkOAuth1_Generate;
*GenNonce = *chilkatc::CkOAuth1_GenNonce;
*GenTimestamp = *chilkatc::CkOAuth1_GenTimestamp;
*RemoveParam = *chilkatc::CkOAuth1_RemoveParam;
*SetRsaKey = *chilkatc::CkOAuth1_SetRsaKey;
sub DISOWN {
    my $self = shift;
    my $ptr = tied(%$self);
    delete $OWNER{$ptr};
}

sub ACQUIRE {
    my $self = shift;
    my $ptr = tied(%$self);
    $OWNER{$ptr} = 1;
}


############# Class : chilkat::CkOAuth2 ##############

package chilkat::CkOAuth2;
use vars qw(@ISA %OWNER %ITERATORS %BLESSEDMEMBERS);
@ISA = qw( chilkat );
%OWNER = ();
%ITERATORS = ();
sub new {
    my $pkg = shift;
    my $self = chilkatc::new_CkOAuth2(@_);
    bless $self, $pkg if defined($self);
}

sub DESTROY {
    return unless $_[0]->isa('HASH');
    my $self = tied(%{$_[0]});
    return unless defined $self;
    delete $ITERATORS{$self};
    if (exists $OWNER{$self}) {
        chilkatc::delete_CkOAuth2($self);
        delete $OWNER{$self};
    }
}

*get_Utf8 = *chilkatc::CkOAuth2_get_Utf8;
*put_Utf8 = *chilkatc::CkOAuth2_put_Utf8;
*LastErrorXml = *chilkatc::CkOAuth2_LastErrorXml;
*LastErrorHtml = *chilkatc::CkOAuth2_LastErrorHtml;
*LastErrorText = *chilkatc::CkOAuth2_LastErrorText;
*put_EventCallbackObject = *chilkatc::CkOAuth2_put_EventCallbackObject;
*get_AccessToken = *chilkatc::CkOAuth2_get_AccessToken;
*accessToken = *chilkatc::CkOAuth2_accessToken;
*put_AccessToken = *chilkatc::CkOAuth2_put_AccessToken;
*get_AccessTokenResponse = *chilkatc::CkOAuth2_get_AccessTokenResponse;
*accessTokenResponse = *chilkatc::CkOAuth2_accessTokenResponse;
*get_AppCallbackUrl = *chilkatc::CkOAuth2_get_AppCallbackUrl;
*appCallbackUrl = *chilkatc::CkOAuth2_appCallbackUrl;
*put_AppCallbackUrl = *chilkatc::CkOAuth2_put_AppCallbackUrl;
*get_AuthFlowState = *chilkatc::CkOAuth2_get_AuthFlowState;
*get_AuthorizationEndpoint = *chilkatc::CkOAuth2_get_AuthorizationEndpoint;
*authorizationEndpoint = *chilkatc::CkOAuth2_authorizationEndpoint;
*put_AuthorizationEndpoint = *chilkatc::CkOAuth2_put_AuthorizationEndpoint;
*get_ClientId = *chilkatc::CkOAuth2_get_ClientId;
*clientId = *chilkatc::CkOAuth2_clientId;
*put_ClientId = *chilkatc::CkOAuth2_put_ClientId;
*get_ClientSecret = *chilkatc::CkOAuth2_get_ClientSecret;
*clientSecret = *chilkatc::CkOAuth2_clientSecret;
*put_ClientSecret = *chilkatc::CkOAuth2_put_ClientSecret;
*get_CodeChallenge = *chilkatc::CkOAuth2_get_CodeChallenge;
*put_CodeChallenge = *chilkatc::CkOAuth2_put_CodeChallenge;
*get_CodeChallengeMethod = *chilkatc::CkOAuth2_get_CodeChallengeMethod;
*codeChallengeMethod = *chilkatc::CkOAuth2_codeChallengeMethod;
*put_CodeChallengeMethod = *chilkatc::CkOAuth2_put_CodeChallengeMethod;
*get_DebugLogFilePath = *chilkatc::CkOAuth2_get_DebugLogFilePath;
*debugLogFilePath = *chilkatc::CkOAuth2_debugLogFilePath;
*put_DebugLogFilePath = *chilkatc::CkOAuth2_put_DebugLogFilePath;
*get_FailureInfo = *chilkatc::CkOAuth2_get_FailureInfo;
*failureInfo = *chilkatc::CkOAuth2_failureInfo;
*get_IncludeNonce = *chilkatc::CkOAuth2_get_IncludeNonce;
*put_IncludeNonce = *chilkatc::CkOAuth2_put_IncludeNonce;
*get_LastErrorHtml = *chilkatc::CkOAuth2_get_LastErrorHtml;
*lastErrorHtml = *chilkatc::CkOAuth2_lastErrorHtml;
*get_LastErrorText = *chilkatc::CkOAuth2_get_LastErrorText;
*lastErrorText = *chilkatc::CkOAuth2_lastErrorText;
*get_LastErrorXml = *chilkatc::CkOAuth2_get_LastErrorXml;
*lastErrorXml = *chilkatc::CkOAuth2_lastErrorXml;
*get_LastMethodSuccess = *chilkatc::CkOAuth2_get_LastMethodSuccess;
*put_LastMethodSuccess = *chilkatc::CkOAuth2_put_LastMethodSuccess;
*get_ListenPort = *chilkatc::CkOAuth2_get_ListenPort;
*put_ListenPort = *chilkatc::CkOAuth2_put_ListenPort;
*get_ListenPortRangeEnd = *chilkatc::CkOAuth2_get_ListenPortRangeEnd;
*put_ListenPortRangeEnd = *chilkatc::CkOAuth2_put_ListenPortRangeEnd;
*get_ListenPortSelected = *chilkatc::CkOAuth2_get_ListenPortSelected;
*get_LocalHost = *chilkatc::CkOAuth2_get_LocalHost;
*localHost = *chilkatc::CkOAuth2_localHost;
*put_LocalHost = *chilkatc::CkOAuth2_put_LocalHost;
*get_NonceLength = *chilkatc::CkOAuth2_get_NonceLength;
*put_NonceLength = *chilkatc::CkOAuth2_put_NonceLength;
*get_Oob = *chilkatc::CkOAuth2_get_Oob;
*put_Oob = *chilkatc::CkOAuth2_put_Oob;
*get_RedirectAllowHtml = *chilkatc::CkOAuth2_get_RedirectAllowHtml;
*redirectAllowHtml = *chilkatc::CkOAuth2_redirectAllowHtml;
*put_RedirectAllowHtml = *chilkatc::CkOAuth2_put_RedirectAllowHtml;
*get_RedirectDenyHtml = *chilkatc::CkOAuth2_get_RedirectDenyHtml;
*redirectDenyHtml = *chilkatc::CkOAuth2_redirectDenyHtml;
*put_RedirectDenyHtml = *chilkatc::CkOAuth2_put_RedirectDenyHtml;
*get_RedirectReqReceived = *chilkatc::CkOAuth2_get_RedirectReqReceived;
*redirectReqReceived = *chilkatc::CkOAuth2_redirectReqReceived;
*get_RefreshToken = *chilkatc::CkOAuth2_get_RefreshToken;
*refreshToken = *chilkatc::CkOAuth2_refreshToken;
*put_RefreshToken = *chilkatc::CkOAuth2_put_RefreshToken;
*get_Resource = *chilkatc::CkOAuth2_get_Resource;
*resource = *chilkatc::CkOAuth2_resource;
*put_Resource = *chilkatc::CkOAuth2_put_Resource;
*get_ResponseMode = *chilkatc::CkOAuth2_get_ResponseMode;
*responseMode = *chilkatc::CkOAuth2_responseMode;
*put_ResponseMode = *chilkatc::CkOAuth2_put_ResponseMode;
*get_ResponseType = *chilkatc::CkOAuth2_get_ResponseType;
*responseType = *chilkatc::CkOAuth2_responseType;
*put_ResponseType = *chilkatc::CkOAuth2_put_ResponseType;
*get_Scope = *chilkatc::CkOAuth2_get_Scope;
*scope = *chilkatc::CkOAuth2_scope;
*put_Scope = *chilkatc::CkOAuth2_put_Scope;
*get_StateParam = *chilkatc::CkOAuth2_get_StateParam;
*stateParam = *chilkatc::CkOAuth2_stateParam;
*put_StateParam = *chilkatc::CkOAuth2_put_StateParam;
*get_TokenEndpoint = *chilkatc::CkOAuth2_get_TokenEndpoint;
*tokenEndpoint = *chilkatc::CkOAuth2_tokenEndpoint;
*put_TokenEndpoint = *chilkatc::CkOAuth2_put_TokenEndpoint;
*get_TokenType = *chilkatc::CkOAuth2_get_TokenType;
*tokenType = *chilkatc::CkOAuth2_tokenType;
*put_TokenType = *chilkatc::CkOAuth2_put_TokenType;
*get_UncommonOptions = *chilkatc::CkOAuth2_get_UncommonOptions;
*uncommonOptions = *chilkatc::CkOAuth2_uncommonOptions;
*put_UncommonOptions = *chilkatc::CkOAuth2_put_UncommonOptions;
*get_UseBasicAuth = *chilkatc::CkOAuth2_get_UseBasicAuth;
*put_UseBasicAuth = *chilkatc::CkOAuth2_put_UseBasicAuth;
*get_VerboseLogging = *chilkatc::CkOAuth2_get_VerboseLogging;
*put_VerboseLogging = *chilkatc::CkOAuth2_put_VerboseLogging;
*get_Version = *chilkatc::CkOAuth2_get_Version;
*version = *chilkatc::CkOAuth2_version;
*AddAuthQueryParam = *chilkatc::CkOAuth2_AddAuthQueryParam;
*AddRefreshQueryParam = *chilkatc::CkOAuth2_AddRefreshQueryParam;
*AddTokenQueryParam = *chilkatc::CkOAuth2_AddTokenQueryParam;
*Cancel = *chilkatc::CkOAuth2_Cancel;
*ExchangeCodeForToken = *chilkatc::CkOAuth2_ExchangeCodeForToken;
*ExchangeCodeForTokenAsync = *chilkatc::CkOAuth2_ExchangeCodeForTokenAsync;
*GetAccessTokenResponseSb = *chilkatc::CkOAuth2_GetAccessTokenResponseSb;
*GetRedirectRequestParam = *chilkatc::CkOAuth2_GetRedirectRequestParam;
*getRedirectRequestParam = *chilkatc::CkOAuth2_getRedirectRequestParam;
*redirectRequestParam = *chilkatc::CkOAuth2_redirectRequestParam;
*LaunchBrowser = *chilkatc::CkOAuth2_LaunchBrowser;
*LoadTaskCaller = *chilkatc::CkOAuth2_LoadTaskCaller;
*RefreshAccessToken = *chilkatc::CkOAuth2_RefreshAccessToken;
*RefreshAccessTokenAsync = *chilkatc::CkOAuth2_RefreshAccessTokenAsync;
*SetRefreshHeader = *chilkatc::CkOAuth2_SetRefreshHeader;
*SleepMs = *chilkatc::CkOAuth2_SleepMs;
*StartAuth = *chilkatc::CkOAuth2_StartAuth;
*startAuth = *chilkatc::CkOAuth2_startAuth;
*UseConnection = *chilkatc::CkOAuth2_UseConnection;
sub DISOWN {
    my $self = shift;
    my $ptr = tied(%$self);
    delete $OWNER{$ptr};
}

sub ACQUIRE {
    my $self = shift;
    my $ptr = tied(%$self);
    $OWNER{$ptr} = 1;
}


############# Class : chilkat::CkPdf ##############

package chilkat::CkPdf;
use vars qw(@ISA %OWNER %ITERATORS %BLESSEDMEMBERS);
@ISA = qw( chilkat );
%OWNER = ();
%ITERATORS = ();
sub new {
    my $pkg = shift;
    my $self = chilkatc::new_CkPdf(@_);
    bless $self, $pkg if defined($self);
}

sub DESTROY {
    return unless $_[0]->isa('HASH');
    my $self = tied(%{$_[0]});
    return unless defined $self;
    delete $ITERATORS{$self};
    if (exists $OWNER{$self}) {
        chilkatc::delete_CkPdf($self);
        delete $OWNER{$self};
    }
}

*get_Utf8 = *chilkatc::CkPdf_get_Utf8;
*put_Utf8 = *chilkatc::CkPdf_put_Utf8;
*LastErrorXml = *chilkatc::CkPdf_LastErrorXml;
*LastErrorHtml = *chilkatc::CkPdf_LastErrorHtml;
*LastErrorText = *chilkatc::CkPdf_LastErrorText;
*put_EventCallbackObject = *chilkatc::CkPdf_put_EventCallbackObject;
*get_DebugLogFilePath = *chilkatc::CkPdf_get_DebugLogFilePath;
*debugLogFilePath = *chilkatc::CkPdf_debugLogFilePath;
*put_DebugLogFilePath = *chilkatc::CkPdf_put_DebugLogFilePath;
*get_HasCertificationSig = *chilkatc::CkPdf_get_HasCertificationSig;
*get_LastErrorHtml = *chilkatc::CkPdf_get_LastErrorHtml;
*lastErrorHtml = *chilkatc::CkPdf_lastErrorHtml;
*get_LastErrorText = *chilkatc::CkPdf_get_LastErrorText;
*lastErrorText = *chilkatc::CkPdf_lastErrorText;
*get_LastErrorXml = *chilkatc::CkPdf_get_LastErrorXml;
*lastErrorXml = *chilkatc::CkPdf_lastErrorXml;
*get_LastMethodSuccess = *chilkatc::CkPdf_get_LastMethodSuccess;
*put_LastMethodSuccess = *chilkatc::CkPdf_put_LastMethodSuccess;
*get_NumEmbeddedFiles = *chilkatc::CkPdf_get_NumEmbeddedFiles;
*get_NumPages = *chilkatc::CkPdf_get_NumPages;
*get_NumSignatures = *chilkatc::CkPdf_get_NumSignatures;
*get_OwnerPassword = *chilkatc::CkPdf_get_OwnerPassword;
*ownerPassword = *chilkatc::CkPdf_ownerPassword;
*put_OwnerPassword = *chilkatc::CkPdf_put_OwnerPassword;
*get_SigAllocateSize = *chilkatc::CkPdf_get_SigAllocateSize;
*put_SigAllocateSize = *chilkatc::CkPdf_put_SigAllocateSize;
*get_UncommonOptions = *chilkatc::CkPdf_get_UncommonOptions;
*uncommonOptions = *chilkatc::CkPdf_uncommonOptions;
*put_UncommonOptions = *chilkatc::CkPdf_put_UncommonOptions;
*get_UserPassword = *chilkatc::CkPdf_get_UserPassword;
*userPassword = *chilkatc::CkPdf_userPassword;
*put_UserPassword = *chilkatc::CkPdf_put_UserPassword;
*get_VerboseLogging = *chilkatc::CkPdf_get_VerboseLogging;
*put_VerboseLogging = *chilkatc::CkPdf_put_VerboseLogging;
*get_Version = *chilkatc::CkPdf_get_Version;
*version = *chilkatc::CkPdf_version;
*AddEmbeddedFiles = *chilkatc::CkPdf_AddEmbeddedFiles;
*AddEmbeddedFilesBd = *chilkatc::CkPdf_AddEmbeddedFilesBd;
*AddSigningCert = *chilkatc::CkPdf_AddSigningCert;
*AddVerificationInfo = *chilkatc::CkPdf_AddVerificationInfo;
*AddVerificationInfoAsync = *chilkatc::CkPdf_AddVerificationInfoAsync;
*GetDss = *chilkatc::CkPdf_GetDss;
*GetEmbeddedFileBd = *chilkatc::CkPdf_GetEmbeddedFileBd;
*GetEmbeddedFileInfo = *chilkatc::CkPdf_GetEmbeddedFileInfo;
*GetLastJsonData = *chilkatc::CkPdf_GetLastJsonData;
*GetMetadata = *chilkatc::CkPdf_GetMetadata;
*GetSignatureContent = *chilkatc::CkPdf_GetSignatureContent;
*GetSignerCert = *chilkatc::CkPdf_GetSignerCert;
*GetUnsignedSigFields = *chilkatc::CkPdf_GetUnsignedSigFields;
*LastJsonData = *chilkatc::CkPdf_LastJsonData;
*LoadBd = *chilkatc::CkPdf_LoadBd;
*LoadFile = *chilkatc::CkPdf_LoadFile;
*SetHttpObj = *chilkatc::CkPdf_SetHttpObj;
*SetSignatureJpeg = *chilkatc::CkPdf_SetSignatureJpeg;
*SetSigningCert = *chilkatc::CkPdf_SetSigningCert;
*SetSigningCert2 = *chilkatc::CkPdf_SetSigningCert2;
*SignPdf = *chilkatc::CkPdf_SignPdf;
*SignPdfAsync = *chilkatc::CkPdf_SignPdfAsync;
*SignPdfBd = *chilkatc::CkPdf_SignPdfBd;
*SignPdfBdAsync = *chilkatc::CkPdf_SignPdfBdAsync;
*UpdateMetadata = *chilkatc::CkPdf_UpdateMetadata;
*UpdateMetadataBd = *chilkatc::CkPdf_UpdateMetadataBd;
*VerifySignature = *chilkatc::CkPdf_VerifySignature;
sub DISOWN {
    my $self = shift;
    my $ptr = tied(%$self);
    delete $OWNER{$ptr};
}

sub ACQUIRE {
    my $self = shift;
    my $ptr = tied(%$self);
    $OWNER{$ptr} = 1;
}


############# Class : chilkat::CkPem ##############

package chilkat::CkPem;
use vars qw(@ISA %OWNER %ITERATORS %BLESSEDMEMBERS);
@ISA = qw( chilkat );
%OWNER = ();
%ITERATORS = ();
sub new {
    my $pkg = shift;
    my $self = chilkatc::new_CkPem(@_);
    bless $self, $pkg if defined($self);
}

sub DESTROY {
    return unless $_[0]->isa('HASH');
    my $self = tied(%{$_[0]});
    return unless defined $self;
    delete $ITERATORS{$self};
    if (exists $OWNER{$self}) {
        chilkatc::delete_CkPem($self);
        delete $OWNER{$self};
    }
}

*get_Utf8 = *chilkatc::CkPem_get_Utf8;
*put_Utf8 = *chilkatc::CkPem_put_Utf8;
*LastErrorXml = *chilkatc::CkPem_LastErrorXml;
*LastErrorHtml = *chilkatc::CkPem_LastErrorHtml;
*LastErrorText = *chilkatc::CkPem_LastErrorText;
*get_AppendMode = *chilkatc::CkPem_get_AppendMode;
*put_AppendMode = *chilkatc::CkPem_put_AppendMode;
*get_DebugLogFilePath = *chilkatc::CkPem_get_DebugLogFilePath;
*debugLogFilePath = *chilkatc::CkPem_debugLogFilePath;
*put_DebugLogFilePath = *chilkatc::CkPem_put_DebugLogFilePath;
*get_HeartbeatMs = *chilkatc::CkPem_get_HeartbeatMs;
*put_HeartbeatMs = *chilkatc::CkPem_put_HeartbeatMs;
*get_LastErrorHtml = *chilkatc::CkPem_get_LastErrorHtml;
*lastErrorHtml = *chilkatc::CkPem_lastErrorHtml;
*get_LastErrorText = *chilkatc::CkPem_get_LastErrorText;
*lastErrorText = *chilkatc::CkPem_lastErrorText;
*get_LastErrorXml = *chilkatc::CkPem_get_LastErrorXml;
*lastErrorXml = *chilkatc::CkPem_lastErrorXml;
*get_LastMethodSuccess = *chilkatc::CkPem_get_LastMethodSuccess;
*put_LastMethodSuccess = *chilkatc::CkPem_put_LastMethodSuccess;
*get_NumCerts = *chilkatc::CkPem_get_NumCerts;
*get_NumCrls = *chilkatc::CkPem_get_NumCrls;
*get_NumCsrs = *chilkatc::CkPem_get_NumCsrs;
*get_NumPrivateKeys = *chilkatc::CkPem_get_NumPrivateKeys;
*get_NumPublicKeys = *chilkatc::CkPem_get_NumPublicKeys;
*get_PrivateKeyFormat = *chilkatc::CkPem_get_PrivateKeyFormat;
*privateKeyFormat = *chilkatc::CkPem_privateKeyFormat;
*put_PrivateKeyFormat = *chilkatc::CkPem_put_PrivateKeyFormat;
*get_PublicKeyFormat = *chilkatc::CkPem_get_PublicKeyFormat;
*publicKeyFormat = *chilkatc::CkPem_publicKeyFormat;
*put_PublicKeyFormat = *chilkatc::CkPem_put_PublicKeyFormat;
*get_VerboseLogging = *chilkatc::CkPem_get_VerboseLogging;
*put_VerboseLogging = *chilkatc::CkPem_put_VerboseLogging;
*get_Version = *chilkatc::CkPem_get_Version;
*version = *chilkatc::CkPem_version;
*AddCert = *chilkatc::CkPem_AddCert;
*AddItem = *chilkatc::CkPem_AddItem;
*AddP7b = *chilkatc::CkPem_AddP7b;
*AddPrivateKey = *chilkatc::CkPem_AddPrivateKey;
*AddPrivateKey2 = *chilkatc::CkPem_AddPrivateKey2;
*AddPublicKey = *chilkatc::CkPem_AddPublicKey;
*CertAt = *chilkatc::CkPem_CertAt;
*Clear = *chilkatc::CkPem_Clear;
*GetCert = *chilkatc::CkPem_GetCert;
*GetEncodedItem = *chilkatc::CkPem_GetEncodedItem;
*getEncodedItem = *chilkatc::CkPem_getEncodedItem;
*encodedItem = *chilkatc::CkPem_encodedItem;
*GetPrivateKey = *chilkatc::CkPem_GetPrivateKey;
*GetPublicKey = *chilkatc::CkPem_GetPublicKey;
*LoadP7b = *chilkatc::CkPem_LoadP7b;
*LoadP7bFile = *chilkatc::CkPem_LoadP7bFile;
*LoadPem = *chilkatc::CkPem_LoadPem;
*LoadPemFile = *chilkatc::CkPem_LoadPemFile;
*LoadTaskCaller = *chilkatc::CkPem_LoadTaskCaller;
*PrivateKeyAt = *chilkatc::CkPem_PrivateKeyAt;
*PublicKeyAt = *chilkatc::CkPem_PublicKeyAt;
*RemoveCert = *chilkatc::CkPem_RemoveCert;
*RemovePrivateKey = *chilkatc::CkPem_RemovePrivateKey;
*ToJks = *chilkatc::CkPem_ToJks;
*ToJksObj = *chilkatc::CkPem_ToJksObj;
*ToPem = *chilkatc::CkPem_ToPem;
*toPem = *chilkatc::CkPem_toPem;
*ToPemEx = *chilkatc::CkPem_ToPemEx;
*toPemEx = *chilkatc::CkPem_toPemEx;
*ToPfx = *chilkatc::CkPem_ToPfx;
*ToPfxObj = *chilkatc::CkPem_ToPfxObj;
sub DISOWN {
    my $self = shift;
    my $ptr = tied(%$self);
    delete $OWNER{$ptr};
}

sub ACQUIRE {
    my $self = shift;
    my $ptr = tied(%$self);
    $OWNER{$ptr} = 1;
}


############# Class : chilkat::CkPfx ##############

package chilkat::CkPfx;
use vars qw(@ISA %OWNER %ITERATORS %BLESSEDMEMBERS);
@ISA = qw( chilkat );
%OWNER = ();
%ITERATORS = ();
sub new {
    my $pkg = shift;
    my $self = chilkatc::new_CkPfx(@_);
    bless $self, $pkg if defined($self);
}

sub DESTROY {
    return unless $_[0]->isa('HASH');
    my $self = tied(%{$_[0]});
    return unless defined $self;
    delete $ITERATORS{$self};
    if (exists $OWNER{$self}) {
        chilkatc::delete_CkPfx($self);
        delete $OWNER{$self};
    }
}

*get_Utf8 = *chilkatc::CkPfx_get_Utf8;
*put_Utf8 = *chilkatc::CkPfx_put_Utf8;
*LastErrorXml = *chilkatc::CkPfx_LastErrorXml;
*LastErrorHtml = *chilkatc::CkPfx_LastErrorHtml;
*LastErrorText = *chilkatc::CkPfx_LastErrorText;
*get_AlgorithmId = *chilkatc::CkPfx_get_AlgorithmId;
*algorithmId = *chilkatc::CkPfx_algorithmId;
*put_AlgorithmId = *chilkatc::CkPfx_put_AlgorithmId;
*get_DebugLogFilePath = *chilkatc::CkPfx_get_DebugLogFilePath;
*debugLogFilePath = *chilkatc::CkPfx_debugLogFilePath;
*put_DebugLogFilePath = *chilkatc::CkPfx_put_DebugLogFilePath;
*get_LastErrorHtml = *chilkatc::CkPfx_get_LastErrorHtml;
*lastErrorHtml = *chilkatc::CkPfx_lastErrorHtml;
*get_LastErrorText = *chilkatc::CkPfx_get_LastErrorText;
*lastErrorText = *chilkatc::CkPfx_lastErrorText;
*get_LastErrorXml = *chilkatc::CkPfx_get_LastErrorXml;
*lastErrorXml = *chilkatc::CkPfx_lastErrorXml;
*get_LastMethodSuccess = *chilkatc::CkPfx_get_LastMethodSuccess;
*put_LastMethodSuccess = *chilkatc::CkPfx_put_LastMethodSuccess;
*get_NumCerts = *chilkatc::CkPfx_get_NumCerts;
*get_NumPrivateKeys = *chilkatc::CkPfx_get_NumPrivateKeys;
*get_Pbes2CryptAlg = *chilkatc::CkPfx_get_Pbes2CryptAlg;
*pbes2CryptAlg = *chilkatc::CkPfx_pbes2CryptAlg;
*put_Pbes2CryptAlg = *chilkatc::CkPfx_put_Pbes2CryptAlg;
*get_Pbes2HmacAlg = *chilkatc::CkPfx_get_Pbes2HmacAlg;
*pbes2HmacAlg = *chilkatc::CkPfx_pbes2HmacAlg;
*put_Pbes2HmacAlg = *chilkatc::CkPfx_put_Pbes2HmacAlg;
*get_UncommonOptions = *chilkatc::CkPfx_get_UncommonOptions;
*uncommonOptions = *chilkatc::CkPfx_uncommonOptions;
*put_UncommonOptions = *chilkatc::CkPfx_put_UncommonOptions;
*get_VerboseLogging = *chilkatc::CkPfx_get_VerboseLogging;
*put_VerboseLogging = *chilkatc::CkPfx_put_VerboseLogging;
*get_Version = *chilkatc::CkPfx_get_Version;
*version = *chilkatc::CkPfx_version;
*AddCert = *chilkatc::CkPfx_AddCert;
*AddPrivateKey = *chilkatc::CkPfx_AddPrivateKey;
*CertAt = *chilkatc::CkPfx_CertAt;
*CertByLocalKeyId = *chilkatc::CkPfx_CertByLocalKeyId;
*FindCertByLocalKeyId = *chilkatc::CkPfx_FindCertByLocalKeyId;
*GetCert = *chilkatc::CkPfx_GetCert;
*GetLastJsonData = *chilkatc::CkPfx_GetLastJsonData;
*GetPrivateKey = *chilkatc::CkPfx_GetPrivateKey;
*GetSafeBagAttr = *chilkatc::CkPfx_GetSafeBagAttr;
*getSafeBagAttr = *chilkatc::CkPfx_getSafeBagAttr;
*safeBagAttr = *chilkatc::CkPfx_safeBagAttr;
*ImportToKeychain = *chilkatc::CkPfx_ImportToKeychain;
*ImportToWindows = *chilkatc::CkPfx_ImportToWindows;
*LastJsonData = *chilkatc::CkPfx_LastJsonData;
*LoadPem = *chilkatc::CkPfx_LoadPem;
*LoadPfxBd = *chilkatc::CkPfx_LoadPfxBd;
*LoadPfxBytes = *chilkatc::CkPfx_LoadPfxBytes;
*LoadPfxEncoded = *chilkatc::CkPfx_LoadPfxEncoded;
*LoadPfxFile = *chilkatc::CkPfx_LoadPfxFile;
*PrivateKeyAt = *chilkatc::CkPfx_PrivateKeyAt;
*SetSafeBagAttr = *chilkatc::CkPfx_SetSafeBagAttr;
*ToBd = *chilkatc::CkPfx_ToBd;
*ToBinary = *chilkatc::CkPfx_ToBinary;
*ToEncodedString = *chilkatc::CkPfx_ToEncodedString;
*toEncodedString = *chilkatc::CkPfx_toEncodedString;
*ToFile = *chilkatc::CkPfx_ToFile;
*ToJavaKeyStore = *chilkatc::CkPfx_ToJavaKeyStore;
*ToJksObj = *chilkatc::CkPfx_ToJksObj;
*ToPem = *chilkatc::CkPfx_ToPem;
*toPem = *chilkatc::CkPfx_toPem;
*ToPemEx = *chilkatc::CkPfx_ToPemEx;
*toPemEx = *chilkatc::CkPfx_toPemEx;
*UseCertVault = *chilkatc::CkPfx_UseCertVault;
sub DISOWN {
    my $self = shift;
    my $ptr = tied(%$self);
    delete $OWNER{$ptr};
}

sub ACQUIRE {
    my $self = shift;
    my $ptr = tied(%$self);
    $OWNER{$ptr} = 1;
}


############# Class : chilkat::CkPkcs11 ##############

package chilkat::CkPkcs11;
use vars qw(@ISA %OWNER %ITERATORS %BLESSEDMEMBERS);
@ISA = qw( chilkat );
%OWNER = ();
%ITERATORS = ();
sub new {
    my $pkg = shift;
    my $self = chilkatc::new_CkPkcs11(@_);
    bless $self, $pkg if defined($self);
}

sub DESTROY {
    return unless $_[0]->isa('HASH');
    my $self = tied(%{$_[0]});
    return unless defined $self;
    delete $ITERATORS{$self};
    if (exists $OWNER{$self}) {
        chilkatc::delete_CkPkcs11($self);
        delete $OWNER{$self};
    }
}

*get_Utf8 = *chilkatc::CkPkcs11_get_Utf8;
*put_Utf8 = *chilkatc::CkPkcs11_put_Utf8;
*LastErrorXml = *chilkatc::CkPkcs11_LastErrorXml;
*LastErrorHtml = *chilkatc::CkPkcs11_LastErrorHtml;
*LastErrorText = *chilkatc::CkPkcs11_LastErrorText;
*get_DebugLogFilePath = *chilkatc::CkPkcs11_get_DebugLogFilePath;
*debugLogFilePath = *chilkatc::CkPkcs11_debugLogFilePath;
*put_DebugLogFilePath = *chilkatc::CkPkcs11_put_DebugLogFilePath;
*get_LastErrorHtml = *chilkatc::CkPkcs11_get_LastErrorHtml;
*lastErrorHtml = *chilkatc::CkPkcs11_lastErrorHtml;
*get_LastErrorText = *chilkatc::CkPkcs11_get_LastErrorText;
*lastErrorText = *chilkatc::CkPkcs11_lastErrorText;
*get_LastErrorXml = *chilkatc::CkPkcs11_get_LastErrorXml;
*lastErrorXml = *chilkatc::CkPkcs11_lastErrorXml;
*get_LastMethodSuccess = *chilkatc::CkPkcs11_get_LastMethodSuccess;
*put_LastMethodSuccess = *chilkatc::CkPkcs11_put_LastMethodSuccess;
*get_NumCerts = *chilkatc::CkPkcs11_get_NumCerts;
*get_SharedLibPath = *chilkatc::CkPkcs11_get_SharedLibPath;
*sharedLibPath = *chilkatc::CkPkcs11_sharedLibPath;
*put_SharedLibPath = *chilkatc::CkPkcs11_put_SharedLibPath;
*get_SigContextPin = *chilkatc::CkPkcs11_get_SigContextPin;
*sigContextPin = *chilkatc::CkPkcs11_sigContextPin;
*put_SigContextPin = *chilkatc::CkPkcs11_put_SigContextPin;
*get_UncommonOptions = *chilkatc::CkPkcs11_get_UncommonOptions;
*uncommonOptions = *chilkatc::CkPkcs11_uncommonOptions;
*put_UncommonOptions = *chilkatc::CkPkcs11_put_UncommonOptions;
*get_VerboseLogging = *chilkatc::CkPkcs11_get_VerboseLogging;
*put_VerboseLogging = *chilkatc::CkPkcs11_put_VerboseLogging;
*get_Version = *chilkatc::CkPkcs11_get_Version;
*version = *chilkatc::CkPkcs11_version;
*CloseSession = *chilkatc::CkPkcs11_CloseSession;
*CreatePkcs11Object = *chilkatc::CkPkcs11_CreatePkcs11Object;
*DestroyObject = *chilkatc::CkPkcs11_DestroyObject;
*Discover = *chilkatc::CkPkcs11_Discover;
*ExportPublicKey = *chilkatc::CkPkcs11_ExportPublicKey;
*FindAllCerts = *chilkatc::CkPkcs11_FindAllCerts;
*FindAllKeys = *chilkatc::CkPkcs11_FindAllKeys;
*FindCert = *chilkatc::CkPkcs11_FindCert;
*FindObject = *chilkatc::CkPkcs11_FindObject;
*GenEcKey = *chilkatc::CkPkcs11_GenEcKey;
*GenRsaKey = *chilkatc::CkPkcs11_GenRsaKey;
*GenSecretKey = *chilkatc::CkPkcs11_GenSecretKey;
*GetCert = *chilkatc::CkPkcs11_GetCert;
*ImportPrivateKey = *chilkatc::CkPkcs11_ImportPrivateKey;
*ImportSshKey = *chilkatc::CkPkcs11_ImportSshKey;
*Initialize = *chilkatc::CkPkcs11_Initialize;
*InitPin = *chilkatc::CkPkcs11_InitPin;
*InitToken = *chilkatc::CkPkcs11_InitToken;
*Login = *chilkatc::CkPkcs11_Login;
*Logout = *chilkatc::CkPkcs11_Logout;
*OpenSession = *chilkatc::CkPkcs11_OpenSession;
*QuickSession = *chilkatc::CkPkcs11_QuickSession;
*SetPin = *chilkatc::CkPkcs11_SetPin;
sub DISOWN {
    my $self = shift;
    my $ptr = tied(%$self);
    delete $OWNER{$ptr};
}

sub ACQUIRE {
    my $self = shift;
    my $ptr = tied(%$self);
    $OWNER{$ptr} = 1;
}


############# Class : chilkat::CkPrivateKey ##############

package chilkat::CkPrivateKey;
use vars qw(@ISA %OWNER %ITERATORS %BLESSEDMEMBERS);
@ISA = qw( chilkat );
%OWNER = ();
%ITERATORS = ();
sub new {
    my $pkg = shift;
    my $self = chilkatc::new_CkPrivateKey(@_);
    bless $self, $pkg if defined($self);
}

sub DESTROY {
    return unless $_[0]->isa('HASH');
    my $self = tied(%{$_[0]});
    return unless defined $self;
    delete $ITERATORS{$self};
    if (exists $OWNER{$self}) {
        chilkatc::delete_CkPrivateKey($self);
        delete $OWNER{$self};
    }
}

*get_Utf8 = *chilkatc::CkPrivateKey_get_Utf8;
*put_Utf8 = *chilkatc::CkPrivateKey_put_Utf8;
*LastErrorXml = *chilkatc::CkPrivateKey_LastErrorXml;
*LastErrorHtml = *chilkatc::CkPrivateKey_LastErrorHtml;
*LastErrorText = *chilkatc::CkPrivateKey_LastErrorText;
*put_EventCallbackObject = *chilkatc::CkPrivateKey_put_EventCallbackObject;
*get_BitLength = *chilkatc::CkPrivateKey_get_BitLength;
*get_DebugLogFilePath = *chilkatc::CkPrivateKey_get_DebugLogFilePath;
*debugLogFilePath = *chilkatc::CkPrivateKey_debugLogFilePath;
*put_DebugLogFilePath = *chilkatc::CkPrivateKey_put_DebugLogFilePath;
*get_KeyType = *chilkatc::CkPrivateKey_get_KeyType;
*keyType = *chilkatc::CkPrivateKey_keyType;
*get_LastErrorHtml = *chilkatc::CkPrivateKey_get_LastErrorHtml;
*lastErrorHtml = *chilkatc::CkPrivateKey_lastErrorHtml;
*get_LastErrorText = *chilkatc::CkPrivateKey_get_LastErrorText;
*lastErrorText = *chilkatc::CkPrivateKey_lastErrorText;
*get_LastErrorXml = *chilkatc::CkPrivateKey_get_LastErrorXml;
*lastErrorXml = *chilkatc::CkPrivateKey_lastErrorXml;
*get_LastMethodSuccess = *chilkatc::CkPrivateKey_get_LastMethodSuccess;
*put_LastMethodSuccess = *chilkatc::CkPrivateKey_put_LastMethodSuccess;
*get_Pkcs8EncryptAlg = *chilkatc::CkPrivateKey_get_Pkcs8EncryptAlg;
*pkcs8EncryptAlg = *chilkatc::CkPrivateKey_pkcs8EncryptAlg;
*put_Pkcs8EncryptAlg = *chilkatc::CkPrivateKey_put_Pkcs8EncryptAlg;
*get_UncommonOptions = *chilkatc::CkPrivateKey_get_UncommonOptions;
*uncommonOptions = *chilkatc::CkPrivateKey_uncommonOptions;
*put_UncommonOptions = *chilkatc::CkPrivateKey_put_UncommonOptions;
*get_VerboseLogging = *chilkatc::CkPrivateKey_get_VerboseLogging;
*put_VerboseLogging = *chilkatc::CkPrivateKey_put_VerboseLogging;
*get_Version = *chilkatc::CkPrivateKey_get_Version;
*version = *chilkatc::CkPrivateKey_version;
*GetJwk = *chilkatc::CkPrivateKey_GetJwk;
*getJwk = *chilkatc::CkPrivateKey_getJwk;
*jwk = *chilkatc::CkPrivateKey_jwk;
*GetJwkThumbprint = *chilkatc::CkPrivateKey_GetJwkThumbprint;
*getJwkThumbprint = *chilkatc::CkPrivateKey_getJwkThumbprint;
*jwkThumbprint = *chilkatc::CkPrivateKey_jwkThumbprint;
*GetPkcs1 = *chilkatc::CkPrivateKey_GetPkcs1;
*GetPkcs1ENC = *chilkatc::CkPrivateKey_GetPkcs1ENC;
*getPkcs1ENC = *chilkatc::CkPrivateKey_getPkcs1ENC;
*pkcs1ENC = *chilkatc::CkPrivateKey_pkcs1ENC;
*GetPkcs1Pem = *chilkatc::CkPrivateKey_GetPkcs1Pem;
*getPkcs1Pem = *chilkatc::CkPrivateKey_getPkcs1Pem;
*pkcs1Pem = *chilkatc::CkPrivateKey_pkcs1Pem;
*GetPkcs8 = *chilkatc::CkPrivateKey_GetPkcs8;
*GetPkcs8ENC = *chilkatc::CkPrivateKey_GetPkcs8ENC;
*getPkcs8ENC = *chilkatc::CkPrivateKey_getPkcs8ENC;
*pkcs8ENC = *chilkatc::CkPrivateKey_pkcs8ENC;
*GetPkcs8Encrypted = *chilkatc::CkPrivateKey_GetPkcs8Encrypted;
*GetPkcs8EncryptedENC = *chilkatc::CkPrivateKey_GetPkcs8EncryptedENC;
*getPkcs8EncryptedENC = *chilkatc::CkPrivateKey_getPkcs8EncryptedENC;
*pkcs8EncryptedENC = *chilkatc::CkPrivateKey_pkcs8EncryptedENC;
*GetPkcs8EncryptedPem = *chilkatc::CkPrivateKey_GetPkcs8EncryptedPem;
*getPkcs8EncryptedPem = *chilkatc::CkPrivateKey_getPkcs8EncryptedPem;
*pkcs8EncryptedPem = *chilkatc::CkPrivateKey_pkcs8EncryptedPem;
*GetPkcs8Pem = *chilkatc::CkPrivateKey_GetPkcs8Pem;
*getPkcs8Pem = *chilkatc::CkPrivateKey_getPkcs8Pem;
*pkcs8Pem = *chilkatc::CkPrivateKey_pkcs8Pem;
*GetPkcsBd = *chilkatc::CkPrivateKey_GetPkcsBd;
*GetPublicKey = *chilkatc::CkPrivateKey_GetPublicKey;
*GetRawHex = *chilkatc::CkPrivateKey_GetRawHex;
*getRawHex = *chilkatc::CkPrivateKey_getRawHex;
*rawHex = *chilkatc::CkPrivateKey_rawHex;
*GetXml = *chilkatc::CkPrivateKey_GetXml;
*getXml = *chilkatc::CkPrivateKey_getXml;
*xml = *chilkatc::CkPrivateKey_xml;
*LoadAnyFormat = *chilkatc::CkPrivateKey_LoadAnyFormat;
*LoadAnyFormatFile = *chilkatc::CkPrivateKey_LoadAnyFormatFile;
*LoadEd25519 = *chilkatc::CkPrivateKey_LoadEd25519;
*LoadEncryptedPem = *chilkatc::CkPrivateKey_LoadEncryptedPem;
*LoadEncryptedPemFile = *chilkatc::CkPrivateKey_LoadEncryptedPemFile;
*LoadJwk = *chilkatc::CkPrivateKey_LoadJwk;
*LoadPem = *chilkatc::CkPrivateKey_LoadPem;
*LoadPemFile = *chilkatc::CkPrivateKey_LoadPemFile;
*LoadPkcs1 = *chilkatc::CkPrivateKey_LoadPkcs1;
*LoadPkcs1File = *chilkatc::CkPrivateKey_LoadPkcs1File;
*LoadPkcs8 = *chilkatc::CkPrivateKey_LoadPkcs8;
*LoadPkcs8Encrypted = *chilkatc::CkPrivateKey_LoadPkcs8Encrypted;
*LoadPkcs8EncryptedFile = *chilkatc::CkPrivateKey_LoadPkcs8EncryptedFile;
*LoadPkcs8File = *chilkatc::CkPrivateKey_LoadPkcs8File;
*LoadPvk = *chilkatc::CkPrivateKey_LoadPvk;
*LoadPvkFile = *chilkatc::CkPrivateKey_LoadPvkFile;
*LoadXml = *chilkatc::CkPrivateKey_LoadXml;
*LoadXmlFile = *chilkatc::CkPrivateKey_LoadXmlFile;
*SavePemFile = *chilkatc::CkPrivateKey_SavePemFile;
*SavePkcs1File = *chilkatc::CkPrivateKey_SavePkcs1File;
*SavePkcs8EncryptedFile = *chilkatc::CkPrivateKey_SavePkcs8EncryptedFile;
*SavePkcs8EncryptedPemFile = *chilkatc::CkPrivateKey_SavePkcs8EncryptedPemFile;
*SavePkcs8File = *chilkatc::CkPrivateKey_SavePkcs8File;
*SavePkcs8PemFile = *chilkatc::CkPrivateKey_SavePkcs8PemFile;
*SaveXmlFile = *chilkatc::CkPrivateKey_SaveXmlFile;
*ToPublicKey = *chilkatc::CkPrivateKey_ToPublicKey;
*UploadToCloud = *chilkatc::CkPrivateKey_UploadToCloud;
*UploadToCloudAsync = *chilkatc::CkPrivateKey_UploadToCloudAsync;
sub DISOWN {
    my $self = shift;
    my $ptr = tied(%$self);
    delete $OWNER{$ptr};
}

sub ACQUIRE {
    my $self = shift;
    my $ptr = tied(%$self);
    $OWNER{$ptr} = 1;
}


############# Class : chilkat::CkPrng ##############

package chilkat::CkPrng;
use vars qw(@ISA %OWNER %ITERATORS %BLESSEDMEMBERS);
@ISA = qw( chilkat );
%OWNER = ();
%ITERATORS = ();
sub new {
    my $pkg = shift;
    my $self = chilkatc::new_CkPrng(@_);
    bless $self, $pkg if defined($self);
}

sub DESTROY {
    return unless $_[0]->isa('HASH');
    my $self = tied(%{$_[0]});
    return unless defined $self;
    delete $ITERATORS{$self};
    if (exists $OWNER{$self}) {
        chilkatc::delete_CkPrng($self);
        delete $OWNER{$self};
    }
}

*get_Utf8 = *chilkatc::CkPrng_get_Utf8;
*put_Utf8 = *chilkatc::CkPrng_put_Utf8;
*LastErrorXml = *chilkatc::CkPrng_LastErrorXml;
*LastErrorHtml = *chilkatc::CkPrng_LastErrorHtml;
*LastErrorText = *chilkatc::CkPrng_LastErrorText;
*get_DebugLogFilePath = *chilkatc::CkPrng_get_DebugLogFilePath;
*debugLogFilePath = *chilkatc::CkPrng_debugLogFilePath;
*put_DebugLogFilePath = *chilkatc::CkPrng_put_DebugLogFilePath;
*get_LastErrorHtml = *chilkatc::CkPrng_get_LastErrorHtml;
*lastErrorHtml = *chilkatc::CkPrng_lastErrorHtml;
*get_LastErrorText = *chilkatc::CkPrng_get_LastErrorText;
*lastErrorText = *chilkatc::CkPrng_lastErrorText;
*get_LastErrorXml = *chilkatc::CkPrng_get_LastErrorXml;
*lastErrorXml = *chilkatc::CkPrng_lastErrorXml;
*get_LastMethodSuccess = *chilkatc::CkPrng_get_LastMethodSuccess;
*put_LastMethodSuccess = *chilkatc::CkPrng_put_LastMethodSuccess;
*get_PrngName = *chilkatc::CkPrng_get_PrngName;
*prngName = *chilkatc::CkPrng_prngName;
*put_PrngName = *chilkatc::CkPrng_put_PrngName;
*get_VerboseLogging = *chilkatc::CkPrng_get_VerboseLogging;
*put_VerboseLogging = *chilkatc::CkPrng_put_VerboseLogging;
*get_Version = *chilkatc::CkPrng_get_Version;
*version = *chilkatc::CkPrng_version;
*AddEntropy = *chilkatc::CkPrng_AddEntropy;
*AddEntropyBytes = *chilkatc::CkPrng_AddEntropyBytes;
*ExportEntropy = *chilkatc::CkPrng_ExportEntropy;
*exportEntropy = *chilkatc::CkPrng_exportEntropy;
*FirebasePushId = *chilkatc::CkPrng_FirebasePushId;
*firebasePushId = *chilkatc::CkPrng_firebasePushId;
*GenRandom = *chilkatc::CkPrng_GenRandom;
*genRandom = *chilkatc::CkPrng_genRandom;
*GenRandomBd = *chilkatc::CkPrng_GenRandomBd;
*GenRandomBytes = *chilkatc::CkPrng_GenRandomBytes;
*GetEntropy = *chilkatc::CkPrng_GetEntropy;
*getEntropy = *chilkatc::CkPrng_getEntropy;
*entropy = *chilkatc::CkPrng_entropy;
*GetEntropyBytes = *chilkatc::CkPrng_GetEntropyBytes;
*ImportEntropy = *chilkatc::CkPrng_ImportEntropy;
*RandomInt = *chilkatc::CkPrng_RandomInt;
*RandomPassword = *chilkatc::CkPrng_RandomPassword;
*randomPassword = *chilkatc::CkPrng_randomPassword;
*RandomString = *chilkatc::CkPrng_RandomString;
*randomString = *chilkatc::CkPrng_randomString;
sub DISOWN {
    my $self = shift;
    my $ptr = tied(%$self);
    delete $OWNER{$ptr};
}

sub ACQUIRE {
    my $self = shift;
    my $ptr = tied(%$self);
    $OWNER{$ptr} = 1;
}


############# Class : chilkat::CkPublicKey ##############

package chilkat::CkPublicKey;
use vars qw(@ISA %OWNER %ITERATORS %BLESSEDMEMBERS);
@ISA = qw( chilkat );
%OWNER = ();
%ITERATORS = ();
sub new {
    my $pkg = shift;
    my $self = chilkatc::new_CkPublicKey(@_);
    bless $self, $pkg if defined($self);
}

sub DESTROY {
    return unless $_[0]->isa('HASH');
    my $self = tied(%{$_[0]});
    return unless defined $self;
    delete $ITERATORS{$self};
    if (exists $OWNER{$self}) {
        chilkatc::delete_CkPublicKey($self);
        delete $OWNER{$self};
    }
}

*get_Utf8 = *chilkatc::CkPublicKey_get_Utf8;
*put_Utf8 = *chilkatc::CkPublicKey_put_Utf8;
*LastErrorXml = *chilkatc::CkPublicKey_LastErrorXml;
*LastErrorHtml = *chilkatc::CkPublicKey_LastErrorHtml;
*LastErrorText = *chilkatc::CkPublicKey_LastErrorText;
*get_DebugLogFilePath = *chilkatc::CkPublicKey_get_DebugLogFilePath;
*debugLogFilePath = *chilkatc::CkPublicKey_debugLogFilePath;
*put_DebugLogFilePath = *chilkatc::CkPublicKey_put_DebugLogFilePath;
*get_Empty = *chilkatc::CkPublicKey_get_Empty;
*get_KeySize = *chilkatc::CkPublicKey_get_KeySize;
*get_KeyType = *chilkatc::CkPublicKey_get_KeyType;
*keyType = *chilkatc::CkPublicKey_keyType;
*get_LastErrorHtml = *chilkatc::CkPublicKey_get_LastErrorHtml;
*lastErrorHtml = *chilkatc::CkPublicKey_lastErrorHtml;
*get_LastErrorText = *chilkatc::CkPublicKey_get_LastErrorText;
*lastErrorText = *chilkatc::CkPublicKey_lastErrorText;
*get_LastErrorXml = *chilkatc::CkPublicKey_get_LastErrorXml;
*lastErrorXml = *chilkatc::CkPublicKey_lastErrorXml;
*get_LastMethodSuccess = *chilkatc::CkPublicKey_get_LastMethodSuccess;
*put_LastMethodSuccess = *chilkatc::CkPublicKey_put_LastMethodSuccess;
*get_VerboseLogging = *chilkatc::CkPublicKey_get_VerboseLogging;
*put_VerboseLogging = *chilkatc::CkPublicKey_put_VerboseLogging;
*get_Version = *chilkatc::CkPublicKey_get_Version;
*version = *chilkatc::CkPublicKey_version;
*GetDer = *chilkatc::CkPublicKey_GetDer;
*GetDerBd = *chilkatc::CkPublicKey_GetDerBd;
*GetEncoded = *chilkatc::CkPublicKey_GetEncoded;
*getEncoded = *chilkatc::CkPublicKey_getEncoded;
*encoded = *chilkatc::CkPublicKey_encoded;
*GetJwk = *chilkatc::CkPublicKey_GetJwk;
*getJwk = *chilkatc::CkPublicKey_getJwk;
*jwk = *chilkatc::CkPublicKey_jwk;
*GetJwkThumbprint = *chilkatc::CkPublicKey_GetJwkThumbprint;
*getJwkThumbprint = *chilkatc::CkPublicKey_getJwkThumbprint;
*jwkThumbprint = *chilkatc::CkPublicKey_jwkThumbprint;
*GetPem = *chilkatc::CkPublicKey_GetPem;
*getPem = *chilkatc::CkPublicKey_getPem;
*pem = *chilkatc::CkPublicKey_pem;
*GetXml = *chilkatc::CkPublicKey_GetXml;
*getXml = *chilkatc::CkPublicKey_getXml;
*xml = *chilkatc::CkPublicKey_xml;
*LoadBase64 = *chilkatc::CkPublicKey_LoadBase64;
*LoadBd = *chilkatc::CkPublicKey_LoadBd;
*LoadEcdsa = *chilkatc::CkPublicKey_LoadEcdsa;
*LoadEd25519 = *chilkatc::CkPublicKey_LoadEd25519;
*LoadFromBinary = *chilkatc::CkPublicKey_LoadFromBinary;
*LoadFromFile = *chilkatc::CkPublicKey_LoadFromFile;
*LoadFromString = *chilkatc::CkPublicKey_LoadFromString;
*SaveDerFile = *chilkatc::CkPublicKey_SaveDerFile;
*SavePemFile = *chilkatc::CkPublicKey_SavePemFile;
*SaveXmlFile = *chilkatc::CkPublicKey_SaveXmlFile;
sub DISOWN {
    my $self = shift;
    my $ptr = tied(%$self);
    delete $OWNER{$ptr};
}

sub ACQUIRE {
    my $self = shift;
    my $ptr = tied(%$self);
    $OWNER{$ptr} = 1;
}


############# Class : chilkat::CkRest ##############

package chilkat::CkRest;
use vars qw(@ISA %OWNER %ITERATORS %BLESSEDMEMBERS);
@ISA = qw( chilkat );
%OWNER = ();
%ITERATORS = ();
sub new {
    my $pkg = shift;
    my $self = chilkatc::new_CkRest(@_);
    bless $self, $pkg if defined($self);
}

sub DESTROY {
    return unless $_[0]->isa('HASH');
    my $self = tied(%{$_[0]});
    return unless defined $self;
    delete $ITERATORS{$self};
    if (exists $OWNER{$self}) {
        chilkatc::delete_CkRest($self);
        delete $OWNER{$self};
    }
}

*get_Utf8 = *chilkatc::CkRest_get_Utf8;
*put_Utf8 = *chilkatc::CkRest_put_Utf8;
*LastErrorXml = *chilkatc::CkRest_LastErrorXml;
*LastErrorHtml = *chilkatc::CkRest_LastErrorHtml;
*LastErrorText = *chilkatc::CkRest_LastErrorText;
*put_EventCallbackObject = *chilkatc::CkRest_put_EventCallbackObject;
*get_AllowHeaderFolding = *chilkatc::CkRest_get_AllowHeaderFolding;
*put_AllowHeaderFolding = *chilkatc::CkRest_put_AllowHeaderFolding;
*get_AllowHeaderQB = *chilkatc::CkRest_get_AllowHeaderQB;
*put_AllowHeaderQB = *chilkatc::CkRest_put_AllowHeaderQB;
*get_Authorization = *chilkatc::CkRest_get_Authorization;
*authorization = *chilkatc::CkRest_authorization;
*put_Authorization = *chilkatc::CkRest_put_Authorization;
*get_ConnectFailReason = *chilkatc::CkRest_get_ConnectFailReason;
*get_ConnectTimeoutMs = *chilkatc::CkRest_get_ConnectTimeoutMs;
*put_ConnectTimeoutMs = *chilkatc::CkRest_put_ConnectTimeoutMs;
*get_DebugLogFilePath = *chilkatc::CkRest_get_DebugLogFilePath;
*debugLogFilePath = *chilkatc::CkRest_debugLogFilePath;
*put_DebugLogFilePath = *chilkatc::CkRest_put_DebugLogFilePath;
*get_DebugMode = *chilkatc::CkRest_get_DebugMode;
*put_DebugMode = *chilkatc::CkRest_put_DebugMode;
*get_HeartbeatMs = *chilkatc::CkRest_get_HeartbeatMs;
*put_HeartbeatMs = *chilkatc::CkRest_put_HeartbeatMs;
*get_Host = *chilkatc::CkRest_get_Host;
*host = *chilkatc::CkRest_host;
*put_Host = *chilkatc::CkRest_put_Host;
*get_IdleTimeoutMs = *chilkatc::CkRest_get_IdleTimeoutMs;
*put_IdleTimeoutMs = *chilkatc::CkRest_put_IdleTimeoutMs;
*get_LastErrorHtml = *chilkatc::CkRest_get_LastErrorHtml;
*lastErrorHtml = *chilkatc::CkRest_lastErrorHtml;
*get_LastErrorText = *chilkatc::CkRest_get_LastErrorText;
*lastErrorText = *chilkatc::CkRest_lastErrorText;
*get_LastErrorXml = *chilkatc::CkRest_get_LastErrorXml;
*lastErrorXml = *chilkatc::CkRest_lastErrorXml;
*get_LastMethodSuccess = *chilkatc::CkRest_get_LastMethodSuccess;
*put_LastMethodSuccess = *chilkatc::CkRest_put_LastMethodSuccess;
*get_LastRedirectUrl = *chilkatc::CkRest_get_LastRedirectUrl;
*lastRedirectUrl = *chilkatc::CkRest_lastRedirectUrl;
*get_LastRequestHeader = *chilkatc::CkRest_get_LastRequestHeader;
*lastRequestHeader = *chilkatc::CkRest_lastRequestHeader;
*get_LastRequestStartLine = *chilkatc::CkRest_get_LastRequestStartLine;
*lastRequestStartLine = *chilkatc::CkRest_lastRequestStartLine;
*get_NumResponseHeaders = *chilkatc::CkRest_get_NumResponseHeaders;
*get_PartSelector = *chilkatc::CkRest_get_PartSelector;
*partSelector = *chilkatc::CkRest_partSelector;
*put_PartSelector = *chilkatc::CkRest_put_PartSelector;
*get_PercentDoneOnSend = *chilkatc::CkRest_get_PercentDoneOnSend;
*put_PercentDoneOnSend = *chilkatc::CkRest_put_PercentDoneOnSend;
*get_ResponseHeader = *chilkatc::CkRest_get_ResponseHeader;
*responseHeader = *chilkatc::CkRest_responseHeader;
*get_ResponseStatusCode = *chilkatc::CkRest_get_ResponseStatusCode;
*get_ResponseStatusText = *chilkatc::CkRest_get_ResponseStatusText;
*responseStatusText = *chilkatc::CkRest_responseStatusText;
*get_StreamNonChunked = *chilkatc::CkRest_get_StreamNonChunked;
*put_StreamNonChunked = *chilkatc::CkRest_put_StreamNonChunked;
*get_UncommonOptions = *chilkatc::CkRest_get_UncommonOptions;
*uncommonOptions = *chilkatc::CkRest_uncommonOptions;
*put_UncommonOptions = *chilkatc::CkRest_put_UncommonOptions;
*get_VerboseLogging = *chilkatc::CkRest_get_VerboseLogging;
*put_VerboseLogging = *chilkatc::CkRest_put_VerboseLogging;
*get_Version = *chilkatc::CkRest_get_Version;
*version = *chilkatc::CkRest_version;
*AddHeader = *chilkatc::CkRest_AddHeader;
*AddMwsSignature = *chilkatc::CkRest_AddMwsSignature;
*AddPathParam = *chilkatc::CkRest_AddPathParam;
*AddQueryParam = *chilkatc::CkRest_AddQueryParam;
*AddQueryParams = *chilkatc::CkRest_AddQueryParams;
*AddQueryParamSb = *chilkatc::CkRest_AddQueryParamSb;
*ClearAllHeaders = *chilkatc::CkRest_ClearAllHeaders;
*ClearAllParts = *chilkatc::CkRest_ClearAllParts;
*ClearAllPathParams = *chilkatc::CkRest_ClearAllPathParams;
*ClearAllQueryParams = *chilkatc::CkRest_ClearAllQueryParams;
*ClearAuth = *chilkatc::CkRest_ClearAuth;
*ClearResponseBodyStream = *chilkatc::CkRest_ClearResponseBodyStream;
*Connect = *chilkatc::CkRest_Connect;
*ConnectAsync = *chilkatc::CkRest_ConnectAsync;
*Disconnect = *chilkatc::CkRest_Disconnect;
*DisconnectAsync = *chilkatc::CkRest_DisconnectAsync;
*FullRequestBd = *chilkatc::CkRest_FullRequestBd;
*FullRequestBdAsync = *chilkatc::CkRest_FullRequestBdAsync;
*FullRequestBinary = *chilkatc::CkRest_FullRequestBinary;
*fullRequestBinary = *chilkatc::CkRest_fullRequestBinary;
*FullRequestBinaryAsync = *chilkatc::CkRest_FullRequestBinaryAsync;
*FullRequestFormUrlEncoded = *chilkatc::CkRest_FullRequestFormUrlEncoded;
*fullRequestFormUrlEncoded = *chilkatc::CkRest_fullRequestFormUrlEncoded;
*FullRequestFormUrlEncodedAsync = *chilkatc::CkRest_FullRequestFormUrlEncodedAsync;
*FullRequestMultipart = *chilkatc::CkRest_FullRequestMultipart;
*fullRequestMultipart = *chilkatc::CkRest_fullRequestMultipart;
*FullRequestMultipartAsync = *chilkatc::CkRest_FullRequestMultipartAsync;
*FullRequestNoBody = *chilkatc::CkRest_FullRequestNoBody;
*fullRequestNoBody = *chilkatc::CkRest_fullRequestNoBody;
*FullRequestNoBodyAsync = *chilkatc::CkRest_FullRequestNoBodyAsync;
*FullRequestNoBodyBd = *chilkatc::CkRest_FullRequestNoBodyBd;
*FullRequestNoBodyBdAsync = *chilkatc::CkRest_FullRequestNoBodyBdAsync;
*FullRequestNoBodySb = *chilkatc::CkRest_FullRequestNoBodySb;
*FullRequestNoBodySbAsync = *chilkatc::CkRest_FullRequestNoBodySbAsync;
*FullRequestSb = *chilkatc::CkRest_FullRequestSb;
*FullRequestSbAsync = *chilkatc::CkRest_FullRequestSbAsync;
*FullRequestStream = *chilkatc::CkRest_FullRequestStream;
*fullRequestStream = *chilkatc::CkRest_fullRequestStream;
*FullRequestStreamAsync = *chilkatc::CkRest_FullRequestStreamAsync;
*FullRequestString = *chilkatc::CkRest_FullRequestString;
*fullRequestString = *chilkatc::CkRest_fullRequestString;
*FullRequestStringAsync = *chilkatc::CkRest_FullRequestStringAsync;
*GetLastDebugRequest = *chilkatc::CkRest_GetLastDebugRequest;
*GetLastJsonData = *chilkatc::CkRest_GetLastJsonData;
*LastJsonData = *chilkatc::CkRest_LastJsonData;
*LoadTaskCaller = *chilkatc::CkRest_LoadTaskCaller;
*ReadRespBd = *chilkatc::CkRest_ReadRespBd;
*ReadRespBdAsync = *chilkatc::CkRest_ReadRespBdAsync;
*ReadRespBodyBinary = *chilkatc::CkRest_ReadRespBodyBinary;
*ReadRespBodyBinaryAsync = *chilkatc::CkRest_ReadRespBodyBinaryAsync;
*ReadRespBodyStream = *chilkatc::CkRest_ReadRespBodyStream;
*ReadRespBodyStreamAsync = *chilkatc::CkRest_ReadRespBodyStreamAsync;
*ReadRespBodyString = *chilkatc::CkRest_ReadRespBodyString;
*readRespBodyString = *chilkatc::CkRest_readRespBodyString;
*ReadRespBodyStringAsync = *chilkatc::CkRest_ReadRespBodyStringAsync;
*ReadRespChunkBd = *chilkatc::CkRest_ReadRespChunkBd;
*ReadRespChunkBdAsync = *chilkatc::CkRest_ReadRespChunkBdAsync;
*ReadResponseHeader = *chilkatc::CkRest_ReadResponseHeader;
*ReadResponseHeaderAsync = *chilkatc::CkRest_ReadResponseHeaderAsync;
*ReadRespSb = *chilkatc::CkRest_ReadRespSb;
*ReadRespSbAsync = *chilkatc::CkRest_ReadRespSbAsync;
*RedirectUrl = *chilkatc::CkRest_RedirectUrl;
*RemoveHeader = *chilkatc::CkRest_RemoveHeader;
*RemoveQueryParam = *chilkatc::CkRest_RemoveQueryParam;
*ResponseHdrByName = *chilkatc::CkRest_ResponseHdrByName;
*responseHdrByName = *chilkatc::CkRest_responseHdrByName;
*ResponseHdrName = *chilkatc::CkRest_ResponseHdrName;
*responseHdrName = *chilkatc::CkRest_responseHdrName;
*ResponseHdrValue = *chilkatc::CkRest_ResponseHdrValue;
*responseHdrValue = *chilkatc::CkRest_responseHdrValue;
*SendReqBd = *chilkatc::CkRest_SendReqBd;
*SendReqBdAsync = *chilkatc::CkRest_SendReqBdAsync;
*SendReqBinaryBody = *chilkatc::CkRest_SendReqBinaryBody;
*SendReqBinaryBodyAsync = *chilkatc::CkRest_SendReqBinaryBodyAsync;
*SendReqFormUrlEncoded = *chilkatc::CkRest_SendReqFormUrlEncoded;
*SendReqFormUrlEncodedAsync = *chilkatc::CkRest_SendReqFormUrlEncodedAsync;
*SendReqMultipart = *chilkatc::CkRest_SendReqMultipart;
*SendReqMultipartAsync = *chilkatc::CkRest_SendReqMultipartAsync;
*SendReqNoBody = *chilkatc::CkRest_SendReqNoBody;
*SendReqNoBodyAsync = *chilkatc::CkRest_SendReqNoBodyAsync;
*SendReqSb = *chilkatc::CkRest_SendReqSb;
*SendReqSbAsync = *chilkatc::CkRest_SendReqSbAsync;
*SendReqStreamBody = *chilkatc::CkRest_SendReqStreamBody;
*SendReqStreamBodyAsync = *chilkatc::CkRest_SendReqStreamBodyAsync;
*SendReqStringBody = *chilkatc::CkRest_SendReqStringBody;
*SendReqStringBodyAsync = *chilkatc::CkRest_SendReqStringBodyAsync;
*SetAuthAws = *chilkatc::CkRest_SetAuthAws;
*SetAuthAzureSas = *chilkatc::CkRest_SetAuthAzureSas;
*SetAuthAzureStorage = *chilkatc::CkRest_SetAuthAzureStorage;
*SetAuthBasic = *chilkatc::CkRest_SetAuthBasic;
*SetAuthBasicSecure = *chilkatc::CkRest_SetAuthBasicSecure;
*SetAuthGoogle = *chilkatc::CkRest_SetAuthGoogle;
*SetAuthOAuth1 = *chilkatc::CkRest_SetAuthOAuth1;
*SetAuthOAuth2 = *chilkatc::CkRest_SetAuthOAuth2;
*SetMultipartBodyBd = *chilkatc::CkRest_SetMultipartBodyBd;
*SetMultipartBodyBinary = *chilkatc::CkRest_SetMultipartBodyBinary;
*SetMultipartBodySb = *chilkatc::CkRest_SetMultipartBodySb;
*SetMultipartBodyStream = *chilkatc::CkRest_SetMultipartBodyStream;
*SetMultipartBodyString = *chilkatc::CkRest_SetMultipartBodyString;
*SetResponseBodyStream = *chilkatc::CkRest_SetResponseBodyStream;
*UseConnection = *chilkatc::CkRest_UseConnection;
sub DISOWN {
    my $self = shift;
    my $ptr = tied(%$self);
    delete $OWNER{$ptr};
}

sub ACQUIRE {
    my $self = shift;
    my $ptr = tied(%$self);
    $OWNER{$ptr} = 1;
}


############# Class : chilkat::CkRsa ##############

package chilkat::CkRsa;
use vars qw(@ISA %OWNER %ITERATORS %BLESSEDMEMBERS);
@ISA = qw( chilkat );
%OWNER = ();
%ITERATORS = ();
sub new {
    my $pkg = shift;
    my $self = chilkatc::new_CkRsa(@_);
    bless $self, $pkg if defined($self);
}

sub DESTROY {
    return unless $_[0]->isa('HASH');
    my $self = tied(%{$_[0]});
    return unless defined $self;
    delete $ITERATORS{$self};
    if (exists $OWNER{$self}) {
        chilkatc::delete_CkRsa($self);
        delete $OWNER{$self};
    }
}

*get_Utf8 = *chilkatc::CkRsa_get_Utf8;
*put_Utf8 = *chilkatc::CkRsa_put_Utf8;
*LastErrorXml = *chilkatc::CkRsa_LastErrorXml;
*LastErrorHtml = *chilkatc::CkRsa_LastErrorHtml;
*LastErrorText = *chilkatc::CkRsa_LastErrorText;
*get_Charset = *chilkatc::CkRsa_get_Charset;
*charset = *chilkatc::CkRsa_charset;
*put_Charset = *chilkatc::CkRsa_put_Charset;
*get_DebugLogFilePath = *chilkatc::CkRsa_get_DebugLogFilePath;
*debugLogFilePath = *chilkatc::CkRsa_debugLogFilePath;
*put_DebugLogFilePath = *chilkatc::CkRsa_put_DebugLogFilePath;
*get_EncodingMode = *chilkatc::CkRsa_get_EncodingMode;
*encodingMode = *chilkatc::CkRsa_encodingMode;
*put_EncodingMode = *chilkatc::CkRsa_put_EncodingMode;
*get_LastErrorHtml = *chilkatc::CkRsa_get_LastErrorHtml;
*lastErrorHtml = *chilkatc::CkRsa_lastErrorHtml;
*get_LastErrorText = *chilkatc::CkRsa_get_LastErrorText;
*lastErrorText = *chilkatc::CkRsa_lastErrorText;
*get_LastErrorXml = *chilkatc::CkRsa_get_LastErrorXml;
*lastErrorXml = *chilkatc::CkRsa_lastErrorXml;
*get_LastMethodSuccess = *chilkatc::CkRsa_get_LastMethodSuccess;
*put_LastMethodSuccess = *chilkatc::CkRsa_put_LastMethodSuccess;
*get_LittleEndian = *chilkatc::CkRsa_get_LittleEndian;
*put_LittleEndian = *chilkatc::CkRsa_put_LittleEndian;
*get_NoUnpad = *chilkatc::CkRsa_get_NoUnpad;
*put_NoUnpad = *chilkatc::CkRsa_put_NoUnpad;
*get_NumBits = *chilkatc::CkRsa_get_NumBits;
*get_OaepHash = *chilkatc::CkRsa_get_OaepHash;
*oaepHash = *chilkatc::CkRsa_oaepHash;
*put_OaepHash = *chilkatc::CkRsa_put_OaepHash;
*get_OaepLabel = *chilkatc::CkRsa_get_OaepLabel;
*oaepLabel = *chilkatc::CkRsa_oaepLabel;
*put_OaepLabel = *chilkatc::CkRsa_put_OaepLabel;
*get_OaepMgfHash = *chilkatc::CkRsa_get_OaepMgfHash;
*oaepMgfHash = *chilkatc::CkRsa_oaepMgfHash;
*put_OaepMgfHash = *chilkatc::CkRsa_put_OaepMgfHash;
*get_OaepPadding = *chilkatc::CkRsa_get_OaepPadding;
*put_OaepPadding = *chilkatc::CkRsa_put_OaepPadding;
*get_PkcsPadding = *chilkatc::CkRsa_get_PkcsPadding;
*put_PkcsPadding = *chilkatc::CkRsa_put_PkcsPadding;
*get_PssSaltLen = *chilkatc::CkRsa_get_PssSaltLen;
*put_PssSaltLen = *chilkatc::CkRsa_put_PssSaltLen;
*get_UncommonOptions = *chilkatc::CkRsa_get_UncommonOptions;
*uncommonOptions = *chilkatc::CkRsa_uncommonOptions;
*put_UncommonOptions = *chilkatc::CkRsa_put_UncommonOptions;
*get_VerboseLogging = *chilkatc::CkRsa_get_VerboseLogging;
*put_VerboseLogging = *chilkatc::CkRsa_put_VerboseLogging;
*get_Version = *chilkatc::CkRsa_get_Version;
*version = *chilkatc::CkRsa_version;
*DecryptBd = *chilkatc::CkRsa_DecryptBd;
*DecryptBytes = *chilkatc::CkRsa_DecryptBytes;
*DecryptBytesENC = *chilkatc::CkRsa_DecryptBytesENC;
*DecryptString = *chilkatc::CkRsa_DecryptString;
*decryptString = *chilkatc::CkRsa_decryptString;
*DecryptStringENC = *chilkatc::CkRsa_DecryptStringENC;
*decryptStringENC = *chilkatc::CkRsa_decryptStringENC;
*EncryptBd = *chilkatc::CkRsa_EncryptBd;
*EncryptBytes = *chilkatc::CkRsa_EncryptBytes;
*EncryptBytesENC = *chilkatc::CkRsa_EncryptBytesENC;
*encryptBytesENC = *chilkatc::CkRsa_encryptBytesENC;
*EncryptString = *chilkatc::CkRsa_EncryptString;
*EncryptStringENC = *chilkatc::CkRsa_EncryptStringENC;
*encryptStringENC = *chilkatc::CkRsa_encryptStringENC;
*ExportPrivateKey = *chilkatc::CkRsa_ExportPrivateKey;
*exportPrivateKey = *chilkatc::CkRsa_exportPrivateKey;
*ExportPrivateKeyObj = *chilkatc::CkRsa_ExportPrivateKeyObj;
*ExportPublicKey = *chilkatc::CkRsa_ExportPublicKey;
*exportPublicKey = *chilkatc::CkRsa_exportPublicKey;
*ExportPublicKeyObj = *chilkatc::CkRsa_ExportPublicKeyObj;
*GenerateKey = *chilkatc::CkRsa_GenerateKey;
*GenKey = *chilkatc::CkRsa_GenKey;
*ImportPrivateKey = *chilkatc::CkRsa_ImportPrivateKey;
*ImportPrivateKeyObj = *chilkatc::CkRsa_ImportPrivateKeyObj;
*ImportPublicKey = *chilkatc::CkRsa_ImportPublicKey;
*ImportPublicKeyObj = *chilkatc::CkRsa_ImportPublicKeyObj;
*OpenSslSignBd = *chilkatc::CkRsa_OpenSslSignBd;
*OpenSslSignBytes = *chilkatc::CkRsa_OpenSslSignBytes;
*OpenSslSignBytesENC = *chilkatc::CkRsa_OpenSslSignBytesENC;
*openSslSignBytesENC = *chilkatc::CkRsa_openSslSignBytesENC;
*OpenSslSignString = *chilkatc::CkRsa_OpenSslSignString;
*OpenSslSignStringENC = *chilkatc::CkRsa_OpenSslSignStringENC;
*openSslSignStringENC = *chilkatc::CkRsa_openSslSignStringENC;
*OpenSslVerifyBd = *chilkatc::CkRsa_OpenSslVerifyBd;
*OpenSslVerifyBytes = *chilkatc::CkRsa_OpenSslVerifyBytes;
*OpenSslVerifyBytesENC = *chilkatc::CkRsa_OpenSslVerifyBytesENC;
*OpenSslVerifyString = *chilkatc::CkRsa_OpenSslVerifyString;
*openSslVerifyString = *chilkatc::CkRsa_openSslVerifyString;
*OpenSslVerifyStringENC = *chilkatc::CkRsa_OpenSslVerifyStringENC;
*openSslVerifyStringENC = *chilkatc::CkRsa_openSslVerifyStringENC;
*SetX509Cert = *chilkatc::CkRsa_SetX509Cert;
*SignBd = *chilkatc::CkRsa_SignBd;
*SignBytes = *chilkatc::CkRsa_SignBytes;
*SignBytesENC = *chilkatc::CkRsa_SignBytesENC;
*signBytesENC = *chilkatc::CkRsa_signBytesENC;
*SignHash = *chilkatc::CkRsa_SignHash;
*SignHashENC = *chilkatc::CkRsa_SignHashENC;
*signHashENC = *chilkatc::CkRsa_signHashENC;
*SignRawBd = *chilkatc::CkRsa_SignRawBd;
*SignString = *chilkatc::CkRsa_SignString;
*SignStringENC = *chilkatc::CkRsa_SignStringENC;
*signStringENC = *chilkatc::CkRsa_signStringENC;
*SnkToXml = *chilkatc::CkRsa_SnkToXml;
*snkToXml = *chilkatc::CkRsa_snkToXml;
*UsePrivateKey = *chilkatc::CkRsa_UsePrivateKey;
*UsePublicKey = *chilkatc::CkRsa_UsePublicKey;
*VerifyBd = *chilkatc::CkRsa_VerifyBd;
*VerifyBytes = *chilkatc::CkRsa_VerifyBytes;
*VerifyBytesENC = *chilkatc::CkRsa_VerifyBytesENC;
*VerifyHash = *chilkatc::CkRsa_VerifyHash;
*VerifyHashENC = *chilkatc::CkRsa_VerifyHashENC;
*VerifyRawBd = *chilkatc::CkRsa_VerifyRawBd;
*VerifyString = *chilkatc::CkRsa_VerifyString;
*VerifyStringENC = *chilkatc::CkRsa_VerifyStringENC;
sub DISOWN {
    my $self = shift;
    my $ptr = tied(%$self);
    delete $OWNER{$ptr};
}

sub ACQUIRE {
    my $self = shift;
    my $ptr = tied(%$self);
    $OWNER{$ptr} = 1;
}


############# Class : chilkat::CkSCard ##############

package chilkat::CkSCard;
use vars qw(@ISA %OWNER %ITERATORS %BLESSEDMEMBERS);
@ISA = qw( chilkat );
%OWNER = ();
%ITERATORS = ();
sub new {
    my $pkg = shift;
    my $self = chilkatc::new_CkSCard(@_);
    bless $self, $pkg if defined($self);
}

sub DESTROY {
    return unless $_[0]->isa('HASH');
    my $self = tied(%{$_[0]});
    return unless defined $self;
    delete $ITERATORS{$self};
    if (exists $OWNER{$self}) {
        chilkatc::delete_CkSCard($self);
        delete $OWNER{$self};
    }
}

*get_Utf8 = *chilkatc::CkSCard_get_Utf8;
*put_Utf8 = *chilkatc::CkSCard_put_Utf8;
*LastErrorXml = *chilkatc::CkSCard_LastErrorXml;
*LastErrorHtml = *chilkatc::CkSCard_LastErrorHtml;
*LastErrorText = *chilkatc::CkSCard_LastErrorText;
*put_EventCallbackObject = *chilkatc::CkSCard_put_EventCallbackObject;
*get_ActiveProtocol = *chilkatc::CkSCard_get_ActiveProtocol;
*activeProtocol = *chilkatc::CkSCard_activeProtocol;
*get_CardAtr = *chilkatc::CkSCard_get_CardAtr;
*cardAtr = *chilkatc::CkSCard_cardAtr;
*get_ConnectedReader = *chilkatc::CkSCard_get_ConnectedReader;
*connectedReader = *chilkatc::CkSCard_connectedReader;
*get_Context = *chilkatc::CkSCard_get_Context;
*context = *chilkatc::CkSCard_context;
*get_DebugLogFilePath = *chilkatc::CkSCard_get_DebugLogFilePath;
*debugLogFilePath = *chilkatc::CkSCard_debugLogFilePath;
*put_DebugLogFilePath = *chilkatc::CkSCard_put_DebugLogFilePath;
*get_LastErrorHtml = *chilkatc::CkSCard_get_LastErrorHtml;
*lastErrorHtml = *chilkatc::CkSCard_lastErrorHtml;
*get_LastErrorText = *chilkatc::CkSCard_get_LastErrorText;
*lastErrorText = *chilkatc::CkSCard_lastErrorText;
*get_LastErrorXml = *chilkatc::CkSCard_get_LastErrorXml;
*lastErrorXml = *chilkatc::CkSCard_lastErrorXml;
*get_LastMethodSuccess = *chilkatc::CkSCard_get_LastMethodSuccess;
*put_LastMethodSuccess = *chilkatc::CkSCard_put_LastMethodSuccess;
*get_PcscLibPath = *chilkatc::CkSCard_get_PcscLibPath;
*pcscLibPath = *chilkatc::CkSCard_pcscLibPath;
*put_PcscLibPath = *chilkatc::CkSCard_put_PcscLibPath;
*get_ReaderStatus = *chilkatc::CkSCard_get_ReaderStatus;
*readerStatus = *chilkatc::CkSCard_readerStatus;
*get_ScardError = *chilkatc::CkSCard_get_ScardError;
*scardError = *chilkatc::CkSCard_scardError;
*get_VerboseLogging = *chilkatc::CkSCard_get_VerboseLogging;
*put_VerboseLogging = *chilkatc::CkSCard_put_VerboseLogging;
*get_Version = *chilkatc::CkSCard_get_Version;
*version = *chilkatc::CkSCard_version;
*BeginTransaction = *chilkatc::CkSCard_BeginTransaction;
*CheckStatus = *chilkatc::CkSCard_CheckStatus;
*Connect = *chilkatc::CkSCard_Connect;
*Disconnect = *chilkatc::CkSCard_Disconnect;
*EndTransaction = *chilkatc::CkSCard_EndTransaction;
*EstablishContext = *chilkatc::CkSCard_EstablishContext;
*FindSmartcards = *chilkatc::CkSCard_FindSmartcards;
*GetAttrib = *chilkatc::CkSCard_GetAttrib;
*GetAttribStr = *chilkatc::CkSCard_GetAttribStr;
*getAttribStr = *chilkatc::CkSCard_getAttribStr;
*attribStr = *chilkatc::CkSCard_attribStr;
*GetAttribUint = *chilkatc::CkSCard_GetAttribUint;
*GetStatusChange = *chilkatc::CkSCard_GetStatusChange;
*GetStatusChangeAsync = *chilkatc::CkSCard_GetStatusChangeAsync;
*GetStatusChangeCancel = *chilkatc::CkSCard_GetStatusChangeCancel;
*ListReaderGroups = *chilkatc::CkSCard_ListReaderGroups;
*ListReaders = *chilkatc::CkSCard_ListReaders;
*Reconnect = *chilkatc::CkSCard_Reconnect;
*ReleaseContext = *chilkatc::CkSCard_ReleaseContext;
*SendControl = *chilkatc::CkSCard_SendControl;
*SendControlHex = *chilkatc::CkSCard_SendControlHex;
*Transmit = *chilkatc::CkSCard_Transmit;
*TransmitHex = *chilkatc::CkSCard_TransmitHex;
sub DISOWN {
    my $self = shift;
    my $ptr = tied(%$self);
    delete $OWNER{$ptr};
}

sub ACQUIRE {
    my $self = shift;
    my $ptr = tied(%$self);
    $OWNER{$ptr} = 1;
}


############# Class : chilkat::CkSFtp ##############

package chilkat::CkSFtp;
use vars qw(@ISA %OWNER %ITERATORS %BLESSEDMEMBERS);
@ISA = qw( chilkat );
%OWNER = ();
%ITERATORS = ();
sub new {
    my $pkg = shift;
    my $self = chilkatc::new_CkSFtp(@_);
    bless $self, $pkg if defined($self);
}

sub DESTROY {
    return unless $_[0]->isa('HASH');
    my $self = tied(%{$_[0]});
    return unless defined $self;
    delete $ITERATORS{$self};
    if (exists $OWNER{$self}) {
        chilkatc::delete_CkSFtp($self);
        delete $OWNER{$self};
    }
}

*get_Utf8 = *chilkatc::CkSFtp_get_Utf8;
*put_Utf8 = *chilkatc::CkSFtp_put_Utf8;
*LastErrorXml = *chilkatc::CkSFtp_LastErrorXml;
*LastErrorHtml = *chilkatc::CkSFtp_LastErrorHtml;
*LastErrorText = *chilkatc::CkSFtp_LastErrorText;
*put_EventCallbackObject = *chilkatc::CkSFtp_put_EventCallbackObject;
*get_AbortCurrent = *chilkatc::CkSFtp_get_AbortCurrent;
*put_AbortCurrent = *chilkatc::CkSFtp_put_AbortCurrent;
*get_AuthFailReason = *chilkatc::CkSFtp_get_AuthFailReason;
*get_BandwidthThrottleDown = *chilkatc::CkSFtp_get_BandwidthThrottleDown;
*put_BandwidthThrottleDown = *chilkatc::CkSFtp_put_BandwidthThrottleDown;
*get_BandwidthThrottleUp = *chilkatc::CkSFtp_get_BandwidthThrottleUp;
*put_BandwidthThrottleUp = *chilkatc::CkSFtp_put_BandwidthThrottleUp;
*get_ClientIdentifier = *chilkatc::CkSFtp_get_ClientIdentifier;
*clientIdentifier = *chilkatc::CkSFtp_clientIdentifier;
*put_ClientIdentifier = *chilkatc::CkSFtp_put_ClientIdentifier;
*get_ClientIpAddress = *chilkatc::CkSFtp_get_ClientIpAddress;
*clientIpAddress = *chilkatc::CkSFtp_clientIpAddress;
*put_ClientIpAddress = *chilkatc::CkSFtp_put_ClientIpAddress;
*get_ConnectTimeoutMs = *chilkatc::CkSFtp_get_ConnectTimeoutMs;
*put_ConnectTimeoutMs = *chilkatc::CkSFtp_put_ConnectTimeoutMs;
*get_DebugLogFilePath = *chilkatc::CkSFtp_get_DebugLogFilePath;
*debugLogFilePath = *chilkatc::CkSFtp_debugLogFilePath;
*put_DebugLogFilePath = *chilkatc::CkSFtp_put_DebugLogFilePath;
*get_DisconnectCode = *chilkatc::CkSFtp_get_DisconnectCode;
*get_DisconnectReason = *chilkatc::CkSFtp_get_DisconnectReason;
*disconnectReason = *chilkatc::CkSFtp_disconnectReason;
*get_EnableCache = *chilkatc::CkSFtp_get_EnableCache;
*put_EnableCache = *chilkatc::CkSFtp_put_EnableCache;
*get_EnableCompression = *chilkatc::CkSFtp_get_EnableCompression;
*put_EnableCompression = *chilkatc::CkSFtp_put_EnableCompression;
*get_FilenameCharset = *chilkatc::CkSFtp_get_FilenameCharset;
*filenameCharset = *chilkatc::CkSFtp_filenameCharset;
*put_FilenameCharset = *chilkatc::CkSFtp_put_FilenameCharset;
*get_ForceCipher = *chilkatc::CkSFtp_get_ForceCipher;
*forceCipher = *chilkatc::CkSFtp_forceCipher;
*put_ForceCipher = *chilkatc::CkSFtp_put_ForceCipher;
*get_ForceV3 = *chilkatc::CkSFtp_get_ForceV3;
*put_ForceV3 = *chilkatc::CkSFtp_put_ForceV3;
*get_HeartbeatMs = *chilkatc::CkSFtp_get_HeartbeatMs;
*put_HeartbeatMs = *chilkatc::CkSFtp_put_HeartbeatMs;
*get_HostKeyAlg = *chilkatc::CkSFtp_get_HostKeyAlg;
*hostKeyAlg = *chilkatc::CkSFtp_hostKeyAlg;
*put_HostKeyAlg = *chilkatc::CkSFtp_put_HostKeyAlg;
*get_HostKeyFingerprint = *chilkatc::CkSFtp_get_HostKeyFingerprint;
*hostKeyFingerprint = *chilkatc::CkSFtp_hostKeyFingerprint;
*get_HttpProxyAuthMethod = *chilkatc::CkSFtp_get_HttpProxyAuthMethod;
*httpProxyAuthMethod = *chilkatc::CkSFtp_httpProxyAuthMethod;
*put_HttpProxyAuthMethod = *chilkatc::CkSFtp_put_HttpProxyAuthMethod;
*get_HttpProxyDomain = *chilkatc::CkSFtp_get_HttpProxyDomain;
*httpProxyDomain = *chilkatc::CkSFtp_httpProxyDomain;
*put_HttpProxyDomain = *chilkatc::CkSFtp_put_HttpProxyDomain;
*get_HttpProxyHostname = *chilkatc::CkSFtp_get_HttpProxyHostname;
*httpProxyHostname = *chilkatc::CkSFtp_httpProxyHostname;
*put_HttpProxyHostname = *chilkatc::CkSFtp_put_HttpProxyHostname;
*get_HttpProxyPassword = *chilkatc::CkSFtp_get_HttpProxyPassword;
*httpProxyPassword = *chilkatc::CkSFtp_httpProxyPassword;
*put_HttpProxyPassword = *chilkatc::CkSFtp_put_HttpProxyPassword;
*get_HttpProxyPort = *chilkatc::CkSFtp_get_HttpProxyPort;
*put_HttpProxyPort = *chilkatc::CkSFtp_put_HttpProxyPort;
*get_HttpProxyUsername = *chilkatc::CkSFtp_get_HttpProxyUsername;
*httpProxyUsername = *chilkatc::CkSFtp_httpProxyUsername;
*put_HttpProxyUsername = *chilkatc::CkSFtp_put_HttpProxyUsername;
*get_IdleTimeoutMs = *chilkatc::CkSFtp_get_IdleTimeoutMs;
*put_IdleTimeoutMs = *chilkatc::CkSFtp_put_IdleTimeoutMs;
*get_IncludeDotDirs = *chilkatc::CkSFtp_get_IncludeDotDirs;
*put_IncludeDotDirs = *chilkatc::CkSFtp_put_IncludeDotDirs;
*get_InitializeFailCode = *chilkatc::CkSFtp_get_InitializeFailCode;
*get_InitializeFailReason = *chilkatc::CkSFtp_get_InitializeFailReason;
*initializeFailReason = *chilkatc::CkSFtp_initializeFailReason;
*get_IsConnected = *chilkatc::CkSFtp_get_IsConnected;
*get_KeepSessionLog = *chilkatc::CkSFtp_get_KeepSessionLog;
*put_KeepSessionLog = *chilkatc::CkSFtp_put_KeepSessionLog;
*get_LastErrorHtml = *chilkatc::CkSFtp_get_LastErrorHtml;
*lastErrorHtml = *chilkatc::CkSFtp_lastErrorHtml;
*get_LastErrorText = *chilkatc::CkSFtp_get_LastErrorText;
*lastErrorText = *chilkatc::CkSFtp_lastErrorText;
*get_LastErrorXml = *chilkatc::CkSFtp_get_LastErrorXml;
*lastErrorXml = *chilkatc::CkSFtp_lastErrorXml;
*get_LastMethodSuccess = *chilkatc::CkSFtp_get_LastMethodSuccess;
*put_LastMethodSuccess = *chilkatc::CkSFtp_put_LastMethodSuccess;
*get_LastStatusCode = *chilkatc::CkSFtp_get_LastStatusCode;
*get_LastStatusMessage = *chilkatc::CkSFtp_get_LastStatusMessage;
*lastStatusMessage = *chilkatc::CkSFtp_lastStatusMessage;
*get_MaxPacketSize = *chilkatc::CkSFtp_get_MaxPacketSize;
*put_MaxPacketSize = *chilkatc::CkSFtp_put_MaxPacketSize;
*get_PasswordChangeRequested = *chilkatc::CkSFtp_get_PasswordChangeRequested;
*get_PercentDoneScale = *chilkatc::CkSFtp_get_PercentDoneScale;
*put_PercentDoneScale = *chilkatc::CkSFtp_put_PercentDoneScale;
*get_PreferIpv6 = *chilkatc::CkSFtp_get_PreferIpv6;
*put_PreferIpv6 = *chilkatc::CkSFtp_put_PreferIpv6;
*get_PreserveDate = *chilkatc::CkSFtp_get_PreserveDate;
*put_PreserveDate = *chilkatc::CkSFtp_put_PreserveDate;
*get_ProtocolVersion = *chilkatc::CkSFtp_get_ProtocolVersion;
*get_ReadDirMustMatch = *chilkatc::CkSFtp_get_ReadDirMustMatch;
*readDirMustMatch = *chilkatc::CkSFtp_readDirMustMatch;
*put_ReadDirMustMatch = *chilkatc::CkSFtp_put_ReadDirMustMatch;
*get_ReadDirMustNotMatch = *chilkatc::CkSFtp_get_ReadDirMustNotMatch;
*readDirMustNotMatch = *chilkatc::CkSFtp_readDirMustNotMatch;
*put_ReadDirMustNotMatch = *chilkatc::CkSFtp_put_ReadDirMustNotMatch;
*get_ServerIdentifier = *chilkatc::CkSFtp_get_ServerIdentifier;
*serverIdentifier = *chilkatc::CkSFtp_serverIdentifier;
*get_SessionLog = *chilkatc::CkSFtp_get_SessionLog;
*sessionLog = *chilkatc::CkSFtp_sessionLog;
*get_SocksHostname = *chilkatc::CkSFtp_get_SocksHostname;
*socksHostname = *chilkatc::CkSFtp_socksHostname;
*put_SocksHostname = *chilkatc::CkSFtp_put_SocksHostname;
*get_SocksPassword = *chilkatc::CkSFtp_get_SocksPassword;
*socksPassword = *chilkatc::CkSFtp_socksPassword;
*put_SocksPassword = *chilkatc::CkSFtp_put_SocksPassword;
*get_SocksPort = *chilkatc::CkSFtp_get_SocksPort;
*put_SocksPort = *chilkatc::CkSFtp_put_SocksPort;
*get_SocksUsername = *chilkatc::CkSFtp_get_SocksUsername;
*socksUsername = *chilkatc::CkSFtp_socksUsername;
*put_SocksUsername = *chilkatc::CkSFtp_put_SocksUsername;
*get_SocksVersion = *chilkatc::CkSFtp_get_SocksVersion;
*put_SocksVersion = *chilkatc::CkSFtp_put_SocksVersion;
*get_SoRcvBuf = *chilkatc::CkSFtp_get_SoRcvBuf;
*put_SoRcvBuf = *chilkatc::CkSFtp_put_SoRcvBuf;
*get_SoSndBuf = *chilkatc::CkSFtp_get_SoSndBuf;
*put_SoSndBuf = *chilkatc::CkSFtp_put_SoSndBuf;
*get_SyncCreateAllLocalDirs = *chilkatc::CkSFtp_get_SyncCreateAllLocalDirs;
*put_SyncCreateAllLocalDirs = *chilkatc::CkSFtp_put_SyncCreateAllLocalDirs;
*get_SyncDirectives = *chilkatc::CkSFtp_get_SyncDirectives;
*syncDirectives = *chilkatc::CkSFtp_syncDirectives;
*put_SyncDirectives = *chilkatc::CkSFtp_put_SyncDirectives;
*get_SyncMustMatch = *chilkatc::CkSFtp_get_SyncMustMatch;
*syncMustMatch = *chilkatc::CkSFtp_syncMustMatch;
*put_SyncMustMatch = *chilkatc::CkSFtp_put_SyncMustMatch;
*get_SyncMustMatchDir = *chilkatc::CkSFtp_get_SyncMustMatchDir;
*syncMustMatchDir = *chilkatc::CkSFtp_syncMustMatchDir;
*put_SyncMustMatchDir = *chilkatc::CkSFtp_put_SyncMustMatchDir;
*get_SyncMustNotMatch = *chilkatc::CkSFtp_get_SyncMustNotMatch;
*syncMustNotMatch = *chilkatc::CkSFtp_syncMustNotMatch;
*put_SyncMustNotMatch = *chilkatc::CkSFtp_put_SyncMustNotMatch;
*get_SyncMustNotMatchDir = *chilkatc::CkSFtp_get_SyncMustNotMatchDir;
*syncMustNotMatchDir = *chilkatc::CkSFtp_syncMustNotMatchDir;
*put_SyncMustNotMatchDir = *chilkatc::CkSFtp_put_SyncMustNotMatchDir;
*get_TcpNoDelay = *chilkatc::CkSFtp_get_TcpNoDelay;
*put_TcpNoDelay = *chilkatc::CkSFtp_put_TcpNoDelay;
*get_UncommonOptions = *chilkatc::CkSFtp_get_UncommonOptions;
*uncommonOptions = *chilkatc::CkSFtp_uncommonOptions;
*put_UncommonOptions = *chilkatc::CkSFtp_put_UncommonOptions;
*get_UploadChunkSize = *chilkatc::CkSFtp_get_UploadChunkSize;
*put_UploadChunkSize = *chilkatc::CkSFtp_put_UploadChunkSize;
*get_UserAuthBanner = *chilkatc::CkSFtp_get_UserAuthBanner;
*userAuthBanner = *chilkatc::CkSFtp_userAuthBanner;
*put_UserAuthBanner = *chilkatc::CkSFtp_put_UserAuthBanner;
*get_UtcMode = *chilkatc::CkSFtp_get_UtcMode;
*put_UtcMode = *chilkatc::CkSFtp_put_UtcMode;
*get_VerboseLogging = *chilkatc::CkSFtp_get_VerboseLogging;
*put_VerboseLogging = *chilkatc::CkSFtp_put_VerboseLogging;
*get_Version = *chilkatc::CkSFtp_get_Version;
*version = *chilkatc::CkSFtp_version;
*get_XferByteCount = *chilkatc::CkSFtp_get_XferByteCount;
*get_XferByteCount64 = *chilkatc::CkSFtp_get_XferByteCount64;
*AccumulateBytes = *chilkatc::CkSFtp_AccumulateBytes;
*AccumulateBytesAsync = *chilkatc::CkSFtp_AccumulateBytesAsync;
*Add64 = *chilkatc::CkSFtp_Add64;
*add64 = *chilkatc::CkSFtp_add64;
*AuthenticatePk = *chilkatc::CkSFtp_AuthenticatePk;
*AuthenticatePkAsync = *chilkatc::CkSFtp_AuthenticatePkAsync;
*AuthenticatePw = *chilkatc::CkSFtp_AuthenticatePw;
*AuthenticatePwAsync = *chilkatc::CkSFtp_AuthenticatePwAsync;
*AuthenticatePwPk = *chilkatc::CkSFtp_AuthenticatePwPk;
*AuthenticatePwPkAsync = *chilkatc::CkSFtp_AuthenticatePwPkAsync;
*AuthenticateSecPw = *chilkatc::CkSFtp_AuthenticateSecPw;
*AuthenticateSecPwAsync = *chilkatc::CkSFtp_AuthenticateSecPwAsync;
*AuthenticateSecPwPk = *chilkatc::CkSFtp_AuthenticateSecPwPk;
*AuthenticateSecPwPkAsync = *chilkatc::CkSFtp_AuthenticateSecPwPkAsync;
*ClearAccumulateBuffer = *chilkatc::CkSFtp_ClearAccumulateBuffer;
*ClearCache = *chilkatc::CkSFtp_ClearCache;
*ClearSessionLog = *chilkatc::CkSFtp_ClearSessionLog;
*CloseHandle = *chilkatc::CkSFtp_CloseHandle;
*CloseHandleAsync = *chilkatc::CkSFtp_CloseHandleAsync;
*Connect = *chilkatc::CkSFtp_Connect;
*ConnectAsync = *chilkatc::CkSFtp_ConnectAsync;
*ConnectThroughSsh = *chilkatc::CkSFtp_ConnectThroughSsh;
*ConnectThroughSshAsync = *chilkatc::CkSFtp_ConnectThroughSshAsync;
*ContinueKeyboardAuth = *chilkatc::CkSFtp_ContinueKeyboardAuth;
*continueKeyboardAuth = *chilkatc::CkSFtp_continueKeyboardAuth;
*ContinueKeyboardAuthAsync = *chilkatc::CkSFtp_ContinueKeyboardAuthAsync;
*CopyFileAttr = *chilkatc::CkSFtp_CopyFileAttr;
*CopyFileAttrAsync = *chilkatc::CkSFtp_CopyFileAttrAsync;
*CreateDir = *chilkatc::CkSFtp_CreateDir;
*CreateDirAsync = *chilkatc::CkSFtp_CreateDirAsync;
*Disconnect = *chilkatc::CkSFtp_Disconnect;
*DownloadBd = *chilkatc::CkSFtp_DownloadBd;
*DownloadBdAsync = *chilkatc::CkSFtp_DownloadBdAsync;
*DownloadFile = *chilkatc::CkSFtp_DownloadFile;
*DownloadFileAsync = *chilkatc::CkSFtp_DownloadFileAsync;
*DownloadFileByName = *chilkatc::CkSFtp_DownloadFileByName;
*DownloadFileByNameAsync = *chilkatc::CkSFtp_DownloadFileByNameAsync;
*DownloadSb = *chilkatc::CkSFtp_DownloadSb;
*DownloadSbAsync = *chilkatc::CkSFtp_DownloadSbAsync;
*Eof = *chilkatc::CkSFtp_Eof;
*FileExists = *chilkatc::CkSFtp_FileExists;
*FileExistsAsync = *chilkatc::CkSFtp_FileExistsAsync;
*Fsync = *chilkatc::CkSFtp_Fsync;
*FsyncAsync = *chilkatc::CkSFtp_FsyncAsync;
*GetFileCreateDt = *chilkatc::CkSFtp_GetFileCreateDt;
*GetFileCreateDtAsync = *chilkatc::CkSFtp_GetFileCreateDtAsync;
*GetFileCreateTimeStr = *chilkatc::CkSFtp_GetFileCreateTimeStr;
*getFileCreateTimeStr = *chilkatc::CkSFtp_getFileCreateTimeStr;
*fileCreateTimeStr = *chilkatc::CkSFtp_fileCreateTimeStr;
*GetFileCreateTimeStrAsync = *chilkatc::CkSFtp_GetFileCreateTimeStrAsync;
*GetFileGroup = *chilkatc::CkSFtp_GetFileGroup;
*getFileGroup = *chilkatc::CkSFtp_getFileGroup;
*fileGroup = *chilkatc::CkSFtp_fileGroup;
*GetFileGroupAsync = *chilkatc::CkSFtp_GetFileGroupAsync;
*GetFileLastAccessDt = *chilkatc::CkSFtp_GetFileLastAccessDt;
*GetFileLastAccessDtAsync = *chilkatc::CkSFtp_GetFileLastAccessDtAsync;
*GetFileLastAccessStr = *chilkatc::CkSFtp_GetFileLastAccessStr;
*getFileLastAccessStr = *chilkatc::CkSFtp_getFileLastAccessStr;
*fileLastAccessStr = *chilkatc::CkSFtp_fileLastAccessStr;
*GetFileLastAccessStrAsync = *chilkatc::CkSFtp_GetFileLastAccessStrAsync;
*GetFileLastModifiedDt = *chilkatc::CkSFtp_GetFileLastModifiedDt;
*GetFileLastModifiedDtAsync = *chilkatc::CkSFtp_GetFileLastModifiedDtAsync;
*GetFileLastModifiedStr = *chilkatc::CkSFtp_GetFileLastModifiedStr;
*getFileLastModifiedStr = *chilkatc::CkSFtp_getFileLastModifiedStr;
*fileLastModifiedStr = *chilkatc::CkSFtp_fileLastModifiedStr;
*GetFileLastModifiedStrAsync = *chilkatc::CkSFtp_GetFileLastModifiedStrAsync;
*GetFileOwner = *chilkatc::CkSFtp_GetFileOwner;
*getFileOwner = *chilkatc::CkSFtp_getFileOwner;
*fileOwner = *chilkatc::CkSFtp_fileOwner;
*GetFileOwnerAsync = *chilkatc::CkSFtp_GetFileOwnerAsync;
*GetFilePermissions = *chilkatc::CkSFtp_GetFilePermissions;
*GetFilePermissionsAsync = *chilkatc::CkSFtp_GetFilePermissionsAsync;
*GetFileSize32 = *chilkatc::CkSFtp_GetFileSize32;
*GetFileSize32Async = *chilkatc::CkSFtp_GetFileSize32Async;
*GetFileSize64 = *chilkatc::CkSFtp_GetFileSize64;
*GetFileSize64Async = *chilkatc::CkSFtp_GetFileSize64Async;
*GetFileSizeStr = *chilkatc::CkSFtp_GetFileSizeStr;
*getFileSizeStr = *chilkatc::CkSFtp_getFileSizeStr;
*fileSizeStr = *chilkatc::CkSFtp_fileSizeStr;
*GetFileSizeStrAsync = *chilkatc::CkSFtp_GetFileSizeStrAsync;
*GetHostKeyFP = *chilkatc::CkSFtp_GetHostKeyFP;
*getHostKeyFP = *chilkatc::CkSFtp_getHostKeyFP;
*hostKeyFP = *chilkatc::CkSFtp_hostKeyFP;
*GetLastJsonData = *chilkatc::CkSFtp_GetLastJsonData;
*GetSyncedFiles = *chilkatc::CkSFtp_GetSyncedFiles;
*HardLink = *chilkatc::CkSFtp_HardLink;
*HardLinkAsync = *chilkatc::CkSFtp_HardLinkAsync;
*InitializeSftp = *chilkatc::CkSFtp_InitializeSftp;
*InitializeSftpAsync = *chilkatc::CkSFtp_InitializeSftpAsync;
*LastJsonData = *chilkatc::CkSFtp_LastJsonData;
*LastReadFailed = *chilkatc::CkSFtp_LastReadFailed;
*LastReadNumBytes = *chilkatc::CkSFtp_LastReadNumBytes;
*LoadTaskCaller = *chilkatc::CkSFtp_LoadTaskCaller;
*OpenDir = *chilkatc::CkSFtp_OpenDir;
*openDir = *chilkatc::CkSFtp_openDir;
*OpenDirAsync = *chilkatc::CkSFtp_OpenDirAsync;
*OpenFile = *chilkatc::CkSFtp_OpenFile;
*openFile = *chilkatc::CkSFtp_openFile;
*OpenFileAsync = *chilkatc::CkSFtp_OpenFileAsync;
*ReadDir = *chilkatc::CkSFtp_ReadDir;
*ReadDirAsync = *chilkatc::CkSFtp_ReadDirAsync;
*ReadDirListing = *chilkatc::CkSFtp_ReadDirListing;
*ReadDirListingAsync = *chilkatc::CkSFtp_ReadDirListingAsync;
*ReadFileBd = *chilkatc::CkSFtp_ReadFileBd;
*ReadFileBdAsync = *chilkatc::CkSFtp_ReadFileBdAsync;
*ReadFileBytes = *chilkatc::CkSFtp_ReadFileBytes;
*ReadFileBytesAsync = *chilkatc::CkSFtp_ReadFileBytesAsync;
*ReadFileBytes32 = *chilkatc::CkSFtp_ReadFileBytes32;
*ReadFileBytes32Async = *chilkatc::CkSFtp_ReadFileBytes32Async;
*ReadFileBytes64 = *chilkatc::CkSFtp_ReadFileBytes64;
*ReadFileBytes64Async = *chilkatc::CkSFtp_ReadFileBytes64Async;
*ReadFileBytes64s = *chilkatc::CkSFtp_ReadFileBytes64s;
*ReadFileBytes64sAsync = *chilkatc::CkSFtp_ReadFileBytes64sAsync;
*ReadFileText = *chilkatc::CkSFtp_ReadFileText;
*readFileText = *chilkatc::CkSFtp_readFileText;
*ReadFileTextAsync = *chilkatc::CkSFtp_ReadFileTextAsync;
*ReadFileText32 = *chilkatc::CkSFtp_ReadFileText32;
*readFileText32 = *chilkatc::CkSFtp_readFileText32;
*ReadFileText32Async = *chilkatc::CkSFtp_ReadFileText32Async;
*ReadFileText64 = *chilkatc::CkSFtp_ReadFileText64;
*readFileText64 = *chilkatc::CkSFtp_readFileText64;
*ReadFileText64Async = *chilkatc::CkSFtp_ReadFileText64Async;
*ReadFileText64s = *chilkatc::CkSFtp_ReadFileText64s;
*readFileText64s = *chilkatc::CkSFtp_readFileText64s;
*ReadFileText64sAsync = *chilkatc::CkSFtp_ReadFileText64sAsync;
*ReadLink = *chilkatc::CkSFtp_ReadLink;
*readLink = *chilkatc::CkSFtp_readLink;
*ReadLinkAsync = *chilkatc::CkSFtp_ReadLinkAsync;
*RealPath = *chilkatc::CkSFtp_RealPath;
*realPath = *chilkatc::CkSFtp_realPath;
*RealPathAsync = *chilkatc::CkSFtp_RealPathAsync;
*RemoveDir = *chilkatc::CkSFtp_RemoveDir;
*RemoveDirAsync = *chilkatc::CkSFtp_RemoveDirAsync;
*RemoveFile = *chilkatc::CkSFtp_RemoveFile;
*RemoveFileAsync = *chilkatc::CkSFtp_RemoveFileAsync;
*RenameFileOrDir = *chilkatc::CkSFtp_RenameFileOrDir;
*RenameFileOrDirAsync = *chilkatc::CkSFtp_RenameFileOrDirAsync;
*ResumeDownloadFileByName = *chilkatc::CkSFtp_ResumeDownloadFileByName;
*ResumeDownloadFileByNameAsync = *chilkatc::CkSFtp_ResumeDownloadFileByNameAsync;
*ResumeUploadFileByName = *chilkatc::CkSFtp_ResumeUploadFileByName;
*ResumeUploadFileByNameAsync = *chilkatc::CkSFtp_ResumeUploadFileByNameAsync;
*SendIgnore = *chilkatc::CkSFtp_SendIgnore;
*SendIgnoreAsync = *chilkatc::CkSFtp_SendIgnoreAsync;
*SetAllowedAlgorithms = *chilkatc::CkSFtp_SetAllowedAlgorithms;
*SetCreateDt = *chilkatc::CkSFtp_SetCreateDt;
*SetCreateDtAsync = *chilkatc::CkSFtp_SetCreateDtAsync;
*SetCreateTimeStr = *chilkatc::CkSFtp_SetCreateTimeStr;
*SetCreateTimeStrAsync = *chilkatc::CkSFtp_SetCreateTimeStrAsync;
*SetLastAccessDt = *chilkatc::CkSFtp_SetLastAccessDt;
*SetLastAccessDtAsync = *chilkatc::CkSFtp_SetLastAccessDtAsync;
*SetLastAccessTimeStr = *chilkatc::CkSFtp_SetLastAccessTimeStr;
*SetLastAccessTimeStrAsync = *chilkatc::CkSFtp_SetLastAccessTimeStrAsync;
*SetLastModifiedDt = *chilkatc::CkSFtp_SetLastModifiedDt;
*SetLastModifiedDtAsync = *chilkatc::CkSFtp_SetLastModifiedDtAsync;
*SetLastModifiedTimeStr = *chilkatc::CkSFtp_SetLastModifiedTimeStr;
*SetLastModifiedTimeStrAsync = *chilkatc::CkSFtp_SetLastModifiedTimeStrAsync;
*SetOwnerAndGroup = *chilkatc::CkSFtp_SetOwnerAndGroup;
*SetOwnerAndGroupAsync = *chilkatc::CkSFtp_SetOwnerAndGroupAsync;
*SetPermissions = *chilkatc::CkSFtp_SetPermissions;
*SetPermissionsAsync = *chilkatc::CkSFtp_SetPermissionsAsync;
*StartKeyboardAuth = *chilkatc::CkSFtp_StartKeyboardAuth;
*startKeyboardAuth = *chilkatc::CkSFtp_startKeyboardAuth;
*StartKeyboardAuthAsync = *chilkatc::CkSFtp_StartKeyboardAuthAsync;
*SymLink = *chilkatc::CkSFtp_SymLink;
*SymLinkAsync = *chilkatc::CkSFtp_SymLinkAsync;
*SyncTreeDownload = *chilkatc::CkSFtp_SyncTreeDownload;
*SyncTreeDownloadAsync = *chilkatc::CkSFtp_SyncTreeDownloadAsync;
*SyncTreeUpload = *chilkatc::CkSFtp_SyncTreeUpload;
*SyncTreeUploadAsync = *chilkatc::CkSFtp_SyncTreeUploadAsync;
*UploadBd = *chilkatc::CkSFtp_UploadBd;
*UploadBdAsync = *chilkatc::CkSFtp_UploadBdAsync;
*UploadFile = *chilkatc::CkSFtp_UploadFile;
*UploadFileAsync = *chilkatc::CkSFtp_UploadFileAsync;
*UploadFileByName = *chilkatc::CkSFtp_UploadFileByName;
*UploadFileByNameAsync = *chilkatc::CkSFtp_UploadFileByNameAsync;
*UploadSb = *chilkatc::CkSFtp_UploadSb;
*UploadSbAsync = *chilkatc::CkSFtp_UploadSbAsync;
*WriteFileBd = *chilkatc::CkSFtp_WriteFileBd;
*WriteFileBdAsync = *chilkatc::CkSFtp_WriteFileBdAsync;
*WriteFileBytes = *chilkatc::CkSFtp_WriteFileBytes;
*WriteFileBytesAsync = *chilkatc::CkSFtp_WriteFileBytesAsync;
*WriteFileBytes32 = *chilkatc::CkSFtp_WriteFileBytes32;
*WriteFileBytes32Async = *chilkatc::CkSFtp_WriteFileBytes32Async;
*WriteFileBytes64 = *chilkatc::CkSFtp_WriteFileBytes64;
*WriteFileBytes64Async = *chilkatc::CkSFtp_WriteFileBytes64Async;
*WriteFileBytes64s = *chilkatc::CkSFtp_WriteFileBytes64s;
*WriteFileBytes64sAsync = *chilkatc::CkSFtp_WriteFileBytes64sAsync;
*WriteFileText = *chilkatc::CkSFtp_WriteFileText;
*WriteFileTextAsync = *chilkatc::CkSFtp_WriteFileTextAsync;
*WriteFileText32 = *chilkatc::CkSFtp_WriteFileText32;
*WriteFileText32Async = *chilkatc::CkSFtp_WriteFileText32Async;
*WriteFileText64 = *chilkatc::CkSFtp_WriteFileText64;
*WriteFileText64Async = *chilkatc::CkSFtp_WriteFileText64Async;
*WriteFileText64s = *chilkatc::CkSFtp_WriteFileText64s;
*WriteFileText64sAsync = *chilkatc::CkSFtp_WriteFileText64sAsync;
sub DISOWN {
    my $self = shift;
    my $ptr = tied(%$self);
    delete $OWNER{$ptr};
}

sub ACQUIRE {
    my $self = shift;
    my $ptr = tied(%$self);
    $OWNER{$ptr} = 1;
}


############# Class : chilkat::CkSFtpDir ##############

package chilkat::CkSFtpDir;
use vars qw(@ISA %OWNER %ITERATORS %BLESSEDMEMBERS);
@ISA = qw( chilkat );
%OWNER = ();
%ITERATORS = ();
sub new {
    my $pkg = shift;
    my $self = chilkatc::new_CkSFtpDir(@_);
    bless $self, $pkg if defined($self);
}

sub DESTROY {
    return unless $_[0]->isa('HASH');
    my $self = tied(%{$_[0]});
    return unless defined $self;
    delete $ITERATORS{$self};
    if (exists $OWNER{$self}) {
        chilkatc::delete_CkSFtpDir($self);
        delete $OWNER{$self};
    }
}

*get_Utf8 = *chilkatc::CkSFtpDir_get_Utf8;
*put_Utf8 = *chilkatc::CkSFtpDir_put_Utf8;
*get_DebugLogFilePath = *chilkatc::CkSFtpDir_get_DebugLogFilePath;
*debugLogFilePath = *chilkatc::CkSFtpDir_debugLogFilePath;
*put_DebugLogFilePath = *chilkatc::CkSFtpDir_put_DebugLogFilePath;
*get_LastErrorHtml = *chilkatc::CkSFtpDir_get_LastErrorHtml;
*lastErrorHtml = *chilkatc::CkSFtpDir_lastErrorHtml;
*get_LastErrorText = *chilkatc::CkSFtpDir_get_LastErrorText;
*lastErrorText = *chilkatc::CkSFtpDir_lastErrorText;
*get_LastErrorXml = *chilkatc::CkSFtpDir_get_LastErrorXml;
*lastErrorXml = *chilkatc::CkSFtpDir_lastErrorXml;
*get_LastMethodSuccess = *chilkatc::CkSFtpDir_get_LastMethodSuccess;
*put_LastMethodSuccess = *chilkatc::CkSFtpDir_put_LastMethodSuccess;
*get_NumFilesAndDirs = *chilkatc::CkSFtpDir_get_NumFilesAndDirs;
*get_OriginalPath = *chilkatc::CkSFtpDir_get_OriginalPath;
*originalPath = *chilkatc::CkSFtpDir_originalPath;
*get_VerboseLogging = *chilkatc::CkSFtpDir_get_VerboseLogging;
*put_VerboseLogging = *chilkatc::CkSFtpDir_put_VerboseLogging;
*get_Version = *chilkatc::CkSFtpDir_get_Version;
*version = *chilkatc::CkSFtpDir_version;
*FileAt = *chilkatc::CkSFtpDir_FileAt;
*GetFilename = *chilkatc::CkSFtpDir_GetFilename;
*getFilename = *chilkatc::CkSFtpDir_getFilename;
*filename = *chilkatc::CkSFtpDir_filename;
*GetFileObject = *chilkatc::CkSFtpDir_GetFileObject;
*LoadTaskResult = *chilkatc::CkSFtpDir_LoadTaskResult;
*Sort = *chilkatc::CkSFtpDir_Sort;
sub DISOWN {
    my $self = shift;
    my $ptr = tied(%$self);
    delete $OWNER{$ptr};
}

sub ACQUIRE {
    my $self = shift;
    my $ptr = tied(%$self);
    $OWNER{$ptr} = 1;
}


############# Class : chilkat::CkSFtpFile ##############

package chilkat::CkSFtpFile;
use vars qw(@ISA %OWNER %ITERATORS %BLESSEDMEMBERS);
@ISA = qw( chilkat );
%OWNER = ();
%ITERATORS = ();
sub new {
    my $pkg = shift;
    my $self = chilkatc::new_CkSFtpFile(@_);
    bless $self, $pkg if defined($self);
}

sub DESTROY {
    return unless $_[0]->isa('HASH');
    my $self = tied(%{$_[0]});
    return unless defined $self;
    delete $ITERATORS{$self};
    if (exists $OWNER{$self}) {
        chilkatc::delete_CkSFtpFile($self);
        delete $OWNER{$self};
    }
}

*get_Utf8 = *chilkatc::CkSFtpFile_get_Utf8;
*put_Utf8 = *chilkatc::CkSFtpFile_put_Utf8;
*get_CreateTimeStr = *chilkatc::CkSFtpFile_get_CreateTimeStr;
*createTimeStr = *chilkatc::CkSFtpFile_createTimeStr;
*get_DebugLogFilePath = *chilkatc::CkSFtpFile_get_DebugLogFilePath;
*debugLogFilePath = *chilkatc::CkSFtpFile_debugLogFilePath;
*put_DebugLogFilePath = *chilkatc::CkSFtpFile_put_DebugLogFilePath;
*get_Filename = *chilkatc::CkSFtpFile_get_Filename;
*filename = *chilkatc::CkSFtpFile_filename;
*get_FileType = *chilkatc::CkSFtpFile_get_FileType;
*fileType = *chilkatc::CkSFtpFile_fileType;
*get_Gid = *chilkatc::CkSFtpFile_get_Gid;
*get_Group = *chilkatc::CkSFtpFile_get_Group;
*group = *chilkatc::CkSFtpFile_group;
*get_IsAppendOnly = *chilkatc::CkSFtpFile_get_IsAppendOnly;
*get_IsArchive = *chilkatc::CkSFtpFile_get_IsArchive;
*get_IsCaseInsensitive = *chilkatc::CkSFtpFile_get_IsCaseInsensitive;
*get_IsCompressed = *chilkatc::CkSFtpFile_get_IsCompressed;
*get_IsDirectory = *chilkatc::CkSFtpFile_get_IsDirectory;
*get_IsEncrypted = *chilkatc::CkSFtpFile_get_IsEncrypted;
*get_IsHidden = *chilkatc::CkSFtpFile_get_IsHidden;
*get_IsImmutable = *chilkatc::CkSFtpFile_get_IsImmutable;
*get_IsReadOnly = *chilkatc::CkSFtpFile_get_IsReadOnly;
*get_IsRegular = *chilkatc::CkSFtpFile_get_IsRegular;
*get_IsSparse = *chilkatc::CkSFtpFile_get_IsSparse;
*get_IsSymLink = *chilkatc::CkSFtpFile_get_IsSymLink;
*get_IsSync = *chilkatc::CkSFtpFile_get_IsSync;
*get_IsSystem = *chilkatc::CkSFtpFile_get_IsSystem;
*get_LastAccessTimeStr = *chilkatc::CkSFtpFile_get_LastAccessTimeStr;
*lastAccessTimeStr = *chilkatc::CkSFtpFile_lastAccessTimeStr;
*get_LastErrorHtml = *chilkatc::CkSFtpFile_get_LastErrorHtml;
*lastErrorHtml = *chilkatc::CkSFtpFile_lastErrorHtml;
*get_LastErrorText = *chilkatc::CkSFtpFile_get_LastErrorText;
*lastErrorText = *chilkatc::CkSFtpFile_lastErrorText;
*get_LastErrorXml = *chilkatc::CkSFtpFile_get_LastErrorXml;
*lastErrorXml = *chilkatc::CkSFtpFile_lastErrorXml;
*get_LastMethodSuccess = *chilkatc::CkSFtpFile_get_LastMethodSuccess;
*put_LastMethodSuccess = *chilkatc::CkSFtpFile_put_LastMethodSuccess;
*get_LastModifiedTimeStr = *chilkatc::CkSFtpFile_get_LastModifiedTimeStr;
*lastModifiedTimeStr = *chilkatc::CkSFtpFile_lastModifiedTimeStr;
*get_Owner = *chilkatc::CkSFtpFile_get_Owner;
*owner = *chilkatc::CkSFtpFile_owner;
*get_Permissions = *chilkatc::CkSFtpFile_get_Permissions;
*get_Size32 = *chilkatc::CkSFtpFile_get_Size32;
*get_Size64 = *chilkatc::CkSFtpFile_get_Size64;
*get_SizeStr = *chilkatc::CkSFtpFile_get_SizeStr;
*sizeStr = *chilkatc::CkSFtpFile_sizeStr;
*get_Uid = *chilkatc::CkSFtpFile_get_Uid;
*get_VerboseLogging = *chilkatc::CkSFtpFile_get_VerboseLogging;
*put_VerboseLogging = *chilkatc::CkSFtpFile_put_VerboseLogging;
*get_Version = *chilkatc::CkSFtpFile_get_Version;
*version = *chilkatc::CkSFtpFile_version;
*GetCreateDt = *chilkatc::CkSFtpFile_GetCreateDt;
*GetLastAccessDt = *chilkatc::CkSFtpFile_GetLastAccessDt;
*GetLastModifiedDt = *chilkatc::CkSFtpFile_GetLastModifiedDt;
sub DISOWN {
    my $self = shift;
    my $ptr = tied(%$self);
    delete $OWNER{$ptr};
}

sub ACQUIRE {
    my $self = shift;
    my $ptr = tied(%$self);
    $OWNER{$ptr} = 1;
}


############# Class : chilkat::CkScMinidriver ##############

package chilkat::CkScMinidriver;
use vars qw(@ISA %OWNER %ITERATORS %BLESSEDMEMBERS);
@ISA = qw( chilkat );
%OWNER = ();
%ITERATORS = ();
sub new {
    my $pkg = shift;
    my $self = chilkatc::new_CkScMinidriver(@_);
    bless $self, $pkg if defined($self);
}

sub DESTROY {
    return unless $_[0]->isa('HASH');
    my $self = tied(%{$_[0]});
    return unless defined $self;
    delete $ITERATORS{$self};
    if (exists $OWNER{$self}) {
        chilkatc::delete_CkScMinidriver($self);
        delete $OWNER{$self};
    }
}

*get_Utf8 = *chilkatc::CkScMinidriver_get_Utf8;
*put_Utf8 = *chilkatc::CkScMinidriver_put_Utf8;
*LastErrorXml = *chilkatc::CkScMinidriver_LastErrorXml;
*LastErrorHtml = *chilkatc::CkScMinidriver_LastErrorHtml;
*LastErrorText = *chilkatc::CkScMinidriver_LastErrorText;
*get_Atr = *chilkatc::CkScMinidriver_get_Atr;
*atr = *chilkatc::CkScMinidriver_atr;
*get_CardName = *chilkatc::CkScMinidriver_get_CardName;
*cardName = *chilkatc::CkScMinidriver_cardName;
*get_DebugLogFilePath = *chilkatc::CkScMinidriver_get_DebugLogFilePath;
*debugLogFilePath = *chilkatc::CkScMinidriver_debugLogFilePath;
*put_DebugLogFilePath = *chilkatc::CkScMinidriver_put_DebugLogFilePath;
*get_LastErrorHtml = *chilkatc::CkScMinidriver_get_LastErrorHtml;
*lastErrorHtml = *chilkatc::CkScMinidriver_lastErrorHtml;
*get_LastErrorText = *chilkatc::CkScMinidriver_get_LastErrorText;
*lastErrorText = *chilkatc::CkScMinidriver_lastErrorText;
*get_LastErrorXml = *chilkatc::CkScMinidriver_get_LastErrorXml;
*lastErrorXml = *chilkatc::CkScMinidriver_lastErrorXml;
*get_LastMethodSuccess = *chilkatc::CkScMinidriver_get_LastMethodSuccess;
*put_LastMethodSuccess = *chilkatc::CkScMinidriver_put_LastMethodSuccess;
*get_MaxContainers = *chilkatc::CkScMinidriver_get_MaxContainers;
*get_RsaPaddingHash = *chilkatc::CkScMinidriver_get_RsaPaddingHash;
*rsaPaddingHash = *chilkatc::CkScMinidriver_rsaPaddingHash;
*put_RsaPaddingHash = *chilkatc::CkScMinidriver_put_RsaPaddingHash;
*get_RsaPaddingScheme = *chilkatc::CkScMinidriver_get_RsaPaddingScheme;
*rsaPaddingScheme = *chilkatc::CkScMinidriver_rsaPaddingScheme;
*put_RsaPaddingScheme = *chilkatc::CkScMinidriver_put_RsaPaddingScheme;
*get_UncommonOptions = *chilkatc::CkScMinidriver_get_UncommonOptions;
*uncommonOptions = *chilkatc::CkScMinidriver_uncommonOptions;
*put_UncommonOptions = *chilkatc::CkScMinidriver_put_UncommonOptions;
*get_VerboseLogging = *chilkatc::CkScMinidriver_get_VerboseLogging;
*put_VerboseLogging = *chilkatc::CkScMinidriver_put_VerboseLogging;
*get_Version = *chilkatc::CkScMinidriver_get_Version;
*version = *chilkatc::CkScMinidriver_version;
*AcquireContext = *chilkatc::CkScMinidriver_AcquireContext;
*CardDeleteFile = *chilkatc::CkScMinidriver_CardDeleteFile;
*DeleteCert = *chilkatc::CkScMinidriver_DeleteCert;
*DeleteContext = *chilkatc::CkScMinidriver_DeleteContext;
*DeleteKeyContainer = *chilkatc::CkScMinidriver_DeleteKeyContainer;
*EnumFiles = *chilkatc::CkScMinidriver_EnumFiles;
*FindCert = *chilkatc::CkScMinidriver_FindCert;
*GenerateKey = *chilkatc::CkScMinidriver_GenerateKey;
*GetCardProperties = *chilkatc::CkScMinidriver_GetCardProperties;
*GetCert = *chilkatc::CkScMinidriver_GetCert;
*GetContainerKeys = *chilkatc::CkScMinidriver_GetContainerKeys;
*GetCspContainerMap = *chilkatc::CkScMinidriver_GetCspContainerMap;
*ImportCert = *chilkatc::CkScMinidriver_ImportCert;
*ImportKey = *chilkatc::CkScMinidriver_ImportKey;
*ListCerts = *chilkatc::CkScMinidriver_ListCerts;
*PinAuthenticate = *chilkatc::CkScMinidriver_PinAuthenticate;
*PinAuthenticateHex = *chilkatc::CkScMinidriver_PinAuthenticateHex;
*PinChange = *chilkatc::CkScMinidriver_PinChange;
*PinDeauthenticate = *chilkatc::CkScMinidriver_PinDeauthenticate;
*ReadFile = *chilkatc::CkScMinidriver_ReadFile;
*SignData = *chilkatc::CkScMinidriver_SignData;
*WriteFile = *chilkatc::CkScMinidriver_WriteFile;
sub DISOWN {
    my $self = shift;
    my $ptr = tied(%$self);
    delete $OWNER{$ptr};
}

sub ACQUIRE {
    my $self = shift;
    my $ptr = tied(%$self);
    $OWNER{$ptr} = 1;
}


############# Class : chilkat::CkScp ##############

package chilkat::CkScp;
use vars qw(@ISA %OWNER %ITERATORS %BLESSEDMEMBERS);
@ISA = qw( chilkat );
%OWNER = ();
%ITERATORS = ();
sub new {
    my $pkg = shift;
    my $self = chilkatc::new_CkScp(@_);
    bless $self, $pkg if defined($self);
}

sub DESTROY {
    return unless $_[0]->isa('HASH');
    my $self = tied(%{$_[0]});
    return unless defined $self;
    delete $ITERATORS{$self};
    if (exists $OWNER{$self}) {
        chilkatc::delete_CkScp($self);
        delete $OWNER{$self};
    }
}

*get_Utf8 = *chilkatc::CkScp_get_Utf8;
*put_Utf8 = *chilkatc::CkScp_put_Utf8;
*LastErrorXml = *chilkatc::CkScp_LastErrorXml;
*LastErrorHtml = *chilkatc::CkScp_LastErrorHtml;
*LastErrorText = *chilkatc::CkScp_LastErrorText;
*put_EventCallbackObject = *chilkatc::CkScp_put_EventCallbackObject;
*get_AbortCurrent = *chilkatc::CkScp_get_AbortCurrent;
*put_AbortCurrent = *chilkatc::CkScp_put_AbortCurrent;
*get_DebugLogFilePath = *chilkatc::CkScp_get_DebugLogFilePath;
*debugLogFilePath = *chilkatc::CkScp_debugLogFilePath;
*put_DebugLogFilePath = *chilkatc::CkScp_put_DebugLogFilePath;
*get_HeartbeatMs = *chilkatc::CkScp_get_HeartbeatMs;
*put_HeartbeatMs = *chilkatc::CkScp_put_HeartbeatMs;
*get_LastErrorHtml = *chilkatc::CkScp_get_LastErrorHtml;
*lastErrorHtml = *chilkatc::CkScp_lastErrorHtml;
*get_LastErrorText = *chilkatc::CkScp_get_LastErrorText;
*lastErrorText = *chilkatc::CkScp_lastErrorText;
*get_LastErrorXml = *chilkatc::CkScp_get_LastErrorXml;
*lastErrorXml = *chilkatc::CkScp_lastErrorXml;
*get_LastMethodSuccess = *chilkatc::CkScp_get_LastMethodSuccess;
*put_LastMethodSuccess = *chilkatc::CkScp_put_LastMethodSuccess;
*get_PercentDoneScale = *chilkatc::CkScp_get_PercentDoneScale;
*put_PercentDoneScale = *chilkatc::CkScp_put_PercentDoneScale;
*get_SendEnv = *chilkatc::CkScp_get_SendEnv;
*sendEnv = *chilkatc::CkScp_sendEnv;
*put_SendEnv = *chilkatc::CkScp_put_SendEnv;
*get_SyncedFiles = *chilkatc::CkScp_get_SyncedFiles;
*syncedFiles = *chilkatc::CkScp_syncedFiles;
*put_SyncedFiles = *chilkatc::CkScp_put_SyncedFiles;
*get_SyncMustMatch = *chilkatc::CkScp_get_SyncMustMatch;
*syncMustMatch = *chilkatc::CkScp_syncMustMatch;
*put_SyncMustMatch = *chilkatc::CkScp_put_SyncMustMatch;
*get_SyncMustMatchDir = *chilkatc::CkScp_get_SyncMustMatchDir;
*syncMustMatchDir = *chilkatc::CkScp_syncMustMatchDir;
*put_SyncMustMatchDir = *chilkatc::CkScp_put_SyncMustMatchDir;
*get_SyncMustNotMatch = *chilkatc::CkScp_get_SyncMustNotMatch;
*syncMustNotMatch = *chilkatc::CkScp_syncMustNotMatch;
*put_SyncMustNotMatch = *chilkatc::CkScp_put_SyncMustNotMatch;
*get_SyncMustNotMatchDir = *chilkatc::CkScp_get_SyncMustNotMatchDir;
*syncMustNotMatchDir = *chilkatc::CkScp_syncMustNotMatchDir;
*put_SyncMustNotMatchDir = *chilkatc::CkScp_put_SyncMustNotMatchDir;
*get_UncommonOptions = *chilkatc::CkScp_get_UncommonOptions;
*uncommonOptions = *chilkatc::CkScp_uncommonOptions;
*put_UncommonOptions = *chilkatc::CkScp_put_UncommonOptions;
*get_UnixPermOverride = *chilkatc::CkScp_get_UnixPermOverride;
*unixPermOverride = *chilkatc::CkScp_unixPermOverride;
*put_UnixPermOverride = *chilkatc::CkScp_put_UnixPermOverride;
*get_VerboseLogging = *chilkatc::CkScp_get_VerboseLogging;
*put_VerboseLogging = *chilkatc::CkScp_put_VerboseLogging;
*get_Version = *chilkatc::CkScp_get_Version;
*version = *chilkatc::CkScp_version;
*DownloadBd = *chilkatc::CkScp_DownloadBd;
*DownloadBdAsync = *chilkatc::CkScp_DownloadBdAsync;
*DownloadBinary = *chilkatc::CkScp_DownloadBinary;
*DownloadBinaryAsync = *chilkatc::CkScp_DownloadBinaryAsync;
*DownloadBinaryEncoded = *chilkatc::CkScp_DownloadBinaryEncoded;
*downloadBinaryEncoded = *chilkatc::CkScp_downloadBinaryEncoded;
*DownloadBinaryEncodedAsync = *chilkatc::CkScp_DownloadBinaryEncodedAsync;
*DownloadFile = *chilkatc::CkScp_DownloadFile;
*DownloadFileAsync = *chilkatc::CkScp_DownloadFileAsync;
*DownloadString = *chilkatc::CkScp_DownloadString;
*downloadString = *chilkatc::CkScp_downloadString;
*DownloadStringAsync = *chilkatc::CkScp_DownloadStringAsync;
*LoadTaskCaller = *chilkatc::CkScp_LoadTaskCaller;
*SyncTreeDownload = *chilkatc::CkScp_SyncTreeDownload;
*SyncTreeDownloadAsync = *chilkatc::CkScp_SyncTreeDownloadAsync;
*SyncTreeUpload = *chilkatc::CkScp_SyncTreeUpload;
*SyncTreeUploadAsync = *chilkatc::CkScp_SyncTreeUploadAsync;
*UploadBd = *chilkatc::CkScp_UploadBd;
*UploadBdAsync = *chilkatc::CkScp_UploadBdAsync;
*UploadBinary = *chilkatc::CkScp_UploadBinary;
*UploadBinaryAsync = *chilkatc::CkScp_UploadBinaryAsync;
*UploadBinaryEncoded = *chilkatc::CkScp_UploadBinaryEncoded;
*UploadBinaryEncodedAsync = *chilkatc::CkScp_UploadBinaryEncodedAsync;
*UploadFile = *chilkatc::CkScp_UploadFile;
*UploadFileAsync = *chilkatc::CkScp_UploadFileAsync;
*UploadString = *chilkatc::CkScp_UploadString;
*UploadStringAsync = *chilkatc::CkScp_UploadStringAsync;
*UseSsh = *chilkatc::CkScp_UseSsh;
sub DISOWN {
    my $self = shift;
    my $ptr = tied(%$self);
    delete $OWNER{$ptr};
}

sub ACQUIRE {
    my $self = shift;
    my $ptr = tied(%$self);
    $OWNER{$ptr} = 1;
}


############# Class : chilkat::CkSecrets ##############

package chilkat::CkSecrets;
use vars qw(@ISA %OWNER %ITERATORS %BLESSEDMEMBERS);
@ISA = qw( chilkat );
%OWNER = ();
%ITERATORS = ();
sub new {
    my $pkg = shift;
    my $self = chilkatc::new_CkSecrets(@_);
    bless $self, $pkg if defined($self);
}

sub DESTROY {
    return unless $_[0]->isa('HASH');
    my $self = tied(%{$_[0]});
    return unless defined $self;
    delete $ITERATORS{$self};
    if (exists $OWNER{$self}) {
        chilkatc::delete_CkSecrets($self);
        delete $OWNER{$self};
    }
}

*get_Utf8 = *chilkatc::CkSecrets_get_Utf8;
*put_Utf8 = *chilkatc::CkSecrets_put_Utf8;
*LastErrorXml = *chilkatc::CkSecrets_LastErrorXml;
*LastErrorHtml = *chilkatc::CkSecrets_LastErrorHtml;
*LastErrorText = *chilkatc::CkSecrets_LastErrorText;
*put_EventCallbackObject = *chilkatc::CkSecrets_put_EventCallbackObject;
*get_AutoSplit = *chilkatc::CkSecrets_get_AutoSplit;
*put_AutoSplit = *chilkatc::CkSecrets_put_AutoSplit;
*get_Compression = *chilkatc::CkSecrets_get_Compression;
*put_Compression = *chilkatc::CkSecrets_put_Compression;
*get_DebugLogFilePath = *chilkatc::CkSecrets_get_DebugLogFilePath;
*debugLogFilePath = *chilkatc::CkSecrets_debugLogFilePath;
*put_DebugLogFilePath = *chilkatc::CkSecrets_put_DebugLogFilePath;
*get_LastErrorHtml = *chilkatc::CkSecrets_get_LastErrorHtml;
*lastErrorHtml = *chilkatc::CkSecrets_lastErrorHtml;
*get_LastErrorText = *chilkatc::CkSecrets_get_LastErrorText;
*lastErrorText = *chilkatc::CkSecrets_lastErrorText;
*get_LastErrorXml = *chilkatc::CkSecrets_get_LastErrorXml;
*lastErrorXml = *chilkatc::CkSecrets_lastErrorXml;
*get_LastMethodSuccess = *chilkatc::CkSecrets_get_LastMethodSuccess;
*put_LastMethodSuccess = *chilkatc::CkSecrets_put_LastMethodSuccess;
*get_Location = *chilkatc::CkSecrets_get_Location;
*location = *chilkatc::CkSecrets_location;
*put_Location = *chilkatc::CkSecrets_put_Location;
*get_UncommonOptions = *chilkatc::CkSecrets_get_UncommonOptions;
*uncommonOptions = *chilkatc::CkSecrets_uncommonOptions;
*put_UncommonOptions = *chilkatc::CkSecrets_put_UncommonOptions;
*get_VerboseLogging = *chilkatc::CkSecrets_get_VerboseLogging;
*put_VerboseLogging = *chilkatc::CkSecrets_put_VerboseLogging;
*get_Version = *chilkatc::CkSecrets_get_Version;
*version = *chilkatc::CkSecrets_version;
*DeleteSecret = *chilkatc::CkSecrets_DeleteSecret;
*DeleteSecretAsync = *chilkatc::CkSecrets_DeleteSecretAsync;
*GetSecretBd = *chilkatc::CkSecrets_GetSecretBd;
*GetSecretBdAsync = *chilkatc::CkSecrets_GetSecretBdAsync;
*GetSecretJson = *chilkatc::CkSecrets_GetSecretJson;
*GetSecretJsonAsync = *chilkatc::CkSecrets_GetSecretJsonAsync;
*GetSecretSb = *chilkatc::CkSecrets_GetSecretSb;
*GetSecretSbAsync = *chilkatc::CkSecrets_GetSecretSbAsync;
*GetSecretStr = *chilkatc::CkSecrets_GetSecretStr;
*getSecretStr = *chilkatc::CkSecrets_getSecretStr;
*secretStr = *chilkatc::CkSecrets_secretStr;
*GetSecretStrAsync = *chilkatc::CkSecrets_GetSecretStrAsync;
*ListSecrets = *chilkatc::CkSecrets_ListSecrets;
*ListSecretsAsync = *chilkatc::CkSecrets_ListSecretsAsync;
*SetBootstrapSecret = *chilkatc::CkSecrets_SetBootstrapSecret;
*UpdateSecretBd = *chilkatc::CkSecrets_UpdateSecretBd;
*UpdateSecretBdAsync = *chilkatc::CkSecrets_UpdateSecretBdAsync;
*UpdateSecretJson = *chilkatc::CkSecrets_UpdateSecretJson;
*UpdateSecretJsonAsync = *chilkatc::CkSecrets_UpdateSecretJsonAsync;
*UpdateSecretSb = *chilkatc::CkSecrets_UpdateSecretSb;
*UpdateSecretSbAsync = *chilkatc::CkSecrets_UpdateSecretSbAsync;
*UpdateSecretStr = *chilkatc::CkSecrets_UpdateSecretStr;
*UpdateSecretStrAsync = *chilkatc::CkSecrets_UpdateSecretStrAsync;
sub DISOWN {
    my $self = shift;
    my $ptr = tied(%$self);
    delete $OWNER{$ptr};
}

sub ACQUIRE {
    my $self = shift;
    my $ptr = tied(%$self);
    $OWNER{$ptr} = 1;
}


############# Class : chilkat::CkSecureString ##############

package chilkat::CkSecureString;
use vars qw(@ISA %OWNER %ITERATORS %BLESSEDMEMBERS);
@ISA = qw( chilkat );
%OWNER = ();
%ITERATORS = ();
sub new {
    my $pkg = shift;
    my $self = chilkatc::new_CkSecureString(@_);
    bless $self, $pkg if defined($self);
}

sub DESTROY {
    return unless $_[0]->isa('HASH');
    my $self = tied(%{$_[0]});
    return unless defined $self;
    delete $ITERATORS{$self};
    if (exists $OWNER{$self}) {
        chilkatc::delete_CkSecureString($self);
        delete $OWNER{$self};
    }
}

*get_Utf8 = *chilkatc::CkSecureString_get_Utf8;
*put_Utf8 = *chilkatc::CkSecureString_put_Utf8;
*get_DebugLogFilePath = *chilkatc::CkSecureString_get_DebugLogFilePath;
*debugLogFilePath = *chilkatc::CkSecureString_debugLogFilePath;
*put_DebugLogFilePath = *chilkatc::CkSecureString_put_DebugLogFilePath;
*get_LastErrorHtml = *chilkatc::CkSecureString_get_LastErrorHtml;
*lastErrorHtml = *chilkatc::CkSecureString_lastErrorHtml;
*get_LastErrorText = *chilkatc::CkSecureString_get_LastErrorText;
*lastErrorText = *chilkatc::CkSecureString_lastErrorText;
*get_LastErrorXml = *chilkatc::CkSecureString_get_LastErrorXml;
*lastErrorXml = *chilkatc::CkSecureString_lastErrorXml;
*get_LastMethodSuccess = *chilkatc::CkSecureString_get_LastMethodSuccess;
*put_LastMethodSuccess = *chilkatc::CkSecureString_put_LastMethodSuccess;
*get_MaintainHash = *chilkatc::CkSecureString_get_MaintainHash;
*maintainHash = *chilkatc::CkSecureString_maintainHash;
*put_MaintainHash = *chilkatc::CkSecureString_put_MaintainHash;
*get_ReadOnly = *chilkatc::CkSecureString_get_ReadOnly;
*put_ReadOnly = *chilkatc::CkSecureString_put_ReadOnly;
*get_VerboseLogging = *chilkatc::CkSecureString_get_VerboseLogging;
*put_VerboseLogging = *chilkatc::CkSecureString_put_VerboseLogging;
*get_Version = *chilkatc::CkSecureString_get_Version;
*version = *chilkatc::CkSecureString_version;
*Access = *chilkatc::CkSecureString_Access;
*access = *chilkatc::CkSecureString_access;
*Append = *chilkatc::CkSecureString_Append;
*AppendSb = *chilkatc::CkSecureString_AppendSb;
*AppendSecure = *chilkatc::CkSecureString_AppendSecure;
*HashVal = *chilkatc::CkSecureString_HashVal;
*hashVal = *chilkatc::CkSecureString_hashVal;
*LoadFile = *chilkatc::CkSecureString_LoadFile;
*SecStrEquals = *chilkatc::CkSecureString_SecStrEquals;
*VerifyHash = *chilkatc::CkSecureString_VerifyHash;
sub DISOWN {
    my $self = shift;
    my $ptr = tied(%$self);
    delete $OWNER{$ptr};
}

sub ACQUIRE {
    my $self = shift;
    my $ptr = tied(%$self);
    $OWNER{$ptr} = 1;
}


############# Class : chilkat::CkServerSentEvent ##############

package chilkat::CkServerSentEvent;
use vars qw(@ISA %OWNER %ITERATORS %BLESSEDMEMBERS);
@ISA = qw( chilkat );
%OWNER = ();
%ITERATORS = ();
sub new {
    my $pkg = shift;
    my $self = chilkatc::new_CkServerSentEvent(@_);
    bless $self, $pkg if defined($self);
}

sub DESTROY {
    return unless $_[0]->isa('HASH');
    my $self = tied(%{$_[0]});
    return unless defined $self;
    delete $ITERATORS{$self};
    if (exists $OWNER{$self}) {
        chilkatc::delete_CkServerSentEvent($self);
        delete $OWNER{$self};
    }
}

*get_Utf8 = *chilkatc::CkServerSentEvent_get_Utf8;
*put_Utf8 = *chilkatc::CkServerSentEvent_put_Utf8;
*get_Data = *chilkatc::CkServerSentEvent_get_Data;
*data = *chilkatc::CkServerSentEvent_data;
*get_DebugLogFilePath = *chilkatc::CkServerSentEvent_get_DebugLogFilePath;
*debugLogFilePath = *chilkatc::CkServerSentEvent_debugLogFilePath;
*put_DebugLogFilePath = *chilkatc::CkServerSentEvent_put_DebugLogFilePath;
*get_EventName = *chilkatc::CkServerSentEvent_get_EventName;
*eventName = *chilkatc::CkServerSentEvent_eventName;
*get_LastErrorHtml = *chilkatc::CkServerSentEvent_get_LastErrorHtml;
*lastErrorHtml = *chilkatc::CkServerSentEvent_lastErrorHtml;
*get_LastErrorText = *chilkatc::CkServerSentEvent_get_LastErrorText;
*lastErrorText = *chilkatc::CkServerSentEvent_lastErrorText;
*get_LastErrorXml = *chilkatc::CkServerSentEvent_get_LastErrorXml;
*lastErrorXml = *chilkatc::CkServerSentEvent_lastErrorXml;
*get_LastEventId = *chilkatc::CkServerSentEvent_get_LastEventId;
*lastEventId = *chilkatc::CkServerSentEvent_lastEventId;
*get_LastMethodSuccess = *chilkatc::CkServerSentEvent_get_LastMethodSuccess;
*put_LastMethodSuccess = *chilkatc::CkServerSentEvent_put_LastMethodSuccess;
*get_Retry = *chilkatc::CkServerSentEvent_get_Retry;
*get_VerboseLogging = *chilkatc::CkServerSentEvent_get_VerboseLogging;
*put_VerboseLogging = *chilkatc::CkServerSentEvent_put_VerboseLogging;
*get_Version = *chilkatc::CkServerSentEvent_get_Version;
*version = *chilkatc::CkServerSentEvent_version;
*LoadEvent = *chilkatc::CkServerSentEvent_LoadEvent;
sub DISOWN {
    my $self = shift;
    my $ptr = tied(%$self);
    delete $OWNER{$ptr};
}

sub ACQUIRE {
    my $self = shift;
    my $ptr = tied(%$self);
    $OWNER{$ptr} = 1;
}


############# Class : chilkat::CkSocket ##############

package chilkat::CkSocket;
use vars qw(@ISA %OWNER %ITERATORS %BLESSEDMEMBERS);
@ISA = qw( chilkat );
%OWNER = ();
%ITERATORS = ();
sub new {
    my $pkg = shift;
    my $self = chilkatc::new_CkSocket(@_);
    bless $self, $pkg if defined($self);
}

sub DESTROY {
    return unless $_[0]->isa('HASH');
    my $self = tied(%{$_[0]});
    return unless defined $self;
    delete $ITERATORS{$self};
    if (exists $OWNER{$self}) {
        chilkatc::delete_CkSocket($self);
        delete $OWNER{$self};
    }
}

*get_Utf8 = *chilkatc::CkSocket_get_Utf8;
*put_Utf8 = *chilkatc::CkSocket_put_Utf8;
*LastErrorXml = *chilkatc::CkSocket_LastErrorXml;
*LastErrorHtml = *chilkatc::CkSocket_LastErrorHtml;
*LastErrorText = *chilkatc::CkSocket_LastErrorText;
*put_EventCallbackObject = *chilkatc::CkSocket_put_EventCallbackObject;
*get_AbortCurrent = *chilkatc::CkSocket_get_AbortCurrent;
*put_AbortCurrent = *chilkatc::CkSocket_put_AbortCurrent;
*get_AcceptFailReason = *chilkatc::CkSocket_get_AcceptFailReason;
*get_AlpnProtocol = *chilkatc::CkSocket_get_AlpnProtocol;
*alpnProtocol = *chilkatc::CkSocket_alpnProtocol;
*put_AlpnProtocol = *chilkatc::CkSocket_put_AlpnProtocol;
*get_BandwidthThrottleDown = *chilkatc::CkSocket_get_BandwidthThrottleDown;
*put_BandwidthThrottleDown = *chilkatc::CkSocket_put_BandwidthThrottleDown;
*get_BandwidthThrottleUp = *chilkatc::CkSocket_get_BandwidthThrottleUp;
*put_BandwidthThrottleUp = *chilkatc::CkSocket_put_BandwidthThrottleUp;
*get_BigEndian = *chilkatc::CkSocket_get_BigEndian;
*put_BigEndian = *chilkatc::CkSocket_put_BigEndian;
*get_ClientIpAddress = *chilkatc::CkSocket_get_ClientIpAddress;
*clientIpAddress = *chilkatc::CkSocket_clientIpAddress;
*put_ClientIpAddress = *chilkatc::CkSocket_put_ClientIpAddress;
*get_ClientPort = *chilkatc::CkSocket_get_ClientPort;
*put_ClientPort = *chilkatc::CkSocket_put_ClientPort;
*get_ConnectFailReason = *chilkatc::CkSocket_get_ConnectFailReason;
*get_DebugLogFilePath = *chilkatc::CkSocket_get_DebugLogFilePath;
*debugLogFilePath = *chilkatc::CkSocket_debugLogFilePath;
*put_DebugLogFilePath = *chilkatc::CkSocket_put_DebugLogFilePath;
*get_ElapsedSeconds = *chilkatc::CkSocket_get_ElapsedSeconds;
*get_HeartbeatMs = *chilkatc::CkSocket_get_HeartbeatMs;
*put_HeartbeatMs = *chilkatc::CkSocket_put_HeartbeatMs;
*get_HttpProxyAuthMethod = *chilkatc::CkSocket_get_HttpProxyAuthMethod;
*httpProxyAuthMethod = *chilkatc::CkSocket_httpProxyAuthMethod;
*put_HttpProxyAuthMethod = *chilkatc::CkSocket_put_HttpProxyAuthMethod;
*get_HttpProxyDomain = *chilkatc::CkSocket_get_HttpProxyDomain;
*httpProxyDomain = *chilkatc::CkSocket_httpProxyDomain;
*put_HttpProxyDomain = *chilkatc::CkSocket_put_HttpProxyDomain;
*get_HttpProxyForHttp = *chilkatc::CkSocket_get_HttpProxyForHttp;
*put_HttpProxyForHttp = *chilkatc::CkSocket_put_HttpProxyForHttp;
*get_HttpProxyHostname = *chilkatc::CkSocket_get_HttpProxyHostname;
*httpProxyHostname = *chilkatc::CkSocket_httpProxyHostname;
*put_HttpProxyHostname = *chilkatc::CkSocket_put_HttpProxyHostname;
*get_HttpProxyPassword = *chilkatc::CkSocket_get_HttpProxyPassword;
*httpProxyPassword = *chilkatc::CkSocket_httpProxyPassword;
*put_HttpProxyPassword = *chilkatc::CkSocket_put_HttpProxyPassword;
*get_HttpProxyPort = *chilkatc::CkSocket_get_HttpProxyPort;
*put_HttpProxyPort = *chilkatc::CkSocket_put_HttpProxyPort;
*get_HttpProxyUsername = *chilkatc::CkSocket_get_HttpProxyUsername;
*httpProxyUsername = *chilkatc::CkSocket_httpProxyUsername;
*put_HttpProxyUsername = *chilkatc::CkSocket_put_HttpProxyUsername;
*get_IsConnected = *chilkatc::CkSocket_get_IsConnected;
*get_KeepAlive = *chilkatc::CkSocket_get_KeepAlive;
*put_KeepAlive = *chilkatc::CkSocket_put_KeepAlive;
*get_KeepSessionLog = *chilkatc::CkSocket_get_KeepSessionLog;
*put_KeepSessionLog = *chilkatc::CkSocket_put_KeepSessionLog;
*get_LastErrorHtml = *chilkatc::CkSocket_get_LastErrorHtml;
*lastErrorHtml = *chilkatc::CkSocket_lastErrorHtml;
*get_LastErrorText = *chilkatc::CkSocket_get_LastErrorText;
*lastErrorText = *chilkatc::CkSocket_lastErrorText;
*get_LastErrorXml = *chilkatc::CkSocket_get_LastErrorXml;
*lastErrorXml = *chilkatc::CkSocket_lastErrorXml;
*get_LastMethodFailed = *chilkatc::CkSocket_get_LastMethodFailed;
*get_LastMethodSuccess = *chilkatc::CkSocket_get_LastMethodSuccess;
*put_LastMethodSuccess = *chilkatc::CkSocket_put_LastMethodSuccess;
*get_ListenIpv6 = *chilkatc::CkSocket_get_ListenIpv6;
*put_ListenIpv6 = *chilkatc::CkSocket_put_ListenIpv6;
*get_ListenPort = *chilkatc::CkSocket_get_ListenPort;
*get_LocalIpAddress = *chilkatc::CkSocket_get_LocalIpAddress;
*localIpAddress = *chilkatc::CkSocket_localIpAddress;
*get_LocalPort = *chilkatc::CkSocket_get_LocalPort;
*get_MaxReadIdleMs = *chilkatc::CkSocket_get_MaxReadIdleMs;
*put_MaxReadIdleMs = *chilkatc::CkSocket_put_MaxReadIdleMs;
*get_MaxSendIdleMs = *chilkatc::CkSocket_get_MaxSendIdleMs;
*put_MaxSendIdleMs = *chilkatc::CkSocket_put_MaxSendIdleMs;
*get_MyIpAddress = *chilkatc::CkSocket_get_MyIpAddress;
*myIpAddress = *chilkatc::CkSocket_myIpAddress;
*get_NumBytesAvailable = *chilkatc::CkSocket_get_NumBytesAvailable;
*get_NumReceivedClientCerts = *chilkatc::CkSocket_get_NumReceivedClientCerts;
*get_NumSocketsInSet = *chilkatc::CkSocket_get_NumSocketsInSet;
*get_NumSslAcceptableClientCAs = *chilkatc::CkSocket_get_NumSslAcceptableClientCAs;
*get_ObjectId = *chilkatc::CkSocket_get_ObjectId;
*get_PercentDoneScale = *chilkatc::CkSocket_get_PercentDoneScale;
*put_PercentDoneScale = *chilkatc::CkSocket_put_PercentDoneScale;
*get_PreferIpv6 = *chilkatc::CkSocket_get_PreferIpv6;
*put_PreferIpv6 = *chilkatc::CkSocket_put_PreferIpv6;
*get_RcvBytesPerSec = *chilkatc::CkSocket_get_RcvBytesPerSec;
*get_ReceivedCount = *chilkatc::CkSocket_get_ReceivedCount;
*put_ReceivedCount = *chilkatc::CkSocket_put_ReceivedCount;
*get_ReceivedInt = *chilkatc::CkSocket_get_ReceivedInt;
*put_ReceivedInt = *chilkatc::CkSocket_put_ReceivedInt;
*get_ReceiveFailReason = *chilkatc::CkSocket_get_ReceiveFailReason;
*get_ReceivePacketSize = *chilkatc::CkSocket_get_ReceivePacketSize;
*put_ReceivePacketSize = *chilkatc::CkSocket_put_ReceivePacketSize;
*get_RemoteIpAddress = *chilkatc::CkSocket_get_RemoteIpAddress;
*remoteIpAddress = *chilkatc::CkSocket_remoteIpAddress;
*get_RemotePort = *chilkatc::CkSocket_get_RemotePort;
*get_RequireSslCertVerify = *chilkatc::CkSocket_get_RequireSslCertVerify;
*put_RequireSslCertVerify = *chilkatc::CkSocket_put_RequireSslCertVerify;
*get_SelectorIndex = *chilkatc::CkSocket_get_SelectorIndex;
*put_SelectorIndex = *chilkatc::CkSocket_put_SelectorIndex;
*get_SelectorReadIndex = *chilkatc::CkSocket_get_SelectorReadIndex;
*put_SelectorReadIndex = *chilkatc::CkSocket_put_SelectorReadIndex;
*get_SelectorWriteIndex = *chilkatc::CkSocket_get_SelectorWriteIndex;
*put_SelectorWriteIndex = *chilkatc::CkSocket_put_SelectorWriteIndex;
*get_SendBytesPerSec = *chilkatc::CkSocket_get_SendBytesPerSec;
*get_SendFailReason = *chilkatc::CkSocket_get_SendFailReason;
*get_SendPacketSize = *chilkatc::CkSocket_get_SendPacketSize;
*put_SendPacketSize = *chilkatc::CkSocket_put_SendPacketSize;
*get_SessionLog = *chilkatc::CkSocket_get_SessionLog;
*sessionLog = *chilkatc::CkSocket_sessionLog;
*get_SessionLogEncoding = *chilkatc::CkSocket_get_SessionLogEncoding;
*sessionLogEncoding = *chilkatc::CkSocket_sessionLogEncoding;
*put_SessionLogEncoding = *chilkatc::CkSocket_put_SessionLogEncoding;
*get_SniHostname = *chilkatc::CkSocket_get_SniHostname;
*sniHostname = *chilkatc::CkSocket_sniHostname;
*put_SniHostname = *chilkatc::CkSocket_put_SniHostname;
*get_SocksHostname = *chilkatc::CkSocket_get_SocksHostname;
*socksHostname = *chilkatc::CkSocket_socksHostname;
*put_SocksHostname = *chilkatc::CkSocket_put_SocksHostname;
*get_SocksPassword = *chilkatc::CkSocket_get_SocksPassword;
*socksPassword = *chilkatc::CkSocket_socksPassword;
*put_SocksPassword = *chilkatc::CkSocket_put_SocksPassword;
*get_SocksPort = *chilkatc::CkSocket_get_SocksPort;
*put_SocksPort = *chilkatc::CkSocket_put_SocksPort;
*get_SocksUsername = *chilkatc::CkSocket_get_SocksUsername;
*socksUsername = *chilkatc::CkSocket_socksUsername;
*put_SocksUsername = *chilkatc::CkSocket_put_SocksUsername;
*get_SocksVersion = *chilkatc::CkSocket_get_SocksVersion;
*put_SocksVersion = *chilkatc::CkSocket_put_SocksVersion;
*get_SoRcvBuf = *chilkatc::CkSocket_get_SoRcvBuf;
*put_SoRcvBuf = *chilkatc::CkSocket_put_SoRcvBuf;
*get_SoReuseAddr = *chilkatc::CkSocket_get_SoReuseAddr;
*put_SoReuseAddr = *chilkatc::CkSocket_put_SoReuseAddr;
*get_SoSndBuf = *chilkatc::CkSocket_get_SoSndBuf;
*put_SoSndBuf = *chilkatc::CkSocket_put_SoSndBuf;
*get_Ssl = *chilkatc::CkSocket_get_Ssl;
*put_Ssl = *chilkatc::CkSocket_put_Ssl;
*get_SslAllowedCiphers = *chilkatc::CkSocket_get_SslAllowedCiphers;
*sslAllowedCiphers = *chilkatc::CkSocket_sslAllowedCiphers;
*put_SslAllowedCiphers = *chilkatc::CkSocket_put_SslAllowedCiphers;
*get_SslProtocol = *chilkatc::CkSocket_get_SslProtocol;
*sslProtocol = *chilkatc::CkSocket_sslProtocol;
*put_SslProtocol = *chilkatc::CkSocket_put_SslProtocol;
*get_StringCharset = *chilkatc::CkSocket_get_StringCharset;
*stringCharset = *chilkatc::CkSocket_stringCharset;
*put_StringCharset = *chilkatc::CkSocket_put_StringCharset;
*get_TcpNoDelay = *chilkatc::CkSocket_get_TcpNoDelay;
*put_TcpNoDelay = *chilkatc::CkSocket_put_TcpNoDelay;
*get_TlsCipherSuite = *chilkatc::CkSocket_get_TlsCipherSuite;
*tlsCipherSuite = *chilkatc::CkSocket_tlsCipherSuite;
*get_TlsPinSet = *chilkatc::CkSocket_get_TlsPinSet;
*tlsPinSet = *chilkatc::CkSocket_tlsPinSet;
*put_TlsPinSet = *chilkatc::CkSocket_put_TlsPinSet;
*get_TlsVersion = *chilkatc::CkSocket_get_TlsVersion;
*tlsVersion = *chilkatc::CkSocket_tlsVersion;
*get_UncommonOptions = *chilkatc::CkSocket_get_UncommonOptions;
*uncommonOptions = *chilkatc::CkSocket_uncommonOptions;
*put_UncommonOptions = *chilkatc::CkSocket_put_UncommonOptions;
*get_UserData = *chilkatc::CkSocket_get_UserData;
*userData = *chilkatc::CkSocket_userData;
*put_UserData = *chilkatc::CkSocket_put_UserData;
*get_VerboseLogging = *chilkatc::CkSocket_get_VerboseLogging;
*put_VerboseLogging = *chilkatc::CkSocket_put_VerboseLogging;
*get_Version = *chilkatc::CkSocket_get_Version;
*version = *chilkatc::CkSocket_version;
*AcceptNext = *chilkatc::CkSocket_AcceptNext;
*AcceptNextAsync = *chilkatc::CkSocket_AcceptNextAsync;
*AcceptNextConnection = *chilkatc::CkSocket_AcceptNextConnection;
*AcceptNextConnectionAsync = *chilkatc::CkSocket_AcceptNextConnectionAsync;
*AddSslAcceptableClientCaDn = *chilkatc::CkSocket_AddSslAcceptableClientCaDn;
*BindAndListen = *chilkatc::CkSocket_BindAndListen;
*BindAndListenAsync = *chilkatc::CkSocket_BindAndListenAsync;
*BindAndListenPortRange = *chilkatc::CkSocket_BindAndListenPortRange;
*BindAndListenPortRangeAsync = *chilkatc::CkSocket_BindAndListenPortRangeAsync;
*BuildHttpGetRequest = *chilkatc::CkSocket_BuildHttpGetRequest;
*buildHttpGetRequest = *chilkatc::CkSocket_buildHttpGetRequest;
*CheckWriteable = *chilkatc::CkSocket_CheckWriteable;
*CheckWriteableAsync = *chilkatc::CkSocket_CheckWriteableAsync;
*ClearSessionLog = *chilkatc::CkSocket_ClearSessionLog;
*CloneSocket = *chilkatc::CkSocket_CloneSocket;
*Close = *chilkatc::CkSocket_Close;
*CloseAsync = *chilkatc::CkSocket_CloseAsync;
*Connect = *chilkatc::CkSocket_Connect;
*ConnectAsync = *chilkatc::CkSocket_ConnectAsync;
*ConvertFromSsl = *chilkatc::CkSocket_ConvertFromSsl;
*ConvertFromSslAsync = *chilkatc::CkSocket_ConvertFromSslAsync;
*ConvertToSsl = *chilkatc::CkSocket_ConvertToSsl;
*ConvertToSslAsync = *chilkatc::CkSocket_ConvertToSslAsync;
*DnsCacheClear = *chilkatc::CkSocket_DnsCacheClear;
*DnsLookup = *chilkatc::CkSocket_DnsLookup;
*dnsLookup = *chilkatc::CkSocket_dnsLookup;
*DnsLookupAsync = *chilkatc::CkSocket_DnsLookupAsync;
*DupSocket = *chilkatc::CkSocket_DupSocket;
*GetAdaptersAddresses = *chilkatc::CkSocket_GetAdaptersAddresses;
*GetLastJsonData = *chilkatc::CkSocket_GetLastJsonData;
*GetMyCert = *chilkatc::CkSocket_GetMyCert;
*GetMyServerCert = *chilkatc::CkSocket_GetMyServerCert;
*GetRcvdClientCert = *chilkatc::CkSocket_GetRcvdClientCert;
*GetReceivedClientCert = *chilkatc::CkSocket_GetReceivedClientCert;
*GetServerCert = *chilkatc::CkSocket_GetServerCert;
*GetSslAcceptableClientCaDn = *chilkatc::CkSocket_GetSslAcceptableClientCaDn;
*getSslAcceptableClientCaDn = *chilkatc::CkSocket_getSslAcceptableClientCaDn;
*sslAcceptableClientCaDn = *chilkatc::CkSocket_sslAcceptableClientCaDn;
*GetSslServerCert = *chilkatc::CkSocket_GetSslServerCert;
*InitSslServer = *chilkatc::CkSocket_InitSslServer;
*LastJsonData = *chilkatc::CkSocket_LastJsonData;
*LoadTaskCaller = *chilkatc::CkSocket_LoadTaskCaller;
*LoadTaskResult = *chilkatc::CkSocket_LoadTaskResult;
*PollDataAvailable = *chilkatc::CkSocket_PollDataAvailable;
*PollDataAvailableAsync = *chilkatc::CkSocket_PollDataAvailableAsync;
*ReceiveBd = *chilkatc::CkSocket_ReceiveBd;
*ReceiveBdAsync = *chilkatc::CkSocket_ReceiveBdAsync;
*ReceiveBdN = *chilkatc::CkSocket_ReceiveBdN;
*ReceiveBdNAsync = *chilkatc::CkSocket_ReceiveBdNAsync;
*ReceiveByte = *chilkatc::CkSocket_ReceiveByte;
*ReceiveByteAsync = *chilkatc::CkSocket_ReceiveByteAsync;
*ReceiveBytes = *chilkatc::CkSocket_ReceiveBytes;
*ReceiveBytesAsync = *chilkatc::CkSocket_ReceiveBytesAsync;
*ReceiveBytesENC = *chilkatc::CkSocket_ReceiveBytesENC;
*receiveBytesENC = *chilkatc::CkSocket_receiveBytesENC;
*ReceiveBytesENCAsync = *chilkatc::CkSocket_ReceiveBytesENCAsync;
*ReceiveBytesN = *chilkatc::CkSocket_ReceiveBytesN;
*ReceiveBytesNAsync = *chilkatc::CkSocket_ReceiveBytesNAsync;
*ReceiveBytesToFile = *chilkatc::CkSocket_ReceiveBytesToFile;
*ReceiveBytesToFileAsync = *chilkatc::CkSocket_ReceiveBytesToFileAsync;
*ReceiveCount = *chilkatc::CkSocket_ReceiveCount;
*ReceiveCountAsync = *chilkatc::CkSocket_ReceiveCountAsync;
*ReceiveInt16 = *chilkatc::CkSocket_ReceiveInt16;
*ReceiveInt16Async = *chilkatc::CkSocket_ReceiveInt16Async;
*ReceiveInt32 = *chilkatc::CkSocket_ReceiveInt32;
*ReceiveInt32Async = *chilkatc::CkSocket_ReceiveInt32Async;
*ReceiveNBytesENC = *chilkatc::CkSocket_ReceiveNBytesENC;
*receiveNBytesENC = *chilkatc::CkSocket_receiveNBytesENC;
*ReceiveNBytesENCAsync = *chilkatc::CkSocket_ReceiveNBytesENCAsync;
*ReceiveSb = *chilkatc::CkSocket_ReceiveSb;
*ReceiveSbAsync = *chilkatc::CkSocket_ReceiveSbAsync;
*ReceiveString = *chilkatc::CkSocket_ReceiveString;
*receiveString = *chilkatc::CkSocket_receiveString;
*ReceiveStringAsync = *chilkatc::CkSocket_ReceiveStringAsync;
*ReceiveStringMaxN = *chilkatc::CkSocket_ReceiveStringMaxN;
*receiveStringMaxN = *chilkatc::CkSocket_receiveStringMaxN;
*ReceiveStringMaxNAsync = *chilkatc::CkSocket_ReceiveStringMaxNAsync;
*ReceiveStringUntilByte = *chilkatc::CkSocket_ReceiveStringUntilByte;
*receiveStringUntilByte = *chilkatc::CkSocket_receiveStringUntilByte;
*ReceiveStringUntilByteAsync = *chilkatc::CkSocket_ReceiveStringUntilByteAsync;
*ReceiveToCRLF = *chilkatc::CkSocket_ReceiveToCRLF;
*receiveToCRLF = *chilkatc::CkSocket_receiveToCRLF;
*ReceiveToCRLFAsync = *chilkatc::CkSocket_ReceiveToCRLFAsync;
*ReceiveUntilByte = *chilkatc::CkSocket_ReceiveUntilByte;
*ReceiveUntilByteAsync = *chilkatc::CkSocket_ReceiveUntilByteAsync;
*ReceiveUntilByteBd = *chilkatc::CkSocket_ReceiveUntilByteBd;
*ReceiveUntilByteBdAsync = *chilkatc::CkSocket_ReceiveUntilByteBdAsync;
*ReceiveUntilMatch = *chilkatc::CkSocket_ReceiveUntilMatch;
*receiveUntilMatch = *chilkatc::CkSocket_receiveUntilMatch;
*ReceiveUntilMatchAsync = *chilkatc::CkSocket_ReceiveUntilMatchAsync;
*ReceiveUntilMatchSb = *chilkatc::CkSocket_ReceiveUntilMatchSb;
*ReceiveUntilMatchSbAsync = *chilkatc::CkSocket_ReceiveUntilMatchSbAsync;
*ResetPerf = *chilkatc::CkSocket_ResetPerf;
*SelectForReading = *chilkatc::CkSocket_SelectForReading;
*SelectForReadingAsync = *chilkatc::CkSocket_SelectForReadingAsync;
*SelectForWriting = *chilkatc::CkSocket_SelectForWriting;
*SelectForWritingAsync = *chilkatc::CkSocket_SelectForWritingAsync;
*SendBd = *chilkatc::CkSocket_SendBd;
*SendBdAsync = *chilkatc::CkSocket_SendBdAsync;
*SendByte = *chilkatc::CkSocket_SendByte;
*SendByteAsync = *chilkatc::CkSocket_SendByteAsync;
*SendBytes = *chilkatc::CkSocket_SendBytes;
*SendBytesAsync = *chilkatc::CkSocket_SendBytesAsync;
*SendBytesENC = *chilkatc::CkSocket_SendBytesENC;
*SendBytesENCAsync = *chilkatc::CkSocket_SendBytesENCAsync;
*SendCount = *chilkatc::CkSocket_SendCount;
*SendCountAsync = *chilkatc::CkSocket_SendCountAsync;
*SendInt16 = *chilkatc::CkSocket_SendInt16;
*SendInt16Async = *chilkatc::CkSocket_SendInt16Async;
*SendInt32 = *chilkatc::CkSocket_SendInt32;
*SendInt32Async = *chilkatc::CkSocket_SendInt32Async;
*SendSb = *chilkatc::CkSocket_SendSb;
*SendSbAsync = *chilkatc::CkSocket_SendSbAsync;
*SendString = *chilkatc::CkSocket_SendString;
*SendStringAsync = *chilkatc::CkSocket_SendStringAsync;
*SendWakeOnLan = *chilkatc::CkSocket_SendWakeOnLan;
*SendWakeOnLan2 = *chilkatc::CkSocket_SendWakeOnLan2;
*SetSslClientCert = *chilkatc::CkSocket_SetSslClientCert;
*SetSslClientCertPem = *chilkatc::CkSocket_SetSslClientCertPem;
*SetSslClientCertPfx = *chilkatc::CkSocket_SetSslClientCertPfx;
*SleepMs = *chilkatc::CkSocket_SleepMs;
*SshAuthenticatePk = *chilkatc::CkSocket_SshAuthenticatePk;
*SshAuthenticatePkAsync = *chilkatc::CkSocket_SshAuthenticatePkAsync;
*SshAuthenticatePw = *chilkatc::CkSocket_SshAuthenticatePw;
*SshAuthenticatePwAsync = *chilkatc::CkSocket_SshAuthenticatePwAsync;
*SshCloseTunnel = *chilkatc::CkSocket_SshCloseTunnel;
*SshCloseTunnelAsync = *chilkatc::CkSocket_SshCloseTunnelAsync;
*SshNewChannel = *chilkatc::CkSocket_SshNewChannel;
*SshNewChannelAsync = *chilkatc::CkSocket_SshNewChannelAsync;
*SshOpenChannel = *chilkatc::CkSocket_SshOpenChannel;
*SshOpenChannelAsync = *chilkatc::CkSocket_SshOpenChannelAsync;
*SshOpenTunnel = *chilkatc::CkSocket_SshOpenTunnel;
*SshOpenTunnelAsync = *chilkatc::CkSocket_SshOpenTunnelAsync;
*StartTiming = *chilkatc::CkSocket_StartTiming;
*TakeConnection = *chilkatc::CkSocket_TakeConnection;
*TakeSocket = *chilkatc::CkSocket_TakeSocket;
*TlsRenegotiate = *chilkatc::CkSocket_TlsRenegotiate;
*TlsRenegotiateAsync = *chilkatc::CkSocket_TlsRenegotiateAsync;
*UseSsh = *chilkatc::CkSocket_UseSsh;
sub DISOWN {
    my $self = shift;
    my $ptr = tied(%$self);
    delete $OWNER{$ptr};
}

sub ACQUIRE {
    my $self = shift;
    my $ptr = tied(%$self);
    $OWNER{$ptr} = 1;
}


############# Class : chilkat::CkSpider ##############

package chilkat::CkSpider;
use vars qw(@ISA %OWNER %ITERATORS %BLESSEDMEMBERS);
@ISA = qw( chilkat );
%OWNER = ();
%ITERATORS = ();
sub new {
    my $pkg = shift;
    my $self = chilkatc::new_CkSpider(@_);
    bless $self, $pkg if defined($self);
}

sub DESTROY {
    return unless $_[0]->isa('HASH');
    my $self = tied(%{$_[0]});
    return unless defined $self;
    delete $ITERATORS{$self};
    if (exists $OWNER{$self}) {
        chilkatc::delete_CkSpider($self);
        delete $OWNER{$self};
    }
}

*get_Utf8 = *chilkatc::CkSpider_get_Utf8;
*put_Utf8 = *chilkatc::CkSpider_put_Utf8;
*LastErrorXml = *chilkatc::CkSpider_LastErrorXml;
*LastErrorHtml = *chilkatc::CkSpider_LastErrorHtml;
*LastErrorText = *chilkatc::CkSpider_LastErrorText;
*put_EventCallbackObject = *chilkatc::CkSpider_put_EventCallbackObject;
*get_AbortCurrent = *chilkatc::CkSpider_get_AbortCurrent;
*put_AbortCurrent = *chilkatc::CkSpider_put_AbortCurrent;
*get_AvoidHttps = *chilkatc::CkSpider_get_AvoidHttps;
*put_AvoidHttps = *chilkatc::CkSpider_put_AvoidHttps;
*get_CacheDir = *chilkatc::CkSpider_get_CacheDir;
*cacheDir = *chilkatc::CkSpider_cacheDir;
*put_CacheDir = *chilkatc::CkSpider_put_CacheDir;
*get_ChopAtQuery = *chilkatc::CkSpider_get_ChopAtQuery;
*put_ChopAtQuery = *chilkatc::CkSpider_put_ChopAtQuery;
*get_ConnectTimeout = *chilkatc::CkSpider_get_ConnectTimeout;
*put_ConnectTimeout = *chilkatc::CkSpider_put_ConnectTimeout;
*get_DebugLogFilePath = *chilkatc::CkSpider_get_DebugLogFilePath;
*debugLogFilePath = *chilkatc::CkSpider_debugLogFilePath;
*put_DebugLogFilePath = *chilkatc::CkSpider_put_DebugLogFilePath;
*get_Domain = *chilkatc::CkSpider_get_Domain;
*domain = *chilkatc::CkSpider_domain;
*get_FetchFromCache = *chilkatc::CkSpider_get_FetchFromCache;
*put_FetchFromCache = *chilkatc::CkSpider_put_FetchFromCache;
*get_FinalRedirectUrl = *chilkatc::CkSpider_get_FinalRedirectUrl;
*finalRedirectUrl = *chilkatc::CkSpider_finalRedirectUrl;
*get_HeartbeatMs = *chilkatc::CkSpider_get_HeartbeatMs;
*put_HeartbeatMs = *chilkatc::CkSpider_put_HeartbeatMs;
*get_LastErrorHtml = *chilkatc::CkSpider_get_LastErrorHtml;
*lastErrorHtml = *chilkatc::CkSpider_lastErrorHtml;
*get_LastErrorText = *chilkatc::CkSpider_get_LastErrorText;
*lastErrorText = *chilkatc::CkSpider_lastErrorText;
*get_LastErrorXml = *chilkatc::CkSpider_get_LastErrorXml;
*lastErrorXml = *chilkatc::CkSpider_lastErrorXml;
*get_LastFromCache = *chilkatc::CkSpider_get_LastFromCache;
*get_LastHtml = *chilkatc::CkSpider_get_LastHtml;
*lastHtml = *chilkatc::CkSpider_lastHtml;
*get_LastHtmlDescription = *chilkatc::CkSpider_get_LastHtmlDescription;
*lastHtmlDescription = *chilkatc::CkSpider_lastHtmlDescription;
*get_LastHtmlKeywords = *chilkatc::CkSpider_get_LastHtmlKeywords;
*lastHtmlKeywords = *chilkatc::CkSpider_lastHtmlKeywords;
*get_LastHtmlTitle = *chilkatc::CkSpider_get_LastHtmlTitle;
*lastHtmlTitle = *chilkatc::CkSpider_lastHtmlTitle;
*get_LastMethodSuccess = *chilkatc::CkSpider_get_LastMethodSuccess;
*put_LastMethodSuccess = *chilkatc::CkSpider_put_LastMethodSuccess;
*get_LastModDateStr = *chilkatc::CkSpider_get_LastModDateStr;
*lastModDateStr = *chilkatc::CkSpider_lastModDateStr;
*get_LastUrl = *chilkatc::CkSpider_get_LastUrl;
*lastUrl = *chilkatc::CkSpider_lastUrl;
*get_MaxResponseSize = *chilkatc::CkSpider_get_MaxResponseSize;
*put_MaxResponseSize = *chilkatc::CkSpider_put_MaxResponseSize;
*get_MaxUrlLen = *chilkatc::CkSpider_get_MaxUrlLen;
*put_MaxUrlLen = *chilkatc::CkSpider_put_MaxUrlLen;
*get_NumAvoidPatterns = *chilkatc::CkSpider_get_NumAvoidPatterns;
*get_NumFailed = *chilkatc::CkSpider_get_NumFailed;
*get_NumOutboundLinks = *chilkatc::CkSpider_get_NumOutboundLinks;
*get_NumSpidered = *chilkatc::CkSpider_get_NumSpidered;
*get_NumUnspidered = *chilkatc::CkSpider_get_NumUnspidered;
*get_PreferIpv6 = *chilkatc::CkSpider_get_PreferIpv6;
*put_PreferIpv6 = *chilkatc::CkSpider_put_PreferIpv6;
*get_ProxyDomain = *chilkatc::CkSpider_get_ProxyDomain;
*proxyDomain = *chilkatc::CkSpider_proxyDomain;
*put_ProxyDomain = *chilkatc::CkSpider_put_ProxyDomain;
*get_ProxyLogin = *chilkatc::CkSpider_get_ProxyLogin;
*proxyLogin = *chilkatc::CkSpider_proxyLogin;
*put_ProxyLogin = *chilkatc::CkSpider_put_ProxyLogin;
*get_ProxyPassword = *chilkatc::CkSpider_get_ProxyPassword;
*proxyPassword = *chilkatc::CkSpider_proxyPassword;
*put_ProxyPassword = *chilkatc::CkSpider_put_ProxyPassword;
*get_ProxyPort = *chilkatc::CkSpider_get_ProxyPort;
*put_ProxyPort = *chilkatc::CkSpider_put_ProxyPort;
*get_ReadTimeout = *chilkatc::CkSpider_get_ReadTimeout;
*put_ReadTimeout = *chilkatc::CkSpider_put_ReadTimeout;
*get_UpdateCache = *chilkatc::CkSpider_get_UpdateCache;
*put_UpdateCache = *chilkatc::CkSpider_put_UpdateCache;
*get_UserAgent = *chilkatc::CkSpider_get_UserAgent;
*userAgent = *chilkatc::CkSpider_userAgent;
*put_UserAgent = *chilkatc::CkSpider_put_UserAgent;
*get_VerboseLogging = *chilkatc::CkSpider_get_VerboseLogging;
*put_VerboseLogging = *chilkatc::CkSpider_put_VerboseLogging;
*get_Version = *chilkatc::CkSpider_get_Version;
*version = *chilkatc::CkSpider_version;
*get_WasRedirected = *chilkatc::CkSpider_get_WasRedirected;
*get_WindDownCount = *chilkatc::CkSpider_get_WindDownCount;
*put_WindDownCount = *chilkatc::CkSpider_put_WindDownCount;
*AddAvoidOutboundLinkPattern = *chilkatc::CkSpider_AddAvoidOutboundLinkPattern;
*AddAvoidPattern = *chilkatc::CkSpider_AddAvoidPattern;
*AddMustMatchPattern = *chilkatc::CkSpider_AddMustMatchPattern;
*AddUnspidered = *chilkatc::CkSpider_AddUnspidered;
*CanonicalizeUrl = *chilkatc::CkSpider_CanonicalizeUrl;
*canonicalizeUrl = *chilkatc::CkSpider_canonicalizeUrl;
*ClearFailedUrls = *chilkatc::CkSpider_ClearFailedUrls;
*ClearOutboundLinks = *chilkatc::CkSpider_ClearOutboundLinks;
*ClearSpideredUrls = *chilkatc::CkSpider_ClearSpideredUrls;
*CrawlNext = *chilkatc::CkSpider_CrawlNext;
*CrawlNextAsync = *chilkatc::CkSpider_CrawlNextAsync;
*FetchRobotsText = *chilkatc::CkSpider_FetchRobotsText;
*fetchRobotsText = *chilkatc::CkSpider_fetchRobotsText;
*FetchRobotsTextAsync = *chilkatc::CkSpider_FetchRobotsTextAsync;
*GetAvoidPattern = *chilkatc::CkSpider_GetAvoidPattern;
*getAvoidPattern = *chilkatc::CkSpider_getAvoidPattern;
*avoidPattern = *chilkatc::CkSpider_avoidPattern;
*GetBaseDomain = *chilkatc::CkSpider_GetBaseDomain;
*getBaseDomain = *chilkatc::CkSpider_getBaseDomain;
*baseDomain = *chilkatc::CkSpider_baseDomain;
*GetFailedUrl = *chilkatc::CkSpider_GetFailedUrl;
*getFailedUrl = *chilkatc::CkSpider_getFailedUrl;
*failedUrl = *chilkatc::CkSpider_failedUrl;
*GetOutboundLink = *chilkatc::CkSpider_GetOutboundLink;
*getOutboundLink = *chilkatc::CkSpider_getOutboundLink;
*outboundLink = *chilkatc::CkSpider_outboundLink;
*GetSpideredUrl = *chilkatc::CkSpider_GetSpideredUrl;
*getSpideredUrl = *chilkatc::CkSpider_getSpideredUrl;
*spideredUrl = *chilkatc::CkSpider_spideredUrl;
*GetUnspideredUrl = *chilkatc::CkSpider_GetUnspideredUrl;
*getUnspideredUrl = *chilkatc::CkSpider_getUnspideredUrl;
*unspideredUrl = *chilkatc::CkSpider_unspideredUrl;
*GetUrlDomain = *chilkatc::CkSpider_GetUrlDomain;
*getUrlDomain = *chilkatc::CkSpider_getUrlDomain;
*urlDomain = *chilkatc::CkSpider_urlDomain;
*Initialize = *chilkatc::CkSpider_Initialize;
*LoadTaskCaller = *chilkatc::CkSpider_LoadTaskCaller;
*RecrawlLast = *chilkatc::CkSpider_RecrawlLast;
*RecrawlLastAsync = *chilkatc::CkSpider_RecrawlLastAsync;
*SkipUnspidered = *chilkatc::CkSpider_SkipUnspidered;
*SleepMs = *chilkatc::CkSpider_SleepMs;
sub DISOWN {
    my $self = shift;
    my $ptr = tied(%$self);
    delete $OWNER{$ptr};
}

sub ACQUIRE {
    my $self = shift;
    my $ptr = tied(%$self);
    $OWNER{$ptr} = 1;
}


############# Class : chilkat::CkSsh ##############

package chilkat::CkSsh;
use vars qw(@ISA %OWNER %ITERATORS %BLESSEDMEMBERS);
@ISA = qw( chilkat );
%OWNER = ();
%ITERATORS = ();
sub new {
    my $pkg = shift;
    my $self = chilkatc::new_CkSsh(@_);
    bless $self, $pkg if defined($self);
}

sub DESTROY {
    return unless $_[0]->isa('HASH');
    my $self = tied(%{$_[0]});
    return unless defined $self;
    delete $ITERATORS{$self};
    if (exists $OWNER{$self}) {
        chilkatc::delete_CkSsh($self);
        delete $OWNER{$self};
    }
}

*get_Utf8 = *chilkatc::CkSsh_get_Utf8;
*put_Utf8 = *chilkatc::CkSsh_put_Utf8;
*LastErrorXml = *chilkatc::CkSsh_LastErrorXml;
*LastErrorHtml = *chilkatc::CkSsh_LastErrorHtml;
*LastErrorText = *chilkatc::CkSsh_LastErrorText;
*put_EventCallbackObject = *chilkatc::CkSsh_put_EventCallbackObject;
*get_AbortCurrent = *chilkatc::CkSsh_get_AbortCurrent;
*put_AbortCurrent = *chilkatc::CkSsh_put_AbortCurrent;
*get_AuthFailReason = *chilkatc::CkSsh_get_AuthFailReason;
*get_CaretControl = *chilkatc::CkSsh_get_CaretControl;
*put_CaretControl = *chilkatc::CkSsh_put_CaretControl;
*get_ChannelOpenFailCode = *chilkatc::CkSsh_get_ChannelOpenFailCode;
*get_ChannelOpenFailReason = *chilkatc::CkSsh_get_ChannelOpenFailReason;
*channelOpenFailReason = *chilkatc::CkSsh_channelOpenFailReason;
*get_ClientIdentifier = *chilkatc::CkSsh_get_ClientIdentifier;
*clientIdentifier = *chilkatc::CkSsh_clientIdentifier;
*put_ClientIdentifier = *chilkatc::CkSsh_put_ClientIdentifier;
*get_ClientIpAddress = *chilkatc::CkSsh_get_ClientIpAddress;
*clientIpAddress = *chilkatc::CkSsh_clientIpAddress;
*put_ClientIpAddress = *chilkatc::CkSsh_put_ClientIpAddress;
*get_ClientPort = *chilkatc::CkSsh_get_ClientPort;
*put_ClientPort = *chilkatc::CkSsh_put_ClientPort;
*get_ConnectTimeoutMs = *chilkatc::CkSsh_get_ConnectTimeoutMs;
*put_ConnectTimeoutMs = *chilkatc::CkSsh_put_ConnectTimeoutMs;
*get_DebugLogFilePath = *chilkatc::CkSsh_get_DebugLogFilePath;
*debugLogFilePath = *chilkatc::CkSsh_debugLogFilePath;
*put_DebugLogFilePath = *chilkatc::CkSsh_put_DebugLogFilePath;
*get_DisconnectCode = *chilkatc::CkSsh_get_DisconnectCode;
*get_DisconnectReason = *chilkatc::CkSsh_get_DisconnectReason;
*disconnectReason = *chilkatc::CkSsh_disconnectReason;
*get_EnableCompression = *chilkatc::CkSsh_get_EnableCompression;
*put_EnableCompression = *chilkatc::CkSsh_put_EnableCompression;
*get_ForceCipher = *chilkatc::CkSsh_get_ForceCipher;
*forceCipher = *chilkatc::CkSsh_forceCipher;
*put_ForceCipher = *chilkatc::CkSsh_put_ForceCipher;
*get_HeartbeatMs = *chilkatc::CkSsh_get_HeartbeatMs;
*put_HeartbeatMs = *chilkatc::CkSsh_put_HeartbeatMs;
*get_HostKeyAlg = *chilkatc::CkSsh_get_HostKeyAlg;
*hostKeyAlg = *chilkatc::CkSsh_hostKeyAlg;
*put_HostKeyAlg = *chilkatc::CkSsh_put_HostKeyAlg;
*get_HostKeyFingerprint = *chilkatc::CkSsh_get_HostKeyFingerprint;
*hostKeyFingerprint = *chilkatc::CkSsh_hostKeyFingerprint;
*get_HttpProxyAuthMethod = *chilkatc::CkSsh_get_HttpProxyAuthMethod;
*httpProxyAuthMethod = *chilkatc::CkSsh_httpProxyAuthMethod;
*put_HttpProxyAuthMethod = *chilkatc::CkSsh_put_HttpProxyAuthMethod;
*get_HttpProxyDomain = *chilkatc::CkSsh_get_HttpProxyDomain;
*httpProxyDomain = *chilkatc::CkSsh_httpProxyDomain;
*put_HttpProxyDomain = *chilkatc::CkSsh_put_HttpProxyDomain;
*get_HttpProxyHostname = *chilkatc::CkSsh_get_HttpProxyHostname;
*httpProxyHostname = *chilkatc::CkSsh_httpProxyHostname;
*put_HttpProxyHostname = *chilkatc::CkSsh_put_HttpProxyHostname;
*get_HttpProxyPassword = *chilkatc::CkSsh_get_HttpProxyPassword;
*httpProxyPassword = *chilkatc::CkSsh_httpProxyPassword;
*put_HttpProxyPassword = *chilkatc::CkSsh_put_HttpProxyPassword;
*get_HttpProxyPort = *chilkatc::CkSsh_get_HttpProxyPort;
*put_HttpProxyPort = *chilkatc::CkSsh_put_HttpProxyPort;
*get_HttpProxyUsername = *chilkatc::CkSsh_get_HttpProxyUsername;
*httpProxyUsername = *chilkatc::CkSsh_httpProxyUsername;
*put_HttpProxyUsername = *chilkatc::CkSsh_put_HttpProxyUsername;
*get_IdleTimeoutMs = *chilkatc::CkSsh_get_IdleTimeoutMs;
*put_IdleTimeoutMs = *chilkatc::CkSsh_put_IdleTimeoutMs;
*get_IsConnected = *chilkatc::CkSsh_get_IsConnected;
*get_KeepSessionLog = *chilkatc::CkSsh_get_KeepSessionLog;
*put_KeepSessionLog = *chilkatc::CkSsh_put_KeepSessionLog;
*get_LastErrorHtml = *chilkatc::CkSsh_get_LastErrorHtml;
*lastErrorHtml = *chilkatc::CkSsh_lastErrorHtml;
*get_LastErrorText = *chilkatc::CkSsh_get_LastErrorText;
*lastErrorText = *chilkatc::CkSsh_lastErrorText;
*get_LastErrorXml = *chilkatc::CkSsh_get_LastErrorXml;
*lastErrorXml = *chilkatc::CkSsh_lastErrorXml;
*get_LastMethodSuccess = *chilkatc::CkSsh_get_LastMethodSuccess;
*put_LastMethodSuccess = *chilkatc::CkSsh_put_LastMethodSuccess;
*get_MaxPacketSize = *chilkatc::CkSsh_get_MaxPacketSize;
*put_MaxPacketSize = *chilkatc::CkSsh_put_MaxPacketSize;
*get_NumOpenChannels = *chilkatc::CkSsh_get_NumOpenChannels;
*get_PasswordChangeRequested = *chilkatc::CkSsh_get_PasswordChangeRequested;
*get_PreferIpv6 = *chilkatc::CkSsh_get_PreferIpv6;
*put_PreferIpv6 = *chilkatc::CkSsh_put_PreferIpv6;
*get_ReadTimeoutMs = *chilkatc::CkSsh_get_ReadTimeoutMs;
*put_ReadTimeoutMs = *chilkatc::CkSsh_put_ReadTimeoutMs;
*get_ReqExecCharset = *chilkatc::CkSsh_get_ReqExecCharset;
*reqExecCharset = *chilkatc::CkSsh_reqExecCharset;
*put_ReqExecCharset = *chilkatc::CkSsh_put_ReqExecCharset;
*get_ServerIdentifier = *chilkatc::CkSsh_get_ServerIdentifier;
*serverIdentifier = *chilkatc::CkSsh_serverIdentifier;
*get_SessionLog = *chilkatc::CkSsh_get_SessionLog;
*sessionLog = *chilkatc::CkSsh_sessionLog;
*get_SocksHostname = *chilkatc::CkSsh_get_SocksHostname;
*socksHostname = *chilkatc::CkSsh_socksHostname;
*put_SocksHostname = *chilkatc::CkSsh_put_SocksHostname;
*get_SocksPassword = *chilkatc::CkSsh_get_SocksPassword;
*socksPassword = *chilkatc::CkSsh_socksPassword;
*put_SocksPassword = *chilkatc::CkSsh_put_SocksPassword;
*get_SocksPort = *chilkatc::CkSsh_get_SocksPort;
*put_SocksPort = *chilkatc::CkSsh_put_SocksPort;
*get_SocksUsername = *chilkatc::CkSsh_get_SocksUsername;
*socksUsername = *chilkatc::CkSsh_socksUsername;
*put_SocksUsername = *chilkatc::CkSsh_put_SocksUsername;
*get_SocksVersion = *chilkatc::CkSsh_get_SocksVersion;
*put_SocksVersion = *chilkatc::CkSsh_put_SocksVersion;
*get_SoRcvBuf = *chilkatc::CkSsh_get_SoRcvBuf;
*put_SoRcvBuf = *chilkatc::CkSsh_put_SoRcvBuf;
*get_SoSndBuf = *chilkatc::CkSsh_get_SoSndBuf;
*put_SoSndBuf = *chilkatc::CkSsh_put_SoSndBuf;
*get_StderrToStdout = *chilkatc::CkSsh_get_StderrToStdout;
*put_StderrToStdout = *chilkatc::CkSsh_put_StderrToStdout;
*get_StripColorCodes = *chilkatc::CkSsh_get_StripColorCodes;
*put_StripColorCodes = *chilkatc::CkSsh_put_StripColorCodes;
*get_TcpNoDelay = *chilkatc::CkSsh_get_TcpNoDelay;
*put_TcpNoDelay = *chilkatc::CkSsh_put_TcpNoDelay;
*get_UncommonOptions = *chilkatc::CkSsh_get_UncommonOptions;
*uncommonOptions = *chilkatc::CkSsh_uncommonOptions;
*put_UncommonOptions = *chilkatc::CkSsh_put_UncommonOptions;
*get_UserAuthBanner = *chilkatc::CkSsh_get_UserAuthBanner;
*userAuthBanner = *chilkatc::CkSsh_userAuthBanner;
*put_UserAuthBanner = *chilkatc::CkSsh_put_UserAuthBanner;
*get_VerboseLogging = *chilkatc::CkSsh_get_VerboseLogging;
*put_VerboseLogging = *chilkatc::CkSsh_put_VerboseLogging;
*get_Version = *chilkatc::CkSsh_get_Version;
*version = *chilkatc::CkSsh_version;
*AuthenticatePk = *chilkatc::CkSsh_AuthenticatePk;
*AuthenticatePkAsync = *chilkatc::CkSsh_AuthenticatePkAsync;
*AuthenticatePw = *chilkatc::CkSsh_AuthenticatePw;
*AuthenticatePwAsync = *chilkatc::CkSsh_AuthenticatePwAsync;
*AuthenticatePwPk = *chilkatc::CkSsh_AuthenticatePwPk;
*AuthenticatePwPkAsync = *chilkatc::CkSsh_AuthenticatePwPkAsync;
*AuthenticateSecPw = *chilkatc::CkSsh_AuthenticateSecPw;
*AuthenticateSecPwAsync = *chilkatc::CkSsh_AuthenticateSecPwAsync;
*AuthenticateSecPwPk = *chilkatc::CkSsh_AuthenticateSecPwPk;
*AuthenticateSecPwPkAsync = *chilkatc::CkSsh_AuthenticateSecPwPkAsync;
*ChannelIsOpen = *chilkatc::CkSsh_ChannelIsOpen;
*ChannelPoll = *chilkatc::CkSsh_ChannelPoll;
*ChannelPollAsync = *chilkatc::CkSsh_ChannelPollAsync;
*ChannelRead = *chilkatc::CkSsh_ChannelRead;
*ChannelReadAsync = *chilkatc::CkSsh_ChannelReadAsync;
*ChannelReadAndPoll = *chilkatc::CkSsh_ChannelReadAndPoll;
*ChannelReadAndPollAsync = *chilkatc::CkSsh_ChannelReadAndPollAsync;
*ChannelReadAndPoll2 = *chilkatc::CkSsh_ChannelReadAndPoll2;
*ChannelReadAndPoll2Async = *chilkatc::CkSsh_ChannelReadAndPoll2Async;
*ChannelReceivedClose = *chilkatc::CkSsh_ChannelReceivedClose;
*ChannelReceivedEof = *chilkatc::CkSsh_ChannelReceivedEof;
*ChannelReceivedExitStatus = *chilkatc::CkSsh_ChannelReceivedExitStatus;
*ChannelReceiveToClose = *chilkatc::CkSsh_ChannelReceiveToClose;
*ChannelReceiveToCloseAsync = *chilkatc::CkSsh_ChannelReceiveToCloseAsync;
*ChannelReceiveUntilMatch = *chilkatc::CkSsh_ChannelReceiveUntilMatch;
*ChannelReceiveUntilMatchAsync = *chilkatc::CkSsh_ChannelReceiveUntilMatchAsync;
*ChannelReceiveUntilMatchN = *chilkatc::CkSsh_ChannelReceiveUntilMatchN;
*ChannelReceiveUntilMatchNAsync = *chilkatc::CkSsh_ChannelReceiveUntilMatchNAsync;
*ChannelRelease = *chilkatc::CkSsh_ChannelRelease;
*ChannelSendClose = *chilkatc::CkSsh_ChannelSendClose;
*ChannelSendCloseAsync = *chilkatc::CkSsh_ChannelSendCloseAsync;
*ChannelSendData = *chilkatc::CkSsh_ChannelSendData;
*ChannelSendDataAsync = *chilkatc::CkSsh_ChannelSendDataAsync;
*ChannelSendEof = *chilkatc::CkSsh_ChannelSendEof;
*ChannelSendEofAsync = *chilkatc::CkSsh_ChannelSendEofAsync;
*ChannelSendString = *chilkatc::CkSsh_ChannelSendString;
*ChannelSendStringAsync = *chilkatc::CkSsh_ChannelSendStringAsync;
*CheckConnection = *chilkatc::CkSsh_CheckConnection;
*ClearTtyModes = *chilkatc::CkSsh_ClearTtyModes;
*Connect = *chilkatc::CkSsh_Connect;
*ConnectAsync = *chilkatc::CkSsh_ConnectAsync;
*ConnectThroughSsh = *chilkatc::CkSsh_ConnectThroughSsh;
*ConnectThroughSshAsync = *chilkatc::CkSsh_ConnectThroughSshAsync;
*ContinueKeyboardAuth = *chilkatc::CkSsh_ContinueKeyboardAuth;
*continueKeyboardAuth = *chilkatc::CkSsh_continueKeyboardAuth;
*ContinueKeyboardAuthAsync = *chilkatc::CkSsh_ContinueKeyboardAuthAsync;
*Disconnect = *chilkatc::CkSsh_Disconnect;
*GetAuthMethods = *chilkatc::CkSsh_GetAuthMethods;
*getAuthMethods = *chilkatc::CkSsh_getAuthMethods;
*authMethods = *chilkatc::CkSsh_authMethods;
*GetAuthMethodsAsync = *chilkatc::CkSsh_GetAuthMethodsAsync;
*GetChannelExitStatus = *chilkatc::CkSsh_GetChannelExitStatus;
*GetChannelNumber = *chilkatc::CkSsh_GetChannelNumber;
*GetChannelType = *chilkatc::CkSsh_GetChannelType;
*getChannelType = *chilkatc::CkSsh_getChannelType;
*channelType = *chilkatc::CkSsh_channelType;
*GetHostKeyFP = *chilkatc::CkSsh_GetHostKeyFP;
*getHostKeyFP = *chilkatc::CkSsh_getHostKeyFP;
*hostKeyFP = *chilkatc::CkSsh_hostKeyFP;
*GetLastJsonData = *chilkatc::CkSsh_GetLastJsonData;
*GetReceivedData = *chilkatc::CkSsh_GetReceivedData;
*GetReceivedDataN = *chilkatc::CkSsh_GetReceivedDataN;
*GetReceivedNumBytes = *chilkatc::CkSsh_GetReceivedNumBytes;
*GetReceivedStderr = *chilkatc::CkSsh_GetReceivedStderr;
*GetReceivedStderrText = *chilkatc::CkSsh_GetReceivedStderrText;
*getReceivedStderrText = *chilkatc::CkSsh_getReceivedStderrText;
*receivedStderrText = *chilkatc::CkSsh_receivedStderrText;
*GetReceivedText = *chilkatc::CkSsh_GetReceivedText;
*getReceivedText = *chilkatc::CkSsh_getReceivedText;
*receivedText = *chilkatc::CkSsh_receivedText;
*GetReceivedTextS = *chilkatc::CkSsh_GetReceivedTextS;
*getReceivedTextS = *chilkatc::CkSsh_getReceivedTextS;
*receivedTextS = *chilkatc::CkSsh_receivedTextS;
*LastJsonData = *chilkatc::CkSsh_LastJsonData;
*LoadTaskCaller = *chilkatc::CkSsh_LoadTaskCaller;
*OpenCustomChannel = *chilkatc::CkSsh_OpenCustomChannel;
*OpenCustomChannelAsync = *chilkatc::CkSsh_OpenCustomChannelAsync;
*OpenDirectTcpIpChannel = *chilkatc::CkSsh_OpenDirectTcpIpChannel;
*OpenDirectTcpIpChannelAsync = *chilkatc::CkSsh_OpenDirectTcpIpChannelAsync;
*OpenSessionChannel = *chilkatc::CkSsh_OpenSessionChannel;
*OpenSessionChannelAsync = *chilkatc::CkSsh_OpenSessionChannelAsync;
*PeekReceivedText = *chilkatc::CkSsh_PeekReceivedText;
*peekReceivedText = *chilkatc::CkSsh_peekReceivedText;
*QuickCmdCheck = *chilkatc::CkSsh_QuickCmdCheck;
*QuickCmdCheckAsync = *chilkatc::CkSsh_QuickCmdCheckAsync;
*QuickCmdSend = *chilkatc::CkSsh_QuickCmdSend;
*QuickCmdSendAsync = *chilkatc::CkSsh_QuickCmdSendAsync;
*QuickCommand = *chilkatc::CkSsh_QuickCommand;
*quickCommand = *chilkatc::CkSsh_quickCommand;
*QuickCommandAsync = *chilkatc::CkSsh_QuickCommandAsync;
*QuickShell = *chilkatc::CkSsh_QuickShell;
*QuickShellAsync = *chilkatc::CkSsh_QuickShellAsync;
*ReKey = *chilkatc::CkSsh_ReKey;
*ReKeyAsync = *chilkatc::CkSsh_ReKeyAsync;
*SendIgnore = *chilkatc::CkSsh_SendIgnore;
*SendIgnoreAsync = *chilkatc::CkSsh_SendIgnoreAsync;
*SendReqExec = *chilkatc::CkSsh_SendReqExec;
*SendReqExecAsync = *chilkatc::CkSsh_SendReqExecAsync;
*SendReqPty = *chilkatc::CkSsh_SendReqPty;
*SendReqPtyAsync = *chilkatc::CkSsh_SendReqPtyAsync;
*SendReqSetEnv = *chilkatc::CkSsh_SendReqSetEnv;
*SendReqSetEnvAsync = *chilkatc::CkSsh_SendReqSetEnvAsync;
*SendReqShell = *chilkatc::CkSsh_SendReqShell;
*SendReqShellAsync = *chilkatc::CkSsh_SendReqShellAsync;
*SendReqSignal = *chilkatc::CkSsh_SendReqSignal;
*SendReqSignalAsync = *chilkatc::CkSsh_SendReqSignalAsync;
*SendReqSubsystem = *chilkatc::CkSsh_SendReqSubsystem;
*SendReqSubsystemAsync = *chilkatc::CkSsh_SendReqSubsystemAsync;
*SendReqWindowChange = *chilkatc::CkSsh_SendReqWindowChange;
*SendReqWindowChangeAsync = *chilkatc::CkSsh_SendReqWindowChangeAsync;
*SendReqX11Forwarding = *chilkatc::CkSsh_SendReqX11Forwarding;
*SendReqX11ForwardingAsync = *chilkatc::CkSsh_SendReqX11ForwardingAsync;
*SendReqXonXoff = *chilkatc::CkSsh_SendReqXonXoff;
*SendReqXonXoffAsync = *chilkatc::CkSsh_SendReqXonXoffAsync;
*SetAllowedAlgorithms = *chilkatc::CkSsh_SetAllowedAlgorithms;
*SetTtyMode = *chilkatc::CkSsh_SetTtyMode;
*StartKeyboardAuth = *chilkatc::CkSsh_StartKeyboardAuth;
*startKeyboardAuth = *chilkatc::CkSsh_startKeyboardAuth;
*StartKeyboardAuthAsync = *chilkatc::CkSsh_StartKeyboardAuthAsync;
*WaitForChannelMessage = *chilkatc::CkSsh_WaitForChannelMessage;
*WaitForChannelMessageAsync = *chilkatc::CkSsh_WaitForChannelMessageAsync;
sub DISOWN {
    my $self = shift;
    my $ptr = tied(%$self);
    delete $OWNER{$ptr};
}

sub ACQUIRE {
    my $self = shift;
    my $ptr = tied(%$self);
    $OWNER{$ptr} = 1;
}


############# Class : chilkat::CkSshKey ##############

package chilkat::CkSshKey;
use vars qw(@ISA %OWNER %ITERATORS %BLESSEDMEMBERS);
@ISA = qw( chilkat );
%OWNER = ();
%ITERATORS = ();
sub new {
    my $pkg = shift;
    my $self = chilkatc::new_CkSshKey(@_);
    bless $self, $pkg if defined($self);
}

sub DESTROY {
    return unless $_[0]->isa('HASH');
    my $self = tied(%{$_[0]});
    return unless defined $self;
    delete $ITERATORS{$self};
    if (exists $OWNER{$self}) {
        chilkatc::delete_CkSshKey($self);
        delete $OWNER{$self};
    }
}

*get_Utf8 = *chilkatc::CkSshKey_get_Utf8;
*put_Utf8 = *chilkatc::CkSshKey_put_Utf8;
*LastErrorXml = *chilkatc::CkSshKey_LastErrorXml;
*LastErrorHtml = *chilkatc::CkSshKey_LastErrorHtml;
*LastErrorText = *chilkatc::CkSshKey_LastErrorText;
*get_Comment = *chilkatc::CkSshKey_get_Comment;
*comment = *chilkatc::CkSshKey_comment;
*put_Comment = *chilkatc::CkSshKey_put_Comment;
*get_DebugLogFilePath = *chilkatc::CkSshKey_get_DebugLogFilePath;
*debugLogFilePath = *chilkatc::CkSshKey_debugLogFilePath;
*put_DebugLogFilePath = *chilkatc::CkSshKey_put_DebugLogFilePath;
*get_IsDsaKey = *chilkatc::CkSshKey_get_IsDsaKey;
*get_IsPrivateKey = *chilkatc::CkSshKey_get_IsPrivateKey;
*get_IsRsaKey = *chilkatc::CkSshKey_get_IsRsaKey;
*get_KeyType = *chilkatc::CkSshKey_get_KeyType;
*keyType = *chilkatc::CkSshKey_keyType;
*get_LastErrorHtml = *chilkatc::CkSshKey_get_LastErrorHtml;
*lastErrorHtml = *chilkatc::CkSshKey_lastErrorHtml;
*get_LastErrorText = *chilkatc::CkSshKey_get_LastErrorText;
*lastErrorText = *chilkatc::CkSshKey_lastErrorText;
*get_LastErrorXml = *chilkatc::CkSshKey_get_LastErrorXml;
*lastErrorXml = *chilkatc::CkSshKey_lastErrorXml;
*get_LastMethodSuccess = *chilkatc::CkSshKey_get_LastMethodSuccess;
*put_LastMethodSuccess = *chilkatc::CkSshKey_put_LastMethodSuccess;
*get_Password = *chilkatc::CkSshKey_get_Password;
*password = *chilkatc::CkSshKey_password;
*put_Password = *chilkatc::CkSshKey_put_Password;
*get_UncommonOptions = *chilkatc::CkSshKey_get_UncommonOptions;
*uncommonOptions = *chilkatc::CkSshKey_uncommonOptions;
*put_UncommonOptions = *chilkatc::CkSshKey_put_UncommonOptions;
*get_VerboseLogging = *chilkatc::CkSshKey_get_VerboseLogging;
*put_VerboseLogging = *chilkatc::CkSshKey_put_VerboseLogging;
*get_Version = *chilkatc::CkSshKey_get_Version;
*version = *chilkatc::CkSshKey_version;
*FromOpenSshPrivateKey = *chilkatc::CkSshKey_FromOpenSshPrivateKey;
*FromOpenSshPublicKey = *chilkatc::CkSshKey_FromOpenSshPublicKey;
*FromPuttyPrivateKey = *chilkatc::CkSshKey_FromPuttyPrivateKey;
*FromRfc4716PublicKey = *chilkatc::CkSshKey_FromRfc4716PublicKey;
*FromXml = *chilkatc::CkSshKey_FromXml;
*GenerateDsaKey = *chilkatc::CkSshKey_GenerateDsaKey;
*GenerateEcdsaKey = *chilkatc::CkSshKey_GenerateEcdsaKey;
*GenerateEd25519Key = *chilkatc::CkSshKey_GenerateEd25519Key;
*GenerateRsaKey = *chilkatc::CkSshKey_GenerateRsaKey;
*GenFingerprint = *chilkatc::CkSshKey_GenFingerprint;
*genFingerprint = *chilkatc::CkSshKey_genFingerprint;
*LoadText = *chilkatc::CkSshKey_LoadText;
*loadText = *chilkatc::CkSshKey_loadText;
*SaveText = *chilkatc::CkSshKey_SaveText;
*ToOpenSshPrivateKey = *chilkatc::CkSshKey_ToOpenSshPrivateKey;
*toOpenSshPrivateKey = *chilkatc::CkSshKey_toOpenSshPrivateKey;
*ToOpenSshPublicKey = *chilkatc::CkSshKey_ToOpenSshPublicKey;
*toOpenSshPublicKey = *chilkatc::CkSshKey_toOpenSshPublicKey;
*ToPuttyPrivateKey = *chilkatc::CkSshKey_ToPuttyPrivateKey;
*toPuttyPrivateKey = *chilkatc::CkSshKey_toPuttyPrivateKey;
*ToRfc4716PublicKey = *chilkatc::CkSshKey_ToRfc4716PublicKey;
*toRfc4716PublicKey = *chilkatc::CkSshKey_toRfc4716PublicKey;
*ToXml = *chilkatc::CkSshKey_ToXml;
*toXml = *chilkatc::CkSshKey_toXml;
*UsePkcs11 = *chilkatc::CkSshKey_UsePkcs11;
*UseSshCertificate = *chilkatc::CkSshKey_UseSshCertificate;
sub DISOWN {
    my $self = shift;
    my $ptr = tied(%$self);
    delete $OWNER{$ptr};
}

sub ACQUIRE {
    my $self = shift;
    my $ptr = tied(%$self);
    $OWNER{$ptr} = 1;
}


############# Class : chilkat::CkSshTunnel ##############

package chilkat::CkSshTunnel;
use vars qw(@ISA %OWNER %ITERATORS %BLESSEDMEMBERS);
@ISA = qw( chilkat );
%OWNER = ();
%ITERATORS = ();
sub new {
    my $pkg = shift;
    my $self = chilkatc::new_CkSshTunnel(@_);
    bless $self, $pkg if defined($self);
}

sub DESTROY {
    return unless $_[0]->isa('HASH');
    my $self = tied(%{$_[0]});
    return unless defined $self;
    delete $ITERATORS{$self};
    if (exists $OWNER{$self}) {
        chilkatc::delete_CkSshTunnel($self);
        delete $OWNER{$self};
    }
}

*get_Utf8 = *chilkatc::CkSshTunnel_get_Utf8;
*put_Utf8 = *chilkatc::CkSshTunnel_put_Utf8;
*LastErrorXml = *chilkatc::CkSshTunnel_LastErrorXml;
*LastErrorHtml = *chilkatc::CkSshTunnel_LastErrorHtml;
*LastErrorText = *chilkatc::CkSshTunnel_LastErrorText;
*put_EventCallbackObject = *chilkatc::CkSshTunnel_put_EventCallbackObject;
*get_AbortCurrent = *chilkatc::CkSshTunnel_get_AbortCurrent;
*put_AbortCurrent = *chilkatc::CkSshTunnel_put_AbortCurrent;
*get_AcceptLog = *chilkatc::CkSshTunnel_get_AcceptLog;
*acceptLog = *chilkatc::CkSshTunnel_acceptLog;
*put_AcceptLog = *chilkatc::CkSshTunnel_put_AcceptLog;
*get_AcceptLogPath = *chilkatc::CkSshTunnel_get_AcceptLogPath;
*acceptLogPath = *chilkatc::CkSshTunnel_acceptLogPath;
*put_AcceptLogPath = *chilkatc::CkSshTunnel_put_AcceptLogPath;
*get_ClientIdentifier = *chilkatc::CkSshTunnel_get_ClientIdentifier;
*clientIdentifier = *chilkatc::CkSshTunnel_clientIdentifier;
*put_ClientIdentifier = *chilkatc::CkSshTunnel_put_ClientIdentifier;
*get_ClientLogDir = *chilkatc::CkSshTunnel_get_ClientLogDir;
*clientLogDir = *chilkatc::CkSshTunnel_clientLogDir;
*put_ClientLogDir = *chilkatc::CkSshTunnel_put_ClientLogDir;
*get_ConnectTimeoutMs = *chilkatc::CkSshTunnel_get_ConnectTimeoutMs;
*put_ConnectTimeoutMs = *chilkatc::CkSshTunnel_put_ConnectTimeoutMs;
*get_DebugLogFilePath = *chilkatc::CkSshTunnel_get_DebugLogFilePath;
*debugLogFilePath = *chilkatc::CkSshTunnel_debugLogFilePath;
*put_DebugLogFilePath = *chilkatc::CkSshTunnel_put_DebugLogFilePath;
*get_DestHostname = *chilkatc::CkSshTunnel_get_DestHostname;
*destHostname = *chilkatc::CkSshTunnel_destHostname;
*put_DestHostname = *chilkatc::CkSshTunnel_put_DestHostname;
*get_DestPort = *chilkatc::CkSshTunnel_get_DestPort;
*put_DestPort = *chilkatc::CkSshTunnel_put_DestPort;
*get_DynamicPortForwarding = *chilkatc::CkSshTunnel_get_DynamicPortForwarding;
*put_DynamicPortForwarding = *chilkatc::CkSshTunnel_put_DynamicPortForwarding;
*get_HostKeyFingerprint = *chilkatc::CkSshTunnel_get_HostKeyFingerprint;
*hostKeyFingerprint = *chilkatc::CkSshTunnel_hostKeyFingerprint;
*get_HttpProxyAuthMethod = *chilkatc::CkSshTunnel_get_HttpProxyAuthMethod;
*httpProxyAuthMethod = *chilkatc::CkSshTunnel_httpProxyAuthMethod;
*put_HttpProxyAuthMethod = *chilkatc::CkSshTunnel_put_HttpProxyAuthMethod;
*get_HttpProxyDomain = *chilkatc::CkSshTunnel_get_HttpProxyDomain;
*httpProxyDomain = *chilkatc::CkSshTunnel_httpProxyDomain;
*put_HttpProxyDomain = *chilkatc::CkSshTunnel_put_HttpProxyDomain;
*get_HttpProxyHostname = *chilkatc::CkSshTunnel_get_HttpProxyHostname;
*httpProxyHostname = *chilkatc::CkSshTunnel_httpProxyHostname;
*put_HttpProxyHostname = *chilkatc::CkSshTunnel_put_HttpProxyHostname;
*get_HttpProxyPassword = *chilkatc::CkSshTunnel_get_HttpProxyPassword;
*httpProxyPassword = *chilkatc::CkSshTunnel_httpProxyPassword;
*put_HttpProxyPassword = *chilkatc::CkSshTunnel_put_HttpProxyPassword;
*get_HttpProxyPort = *chilkatc::CkSshTunnel_get_HttpProxyPort;
*put_HttpProxyPort = *chilkatc::CkSshTunnel_put_HttpProxyPort;
*get_HttpProxyUsername = *chilkatc::CkSshTunnel_get_HttpProxyUsername;
*httpProxyUsername = *chilkatc::CkSshTunnel_httpProxyUsername;
*put_HttpProxyUsername = *chilkatc::CkSshTunnel_put_HttpProxyUsername;
*get_IdleTimeoutMs = *chilkatc::CkSshTunnel_get_IdleTimeoutMs;
*put_IdleTimeoutMs = *chilkatc::CkSshTunnel_put_IdleTimeoutMs;
*get_InboundSocksPassword = *chilkatc::CkSshTunnel_get_InboundSocksPassword;
*inboundSocksPassword = *chilkatc::CkSshTunnel_inboundSocksPassword;
*put_InboundSocksPassword = *chilkatc::CkSshTunnel_put_InboundSocksPassword;
*get_InboundSocksUsername = *chilkatc::CkSshTunnel_get_InboundSocksUsername;
*inboundSocksUsername = *chilkatc::CkSshTunnel_inboundSocksUsername;
*put_InboundSocksUsername = *chilkatc::CkSshTunnel_put_InboundSocksUsername;
*get_IsAccepting = *chilkatc::CkSshTunnel_get_IsAccepting;
*get_KeepAcceptLog = *chilkatc::CkSshTunnel_get_KeepAcceptLog;
*put_KeepAcceptLog = *chilkatc::CkSshTunnel_put_KeepAcceptLog;
*get_KeepTunnelLog = *chilkatc::CkSshTunnel_get_KeepTunnelLog;
*put_KeepTunnelLog = *chilkatc::CkSshTunnel_put_KeepTunnelLog;
*get_LastErrorHtml = *chilkatc::CkSshTunnel_get_LastErrorHtml;
*lastErrorHtml = *chilkatc::CkSshTunnel_lastErrorHtml;
*get_LastErrorText = *chilkatc::CkSshTunnel_get_LastErrorText;
*lastErrorText = *chilkatc::CkSshTunnel_lastErrorText;
*get_LastErrorXml = *chilkatc::CkSshTunnel_get_LastErrorXml;
*lastErrorXml = *chilkatc::CkSshTunnel_lastErrorXml;
*get_LastMethodSuccess = *chilkatc::CkSshTunnel_get_LastMethodSuccess;
*put_LastMethodSuccess = *chilkatc::CkSshTunnel_put_LastMethodSuccess;
*get_ListenBindIpAddress = *chilkatc::CkSshTunnel_get_ListenBindIpAddress;
*listenBindIpAddress = *chilkatc::CkSshTunnel_listenBindIpAddress;
*put_ListenBindIpAddress = *chilkatc::CkSshTunnel_put_ListenBindIpAddress;
*get_ListenPort = *chilkatc::CkSshTunnel_get_ListenPort;
*get_OutboundBindIpAddress = *chilkatc::CkSshTunnel_get_OutboundBindIpAddress;
*outboundBindIpAddress = *chilkatc::CkSshTunnel_outboundBindIpAddress;
*put_OutboundBindIpAddress = *chilkatc::CkSshTunnel_put_OutboundBindIpAddress;
*get_OutboundBindPort = *chilkatc::CkSshTunnel_get_OutboundBindPort;
*put_OutboundBindPort = *chilkatc::CkSshTunnel_put_OutboundBindPort;
*get_PreferIpv6 = *chilkatc::CkSshTunnel_get_PreferIpv6;
*put_PreferIpv6 = *chilkatc::CkSshTunnel_put_PreferIpv6;
*get_SocksHostname = *chilkatc::CkSshTunnel_get_SocksHostname;
*socksHostname = *chilkatc::CkSshTunnel_socksHostname;
*put_SocksHostname = *chilkatc::CkSshTunnel_put_SocksHostname;
*get_SocksPassword = *chilkatc::CkSshTunnel_get_SocksPassword;
*socksPassword = *chilkatc::CkSshTunnel_socksPassword;
*put_SocksPassword = *chilkatc::CkSshTunnel_put_SocksPassword;
*get_SocksPort = *chilkatc::CkSshTunnel_get_SocksPort;
*put_SocksPort = *chilkatc::CkSshTunnel_put_SocksPort;
*get_SocksUsername = *chilkatc::CkSshTunnel_get_SocksUsername;
*socksUsername = *chilkatc::CkSshTunnel_socksUsername;
*put_SocksUsername = *chilkatc::CkSshTunnel_put_SocksUsername;
*get_SocksVersion = *chilkatc::CkSshTunnel_get_SocksVersion;
*put_SocksVersion = *chilkatc::CkSshTunnel_put_SocksVersion;
*get_SoRcvBuf = *chilkatc::CkSshTunnel_get_SoRcvBuf;
*put_SoRcvBuf = *chilkatc::CkSshTunnel_put_SoRcvBuf;
*get_SoSndBuf = *chilkatc::CkSshTunnel_get_SoSndBuf;
*put_SoSndBuf = *chilkatc::CkSshTunnel_put_SoSndBuf;
*get_TcpNoDelay = *chilkatc::CkSshTunnel_get_TcpNoDelay;
*put_TcpNoDelay = *chilkatc::CkSshTunnel_put_TcpNoDelay;
*get_TunnelLog = *chilkatc::CkSshTunnel_get_TunnelLog;
*tunnelLog = *chilkatc::CkSshTunnel_tunnelLog;
*put_TunnelLog = *chilkatc::CkSshTunnel_put_TunnelLog;
*get_TunnelLogPath = *chilkatc::CkSshTunnel_get_TunnelLogPath;
*tunnelLogPath = *chilkatc::CkSshTunnel_tunnelLogPath;
*put_TunnelLogPath = *chilkatc::CkSshTunnel_put_TunnelLogPath;
*get_UncommonOptions = *chilkatc::CkSshTunnel_get_UncommonOptions;
*uncommonOptions = *chilkatc::CkSshTunnel_uncommonOptions;
*put_UncommonOptions = *chilkatc::CkSshTunnel_put_UncommonOptions;
*get_VerboseLogging = *chilkatc::CkSshTunnel_get_VerboseLogging;
*put_VerboseLogging = *chilkatc::CkSshTunnel_put_VerboseLogging;
*get_Version = *chilkatc::CkSshTunnel_get_Version;
*version = *chilkatc::CkSshTunnel_version;
*AuthenticatePk = *chilkatc::CkSshTunnel_AuthenticatePk;
*AuthenticatePkAsync = *chilkatc::CkSshTunnel_AuthenticatePkAsync;
*AuthenticatePw = *chilkatc::CkSshTunnel_AuthenticatePw;
*AuthenticatePwAsync = *chilkatc::CkSshTunnel_AuthenticatePwAsync;
*AuthenticatePwPk = *chilkatc::CkSshTunnel_AuthenticatePwPk;
*AuthenticatePwPkAsync = *chilkatc::CkSshTunnel_AuthenticatePwPkAsync;
*AuthenticateSecPw = *chilkatc::CkSshTunnel_AuthenticateSecPw;
*AuthenticateSecPwAsync = *chilkatc::CkSshTunnel_AuthenticateSecPwAsync;
*AuthenticateSecPwPk = *chilkatc::CkSshTunnel_AuthenticateSecPwPk;
*AuthenticateSecPwPkAsync = *chilkatc::CkSshTunnel_AuthenticateSecPwPkAsync;
*BeginAccepting = *chilkatc::CkSshTunnel_BeginAccepting;
*BeginAcceptingAsync = *chilkatc::CkSshTunnel_BeginAcceptingAsync;
*CloseTunnel = *chilkatc::CkSshTunnel_CloseTunnel;
*Connect = *chilkatc::CkSshTunnel_Connect;
*ConnectAsync = *chilkatc::CkSshTunnel_ConnectAsync;
*ConnectThroughSsh = *chilkatc::CkSshTunnel_ConnectThroughSsh;
*ConnectThroughSshAsync = *chilkatc::CkSshTunnel_ConnectThroughSshAsync;
*ContinueKeyboardAuth = *chilkatc::CkSshTunnel_ContinueKeyboardAuth;
*continueKeyboardAuth = *chilkatc::CkSshTunnel_continueKeyboardAuth;
*ContinueKeyboardAuthAsync = *chilkatc::CkSshTunnel_ContinueKeyboardAuthAsync;
*DisconnectAllClients = *chilkatc::CkSshTunnel_DisconnectAllClients;
*GetCurrentState = *chilkatc::CkSshTunnel_GetCurrentState;
*getCurrentState = *chilkatc::CkSshTunnel_getCurrentState;
*currentState = *chilkatc::CkSshTunnel_currentState;
*IsSshConnected = *chilkatc::CkSshTunnel_IsSshConnected;
*LoadTaskCaller = *chilkatc::CkSshTunnel_LoadTaskCaller;
*SetAllowedAlgorithms = *chilkatc::CkSshTunnel_SetAllowedAlgorithms;
*StartKeyboardAuth = *chilkatc::CkSshTunnel_StartKeyboardAuth;
*startKeyboardAuth = *chilkatc::CkSshTunnel_startKeyboardAuth;
*StartKeyboardAuthAsync = *chilkatc::CkSshTunnel_StartKeyboardAuthAsync;
*StopAccepting = *chilkatc::CkSshTunnel_StopAccepting;
sub DISOWN {
    my $self = shift;
    my $ptr = tied(%$self);
    delete $OWNER{$ptr};
}

sub ACQUIRE {
    my $self = shift;
    my $ptr = tied(%$self);
    $OWNER{$ptr} = 1;
}


############# Class : chilkat::CkStream ##############

package chilkat::CkStream;
use vars qw(@ISA %OWNER %ITERATORS %BLESSEDMEMBERS);
@ISA = qw( chilkat );
%OWNER = ();
%ITERATORS = ();
sub new {
    my $pkg = shift;
    my $self = chilkatc::new_CkStream(@_);
    bless $self, $pkg if defined($self);
}

sub DESTROY {
    return unless $_[0]->isa('HASH');
    my $self = tied(%{$_[0]});
    return unless defined $self;
    delete $ITERATORS{$self};
    if (exists $OWNER{$self}) {
        chilkatc::delete_CkStream($self);
        delete $OWNER{$self};
    }
}

*get_Utf8 = *chilkatc::CkStream_get_Utf8;
*put_Utf8 = *chilkatc::CkStream_put_Utf8;
*LastErrorXml = *chilkatc::CkStream_LastErrorXml;
*LastErrorHtml = *chilkatc::CkStream_LastErrorHtml;
*LastErrorText = *chilkatc::CkStream_LastErrorText;
*put_EventCallbackObject = *chilkatc::CkStream_put_EventCallbackObject;
*get_AbortCurrent = *chilkatc::CkStream_get_AbortCurrent;
*put_AbortCurrent = *chilkatc::CkStream_put_AbortCurrent;
*get_CanRead = *chilkatc::CkStream_get_CanRead;
*get_CanWrite = *chilkatc::CkStream_get_CanWrite;
*get_DataAvailable = *chilkatc::CkStream_get_DataAvailable;
*get_DebugLogFilePath = *chilkatc::CkStream_get_DebugLogFilePath;
*debugLogFilePath = *chilkatc::CkStream_debugLogFilePath;
*put_DebugLogFilePath = *chilkatc::CkStream_put_DebugLogFilePath;
*get_DefaultChunkSize = *chilkatc::CkStream_get_DefaultChunkSize;
*put_DefaultChunkSize = *chilkatc::CkStream_put_DefaultChunkSize;
*get_EndOfStream = *chilkatc::CkStream_get_EndOfStream;
*get_HeartbeatMs = *chilkatc::CkStream_get_HeartbeatMs;
*put_HeartbeatMs = *chilkatc::CkStream_put_HeartbeatMs;
*get_IsWriteClosed = *chilkatc::CkStream_get_IsWriteClosed;
*get_LastErrorHtml = *chilkatc::CkStream_get_LastErrorHtml;
*lastErrorHtml = *chilkatc::CkStream_lastErrorHtml;
*get_LastErrorText = *chilkatc::CkStream_get_LastErrorText;
*lastErrorText = *chilkatc::CkStream_lastErrorText;
*get_LastErrorXml = *chilkatc::CkStream_get_LastErrorXml;
*lastErrorXml = *chilkatc::CkStream_lastErrorXml;
*get_LastMethodSuccess = *chilkatc::CkStream_get_LastMethodSuccess;
*put_LastMethodSuccess = *chilkatc::CkStream_put_LastMethodSuccess;
*get_Length = *chilkatc::CkStream_get_Length;
*put_Length = *chilkatc::CkStream_put_Length;
*get_Length32 = *chilkatc::CkStream_get_Length32;
*put_Length32 = *chilkatc::CkStream_put_Length32;
*get_NumReceived = *chilkatc::CkStream_get_NumReceived;
*get_NumSent = *chilkatc::CkStream_get_NumSent;
*get_ReadFailReason = *chilkatc::CkStream_get_ReadFailReason;
*get_ReadTimeoutMs = *chilkatc::CkStream_get_ReadTimeoutMs;
*put_ReadTimeoutMs = *chilkatc::CkStream_put_ReadTimeoutMs;
*get_SinkFile = *chilkatc::CkStream_get_SinkFile;
*sinkFile = *chilkatc::CkStream_sinkFile;
*put_SinkFile = *chilkatc::CkStream_put_SinkFile;
*get_SinkFileAppend = *chilkatc::CkStream_get_SinkFileAppend;
*put_SinkFileAppend = *chilkatc::CkStream_put_SinkFileAppend;
*get_SourceFile = *chilkatc::CkStream_get_SourceFile;
*sourceFile = *chilkatc::CkStream_sourceFile;
*put_SourceFile = *chilkatc::CkStream_put_SourceFile;
*get_SourceFilePart = *chilkatc::CkStream_get_SourceFilePart;
*put_SourceFilePart = *chilkatc::CkStream_put_SourceFilePart;
*get_SourceFilePartSize = *chilkatc::CkStream_get_SourceFilePartSize;
*put_SourceFilePartSize = *chilkatc::CkStream_put_SourceFilePartSize;
*get_StringBom = *chilkatc::CkStream_get_StringBom;
*put_StringBom = *chilkatc::CkStream_put_StringBom;
*get_StringCharset = *chilkatc::CkStream_get_StringCharset;
*stringCharset = *chilkatc::CkStream_stringCharset;
*put_StringCharset = *chilkatc::CkStream_put_StringCharset;
*get_VerboseLogging = *chilkatc::CkStream_get_VerboseLogging;
*put_VerboseLogging = *chilkatc::CkStream_put_VerboseLogging;
*get_Version = *chilkatc::CkStream_get_Version;
*version = *chilkatc::CkStream_version;
*get_WriteFailReason = *chilkatc::CkStream_get_WriteFailReason;
*get_WriteTimeoutMs = *chilkatc::CkStream_get_WriteTimeoutMs;
*put_WriteTimeoutMs = *chilkatc::CkStream_put_WriteTimeoutMs;
*LoadTaskCaller = *chilkatc::CkStream_LoadTaskCaller;
*ReadBd = *chilkatc::CkStream_ReadBd;
*ReadBdAsync = *chilkatc::CkStream_ReadBdAsync;
*ReadBytes = *chilkatc::CkStream_ReadBytes;
*ReadBytesAsync = *chilkatc::CkStream_ReadBytesAsync;
*ReadBytesENC = *chilkatc::CkStream_ReadBytesENC;
*readBytesENC = *chilkatc::CkStream_readBytesENC;
*ReadBytesENCAsync = *chilkatc::CkStream_ReadBytesENCAsync;
*ReadNBytes = *chilkatc::CkStream_ReadNBytes;
*ReadNBytesAsync = *chilkatc::CkStream_ReadNBytesAsync;
*ReadNBytesENC = *chilkatc::CkStream_ReadNBytesENC;
*readNBytesENC = *chilkatc::CkStream_readNBytesENC;
*ReadNBytesENCAsync = *chilkatc::CkStream_ReadNBytesENCAsync;
*ReadSb = *chilkatc::CkStream_ReadSb;
*ReadSbAsync = *chilkatc::CkStream_ReadSbAsync;
*ReadString = *chilkatc::CkStream_ReadString;
*readString = *chilkatc::CkStream_readString;
*ReadStringAsync = *chilkatc::CkStream_ReadStringAsync;
*ReadToCRLF = *chilkatc::CkStream_ReadToCRLF;
*readToCRLF = *chilkatc::CkStream_readToCRLF;
*ReadToCRLFAsync = *chilkatc::CkStream_ReadToCRLFAsync;
*ReadUntilMatch = *chilkatc::CkStream_ReadUntilMatch;
*readUntilMatch = *chilkatc::CkStream_readUntilMatch;
*ReadUntilMatchAsync = *chilkatc::CkStream_ReadUntilMatchAsync;
*Reset = *chilkatc::CkStream_Reset;
*SetSourceBytes = *chilkatc::CkStream_SetSourceBytes;
*SetSourceString = *chilkatc::CkStream_SetSourceString;
*WriteBd = *chilkatc::CkStream_WriteBd;
*WriteBdAsync = *chilkatc::CkStream_WriteBdAsync;
*WriteByte = *chilkatc::CkStream_WriteByte;
*WriteByteAsync = *chilkatc::CkStream_WriteByteAsync;
*WriteBytes = *chilkatc::CkStream_WriteBytes;
*WriteBytesAsync = *chilkatc::CkStream_WriteBytesAsync;
*WriteBytesENC = *chilkatc::CkStream_WriteBytesENC;
*WriteBytesENCAsync = *chilkatc::CkStream_WriteBytesENCAsync;
*WriteClose = *chilkatc::CkStream_WriteClose;
*WriteSb = *chilkatc::CkStream_WriteSb;
*WriteSbAsync = *chilkatc::CkStream_WriteSbAsync;
*WriteString = *chilkatc::CkStream_WriteString;
*WriteStringAsync = *chilkatc::CkStream_WriteStringAsync;
sub DISOWN {
    my $self = shift;
    my $ptr = tied(%$self);
    delete $OWNER{$ptr};
}

sub ACQUIRE {
    my $self = shift;
    my $ptr = tied(%$self);
    $OWNER{$ptr} = 1;
}


############# Class : chilkat::CkStringArray ##############

package chilkat::CkStringArray;
use vars qw(@ISA %OWNER %ITERATORS %BLESSEDMEMBERS);
@ISA = qw( chilkat );
%OWNER = ();
%ITERATORS = ();
sub new {
    my $pkg = shift;
    my $self = chilkatc::new_CkStringArray(@_);
    bless $self, $pkg if defined($self);
}

sub DESTROY {
    return unless $_[0]->isa('HASH');
    my $self = tied(%{$_[0]});
    return unless defined $self;
    delete $ITERATORS{$self};
    if (exists $OWNER{$self}) {
        chilkatc::delete_CkStringArray($self);
        delete $OWNER{$self};
    }
}

*get_Utf8 = *chilkatc::CkStringArray_get_Utf8;
*put_Utf8 = *chilkatc::CkStringArray_put_Utf8;
*LastErrorXml = *chilkatc::CkStringArray_LastErrorXml;
*LastErrorHtml = *chilkatc::CkStringArray_LastErrorHtml;
*LastErrorText = *chilkatc::CkStringArray_LastErrorText;
*get_Count = *chilkatc::CkStringArray_get_Count;
*get_Crlf = *chilkatc::CkStringArray_get_Crlf;
*put_Crlf = *chilkatc::CkStringArray_put_Crlf;
*get_DebugLogFilePath = *chilkatc::CkStringArray_get_DebugLogFilePath;
*debugLogFilePath = *chilkatc::CkStringArray_debugLogFilePath;
*put_DebugLogFilePath = *chilkatc::CkStringArray_put_DebugLogFilePath;
*get_LastErrorHtml = *chilkatc::CkStringArray_get_LastErrorHtml;
*lastErrorHtml = *chilkatc::CkStringArray_lastErrorHtml;
*get_LastErrorText = *chilkatc::CkStringArray_get_LastErrorText;
*lastErrorText = *chilkatc::CkStringArray_lastErrorText;
*get_LastErrorXml = *chilkatc::CkStringArray_get_LastErrorXml;
*lastErrorXml = *chilkatc::CkStringArray_lastErrorXml;
*get_LastMethodSuccess = *chilkatc::CkStringArray_get_LastMethodSuccess;
*put_LastMethodSuccess = *chilkatc::CkStringArray_put_LastMethodSuccess;
*get_Length = *chilkatc::CkStringArray_get_Length;
*get_Trim = *chilkatc::CkStringArray_get_Trim;
*put_Trim = *chilkatc::CkStringArray_put_Trim;
*get_Unique = *chilkatc::CkStringArray_get_Unique;
*put_Unique = *chilkatc::CkStringArray_put_Unique;
*get_VerboseLogging = *chilkatc::CkStringArray_get_VerboseLogging;
*put_VerboseLogging = *chilkatc::CkStringArray_put_VerboseLogging;
*get_Version = *chilkatc::CkStringArray_get_Version;
*version = *chilkatc::CkStringArray_version;
*Append = *chilkatc::CkStringArray_Append;
*AppendSerialized = *chilkatc::CkStringArray_AppendSerialized;
*Clear = *chilkatc::CkStringArray_Clear;
*Contains = *chilkatc::CkStringArray_Contains;
*Find = *chilkatc::CkStringArray_Find;
*FindFirstMatch = *chilkatc::CkStringArray_FindFirstMatch;
*GetString = *chilkatc::CkStringArray_GetString;
*getString = *chilkatc::CkStringArray_getString;
*string = *chilkatc::CkStringArray_string;
*GetStringLen = *chilkatc::CkStringArray_GetStringLen;
*InsertAt = *chilkatc::CkStringArray_InsertAt;
*LastString = *chilkatc::CkStringArray_LastString;
*lastString = *chilkatc::CkStringArray_lastString;
*LoadFromFile = *chilkatc::CkStringArray_LoadFromFile;
*LoadFromFile2 = *chilkatc::CkStringArray_LoadFromFile2;
*LoadFromText = *chilkatc::CkStringArray_LoadFromText;
*LoadTaskResult = *chilkatc::CkStringArray_LoadTaskResult;
*Pop = *chilkatc::CkStringArray_Pop;
*pop = *chilkatc::CkStringArray_pop;
*Prepend = *chilkatc::CkStringArray_Prepend;
*Remove = *chilkatc::CkStringArray_Remove;
*RemoveAt = *chilkatc::CkStringArray_RemoveAt;
*ReplaceAt = *chilkatc::CkStringArray_ReplaceAt;
*SaveNthToFile = *chilkatc::CkStringArray_SaveNthToFile;
*SaveToFile = *chilkatc::CkStringArray_SaveToFile;
*SaveToFile2 = *chilkatc::CkStringArray_SaveToFile2;
*SaveToText = *chilkatc::CkStringArray_SaveToText;
*saveToText = *chilkatc::CkStringArray_saveToText;
*Serialize = *chilkatc::CkStringArray_Serialize;
*serialize = *chilkatc::CkStringArray_serialize;
*Sort = *chilkatc::CkStringArray_Sort;
*SplitAndAppend = *chilkatc::CkStringArray_SplitAndAppend;
*StrAt = *chilkatc::CkStringArray_StrAt;
*strAt = *chilkatc::CkStringArray_strAt;
*Subtract = *chilkatc::CkStringArray_Subtract;
*Union = *chilkatc::CkStringArray_Union;
sub DISOWN {
    my $self = shift;
    my $ptr = tied(%$self);
    delete $OWNER{$ptr};
}

sub ACQUIRE {
    my $self = shift;
    my $ptr = tied(%$self);
    $OWNER{$ptr} = 1;
}


############# Class : chilkat::CkStringBuilder ##############

package chilkat::CkStringBuilder;
use vars qw(@ISA %OWNER %ITERATORS %BLESSEDMEMBERS);
@ISA = qw( chilkat );
%OWNER = ();
%ITERATORS = ();
sub new {
    my $pkg = shift;
    my $self = chilkatc::new_CkStringBuilder(@_);
    bless $self, $pkg if defined($self);
}

sub DESTROY {
    return unless $_[0]->isa('HASH');
    my $self = tied(%{$_[0]});
    return unless defined $self;
    delete $ITERATORS{$self};
    if (exists $OWNER{$self}) {
        chilkatc::delete_CkStringBuilder($self);
        delete $OWNER{$self};
    }
}

*get_Utf8 = *chilkatc::CkStringBuilder_get_Utf8;
*put_Utf8 = *chilkatc::CkStringBuilder_put_Utf8;
*get_DebugLogFilePath = *chilkatc::CkStringBuilder_get_DebugLogFilePath;
*debugLogFilePath = *chilkatc::CkStringBuilder_debugLogFilePath;
*put_DebugLogFilePath = *chilkatc::CkStringBuilder_put_DebugLogFilePath;
*get_HasEmojis = *chilkatc::CkStringBuilder_get_HasEmojis;
*get_IntValue = *chilkatc::CkStringBuilder_get_IntValue;
*put_IntValue = *chilkatc::CkStringBuilder_put_IntValue;
*get_IsBase64 = *chilkatc::CkStringBuilder_get_IsBase64;
*get_LastErrorHtml = *chilkatc::CkStringBuilder_get_LastErrorHtml;
*lastErrorHtml = *chilkatc::CkStringBuilder_lastErrorHtml;
*get_LastErrorText = *chilkatc::CkStringBuilder_get_LastErrorText;
*lastErrorText = *chilkatc::CkStringBuilder_lastErrorText;
*get_LastErrorXml = *chilkatc::CkStringBuilder_get_LastErrorXml;
*lastErrorXml = *chilkatc::CkStringBuilder_lastErrorXml;
*get_LastMethodSuccess = *chilkatc::CkStringBuilder_get_LastMethodSuccess;
*put_LastMethodSuccess = *chilkatc::CkStringBuilder_put_LastMethodSuccess;
*get_Length = *chilkatc::CkStringBuilder_get_Length;
*get_VerboseLogging = *chilkatc::CkStringBuilder_get_VerboseLogging;
*put_VerboseLogging = *chilkatc::CkStringBuilder_put_VerboseLogging;
*get_Version = *chilkatc::CkStringBuilder_get_Version;
*version = *chilkatc::CkStringBuilder_version;
*Append = *chilkatc::CkStringBuilder_Append;
*AppendBd = *chilkatc::CkStringBuilder_AppendBd;
*AppendEncoded = *chilkatc::CkStringBuilder_AppendEncoded;
*AppendInt = *chilkatc::CkStringBuilder_AppendInt;
*AppendInt64 = *chilkatc::CkStringBuilder_AppendInt64;
*AppendLine = *chilkatc::CkStringBuilder_AppendLine;
*AppendRandom = *chilkatc::CkStringBuilder_AppendRandom;
*AppendSb = *chilkatc::CkStringBuilder_AppendSb;
*AppendUuid = *chilkatc::CkStringBuilder_AppendUuid;
*AppendUuid7 = *chilkatc::CkStringBuilder_AppendUuid7;
*Clear = *chilkatc::CkStringBuilder_Clear;
*Contains = *chilkatc::CkStringBuilder_Contains;
*ContainsWord = *chilkatc::CkStringBuilder_ContainsWord;
*ContentsEqual = *chilkatc::CkStringBuilder_ContentsEqual;
*ContentsEqualSb = *chilkatc::CkStringBuilder_ContentsEqualSb;
*Decode = *chilkatc::CkStringBuilder_Decode;
*DecodeAndAppend = *chilkatc::CkStringBuilder_DecodeAndAppend;
*Encode = *chilkatc::CkStringBuilder_Encode;
*EndsWith = *chilkatc::CkStringBuilder_EndsWith;
*EntityDecode = *chilkatc::CkStringBuilder_EntityDecode;
*GetAfterBetween = *chilkatc::CkStringBuilder_GetAfterBetween;
*getAfterBetween = *chilkatc::CkStringBuilder_getAfterBetween;
*afterBetween = *chilkatc::CkStringBuilder_afterBetween;
*GetAfterFinal = *chilkatc::CkStringBuilder_GetAfterFinal;
*getAfterFinal = *chilkatc::CkStringBuilder_getAfterFinal;
*afterFinal = *chilkatc::CkStringBuilder_afterFinal;
*GetAsString = *chilkatc::CkStringBuilder_GetAsString;
*getAsString = *chilkatc::CkStringBuilder_getAsString;
*asString = *chilkatc::CkStringBuilder_asString;
*GetBefore = *chilkatc::CkStringBuilder_GetBefore;
*getBefore = *chilkatc::CkStringBuilder_getBefore;
*before = *chilkatc::CkStringBuilder_before;
*GetBetween = *chilkatc::CkStringBuilder_GetBetween;
*getBetween = *chilkatc::CkStringBuilder_getBetween;
*between = *chilkatc::CkStringBuilder_between;
*GetDecoded = *chilkatc::CkStringBuilder_GetDecoded;
*GetEncoded = *chilkatc::CkStringBuilder_GetEncoded;
*getEncoded = *chilkatc::CkStringBuilder_getEncoded;
*encoded = *chilkatc::CkStringBuilder_encoded;
*GetHash = *chilkatc::CkStringBuilder_GetHash;
*getHash = *chilkatc::CkStringBuilder_getHash;
*hash = *chilkatc::CkStringBuilder_hash;
*GetNth = *chilkatc::CkStringBuilder_GetNth;
*getNth = *chilkatc::CkStringBuilder_getNth;
*nth = *chilkatc::CkStringBuilder_nth;
*GetRange = *chilkatc::CkStringBuilder_GetRange;
*getRange = *chilkatc::CkStringBuilder_getRange;
*range = *chilkatc::CkStringBuilder_range;
*GetRangeSb = *chilkatc::CkStringBuilder_GetRangeSb;
*LastNLines = *chilkatc::CkStringBuilder_LastNLines;
*lastNLines = *chilkatc::CkStringBuilder_lastNLines;
*LoadFile = *chilkatc::CkStringBuilder_LoadFile;
*MarkdownToHtml = *chilkatc::CkStringBuilder_MarkdownToHtml;
*MaskQuotedStrings = *chilkatc::CkStringBuilder_MaskQuotedStrings;
*Obfuscate = *chilkatc::CkStringBuilder_Obfuscate;
*Prepend = *chilkatc::CkStringBuilder_Prepend;
*PunyDecode = *chilkatc::CkStringBuilder_PunyDecode;
*PunyEncode = *chilkatc::CkStringBuilder_PunyEncode;
*RegexMatch = *chilkatc::CkStringBuilder_RegexMatch;
*RegexReplace = *chilkatc::CkStringBuilder_RegexReplace;
*RemoveAccents = *chilkatc::CkStringBuilder_RemoveAccents;
*RemoveAfterFinal = *chilkatc::CkStringBuilder_RemoveAfterFinal;
*RemoveBefore = *chilkatc::CkStringBuilder_RemoveBefore;
*RemoveCharsAt = *chilkatc::CkStringBuilder_RemoveCharsAt;
*RemoveEmojis = *chilkatc::CkStringBuilder_RemoveEmojis;
*Replace = *chilkatc::CkStringBuilder_Replace;
*ReplaceAfterFinal = *chilkatc::CkStringBuilder_ReplaceAfterFinal;
*ReplaceAllBetween = *chilkatc::CkStringBuilder_ReplaceAllBetween;
*ReplaceBetween = *chilkatc::CkStringBuilder_ReplaceBetween;
*ReplaceFirst = *chilkatc::CkStringBuilder_ReplaceFirst;
*ReplaceI = *chilkatc::CkStringBuilder_ReplaceI;
*ReplaceNoCase = *chilkatc::CkStringBuilder_ReplaceNoCase;
*ReplaceWord = *chilkatc::CkStringBuilder_ReplaceWord;
*RestoreMaskedStrings = *chilkatc::CkStringBuilder_RestoreMaskedStrings;
*SecureClear = *chilkatc::CkStringBuilder_SecureClear;
*SetNth = *chilkatc::CkStringBuilder_SetNth;
*SetString = *chilkatc::CkStringBuilder_SetString;
*Shorten = *chilkatc::CkStringBuilder_Shorten;
*StartsWith = *chilkatc::CkStringBuilder_StartsWith;
*ToCRLF = *chilkatc::CkStringBuilder_ToCRLF;
*ToLF = *chilkatc::CkStringBuilder_ToLF;
*ToLowercase = *chilkatc::CkStringBuilder_ToLowercase;
*ToUppercase = *chilkatc::CkStringBuilder_ToUppercase;
*Trim = *chilkatc::CkStringBuilder_Trim;
*TrimInsideSpaces = *chilkatc::CkStringBuilder_TrimInsideSpaces;
*Unobfuscate = *chilkatc::CkStringBuilder_Unobfuscate;
*WriteFile = *chilkatc::CkStringBuilder_WriteFile;
*WriteFileIfModified = *chilkatc::CkStringBuilder_WriteFileIfModified;
sub DISOWN {
    my $self = shift;
    my $ptr = tied(%$self);
    delete $OWNER{$ptr};
}

sub ACQUIRE {
    my $self = shift;
    my $ptr = tied(%$self);
    $OWNER{$ptr} = 1;
}


############# Class : chilkat::CkStringTable ##############

package chilkat::CkStringTable;
use vars qw(@ISA %OWNER %ITERATORS %BLESSEDMEMBERS);
@ISA = qw( chilkat );
%OWNER = ();
%ITERATORS = ();
sub new {
    my $pkg = shift;
    my $self = chilkatc::new_CkStringTable(@_);
    bless $self, $pkg if defined($self);
}

sub DESTROY {
    return unless $_[0]->isa('HASH');
    my $self = tied(%{$_[0]});
    return unless defined $self;
    delete $ITERATORS{$self};
    if (exists $OWNER{$self}) {
        chilkatc::delete_CkStringTable($self);
        delete $OWNER{$self};
    }
}

*get_Utf8 = *chilkatc::CkStringTable_get_Utf8;
*put_Utf8 = *chilkatc::CkStringTable_put_Utf8;
*LastErrorXml = *chilkatc::CkStringTable_LastErrorXml;
*LastErrorHtml = *chilkatc::CkStringTable_LastErrorHtml;
*LastErrorText = *chilkatc::CkStringTable_LastErrorText;
*get_Count = *chilkatc::CkStringTable_get_Count;
*get_DebugLogFilePath = *chilkatc::CkStringTable_get_DebugLogFilePath;
*debugLogFilePath = *chilkatc::CkStringTable_debugLogFilePath;
*put_DebugLogFilePath = *chilkatc::CkStringTable_put_DebugLogFilePath;
*get_LastErrorHtml = *chilkatc::CkStringTable_get_LastErrorHtml;
*lastErrorHtml = *chilkatc::CkStringTable_lastErrorHtml;
*get_LastErrorText = *chilkatc::CkStringTable_get_LastErrorText;
*lastErrorText = *chilkatc::CkStringTable_lastErrorText;
*get_LastErrorXml = *chilkatc::CkStringTable_get_LastErrorXml;
*lastErrorXml = *chilkatc::CkStringTable_lastErrorXml;
*get_LastMethodSuccess = *chilkatc::CkStringTable_get_LastMethodSuccess;
*put_LastMethodSuccess = *chilkatc::CkStringTable_put_LastMethodSuccess;
*get_VerboseLogging = *chilkatc::CkStringTable_get_VerboseLogging;
*put_VerboseLogging = *chilkatc::CkStringTable_put_VerboseLogging;
*get_Version = *chilkatc::CkStringTable_get_Version;
*version = *chilkatc::CkStringTable_version;
*Append = *chilkatc::CkStringTable_Append;
*AppendFromFile = *chilkatc::CkStringTable_AppendFromFile;
*AppendFromSb = *chilkatc::CkStringTable_AppendFromSb;
*Clear = *chilkatc::CkStringTable_Clear;
*FindMatch = *chilkatc::CkStringTable_FindMatch;
*FindSubstring = *chilkatc::CkStringTable_FindSubstring;
*GetStrings = *chilkatc::CkStringTable_GetStrings;
*getStrings = *chilkatc::CkStringTable_getStrings;
*strings = *chilkatc::CkStringTable_strings;
*IntAt = *chilkatc::CkStringTable_IntAt;
*SaveToFile = *chilkatc::CkStringTable_SaveToFile;
*Sort = *chilkatc::CkStringTable_Sort;
*SplitAndAppend = *chilkatc::CkStringTable_SplitAndAppend;
*StringAt = *chilkatc::CkStringTable_StringAt;
*stringAt = *chilkatc::CkStringTable_stringAt;
*StringAtSb = *chilkatc::CkStringTable_StringAtSb;
*ToSb = *chilkatc::CkStringTable_ToSb;
*WordFollowing = *chilkatc::CkStringTable_WordFollowing;
sub DISOWN {
    my $self = shift;
    my $ptr = tied(%$self);
    delete $OWNER{$ptr};
}

sub ACQUIRE {
    my $self = shift;
    my $ptr = tied(%$self);
    $OWNER{$ptr} = 1;
}


############# Class : chilkat::CkTar ##############

package chilkat::CkTar;
use vars qw(@ISA %OWNER %ITERATORS %BLESSEDMEMBERS);
@ISA = qw( chilkat );
%OWNER = ();
%ITERATORS = ();
sub new {
    my $pkg = shift;
    my $self = chilkatc::new_CkTar(@_);
    bless $self, $pkg if defined($self);
}

sub DESTROY {
    return unless $_[0]->isa('HASH');
    my $self = tied(%{$_[0]});
    return unless defined $self;
    delete $ITERATORS{$self};
    if (exists $OWNER{$self}) {
        chilkatc::delete_CkTar($self);
        delete $OWNER{$self};
    }
}

*get_Utf8 = *chilkatc::CkTar_get_Utf8;
*put_Utf8 = *chilkatc::CkTar_put_Utf8;
*LastErrorXml = *chilkatc::CkTar_LastErrorXml;
*LastErrorHtml = *chilkatc::CkTar_LastErrorHtml;
*LastErrorText = *chilkatc::CkTar_LastErrorText;
*put_EventCallbackObject = *chilkatc::CkTar_put_EventCallbackObject;
*get_CaptureXmlListing = *chilkatc::CkTar_get_CaptureXmlListing;
*put_CaptureXmlListing = *chilkatc::CkTar_put_CaptureXmlListing;
*get_Charset = *chilkatc::CkTar_get_Charset;
*charset = *chilkatc::CkTar_charset;
*put_Charset = *chilkatc::CkTar_put_Charset;
*get_DebugLogFilePath = *chilkatc::CkTar_get_DebugLogFilePath;
*debugLogFilePath = *chilkatc::CkTar_debugLogFilePath;
*put_DebugLogFilePath = *chilkatc::CkTar_put_DebugLogFilePath;
*get_DirMode = *chilkatc::CkTar_get_DirMode;
*put_DirMode = *chilkatc::CkTar_put_DirMode;
*get_DirPrefix = *chilkatc::CkTar_get_DirPrefix;
*dirPrefix = *chilkatc::CkTar_dirPrefix;
*put_DirPrefix = *chilkatc::CkTar_put_DirPrefix;
*get_FileMode = *chilkatc::CkTar_get_FileMode;
*put_FileMode = *chilkatc::CkTar_put_FileMode;
*get_GroupId = *chilkatc::CkTar_get_GroupId;
*put_GroupId = *chilkatc::CkTar_put_GroupId;
*get_GroupName = *chilkatc::CkTar_get_GroupName;
*groupName = *chilkatc::CkTar_groupName;
*put_GroupName = *chilkatc::CkTar_put_GroupName;
*get_HeartbeatMs = *chilkatc::CkTar_get_HeartbeatMs;
*put_HeartbeatMs = *chilkatc::CkTar_put_HeartbeatMs;
*get_LastErrorHtml = *chilkatc::CkTar_get_LastErrorHtml;
*lastErrorHtml = *chilkatc::CkTar_lastErrorHtml;
*get_LastErrorText = *chilkatc::CkTar_get_LastErrorText;
*lastErrorText = *chilkatc::CkTar_lastErrorText;
*get_LastErrorXml = *chilkatc::CkTar_get_LastErrorXml;
*lastErrorXml = *chilkatc::CkTar_lastErrorXml;
*get_LastMethodSuccess = *chilkatc::CkTar_get_LastMethodSuccess;
*put_LastMethodSuccess = *chilkatc::CkTar_put_LastMethodSuccess;
*get_MatchCaseSensitive = *chilkatc::CkTar_get_MatchCaseSensitive;
*put_MatchCaseSensitive = *chilkatc::CkTar_put_MatchCaseSensitive;
*get_MustMatch = *chilkatc::CkTar_get_MustMatch;
*mustMatch = *chilkatc::CkTar_mustMatch;
*put_MustMatch = *chilkatc::CkTar_put_MustMatch;
*get_MustNotMatch = *chilkatc::CkTar_get_MustNotMatch;
*mustNotMatch = *chilkatc::CkTar_mustNotMatch;
*put_MustNotMatch = *chilkatc::CkTar_put_MustNotMatch;
*get_NoAbsolutePaths = *chilkatc::CkTar_get_NoAbsolutePaths;
*put_NoAbsolutePaths = *chilkatc::CkTar_put_NoAbsolutePaths;
*get_NumDirRoots = *chilkatc::CkTar_get_NumDirRoots;
*get_PercentDoneScale = *chilkatc::CkTar_get_PercentDoneScale;
*put_PercentDoneScale = *chilkatc::CkTar_put_PercentDoneScale;
*get_ScriptFileMode = *chilkatc::CkTar_get_ScriptFileMode;
*put_ScriptFileMode = *chilkatc::CkTar_put_ScriptFileMode;
*get_SuppressOutput = *chilkatc::CkTar_get_SuppressOutput;
*put_SuppressOutput = *chilkatc::CkTar_put_SuppressOutput;
*get_UntarCaseSensitive = *chilkatc::CkTar_get_UntarCaseSensitive;
*put_UntarCaseSensitive = *chilkatc::CkTar_put_UntarCaseSensitive;
*get_UntarDebugLog = *chilkatc::CkTar_get_UntarDebugLog;
*put_UntarDebugLog = *chilkatc::CkTar_put_UntarDebugLog;
*get_UntarDiscardPaths = *chilkatc::CkTar_get_UntarDiscardPaths;
*put_UntarDiscardPaths = *chilkatc::CkTar_put_UntarDiscardPaths;
*get_UntarFromDir = *chilkatc::CkTar_get_UntarFromDir;
*untarFromDir = *chilkatc::CkTar_untarFromDir;
*put_UntarFromDir = *chilkatc::CkTar_put_UntarFromDir;
*get_UntarMaxCount = *chilkatc::CkTar_get_UntarMaxCount;
*put_UntarMaxCount = *chilkatc::CkTar_put_UntarMaxCount;
*get_UserId = *chilkatc::CkTar_get_UserId;
*put_UserId = *chilkatc::CkTar_put_UserId;
*get_UserName = *chilkatc::CkTar_get_UserName;
*userName = *chilkatc::CkTar_userName;
*put_UserName = *chilkatc::CkTar_put_UserName;
*get_VerboseLogging = *chilkatc::CkTar_get_VerboseLogging;
*put_VerboseLogging = *chilkatc::CkTar_put_VerboseLogging;
*get_Version = *chilkatc::CkTar_get_Version;
*version = *chilkatc::CkTar_version;
*get_WriteFormat = *chilkatc::CkTar_get_WriteFormat;
*writeFormat = *chilkatc::CkTar_writeFormat;
*put_WriteFormat = *chilkatc::CkTar_put_WriteFormat;
*get_XmlListing = *chilkatc::CkTar_get_XmlListing;
*xmlListing = *chilkatc::CkTar_xmlListing;
*put_XmlListing = *chilkatc::CkTar_put_XmlListing;
*AddDirRoot = *chilkatc::CkTar_AddDirRoot;
*AddDirRoot2 = *chilkatc::CkTar_AddDirRoot2;
*AddFile = *chilkatc::CkTar_AddFile;
*AddFile2 = *chilkatc::CkTar_AddFile2;
*ClearDirRootsAndFiles = *chilkatc::CkTar_ClearDirRootsAndFiles;
*CreateDeb = *chilkatc::CkTar_CreateDeb;
*GetDirRoot = *chilkatc::CkTar_GetDirRoot;
*getDirRoot = *chilkatc::CkTar_getDirRoot;
*dirRoot = *chilkatc::CkTar_dirRoot;
*ListXml = *chilkatc::CkTar_ListXml;
*listXml = *chilkatc::CkTar_listXml;
*ListXmlAsync = *chilkatc::CkTar_ListXmlAsync;
*LoadTaskCaller = *chilkatc::CkTar_LoadTaskCaller;
*Untar = *chilkatc::CkTar_Untar;
*UntarAsync = *chilkatc::CkTar_UntarAsync;
*UntarBz2 = *chilkatc::CkTar_UntarBz2;
*UntarBz2Async = *chilkatc::CkTar_UntarBz2Async;
*UntarFirstMatchingToBd = *chilkatc::CkTar_UntarFirstMatchingToBd;
*UntarFirstMatchingToMemory = *chilkatc::CkTar_UntarFirstMatchingToMemory;
*UntarFromMemory = *chilkatc::CkTar_UntarFromMemory;
*UntarFromMemoryAsync = *chilkatc::CkTar_UntarFromMemoryAsync;
*UntarGz = *chilkatc::CkTar_UntarGz;
*UntarGzAsync = *chilkatc::CkTar_UntarGzAsync;
*UntarZ = *chilkatc::CkTar_UntarZ;
*UntarZAsync = *chilkatc::CkTar_UntarZAsync;
*VerifyTar = *chilkatc::CkTar_VerifyTar;
*VerifyTarAsync = *chilkatc::CkTar_VerifyTarAsync;
*WriteTar = *chilkatc::CkTar_WriteTar;
*WriteTarAsync = *chilkatc::CkTar_WriteTarAsync;
*WriteTarBz2 = *chilkatc::CkTar_WriteTarBz2;
*WriteTarBz2Async = *chilkatc::CkTar_WriteTarBz2Async;
*WriteTarGz = *chilkatc::CkTar_WriteTarGz;
*WriteTarGzAsync = *chilkatc::CkTar_WriteTarGzAsync;
sub DISOWN {
    my $self = shift;
    my $ptr = tied(%$self);
    delete $OWNER{$ptr};
}

sub ACQUIRE {
    my $self = shift;
    my $ptr = tied(%$self);
    $OWNER{$ptr} = 1;
}


############# Class : chilkat::CkTask ##############

package chilkat::CkTask;
use vars qw(@ISA %OWNER %ITERATORS %BLESSEDMEMBERS);
@ISA = qw( chilkat );
%OWNER = ();
%ITERATORS = ();
sub new {
    my $pkg = shift;
    my $self = chilkatc::new_CkTask(@_);
    bless $self, $pkg if defined($self);
}

sub DESTROY {
    return unless $_[0]->isa('HASH');
    my $self = tied(%{$_[0]});
    return unless defined $self;
    delete $ITERATORS{$self};
    if (exists $OWNER{$self}) {
        chilkatc::delete_CkTask($self);
        delete $OWNER{$self};
    }
}

*get_Utf8 = *chilkatc::CkTask_get_Utf8;
*put_Utf8 = *chilkatc::CkTask_put_Utf8;
*LastErrorXml = *chilkatc::CkTask_LastErrorXml;
*LastErrorHtml = *chilkatc::CkTask_LastErrorHtml;
*LastErrorText = *chilkatc::CkTask_LastErrorText;
*put_EventCallbackObject = *chilkatc::CkTask_put_EventCallbackObject;
*get_DebugLogFilePath = *chilkatc::CkTask_get_DebugLogFilePath;
*debugLogFilePath = *chilkatc::CkTask_debugLogFilePath;
*put_DebugLogFilePath = *chilkatc::CkTask_put_DebugLogFilePath;
*get_Finished = *chilkatc::CkTask_get_Finished;
*get_HeartbeatMs = *chilkatc::CkTask_get_HeartbeatMs;
*put_HeartbeatMs = *chilkatc::CkTask_put_HeartbeatMs;
*get_Inert = *chilkatc::CkTask_get_Inert;
*get_KeepProgressLog = *chilkatc::CkTask_get_KeepProgressLog;
*put_KeepProgressLog = *chilkatc::CkTask_put_KeepProgressLog;
*get_LastErrorHtml = *chilkatc::CkTask_get_LastErrorHtml;
*lastErrorHtml = *chilkatc::CkTask_lastErrorHtml;
*get_LastErrorText = *chilkatc::CkTask_get_LastErrorText;
*lastErrorText = *chilkatc::CkTask_lastErrorText;
*get_LastErrorXml = *chilkatc::CkTask_get_LastErrorXml;
*lastErrorXml = *chilkatc::CkTask_lastErrorXml;
*get_LastMethodSuccess = *chilkatc::CkTask_get_LastMethodSuccess;
*put_LastMethodSuccess = *chilkatc::CkTask_put_LastMethodSuccess;
*get_Live = *chilkatc::CkTask_get_Live;
*get_PercentDone = *chilkatc::CkTask_get_PercentDone;
*get_ProgressLogSize = *chilkatc::CkTask_get_ProgressLogSize;
*get_ResultErrorText = *chilkatc::CkTask_get_ResultErrorText;
*resultErrorText = *chilkatc::CkTask_resultErrorText;
*get_ResultType = *chilkatc::CkTask_get_ResultType;
*resultType = *chilkatc::CkTask_resultType;
*get_Status = *chilkatc::CkTask_get_Status;
*status = *chilkatc::CkTask_status;
*get_StatusInt = *chilkatc::CkTask_get_StatusInt;
*get_TaskId = *chilkatc::CkTask_get_TaskId;
*get_TaskSuccess = *chilkatc::CkTask_get_TaskSuccess;
*get_UserData = *chilkatc::CkTask_get_UserData;
*userData = *chilkatc::CkTask_userData;
*put_UserData = *chilkatc::CkTask_put_UserData;
*get_VerboseLogging = *chilkatc::CkTask_get_VerboseLogging;
*put_VerboseLogging = *chilkatc::CkTask_put_VerboseLogging;
*get_Version = *chilkatc::CkTask_get_Version;
*version = *chilkatc::CkTask_version;
*Cancel = *chilkatc::CkTask_Cancel;
*ClearProgressLog = *chilkatc::CkTask_ClearProgressLog;
*CopyResultBytes = *chilkatc::CkTask_CopyResultBytes;
*GetResultBool = *chilkatc::CkTask_GetResultBool;
*GetResultBytes = *chilkatc::CkTask_GetResultBytes;
*GetResultInt = *chilkatc::CkTask_GetResultInt;
*GetResultString = *chilkatc::CkTask_GetResultString;
*getResultString = *chilkatc::CkTask_getResultString;
*resultString = *chilkatc::CkTask_resultString;
*ProgressInfoName = *chilkatc::CkTask_ProgressInfoName;
*progressInfoName = *chilkatc::CkTask_progressInfoName;
*ProgressInfoValue = *chilkatc::CkTask_ProgressInfoValue;
*progressInfoValue = *chilkatc::CkTask_progressInfoValue;
*RemoveProgressInfo = *chilkatc::CkTask_RemoveProgressInfo;
*Run = *chilkatc::CkTask_Run;
*RunSynchronously = *chilkatc::CkTask_RunSynchronously;
*SleepMs = *chilkatc::CkTask_SleepMs;
*Wait = *chilkatc::CkTask_Wait;
sub DISOWN {
    my $self = shift;
    my $ptr = tied(%$self);
    delete $OWNER{$ptr};
}

sub ACQUIRE {
    my $self = shift;
    my $ptr = tied(%$self);
    $OWNER{$ptr} = 1;
}


############# Class : chilkat::CkTaskChain ##############

package chilkat::CkTaskChain;
use vars qw(@ISA %OWNER %ITERATORS %BLESSEDMEMBERS);
@ISA = qw( chilkat );
%OWNER = ();
%ITERATORS = ();
sub new {
    my $pkg = shift;
    my $self = chilkatc::new_CkTaskChain(@_);
    bless $self, $pkg if defined($self);
}

sub DESTROY {
    return unless $_[0]->isa('HASH');
    my $self = tied(%{$_[0]});
    return unless defined $self;
    delete $ITERATORS{$self};
    if (exists $OWNER{$self}) {
        chilkatc::delete_CkTaskChain($self);
        delete $OWNER{$self};
    }
}

*get_Utf8 = *chilkatc::CkTaskChain_get_Utf8;
*put_Utf8 = *chilkatc::CkTaskChain_put_Utf8;
*LastErrorXml = *chilkatc::CkTaskChain_LastErrorXml;
*LastErrorHtml = *chilkatc::CkTaskChain_LastErrorHtml;
*LastErrorText = *chilkatc::CkTaskChain_LastErrorText;
*put_EventCallbackObject = *chilkatc::CkTaskChain_put_EventCallbackObject;
*get_DebugLogFilePath = *chilkatc::CkTaskChain_get_DebugLogFilePath;
*debugLogFilePath = *chilkatc::CkTaskChain_debugLogFilePath;
*put_DebugLogFilePath = *chilkatc::CkTaskChain_put_DebugLogFilePath;
*get_Finished = *chilkatc::CkTaskChain_get_Finished;
*get_HeartbeatMs = *chilkatc::CkTaskChain_get_HeartbeatMs;
*put_HeartbeatMs = *chilkatc::CkTaskChain_put_HeartbeatMs;
*get_Inert = *chilkatc::CkTaskChain_get_Inert;
*get_LastErrorHtml = *chilkatc::CkTaskChain_get_LastErrorHtml;
*lastErrorHtml = *chilkatc::CkTaskChain_lastErrorHtml;
*get_LastErrorText = *chilkatc::CkTaskChain_get_LastErrorText;
*lastErrorText = *chilkatc::CkTaskChain_lastErrorText;
*get_LastErrorXml = *chilkatc::CkTaskChain_get_LastErrorXml;
*lastErrorXml = *chilkatc::CkTaskChain_lastErrorXml;
*get_LastMethodSuccess = *chilkatc::CkTaskChain_get_LastMethodSuccess;
*put_LastMethodSuccess = *chilkatc::CkTaskChain_put_LastMethodSuccess;
*get_Live = *chilkatc::CkTaskChain_get_Live;
*get_NumTasks = *chilkatc::CkTaskChain_get_NumTasks;
*get_Status = *chilkatc::CkTaskChain_get_Status;
*status = *chilkatc::CkTaskChain_status;
*get_StatusInt = *chilkatc::CkTaskChain_get_StatusInt;
*get_StopOnFailedTask = *chilkatc::CkTaskChain_get_StopOnFailedTask;
*put_StopOnFailedTask = *chilkatc::CkTaskChain_put_StopOnFailedTask;
*get_VerboseLogging = *chilkatc::CkTaskChain_get_VerboseLogging;
*put_VerboseLogging = *chilkatc::CkTaskChain_put_VerboseLogging;
*get_Version = *chilkatc::CkTaskChain_get_Version;
*version = *chilkatc::CkTaskChain_version;
*Append = *chilkatc::CkTaskChain_Append;
*Cancel = *chilkatc::CkTaskChain_Cancel;
*GetTask = *chilkatc::CkTaskChain_GetTask;
*Run = *chilkatc::CkTaskChain_Run;
*RunSynchronously = *chilkatc::CkTaskChain_RunSynchronously;
*SleepMs = *chilkatc::CkTaskChain_SleepMs;
*Wait = *chilkatc::CkTaskChain_Wait;
sub DISOWN {
    my $self = shift;
    my $ptr = tied(%$self);
    delete $OWNER{$ptr};
}

sub ACQUIRE {
    my $self = shift;
    my $ptr = tied(%$self);
    $OWNER{$ptr} = 1;
}


############# Class : chilkat::CkTrustedRoots ##############

package chilkat::CkTrustedRoots;
use vars qw(@ISA %OWNER %ITERATORS %BLESSEDMEMBERS);
@ISA = qw( chilkat );
%OWNER = ();
%ITERATORS = ();
sub new {
    my $pkg = shift;
    my $self = chilkatc::new_CkTrustedRoots(@_);
    bless $self, $pkg if defined($self);
}

sub DESTROY {
    return unless $_[0]->isa('HASH');
    my $self = tied(%{$_[0]});
    return unless defined $self;
    delete $ITERATORS{$self};
    if (exists $OWNER{$self}) {
        chilkatc::delete_CkTrustedRoots($self);
        delete $OWNER{$self};
    }
}

*get_Utf8 = *chilkatc::CkTrustedRoots_get_Utf8;
*put_Utf8 = *chilkatc::CkTrustedRoots_put_Utf8;
*LastErrorXml = *chilkatc::CkTrustedRoots_LastErrorXml;
*LastErrorHtml = *chilkatc::CkTrustedRoots_LastErrorHtml;
*LastErrorText = *chilkatc::CkTrustedRoots_LastErrorText;
*put_EventCallbackObject = *chilkatc::CkTrustedRoots_put_EventCallbackObject;
*get_DebugLogFilePath = *chilkatc::CkTrustedRoots_get_DebugLogFilePath;
*debugLogFilePath = *chilkatc::CkTrustedRoots_debugLogFilePath;
*put_DebugLogFilePath = *chilkatc::CkTrustedRoots_put_DebugLogFilePath;
*get_LastErrorHtml = *chilkatc::CkTrustedRoots_get_LastErrorHtml;
*lastErrorHtml = *chilkatc::CkTrustedRoots_lastErrorHtml;
*get_LastErrorText = *chilkatc::CkTrustedRoots_get_LastErrorText;
*lastErrorText = *chilkatc::CkTrustedRoots_lastErrorText;
*get_LastErrorXml = *chilkatc::CkTrustedRoots_get_LastErrorXml;
*lastErrorXml = *chilkatc::CkTrustedRoots_lastErrorXml;
*get_LastMethodSuccess = *chilkatc::CkTrustedRoots_get_LastMethodSuccess;
*put_LastMethodSuccess = *chilkatc::CkTrustedRoots_put_LastMethodSuccess;
*get_NumCerts = *chilkatc::CkTrustedRoots_get_NumCerts;
*get_RejectSelfSignedCerts = *chilkatc::CkTrustedRoots_get_RejectSelfSignedCerts;
*put_RejectSelfSignedCerts = *chilkatc::CkTrustedRoots_put_RejectSelfSignedCerts;
*get_TrustSystemCaRoots = *chilkatc::CkTrustedRoots_get_TrustSystemCaRoots;
*put_TrustSystemCaRoots = *chilkatc::CkTrustedRoots_put_TrustSystemCaRoots;
*get_VerboseLogging = *chilkatc::CkTrustedRoots_get_VerboseLogging;
*put_VerboseLogging = *chilkatc::CkTrustedRoots_put_VerboseLogging;
*get_Version = *chilkatc::CkTrustedRoots_get_Version;
*version = *chilkatc::CkTrustedRoots_version;
*Activate = *chilkatc::CkTrustedRoots_Activate;
*AddCert = *chilkatc::CkTrustedRoots_AddCert;
*AddJavaKeyStore = *chilkatc::CkTrustedRoots_AddJavaKeyStore;
*AddJavaKeyStoreAsync = *chilkatc::CkTrustedRoots_AddJavaKeyStoreAsync;
*CertAt = *chilkatc::CkTrustedRoots_CertAt;
*Deactivate = *chilkatc::CkTrustedRoots_Deactivate;
*GetCert = *chilkatc::CkTrustedRoots_GetCert;
*LoadCaCertsPem = *chilkatc::CkTrustedRoots_LoadCaCertsPem;
*LoadCaCertsPemAsync = *chilkatc::CkTrustedRoots_LoadCaCertsPemAsync;
*LoadTaskCaller = *chilkatc::CkTrustedRoots_LoadTaskCaller;
sub DISOWN {
    my $self = shift;
    my $ptr = tied(%$self);
    delete $OWNER{$ptr};
}

sub ACQUIRE {
    my $self = shift;
    my $ptr = tied(%$self);
    $OWNER{$ptr} = 1;
}


############# Class : chilkat::CkUnixCompress ##############

package chilkat::CkUnixCompress;
use vars qw(@ISA %OWNER %ITERATORS %BLESSEDMEMBERS);
@ISA = qw( chilkat );
%OWNER = ();
%ITERATORS = ();
sub new {
    my $pkg = shift;
    my $self = chilkatc::new_CkUnixCompress(@_);
    bless $self, $pkg if defined($self);
}

sub DESTROY {
    return unless $_[0]->isa('HASH');
    my $self = tied(%{$_[0]});
    return unless defined $self;
    delete $ITERATORS{$self};
    if (exists $OWNER{$self}) {
        chilkatc::delete_CkUnixCompress($self);
        delete $OWNER{$self};
    }
}

*get_Utf8 = *chilkatc::CkUnixCompress_get_Utf8;
*put_Utf8 = *chilkatc::CkUnixCompress_put_Utf8;
*LastErrorXml = *chilkatc::CkUnixCompress_LastErrorXml;
*LastErrorHtml = *chilkatc::CkUnixCompress_LastErrorHtml;
*LastErrorText = *chilkatc::CkUnixCompress_LastErrorText;
*put_EventCallbackObject = *chilkatc::CkUnixCompress_put_EventCallbackObject;
*get_AbortCurrent = *chilkatc::CkUnixCompress_get_AbortCurrent;
*put_AbortCurrent = *chilkatc::CkUnixCompress_put_AbortCurrent;
*get_DebugLogFilePath = *chilkatc::CkUnixCompress_get_DebugLogFilePath;
*debugLogFilePath = *chilkatc::CkUnixCompress_debugLogFilePath;
*put_DebugLogFilePath = *chilkatc::CkUnixCompress_put_DebugLogFilePath;
*get_HeartbeatMs = *chilkatc::CkUnixCompress_get_HeartbeatMs;
*put_HeartbeatMs = *chilkatc::CkUnixCompress_put_HeartbeatMs;
*get_LastErrorHtml = *chilkatc::CkUnixCompress_get_LastErrorHtml;
*lastErrorHtml = *chilkatc::CkUnixCompress_lastErrorHtml;
*get_LastErrorText = *chilkatc::CkUnixCompress_get_LastErrorText;
*lastErrorText = *chilkatc::CkUnixCompress_lastErrorText;
*get_LastErrorXml = *chilkatc::CkUnixCompress_get_LastErrorXml;
*lastErrorXml = *chilkatc::CkUnixCompress_lastErrorXml;
*get_LastMethodSuccess = *chilkatc::CkUnixCompress_get_LastMethodSuccess;
*put_LastMethodSuccess = *chilkatc::CkUnixCompress_put_LastMethodSuccess;
*get_VerboseLogging = *chilkatc::CkUnixCompress_get_VerboseLogging;
*put_VerboseLogging = *chilkatc::CkUnixCompress_put_VerboseLogging;
*get_Version = *chilkatc::CkUnixCompress_get_Version;
*version = *chilkatc::CkUnixCompress_version;
*CompressFile = *chilkatc::CkUnixCompress_CompressFile;
*CompressFileAsync = *chilkatc::CkUnixCompress_CompressFileAsync;
*CompressFileToMem = *chilkatc::CkUnixCompress_CompressFileToMem;
*CompressFileToMemAsync = *chilkatc::CkUnixCompress_CompressFileToMemAsync;
*CompressMemory = *chilkatc::CkUnixCompress_CompressMemory;
*CompressMemToFile = *chilkatc::CkUnixCompress_CompressMemToFile;
*CompressString = *chilkatc::CkUnixCompress_CompressString;
*CompressStringToFile = *chilkatc::CkUnixCompress_CompressStringToFile;
*LoadTaskCaller = *chilkatc::CkUnixCompress_LoadTaskCaller;
*UncompressFile = *chilkatc::CkUnixCompress_UncompressFile;
*UncompressFileAsync = *chilkatc::CkUnixCompress_UncompressFileAsync;
*UncompressFileToMem = *chilkatc::CkUnixCompress_UncompressFileToMem;
*UncompressFileToMemAsync = *chilkatc::CkUnixCompress_UncompressFileToMemAsync;
*UncompressFileToString = *chilkatc::CkUnixCompress_UncompressFileToString;
*uncompressFileToString = *chilkatc::CkUnixCompress_uncompressFileToString;
*UncompressFileToStringAsync = *chilkatc::CkUnixCompress_UncompressFileToStringAsync;
*UncompressMemory = *chilkatc::CkUnixCompress_UncompressMemory;
*UncompressMemToFile = *chilkatc::CkUnixCompress_UncompressMemToFile;
*UncompressString = *chilkatc::CkUnixCompress_UncompressString;
*uncompressString = *chilkatc::CkUnixCompress_uncompressString;
*UnTarZ = *chilkatc::CkUnixCompress_UnTarZ;
*UnTarZAsync = *chilkatc::CkUnixCompress_UnTarZAsync;
sub DISOWN {
    my $self = shift;
    my $ptr = tied(%$self);
    delete $OWNER{$ptr};
}

sub ACQUIRE {
    my $self = shift;
    my $ptr = tied(%$self);
    $OWNER{$ptr} = 1;
}


############# Class : chilkat::CkUpload ##############

package chilkat::CkUpload;
use vars qw(@ISA %OWNER %ITERATORS %BLESSEDMEMBERS);
@ISA = qw( chilkat );
%OWNER = ();
%ITERATORS = ();
sub new {
    my $pkg = shift;
    my $self = chilkatc::new_CkUpload(@_);
    bless $self, $pkg if defined($self);
}

sub DESTROY {
    return unless $_[0]->isa('HASH');
    my $self = tied(%{$_[0]});
    return unless defined $self;
    delete $ITERATORS{$self};
    if (exists $OWNER{$self}) {
        chilkatc::delete_CkUpload($self);
        delete $OWNER{$self};
    }
}

*get_Utf8 = *chilkatc::CkUpload_get_Utf8;
*put_Utf8 = *chilkatc::CkUpload_put_Utf8;
*LastErrorXml = *chilkatc::CkUpload_LastErrorXml;
*LastErrorHtml = *chilkatc::CkUpload_LastErrorHtml;
*LastErrorText = *chilkatc::CkUpload_LastErrorText;
*put_EventCallbackObject = *chilkatc::CkUpload_put_EventCallbackObject;
*get_AbortCurrent = *chilkatc::CkUpload_get_AbortCurrent;
*put_AbortCurrent = *chilkatc::CkUpload_put_AbortCurrent;
*get_BandwidthThrottleUp = *chilkatc::CkUpload_get_BandwidthThrottleUp;
*put_BandwidthThrottleUp = *chilkatc::CkUpload_put_BandwidthThrottleUp;
*get_ChunkSize = *chilkatc::CkUpload_get_ChunkSize;
*put_ChunkSize = *chilkatc::CkUpload_put_ChunkSize;
*get_ClientIpAddress = *chilkatc::CkUpload_get_ClientIpAddress;
*clientIpAddress = *chilkatc::CkUpload_clientIpAddress;
*put_ClientIpAddress = *chilkatc::CkUpload_put_ClientIpAddress;
*get_CurrentFilename = *chilkatc::CkUpload_get_CurrentFilename;
*currentFilename = *chilkatc::CkUpload_currentFilename;
*get_DebugLogFilePath = *chilkatc::CkUpload_get_DebugLogFilePath;
*debugLogFilePath = *chilkatc::CkUpload_debugLogFilePath;
*put_DebugLogFilePath = *chilkatc::CkUpload_put_DebugLogFilePath;
*get_Expect100Continue = *chilkatc::CkUpload_get_Expect100Continue;
*put_Expect100Continue = *chilkatc::CkUpload_put_Expect100Continue;
*get_HeartbeatMs = *chilkatc::CkUpload_get_HeartbeatMs;
*put_HeartbeatMs = *chilkatc::CkUpload_put_HeartbeatMs;
*get_Hostname = *chilkatc::CkUpload_get_Hostname;
*hostname = *chilkatc::CkUpload_hostname;
*put_Hostname = *chilkatc::CkUpload_put_Hostname;
*get_IdleTimeoutMs = *chilkatc::CkUpload_get_IdleTimeoutMs;
*put_IdleTimeoutMs = *chilkatc::CkUpload_put_IdleTimeoutMs;
*get_LastErrorHtml = *chilkatc::CkUpload_get_LastErrorHtml;
*lastErrorHtml = *chilkatc::CkUpload_lastErrorHtml;
*get_LastErrorText = *chilkatc::CkUpload_get_LastErrorText;
*lastErrorText = *chilkatc::CkUpload_lastErrorText;
*get_LastErrorXml = *chilkatc::CkUpload_get_LastErrorXml;
*lastErrorXml = *chilkatc::CkUpload_lastErrorXml;
*get_LastMethodSuccess = *chilkatc::CkUpload_get_LastMethodSuccess;
*put_LastMethodSuccess = *chilkatc::CkUpload_put_LastMethodSuccess;
*get_Login = *chilkatc::CkUpload_get_Login;
*login = *chilkatc::CkUpload_login;
*put_Login = *chilkatc::CkUpload_put_Login;
*get_NumBytesSent = *chilkatc::CkUpload_get_NumBytesSent;
*get_Password = *chilkatc::CkUpload_get_Password;
*password = *chilkatc::CkUpload_password;
*put_Password = *chilkatc::CkUpload_put_Password;
*get_Path = *chilkatc::CkUpload_get_Path;
*path = *chilkatc::CkUpload_path;
*put_Path = *chilkatc::CkUpload_put_Path;
*get_PercentDoneScale = *chilkatc::CkUpload_get_PercentDoneScale;
*put_PercentDoneScale = *chilkatc::CkUpload_put_PercentDoneScale;
*get_PercentUploaded = *chilkatc::CkUpload_get_PercentUploaded;
*get_Port = *chilkatc::CkUpload_get_Port;
*put_Port = *chilkatc::CkUpload_put_Port;
*get_PreferIpv6 = *chilkatc::CkUpload_get_PreferIpv6;
*put_PreferIpv6 = *chilkatc::CkUpload_put_PreferIpv6;
*get_ProxyDomain = *chilkatc::CkUpload_get_ProxyDomain;
*proxyDomain = *chilkatc::CkUpload_proxyDomain;
*put_ProxyDomain = *chilkatc::CkUpload_put_ProxyDomain;
*get_ProxyLogin = *chilkatc::CkUpload_get_ProxyLogin;
*proxyLogin = *chilkatc::CkUpload_proxyLogin;
*put_ProxyLogin = *chilkatc::CkUpload_put_ProxyLogin;
*get_ProxyPassword = *chilkatc::CkUpload_get_ProxyPassword;
*proxyPassword = *chilkatc::CkUpload_proxyPassword;
*put_ProxyPassword = *chilkatc::CkUpload_put_ProxyPassword;
*get_ProxyPort = *chilkatc::CkUpload_get_ProxyPort;
*put_ProxyPort = *chilkatc::CkUpload_put_ProxyPort;
*get_ResponseBodyStr = *chilkatc::CkUpload_get_ResponseBodyStr;
*responseBodyStr = *chilkatc::CkUpload_responseBodyStr;
*get_ResponseHeader = *chilkatc::CkUpload_get_ResponseHeader;
*responseHeader = *chilkatc::CkUpload_responseHeader;
*get_ResponseStatus = *chilkatc::CkUpload_get_ResponseStatus;
*get_Ssl = *chilkatc::CkUpload_get_Ssl;
*put_Ssl = *chilkatc::CkUpload_put_Ssl;
*get_SslAllowedCiphers = *chilkatc::CkUpload_get_SslAllowedCiphers;
*sslAllowedCiphers = *chilkatc::CkUpload_sslAllowedCiphers;
*put_SslAllowedCiphers = *chilkatc::CkUpload_put_SslAllowedCiphers;
*get_SslProtocol = *chilkatc::CkUpload_get_SslProtocol;
*sslProtocol = *chilkatc::CkUpload_sslProtocol;
*put_SslProtocol = *chilkatc::CkUpload_put_SslProtocol;
*get_TlsPinSet = *chilkatc::CkUpload_get_TlsPinSet;
*tlsPinSet = *chilkatc::CkUpload_tlsPinSet;
*put_TlsPinSet = *chilkatc::CkUpload_put_TlsPinSet;
*get_TotalUploadSize = *chilkatc::CkUpload_get_TotalUploadSize;
*get_UploadInProgress = *chilkatc::CkUpload_get_UploadInProgress;
*get_UploadSuccess = *chilkatc::CkUpload_get_UploadSuccess;
*get_VerboseLogging = *chilkatc::CkUpload_get_VerboseLogging;
*put_VerboseLogging = *chilkatc::CkUpload_put_VerboseLogging;
*get_Version = *chilkatc::CkUpload_get_Version;
*version = *chilkatc::CkUpload_version;
*AbortUpload = *chilkatc::CkUpload_AbortUpload;
*AddCustomHeader = *chilkatc::CkUpload_AddCustomHeader;
*AddFileReference = *chilkatc::CkUpload_AddFileReference;
*AddParam = *chilkatc::CkUpload_AddParam;
*BeginUpload = *chilkatc::CkUpload_BeginUpload;
*BlockingUpload = *chilkatc::CkUpload_BlockingUpload;
*BlockingUploadAsync = *chilkatc::CkUpload_BlockingUploadAsync;
*ClearFileReferences = *chilkatc::CkUpload_ClearFileReferences;
*ClearParams = *chilkatc::CkUpload_ClearParams;
*LoadTaskCaller = *chilkatc::CkUpload_LoadTaskCaller;
*SleepMs = *chilkatc::CkUpload_SleepMs;
*UploadToMemory = *chilkatc::CkUpload_UploadToMemory;
sub DISOWN {
    my $self = shift;
    my $ptr = tied(%$self);
    delete $OWNER{$ptr};
}

sub ACQUIRE {
    my $self = shift;
    my $ptr = tied(%$self);
    $OWNER{$ptr} = 1;
}


############# Class : chilkat::CkUrl ##############

package chilkat::CkUrl;
use vars qw(@ISA %OWNER %ITERATORS %BLESSEDMEMBERS);
@ISA = qw( chilkat );
%OWNER = ();
%ITERATORS = ();
sub new {
    my $pkg = shift;
    my $self = chilkatc::new_CkUrl(@_);
    bless $self, $pkg if defined($self);
}

sub DESTROY {
    return unless $_[0]->isa('HASH');
    my $self = tied(%{$_[0]});
    return unless defined $self;
    delete $ITERATORS{$self};
    if (exists $OWNER{$self}) {
        chilkatc::delete_CkUrl($self);
        delete $OWNER{$self};
    }
}

*get_Utf8 = *chilkatc::CkUrl_get_Utf8;
*put_Utf8 = *chilkatc::CkUrl_put_Utf8;
*get_DebugLogFilePath = *chilkatc::CkUrl_get_DebugLogFilePath;
*debugLogFilePath = *chilkatc::CkUrl_debugLogFilePath;
*put_DebugLogFilePath = *chilkatc::CkUrl_put_DebugLogFilePath;
*get_Frag = *chilkatc::CkUrl_get_Frag;
*frag = *chilkatc::CkUrl_frag;
*get_Host = *chilkatc::CkUrl_get_Host;
*host = *chilkatc::CkUrl_host;
*get_HostType = *chilkatc::CkUrl_get_HostType;
*hostType = *chilkatc::CkUrl_hostType;
*get_LastErrorHtml = *chilkatc::CkUrl_get_LastErrorHtml;
*lastErrorHtml = *chilkatc::CkUrl_lastErrorHtml;
*get_LastErrorText = *chilkatc::CkUrl_get_LastErrorText;
*lastErrorText = *chilkatc::CkUrl_lastErrorText;
*get_LastErrorXml = *chilkatc::CkUrl_get_LastErrorXml;
*lastErrorXml = *chilkatc::CkUrl_lastErrorXml;
*get_LastMethodSuccess = *chilkatc::CkUrl_get_LastMethodSuccess;
*put_LastMethodSuccess = *chilkatc::CkUrl_put_LastMethodSuccess;
*get_Login = *chilkatc::CkUrl_get_Login;
*login = *chilkatc::CkUrl_login;
*get_Password = *chilkatc::CkUrl_get_Password;
*password = *chilkatc::CkUrl_password;
*get_Path = *chilkatc::CkUrl_get_Path;
*path = *chilkatc::CkUrl_path;
*get_PathWithQueryParams = *chilkatc::CkUrl_get_PathWithQueryParams;
*pathWithQueryParams = *chilkatc::CkUrl_pathWithQueryParams;
*get_Port = *chilkatc::CkUrl_get_Port;
*get_Query = *chilkatc::CkUrl_get_Query;
*query = *chilkatc::CkUrl_query;
*get_Ssl = *chilkatc::CkUrl_get_Ssl;
*get_VerboseLogging = *chilkatc::CkUrl_get_VerboseLogging;
*put_VerboseLogging = *chilkatc::CkUrl_put_VerboseLogging;
*get_Version = *chilkatc::CkUrl_get_Version;
*version = *chilkatc::CkUrl_version;
*ParseUrl = *chilkatc::CkUrl_ParseUrl;
sub DISOWN {
    my $self = shift;
    my $ptr = tied(%$self);
    delete $OWNER{$ptr};
}

sub ACQUIRE {
    my $self = shift;
    my $ptr = tied(%$self);
    $OWNER{$ptr} = 1;
}


############# Class : chilkat::CkWebSocket ##############

package chilkat::CkWebSocket;
use vars qw(@ISA %OWNER %ITERATORS %BLESSEDMEMBERS);
@ISA = qw( chilkat );
%OWNER = ();
%ITERATORS = ();
sub new {
    my $pkg = shift;
    my $self = chilkatc::new_CkWebSocket(@_);
    bless $self, $pkg if defined($self);
}

sub DESTROY {
    return unless $_[0]->isa('HASH');
    my $self = tied(%{$_[0]});
    return unless defined $self;
    delete $ITERATORS{$self};
    if (exists $OWNER{$self}) {
        chilkatc::delete_CkWebSocket($self);
        delete $OWNER{$self};
    }
}

*get_Utf8 = *chilkatc::CkWebSocket_get_Utf8;
*put_Utf8 = *chilkatc::CkWebSocket_put_Utf8;
*LastErrorXml = *chilkatc::CkWebSocket_LastErrorXml;
*LastErrorHtml = *chilkatc::CkWebSocket_LastErrorHtml;
*LastErrorText = *chilkatc::CkWebSocket_LastErrorText;
*put_EventCallbackObject = *chilkatc::CkWebSocket_put_EventCallbackObject;
*get_CloseAutoRespond = *chilkatc::CkWebSocket_get_CloseAutoRespond;
*put_CloseAutoRespond = *chilkatc::CkWebSocket_put_CloseAutoRespond;
*get_CloseReason = *chilkatc::CkWebSocket_get_CloseReason;
*closeReason = *chilkatc::CkWebSocket_closeReason;
*get_CloseReceived = *chilkatc::CkWebSocket_get_CloseReceived;
*get_CloseStatusCode = *chilkatc::CkWebSocket_get_CloseStatusCode;
*get_DebugLogFilePath = *chilkatc::CkWebSocket_get_DebugLogFilePath;
*debugLogFilePath = *chilkatc::CkWebSocket_debugLogFilePath;
*put_DebugLogFilePath = *chilkatc::CkWebSocket_put_DebugLogFilePath;
*get_FinalFrame = *chilkatc::CkWebSocket_get_FinalFrame;
*get_FrameDataLen = *chilkatc::CkWebSocket_get_FrameDataLen;
*get_FrameOpcode = *chilkatc::CkWebSocket_get_FrameOpcode;
*frameOpcode = *chilkatc::CkWebSocket_frameOpcode;
*get_FrameOpcodeInt = *chilkatc::CkWebSocket_get_FrameOpcodeInt;
*get_HeartbeatMs = *chilkatc::CkWebSocket_get_HeartbeatMs;
*put_HeartbeatMs = *chilkatc::CkWebSocket_put_HeartbeatMs;
*get_IdleTimeoutMs = *chilkatc::CkWebSocket_get_IdleTimeoutMs;
*put_IdleTimeoutMs = *chilkatc::CkWebSocket_put_IdleTimeoutMs;
*get_IsConnected = *chilkatc::CkWebSocket_get_IsConnected;
*get_LastErrorHtml = *chilkatc::CkWebSocket_get_LastErrorHtml;
*lastErrorHtml = *chilkatc::CkWebSocket_lastErrorHtml;
*get_LastErrorText = *chilkatc::CkWebSocket_get_LastErrorText;
*lastErrorText = *chilkatc::CkWebSocket_lastErrorText;
*get_LastErrorXml = *chilkatc::CkWebSocket_get_LastErrorXml;
*lastErrorXml = *chilkatc::CkWebSocket_lastErrorXml;
*get_LastMethodSuccess = *chilkatc::CkWebSocket_get_LastMethodSuccess;
*put_LastMethodSuccess = *chilkatc::CkWebSocket_put_LastMethodSuccess;
*get_NeedSendPong = *chilkatc::CkWebSocket_get_NeedSendPong;
*get_PingAutoRespond = *chilkatc::CkWebSocket_get_PingAutoRespond;
*put_PingAutoRespond = *chilkatc::CkWebSocket_put_PingAutoRespond;
*get_PongAutoConsume = *chilkatc::CkWebSocket_get_PongAutoConsume;
*put_PongAutoConsume = *chilkatc::CkWebSocket_put_PongAutoConsume;
*get_PongConsumed = *chilkatc::CkWebSocket_get_PongConsumed;
*get_ReadFrameFailReason = *chilkatc::CkWebSocket_get_ReadFrameFailReason;
*get_UncommonOptions = *chilkatc::CkWebSocket_get_UncommonOptions;
*uncommonOptions = *chilkatc::CkWebSocket_uncommonOptions;
*get_VerboseLogging = *chilkatc::CkWebSocket_get_VerboseLogging;
*put_VerboseLogging = *chilkatc::CkWebSocket_put_VerboseLogging;
*get_Version = *chilkatc::CkWebSocket_get_Version;
*version = *chilkatc::CkWebSocket_version;
*AddClientHeaders = *chilkatc::CkWebSocket_AddClientHeaders;
*CloseConnection = *chilkatc::CkWebSocket_CloseConnection;
*GetFrameData = *chilkatc::CkWebSocket_GetFrameData;
*getFrameData = *chilkatc::CkWebSocket_getFrameData;
*frameData = *chilkatc::CkWebSocket_frameData;
*GetFrameDataBd = *chilkatc::CkWebSocket_GetFrameDataBd;
*GetFrameDataSb = *chilkatc::CkWebSocket_GetFrameDataSb;
*LoadTaskCaller = *chilkatc::CkWebSocket_LoadTaskCaller;
*PollDataAvailable = *chilkatc::CkWebSocket_PollDataAvailable;
*ReadFrame = *chilkatc::CkWebSocket_ReadFrame;
*ReadFrameAsync = *chilkatc::CkWebSocket_ReadFrameAsync;
*SendClose = *chilkatc::CkWebSocket_SendClose;
*SendCloseAsync = *chilkatc::CkWebSocket_SendCloseAsync;
*SendFrame = *chilkatc::CkWebSocket_SendFrame;
*SendFrameAsync = *chilkatc::CkWebSocket_SendFrameAsync;
*SendFrameBd = *chilkatc::CkWebSocket_SendFrameBd;
*SendFrameBdAsync = *chilkatc::CkWebSocket_SendFrameBdAsync;
*SendFrameSb = *chilkatc::CkWebSocket_SendFrameSb;
*SendFrameSbAsync = *chilkatc::CkWebSocket_SendFrameSbAsync;
*SendPing = *chilkatc::CkWebSocket_SendPing;
*SendPingAsync = *chilkatc::CkWebSocket_SendPingAsync;
*SendPong = *chilkatc::CkWebSocket_SendPong;
*SendPongAsync = *chilkatc::CkWebSocket_SendPongAsync;
*ShareConnection = *chilkatc::CkWebSocket_ShareConnection;
*UseConnection = *chilkatc::CkWebSocket_UseConnection;
*ValidateServerHandshake = *chilkatc::CkWebSocket_ValidateServerHandshake;
sub DISOWN {
    my $self = shift;
    my $ptr = tied(%$self);
    delete $OWNER{$ptr};
}

sub ACQUIRE {
    my $self = shift;
    my $ptr = tied(%$self);
    $OWNER{$ptr} = 1;
}


############# Class : chilkat::CkXml ##############

package chilkat::CkXml;
use vars qw(@ISA %OWNER %ITERATORS %BLESSEDMEMBERS);
@ISA = qw( chilkat );
%OWNER = ();
%ITERATORS = ();
sub new {
    my $pkg = shift;
    my $self = chilkatc::new_CkXml(@_);
    bless $self, $pkg if defined($self);
}

sub DESTROY {
    return unless $_[0]->isa('HASH');
    my $self = tied(%{$_[0]});
    return unless defined $self;
    delete $ITERATORS{$self};
    if (exists $OWNER{$self}) {
        chilkatc::delete_CkXml($self);
        delete $OWNER{$self};
    }
}

*get_Utf8 = *chilkatc::CkXml_get_Utf8;
*put_Utf8 = *chilkatc::CkXml_put_Utf8;
*LastErrorXml = *chilkatc::CkXml_LastErrorXml;
*LastErrorHtml = *chilkatc::CkXml_LastErrorHtml;
*LastErrorText = *chilkatc::CkXml_LastErrorText;
*get_Cdata = *chilkatc::CkXml_get_Cdata;
*put_Cdata = *chilkatc::CkXml_put_Cdata;
*get_Content = *chilkatc::CkXml_get_Content;
*content = *chilkatc::CkXml_content;
*put_Content = *chilkatc::CkXml_put_Content;
*get_ContentInt = *chilkatc::CkXml_get_ContentInt;
*put_ContentInt = *chilkatc::CkXml_put_ContentInt;
*get_DebugLogFilePath = *chilkatc::CkXml_get_DebugLogFilePath;
*debugLogFilePath = *chilkatc::CkXml_debugLogFilePath;
*put_DebugLogFilePath = *chilkatc::CkXml_put_DebugLogFilePath;
*get_DocType = *chilkatc::CkXml_get_DocType;
*docType = *chilkatc::CkXml_docType;
*put_DocType = *chilkatc::CkXml_put_DocType;
*get_EmitBom = *chilkatc::CkXml_get_EmitBom;
*put_EmitBom = *chilkatc::CkXml_put_EmitBom;
*get_EmitCompact = *chilkatc::CkXml_get_EmitCompact;
*put_EmitCompact = *chilkatc::CkXml_put_EmitCompact;
*get_EmitXmlDecl = *chilkatc::CkXml_get_EmitXmlDecl;
*put_EmitXmlDecl = *chilkatc::CkXml_put_EmitXmlDecl;
*get_Encoding = *chilkatc::CkXml_get_Encoding;
*encoding = *chilkatc::CkXml_encoding;
*put_Encoding = *chilkatc::CkXml_put_Encoding;
*get_I = *chilkatc::CkXml_get_I;
*put_I = *chilkatc::CkXml_put_I;
*get_IsBase64 = *chilkatc::CkXml_get_IsBase64;
*get_J = *chilkatc::CkXml_get_J;
*put_J = *chilkatc::CkXml_put_J;
*get_K = *chilkatc::CkXml_get_K;
*put_K = *chilkatc::CkXml_put_K;
*get_LastErrorHtml = *chilkatc::CkXml_get_LastErrorHtml;
*lastErrorHtml = *chilkatc::CkXml_lastErrorHtml;
*get_LastErrorText = *chilkatc::CkXml_get_LastErrorText;
*lastErrorText = *chilkatc::CkXml_lastErrorText;
*get_LastErrorXml = *chilkatc::CkXml_get_LastErrorXml;
*lastErrorXml = *chilkatc::CkXml_lastErrorXml;
*get_LastMethodSuccess = *chilkatc::CkXml_get_LastMethodSuccess;
*put_LastMethodSuccess = *chilkatc::CkXml_put_LastMethodSuccess;
*get_NumAttributes = *chilkatc::CkXml_get_NumAttributes;
*get_NumChildren = *chilkatc::CkXml_get_NumChildren;
*get_SortCaseInsensitive = *chilkatc::CkXml_get_SortCaseInsensitive;
*put_SortCaseInsensitive = *chilkatc::CkXml_put_SortCaseInsensitive;
*get_Standalone = *chilkatc::CkXml_get_Standalone;
*put_Standalone = *chilkatc::CkXml_put_Standalone;
*get_Tag = *chilkatc::CkXml_get_Tag;
*tag = *chilkatc::CkXml_tag;
*put_Tag = *chilkatc::CkXml_put_Tag;
*get_TagNsPrefix = *chilkatc::CkXml_get_TagNsPrefix;
*tagNsPrefix = *chilkatc::CkXml_tagNsPrefix;
*put_TagNsPrefix = *chilkatc::CkXml_put_TagNsPrefix;
*get_TagPath = *chilkatc::CkXml_get_TagPath;
*tagPath = *chilkatc::CkXml_tagPath;
*get_TagUnprefixed = *chilkatc::CkXml_get_TagUnprefixed;
*tagUnprefixed = *chilkatc::CkXml_tagUnprefixed;
*put_TagUnprefixed = *chilkatc::CkXml_put_TagUnprefixed;
*get_TreeId = *chilkatc::CkXml_get_TreeId;
*get_UncommonOptions = *chilkatc::CkXml_get_UncommonOptions;
*uncommonOptions = *chilkatc::CkXml_uncommonOptions;
*put_UncommonOptions = *chilkatc::CkXml_put_UncommonOptions;
*get_VerboseLogging = *chilkatc::CkXml_get_VerboseLogging;
*put_VerboseLogging = *chilkatc::CkXml_put_VerboseLogging;
*get_Version = *chilkatc::CkXml_get_Version;
*version = *chilkatc::CkXml_version;
*AccumulateTagContent = *chilkatc::CkXml_AccumulateTagContent;
*accumulateTagContent = *chilkatc::CkXml_accumulateTagContent;
*AddAttribute = *chilkatc::CkXml_AddAttribute;
*AddAttributeInt = *chilkatc::CkXml_AddAttributeInt;
*AddChildTree = *chilkatc::CkXml_AddChildTree;
*AddOrUpdateAttribute = *chilkatc::CkXml_AddOrUpdateAttribute;
*AddOrUpdateAttributeI = *chilkatc::CkXml_AddOrUpdateAttributeI;
*AddStyleSheet = *chilkatc::CkXml_AddStyleSheet;
*AddToAttribute = *chilkatc::CkXml_AddToAttribute;
*AddToChildContent = *chilkatc::CkXml_AddToChildContent;
*AddToContent = *chilkatc::CkXml_AddToContent;
*AppendToContent = *chilkatc::CkXml_AppendToContent;
*BEncodeContent = *chilkatc::CkXml_BEncodeContent;
*ChildContentMatches = *chilkatc::CkXml_ChildContentMatches;
*ChilkatPath = *chilkatc::CkXml_ChilkatPath;
*chilkatPath = *chilkatc::CkXml_chilkatPath;
*Clear = *chilkatc::CkXml_Clear;
*ContentMatches = *chilkatc::CkXml_ContentMatches;
*Copy = *chilkatc::CkXml_Copy;
*CopyRef = *chilkatc::CkXml_CopyRef;
*DecodeContent = *chilkatc::CkXml_DecodeContent;
*DecodeEntities = *chilkatc::CkXml_DecodeEntities;
*decodeEntities = *chilkatc::CkXml_decodeEntities;
*DecryptContent = *chilkatc::CkXml_DecryptContent;
*EncryptContent = *chilkatc::CkXml_EncryptContent;
*ExtractChildByIndex = *chilkatc::CkXml_ExtractChildByIndex;
*ExtractChildByName = *chilkatc::CkXml_ExtractChildByName;
*FindChild = *chilkatc::CkXml_FindChild;
*FindChild2 = *chilkatc::CkXml_FindChild2;
*FindNextRecord = *chilkatc::CkXml_FindNextRecord;
*FindOrAddNewChild = *chilkatc::CkXml_FindOrAddNewChild;
*FirstChild = *chilkatc::CkXml_FirstChild;
*FirstChild2 = *chilkatc::CkXml_FirstChild2;
*GetAttributeName = *chilkatc::CkXml_GetAttributeName;
*getAttributeName = *chilkatc::CkXml_getAttributeName;
*attributeName = *chilkatc::CkXml_attributeName;
*GetAttributeValue = *chilkatc::CkXml_GetAttributeValue;
*getAttributeValue = *chilkatc::CkXml_getAttributeValue;
*attributeValue = *chilkatc::CkXml_attributeValue;
*GetAttributeValueInt = *chilkatc::CkXml_GetAttributeValueInt;
*GetAttrValue = *chilkatc::CkXml_GetAttrValue;
*getAttrValue = *chilkatc::CkXml_getAttrValue;
*attrValue = *chilkatc::CkXml_attrValue;
*GetAttrValueInt = *chilkatc::CkXml_GetAttrValueInt;
*GetBinaryContent = *chilkatc::CkXml_GetBinaryContent;
*GetChild = *chilkatc::CkXml_GetChild;
*GetChild2 = *chilkatc::CkXml_GetChild2;
*GetChildAttrValue = *chilkatc::CkXml_GetChildAttrValue;
*getChildAttrValue = *chilkatc::CkXml_getChildAttrValue;
*childAttrValue = *chilkatc::CkXml_childAttrValue;
*GetChildBoolValue = *chilkatc::CkXml_GetChildBoolValue;
*GetChildContent = *chilkatc::CkXml_GetChildContent;
*getChildContent = *chilkatc::CkXml_getChildContent;
*childContent = *chilkatc::CkXml_childContent;
*GetChildContentByIndex = *chilkatc::CkXml_GetChildContentByIndex;
*getChildContentByIndex = *chilkatc::CkXml_getChildContentByIndex;
*childContentByIndex = *chilkatc::CkXml_childContentByIndex;
*GetChildContentSb = *chilkatc::CkXml_GetChildContentSb;
*GetChildExact = *chilkatc::CkXml_GetChildExact;
*GetChildIntValue = *chilkatc::CkXml_GetChildIntValue;
*GetChildTag = *chilkatc::CkXml_GetChildTag;
*getChildTag = *chilkatc::CkXml_getChildTag;
*childTag = *chilkatc::CkXml_childTag;
*GetChildTagByIndex = *chilkatc::CkXml_GetChildTagByIndex;
*getChildTagByIndex = *chilkatc::CkXml_getChildTagByIndex;
*childTagByIndex = *chilkatc::CkXml_childTagByIndex;
*GetChildWithAttr = *chilkatc::CkXml_GetChildWithAttr;
*GetChildWithContent = *chilkatc::CkXml_GetChildWithContent;
*GetChildWithTag = *chilkatc::CkXml_GetChildWithTag;
*GetChildWithTag2 = *chilkatc::CkXml_GetChildWithTag2;
*GetNthChildWithTag = *chilkatc::CkXml_GetNthChildWithTag;
*GetNthChildWithTag2 = *chilkatc::CkXml_GetNthChildWithTag2;
*GetParent = *chilkatc::CkXml_GetParent;
*GetParent2 = *chilkatc::CkXml_GetParent2;
*GetRoot = *chilkatc::CkXml_GetRoot;
*GetRoot2 = *chilkatc::CkXml_GetRoot2;
*GetSelf = *chilkatc::CkXml_GetSelf;
*GetXml = *chilkatc::CkXml_GetXml;
*getXml = *chilkatc::CkXml_getXml;
*xml = *chilkatc::CkXml_xml;
*GetXmlBd = *chilkatc::CkXml_GetXmlBd;
*GetXmlSb = *chilkatc::CkXml_GetXmlSb;
*HasAttribute = *chilkatc::CkXml_HasAttribute;
*HasAttrWithValue = *chilkatc::CkXml_HasAttrWithValue;
*HasChildWithContent = *chilkatc::CkXml_HasChildWithContent;
*HasChildWithTag = *chilkatc::CkXml_HasChildWithTag;
*HasChildWithTagAndContent = *chilkatc::CkXml_HasChildWithTagAndContent;
*InsertChildTreeAfter = *chilkatc::CkXml_InsertChildTreeAfter;
*InsertChildTreeBefore = *chilkatc::CkXml_InsertChildTreeBefore;
*LastChild = *chilkatc::CkXml_LastChild;
*LastChild2 = *chilkatc::CkXml_LastChild2;
*LoadBd = *chilkatc::CkXml_LoadBd;
*LoadSb = *chilkatc::CkXml_LoadSb;
*LoadXml = *chilkatc::CkXml_LoadXml;
*LoadXml2 = *chilkatc::CkXml_LoadXml2;
*LoadXmlFile = *chilkatc::CkXml_LoadXmlFile;
*LoadXmlFile2 = *chilkatc::CkXml_LoadXmlFile2;
*NewChild = *chilkatc::CkXml_NewChild;
*NewChild2 = *chilkatc::CkXml_NewChild2;
*NewChildAfter = *chilkatc::CkXml_NewChildAfter;
*NewChildBefore = *chilkatc::CkXml_NewChildBefore;
*NewChildInt2 = *chilkatc::CkXml_NewChildInt2;
*NextInTraversal2 = *chilkatc::CkXml_NextInTraversal2;
*NextSibling = *chilkatc::CkXml_NextSibling;
*NextSibling2 = *chilkatc::CkXml_NextSibling2;
*NumChildrenAt = *chilkatc::CkXml_NumChildrenAt;
*NumChildrenHavingTag = *chilkatc::CkXml_NumChildrenHavingTag;
*PreviousSibling = *chilkatc::CkXml_PreviousSibling;
*PreviousSibling2 = *chilkatc::CkXml_PreviousSibling2;
*PruneAttribute = *chilkatc::CkXml_PruneAttribute;
*PruneTag = *chilkatc::CkXml_PruneTag;
*QEncodeContent = *chilkatc::CkXml_QEncodeContent;
*RemoveAllAttributes = *chilkatc::CkXml_RemoveAllAttributes;
*RemoveAllChildren = *chilkatc::CkXml_RemoveAllChildren;
*RemoveAttribute = *chilkatc::CkXml_RemoveAttribute;
*RemoveChild = *chilkatc::CkXml_RemoveChild;
*RemoveChildByIndex = *chilkatc::CkXml_RemoveChildByIndex;
*RemoveChildWithContent = *chilkatc::CkXml_RemoveChildWithContent;
*RemoveFromTree = *chilkatc::CkXml_RemoveFromTree;
*RemoveStyleSheet = *chilkatc::CkXml_RemoveStyleSheet;
*SaveBinaryContent = *chilkatc::CkXml_SaveBinaryContent;
*SaveXml = *chilkatc::CkXml_SaveXml;
*Scrub = *chilkatc::CkXml_Scrub;
*SearchAllForContent = *chilkatc::CkXml_SearchAllForContent;
*SearchAllForContent2 = *chilkatc::CkXml_SearchAllForContent2;
*SearchForAttribute = *chilkatc::CkXml_SearchForAttribute;
*SearchForAttribute2 = *chilkatc::CkXml_SearchForAttribute2;
*SearchForContent = *chilkatc::CkXml_SearchForContent;
*SearchForContent2 = *chilkatc::CkXml_SearchForContent2;
*SearchForTag = *chilkatc::CkXml_SearchForTag;
*SearchForTag2 = *chilkatc::CkXml_SearchForTag2;
*SetBinaryContent = *chilkatc::CkXml_SetBinaryContent;
*SetBinaryContentBd = *chilkatc::CkXml_SetBinaryContentBd;
*SetBinaryContentFromFile = *chilkatc::CkXml_SetBinaryContentFromFile;
*SortByAttribute = *chilkatc::CkXml_SortByAttribute;
*SortByAttributeInt = *chilkatc::CkXml_SortByAttributeInt;
*SortByContent = *chilkatc::CkXml_SortByContent;
*SortByTag = *chilkatc::CkXml_SortByTag;
*SortRecordsByAttribute = *chilkatc::CkXml_SortRecordsByAttribute;
*SortRecordsByContent = *chilkatc::CkXml_SortRecordsByContent;
*SortRecordsByContentInt = *chilkatc::CkXml_SortRecordsByContentInt;
*SwapNode = *chilkatc::CkXml_SwapNode;
*SwapTree = *chilkatc::CkXml_SwapTree;
*TagContent = *chilkatc::CkXml_TagContent;
*tagContent = *chilkatc::CkXml_tagContent;
*TagEquals = *chilkatc::CkXml_TagEquals;
*TagIndex = *chilkatc::CkXml_TagIndex;
*TagNsEquals = *chilkatc::CkXml_TagNsEquals;
*TagUnpEquals = *chilkatc::CkXml_TagUnpEquals;
*UnzipContent = *chilkatc::CkXml_UnzipContent;
*UnzipTree = *chilkatc::CkXml_UnzipTree;
*UpdateAt = *chilkatc::CkXml_UpdateAt;
*UpdateAttrAt = *chilkatc::CkXml_UpdateAttrAt;
*UpdateAttribute = *chilkatc::CkXml_UpdateAttribute;
*UpdateAttributeInt = *chilkatc::CkXml_UpdateAttributeInt;
*UpdateChildContent = *chilkatc::CkXml_UpdateChildContent;
*UpdateChildContentInt = *chilkatc::CkXml_UpdateChildContentInt;
*ZipContent = *chilkatc::CkXml_ZipContent;
*ZipTree = *chilkatc::CkXml_ZipTree;
sub DISOWN {
    my $self = shift;
    my $ptr = tied(%$self);
    delete $OWNER{$ptr};
}

sub ACQUIRE {
    my $self = shift;
    my $ptr = tied(%$self);
    $OWNER{$ptr} = 1;
}


############# Class : chilkat::CkXmlCertVault ##############

package chilkat::CkXmlCertVault;
use vars qw(@ISA %OWNER %ITERATORS %BLESSEDMEMBERS);
@ISA = qw( chilkat );
%OWNER = ();
%ITERATORS = ();
sub new {
    my $pkg = shift;
    my $self = chilkatc::new_CkXmlCertVault(@_);
    bless $self, $pkg if defined($self);
}

sub DESTROY {
    return unless $_[0]->isa('HASH');
    my $self = tied(%{$_[0]});
    return unless defined $self;
    delete $ITERATORS{$self};
    if (exists $OWNER{$self}) {
        chilkatc::delete_CkXmlCertVault($self);
        delete $OWNER{$self};
    }
}

*get_Utf8 = *chilkatc::CkXmlCertVault_get_Utf8;
*put_Utf8 = *chilkatc::CkXmlCertVault_put_Utf8;
*LastErrorXml = *chilkatc::CkXmlCertVault_LastErrorXml;
*LastErrorHtml = *chilkatc::CkXmlCertVault_LastErrorHtml;
*LastErrorText = *chilkatc::CkXmlCertVault_LastErrorText;
*get_DebugLogFilePath = *chilkatc::CkXmlCertVault_get_DebugLogFilePath;
*debugLogFilePath = *chilkatc::CkXmlCertVault_debugLogFilePath;
*put_DebugLogFilePath = *chilkatc::CkXmlCertVault_put_DebugLogFilePath;
*get_LastErrorHtml = *chilkatc::CkXmlCertVault_get_LastErrorHtml;
*lastErrorHtml = *chilkatc::CkXmlCertVault_lastErrorHtml;
*get_LastErrorText = *chilkatc::CkXmlCertVault_get_LastErrorText;
*lastErrorText = *chilkatc::CkXmlCertVault_lastErrorText;
*get_LastErrorXml = *chilkatc::CkXmlCertVault_get_LastErrorXml;
*lastErrorXml = *chilkatc::CkXmlCertVault_lastErrorXml;
*get_LastMethodSuccess = *chilkatc::CkXmlCertVault_get_LastMethodSuccess;
*put_LastMethodSuccess = *chilkatc::CkXmlCertVault_put_LastMethodSuccess;
*get_MasterPassword = *chilkatc::CkXmlCertVault_get_MasterPassword;
*masterPassword = *chilkatc::CkXmlCertVault_masterPassword;
*put_MasterPassword = *chilkatc::CkXmlCertVault_put_MasterPassword;
*get_VerboseLogging = *chilkatc::CkXmlCertVault_get_VerboseLogging;
*put_VerboseLogging = *chilkatc::CkXmlCertVault_put_VerboseLogging;
*get_Version = *chilkatc::CkXmlCertVault_get_Version;
*version = *chilkatc::CkXmlCertVault_version;
*AddCert = *chilkatc::CkXmlCertVault_AddCert;
*AddCertBinary = *chilkatc::CkXmlCertVault_AddCertBinary;
*AddCertChain = *chilkatc::CkXmlCertVault_AddCertChain;
*AddCertEncoded = *chilkatc::CkXmlCertVault_AddCertEncoded;
*AddCertFile = *chilkatc::CkXmlCertVault_AddCertFile;
*AddCertString = *chilkatc::CkXmlCertVault_AddCertString;
*AddPemFile = *chilkatc::CkXmlCertVault_AddPemFile;
*AddPfx = *chilkatc::CkXmlCertVault_AddPfx;
*AddPfxBinary = *chilkatc::CkXmlCertVault_AddPfxBinary;
*AddPfxEncoded = *chilkatc::CkXmlCertVault_AddPfxEncoded;
*AddPfxFile = *chilkatc::CkXmlCertVault_AddPfxFile;
*GetXml = *chilkatc::CkXmlCertVault_GetXml;
*getXml = *chilkatc::CkXmlCertVault_getXml;
*xml = *chilkatc::CkXmlCertVault_xml;
*LoadXml = *chilkatc::CkXmlCertVault_LoadXml;
*LoadXmlFile = *chilkatc::CkXmlCertVault_LoadXmlFile;
*SaveXml = *chilkatc::CkXmlCertVault_SaveXml;
sub DISOWN {
    my $self = shift;
    my $ptr = tied(%$self);
    delete $OWNER{$ptr};
}

sub ACQUIRE {
    my $self = shift;
    my $ptr = tied(%$self);
    $OWNER{$ptr} = 1;
}


############# Class : chilkat::CkXmlDSig ##############

package chilkat::CkXmlDSig;
use vars qw(@ISA %OWNER %ITERATORS %BLESSEDMEMBERS);
@ISA = qw( chilkat );
%OWNER = ();
%ITERATORS = ();
sub new {
    my $pkg = shift;
    my $self = chilkatc::new_CkXmlDSig(@_);
    bless $self, $pkg if defined($self);
}

sub DESTROY {
    return unless $_[0]->isa('HASH');
    my $self = tied(%{$_[0]});
    return unless defined $self;
    delete $ITERATORS{$self};
    if (exists $OWNER{$self}) {
        chilkatc::delete_CkXmlDSig($self);
        delete $OWNER{$self};
    }
}

*get_Utf8 = *chilkatc::CkXmlDSig_get_Utf8;
*put_Utf8 = *chilkatc::CkXmlDSig_put_Utf8;
*LastErrorXml = *chilkatc::CkXmlDSig_LastErrorXml;
*LastErrorHtml = *chilkatc::CkXmlDSig_LastErrorHtml;
*LastErrorText = *chilkatc::CkXmlDSig_LastErrorText;
*get_DebugLogFilePath = *chilkatc::CkXmlDSig_get_DebugLogFilePath;
*debugLogFilePath = *chilkatc::CkXmlDSig_debugLogFilePath;
*put_DebugLogFilePath = *chilkatc::CkXmlDSig_put_DebugLogFilePath;
*get_ExternalRefDirs = *chilkatc::CkXmlDSig_get_ExternalRefDirs;
*externalRefDirs = *chilkatc::CkXmlDSig_externalRefDirs;
*put_ExternalRefDirs = *chilkatc::CkXmlDSig_put_ExternalRefDirs;
*get_IgnoreExternalRefs = *chilkatc::CkXmlDSig_get_IgnoreExternalRefs;
*put_IgnoreExternalRefs = *chilkatc::CkXmlDSig_put_IgnoreExternalRefs;
*get_LastErrorHtml = *chilkatc::CkXmlDSig_get_LastErrorHtml;
*lastErrorHtml = *chilkatc::CkXmlDSig_lastErrorHtml;
*get_LastErrorText = *chilkatc::CkXmlDSig_get_LastErrorText;
*lastErrorText = *chilkatc::CkXmlDSig_lastErrorText;
*get_LastErrorXml = *chilkatc::CkXmlDSig_get_LastErrorXml;
*lastErrorXml = *chilkatc::CkXmlDSig_lastErrorXml;
*get_LastMethodSuccess = *chilkatc::CkXmlDSig_get_LastMethodSuccess;
*put_LastMethodSuccess = *chilkatc::CkXmlDSig_put_LastMethodSuccess;
*get_NumReferences = *chilkatc::CkXmlDSig_get_NumReferences;
*get_NumSignatures = *chilkatc::CkXmlDSig_get_NumSignatures;
*get_RefFailReason = *chilkatc::CkXmlDSig_get_RefFailReason;
*get_Selector = *chilkatc::CkXmlDSig_get_Selector;
*put_Selector = *chilkatc::CkXmlDSig_put_Selector;
*get_UncommonOptions = *chilkatc::CkXmlDSig_get_UncommonOptions;
*uncommonOptions = *chilkatc::CkXmlDSig_uncommonOptions;
*put_UncommonOptions = *chilkatc::CkXmlDSig_put_UncommonOptions;
*get_VerboseLogging = *chilkatc::CkXmlDSig_get_VerboseLogging;
*put_VerboseLogging = *chilkatc::CkXmlDSig_put_VerboseLogging;
*get_Version = *chilkatc::CkXmlDSig_get_Version;
*version = *chilkatc::CkXmlDSig_version;
*AddEncapsulatedTimeStamp = *chilkatc::CkXmlDSig_AddEncapsulatedTimeStamp;
*CanonicalizeFragment = *chilkatc::CkXmlDSig_CanonicalizeFragment;
*canonicalizeFragment = *chilkatc::CkXmlDSig_canonicalizeFragment;
*CanonicalizeXml = *chilkatc::CkXmlDSig_CanonicalizeXml;
*canonicalizeXml = *chilkatc::CkXmlDSig_canonicalizeXml;
*GetCerts = *chilkatc::CkXmlDSig_GetCerts;
*GetKeyInfo = *chilkatc::CkXmlDSig_GetKeyInfo;
*GetPublicKey = *chilkatc::CkXmlDSig_GetPublicKey;
*HasEncapsulatedTimeStamp = *chilkatc::CkXmlDSig_HasEncapsulatedTimeStamp;
*IsReferenceExternal = *chilkatc::CkXmlDSig_IsReferenceExternal;
*LoadSignature = *chilkatc::CkXmlDSig_LoadSignature;
*LoadSignatureBd = *chilkatc::CkXmlDSig_LoadSignatureBd;
*LoadSignatureSb = *chilkatc::CkXmlDSig_LoadSignatureSb;
*ReferenceUri = *chilkatc::CkXmlDSig_ReferenceUri;
*referenceUri = *chilkatc::CkXmlDSig_referenceUri;
*SetHmacKey = *chilkatc::CkXmlDSig_SetHmacKey;
*SetHttpObj = *chilkatc::CkXmlDSig_SetHttpObj;
*SetPublicKey = *chilkatc::CkXmlDSig_SetPublicKey;
*SetRefDataBd = *chilkatc::CkXmlDSig_SetRefDataBd;
*SetRefDataFile = *chilkatc::CkXmlDSig_SetRefDataFile;
*SetRefDataSb = *chilkatc::CkXmlDSig_SetRefDataSb;
*UseCertVault = *chilkatc::CkXmlDSig_UseCertVault;
*VerifyReferenceDigest = *chilkatc::CkXmlDSig_VerifyReferenceDigest;
*VerifySignature = *chilkatc::CkXmlDSig_VerifySignature;
sub DISOWN {
    my $self = shift;
    my $ptr = tied(%$self);
    delete $OWNER{$ptr};
}

sub ACQUIRE {
    my $self = shift;
    my $ptr = tied(%$self);
    $OWNER{$ptr} = 1;
}


############# Class : chilkat::CkXmlDSigGen ##############

package chilkat::CkXmlDSigGen;
use vars qw(@ISA %OWNER %ITERATORS %BLESSEDMEMBERS);
@ISA = qw( chilkat );
%OWNER = ();
%ITERATORS = ();
sub new {
    my $pkg = shift;
    my $self = chilkatc::new_CkXmlDSigGen(@_);
    bless $self, $pkg if defined($self);
}

sub DESTROY {
    return unless $_[0]->isa('HASH');
    my $self = tied(%{$_[0]});
    return unless defined $self;
    delete $ITERATORS{$self};
    if (exists $OWNER{$self}) {
        chilkatc::delete_CkXmlDSigGen($self);
        delete $OWNER{$self};
    }
}

*get_Utf8 = *chilkatc::CkXmlDSigGen_get_Utf8;
*put_Utf8 = *chilkatc::CkXmlDSigGen_put_Utf8;
*LastErrorXml = *chilkatc::CkXmlDSigGen_LastErrorXml;
*LastErrorHtml = *chilkatc::CkXmlDSigGen_LastErrorHtml;
*LastErrorText = *chilkatc::CkXmlDSigGen_LastErrorText;
*put_EventCallbackObject = *chilkatc::CkXmlDSigGen_put_EventCallbackObject;
*get_Behaviors = *chilkatc::CkXmlDSigGen_get_Behaviors;
*behaviors = *chilkatc::CkXmlDSigGen_behaviors;
*put_Behaviors = *chilkatc::CkXmlDSigGen_put_Behaviors;
*get_CustomKeyInfoXml = *chilkatc::CkXmlDSigGen_get_CustomKeyInfoXml;
*customKeyInfoXml = *chilkatc::CkXmlDSigGen_customKeyInfoXml;
*put_CustomKeyInfoXml = *chilkatc::CkXmlDSigGen_put_CustomKeyInfoXml;
*get_DebugLogFilePath = *chilkatc::CkXmlDSigGen_get_DebugLogFilePath;
*debugLogFilePath = *chilkatc::CkXmlDSigGen_debugLogFilePath;
*put_DebugLogFilePath = *chilkatc::CkXmlDSigGen_put_DebugLogFilePath;
*get_IncNamespacePrefix = *chilkatc::CkXmlDSigGen_get_IncNamespacePrefix;
*incNamespacePrefix = *chilkatc::CkXmlDSigGen_incNamespacePrefix;
*put_IncNamespacePrefix = *chilkatc::CkXmlDSigGen_put_IncNamespacePrefix;
*get_IncNamespaceUri = *chilkatc::CkXmlDSigGen_get_IncNamespaceUri;
*incNamespaceUri = *chilkatc::CkXmlDSigGen_incNamespaceUri;
*put_IncNamespaceUri = *chilkatc::CkXmlDSigGen_put_IncNamespaceUri;
*get_KeyInfoId = *chilkatc::CkXmlDSigGen_get_KeyInfoId;
*keyInfoId = *chilkatc::CkXmlDSigGen_keyInfoId;
*put_KeyInfoId = *chilkatc::CkXmlDSigGen_put_KeyInfoId;
*get_KeyInfoKeyName = *chilkatc::CkXmlDSigGen_get_KeyInfoKeyName;
*keyInfoKeyName = *chilkatc::CkXmlDSigGen_keyInfoKeyName;
*put_KeyInfoKeyName = *chilkatc::CkXmlDSigGen_put_KeyInfoKeyName;
*get_KeyInfoType = *chilkatc::CkXmlDSigGen_get_KeyInfoType;
*keyInfoType = *chilkatc::CkXmlDSigGen_keyInfoType;
*put_KeyInfoType = *chilkatc::CkXmlDSigGen_put_KeyInfoType;
*get_LastErrorHtml = *chilkatc::CkXmlDSigGen_get_LastErrorHtml;
*lastErrorHtml = *chilkatc::CkXmlDSigGen_lastErrorHtml;
*get_LastErrorText = *chilkatc::CkXmlDSigGen_get_LastErrorText;
*lastErrorText = *chilkatc::CkXmlDSigGen_lastErrorText;
*get_LastErrorXml = *chilkatc::CkXmlDSigGen_get_LastErrorXml;
*lastErrorXml = *chilkatc::CkXmlDSigGen_lastErrorXml;
*get_LastMethodSuccess = *chilkatc::CkXmlDSigGen_get_LastMethodSuccess;
*put_LastMethodSuccess = *chilkatc::CkXmlDSigGen_put_LastMethodSuccess;
*get_SigId = *chilkatc::CkXmlDSigGen_get_SigId;
*sigId = *chilkatc::CkXmlDSigGen_sigId;
*put_SigId = *chilkatc::CkXmlDSigGen_put_SigId;
*get_SigLocation = *chilkatc::CkXmlDSigGen_get_SigLocation;
*sigLocation = *chilkatc::CkXmlDSigGen_sigLocation;
*put_SigLocation = *chilkatc::CkXmlDSigGen_put_SigLocation;
*get_SigLocationIdx = *chilkatc::CkXmlDSigGen_get_SigLocationIdx;
*put_SigLocationIdx = *chilkatc::CkXmlDSigGen_put_SigLocationIdx;
*get_SigLocationMod = *chilkatc::CkXmlDSigGen_get_SigLocationMod;
*put_SigLocationMod = *chilkatc::CkXmlDSigGen_put_SigLocationMod;
*get_SigNamespacePrefix = *chilkatc::CkXmlDSigGen_get_SigNamespacePrefix;
*sigNamespacePrefix = *chilkatc::CkXmlDSigGen_sigNamespacePrefix;
*put_SigNamespacePrefix = *chilkatc::CkXmlDSigGen_put_SigNamespacePrefix;
*get_SigNamespaceUri = *chilkatc::CkXmlDSigGen_get_SigNamespaceUri;
*sigNamespaceUri = *chilkatc::CkXmlDSigGen_sigNamespaceUri;
*put_SigNamespaceUri = *chilkatc::CkXmlDSigGen_put_SigNamespaceUri;
*get_SignedInfoCanonAlg = *chilkatc::CkXmlDSigGen_get_SignedInfoCanonAlg;
*signedInfoCanonAlg = *chilkatc::CkXmlDSigGen_signedInfoCanonAlg;
*put_SignedInfoCanonAlg = *chilkatc::CkXmlDSigGen_put_SignedInfoCanonAlg;
*get_SignedInfoDigestMethod = *chilkatc::CkXmlDSigGen_get_SignedInfoDigestMethod;
*signedInfoDigestMethod = *chilkatc::CkXmlDSigGen_signedInfoDigestMethod;
*put_SignedInfoDigestMethod = *chilkatc::CkXmlDSigGen_put_SignedInfoDigestMethod;
*get_SignedInfoId = *chilkatc::CkXmlDSigGen_get_SignedInfoId;
*signedInfoId = *chilkatc::CkXmlDSigGen_signedInfoId;
*put_SignedInfoId = *chilkatc::CkXmlDSigGen_put_SignedInfoId;
*get_SignedInfoPrefixList = *chilkatc::CkXmlDSigGen_get_SignedInfoPrefixList;
*signedInfoPrefixList = *chilkatc::CkXmlDSigGen_signedInfoPrefixList;
*put_SignedInfoPrefixList = *chilkatc::CkXmlDSigGen_put_SignedInfoPrefixList;
*get_SigningAlg = *chilkatc::CkXmlDSigGen_get_SigningAlg;
*signingAlg = *chilkatc::CkXmlDSigGen_signingAlg;
*put_SigningAlg = *chilkatc::CkXmlDSigGen_put_SigningAlg;
*get_SigValueId = *chilkatc::CkXmlDSigGen_get_SigValueId;
*sigValueId = *chilkatc::CkXmlDSigGen_sigValueId;
*put_SigValueId = *chilkatc::CkXmlDSigGen_put_SigValueId;
*get_UncommonOptions = *chilkatc::CkXmlDSigGen_get_UncommonOptions;
*uncommonOptions = *chilkatc::CkXmlDSigGen_uncommonOptions;
*put_UncommonOptions = *chilkatc::CkXmlDSigGen_put_UncommonOptions;
*get_VerboseLogging = *chilkatc::CkXmlDSigGen_get_VerboseLogging;
*put_VerboseLogging = *chilkatc::CkXmlDSigGen_put_VerboseLogging;
*get_Version = *chilkatc::CkXmlDSigGen_get_Version;
*version = *chilkatc::CkXmlDSigGen_version;
*get_X509Type = *chilkatc::CkXmlDSigGen_get_X509Type;
*x509Type = *chilkatc::CkXmlDSigGen_x509Type;
*put_X509Type = *chilkatc::CkXmlDSigGen_put_X509Type;
*AddEnvelopedRef = *chilkatc::CkXmlDSigGen_AddEnvelopedRef;
*AddExternalBinaryRef = *chilkatc::CkXmlDSigGen_AddExternalBinaryRef;
*AddExternalFileRef = *chilkatc::CkXmlDSigGen_AddExternalFileRef;
*AddExternalTextRef = *chilkatc::CkXmlDSigGen_AddExternalTextRef;
*AddExternalXmlRef = *chilkatc::CkXmlDSigGen_AddExternalXmlRef;
*AddObject = *chilkatc::CkXmlDSigGen_AddObject;
*AddObjectRef = *chilkatc::CkXmlDSigGen_AddObjectRef;
*AddObjectRef2 = *chilkatc::CkXmlDSigGen_AddObjectRef2;
*AddSameDocRef = *chilkatc::CkXmlDSigGen_AddSameDocRef;
*AddSameDocRef2 = *chilkatc::CkXmlDSigGen_AddSameDocRef2;
*AddSignatureNamespace = *chilkatc::CkXmlDSigGen_AddSignatureNamespace;
*ConstructSignedInfo = *chilkatc::CkXmlDSigGen_ConstructSignedInfo;
*constructSignedInfo = *chilkatc::CkXmlDSigGen_constructSignedInfo;
*CreateXmlDSig = *chilkatc::CkXmlDSigGen_CreateXmlDSig;
*createXmlDSig = *chilkatc::CkXmlDSigGen_createXmlDSig;
*CreateXmlDSigAsync = *chilkatc::CkXmlDSigGen_CreateXmlDSigAsync;
*CreateXmlDSigSb = *chilkatc::CkXmlDSigGen_CreateXmlDSigSb;
*CreateXmlDSigSbAsync = *chilkatc::CkXmlDSigGen_CreateXmlDSigSbAsync;
*SetHmacKey = *chilkatc::CkXmlDSigGen_SetHmacKey;
*SetHttpObj = *chilkatc::CkXmlDSigGen_SetHttpObj;
*SetPrivateKey = *chilkatc::CkXmlDSigGen_SetPrivateKey;
*SetRefIdAttr = *chilkatc::CkXmlDSigGen_SetRefIdAttr;
*SetTsa = *chilkatc::CkXmlDSigGen_SetTsa;
*SetX509Cert = *chilkatc::CkXmlDSigGen_SetX509Cert;
sub DISOWN {
    my $self = shift;
    my $ptr = tied(%$self);
    delete $OWNER{$ptr};
}

sub ACQUIRE {
    my $self = shift;
    my $ptr = tied(%$self);
    $OWNER{$ptr} = 1;
}


############# Class : chilkat::CkXmp ##############

package chilkat::CkXmp;
use vars qw(@ISA %OWNER %ITERATORS %BLESSEDMEMBERS);
@ISA = qw( chilkat );
%OWNER = ();
%ITERATORS = ();
sub new {
    my $pkg = shift;
    my $self = chilkatc::new_CkXmp(@_);
    bless $self, $pkg if defined($self);
}

sub DESTROY {
    return unless $_[0]->isa('HASH');
    my $self = tied(%{$_[0]});
    return unless defined $self;
    delete $ITERATORS{$self};
    if (exists $OWNER{$self}) {
        chilkatc::delete_CkXmp($self);
        delete $OWNER{$self};
    }
}

*get_Utf8 = *chilkatc::CkXmp_get_Utf8;
*put_Utf8 = *chilkatc::CkXmp_put_Utf8;
*LastErrorXml = *chilkatc::CkXmp_LastErrorXml;
*LastErrorHtml = *chilkatc::CkXmp_LastErrorHtml;
*LastErrorText = *chilkatc::CkXmp_LastErrorText;
*get_DebugLogFilePath = *chilkatc::CkXmp_get_DebugLogFilePath;
*debugLogFilePath = *chilkatc::CkXmp_debugLogFilePath;
*put_DebugLogFilePath = *chilkatc::CkXmp_put_DebugLogFilePath;
*get_LastErrorHtml = *chilkatc::CkXmp_get_LastErrorHtml;
*lastErrorHtml = *chilkatc::CkXmp_lastErrorHtml;
*get_LastErrorText = *chilkatc::CkXmp_get_LastErrorText;
*lastErrorText = *chilkatc::CkXmp_lastErrorText;
*get_LastErrorXml = *chilkatc::CkXmp_get_LastErrorXml;
*lastErrorXml = *chilkatc::CkXmp_lastErrorXml;
*get_LastMethodSuccess = *chilkatc::CkXmp_get_LastMethodSuccess;
*put_LastMethodSuccess = *chilkatc::CkXmp_put_LastMethodSuccess;
*get_NumEmbedded = *chilkatc::CkXmp_get_NumEmbedded;
*get_StructInnerDescrip = *chilkatc::CkXmp_get_StructInnerDescrip;
*put_StructInnerDescrip = *chilkatc::CkXmp_put_StructInnerDescrip;
*get_UncommonOptions = *chilkatc::CkXmp_get_UncommonOptions;
*uncommonOptions = *chilkatc::CkXmp_uncommonOptions;
*put_UncommonOptions = *chilkatc::CkXmp_put_UncommonOptions;
*get_VerboseLogging = *chilkatc::CkXmp_get_VerboseLogging;
*put_VerboseLogging = *chilkatc::CkXmp_put_VerboseLogging;
*get_Version = *chilkatc::CkXmp_get_Version;
*version = *chilkatc::CkXmp_version;
*AddArray = *chilkatc::CkXmp_AddArray;
*AddNsMapping = *chilkatc::CkXmp_AddNsMapping;
*AddSimpleInt = *chilkatc::CkXmp_AddSimpleInt;
*AddSimpleStr = *chilkatc::CkXmp_AddSimpleStr;
*AddStructProp = *chilkatc::CkXmp_AddStructProp;
*Append = *chilkatc::CkXmp_Append;
*GetArray = *chilkatc::CkXmp_GetArray;
*GetEmbedded = *chilkatc::CkXmp_GetEmbedded;
*GetProperty = *chilkatc::CkXmp_GetProperty;
*GetSimpleInt = *chilkatc::CkXmp_GetSimpleInt;
*GetSimpleStr = *chilkatc::CkXmp_GetSimpleStr;
*getSimpleStr = *chilkatc::CkXmp_getSimpleStr;
*simpleStr = *chilkatc::CkXmp_simpleStr;
*GetStructPropNames = *chilkatc::CkXmp_GetStructPropNames;
*GetStructValue = *chilkatc::CkXmp_GetStructValue;
*getStructValue = *chilkatc::CkXmp_getStructValue;
*structValue = *chilkatc::CkXmp_structValue;
*LoadAppFile = *chilkatc::CkXmp_LoadAppFile;
*LoadFromBuffer = *chilkatc::CkXmp_LoadFromBuffer;
*NewXmp = *chilkatc::CkXmp_NewXmp;
*RemoveAllEmbedded = *chilkatc::CkXmp_RemoveAllEmbedded;
*RemoveArray = *chilkatc::CkXmp_RemoveArray;
*RemoveEmbedded = *chilkatc::CkXmp_RemoveEmbedded;
*RemoveNsMapping = *chilkatc::CkXmp_RemoveNsMapping;
*RemoveSimple = *chilkatc::CkXmp_RemoveSimple;
*RemoveStruct = *chilkatc::CkXmp_RemoveStruct;
*RemoveStructProp = *chilkatc::CkXmp_RemoveStructProp;
*SaveAppFile = *chilkatc::CkXmp_SaveAppFile;
*SaveToBuffer = *chilkatc::CkXmp_SaveToBuffer;
sub DISOWN {
    my $self = shift;
    my $ptr = tied(%$self);
    delete $OWNER{$ptr};
}

sub ACQUIRE {
    my $self = shift;
    my $ptr = tied(%$self);
    $OWNER{$ptr} = 1;
}


############# Class : chilkat::CkZip ##############

package chilkat::CkZip;
use vars qw(@ISA %OWNER %ITERATORS %BLESSEDMEMBERS);
@ISA = qw( chilkat );
%OWNER = ();
%ITERATORS = ();
sub new {
    my $pkg = shift;
    my $self = chilkatc::new_CkZip(@_);
    bless $self, $pkg if defined($self);
}

sub DESTROY {
    return unless $_[0]->isa('HASH');
    my $self = tied(%{$_[0]});
    return unless defined $self;
    delete $ITERATORS{$self};
    if (exists $OWNER{$self}) {
        chilkatc::delete_CkZip($self);
        delete $OWNER{$self};
    }
}

*get_Utf8 = *chilkatc::CkZip_get_Utf8;
*put_Utf8 = *chilkatc::CkZip_put_Utf8;
*LastErrorXml = *chilkatc::CkZip_LastErrorXml;
*LastErrorHtml = *chilkatc::CkZip_LastErrorHtml;
*LastErrorText = *chilkatc::CkZip_LastErrorText;
*put_EventCallbackObject = *chilkatc::CkZip_put_EventCallbackObject;
*get_AbortCurrent = *chilkatc::CkZip_get_AbortCurrent;
*put_AbortCurrent = *chilkatc::CkZip_put_AbortCurrent;
*get_AppendFromDir = *chilkatc::CkZip_get_AppendFromDir;
*appendFromDir = *chilkatc::CkZip_appendFromDir;
*put_AppendFromDir = *chilkatc::CkZip_put_AppendFromDir;
*get_AutoRun = *chilkatc::CkZip_get_AutoRun;
*autoRun = *chilkatc::CkZip_autoRun;
*put_AutoRun = *chilkatc::CkZip_put_AutoRun;
*get_AutoRunParams = *chilkatc::CkZip_get_AutoRunParams;
*autoRunParams = *chilkatc::CkZip_autoRunParams;
*put_AutoRunParams = *chilkatc::CkZip_put_AutoRunParams;
*get_AutoTemp = *chilkatc::CkZip_get_AutoTemp;
*put_AutoTemp = *chilkatc::CkZip_put_AutoTemp;
*get_CaseSensitive = *chilkatc::CkZip_get_CaseSensitive;
*put_CaseSensitive = *chilkatc::CkZip_put_CaseSensitive;
*get_ClearArchiveAttribute = *chilkatc::CkZip_get_ClearArchiveAttribute;
*put_ClearArchiveAttribute = *chilkatc::CkZip_put_ClearArchiveAttribute;
*get_ClearReadOnlyAttr = *chilkatc::CkZip_get_ClearReadOnlyAttr;
*put_ClearReadOnlyAttr = *chilkatc::CkZip_put_ClearReadOnlyAttr;
*get_Comment = *chilkatc::CkZip_get_Comment;
*comment = *chilkatc::CkZip_comment;
*put_Comment = *chilkatc::CkZip_put_Comment;
*get_DebugLogFilePath = *chilkatc::CkZip_get_DebugLogFilePath;
*debugLogFilePath = *chilkatc::CkZip_debugLogFilePath;
*put_DebugLogFilePath = *chilkatc::CkZip_put_DebugLogFilePath;
*get_DecryptPassword = *chilkatc::CkZip_get_DecryptPassword;
*decryptPassword = *chilkatc::CkZip_decryptPassword;
*put_DecryptPassword = *chilkatc::CkZip_put_DecryptPassword;
*get_DiscardPaths = *chilkatc::CkZip_get_DiscardPaths;
*put_DiscardPaths = *chilkatc::CkZip_put_DiscardPaths;
*get_Encryption = *chilkatc::CkZip_get_Encryption;
*put_Encryption = *chilkatc::CkZip_put_Encryption;
*get_EncryptKeyLength = *chilkatc::CkZip_get_EncryptKeyLength;
*put_EncryptKeyLength = *chilkatc::CkZip_put_EncryptKeyLength;
*get_EncryptPassword = *chilkatc::CkZip_get_EncryptPassword;
*encryptPassword = *chilkatc::CkZip_encryptPassword;
*put_EncryptPassword = *chilkatc::CkZip_put_EncryptPassword;
*get_ExeDefaultDir = *chilkatc::CkZip_get_ExeDefaultDir;
*exeDefaultDir = *chilkatc::CkZip_exeDefaultDir;
*put_ExeDefaultDir = *chilkatc::CkZip_put_ExeDefaultDir;
*get_ExeFinishNotifier = *chilkatc::CkZip_get_ExeFinishNotifier;
*put_ExeFinishNotifier = *chilkatc::CkZip_put_ExeFinishNotifier;
*get_ExeIconFile = *chilkatc::CkZip_get_ExeIconFile;
*exeIconFile = *chilkatc::CkZip_exeIconFile;
*put_ExeIconFile = *chilkatc::CkZip_put_ExeIconFile;
*get_ExeNoInterface = *chilkatc::CkZip_get_ExeNoInterface;
*put_ExeNoInterface = *chilkatc::CkZip_put_ExeNoInterface;
*get_ExeSilentProgress = *chilkatc::CkZip_get_ExeSilentProgress;
*put_ExeSilentProgress = *chilkatc::CkZip_put_ExeSilentProgress;
*get_ExeTitle = *chilkatc::CkZip_get_ExeTitle;
*exeTitle = *chilkatc::CkZip_exeTitle;
*put_ExeTitle = *chilkatc::CkZip_put_ExeTitle;
*get_ExeUnzipCaption = *chilkatc::CkZip_get_ExeUnzipCaption;
*exeUnzipCaption = *chilkatc::CkZip_exeUnzipCaption;
*put_ExeUnzipCaption = *chilkatc::CkZip_put_ExeUnzipCaption;
*get_ExeUnzipDir = *chilkatc::CkZip_get_ExeUnzipDir;
*exeUnzipDir = *chilkatc::CkZip_exeUnzipDir;
*put_ExeUnzipDir = *chilkatc::CkZip_put_ExeUnzipDir;
*get_ExeWaitForSetup = *chilkatc::CkZip_get_ExeWaitForSetup;
*put_ExeWaitForSetup = *chilkatc::CkZip_put_ExeWaitForSetup;
*get_ExeXmlConfig = *chilkatc::CkZip_get_ExeXmlConfig;
*exeXmlConfig = *chilkatc::CkZip_exeXmlConfig;
*put_ExeXmlConfig = *chilkatc::CkZip_put_ExeXmlConfig;
*get_FileCount = *chilkatc::CkZip_get_FileCount;
*get_FileName = *chilkatc::CkZip_get_FileName;
*fileName = *chilkatc::CkZip_fileName;
*put_FileName = *chilkatc::CkZip_put_FileName;
*get_HasZipFormatErrors = *chilkatc::CkZip_get_HasZipFormatErrors;
*get_HeartbeatMs = *chilkatc::CkZip_get_HeartbeatMs;
*put_HeartbeatMs = *chilkatc::CkZip_put_HeartbeatMs;
*get_IgnoreAccessDenied = *chilkatc::CkZip_get_IgnoreAccessDenied;
*put_IgnoreAccessDenied = *chilkatc::CkZip_put_IgnoreAccessDenied;
*get_LastErrorHtml = *chilkatc::CkZip_get_LastErrorHtml;
*lastErrorHtml = *chilkatc::CkZip_lastErrorHtml;
*get_LastErrorText = *chilkatc::CkZip_get_LastErrorText;
*lastErrorText = *chilkatc::CkZip_lastErrorText;
*get_LastErrorXml = *chilkatc::CkZip_get_LastErrorXml;
*lastErrorXml = *chilkatc::CkZip_lastErrorXml;
*get_LastMethodSuccess = *chilkatc::CkZip_get_LastMethodSuccess;
*put_LastMethodSuccess = *chilkatc::CkZip_put_LastMethodSuccess;
*get_MaxDate = *chilkatc::CkZip_get_MaxDate;
*maxDate = *chilkatc::CkZip_maxDate;
*put_MaxDate = *chilkatc::CkZip_put_MaxDate;
*get_MaxUncompressSize = *chilkatc::CkZip_get_MaxUncompressSize;
*put_MaxUncompressSize = *chilkatc::CkZip_put_MaxUncompressSize;
*get_MinDate = *chilkatc::CkZip_get_MinDate;
*minDate = *chilkatc::CkZip_minDate;
*put_MinDate = *chilkatc::CkZip_put_MinDate;
*get_NumEntries = *chilkatc::CkZip_get_NumEntries;
*get_OemCodePage = *chilkatc::CkZip_get_OemCodePage;
*put_OemCodePage = *chilkatc::CkZip_put_OemCodePage;
*get_OverwriteExisting = *chilkatc::CkZip_get_OverwriteExisting;
*put_OverwriteExisting = *chilkatc::CkZip_put_OverwriteExisting;
*get_PasswordProtect = *chilkatc::CkZip_get_PasswordProtect;
*put_PasswordProtect = *chilkatc::CkZip_put_PasswordProtect;
*get_PathPrefix = *chilkatc::CkZip_get_PathPrefix;
*pathPrefix = *chilkatc::CkZip_pathPrefix;
*put_PathPrefix = *chilkatc::CkZip_put_PathPrefix;
*get_PercentDoneScale = *chilkatc::CkZip_get_PercentDoneScale;
*put_PercentDoneScale = *chilkatc::CkZip_put_PercentDoneScale;
*get_PwdProtCharset = *chilkatc::CkZip_get_PwdProtCharset;
*pwdProtCharset = *chilkatc::CkZip_pwdProtCharset;
*put_PwdProtCharset = *chilkatc::CkZip_put_PwdProtCharset;
*get_TempDir = *chilkatc::CkZip_get_TempDir;
*tempDir = *chilkatc::CkZip_tempDir;
*put_TempDir = *chilkatc::CkZip_put_TempDir;
*get_UncommonOptions = *chilkatc::CkZip_get_UncommonOptions;
*uncommonOptions = *chilkatc::CkZip_uncommonOptions;
*put_UncommonOptions = *chilkatc::CkZip_put_UncommonOptions;
*get_VerboseLogging = *chilkatc::CkZip_get_VerboseLogging;
*put_VerboseLogging = *chilkatc::CkZip_put_VerboseLogging;
*get_Version = *chilkatc::CkZip_get_Version;
*version = *chilkatc::CkZip_version;
*get_Zipx = *chilkatc::CkZip_get_Zipx;
*put_Zipx = *chilkatc::CkZip_put_Zipx;
*get_ZipxDefaultAlg = *chilkatc::CkZip_get_ZipxDefaultAlg;
*zipxDefaultAlg = *chilkatc::CkZip_zipxDefaultAlg;
*put_ZipxDefaultAlg = *chilkatc::CkZip_put_ZipxDefaultAlg;
*AddBd = *chilkatc::CkZip_AddBd;
*AddEmpty = *chilkatc::CkZip_AddEmpty;
*AddEncoded = *chilkatc::CkZip_AddEncoded;
*AddFile = *chilkatc::CkZip_AddFile;
*AddNoCompressExtension = *chilkatc::CkZip_AddNoCompressExtension;
*AddSb = *chilkatc::CkZip_AddSb;
*AddString = *chilkatc::CkZip_AddString;
*AppendBd = *chilkatc::CkZip_AppendBd;
*AppendData = *chilkatc::CkZip_AppendData;
*AppendDataEncoded = *chilkatc::CkZip_AppendDataEncoded;
*AppendFiles = *chilkatc::CkZip_AppendFiles;
*AppendFilesAsync = *chilkatc::CkZip_AppendFilesAsync;
*AppendFilesEx = *chilkatc::CkZip_AppendFilesEx;
*AppendFilesExAsync = *chilkatc::CkZip_AppendFilesExAsync;
*AppendNew = *chilkatc::CkZip_AppendNew;
*AppendNewDir = *chilkatc::CkZip_AppendNewDir;
*AppendOneFileOrDir = *chilkatc::CkZip_AppendOneFileOrDir;
*AppendOneFileOrDirAsync = *chilkatc::CkZip_AppendOneFileOrDirAsync;
*AppendSb = *chilkatc::CkZip_AppendSb;
*AppendString = *chilkatc::CkZip_AppendString;
*AppendString2 = *chilkatc::CkZip_AppendString2;
*AppendZip = *chilkatc::CkZip_AppendZip;
*CloseZip = *chilkatc::CkZip_CloseZip;
*DeleteEntry = *chilkatc::CkZip_DeleteEntry;
*EntryAt = *chilkatc::CkZip_EntryAt;
*EntryById = *chilkatc::CkZip_EntryById;
*EntryMatching = *chilkatc::CkZip_EntryMatching;
*EntryOf = *chilkatc::CkZip_EntryOf;
*ExcludeDir = *chilkatc::CkZip_ExcludeDir;
*ExtractExe = *chilkatc::CkZip_ExtractExe;
*ExtractExeAsync = *chilkatc::CkZip_ExtractExeAsync;
*FirstEntry = *chilkatc::CkZip_FirstEntry;
*FirstMatchingEntry = *chilkatc::CkZip_FirstMatchingEntry;
*GetDirectoryAsXML = *chilkatc::CkZip_GetDirectoryAsXML;
*getDirectoryAsXML = *chilkatc::CkZip_getDirectoryAsXML;
*directoryAsXML = *chilkatc::CkZip_directoryAsXML;
*GetEntryByID = *chilkatc::CkZip_GetEntryByID;
*GetEntryByIndex = *chilkatc::CkZip_GetEntryByIndex;
*GetEntryByName = *chilkatc::CkZip_GetEntryByName;
*GetExclusions = *chilkatc::CkZip_GetExclusions;
*GetExeConfigParam = *chilkatc::CkZip_GetExeConfigParam;
*getExeConfigParam = *chilkatc::CkZip_getExeConfigParam;
*exeConfigParam = *chilkatc::CkZip_exeConfigParam;
*GetMaxUncompressedSize = *chilkatc::CkZip_GetMaxUncompressedSize;
*getMaxUncompressedSize = *chilkatc::CkZip_getMaxUncompressedSize;
*maxUncompressedSize = *chilkatc::CkZip_maxUncompressedSize;
*IsNoCompressExtension = *chilkatc::CkZip_IsNoCompressExtension;
*IsPasswordProtected = *chilkatc::CkZip_IsPasswordProtected;
*LoadTaskCaller = *chilkatc::CkZip_LoadTaskCaller;
*NewZip = *chilkatc::CkZip_NewZip;
*OpenBd = *chilkatc::CkZip_OpenBd;
*OpenEmbedded = *chilkatc::CkZip_OpenEmbedded;
*OpenFromByteData = *chilkatc::CkZip_OpenFromByteData;
*OpenFromMemory = *chilkatc::CkZip_OpenFromMemory;
*OpenZip = *chilkatc::CkZip_OpenZip;
*OpenZipAsync = *chilkatc::CkZip_OpenZipAsync;
*QuickAppend = *chilkatc::CkZip_QuickAppend;
*QuickAppendAsync = *chilkatc::CkZip_QuickAppendAsync;
*RemoveNoCompressExtension = *chilkatc::CkZip_RemoveNoCompressExtension;
*SetCompressionLevel = *chilkatc::CkZip_SetCompressionLevel;
*SetExclusions = *chilkatc::CkZip_SetExclusions;
*SetExeConfigParam = *chilkatc::CkZip_SetExeConfigParam;
*SetPassword = *chilkatc::CkZip_SetPassword;
*Unzip = *chilkatc::CkZip_Unzip;
*UnzipAsync = *chilkatc::CkZip_UnzipAsync;
*UnzipInto = *chilkatc::CkZip_UnzipInto;
*UnzipIntoAsync = *chilkatc::CkZip_UnzipIntoAsync;
*UnzipMatching = *chilkatc::CkZip_UnzipMatching;
*UnzipMatchingAsync = *chilkatc::CkZip_UnzipMatchingAsync;
*UnzipMatchingInto = *chilkatc::CkZip_UnzipMatchingInto;
*UnzipMatchingIntoAsync = *chilkatc::CkZip_UnzipMatchingIntoAsync;
*UnzipNewer = *chilkatc::CkZip_UnzipNewer;
*UnzipNewerAsync = *chilkatc::CkZip_UnzipNewerAsync;
*VerifyPassword = *chilkatc::CkZip_VerifyPassword;
*WriteBd = *chilkatc::CkZip_WriteBd;
*WriteBdAsync = *chilkatc::CkZip_WriteBdAsync;
*WriteExe = *chilkatc::CkZip_WriteExe;
*WriteExeAsync = *chilkatc::CkZip_WriteExeAsync;
*WriteExe2 = *chilkatc::CkZip_WriteExe2;
*WriteExe2Async = *chilkatc::CkZip_WriteExe2Async;
*WriteExeToMemory = *chilkatc::CkZip_WriteExeToMemory;
*WriteExeToMemoryAsync = *chilkatc::CkZip_WriteExeToMemoryAsync;
*WriteToMemory = *chilkatc::CkZip_WriteToMemory;
*WriteToMemoryAsync = *chilkatc::CkZip_WriteToMemoryAsync;
*WriteZip = *chilkatc::CkZip_WriteZip;
*WriteZipAsync = *chilkatc::CkZip_WriteZipAsync;
*WriteZipAndClose = *chilkatc::CkZip_WriteZipAndClose;
*WriteZipAndCloseAsync = *chilkatc::CkZip_WriteZipAndCloseAsync;
sub DISOWN {
    my $self = shift;
    my $ptr = tied(%$self);
    delete $OWNER{$ptr};
}

sub ACQUIRE {
    my $self = shift;
    my $ptr = tied(%$self);
    $OWNER{$ptr} = 1;
}


############# Class : chilkat::CkZipCrc ##############

package chilkat::CkZipCrc;
use vars qw(@ISA %OWNER %ITERATORS %BLESSEDMEMBERS);
@ISA = qw( chilkat );
%OWNER = ();
%ITERATORS = ();
sub new {
    my $pkg = shift;
    my $self = chilkatc::new_CkZipCrc(@_);
    bless $self, $pkg if defined($self);
}

sub DESTROY {
    return unless $_[0]->isa('HASH');
    my $self = tied(%{$_[0]});
    return unless defined $self;
    delete $ITERATORS{$self};
    if (exists $OWNER{$self}) {
        chilkatc::delete_CkZipCrc($self);
        delete $OWNER{$self};
    }
}

*get_Utf8 = *chilkatc::CkZipCrc_get_Utf8;
*put_Utf8 = *chilkatc::CkZipCrc_put_Utf8;
*LastErrorXml = *chilkatc::CkZipCrc_LastErrorXml;
*LastErrorHtml = *chilkatc::CkZipCrc_LastErrorHtml;
*LastErrorText = *chilkatc::CkZipCrc_LastErrorText;
*put_EventCallbackObject = *chilkatc::CkZipCrc_put_EventCallbackObject;
*get_DebugLogFilePath = *chilkatc::CkZipCrc_get_DebugLogFilePath;
*debugLogFilePath = *chilkatc::CkZipCrc_debugLogFilePath;
*put_DebugLogFilePath = *chilkatc::CkZipCrc_put_DebugLogFilePath;
*get_LastErrorHtml = *chilkatc::CkZipCrc_get_LastErrorHtml;
*lastErrorHtml = *chilkatc::CkZipCrc_lastErrorHtml;
*get_LastErrorText = *chilkatc::CkZipCrc_get_LastErrorText;
*lastErrorText = *chilkatc::CkZipCrc_lastErrorText;
*get_LastErrorXml = *chilkatc::CkZipCrc_get_LastErrorXml;
*lastErrorXml = *chilkatc::CkZipCrc_lastErrorXml;
*get_LastMethodSuccess = *chilkatc::CkZipCrc_get_LastMethodSuccess;
*put_LastMethodSuccess = *chilkatc::CkZipCrc_put_LastMethodSuccess;
*get_VerboseLogging = *chilkatc::CkZipCrc_get_VerboseLogging;
*put_VerboseLogging = *chilkatc::CkZipCrc_put_VerboseLogging;
*get_Version = *chilkatc::CkZipCrc_get_Version;
*version = *chilkatc::CkZipCrc_version;
*BeginStream = *chilkatc::CkZipCrc_BeginStream;
*CalculateCrc = *chilkatc::CkZipCrc_CalculateCrc;
*CrcBd = *chilkatc::CkZipCrc_CrcBd;
*CrcSb = *chilkatc::CkZipCrc_CrcSb;
*CrcString = *chilkatc::CkZipCrc_CrcString;
*EndStream = *chilkatc::CkZipCrc_EndStream;
*FileCrc = *chilkatc::CkZipCrc_FileCrc;
*FileCrcAsync = *chilkatc::CkZipCrc_FileCrcAsync;
*LoadTaskCaller = *chilkatc::CkZipCrc_LoadTaskCaller;
*MoreData = *chilkatc::CkZipCrc_MoreData;
*ToHex = *chilkatc::CkZipCrc_ToHex;
*toHex = *chilkatc::CkZipCrc_toHex;
sub DISOWN {
    my $self = shift;
    my $ptr = tied(%$self);
    delete $OWNER{$ptr};
}

sub ACQUIRE {
    my $self = shift;
    my $ptr = tied(%$self);
    $OWNER{$ptr} = 1;
}


############# Class : chilkat::CkZipEntry ##############

package chilkat::CkZipEntry;
use vars qw(@ISA %OWNER %ITERATORS %BLESSEDMEMBERS);
@ISA = qw( chilkat );
%OWNER = ();
%ITERATORS = ();
sub new {
    my $pkg = shift;
    my $self = chilkatc::new_CkZipEntry(@_);
    bless $self, $pkg if defined($self);
}

sub DESTROY {
    return unless $_[0]->isa('HASH');
    my $self = tied(%{$_[0]});
    return unless defined $self;
    delete $ITERATORS{$self};
    if (exists $OWNER{$self}) {
        chilkatc::delete_CkZipEntry($self);
        delete $OWNER{$self};
    }
}

*get_Utf8 = *chilkatc::CkZipEntry_get_Utf8;
*put_Utf8 = *chilkatc::CkZipEntry_put_Utf8;
*LastErrorXml = *chilkatc::CkZipEntry_LastErrorXml;
*LastErrorHtml = *chilkatc::CkZipEntry_LastErrorHtml;
*LastErrorText = *chilkatc::CkZipEntry_LastErrorText;
*put_EventCallbackObject = *chilkatc::CkZipEntry_put_EventCallbackObject;
*get_Comment = *chilkatc::CkZipEntry_get_Comment;
*comment = *chilkatc::CkZipEntry_comment;
*put_Comment = *chilkatc::CkZipEntry_put_Comment;
*get_CompressedLength = *chilkatc::CkZipEntry_get_CompressedLength;
*get_CompressedLength64 = *chilkatc::CkZipEntry_get_CompressedLength64;
*get_CompressedLengthStr = *chilkatc::CkZipEntry_get_CompressedLengthStr;
*compressedLengthStr = *chilkatc::CkZipEntry_compressedLengthStr;
*get_CompressionLevel = *chilkatc::CkZipEntry_get_CompressionLevel;
*put_CompressionLevel = *chilkatc::CkZipEntry_put_CompressionLevel;
*get_CompressionMethod = *chilkatc::CkZipEntry_get_CompressionMethod;
*put_CompressionMethod = *chilkatc::CkZipEntry_put_CompressionMethod;
*get_Crc = *chilkatc::CkZipEntry_get_Crc;
*get_DebugLogFilePath = *chilkatc::CkZipEntry_get_DebugLogFilePath;
*debugLogFilePath = *chilkatc::CkZipEntry_debugLogFilePath;
*put_DebugLogFilePath = *chilkatc::CkZipEntry_put_DebugLogFilePath;
*get_EncryptionKeyLen = *chilkatc::CkZipEntry_get_EncryptionKeyLen;
*get_EntryID = *chilkatc::CkZipEntry_get_EntryID;
*get_EntryType = *chilkatc::CkZipEntry_get_EntryType;
*get_FileDateTimeStr = *chilkatc::CkZipEntry_get_FileDateTimeStr;
*fileDateTimeStr = *chilkatc::CkZipEntry_fileDateTimeStr;
*put_FileDateTimeStr = *chilkatc::CkZipEntry_put_FileDateTimeStr;
*get_FileName = *chilkatc::CkZipEntry_get_FileName;
*fileName = *chilkatc::CkZipEntry_fileName;
*put_FileName = *chilkatc::CkZipEntry_put_FileName;
*get_FileNameHex = *chilkatc::CkZipEntry_get_FileNameHex;
*fileNameHex = *chilkatc::CkZipEntry_fileNameHex;
*get_HeartbeatMs = *chilkatc::CkZipEntry_get_HeartbeatMs;
*put_HeartbeatMs = *chilkatc::CkZipEntry_put_HeartbeatMs;
*get_IsAesEncrypted = *chilkatc::CkZipEntry_get_IsAesEncrypted;
*get_IsDirectory = *chilkatc::CkZipEntry_get_IsDirectory;
*get_LastErrorHtml = *chilkatc::CkZipEntry_get_LastErrorHtml;
*lastErrorHtml = *chilkatc::CkZipEntry_lastErrorHtml;
*get_LastErrorText = *chilkatc::CkZipEntry_get_LastErrorText;
*lastErrorText = *chilkatc::CkZipEntry_lastErrorText;
*get_LastErrorXml = *chilkatc::CkZipEntry_get_LastErrorXml;
*lastErrorXml = *chilkatc::CkZipEntry_lastErrorXml;
*get_LastMethodSuccess = *chilkatc::CkZipEntry_get_LastMethodSuccess;
*put_LastMethodSuccess = *chilkatc::CkZipEntry_put_LastMethodSuccess;
*get_TextFlag = *chilkatc::CkZipEntry_get_TextFlag;
*put_TextFlag = *chilkatc::CkZipEntry_put_TextFlag;
*get_UncompressedLength = *chilkatc::CkZipEntry_get_UncompressedLength;
*get_UncompressedLength64 = *chilkatc::CkZipEntry_get_UncompressedLength64;
*get_UncompressedLengthStr = *chilkatc::CkZipEntry_get_UncompressedLengthStr;
*uncompressedLengthStr = *chilkatc::CkZipEntry_uncompressedLengthStr;
*get_VerboseLogging = *chilkatc::CkZipEntry_get_VerboseLogging;
*put_VerboseLogging = *chilkatc::CkZipEntry_put_VerboseLogging;
*get_Version = *chilkatc::CkZipEntry_get_Version;
*version = *chilkatc::CkZipEntry_version;
*AppendData = *chilkatc::CkZipEntry_AppendData;
*AppendDataAsync = *chilkatc::CkZipEntry_AppendDataAsync;
*AppendString = *chilkatc::CkZipEntry_AppendString;
*AppendStringAsync = *chilkatc::CkZipEntry_AppendStringAsync;
*Copy = *chilkatc::CkZipEntry_Copy;
*CopyToBase64 = *chilkatc::CkZipEntry_CopyToBase64;
*copyToBase64 = *chilkatc::CkZipEntry_copyToBase64;
*CopyToHex = *chilkatc::CkZipEntry_CopyToHex;
*copyToHex = *chilkatc::CkZipEntry_copyToHex;
*Extract = *chilkatc::CkZipEntry_Extract;
*ExtractAsync = *chilkatc::CkZipEntry_ExtractAsync;
*ExtractInto = *chilkatc::CkZipEntry_ExtractInto;
*ExtractIntoAsync = *chilkatc::CkZipEntry_ExtractIntoAsync;
*GetDt = *chilkatc::CkZipEntry_GetDt;
*GetNext = *chilkatc::CkZipEntry_GetNext;
*GetNextMatch = *chilkatc::CkZipEntry_GetNextMatch;
*Inflate = *chilkatc::CkZipEntry_Inflate;
*InflateAsync = *chilkatc::CkZipEntry_InflateAsync;
*LoadTaskCaller = *chilkatc::CkZipEntry_LoadTaskCaller;
*NextEntry = *chilkatc::CkZipEntry_NextEntry;
*NextMatchingEntry = *chilkatc::CkZipEntry_NextMatchingEntry;
*ReplaceData = *chilkatc::CkZipEntry_ReplaceData;
*ReplaceString = *chilkatc::CkZipEntry_ReplaceString;
*SetDt = *chilkatc::CkZipEntry_SetDt;
*UnzipToBd = *chilkatc::CkZipEntry_UnzipToBd;
*UnzipToBdAsync = *chilkatc::CkZipEntry_UnzipToBdAsync;
*UnzipToSb = *chilkatc::CkZipEntry_UnzipToSb;
*UnzipToSbAsync = *chilkatc::CkZipEntry_UnzipToSbAsync;
*UnzipToStream = *chilkatc::CkZipEntry_UnzipToStream;
*UnzipToStreamAsync = *chilkatc::CkZipEntry_UnzipToStreamAsync;
*UnzipToString = *chilkatc::CkZipEntry_UnzipToString;
*unzipToString = *chilkatc::CkZipEntry_unzipToString;
*UnzipToStringAsync = *chilkatc::CkZipEntry_UnzipToStringAsync;
sub DISOWN {
    my $self = shift;
    my $ptr = tied(%$self);
    delete $OWNER{$ptr};
}

sub ACQUIRE {
    my $self = shift;
    my $ptr = tied(%$self);
    $OWNER{$ptr} = 1;
}


# ------- VARIABLE STUBS --------

package chilkat;

*_ck_null_error_msg = *chilkatc::_ck_null_error_msg;
*_ck_arg_error_msg = *chilkatc::_ck_arg_error_msg;
*_ck_usage_error_msg = *chilkatc::_ck_usage_error_msg;
1;
