int secureblackbox_pdfsigner_getattachedfilecount(void* lpObj);

char* secureblackbox_pdfsigner_getattachedfilescontentsubtype(void* lpObj, int attachedfileindex);

char* secureblackbox_pdfsigner_getattachedfilescontenttype(void* lpObj, int attachedfileindex);

char* secureblackbox_pdfsigner_getattachedfilescreationdate(void* lpObj, int attachedfileindex);

int secureblackbox_pdfsigner_getattachedfilesdata(void* lpObj, int attachedfileindex, char** lpAttachedFilesData, int* lenAttachedFilesData);

char* secureblackbox_pdfsigner_getattachedfilesdescription(void* lpObj, int attachedfileindex);

char* secureblackbox_pdfsigner_getattachedfilesfilename(void* lpObj, int attachedfileindex);

int64 secureblackbox_pdfsigner_getattachedfileshandle(void* lpObj, int attachedfileindex);

char* secureblackbox_pdfsigner_getattachedfilesid(void* lpObj, int attachedfileindex);

char* secureblackbox_pdfsigner_getattachedfilesmodificationdate(void* lpObj, int attachedfileindex);

char* secureblackbox_pdfsigner_getattachedfilesreaddate(void* lpObj, int attachedfileindex);

int64 secureblackbox_pdfsigner_getattachedfilessize(void* lpObj, int attachedfileindex);

int GetAttachedFileCount();

QString GetAttachedFilesContentSubtype(int iAttachedFileIndex);

QString GetAttachedFilesContentType(int iAttachedFileIndex);

QString GetAttachedFilesCreationDate(int iAttachedFileIndex);

QByteArray GetAttachedFilesData(int iAttachedFileIndex);

QString GetAttachedFilesDescription(int iAttachedFileIndex);

QString GetAttachedFilesFileName(int iAttachedFileIndex);

qint64 GetAttachedFilesHandle(int iAttachedFileIndex);

QString GetAttachedFilesID(int iAttachedFileIndex);

QString GetAttachedFilesModificationDate(int iAttachedFileIndex);

QString GetAttachedFilesReadDate(int iAttachedFileIndex);

qint64 GetAttachedFilesSize(int iAttachedFileIndex);

int secureblackbox_pdfsigner_getautovalidatesignatures(void* lpObj);
int secureblackbox_pdfsigner_setautovalidatesignatures(void* lpObj, int bAutoValidateSignatures);

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

int secureblackbox_pdfsigner_getblockedcertcount(void* lpObj);
int secureblackbox_pdfsigner_setblockedcertcount(void* lpObj, int iBlockedCertCount);

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

int64 secureblackbox_pdfsigner_getblockedcerthandle(void* lpObj, int blockedcertindex);
int secureblackbox_pdfsigner_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_pdfsigner_getcertcount(void* lpObj);

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

int secureblackbox_pdfsigner_getcertca(void* lpObj, int certindex);

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

int secureblackbox_pdfsigner_getcertcerttype(void* lpObj, int certindex);

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

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

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

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

int64 secureblackbox_pdfsigner_getcerthandle(void* lpObj, int certindex);

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

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

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

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

int secureblackbox_pdfsigner_getcertkeybits(void* lpObj, int certindex);

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

int secureblackbox_pdfsigner_getcertkeyusage(void* lpObj, int certindex);

int secureblackbox_pdfsigner_getcertkeyvalid(void* lpObj, int certindex);

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

int secureblackbox_pdfsigner_getcertocspnocheck(void* lpObj, int certindex);

int secureblackbox_pdfsigner_getcertorigin(void* lpObj, int certindex);

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

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

int secureblackbox_pdfsigner_getcertprivatekeyexists(void* lpObj, int certindex);

int secureblackbox_pdfsigner_getcertprivatekeyextractable(void* lpObj, int certindex);

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

int secureblackbox_pdfsigner_getcertqualified(void* lpObj, int certindex);

int secureblackbox_pdfsigner_getcertqualifiedstatements(void* lpObj, int certindex);

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

int secureblackbox_pdfsigner_getcertselfsigned(void* lpObj, int certindex);

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

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

int secureblackbox_pdfsigner_getcertsource(void* lpObj, int certindex);

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

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

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

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

int secureblackbox_pdfsigner_getcertvalid(void* lpObj, int certindex);

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

char* secureblackbox_pdfsigner_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_pdfsigner_getchecktrustedlists(void* lpObj);
int secureblackbox_pdfsigner_setchecktrustedlists(void* lpObj, int bCheckTrustedLists);

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

int secureblackbox_pdfsigner_getcrlcount(void* lpObj);

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

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

int secureblackbox_pdfsigner_getcrlentrycount(void* lpObj, int crlindex);

int64 secureblackbox_pdfsigner_getcrlhandle(void* lpObj, int crlindex);

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

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

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

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

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

int secureblackbox_pdfsigner_getcrlsource(void* lpObj, int crlindex);

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

char* secureblackbox_pdfsigner_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_pdfsigner_getdecryptioncertificatebytes(void* lpObj, char** lpDecryptionCertificateBytes, int* lenDecryptionCertificateBytes);

int64 secureblackbox_pdfsigner_getdecryptioncertificatehandle(void* lpObj);
int secureblackbox_pdfsigner_setdecryptioncertificatehandle(void* lpObj, int64 lDecryptionCertificateHandle);

QByteArray GetDecryptionCertificateBytes();

qint64 GetDecryptionCertificateHandle();
int SetDecryptionCertificateHandle(qint64 lDecryptionCertificateHandle);

char* secureblackbox_pdfsigner_getdocumentinfoencryptionalgorithm(void* lpObj);

int secureblackbox_pdfsigner_getdocumentinfoencryptiontype(void* lpObj);

int secureblackbox_pdfsigner_getdocumentinfometadataencrypted(void* lpObj);

int secureblackbox_pdfsigner_getdocumentinfopermissions(void* lpObj);

QString GetDocumentInfoEncryptionAlgorithm();

int GetDocumentInfoEncryptionType();

bool GetDocumentInfoMetadataEncrypted();

int GetDocumentInfoPermissions();

int secureblackbox_pdfsigner_getemptyfieldindex(void* lpObj);
int secureblackbox_pdfsigner_setemptyfieldindex(void* lpObj, int iEmptyFieldIndex);

int GetEmptyFieldIndex();
int SetEmptyFieldIndex(int iEmptyFieldIndex);

char* secureblackbox_pdfsigner_getexternalcryptoasyncdocumentid(void* lpObj);
int secureblackbox_pdfsigner_setexternalcryptoasyncdocumentid(void* lpObj, const char* lpszExternalCryptoAsyncDocumentID);

char* secureblackbox_pdfsigner_getexternalcryptocustomparams(void* lpObj);
int secureblackbox_pdfsigner_setexternalcryptocustomparams(void* lpObj, const char* lpszExternalCryptoCustomParams);

char* secureblackbox_pdfsigner_getexternalcryptodata(void* lpObj);
int secureblackbox_pdfsigner_setexternalcryptodata(void* lpObj, const char* lpszExternalCryptoData);

int secureblackbox_pdfsigner_getexternalcryptoexternalhashcalculation(void* lpObj);
int secureblackbox_pdfsigner_setexternalcryptoexternalhashcalculation(void* lpObj, int bExternalCryptoExternalHashCalculation);

char* secureblackbox_pdfsigner_getexternalcryptohashalgorithm(void* lpObj);
int secureblackbox_pdfsigner_setexternalcryptohashalgorithm(void* lpObj, const char* lpszExternalCryptoHashAlgorithm);

char* secureblackbox_pdfsigner_getexternalcryptokeyid(void* lpObj);
int secureblackbox_pdfsigner_setexternalcryptokeyid(void* lpObj, const char* lpszExternalCryptoKeyID);

char* secureblackbox_pdfsigner_getexternalcryptokeysecret(void* lpObj);
int secureblackbox_pdfsigner_setexternalcryptokeysecret(void* lpObj, const char* lpszExternalCryptoKeySecret);

int secureblackbox_pdfsigner_getexternalcryptomethod(void* lpObj);
int secureblackbox_pdfsigner_setexternalcryptomethod(void* lpObj, int iExternalCryptoMethod);

int secureblackbox_pdfsigner_getexternalcryptomode(void* lpObj);
int secureblackbox_pdfsigner_setexternalcryptomode(void* lpObj, int iExternalCryptoMode);

char* secureblackbox_pdfsigner_getexternalcryptopublickeyalgorithm(void* lpObj);
int secureblackbox_pdfsigner_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_pdfsigner_getfipsmode(void* lpObj);
int secureblackbox_pdfsigner_setfipsmode(void* lpObj, int bFIPSMode);

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

int secureblackbox_pdfsigner_getignorechainvalidationerrors(void* lpObj);
int secureblackbox_pdfsigner_setignorechainvalidationerrors(void* lpObj, int bIgnoreChainValidationErrors);

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

int secureblackbox_pdfsigner_getinputbytes(void* lpObj, char** lpInputBytes, int* lenInputBytes);
int secureblackbox_pdfsigner_setinputbytes(void* lpObj, const char* lpInputBytes, int lenInputBytes);

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

char* secureblackbox_pdfsigner_getinputfile(void* lpObj);
int secureblackbox_pdfsigner_setinputfile(void* lpObj, const char* lpszInputFile);

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

int secureblackbox_pdfsigner_getknowncertcount(void* lpObj);
int secureblackbox_pdfsigner_setknowncertcount(void* lpObj, int iKnownCertCount);

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

int64 secureblackbox_pdfsigner_getknowncerthandle(void* lpObj, int knowncertindex);
int secureblackbox_pdfsigner_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_pdfsigner_getknowncrlcount(void* lpObj);
int secureblackbox_pdfsigner_setknowncrlcount(void* lpObj, int iKnownCRLCount);

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

int64 secureblackbox_pdfsigner_getknowncrlhandle(void* lpObj, int knowncrlindex);
int secureblackbox_pdfsigner_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_pdfsigner_getknownocspcount(void* lpObj);
int secureblackbox_pdfsigner_setknownocspcount(void* lpObj, int iKnownOCSPCount);

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

int64 secureblackbox_pdfsigner_getknownocsphandle(void* lpObj, int knownocspindex);
int secureblackbox_pdfsigner_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_pdfsigner_getnewsigallowedchanges(void* lpObj);
int secureblackbox_pdfsigner_setnewsigallowedchanges(void* lpObj, int iNewSigAllowedChanges);

char* secureblackbox_pdfsigner_getnewsigauthorname(void* lpObj);
int secureblackbox_pdfsigner_setnewsigauthorname(void* lpObj, const char* lpszNewSigAuthorName);

int secureblackbox_pdfsigner_getnewsigcertification(void* lpObj);
int secureblackbox_pdfsigner_setnewsigcertification(void* lpObj, int bNewSigCertification);

int secureblackbox_pdfsigner_getnewsigchainvalidationdetails(void* lpObj);

int secureblackbox_pdfsigner_getnewsigchainvalidationresult(void* lpObj);

char* secureblackbox_pdfsigner_getnewsigclaimedsigningtime(void* lpObj);
int secureblackbox_pdfsigner_setnewsigclaimedsigningtime(void* lpObj, const char* lpszNewSigClaimedSigningTime);

int secureblackbox_pdfsigner_getnewsigcompatibilityerrors(void* lpObj);

char* secureblackbox_pdfsigner_getnewsigcontactinfo(void* lpObj);
int secureblackbox_pdfsigner_setnewsigcontactinfo(void* lpObj, const char* lpszNewSigContactInfo);

int secureblackbox_pdfsigner_getnewsigcontainslongterminfo(void* lpObj);

int secureblackbox_pdfsigner_getnewsigcoverageendsat(void* lpObj);

int secureblackbox_pdfsigner_getnewsigcustomdata(void* lpObj, char** lpNewSigCustomData, int* lenNewSigCustomData);
int secureblackbox_pdfsigner_setnewsigcustomdata(void* lpObj, const char* lpNewSigCustomData, int lenNewSigCustomData);

int secureblackbox_pdfsigner_getnewsigemptyfield(void* lpObj);
int secureblackbox_pdfsigner_setnewsigemptyfield(void* lpObj, int bNewSigEmptyField);

char* secureblackbox_pdfsigner_getnewsigentitylabel(void* lpObj);

char* secureblackbox_pdfsigner_getnewsigfiltername(void* lpObj);
int secureblackbox_pdfsigner_setnewsigfiltername(void* lpObj, const char* lpszNewSigFilterName);

char* secureblackbox_pdfsigner_getnewsigfullsignaturename(void* lpObj);

int64 secureblackbox_pdfsigner_getnewsighandle(void* lpObj);
int secureblackbox_pdfsigner_setnewsighandle(void* lpObj, int64 lNewSigHandle);

char* secureblackbox_pdfsigner_getnewsighashalgorithm(void* lpObj);
int secureblackbox_pdfsigner_setnewsighashalgorithm(void* lpObj, const char* lpszNewSigHashAlgorithm);

int secureblackbox_pdfsigner_getnewsigheight(void* lpObj);
int secureblackbox_pdfsigner_setnewsigheight(void* lpObj, int iNewSigHeight);

char* secureblackbox_pdfsigner_getnewsigissuerrdn(void* lpObj);

int secureblackbox_pdfsigner_getnewsiglevel(void* lpObj);
int secureblackbox_pdfsigner_setnewsiglevel(void* lpObj, int iNewSigLevel);

char* secureblackbox_pdfsigner_getnewsiglocation(void* lpObj);
int secureblackbox_pdfsigner_setnewsiglocation(void* lpObj, const char* lpszNewSigLocation);

int secureblackbox_pdfsigner_getnewsigoffsetx(void* lpObj);
int secureblackbox_pdfsigner_setnewsigoffsetx(void* lpObj, int iNewSigOffsetX);

int secureblackbox_pdfsigner_getnewsigoffsety(void* lpObj);
int secureblackbox_pdfsigner_setnewsigoffsety(void* lpObj, int iNewSigOffsetY);

int secureblackbox_pdfsigner_getnewsigpage(void* lpObj);

char* secureblackbox_pdfsigner_getnewsigpolicyhash(void* lpObj);
int secureblackbox_pdfsigner_setnewsigpolicyhash(void* lpObj, const char* lpszNewSigPolicyHash);

char* secureblackbox_pdfsigner_getnewsigpolicyhashalgorithm(void* lpObj);
int secureblackbox_pdfsigner_setnewsigpolicyhashalgorithm(void* lpObj, const char* lpszNewSigPolicyHashAlgorithm);

char* secureblackbox_pdfsigner_getnewsigpolicyid(void* lpObj);
int secureblackbox_pdfsigner_setnewsigpolicyid(void* lpObj, const char* lpszNewSigPolicyID);

char* secureblackbox_pdfsigner_getnewsigreason(void* lpObj);
int secureblackbox_pdfsigner_setnewsigreason(void* lpObj, const char* lpszNewSigReason);

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

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

char* secureblackbox_pdfsigner_getnewsigsignaturename(void* lpObj);
int secureblackbox_pdfsigner_setnewsigsignaturename(void* lpObj, const char* lpszNewSigSignatureName);

int secureblackbox_pdfsigner_getnewsigsignaturevalidationresult(void* lpObj);

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

char* secureblackbox_pdfsigner_getnewsigsubjectrdn(void* lpObj);

int secureblackbox_pdfsigner_getnewsigtimestamped(void* lpObj);

char* secureblackbox_pdfsigner_getnewsigvalidatedsigningtime(void* lpObj);

char* secureblackbox_pdfsigner_getnewsigvalidationlog(void* lpObj);

int secureblackbox_pdfsigner_getnewsigwidth(void* lpObj);
int secureblackbox_pdfsigner_setnewsigwidth(void* lpObj, int iNewSigWidth);

int GetNewSigAllowedChanges();
int SetNewSigAllowedChanges(int iNewSigAllowedChanges);

QString GetNewSigAuthorName();
int SetNewSigAuthorName(QString qsNewSigAuthorName);

bool GetNewSigCertification();
int SetNewSigCertification(bool bNewSigCertification);

int GetNewSigChainValidationDetails();

int GetNewSigChainValidationResult();

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

int GetNewSigCompatibilityErrors();

QString GetNewSigContactInfo();
int SetNewSigContactInfo(QString qsNewSigContactInfo);

bool GetNewSigContainsLongTermInfo();

int GetNewSigCoverageEndsAt();

QByteArray GetNewSigCustomData();
int SetNewSigCustomData(QByteArray qbaNewSigCustomData);

bool GetNewSigEmptyField();
int SetNewSigEmptyField(bool bNewSigEmptyField);

QString GetNewSigEntityLabel();

QString GetNewSigFilterName();
int SetNewSigFilterName(QString qsNewSigFilterName);

QString GetNewSigFullSignatureName();

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

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

int GetNewSigHeight();
int SetNewSigHeight(int iNewSigHeight);

QString GetNewSigIssuerRDN();

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

QString GetNewSigLocation();
int SetNewSigLocation(QString qsNewSigLocation);

int GetNewSigOffsetX();
int SetNewSigOffsetX(int iNewSigOffsetX);

int GetNewSigOffsetY();
int SetNewSigOffsetY(int iNewSigOffsetY);

int GetNewSigPage();

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

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

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

QString GetNewSigReason();
int SetNewSigReason(QString qsNewSigReason);

QByteArray GetNewSigSerialNumber();

QByteArray GetNewSigSignatureBytes();

QString GetNewSigSignatureName();
int SetNewSigSignatureName(QString qsNewSigSignatureName);

int GetNewSigSignatureValidationResult();

QByteArray GetNewSigSubjectKeyID();

QString GetNewSigSubjectRDN();

bool GetNewSigTimestamped();

QString GetNewSigValidatedSigningTime();

QString GetNewSigValidationLog();

int GetNewSigWidth();
int SetNewSigWidth(int iNewSigWidth);

int secureblackbox_pdfsigner_getocspcount(void* lpObj);

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

int secureblackbox_pdfsigner_getocspentrycount(void* lpObj, int ocspindex);

int64 secureblackbox_pdfsigner_getocsphandle(void* lpObj, int ocspindex);

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

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

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

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

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

int secureblackbox_pdfsigner_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_pdfsigner_getofflinemode(void* lpObj);
int secureblackbox_pdfsigner_setofflinemode(void* lpObj, int bOfflineMode);

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

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

QByteArray GetOutputBytes();

char* secureblackbox_pdfsigner_getoutputfile(void* lpObj);
int secureblackbox_pdfsigner_setoutputfile(void* lpObj, const char* lpszOutputFile);

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

int secureblackbox_pdfsigner_getpagecount(void* lpObj);

int secureblackbox_pdfsigner_getpagecropllx(void* lpObj, int pageindex);

int secureblackbox_pdfsigner_getpagecroplly(void* lpObj, int pageindex);

int secureblackbox_pdfsigner_getpagecropurx(void* lpObj, int pageindex);

int secureblackbox_pdfsigner_getpagecropury(void* lpObj, int pageindex);

int secureblackbox_pdfsigner_getpageheight(void* lpObj, int pageindex);

int secureblackbox_pdfsigner_getpagemediallx(void* lpObj, int pageindex);

int secureblackbox_pdfsigner_getpagemedially(void* lpObj, int pageindex);

int secureblackbox_pdfsigner_getpagemediaurx(void* lpObj, int pageindex);

int secureblackbox_pdfsigner_getpagemediaury(void* lpObj, int pageindex);

int secureblackbox_pdfsigner_getpagerotate(void* lpObj, int pageindex);

int secureblackbox_pdfsigner_getpagewidth(void* lpObj, int pageindex);

int GetPageCount();

int GetPageCropLLX(int iPageIndex);

int GetPageCropLLY(int iPageIndex);

int GetPageCropURX(int iPageIndex);

int GetPageCropURY(int iPageIndex);

int GetPageHeight(int iPageIndex);

int GetPageMediaLLX(int iPageIndex);

int GetPageMediaLLY(int iPageIndex);

int GetPageMediaURX(int iPageIndex);

int GetPageMediaURY(int iPageIndex);

int GetPageRotate(int iPageIndex);

int GetPageWidth(int iPageIndex);

char* secureblackbox_pdfsigner_getpassword(void* lpObj);
int secureblackbox_pdfsigner_setpassword(void* lpObj, const char* lpszPassword);

QString GetPassword();
int SetPassword(QString qsPassword);

char* secureblackbox_pdfsigner_getprofile(void* lpObj);
int secureblackbox_pdfsigner_setprofile(void* lpObj, const char* lpszProfile);

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

char* secureblackbox_pdfsigner_getproxyaddress(void* lpObj);
int secureblackbox_pdfsigner_setproxyaddress(void* lpObj, const char* lpszProxyAddress);

int secureblackbox_pdfsigner_getproxyauthentication(void* lpObj);
int secureblackbox_pdfsigner_setproxyauthentication(void* lpObj, int iProxyAuthentication);

char* secureblackbox_pdfsigner_getproxypassword(void* lpObj);
int secureblackbox_pdfsigner_setproxypassword(void* lpObj, const char* lpszProxyPassword);

int secureblackbox_pdfsigner_getproxyport(void* lpObj);
int secureblackbox_pdfsigner_setproxyport(void* lpObj, int iProxyPort);

int secureblackbox_pdfsigner_getproxyproxytype(void* lpObj);
int secureblackbox_pdfsigner_setproxyproxytype(void* lpObj, int iProxyProxyType);

char* secureblackbox_pdfsigner_getproxyrequestheaders(void* lpObj);
int secureblackbox_pdfsigner_setproxyrequestheaders(void* lpObj, const char* lpszProxyRequestHeaders);

char* secureblackbox_pdfsigner_getproxyresponsebody(void* lpObj);
int secureblackbox_pdfsigner_setproxyresponsebody(void* lpObj, const char* lpszProxyResponseBody);

char* secureblackbox_pdfsigner_getproxyresponseheaders(void* lpObj);
int secureblackbox_pdfsigner_setproxyresponseheaders(void* lpObj, const char* lpszProxyResponseHeaders);

int secureblackbox_pdfsigner_getproxyuseipv6(void* lpObj);
int secureblackbox_pdfsigner_setproxyuseipv6(void* lpObj, int bProxyUseIPv6);

char* secureblackbox_pdfsigner_getproxyusername(void* lpObj);
int secureblackbox_pdfsigner_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_pdfsigner_getrevocationcheck(void* lpObj);
int secureblackbox_pdfsigner_setrevocationcheck(void* lpObj, int iRevocationCheck);

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

int secureblackbox_pdfsigner_getsignaturecount(void* lpObj);

int secureblackbox_pdfsigner_getsignatureallowedchanges(void* lpObj, int signatureindex);

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

int secureblackbox_pdfsigner_getsignaturecertification(void* lpObj, int signatureindex);

int secureblackbox_pdfsigner_getsignaturechainvalidationdetails(void* lpObj, int signatureindex);

int secureblackbox_pdfsigner_getsignaturechainvalidationresult(void* lpObj, int signatureindex);

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

int secureblackbox_pdfsigner_getsignaturecompatibilityerrors(void* lpObj, int signatureindex);

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

int secureblackbox_pdfsigner_getsignaturecontainslongterminfo(void* lpObj, int signatureindex);

int secureblackbox_pdfsigner_getsignaturecoverageendsat(void* lpObj, int signatureindex);

int secureblackbox_pdfsigner_getsignaturecustomdata(void* lpObj, int signatureindex, char** lpSignatureCustomData, int* lenSignatureCustomData);

int secureblackbox_pdfsigner_getsignatureemptyfield(void* lpObj, int signatureindex);

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

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

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

int64 secureblackbox_pdfsigner_getsignaturehandle(void* lpObj, int signatureindex);

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

int secureblackbox_pdfsigner_getsignatureheight(void* lpObj, int signatureindex);

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

int secureblackbox_pdfsigner_getsignaturelevel(void* lpObj, int signatureindex);

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

int secureblackbox_pdfsigner_getsignatureoffsetx(void* lpObj, int signatureindex);

int secureblackbox_pdfsigner_getsignatureoffsety(void* lpObj, int signatureindex);

int secureblackbox_pdfsigner_getsignaturepage(void* lpObj, int signatureindex);

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

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

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

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

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

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

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

int secureblackbox_pdfsigner_getsignaturesignaturevalidationresult(void* lpObj, int signatureindex);

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

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

int secureblackbox_pdfsigner_getsignaturetimestamped(void* lpObj, int signatureindex);

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

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

int secureblackbox_pdfsigner_getsignaturewidth(void* lpObj, int signatureindex);

int GetSignatureCount();

int GetSignatureAllowedChanges(int iSignatureIndex);

QString GetSignatureAuthorName(int iSignatureIndex);

bool GetSignatureCertification(int iSignatureIndex);

int GetSignatureChainValidationDetails(int iSignatureIndex);

int GetSignatureChainValidationResult(int iSignatureIndex);

QString GetSignatureClaimedSigningTime(int iSignatureIndex);

int GetSignatureCompatibilityErrors(int iSignatureIndex);

QString GetSignatureContactInfo(int iSignatureIndex);

bool GetSignatureContainsLongTermInfo(int iSignatureIndex);

int GetSignatureCoverageEndsAt(int iSignatureIndex);

QByteArray GetSignatureCustomData(int iSignatureIndex);

bool GetSignatureEmptyField(int iSignatureIndex);

QString GetSignatureEntityLabel(int iSignatureIndex);

QString GetSignatureFilterName(int iSignatureIndex);

QString GetSignatureFullSignatureName(int iSignatureIndex);

qint64 GetSignatureHandle(int iSignatureIndex);

QString GetSignatureHashAlgorithm(int iSignatureIndex);

int GetSignatureHeight(int iSignatureIndex);

QString GetSignatureIssuerRDN(int iSignatureIndex);

int GetSignatureLevel(int iSignatureIndex);

QString GetSignatureLocation(int iSignatureIndex);

int GetSignatureOffsetX(int iSignatureIndex);

int GetSignatureOffsetY(int iSignatureIndex);

int GetSignaturePage(int iSignatureIndex);

QString GetSignaturePolicyHash(int iSignatureIndex);

QString GetSignaturePolicyHashAlgorithm(int iSignatureIndex);

QString GetSignaturePolicyID(int iSignatureIndex);

QString GetSignatureReason(int iSignatureIndex);

QByteArray GetSignatureSerialNumber(int iSignatureIndex);

QByteArray GetSignatureSignatureBytes(int iSignatureIndex);

QString GetSignatureSignatureName(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 GetSignatureWidth(int iSignatureIndex);

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

int64 secureblackbox_pdfsigner_getsigningcerthandle(void* lpObj);
int secureblackbox_pdfsigner_setsigningcerthandle(void* lpObj, int64 lSigningCertHandle);

QByteArray GetSigningCertBytes();

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

int secureblackbox_pdfsigner_getsigningchaincount(void* lpObj);
int secureblackbox_pdfsigner_setsigningchaincount(void* lpObj, int iSigningChainCount);

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

int64 secureblackbox_pdfsigner_getsigningchainhandle(void* lpObj, int signingchainindex);
int secureblackbox_pdfsigner_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_pdfsigner_getsocketdnsmode(void* lpObj);
int secureblackbox_pdfsigner_setsocketdnsmode(void* lpObj, int iSocketDNSMode);

int secureblackbox_pdfsigner_getsocketdnsport(void* lpObj);
int secureblackbox_pdfsigner_setsocketdnsport(void* lpObj, int iSocketDNSPort);

int secureblackbox_pdfsigner_getsocketdnsquerytimeout(void* lpObj);
int secureblackbox_pdfsigner_setsocketdnsquerytimeout(void* lpObj, int iSocketDNSQueryTimeout);

char* secureblackbox_pdfsigner_getsocketdnsservers(void* lpObj);
int secureblackbox_pdfsigner_setsocketdnsservers(void* lpObj, const char* lpszSocketDNSServers);

int secureblackbox_pdfsigner_getsocketdnstotaltimeout(void* lpObj);
int secureblackbox_pdfsigner_setsocketdnstotaltimeout(void* lpObj, int iSocketDNSTotalTimeout);

int secureblackbox_pdfsigner_getsocketincomingspeedlimit(void* lpObj);
int secureblackbox_pdfsigner_setsocketincomingspeedlimit(void* lpObj, int iSocketIncomingSpeedLimit);

char* secureblackbox_pdfsigner_getsocketlocaladdress(void* lpObj);
int secureblackbox_pdfsigner_setsocketlocaladdress(void* lpObj, const char* lpszSocketLocalAddress);

int secureblackbox_pdfsigner_getsocketlocalport(void* lpObj);
int secureblackbox_pdfsigner_setsocketlocalport(void* lpObj, int iSocketLocalPort);

int secureblackbox_pdfsigner_getsocketoutgoingspeedlimit(void* lpObj);
int secureblackbox_pdfsigner_setsocketoutgoingspeedlimit(void* lpObj, int iSocketOutgoingSpeedLimit);

int secureblackbox_pdfsigner_getsockettimeout(void* lpObj);
int secureblackbox_pdfsigner_setsockettimeout(void* lpObj, int iSocketTimeout);

int secureblackbox_pdfsigner_getsocketuseipv6(void* lpObj);
int secureblackbox_pdfsigner_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_pdfsigner_gettimestampcount(void* lpObj);

int64 secureblackbox_pdfsigner_gettimestampaccuracy(void* lpObj, int timestampindex);

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

int secureblackbox_pdfsigner_gettimestampcertificateindex(void* lpObj, int timestampindex);

int secureblackbox_pdfsigner_gettimestampchainvalidationdetails(void* lpObj, int timestampindex);

int secureblackbox_pdfsigner_gettimestampchainvalidationresult(void* lpObj, int timestampindex);

int secureblackbox_pdfsigner_gettimestampcontainslongterminfo(void* lpObj, int timestampindex);

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

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

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

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

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

int secureblackbox_pdfsigner_gettimestamptimestamptype(void* lpObj, int timestampindex);

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

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

int secureblackbox_pdfsigner_gettimestampvalidationresult(void* lpObj, int timestampindex);

int GetTimestampCount();

qint64 GetTimestampAccuracy(int iTimestampIndex);

QByteArray GetTimestampBytes(int iTimestampIndex);

int GetTimestampCertificateIndex(int iTimestampIndex);

int GetTimestampChainValidationDetails(int iTimestampIndex);

int GetTimestampChainValidationResult(int iTimestampIndex);

bool GetTimestampContainsLongTermInfo(int iTimestampIndex);

QString GetTimestampEntityLabel(int iTimestampIndex);

QString GetTimestampHashAlgorithm(int iTimestampIndex);

QString GetTimestampParentEntity(int iTimestampIndex);

QByteArray GetTimestampSerialNumber(int iTimestampIndex);

QString GetTimestampTime(int iTimestampIndex);

int GetTimestampTimestampType(int iTimestampIndex);

QString GetTimestampTSAName(int iTimestampIndex);

QString GetTimestampValidationLog(int iTimestampIndex);

int GetTimestampValidationResult(int iTimestampIndex);

char* secureblackbox_pdfsigner_gettimestampserver(void* lpObj);
int secureblackbox_pdfsigner_settimestampserver(void* lpObj, const char* lpszTimestampServer);

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

int secureblackbox_pdfsigner_gettlsclientcertcount(void* lpObj);
int secureblackbox_pdfsigner_settlsclientcertcount(void* lpObj, int iTLSClientCertCount);

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

int64 secureblackbox_pdfsigner_gettlsclientcerthandle(void* lpObj, int tlsclientcertindex);
int secureblackbox_pdfsigner_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_pdfsigner_gettlsservercertcount(void* lpObj);

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

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

int64 secureblackbox_pdfsigner_gettlsservercerthandle(void* lpObj, int tlsservercertindex);

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

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

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

int secureblackbox_pdfsigner_gettlsservercertkeybits(void* lpObj, int tlsservercertindex);

int secureblackbox_pdfsigner_gettlsservercertkeyusage(void* lpObj, int tlsservercertindex);

int secureblackbox_pdfsigner_gettlsservercertselfsigned(void* lpObj, int tlsservercertindex);

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

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

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

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

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

char* secureblackbox_pdfsigner_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_pdfsigner_gettlsautovalidatecertificates(void* lpObj);
int secureblackbox_pdfsigner_settlsautovalidatecertificates(void* lpObj, int bTLSAutoValidateCertificates);

int secureblackbox_pdfsigner_gettlsbaseconfiguration(void* lpObj);
int secureblackbox_pdfsigner_settlsbaseconfiguration(void* lpObj, int iTLSBaseConfiguration);

char* secureblackbox_pdfsigner_gettlsciphersuites(void* lpObj);
int secureblackbox_pdfsigner_settlsciphersuites(void* lpObj, const char* lpszTLSCiphersuites);

int secureblackbox_pdfsigner_gettlsclientauth(void* lpObj);
int secureblackbox_pdfsigner_settlsclientauth(void* lpObj, int iTLSClientAuth);

char* secureblackbox_pdfsigner_gettlseccurves(void* lpObj);
int secureblackbox_pdfsigner_settlseccurves(void* lpObj, const char* lpszTLSECCurves);

char* secureblackbox_pdfsigner_gettlsextensions(void* lpObj);
int secureblackbox_pdfsigner_settlsextensions(void* lpObj, const char* lpszTLSExtensions);

int secureblackbox_pdfsigner_gettlsforceresumeifdestinationchanges(void* lpObj);
int secureblackbox_pdfsigner_settlsforceresumeifdestinationchanges(void* lpObj, int bTLSForceResumeIfDestinationChanges);

char* secureblackbox_pdfsigner_gettlspresharedidentity(void* lpObj);
int secureblackbox_pdfsigner_settlspresharedidentity(void* lpObj, const char* lpszTLSPreSharedIdentity);

char* secureblackbox_pdfsigner_gettlspresharedkey(void* lpObj);
int secureblackbox_pdfsigner_settlspresharedkey(void* lpObj, const char* lpszTLSPreSharedKey);

char* secureblackbox_pdfsigner_gettlspresharedkeyciphersuite(void* lpObj);
int secureblackbox_pdfsigner_settlspresharedkeyciphersuite(void* lpObj, const char* lpszTLSPreSharedKeyCiphersuite);

int secureblackbox_pdfsigner_gettlsrenegotiationattackpreventionmode(void* lpObj);
int secureblackbox_pdfsigner_settlsrenegotiationattackpreventionmode(void* lpObj, int iTLSRenegotiationAttackPreventionMode);

int secureblackbox_pdfsigner_gettlsrevocationcheck(void* lpObj);
int secureblackbox_pdfsigner_settlsrevocationcheck(void* lpObj, int iTLSRevocationCheck);

int secureblackbox_pdfsigner_gettlsssloptions(void* lpObj);
int secureblackbox_pdfsigner_settlsssloptions(void* lpObj, int iTLSSSLOptions);

int secureblackbox_pdfsigner_gettlstlsmode(void* lpObj);
int secureblackbox_pdfsigner_settlstlsmode(void* lpObj, int iTLSTLSMode);

int secureblackbox_pdfsigner_gettlsuseextendedmastersecret(void* lpObj);
int secureblackbox_pdfsigner_settlsuseextendedmastersecret(void* lpObj, int bTLSUseExtendedMasterSecret);

int secureblackbox_pdfsigner_gettlsusesessionresumption(void* lpObj);
int secureblackbox_pdfsigner_settlsusesessionresumption(void* lpObj, int bTLSUseSessionResumption);

int secureblackbox_pdfsigner_gettlsversions(void* lpObj);
int secureblackbox_pdfsigner_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_pdfsigner_gettrustedcertcount(void* lpObj);
int secureblackbox_pdfsigner_settrustedcertcount(void* lpObj, int iTrustedCertCount);

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

int64 secureblackbox_pdfsigner_gettrustedcerthandle(void* lpObj, int trustedcertindex);
int secureblackbox_pdfsigner_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_pdfsigner_getvalidationmoment(void* lpObj);
int secureblackbox_pdfsigner_setvalidationmoment(void* lpObj, const char* lpszValidationMoment);

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

char* secureblackbox_pdfsigner_getwidgetalgorithmcaption(void* lpObj);
int secureblackbox_pdfsigner_setwidgetalgorithmcaption(void* lpObj, const char* lpszWidgetAlgorithmCaption);

char* secureblackbox_pdfsigner_getwidgetalgorithminfo(void* lpObj);
int secureblackbox_pdfsigner_setwidgetalgorithminfo(void* lpObj, const char* lpszWidgetAlgorithmInfo);

int secureblackbox_pdfsigner_getwidgetbackgrounddata(void* lpObj, char** lpWidgetBackgroundData, int* lenWidgetBackgroundData);
int secureblackbox_pdfsigner_setwidgetbackgrounddata(void* lpObj, const char* lpWidgetBackgroundData, int lenWidgetBackgroundData);

char* secureblackbox_pdfsigner_getwidgetbackgroundheight(void* lpObj);
int secureblackbox_pdfsigner_setwidgetbackgroundheight(void* lpObj, const char* lpszWidgetBackgroundHeight);

int secureblackbox_pdfsigner_getwidgetbackgroundimageheight(void* lpObj);
int secureblackbox_pdfsigner_setwidgetbackgroundimageheight(void* lpObj, int iWidgetBackgroundImageHeight);

int secureblackbox_pdfsigner_getwidgetbackgroundimagetype(void* lpObj);
int secureblackbox_pdfsigner_setwidgetbackgroundimagetype(void* lpObj, int iWidgetBackgroundImageType);

int secureblackbox_pdfsigner_getwidgetbackgroundimagewidth(void* lpObj);
int secureblackbox_pdfsigner_setwidgetbackgroundimagewidth(void* lpObj, int iWidgetBackgroundImageWidth);

int secureblackbox_pdfsigner_getwidgetbackgroundmask(void* lpObj, char** lpWidgetBackgroundMask, int* lenWidgetBackgroundMask);
int secureblackbox_pdfsigner_setwidgetbackgroundmask(void* lpObj, const char* lpWidgetBackgroundMask, int lenWidgetBackgroundMask);

char* secureblackbox_pdfsigner_getwidgetbackgroundposition(void* lpObj);
int secureblackbox_pdfsigner_setwidgetbackgroundposition(void* lpObj, const char* lpszWidgetBackgroundPosition);

int secureblackbox_pdfsigner_getwidgetbackgroundstyle(void* lpObj);
int secureblackbox_pdfsigner_setwidgetbackgroundstyle(void* lpObj, int iWidgetBackgroundStyle);

char* secureblackbox_pdfsigner_getwidgetbackgroundwidth(void* lpObj);
int secureblackbox_pdfsigner_setwidgetbackgroundwidth(void* lpObj, const char* lpszWidgetBackgroundWidth);

int secureblackbox_pdfsigner_getwidgetcompresswidgetdata(void* lpObj);
int secureblackbox_pdfsigner_setwidgetcompresswidgetdata(void* lpObj, int bWidgetCompressWidgetData);

int secureblackbox_pdfsigner_getwidgetcustomappearance(void* lpObj, char** lpWidgetCustomAppearance, int* lenWidgetCustomAppearance);
int secureblackbox_pdfsigner_setwidgetcustomappearance(void* lpObj, const char* lpWidgetCustomAppearance, int lenWidgetCustomAppearance);

char* secureblackbox_pdfsigner_getwidgetcustombackgroundcontentstream(void* lpObj);
int secureblackbox_pdfsigner_setwidgetcustombackgroundcontentstream(void* lpObj, const char* lpszWidgetCustomBackgroundContentStream);

char* secureblackbox_pdfsigner_getwidgetcustomvisualstatusmatrix(void* lpObj);
int secureblackbox_pdfsigner_setwidgetcustomvisualstatusmatrix(void* lpObj, const char* lpszWidgetCustomVisualStatusMatrix);

char* secureblackbox_pdfsigner_getwidgetdateformat(void* lpObj);
int secureblackbox_pdfsigner_setwidgetdateformat(void* lpObj, const char* lpszWidgetDateFormat);

char* secureblackbox_pdfsigner_getwidgetfontname(void* lpObj);
int secureblackbox_pdfsigner_setwidgetfontname(void* lpObj, const char* lpszWidgetFontName);

int64 secureblackbox_pdfsigner_getwidgethandle(void* lpObj);
int secureblackbox_pdfsigner_setwidgethandle(void* lpObj, int64 lWidgetHandle);

char* secureblackbox_pdfsigner_getwidgetheader(void* lpObj);
int secureblackbox_pdfsigner_setwidgetheader(void* lpObj, const char* lpszWidgetHeader);

int secureblackbox_pdfsigner_getwidgethidedefaulttext(void* lpObj);
int secureblackbox_pdfsigner_setwidgethidedefaulttext(void* lpObj, int bWidgetHideDefaultText);

int secureblackbox_pdfsigner_getwidgetignoreexistingappearance(void* lpObj);
int secureblackbox_pdfsigner_setwidgetignoreexistingappearance(void* lpObj, int bWidgetIgnoreExistingAppearance);

int secureblackbox_pdfsigner_getwidgetinvertmask(void* lpObj);
int secureblackbox_pdfsigner_setwidgetinvertmask(void* lpObj, int bWidgetInvertMask);

int secureblackbox_pdfsigner_getwidgetinvisible(void* lpObj);
int secureblackbox_pdfsigner_setwidgetinvisible(void* lpObj, int bWidgetInvisible);

char* secureblackbox_pdfsigner_getwidgetpagestoplaceon(void* lpObj);
int secureblackbox_pdfsigner_setwidgetpagestoplaceon(void* lpObj, const char* lpszWidgetPagesToPlaceOn);

int secureblackbox_pdfsigner_getwidgetpositionanchor(void* lpObj);
int secureblackbox_pdfsigner_setwidgetpositionanchor(void* lpObj, int iWidgetPositionAnchor);

int secureblackbox_pdfsigner_getwidgetrenderoptions(void* lpObj);
int secureblackbox_pdfsigner_setwidgetrenderoptions(void* lpObj, int iWidgetRenderOptions);

int secureblackbox_pdfsigner_getwidgetrotate(void* lpObj);
int secureblackbox_pdfsigner_setwidgetrotate(void* lpObj, int iWidgetRotate);

int secureblackbox_pdfsigner_getwidgetshowdate(void* lpObj);
int secureblackbox_pdfsigner_setwidgetshowdate(void* lpObj, int bWidgetShowDate);

int secureblackbox_pdfsigner_getwidgetshowvisualstatus(void* lpObj);
int secureblackbox_pdfsigner_setwidgetshowvisualstatus(void* lpObj, int bWidgetShowVisualStatus);

char* secureblackbox_pdfsigner_getwidgetsignercaption(void* lpObj);
int secureblackbox_pdfsigner_setwidgetsignercaption(void* lpObj, const char* lpszWidgetSignerCaption);

char* secureblackbox_pdfsigner_getwidgetsignerinfo(void* lpObj);
int secureblackbox_pdfsigner_setwidgetsignerinfo(void* lpObj, const char* lpszWidgetSignerInfo);

QString GetWidgetAlgorithmCaption();
int SetWidgetAlgorithmCaption(QString qsWidgetAlgorithmCaption);

QString GetWidgetAlgorithmInfo();
int SetWidgetAlgorithmInfo(QString qsWidgetAlgorithmInfo);

QByteArray GetWidgetBackgroundData();
int SetWidgetBackgroundData(QByteArray qbaWidgetBackgroundData);

QString GetWidgetBackgroundHeight();
int SetWidgetBackgroundHeight(QString qsWidgetBackgroundHeight);

int GetWidgetBackgroundImageHeight();
int SetWidgetBackgroundImageHeight(int iWidgetBackgroundImageHeight);

int GetWidgetBackgroundImageType();
int SetWidgetBackgroundImageType(int iWidgetBackgroundImageType);

int GetWidgetBackgroundImageWidth();
int SetWidgetBackgroundImageWidth(int iWidgetBackgroundImageWidth);

QByteArray GetWidgetBackgroundMask();
int SetWidgetBackgroundMask(QByteArray qbaWidgetBackgroundMask);

QString GetWidgetBackgroundPosition();
int SetWidgetBackgroundPosition(QString qsWidgetBackgroundPosition);

int GetWidgetBackgroundStyle();
int SetWidgetBackgroundStyle(int iWidgetBackgroundStyle);

QString GetWidgetBackgroundWidth();
int SetWidgetBackgroundWidth(QString qsWidgetBackgroundWidth);

bool GetWidgetCompressWidgetData();
int SetWidgetCompressWidgetData(bool bWidgetCompressWidgetData);

QByteArray GetWidgetCustomAppearance();
int SetWidgetCustomAppearance(QByteArray qbaWidgetCustomAppearance);

QString GetWidgetCustomBackgroundContentStream();
int SetWidgetCustomBackgroundContentStream(QString qsWidgetCustomBackgroundContentStream);

QString GetWidgetCustomVisualStatusMatrix();
int SetWidgetCustomVisualStatusMatrix(QString qsWidgetCustomVisualStatusMatrix);

QString GetWidgetDateFormat();
int SetWidgetDateFormat(QString qsWidgetDateFormat);

QString GetWidgetFontName();
int SetWidgetFontName(QString qsWidgetFontName);

qint64 GetWidgetHandle();
int SetWidgetHandle(qint64 lWidgetHandle);

QString GetWidgetHeader();
int SetWidgetHeader(QString qsWidgetHeader);

bool GetWidgetHideDefaultText();
int SetWidgetHideDefaultText(bool bWidgetHideDefaultText);

bool GetWidgetIgnoreExistingAppearance();
int SetWidgetIgnoreExistingAppearance(bool bWidgetIgnoreExistingAppearance);

bool GetWidgetInvertMask();
int SetWidgetInvertMask(bool bWidgetInvertMask);

bool GetWidgetInvisible();
int SetWidgetInvisible(bool bWidgetInvisible);

QString GetWidgetPagesToPlaceOn();
int SetWidgetPagesToPlaceOn(QString qsWidgetPagesToPlaceOn);

int GetWidgetPositionAnchor();
int SetWidgetPositionAnchor(int iWidgetPositionAnchor);

int GetWidgetRenderOptions();
int SetWidgetRenderOptions(int iWidgetRenderOptions);

int GetWidgetRotate();
int SetWidgetRotate(int iWidgetRotate);

bool GetWidgetShowDate();
int SetWidgetShowDate(bool bWidgetShowDate);

bool GetWidgetShowVisualStatus();
int SetWidgetShowVisualStatus(bool bWidgetShowVisualStatus);

QString GetWidgetSignerCaption();
int SetWidgetSignerCaption(QString qsWidgetSignerCaption);

QString GetWidgetSignerInfo();
int SetWidgetSignerInfo(QString qsWidgetSignerInfo);

int secureblackbox_pdfsigner_addwidgetcustomdata(void* lpObj, const char* lpszCustomData);

int AddWidgetCustomData(const QString& qsCustomData);

int secureblackbox_pdfsigner_addwidgettext(void* lpObj, const char* lpszText, int iX, int iY, const char* lpszFontSize);

int AddWidgetText(const QString& qsText, int iX, int iY, const QString& qsFontSize);

int secureblackbox_pdfsigner_addwidgettextex(void* lpObj, const char* lpszText, const char* lpszSettings);

int AddWidgetTextEx(const QString& qsText, const QString& qsSettings);

int secureblackbox_pdfsigner_attachbytes(void* lpObj, const char* lpData, int lenData, const char* lpszObjName, const char* lpszFileName, const char* lpszDescription, const char* lpszSubType, const char* lpszCDate, const char* lpszMDate);

int AttachBytes(QByteArray qbaData, const QString& qsObjName, const QString& qsFileName, const QString& qsDescription, const QString& qsSubType, const QString& qsCDate, const QString& qsMDate);

int secureblackbox_pdfsigner_attachfile(void* lpObj, const char* lpszPath, const char* lpszObjName, const char* lpszFileName, const char* lpszDescription, const char* lpszSubType, const char* lpszCDate, const char* lpszMDate);

int AttachFile(const QString& qsPath, const QString& qsObjName, const QString& qsFileName, const QString& qsDescription, const QString& qsSubType, const QString& qsCDate, const QString& qsMDate);

int secureblackbox_pdfsigner_attachstream(void* lpObj, SecureBlackboxStream* sStream, const char* lpszObjName, const char* lpszFileName, const char* lpszDescription, const char* lpszSubType, const char* lpszCDate, const char* lpszMDate);

int AttachStream(SecureBlackboxStream* sStream, const QString& qsObjName, const QString& qsFileName, const QString& qsDescription, const QString& qsSubType, const QString& qsCDate, const QString& qsMDate);

int secureblackbox_pdfsigner_close(void* lpObj, int bSaveChanges);

int Close(bool bSaveChanges);

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

QString Config(const QString& qsConfigurationString);

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

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

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

QString ExtractAsyncData(const QString& qsAsyncReply);

char* secureblackbox_pdfsigner_getattachedbytes(void* lpObj, int iIndex, int *lpSize);

QByteArray GetAttachedBytes(int iIndex);

int secureblackbox_pdfsigner_getattachedfile(void* lpObj, int iIndex, const char* lpszPath);

int GetAttachedFile(int iIndex, const QString& qsPath);

int secureblackbox_pdfsigner_getattachedstream(void* lpObj, int iIndex, SecureBlackboxStream* sStream);

int GetAttachedStream(int iIndex, SecureBlackboxStream* sStream);

int secureblackbox_pdfsigner_open(void* lpObj);

int Open();

int secureblackbox_pdfsigner_reset(void* lpObj);

int Reset();

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

int Revalidate(const QString& qsSigLabel);

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

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

int secureblackbox_pdfsigner_sign(void* lpObj);

int Sign();

char* secureblackbox_pdfsigner_signasyncbegin(void* lpObj);

QString SignAsyncBegin();

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

int SignAsyncEnd(const QString& qsAsyncReply);

int secureblackbox_pdfsigner_signexternal(void* lpObj);

int SignExternal();

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

int Update(const QString& qsSigLabel);

#define EID_PDFSIGNER_CHAINELEMENTDOWNLOAD 1

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

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

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

#define EID_PDFSIGNER_CHAINELEMENTNEEDED 2

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

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

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

#define EID_PDFSIGNER_CHAINVALIDATED 3

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

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

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

#define EID_PDFSIGNER_CHAINVALIDATIONPROGRESS 4

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

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

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

#define EID_PDFSIGNER_DOCUMENTLOADED 5

virtual INT SECUREBLACKBOX_CALL FireDocumentLoaded(BOOL &bCancel);

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

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

#define EID_PDFSIGNER_ENCRYPTED 6

virtual INT SECUREBLACKBOX_CALL FireEncrypted(BOOL &bCertUsed, LPSTR &lpszIssuerRDN, LPSTR &lpSerialNumber, INT &lenSerialNumber, LPSTR &lpSubjectKeyID, INT &lenSubjectKeyID, BOOL &bNeedCredential, BOOL &bSkipThis);

class PDFSignerEncryptedEventParams {
public:
  bool CertUsed();

  const QString &IssuerRDN();

  const QByteArray &SerialNumber();

  const QByteArray &SubjectKeyID();

  bool NeedCredential();

  bool SkipThis();
  void SetSkipThis(bool bSkipThis);

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

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

// Or, subclass PDFSigner and override this emitter function.
virtual int FireEncrypted(PDFSignerEncryptedEventParams *e) {...}

#define EID_PDFSIGNER_ERROR 7

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

class PDFSignerErrorEventParams {
public:
  int ErrorCode();

  const QString &Description();

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

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

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