int secureblackbox_officesigner_getautovalidatesignatures(void* lpObj);
int secureblackbox_officesigner_setautovalidatesignatures(void* lpObj, int bAutoValidateSignatures);

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

int secureblackbox_officesigner_getblockedcertcount(void* lpObj);
int secureblackbox_officesigner_setblockedcertcount(void* lpObj, int iBlockedCertCount);

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

int64 secureblackbox_officesigner_getblockedcerthandle(void* lpObj, int blockedcertindex);
int secureblackbox_officesigner_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_officesigner_getcertcount(void* lpObj);

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

int secureblackbox_officesigner_getcertca(void* lpObj, int certindex);

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

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

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

int secureblackbox_officesigner_getcertfingerprint(void* lpObj, int certindex, char** lpCertFingerprint, int* lenCertFingerprint);

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

int64 secureblackbox_officesigner_getcerthandle(void* lpObj, int certindex);

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

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

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

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

int secureblackbox_officesigner_getcertkeybits(void* lpObj, int certindex);

int secureblackbox_officesigner_getcertkeyfingerprint(void* lpObj, int certindex, char** lpCertKeyFingerprint, int* lenCertKeyFingerprint);

int secureblackbox_officesigner_getcertkeyusage(void* lpObj, int certindex);

int secureblackbox_officesigner_getcertkeyvalid(void* lpObj, int certindex);

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

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

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

int secureblackbox_officesigner_getcertqualified(void* lpObj, int certindex);

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

int secureblackbox_officesigner_getcertselfsigned(void* lpObj, int certindex);

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

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

int secureblackbox_officesigner_getcertsource(void* lpObj, int certindex);

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

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

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

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

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

int GetCertCount();

QByteArray GetCertBytes(int iCertIndex);

bool GetCertCA(int iCertIndex);

QByteArray GetCertCAKeyID(int iCertIndex);

QString GetCertCRLDistributionPoints(int iCertIndex);

QString GetCertCurve(int iCertIndex);

QByteArray 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);

QByteArray GetCertKeyFingerprint(int iCertIndex);

int GetCertKeyUsage(int iCertIndex);

bool GetCertKeyValid(int iCertIndex);

QString GetCertOCSPLocations(int iCertIndex);

QString GetCertPolicyIDs(int iCertIndex);

QByteArray GetCertPublicKeyBytes(int iCertIndex);

bool GetCertQualified(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);

QByteArray GetCertSubjectKeyID(int iCertIndex);

QString GetCertSubjectRDN(int iCertIndex);

QString GetCertValidFrom(int iCertIndex);

QString GetCertValidTo(int iCertIndex);

int secureblackbox_officesigner_getchecktrustedlists(void* lpObj);
int secureblackbox_officesigner_setchecktrustedlists(void* lpObj, int bCheckTrustedLists);

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

int secureblackbox_officesigner_getcrlcount(void* lpObj);

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

int64 secureblackbox_officesigner_getcrlhandle(void* lpObj, int crlindex);

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

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

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

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

int secureblackbox_officesigner_getcrlsource(void* lpObj, int crlindex);

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

int GetCRLCount();

QByteArray GetCRLBytes(int iCRLIndex);

qint64 GetCRLHandle(int iCRLIndex);

QString GetCRLIssuer(int iCRLIndex);

QString GetCRLIssuerRDN(int iCRLIndex);

QString GetCRLLocation(int iCRLIndex);

QString GetCRLNextUpdate(int iCRLIndex);

int GetCRLSource(int iCRLIndex);

QString GetCRLThisUpdate(int iCRLIndex);

int secureblackbox_officesigner_getdocumentformat(void* lpObj);

int GetDocumentFormat();

char* secureblackbox_officesigner_getdocumenttype(void* lpObj);

QString GetDocumentType();

char* secureblackbox_officesigner_getexternalcryptoasyncdocumentid(void* lpObj);
int secureblackbox_officesigner_setexternalcryptoasyncdocumentid(void* lpObj, const char* lpszExternalCryptoAsyncDocumentID);

char* secureblackbox_officesigner_getexternalcryptocustomparams(void* lpObj);
int secureblackbox_officesigner_setexternalcryptocustomparams(void* lpObj, const char* lpszExternalCryptoCustomParams);

char* secureblackbox_officesigner_getexternalcryptodata(void* lpObj);
int secureblackbox_officesigner_setexternalcryptodata(void* lpObj, const char* lpszExternalCryptoData);

int secureblackbox_officesigner_getexternalcryptoexternalhashcalculation(void* lpObj);
int secureblackbox_officesigner_setexternalcryptoexternalhashcalculation(void* lpObj, int bExternalCryptoExternalHashCalculation);

char* secureblackbox_officesigner_getexternalcryptohashalgorithm(void* lpObj);
int secureblackbox_officesigner_setexternalcryptohashalgorithm(void* lpObj, const char* lpszExternalCryptoHashAlgorithm);

char* secureblackbox_officesigner_getexternalcryptokeyid(void* lpObj);
int secureblackbox_officesigner_setexternalcryptokeyid(void* lpObj, const char* lpszExternalCryptoKeyID);

char* secureblackbox_officesigner_getexternalcryptokeysecret(void* lpObj);
int secureblackbox_officesigner_setexternalcryptokeysecret(void* lpObj, const char* lpszExternalCryptoKeySecret);

int secureblackbox_officesigner_getexternalcryptomethod(void* lpObj);
int secureblackbox_officesigner_setexternalcryptomethod(void* lpObj, int iExternalCryptoMethod);

int secureblackbox_officesigner_getexternalcryptomode(void* lpObj);
int secureblackbox_officesigner_setexternalcryptomode(void* lpObj, int iExternalCryptoMode);

char* secureblackbox_officesigner_getexternalcryptopublickeyalgorithm(void* lpObj);
int secureblackbox_officesigner_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_officesigner_getfipsmode(void* lpObj);
int secureblackbox_officesigner_setfipsmode(void* lpObj, int bFIPSMode);

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

int secureblackbox_officesigner_getignorechainvalidationerrors(void* lpObj);
int secureblackbox_officesigner_setignorechainvalidationerrors(void* lpObj, int bIgnoreChainValidationErrors);

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

int secureblackbox_officesigner_getinputbytes(void* lpObj, char** lpInputBytes, int* lenInputBytes);
int secureblackbox_officesigner_setinputbytes(void* lpObj, const char* lpInputBytes, int lenInputBytes);

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

char* secureblackbox_officesigner_getinputfile(void* lpObj);
int secureblackbox_officesigner_setinputfile(void* lpObj, const char* lpszInputFile);

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

int secureblackbox_officesigner_getknowncertcount(void* lpObj);
int secureblackbox_officesigner_setknowncertcount(void* lpObj, int iKnownCertCount);

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

int64 secureblackbox_officesigner_getknowncerthandle(void* lpObj, int knowncertindex);
int secureblackbox_officesigner_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_officesigner_getknowncrlcount(void* lpObj);
int secureblackbox_officesigner_setknowncrlcount(void* lpObj, int iKnownCRLCount);

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

int64 secureblackbox_officesigner_getknowncrlhandle(void* lpObj, int knowncrlindex);
int secureblackbox_officesigner_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_officesigner_getknownocspcount(void* lpObj);
int secureblackbox_officesigner_setknownocspcount(void* lpObj, int iKnownOCSPCount);

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

int64 secureblackbox_officesigner_getknownocsphandle(void* lpObj, int knownocspindex);
int secureblackbox_officesigner_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_officesigner_getnewsigcertificateindex(void* lpObj);

int secureblackbox_officesigner_getnewsigchainvalidationdetails(void* lpObj);

int secureblackbox_officesigner_getnewsigchainvalidationresult(void* lpObj);

char* secureblackbox_officesigner_getnewsigclaimedsigningtime(void* lpObj);
int secureblackbox_officesigner_setnewsigclaimedsigningtime(void* lpObj, const char* lpszNewSigClaimedSigningTime);

int secureblackbox_officesigner_getnewsigcontainslongterminfo(void* lpObj);

int secureblackbox_officesigner_getnewsigcorepropertiessigned(void* lpObj);
int secureblackbox_officesigner_setnewsigcorepropertiessigned(void* lpObj, int bNewSigCorePropertiesSigned);

int secureblackbox_officesigner_getnewsigdocumentsigned(void* lpObj);
int secureblackbox_officesigner_setnewsigdocumentsigned(void* lpObj, int bNewSigDocumentSigned);

char* secureblackbox_officesigner_getnewsigexpiretime(void* lpObj);

int64 secureblackbox_officesigner_getnewsighandle(void* lpObj);
int secureblackbox_officesigner_setnewsighandle(void* lpObj, int64 lNewSigHandle);

char* secureblackbox_officesigner_getnewsighashalgorithm(void* lpObj);
int secureblackbox_officesigner_setnewsighashalgorithm(void* lpObj, const char* lpszNewSigHashAlgorithm);

char* secureblackbox_officesigner_getnewsigissuerrdn(void* lpObj);

char* secureblackbox_officesigner_getnewsiglastarchivaltime(void* lpObj);

char* secureblackbox_officesigner_getnewsigpolicyhash(void* lpObj);
int secureblackbox_officesigner_setnewsigpolicyhash(void* lpObj, const char* lpszNewSigPolicyHash);

char* secureblackbox_officesigner_getnewsigpolicyhashalgorithm(void* lpObj);
int secureblackbox_officesigner_setnewsigpolicyhashalgorithm(void* lpObj, const char* lpszNewSigPolicyHashAlgorithm);

char* secureblackbox_officesigner_getnewsigpolicyid(void* lpObj);
int secureblackbox_officesigner_setnewsigpolicyid(void* lpObj, const char* lpszNewSigPolicyID);

char* secureblackbox_officesigner_getnewsigpolicyuri(void* lpObj);
int secureblackbox_officesigner_setnewsigpolicyuri(void* lpObj, const char* lpszNewSigPolicyURI);

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

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

char* secureblackbox_officesigner_getnewsigsignatureinfocomments(void* lpObj);
int secureblackbox_officesigner_setnewsigsignatureinfocomments(void* lpObj, const char* lpszNewSigSignatureInfoComments);

char* secureblackbox_officesigner_getnewsigsignatureinfotext(void* lpObj);
int secureblackbox_officesigner_setnewsigsignatureinfotext(void* lpObj, const char* lpszNewSigSignatureInfoText);

int secureblackbox_officesigner_getnewsigsignatureoriginsigned(void* lpObj);
int secureblackbox_officesigner_setnewsigsignatureoriginsigned(void* lpObj, int bNewSigSignatureOriginSigned);

int secureblackbox_officesigner_getnewsigsignaturetype(void* lpObj);
int secureblackbox_officesigner_setnewsigsignaturetype(void* lpObj, int iNewSigSignatureType);

int secureblackbox_officesigner_getnewsigsignaturevalidationresult(void* lpObj);

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

char* secureblackbox_officesigner_getnewsigsubjectrdn(void* lpObj);

int secureblackbox_officesigner_getnewsigtimestamped(void* lpObj);

char* secureblackbox_officesigner_getnewsigvalidatedsigningtime(void* lpObj);

char* secureblackbox_officesigner_getnewsigvalidationlog(void* lpObj);

int secureblackbox_officesigner_getnewsigxades(void* lpObj);
int secureblackbox_officesigner_setnewsigxades(void* lpObj, int bNewSigXAdES);

int secureblackbox_officesigner_getnewsigxadesform(void* lpObj);
int secureblackbox_officesigner_setnewsigxadesform(void* lpObj, int iNewSigXAdESForm);

int secureblackbox_officesigner_getnewsigxadeslevel(void* lpObj);
int secureblackbox_officesigner_setnewsigxadeslevel(void* lpObj, int iNewSigXAdESLevel);

int secureblackbox_officesigner_getnewsigxadesversion(void* lpObj);
int secureblackbox_officesigner_setnewsigxadesversion(void* lpObj, int iNewSigXAdESVersion);

int GetNewSigCertificateIndex();

int GetNewSigChainValidationDetails();

int GetNewSigChainValidationResult();

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

bool GetNewSigContainsLongTermInfo();

bool GetNewSigCorePropertiesSigned();
int SetNewSigCorePropertiesSigned(bool bNewSigCorePropertiesSigned);

bool GetNewSigDocumentSigned();
int SetNewSigDocumentSigned(bool bNewSigDocumentSigned);

QString GetNewSigExpireTime();

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

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

QString GetNewSigIssuerRDN();

QString GetNewSigLastArchivalTime();

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();

QString GetNewSigSignatureInfoComments();
int SetNewSigSignatureInfoComments(QString qsNewSigSignatureInfoComments);

QString GetNewSigSignatureInfoText();
int SetNewSigSignatureInfoText(QString qsNewSigSignatureInfoText);

bool GetNewSigSignatureOriginSigned();
int SetNewSigSignatureOriginSigned(bool bNewSigSignatureOriginSigned);

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

int GetNewSigSignatureValidationResult();

QByteArray GetNewSigSubjectKeyID();

QString GetNewSigSubjectRDN();

bool GetNewSigTimestamped();

QString GetNewSigValidatedSigningTime();

QString GetNewSigValidationLog();

bool GetNewSigXAdES();
int SetNewSigXAdES(bool bNewSigXAdES);

int GetNewSigXAdESForm();
int SetNewSigXAdESForm(int iNewSigXAdESForm);

int GetNewSigXAdESLevel();
int SetNewSigXAdESLevel(int iNewSigXAdESLevel);

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

int secureblackbox_officesigner_getocspcount(void* lpObj);

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

int64 secureblackbox_officesigner_getocsphandle(void* lpObj, int ocspindex);

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

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

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

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

int secureblackbox_officesigner_getocspsource(void* lpObj, int ocspindex);

int GetOCSPCount();

QByteArray GetOCSPBytes(int iOCSPIndex);

qint64 GetOCSPHandle(int iOCSPIndex);

QString GetOCSPIssuer(int iOCSPIndex);

QString GetOCSPIssuerRDN(int iOCSPIndex);

QString GetOCSPLocation(int iOCSPIndex);

QString GetOCSPProducedAt(int iOCSPIndex);

int GetOCSPSource(int iOCSPIndex);

int secureblackbox_officesigner_getofflinemode(void* lpObj);
int secureblackbox_officesigner_setofflinemode(void* lpObj, int bOfflineMode);

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

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

QByteArray GetOutputBytes();

char* secureblackbox_officesigner_getoutputfile(void* lpObj);
int secureblackbox_officesigner_setoutputfile(void* lpObj, const char* lpszOutputFile);

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

char* secureblackbox_officesigner_getprofile(void* lpObj);
int secureblackbox_officesigner_setprofile(void* lpObj, const char* lpszProfile);

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

char* secureblackbox_officesigner_getproxyaddress(void* lpObj);
int secureblackbox_officesigner_setproxyaddress(void* lpObj, const char* lpszProxyAddress);

int secureblackbox_officesigner_getproxyauthentication(void* lpObj);
int secureblackbox_officesigner_setproxyauthentication(void* lpObj, int iProxyAuthentication);

char* secureblackbox_officesigner_getproxypassword(void* lpObj);
int secureblackbox_officesigner_setproxypassword(void* lpObj, const char* lpszProxyPassword);

int secureblackbox_officesigner_getproxyport(void* lpObj);
int secureblackbox_officesigner_setproxyport(void* lpObj, int iProxyPort);

int secureblackbox_officesigner_getproxyproxytype(void* lpObj);
int secureblackbox_officesigner_setproxyproxytype(void* lpObj, int iProxyProxyType);

char* secureblackbox_officesigner_getproxyrequestheaders(void* lpObj);
int secureblackbox_officesigner_setproxyrequestheaders(void* lpObj, const char* lpszProxyRequestHeaders);

char* secureblackbox_officesigner_getproxyresponsebody(void* lpObj);
int secureblackbox_officesigner_setproxyresponsebody(void* lpObj, const char* lpszProxyResponseBody);

char* secureblackbox_officesigner_getproxyresponseheaders(void* lpObj);
int secureblackbox_officesigner_setproxyresponseheaders(void* lpObj, const char* lpszProxyResponseHeaders);

int secureblackbox_officesigner_getproxyuseipv6(void* lpObj);
int secureblackbox_officesigner_setproxyuseipv6(void* lpObj, int bProxyUseIPv6);

char* secureblackbox_officesigner_getproxyusername(void* lpObj);
int secureblackbox_officesigner_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_officesigner_getrevocationcheck(void* lpObj);
int secureblackbox_officesigner_setrevocationcheck(void* lpObj, int iRevocationCheck);

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

int secureblackbox_officesigner_getsignaturecount(void* lpObj);

int secureblackbox_officesigner_getsignaturecertificateindex(void* lpObj, int signatureindex);

int secureblackbox_officesigner_getsignaturechainvalidationdetails(void* lpObj, int signatureindex);

int secureblackbox_officesigner_getsignaturechainvalidationresult(void* lpObj, int signatureindex);

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

int secureblackbox_officesigner_getsignaturecontainslongterminfo(void* lpObj, int signatureindex);

int secureblackbox_officesigner_getsignaturecorepropertiessigned(void* lpObj, int signatureindex);

int secureblackbox_officesigner_getsignaturedocumentsigned(void* lpObj, int signatureindex);

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

int64 secureblackbox_officesigner_getsignaturehandle(void* lpObj, int signatureindex);

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

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

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

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

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

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

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

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

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

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

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

int secureblackbox_officesigner_getsignaturesignatureoriginsigned(void* lpObj, int signatureindex);

int secureblackbox_officesigner_getsignaturesignaturetype(void* lpObj, int signatureindex);

int secureblackbox_officesigner_getsignaturesignaturevalidationresult(void* lpObj, int signatureindex);

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

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

int secureblackbox_officesigner_getsignaturetimestamped(void* lpObj, int signatureindex);

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

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

int secureblackbox_officesigner_getsignaturexades(void* lpObj, int signatureindex);

int secureblackbox_officesigner_getsignaturexadesform(void* lpObj, int signatureindex);

int secureblackbox_officesigner_getsignaturexadeslevel(void* lpObj, int signatureindex);

int secureblackbox_officesigner_getsignaturexadesversion(void* lpObj, int signatureindex);

int GetSignatureCount();

int GetSignatureCertificateIndex(int iSignatureIndex);

int GetSignatureChainValidationDetails(int iSignatureIndex);

int GetSignatureChainValidationResult(int iSignatureIndex);

QString GetSignatureClaimedSigningTime(int iSignatureIndex);

bool GetSignatureContainsLongTermInfo(int iSignatureIndex);

bool GetSignatureCorePropertiesSigned(int iSignatureIndex);

bool GetSignatureDocumentSigned(int iSignatureIndex);

QString GetSignatureExpireTime(int iSignatureIndex);

qint64 GetSignatureHandle(int iSignatureIndex);

QString GetSignatureHashAlgorithm(int iSignatureIndex);

QString GetSignatureIssuerRDN(int iSignatureIndex);

QString GetSignatureLastArchivalTime(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);

QString GetSignatureSignatureInfoComments(int iSignatureIndex);

QString GetSignatureSignatureInfoText(int iSignatureIndex);

bool GetSignatureSignatureOriginSigned(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);

bool GetSignatureXAdES(int iSignatureIndex);

int GetSignatureXAdESForm(int iSignatureIndex);

int GetSignatureXAdESLevel(int iSignatureIndex);

int GetSignatureXAdESVersion(int iSignatureIndex);

int secureblackbox_officesigner_getsignedpartcount(void* lpObj);

char* secureblackbox_officesigner_getsignedpartcontenttype(void* lpObj, int signedpartindex);

char* secureblackbox_officesigner_getsignedparthashalgorithm(void* lpObj, int signedpartindex);

int secureblackbox_officesigner_getsignedpartisrelationshippart(void* lpObj, int signedpartindex);

char* secureblackbox_officesigner_getsignedpartpath(void* lpObj, int signedpartindex);

int secureblackbox_officesigner_getsignedpartsignatureindex(void* lpObj, int signedpartindex);

int secureblackbox_officesigner_getsignedpartvalidationresult(void* lpObj, int signedpartindex);

int GetSignedPartCount();

QString GetSignedPartContentType(int iSignedPartIndex);

QString GetSignedPartHashAlgorithm(int iSignedPartIndex);

bool GetSignedPartIsRelationshipPart(int iSignedPartIndex);

QString GetSignedPartPath(int iSignedPartIndex);

int GetSignedPartSignatureIndex(int iSignedPartIndex);

int GetSignedPartValidationResult(int iSignedPartIndex);

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

int64 secureblackbox_officesigner_getsigningcerthandle(void* lpObj);
int secureblackbox_officesigner_setsigningcerthandle(void* lpObj, int64 lSigningCertHandle);

QByteArray GetSigningCertBytes();

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

int secureblackbox_officesigner_getsigningchaincount(void* lpObj);
int secureblackbox_officesigner_setsigningchaincount(void* lpObj, int iSigningChainCount);

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

int64 secureblackbox_officesigner_getsigningchainhandle(void* lpObj, int signingchainindex);
int secureblackbox_officesigner_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_officesigner_getsocketdnsmode(void* lpObj);
int secureblackbox_officesigner_setsocketdnsmode(void* lpObj, int iSocketDNSMode);

int secureblackbox_officesigner_getsocketdnsport(void* lpObj);
int secureblackbox_officesigner_setsocketdnsport(void* lpObj, int iSocketDNSPort);

int secureblackbox_officesigner_getsocketdnsquerytimeout(void* lpObj);
int secureblackbox_officesigner_setsocketdnsquerytimeout(void* lpObj, int iSocketDNSQueryTimeout);

char* secureblackbox_officesigner_getsocketdnsservers(void* lpObj);
int secureblackbox_officesigner_setsocketdnsservers(void* lpObj, const char* lpszSocketDNSServers);

int secureblackbox_officesigner_getsocketdnstotaltimeout(void* lpObj);
int secureblackbox_officesigner_setsocketdnstotaltimeout(void* lpObj, int iSocketDNSTotalTimeout);

int secureblackbox_officesigner_getsocketincomingspeedlimit(void* lpObj);
int secureblackbox_officesigner_setsocketincomingspeedlimit(void* lpObj, int iSocketIncomingSpeedLimit);

char* secureblackbox_officesigner_getsocketlocaladdress(void* lpObj);
int secureblackbox_officesigner_setsocketlocaladdress(void* lpObj, const char* lpszSocketLocalAddress);

int secureblackbox_officesigner_getsocketlocalport(void* lpObj);
int secureblackbox_officesigner_setsocketlocalport(void* lpObj, int iSocketLocalPort);

int secureblackbox_officesigner_getsocketoutgoingspeedlimit(void* lpObj);
int secureblackbox_officesigner_setsocketoutgoingspeedlimit(void* lpObj, int iSocketOutgoingSpeedLimit);

int secureblackbox_officesigner_getsockettimeout(void* lpObj);
int secureblackbox_officesigner_setsockettimeout(void* lpObj, int iSocketTimeout);

int secureblackbox_officesigner_getsocketuseipv6(void* lpObj);
int secureblackbox_officesigner_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_officesigner_gettimestampcount(void* lpObj);

int64 secureblackbox_officesigner_gettimestampaccuracy(void* lpObj, int timestampindex);

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

int secureblackbox_officesigner_gettimestampcertificateindex(void* lpObj, int timestampindex);

int secureblackbox_officesigner_gettimestampchainvalidationdetails(void* lpObj, int timestampindex);

int secureblackbox_officesigner_gettimestampchainvalidationresult(void* lpObj, int timestampindex);

int secureblackbox_officesigner_gettimestampcontainslongterminfo(void* lpObj, int timestampindex);

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

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

int secureblackbox_officesigner_gettimestampsignatureindex(void* lpObj, int timestampindex);

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

int secureblackbox_officesigner_gettimestamptimestamptype(void* lpObj, int timestampindex);

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

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

int secureblackbox_officesigner_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 GetTimestampHashAlgorithm(int iTimestampIndex);

QByteArray GetTimestampSerialNumber(int iTimestampIndex);

int GetTimestampSignatureIndex(int iTimestampIndex);

QString GetTimestampTime(int iTimestampIndex);

int GetTimestampTimestampType(int iTimestampIndex);

QString GetTimestampTSAName(int iTimestampIndex);

QString GetTimestampValidationLog(int iTimestampIndex);

int GetTimestampValidationResult(int iTimestampIndex);

char* secureblackbox_officesigner_gettimestampserver(void* lpObj);
int secureblackbox_officesigner_settimestampserver(void* lpObj, const char* lpszTimestampServer);

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

int secureblackbox_officesigner_gettlsclientcertcount(void* lpObj);
int secureblackbox_officesigner_settlsclientcertcount(void* lpObj, int iTLSClientCertCount);

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

int64 secureblackbox_officesigner_gettlsclientcerthandle(void* lpObj, int tlsclientcertindex);
int secureblackbox_officesigner_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_officesigner_gettlsservercertcount(void* lpObj);

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

int secureblackbox_officesigner_gettlsservercertfingerprint(void* lpObj, int tlsservercertindex, char** lpTLSServerCertFingerprint, int* lenTLSServerCertFingerprint);

int64 secureblackbox_officesigner_gettlsservercerthandle(void* lpObj, int tlsservercertindex);

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

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

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

int secureblackbox_officesigner_gettlsservercertkeybits(void* lpObj, int tlsservercertindex);

int secureblackbox_officesigner_gettlsservercertkeyusage(void* lpObj, int tlsservercertindex);

int secureblackbox_officesigner_gettlsservercertselfsigned(void* lpObj, int tlsservercertindex);

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

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

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

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

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

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

int GetTLSServerCertCount();

QByteArray GetTLSServerCertBytes(int iTLSServerCertIndex);

QByteArray 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_officesigner_gettlsautovalidatecertificates(void* lpObj);
int secureblackbox_officesigner_settlsautovalidatecertificates(void* lpObj, int bTLSAutoValidateCertificates);

int secureblackbox_officesigner_gettlsbaseconfiguration(void* lpObj);
int secureblackbox_officesigner_settlsbaseconfiguration(void* lpObj, int iTLSBaseConfiguration);

char* secureblackbox_officesigner_gettlsciphersuites(void* lpObj);
int secureblackbox_officesigner_settlsciphersuites(void* lpObj, const char* lpszTLSCiphersuites);

int secureblackbox_officesigner_gettlsclientauth(void* lpObj);
int secureblackbox_officesigner_settlsclientauth(void* lpObj, int iTLSClientAuth);

char* secureblackbox_officesigner_gettlseccurves(void* lpObj);
int secureblackbox_officesigner_settlseccurves(void* lpObj, const char* lpszTLSECCurves);

char* secureblackbox_officesigner_gettlsextensions(void* lpObj);
int secureblackbox_officesigner_settlsextensions(void* lpObj, const char* lpszTLSExtensions);

int secureblackbox_officesigner_gettlsforceresumeifdestinationchanges(void* lpObj);
int secureblackbox_officesigner_settlsforceresumeifdestinationchanges(void* lpObj, int bTLSForceResumeIfDestinationChanges);

char* secureblackbox_officesigner_gettlspresharedidentity(void* lpObj);
int secureblackbox_officesigner_settlspresharedidentity(void* lpObj, const char* lpszTLSPreSharedIdentity);

char* secureblackbox_officesigner_gettlspresharedkey(void* lpObj);
int secureblackbox_officesigner_settlspresharedkey(void* lpObj, const char* lpszTLSPreSharedKey);

char* secureblackbox_officesigner_gettlspresharedkeyciphersuite(void* lpObj);
int secureblackbox_officesigner_settlspresharedkeyciphersuite(void* lpObj, const char* lpszTLSPreSharedKeyCiphersuite);

int secureblackbox_officesigner_gettlsrenegotiationattackpreventionmode(void* lpObj);
int secureblackbox_officesigner_settlsrenegotiationattackpreventionmode(void* lpObj, int iTLSRenegotiationAttackPreventionMode);

int secureblackbox_officesigner_gettlsrevocationcheck(void* lpObj);
int secureblackbox_officesigner_settlsrevocationcheck(void* lpObj, int iTLSRevocationCheck);

int secureblackbox_officesigner_gettlsssloptions(void* lpObj);
int secureblackbox_officesigner_settlsssloptions(void* lpObj, int iTLSSSLOptions);

int secureblackbox_officesigner_gettlstlsmode(void* lpObj);
int secureblackbox_officesigner_settlstlsmode(void* lpObj, int iTLSTLSMode);

int secureblackbox_officesigner_gettlsuseextendedmastersecret(void* lpObj);
int secureblackbox_officesigner_settlsuseextendedmastersecret(void* lpObj, int bTLSUseExtendedMasterSecret);

int secureblackbox_officesigner_gettlsusesessionresumption(void* lpObj);
int secureblackbox_officesigner_settlsusesessionresumption(void* lpObj, int bTLSUseSessionResumption);

int secureblackbox_officesigner_gettlsversions(void* lpObj);
int secureblackbox_officesigner_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_officesigner_gettrustedcertcount(void* lpObj);
int secureblackbox_officesigner_settrustedcertcount(void* lpObj, int iTrustedCertCount);

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

int64 secureblackbox_officesigner_gettrustedcerthandle(void* lpObj, int trustedcertindex);
int secureblackbox_officesigner_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_officesigner_getvalidationmoment(void* lpObj);
int secureblackbox_officesigner_setvalidationmoment(void* lpObj, const char* lpszValidationMoment);

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

int secureblackbox_officesigner_close(void* lpObj, int bSaveChanges);

int Close(bool bSaveChanges);

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

QString Config(const QString& qsConfigurationString);

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

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

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

QString ExtractAsyncData(const QString& qsAsyncReply);

int secureblackbox_officesigner_open(void* lpObj);

int Open();

int secureblackbox_officesigner_reset(void* lpObj);

int Reset();

int secureblackbox_officesigner_revalidate(void* lpObj, int iSigIndex);

int Revalidate(int iSigIndex);

int secureblackbox_officesigner_selectrevinfo(void* lpObj, int iSigIndex, int iRevInfoType);

int SelectRevInfo(int iSigIndex, int iRevInfoType);

int secureblackbox_officesigner_sign(void* lpObj);

int Sign();

char* secureblackbox_officesigner_signasyncbegin(void* lpObj);

QString SignAsyncBegin();

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

int SignAsyncEnd(const QString& qsAsyncReply);

int secureblackbox_officesigner_signexternal(void* lpObj);

int SignExternal();

int secureblackbox_officesigner_timestamp(void* lpObj, int iSigIndex, int iTimestampType);

int Timestamp(int iSigIndex, int iTimestampType);

int secureblackbox_officesigner_upgrade(void* lpObj, int iSigIndex, int iUpgradeKind);

int Upgrade(int iSigIndex, int iUpgradeKind);

#define EID_OFFICESIGNER_CHAINELEMENTDOWNLOAD 1

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

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

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

#define EID_OFFICESIGNER_CHAINELEMENTNEEDED 2

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

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

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

#define EID_OFFICESIGNER_CHAINELEMENTSTORE 3

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

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

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

#define EID_OFFICESIGNER_CHAINVALIDATED 4

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

class OfficeSignerChainValidatedEventParams {
public:
  int Index();

  const QString &SubjectRDN();

  int ValidationResult();

  int ValidationDetails();

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

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

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

#define EID_OFFICESIGNER_CHAINVALIDATIONPROGRESS 5

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

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

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

#define EID_OFFICESIGNER_DOCUMENTLOADED 6

virtual INT SECUREBLACKBOX_CALL FireDocumentLoaded(BOOL &bCancel);

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

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

#define EID_OFFICESIGNER_ERROR 7

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

class OfficeSignerErrorEventParams {
public:
  int ErrorCode();

  const QString &Description();

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

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

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

#define EID_OFFICESIGNER_EXTERNALSIGN 8

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

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

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

#define EID_OFFICESIGNER_NOTIFICATION 9

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

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

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

#define EID_OFFICESIGNER_SIGNATUREFOUND 10

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

class OfficeSignerSignatureFoundEventParams {
public:
  int Index();

  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(OfficeSignerSignatureFoundEventParams *e);

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

#define EID_OFFICESIGNER_SIGNATUREVALIDATED 11

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

class OfficeSignerSignatureValidatedEventParams {
public:
  int Index();

  const QString &IssuerRDN();

  const QByteArray &SerialNumber();

  const QByteArray &SubjectKeyID();

  int ValidationResult();

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

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

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

#define EID_OFFICESIGNER_TIMESTAMPFOUND 12

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

class OfficeSignerTimestampFoundEventParams {
public:
  int Index();

  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(OfficeSignerTimestampFoundEventParams *e);

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

#define EID_OFFICESIGNER_TIMESTAMPREQUEST 13

virtual INT SECUREBLACKBOX_CALL FireTimestampRequest(LPSTR &lpszTSA, LPSTR &lpszTimestampRequest, LPSTR &lpszTimestampResponse, BOOL &bSuppressDefault);

class OfficeSignerTimestampRequestEventParams {
public:
  const QString &TSA();

  const QString &TimestampRequest();

  const QString &TimestampResponse();
  void SetTimestampResponse(const QString &qsTimestampResponse);

  bool SuppressDefault();
  void SetSuppressDefault(bool bSuppressDefault);

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

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

// Or, subclass OfficeSigner and override this emitter function.
virtual int FireTimestampRequest(OfficeSignerTimestampRequestEventParams *e) {...}

#define EID_OFFICESIGNER_TIMESTAMPVALIDATED 14

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

class OfficeSignerTimestampValidatedEventParams {
public:
  int Index();

  const QString &IssuerRDN();

  const QByteArray &SerialNumber();

  const QByteArray &SubjectKeyID();

  const QString &Time();

  int ValidationResult();

  int ChainValidationResult();

  int ChainValidationDetails();

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

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

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

#define EID_OFFICESIGNER_TLSCERTNEEDED 15

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

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

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

#define EID_OFFICESIGNER_TLSCERTVALIDATE 16

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

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

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

#define EID_OFFICESIGNER_TLSESTABLISHED 17

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

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

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

#define EID_OFFICESIGNER_TLSHANDSHAKE 18

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

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

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

#define EID_OFFICESIGNER_TLSSHUTDOWN 19

virtual INT SECUREBLACKBOX_CALL FireTLSShutdown(LPSTR &lpszHost);

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

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

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

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