char* secureblackbox_dcauth_getclaimedsigningtime(void* lpObj);
int secureblackbox_dcauth_setclaimedsigningtime(void* lpObj, const char* lpszClaimedSigningTime);

QString GetClaimedSigningTime();
int SetClaimedSigningTime(QString qsClaimedSigningTime);

char* secureblackbox_dcauth_getexternalcryptoasyncdocumentid(void* lpObj);
int secureblackbox_dcauth_setexternalcryptoasyncdocumentid(void* lpObj, const char* lpszExternalCryptoAsyncDocumentID);

char* secureblackbox_dcauth_getexternalcryptocustomparams(void* lpObj);
int secureblackbox_dcauth_setexternalcryptocustomparams(void* lpObj, const char* lpszExternalCryptoCustomParams);

char* secureblackbox_dcauth_getexternalcryptodata(void* lpObj);
int secureblackbox_dcauth_setexternalcryptodata(void* lpObj, const char* lpszExternalCryptoData);

int secureblackbox_dcauth_getexternalcryptoexternalhashcalculation(void* lpObj);
int secureblackbox_dcauth_setexternalcryptoexternalhashcalculation(void* lpObj, int bExternalCryptoExternalHashCalculation);

char* secureblackbox_dcauth_getexternalcryptohashalgorithm(void* lpObj);
int secureblackbox_dcauth_setexternalcryptohashalgorithm(void* lpObj, const char* lpszExternalCryptoHashAlgorithm);

char* secureblackbox_dcauth_getexternalcryptokeyid(void* lpObj);
int secureblackbox_dcauth_setexternalcryptokeyid(void* lpObj, const char* lpszExternalCryptoKeyID);

char* secureblackbox_dcauth_getexternalcryptokeysecret(void* lpObj);
int secureblackbox_dcauth_setexternalcryptokeysecret(void* lpObj, const char* lpszExternalCryptoKeySecret);

int secureblackbox_dcauth_getexternalcryptomethod(void* lpObj);
int secureblackbox_dcauth_setexternalcryptomethod(void* lpObj, int iExternalCryptoMethod);

int secureblackbox_dcauth_getexternalcryptomode(void* lpObj);
int secureblackbox_dcauth_setexternalcryptomode(void* lpObj, int iExternalCryptoMode);

char* secureblackbox_dcauth_getexternalcryptopublickeyalgorithm(void* lpObj);
int secureblackbox_dcauth_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_dcauth_getfipsmode(void* lpObj);
int secureblackbox_dcauth_setfipsmode(void* lpObj, int bFIPSMode);

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

char* secureblackbox_dcauth_getinput(void* lpObj);
int secureblackbox_dcauth_setinput(void* lpObj, const char* lpszInput);

QString GetInput();
int SetInput(QString qsInput);

int secureblackbox_dcauth_getinputencoding(void* lpObj);
int secureblackbox_dcauth_setinputencoding(void* lpObj, int iInputEncoding);

int GetInputEncoding();
int SetInputEncoding(int iInputEncoding);

char* secureblackbox_dcauth_getkeyid(void* lpObj);
int secureblackbox_dcauth_setkeyid(void* lpObj, const char* lpszKeyId);

QString GetKeyId();
int SetKeyId(QString qsKeyId);

char* secureblackbox_dcauth_getkeysecret(void* lpObj);
int secureblackbox_dcauth_setkeysecret(void* lpObj, const char* lpszKeySecret);

QString GetKeySecret();
int SetKeySecret(QString qsKeySecret);

char* secureblackbox_dcauth_getoutput(void* lpObj);

QString GetOutput();

int secureblackbox_dcauth_getoutputencoding(void* lpObj);
int secureblackbox_dcauth_setoutputencoding(void* lpObj, int iOutputEncoding);

int GetOutputEncoding();
int SetOutputEncoding(int iOutputEncoding);

int secureblackbox_dcauth_getpolicies(void* lpObj);
int secureblackbox_dcauth_setpolicies(void* lpObj, int iPolicies);

int GetPolicies();
int SetPolicies(int iPolicies);

char* secureblackbox_dcauth_getprofile(void* lpObj);
int secureblackbox_dcauth_setprofile(void* lpObj, const char* lpszProfile);

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

char* secureblackbox_dcauth_getproxyaddress(void* lpObj);
int secureblackbox_dcauth_setproxyaddress(void* lpObj, const char* lpszProxyAddress);

int secureblackbox_dcauth_getproxyauthentication(void* lpObj);
int secureblackbox_dcauth_setproxyauthentication(void* lpObj, int iProxyAuthentication);

char* secureblackbox_dcauth_getproxypassword(void* lpObj);
int secureblackbox_dcauth_setproxypassword(void* lpObj, const char* lpszProxyPassword);

int secureblackbox_dcauth_getproxyport(void* lpObj);
int secureblackbox_dcauth_setproxyport(void* lpObj, int iProxyPort);

int secureblackbox_dcauth_getproxyproxytype(void* lpObj);
int secureblackbox_dcauth_setproxyproxytype(void* lpObj, int iProxyProxyType);

char* secureblackbox_dcauth_getproxyrequestheaders(void* lpObj);
int secureblackbox_dcauth_setproxyrequestheaders(void* lpObj, const char* lpszProxyRequestHeaders);

char* secureblackbox_dcauth_getproxyresponsebody(void* lpObj);
int secureblackbox_dcauth_setproxyresponsebody(void* lpObj, const char* lpszProxyResponseBody);

char* secureblackbox_dcauth_getproxyresponseheaders(void* lpObj);
int secureblackbox_dcauth_setproxyresponseheaders(void* lpObj, const char* lpszProxyResponseHeaders);

int secureblackbox_dcauth_getproxyuseipv6(void* lpObj);
int secureblackbox_dcauth_setproxyuseipv6(void* lpObj, int bProxyUseIPv6);

char* secureblackbox_dcauth_getproxyusername(void* lpObj);
int secureblackbox_dcauth_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_dcauth_getsigningcertbytes(void* lpObj, char** lpSigningCertBytes, int* lenSigningCertBytes);

int64 secureblackbox_dcauth_getsigningcerthandle(void* lpObj);
int secureblackbox_dcauth_setsigningcerthandle(void* lpObj, int64 lSigningCertHandle);

QByteArray GetSigningCertBytes();

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

int secureblackbox_dcauth_getsigningchaincount(void* lpObj);
int secureblackbox_dcauth_setsigningchaincount(void* lpObj, int iSigningChainCount);

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

int64 secureblackbox_dcauth_getsigningchainhandle(void* lpObj, int signingchainindex);
int secureblackbox_dcauth_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_dcauth_getsocketdnsmode(void* lpObj);
int secureblackbox_dcauth_setsocketdnsmode(void* lpObj, int iSocketDNSMode);

int secureblackbox_dcauth_getsocketdnsport(void* lpObj);
int secureblackbox_dcauth_setsocketdnsport(void* lpObj, int iSocketDNSPort);

int secureblackbox_dcauth_getsocketdnsquerytimeout(void* lpObj);
int secureblackbox_dcauth_setsocketdnsquerytimeout(void* lpObj, int iSocketDNSQueryTimeout);

char* secureblackbox_dcauth_getsocketdnsservers(void* lpObj);
int secureblackbox_dcauth_setsocketdnsservers(void* lpObj, const char* lpszSocketDNSServers);

int secureblackbox_dcauth_getsocketdnstotaltimeout(void* lpObj);
int secureblackbox_dcauth_setsocketdnstotaltimeout(void* lpObj, int iSocketDNSTotalTimeout);

int secureblackbox_dcauth_getsocketincomingspeedlimit(void* lpObj);
int secureblackbox_dcauth_setsocketincomingspeedlimit(void* lpObj, int iSocketIncomingSpeedLimit);

char* secureblackbox_dcauth_getsocketlocaladdress(void* lpObj);
int secureblackbox_dcauth_setsocketlocaladdress(void* lpObj, const char* lpszSocketLocalAddress);

int secureblackbox_dcauth_getsocketlocalport(void* lpObj);
int secureblackbox_dcauth_setsocketlocalport(void* lpObj, int iSocketLocalPort);

int secureblackbox_dcauth_getsocketoutgoingspeedlimit(void* lpObj);
int secureblackbox_dcauth_setsocketoutgoingspeedlimit(void* lpObj, int iSocketOutgoingSpeedLimit);

int secureblackbox_dcauth_getsockettimeout(void* lpObj);
int secureblackbox_dcauth_setsockettimeout(void* lpObj, int iSocketTimeout);

int secureblackbox_dcauth_getsocketuseipv6(void* lpObj);
int secureblackbox_dcauth_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);

char* secureblackbox_dcauth_getstorageid(void* lpObj);
int secureblackbox_dcauth_setstorageid(void* lpObj, const char* lpszStorageId);

QString GetStorageId();
int SetStorageId(QString qsStorageId);

char* secureblackbox_dcauth_gettimestampserver(void* lpObj);
int secureblackbox_dcauth_settimestampserver(void* lpObj, const char* lpszTimestampServer);

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

int secureblackbox_dcauth_gettlsclientcertcount(void* lpObj);
int secureblackbox_dcauth_settlsclientcertcount(void* lpObj, int iTLSClientCertCount);

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

int64 secureblackbox_dcauth_gettlsclientcerthandle(void* lpObj, int tlsclientcertindex);
int secureblackbox_dcauth_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_dcauth_gettlsservercertcount(void* lpObj);

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

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

int64 secureblackbox_dcauth_gettlsservercerthandle(void* lpObj, int tlsservercertindex);

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

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

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

int secureblackbox_dcauth_gettlsservercertkeybits(void* lpObj, int tlsservercertindex);

int secureblackbox_dcauth_gettlsservercertkeyusage(void* lpObj, int tlsservercertindex);

int secureblackbox_dcauth_gettlsservercertselfsigned(void* lpObj, int tlsservercertindex);

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

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

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

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

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

char* secureblackbox_dcauth_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_dcauth_gettlsautovalidatecertificates(void* lpObj);
int secureblackbox_dcauth_settlsautovalidatecertificates(void* lpObj, int bTLSAutoValidateCertificates);

int secureblackbox_dcauth_gettlsbaseconfiguration(void* lpObj);
int secureblackbox_dcauth_settlsbaseconfiguration(void* lpObj, int iTLSBaseConfiguration);

char* secureblackbox_dcauth_gettlsciphersuites(void* lpObj);
int secureblackbox_dcauth_settlsciphersuites(void* lpObj, const char* lpszTLSCiphersuites);

int secureblackbox_dcauth_gettlsclientauth(void* lpObj);
int secureblackbox_dcauth_settlsclientauth(void* lpObj, int iTLSClientAuth);

char* secureblackbox_dcauth_gettlseccurves(void* lpObj);
int secureblackbox_dcauth_settlseccurves(void* lpObj, const char* lpszTLSECCurves);

char* secureblackbox_dcauth_gettlsextensions(void* lpObj);
int secureblackbox_dcauth_settlsextensions(void* lpObj, const char* lpszTLSExtensions);

int secureblackbox_dcauth_gettlsforceresumeifdestinationchanges(void* lpObj);
int secureblackbox_dcauth_settlsforceresumeifdestinationchanges(void* lpObj, int bTLSForceResumeIfDestinationChanges);

char* secureblackbox_dcauth_gettlspresharedidentity(void* lpObj);
int secureblackbox_dcauth_settlspresharedidentity(void* lpObj, const char* lpszTLSPreSharedIdentity);

char* secureblackbox_dcauth_gettlspresharedkey(void* lpObj);
int secureblackbox_dcauth_settlspresharedkey(void* lpObj, const char* lpszTLSPreSharedKey);

char* secureblackbox_dcauth_gettlspresharedkeyciphersuite(void* lpObj);
int secureblackbox_dcauth_settlspresharedkeyciphersuite(void* lpObj, const char* lpszTLSPreSharedKeyCiphersuite);

int secureblackbox_dcauth_gettlsrenegotiationattackpreventionmode(void* lpObj);
int secureblackbox_dcauth_settlsrenegotiationattackpreventionmode(void* lpObj, int iTLSRenegotiationAttackPreventionMode);

int secureblackbox_dcauth_gettlsrevocationcheck(void* lpObj);
int secureblackbox_dcauth_settlsrevocationcheck(void* lpObj, int iTLSRevocationCheck);

int secureblackbox_dcauth_gettlsssloptions(void* lpObj);
int secureblackbox_dcauth_settlsssloptions(void* lpObj, int iTLSSSLOptions);

int secureblackbox_dcauth_gettlstlsmode(void* lpObj);
int secureblackbox_dcauth_settlstlsmode(void* lpObj, int iTLSTLSMode);

int secureblackbox_dcauth_gettlsuseextendedmastersecret(void* lpObj);
int secureblackbox_dcauth_settlsuseextendedmastersecret(void* lpObj, int bTLSUseExtendedMasterSecret);

int secureblackbox_dcauth_gettlsusesessionresumption(void* lpObj);
int secureblackbox_dcauth_settlsusesessionresumption(void* lpObj, int bTLSUseSessionResumption);

int secureblackbox_dcauth_gettlsversions(void* lpObj);
int secureblackbox_dcauth_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);

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

QString Config(const QString& qsConfigurationString);

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

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

int secureblackbox_dcauth_processrequest(void* lpObj);

int ProcessRequest();

int secureblackbox_dcauth_reset(void* lpObj);

int Reset();

#define EID_DCAUTH_CUSTOMPARAMETERSRECEIVED 1

virtual INT SECUREBLACKBOX_CALL FireCustomParametersReceived(LPSTR &lpszValue);

class DCAuthCustomParametersReceivedEventParams {
public:
  const QString &Value();

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

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

// Or, subclass DCAuth and override this emitter function.
virtual int FireCustomParametersReceived(DCAuthCustomParametersReceivedEventParams *e) {...}

#define EID_DCAUTH_ERROR 2

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

class DCAuthErrorEventParams {
public:
  int ErrorCode();

  const QString &Description();

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

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

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

#define EID_DCAUTH_EXTERNALSIGN 3

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

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

  const QString &HashAlgorithm();

  const QString &Pars();

  const QString &MethodPars();

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

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

#define EID_DCAUTH_KEYSECRETNEEDED 4

virtual INT SECUREBLACKBOX_CALL FireKeySecretNeeded(LPSTR &lpszKeyId, LPSTR &lpszKeySecret);

class DCAuthKeySecretNeededEventParams {
public:
  const QString &KeyId();

  const QString &KeySecret();
  void SetKeySecret(const QString &qsKeySecret);

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

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

// Or, subclass DCAuth and override this emitter function.
virtual int FireKeySecretNeeded(DCAuthKeySecretNeededEventParams *e) {...}

#define EID_DCAUTH_NOTIFICATION 5

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

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

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

#define EID_DCAUTH_PARAMETERRECEIVED 6

virtual INT SECUREBLACKBOX_CALL FireParameterReceived(LPSTR &lpszName, LPSTR &lpszValue);

class DCAuthParameterReceivedEventParams {
public:
  const QString &Name();

  const QString &Value();

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

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

// Or, subclass DCAuth and override this emitter function.
virtual int FireParameterReceived(DCAuthParameterReceivedEventParams *e) {...}

#define EID_DCAUTH_SIGNREQUEST 7

virtual INT SECUREBLACKBOX_CALL FireSignRequest(INT &iMethod, LPSTR &lpszHashAlgorithm, LPSTR &lpHash, INT &lenHash, LPSTR &lpszKeyID, LPSTR &lpszPars, LPSTR &lpszMethodPars, BOOL &bAllow);

class DCAuthSignRequestEventParams {
public:
  int Method();

  const QString &HashAlgorithm();

  const QByteArray &Hash();

  const QString &KeyID();

  const QString &Pars();

  const QString &MethodPars();

  bool Allow();
  void SetAllow(bool bAllow);

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

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

// Or, subclass DCAuth and override this emitter function.
virtual int FireSignRequest(DCAuthSignRequestEventParams *e) {...}

#define EID_DCAUTH_SIGNREQUESTCOMPLETED 8

virtual INT SECUREBLACKBOX_CALL FireSignRequestCompleted(INT &iMethod, LPSTR &lpszHashAlgorithm, LPSTR &lpHash, INT &lenHash, LPSTR &lpszKeyID, LPSTR &lpszPars, LPSTR &lpszMethodPars, LPSTR &lpSignature, INT &lenSignature);

class DCAuthSignRequestCompletedEventParams {
public:
  int Method();

  const QString &HashAlgorithm();

  const QByteArray &Hash();

  const QString &KeyID();

  const QString &Pars();

  const QString &MethodPars();

  const QByteArray &Signature();

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

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

// Or, subclass DCAuth and override this emitter function.
virtual int FireSignRequestCompleted(DCAuthSignRequestCompletedEventParams *e) {...}

#define EID_DCAUTH_TIMESTAMPREQUEST 9

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

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

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

#define EID_DCAUTH_TLSCERTNEEDED 10

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

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

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

#define EID_DCAUTH_TLSCERTVALIDATE 11

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

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

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

#define EID_DCAUTH_TLSESTABLISHED 12

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

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

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

#define EID_DCAUTH_TLSHANDSHAKE 13

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

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

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

#define EID_DCAUTH_TLSSHUTDOWN 14

virtual INT SECUREBLACKBOX_CALL FireTLSShutdown(LPSTR &lpszHost);

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

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

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

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