int secureblackbox_xadesverifier_getallsignaturesvalid(void* lpObj);

bool GetAllSignaturesValid();

int secureblackbox_xadesverifier_getautovalidatesignatures(void* lpObj);
int secureblackbox_xadesverifier_setautovalidatesignatures(void* lpObj, int bAutoValidateSignatures);

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

int secureblackbox_xadesverifier_getblockedcertcount(void* lpObj);
int secureblackbox_xadesverifier_setblockedcertcount(void* lpObj, int iBlockedCertCount);

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

int64 secureblackbox_xadesverifier_getblockedcerthandle(void* lpObj, int blockedcertindex);
int secureblackbox_xadesverifier_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_xadesverifier_getcertcount(void* lpObj);

int secureblackbox_xadesverifier_getcertbytes(void* lpObj, int certindex, char** lpCertBytes, int* lenCertBytes);

int secureblackbox_xadesverifier_getcertca(void* lpObj, int certindex);

int secureblackbox_xadesverifier_getcertcakeyid(void* lpObj, int certindex, char** lpCertCAKeyID, int* lenCertCAKeyID);

int secureblackbox_xadesverifier_getcertcerttype(void* lpObj, int certindex);

char* secureblackbox_xadesverifier_getcertcrldistributionpoints(void* lpObj, int certindex);

char* secureblackbox_xadesverifier_getcertcurve(void* lpObj, int certindex);

char* secureblackbox_xadesverifier_getcertfingerprint(void* lpObj, int certindex);

char* secureblackbox_xadesverifier_getcertfriendlyname(void* lpObj, int certindex);

int64 secureblackbox_xadesverifier_getcerthandle(void* lpObj, int certindex);

char* secureblackbox_xadesverifier_getcerthashalgorithm(void* lpObj, int certindex);

char* secureblackbox_xadesverifier_getcertissuer(void* lpObj, int certindex);

char* secureblackbox_xadesverifier_getcertissuerrdn(void* lpObj, int certindex);

char* secureblackbox_xadesverifier_getcertkeyalgorithm(void* lpObj, int certindex);

int secureblackbox_xadesverifier_getcertkeybits(void* lpObj, int certindex);

char* secureblackbox_xadesverifier_getcertkeyfingerprint(void* lpObj, int certindex);

int secureblackbox_xadesverifier_getcertkeyusage(void* lpObj, int certindex);

int secureblackbox_xadesverifier_getcertkeyvalid(void* lpObj, int certindex);

char* secureblackbox_xadesverifier_getcertocsplocations(void* lpObj, int certindex);

int secureblackbox_xadesverifier_getcertocspnocheck(void* lpObj, int certindex);

int secureblackbox_xadesverifier_getcertorigin(void* lpObj, int certindex);

char* secureblackbox_xadesverifier_getcertpolicyids(void* lpObj, int certindex);

int secureblackbox_xadesverifier_getcertprivatekeybytes(void* lpObj, int certindex, char** lpCertPrivateKeyBytes, int* lenCertPrivateKeyBytes);

int secureblackbox_xadesverifier_getcertprivatekeyexists(void* lpObj, int certindex);

int secureblackbox_xadesverifier_getcertprivatekeyextractable(void* lpObj, int certindex);

int secureblackbox_xadesverifier_getcertpublickeybytes(void* lpObj, int certindex, char** lpCertPublicKeyBytes, int* lenCertPublicKeyBytes);

int secureblackbox_xadesverifier_getcertqualified(void* lpObj, int certindex);

int secureblackbox_xadesverifier_getcertqualifiedstatements(void* lpObj, int certindex);

char* secureblackbox_xadesverifier_getcertqualifiers(void* lpObj, int certindex);

int secureblackbox_xadesverifier_getcertselfsigned(void* lpObj, int certindex);

int secureblackbox_xadesverifier_getcertserialnumber(void* lpObj, int certindex, char** lpCertSerialNumber, int* lenCertSerialNumber);

char* secureblackbox_xadesverifier_getcertsigalgorithm(void* lpObj, int certindex);

int secureblackbox_xadesverifier_getcertsource(void* lpObj, int certindex);

char* secureblackbox_xadesverifier_getcertsubject(void* lpObj, int certindex);

char* secureblackbox_xadesverifier_getcertsubjectalternativename(void* lpObj, int certindex);

int secureblackbox_xadesverifier_getcertsubjectkeyid(void* lpObj, int certindex, char** lpCertSubjectKeyID, int* lenCertSubjectKeyID);

char* secureblackbox_xadesverifier_getcertsubjectrdn(void* lpObj, int certindex);

int secureblackbox_xadesverifier_getcertvalid(void* lpObj, int certindex);

char* secureblackbox_xadesverifier_getcertvalidfrom(void* lpObj, int certindex);

char* secureblackbox_xadesverifier_getcertvalidto(void* lpObj, int certindex);

int GetCertCount();

QByteArray GetCertBytes(int iCertIndex);

bool GetCertCA(int iCertIndex);

QByteArray GetCertCAKeyID(int iCertIndex);

int GetCertCertType(int iCertIndex);

QString GetCertCRLDistributionPoints(int iCertIndex);

QString GetCertCurve(int iCertIndex);

QString GetCertFingerprint(int iCertIndex);

QString GetCertFriendlyName(int iCertIndex);

qint64 GetCertHandle(int iCertIndex);

QString GetCertHashAlgorithm(int iCertIndex);

QString GetCertIssuer(int iCertIndex);

QString GetCertIssuerRDN(int iCertIndex);

QString GetCertKeyAlgorithm(int iCertIndex);

int GetCertKeyBits(int iCertIndex);

QString GetCertKeyFingerprint(int iCertIndex);

int GetCertKeyUsage(int iCertIndex);

bool GetCertKeyValid(int iCertIndex);

QString GetCertOCSPLocations(int iCertIndex);

bool GetCertOCSPNoCheck(int iCertIndex);

int GetCertOrigin(int iCertIndex);

QString GetCertPolicyIDs(int iCertIndex);

QByteArray GetCertPrivateKeyBytes(int iCertIndex);

bool GetCertPrivateKeyExists(int iCertIndex);

bool GetCertPrivateKeyExtractable(int iCertIndex);

QByteArray GetCertPublicKeyBytes(int iCertIndex);

bool GetCertQualified(int iCertIndex);

int GetCertQualifiedStatements(int iCertIndex);

QString GetCertQualifiers(int iCertIndex);

bool GetCertSelfSigned(int iCertIndex);

QByteArray GetCertSerialNumber(int iCertIndex);

QString GetCertSigAlgorithm(int iCertIndex);

int GetCertSource(int iCertIndex);

QString GetCertSubject(int iCertIndex);

QString GetCertSubjectAlternativeName(int iCertIndex);

QByteArray GetCertSubjectKeyID(int iCertIndex);

QString GetCertSubjectRDN(int iCertIndex);

bool GetCertValid(int iCertIndex);

QString GetCertValidFrom(int iCertIndex);

QString GetCertValidTo(int iCertIndex);

int secureblackbox_xadesverifier_getchecktrustedlists(void* lpObj);
int secureblackbox_xadesverifier_setchecktrustedlists(void* lpObj, int bCheckTrustedLists);

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

int secureblackbox_xadesverifier_getcrlcount(void* lpObj);

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

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

int secureblackbox_xadesverifier_getcrlentrycount(void* lpObj, int crlindex);

int64 secureblackbox_xadesverifier_getcrlhandle(void* lpObj, int crlindex);

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

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

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

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

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

int secureblackbox_xadesverifier_getcrlsource(void* lpObj, int crlindex);

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

char* secureblackbox_xadesverifier_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_xadesverifier_getdatabytes(void* lpObj, char** lpDataBytes, int* lenDataBytes);
int secureblackbox_xadesverifier_setdatabytes(void* lpObj, const char* lpDataBytes, int lenDataBytes);

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

char* secureblackbox_xadesverifier_getdatafile(void* lpObj);
int secureblackbox_xadesverifier_setdatafile(void* lpObj, const char* lpszDataFile);

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

int secureblackbox_xadesverifier_getdatatype(void* lpObj);
int secureblackbox_xadesverifier_setdatatype(void* lpObj, int iDataType);

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

char* secureblackbox_xadesverifier_getdatauri(void* lpObj);
int secureblackbox_xadesverifier_setdatauri(void* lpObj, const char* lpszDataURI);

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

char* secureblackbox_xadesverifier_getencoding(void* lpObj);
int secureblackbox_xadesverifier_setencoding(void* lpObj, const char* lpszEncoding);

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

int secureblackbox_xadesverifier_getfipsmode(void* lpObj);
int secureblackbox_xadesverifier_setfipsmode(void* lpObj, int bFIPSMode);

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

int secureblackbox_xadesverifier_getignorechainvalidationerrors(void* lpObj);
int secureblackbox_xadesverifier_setignorechainvalidationerrors(void* lpObj, int bIgnoreChainValidationErrors);

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

int secureblackbox_xadesverifier_getinputbytes(void* lpObj, char** lpInputBytes, int* lenInputBytes);
int secureblackbox_xadesverifier_setinputbytes(void* lpObj, const char* lpInputBytes, int lenInputBytes);

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

char* secureblackbox_xadesverifier_getinputfile(void* lpObj);
int secureblackbox_xadesverifier_setinputfile(void* lpObj, const char* lpszInputFile);

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

int secureblackbox_xadesverifier_getknowncertcount(void* lpObj);
int secureblackbox_xadesverifier_setknowncertcount(void* lpObj, int iKnownCertCount);

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

int64 secureblackbox_xadesverifier_getknowncerthandle(void* lpObj, int knowncertindex);
int secureblackbox_xadesverifier_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_xadesverifier_getknowncrlcount(void* lpObj);
int secureblackbox_xadesverifier_setknowncrlcount(void* lpObj, int iKnownCRLCount);

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

int64 secureblackbox_xadesverifier_getknowncrlhandle(void* lpObj, int knowncrlindex);
int secureblackbox_xadesverifier_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_xadesverifier_getknownocspcount(void* lpObj);
int secureblackbox_xadesverifier_setknownocspcount(void* lpObj, int iKnownOCSPCount);

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

int64 secureblackbox_xadesverifier_getknownocsphandle(void* lpObj, int knownocspindex);
int secureblackbox_xadesverifier_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_xadesverifier_getocspcount(void* lpObj);

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

int secureblackbox_xadesverifier_getocspentrycount(void* lpObj, int ocspindex);

int64 secureblackbox_xadesverifier_getocsphandle(void* lpObj, int ocspindex);

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

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

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

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

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

int secureblackbox_xadesverifier_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_xadesverifier_getofflinemode(void* lpObj);
int secureblackbox_xadesverifier_setofflinemode(void* lpObj, int bOfflineMode);

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

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

QByteArray GetOutputBytes();

char* secureblackbox_xadesverifier_getoutputfile(void* lpObj);
int secureblackbox_xadesverifier_setoutputfile(void* lpObj, const char* lpszOutputFile);

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

char* secureblackbox_xadesverifier_getprofile(void* lpObj);
int secureblackbox_xadesverifier_setprofile(void* lpObj, const char* lpszProfile);

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

char* secureblackbox_xadesverifier_getproxyaddress(void* lpObj);
int secureblackbox_xadesverifier_setproxyaddress(void* lpObj, const char* lpszProxyAddress);

int secureblackbox_xadesverifier_getproxyauthentication(void* lpObj);
int secureblackbox_xadesverifier_setproxyauthentication(void* lpObj, int iProxyAuthentication);

char* secureblackbox_xadesverifier_getproxypassword(void* lpObj);
int secureblackbox_xadesverifier_setproxypassword(void* lpObj, const char* lpszProxyPassword);

int secureblackbox_xadesverifier_getproxyport(void* lpObj);
int secureblackbox_xadesverifier_setproxyport(void* lpObj, int iProxyPort);

int secureblackbox_xadesverifier_getproxyproxytype(void* lpObj);
int secureblackbox_xadesverifier_setproxyproxytype(void* lpObj, int iProxyProxyType);

char* secureblackbox_xadesverifier_getproxyrequestheaders(void* lpObj);
int secureblackbox_xadesverifier_setproxyrequestheaders(void* lpObj, const char* lpszProxyRequestHeaders);

char* secureblackbox_xadesverifier_getproxyresponsebody(void* lpObj);
int secureblackbox_xadesverifier_setproxyresponsebody(void* lpObj, const char* lpszProxyResponseBody);

char* secureblackbox_xadesverifier_getproxyresponseheaders(void* lpObj);
int secureblackbox_xadesverifier_setproxyresponseheaders(void* lpObj, const char* lpszProxyResponseHeaders);

int secureblackbox_xadesverifier_getproxyuseipv6(void* lpObj);
int secureblackbox_xadesverifier_setproxyuseipv6(void* lpObj, int bProxyUseIPv6);

char* secureblackbox_xadesverifier_getproxyusername(void* lpObj);
int secureblackbox_xadesverifier_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_xadesverifier_getreferencecount(void* lpObj);

int secureblackbox_xadesverifier_getreferenceautogenerateelementid(void* lpObj, int referenceindex);

int secureblackbox_xadesverifier_getreferencecanonicalizationmethod(void* lpObj, int referenceindex);

char* secureblackbox_xadesverifier_getreferencecustomelementid(void* lpObj, int referenceindex);

char* secureblackbox_xadesverifier_getreferencedataobjectdescription(void* lpObj, int referenceindex);

char* secureblackbox_xadesverifier_getreferencedataobjectencoding(void* lpObj, int referenceindex);

char* secureblackbox_xadesverifier_getreferencedataobjectidentifier(void* lpObj, int referenceindex);

char* secureblackbox_xadesverifier_getreferencedataobjectmimetype(void* lpObj, int referenceindex);

int secureblackbox_xadesverifier_getreferencedigestvalue(void* lpObj, int referenceindex, char** lpReferenceDigestValue, int* lenReferenceDigestValue);

int64 secureblackbox_xadesverifier_getreferencehandle(void* lpObj, int referenceindex);

int secureblackbox_xadesverifier_getreferencehasdataobjectformat(void* lpObj, int referenceindex);

char* secureblackbox_xadesverifier_getreferencehashalgorithm(void* lpObj, int referenceindex);

int secureblackbox_xadesverifier_getreferencehasuri(void* lpObj, int referenceindex);

char* secureblackbox_xadesverifier_getreferenceid(void* lpObj, int referenceindex);

char* secureblackbox_xadesverifier_getreferenceinclusivenamespacesprefixlist(void* lpObj, int referenceindex);

char* secureblackbox_xadesverifier_getreferencereferencetype(void* lpObj, int referenceindex);

int secureblackbox_xadesverifier_getreferencetargetdata(void* lpObj, int referenceindex, char** lpReferenceTargetData, int* lenReferenceTargetData);

int secureblackbox_xadesverifier_getreferencetargettype(void* lpObj, int referenceindex);

char* secureblackbox_xadesverifier_getreferencetargetxmlelement(void* lpObj, int referenceindex);

char* secureblackbox_xadesverifier_getreferenceuri(void* lpObj, int referenceindex);

int secureblackbox_xadesverifier_getreferenceusebase64transform(void* lpObj, int referenceindex);

int secureblackbox_xadesverifier_getreferenceuseenvelopedsignaturetransform(void* lpObj, int referenceindex);

int secureblackbox_xadesverifier_getreferenceusexpathfilter2transform(void* lpObj, int referenceindex);

int secureblackbox_xadesverifier_getreferenceusexpathtransform(void* lpObj, int referenceindex);

int secureblackbox_xadesverifier_getreferencevalidationresult(void* lpObj, int referenceindex);

char* secureblackbox_xadesverifier_getreferencexpathexpression(void* lpObj, int referenceindex);

char* secureblackbox_xadesverifier_getreferencexpathfilter2expressions(void* lpObj, int referenceindex);

char* secureblackbox_xadesverifier_getreferencexpathfilter2filters(void* lpObj, int referenceindex);

char* secureblackbox_xadesverifier_getreferencexpathfilter2prefixlist(void* lpObj, int referenceindex);

char* secureblackbox_xadesverifier_getreferencexpathprefixlist(void* lpObj, int referenceindex);

int GetReferenceCount();

bool GetReferenceAutoGenerateElementId(int iReferenceIndex);

int GetReferenceCanonicalizationMethod(int iReferenceIndex);

QString GetReferenceCustomElementId(int iReferenceIndex);

QString GetReferenceDataObjectDescription(int iReferenceIndex);

QString GetReferenceDataObjectEncoding(int iReferenceIndex);

QString GetReferenceDataObjectIdentifier(int iReferenceIndex);

QString GetReferenceDataObjectMimeType(int iReferenceIndex);

QByteArray GetReferenceDigestValue(int iReferenceIndex);

qint64 GetReferenceHandle(int iReferenceIndex);

bool GetReferenceHasDataObjectFormat(int iReferenceIndex);

QString GetReferenceHashAlgorithm(int iReferenceIndex);

bool GetReferenceHasURI(int iReferenceIndex);

QString GetReferenceID(int iReferenceIndex);

QString GetReferenceInclusiveNamespacesPrefixList(int iReferenceIndex);

QString GetReferenceReferenceType(int iReferenceIndex);

QByteArray GetReferenceTargetData(int iReferenceIndex);

int GetReferenceTargetType(int iReferenceIndex);

QString GetReferenceTargetXMLElement(int iReferenceIndex);

QString GetReferenceURI(int iReferenceIndex);

bool GetReferenceUseBase64Transform(int iReferenceIndex);

bool GetReferenceUseEnvelopedSignatureTransform(int iReferenceIndex);

bool GetReferenceUseXPathFilter2Transform(int iReferenceIndex);

bool GetReferenceUseXPathTransform(int iReferenceIndex);

bool GetReferenceValidationResult(int iReferenceIndex);

QString GetReferenceXPathExpression(int iReferenceIndex);

QString GetReferenceXPathFilter2Expressions(int iReferenceIndex);

QString GetReferenceXPathFilter2Filters(int iReferenceIndex);

QString GetReferenceXPathFilter2PrefixList(int iReferenceIndex);

QString GetReferenceXPathPrefixList(int iReferenceIndex);

int secureblackbox_xadesverifier_getrevocationcheck(void* lpObj);
int secureblackbox_xadesverifier_setrevocationcheck(void* lpObj, int iRevocationCheck);

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

int secureblackbox_xadesverifier_getsignaturecount(void* lpObj);

int secureblackbox_xadesverifier_getsignaturecanonicalizationmethod(void* lpObj, int signatureindex);

int secureblackbox_xadesverifier_getsignaturechainvalidationdetails(void* lpObj, int signatureindex);

int secureblackbox_xadesverifier_getsignaturechainvalidationresult(void* lpObj, int signatureindex);

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

int secureblackbox_xadesverifier_getsignaturecompatibilityerrors(void* lpObj, int signatureindex);

int secureblackbox_xadesverifier_getsignaturecontainslongterminfo(void* lpObj, int signatureindex);

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

int64 secureblackbox_xadesverifier_getsignaturehandle(void* lpObj, int signatureindex);

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

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

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

int secureblackbox_xadesverifier_getsignaturelevel(void* lpObj, int signatureindex);

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

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

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

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

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

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

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

int secureblackbox_xadesverifier_getsignaturesignaturetype(void* lpObj, int signatureindex);

int secureblackbox_xadesverifier_getsignaturesignaturevalidationresult(void* lpObj, int signatureindex);

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

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

int secureblackbox_xadesverifier_getsignaturetimestamped(void* lpObj, int signatureindex);

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

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

int secureblackbox_xadesverifier_getsignaturexadesversion(void* lpObj, int signatureindex);

char* secureblackbox_xadesverifier_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_xadesverifier_getsocketdnsmode(void* lpObj);
int secureblackbox_xadesverifier_setsocketdnsmode(void* lpObj, int iSocketDNSMode);

int secureblackbox_xadesverifier_getsocketdnsport(void* lpObj);
int secureblackbox_xadesverifier_setsocketdnsport(void* lpObj, int iSocketDNSPort);

int secureblackbox_xadesverifier_getsocketdnsquerytimeout(void* lpObj);
int secureblackbox_xadesverifier_setsocketdnsquerytimeout(void* lpObj, int iSocketDNSQueryTimeout);

char* secureblackbox_xadesverifier_getsocketdnsservers(void* lpObj);
int secureblackbox_xadesverifier_setsocketdnsservers(void* lpObj, const char* lpszSocketDNSServers);

int secureblackbox_xadesverifier_getsocketdnstotaltimeout(void* lpObj);
int secureblackbox_xadesverifier_setsocketdnstotaltimeout(void* lpObj, int iSocketDNSTotalTimeout);

int secureblackbox_xadesverifier_getsocketincomingspeedlimit(void* lpObj);
int secureblackbox_xadesverifier_setsocketincomingspeedlimit(void* lpObj, int iSocketIncomingSpeedLimit);

char* secureblackbox_xadesverifier_getsocketlocaladdress(void* lpObj);
int secureblackbox_xadesverifier_setsocketlocaladdress(void* lpObj, const char* lpszSocketLocalAddress);

int secureblackbox_xadesverifier_getsocketlocalport(void* lpObj);
int secureblackbox_xadesverifier_setsocketlocalport(void* lpObj, int iSocketLocalPort);

int secureblackbox_xadesverifier_getsocketoutgoingspeedlimit(void* lpObj);
int secureblackbox_xadesverifier_setsocketoutgoingspeedlimit(void* lpObj, int iSocketOutgoingSpeedLimit);

int secureblackbox_xadesverifier_getsockettimeout(void* lpObj);
int secureblackbox_xadesverifier_setsockettimeout(void* lpObj, int iSocketTimeout);

int secureblackbox_xadesverifier_getsocketuseipv6(void* lpObj);
int secureblackbox_xadesverifier_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_xadesverifier_gettimestampcount(void* lpObj);

int64 secureblackbox_xadesverifier_gettimestampaccuracy(void* lpObj, int timestampindex);

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

int secureblackbox_xadesverifier_gettimestampcertificateindex(void* lpObj, int timestampindex);

int secureblackbox_xadesverifier_gettimestampchainvalidationdetails(void* lpObj, int timestampindex);

int secureblackbox_xadesverifier_gettimestampchainvalidationresult(void* lpObj, int timestampindex);

int secureblackbox_xadesverifier_gettimestampcontainslongterminfo(void* lpObj, int timestampindex);

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

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

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

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

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

int secureblackbox_xadesverifier_gettimestamptimestamptype(void* lpObj, int timestampindex);

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

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

int secureblackbox_xadesverifier_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);

int secureblackbox_xadesverifier_gettlsclientcertcount(void* lpObj);
int secureblackbox_xadesverifier_settlsclientcertcount(void* lpObj, int iTLSClientCertCount);

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

int64 secureblackbox_xadesverifier_gettlsclientcerthandle(void* lpObj, int tlsclientcertindex);
int secureblackbox_xadesverifier_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_xadesverifier_gettlsservercertcount(void* lpObj);

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

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

int64 secureblackbox_xadesverifier_gettlsservercerthandle(void* lpObj, int tlsservercertindex);

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

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

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

int secureblackbox_xadesverifier_gettlsservercertkeybits(void* lpObj, int tlsservercertindex);

int secureblackbox_xadesverifier_gettlsservercertkeyusage(void* lpObj, int tlsservercertindex);

int secureblackbox_xadesverifier_gettlsservercertselfsigned(void* lpObj, int tlsservercertindex);

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

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

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

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

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

char* secureblackbox_xadesverifier_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_xadesverifier_gettlsautovalidatecertificates(void* lpObj);
int secureblackbox_xadesverifier_settlsautovalidatecertificates(void* lpObj, int bTLSAutoValidateCertificates);

int secureblackbox_xadesverifier_gettlsbaseconfiguration(void* lpObj);
int secureblackbox_xadesverifier_settlsbaseconfiguration(void* lpObj, int iTLSBaseConfiguration);

char* secureblackbox_xadesverifier_gettlsciphersuites(void* lpObj);
int secureblackbox_xadesverifier_settlsciphersuites(void* lpObj, const char* lpszTLSCiphersuites);

int secureblackbox_xadesverifier_gettlsclientauth(void* lpObj);
int secureblackbox_xadesverifier_settlsclientauth(void* lpObj, int iTLSClientAuth);

char* secureblackbox_xadesverifier_gettlseccurves(void* lpObj);
int secureblackbox_xadesverifier_settlseccurves(void* lpObj, const char* lpszTLSECCurves);

char* secureblackbox_xadesverifier_gettlsextensions(void* lpObj);
int secureblackbox_xadesverifier_settlsextensions(void* lpObj, const char* lpszTLSExtensions);

int secureblackbox_xadesverifier_gettlsforceresumeifdestinationchanges(void* lpObj);
int secureblackbox_xadesverifier_settlsforceresumeifdestinationchanges(void* lpObj, int bTLSForceResumeIfDestinationChanges);

char* secureblackbox_xadesverifier_gettlspresharedidentity(void* lpObj);
int secureblackbox_xadesverifier_settlspresharedidentity(void* lpObj, const char* lpszTLSPreSharedIdentity);

char* secureblackbox_xadesverifier_gettlspresharedkey(void* lpObj);
int secureblackbox_xadesverifier_settlspresharedkey(void* lpObj, const char* lpszTLSPreSharedKey);

char* secureblackbox_xadesverifier_gettlspresharedkeyciphersuite(void* lpObj);
int secureblackbox_xadesverifier_settlspresharedkeyciphersuite(void* lpObj, const char* lpszTLSPreSharedKeyCiphersuite);

int secureblackbox_xadesverifier_gettlsrenegotiationattackpreventionmode(void* lpObj);
int secureblackbox_xadesverifier_settlsrenegotiationattackpreventionmode(void* lpObj, int iTLSRenegotiationAttackPreventionMode);

int secureblackbox_xadesverifier_gettlsrevocationcheck(void* lpObj);
int secureblackbox_xadesverifier_settlsrevocationcheck(void* lpObj, int iTLSRevocationCheck);

int secureblackbox_xadesverifier_gettlsssloptions(void* lpObj);
int secureblackbox_xadesverifier_settlsssloptions(void* lpObj, int iTLSSSLOptions);

int secureblackbox_xadesverifier_gettlstlsmode(void* lpObj);
int secureblackbox_xadesverifier_settlstlsmode(void* lpObj, int iTLSTLSMode);

int secureblackbox_xadesverifier_gettlsuseextendedmastersecret(void* lpObj);
int secureblackbox_xadesverifier_settlsuseextendedmastersecret(void* lpObj, int bTLSUseExtendedMasterSecret);

int secureblackbox_xadesverifier_gettlsusesessionresumption(void* lpObj);
int secureblackbox_xadesverifier_settlsusesessionresumption(void* lpObj, int bTLSUseSessionResumption);

int secureblackbox_xadesverifier_gettlsversions(void* lpObj);
int secureblackbox_xadesverifier_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_xadesverifier_gettrustedcertcount(void* lpObj);
int secureblackbox_xadesverifier_settrustedcertcount(void* lpObj, int iTrustedCertCount);

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

int64 secureblackbox_xadesverifier_gettrustedcerthandle(void* lpObj, int trustedcertindex);
int secureblackbox_xadesverifier_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_xadesverifier_getvalidationmoment(void* lpObj);
int secureblackbox_xadesverifier_setvalidationmoment(void* lpObj, const char* lpszValidationMoment);

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

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

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

int secureblackbox_xadesverifier_close(void* lpObj, int bSaveChanges);

int Close(bool bSaveChanges);

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

QString Config(const QString& qsConfigurationString);

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

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

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

QString GetInnerXML(const QString& qsXPath);

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

QString GetOuterXML(const QString& qsXPath);

int secureblackbox_xadesverifier_getsigneddata(void* lpObj, const char* lpszSigLabel, int iRefIndex);

int GetSignedData(const QString& qsSigLabel, int iRefIndex);

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

QString GetTextContent(const QString& qsXPath);

int secureblackbox_xadesverifier_open(void* lpObj);

int Open();

int secureblackbox_xadesverifier_reset(void* lpObj);

int Reset();

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

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

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

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

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

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

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

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

int secureblackbox_xadesverifier_unsign(void* lpObj, const char* lpszSigLabel);

int Unsign(const QString& qsSigLabel);

int secureblackbox_xadesverifier_verify(void* lpObj);

int Verify();

int secureblackbox_xadesverifier_verifydetached(void* lpObj);

int VerifyDetached();

#define EID_XADESVERIFIER_CHAINELEMENTDOWNLOAD 1

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

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

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

#define EID_XADESVERIFIER_CHAINELEMENTNEEDED 2

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

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

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

#define EID_XADESVERIFIER_CHAINELEMENTSTORE 3

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

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

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

#define EID_XADESVERIFIER_CHAINVALIDATED 4

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

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

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

#define EID_XADESVERIFIER_CHAINVALIDATIONPROGRESS 5

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

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

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

#define EID_XADESVERIFIER_DOCUMENTLOADED 6

virtual INT SECUREBLACKBOX_CALL FireDocumentLoaded(BOOL &bCancel);

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

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

#define EID_XADESVERIFIER_ERROR 7

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

class XAdESVerifierErrorEventParams {
public:
  int ErrorCode();

  const QString &Description();

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

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

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

#define EID_XADESVERIFIER_NOTIFICATION 8

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

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

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

#define EID_XADESVERIFIER_REFERENCEVALIDATED 9

virtual INT SECUREBLACKBOX_CALL FireReferenceValidated(INT &iReferenceIndex, LPSTR &lpszID, LPSTR &lpszURI, LPSTR &lpszRefType, BOOL &bDigestValid);

class XAdESVerifierReferenceValidatedEventParams {
public:
  int ReferenceIndex();

  const QString &ID();

  const QString &URI();

  const QString &RefType();

  bool DigestValid();

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

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

// Or, subclass XAdESVerifier and override this emitter function.
virtual int FireReferenceValidated(XAdESVerifierReferenceValidatedEventParams *e) {...}

#define EID_XADESVERIFIER_RESOLVEREFERENCE 10

virtual INT SECUREBLACKBOX_CALL FireResolveReference(INT &iReferenceIndex, LPSTR &lpszURI);

class XAdESVerifierResolveReferenceEventParams {
public:
  int ReferenceIndex();

  const QString &URI();

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

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

// Or, subclass XAdESVerifier and override this emitter function.
virtual int FireResolveReference(XAdESVerifierResolveReferenceEventParams *e) {...}

#define EID_XADESVERIFIER_SIGNATUREFOUND 11

virtual INT SECUREBLACKBOX_CALL FireSignatureFound(INT &iIndex, LPSTR &lpszEntityLabel, LPSTR &lpszIssuerRDN, LPSTR &lpSerialNumber, INT &lenSerialNumber, LPSTR &lpSubjectKeyID, INT &lenSubjectKeyID, BOOL &bCertFound, BOOL &bValidateSignature, BOOL &bValidateChain);

class XAdESVerifierSignatureFoundEventParams {
public:
  int Index();

  const QString &EntityLabel();

  const QString &IssuerRDN();

  const QByteArray &SerialNumber();

  const QByteArray &SubjectKeyID();

  bool CertFound();

  bool ValidateSignature();
  void SetValidateSignature(bool bValidateSignature);

  bool ValidateChain();
  void SetValidateChain(bool bValidateChain);

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

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

// Or, subclass XAdESVerifier and override this emitter function.
virtual int FireSignatureFound(XAdESVerifierSignatureFoundEventParams *e) {...}

#define EID_XADESVERIFIER_SIGNATUREVALIDATED 12

virtual INT SECUREBLACKBOX_CALL FireSignatureValidated(INT &iIndex, LPSTR &lpszEntityLabel, LPSTR &lpszIssuerRDN, LPSTR &lpSerialNumber, INT &lenSerialNumber, LPSTR &lpSubjectKeyID, INT &lenSubjectKeyID, INT &iValidationResult, BOOL &bCancel);

class XAdESVerifierSignatureValidatedEventParams {
public:
  int Index();

  const QString &EntityLabel();

  const QString &IssuerRDN();

  const QByteArray &SerialNumber();

  const QByteArray &SubjectKeyID();

  int ValidationResult();

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

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

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

// Or, subclass XAdESVerifier and override this emitter function.
virtual int FireSignatureValidated(XAdESVerifierSignatureValidatedEventParams *e) {...}

#define EID_XADESVERIFIER_TIMESTAMPFOUND 13

virtual INT SECUREBLACKBOX_CALL FireTimestampFound(INT &iIndex, LPSTR &lpszEntityLabel, LPSTR &lpszIssuerRDN, LPSTR &lpSerialNumber, INT &lenSerialNumber, LPSTR &lpSubjectKeyID, INT &lenSubjectKeyID, BOOL &bCertFound, BOOL &bValidateTimestamp, BOOL &bValidateChain);

class XAdESVerifierTimestampFoundEventParams {
public:
  int Index();

  const QString &EntityLabel();

  const QString &IssuerRDN();

  const QByteArray &SerialNumber();

  const QByteArray &SubjectKeyID();

  bool CertFound();

  bool ValidateTimestamp();
  void SetValidateTimestamp(bool bValidateTimestamp);

  bool ValidateChain();
  void SetValidateChain(bool bValidateChain);

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

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

// Or, subclass XAdESVerifier and override this emitter function.
virtual int FireTimestampFound(XAdESVerifierTimestampFoundEventParams *e) {...}

#define EID_XADESVERIFIER_TIMESTAMPVALIDATED 14

virtual INT SECUREBLACKBOX_CALL FireTimestampValidated(INT &iIndex, LPSTR &lpszEntityLabel, LPSTR &lpszIssuerRDN, LPSTR &lpSerialNumber, INT &lenSerialNumber, LPSTR &lpSubjectKeyID, INT &lenSubjectKeyID, LPSTR &lpszTime, INT &iValidationResult, INT &iChainValidationResult, INT &iChainValidationDetails, BOOL &bCancel);

class XAdESVerifierTimestampValidatedEventParams {
public:
  int Index();

  const QString &EntityLabel();

  const QString &IssuerRDN();

  const QByteArray &SerialNumber();

  const QByteArray &SubjectKeyID();

  const QString &Time();

  int ValidationResult();

  int ChainValidationResult();

  int ChainValidationDetails();

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

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

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

// Or, subclass XAdESVerifier and override this emitter function.
virtual int FireTimestampValidated(XAdESVerifierTimestampValidatedEventParams *e) {...}

#define EID_XADESVERIFIER_TLSCERTNEEDED 15

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

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

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

#define EID_XADESVERIFIER_TLSCERTVALIDATE 16

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

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

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

#define EID_XADESVERIFIER_TLSESTABLISHED 17

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

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

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

#define EID_XADESVERIFIER_TLSHANDSHAKE 18

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

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

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

#define EID_XADESVERIFIER_TLSSHUTDOWN 19

virtual INT SECUREBLACKBOX_CALL FireTLSShutdown(LPSTR &lpszHost);

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

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

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

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