int secureblackbox_soapclient_getattachmentbytes(void* lpObj, char** lpAttachmentBytes, int* lenAttachmentBytes);
int secureblackbox_soapclient_setattachmentbytes(void* lpObj, const char* lpAttachmentBytes, int lenAttachmentBytes);

QByteArray GetAttachmentBytes();
int SetAttachmentBytes(QByteArray qbaAttachmentBytes);

char* secureblackbox_soapclient_getattachmentfile(void* lpObj);
int secureblackbox_soapclient_setattachmentfile(void* lpObj, const char* lpszAttachmentFile);

QString GetAttachmentFile();
int SetAttachmentFile(QString qsAttachmentFile);

int secureblackbox_soapclient_getauthtypes(void* lpObj);
int secureblackbox_soapclient_setauthtypes(void* lpObj, int iAuthTypes);

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

int secureblackbox_soapclient_getblockedcertcount(void* lpObj);
int secureblackbox_soapclient_setblockedcertcount(void* lpObj, int iBlockedCertCount);

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

int64 secureblackbox_soapclient_getblockedcerthandle(void* lpObj, int blockedcertindex);
int secureblackbox_soapclient_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_soapclient_getconninfoaeadcipher(void* lpObj);

int secureblackbox_soapclient_getconninfochainvalidationdetails(void* lpObj);

int secureblackbox_soapclient_getconninfochainvalidationresult(void* lpObj);

char* secureblackbox_soapclient_getconninfociphersuite(void* lpObj);

int secureblackbox_soapclient_getconninfoclientauthenticated(void* lpObj);

int secureblackbox_soapclient_getconninfoclientauthrequested(void* lpObj);

int secureblackbox_soapclient_getconninfoconnectionestablished(void* lpObj);

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

char* secureblackbox_soapclient_getconninfodigestalgorithm(void* lpObj);

char* secureblackbox_soapclient_getconninfoencryptionalgorithm(void* lpObj);

int secureblackbox_soapclient_getconninfoexportable(void* lpObj);

int64 secureblackbox_soapclient_getconninfoid(void* lpObj);

char* secureblackbox_soapclient_getconninfokeyexchangealgorithm(void* lpObj);

int secureblackbox_soapclient_getconninfokeyexchangekeybits(void* lpObj);

char* secureblackbox_soapclient_getconninfonamedeccurve(void* lpObj);

int secureblackbox_soapclient_getconninfopfscipher(void* lpObj);

char* secureblackbox_soapclient_getconninfopresharedidentity(void* lpObj);

char* secureblackbox_soapclient_getconninfopresharedidentityhint(void* lpObj);

int secureblackbox_soapclient_getconninfopublickeybits(void* lpObj);

char* secureblackbox_soapclient_getconninforemoteaddress(void* lpObj);

int secureblackbox_soapclient_getconninforemoteport(void* lpObj);

int secureblackbox_soapclient_getconninforesumedsession(void* lpObj);

int secureblackbox_soapclient_getconninfosecureconnection(void* lpObj);

int secureblackbox_soapclient_getconninfoserverauthenticated(void* lpObj);

char* secureblackbox_soapclient_getconninfosignaturealgorithm(void* lpObj);

int secureblackbox_soapclient_getconninfosymmetricblocksize(void* lpObj);

int secureblackbox_soapclient_getconninfosymmetrickeybits(void* lpObj);

int64 secureblackbox_soapclient_getconninfototalbytesreceived(void* lpObj);

int64 secureblackbox_soapclient_getconninfototalbytessent(void* lpObj);

char* secureblackbox_soapclient_getconninfovalidationlog(void* lpObj);

char* secureblackbox_soapclient_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_soapclient_getencoding(void* lpObj);
int secureblackbox_soapclient_setencoding(void* lpObj, const char* lpszEncoding);

QString GetEncoding();
int SetEncoding(QString qsEncoding);

char* secureblackbox_soapclient_getexternalcryptoasyncdocumentid(void* lpObj);
int secureblackbox_soapclient_setexternalcryptoasyncdocumentid(void* lpObj, const char* lpszExternalCryptoAsyncDocumentID);

char* secureblackbox_soapclient_getexternalcryptocustomparams(void* lpObj);
int secureblackbox_soapclient_setexternalcryptocustomparams(void* lpObj, const char* lpszExternalCryptoCustomParams);

char* secureblackbox_soapclient_getexternalcryptodata(void* lpObj);
int secureblackbox_soapclient_setexternalcryptodata(void* lpObj, const char* lpszExternalCryptoData);

int secureblackbox_soapclient_getexternalcryptoexternalhashcalculation(void* lpObj);
int secureblackbox_soapclient_setexternalcryptoexternalhashcalculation(void* lpObj, int bExternalCryptoExternalHashCalculation);

char* secureblackbox_soapclient_getexternalcryptohashalgorithm(void* lpObj);
int secureblackbox_soapclient_setexternalcryptohashalgorithm(void* lpObj, const char* lpszExternalCryptoHashAlgorithm);

char* secureblackbox_soapclient_getexternalcryptokeyid(void* lpObj);
int secureblackbox_soapclient_setexternalcryptokeyid(void* lpObj, const char* lpszExternalCryptoKeyID);

char* secureblackbox_soapclient_getexternalcryptokeysecret(void* lpObj);
int secureblackbox_soapclient_setexternalcryptokeysecret(void* lpObj, const char* lpszExternalCryptoKeySecret);

int secureblackbox_soapclient_getexternalcryptomethod(void* lpObj);
int secureblackbox_soapclient_setexternalcryptomethod(void* lpObj, int iExternalCryptoMethod);

int secureblackbox_soapclient_getexternalcryptomode(void* lpObj);
int secureblackbox_soapclient_setexternalcryptomode(void* lpObj, int iExternalCryptoMode);

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

char* secureblackbox_soapclient_getfaultactor(void* lpObj);

QString GetFaultActor();

char* secureblackbox_soapclient_getfaultcode(void* lpObj);

QString GetFaultCode();

char* secureblackbox_soapclient_getfaultdetail(void* lpObj);

QString GetFaultDetail();

char* secureblackbox_soapclient_getfaultstring(void* lpObj);

QString GetFaultString();

int secureblackbox_soapclient_getfipsmode(void* lpObj);
int secureblackbox_soapclient_setfipsmode(void* lpObj, int bFIPSMode);

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

int secureblackbox_soapclient_getinputbytes(void* lpObj, char** lpInputBytes, int* lenInputBytes);
int secureblackbox_soapclient_setinputbytes(void* lpObj, const char* lpInputBytes, int lenInputBytes);

QByteArray GetInputBytes();
int SetInputBytes(QByteArray qbaInputBytes);

char* secureblackbox_soapclient_getinputfile(void* lpObj);
int secureblackbox_soapclient_setinputfile(void* lpObj, const char* lpszInputFile);

QString GetInputFile();
int SetInputFile(QString qsInputFile);

int secureblackbox_soapclient_getkeepalivepolicy(void* lpObj);
int secureblackbox_soapclient_setkeepalivepolicy(void* lpObj, int iKeepAlivePolicy);

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

int secureblackbox_soapclient_getknowncertcount(void* lpObj);
int secureblackbox_soapclient_setknowncertcount(void* lpObj, int iKnownCertCount);

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

int64 secureblackbox_soapclient_getknowncerthandle(void* lpObj, int knowncertindex);
int secureblackbox_soapclient_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_soapclient_getknowncrlcount(void* lpObj);
int secureblackbox_soapclient_setknowncrlcount(void* lpObj, int iKnownCRLCount);

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

int64 secureblackbox_soapclient_getknowncrlhandle(void* lpObj, int knowncrlindex);
int secureblackbox_soapclient_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_soapclient_getknownocspcount(void* lpObj);
int secureblackbox_soapclient_setknownocspcount(void* lpObj, int iKnownOCSPCount);

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

int64 secureblackbox_soapclient_getknownocsphandle(void* lpObj, int knownocspindex);
int secureblackbox_soapclient_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);

char* secureblackbox_soapclient_getmimetype(void* lpObj);
int secureblackbox_soapclient_setmimetype(void* lpObj, const char* lpszMimeType);

QString GetMimeType();
int SetMimeType(QString qsMimeType);

char* secureblackbox_soapclient_getoperationname(void* lpObj);
int secureblackbox_soapclient_setoperationname(void* lpObj, const char* lpszOperationName);

QString GetOperationName();
int SetOperationName(QString qsOperationName);

char* secureblackbox_soapclient_getoperationnamespaceuri(void* lpObj);
int secureblackbox_soapclient_setoperationnamespaceuri(void* lpObj, const char* lpszOperationNamespaceURI);

QString GetOperationNamespaceURI();
int SetOperationNamespaceURI(QString qsOperationNamespaceURI);

char* secureblackbox_soapclient_getoperationresponsename(void* lpObj);

QString GetOperationResponseName();

char* secureblackbox_soapclient_getoperationresponsenamespaceuri(void* lpObj);

QString GetOperationResponseNamespaceURI();

char* secureblackbox_soapclient_getoperationresponsetextcontent(void* lpObj);

QString GetOperationResponseTextContent();

char* secureblackbox_soapclient_getoperationresponsexml(void* lpObj);

QString GetOperationResponseXML();

int secureblackbox_soapclient_getoutputattachmentbytes(void* lpObj, char** lpOutputAttachmentBytes, int* lenOutputAttachmentBytes);

QByteArray GetOutputAttachmentBytes();

char* secureblackbox_soapclient_getoutputattachmentfile(void* lpObj);
int secureblackbox_soapclient_setoutputattachmentfile(void* lpObj, const char* lpszOutputAttachmentFile);

QString GetOutputAttachmentFile();
int SetOutputAttachmentFile(QString qsOutputAttachmentFile);

int secureblackbox_soapclient_getoutputbytes(void* lpObj, char** lpOutputBytes, int* lenOutputBytes);

QByteArray GetOutputBytes();

char* secureblackbox_soapclient_getoutputfile(void* lpObj);
int secureblackbox_soapclient_setoutputfile(void* lpObj, const char* lpszOutputFile);

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

char* secureblackbox_soapclient_getproxyaddress(void* lpObj);
int secureblackbox_soapclient_setproxyaddress(void* lpObj, const char* lpszProxyAddress);

int secureblackbox_soapclient_getproxyauthentication(void* lpObj);
int secureblackbox_soapclient_setproxyauthentication(void* lpObj, int iProxyAuthentication);

char* secureblackbox_soapclient_getproxypassword(void* lpObj);
int secureblackbox_soapclient_setproxypassword(void* lpObj, const char* lpszProxyPassword);

int secureblackbox_soapclient_getproxyport(void* lpObj);
int secureblackbox_soapclient_setproxyport(void* lpObj, int iProxyPort);

int secureblackbox_soapclient_getproxyproxytype(void* lpObj);
int secureblackbox_soapclient_setproxyproxytype(void* lpObj, int iProxyProxyType);

char* secureblackbox_soapclient_getproxyrequestheaders(void* lpObj);
int secureblackbox_soapclient_setproxyrequestheaders(void* lpObj, const char* lpszProxyRequestHeaders);

char* secureblackbox_soapclient_getproxyresponsebody(void* lpObj);
int secureblackbox_soapclient_setproxyresponsebody(void* lpObj, const char* lpszProxyResponseBody);

char* secureblackbox_soapclient_getproxyresponseheaders(void* lpObj);
int secureblackbox_soapclient_setproxyresponseheaders(void* lpObj, const char* lpszProxyResponseHeaders);

int secureblackbox_soapclient_getproxyuseipv6(void* lpObj);
int secureblackbox_soapclient_setproxyuseipv6(void* lpObj, int bProxyUseIPv6);

char* secureblackbox_soapclient_getproxyusername(void* lpObj);
int secureblackbox_soapclient_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_soapclient_getreasonphrase(void* lpObj);

QString GetReasonPhrase();

int secureblackbox_soapclient_getreqheadercount(void* lpObj);
int secureblackbox_soapclient_setreqheadercount(void* lpObj, int iReqHeaderCount);

char* secureblackbox_soapclient_getreqheadercategory(void* lpObj, int reqheaderindex);
int secureblackbox_soapclient_setreqheadercategory(void* lpObj, int reqheaderindex, const char* lpszReqHeaderCategory);

int secureblackbox_soapclient_getreqheaderformat(void* lpObj, int reqheaderindex);
int secureblackbox_soapclient_setreqheaderformat(void* lpObj, int reqheaderindex, int iReqHeaderFormat);

char* secureblackbox_soapclient_getreqheadername(void* lpObj, int reqheaderindex);
int secureblackbox_soapclient_setreqheadername(void* lpObj, int reqheaderindex, const char* lpszReqHeaderName);

char* secureblackbox_soapclient_getreqheadervalue(void* lpObj, int reqheaderindex);
int secureblackbox_soapclient_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_soapclient_getreqparamsaccept(void* lpObj);
int secureblackbox_soapclient_setreqparamsaccept(void* lpObj, const char* lpszReqParamsAccept);

char* secureblackbox_soapclient_getreqparamsacceptcharset(void* lpObj);
int secureblackbox_soapclient_setreqparamsacceptcharset(void* lpObj, const char* lpszReqParamsAcceptCharset);

char* secureblackbox_soapclient_getreqparamsacceptlanguage(void* lpObj);
int secureblackbox_soapclient_setreqparamsacceptlanguage(void* lpObj, const char* lpszReqParamsAcceptLanguage);

int64 secureblackbox_soapclient_getreqparamsacceptrangeend(void* lpObj);
int secureblackbox_soapclient_setreqparamsacceptrangeend(void* lpObj, int64 lReqParamsAcceptRangeEnd);

int64 secureblackbox_soapclient_getreqparamsacceptrangestart(void* lpObj);
int secureblackbox_soapclient_setreqparamsacceptrangestart(void* lpObj, int64 lReqParamsAcceptRangeStart);

char* secureblackbox_soapclient_getreqparamsauthorization(void* lpObj);
int secureblackbox_soapclient_setreqparamsauthorization(void* lpObj, const char* lpszReqParamsAuthorization);

char* secureblackbox_soapclient_getreqparamsconnection(void* lpObj);
int secureblackbox_soapclient_setreqparamsconnection(void* lpObj, const char* lpszReqParamsConnection);

int64 secureblackbox_soapclient_getreqparamscontentlength(void* lpObj);
int secureblackbox_soapclient_setreqparamscontentlength(void* lpObj, int64 lReqParamsContentLength);

int64 secureblackbox_soapclient_getreqparamscontentrangeend(void* lpObj);
int secureblackbox_soapclient_setreqparamscontentrangeend(void* lpObj, int64 lReqParamsContentRangeEnd);

int64 secureblackbox_soapclient_getreqparamscontentrangefullsize(void* lpObj);
int secureblackbox_soapclient_setreqparamscontentrangefullsize(void* lpObj, int64 lReqParamsContentRangeFullSize);

int64 secureblackbox_soapclient_getreqparamscontentrangestart(void* lpObj);
int secureblackbox_soapclient_setreqparamscontentrangestart(void* lpObj, int64 lReqParamsContentRangeStart);

char* secureblackbox_soapclient_getreqparamscontenttype(void* lpObj);
int secureblackbox_soapclient_setreqparamscontenttype(void* lpObj, const char* lpszReqParamsContentType);

char* secureblackbox_soapclient_getreqparamscookie(void* lpObj);
int secureblackbox_soapclient_setreqparamscookie(void* lpObj, const char* lpszReqParamsCookie);

char* secureblackbox_soapclient_getreqparamscustomheaders(void* lpObj);
int secureblackbox_soapclient_setreqparamscustomheaders(void* lpObj, const char* lpszReqParamsCustomHeaders);

char* secureblackbox_soapclient_getreqparamsdate(void* lpObj);
int secureblackbox_soapclient_setreqparamsdate(void* lpObj, const char* lpszReqParamsDate);

char* secureblackbox_soapclient_getreqparamsfrom(void* lpObj);
int secureblackbox_soapclient_setreqparamsfrom(void* lpObj, const char* lpszReqParamsFrom);

char* secureblackbox_soapclient_getreqparamshost(void* lpObj);
int secureblackbox_soapclient_setreqparamshost(void* lpObj, const char* lpszReqParamsHost);

int secureblackbox_soapclient_getreqparamshttpversion(void* lpObj);
int secureblackbox_soapclient_setreqparamshttpversion(void* lpObj, int iReqParamsHTTPVersion);

char* secureblackbox_soapclient_getreqparamsifmatch(void* lpObj);
int secureblackbox_soapclient_setreqparamsifmatch(void* lpObj, const char* lpszReqParamsIfMatch);

char* secureblackbox_soapclient_getreqparamsifmodifiedsince(void* lpObj);
int secureblackbox_soapclient_setreqparamsifmodifiedsince(void* lpObj, const char* lpszReqParamsIfModifiedSince);

char* secureblackbox_soapclient_getreqparamsifnonematch(void* lpObj);
int secureblackbox_soapclient_setreqparamsifnonematch(void* lpObj, const char* lpszReqParamsIfNoneMatch);

char* secureblackbox_soapclient_getreqparamsifunmodifiedsince(void* lpObj);
int secureblackbox_soapclient_setreqparamsifunmodifiedsince(void* lpObj, const char* lpszReqParamsIfUnmodifiedSince);

char* secureblackbox_soapclient_getreqparamspassword(void* lpObj);
int secureblackbox_soapclient_setreqparamspassword(void* lpObj, const char* lpszReqParamsPassword);

char* secureblackbox_soapclient_getreqparamsreferer(void* lpObj);
int secureblackbox_soapclient_setreqparamsreferer(void* lpObj, const char* lpszReqParamsReferer);

char* secureblackbox_soapclient_getreqparamsuseragent(void* lpObj);
int secureblackbox_soapclient_setreqparamsuseragent(void* lpObj, const char* lpszReqParamsUserAgent);

char* secureblackbox_soapclient_getreqparamsusername(void* lpObj);
int secureblackbox_soapclient_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_soapclient_getrespheadercount(void* lpObj);

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

int secureblackbox_soapclient_getrespheaderformat(void* lpObj, int respheaderindex);

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

char* secureblackbox_soapclient_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_soapclient_getrespparamscontentlength(void* lpObj);

char* secureblackbox_soapclient_getrespparamsdate(void* lpObj);

char* secureblackbox_soapclient_getrespparamsreasonphrase(void* lpObj);

int secureblackbox_soapclient_getrespparamsstatuscode(void* lpObj);

qint64 GetRespParamsContentLength();

QString GetRespParamsDate();

QString GetRespParamsReasonPhrase();

int GetRespParamsStatusCode();

char* secureblackbox_soapclient_getsoapaction(void* lpObj);
int secureblackbox_soapclient_setsoapaction(void* lpObj, const char* lpszSOAPAction);

QString GetSOAPAction();
int SetSOAPAction(QString qsSOAPAction);

int secureblackbox_soapclient_getsoapresponsetype(void* lpObj);

int GetSOAPResponseType();

int secureblackbox_soapclient_getsoapversion(void* lpObj);
int secureblackbox_soapclient_setsoapversion(void* lpObj, int iSOAPVersion);

int GetSOAPVersion();
int SetSOAPVersion(int iSOAPVersion);

int secureblackbox_soapclient_getsocketdnsmode(void* lpObj);
int secureblackbox_soapclient_setsocketdnsmode(void* lpObj, int iSocketDNSMode);

int secureblackbox_soapclient_getsocketdnsport(void* lpObj);
int secureblackbox_soapclient_setsocketdnsport(void* lpObj, int iSocketDNSPort);

int secureblackbox_soapclient_getsocketdnsquerytimeout(void* lpObj);
int secureblackbox_soapclient_setsocketdnsquerytimeout(void* lpObj, int iSocketDNSQueryTimeout);

char* secureblackbox_soapclient_getsocketdnsservers(void* lpObj);
int secureblackbox_soapclient_setsocketdnsservers(void* lpObj, const char* lpszSocketDNSServers);

int secureblackbox_soapclient_getsocketdnstotaltimeout(void* lpObj);
int secureblackbox_soapclient_setsocketdnstotaltimeout(void* lpObj, int iSocketDNSTotalTimeout);

int secureblackbox_soapclient_getsocketincomingspeedlimit(void* lpObj);
int secureblackbox_soapclient_setsocketincomingspeedlimit(void* lpObj, int iSocketIncomingSpeedLimit);

char* secureblackbox_soapclient_getsocketlocaladdress(void* lpObj);
int secureblackbox_soapclient_setsocketlocaladdress(void* lpObj, const char* lpszSocketLocalAddress);

int secureblackbox_soapclient_getsocketlocalport(void* lpObj);
int secureblackbox_soapclient_setsocketlocalport(void* lpObj, int iSocketLocalPort);

int secureblackbox_soapclient_getsocketoutgoingspeedlimit(void* lpObj);
int secureblackbox_soapclient_setsocketoutgoingspeedlimit(void* lpObj, int iSocketOutgoingSpeedLimit);

int secureblackbox_soapclient_getsockettimeout(void* lpObj);
int secureblackbox_soapclient_setsockettimeout(void* lpObj, int iSocketTimeout);

int secureblackbox_soapclient_getsocketuseipv6(void* lpObj);
int secureblackbox_soapclient_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_soapclient_getstatuscode(void* lpObj);

int GetStatusCode();

int secureblackbox_soapclient_gettlsclientcertcount(void* lpObj);
int secureblackbox_soapclient_settlsclientcertcount(void* lpObj, int iTLSClientCertCount);

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

int64 secureblackbox_soapclient_gettlsclientcerthandle(void* lpObj, int tlsclientcertindex);
int secureblackbox_soapclient_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_soapclient_gettlsservercertcount(void* lpObj);

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

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

int64 secureblackbox_soapclient_gettlsservercerthandle(void* lpObj, int tlsservercertindex);

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

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

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

int secureblackbox_soapclient_gettlsservercertkeybits(void* lpObj, int tlsservercertindex);

int secureblackbox_soapclient_gettlsservercertkeyusage(void* lpObj, int tlsservercertindex);

int secureblackbox_soapclient_gettlsservercertselfsigned(void* lpObj, int tlsservercertindex);

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

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

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

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

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

char* secureblackbox_soapclient_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_soapclient_gettlsautovalidatecertificates(void* lpObj);
int secureblackbox_soapclient_settlsautovalidatecertificates(void* lpObj, int bTLSAutoValidateCertificates);

int secureblackbox_soapclient_gettlsbaseconfiguration(void* lpObj);
int secureblackbox_soapclient_settlsbaseconfiguration(void* lpObj, int iTLSBaseConfiguration);

char* secureblackbox_soapclient_gettlsciphersuites(void* lpObj);
int secureblackbox_soapclient_settlsciphersuites(void* lpObj, const char* lpszTLSCiphersuites);

int secureblackbox_soapclient_gettlsclientauth(void* lpObj);
int secureblackbox_soapclient_settlsclientauth(void* lpObj, int iTLSClientAuth);

char* secureblackbox_soapclient_gettlseccurves(void* lpObj);
int secureblackbox_soapclient_settlseccurves(void* lpObj, const char* lpszTLSECCurves);

char* secureblackbox_soapclient_gettlsextensions(void* lpObj);
int secureblackbox_soapclient_settlsextensions(void* lpObj, const char* lpszTLSExtensions);

int secureblackbox_soapclient_gettlsforceresumeifdestinationchanges(void* lpObj);
int secureblackbox_soapclient_settlsforceresumeifdestinationchanges(void* lpObj, int bTLSForceResumeIfDestinationChanges);

char* secureblackbox_soapclient_gettlspresharedidentity(void* lpObj);
int secureblackbox_soapclient_settlspresharedidentity(void* lpObj, const char* lpszTLSPreSharedIdentity);

char* secureblackbox_soapclient_gettlspresharedkey(void* lpObj);
int secureblackbox_soapclient_settlspresharedkey(void* lpObj, const char* lpszTLSPreSharedKey);

char* secureblackbox_soapclient_gettlspresharedkeyciphersuite(void* lpObj);
int secureblackbox_soapclient_settlspresharedkeyciphersuite(void* lpObj, const char* lpszTLSPreSharedKeyCiphersuite);

int secureblackbox_soapclient_gettlsrenegotiationattackpreventionmode(void* lpObj);
int secureblackbox_soapclient_settlsrenegotiationattackpreventionmode(void* lpObj, int iTLSRenegotiationAttackPreventionMode);

int secureblackbox_soapclient_gettlsrevocationcheck(void* lpObj);
int secureblackbox_soapclient_settlsrevocationcheck(void* lpObj, int iTLSRevocationCheck);

int secureblackbox_soapclient_gettlsssloptions(void* lpObj);
int secureblackbox_soapclient_settlsssloptions(void* lpObj, int iTLSSSLOptions);

int secureblackbox_soapclient_gettlstlsmode(void* lpObj);
int secureblackbox_soapclient_settlstlsmode(void* lpObj, int iTLSTLSMode);

int secureblackbox_soapclient_gettlsuseextendedmastersecret(void* lpObj);
int secureblackbox_soapclient_settlsuseextendedmastersecret(void* lpObj, int bTLSUseExtendedMasterSecret);

int secureblackbox_soapclient_gettlsusesessionresumption(void* lpObj);
int secureblackbox_soapclient_settlsusesessionresumption(void* lpObj, int bTLSUseSessionResumption);

int secureblackbox_soapclient_gettlsversions(void* lpObj);
int secureblackbox_soapclient_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_soapclient_gettrustedcertcount(void* lpObj);
int secureblackbox_soapclient_settrustedcertcount(void* lpObj, int iTrustedCertCount);

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

int64 secureblackbox_soapclient_gettrustedcerthandle(void* lpObj, int trustedcertindex);
int secureblackbox_soapclient_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_soapclient_config(void* lpObj, const char* lpszConfigurationString);

QString Config(const QString& qsConfigurationString);

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

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

int secureblackbox_soapclient_reset(void* lpObj);

int Reset();

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

int SendMessage(const QString& qsUrl);

int secureblackbox_soapclient_sendmessagewithattachments(void* lpObj, const char* lpszUrl, const char* lpszPrimaryMessageId);

int SendMessageWithAttachments(const QString& qsUrl, const QString& qsPrimaryMessageId);

#define EID_SOAPCLIENT_BEFORERECEIVEATTACHMENT 1

virtual INT SECUREBLACKBOX_CALL FireBeforeReceiveAttachment();

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

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

// Or, subclass SOAPClient and override this emitter function.
virtual int FireBeforeReceiveAttachment(SOAPClientBeforeReceiveAttachmentEventParams *e) {...}

#define EID_SOAPCLIENT_BEFORESENDATTACHMENT 2

virtual INT SECUREBLACKBOX_CALL FireBeforeSendAttachment(BOOL &bLastAttachment);

class SOAPClientBeforeSendAttachmentEventParams {
public:
  bool LastAttachment();
  void SetLastAttachment(bool bLastAttachment);

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

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

// Or, subclass SOAPClient and override this emitter function.
virtual int FireBeforeSendAttachment(SOAPClientBeforeSendAttachmentEventParams *e) {...}

#define EID_SOAPCLIENT_COOKIE 3

virtual INT SECUREBLACKBOX_CALL FireCookie(LPSTR &lpszCookieText);

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

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

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

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

#define EID_SOAPCLIENT_DOCUMENTBEGIN 4

virtual INT SECUREBLACKBOX_CALL FireDocumentBegin();

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

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

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

#define EID_SOAPCLIENT_DOCUMENTEND 5

virtual INT SECUREBLACKBOX_CALL FireDocumentEnd();

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

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

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

#define EID_SOAPCLIENT_ERROR 6

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

class SOAPClientErrorEventParams {
public:
  int ErrorCode();

  const QString &Description();

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

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

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

#define EID_SOAPCLIENT_EXTERNALSIGN 7

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

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

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

#define EID_SOAPCLIENT_HEADERSPREPARED 8

virtual INT SECUREBLACKBOX_CALL FireHeadersPrepared();

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

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

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

#define EID_SOAPCLIENT_HEADERSRECEIVED 9

virtual INT SECUREBLACKBOX_CALL FireHeadersReceived();

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

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

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

#define EID_SOAPCLIENT_NOTIFICATION 10

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

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

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

#define EID_SOAPCLIENT_PROGRESS 11

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

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

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

#define EID_SOAPCLIENT_REDIRECTION 12

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

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

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

#define EID_SOAPCLIENT_TLSCERTNEEDED 13

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

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

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

#define EID_SOAPCLIENT_TLSCERTVALIDATE 14

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

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

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

#define EID_SOAPCLIENT_TLSESTABLISHED 15

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

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

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

#define EID_SOAPCLIENT_TLSHANDSHAKE 16

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

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

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

#define EID_SOAPCLIENT_TLSPSK 17

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

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

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

#define EID_SOAPCLIENT_TLSSHUTDOWN 18

virtual INT SECUREBLACKBOX_CALL FireTLSShutdown(LPSTR &lpszHost);

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

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

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

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