int secureblackbox_sftpclient_getauthattempts(void* lpObj);
int secureblackbox_sftpclient_setauthattempts(void* lpObj, int iAuthAttempts);

int GetAuthAttempts();
int SetAuthAttempts(int iAuthAttempts);

int secureblackbox_sftpclient_getautoadjusttransferblock(void* lpObj);
int secureblackbox_sftpclient_setautoadjusttransferblock(void* lpObj, int bAutoAdjustTransferBlock);

bool GetAutoAdjustTransferBlock();
int SetAutoAdjustTransferBlock(bool bAutoAdjustTransferBlock);

int secureblackbox_sftpclient_getconflictresolutionmode(void* lpObj);
int secureblackbox_sftpclient_setconflictresolutionmode(void* lpObj, int iConflictResolutionMode);

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

int secureblackbox_sftpclient_getconnected(void* lpObj);

bool GetConnected();

char* secureblackbox_sftpclient_getconninfoclientkeyalgorithm(void* lpObj);

int secureblackbox_sftpclient_getconninfoclientkeybits(void* lpObj);

char* secureblackbox_sftpclient_getconninfoclientkeyfingerprint(void* lpObj);

char* secureblackbox_sftpclient_getconninfoclosereason(void* lpObj);

char* secureblackbox_sftpclient_getconninfocompressionalgorithminbound(void* lpObj);

char* secureblackbox_sftpclient_getconninfocompressionalgorithmoutbound(void* lpObj);

char* secureblackbox_sftpclient_getconninfoencryptionalgorithminbound(void* lpObj);

char* secureblackbox_sftpclient_getconninfoencryptionalgorithmoutbound(void* lpObj);

int secureblackbox_sftpclient_getconninfoinboundencryptionkeybits(void* lpObj);

char* secureblackbox_sftpclient_getconninfokexalgorithm(void* lpObj);

int secureblackbox_sftpclient_getconninfokexbits(void* lpObj);

char* secureblackbox_sftpclient_getconninfokexlines(void* lpObj);

char* secureblackbox_sftpclient_getconninfomacalgorithminbound(void* lpObj);

char* secureblackbox_sftpclient_getconninfomacalgorithmoutbound(void* lpObj);

int secureblackbox_sftpclient_getconninfooutboundencryptionkeybits(void* lpObj);

char* secureblackbox_sftpclient_getconninfopublickeyalgorithm(void* lpObj);

char* secureblackbox_sftpclient_getconninforemoteaddress(void* lpObj);

int secureblackbox_sftpclient_getconninforemoteport(void* lpObj);

char* secureblackbox_sftpclient_getconninfoserverkeyalgorithm(void* lpObj);

int secureblackbox_sftpclient_getconninfoserverkeybits(void* lpObj);

char* secureblackbox_sftpclient_getconninfoserverkeyfingerprint(void* lpObj);

char* secureblackbox_sftpclient_getconninfoserversoftwarename(void* lpObj);

int64 secureblackbox_sftpclient_getconninfototalbytesreceived(void* lpObj);

int64 secureblackbox_sftpclient_getconninfototalbytessent(void* lpObj);

int secureblackbox_sftpclient_getconninfoversion(void* lpObj);

QString GetConnInfoClientKeyAlgorithm();

int GetConnInfoClientKeyBits();

QString GetConnInfoClientKeyFingerprint();

QString GetConnInfoCloseReason();

QString GetConnInfoCompressionAlgorithmInbound();

QString GetConnInfoCompressionAlgorithmOutbound();

QString GetConnInfoEncryptionAlgorithmInbound();

QString GetConnInfoEncryptionAlgorithmOutbound();

int GetConnInfoInboundEncryptionKeyBits();

QString GetConnInfoKexAlgorithm();

int GetConnInfoKexBits();

QString GetConnInfoKexLines();

QString GetConnInfoMacAlgorithmInbound();

QString GetConnInfoMacAlgorithmOutbound();

int GetConnInfoOutboundEncryptionKeyBits();

QString GetConnInfoPublicKeyAlgorithm();

QString GetConnInfoRemoteAddress();

int GetConnInfoRemotePort();

QString GetConnInfoServerKeyAlgorithm();

int GetConnInfoServerKeyBits();

QString GetConnInfoServerKeyFingerprint();

QString GetConnInfoServerSoftwareName();

qint64 GetConnInfoTotalBytesReceived();

qint64 GetConnInfoTotalBytesSent();

int GetConnInfoVersion();

char* secureblackbox_sftpclient_getcurrlistentryaccesstime(void* lpObj);

char* secureblackbox_sftpclient_getcurrlistentrycreationtime(void* lpObj);

int secureblackbox_sftpclient_getcurrlistentryentryformat(void* lpObj);

int secureblackbox_sftpclient_getcurrlistentryfiletype(void* lpObj);

int64 secureblackbox_sftpclient_getcurrlistentryhandle(void* lpObj);

char* secureblackbox_sftpclient_getcurrlistentrymodificationtime(void* lpObj);

char* secureblackbox_sftpclient_getcurrlistentryname(void* lpObj);

char* secureblackbox_sftpclient_getcurrlistentrypath(void* lpObj);

char* secureblackbox_sftpclient_getcurrlistentryprincipal(void* lpObj);

int64 secureblackbox_sftpclient_getcurrlistentrysize(void* lpObj);

int secureblackbox_sftpclient_getcurrlistentryunixperms(void* lpObj);

char* secureblackbox_sftpclient_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_sftpclient_getdownloadblocksize(void* lpObj);
int secureblackbox_sftpclient_setdownloadblocksize(void* lpObj, int iDownloadBlockSize);

int GetDownloadBlockSize();
int SetDownloadBlockSize(int iDownloadBlockSize);

char* secureblackbox_sftpclient_getexternalcryptoasyncdocumentid(void* lpObj);
int secureblackbox_sftpclient_setexternalcryptoasyncdocumentid(void* lpObj, const char* lpszExternalCryptoAsyncDocumentID);

char* secureblackbox_sftpclient_getexternalcryptocustomparams(void* lpObj);
int secureblackbox_sftpclient_setexternalcryptocustomparams(void* lpObj, const char* lpszExternalCryptoCustomParams);

char* secureblackbox_sftpclient_getexternalcryptodata(void* lpObj);
int secureblackbox_sftpclient_setexternalcryptodata(void* lpObj, const char* lpszExternalCryptoData);

int secureblackbox_sftpclient_getexternalcryptoexternalhashcalculation(void* lpObj);
int secureblackbox_sftpclient_setexternalcryptoexternalhashcalculation(void* lpObj, int bExternalCryptoExternalHashCalculation);

char* secureblackbox_sftpclient_getexternalcryptohashalgorithm(void* lpObj);
int secureblackbox_sftpclient_setexternalcryptohashalgorithm(void* lpObj, const char* lpszExternalCryptoHashAlgorithm);

char* secureblackbox_sftpclient_getexternalcryptokeyid(void* lpObj);
int secureblackbox_sftpclient_setexternalcryptokeyid(void* lpObj, const char* lpszExternalCryptoKeyID);

char* secureblackbox_sftpclient_getexternalcryptokeysecret(void* lpObj);
int secureblackbox_sftpclient_setexternalcryptokeysecret(void* lpObj, const char* lpszExternalCryptoKeySecret);

int secureblackbox_sftpclient_getexternalcryptomethod(void* lpObj);
int secureblackbox_sftpclient_setexternalcryptomethod(void* lpObj, int iExternalCryptoMethod);

int secureblackbox_sftpclient_getexternalcryptomode(void* lpObj);
int secureblackbox_sftpclient_setexternalcryptomode(void* lpObj, int iExternalCryptoMode);

char* secureblackbox_sftpclient_getexternalcryptopublickeyalgorithm(void* lpObj);
int secureblackbox_sftpclient_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_sftpclient_getfipsmode(void* lpObj);
int secureblackbox_sftpclient_setfipsmode(void* lpObj, int bFIPSMode);

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

int secureblackbox_sftpclient_getforcecompression(void* lpObj);
int secureblackbox_sftpclient_setforcecompression(void* lpObj, int bForceCompression);

bool GetForceCompression();
int SetForceCompression(bool bForceCompression);

char* secureblackbox_sftpclient_getkeyfingerprintsha1(void* lpObj);

char* secureblackbox_sftpclient_getkeyfingerprintsha256(void* lpObj);

int64 secureblackbox_sftpclient_getkeyhandle(void* lpObj);
int secureblackbox_sftpclient_setkeyhandle(void* lpObj, int64 lKeyHandle);

QString GetKeyFingerprintSHA1();

QString GetKeyFingerprintSHA256();

qint64 GetKeyHandle();
int SetKeyHandle(qint64 lKeyHandle);

int secureblackbox_sftpclient_getmaxsftpversion(void* lpObj);
int secureblackbox_sftpclient_setmaxsftpversion(void* lpObj, int iMaxSFTPVersion);

int GetMaxSFTPVersion();
int SetMaxSFTPVersion(int iMaxSFTPVersion);

int secureblackbox_sftpclient_getminsftpversion(void* lpObj);
int secureblackbox_sftpclient_setminsftpversion(void* lpObj, int iMinSFTPVersion);

int GetMinSFTPVersion();
int SetMinSFTPVersion(int iMinSFTPVersion);

char* secureblackbox_sftpclient_getpassword(void* lpObj);
int secureblackbox_sftpclient_setpassword(void* lpObj, const char* lpszPassword);

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

int secureblackbox_sftpclient_getpipelinelength(void* lpObj);
int secureblackbox_sftpclient_setpipelinelength(void* lpObj, int iPipelineLength);

int GetPipelineLength();
int SetPipelineLength(int iPipelineLength);

char* secureblackbox_sftpclient_getproxyaddress(void* lpObj);
int secureblackbox_sftpclient_setproxyaddress(void* lpObj, const char* lpszProxyAddress);

int secureblackbox_sftpclient_getproxyauthentication(void* lpObj);
int secureblackbox_sftpclient_setproxyauthentication(void* lpObj, int iProxyAuthentication);

char* secureblackbox_sftpclient_getproxypassword(void* lpObj);
int secureblackbox_sftpclient_setproxypassword(void* lpObj, const char* lpszProxyPassword);

int secureblackbox_sftpclient_getproxyport(void* lpObj);
int secureblackbox_sftpclient_setproxyport(void* lpObj, int iProxyPort);

int secureblackbox_sftpclient_getproxyproxytype(void* lpObj);
int secureblackbox_sftpclient_setproxyproxytype(void* lpObj, int iProxyProxyType);

char* secureblackbox_sftpclient_getproxyrequestheaders(void* lpObj);
int secureblackbox_sftpclient_setproxyrequestheaders(void* lpObj, const char* lpszProxyRequestHeaders);

char* secureblackbox_sftpclient_getproxyresponsebody(void* lpObj);
int secureblackbox_sftpclient_setproxyresponsebody(void* lpObj, const char* lpszProxyResponseBody);

char* secureblackbox_sftpclient_getproxyresponseheaders(void* lpObj);
int secureblackbox_sftpclient_setproxyresponseheaders(void* lpObj, const char* lpszProxyResponseHeaders);

int secureblackbox_sftpclient_getproxyuseipv6(void* lpObj);
int secureblackbox_sftpclient_setproxyuseipv6(void* lpObj, int bProxyUseIPv6);

char* secureblackbox_sftpclient_getproxyusername(void* lpObj);
int secureblackbox_sftpclient_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);

char* secureblackbox_sftpclient_getserverkeyalgorithm(void* lpObj);

int secureblackbox_sftpclient_getserverkeybits(void* lpObj);

char* secureblackbox_sftpclient_getserverkeycomment(void* lpObj);

char* secureblackbox_sftpclient_getserverkeycurve(void* lpObj);

int secureblackbox_sftpclient_getserverkeydssg(void* lpObj, char** lpServerKeyDSSG, int* lenServerKeyDSSG);

int secureblackbox_sftpclient_getserverkeydssp(void* lpObj, char** lpServerKeyDSSP, int* lenServerKeyDSSP);

int secureblackbox_sftpclient_getserverkeydssq(void* lpObj, char** lpServerKeyDSSQ, int* lenServerKeyDSSQ);

int secureblackbox_sftpclient_getserverkeydssx(void* lpObj, char** lpServerKeyDSSX, int* lenServerKeyDSSX);

int secureblackbox_sftpclient_getserverkeydssy(void* lpObj, char** lpServerKeyDSSY, int* lenServerKeyDSSY);

int secureblackbox_sftpclient_getserverkeyeccd(void* lpObj, char** lpServerKeyECCD, int* lenServerKeyECCD);

int secureblackbox_sftpclient_getserverkeyeccqx(void* lpObj, char** lpServerKeyECCQX, int* lenServerKeyECCQX);

int secureblackbox_sftpclient_getserverkeyeccqy(void* lpObj, char** lpServerKeyECCQY, int* lenServerKeyECCQY);

int secureblackbox_sftpclient_getserverkeyedprivate(void* lpObj, char** lpServerKeyEdPrivate, int* lenServerKeyEdPrivate);

int secureblackbox_sftpclient_getserverkeyedpublic(void* lpObj, char** lpServerKeyEdPublic, int* lenServerKeyEdPublic);

char* secureblackbox_sftpclient_getserverkeyfingerprintmd5(void* lpObj);

char* secureblackbox_sftpclient_getserverkeyfingerprintsha1(void* lpObj);

char* secureblackbox_sftpclient_getserverkeyfingerprintsha256(void* lpObj);

int64 secureblackbox_sftpclient_getserverkeyhandle(void* lpObj);

int secureblackbox_sftpclient_getserverkeyisextractable(void* lpObj);

int secureblackbox_sftpclient_getserverkeyisprivate(void* lpObj);

int secureblackbox_sftpclient_getserverkeyispublic(void* lpObj);

int secureblackbox_sftpclient_getserverkeykdfrounds(void* lpObj);

int secureblackbox_sftpclient_getserverkeykdfsalt(void* lpObj, char** lpServerKeyKDFSalt, int* lenServerKeyKDFSalt);

int secureblackbox_sftpclient_getserverkeykeyformat(void* lpObj);

char* secureblackbox_sftpclient_getserverkeykeyprotectionalgorithm(void* lpObj);

int secureblackbox_sftpclient_getserverkeyrsaexponent(void* lpObj, char** lpServerKeyRSAExponent, int* lenServerKeyRSAExponent);

int secureblackbox_sftpclient_getserverkeyrsaiqmp(void* lpObj, char** lpServerKeyRSAIQMP, int* lenServerKeyRSAIQMP);

int secureblackbox_sftpclient_getserverkeyrsamodulus(void* lpObj, char** lpServerKeyRSAModulus, int* lenServerKeyRSAModulus);

int secureblackbox_sftpclient_getserverkeyrsap(void* lpObj, char** lpServerKeyRSAP, int* lenServerKeyRSAP);

int secureblackbox_sftpclient_getserverkeyrsaprivateexponent(void* lpObj, char** lpServerKeyRSAPrivateExponent, int* lenServerKeyRSAPrivateExponent);

int secureblackbox_sftpclient_getserverkeyrsaq(void* lpObj, char** lpServerKeyRSAQ, int* lenServerKeyRSAQ);

char* secureblackbox_sftpclient_getserverkeysubject(void* lpObj);

QString GetServerKeyAlgorithm();

int GetServerKeyBits();

QString GetServerKeyComment();

QString GetServerKeyCurve();

QByteArray GetServerKeyDSSG();

QByteArray GetServerKeyDSSP();

QByteArray GetServerKeyDSSQ();

QByteArray GetServerKeyDSSX();

QByteArray GetServerKeyDSSY();

QByteArray GetServerKeyECCD();

QByteArray GetServerKeyECCQX();

QByteArray GetServerKeyECCQY();

QByteArray GetServerKeyEdPrivate();

QByteArray GetServerKeyEdPublic();

QString GetServerKeyFingerprintMD5();

QString GetServerKeyFingerprintSHA1();

QString GetServerKeyFingerprintSHA256();

qint64 GetServerKeyHandle();

bool GetServerKeyIsExtractable();

bool GetServerKeyIsPrivate();

bool GetServerKeyIsPublic();

int GetServerKeyKDFRounds();

QByteArray GetServerKeyKDFSalt();

int GetServerKeyKeyFormat();

QString GetServerKeyKeyProtectionAlgorithm();

QByteArray GetServerKeyRSAExponent();

QByteArray GetServerKeyRSAIQMP();

QByteArray GetServerKeyRSAModulus();

QByteArray GetServerKeyRSAP();

QByteArray GetServerKeyRSAPrivateExponent();

QByteArray GetServerKeyRSAQ();

QString GetServerKeySubject();

int secureblackbox_sftpclient_getsocketdnsmode(void* lpObj);
int secureblackbox_sftpclient_setsocketdnsmode(void* lpObj, int iSocketDNSMode);

int secureblackbox_sftpclient_getsocketdnsport(void* lpObj);
int secureblackbox_sftpclient_setsocketdnsport(void* lpObj, int iSocketDNSPort);

int secureblackbox_sftpclient_getsocketdnsquerytimeout(void* lpObj);
int secureblackbox_sftpclient_setsocketdnsquerytimeout(void* lpObj, int iSocketDNSQueryTimeout);

char* secureblackbox_sftpclient_getsocketdnsservers(void* lpObj);
int secureblackbox_sftpclient_setsocketdnsservers(void* lpObj, const char* lpszSocketDNSServers);

int secureblackbox_sftpclient_getsocketdnstotaltimeout(void* lpObj);
int secureblackbox_sftpclient_setsocketdnstotaltimeout(void* lpObj, int iSocketDNSTotalTimeout);

int secureblackbox_sftpclient_getsocketincomingspeedlimit(void* lpObj);
int secureblackbox_sftpclient_setsocketincomingspeedlimit(void* lpObj, int iSocketIncomingSpeedLimit);

char* secureblackbox_sftpclient_getsocketlocaladdress(void* lpObj);
int secureblackbox_sftpclient_setsocketlocaladdress(void* lpObj, const char* lpszSocketLocalAddress);

int secureblackbox_sftpclient_getsocketlocalport(void* lpObj);
int secureblackbox_sftpclient_setsocketlocalport(void* lpObj, int iSocketLocalPort);

int secureblackbox_sftpclient_getsocketoutgoingspeedlimit(void* lpObj);
int secureblackbox_sftpclient_setsocketoutgoingspeedlimit(void* lpObj, int iSocketOutgoingSpeedLimit);

int secureblackbox_sftpclient_getsockettimeout(void* lpObj);
int secureblackbox_sftpclient_setsockettimeout(void* lpObj, int iSocketTimeout);

int secureblackbox_sftpclient_getsocketuseipv6(void* lpObj);
int secureblackbox_sftpclient_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_sftpclient_getsshsettingsautoadjustciphers(void* lpObj);
int secureblackbox_sftpclient_setsshsettingsautoadjustciphers(void* lpObj, int bSSHSettingsAutoAdjustCiphers);

int secureblackbox_sftpclient_getsshsettingsbaseconfiguration(void* lpObj);
int secureblackbox_sftpclient_setsshsettingsbaseconfiguration(void* lpObj, int iSSHSettingsBaseConfiguration);

char* secureblackbox_sftpclient_getsshsettingscompressionalgorithms(void* lpObj);
int secureblackbox_sftpclient_setsshsettingscompressionalgorithms(void* lpObj, const char* lpszSSHSettingsCompressionAlgorithms);

int secureblackbox_sftpclient_getsshsettingscompressionlevel(void* lpObj);
int secureblackbox_sftpclient_setsshsettingscompressionlevel(void* lpObj, int iSSHSettingsCompressionLevel);

int secureblackbox_sftpclient_getsshsettingsdefaultwindowsize(void* lpObj);
int secureblackbox_sftpclient_setsshsettingsdefaultwindowsize(void* lpObj, int iSSHSettingsDefaultWindowSize);

char* secureblackbox_sftpclient_getsshsettingsencryptionalgorithms(void* lpObj);
int secureblackbox_sftpclient_setsshsettingsencryptionalgorithms(void* lpObj, const char* lpszSSHSettingsEncryptionAlgorithms);

int secureblackbox_sftpclient_getsshsettingsforcecompression(void* lpObj);
int secureblackbox_sftpclient_setsshsettingsforcecompression(void* lpObj, int bSSHSettingsForceCompression);

int secureblackbox_sftpclient_getsshsettingsforwardauthagent(void* lpObj);
int secureblackbox_sftpclient_setsshsettingsforwardauthagent(void* lpObj, int bSSHSettingsForwardAuthAgent);

char* secureblackbox_sftpclient_getsshsettingsgssauthtypes(void* lpObj);
int secureblackbox_sftpclient_setsshsettingsgssauthtypes(void* lpObj, const char* lpszSSHSettingsGSSAuthTypes);

int secureblackbox_sftpclient_getsshsettingsgssdelegatecreds(void* lpObj);
int secureblackbox_sftpclient_setsshsettingsgssdelegatecreds(void* lpObj, int bSSHSettingsGSSDelegateCreds);

char* secureblackbox_sftpclient_getsshsettingsgsshostname(void* lpObj);
int secureblackbox_sftpclient_setsshsettingsgsshostname(void* lpObj, const char* lpszSSHSettingsGSSHostname);

char* secureblackbox_sftpclient_getsshsettingsgsslib(void* lpObj);
int secureblackbox_sftpclient_setsshsettingsgsslib(void* lpObj, const char* lpszSSHSettingsGSSLib);

char* secureblackbox_sftpclient_getsshsettingsgssmechanisms(void* lpObj);
int secureblackbox_sftpclient_setsshsettingsgssmechanisms(void* lpObj, const char* lpszSSHSettingsGSSMechanisms);

char* secureblackbox_sftpclient_getsshsettingsgssprotocols(void* lpObj);
int secureblackbox_sftpclient_setsshsettingsgssprotocols(void* lpObj, const char* lpszSSHSettingsGSSProtocols);

int secureblackbox_sftpclient_getsshsettingshandshaketimeout(void* lpObj);
int secureblackbox_sftpclient_setsshsettingshandshaketimeout(void* lpObj, int iSSHSettingsHandshakeTimeout);

char* secureblackbox_sftpclient_getsshsettingskexalgorithms(void* lpObj);
int secureblackbox_sftpclient_setsshsettingskexalgorithms(void* lpObj, const char* lpszSSHSettingsKexAlgorithms);

char* secureblackbox_sftpclient_getsshsettingsmacalgorithms(void* lpObj);
int secureblackbox_sftpclient_setsshsettingsmacalgorithms(void* lpObj, const char* lpszSSHSettingsMacAlgorithms);

int secureblackbox_sftpclient_getsshsettingsmaxsshpacketsize(void* lpObj);
int secureblackbox_sftpclient_setsshsettingsmaxsshpacketsize(void* lpObj, int iSSHSettingsMaxSSHPacketSize);

int secureblackbox_sftpclient_getsshsettingsminwindowsize(void* lpObj);
int secureblackbox_sftpclient_setsshsettingsminwindowsize(void* lpObj, int iSSHSettingsMinWindowSize);

int secureblackbox_sftpclient_getsshsettingsobfuscatehandshake(void* lpObj);
int secureblackbox_sftpclient_setsshsettingsobfuscatehandshake(void* lpObj, int bSSHSettingsObfuscateHandshake);

char* secureblackbox_sftpclient_getsshsettingsobfuscationpassword(void* lpObj);
int secureblackbox_sftpclient_setsshsettingsobfuscationpassword(void* lpObj, const char* lpszSSHSettingsObfuscationPassword);

char* secureblackbox_sftpclient_getsshsettingspublickeyalgorithms(void* lpObj);
int secureblackbox_sftpclient_setsshsettingspublickeyalgorithms(void* lpObj, const char* lpszSSHSettingsPublicKeyAlgorithms);

int secureblackbox_sftpclient_getsshsettingsrequestpasswordchange(void* lpObj);
int secureblackbox_sftpclient_setsshsettingsrequestpasswordchange(void* lpObj, int bSSHSettingsRequestPasswordChange);

char* secureblackbox_sftpclient_getsshsettingssoftwarename(void* lpObj);
int secureblackbox_sftpclient_setsshsettingssoftwarename(void* lpObj, const char* lpszSSHSettingsSoftwareName);

int secureblackbox_sftpclient_getsshsettingstrustallkeys(void* lpObj);
int secureblackbox_sftpclient_setsshsettingstrustallkeys(void* lpObj, int bSSHSettingsTrustAllKeys);

int secureblackbox_sftpclient_getsshsettingsuseauthagent(void* lpObj);
int secureblackbox_sftpclient_setsshsettingsuseauthagent(void* lpObj, int bSSHSettingsUseAuthAgent);

int secureblackbox_sftpclient_getsshsettingsversions(void* lpObj);
int secureblackbox_sftpclient_setsshsettingsversions(void* lpObj, int iSSHSettingsVersions);

bool GetSSHSettingsAutoAdjustCiphers();
int SetSSHSettingsAutoAdjustCiphers(bool bSSHSettingsAutoAdjustCiphers);

int GetSSHSettingsBaseConfiguration();
int SetSSHSettingsBaseConfiguration(int iSSHSettingsBaseConfiguration);

QString GetSSHSettingsCompressionAlgorithms();
int SetSSHSettingsCompressionAlgorithms(QString qsSSHSettingsCompressionAlgorithms);

int GetSSHSettingsCompressionLevel();
int SetSSHSettingsCompressionLevel(int iSSHSettingsCompressionLevel);

int GetSSHSettingsDefaultWindowSize();
int SetSSHSettingsDefaultWindowSize(int iSSHSettingsDefaultWindowSize);

QString GetSSHSettingsEncryptionAlgorithms();
int SetSSHSettingsEncryptionAlgorithms(QString qsSSHSettingsEncryptionAlgorithms);

bool GetSSHSettingsForceCompression();
int SetSSHSettingsForceCompression(bool bSSHSettingsForceCompression);

bool GetSSHSettingsForwardAuthAgent();
int SetSSHSettingsForwardAuthAgent(bool bSSHSettingsForwardAuthAgent);

QString GetSSHSettingsGSSAuthTypes();
int SetSSHSettingsGSSAuthTypes(QString qsSSHSettingsGSSAuthTypes);

bool GetSSHSettingsGSSDelegateCreds();
int SetSSHSettingsGSSDelegateCreds(bool bSSHSettingsGSSDelegateCreds);

QString GetSSHSettingsGSSHostname();
int SetSSHSettingsGSSHostname(QString qsSSHSettingsGSSHostname);

QString GetSSHSettingsGSSLib();
int SetSSHSettingsGSSLib(QString qsSSHSettingsGSSLib);

QString GetSSHSettingsGSSMechanisms();
int SetSSHSettingsGSSMechanisms(QString qsSSHSettingsGSSMechanisms);

QString GetSSHSettingsGSSProtocols();
int SetSSHSettingsGSSProtocols(QString qsSSHSettingsGSSProtocols);

int GetSSHSettingsHandshakeTimeout();
int SetSSHSettingsHandshakeTimeout(int iSSHSettingsHandshakeTimeout);

QString GetSSHSettingsKexAlgorithms();
int SetSSHSettingsKexAlgorithms(QString qsSSHSettingsKexAlgorithms);

QString GetSSHSettingsMacAlgorithms();
int SetSSHSettingsMacAlgorithms(QString qsSSHSettingsMacAlgorithms);

int GetSSHSettingsMaxSSHPacketSize();
int SetSSHSettingsMaxSSHPacketSize(int iSSHSettingsMaxSSHPacketSize);

int GetSSHSettingsMinWindowSize();
int SetSSHSettingsMinWindowSize(int iSSHSettingsMinWindowSize);

bool GetSSHSettingsObfuscateHandshake();
int SetSSHSettingsObfuscateHandshake(bool bSSHSettingsObfuscateHandshake);

QString GetSSHSettingsObfuscationPassword();
int SetSSHSettingsObfuscationPassword(QString qsSSHSettingsObfuscationPassword);

QString GetSSHSettingsPublicKeyAlgorithms();
int SetSSHSettingsPublicKeyAlgorithms(QString qsSSHSettingsPublicKeyAlgorithms);

bool GetSSHSettingsRequestPasswordChange();
int SetSSHSettingsRequestPasswordChange(bool bSSHSettingsRequestPasswordChange);

QString GetSSHSettingsSoftwareName();
int SetSSHSettingsSoftwareName(QString qsSSHSettingsSoftwareName);

bool GetSSHSettingsTrustAllKeys();
int SetSSHSettingsTrustAllKeys(bool bSSHSettingsTrustAllKeys);

bool GetSSHSettingsUseAuthAgent();
int SetSSHSettingsUseAuthAgent(bool bSSHSettingsUseAuthAgent);

int GetSSHSettingsVersions();
int SetSSHSettingsVersions(int iSSHSettingsVersions);

char* secureblackbox_sftpclient_gettrustedkeysfile(void* lpObj);
int secureblackbox_sftpclient_settrustedkeysfile(void* lpObj, const char* lpszTrustedKeysFile);

QString GetTrustedKeysFile();
int SetTrustedKeysFile(QString qsTrustedKeysFile);

int secureblackbox_sftpclient_getuploadblocksize(void* lpObj);
int secureblackbox_sftpclient_setuploadblocksize(void* lpObj, int iUploadBlockSize);

int GetUploadBlockSize();
int SetUploadBlockSize(int iUploadBlockSize);

char* secureblackbox_sftpclient_getusername(void* lpObj);
int secureblackbox_sftpclient_setusername(void* lpObj, const char* lpszUsername);

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

int secureblackbox_sftpclient_getuseutf8(void* lpObj);
int secureblackbox_sftpclient_setuseutf8(void* lpObj, int bUseUTF8);

bool GetUseUTF8();
int SetUseUTF8(bool bUseUTF8);

int secureblackbox_sftpclient_getversion(void* lpObj);

int GetVersion();

char* secureblackbox_sftpclient_absolutepath(void* lpObj, const char* lpszRemotePath);

QString AbsolutePath(const QString& qsRemotePath);

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

int ChangeDir(const QString& qsRemoteDir);

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

QString Config(const QString& qsConfigurationString);

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

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

int secureblackbox_sftpclient_createlink(void* lpObj, const char* lpszLinkPath, const char* lpszTargetPath, int bHardLink);

int CreateLink(const QString& qsLinkPath, const QString& qsTargetPath, bool bHardLink);

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

int DeleteDir(const QString& qsRemoteDir);

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

int DeleteFile(const QString& qsRemoteFile);

int secureblackbox_sftpclient_deletefiles(void* lpObj, const char* lpszRemotePath, const char* lpszMask, int bCaseSensitive, int bRecursive, int iErrorHandling);

int DeleteFiles(const QString& qsRemotePath, const QString& qsMask, bool bCaseSensitive, bool bRecursive, int iErrorHandling);

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

bool DirExists(const QString& qsRemoteDir);

int secureblackbox_sftpclient_disconnect(void* lpObj);

int Disconnect();

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

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

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

QByteArray DownloadBytes(const QString& qsRemoteFile);

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

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

int secureblackbox_sftpclient_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_sftpclient_downloadstream(void* lpObj, const char* lpszRemoteFile, SecureBlackboxStream* sLocalStream);

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

char* secureblackbox_sftpclient_executesshcommand(void* lpObj, const char* lpszCommand, int *lpSize);

QByteArray ExecuteSSHCommand(const QString& qsCommand);

char* secureblackbox_sftpclient_extensioncmd(void* lpObj, const char* lpszExtn, const char* lpDataBuffer, int lenDataBuffer, int *lpSize);

QByteArray ExtensionCmd(const QString& qsExtn, QByteArray qbaDataBuffer);

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

bool FileExists(const QString& qsRemoteFile);

char* secureblackbox_sftpclient_getcurrentdir(void* lpObj);

QString GetCurrentDir();

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

qint64 GetFileSize(const QString& qsRemoteFile);

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

QString ListDir(bool bIncludeFiles, bool bIncludeDirectories);

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

int MakeDir(const QString& qsRemoteDir);

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

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

char* secureblackbox_sftpclient_requestattributes(void* lpObj, const char* lpszRemotePath, int bFollowSymLinks);

QString RequestAttributes(const QString& qsRemotePath, bool bFollowSymLinks);

int secureblackbox_sftpclient_reset(void* lpObj);

int Reset();

int secureblackbox_sftpclient_setattributes(void* lpObj, const char* lpszRemotePath, const char* lpszAttributes);

int SetAttributes(const QString& qsRemotePath, const QString& qsAttributes);

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

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

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

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

int secureblackbox_sftpclient_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_sftpclient_uploadstream(void* lpObj, SecureBlackboxStream* sLocalStream, const char* lpszRemoteFile);

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

#define EID_SFTPCLIENT_AUTHATTEMPT 1

virtual INT SECUREBLACKBOX_CALL FireAuthAttempt(INT &iAuthType);

class SFTPClientAuthAttemptEventParams {
public:
  int AuthType();

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

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

// Or, subclass SFTPClient and override this emitter function.
virtual int FireAuthAttempt(SFTPClientAuthAttemptEventParams *e) {...}

#define EID_SFTPCLIENT_AUTHFAILED 2

virtual INT SECUREBLACKBOX_CALL FireAuthFailed(INT &iAuthType);

class SFTPClientAuthFailedEventParams {
public:
  int AuthType();

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

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

// Or, subclass SFTPClient and override this emitter function.
virtual int FireAuthFailed(SFTPClientAuthFailedEventParams *e) {...}

#define EID_SFTPCLIENT_AUTHSUCCEEDED 3

virtual INT SECUREBLACKBOX_CALL FireAuthSucceeded();

class SFTPClientAuthSucceededEventParams {
public:
  int EventRetVal();
  void SetEventRetVal(int iRetVal);
};

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

// Or, subclass SFTPClient and override this emitter function.
virtual int FireAuthSucceeded(SFTPClientAuthSucceededEventParams *e) {...}

#define EID_SFTPCLIENT_BANNER 4

virtual INT SECUREBLACKBOX_CALL FireBanner(LPSTR &lpText, INT &lenText, LPSTR &lpLanguage, INT &lenLanguage);

class SFTPClientBannerEventParams {
public:
  const QByteArray &Text();

  const QByteArray &Language();

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

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

// Or, subclass SFTPClient and override this emitter function.
virtual int FireBanner(SFTPClientBannerEventParams *e) {...}

#define EID_SFTPCLIENT_DISCONNECT 5

virtual INT SECUREBLACKBOX_CALL FireDisconnect(INT &iCloseReason);

class SFTPClientDisconnectEventParams {
public:
  int CloseReason();

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

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

// Or, subclass SFTPClient and override this emitter function.
virtual int FireDisconnect(SFTPClientDisconnectEventParams *e) {...}

#define EID_SFTPCLIENT_ERROR 6

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

class SFTPClientErrorEventParams {
public:
  int ErrorCode();

  const QString &Description();

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

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

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

#define EID_SFTPCLIENT_EXTERNALSIGN 7

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

class SFTPClientExternalSignEventParams {
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(SFTPClientExternalSignEventParams *e);

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

#define EID_SFTPCLIENT_FILENAMECHANGENEEDED 8

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

class SFTPClientFileNameChangeNeededEventParams {
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(SFTPClientFileNameChangeNeededEventParams *e);

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

#define EID_SFTPCLIENT_FILEOPERATION 9

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

class SFTPClientFileOperationEventParams {
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(SFTPClientFileOperationEventParams *e);

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

#define EID_SFTPCLIENT_FILEOPERATIONRESULT 10

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

class SFTPClientFileOperationResultEventParams {
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(SFTPClientFileOperationResultEventParams *e);

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

#define EID_SFTPCLIENT_KNOWNKEYRECEIVED 11

virtual INT SECUREBLACKBOX_CALL FireKnownKeyReceived(LPSTR &lpszAlgorithm, INT &iBits, LPSTR &lpszFingerprintSHA256);

class SFTPClientKnownKeyReceivedEventParams {
public:
  const QString &Algorithm();

  int Bits();

  const QString &FingerprintSHA256();

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

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

// Or, subclass SFTPClient and override this emitter function.
virtual int FireKnownKeyReceived(SFTPClientKnownKeyReceivedEventParams *e) {...}

#define EID_SFTPCLIENT_LISTENTRY 12

virtual INT SECUREBLACKBOX_CALL FireListEntry(LPSTR &lpszFileName);

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

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

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

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

#define EID_SFTPCLIENT_NOTIFICATION 13

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

class SFTPClientNotificationEventParams {
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(SFTPClientNotificationEventParams *e);

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

#define EID_SFTPCLIENT_PASSWORDCHANGEREQUEST 14

virtual INT SECUREBLACKBOX_CALL FirePasswordChangeRequest(LPSTR &lpszPrompt, LPSTR &lpszNewPassword, BOOL &bCancel);

class SFTPClientPasswordChangeRequestEventParams {
public:
  const QString &Prompt();

  const QString &NewPassword();
  void SetNewPassword(const QString &qsNewPassword);

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

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

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

// Or, subclass SFTPClient and override this emitter function.
virtual int FirePasswordChangeRequest(SFTPClientPasswordChangeRequestEventParams *e) {...}

#define EID_SFTPCLIENT_PRIVATEKEYNEEDED 15

virtual INT SECUREBLACKBOX_CALL FirePrivateKeyNeeded(BOOL &bSkip);

class SFTPClientPrivateKeyNeededEventParams {
public:
  bool Skip();
  void SetSkip(bool bSkip);

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

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

// Or, subclass SFTPClient and override this emitter function.
virtual int FirePrivateKeyNeeded(SFTPClientPrivateKeyNeededEventParams *e) {...}

#define EID_SFTPCLIENT_PROGRESS 16

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

class SFTPClientProgressEventParams {
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(SFTPClientProgressEventParams *e);

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

#define EID_SFTPCLIENT_UNKNOWNKEYRECEIVED 17

virtual INT SECUREBLACKBOX_CALL FireUnknownKeyReceived(LPSTR &lpszAlgorithm, INT &iBits, LPSTR &lpszFingerprintSHA256, INT &iAction);

class SFTPClientUnknownKeyReceivedEventParams {
public:
  const QString &Algorithm();

  int Bits();

  const QString &FingerprintSHA256();

  int Action();
  void SetAction(int iAction);

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

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

// Or, subclass SFTPClient and override this emitter function.
virtual int FireUnknownKeyReceived(SFTPClientUnknownKeyReceivedEventParams *e) {...}