char* secureblackbox_ftpclient_getaccountinfo(void* lpObj);
int secureblackbox_ftpclient_setaccountinfo(void* lpObj, const char* lpszAccountInfo);

QString GetAccountInfo();
int SetAccountInfo(QString qsAccountInfo);

int secureblackbox_ftpclient_getadjustpasvaddress(void* lpObj);
int secureblackbox_ftpclient_setadjustpasvaddress(void* lpObj, int bAdjustPasvAddress);

bool GetAdjustPasvAddress();
int SetAdjustPasvAddress(bool bAdjustPasvAddress);

int secureblackbox_ftpclient_getblockedcertcount(void* lpObj);
int secureblackbox_ftpclient_setblockedcertcount(void* lpObj, int iBlockedCertCount);

int secureblackbox_ftpclient_getblockedcertbytes(void* lpObj, int blockedcertindex, char** lpBlockedCertBytes, int* lenBlockedCertBytes);

int64 secureblackbox_ftpclient_getblockedcerthandle(void* lpObj, int blockedcertindex);
int secureblackbox_ftpclient_setblockedcerthandle(void* lpObj, int blockedcertindex, int64 lBlockedCertHandle);

int GetBlockedCertCount();
int SetBlockedCertCount(int iBlockedCertCount);

QByteArray GetBlockedCertBytes(int iBlockedCertIndex);

qint64 GetBlockedCertHandle(int iBlockedCertIndex);
int SetBlockedCertHandle(int iBlockedCertIndex, qint64 lBlockedCertHandle);

int secureblackbox_ftpclient_getconflictresolutionmode(void* lpObj);
int secureblackbox_ftpclient_setconflictresolutionmode(void* lpObj, int iConflictResolutionMode);

int GetConflictResolutionMode();
int SetConflictResolutionMode(int iConflictResolutionMode);

int secureblackbox_ftpclient_getconnected(void* lpObj);

bool GetConnected();

char* secureblackbox_ftpclient_getcontrolchannellog(void* lpObj);

QString GetControlChannelLog();

int secureblackbox_ftpclient_getctlconninfoaeadcipher(void* lpObj);

int secureblackbox_ftpclient_getctlconninfochainvalidationdetails(void* lpObj);

int secureblackbox_ftpclient_getctlconninfochainvalidationresult(void* lpObj);

char* secureblackbox_ftpclient_getctlconninfociphersuite(void* lpObj);

int secureblackbox_ftpclient_getctlconninfoclientauthenticated(void* lpObj);

int secureblackbox_ftpclient_getctlconninfoclientauthrequested(void* lpObj);

int secureblackbox_ftpclient_getctlconninfoconnectionestablished(void* lpObj);

int secureblackbox_ftpclient_getctlconninfoconnectionid(void* lpObj, char** lpCtlConnInfoConnectionID, int* lenCtlConnInfoConnectionID);

char* secureblackbox_ftpclient_getctlconninfodigestalgorithm(void* lpObj);

char* secureblackbox_ftpclient_getctlconninfoencryptionalgorithm(void* lpObj);

int secureblackbox_ftpclient_getctlconninfoexportable(void* lpObj);

int64 secureblackbox_ftpclient_getctlconninfoid(void* lpObj);

char* secureblackbox_ftpclient_getctlconninfokeyexchangealgorithm(void* lpObj);

int secureblackbox_ftpclient_getctlconninfokeyexchangekeybits(void* lpObj);

char* secureblackbox_ftpclient_getctlconninfonamedeccurve(void* lpObj);

int secureblackbox_ftpclient_getctlconninfopfscipher(void* lpObj);

char* secureblackbox_ftpclient_getctlconninfopresharedidentity(void* lpObj);

char* secureblackbox_ftpclient_getctlconninfopresharedidentityhint(void* lpObj);

int secureblackbox_ftpclient_getctlconninfopublickeybits(void* lpObj);

char* secureblackbox_ftpclient_getctlconninforemoteaddress(void* lpObj);

int secureblackbox_ftpclient_getctlconninforemoteport(void* lpObj);

int secureblackbox_ftpclient_getctlconninforesumedsession(void* lpObj);

int secureblackbox_ftpclient_getctlconninfosecureconnection(void* lpObj);

int secureblackbox_ftpclient_getctlconninfoserverauthenticated(void* lpObj);

char* secureblackbox_ftpclient_getctlconninfosignaturealgorithm(void* lpObj);

int secureblackbox_ftpclient_getctlconninfosymmetricblocksize(void* lpObj);

int secureblackbox_ftpclient_getctlconninfosymmetrickeybits(void* lpObj);

int64 secureblackbox_ftpclient_getctlconninfototalbytesreceived(void* lpObj);

int64 secureblackbox_ftpclient_getctlconninfototalbytessent(void* lpObj);

char* secureblackbox_ftpclient_getctlconninfovalidationlog(void* lpObj);

char* secureblackbox_ftpclient_getctlconninfoversion(void* lpObj);

bool GetCtlConnInfoAEADCipher();

int GetCtlConnInfoChainValidationDetails();

int GetCtlConnInfoChainValidationResult();

QString GetCtlConnInfoCiphersuite();

bool GetCtlConnInfoClientAuthenticated();

bool GetCtlConnInfoClientAuthRequested();

bool GetCtlConnInfoConnectionEstablished();

QByteArray GetCtlConnInfoConnectionID();

QString GetCtlConnInfoDigestAlgorithm();

QString GetCtlConnInfoEncryptionAlgorithm();

bool GetCtlConnInfoExportable();

qint64 GetCtlConnInfoID();

QString GetCtlConnInfoKeyExchangeAlgorithm();

int GetCtlConnInfoKeyExchangeKeyBits();

QString GetCtlConnInfoNamedECCurve();

bool GetCtlConnInfoPFSCipher();

QString GetCtlConnInfoPreSharedIdentity();

QString GetCtlConnInfoPreSharedIdentityHint();

int GetCtlConnInfoPublicKeyBits();

QString GetCtlConnInfoRemoteAddress();

int GetCtlConnInfoRemotePort();

bool GetCtlConnInfoResumedSession();

bool GetCtlConnInfoSecureConnection();

bool GetCtlConnInfoServerAuthenticated();

QString GetCtlConnInfoSignatureAlgorithm();

int GetCtlConnInfoSymmetricBlockSize();

int GetCtlConnInfoSymmetricKeyBits();

qint64 GetCtlConnInfoTotalBytesReceived();

qint64 GetCtlConnInfoTotalBytesSent();

QString GetCtlConnInfoValidationLog();

QString GetCtlConnInfoVersion();

char* secureblackbox_ftpclient_getcurrlistentryaccesstime(void* lpObj);

char* secureblackbox_ftpclient_getcurrlistentrycreationtime(void* lpObj);

int secureblackbox_ftpclient_getcurrlistentryentryformat(void* lpObj);

int secureblackbox_ftpclient_getcurrlistentryfiletype(void* lpObj);

int64 secureblackbox_ftpclient_getcurrlistentryhandle(void* lpObj);

char* secureblackbox_ftpclient_getcurrlistentrymodificationtime(void* lpObj);

char* secureblackbox_ftpclient_getcurrlistentryname(void* lpObj);

char* secureblackbox_ftpclient_getcurrlistentrypath(void* lpObj);

char* secureblackbox_ftpclient_getcurrlistentryprincipal(void* lpObj);

int64 secureblackbox_ftpclient_getcurrlistentrysize(void* lpObj);

int secureblackbox_ftpclient_getcurrlistentryunixperms(void* lpObj);

char* secureblackbox_ftpclient_getcurrlistentryunparsedname(void* lpObj);

QString GetCurrListEntryAccessTime();

QString GetCurrListEntryCreationTime();

int GetCurrListEntryEntryFormat();

int GetCurrListEntryFileType();

qint64 GetCurrListEntryHandle();

QString GetCurrListEntryModificationTime();

QString GetCurrListEntryName();

QString GetCurrListEntryPath();

QString GetCurrListEntryPrincipal();

qint64 GetCurrListEntrySize();

int GetCurrListEntryUnixPerms();

QString GetCurrListEntryUnparsedName();

int secureblackbox_ftpclient_getdataconninfoaeadcipher(void* lpObj);

int secureblackbox_ftpclient_getdataconninfochainvalidationdetails(void* lpObj);

int secureblackbox_ftpclient_getdataconninfochainvalidationresult(void* lpObj);

char* secureblackbox_ftpclient_getdataconninfociphersuite(void* lpObj);

int secureblackbox_ftpclient_getdataconninfoclientauthenticated(void* lpObj);

int secureblackbox_ftpclient_getdataconninfoclientauthrequested(void* lpObj);

int secureblackbox_ftpclient_getdataconninfoconnectionestablished(void* lpObj);

int secureblackbox_ftpclient_getdataconninfoconnectionid(void* lpObj, char** lpDataConnInfoConnectionID, int* lenDataConnInfoConnectionID);

char* secureblackbox_ftpclient_getdataconninfodigestalgorithm(void* lpObj);

char* secureblackbox_ftpclient_getdataconninfoencryptionalgorithm(void* lpObj);

int secureblackbox_ftpclient_getdataconninfoexportable(void* lpObj);

int64 secureblackbox_ftpclient_getdataconninfoid(void* lpObj);

char* secureblackbox_ftpclient_getdataconninfokeyexchangealgorithm(void* lpObj);

int secureblackbox_ftpclient_getdataconninfokeyexchangekeybits(void* lpObj);

char* secureblackbox_ftpclient_getdataconninfonamedeccurve(void* lpObj);

int secureblackbox_ftpclient_getdataconninfopfscipher(void* lpObj);

char* secureblackbox_ftpclient_getdataconninfopresharedidentity(void* lpObj);

char* secureblackbox_ftpclient_getdataconninfopresharedidentityhint(void* lpObj);

int secureblackbox_ftpclient_getdataconninfopublickeybits(void* lpObj);

char* secureblackbox_ftpclient_getdataconninforemoteaddress(void* lpObj);

int secureblackbox_ftpclient_getdataconninforemoteport(void* lpObj);

int secureblackbox_ftpclient_getdataconninforesumedsession(void* lpObj);

int secureblackbox_ftpclient_getdataconninfosecureconnection(void* lpObj);

int secureblackbox_ftpclient_getdataconninfoserverauthenticated(void* lpObj);

char* secureblackbox_ftpclient_getdataconninfosignaturealgorithm(void* lpObj);

int secureblackbox_ftpclient_getdataconninfosymmetricblocksize(void* lpObj);

int secureblackbox_ftpclient_getdataconninfosymmetrickeybits(void* lpObj);

int64 secureblackbox_ftpclient_getdataconninfototalbytesreceived(void* lpObj);

int64 secureblackbox_ftpclient_getdataconninfototalbytessent(void* lpObj);

char* secureblackbox_ftpclient_getdataconninfovalidationlog(void* lpObj);

char* secureblackbox_ftpclient_getdataconninfoversion(void* lpObj);

bool GetDataConnInfoAEADCipher();

int GetDataConnInfoChainValidationDetails();

int GetDataConnInfoChainValidationResult();

QString GetDataConnInfoCiphersuite();

bool GetDataConnInfoClientAuthenticated();

bool GetDataConnInfoClientAuthRequested();

bool GetDataConnInfoConnectionEstablished();

QByteArray GetDataConnInfoConnectionID();

QString GetDataConnInfoDigestAlgorithm();

QString GetDataConnInfoEncryptionAlgorithm();

bool GetDataConnInfoExportable();

qint64 GetDataConnInfoID();

QString GetDataConnInfoKeyExchangeAlgorithm();

int GetDataConnInfoKeyExchangeKeyBits();

QString GetDataConnInfoNamedECCurve();

bool GetDataConnInfoPFSCipher();

QString GetDataConnInfoPreSharedIdentity();

QString GetDataConnInfoPreSharedIdentityHint();

int GetDataConnInfoPublicKeyBits();

QString GetDataConnInfoRemoteAddress();

int GetDataConnInfoRemotePort();

bool GetDataConnInfoResumedSession();

bool GetDataConnInfoSecureConnection();

bool GetDataConnInfoServerAuthenticated();

QString GetDataConnInfoSignatureAlgorithm();

int GetDataConnInfoSymmetricBlockSize();

int GetDataConnInfoSymmetricKeyBits();

qint64 GetDataConnInfoTotalBytesReceived();

qint64 GetDataConnInfoTotalBytesSent();

QString GetDataConnInfoValidationLog();

QString GetDataConnInfoVersion();

int secureblackbox_ftpclient_getencryptdatachannel(void* lpObj);
int secureblackbox_ftpclient_setencryptdatachannel(void* lpObj, int bEncryptDataChannel);

bool GetEncryptDataChannel();
int SetEncryptDataChannel(bool bEncryptDataChannel);

char* secureblackbox_ftpclient_getexternalcryptoasyncdocumentid(void* lpObj);
int secureblackbox_ftpclient_setexternalcryptoasyncdocumentid(void* lpObj, const char* lpszExternalCryptoAsyncDocumentID);

char* secureblackbox_ftpclient_getexternalcryptocustomparams(void* lpObj);
int secureblackbox_ftpclient_setexternalcryptocustomparams(void* lpObj, const char* lpszExternalCryptoCustomParams);

char* secureblackbox_ftpclient_getexternalcryptodata(void* lpObj);
int secureblackbox_ftpclient_setexternalcryptodata(void* lpObj, const char* lpszExternalCryptoData);

int secureblackbox_ftpclient_getexternalcryptoexternalhashcalculation(void* lpObj);
int secureblackbox_ftpclient_setexternalcryptoexternalhashcalculation(void* lpObj, int bExternalCryptoExternalHashCalculation);

char* secureblackbox_ftpclient_getexternalcryptohashalgorithm(void* lpObj);
int secureblackbox_ftpclient_setexternalcryptohashalgorithm(void* lpObj, const char* lpszExternalCryptoHashAlgorithm);

char* secureblackbox_ftpclient_getexternalcryptokeyid(void* lpObj);
int secureblackbox_ftpclient_setexternalcryptokeyid(void* lpObj, const char* lpszExternalCryptoKeyID);

char* secureblackbox_ftpclient_getexternalcryptokeysecret(void* lpObj);
int secureblackbox_ftpclient_setexternalcryptokeysecret(void* lpObj, const char* lpszExternalCryptoKeySecret);

int secureblackbox_ftpclient_getexternalcryptomethod(void* lpObj);
int secureblackbox_ftpclient_setexternalcryptomethod(void* lpObj, int iExternalCryptoMethod);

int secureblackbox_ftpclient_getexternalcryptomode(void* lpObj);
int secureblackbox_ftpclient_setexternalcryptomode(void* lpObj, int iExternalCryptoMode);

char* secureblackbox_ftpclient_getexternalcryptopublickeyalgorithm(void* lpObj);
int secureblackbox_ftpclient_setexternalcryptopublickeyalgorithm(void* lpObj, const char* lpszExternalCryptoPublicKeyAlgorithm);

QString GetExternalCryptoAsyncDocumentID();
int SetExternalCryptoAsyncDocumentID(QString qsExternalCryptoAsyncDocumentID);

QString GetExternalCryptoCustomParams();
int SetExternalCryptoCustomParams(QString qsExternalCryptoCustomParams);

QString GetExternalCryptoData();
int SetExternalCryptoData(QString qsExternalCryptoData);

bool GetExternalCryptoExternalHashCalculation();
int SetExternalCryptoExternalHashCalculation(bool bExternalCryptoExternalHashCalculation);

QString GetExternalCryptoHashAlgorithm();
int SetExternalCryptoHashAlgorithm(QString qsExternalCryptoHashAlgorithm);

QString GetExternalCryptoKeyID();
int SetExternalCryptoKeyID(QString qsExternalCryptoKeyID);

QString GetExternalCryptoKeySecret();
int SetExternalCryptoKeySecret(QString qsExternalCryptoKeySecret);

int GetExternalCryptoMethod();
int SetExternalCryptoMethod(int iExternalCryptoMethod);

int GetExternalCryptoMode();
int SetExternalCryptoMode(int iExternalCryptoMode);

QString GetExternalCryptoPublicKeyAlgorithm();
int SetExternalCryptoPublicKeyAlgorithm(QString qsExternalCryptoPublicKeyAlgorithm);

int secureblackbox_ftpclient_getfipsmode(void* lpObj);
int secureblackbox_ftpclient_setfipsmode(void* lpObj, int bFIPSMode);

bool GetFIPSMode();
int SetFIPSMode(bool bFIPSMode);

int secureblackbox_ftpclient_getknowncertcount(void* lpObj);
int secureblackbox_ftpclient_setknowncertcount(void* lpObj, int iKnownCertCount);

int secureblackbox_ftpclient_getknowncertbytes(void* lpObj, int knowncertindex, char** lpKnownCertBytes, int* lenKnownCertBytes);

int64 secureblackbox_ftpclient_getknowncerthandle(void* lpObj, int knowncertindex);
int secureblackbox_ftpclient_setknowncerthandle(void* lpObj, int knowncertindex, int64 lKnownCertHandle);

int GetKnownCertCount();
int SetKnownCertCount(int iKnownCertCount);

QByteArray GetKnownCertBytes(int iKnownCertIndex);

qint64 GetKnownCertHandle(int iKnownCertIndex);
int SetKnownCertHandle(int iKnownCertIndex, qint64 lKnownCertHandle);

int secureblackbox_ftpclient_getknowncrlcount(void* lpObj);
int secureblackbox_ftpclient_setknowncrlcount(void* lpObj, int iKnownCRLCount);

int secureblackbox_ftpclient_getknowncrlbytes(void* lpObj, int knowncrlindex, char** lpKnownCRLBytes, int* lenKnownCRLBytes);

int64 secureblackbox_ftpclient_getknowncrlhandle(void* lpObj, int knowncrlindex);
int secureblackbox_ftpclient_setknowncrlhandle(void* lpObj, int knowncrlindex, int64 lKnownCRLHandle);

int GetKnownCRLCount();
int SetKnownCRLCount(int iKnownCRLCount);

QByteArray GetKnownCRLBytes(int iKnownCRLIndex);

qint64 GetKnownCRLHandle(int iKnownCRLIndex);
int SetKnownCRLHandle(int iKnownCRLIndex, qint64 lKnownCRLHandle);

int secureblackbox_ftpclient_getknownocspcount(void* lpObj);
int secureblackbox_ftpclient_setknownocspcount(void* lpObj, int iKnownOCSPCount);

int secureblackbox_ftpclient_getknownocspbytes(void* lpObj, int knownocspindex, char** lpKnownOCSPBytes, int* lenKnownOCSPBytes);

int64 secureblackbox_ftpclient_getknownocsphandle(void* lpObj, int knownocspindex);
int secureblackbox_ftpclient_setknownocsphandle(void* lpObj, int knownocspindex, int64 lKnownOCSPHandle);

int GetKnownOCSPCount();
int SetKnownOCSPCount(int iKnownOCSPCount);

QByteArray GetKnownOCSPBytes(int iKnownOCSPIndex);

qint64 GetKnownOCSPHandle(int iKnownOCSPIndex);
int SetKnownOCSPHandle(int iKnownOCSPIndex, qint64 lKnownOCSPHandle);

int secureblackbox_ftpclient_getmodez(void* lpObj);
int secureblackbox_ftpclient_setmodez(void* lpObj, int bModeZ);

bool GetModeZ();
int SetModeZ(bool bModeZ);

int secureblackbox_ftpclient_getpassivemode(void* lpObj);
int secureblackbox_ftpclient_setpassivemode(void* lpObj, int bPassiveMode);

bool GetPassiveMode();
int SetPassiveMode(bool bPassiveMode);

char* secureblackbox_ftpclient_getpassword(void* lpObj);
int secureblackbox_ftpclient_setpassword(void* lpObj, const char* lpszPassword);

QString GetPassword();
int SetPassword(QString qsPassword);

char* secureblackbox_ftpclient_getproxyaddress(void* lpObj);
int secureblackbox_ftpclient_setproxyaddress(void* lpObj, const char* lpszProxyAddress);

int secureblackbox_ftpclient_getproxyauthentication(void* lpObj);
int secureblackbox_ftpclient_setproxyauthentication(void* lpObj, int iProxyAuthentication);

char* secureblackbox_ftpclient_getproxypassword(void* lpObj);
int secureblackbox_ftpclient_setproxypassword(void* lpObj, const char* lpszProxyPassword);

int secureblackbox_ftpclient_getproxyport(void* lpObj);
int secureblackbox_ftpclient_setproxyport(void* lpObj, int iProxyPort);

int secureblackbox_ftpclient_getproxyproxytype(void* lpObj);
int secureblackbox_ftpclient_setproxyproxytype(void* lpObj, int iProxyProxyType);

char* secureblackbox_ftpclient_getproxyrequestheaders(void* lpObj);
int secureblackbox_ftpclient_setproxyrequestheaders(void* lpObj, const char* lpszProxyRequestHeaders);

char* secureblackbox_ftpclient_getproxyresponsebody(void* lpObj);
int secureblackbox_ftpclient_setproxyresponsebody(void* lpObj, const char* lpszProxyResponseBody);

char* secureblackbox_ftpclient_getproxyresponseheaders(void* lpObj);
int secureblackbox_ftpclient_setproxyresponseheaders(void* lpObj, const char* lpszProxyResponseHeaders);

int secureblackbox_ftpclient_getproxyuseipv6(void* lpObj);
int secureblackbox_ftpclient_setproxyuseipv6(void* lpObj, int bProxyUseIPv6);

char* secureblackbox_ftpclient_getproxyusername(void* lpObj);
int secureblackbox_ftpclient_setproxyusername(void* lpObj, const char* lpszProxyUsername);

QString GetProxyAddress();
int SetProxyAddress(QString qsProxyAddress);

int GetProxyAuthentication();
int SetProxyAuthentication(int iProxyAuthentication);

QString GetProxyPassword();
int SetProxyPassword(QString qsProxyPassword);

int GetProxyPort();
int SetProxyPort(int iProxyPort);

int GetProxyProxyType();
int SetProxyProxyType(int iProxyProxyType);

QString GetProxyRequestHeaders();
int SetProxyRequestHeaders(QString qsProxyRequestHeaders);

QString GetProxyResponseBody();
int SetProxyResponseBody(QString qsProxyResponseBody);

QString GetProxyResponseHeaders();
int SetProxyResponseHeaders(QString qsProxyResponseHeaders);

bool GetProxyUseIPv6();
int SetProxyUseIPv6(bool bProxyUseIPv6);

QString GetProxyUsername();
int SetProxyUsername(QString qsProxyUsername);

int64 secureblackbox_ftpclient_getrestartat(void* lpObj);
int secureblackbox_ftpclient_setrestartat(void* lpObj, int64 lRestartAt);

qint64 GetRestartAt();
int SetRestartAt(qint64 lRestartAt);

int secureblackbox_ftpclient_getsocketdnsmode(void* lpObj);
int secureblackbox_ftpclient_setsocketdnsmode(void* lpObj, int iSocketDNSMode);

int secureblackbox_ftpclient_getsocketdnsport(void* lpObj);
int secureblackbox_ftpclient_setsocketdnsport(void* lpObj, int iSocketDNSPort);

int secureblackbox_ftpclient_getsocketdnsquerytimeout(void* lpObj);
int secureblackbox_ftpclient_setsocketdnsquerytimeout(void* lpObj, int iSocketDNSQueryTimeout);

char* secureblackbox_ftpclient_getsocketdnsservers(void* lpObj);
int secureblackbox_ftpclient_setsocketdnsservers(void* lpObj, const char* lpszSocketDNSServers);

int secureblackbox_ftpclient_getsocketdnstotaltimeout(void* lpObj);
int secureblackbox_ftpclient_setsocketdnstotaltimeout(void* lpObj, int iSocketDNSTotalTimeout);

int secureblackbox_ftpclient_getsocketincomingspeedlimit(void* lpObj);
int secureblackbox_ftpclient_setsocketincomingspeedlimit(void* lpObj, int iSocketIncomingSpeedLimit);

char* secureblackbox_ftpclient_getsocketlocaladdress(void* lpObj);
int secureblackbox_ftpclient_setsocketlocaladdress(void* lpObj, const char* lpszSocketLocalAddress);

int secureblackbox_ftpclient_getsocketlocalport(void* lpObj);
int secureblackbox_ftpclient_setsocketlocalport(void* lpObj, int iSocketLocalPort);

int secureblackbox_ftpclient_getsocketoutgoingspeedlimit(void* lpObj);
int secureblackbox_ftpclient_setsocketoutgoingspeedlimit(void* lpObj, int iSocketOutgoingSpeedLimit);

int secureblackbox_ftpclient_getsockettimeout(void* lpObj);
int secureblackbox_ftpclient_setsockettimeout(void* lpObj, int iSocketTimeout);

int secureblackbox_ftpclient_getsocketuseipv6(void* lpObj);
int secureblackbox_ftpclient_setsocketuseipv6(void* lpObj, int bSocketUseIPv6);

int GetSocketDNSMode();
int SetSocketDNSMode(int iSocketDNSMode);

int GetSocketDNSPort();
int SetSocketDNSPort(int iSocketDNSPort);

int GetSocketDNSQueryTimeout();
int SetSocketDNSQueryTimeout(int iSocketDNSQueryTimeout);

QString GetSocketDNSServers();
int SetSocketDNSServers(QString qsSocketDNSServers);

int GetSocketDNSTotalTimeout();
int SetSocketDNSTotalTimeout(int iSocketDNSTotalTimeout);

int GetSocketIncomingSpeedLimit();
int SetSocketIncomingSpeedLimit(int iSocketIncomingSpeedLimit);

QString GetSocketLocalAddress();
int SetSocketLocalAddress(QString qsSocketLocalAddress);

int GetSocketLocalPort();
int SetSocketLocalPort(int iSocketLocalPort);

int GetSocketOutgoingSpeedLimit();
int SetSocketOutgoingSpeedLimit(int iSocketOutgoingSpeedLimit);

int GetSocketTimeout();
int SetSocketTimeout(int iSocketTimeout);

bool GetSocketUseIPv6();
int SetSocketUseIPv6(bool bSocketUseIPv6);

int secureblackbox_ftpclient_gettlsclientcertcount(void* lpObj);
int secureblackbox_ftpclient_settlsclientcertcount(void* lpObj, int iTLSClientCertCount);

int secureblackbox_ftpclient_gettlsclientcertbytes(void* lpObj, int tlsclientcertindex, char** lpTLSClientCertBytes, int* lenTLSClientCertBytes);

int64 secureblackbox_ftpclient_gettlsclientcerthandle(void* lpObj, int tlsclientcertindex);
int secureblackbox_ftpclient_settlsclientcerthandle(void* lpObj, int tlsclientcertindex, int64 lTLSClientCertHandle);

int GetTLSClientCertCount();
int SetTLSClientCertCount(int iTLSClientCertCount);

QByteArray GetTLSClientCertBytes(int iTLSClientCertIndex);

qint64 GetTLSClientCertHandle(int iTLSClientCertIndex);
int SetTLSClientCertHandle(int iTLSClientCertIndex, qint64 lTLSClientCertHandle);

int secureblackbox_ftpclient_gettlsservercertcount(void* lpObj);

int secureblackbox_ftpclient_gettlsservercertbytes(void* lpObj, int tlsservercertindex, char** lpTLSServerCertBytes, int* lenTLSServerCertBytes);

char* secureblackbox_ftpclient_gettlsservercertfingerprint(void* lpObj, int tlsservercertindex);

int64 secureblackbox_ftpclient_gettlsservercerthandle(void* lpObj, int tlsservercertindex);

char* secureblackbox_ftpclient_gettlsservercertissuer(void* lpObj, int tlsservercertindex);

char* secureblackbox_ftpclient_gettlsservercertissuerrdn(void* lpObj, int tlsservercertindex);

char* secureblackbox_ftpclient_gettlsservercertkeyalgorithm(void* lpObj, int tlsservercertindex);

int secureblackbox_ftpclient_gettlsservercertkeybits(void* lpObj, int tlsservercertindex);

int secureblackbox_ftpclient_gettlsservercertkeyusage(void* lpObj, int tlsservercertindex);

int secureblackbox_ftpclient_gettlsservercertselfsigned(void* lpObj, int tlsservercertindex);

int secureblackbox_ftpclient_gettlsservercertserialnumber(void* lpObj, int tlsservercertindex, char** lpTLSServerCertSerialNumber, int* lenTLSServerCertSerialNumber);

char* secureblackbox_ftpclient_gettlsservercertsigalgorithm(void* lpObj, int tlsservercertindex);

char* secureblackbox_ftpclient_gettlsservercertsubject(void* lpObj, int tlsservercertindex);

char* secureblackbox_ftpclient_gettlsservercertsubjectrdn(void* lpObj, int tlsservercertindex);

char* secureblackbox_ftpclient_gettlsservercertvalidfrom(void* lpObj, int tlsservercertindex);

char* secureblackbox_ftpclient_gettlsservercertvalidto(void* lpObj, int tlsservercertindex);

int GetTLSServerCertCount();

QByteArray GetTLSServerCertBytes(int iTLSServerCertIndex);

QString GetTLSServerCertFingerprint(int iTLSServerCertIndex);

qint64 GetTLSServerCertHandle(int iTLSServerCertIndex);

QString GetTLSServerCertIssuer(int iTLSServerCertIndex);

QString GetTLSServerCertIssuerRDN(int iTLSServerCertIndex);

QString GetTLSServerCertKeyAlgorithm(int iTLSServerCertIndex);

int GetTLSServerCertKeyBits(int iTLSServerCertIndex);

int GetTLSServerCertKeyUsage(int iTLSServerCertIndex);

bool GetTLSServerCertSelfSigned(int iTLSServerCertIndex);

QByteArray GetTLSServerCertSerialNumber(int iTLSServerCertIndex);

QString GetTLSServerCertSigAlgorithm(int iTLSServerCertIndex);

QString GetTLSServerCertSubject(int iTLSServerCertIndex);

QString GetTLSServerCertSubjectRDN(int iTLSServerCertIndex);

QString GetTLSServerCertValidFrom(int iTLSServerCertIndex);

QString GetTLSServerCertValidTo(int iTLSServerCertIndex);

int secureblackbox_ftpclient_gettlsautovalidatecertificates(void* lpObj);
int secureblackbox_ftpclient_settlsautovalidatecertificates(void* lpObj, int bTLSAutoValidateCertificates);

int secureblackbox_ftpclient_gettlsbaseconfiguration(void* lpObj);
int secureblackbox_ftpclient_settlsbaseconfiguration(void* lpObj, int iTLSBaseConfiguration);

char* secureblackbox_ftpclient_gettlsciphersuites(void* lpObj);
int secureblackbox_ftpclient_settlsciphersuites(void* lpObj, const char* lpszTLSCiphersuites);

int secureblackbox_ftpclient_gettlsclientauth(void* lpObj);
int secureblackbox_ftpclient_settlsclientauth(void* lpObj, int iTLSClientAuth);

char* secureblackbox_ftpclient_gettlseccurves(void* lpObj);
int secureblackbox_ftpclient_settlseccurves(void* lpObj, const char* lpszTLSECCurves);

char* secureblackbox_ftpclient_gettlsextensions(void* lpObj);
int secureblackbox_ftpclient_settlsextensions(void* lpObj, const char* lpszTLSExtensions);

int secureblackbox_ftpclient_gettlsforceresumeifdestinationchanges(void* lpObj);
int secureblackbox_ftpclient_settlsforceresumeifdestinationchanges(void* lpObj, int bTLSForceResumeIfDestinationChanges);

char* secureblackbox_ftpclient_gettlspresharedidentity(void* lpObj);
int secureblackbox_ftpclient_settlspresharedidentity(void* lpObj, const char* lpszTLSPreSharedIdentity);

char* secureblackbox_ftpclient_gettlspresharedkey(void* lpObj);
int secureblackbox_ftpclient_settlspresharedkey(void* lpObj, const char* lpszTLSPreSharedKey);

char* secureblackbox_ftpclient_gettlspresharedkeyciphersuite(void* lpObj);
int secureblackbox_ftpclient_settlspresharedkeyciphersuite(void* lpObj, const char* lpszTLSPreSharedKeyCiphersuite);

int secureblackbox_ftpclient_gettlsrenegotiationattackpreventionmode(void* lpObj);
int secureblackbox_ftpclient_settlsrenegotiationattackpreventionmode(void* lpObj, int iTLSRenegotiationAttackPreventionMode);

int secureblackbox_ftpclient_gettlsrevocationcheck(void* lpObj);
int secureblackbox_ftpclient_settlsrevocationcheck(void* lpObj, int iTLSRevocationCheck);

int secureblackbox_ftpclient_gettlsssloptions(void* lpObj);
int secureblackbox_ftpclient_settlsssloptions(void* lpObj, int iTLSSSLOptions);

int secureblackbox_ftpclient_gettlstlsmode(void* lpObj);
int secureblackbox_ftpclient_settlstlsmode(void* lpObj, int iTLSTLSMode);

int secureblackbox_ftpclient_gettlsuseextendedmastersecret(void* lpObj);
int secureblackbox_ftpclient_settlsuseextendedmastersecret(void* lpObj, int bTLSUseExtendedMasterSecret);

int secureblackbox_ftpclient_gettlsusesessionresumption(void* lpObj);
int secureblackbox_ftpclient_settlsusesessionresumption(void* lpObj, int bTLSUseSessionResumption);

int secureblackbox_ftpclient_gettlsversions(void* lpObj);
int secureblackbox_ftpclient_settlsversions(void* lpObj, int iTLSVersions);

bool GetTLSAutoValidateCertificates();
int SetTLSAutoValidateCertificates(bool bTLSAutoValidateCertificates);

int GetTLSBaseConfiguration();
int SetTLSBaseConfiguration(int iTLSBaseConfiguration);

QString GetTLSCiphersuites();
int SetTLSCiphersuites(QString qsTLSCiphersuites);

int GetTLSClientAuth();
int SetTLSClientAuth(int iTLSClientAuth);

QString GetTLSECCurves();
int SetTLSECCurves(QString qsTLSECCurves);

QString GetTLSExtensions();
int SetTLSExtensions(QString qsTLSExtensions);

bool GetTLSForceResumeIfDestinationChanges();
int SetTLSForceResumeIfDestinationChanges(bool bTLSForceResumeIfDestinationChanges);

QString GetTLSPreSharedIdentity();
int SetTLSPreSharedIdentity(QString qsTLSPreSharedIdentity);

QString GetTLSPreSharedKey();
int SetTLSPreSharedKey(QString qsTLSPreSharedKey);

QString GetTLSPreSharedKeyCiphersuite();
int SetTLSPreSharedKeyCiphersuite(QString qsTLSPreSharedKeyCiphersuite);

int GetTLSRenegotiationAttackPreventionMode();
int SetTLSRenegotiationAttackPreventionMode(int iTLSRenegotiationAttackPreventionMode);

int GetTLSRevocationCheck();
int SetTLSRevocationCheck(int iTLSRevocationCheck);

int GetTLSSSLOptions();
int SetTLSSSLOptions(int iTLSSSLOptions);

int GetTLSTLSMode();
int SetTLSTLSMode(int iTLSTLSMode);

bool GetTLSUseExtendedMasterSecret();
int SetTLSUseExtendedMasterSecret(bool bTLSUseExtendedMasterSecret);

bool GetTLSUseSessionResumption();
int SetTLSUseSessionResumption(bool bTLSUseSessionResumption);

int GetTLSVersions();
int SetTLSVersions(int iTLSVersions);

int secureblackbox_ftpclient_gettransfertype(void* lpObj);
int secureblackbox_ftpclient_settransfertype(void* lpObj, int iTransferType);

int GetTransferType();
int SetTransferType(int iTransferType);

int secureblackbox_ftpclient_gettrustedcertcount(void* lpObj);
int secureblackbox_ftpclient_settrustedcertcount(void* lpObj, int iTrustedCertCount);

int secureblackbox_ftpclient_gettrustedcertbytes(void* lpObj, int trustedcertindex, char** lpTrustedCertBytes, int* lenTrustedCertBytes);

int64 secureblackbox_ftpclient_gettrustedcerthandle(void* lpObj, int trustedcertindex);
int secureblackbox_ftpclient_settrustedcerthandle(void* lpObj, int trustedcertindex, int64 lTrustedCertHandle);

int GetTrustedCertCount();
int SetTrustedCertCount(int iTrustedCertCount);

QByteArray GetTrustedCertBytes(int iTrustedCertIndex);

qint64 GetTrustedCertHandle(int iTrustedCertIndex);
int SetTrustedCertHandle(int iTrustedCertIndex, qint64 lTrustedCertHandle);

char* secureblackbox_ftpclient_getusername(void* lpObj);
int secureblackbox_ftpclient_setusername(void* lpObj, const char* lpszUsername);

QString GetUsername();
int SetUsername(QString qsUsername);

int secureblackbox_ftpclient_abort(void* lpObj);

int Abort();

int secureblackbox_ftpclient_acct(void* lpObj, const char* lpszAcctInfo);

int Acct(const QString& qsAcctInfo);

int secureblackbox_ftpclient_appendbytes(void* lpObj, const char* lpBytes, int lenBytes, const char* lpszRemoteFile);

int AppendBytes(QByteArray qbaBytes, const QString& qsRemoteFile);

int secureblackbox_ftpclient_appendfile(void* lpObj, const char* lpszLocalFile, const char* lpszRemoteFile);

int AppendFile(const QString& qsLocalFile, const QString& qsRemoteFile);

int secureblackbox_ftpclient_appendstream(void* lpObj, SecureBlackboxStream* sLocalStream, const char* lpszRemoteFile);

int AppendStream(SecureBlackboxStream* sLocalStream, const QString& qsRemoteFile);

int secureblackbox_ftpclient_changedir(void* lpObj, const char* lpszRemoteDir);

int ChangeDir(const QString& qsRemoteDir);

int secureblackbox_ftpclient_clearcommandchannel(void* lpObj, int bGracefulSSLClosure);

int ClearCommandChannel(bool bGracefulSSLClosure);

char* secureblackbox_ftpclient_config(void* lpObj, const char* lpszConfigurationString);

QString Config(const QString& qsConfigurationString);

int secureblackbox_ftpclient_connect(void* lpObj, const char* lpszAddress, int iPort);

int Connect(const QString& qsAddress, int iPort);

int secureblackbox_ftpclient_deletedir(void* lpObj, const char* lpszRemoteDir);

int DeleteDir(const QString& qsRemoteDir);

int secureblackbox_ftpclient_deletefile(void* lpObj, const char* lpszRemoteFile);

int DeleteFile(const QString& qsRemoteFile);

bool secureblackbox_ftpclient_direxists(void* lpObj, const char* lpszRemoteDir);

bool DirExists(const QString& qsRemoteDir);

int secureblackbox_ftpclient_disconnect(void* lpObj);

int Disconnect();

char* secureblackbox_ftpclient_doaction(void* lpObj, const char* lpszActionID, const char* lpszActionParams);

QString DoAction(const QString& qsActionID, const QString& qsActionParams);

char* secureblackbox_ftpclient_downloadbytes(void* lpObj, const char* lpszRemoteFile, int *lpSize);

QByteArray DownloadBytes(const QString& qsRemoteFile);

int secureblackbox_ftpclient_downloadfile(void* lpObj, const char* lpszRemoteFile, const char* lpszLocalFile);

int DownloadFile(const QString& qsRemoteFile, const QString& qsLocalFile);

int secureblackbox_ftpclient_downloadfiles(void* lpObj, const char* lpszRemotePath, const char* lpszLocalDir, int bRecursive, int iErrorHandling);

int DownloadFiles(const QString& qsRemotePath, const QString& qsLocalDir, bool bRecursive, int iErrorHandling);

int secureblackbox_ftpclient_downloadstream(void* lpObj, const char* lpszRemoteFile, SecureBlackboxStream* sLocalStream);

int DownloadStream(const QString& qsRemoteFile, SecureBlackboxStream* sLocalStream);

bool secureblackbox_ftpclient_fileexists(void* lpObj, const char* lpszRemoteFile);

bool FileExists(const QString& qsRemoteFile);

char* secureblackbox_ftpclient_getcurrentdir(void* lpObj);

QString GetCurrentDir();

int64 secureblackbox_ftpclient_getfilesize(void* lpObj, const char* lpszRemoteFile);

qint64 GetFileSize(const QString& qsRemoteFile);

char* secureblackbox_ftpclient_listdir(void* lpObj, int bIncludeFiles, int bIncludeDirectories);

QString ListDir(bool bIncludeFiles, bool bIncludeDirectories);

int secureblackbox_ftpclient_makedir(void* lpObj, const char* lpszRemoteDir);

int MakeDir(const QString& qsRemoteDir);

int secureblackbox_ftpclient_noop(void* lpObj);

int Noop();

int secureblackbox_ftpclient_rename(void* lpObj, const char* lpszSourceFile, const char* lpszDestFile);

int Rename(const QString& qsSourceFile, const QString& qsDestFile);

int secureblackbox_ftpclient_reset(void* lpObj);

int Reset();

int secureblackbox_ftpclient_sendcommand(void* lpObj, const char* lpszCommand);

int SendCommand(const QString& qsCommand);

int secureblackbox_ftpclient_uploadbytes(void* lpObj, const char* lpBytes, int lenBytes, const char* lpszRemoteFile);

int UploadBytes(QByteArray qbaBytes, const QString& qsRemoteFile);

int secureblackbox_ftpclient_uploadfile(void* lpObj, const char* lpszLocalFile, const char* lpszRemoteFile);

int UploadFile(const QString& qsLocalFile, const QString& qsRemoteFile);

int secureblackbox_ftpclient_uploadfiles(void* lpObj, const char* lpszLocalPath, const char* lpszRemoteDir, int bRecursive, int iErrorHandling);

int UploadFiles(const QString& qsLocalPath, const QString& qsRemoteDir, bool bRecursive, int iErrorHandling);

int secureblackbox_ftpclient_uploadstream(void* lpObj, SecureBlackboxStream* sLocalStream, const char* lpszRemoteFile);

int UploadStream(SecureBlackboxStream* sLocalStream, const QString& qsRemoteFile);

#define EID_FTPCLIENT_CONTROLRECEIVE 1

virtual INT SECUREBLACKBOX_CALL FireControlReceive(LPSTR &lpszTextLine);

class FTPClientControlReceiveEventParams {
public:
  const QString &TextLine();

  int EventRetVal();
  void SetEventRetVal(int iRetVal);
};

// To handle, connect one or more slots to this signal.
void ControlReceive(FTPClientControlReceiveEventParams *e);

// Or, subclass FTPClient and override this emitter function.
virtual int FireControlReceive(FTPClientControlReceiveEventParams *e) {...}

#define EID_FTPCLIENT_CONTROLSEND 2

virtual INT SECUREBLACKBOX_CALL FireControlSend(LPSTR &lpszTextLine);

class FTPClientControlSendEventParams {
public:
  const QString &TextLine();

  int EventRetVal();
  void SetEventRetVal(int iRetVal);
};

// To handle, connect one or more slots to this signal.
void ControlSend(FTPClientControlSendEventParams *e);

// Or, subclass FTPClient and override this emitter function.
virtual int FireControlSend(FTPClientControlSendEventParams *e) {...}

#define EID_FTPCLIENT_ERROR 3

virtual INT SECUREBLACKBOX_CALL FireError(INT &iErrorCode, LPSTR &lpszDescription);

class FTPClientErrorEventParams {
public:
  int ErrorCode();

  const QString &Description();

  int EventRetVal();
  void SetEventRetVal(int iRetVal);
};

// To handle, connect one or more slots to this signal.
void Error(FTPClientErrorEventParams *e);

// Or, subclass FTPClient and override this emitter function.
virtual int FireError(FTPClientErrorEventParams *e) {...}

#define EID_FTPCLIENT_EXTERNALSIGN 4

virtual INT SECUREBLACKBOX_CALL FireExternalSign(LPSTR &lpszOperationId, LPSTR &lpszHashAlgorithm, LPSTR &lpszPars, LPSTR &lpszData, LPSTR &lpszSignedData);

class FTPClientExternalSignEventParams {
public:
  const QString &OperationId();

  const QString &HashAlgorithm();

  const QString &Pars();

  const QString &Data();

  const QString &SignedData();
  void SetSignedData(const QString &qsSignedData);

  int EventRetVal();
  void SetEventRetVal(int iRetVal);
};

// To handle, connect one or more slots to this signal.
void ExternalSign(FTPClientExternalSignEventParams *e);

// Or, subclass FTPClient and override this emitter function.
virtual int FireExternalSign(FTPClientExternalSignEventParams *e) {...}

#define EID_FTPCLIENT_FILENAMECHANGENEEDED 5

virtual INT SECUREBLACKBOX_CALL FireFileNameChangeNeeded(LPSTR &lpszFileName, BOOL &bForce);

class FTPClientFileNameChangeNeededEventParams {
public:
  const QString &FileName();
  void SetFileName(const QString &qsFileName);

  bool Force();
  void SetForce(bool bForce);

  int EventRetVal();
  void SetEventRetVal(int iRetVal);
};

// To handle, connect one or more slots to this signal.
void FileNameChangeNeeded(FTPClientFileNameChangeNeededEventParams *e);

// Or, subclass FTPClient and override this emitter function.
virtual int FireFileNameChangeNeeded(FTPClientFileNameChangeNeededEventParams *e) {...}

#define EID_FTPCLIENT_FILEOPERATION 6

virtual INT SECUREBLACKBOX_CALL FireFileOperation(INT &iOperation, LPSTR &lpszRemotePath, LPSTR &lpszLocalPath, BOOL &bSkip, BOOL &bCancel);

class FTPClientFileOperationEventParams {
public:
  int Operation();

  const QString &RemotePath();

  const QString &LocalPath();

  bool Skip();
  void SetSkip(bool bSkip);

  bool Cancel();
  void SetCancel(bool bCancel);

  int EventRetVal();
  void SetEventRetVal(int iRetVal);
};

// To handle, connect one or more slots to this signal.
void FileOperation(FTPClientFileOperationEventParams *e);

// Or, subclass FTPClient and override this emitter function.
virtual int FireFileOperation(FTPClientFileOperationEventParams *e) {...}

#define EID_FTPCLIENT_FILEOPERATIONRESULT 7

virtual INT SECUREBLACKBOX_CALL FireFileOperationResult(INT &iOperation, LPSTR &lpszRemotePath, LPSTR &lpszLocalPath, INT &iErrorCode, LPSTR &lpszComment, BOOL &bCancel);

class FTPClientFileOperationResultEventParams {
public:
  int Operation();

  const QString &RemotePath();

  const QString &LocalPath();

  int ErrorCode();

  const QString &Comment();

  bool Cancel();
  void SetCancel(bool bCancel);

  int EventRetVal();
  void SetEventRetVal(int iRetVal);
};

// To handle, connect one or more slots to this signal.
void FileOperationResult(FTPClientFileOperationResultEventParams *e);

// Or, subclass FTPClient and override this emitter function.
virtual int FireFileOperationResult(FTPClientFileOperationResultEventParams *e) {...}

#define EID_FTPCLIENT_LISTENTRY 8

virtual INT SECUREBLACKBOX_CALL FireListEntry(LPSTR &lpszFileName);

class FTPClientListEntryEventParams {
public:
  const QString &FileName();

  int EventRetVal();
  void SetEventRetVal(int iRetVal);
};

// To handle, connect one or more slots to this signal.
void ListEntry(FTPClientListEntryEventParams *e);

// Or, subclass FTPClient and override this emitter function.
virtual int FireListEntry(FTPClientListEntryEventParams *e) {...}

#define EID_FTPCLIENT_NOTIFICATION 9

virtual INT SECUREBLACKBOX_CALL FireNotification(LPSTR &lpszEventID, LPSTR &lpszEventParam);

class FTPClientNotificationEventParams {
public:
  const QString &EventID();

  const QString &EventParam();

  int EventRetVal();
  void SetEventRetVal(int iRetVal);
};

// To handle, connect one or more slots to this signal.
void Notification(FTPClientNotificationEventParams *e);

// Or, subclass FTPClient and override this emitter function.
virtual int FireNotification(FTPClientNotificationEventParams *e) {...}

#define EID_FTPCLIENT_PROGRESS 10

virtual INT SECUREBLACKBOX_CALL FireProgress(LONG64 &lTotal, LONG64 &lCurrent, BOOL &bCancel);

class FTPClientProgressEventParams {
public:
  qint64 Total();

  qint64 Current();

  bool Cancel();
  void SetCancel(bool bCancel);

  int EventRetVal();
  void SetEventRetVal(int iRetVal);
};

// To handle, connect one or more slots to this signal.
void Progress(FTPClientProgressEventParams *e);

// Or, subclass FTPClient and override this emitter function.
virtual int FireProgress(FTPClientProgressEventParams *e) {...}

#define EID_FTPCLIENT_TEXTDATALINE 11

virtual INT SECUREBLACKBOX_CALL FireTextDataLine(LPSTR &lpszTextLine);

class FTPClientTextDataLineEventParams {
public:
  const QString &TextLine();

  int EventRetVal();
  void SetEventRetVal(int iRetVal);
};

// To handle, connect one or more slots to this signal.
void TextDataLine(FTPClientTextDataLineEventParams *e);

// Or, subclass FTPClient and override this emitter function.
virtual int FireTextDataLine(FTPClientTextDataLineEventParams *e) {...}

#define EID_FTPCLIENT_TLSCERTNEEDED 12

virtual INT SECUREBLACKBOX_CALL FireTLSCertNeeded(LPSTR &lpszHost, LPSTR &lpszCANames);

class FTPClientTLSCertNeededEventParams {
public:
  const QString &Host();

  const QString &CANames();

  int EventRetVal();
  void SetEventRetVal(int iRetVal);
};

// To handle, connect one or more slots to this signal.
void TLSCertNeeded(FTPClientTLSCertNeededEventParams *e);

// Or, subclass FTPClient and override this emitter function.
virtual int FireTLSCertNeeded(FTPClientTLSCertNeededEventParams *e) {...}

#define EID_FTPCLIENT_TLSCERTVALIDATE 13

virtual INT SECUREBLACKBOX_CALL FireTLSCertValidate(LPSTR &lpszServerHost, LPSTR &lpszServerIP, BOOL &bAccept);

class FTPClientTLSCertValidateEventParams {
public:
  const QString &ServerHost();

  const QString &ServerIP();

  bool Accept();
  void SetAccept(bool bAccept);

  int EventRetVal();
  void SetEventRetVal(int iRetVal);
};

// To handle, connect one or more slots to this signal.
void TLSCertValidate(FTPClientTLSCertValidateEventParams *e);

// Or, subclass FTPClient and override this emitter function.
virtual int FireTLSCertValidate(FTPClientTLSCertValidateEventParams *e) {...}

#define EID_FTPCLIENT_TLSESTABLISHED 14

virtual INT SECUREBLACKBOX_CALL FireTLSEstablished(LPSTR &lpszHost, LPSTR &lpszVersion, LPSTR &lpszCiphersuite, LPSTR &lpConnectionId, INT &lenConnectionId, BOOL &bAbort);

class FTPClientTLSEstablishedEventParams {
public:
  const QString &Host();

  const QString &Version();

  const QString &Ciphersuite();

  const QByteArray &ConnectionId();

  bool Abort();
  void SetAbort(bool bAbort);

  int EventRetVal();
  void SetEventRetVal(int iRetVal);
};

// To handle, connect one or more slots to this signal.
void TLSEstablished(FTPClientTLSEstablishedEventParams *e);

// Or, subclass FTPClient and override this emitter function.
virtual int FireTLSEstablished(FTPClientTLSEstablishedEventParams *e) {...}

#define EID_FTPCLIENT_TLSHANDSHAKE 15

virtual INT SECUREBLACKBOX_CALL FireTLSHandshake(LPSTR &lpszHost, BOOL &bAbort);

class FTPClientTLSHandshakeEventParams {
public:
  const QString &Host();

  bool Abort();
  void SetAbort(bool bAbort);

  int EventRetVal();
  void SetEventRetVal(int iRetVal);
};

// To handle, connect one or more slots to this signal.
void TLSHandshake(FTPClientTLSHandshakeEventParams *e);

// Or, subclass FTPClient and override this emitter function.
virtual int FireTLSHandshake(FTPClientTLSHandshakeEventParams *e) {...}

#define EID_FTPCLIENT_TLSPSK 16

virtual INT SECUREBLACKBOX_CALL FireTLSPSK(LPSTR &lpszHost, LPSTR &lpszHint);

class FTPClientTLSPSKEventParams {
public:
  const QString &Host();

  const QString &Hint();

  int EventRetVal();
  void SetEventRetVal(int iRetVal);
};

// To handle, connect one or more slots to this signal.
void TLSPSK(FTPClientTLSPSKEventParams *e);

// Or, subclass FTPClient and override this emitter function.
virtual int FireTLSPSK(FTPClientTLSPSKEventParams *e) {...}

#define EID_FTPCLIENT_TLSSHUTDOWN 17

virtual INT SECUREBLACKBOX_CALL FireTLSShutdown(LPSTR &lpszHost);

class FTPClientTLSShutdownEventParams {
public:
  const QString &Host();

  int EventRetVal();
  void SetEventRetVal(int iRetVal);
};

// To handle, connect one or more slots to this signal.
void TLSShutdown(FTPClientTLSShutdownEventParams *e);

// Or, subclass FTPClient and override this emitter function.
virtual int FireTLSShutdown(FTPClientTLSShutdownEventParams *e) {...}