int secureblackbox_pgpreader_getarmored(void* lpObj);

bool GetArmored();

int secureblackbox_pgpreader_getcompressed(void* lpObj);

bool GetCompressed();

int secureblackbox_pgpreader_getdatabytes(void* lpObj, char** lpDataBytes, int* lenDataBytes);
int secureblackbox_pgpreader_setdatabytes(void* lpObj, const char* lpDataBytes, int lenDataBytes);

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

char* secureblackbox_pgpreader_getdatafile(void* lpObj);
int secureblackbox_pgpreader_setdatafile(void* lpObj, const char* lpszDataFile);

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

int secureblackbox_pgpreader_getdecryptingkeycount(void* lpObj);
int secureblackbox_pgpreader_setdecryptingkeycount(void* lpObj, int iDecryptingKeyCount);

int64 secureblackbox_pgpreader_getdecryptingkeyhandle(void* lpObj, int decryptingkeyindex);
int secureblackbox_pgpreader_setdecryptingkeyhandle(void* lpObj, int decryptingkeyindex, int64 lDecryptingKeyHandle);

char* secureblackbox_pgpreader_getdecryptingkeykeyfp(void* lpObj, int decryptingkeyindex);

char* secureblackbox_pgpreader_getdecryptingkeykeyid(void* lpObj, int decryptingkeyindex);

char* secureblackbox_pgpreader_getdecryptingkeypassphrase(void* lpObj, int decryptingkeyindex);
int secureblackbox_pgpreader_setdecryptingkeypassphrase(void* lpObj, int decryptingkeyindex, const char* lpszDecryptingKeyPassphrase);

int secureblackbox_pgpreader_getdecryptingkeypassphrasevalid(void* lpObj, int decryptingkeyindex);

char* secureblackbox_pgpreader_getdecryptingkeyusername(void* lpObj, int decryptingkeyindex);

int GetDecryptingKeyCount();
int SetDecryptingKeyCount(int iDecryptingKeyCount);

qint64 GetDecryptingKeyHandle(int iDecryptingKeyIndex);
int SetDecryptingKeyHandle(int iDecryptingKeyIndex, qint64 lDecryptingKeyHandle);

QString GetDecryptingKeyKeyFP(int iDecryptingKeyIndex);

QString GetDecryptingKeyKeyID(int iDecryptingKeyIndex);

QString GetDecryptingKeyPassphrase(int iDecryptingKeyIndex);
int SetDecryptingKeyPassphrase(int iDecryptingKeyIndex, QString qsDecryptingKeyPassphrase);

bool GetDecryptingKeyPassphraseValid(int iDecryptingKeyIndex);

QString GetDecryptingKeyUsername(int iDecryptingKeyIndex);

char* secureblackbox_pgpreader_getexternalcryptoasyncdocumentid(void* lpObj);
int secureblackbox_pgpreader_setexternalcryptoasyncdocumentid(void* lpObj, const char* lpszExternalCryptoAsyncDocumentID);

char* secureblackbox_pgpreader_getexternalcryptocustomparams(void* lpObj);
int secureblackbox_pgpreader_setexternalcryptocustomparams(void* lpObj, const char* lpszExternalCryptoCustomParams);

char* secureblackbox_pgpreader_getexternalcryptodata(void* lpObj);
int secureblackbox_pgpreader_setexternalcryptodata(void* lpObj, const char* lpszExternalCryptoData);

int secureblackbox_pgpreader_getexternalcryptoexternalhashcalculation(void* lpObj);
int secureblackbox_pgpreader_setexternalcryptoexternalhashcalculation(void* lpObj, int bExternalCryptoExternalHashCalculation);

char* secureblackbox_pgpreader_getexternalcryptohashalgorithm(void* lpObj);
int secureblackbox_pgpreader_setexternalcryptohashalgorithm(void* lpObj, const char* lpszExternalCryptoHashAlgorithm);

char* secureblackbox_pgpreader_getexternalcryptokeyid(void* lpObj);
int secureblackbox_pgpreader_setexternalcryptokeyid(void* lpObj, const char* lpszExternalCryptoKeyID);

char* secureblackbox_pgpreader_getexternalcryptokeysecret(void* lpObj);
int secureblackbox_pgpreader_setexternalcryptokeysecret(void* lpObj, const char* lpszExternalCryptoKeySecret);

int secureblackbox_pgpreader_getexternalcryptomethod(void* lpObj);
int secureblackbox_pgpreader_setexternalcryptomethod(void* lpObj, int iExternalCryptoMethod);

int secureblackbox_pgpreader_getexternalcryptomode(void* lpObj);
int secureblackbox_pgpreader_setexternalcryptomode(void* lpObj, int iExternalCryptoMode);

char* secureblackbox_pgpreader_getexternalcryptopublickeyalgorithm(void* lpObj);
int secureblackbox_pgpreader_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_pgpreader_getfipsmode(void* lpObj);
int secureblackbox_pgpreader_setfipsmode(void* lpObj, int bFIPSMode);

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

int secureblackbox_pgpreader_getinputbytes(void* lpObj, char** lpInputBytes, int* lenInputBytes);
int secureblackbox_pgpreader_setinputbytes(void* lpObj, const char* lpInputBytes, int lenInputBytes);

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

char* secureblackbox_pgpreader_getinputfile(void* lpObj);
int secureblackbox_pgpreader_setinputfile(void* lpObj, const char* lpszInputFile);

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

char* secureblackbox_pgpreader_getkeypassphrase(void* lpObj);
int secureblackbox_pgpreader_setkeypassphrase(void* lpObj, const char* lpszKeyPassphrase);

QString GetKeyPassphrase();
int SetKeyPassphrase(QString qsKeyPassphrase);

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

QByteArray GetOutputBytes();

char* secureblackbox_pgpreader_getoutputfile(void* lpObj);
int secureblackbox_pgpreader_setoutputfile(void* lpObj, const char* lpszOutputFile);

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

char* secureblackbox_pgpreader_getpassphrase(void* lpObj);
int secureblackbox_pgpreader_setpassphrase(void* lpObj, const char* lpszPassphrase);

QString GetPassphrase();
int SetPassphrase(QString qsPassphrase);

int64 secureblackbox_pgpreader_getprocessedlength(void* lpObj);

qint64 GetProcessedLength();

char* secureblackbox_pgpreader_getprofile(void* lpObj);
int secureblackbox_pgpreader_setprofile(void* lpObj, const char* lpszProfile);

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

int secureblackbox_pgpreader_getsignaturecount(void* lpObj);

int secureblackbox_pgpreader_getsignaturecertificationtype(void* lpObj, int signatureindex);

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

int secureblackbox_pgpreader_getsignatureexpirationtime(void* lpObj, int signatureindex);

int secureblackbox_pgpreader_getsignatureexportable(void* lpObj, int signatureindex);

int64 secureblackbox_pgpreader_getsignaturehandle(void* lpObj, int signatureindex);

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

int secureblackbox_pgpreader_getsignaturehashmark(void* lpObj, int signatureindex);

int secureblackbox_pgpreader_getsignaturekeyexpirationtime(void* lpObj, int signatureindex);

int secureblackbox_pgpreader_getsignaturekeyflags(void* lpObj, int signatureindex);

int secureblackbox_pgpreader_getsignaturelegacyformat(void* lpObj, int signatureindex);

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

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

int secureblackbox_pgpreader_getsignatureprimaryuserid(void* lpObj, int signatureindex);

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

int secureblackbox_pgpreader_getsignaturerevocable(void* lpObj, int signatureindex);

int secureblackbox_pgpreader_getsignaturerevocation(void* lpObj, int signatureindex);

int secureblackbox_pgpreader_getsignaturesignatureclass(void* lpObj, int signatureindex);

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

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

int secureblackbox_pgpreader_getsignaturestrictlyvalid(void* lpObj, int signatureindex);

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

int secureblackbox_pgpreader_getsignaturetextsignature(void* lpObj, int signatureindex);

int secureblackbox_pgpreader_getsignaturetrustamount(void* lpObj, int signatureindex);

int secureblackbox_pgpreader_getsignaturetrustlevel(void* lpObj, int signatureindex);

int secureblackbox_pgpreader_getsignaturevalidated(void* lpObj, int signatureindex);

int secureblackbox_pgpreader_getsignaturevalidity(void* lpObj, int signatureindex);

int secureblackbox_pgpreader_getsignatureversion(void* lpObj, int signatureindex);

int GetSignatureCount();

int GetSignatureCertificationType(int iSignatureIndex);

QString GetSignatureCreationTime(int iSignatureIndex);

int GetSignatureExpirationTime(int iSignatureIndex);

bool GetSignatureExportable(int iSignatureIndex);

qint64 GetSignatureHandle(int iSignatureIndex);

QString GetSignatureHashAlgorithm(int iSignatureIndex);

int GetSignatureHashMark(int iSignatureIndex);

int GetSignatureKeyExpirationTime(int iSignatureIndex);

int GetSignatureKeyFlags(int iSignatureIndex);

bool GetSignatureLegacyFormat(int iSignatureIndex);

QString GetSignaturePolicyURL(int iSignatureIndex);

QString GetSignaturePreferredAlgorithms(int iSignatureIndex);

bool GetSignaturePrimaryUserID(int iSignatureIndex);

QString GetSignatureReasonForRevocation(int iSignatureIndex);

bool GetSignatureRevocable(int iSignatureIndex);

bool GetSignatureRevocation(int iSignatureIndex);

int GetSignatureSignatureClass(int iSignatureIndex);

QString GetSignatureSignerKeyID(int iSignatureIndex);

QString GetSignatureSignerUserID(int iSignatureIndex);

bool GetSignatureStrictlyValid(int iSignatureIndex);

QString GetSignatureTarget(int iSignatureIndex);

bool GetSignatureTextSignature(int iSignatureIndex);

int GetSignatureTrustAmount(int iSignatureIndex);

int GetSignatureTrustLevel(int iSignatureIndex);

bool GetSignatureValidated(int iSignatureIndex);

int GetSignatureValidity(int iSignatureIndex);

int GetSignatureVersion(int iSignatureIndex);

int secureblackbox_pgpreader_getverifyingkeycount(void* lpObj);
int secureblackbox_pgpreader_setverifyingkeycount(void* lpObj, int iVerifyingKeyCount);

int64 secureblackbox_pgpreader_getverifyingkeyhandle(void* lpObj, int verifyingkeyindex);
int secureblackbox_pgpreader_setverifyingkeyhandle(void* lpObj, int verifyingkeyindex, int64 lVerifyingKeyHandle);

char* secureblackbox_pgpreader_getverifyingkeykeyfp(void* lpObj, int verifyingkeyindex);

char* secureblackbox_pgpreader_getverifyingkeykeyid(void* lpObj, int verifyingkeyindex);

char* secureblackbox_pgpreader_getverifyingkeyusername(void* lpObj, int verifyingkeyindex);

int GetVerifyingKeyCount();
int SetVerifyingKeyCount(int iVerifyingKeyCount);

qint64 GetVerifyingKeyHandle(int iVerifyingKeyIndex);
int SetVerifyingKeyHandle(int iVerifyingKeyIndex, qint64 lVerifyingKeyHandle);

QString GetVerifyingKeyKeyFP(int iVerifyingKeyIndex);

QString GetVerifyingKeyKeyID(int iVerifyingKeyIndex);

QString GetVerifyingKeyUsername(int iVerifyingKeyIndex);

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

QString Config(const QString& qsConfigurationString);

int secureblackbox_pgpreader_decryptandverify(void* lpObj);

int DecryptAndVerify();

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

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

int secureblackbox_pgpreader_reset(void* lpObj);

int Reset();

int secureblackbox_pgpreader_verifydetached(void* lpObj);

int VerifyDetached();

#define EID_PGPREADER_ENCRYPTIONINFO 1

virtual INT SECUREBLACKBOX_CALL FireEncryptionInfo(LPSTR &lpszKeyIDs, INT &iEncryptedProtection, BOOL &bPassphraseUsed);

class PGPReaderEncryptionInfoEventParams {
public:
  const QString &KeyIDs();

  int EncryptedProtection();

  bool PassphraseUsed();

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

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

// Or, subclass PGPReader and override this emitter function.
virtual int FireEncryptionInfo(PGPReaderEncryptionInfoEventParams *e) {...}

#define EID_PGPREADER_ERROR 2

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

class PGPReaderErrorEventParams {
public:
  int ErrorCode();

  const QString &Description();

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

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

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

#define EID_PGPREADER_EXTERNALDECRYPT 3

virtual INT SECUREBLACKBOX_CALL FireExternalDecrypt(LPSTR &lpszOperationId, LPSTR &lpszAlgorithm, LPSTR &lpszPars, LPSTR &lpszEncryptedData, LPSTR &lpszData);

class PGPReaderExternalDecryptEventParams {
public:
  const QString &OperationId();

  const QString &Algorithm();

  const QString &Pars();

  const QString &EncryptedData();

  const QString &Data();
  void SetData(const QString &qsData);

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

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

// Or, subclass PGPReader and override this emitter function.
virtual int FireExternalDecrypt(PGPReaderExternalDecryptEventParams *e) {...}

#define EID_PGPREADER_FILEEXTRACTIONFINISH 4

virtual INT SECUREBLACKBOX_CALL FireFileExtractionFinish(LPSTR &lpszFileName, LPSTR &lpszTimestamp);

class PGPReaderFileExtractionFinishEventParams {
public:
  const QString &FileName();

  const QString &Timestamp();

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

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

// Or, subclass PGPReader and override this emitter function.
virtual int FireFileExtractionFinish(PGPReaderFileExtractionFinishEventParams *e) {...}

#define EID_PGPREADER_FILEEXTRACTIONSTART 5

virtual INT SECUREBLACKBOX_CALL FireFileExtractionStart(LPSTR &lpszFileName, LPSTR &lpszTimestamp, BOOL &bSkip);

class PGPReaderFileExtractionStartEventParams {
public:
  const QString &FileName();

  const QString &Timestamp();

  bool Skip();
  void SetSkip(bool bSkip);

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

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

// Or, subclass PGPReader and override this emitter function.
virtual int FireFileExtractionStart(PGPReaderFileExtractionStartEventParams *e) {...}

#define EID_PGPREADER_KEYPASSPHRASENEEDED 6

virtual INT SECUREBLACKBOX_CALL FireKeyPassphraseNeeded(LPSTR &lpszKeyID, LPSTR &lpszUserID, BOOL &bMainKey, LPSTR &lpszPassphrase, BOOL &bSkip);

class PGPReaderKeyPassphraseNeededEventParams {
public:
  const QString &KeyID();

  const QString &UserID();

  bool MainKey();

  const QString &Passphrase();
  void SetPassphrase(const QString &qsPassphrase);

  bool Skip();
  void SetSkip(bool bSkip);

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

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

// Or, subclass PGPReader and override this emitter function.
virtual int FireKeyPassphraseNeeded(PGPReaderKeyPassphraseNeededEventParams *e) {...}

#define EID_PGPREADER_MULTIPLEFILESFOUND 7

virtual INT SECUREBLACKBOX_CALL FireMultipleFilesFound(LPSTR &lpszTarFileName, BOOL &bProceed);

class PGPReaderMultipleFilesFoundEventParams {
public:
  const QString &TarFileName();

  bool Proceed();
  void SetProceed(bool bProceed);

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

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

// Or, subclass PGPReader and override this emitter function.
virtual int FireMultipleFilesFound(PGPReaderMultipleFilesFoundEventParams *e) {...}

#define EID_PGPREADER_NOTIFICATION 8

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

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

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

#define EID_PGPREADER_PASSPHRASENEEDED 9

virtual INT SECUREBLACKBOX_CALL FirePassphraseNeeded(LPSTR &lpszPassphrase, BOOL &bSkip);

class PGPReaderPassphraseNeededEventParams {
public:
  const QString &Passphrase();
  void SetPassphrase(const QString &qsPassphrase);

  bool Skip();
  void SetSkip(bool bSkip);

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

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

// Or, subclass PGPReader and override this emitter function.
virtual int FirePassphraseNeeded(PGPReaderPassphraseNeededEventParams *e) {...}

#define EID_PGPREADER_PROGRESS 10

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

class PGPReaderProgressEventParams {
public:
  qint64 Current();

  qint64 Total();

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

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

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

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

#define EID_PGPREADER_SIGNED 11

virtual INT SECUREBLACKBOX_CALL FireSigned(LPSTR &lpszKeyIDs, INT &iSignatureType);

class PGPReaderSignedEventParams {
public:
  const QString &KeyIDs();

  int SignatureType();

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

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

// Or, subclass PGPReader and override this emitter function.
virtual int FireSigned(PGPReaderSignedEventParams *e) {...}