int secureblackbox_restclient_getauthtypes(void* lpObj);
int secureblackbox_restclient_setauthtypes(void* lpObj, int iAuthTypes);

int GetAuthTypes();
int SetAuthTypes(int iAuthTypes);

int secureblackbox_restclient_getblockedcertcount(void* lpObj);
int secureblackbox_restclient_setblockedcertcount(void* lpObj, int iBlockedCertCount);

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

int64 secureblackbox_restclient_getblockedcerthandle(void* lpObj, int blockedcertindex);
int secureblackbox_restclient_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_restclient_getconninfoaeadcipher(void* lpObj);

int secureblackbox_restclient_getconninfochainvalidationdetails(void* lpObj);

int secureblackbox_restclient_getconninfochainvalidationresult(void* lpObj);

char* secureblackbox_restclient_getconninfociphersuite(void* lpObj);

int secureblackbox_restclient_getconninfoclientauthenticated(void* lpObj);

int secureblackbox_restclient_getconninfoclientauthrequested(void* lpObj);

int secureblackbox_restclient_getconninfoconnectionestablished(void* lpObj);

int secureblackbox_restclient_getconninfoconnectionid(void* lpObj, char** lpConnInfoConnectionID, int* lenConnInfoConnectionID);

char* secureblackbox_restclient_getconninfodigestalgorithm(void* lpObj);

char* secureblackbox_restclient_getconninfoencryptionalgorithm(void* lpObj);

int secureblackbox_restclient_getconninfoexportable(void* lpObj);

int64 secureblackbox_restclient_getconninfoid(void* lpObj);

char* secureblackbox_restclient_getconninfokeyexchangealgorithm(void* lpObj);

int secureblackbox_restclient_getconninfokeyexchangekeybits(void* lpObj);

char* secureblackbox_restclient_getconninfonamedeccurve(void* lpObj);

int secureblackbox_restclient_getconninfopfscipher(void* lpObj);

char* secureblackbox_restclient_getconninfopresharedidentity(void* lpObj);

char* secureblackbox_restclient_getconninfopresharedidentityhint(void* lpObj);

int secureblackbox_restclient_getconninfopublickeybits(void* lpObj);

char* secureblackbox_restclient_getconninforemoteaddress(void* lpObj);

int secureblackbox_restclient_getconninforemoteport(void* lpObj);

int secureblackbox_restclient_getconninforesumedsession(void* lpObj);

int secureblackbox_restclient_getconninfosecureconnection(void* lpObj);

int secureblackbox_restclient_getconninfoserverauthenticated(void* lpObj);

char* secureblackbox_restclient_getconninfosignaturealgorithm(void* lpObj);

int secureblackbox_restclient_getconninfosymmetricblocksize(void* lpObj);

int secureblackbox_restclient_getconninfosymmetrickeybits(void* lpObj);

int64 secureblackbox_restclient_getconninfototalbytesreceived(void* lpObj);

int64 secureblackbox_restclient_getconninfototalbytessent(void* lpObj);

char* secureblackbox_restclient_getconninfovalidationlog(void* lpObj);

char* secureblackbox_restclient_getconninfoversion(void* lpObj);

bool GetConnInfoAEADCipher();

int GetConnInfoChainValidationDetails();

int GetConnInfoChainValidationResult();

QString GetConnInfoCiphersuite();

bool GetConnInfoClientAuthenticated();

bool GetConnInfoClientAuthRequested();

bool GetConnInfoConnectionEstablished();

QByteArray GetConnInfoConnectionID();

QString GetConnInfoDigestAlgorithm();

QString GetConnInfoEncryptionAlgorithm();

bool GetConnInfoExportable();

qint64 GetConnInfoID();

QString GetConnInfoKeyExchangeAlgorithm();

int GetConnInfoKeyExchangeKeyBits();

QString GetConnInfoNamedECCurve();

bool GetConnInfoPFSCipher();

QString GetConnInfoPreSharedIdentity();

QString GetConnInfoPreSharedIdentityHint();

int GetConnInfoPublicKeyBits();

QString GetConnInfoRemoteAddress();

int GetConnInfoRemotePort();

bool GetConnInfoResumedSession();

bool GetConnInfoSecureConnection();

bool GetConnInfoServerAuthenticated();

QString GetConnInfoSignatureAlgorithm();

int GetConnInfoSymmetricBlockSize();

int GetConnInfoSymmetricKeyBits();

qint64 GetConnInfoTotalBytesReceived();

qint64 GetConnInfoTotalBytesSent();

QString GetConnInfoValidationLog();

QString GetConnInfoVersion();

char* secureblackbox_restclient_getcustomrequest(void* lpObj);
int secureblackbox_restclient_setcustomrequest(void* lpObj, const char* lpszCustomRequest);

QString GetCustomRequest();
int SetCustomRequest(QString qsCustomRequest);

int secureblackbox_restclient_getdynamicdata(void* lpObj, char** lpDynamicData, int* lenDynamicData);
int secureblackbox_restclient_setdynamicdata(void* lpObj, const char* lpDynamicData, int lenDynamicData);

QByteArray GetDynamicData();
int SetDynamicData(QByteArray qbaDynamicData);

char* secureblackbox_restclient_getexternalcryptoasyncdocumentid(void* lpObj);
int secureblackbox_restclient_setexternalcryptoasyncdocumentid(void* lpObj, const char* lpszExternalCryptoAsyncDocumentID);

char* secureblackbox_restclient_getexternalcryptocustomparams(void* lpObj);
int secureblackbox_restclient_setexternalcryptocustomparams(void* lpObj, const char* lpszExternalCryptoCustomParams);

char* secureblackbox_restclient_getexternalcryptodata(void* lpObj);
int secureblackbox_restclient_setexternalcryptodata(void* lpObj, const char* lpszExternalCryptoData);

int secureblackbox_restclient_getexternalcryptoexternalhashcalculation(void* lpObj);
int secureblackbox_restclient_setexternalcryptoexternalhashcalculation(void* lpObj, int bExternalCryptoExternalHashCalculation);

char* secureblackbox_restclient_getexternalcryptohashalgorithm(void* lpObj);
int secureblackbox_restclient_setexternalcryptohashalgorithm(void* lpObj, const char* lpszExternalCryptoHashAlgorithm);

char* secureblackbox_restclient_getexternalcryptokeyid(void* lpObj);
int secureblackbox_restclient_setexternalcryptokeyid(void* lpObj, const char* lpszExternalCryptoKeyID);

char* secureblackbox_restclient_getexternalcryptokeysecret(void* lpObj);
int secureblackbox_restclient_setexternalcryptokeysecret(void* lpObj, const char* lpszExternalCryptoKeySecret);

int secureblackbox_restclient_getexternalcryptomethod(void* lpObj);
int secureblackbox_restclient_setexternalcryptomethod(void* lpObj, int iExternalCryptoMethod);

int secureblackbox_restclient_getexternalcryptomode(void* lpObj);
int secureblackbox_restclient_setexternalcryptomode(void* lpObj, int iExternalCryptoMode);

char* secureblackbox_restclient_getexternalcryptopublickeyalgorithm(void* lpObj);
int secureblackbox_restclient_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_restclient_getfipsmode(void* lpObj);
int secureblackbox_restclient_setfipsmode(void* lpObj, int bFIPSMode);

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

int secureblackbox_restclient_getkeepalivepolicy(void* lpObj);
int secureblackbox_restclient_setkeepalivepolicy(void* lpObj, int iKeepAlivePolicy);

int GetKeepAlivePolicy();
int SetKeepAlivePolicy(int iKeepAlivePolicy);

int secureblackbox_restclient_getknowncertcount(void* lpObj);
int secureblackbox_restclient_setknowncertcount(void* lpObj, int iKnownCertCount);

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

int64 secureblackbox_restclient_getknowncerthandle(void* lpObj, int knowncertindex);
int secureblackbox_restclient_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_restclient_getknowncrlcount(void* lpObj);
int secureblackbox_restclient_setknowncrlcount(void* lpObj, int iKnownCRLCount);

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

int64 secureblackbox_restclient_getknowncrlhandle(void* lpObj, int knowncrlindex);
int secureblackbox_restclient_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_restclient_getknownocspcount(void* lpObj);
int secureblackbox_restclient_setknownocspcount(void* lpObj, int iKnownOCSPCount);

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

int64 secureblackbox_restclient_getknownocsphandle(void* lpObj, int knownocspindex);
int secureblackbox_restclient_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_restclient_getoutputbytes(void* lpObj, char** lpOutputBytes, int* lenOutputBytes);

QByteArray GetOutputBytes();

char* secureblackbox_restclient_getoutputfile(void* lpObj);
int secureblackbox_restclient_setoutputfile(void* lpObj, const char* lpszOutputFile);

QString GetOutputFile();
int SetOutputFile(QString qsOutputFile);

char* secureblackbox_restclient_getoutputstring(void* lpObj);

QString GetOutputString();

char* secureblackbox_restclient_getproxyaddress(void* lpObj);
int secureblackbox_restclient_setproxyaddress(void* lpObj, const char* lpszProxyAddress);

int secureblackbox_restclient_getproxyauthentication(void* lpObj);
int secureblackbox_restclient_setproxyauthentication(void* lpObj, int iProxyAuthentication);

char* secureblackbox_restclient_getproxypassword(void* lpObj);
int secureblackbox_restclient_setproxypassword(void* lpObj, const char* lpszProxyPassword);

int secureblackbox_restclient_getproxyport(void* lpObj);
int secureblackbox_restclient_setproxyport(void* lpObj, int iProxyPort);

int secureblackbox_restclient_getproxyproxytype(void* lpObj);
int secureblackbox_restclient_setproxyproxytype(void* lpObj, int iProxyProxyType);

char* secureblackbox_restclient_getproxyrequestheaders(void* lpObj);
int secureblackbox_restclient_setproxyrequestheaders(void* lpObj, const char* lpszProxyRequestHeaders);

char* secureblackbox_restclient_getproxyresponsebody(void* lpObj);
int secureblackbox_restclient_setproxyresponsebody(void* lpObj, const char* lpszProxyResponseBody);

char* secureblackbox_restclient_getproxyresponseheaders(void* lpObj);
int secureblackbox_restclient_setproxyresponseheaders(void* lpObj, const char* lpszProxyResponseHeaders);

int secureblackbox_restclient_getproxyuseipv6(void* lpObj);
int secureblackbox_restclient_setproxyuseipv6(void* lpObj, int bProxyUseIPv6);

char* secureblackbox_restclient_getproxyusername(void* lpObj);
int secureblackbox_restclient_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_restclient_getreasonphrase(void* lpObj);

QString GetReasonPhrase();

int secureblackbox_restclient_getreqheadercount(void* lpObj);
int secureblackbox_restclient_setreqheadercount(void* lpObj, int iReqHeaderCount);

char* secureblackbox_restclient_getreqheadercategory(void* lpObj, int reqheaderindex);
int secureblackbox_restclient_setreqheadercategory(void* lpObj, int reqheaderindex, const char* lpszReqHeaderCategory);

int secureblackbox_restclient_getreqheaderformat(void* lpObj, int reqheaderindex);
int secureblackbox_restclient_setreqheaderformat(void* lpObj, int reqheaderindex, int iReqHeaderFormat);

char* secureblackbox_restclient_getreqheadername(void* lpObj, int reqheaderindex);
int secureblackbox_restclient_setreqheadername(void* lpObj, int reqheaderindex, const char* lpszReqHeaderName);

char* secureblackbox_restclient_getreqheadervalue(void* lpObj, int reqheaderindex);
int secureblackbox_restclient_setreqheadervalue(void* lpObj, int reqheaderindex, const char* lpszReqHeaderValue);

int GetReqHeaderCount();
int SetReqHeaderCount(int iReqHeaderCount);

QString GetReqHeaderCategory(int iReqHeaderIndex);
int SetReqHeaderCategory(int iReqHeaderIndex, QString qsReqHeaderCategory);

int GetReqHeaderFormat(int iReqHeaderIndex);
int SetReqHeaderFormat(int iReqHeaderIndex, int iReqHeaderFormat);

QString GetReqHeaderName(int iReqHeaderIndex);
int SetReqHeaderName(int iReqHeaderIndex, QString qsReqHeaderName);

QString GetReqHeaderValue(int iReqHeaderIndex);
int SetReqHeaderValue(int iReqHeaderIndex, QString qsReqHeaderValue);

char* secureblackbox_restclient_getreqparamsaccept(void* lpObj);
int secureblackbox_restclient_setreqparamsaccept(void* lpObj, const char* lpszReqParamsAccept);

char* secureblackbox_restclient_getreqparamsacceptcharset(void* lpObj);
int secureblackbox_restclient_setreqparamsacceptcharset(void* lpObj, const char* lpszReqParamsAcceptCharset);

char* secureblackbox_restclient_getreqparamsacceptlanguage(void* lpObj);
int secureblackbox_restclient_setreqparamsacceptlanguage(void* lpObj, const char* lpszReqParamsAcceptLanguage);

int64 secureblackbox_restclient_getreqparamsacceptrangeend(void* lpObj);
int secureblackbox_restclient_setreqparamsacceptrangeend(void* lpObj, int64 lReqParamsAcceptRangeEnd);

int64 secureblackbox_restclient_getreqparamsacceptrangestart(void* lpObj);
int secureblackbox_restclient_setreqparamsacceptrangestart(void* lpObj, int64 lReqParamsAcceptRangeStart);

char* secureblackbox_restclient_getreqparamsauthorization(void* lpObj);
int secureblackbox_restclient_setreqparamsauthorization(void* lpObj, const char* lpszReqParamsAuthorization);

char* secureblackbox_restclient_getreqparamsconnection(void* lpObj);
int secureblackbox_restclient_setreqparamsconnection(void* lpObj, const char* lpszReqParamsConnection);

int64 secureblackbox_restclient_getreqparamscontentlength(void* lpObj);
int secureblackbox_restclient_setreqparamscontentlength(void* lpObj, int64 lReqParamsContentLength);

int64 secureblackbox_restclient_getreqparamscontentrangeend(void* lpObj);
int secureblackbox_restclient_setreqparamscontentrangeend(void* lpObj, int64 lReqParamsContentRangeEnd);

int64 secureblackbox_restclient_getreqparamscontentrangefullsize(void* lpObj);
int secureblackbox_restclient_setreqparamscontentrangefullsize(void* lpObj, int64 lReqParamsContentRangeFullSize);

int64 secureblackbox_restclient_getreqparamscontentrangestart(void* lpObj);
int secureblackbox_restclient_setreqparamscontentrangestart(void* lpObj, int64 lReqParamsContentRangeStart);

char* secureblackbox_restclient_getreqparamscontenttype(void* lpObj);
int secureblackbox_restclient_setreqparamscontenttype(void* lpObj, const char* lpszReqParamsContentType);

char* secureblackbox_restclient_getreqparamscookie(void* lpObj);
int secureblackbox_restclient_setreqparamscookie(void* lpObj, const char* lpszReqParamsCookie);

char* secureblackbox_restclient_getreqparamscustomheaders(void* lpObj);
int secureblackbox_restclient_setreqparamscustomheaders(void* lpObj, const char* lpszReqParamsCustomHeaders);

char* secureblackbox_restclient_getreqparamsdate(void* lpObj);
int secureblackbox_restclient_setreqparamsdate(void* lpObj, const char* lpszReqParamsDate);

char* secureblackbox_restclient_getreqparamsfrom(void* lpObj);
int secureblackbox_restclient_setreqparamsfrom(void* lpObj, const char* lpszReqParamsFrom);

char* secureblackbox_restclient_getreqparamshost(void* lpObj);
int secureblackbox_restclient_setreqparamshost(void* lpObj, const char* lpszReqParamsHost);

int secureblackbox_restclient_getreqparamshttpversion(void* lpObj);
int secureblackbox_restclient_setreqparamshttpversion(void* lpObj, int iReqParamsHTTPVersion);

char* secureblackbox_restclient_getreqparamsifmatch(void* lpObj);
int secureblackbox_restclient_setreqparamsifmatch(void* lpObj, const char* lpszReqParamsIfMatch);

char* secureblackbox_restclient_getreqparamsifmodifiedsince(void* lpObj);
int secureblackbox_restclient_setreqparamsifmodifiedsince(void* lpObj, const char* lpszReqParamsIfModifiedSince);

char* secureblackbox_restclient_getreqparamsifnonematch(void* lpObj);
int secureblackbox_restclient_setreqparamsifnonematch(void* lpObj, const char* lpszReqParamsIfNoneMatch);

char* secureblackbox_restclient_getreqparamsifunmodifiedsince(void* lpObj);
int secureblackbox_restclient_setreqparamsifunmodifiedsince(void* lpObj, const char* lpszReqParamsIfUnmodifiedSince);

char* secureblackbox_restclient_getreqparamspassword(void* lpObj);
int secureblackbox_restclient_setreqparamspassword(void* lpObj, const char* lpszReqParamsPassword);

char* secureblackbox_restclient_getreqparamsreferer(void* lpObj);
int secureblackbox_restclient_setreqparamsreferer(void* lpObj, const char* lpszReqParamsReferer);

char* secureblackbox_restclient_getreqparamsuseragent(void* lpObj);
int secureblackbox_restclient_setreqparamsuseragent(void* lpObj, const char* lpszReqParamsUserAgent);

char* secureblackbox_restclient_getreqparamsusername(void* lpObj);
int secureblackbox_restclient_setreqparamsusername(void* lpObj, const char* lpszReqParamsUsername);

QString GetReqParamsAccept();
int SetReqParamsAccept(QString qsReqParamsAccept);

QString GetReqParamsAcceptCharset();
int SetReqParamsAcceptCharset(QString qsReqParamsAcceptCharset);

QString GetReqParamsAcceptLanguage();
int SetReqParamsAcceptLanguage(QString qsReqParamsAcceptLanguage);

qint64 GetReqParamsAcceptRangeEnd();
int SetReqParamsAcceptRangeEnd(qint64 lReqParamsAcceptRangeEnd);

qint64 GetReqParamsAcceptRangeStart();
int SetReqParamsAcceptRangeStart(qint64 lReqParamsAcceptRangeStart);

QString GetReqParamsAuthorization();
int SetReqParamsAuthorization(QString qsReqParamsAuthorization);

QString GetReqParamsConnection();
int SetReqParamsConnection(QString qsReqParamsConnection);

qint64 GetReqParamsContentLength();
int SetReqParamsContentLength(qint64 lReqParamsContentLength);

qint64 GetReqParamsContentRangeEnd();
int SetReqParamsContentRangeEnd(qint64 lReqParamsContentRangeEnd);

qint64 GetReqParamsContentRangeFullSize();
int SetReqParamsContentRangeFullSize(qint64 lReqParamsContentRangeFullSize);

qint64 GetReqParamsContentRangeStart();
int SetReqParamsContentRangeStart(qint64 lReqParamsContentRangeStart);

QString GetReqParamsContentType();
int SetReqParamsContentType(QString qsReqParamsContentType);

QString GetReqParamsCookie();
int SetReqParamsCookie(QString qsReqParamsCookie);

QString GetReqParamsCustomHeaders();
int SetReqParamsCustomHeaders(QString qsReqParamsCustomHeaders);

QString GetReqParamsDate();
int SetReqParamsDate(QString qsReqParamsDate);

QString GetReqParamsFrom();
int SetReqParamsFrom(QString qsReqParamsFrom);

QString GetReqParamsHost();
int SetReqParamsHost(QString qsReqParamsHost);

int GetReqParamsHTTPVersion();
int SetReqParamsHTTPVersion(int iReqParamsHTTPVersion);

QString GetReqParamsIfMatch();
int SetReqParamsIfMatch(QString qsReqParamsIfMatch);

QString GetReqParamsIfModifiedSince();
int SetReqParamsIfModifiedSince(QString qsReqParamsIfModifiedSince);

QString GetReqParamsIfNoneMatch();
int SetReqParamsIfNoneMatch(QString qsReqParamsIfNoneMatch);

QString GetReqParamsIfUnmodifiedSince();
int SetReqParamsIfUnmodifiedSince(QString qsReqParamsIfUnmodifiedSince);

QString GetReqParamsPassword();
int SetReqParamsPassword(QString qsReqParamsPassword);

QString GetReqParamsReferer();
int SetReqParamsReferer(QString qsReqParamsReferer);

QString GetReqParamsUserAgent();
int SetReqParamsUserAgent(QString qsReqParamsUserAgent);

QString GetReqParamsUsername();
int SetReqParamsUsername(QString qsReqParamsUsername);

int secureblackbox_restclient_getrespheadercount(void* lpObj);

char* secureblackbox_restclient_getrespheadercategory(void* lpObj, int respheaderindex);

int secureblackbox_restclient_getrespheaderformat(void* lpObj, int respheaderindex);

char* secureblackbox_restclient_getrespheadername(void* lpObj, int respheaderindex);

char* secureblackbox_restclient_getrespheadervalue(void* lpObj, int respheaderindex);

int GetRespHeaderCount();

QString GetRespHeaderCategory(int iRespHeaderIndex);

int GetRespHeaderFormat(int iRespHeaderIndex);

QString GetRespHeaderName(int iRespHeaderIndex);

QString GetRespHeaderValue(int iRespHeaderIndex);

int64 secureblackbox_restclient_getrespparamscontentlength(void* lpObj);

char* secureblackbox_restclient_getrespparamsdate(void* lpObj);

char* secureblackbox_restclient_getrespparamsreasonphrase(void* lpObj);

int secureblackbox_restclient_getrespparamsstatuscode(void* lpObj);

qint64 GetRespParamsContentLength();

QString GetRespParamsDate();

QString GetRespParamsReasonPhrase();

int GetRespParamsStatusCode();

int secureblackbox_restclient_getsocketdnsmode(void* lpObj);
int secureblackbox_restclient_setsocketdnsmode(void* lpObj, int iSocketDNSMode);

int secureblackbox_restclient_getsocketdnsport(void* lpObj);
int secureblackbox_restclient_setsocketdnsport(void* lpObj, int iSocketDNSPort);

int secureblackbox_restclient_getsocketdnsquerytimeout(void* lpObj);
int secureblackbox_restclient_setsocketdnsquerytimeout(void* lpObj, int iSocketDNSQueryTimeout);

char* secureblackbox_restclient_getsocketdnsservers(void* lpObj);
int secureblackbox_restclient_setsocketdnsservers(void* lpObj, const char* lpszSocketDNSServers);

int secureblackbox_restclient_getsocketdnstotaltimeout(void* lpObj);
int secureblackbox_restclient_setsocketdnstotaltimeout(void* lpObj, int iSocketDNSTotalTimeout);

int secureblackbox_restclient_getsocketincomingspeedlimit(void* lpObj);
int secureblackbox_restclient_setsocketincomingspeedlimit(void* lpObj, int iSocketIncomingSpeedLimit);

char* secureblackbox_restclient_getsocketlocaladdress(void* lpObj);
int secureblackbox_restclient_setsocketlocaladdress(void* lpObj, const char* lpszSocketLocalAddress);

int secureblackbox_restclient_getsocketlocalport(void* lpObj);
int secureblackbox_restclient_setsocketlocalport(void* lpObj, int iSocketLocalPort);

int secureblackbox_restclient_getsocketoutgoingspeedlimit(void* lpObj);
int secureblackbox_restclient_setsocketoutgoingspeedlimit(void* lpObj, int iSocketOutgoingSpeedLimit);

int secureblackbox_restclient_getsockettimeout(void* lpObj);
int secureblackbox_restclient_setsockettimeout(void* lpObj, int iSocketTimeout);

int secureblackbox_restclient_getsocketuseipv6(void* lpObj);
int secureblackbox_restclient_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_restclient_getstatuscode(void* lpObj);

int GetStatusCode();

int secureblackbox_restclient_gettlsclientcertcount(void* lpObj);
int secureblackbox_restclient_settlsclientcertcount(void* lpObj, int iTLSClientCertCount);

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

int64 secureblackbox_restclient_gettlsclientcerthandle(void* lpObj, int tlsclientcertindex);
int secureblackbox_restclient_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_restclient_gettlsservercertcount(void* lpObj);

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

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

int64 secureblackbox_restclient_gettlsservercerthandle(void* lpObj, int tlsservercertindex);

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

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

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

int secureblackbox_restclient_gettlsservercertkeybits(void* lpObj, int tlsservercertindex);

int secureblackbox_restclient_gettlsservercertkeyusage(void* lpObj, int tlsservercertindex);

int secureblackbox_restclient_gettlsservercertselfsigned(void* lpObj, int tlsservercertindex);

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

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

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

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

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

char* secureblackbox_restclient_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_restclient_gettlsautovalidatecertificates(void* lpObj);
int secureblackbox_restclient_settlsautovalidatecertificates(void* lpObj, int bTLSAutoValidateCertificates);

int secureblackbox_restclient_gettlsbaseconfiguration(void* lpObj);
int secureblackbox_restclient_settlsbaseconfiguration(void* lpObj, int iTLSBaseConfiguration);

char* secureblackbox_restclient_gettlsciphersuites(void* lpObj);
int secureblackbox_restclient_settlsciphersuites(void* lpObj, const char* lpszTLSCiphersuites);

int secureblackbox_restclient_gettlsclientauth(void* lpObj);
int secureblackbox_restclient_settlsclientauth(void* lpObj, int iTLSClientAuth);

char* secureblackbox_restclient_gettlseccurves(void* lpObj);
int secureblackbox_restclient_settlseccurves(void* lpObj, const char* lpszTLSECCurves);

char* secureblackbox_restclient_gettlsextensions(void* lpObj);
int secureblackbox_restclient_settlsextensions(void* lpObj, const char* lpszTLSExtensions);

int secureblackbox_restclient_gettlsforceresumeifdestinationchanges(void* lpObj);
int secureblackbox_restclient_settlsforceresumeifdestinationchanges(void* lpObj, int bTLSForceResumeIfDestinationChanges);

char* secureblackbox_restclient_gettlspresharedidentity(void* lpObj);
int secureblackbox_restclient_settlspresharedidentity(void* lpObj, const char* lpszTLSPreSharedIdentity);

char* secureblackbox_restclient_gettlspresharedkey(void* lpObj);
int secureblackbox_restclient_settlspresharedkey(void* lpObj, const char* lpszTLSPreSharedKey);

char* secureblackbox_restclient_gettlspresharedkeyciphersuite(void* lpObj);
int secureblackbox_restclient_settlspresharedkeyciphersuite(void* lpObj, const char* lpszTLSPreSharedKeyCiphersuite);

int secureblackbox_restclient_gettlsrenegotiationattackpreventionmode(void* lpObj);
int secureblackbox_restclient_settlsrenegotiationattackpreventionmode(void* lpObj, int iTLSRenegotiationAttackPreventionMode);

int secureblackbox_restclient_gettlsrevocationcheck(void* lpObj);
int secureblackbox_restclient_settlsrevocationcheck(void* lpObj, int iTLSRevocationCheck);

int secureblackbox_restclient_gettlsssloptions(void* lpObj);
int secureblackbox_restclient_settlsssloptions(void* lpObj, int iTLSSSLOptions);

int secureblackbox_restclient_gettlstlsmode(void* lpObj);
int secureblackbox_restclient_settlstlsmode(void* lpObj, int iTLSTLSMode);

int secureblackbox_restclient_gettlsuseextendedmastersecret(void* lpObj);
int secureblackbox_restclient_settlsuseextendedmastersecret(void* lpObj, int bTLSUseExtendedMasterSecret);

int secureblackbox_restclient_gettlsusesessionresumption(void* lpObj);
int secureblackbox_restclient_settlsusesessionresumption(void* lpObj, int bTLSUseSessionResumption);

int secureblackbox_restclient_gettlsversions(void* lpObj);
int secureblackbox_restclient_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_restclient_gettrustedcertcount(void* lpObj);
int secureblackbox_restclient_settrustedcertcount(void* lpObj, int iTrustedCertCount);

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

int64 secureblackbox_restclient_gettrustedcerthandle(void* lpObj, int trustedcertindex);
int secureblackbox_restclient_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_restclient_config(void* lpObj, const char* lpszConfigurationString);

QString Config(const QString& qsConfigurationString);

int secureblackbox_restclient_delete(void* lpObj, const char* lpszUrl);

int Delete(const QString& qsUrl);

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

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

int secureblackbox_restclient_get(void* lpObj, const char* lpszUrl);

int Get(const QString& qsUrl);

int secureblackbox_restclient_head(void* lpObj, const char* lpszUrl);

int Head(const QString& qsUrl);

int secureblackbox_restclient_options(void* lpObj, const char* lpszUrl);

int Options(const QString& qsUrl);

int secureblackbox_restclient_post(void* lpObj, const char* lpszUrl, const char* lpszContent);

int Post(const QString& qsUrl, const QString& qsContent);

int secureblackbox_restclient_postbytes(void* lpObj, const char* lpszUrl, const char* lpContentBytes, int lenContentBytes);

int PostBytes(const QString& qsUrl, QByteArray qbaContentBytes);

int secureblackbox_restclient_postfile(void* lpObj, const char* lpszUrl, const char* lpszFileName);

int PostFile(const QString& qsUrl, const QString& qsFileName);

int secureblackbox_restclient_postjson(void* lpObj, const char* lpszUrl, const char* lpszContent);

int PostJSON(const QString& qsUrl, const QString& qsContent);

int secureblackbox_restclient_poststream(void* lpObj, const char* lpszUrl, SecureBlackboxStream* sInputStream);

int PostStream(const QString& qsUrl, SecureBlackboxStream* sInputStream);

int secureblackbox_restclient_postwebform(void* lpObj, const char* lpszUrl, const char* lpszFields, const char* lpszFileField, const char* lpszFileName, const char* lpszContentType);

int PostWebForm(const QString& qsUrl, const QString& qsFields, const QString& qsFileField, const QString& qsFileName, const QString& qsContentType);

int secureblackbox_restclient_postxml(void* lpObj, const char* lpszUrl, const char* lpszContent);

int PostXML(const QString& qsUrl, const QString& qsContent);

int secureblackbox_restclient_put(void* lpObj, const char* lpszUrl, const char* lpszContent);

int Put(const QString& qsUrl, const QString& qsContent);

int secureblackbox_restclient_putbytes(void* lpObj, const char* lpszUrl, const char* lpContentBytes, int lenContentBytes);

int PutBytes(const QString& qsUrl, QByteArray qbaContentBytes);

int secureblackbox_restclient_putfile(void* lpObj, const char* lpszUrl, const char* lpszFileName);

int PutFile(const QString& qsUrl, const QString& qsFileName);

int secureblackbox_restclient_putjson(void* lpObj, const char* lpszUrl, const char* lpszContent);

int PutJSON(const QString& qsUrl, const QString& qsContent);

int secureblackbox_restclient_putstream(void* lpObj, const char* lpszUrl, SecureBlackboxStream* sInputStream);

int PutStream(const QString& qsUrl, SecureBlackboxStream* sInputStream);

int secureblackbox_restclient_putxml(void* lpObj, const char* lpszUrl, const char* lpszContent);

int PutXML(const QString& qsUrl, const QString& qsContent);

int secureblackbox_restclient_reset(void* lpObj);

int Reset();

int secureblackbox_restclient_trace(void* lpObj, const char* lpszUrl);

int Trace(const QString& qsUrl);

#define EID_RESTCLIENT_COOKIE 1

virtual INT SECUREBLACKBOX_CALL FireCookie(LPSTR &lpszCookieText);

class RESTClientCookieEventParams {
public:
  const QString &CookieText();

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

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

// Or, subclass RESTClient and override this emitter function.
virtual int FireCookie(RESTClientCookieEventParams *e) {...}

#define EID_RESTCLIENT_DOCUMENTBEGIN 2

virtual INT SECUREBLACKBOX_CALL FireDocumentBegin();

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

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

// Or, subclass RESTClient and override this emitter function.
virtual int FireDocumentBegin(RESTClientDocumentBeginEventParams *e) {...}

#define EID_RESTCLIENT_DOCUMENTEND 3

virtual INT SECUREBLACKBOX_CALL FireDocumentEnd();

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

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

// Or, subclass RESTClient and override this emitter function.
virtual int FireDocumentEnd(RESTClientDocumentEndEventParams *e) {...}

#define EID_RESTCLIENT_DYNAMICDATANEEDED 4

virtual INT SECUREBLACKBOX_CALL FireDynamicDataNeeded(INT &iBytesNeeded);

class RESTClientDynamicDataNeededEventParams {
public:
  int BytesNeeded();

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

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

// Or, subclass RESTClient and override this emitter function.
virtual int FireDynamicDataNeeded(RESTClientDynamicDataNeededEventParams *e) {...}

#define EID_RESTCLIENT_ERROR 5

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

class RESTClientErrorEventParams {
public:
  int ErrorCode();

  const QString &Description();

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

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

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

#define EID_RESTCLIENT_EXTERNALSIGN 6

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

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

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

#define EID_RESTCLIENT_HEADERSPREPARED 7

virtual INT SECUREBLACKBOX_CALL FireHeadersPrepared();

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

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

// Or, subclass RESTClient and override this emitter function.
virtual int FireHeadersPrepared(RESTClientHeadersPreparedEventParams *e) {...}

#define EID_RESTCLIENT_HEADERSRECEIVED 8

virtual INT SECUREBLACKBOX_CALL FireHeadersReceived();

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

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

// Or, subclass RESTClient and override this emitter function.
virtual int FireHeadersReceived(RESTClientHeadersReceivedEventParams *e) {...}

#define EID_RESTCLIENT_NOTIFICATION 9

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

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

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

#define EID_RESTCLIENT_PROGRESS 10

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

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

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

#define EID_RESTCLIENT_REDIRECTION 11

virtual INT SECUREBLACKBOX_CALL FireRedirection(LPSTR &lpszOldURL, LPSTR &lpszNewURL, BOOL &bAllowRedirection);

class RESTClientRedirectionEventParams {
public:
  const QString &OldURL();

  const QString &NewURL();
  void SetNewURL(const QString &qsNewURL);

  bool AllowRedirection();
  void SetAllowRedirection(bool bAllowRedirection);

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

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

// Or, subclass RESTClient and override this emitter function.
virtual int FireRedirection(RESTClientRedirectionEventParams *e) {...}

#define EID_RESTCLIENT_TLSCERTNEEDED 12

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

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

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

#define EID_RESTCLIENT_TLSCERTVALIDATE 13

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

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

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

#define EID_RESTCLIENT_TLSESTABLISHED 14

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

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

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

#define EID_RESTCLIENT_TLSHANDSHAKE 15

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

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

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

#define EID_RESTCLIENT_TLSPSK 16

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

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

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

#define EID_RESTCLIENT_TLSSHUTDOWN 17

virtual INT SECUREBLACKBOX_CALL FireTLSShutdown(LPSTR &lpszHost);

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

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

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

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