int secureblackbox_xadessigner_getautovalidatesignatures(void* lpObj);
int secureblackbox_xadessigner_setautovalidatesignatures(void* lpObj, int bAutoValidateSignatures);

bool GetAutoValidateSignatures();
int SetAutoValidateSignatures(bool bAutoValidateSignatures);

int secureblackbox_xadessigner_getblockedcertcount(void* lpObj);
int secureblackbox_xadessigner_setblockedcertcount(void* lpObj, int iBlockedCertCount);

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

int64 secureblackbox_xadessigner_getblockedcerthandle(void* lpObj, int blockedcertindex);
int secureblackbox_xadessigner_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_xadessigner_getchecktrustedlists(void* lpObj);
int secureblackbox_xadessigner_setchecktrustedlists(void* lpObj, int bCheckTrustedLists);

bool GetCheckTrustedLists();
int SetCheckTrustedLists(bool bCheckTrustedLists);

int secureblackbox_xadessigner_getcrlcount(void* lpObj);

int secureblackbox_xadessigner_getcrlbytes(void* lpObj, int crlindex, char** lpCRLBytes, int* lenCRLBytes);

int secureblackbox_xadessigner_getcrlcakeyid(void* lpObj, int crlindex, char** lpCRLCAKeyID, int* lenCRLCAKeyID);

int secureblackbox_xadessigner_getcrlentrycount(void* lpObj, int crlindex);

int64 secureblackbox_xadessigner_getcrlhandle(void* lpObj, int crlindex);

char* secureblackbox_xadessigner_getcrlissuer(void* lpObj, int crlindex);

char* secureblackbox_xadessigner_getcrlissuerrdn(void* lpObj, int crlindex);

char* secureblackbox_xadessigner_getcrllocation(void* lpObj, int crlindex);

char* secureblackbox_xadessigner_getcrlnextupdate(void* lpObj, int crlindex);

char* secureblackbox_xadessigner_getcrlsigalgorithm(void* lpObj, int crlindex);

int secureblackbox_xadessigner_getcrlsource(void* lpObj, int crlindex);

int secureblackbox_xadessigner_getcrltbs(void* lpObj, int crlindex, char** lpCRLTBS, int* lenCRLTBS);

char* secureblackbox_xadessigner_getcrlthisupdate(void* lpObj, int crlindex);

int GetCRLCount();

QByteArray GetCRLBytes(int iCRLIndex);

QByteArray GetCRLCAKeyID(int iCRLIndex);

int GetCRLEntryCount(int iCRLIndex);

qint64 GetCRLHandle(int iCRLIndex);

QString GetCRLIssuer(int iCRLIndex);

QString GetCRLIssuerRDN(int iCRLIndex);

QString GetCRLLocation(int iCRLIndex);

QString GetCRLNextUpdate(int iCRLIndex);

QString GetCRLSigAlgorithm(int iCRLIndex);

int GetCRLSource(int iCRLIndex);

QByteArray GetCRLTBS(int iCRLIndex);

QString GetCRLThisUpdate(int iCRLIndex);

int secureblackbox_xadessigner_getdatabytes(void* lpObj, char** lpDataBytes, int* lenDataBytes);
int secureblackbox_xadessigner_setdatabytes(void* lpObj, const char* lpDataBytes, int lenDataBytes);

QByteArray GetDataBytes();
int SetDataBytes(QByteArray qbaDataBytes);

char* secureblackbox_xadessigner_getdatafile(void* lpObj);
int secureblackbox_xadessigner_setdatafile(void* lpObj, const char* lpszDataFile);

QString GetDataFile();
int SetDataFile(QString qsDataFile);

int secureblackbox_xadessigner_getdatatype(void* lpObj);
int secureblackbox_xadessigner_setdatatype(void* lpObj, int iDataType);

int GetDataType();
int SetDataType(int iDataType);

char* secureblackbox_xadessigner_getdatauri(void* lpObj);
int secureblackbox_xadessigner_setdatauri(void* lpObj, const char* lpszDataURI);

QString GetDataURI();
int SetDataURI(QString qsDataURI);

char* secureblackbox_xadessigner_getencoding(void* lpObj);
int secureblackbox_xadessigner_setencoding(void* lpObj, const char* lpszEncoding);

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

char* secureblackbox_xadessigner_getexternalcryptoasyncdocumentid(void* lpObj);
int secureblackbox_xadessigner_setexternalcryptoasyncdocumentid(void* lpObj, const char* lpszExternalCryptoAsyncDocumentID);

char* secureblackbox_xadessigner_getexternalcryptocustomparams(void* lpObj);
int secureblackbox_xadessigner_setexternalcryptocustomparams(void* lpObj, const char* lpszExternalCryptoCustomParams);

char* secureblackbox_xadessigner_getexternalcryptodata(void* lpObj);
int secureblackbox_xadessigner_setexternalcryptodata(void* lpObj, const char* lpszExternalCryptoData);

int secureblackbox_xadessigner_getexternalcryptoexternalhashcalculation(void* lpObj);
int secureblackbox_xadessigner_setexternalcryptoexternalhashcalculation(void* lpObj, int bExternalCryptoExternalHashCalculation);

char* secureblackbox_xadessigner_getexternalcryptohashalgorithm(void* lpObj);
int secureblackbox_xadessigner_setexternalcryptohashalgorithm(void* lpObj, const char* lpszExternalCryptoHashAlgorithm);

char* secureblackbox_xadessigner_getexternalcryptokeyid(void* lpObj);
int secureblackbox_xadessigner_setexternalcryptokeyid(void* lpObj, const char* lpszExternalCryptoKeyID);

char* secureblackbox_xadessigner_getexternalcryptokeysecret(void* lpObj);
int secureblackbox_xadessigner_setexternalcryptokeysecret(void* lpObj, const char* lpszExternalCryptoKeySecret);

int secureblackbox_xadessigner_getexternalcryptomethod(void* lpObj);
int secureblackbox_xadessigner_setexternalcryptomethod(void* lpObj, int iExternalCryptoMethod);

int secureblackbox_xadessigner_getexternalcryptomode(void* lpObj);
int secureblackbox_xadessigner_setexternalcryptomode(void* lpObj, int iExternalCryptoMode);

char* secureblackbox_xadessigner_getexternalcryptopublickeyalgorithm(void* lpObj);
int secureblackbox_xadessigner_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_xadessigner_getfipsmode(void* lpObj);
int secureblackbox_xadessigner_setfipsmode(void* lpObj, int bFIPSMode);

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

int secureblackbox_xadessigner_getignorechainvalidationerrors(void* lpObj);
int secureblackbox_xadessigner_setignorechainvalidationerrors(void* lpObj, int bIgnoreChainValidationErrors);

bool GetIgnoreChainValidationErrors();
int SetIgnoreChainValidationErrors(bool bIgnoreChainValidationErrors);

int secureblackbox_xadessigner_getinputbytes(void* lpObj, char** lpInputBytes, int* lenInputBytes);
int secureblackbox_xadessigner_setinputbytes(void* lpObj, const char* lpInputBytes, int lenInputBytes);

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

char* secureblackbox_xadessigner_getinputfile(void* lpObj);
int secureblackbox_xadessigner_setinputfile(void* lpObj, const char* lpszInputFile);

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

int secureblackbox_xadessigner_getknowncertcount(void* lpObj);
int secureblackbox_xadessigner_setknowncertcount(void* lpObj, int iKnownCertCount);

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

int64 secureblackbox_xadessigner_getknowncerthandle(void* lpObj, int knowncertindex);
int secureblackbox_xadessigner_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_xadessigner_getknowncrlcount(void* lpObj);
int secureblackbox_xadessigner_setknowncrlcount(void* lpObj, int iKnownCRLCount);

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

int64 secureblackbox_xadessigner_getknowncrlhandle(void* lpObj, int knowncrlindex);
int secureblackbox_xadessigner_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_xadessigner_getknownocspcount(void* lpObj);
int secureblackbox_xadessigner_setknownocspcount(void* lpObj, int iKnownOCSPCount);

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

int64 secureblackbox_xadessigner_getknownocsphandle(void* lpObj, int knownocspindex);
int secureblackbox_xadessigner_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_xadessigner_getnewsigcanonicalizationmethod(void* lpObj);
int secureblackbox_xadessigner_setnewsigcanonicalizationmethod(void* lpObj, int iNewSigCanonicalizationMethod);

int secureblackbox_xadessigner_getnewsigchainvalidationdetails(void* lpObj);

int secureblackbox_xadessigner_getnewsigchainvalidationresult(void* lpObj);

char* secureblackbox_xadessigner_getnewsigclaimedsigningtime(void* lpObj);
int secureblackbox_xadessigner_setnewsigclaimedsigningtime(void* lpObj, const char* lpszNewSigClaimedSigningTime);

int secureblackbox_xadessigner_getnewsigcompatibilityerrors(void* lpObj);

int secureblackbox_xadessigner_getnewsigcontainslongterminfo(void* lpObj);

char* secureblackbox_xadessigner_getnewsigentitylabel(void* lpObj);

int64 secureblackbox_xadessigner_getnewsighandle(void* lpObj);
int secureblackbox_xadessigner_setnewsighandle(void* lpObj, int64 lNewSigHandle);

char* secureblackbox_xadessigner_getnewsighashalgorithm(void* lpObj);
int secureblackbox_xadessigner_setnewsighashalgorithm(void* lpObj, const char* lpszNewSigHashAlgorithm);

char* secureblackbox_xadessigner_getnewsigissuerrdn(void* lpObj);

char* secureblackbox_xadessigner_getnewsiglastarchivaltime(void* lpObj);

int secureblackbox_xadessigner_getnewsiglevel(void* lpObj);
int secureblackbox_xadessigner_setnewsiglevel(void* lpObj, int iNewSigLevel);

char* secureblackbox_xadessigner_getnewsigparententity(void* lpObj);
int secureblackbox_xadessigner_setnewsigparententity(void* lpObj, const char* lpszNewSigParentEntity);

char* secureblackbox_xadessigner_getnewsigpolicyhash(void* lpObj);
int secureblackbox_xadessigner_setnewsigpolicyhash(void* lpObj, const char* lpszNewSigPolicyHash);

char* secureblackbox_xadessigner_getnewsigpolicyhashalgorithm(void* lpObj);
int secureblackbox_xadessigner_setnewsigpolicyhashalgorithm(void* lpObj, const char* lpszNewSigPolicyHashAlgorithm);

char* secureblackbox_xadessigner_getnewsigpolicyid(void* lpObj);
int secureblackbox_xadessigner_setnewsigpolicyid(void* lpObj, const char* lpszNewSigPolicyID);

char* secureblackbox_xadessigner_getnewsigpolicyuri(void* lpObj);
int secureblackbox_xadessigner_setnewsigpolicyuri(void* lpObj, const char* lpszNewSigPolicyURI);

int secureblackbox_xadessigner_getnewsigserialnumber(void* lpObj, char** lpNewSigSerialNumber, int* lenNewSigSerialNumber);

int secureblackbox_xadessigner_getnewsigsignaturebytes(void* lpObj, char** lpNewSigSignatureBytes, int* lenNewSigSignatureBytes);

int secureblackbox_xadessigner_getnewsigsignaturetype(void* lpObj);
int secureblackbox_xadessigner_setnewsigsignaturetype(void* lpObj, int iNewSigSignatureType);

int secureblackbox_xadessigner_getnewsigsignaturevalidationresult(void* lpObj);

int secureblackbox_xadessigner_getnewsigsubjectkeyid(void* lpObj, char** lpNewSigSubjectKeyID, int* lenNewSigSubjectKeyID);

char* secureblackbox_xadessigner_getnewsigsubjectrdn(void* lpObj);

int secureblackbox_xadessigner_getnewsigtimestamped(void* lpObj);

char* secureblackbox_xadessigner_getnewsigvalidatedsigningtime(void* lpObj);

char* secureblackbox_xadessigner_getnewsigvalidationlog(void* lpObj);

int secureblackbox_xadessigner_getnewsigxadesversion(void* lpObj);
int secureblackbox_xadessigner_setnewsigxadesversion(void* lpObj, int iNewSigXAdESVersion);

char* secureblackbox_xadessigner_getnewsigxmlelement(void* lpObj);
int secureblackbox_xadessigner_setnewsigxmlelement(void* lpObj, const char* lpszNewSigXMLElement);

int GetNewSigCanonicalizationMethod();
int SetNewSigCanonicalizationMethod(int iNewSigCanonicalizationMethod);

int GetNewSigChainValidationDetails();

int GetNewSigChainValidationResult();

QString GetNewSigClaimedSigningTime();
int SetNewSigClaimedSigningTime(QString qsNewSigClaimedSigningTime);

int GetNewSigCompatibilityErrors();

bool GetNewSigContainsLongTermInfo();

QString GetNewSigEntityLabel();

qint64 GetNewSigHandle();
int SetNewSigHandle(qint64 lNewSigHandle);

QString GetNewSigHashAlgorithm();
int SetNewSigHashAlgorithm(QString qsNewSigHashAlgorithm);

QString GetNewSigIssuerRDN();

QString GetNewSigLastArchivalTime();

int GetNewSigLevel();
int SetNewSigLevel(int iNewSigLevel);

QString GetNewSigParentEntity();
int SetNewSigParentEntity(QString qsNewSigParentEntity);

QString GetNewSigPolicyHash();
int SetNewSigPolicyHash(QString qsNewSigPolicyHash);

QString GetNewSigPolicyHashAlgorithm();
int SetNewSigPolicyHashAlgorithm(QString qsNewSigPolicyHashAlgorithm);

QString GetNewSigPolicyID();
int SetNewSigPolicyID(QString qsNewSigPolicyID);

QString GetNewSigPolicyURI();
int SetNewSigPolicyURI(QString qsNewSigPolicyURI);

QByteArray GetNewSigSerialNumber();

QByteArray GetNewSigSignatureBytes();

int GetNewSigSignatureType();
int SetNewSigSignatureType(int iNewSigSignatureType);

int GetNewSigSignatureValidationResult();

QByteArray GetNewSigSubjectKeyID();

QString GetNewSigSubjectRDN();

bool GetNewSigTimestamped();

QString GetNewSigValidatedSigningTime();

QString GetNewSigValidationLog();

int GetNewSigXAdESVersion();
int SetNewSigXAdESVersion(int iNewSigXAdESVersion);

QString GetNewSigXMLElement();
int SetNewSigXMLElement(QString qsNewSigXMLElement);

int secureblackbox_xadessigner_getocspcount(void* lpObj);

int secureblackbox_xadessigner_getocspbytes(void* lpObj, int ocspindex, char** lpOCSPBytes, int* lenOCSPBytes);

int secureblackbox_xadessigner_getocspentrycount(void* lpObj, int ocspindex);

int64 secureblackbox_xadessigner_getocsphandle(void* lpObj, int ocspindex);

char* secureblackbox_xadessigner_getocspissuer(void* lpObj, int ocspindex);

char* secureblackbox_xadessigner_getocspissuerrdn(void* lpObj, int ocspindex);

char* secureblackbox_xadessigner_getocsplocation(void* lpObj, int ocspindex);

char* secureblackbox_xadessigner_getocspproducedat(void* lpObj, int ocspindex);

char* secureblackbox_xadessigner_getocspsigalgorithm(void* lpObj, int ocspindex);

int secureblackbox_xadessigner_getocspsource(void* lpObj, int ocspindex);

int GetOCSPCount();

QByteArray GetOCSPBytes(int iOCSPIndex);

int GetOCSPEntryCount(int iOCSPIndex);

qint64 GetOCSPHandle(int iOCSPIndex);

QString GetOCSPIssuer(int iOCSPIndex);

QString GetOCSPIssuerRDN(int iOCSPIndex);

QString GetOCSPLocation(int iOCSPIndex);

QString GetOCSPProducedAt(int iOCSPIndex);

QString GetOCSPSigAlgorithm(int iOCSPIndex);

int GetOCSPSource(int iOCSPIndex);

int secureblackbox_xadessigner_getofflinemode(void* lpObj);
int secureblackbox_xadessigner_setofflinemode(void* lpObj, int bOfflineMode);

bool GetOfflineMode();
int SetOfflineMode(bool bOfflineMode);

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

QByteArray GetOutputBytes();

char* secureblackbox_xadessigner_getoutputfile(void* lpObj);
int secureblackbox_xadessigner_setoutputfile(void* lpObj, const char* lpszOutputFile);

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

char* secureblackbox_xadessigner_getprofile(void* lpObj);
int secureblackbox_xadessigner_setprofile(void* lpObj, const char* lpszProfile);

QString GetProfile();
int SetProfile(QString qsProfile);

char* secureblackbox_xadessigner_getproxyaddress(void* lpObj);
int secureblackbox_xadessigner_setproxyaddress(void* lpObj, const char* lpszProxyAddress);

int secureblackbox_xadessigner_getproxyauthentication(void* lpObj);
int secureblackbox_xadessigner_setproxyauthentication(void* lpObj, int iProxyAuthentication);

char* secureblackbox_xadessigner_getproxypassword(void* lpObj);
int secureblackbox_xadessigner_setproxypassword(void* lpObj, const char* lpszProxyPassword);

int secureblackbox_xadessigner_getproxyport(void* lpObj);
int secureblackbox_xadessigner_setproxyport(void* lpObj, int iProxyPort);

int secureblackbox_xadessigner_getproxyproxytype(void* lpObj);
int secureblackbox_xadessigner_setproxyproxytype(void* lpObj, int iProxyProxyType);

char* secureblackbox_xadessigner_getproxyrequestheaders(void* lpObj);
int secureblackbox_xadessigner_setproxyrequestheaders(void* lpObj, const char* lpszProxyRequestHeaders);

char* secureblackbox_xadessigner_getproxyresponsebody(void* lpObj);
int secureblackbox_xadessigner_setproxyresponsebody(void* lpObj, const char* lpszProxyResponseBody);

char* secureblackbox_xadessigner_getproxyresponseheaders(void* lpObj);
int secureblackbox_xadessigner_setproxyresponseheaders(void* lpObj, const char* lpszProxyResponseHeaders);

int secureblackbox_xadessigner_getproxyuseipv6(void* lpObj);
int secureblackbox_xadessigner_setproxyuseipv6(void* lpObj, int bProxyUseIPv6);

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

int secureblackbox_xadessigner_getreferencecount(void* lpObj);
int secureblackbox_xadessigner_setreferencecount(void* lpObj, int iReferenceCount);

int secureblackbox_xadessigner_getreferenceautogenerateelementid(void* lpObj, int referenceindex);
int secureblackbox_xadessigner_setreferenceautogenerateelementid(void* lpObj, int referenceindex, int bReferenceAutoGenerateElementId);

int secureblackbox_xadessigner_getreferencecanonicalizationmethod(void* lpObj, int referenceindex);
int secureblackbox_xadessigner_setreferencecanonicalizationmethod(void* lpObj, int referenceindex, int iReferenceCanonicalizationMethod);

char* secureblackbox_xadessigner_getreferencecustomelementid(void* lpObj, int referenceindex);
int secureblackbox_xadessigner_setreferencecustomelementid(void* lpObj, int referenceindex, const char* lpszReferenceCustomElementId);

char* secureblackbox_xadessigner_getreferencedataobjectdescription(void* lpObj, int referenceindex);
int secureblackbox_xadessigner_setreferencedataobjectdescription(void* lpObj, int referenceindex, const char* lpszReferenceDataObjectDescription);

char* secureblackbox_xadessigner_getreferencedataobjectencoding(void* lpObj, int referenceindex);
int secureblackbox_xadessigner_setreferencedataobjectencoding(void* lpObj, int referenceindex, const char* lpszReferenceDataObjectEncoding);

char* secureblackbox_xadessigner_getreferencedataobjectidentifier(void* lpObj, int referenceindex);
int secureblackbox_xadessigner_setreferencedataobjectidentifier(void* lpObj, int referenceindex, const char* lpszReferenceDataObjectIdentifier);

char* secureblackbox_xadessigner_getreferencedataobjectmimetype(void* lpObj, int referenceindex);
int secureblackbox_xadessigner_setreferencedataobjectmimetype(void* lpObj, int referenceindex, const char* lpszReferenceDataObjectMimeType);

int secureblackbox_xadessigner_getreferencedigestvalue(void* lpObj, int referenceindex, char** lpReferenceDigestValue, int* lenReferenceDigestValue);
int secureblackbox_xadessigner_setreferencedigestvalue(void* lpObj, int referenceindex, const char* lpReferenceDigestValue, int lenReferenceDigestValue);

int64 secureblackbox_xadessigner_getreferencehandle(void* lpObj, int referenceindex);
int secureblackbox_xadessigner_setreferencehandle(void* lpObj, int referenceindex, int64 lReferenceHandle);

int secureblackbox_xadessigner_getreferencehasdataobjectformat(void* lpObj, int referenceindex);
int secureblackbox_xadessigner_setreferencehasdataobjectformat(void* lpObj, int referenceindex, int bReferenceHasDataObjectFormat);

char* secureblackbox_xadessigner_getreferencehashalgorithm(void* lpObj, int referenceindex);
int secureblackbox_xadessigner_setreferencehashalgorithm(void* lpObj, int referenceindex, const char* lpszReferenceHashAlgorithm);

int secureblackbox_xadessigner_getreferencehasuri(void* lpObj, int referenceindex);
int secureblackbox_xadessigner_setreferencehasuri(void* lpObj, int referenceindex, int bReferenceHasURI);

char* secureblackbox_xadessigner_getreferenceid(void* lpObj, int referenceindex);
int secureblackbox_xadessigner_setreferenceid(void* lpObj, int referenceindex, const char* lpszReferenceID);

char* secureblackbox_xadessigner_getreferenceinclusivenamespacesprefixlist(void* lpObj, int referenceindex);
int secureblackbox_xadessigner_setreferenceinclusivenamespacesprefixlist(void* lpObj, int referenceindex, const char* lpszReferenceInclusiveNamespacesPrefixList);

char* secureblackbox_xadessigner_getreferencereferencetype(void* lpObj, int referenceindex);
int secureblackbox_xadessigner_setreferencereferencetype(void* lpObj, int referenceindex, const char* lpszReferenceReferenceType);

int secureblackbox_xadessigner_getreferencetargetdata(void* lpObj, int referenceindex, char** lpReferenceTargetData, int* lenReferenceTargetData);
int secureblackbox_xadessigner_setreferencetargetdata(void* lpObj, int referenceindex, const char* lpReferenceTargetData, int lenReferenceTargetData);

int secureblackbox_xadessigner_getreferencetargettype(void* lpObj, int referenceindex);
int secureblackbox_xadessigner_setreferencetargettype(void* lpObj, int referenceindex, int iReferenceTargetType);

char* secureblackbox_xadessigner_getreferencetargetxmlelement(void* lpObj, int referenceindex);
int secureblackbox_xadessigner_setreferencetargetxmlelement(void* lpObj, int referenceindex, const char* lpszReferenceTargetXMLElement);

char* secureblackbox_xadessigner_getreferenceuri(void* lpObj, int referenceindex);
int secureblackbox_xadessigner_setreferenceuri(void* lpObj, int referenceindex, const char* lpszReferenceURI);

int secureblackbox_xadessigner_getreferenceusebase64transform(void* lpObj, int referenceindex);
int secureblackbox_xadessigner_setreferenceusebase64transform(void* lpObj, int referenceindex, int bReferenceUseBase64Transform);

int secureblackbox_xadessigner_getreferenceuseenvelopedsignaturetransform(void* lpObj, int referenceindex);
int secureblackbox_xadessigner_setreferenceuseenvelopedsignaturetransform(void* lpObj, int referenceindex, int bReferenceUseEnvelopedSignatureTransform);

int secureblackbox_xadessigner_getreferenceusexpathfilter2transform(void* lpObj, int referenceindex);
int secureblackbox_xadessigner_setreferenceusexpathfilter2transform(void* lpObj, int referenceindex, int bReferenceUseXPathFilter2Transform);

int secureblackbox_xadessigner_getreferenceusexpathtransform(void* lpObj, int referenceindex);
int secureblackbox_xadessigner_setreferenceusexpathtransform(void* lpObj, int referenceindex, int bReferenceUseXPathTransform);

int secureblackbox_xadessigner_getreferencevalidationresult(void* lpObj, int referenceindex);

char* secureblackbox_xadessigner_getreferencexpathexpression(void* lpObj, int referenceindex);
int secureblackbox_xadessigner_setreferencexpathexpression(void* lpObj, int referenceindex, const char* lpszReferenceXPathExpression);

char* secureblackbox_xadessigner_getreferencexpathfilter2expressions(void* lpObj, int referenceindex);
int secureblackbox_xadessigner_setreferencexpathfilter2expressions(void* lpObj, int referenceindex, const char* lpszReferenceXPathFilter2Expressions);

char* secureblackbox_xadessigner_getreferencexpathfilter2filters(void* lpObj, int referenceindex);
int secureblackbox_xadessigner_setreferencexpathfilter2filters(void* lpObj, int referenceindex, const char* lpszReferenceXPathFilter2Filters);

char* secureblackbox_xadessigner_getreferencexpathfilter2prefixlist(void* lpObj, int referenceindex);
int secureblackbox_xadessigner_setreferencexpathfilter2prefixlist(void* lpObj, int referenceindex, const char* lpszReferenceXPathFilter2PrefixList);

char* secureblackbox_xadessigner_getreferencexpathprefixlist(void* lpObj, int referenceindex);
int secureblackbox_xadessigner_setreferencexpathprefixlist(void* lpObj, int referenceindex, const char* lpszReferenceXPathPrefixList);

int GetReferenceCount();
int SetReferenceCount(int iReferenceCount);

bool GetReferenceAutoGenerateElementId(int iReferenceIndex);
int SetReferenceAutoGenerateElementId(int iReferenceIndex, bool bReferenceAutoGenerateElementId);

int GetReferenceCanonicalizationMethod(int iReferenceIndex);
int SetReferenceCanonicalizationMethod(int iReferenceIndex, int iReferenceCanonicalizationMethod);

QString GetReferenceCustomElementId(int iReferenceIndex);
int SetReferenceCustomElementId(int iReferenceIndex, QString qsReferenceCustomElementId);

QString GetReferenceDataObjectDescription(int iReferenceIndex);
int SetReferenceDataObjectDescription(int iReferenceIndex, QString qsReferenceDataObjectDescription);

QString GetReferenceDataObjectEncoding(int iReferenceIndex);
int SetReferenceDataObjectEncoding(int iReferenceIndex, QString qsReferenceDataObjectEncoding);

QString GetReferenceDataObjectIdentifier(int iReferenceIndex);
int SetReferenceDataObjectIdentifier(int iReferenceIndex, QString qsReferenceDataObjectIdentifier);

QString GetReferenceDataObjectMimeType(int iReferenceIndex);
int SetReferenceDataObjectMimeType(int iReferenceIndex, QString qsReferenceDataObjectMimeType);

QByteArray GetReferenceDigestValue(int iReferenceIndex);
int SetReferenceDigestValue(int iReferenceIndex, QByteArray qbaReferenceDigestValue);

qint64 GetReferenceHandle(int iReferenceIndex);
int SetReferenceHandle(int iReferenceIndex, qint64 lReferenceHandle);

bool GetReferenceHasDataObjectFormat(int iReferenceIndex);
int SetReferenceHasDataObjectFormat(int iReferenceIndex, bool bReferenceHasDataObjectFormat);

QString GetReferenceHashAlgorithm(int iReferenceIndex);
int SetReferenceHashAlgorithm(int iReferenceIndex, QString qsReferenceHashAlgorithm);

bool GetReferenceHasURI(int iReferenceIndex);
int SetReferenceHasURI(int iReferenceIndex, bool bReferenceHasURI);

QString GetReferenceID(int iReferenceIndex);
int SetReferenceID(int iReferenceIndex, QString qsReferenceID);

QString GetReferenceInclusiveNamespacesPrefixList(int iReferenceIndex);
int SetReferenceInclusiveNamespacesPrefixList(int iReferenceIndex, QString qsReferenceInclusiveNamespacesPrefixList);

QString GetReferenceReferenceType(int iReferenceIndex);
int SetReferenceReferenceType(int iReferenceIndex, QString qsReferenceReferenceType);

QByteArray GetReferenceTargetData(int iReferenceIndex);
int SetReferenceTargetData(int iReferenceIndex, QByteArray qbaReferenceTargetData);

int GetReferenceTargetType(int iReferenceIndex);
int SetReferenceTargetType(int iReferenceIndex, int iReferenceTargetType);

QString GetReferenceTargetXMLElement(int iReferenceIndex);
int SetReferenceTargetXMLElement(int iReferenceIndex, QString qsReferenceTargetXMLElement);

QString GetReferenceURI(int iReferenceIndex);
int SetReferenceURI(int iReferenceIndex, QString qsReferenceURI);

bool GetReferenceUseBase64Transform(int iReferenceIndex);
int SetReferenceUseBase64Transform(int iReferenceIndex, bool bReferenceUseBase64Transform);

bool GetReferenceUseEnvelopedSignatureTransform(int iReferenceIndex);
int SetReferenceUseEnvelopedSignatureTransform(int iReferenceIndex, bool bReferenceUseEnvelopedSignatureTransform);

bool GetReferenceUseXPathFilter2Transform(int iReferenceIndex);
int SetReferenceUseXPathFilter2Transform(int iReferenceIndex, bool bReferenceUseXPathFilter2Transform);

bool GetReferenceUseXPathTransform(int iReferenceIndex);
int SetReferenceUseXPathTransform(int iReferenceIndex, bool bReferenceUseXPathTransform);

bool GetReferenceValidationResult(int iReferenceIndex);

QString GetReferenceXPathExpression(int iReferenceIndex);
int SetReferenceXPathExpression(int iReferenceIndex, QString qsReferenceXPathExpression);

QString GetReferenceXPathFilter2Expressions(int iReferenceIndex);
int SetReferenceXPathFilter2Expressions(int iReferenceIndex, QString qsReferenceXPathFilter2Expressions);

QString GetReferenceXPathFilter2Filters(int iReferenceIndex);
int SetReferenceXPathFilter2Filters(int iReferenceIndex, QString qsReferenceXPathFilter2Filters);

QString GetReferenceXPathFilter2PrefixList(int iReferenceIndex);
int SetReferenceXPathFilter2PrefixList(int iReferenceIndex, QString qsReferenceXPathFilter2PrefixList);

QString GetReferenceXPathPrefixList(int iReferenceIndex);
int SetReferenceXPathPrefixList(int iReferenceIndex, QString qsReferenceXPathPrefixList);

int secureblackbox_xadessigner_getrevocationcheck(void* lpObj);
int secureblackbox_xadessigner_setrevocationcheck(void* lpObj, int iRevocationCheck);

int GetRevocationCheck();
int SetRevocationCheck(int iRevocationCheck);

int secureblackbox_xadessigner_getsignaturecount(void* lpObj);

int secureblackbox_xadessigner_getsignaturecanonicalizationmethod(void* lpObj, int signatureindex);

int secureblackbox_xadessigner_getsignaturechainvalidationdetails(void* lpObj, int signatureindex);

int secureblackbox_xadessigner_getsignaturechainvalidationresult(void* lpObj, int signatureindex);

char* secureblackbox_xadessigner_getsignatureclaimedsigningtime(void* lpObj, int signatureindex);

int secureblackbox_xadessigner_getsignaturecompatibilityerrors(void* lpObj, int signatureindex);

int secureblackbox_xadessigner_getsignaturecontainslongterminfo(void* lpObj, int signatureindex);

char* secureblackbox_xadessigner_getsignatureentitylabel(void* lpObj, int signatureindex);

int64 secureblackbox_xadessigner_getsignaturehandle(void* lpObj, int signatureindex);

char* secureblackbox_xadessigner_getsignaturehashalgorithm(void* lpObj, int signatureindex);

char* secureblackbox_xadessigner_getsignatureissuerrdn(void* lpObj, int signatureindex);

char* secureblackbox_xadessigner_getsignaturelastarchivaltime(void* lpObj, int signatureindex);

int secureblackbox_xadessigner_getsignaturelevel(void* lpObj, int signatureindex);

char* secureblackbox_xadessigner_getsignatureparententity(void* lpObj, int signatureindex);

char* secureblackbox_xadessigner_getsignaturepolicyhash(void* lpObj, int signatureindex);

char* secureblackbox_xadessigner_getsignaturepolicyhashalgorithm(void* lpObj, int signatureindex);

char* secureblackbox_xadessigner_getsignaturepolicyid(void* lpObj, int signatureindex);

char* secureblackbox_xadessigner_getsignaturepolicyuri(void* lpObj, int signatureindex);

int secureblackbox_xadessigner_getsignatureserialnumber(void* lpObj, int signatureindex, char** lpSignatureSerialNumber, int* lenSignatureSerialNumber);

int secureblackbox_xadessigner_getsignaturesignaturebytes(void* lpObj, int signatureindex, char** lpSignatureSignatureBytes, int* lenSignatureSignatureBytes);

int secureblackbox_xadessigner_getsignaturesignaturetype(void* lpObj, int signatureindex);

int secureblackbox_xadessigner_getsignaturesignaturevalidationresult(void* lpObj, int signatureindex);

int secureblackbox_xadessigner_getsignaturesubjectkeyid(void* lpObj, int signatureindex, char** lpSignatureSubjectKeyID, int* lenSignatureSubjectKeyID);

char* secureblackbox_xadessigner_getsignaturesubjectrdn(void* lpObj, int signatureindex);

int secureblackbox_xadessigner_getsignaturetimestamped(void* lpObj, int signatureindex);

char* secureblackbox_xadessigner_getsignaturevalidatedsigningtime(void* lpObj, int signatureindex);

char* secureblackbox_xadessigner_getsignaturevalidationlog(void* lpObj, int signatureindex);

int secureblackbox_xadessigner_getsignaturexadesversion(void* lpObj, int signatureindex);

char* secureblackbox_xadessigner_getsignaturexmlelement(void* lpObj, int signatureindex);

int GetSignatureCount();

int GetSignatureCanonicalizationMethod(int iSignatureIndex);

int GetSignatureChainValidationDetails(int iSignatureIndex);

int GetSignatureChainValidationResult(int iSignatureIndex);

QString GetSignatureClaimedSigningTime(int iSignatureIndex);

int GetSignatureCompatibilityErrors(int iSignatureIndex);

bool GetSignatureContainsLongTermInfo(int iSignatureIndex);

QString GetSignatureEntityLabel(int iSignatureIndex);

qint64 GetSignatureHandle(int iSignatureIndex);

QString GetSignatureHashAlgorithm(int iSignatureIndex);

QString GetSignatureIssuerRDN(int iSignatureIndex);

QString GetSignatureLastArchivalTime(int iSignatureIndex);

int GetSignatureLevel(int iSignatureIndex);

QString GetSignatureParentEntity(int iSignatureIndex);

QString GetSignaturePolicyHash(int iSignatureIndex);

QString GetSignaturePolicyHashAlgorithm(int iSignatureIndex);

QString GetSignaturePolicyID(int iSignatureIndex);

QString GetSignaturePolicyURI(int iSignatureIndex);

QByteArray GetSignatureSerialNumber(int iSignatureIndex);

QByteArray GetSignatureSignatureBytes(int iSignatureIndex);

int GetSignatureSignatureType(int iSignatureIndex);

int GetSignatureSignatureValidationResult(int iSignatureIndex);

QByteArray GetSignatureSubjectKeyID(int iSignatureIndex);

QString GetSignatureSubjectRDN(int iSignatureIndex);

bool GetSignatureTimestamped(int iSignatureIndex);

QString GetSignatureValidatedSigningTime(int iSignatureIndex);

QString GetSignatureValidationLog(int iSignatureIndex);

int GetSignatureXAdESVersion(int iSignatureIndex);

QString GetSignatureXMLElement(int iSignatureIndex);

int secureblackbox_xadessigner_getsigningcertbytes(void* lpObj, char** lpSigningCertBytes, int* lenSigningCertBytes);

int64 secureblackbox_xadessigner_getsigningcerthandle(void* lpObj);
int secureblackbox_xadessigner_setsigningcerthandle(void* lpObj, int64 lSigningCertHandle);

QByteArray GetSigningCertBytes();

qint64 GetSigningCertHandle();
int SetSigningCertHandle(qint64 lSigningCertHandle);

int secureblackbox_xadessigner_getsigningchaincount(void* lpObj);
int secureblackbox_xadessigner_setsigningchaincount(void* lpObj, int iSigningChainCount);

int secureblackbox_xadessigner_getsigningchainbytes(void* lpObj, int signingchainindex, char** lpSigningChainBytes, int* lenSigningChainBytes);

int64 secureblackbox_xadessigner_getsigningchainhandle(void* lpObj, int signingchainindex);
int secureblackbox_xadessigner_setsigningchainhandle(void* lpObj, int signingchainindex, int64 lSigningChainHandle);

int GetSigningChainCount();
int SetSigningChainCount(int iSigningChainCount);

QByteArray GetSigningChainBytes(int iSigningChainIndex);

qint64 GetSigningChainHandle(int iSigningChainIndex);
int SetSigningChainHandle(int iSigningChainIndex, qint64 lSigningChainHandle);

int secureblackbox_xadessigner_getsocketdnsmode(void* lpObj);
int secureblackbox_xadessigner_setsocketdnsmode(void* lpObj, int iSocketDNSMode);

int secureblackbox_xadessigner_getsocketdnsport(void* lpObj);
int secureblackbox_xadessigner_setsocketdnsport(void* lpObj, int iSocketDNSPort);

int secureblackbox_xadessigner_getsocketdnsquerytimeout(void* lpObj);
int secureblackbox_xadessigner_setsocketdnsquerytimeout(void* lpObj, int iSocketDNSQueryTimeout);

char* secureblackbox_xadessigner_getsocketdnsservers(void* lpObj);
int secureblackbox_xadessigner_setsocketdnsservers(void* lpObj, const char* lpszSocketDNSServers);

int secureblackbox_xadessigner_getsocketdnstotaltimeout(void* lpObj);
int secureblackbox_xadessigner_setsocketdnstotaltimeout(void* lpObj, int iSocketDNSTotalTimeout);

int secureblackbox_xadessigner_getsocketincomingspeedlimit(void* lpObj);
int secureblackbox_xadessigner_setsocketincomingspeedlimit(void* lpObj, int iSocketIncomingSpeedLimit);

char* secureblackbox_xadessigner_getsocketlocaladdress(void* lpObj);
int secureblackbox_xadessigner_setsocketlocaladdress(void* lpObj, const char* lpszSocketLocalAddress);

int secureblackbox_xadessigner_getsocketlocalport(void* lpObj);
int secureblackbox_xadessigner_setsocketlocalport(void* lpObj, int iSocketLocalPort);

int secureblackbox_xadessigner_getsocketoutgoingspeedlimit(void* lpObj);
int secureblackbox_xadessigner_setsocketoutgoingspeedlimit(void* lpObj, int iSocketOutgoingSpeedLimit);

int secureblackbox_xadessigner_getsockettimeout(void* lpObj);
int secureblackbox_xadessigner_setsockettimeout(void* lpObj, int iSocketTimeout);

int secureblackbox_xadessigner_getsocketuseipv6(void* lpObj);
int secureblackbox_xadessigner_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_xadessigner_gettimestampcount(void* lpObj);

int64 secureblackbox_xadessigner_gettimestampaccuracy(void* lpObj, int timestampindex);

int secureblackbox_xadessigner_gettimestampbytes(void* lpObj, int timestampindex, char** lpTimestampBytes, int* lenTimestampBytes);

int secureblackbox_xadessigner_gettimestampcertificateindex(void* lpObj, int timestampindex);

int secureblackbox_xadessigner_gettimestampchainvalidationdetails(void* lpObj, int timestampindex);

int secureblackbox_xadessigner_gettimestampchainvalidationresult(void* lpObj, int timestampindex);

int secureblackbox_xadessigner_gettimestampcontainslongterminfo(void* lpObj, int timestampindex);

char* secureblackbox_xadessigner_gettimestampentitylabel(void* lpObj, int timestampindex);

char* secureblackbox_xadessigner_gettimestamphashalgorithm(void* lpObj, int timestampindex);

char* secureblackbox_xadessigner_gettimestampparententity(void* lpObj, int timestampindex);

int secureblackbox_xadessigner_gettimestampserialnumber(void* lpObj, int timestampindex, char** lpTimestampSerialNumber, int* lenTimestampSerialNumber);

char* secureblackbox_xadessigner_gettimestamptime(void* lpObj, int timestampindex);

int secureblackbox_xadessigner_gettimestamptimestamptype(void* lpObj, int timestampindex);

char* secureblackbox_xadessigner_gettimestamptsaname(void* lpObj, int timestampindex);

char* secureblackbox_xadessigner_gettimestampvalidationlog(void* lpObj, int timestampindex);

int secureblackbox_xadessigner_gettimestampvalidationresult(void* lpObj, int timestampindex);

int GetTimestampCount();

qint64 GetTimestampAccuracy(int iTimestampIndex);

QByteArray GetTimestampBytes(int iTimestampIndex);

int GetTimestampCertificateIndex(int iTimestampIndex);

int GetTimestampChainValidationDetails(int iTimestampIndex);

int GetTimestampChainValidationResult(int iTimestampIndex);

bool GetTimestampContainsLongTermInfo(int iTimestampIndex);

QString GetTimestampEntityLabel(int iTimestampIndex);

QString GetTimestampHashAlgorithm(int iTimestampIndex);

QString GetTimestampParentEntity(int iTimestampIndex);

QByteArray GetTimestampSerialNumber(int iTimestampIndex);

QString GetTimestampTime(int iTimestampIndex);

int GetTimestampTimestampType(int iTimestampIndex);

QString GetTimestampTSAName(int iTimestampIndex);

QString GetTimestampValidationLog(int iTimestampIndex);

int GetTimestampValidationResult(int iTimestampIndex);

char* secureblackbox_xadessigner_gettimestampserver(void* lpObj);
int secureblackbox_xadessigner_settimestampserver(void* lpObj, const char* lpszTimestampServer);

QString GetTimestampServer();
int SetTimestampServer(QString qsTimestampServer);

int secureblackbox_xadessigner_gettlsclientcertcount(void* lpObj);
int secureblackbox_xadessigner_settlsclientcertcount(void* lpObj, int iTLSClientCertCount);

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

int64 secureblackbox_xadessigner_gettlsclientcerthandle(void* lpObj, int tlsclientcertindex);
int secureblackbox_xadessigner_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_xadessigner_gettlsservercertcount(void* lpObj);

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

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

int64 secureblackbox_xadessigner_gettlsservercerthandle(void* lpObj, int tlsservercertindex);

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

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

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

int secureblackbox_xadessigner_gettlsservercertkeybits(void* lpObj, int tlsservercertindex);

int secureblackbox_xadessigner_gettlsservercertkeyusage(void* lpObj, int tlsservercertindex);

int secureblackbox_xadessigner_gettlsservercertselfsigned(void* lpObj, int tlsservercertindex);

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

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

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

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

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

char* secureblackbox_xadessigner_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_xadessigner_gettlsautovalidatecertificates(void* lpObj);
int secureblackbox_xadessigner_settlsautovalidatecertificates(void* lpObj, int bTLSAutoValidateCertificates);

int secureblackbox_xadessigner_gettlsbaseconfiguration(void* lpObj);
int secureblackbox_xadessigner_settlsbaseconfiguration(void* lpObj, int iTLSBaseConfiguration);

char* secureblackbox_xadessigner_gettlsciphersuites(void* lpObj);
int secureblackbox_xadessigner_settlsciphersuites(void* lpObj, const char* lpszTLSCiphersuites);

int secureblackbox_xadessigner_gettlsclientauth(void* lpObj);
int secureblackbox_xadessigner_settlsclientauth(void* lpObj, int iTLSClientAuth);

char* secureblackbox_xadessigner_gettlseccurves(void* lpObj);
int secureblackbox_xadessigner_settlseccurves(void* lpObj, const char* lpszTLSECCurves);

char* secureblackbox_xadessigner_gettlsextensions(void* lpObj);
int secureblackbox_xadessigner_settlsextensions(void* lpObj, const char* lpszTLSExtensions);

int secureblackbox_xadessigner_gettlsforceresumeifdestinationchanges(void* lpObj);
int secureblackbox_xadessigner_settlsforceresumeifdestinationchanges(void* lpObj, int bTLSForceResumeIfDestinationChanges);

char* secureblackbox_xadessigner_gettlspresharedidentity(void* lpObj);
int secureblackbox_xadessigner_settlspresharedidentity(void* lpObj, const char* lpszTLSPreSharedIdentity);

char* secureblackbox_xadessigner_gettlspresharedkey(void* lpObj);
int secureblackbox_xadessigner_settlspresharedkey(void* lpObj, const char* lpszTLSPreSharedKey);

char* secureblackbox_xadessigner_gettlspresharedkeyciphersuite(void* lpObj);
int secureblackbox_xadessigner_settlspresharedkeyciphersuite(void* lpObj, const char* lpszTLSPreSharedKeyCiphersuite);

int secureblackbox_xadessigner_gettlsrenegotiationattackpreventionmode(void* lpObj);
int secureblackbox_xadessigner_settlsrenegotiationattackpreventionmode(void* lpObj, int iTLSRenegotiationAttackPreventionMode);

int secureblackbox_xadessigner_gettlsrevocationcheck(void* lpObj);
int secureblackbox_xadessigner_settlsrevocationcheck(void* lpObj, int iTLSRevocationCheck);

int secureblackbox_xadessigner_gettlsssloptions(void* lpObj);
int secureblackbox_xadessigner_settlsssloptions(void* lpObj, int iTLSSSLOptions);

int secureblackbox_xadessigner_gettlstlsmode(void* lpObj);
int secureblackbox_xadessigner_settlstlsmode(void* lpObj, int iTLSTLSMode);

int secureblackbox_xadessigner_gettlsuseextendedmastersecret(void* lpObj);
int secureblackbox_xadessigner_settlsuseextendedmastersecret(void* lpObj, int bTLSUseExtendedMasterSecret);

int secureblackbox_xadessigner_gettlsusesessionresumption(void* lpObj);
int secureblackbox_xadessigner_settlsusesessionresumption(void* lpObj, int bTLSUseSessionResumption);

int secureblackbox_xadessigner_gettlsversions(void* lpObj);
int secureblackbox_xadessigner_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_xadessigner_gettrustedcertcount(void* lpObj);
int secureblackbox_xadessigner_settrustedcertcount(void* lpObj, int iTrustedCertCount);

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

int64 secureblackbox_xadessigner_gettrustedcerthandle(void* lpObj, int trustedcertindex);
int secureblackbox_xadessigner_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_xadessigner_getvalidationmoment(void* lpObj);
int secureblackbox_xadessigner_setvalidationmoment(void* lpObj, const char* lpszValidationMoment);

QString GetValidationMoment();
int SetValidationMoment(QString qsValidationMoment);

int secureblackbox_xadessigner_adddatareference(void* lpObj, const char* lpszDataURI, const char* lpData, int lenData);

int AddDataReference(const QString& qsDataURI, QByteArray qbaData);

int secureblackbox_xadessigner_addknownnamespace(void* lpObj, const char* lpszPrefix, const char* lpszURI);

int AddKnownNamespace(const QString& qsPrefix, const QString& qsURI);

int secureblackbox_xadessigner_addreference(void* lpObj, const char* lpszTargetXmlElement, const char* lpszCustomId, int bAutoGenerateId);

int AddReference(const QString& qsTargetXmlElement, const QString& qsCustomId, bool bAutoGenerateId);

int secureblackbox_xadessigner_close(void* lpObj, int bSaveChanges);

int Close(bool bSaveChanges);

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

QString Config(const QString& qsConfigurationString);

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

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

char* secureblackbox_xadessigner_extractasyncdata(void* lpObj, const char* lpszAsyncReply);

QString ExtractAsyncData(const QString& qsAsyncReply);

char* secureblackbox_xadessigner_getinnerxml(void* lpObj, const char* lpszXPath);

QString GetInnerXML(const QString& qsXPath);

char* secureblackbox_xadessigner_getouterxml(void* lpObj, const char* lpszXPath);

QString GetOuterXML(const QString& qsXPath);

char* secureblackbox_xadessigner_gettextcontent(void* lpObj, const char* lpszXPath);

QString GetTextContent(const QString& qsXPath);

int secureblackbox_xadessigner_open(void* lpObj);

int Open();

int secureblackbox_xadessigner_reset(void* lpObj);

int Reset();

int secureblackbox_xadessigner_revalidate(void* lpObj, const char* lpszSigLabel, int bDetached);

int Revalidate(const QString& qsSigLabel, bool bDetached);

int secureblackbox_xadessigner_selectinfo(void* lpObj, const char* lpszEntityLabel, int iInfoType, int bClearSelection);

int SelectInfo(const QString& qsEntityLabel, int iInfoType, bool bClearSelection);

int secureblackbox_xadessigner_setinnerxml(void* lpObj, const char* lpszXPath, const char* lpszValue);

int SetInnerXML(const QString& qsXPath, const QString& qsValue);

int secureblackbox_xadessigner_settextcontent(void* lpObj, const char* lpszXPath, const char* lpszValue);

int SetTextContent(const QString& qsXPath, const QString& qsValue);

int secureblackbox_xadessigner_sign(void* lpObj);

int Sign();

char* secureblackbox_xadessigner_signasyncbegin(void* lpObj);

QString SignAsyncBegin();

int secureblackbox_xadessigner_signasyncend(void* lpObj, const char* lpszAsyncReply);

int SignAsyncEnd(const QString& qsAsyncReply);

int secureblackbox_xadessigner_signexternal(void* lpObj);

int SignExternal();

int secureblackbox_xadessigner_timestamp(void* lpObj, const char* lpszSigLabel, int iTimestampType);

int Timestamp(const QString& qsSigLabel, int iTimestampType);

int secureblackbox_xadessigner_upgrade(void* lpObj, const char* lpszSigLabel, int iUpgradeKind);

int Upgrade(const QString& qsSigLabel, int iUpgradeKind);

#define EID_XADESSIGNER_CHAINELEMENTDOWNLOAD 1

virtual INT SECUREBLACKBOX_CALL FireChainElementDownload(INT &iKind, LPSTR &lpszCertRDN, LPSTR &lpszCACertRDN, LPSTR &lpszLocation, INT &iAction);

class XAdESSignerChainElementDownloadEventParams {
public:
  int Kind();

  const QString &CertRDN();

  const QString &CACertRDN();

  const QString &Location();

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

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

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

// Or, subclass XAdESSigner and override this emitter function.
virtual int FireChainElementDownload(XAdESSignerChainElementDownloadEventParams *e) {...}

#define EID_XADESSIGNER_CHAINELEMENTNEEDED 2

virtual INT SECUREBLACKBOX_CALL FireChainElementNeeded(INT &iKind, LPSTR &lpszCertRDN, LPSTR &lpszCACertRDN);

class XAdESSignerChainElementNeededEventParams {
public:
  int Kind();

  const QString &CertRDN();

  const QString &CACertRDN();

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

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

// Or, subclass XAdESSigner and override this emitter function.
virtual int FireChainElementNeeded(XAdESSignerChainElementNeededEventParams *e) {...}

#define EID_XADESSIGNER_CHAINELEMENTSTORE 3

virtual INT SECUREBLACKBOX_CALL FireChainElementStore(INT &iKind, LPSTR &lpBody, INT &lenBody, LPSTR &lpszURI);

class XAdESSignerChainElementStoreEventParams {
public:
  int Kind();

  const QByteArray &Body();

  const QString &URI();
  void SetURI(const QString &qsURI);

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

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

// Or, subclass XAdESSigner and override this emitter function.
virtual int FireChainElementStore(XAdESSignerChainElementStoreEventParams *e) {...}

#define EID_XADESSIGNER_CHAINVALIDATED 4

virtual INT SECUREBLACKBOX_CALL FireChainValidated(INT &iIndex, LPSTR &lpszEntityLabel, LPSTR &lpszSubjectRDN, INT &iValidationResult, INT &iValidationDetails, BOOL &bCancel);

class XAdESSignerChainValidatedEventParams {
public:
  int Index();

  const QString &EntityLabel();

  const QString &SubjectRDN();

  int ValidationResult();

  int ValidationDetails();

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

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

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

// Or, subclass XAdESSigner and override this emitter function.
virtual int FireChainValidated(XAdESSignerChainValidatedEventParams *e) {...}

#define EID_XADESSIGNER_CHAINVALIDATIONPROGRESS 5

virtual INT SECUREBLACKBOX_CALL FireChainValidationProgress(LPSTR &lpszEventKind, LPSTR &lpszCertRDN, LPSTR &lpszCACertRDN, INT &iAction);

class XAdESSignerChainValidationProgressEventParams {
public:
  const QString &EventKind();

  const QString &CertRDN();

  const QString &CACertRDN();

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

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

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

// Or, subclass XAdESSigner and override this emitter function.
virtual int FireChainValidationProgress(XAdESSignerChainValidationProgressEventParams *e) {...}

#define EID_XADESSIGNER_DOCUMENTLOADED 6

virtual INT SECUREBLACKBOX_CALL FireDocumentLoaded(BOOL &bCancel);

class XAdESSignerDocumentLoadedEventParams {
public:
  bool Cancel();
  void SetCancel(bool bCancel);

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

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

// Or, subclass XAdESSigner and override this emitter function.
virtual int FireDocumentLoaded(XAdESSignerDocumentLoadedEventParams *e) {...}

#define EID_XADESSIGNER_ERROR 7

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

class XAdESSignerErrorEventParams {
public:
  int ErrorCode();

  const QString &Description();

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

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

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

#define EID_XADESSIGNER_EXTERNALSIGN 8

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

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

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

#define EID_XADESSIGNER_FORMATELEMENT 9

virtual INT SECUREBLACKBOX_CALL FireFormatElement(LPSTR &lpszStartTagWhitespace, LPSTR &lpszEndTagWhitespace, INT &iLevel, LPSTR &lpszPath, BOOL &bHasChildElements);

class XAdESSignerFormatElementEventParams {
public:
  const QString &StartTagWhitespace();
  void SetStartTagWhitespace(const QString &qsStartTagWhitespace);

  const QString &EndTagWhitespace();
  void SetEndTagWhitespace(const QString &qsEndTagWhitespace);

  int Level();

  const QString &Path();

  bool HasChildElements();

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

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

// Or, subclass XAdESSigner and override this emitter function.
virtual int FireFormatElement(XAdESSignerFormatElementEventParams *e) {...}

#define EID_XADESSIGNER_FORMATTEXT 10

virtual INT SECUREBLACKBOX_CALL FireFormatText(LPSTR &lpszText, INT &iTextType, INT &iLevel, LPSTR &lpszPath);

class XAdESSignerFormatTextEventParams {
public:
  const QString &Text();
  void SetText(const QString &qsText);

  int TextType();

  int Level();

  const QString &Path();

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

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

// Or, subclass XAdESSigner and override this emitter function.
virtual int FireFormatText(XAdESSignerFormatTextEventParams *e) {...}

#define EID_XADESSIGNER_NOTIFICATION 11

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

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

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