int secureblackbox_httpclient_getauthtypes(void* lpObj);
int secureblackbox_httpclient_setauthtypes(void* lpObj, int iAuthTypes);

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

int secureblackbox_httpclient_getblockedcertcount(void* lpObj);
int secureblackbox_httpclient_setblockedcertcount(void* lpObj, int iBlockedCertCount);

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

int64 secureblackbox_httpclient_getblockedcerthandle(void* lpObj, int blockedcertindex);
int secureblackbox_httpclient_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_httpclient_getconninfoaeadcipher(void* lpObj);

int secureblackbox_httpclient_getconninfochainvalidationdetails(void* lpObj);

int secureblackbox_httpclient_getconninfochainvalidationresult(void* lpObj);

char* secureblackbox_httpclient_getconninfociphersuite(void* lpObj);

int secureblackbox_httpclient_getconninfoclientauthenticated(void* lpObj);

int secureblackbox_httpclient_getconninfoclientauthrequested(void* lpObj);

int secureblackbox_httpclient_getconninfoconnectionestablished(void* lpObj);

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

char* secureblackbox_httpclient_getconninfodigestalgorithm(void* lpObj);

char* secureblackbox_httpclient_getconninfoencryptionalgorithm(void* lpObj);

int secureblackbox_httpclient_getconninfoexportable(void* lpObj);

int64 secureblackbox_httpclient_getconninfoid(void* lpObj);

char* secureblackbox_httpclient_getconninfokeyexchangealgorithm(void* lpObj);

int secureblackbox_httpclient_getconninfokeyexchangekeybits(void* lpObj);

char* secureblackbox_httpclient_getconninfonamedeccurve(void* lpObj);

int secureblackbox_httpclient_getconninfopfscipher(void* lpObj);

char* secureblackbox_httpclient_getconninfopresharedidentity(void* lpObj);

char* secureblackbox_httpclient_getconninfopresharedidentityhint(void* lpObj);

int secureblackbox_httpclient_getconninfopublickeybits(void* lpObj);

char* secureblackbox_httpclient_getconninforemoteaddress(void* lpObj);

int secureblackbox_httpclient_getconninforemoteport(void* lpObj);

int secureblackbox_httpclient_getconninforesumedsession(void* lpObj);

int secureblackbox_httpclient_getconninfosecureconnection(void* lpObj);

int secureblackbox_httpclient_getconninfoserverauthenticated(void* lpObj);

char* secureblackbox_httpclient_getconninfosignaturealgorithm(void* lpObj);

int secureblackbox_httpclient_getconninfosymmetricblocksize(void* lpObj);

int secureblackbox_httpclient_getconninfosymmetrickeybits(void* lpObj);

int64 secureblackbox_httpclient_getconninfototalbytesreceived(void* lpObj);

int64 secureblackbox_httpclient_getconninfototalbytessent(void* lpObj);

char* secureblackbox_httpclient_getconninfovalidationlog(void* lpObj);

char* secureblackbox_httpclient_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_httpclient_getcustomrequest(void* lpObj);
int secureblackbox_httpclient_setcustomrequest(void* lpObj, const char* lpszCustomRequest);

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

int secureblackbox_httpclient_getdynamicdata(void* lpObj, char** lpDynamicData, int* lenDynamicData);
int secureblackbox_httpclient_setdynamicdata(void* lpObj, const char* lpDynamicData, int lenDynamicData);

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

char* secureblackbox_httpclient_getexternalcryptoasyncdocumentid(void* lpObj);
int secureblackbox_httpclient_setexternalcryptoasyncdocumentid(void* lpObj, const char* lpszExternalCryptoAsyncDocumentID);

char* secureblackbox_httpclient_getexternalcryptocustomparams(void* lpObj);
int secureblackbox_httpclient_setexternalcryptocustomparams(void* lpObj, const char* lpszExternalCryptoCustomParams);

char* secureblackbox_httpclient_getexternalcryptodata(void* lpObj);
int secureblackbox_httpclient_setexternalcryptodata(void* lpObj, const char* lpszExternalCryptoData);

int secureblackbox_httpclient_getexternalcryptoexternalhashcalculation(void* lpObj);
int secureblackbox_httpclient_setexternalcryptoexternalhashcalculation(void* lpObj, int bExternalCryptoExternalHashCalculation);

char* secureblackbox_httpclient_getexternalcryptohashalgorithm(void* lpObj);
int secureblackbox_httpclient_setexternalcryptohashalgorithm(void* lpObj, const char* lpszExternalCryptoHashAlgorithm);

char* secureblackbox_httpclient_getexternalcryptokeyid(void* lpObj);
int secureblackbox_httpclient_setexternalcryptokeyid(void* lpObj, const char* lpszExternalCryptoKeyID);

char* secureblackbox_httpclient_getexternalcryptokeysecret(void* lpObj);
int secureblackbox_httpclient_setexternalcryptokeysecret(void* lpObj, const char* lpszExternalCryptoKeySecret);

int secureblackbox_httpclient_getexternalcryptomethod(void* lpObj);
int secureblackbox_httpclient_setexternalcryptomethod(void* lpObj, int iExternalCryptoMethod);

int secureblackbox_httpclient_getexternalcryptomode(void* lpObj);
int secureblackbox_httpclient_setexternalcryptomode(void* lpObj, int iExternalCryptoMode);

char* secureblackbox_httpclient_getexternalcryptopublickeyalgorithm(void* lpObj);
int secureblackbox_httpclient_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_httpclient_getfipsmode(void* lpObj);
int secureblackbox_httpclient_setfipsmode(void* lpObj, int bFIPSMode);

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

int secureblackbox_httpclient_getkeepalivepolicy(void* lpObj);
int secureblackbox_httpclient_setkeepalivepolicy(void* lpObj, int iKeepAlivePolicy);

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

int secureblackbox_httpclient_getknowncertcount(void* lpObj);
int secureblackbox_httpclient_setknowncertcount(void* lpObj, int iKnownCertCount);

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

int64 secureblackbox_httpclient_getknowncerthandle(void* lpObj, int knowncertindex);
int secureblackbox_httpclient_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_httpclient_getknowncrlcount(void* lpObj);
int secureblackbox_httpclient_setknowncrlcount(void* lpObj, int iKnownCRLCount);

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

int64 secureblackbox_httpclient_getknowncrlhandle(void* lpObj, int knowncrlindex);
int secureblackbox_httpclient_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_httpclient_getknownocspcount(void* lpObj);
int secureblackbox_httpclient_setknownocspcount(void* lpObj, int iKnownOCSPCount);

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

int64 secureblackbox_httpclient_getknownocsphandle(void* lpObj, int knownocspindex);
int secureblackbox_httpclient_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_httpclient_getoutputbytes(void* lpObj, char** lpOutputBytes, int* lenOutputBytes);

QByteArray GetOutputBytes();

char* secureblackbox_httpclient_getoutputfile(void* lpObj);
int secureblackbox_httpclient_setoutputfile(void* lpObj, const char* lpszOutputFile);

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

char* secureblackbox_httpclient_getoutputstring(void* lpObj);

QString GetOutputString();

char* secureblackbox_httpclient_getproxyaddress(void* lpObj);
int secureblackbox_httpclient_setproxyaddress(void* lpObj, const char* lpszProxyAddress);

int secureblackbox_httpclient_getproxyauthentication(void* lpObj);
int secureblackbox_httpclient_setproxyauthentication(void* lpObj, int iProxyAuthentication);

char* secureblackbox_httpclient_getproxypassword(void* lpObj);
int secureblackbox_httpclient_setproxypassword(void* lpObj, const char* lpszProxyPassword);

int secureblackbox_httpclient_getproxyport(void* lpObj);
int secureblackbox_httpclient_setproxyport(void* lpObj, int iProxyPort);

int secureblackbox_httpclient_getproxyproxytype(void* lpObj);
int secureblackbox_httpclient_setproxyproxytype(void* lpObj, int iProxyProxyType);

char* secureblackbox_httpclient_getproxyrequestheaders(void* lpObj);
int secureblackbox_httpclient_setproxyrequestheaders(void* lpObj, const char* lpszProxyRequestHeaders);

char* secureblackbox_httpclient_getproxyresponsebody(void* lpObj);
int secureblackbox_httpclient_setproxyresponsebody(void* lpObj, const char* lpszProxyResponseBody);

char* secureblackbox_httpclient_getproxyresponseheaders(void* lpObj);
int secureblackbox_httpclient_setproxyresponseheaders(void* lpObj, const char* lpszProxyResponseHeaders);

int secureblackbox_httpclient_getproxyuseipv6(void* lpObj);
int secureblackbox_httpclient_setproxyuseipv6(void* lpObj, int bProxyUseIPv6);

char* secureblackbox_httpclient_getproxyusername(void* lpObj);
int secureblackbox_httpclient_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_httpclient_getreasonphrase(void* lpObj);

QString GetReasonPhrase();

int secureblackbox_httpclient_getreqheadercount(void* lpObj);
int secureblackbox_httpclient_setreqheadercount(void* lpObj, int iReqHeaderCount);

char* secureblackbox_httpclient_getreqheadercategory(void* lpObj, int reqheaderindex);
int secureblackbox_httpclient_setreqheadercategory(void* lpObj, int reqheaderindex, const char* lpszReqHeaderCategory);

int secureblackbox_httpclient_getreqheaderformat(void* lpObj, int reqheaderindex);
int secureblackbox_httpclient_setreqheaderformat(void* lpObj, int reqheaderindex, int iReqHeaderFormat);

char* secureblackbox_httpclient_getreqheadername(void* lpObj, int reqheaderindex);
int secureblackbox_httpclient_setreqheadername(void* lpObj, int reqheaderindex, const char* lpszReqHeaderName);

char* secureblackbox_httpclient_getreqheadervalue(void* lpObj, int reqheaderindex);
int secureblackbox_httpclient_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_httpclient_getreqparamsaccept(void* lpObj);
int secureblackbox_httpclient_setreqparamsaccept(void* lpObj, const char* lpszReqParamsAccept);

char* secureblackbox_httpclient_getreqparamsacceptcharset(void* lpObj);
int secureblackbox_httpclient_setreqparamsacceptcharset(void* lpObj, const char* lpszReqParamsAcceptCharset);

char* secureblackbox_httpclient_getreqparamsacceptlanguage(void* lpObj);
int secureblackbox_httpclient_setreqparamsacceptlanguage(void* lpObj, const char* lpszReqParamsAcceptLanguage);

int64 secureblackbox_httpclient_getreqparamsacceptrangeend(void* lpObj);
int secureblackbox_httpclient_setreqparamsacceptrangeend(void* lpObj, int64 lReqParamsAcceptRangeEnd);

int64 secureblackbox_httpclient_getreqparamsacceptrangestart(void* lpObj);
int secureblackbox_httpclient_setreqparamsacceptrangestart(void* lpObj, int64 lReqParamsAcceptRangeStart);

char* secureblackbox_httpclient_getreqparamsauthorization(void* lpObj);
int secureblackbox_httpclient_setreqparamsauthorization(void* lpObj, const char* lpszReqParamsAuthorization);

char* secureblackbox_httpclient_getreqparamsconnection(void* lpObj);
int secureblackbox_httpclient_setreqparamsconnection(void* lpObj, const char* lpszReqParamsConnection);

int64 secureblackbox_httpclient_getreqparamscontentlength(void* lpObj);
int secureblackbox_httpclient_setreqparamscontentlength(void* lpObj, int64 lReqParamsContentLength);

int64 secureblackbox_httpclient_getreqparamscontentrangeend(void* lpObj);
int secureblackbox_httpclient_setreqparamscontentrangeend(void* lpObj, int64 lReqParamsContentRangeEnd);

int64 secureblackbox_httpclient_getreqparamscontentrangefullsize(void* lpObj);
int secureblackbox_httpclient_setreqparamscontentrangefullsize(void* lpObj, int64 lReqParamsContentRangeFullSize);

int64 secureblackbox_httpclient_getreqparamscontentrangestart(void* lpObj);
int secureblackbox_httpclient_setreqparamscontentrangestart(void* lpObj, int64 lReqParamsContentRangeStart);

char* secureblackbox_httpclient_getreqparamscontenttype(void* lpObj);
int secureblackbox_httpclient_setreqparamscontenttype(void* lpObj, const char* lpszReqParamsContentType);

char* secureblackbox_httpclient_getreqparamscookie(void* lpObj);
int secureblackbox_httpclient_setreqparamscookie(void* lpObj, const char* lpszReqParamsCookie);

char* secureblackbox_httpclient_getreqparamscustomheaders(void* lpObj);
int secureblackbox_httpclient_setreqparamscustomheaders(void* lpObj, const char* lpszReqParamsCustomHeaders);

char* secureblackbox_httpclient_getreqparamsdate(void* lpObj);
int secureblackbox_httpclient_setreqparamsdate(void* lpObj, const char* lpszReqParamsDate);

char* secureblackbox_httpclient_getreqparamsfrom(void* lpObj);
int secureblackbox_httpclient_setreqparamsfrom(void* lpObj, const char* lpszReqParamsFrom);

char* secureblackbox_httpclient_getreqparamshost(void* lpObj);
int secureblackbox_httpclient_setreqparamshost(void* lpObj, const char* lpszReqParamsHost);

int secureblackbox_httpclient_getreqparamshttpversion(void* lpObj);
int secureblackbox_httpclient_setreqparamshttpversion(void* lpObj, int iReqParamsHTTPVersion);

char* secureblackbox_httpclient_getreqparamsifmatch(void* lpObj);
int secureblackbox_httpclient_setreqparamsifmatch(void* lpObj, const char* lpszReqParamsIfMatch);

char* secureblackbox_httpclient_getreqparamsifmodifiedsince(void* lpObj);
int secureblackbox_httpclient_setreqparamsifmodifiedsince(void* lpObj, const char* lpszReqParamsIfModifiedSince);

char* secureblackbox_httpclient_getreqparamsifnonematch(void* lpObj);
int secureblackbox_httpclient_setreqparamsifnonematch(void* lpObj, const char* lpszReqParamsIfNoneMatch);

char* secureblackbox_httpclient_getreqparamsifunmodifiedsince(void* lpObj);
int secureblackbox_httpclient_setreqparamsifunmodifiedsince(void* lpObj, const char* lpszReqParamsIfUnmodifiedSince);

char* secureblackbox_httpclient_getreqparamspassword(void* lpObj);
int secureblackbox_httpclient_setreqparamspassword(void* lpObj, const char* lpszReqParamsPassword);

char* secureblackbox_httpclient_getreqparamsreferer(void* lpObj);
int secureblackbox_httpclient_setreqparamsreferer(void* lpObj, const char* lpszReqParamsReferer);

char* secureblackbox_httpclient_getreqparamsuseragent(void* lpObj);
int secureblackbox_httpclient_setreqparamsuseragent(void* lpObj, const char* lpszReqParamsUserAgent);

char* secureblackbox_httpclient_getreqparamsusername(void* lpObj);
int secureblackbox_httpclient_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_httpclient_getrespheadercount(void* lpObj);

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

int secureblackbox_httpclient_getrespheaderformat(void* lpObj, int respheaderindex);

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

char* secureblackbox_httpclient_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_httpclient_getrespparamscontentlength(void* lpObj);

char* secureblackbox_httpclient_getrespparamsdate(void* lpObj);

char* secureblackbox_httpclient_getrespparamsreasonphrase(void* lpObj);

int secureblackbox_httpclient_getrespparamsstatuscode(void* lpObj);

qint64 GetRespParamsContentLength();

QString GetRespParamsDate();

QString GetRespParamsReasonPhrase();

int GetRespParamsStatusCode();

int secureblackbox_httpclient_getsocketdnsmode(void* lpObj);
int secureblackbox_httpclient_setsocketdnsmode(void* lpObj, int iSocketDNSMode);

int secureblackbox_httpclient_getsocketdnsport(void* lpObj);
int secureblackbox_httpclient_setsocketdnsport(void* lpObj, int iSocketDNSPort);

int secureblackbox_httpclient_getsocketdnsquerytimeout(void* lpObj);
int secureblackbox_httpclient_setsocketdnsquerytimeout(void* lpObj, int iSocketDNSQueryTimeout);

char* secureblackbox_httpclient_getsocketdnsservers(void* lpObj);
int secureblackbox_httpclient_setsocketdnsservers(void* lpObj, const char* lpszSocketDNSServers);

int secureblackbox_httpclient_getsocketdnstotaltimeout(void* lpObj);
int secureblackbox_httpclient_setsocketdnstotaltimeout(void* lpObj, int iSocketDNSTotalTimeout);

int secureblackbox_httpclient_getsocketincomingspeedlimit(void* lpObj);
int secureblackbox_httpclient_setsocketincomingspeedlimit(void* lpObj, int iSocketIncomingSpeedLimit);

char* secureblackbox_httpclient_getsocketlocaladdress(void* lpObj);
int secureblackbox_httpclient_setsocketlocaladdress(void* lpObj, const char* lpszSocketLocalAddress);

int secureblackbox_httpclient_getsocketlocalport(void* lpObj);
int secureblackbox_httpclient_setsocketlocalport(void* lpObj, int iSocketLocalPort);

int secureblackbox_httpclient_getsocketoutgoingspeedlimit(void* lpObj);
int secureblackbox_httpclient_setsocketoutgoingspeedlimit(void* lpObj, int iSocketOutgoingSpeedLimit);

int secureblackbox_httpclient_getsockettimeout(void* lpObj);
int secureblackbox_httpclient_setsockettimeout(void* lpObj, int iSocketTimeout);

int secureblackbox_httpclient_getsocketuseipv6(void* lpObj);
int secureblackbox_httpclient_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_httpclient_getstatuscode(void* lpObj);

int GetStatusCode();

int secureblackbox_httpclient_gettlsclientcertcount(void* lpObj);
int secureblackbox_httpclient_settlsclientcertcount(void* lpObj, int iTLSClientCertCount);

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

int64 secureblackbox_httpclient_gettlsclientcerthandle(void* lpObj, int tlsclientcertindex);
int secureblackbox_httpclient_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_httpclient_gettlsservercertcount(void* lpObj);

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

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

int64 secureblackbox_httpclient_gettlsservercerthandle(void* lpObj, int tlsservercertindex);

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

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

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

int secureblackbox_httpclient_gettlsservercertkeybits(void* lpObj, int tlsservercertindex);

int secureblackbox_httpclient_gettlsservercertkeyusage(void* lpObj, int tlsservercertindex);

int secureblackbox_httpclient_gettlsservercertselfsigned(void* lpObj, int tlsservercertindex);

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

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

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

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

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

char* secureblackbox_httpclient_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_httpclient_gettlsautovalidatecertificates(void* lpObj);
int secureblackbox_httpclient_settlsautovalidatecertificates(void* lpObj, int bTLSAutoValidateCertificates);

int secureblackbox_httpclient_gettlsbaseconfiguration(void* lpObj);
int secureblackbox_httpclient_settlsbaseconfiguration(void* lpObj, int iTLSBaseConfiguration);

char* secureblackbox_httpclient_gettlsciphersuites(void* lpObj);
int secureblackbox_httpclient_settlsciphersuites(void* lpObj, const char* lpszTLSCiphersuites);

int secureblackbox_httpclient_gettlsclientauth(void* lpObj);
int secureblackbox_httpclient_settlsclientauth(void* lpObj, int iTLSClientAuth);

char* secureblackbox_httpclient_gettlseccurves(void* lpObj);
int secureblackbox_httpclient_settlseccurves(void* lpObj, const char* lpszTLSECCurves);

char* secureblackbox_httpclient_gettlsextensions(void* lpObj);
int secureblackbox_httpclient_settlsextensions(void* lpObj, const char* lpszTLSExtensions);

int secureblackbox_httpclient_gettlsforceresumeifdestinationchanges(void* lpObj);
int secureblackbox_httpclient_settlsforceresumeifdestinationchanges(void* lpObj, int bTLSForceResumeIfDestinationChanges);

char* secureblackbox_httpclient_gettlspresharedidentity(void* lpObj);
int secureblackbox_httpclient_settlspresharedidentity(void* lpObj, const char* lpszTLSPreSharedIdentity);

char* secureblackbox_httpclient_gettlspresharedkey(void* lpObj);
int secureblackbox_httpclient_settlspresharedkey(void* lpObj, const char* lpszTLSPreSharedKey);

char* secureblackbox_httpclient_gettlspresharedkeyciphersuite(void* lpObj);
int secureblackbox_httpclient_settlspresharedkeyciphersuite(void* lpObj, const char* lpszTLSPreSharedKeyCiphersuite);

int secureblackbox_httpclient_gettlsrenegotiationattackpreventionmode(void* lpObj);
int secureblackbox_httpclient_settlsrenegotiationattackpreventionmode(void* lpObj, int iTLSRenegotiationAttackPreventionMode);

int secureblackbox_httpclient_gettlsrevocationcheck(void* lpObj);
int secureblackbox_httpclient_settlsrevocationcheck(void* lpObj, int iTLSRevocationCheck);

int secureblackbox_httpclient_gettlsssloptions(void* lpObj);
int secureblackbox_httpclient_settlsssloptions(void* lpObj, int iTLSSSLOptions);

int secureblackbox_httpclient_gettlstlsmode(void* lpObj);
int secureblackbox_httpclient_settlstlsmode(void* lpObj, int iTLSTLSMode);

int secureblackbox_httpclient_gettlsuseextendedmastersecret(void* lpObj);
int secureblackbox_httpclient_settlsuseextendedmastersecret(void* lpObj, int bTLSUseExtendedMasterSecret);

int secureblackbox_httpclient_gettlsusesessionresumption(void* lpObj);
int secureblackbox_httpclient_settlsusesessionresumption(void* lpObj, int bTLSUseSessionResumption);

int secureblackbox_httpclient_gettlsversions(void* lpObj);
int secureblackbox_httpclient_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_httpclient_gettrustedcertcount(void* lpObj);
int secureblackbox_httpclient_settrustedcertcount(void* lpObj, int iTrustedCertCount);

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

int64 secureblackbox_httpclient_gettrustedcerthandle(void* lpObj, int trustedcertindex);
int secureblackbox_httpclient_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_httpclient_config(void* lpObj, const char* lpszConfigurationString);

QString Config(const QString& qsConfigurationString);

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

int Delete(const QString& qsUrl);

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

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

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

int Get(const QString& qsUrl);

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

int Head(const QString& qsUrl);

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

int Options(const QString& qsUrl);

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

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

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

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

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

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

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

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

int secureblackbox_httpclient_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_httpclient_put(void* lpObj, const char* lpszUrl, const char* lpszContent);

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

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

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

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

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

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

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

int secureblackbox_httpclient_reset(void* lpObj);

int Reset();

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

int Trace(const QString& qsUrl);

#define EID_HTTPCLIENT_COOKIE 1

virtual INT SECUREBLACKBOX_CALL FireCookie(LPSTR &lpszCookieText);

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

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

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

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

#define EID_HTTPCLIENT_DOCUMENTBEGIN 2

virtual INT SECUREBLACKBOX_CALL FireDocumentBegin();

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

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

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

#define EID_HTTPCLIENT_DOCUMENTEND 3

virtual INT SECUREBLACKBOX_CALL FireDocumentEnd();

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

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

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

#define EID_HTTPCLIENT_DYNAMICDATANEEDED 4

virtual INT SECUREBLACKBOX_CALL FireDynamicDataNeeded(INT &iBytesNeeded);

class HTTPClientDynamicDataNeededEventParams {
public:
  int BytesNeeded();

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

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

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

#define EID_HTTPCLIENT_ERROR 5

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

class HTTPClientErrorEventParams {
public:
  int ErrorCode();

  const QString &Description();

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

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

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

#define EID_HTTPCLIENT_EXTERNALSIGN 6

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

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

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

#define EID_HTTPCLIENT_HEADERSPREPARED 7

virtual INT SECUREBLACKBOX_CALL FireHeadersPrepared();

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

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

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

#define EID_HTTPCLIENT_HEADERSRECEIVED 8

virtual INT SECUREBLACKBOX_CALL FireHeadersReceived();

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

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

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

#define EID_HTTPCLIENT_NOTIFICATION 9

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

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

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

#define EID_HTTPCLIENT_PROGRESS 10

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

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

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

#define EID_HTTPCLIENT_REDIRECTION 11

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

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

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

#define EID_HTTPCLIENT_TLSCERTNEEDED 12

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

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

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

#define EID_HTTPCLIENT_TLSCERTVALIDATE 13

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

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

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

#define EID_HTTPCLIENT_TLSESTABLISHED 14

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

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

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

#define EID_HTTPCLIENT_TLSHANDSHAKE 15

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

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

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

#define EID_HTTPCLIENT_TLSPSK 16

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

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

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

#define EID_HTTPCLIENT_TLSSHUTDOWN 17

virtual INT SECUREBLACKBOX_CALL FireTLSShutdown(LPSTR &lpszHost);

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

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

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

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