int secureblackbox_samlspserver_getactive(void* lpObj);

bool GetActive();

char* secureblackbox_samlspserver_getbasedir(void* lpObj);
int secureblackbox_samlspserver_setbasedir(void* lpObj, const char* lpszBaseDir);

QString GetBaseDir();
int SetBaseDir(QString qsBaseDir);

int64 secureblackbox_samlspserver_getbindingkeyhandle(void* lpObj);
int secureblackbox_samlspserver_setbindingkeyhandle(void* lpObj, int64 lBindingKeyHandle);

int secureblackbox_samlspserver_getbindingkeykey(void* lpObj, char** lpBindingKeyKey, int* lenBindingKeyKey);

qint64 GetBindingKeyHandle();
int SetBindingKeyHandle(qint64 lBindingKeyHandle);

QByteArray GetBindingKeyKey();

int secureblackbox_samlspserver_getdecryptioncertbytes(void* lpObj, char** lpDecryptionCertBytes, int* lenDecryptionCertBytes);

int64 secureblackbox_samlspserver_getdecryptioncerthandle(void* lpObj);
int secureblackbox_samlspserver_setdecryptioncerthandle(void* lpObj, int64 lDecryptionCertHandle);

QByteArray GetDecryptionCertBytes();

qint64 GetDecryptionCertHandle();
int SetDecryptionCertHandle(qint64 lDecryptionCertHandle);

char* secureblackbox_samlspserver_getexternalcryptoasyncdocumentid(void* lpObj);
int secureblackbox_samlspserver_setexternalcryptoasyncdocumentid(void* lpObj, const char* lpszExternalCryptoAsyncDocumentID);

char* secureblackbox_samlspserver_getexternalcryptocustomparams(void* lpObj);
int secureblackbox_samlspserver_setexternalcryptocustomparams(void* lpObj, const char* lpszExternalCryptoCustomParams);

char* secureblackbox_samlspserver_getexternalcryptodata(void* lpObj);
int secureblackbox_samlspserver_setexternalcryptodata(void* lpObj, const char* lpszExternalCryptoData);

int secureblackbox_samlspserver_getexternalcryptoexternalhashcalculation(void* lpObj);
int secureblackbox_samlspserver_setexternalcryptoexternalhashcalculation(void* lpObj, int bExternalCryptoExternalHashCalculation);

char* secureblackbox_samlspserver_getexternalcryptohashalgorithm(void* lpObj);
int secureblackbox_samlspserver_setexternalcryptohashalgorithm(void* lpObj, const char* lpszExternalCryptoHashAlgorithm);

char* secureblackbox_samlspserver_getexternalcryptokeyid(void* lpObj);
int secureblackbox_samlspserver_setexternalcryptokeyid(void* lpObj, const char* lpszExternalCryptoKeyID);

char* secureblackbox_samlspserver_getexternalcryptokeysecret(void* lpObj);
int secureblackbox_samlspserver_setexternalcryptokeysecret(void* lpObj, const char* lpszExternalCryptoKeySecret);

int secureblackbox_samlspserver_getexternalcryptomethod(void* lpObj);
int secureblackbox_samlspserver_setexternalcryptomethod(void* lpObj, int iExternalCryptoMethod);

int secureblackbox_samlspserver_getexternalcryptomode(void* lpObj);
int secureblackbox_samlspserver_setexternalcryptomode(void* lpObj, int iExternalCryptoMode);

char* secureblackbox_samlspserver_getexternalcryptopublickeyalgorithm(void* lpObj);
int secureblackbox_samlspserver_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_samlspserver_getfipsmode(void* lpObj);
int secureblackbox_samlspserver_setfipsmode(void* lpObj, int bFIPSMode);

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

int secureblackbox_samlspserver_gethandshaketimeout(void* lpObj);
int secureblackbox_samlspserver_sethandshaketimeout(void* lpObj, int iHandshakeTimeout);

int GetHandshakeTimeout();
int SetHandshakeTimeout(int iHandshakeTimeout);

char* secureblackbox_samlspserver_gethost(void* lpObj);
int secureblackbox_samlspserver_sethost(void* lpObj, const char* lpszHost);

QString GetHost();
int SetHost(QString qsHost);

int secureblackbox_samlspserver_getidpservicecount(void* lpObj);

int secureblackbox_samlspserver_getidpservicebindingtype(void* lpObj, int idpserviceindex);

char* secureblackbox_samlspserver_getidpserviceentityid(void* lpObj, int idpserviceindex);

char* secureblackbox_samlspserver_getidpservicelocation(void* lpObj, int idpserviceindex);

int secureblackbox_samlspserver_getidpservicepriority(void* lpObj, int idpserviceindex);

int secureblackbox_samlspserver_getidpserviceservice(void* lpObj, int idpserviceindex);

int secureblackbox_samlspserver_getidpserviceserviceindex(void* lpObj, int idpserviceindex);

int GetIdPServiceCount();

int GetIdPServiceBindingType(int iIdPServiceIndex);

QString GetIdPServiceEntityID(int iIdPServiceIndex);

QString GetIdPServiceLocation(int iIdPServiceIndex);

int GetIdPServicePriority(int iIdPServiceIndex);

int GetIdPServiceService(int iIdPServiceIndex);

int GetIdPServiceServiceIndex(int iIdPServiceIndex);

char* secureblackbox_samlspserver_getidpcontactperson(void* lpObj);
int secureblackbox_samlspserver_setidpcontactperson(void* lpObj, const char* lpszIdPContactPerson);

int secureblackbox_samlspserver_getidpencryptionkey(void* lpObj, char** lpIdPEncryptionKey, int* lenIdPEncryptionKey);
int secureblackbox_samlspserver_setidpencryptionkey(void* lpObj, const char* lpIdPEncryptionKey, int lenIdPEncryptionKey);

char* secureblackbox_samlspserver_getidpencryptionmethods(void* lpObj);
int secureblackbox_samlspserver_setidpencryptionmethods(void* lpObj, const char* lpszIdPEncryptionMethods);

char* secureblackbox_samlspserver_getidpentityid(void* lpObj);
int secureblackbox_samlspserver_setidpentityid(void* lpObj, const char* lpszIdPEntityID);

int secureblackbox_samlspserver_getidpflags(void* lpObj);
int secureblackbox_samlspserver_setidpflags(void* lpObj, int iIdPFlags);

char* secureblackbox_samlspserver_getidpnameidformats(void* lpObj);
int secureblackbox_samlspserver_setidpnameidformats(void* lpObj, const char* lpszIdPNameIDFormats);

char* secureblackbox_samlspserver_getidporganizationdisplayname(void* lpObj);
int secureblackbox_samlspserver_setidporganizationdisplayname(void* lpObj, const char* lpszIdPOrganizationDisplayName);

char* secureblackbox_samlspserver_getidporganizationlang(void* lpObj);
int secureblackbox_samlspserver_setidporganizationlang(void* lpObj, const char* lpszIdPOrganizationLang);

char* secureblackbox_samlspserver_getidporganizationname(void* lpObj);
int secureblackbox_samlspserver_setidporganizationname(void* lpObj, const char* lpszIdPOrganizationName);

char* secureblackbox_samlspserver_getidporganizationurl(void* lpObj);
int secureblackbox_samlspserver_setidporganizationurl(void* lpObj, const char* lpszIdPOrganizationURL);

int secureblackbox_samlspserver_getidpsignaturevalidationresult(void* lpObj);

int secureblackbox_samlspserver_getidpsigned(void* lpObj);

int secureblackbox_samlspserver_getidpsignedwith(void* lpObj, char** lpIdPSignedWith, int* lenIdPSignedWith);

int secureblackbox_samlspserver_getidpsigningkey(void* lpObj, char** lpIdPSigningKey, int* lenIdPSigningKey);
int secureblackbox_samlspserver_setidpsigningkey(void* lpObj, const char* lpIdPSigningKey, int lenIdPSigningKey);

char* secureblackbox_samlspserver_getidpvaliduntil(void* lpObj);
int secureblackbox_samlspserver_setidpvaliduntil(void* lpObj, const char* lpszIdPValidUntil);

QString GetIdPContactPerson();
int SetIdPContactPerson(QString qsIdPContactPerson);

QByteArray GetIdPEncryptionKey();
int SetIdPEncryptionKey(QByteArray qbaIdPEncryptionKey);

QString GetIdPEncryptionMethods();
int SetIdPEncryptionMethods(QString qsIdPEncryptionMethods);

QString GetIdPEntityID();
int SetIdPEntityID(QString qsIdPEntityID);

int GetIdPFlags();
int SetIdPFlags(int iIdPFlags);

QString GetIdPNameIDFormats();
int SetIdPNameIDFormats(QString qsIdPNameIDFormats);

QString GetIdPOrganizationDisplayName();
int SetIdPOrganizationDisplayName(QString qsIdPOrganizationDisplayName);

QString GetIdPOrganizationLang();
int SetIdPOrganizationLang(QString qsIdPOrganizationLang);

QString GetIdPOrganizationName();
int SetIdPOrganizationName(QString qsIdPOrganizationName);

QString GetIdPOrganizationURL();
int SetIdPOrganizationURL(QString qsIdPOrganizationURL);

int GetIdPSignatureValidationResult();

bool GetIdPSigned();

QByteArray GetIdPSignedWith();

QByteArray GetIdPSigningKey();
int SetIdPSigningKey(QByteArray qbaIdPSigningKey);

QString GetIdPValidUntil();
int SetIdPValidUntil(QString qsIdPValidUntil);

char* secureblackbox_samlspserver_getissuer(void* lpObj);
int secureblackbox_samlspserver_setissuer(void* lpObj, const char* lpszIssuer);

QString GetIssuer();
int SetIssuer(QString qsIssuer);

int secureblackbox_samlspserver_getknowncertcount(void* lpObj);
int secureblackbox_samlspserver_setknowncertcount(void* lpObj, int iKnownCertCount);

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

int64 secureblackbox_samlspserver_getknowncerthandle(void* lpObj, int knowncertindex);
int secureblackbox_samlspserver_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);

char* secureblackbox_samlspserver_getlogoutpage(void* lpObj);
int secureblackbox_samlspserver_setlogoutpage(void* lpObj, const char* lpszLogoutPage);

QString GetLogoutPage();
int SetLogoutPage(QString qsLogoutPage);

char* secureblackbox_samlspserver_getmetadataurl(void* lpObj);
int secureblackbox_samlspserver_setmetadataurl(void* lpObj, const char* lpszMetadataURL);

QString GetMetadataURL();
int SetMetadataURL(QString qsMetadataURL);

int secureblackbox_samlspserver_getmetasigningcertbytes(void* lpObj, char** lpMetaSigningCertBytes, int* lenMetaSigningCertBytes);

int64 secureblackbox_samlspserver_getmetasigningcerthandle(void* lpObj);
int secureblackbox_samlspserver_setmetasigningcerthandle(void* lpObj, int64 lMetaSigningCertHandle);

QByteArray GetMetaSigningCertBytes();

qint64 GetMetaSigningCertHandle();
int SetMetaSigningCertHandle(qint64 lMetaSigningCertHandle);

int secureblackbox_samlspserver_getofflinemode(void* lpObj);
int secureblackbox_samlspserver_setofflinemode(void* lpObj, int bOfflineMode);

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

int secureblackbox_samlspserver_getpinnedclientaeadcipher(void* lpObj);

int secureblackbox_samlspserver_getpinnedclientchainvalidationdetails(void* lpObj);

int secureblackbox_samlspserver_getpinnedclientchainvalidationresult(void* lpObj);

char* secureblackbox_samlspserver_getpinnedclientciphersuite(void* lpObj);

int secureblackbox_samlspserver_getpinnedclientclientauthenticated(void* lpObj);

int secureblackbox_samlspserver_getpinnedclientclientauthrequested(void* lpObj);

int secureblackbox_samlspserver_getpinnedclientconnectionestablished(void* lpObj);

int secureblackbox_samlspserver_getpinnedclientconnectionid(void* lpObj, char** lpPinnedClientConnectionID, int* lenPinnedClientConnectionID);

char* secureblackbox_samlspserver_getpinnedclientdigestalgorithm(void* lpObj);

char* secureblackbox_samlspserver_getpinnedclientencryptionalgorithm(void* lpObj);

int secureblackbox_samlspserver_getpinnedclientexportable(void* lpObj);

int64 secureblackbox_samlspserver_getpinnedclientid(void* lpObj);

char* secureblackbox_samlspserver_getpinnedclientkeyexchangealgorithm(void* lpObj);

int secureblackbox_samlspserver_getpinnedclientkeyexchangekeybits(void* lpObj);

char* secureblackbox_samlspserver_getpinnedclientnamedeccurve(void* lpObj);

int secureblackbox_samlspserver_getpinnedclientpfscipher(void* lpObj);

char* secureblackbox_samlspserver_getpinnedclientpresharedidentity(void* lpObj);

char* secureblackbox_samlspserver_getpinnedclientpresharedidentityhint(void* lpObj);

int secureblackbox_samlspserver_getpinnedclientpublickeybits(void* lpObj);

char* secureblackbox_samlspserver_getpinnedclientremoteaddress(void* lpObj);

int secureblackbox_samlspserver_getpinnedclientremoteport(void* lpObj);

int secureblackbox_samlspserver_getpinnedclientresumedsession(void* lpObj);

int secureblackbox_samlspserver_getpinnedclientsecureconnection(void* lpObj);

int secureblackbox_samlspserver_getpinnedclientserverauthenticated(void* lpObj);

char* secureblackbox_samlspserver_getpinnedclientsignaturealgorithm(void* lpObj);

int secureblackbox_samlspserver_getpinnedclientsymmetricblocksize(void* lpObj);

int secureblackbox_samlspserver_getpinnedclientsymmetrickeybits(void* lpObj);

int64 secureblackbox_samlspserver_getpinnedclienttotalbytesreceived(void* lpObj);

int64 secureblackbox_samlspserver_getpinnedclienttotalbytessent(void* lpObj);

char* secureblackbox_samlspserver_getpinnedclientvalidationlog(void* lpObj);

char* secureblackbox_samlspserver_getpinnedclientversion(void* lpObj);

bool GetPinnedClientAEADCipher();

int GetPinnedClientChainValidationDetails();

int GetPinnedClientChainValidationResult();

QString GetPinnedClientCiphersuite();

bool GetPinnedClientClientAuthenticated();

bool GetPinnedClientClientAuthRequested();

bool GetPinnedClientConnectionEstablished();

QByteArray GetPinnedClientConnectionID();

QString GetPinnedClientDigestAlgorithm();

QString GetPinnedClientEncryptionAlgorithm();

bool GetPinnedClientExportable();

qint64 GetPinnedClientID();

QString GetPinnedClientKeyExchangeAlgorithm();

int GetPinnedClientKeyExchangeKeyBits();

QString GetPinnedClientNamedECCurve();

bool GetPinnedClientPFSCipher();

QString GetPinnedClientPreSharedIdentity();

QString GetPinnedClientPreSharedIdentityHint();

int GetPinnedClientPublicKeyBits();

QString GetPinnedClientRemoteAddress();

int GetPinnedClientRemotePort();

bool GetPinnedClientResumedSession();

bool GetPinnedClientSecureConnection();

bool GetPinnedClientServerAuthenticated();

QString GetPinnedClientSignatureAlgorithm();

int GetPinnedClientSymmetricBlockSize();

int GetPinnedClientSymmetricKeyBits();

qint64 GetPinnedClientTotalBytesReceived();

qint64 GetPinnedClientTotalBytesSent();

QString GetPinnedClientValidationLog();

QString GetPinnedClientVersion();

int secureblackbox_samlspserver_getpinnedclientcertcount(void* lpObj);

int secureblackbox_samlspserver_getpinnedclientcertbytes(void* lpObj, int pinnedclientcertindex, char** lpPinnedClientCertBytes, int* lenPinnedClientCertBytes);

int secureblackbox_samlspserver_getpinnedclientcertcakeyid(void* lpObj, int pinnedclientcertindex, char** lpPinnedClientCertCAKeyID, int* lenPinnedClientCertCAKeyID);

int secureblackbox_samlspserver_getpinnedclientcertfingerprint(void* lpObj, int pinnedclientcertindex, char** lpPinnedClientCertFingerprint, int* lenPinnedClientCertFingerprint);

int64 secureblackbox_samlspserver_getpinnedclientcerthandle(void* lpObj, int pinnedclientcertindex);

char* secureblackbox_samlspserver_getpinnedclientcertissuer(void* lpObj, int pinnedclientcertindex);

char* secureblackbox_samlspserver_getpinnedclientcertissuerrdn(void* lpObj, int pinnedclientcertindex);

char* secureblackbox_samlspserver_getpinnedclientcertkeyalgorithm(void* lpObj, int pinnedclientcertindex);

int secureblackbox_samlspserver_getpinnedclientcertkeybits(void* lpObj, int pinnedclientcertindex);

int secureblackbox_samlspserver_getpinnedclientcertkeyfingerprint(void* lpObj, int pinnedclientcertindex, char** lpPinnedClientCertKeyFingerprint, int* lenPinnedClientCertKeyFingerprint);

int secureblackbox_samlspserver_getpinnedclientcertkeyusage(void* lpObj, int pinnedclientcertindex);

int secureblackbox_samlspserver_getpinnedclientcertpublickeybytes(void* lpObj, int pinnedclientcertindex, char** lpPinnedClientCertPublicKeyBytes, int* lenPinnedClientCertPublicKeyBytes);

int secureblackbox_samlspserver_getpinnedclientcertselfsigned(void* lpObj, int pinnedclientcertindex);

int secureblackbox_samlspserver_getpinnedclientcertserialnumber(void* lpObj, int pinnedclientcertindex, char** lpPinnedClientCertSerialNumber, int* lenPinnedClientCertSerialNumber);

char* secureblackbox_samlspserver_getpinnedclientcertsigalgorithm(void* lpObj, int pinnedclientcertindex);

char* secureblackbox_samlspserver_getpinnedclientcertsubject(void* lpObj, int pinnedclientcertindex);

int secureblackbox_samlspserver_getpinnedclientcertsubjectkeyid(void* lpObj, int pinnedclientcertindex, char** lpPinnedClientCertSubjectKeyID, int* lenPinnedClientCertSubjectKeyID);

char* secureblackbox_samlspserver_getpinnedclientcertsubjectrdn(void* lpObj, int pinnedclientcertindex);

char* secureblackbox_samlspserver_getpinnedclientcertvalidfrom(void* lpObj, int pinnedclientcertindex);

char* secureblackbox_samlspserver_getpinnedclientcertvalidto(void* lpObj, int pinnedclientcertindex);

int GetPinnedClientCertCount();

QByteArray GetPinnedClientCertBytes(int iPinnedClientCertIndex);

QByteArray GetPinnedClientCertCAKeyID(int iPinnedClientCertIndex);

QByteArray GetPinnedClientCertFingerprint(int iPinnedClientCertIndex);

qint64 GetPinnedClientCertHandle(int iPinnedClientCertIndex);

QString GetPinnedClientCertIssuer(int iPinnedClientCertIndex);

QString GetPinnedClientCertIssuerRDN(int iPinnedClientCertIndex);

QString GetPinnedClientCertKeyAlgorithm(int iPinnedClientCertIndex);

int GetPinnedClientCertKeyBits(int iPinnedClientCertIndex);

QByteArray GetPinnedClientCertKeyFingerprint(int iPinnedClientCertIndex);

int GetPinnedClientCertKeyUsage(int iPinnedClientCertIndex);

QByteArray GetPinnedClientCertPublicKeyBytes(int iPinnedClientCertIndex);

bool GetPinnedClientCertSelfSigned(int iPinnedClientCertIndex);

QByteArray GetPinnedClientCertSerialNumber(int iPinnedClientCertIndex);

QString GetPinnedClientCertSigAlgorithm(int iPinnedClientCertIndex);

QString GetPinnedClientCertSubject(int iPinnedClientCertIndex);

QByteArray GetPinnedClientCertSubjectKeyID(int iPinnedClientCertIndex);

QString GetPinnedClientCertSubjectRDN(int iPinnedClientCertIndex);

QString GetPinnedClientCertValidFrom(int iPinnedClientCertIndex);

QString GetPinnedClientCertValidTo(int iPinnedClientCertIndex);

int secureblackbox_samlspserver_getport(void* lpObj);
int secureblackbox_samlspserver_setport(void* lpObj, int iPort);

int GetPort();
int SetPort(int iPort);

char* secureblackbox_samlspserver_getprotectedresources(void* lpObj);
int secureblackbox_samlspserver_setprotectedresources(void* lpObj, const char* lpszProtectedResources);

QString GetProtectedResources();
int SetProtectedResources(QString qsProtectedResources);

char* secureblackbox_samlspserver_getredirectonlogoutpage(void* lpObj);
int secureblackbox_samlspserver_setredirectonlogoutpage(void* lpObj, const char* lpszRedirectOnLogoutPage);

QString GetRedirectOnLogoutPage();
int SetRedirectOnLogoutPage(QString qsRedirectOnLogoutPage);

char* secureblackbox_samlspserver_getsecuritycanonicalizationmethod(void* lpObj);
int secureblackbox_samlspserver_setsecuritycanonicalizationmethod(void* lpObj, const char* lpszSecurityCanonicalizationMethod);

char* secureblackbox_samlspserver_getsecuritydigestmethod(void* lpObj);
int secureblackbox_samlspserver_setsecuritydigestmethod(void* lpObj, const char* lpszSecurityDigestMethod);

char* secureblackbox_samlspserver_getsecurityencryptionmethod(void* lpObj);
int secureblackbox_samlspserver_setsecurityencryptionmethod(void* lpObj, const char* lpszSecurityEncryptionMethod);

int secureblackbox_samlspserver_getsecurityflags(void* lpObj);
int secureblackbox_samlspserver_setsecurityflags(void* lpObj, int iSecurityFlags);

char* secureblackbox_samlspserver_getsecuritysigmethod(void* lpObj);
int secureblackbox_samlspserver_setsecuritysigmethod(void* lpObj, const char* lpszSecuritySigMethod);

int secureblackbox_samlspserver_getsecuritysignaturepolicy(void* lpObj);
int secureblackbox_samlspserver_setsecuritysignaturepolicy(void* lpObj, int iSecuritySignaturePolicy);

QString GetSecurityCanonicalizationMethod();
int SetSecurityCanonicalizationMethod(QString qsSecurityCanonicalizationMethod);

QString GetSecurityDigestMethod();
int SetSecurityDigestMethod(QString qsSecurityDigestMethod);

QString GetSecurityEncryptionMethod();
int SetSecurityEncryptionMethod(QString qsSecurityEncryptionMethod);

int GetSecurityFlags();
int SetSecurityFlags(int iSecurityFlags);

QString GetSecuritySigMethod();
int SetSecuritySigMethod(QString qsSecuritySigMethod);

int GetSecuritySignaturePolicy();
int SetSecuritySignaturePolicy(int iSecuritySignaturePolicy);

int secureblackbox_samlspserver_getsendercertcount(void* lpObj);

int secureblackbox_samlspserver_getsenderchainbytes(void* lpObj, int sendercertindex, char** lpSenderChainBytes, int* lenSenderChainBytes);

int64 secureblackbox_samlspserver_getsenderchainhandle(void* lpObj, int sendercertindex);

int GetSenderCertCount();

QByteArray GetSenderChainBytes(int iSenderCertIndex);

qint64 GetSenderChainHandle(int iSenderCertIndex);

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

int64 secureblackbox_samlspserver_getsigningcerthandle(void* lpObj);
int secureblackbox_samlspserver_setsigningcerthandle(void* lpObj, int64 lSigningCertHandle);

QByteArray GetSigningCertBytes();

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

int secureblackbox_samlspserver_getsigningchaincount(void* lpObj);
int secureblackbox_samlspserver_setsigningchaincount(void* lpObj, int iSigningChainCount);

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

int64 secureblackbox_samlspserver_getsigningchainhandle(void* lpObj, int signingchainindex);
int secureblackbox_samlspserver_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_samlspserver_getsocketincomingspeedlimit(void* lpObj);
int secureblackbox_samlspserver_setsocketincomingspeedlimit(void* lpObj, int iSocketIncomingSpeedLimit);

char* secureblackbox_samlspserver_getsocketlocaladdress(void* lpObj);
int secureblackbox_samlspserver_setsocketlocaladdress(void* lpObj, const char* lpszSocketLocalAddress);

int secureblackbox_samlspserver_getsocketlocalport(void* lpObj);
int secureblackbox_samlspserver_setsocketlocalport(void* lpObj, int iSocketLocalPort);

int secureblackbox_samlspserver_getsocketoutgoingspeedlimit(void* lpObj);
int secureblackbox_samlspserver_setsocketoutgoingspeedlimit(void* lpObj, int iSocketOutgoingSpeedLimit);

int secureblackbox_samlspserver_getsockettimeout(void* lpObj);
int secureblackbox_samlspserver_setsockettimeout(void* lpObj, int iSocketTimeout);

int secureblackbox_samlspserver_getsocketuseipv6(void* lpObj);
int secureblackbox_samlspserver_setsocketuseipv6(void* lpObj, int bSocketUseIPv6);

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_samlspserver_getspservicecount(void* lpObj);

int secureblackbox_samlspserver_getspservicebindingtype(void* lpObj, int spserviceindex);

char* secureblackbox_samlspserver_getspserviceentityid(void* lpObj, int spserviceindex);

char* secureblackbox_samlspserver_getspservicelocation(void* lpObj, int spserviceindex);

int secureblackbox_samlspserver_getspservicepriority(void* lpObj, int spserviceindex);

int secureblackbox_samlspserver_getspserviceservice(void* lpObj, int spserviceindex);

int secureblackbox_samlspserver_getspserviceserviceindex(void* lpObj, int spserviceindex);

int GetSPServiceCount();

int GetSPServiceBindingType(int iSPServiceIndex);

QString GetSPServiceEntityID(int iSPServiceIndex);

QString GetSPServiceLocation(int iSPServiceIndex);

int GetSPServicePriority(int iSPServiceIndex);

int GetSPServiceService(int iSPServiceIndex);

int GetSPServiceServiceIndex(int iSPServiceIndex);

char* secureblackbox_samlspserver_getspcontactperson(void* lpObj);
int secureblackbox_samlspserver_setspcontactperson(void* lpObj, const char* lpszSPContactPerson);

int secureblackbox_samlspserver_getspencryptionkey(void* lpObj, char** lpSPEncryptionKey, int* lenSPEncryptionKey);
int secureblackbox_samlspserver_setspencryptionkey(void* lpObj, const char* lpSPEncryptionKey, int lenSPEncryptionKey);

char* secureblackbox_samlspserver_getspencryptionmethods(void* lpObj);
int secureblackbox_samlspserver_setspencryptionmethods(void* lpObj, const char* lpszSPEncryptionMethods);

char* secureblackbox_samlspserver_getspentityid(void* lpObj);
int secureblackbox_samlspserver_setspentityid(void* lpObj, const char* lpszSPEntityID);

int secureblackbox_samlspserver_getspflags(void* lpObj);
int secureblackbox_samlspserver_setspflags(void* lpObj, int iSPFlags);

char* secureblackbox_samlspserver_getspnameidformats(void* lpObj);
int secureblackbox_samlspserver_setspnameidformats(void* lpObj, const char* lpszSPNameIDFormats);

char* secureblackbox_samlspserver_getsporganizationdisplayname(void* lpObj);
int secureblackbox_samlspserver_setsporganizationdisplayname(void* lpObj, const char* lpszSPOrganizationDisplayName);

char* secureblackbox_samlspserver_getsporganizationlang(void* lpObj);
int secureblackbox_samlspserver_setsporganizationlang(void* lpObj, const char* lpszSPOrganizationLang);

char* secureblackbox_samlspserver_getsporganizationname(void* lpObj);
int secureblackbox_samlspserver_setsporganizationname(void* lpObj, const char* lpszSPOrganizationName);

char* secureblackbox_samlspserver_getsporganizationurl(void* lpObj);
int secureblackbox_samlspserver_setsporganizationurl(void* lpObj, const char* lpszSPOrganizationURL);

int secureblackbox_samlspserver_getspsignaturevalidationresult(void* lpObj);

int secureblackbox_samlspserver_getspsigned(void* lpObj);

int secureblackbox_samlspserver_getspsignedwith(void* lpObj, char** lpSPSignedWith, int* lenSPSignedWith);

int secureblackbox_samlspserver_getspsigningkey(void* lpObj, char** lpSPSigningKey, int* lenSPSigningKey);
int secureblackbox_samlspserver_setspsigningkey(void* lpObj, const char* lpSPSigningKey, int lenSPSigningKey);

char* secureblackbox_samlspserver_getspvaliduntil(void* lpObj);
int secureblackbox_samlspserver_setspvaliduntil(void* lpObj, const char* lpszSPValidUntil);

QString GetSPContactPerson();
int SetSPContactPerson(QString qsSPContactPerson);

QByteArray GetSPEncryptionKey();
int SetSPEncryptionKey(QByteArray qbaSPEncryptionKey);

QString GetSPEncryptionMethods();
int SetSPEncryptionMethods(QString qsSPEncryptionMethods);

QString GetSPEntityID();
int SetSPEntityID(QString qsSPEntityID);

int GetSPFlags();
int SetSPFlags(int iSPFlags);

QString GetSPNameIDFormats();
int SetSPNameIDFormats(QString qsSPNameIDFormats);

QString GetSPOrganizationDisplayName();
int SetSPOrganizationDisplayName(QString qsSPOrganizationDisplayName);

QString GetSPOrganizationLang();
int SetSPOrganizationLang(QString qsSPOrganizationLang);

QString GetSPOrganizationName();
int SetSPOrganizationName(QString qsSPOrganizationName);

QString GetSPOrganizationURL();
int SetSPOrganizationURL(QString qsSPOrganizationURL);

int GetSPSignatureValidationResult();

bool GetSPSigned();

QByteArray GetSPSignedWith();

QByteArray GetSPSigningKey();
int SetSPSigningKey(QByteArray qbaSPSigningKey);

QString GetSPValidUntil();
int SetSPValidUntil(QString qsSPValidUntil);

int secureblackbox_samlspserver_gettlsservercertcount(void* lpObj);
int secureblackbox_samlspserver_settlsservercertcount(void* lpObj, int iTLSServerCertCount);

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

int64 secureblackbox_samlspserver_gettlsservercerthandle(void* lpObj, int tlsservercertindex);
int secureblackbox_samlspserver_settlsservercerthandle(void* lpObj, int tlsservercertindex, int64 lTLSServerCertHandle);

int GetTLSServerCertCount();
int SetTLSServerCertCount(int iTLSServerCertCount);

QByteArray GetTLSServerCertBytes(int iTLSServerCertIndex);

qint64 GetTLSServerCertHandle(int iTLSServerCertIndex);
int SetTLSServerCertHandle(int iTLSServerCertIndex, qint64 lTLSServerCertHandle);

int secureblackbox_samlspserver_gettlsautovalidatecertificates(void* lpObj);
int secureblackbox_samlspserver_settlsautovalidatecertificates(void* lpObj, int bTLSAutoValidateCertificates);

int secureblackbox_samlspserver_gettlsbaseconfiguration(void* lpObj);
int secureblackbox_samlspserver_settlsbaseconfiguration(void* lpObj, int iTLSBaseConfiguration);

char* secureblackbox_samlspserver_gettlsciphersuites(void* lpObj);
int secureblackbox_samlspserver_settlsciphersuites(void* lpObj, const char* lpszTLSCiphersuites);

int secureblackbox_samlspserver_gettlsclientauth(void* lpObj);
int secureblackbox_samlspserver_settlsclientauth(void* lpObj, int iTLSClientAuth);

char* secureblackbox_samlspserver_gettlseccurves(void* lpObj);
int secureblackbox_samlspserver_settlseccurves(void* lpObj, const char* lpszTLSECCurves);

char* secureblackbox_samlspserver_gettlsextensions(void* lpObj);
int secureblackbox_samlspserver_settlsextensions(void* lpObj, const char* lpszTLSExtensions);

int secureblackbox_samlspserver_gettlsforceresumeifdestinationchanges(void* lpObj);
int secureblackbox_samlspserver_settlsforceresumeifdestinationchanges(void* lpObj, int bTLSForceResumeIfDestinationChanges);

char* secureblackbox_samlspserver_gettlspresharedidentity(void* lpObj);
int secureblackbox_samlspserver_settlspresharedidentity(void* lpObj, const char* lpszTLSPreSharedIdentity);

char* secureblackbox_samlspserver_gettlspresharedkey(void* lpObj);
int secureblackbox_samlspserver_settlspresharedkey(void* lpObj, const char* lpszTLSPreSharedKey);

char* secureblackbox_samlspserver_gettlspresharedkeyciphersuite(void* lpObj);
int secureblackbox_samlspserver_settlspresharedkeyciphersuite(void* lpObj, const char* lpszTLSPreSharedKeyCiphersuite);

int secureblackbox_samlspserver_gettlsrenegotiationattackpreventionmode(void* lpObj);
int secureblackbox_samlspserver_settlsrenegotiationattackpreventionmode(void* lpObj, int iTLSRenegotiationAttackPreventionMode);

int secureblackbox_samlspserver_gettlsrevocationcheck(void* lpObj);
int secureblackbox_samlspserver_settlsrevocationcheck(void* lpObj, int iTLSRevocationCheck);

int secureblackbox_samlspserver_gettlsssloptions(void* lpObj);
int secureblackbox_samlspserver_settlsssloptions(void* lpObj, int iTLSSSLOptions);

int secureblackbox_samlspserver_gettlstlsmode(void* lpObj);
int secureblackbox_samlspserver_settlstlsmode(void* lpObj, int iTLSTLSMode);

int secureblackbox_samlspserver_gettlsuseextendedmastersecret(void* lpObj);
int secureblackbox_samlspserver_settlsuseextendedmastersecret(void* lpObj, int bTLSUseExtendedMasterSecret);

int secureblackbox_samlspserver_gettlsusesessionresumption(void* lpObj);
int secureblackbox_samlspserver_settlsusesessionresumption(void* lpObj, int bTLSUseSessionResumption);

int secureblackbox_samlspserver_gettlsversions(void* lpObj);
int secureblackbox_samlspserver_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_samlspserver_geturl(void* lpObj);
int secureblackbox_samlspserver_seturl(void* lpObj, const char* lpszURL);

QString GetURL();
int SetURL(QString qsURL);

int secureblackbox_samlspserver_addidpservice(void* lpObj, int iService, int iBindingType, const char* lpszLocation, int iPriority, int iIndex);

int AddIdPService(int iService, int iBindingType, const QString& qsLocation, int iPriority, int iIndex);

int secureblackbox_samlspserver_addspservice(void* lpObj, int iService, int iBindingType, const char* lpszLocation, int iPriority, int iIndex);

int AddSPService(int iService, int iBindingType, const QString& qsLocation, int iPriority, int iIndex);

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

QString Config(const QString& qsConfigurationString);

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

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

int secureblackbox_samlspserver_dropclient(void* lpObj, int64 lConnectionId, int bForced);

int DropClient(qint64 lConnectionId, bool bForced);

char* secureblackbox_samlspserver_exportsettings(void* lpObj, int bSP);

QString ExportSettings(bool bSP);

char* secureblackbox_samlspserver_getclientbuffer(void* lpObj, int64 lConnectionID, int *lpSize);

QByteArray GetClientBuffer(qint64 lConnectionID);

char* secureblackbox_samlspserver_getproviderproperty(void* lpObj, const char* lpszName);

QString GetProviderProperty(const QString& qsName);

int secureblackbox_samlspserver_importsettings(void* lpObj, const char* lpszMetadata, int bSP);

int ImportSettings(const QString& qsMetadata, bool bSP);

int secureblackbox_samlspserver_initiateartifactresolve(void* lpObj, int64 lConnectionID, const char* lpszSessionID, int iIdPServiceIndex, const char* lpszArtifact);

int InitiateArtifactResolve(qint64 lConnectionID, const QString& qsSessionID, int iIdPServiceIndex, const QString& qsArtifact);

int secureblackbox_samlspserver_initiateattributequery(void* lpObj, int64 lConnectionID, const char* lpszSessionID, int iIdPServiceIndex, const char* lpszAttributes);

int InitiateAttributeQuery(qint64 lConnectionID, const QString& qsSessionID, int iIdPServiceIndex, const QString& qsAttributes);

int secureblackbox_samlspserver_initiateauth(void* lpObj, int64 lConnectionID, const char* lpszSessionID, int iIdPServiceIndex, const char* lpszRelayState);

int InitiateAuth(qint64 lConnectionID, const QString& qsSessionID, int iIdPServiceIndex, const QString& qsRelayState);

int secureblackbox_samlspserver_initiatelogout(void* lpObj, int64 lConnectionID, const char* lpszSessionID, int iIdPServiceIndex, const char* lpszRelayState);

int InitiateLogout(qint64 lConnectionID, const QString& qsSessionID, int iIdPServiceIndex, const QString& qsRelayState);

char* secureblackbox_samlspserver_listclients(void* lpObj);

QString ListClients();

int secureblackbox_samlspserver_pinclient(void* lpObj, int64 lConnectionId);

int PinClient(qint64 lConnectionId);

int secureblackbox_samlspserver_processartifactresolverequest(void* lpObj, int64 lConnectionID, const char* lpszSessionID, const char* lpszRequest);

int ProcessArtifactResolveRequest(qint64 lConnectionID, const QString& qsSessionID, const QString& qsRequest);

int secureblackbox_samlspserver_processassertion(void* lpObj, int64 lConnectionID, const char* lpszSessionID, const char* lpszRequest);

int ProcessAssertion(qint64 lConnectionID, const QString& qsSessionID, const QString& qsRequest);

int secureblackbox_samlspserver_processgenericrequest(void* lpObj, int64 lConnectionID, const char* lpszSessionID, const char* lpszURL, const char* lpszRequest);

int ProcessGenericRequest(qint64 lConnectionID, const QString& qsSessionID, const QString& qsURL, const QString& qsRequest);

int secureblackbox_samlspserver_processlogoutrequest(void* lpObj, int64 lConnectionID, const char* lpszSessionID, const char* lpszRequest);

int ProcessLogoutRequest(qint64 lConnectionID, const QString& qsSessionID, const QString& qsRequest);

int secureblackbox_samlspserver_reset(void* lpObj);

int Reset();

int secureblackbox_samlspserver_setclientbuffer(void* lpObj, int64 lConnectionID, const char* lpValue, int lenValue);

int SetClientBuffer(qint64 lConnectionID, QByteArray qbaValue);

int secureblackbox_samlspserver_setproviderproperty(void* lpObj, const char* lpszName, const char* lpszValue);

int SetProviderProperty(const QString& qsName, const QString& qsValue);

int secureblackbox_samlspserver_start(void* lpObj);

int Start();

int secureblackbox_samlspserver_stop(void* lpObj);

int Stop();

#define EID_SAMLSPSERVER_ACCEPT 1

virtual INT SECUREBLACKBOX_CALL FireAccept(LPSTR &lpszRemoteAddress, INT &iRemotePort, BOOL &bAccept);

class SAMLSPServerAcceptEventParams {
public:
  const QString &RemoteAddress();

  int RemotePort();

  bool Accept();
  void SetAccept(bool bAccept);

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

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

// Or, subclass SAMLSPServer and override this emitter function.
virtual int FireAccept(SAMLSPServerAcceptEventParams *e) {...}

#define EID_SAMLSPSERVER_ARTIFACTRESOLVEREQUESTPREPARED 2

virtual INT SECUREBLACKBOX_CALL FireArtifactResolveRequestPrepared(LONG64 &lConnectionID, LPSTR &lpszSessionID, LPSTR &lpszRequestID, LPSTR &lpszArtifact);

class SAMLSPServerArtifactResolveRequestPreparedEventParams {
public:
  qint64 ConnectionID();

  const QString &SessionID();

  const QString &RequestID();

  const QString &Artifact();

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

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

// Or, subclass SAMLSPServer and override this emitter function.
virtual int FireArtifactResolveRequestPrepared(SAMLSPServerArtifactResolveRequestPreparedEventParams *e) {...}

#define EID_SAMLSPSERVER_ARTIFACTRESOLVEREQUESTRECEIVED 3

virtual INT SECUREBLACKBOX_CALL FireArtifactResolveRequestReceived(LONG64 &lConnectionID, LPSTR &lpszSessionID, LPSTR &lpszRequestID, BOOL &bIsEncrypted, BOOL &bIsSigned, LPSTR &lpszArtifact, INT &iAction);

class SAMLSPServerArtifactResolveRequestReceivedEventParams {
public:
  qint64 ConnectionID();

  const QString &SessionID();

  const QString &RequestID();

  bool IsEncrypted();

  bool IsSigned();

  const QString &Artifact();

  int Action();
  void SetAction(int iAction);

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

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

// Or, subclass SAMLSPServer and override this emitter function.
virtual int FireArtifactResolveRequestReceived(SAMLSPServerArtifactResolveRequestReceivedEventParams *e) {...}

#define EID_SAMLSPSERVER_ASSERTIONRECEIVED 4

virtual INT SECUREBLACKBOX_CALL FireAssertionReceived(LONG64 &lConnectionID, LPSTR &lpszSessionID, LPSTR &lpszRequestID, BOOL &bIsEncrypted, BOOL &bIsSigned, LPSTR &lpszNameID, LPSTR &lpszSessionIndex, INT &iAction);

class SAMLSPServerAssertionReceivedEventParams {
public:
  qint64 ConnectionID();

  const QString &SessionID();

  const QString &RequestID();

  bool IsEncrypted();

  bool IsSigned();

  const QString &NameID();

  const QString &SessionIndex();

  int Action();
  void SetAction(int iAction);

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

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

// Or, subclass SAMLSPServer and override this emitter function.
virtual int FireAssertionReceived(SAMLSPServerAssertionReceivedEventParams *e) {...}

#define EID_SAMLSPSERVER_ATTRIBUTEQUERYPREPARED 5

virtual INT SECUREBLACKBOX_CALL FireAttributeQueryPrepared(LONG64 &lConnectionID, LPSTR &lpszSessionID, LPSTR &lpszRequestID, LPSTR &lpszAttributes);

class SAMLSPServerAttributeQueryPreparedEventParams {
public:
  qint64 ConnectionID();

  const QString &SessionID();

  const QString &RequestID();

  const QString &Attributes();

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

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

// Or, subclass SAMLSPServer and override this emitter function.
virtual int FireAttributeQueryPrepared(SAMLSPServerAttributeQueryPreparedEventParams *e) {...}

#define EID_SAMLSPSERVER_AUTHNREQUESTPREPARED 6

virtual INT SECUREBLACKBOX_CALL FireAuthnRequestPrepared(LONG64 &lConnectionID, LPSTR &lpszSessionID, LPSTR &lpszRequestID, BOOL &bForceAuthn, BOOL &bNonInteractive);

class SAMLSPServerAuthnRequestPreparedEventParams {
public:
  qint64 ConnectionID();

  const QString &SessionID();

  const QString &RequestID();

  bool ForceAuthn();

  bool NonInteractive();

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

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

// Or, subclass SAMLSPServer and override this emitter function.
virtual int FireAuthnRequestPrepared(SAMLSPServerAuthnRequestPreparedEventParams *e) {...}

#define EID_SAMLSPSERVER_CONNECT 7

virtual INT SECUREBLACKBOX_CALL FireConnect(LONG64 &lConnectionId, LPSTR &lpszRemoteAddress, INT &iRemotePort);

class SAMLSPServerConnectEventParams {
public:
  qint64 ConnectionId();

  const QString &RemoteAddress();

  int RemotePort();

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

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

// Or, subclass SAMLSPServer and override this emitter function.
virtual int FireConnect(SAMLSPServerConnectEventParams *e) {...}

#define EID_SAMLSPSERVER_DISCONNECT 8

virtual INT SECUREBLACKBOX_CALL FireDisconnect(LONG64 &lConnectionID);

class SAMLSPServerDisconnectEventParams {
public:
  qint64 ConnectionID();

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

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

// Or, subclass SAMLSPServer and override this emitter function.
virtual int FireDisconnect(SAMLSPServerDisconnectEventParams *e) {...}

#define EID_SAMLSPSERVER_ENCRYPTED 9

virtual INT SECUREBLACKBOX_CALL FireEncrypted(LONG64 &lConnectionID, LPSTR &lpszSessionID, LPSTR &lpszRequestID, LPSTR &lpszIssuerRDN, LPSTR &lpSerialNumber, INT &lenSerialNumber, LPSTR &lpSubjectKeyID, INT &lenSubjectKeyID, BOOL &bNeedCredential, BOOL &bSkipThis);

class SAMLSPServerEncryptedEventParams {
public:
  qint64 ConnectionID();

  const QString &SessionID();

  const QString &RequestID();

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

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

#define EID_SAMLSPSERVER_ERROR 10

virtual INT SECUREBLACKBOX_CALL FireError(LONG64 &lConnectionID, LPSTR &lpszSessionID, INT &iErrorCode, BOOL &bFatal, BOOL &bRemote, LPSTR &lpszDescription);

class SAMLSPServerErrorEventParams {
public:
  qint64 ConnectionID();

  const QString &SessionID();

  int ErrorCode();

  bool Fatal();

  bool Remote();

  const QString &Description();

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

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

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

#define EID_SAMLSPSERVER_EXTERNALSIGN 11

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

class SAMLSPServerExternalSignEventParams {
public:
  qint64 ConnectionID();

  const QString &OperationId();

  const QString &HashAlgorithm();

  const QString &Pars();

  const QString &Data();

  const QString &SignedData();
  void SetSignedData(const QString &qsSignedData);

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

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

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

#define EID_SAMLSPSERVER_LOGOUTREQUESTPREPARED 12

virtual INT SECUREBLACKBOX_CALL FireLogoutRequestPrepared(LONG64 &lConnectionID, LPSTR &lpszSessionID, LPSTR &lpszRequestID, LPSTR &lpszNameID);

class SAMLSPServerLogoutRequestPreparedEventParams {
public:
  qint64 ConnectionID();

  const QString &SessionID();

  const QString &RequestID();

  const QString &NameID();

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

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

// Or, subclass SAMLSPServer and override this emitter function.
virtual int FireLogoutRequestPrepared(SAMLSPServerLogoutRequestPreparedEventParams *e) {...}

#define EID_SAMLSPSERVER_LOGOUTREQUESTRECEIVED 13

virtual INT SECUREBLACKBOX_CALL FireLogoutRequestReceived(LONG64 &lConnectionID, LPSTR &lpszSessionID, LPSTR &lpszRequestID, BOOL &bIsEncrypted, BOOL &bIsSigned, LPSTR &lpszNameID, INT &iAction);

class SAMLSPServerLogoutRequestReceivedEventParams {
public:
  qint64 ConnectionID();

  const QString &SessionID();

  const QString &RequestID();

  bool IsEncrypted();

  bool IsSigned();

  const QString &NameID();

  int Action();
  void SetAction(int iAction);

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

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

// Or, subclass SAMLSPServer and override this emitter function.
virtual int FireLogoutRequestReceived(SAMLSPServerLogoutRequestReceivedEventParams *e) {...}

#define EID_SAMLSPSERVER_METADATAPREPARED 14

virtual INT SECUREBLACKBOX_CALL FireMetadataPrepared(LONG64 &lConnectionID, LPSTR &lpszMetadata);

class SAMLSPServerMetadataPreparedEventParams {
public:
  qint64 ConnectionID();

  const QString &Metadata();
  void SetMetadata(const QString &qsMetadata);

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

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

// Or, subclass SAMLSPServer and override this emitter function.
virtual int FireMetadataPrepared(SAMLSPServerMetadataPreparedEventParams *e) {...}

#define EID_SAMLSPSERVER_NOTIFICATION 15

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

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

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

#define EID_SAMLSPSERVER_PROCESSINGCOMPLETED 16

virtual INT SECUREBLACKBOX_CALL FireProcessingCompleted(LONG64 &lConnectionID, LPSTR &lpszSessionID, INT &iProcessingResult, LPSTR &lpszResponse, BOOL &bRedirect);

class SAMLSPServerProcessingCompletedEventParams {
public:
  qint64 ConnectionID();

  const QString &SessionID();

  int ProcessingResult();

  const QString &Response();

  bool Redirect();

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

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

// Or, subclass SAMLSPServer and override this emitter function.
virtual int FireProcessingCompleted(SAMLSPServerProcessingCompletedEventParams *e) {...}

#define EID_SAMLSPSERVER_RESOURCECLOSE 17

virtual INT SECUREBLACKBOX_CALL FireResourceClose(LONG64 &lConnectionID, LPSTR &lpszSessionID);

class SAMLSPServerResourceCloseEventParams {
public:
  qint64 ConnectionID();

  const QString &SessionID();

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

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

// Or, subclass SAMLSPServer and override this emitter function.
virtual int FireResourceClose(SAMLSPServerResourceCloseEventParams *e) {...}

#define EID_SAMLSPSERVER_RESOURCEOPEN 18

virtual INT SECUREBLACKBOX_CALL FireResourceOpen(LONG64 &lConnectionID, LPSTR &lpszSessionID, LPSTR &lpszURL, INT &iOperationStatus);

class SAMLSPServerResourceOpenEventParams {
public:
  qint64 ConnectionID();

  const QString &SessionID();

  const QString &URL();

  int OperationStatus();
  void SetOperationStatus(int iOperationStatus);

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

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

// Or, subclass SAMLSPServer and override this emitter function.
virtual int FireResourceOpen(SAMLSPServerResourceOpenEventParams *e) {...}

#define EID_SAMLSPSERVER_RESOURCEREAD 19

virtual INT SECUREBLACKBOX_CALL FireResourceRead(LONG64 &lConnectionID, LPSTR &lpszSessionID, INT &iSize, INT &iOperationStatus);

class SAMLSPServerResourceReadEventParams {
public:
  qint64 ConnectionID();

  const QString &SessionID();

  int Size();

  int OperationStatus();
  void SetOperationStatus(int iOperationStatus);

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

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

// Or, subclass SAMLSPServer and override this emitter function.
virtual int FireResourceRead(SAMLSPServerResourceReadEventParams *e) {...}

#define EID_SAMLSPSERVER_RESOURCEREQUEST 20

virtual INT SECUREBLACKBOX_CALL FireResourceRequest(LONG64 &lConnectionID, LPSTR &lpszSessionID, LPSTR &lpszURL, LPSTR &lpszHttpMethod, BOOL &bResProtected, BOOL &bResSpecial, INT &iAction);

class SAMLSPServerResourceRequestEventParams {
public:
  qint64 ConnectionID();

  const QString &SessionID();

  const QString &URL();

  const QString &HttpMethod();

  bool ResProtected();
  void SetResProtected(bool bResProtected);

  bool ResSpecial();
  void SetResSpecial(bool bResSpecial);

  int Action();
  void SetAction(int iAction);

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

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

// Or, subclass SAMLSPServer and override this emitter function.
virtual int FireResourceRequest(SAMLSPServerResourceRequestEventParams *e) {...}

#define EID_SAMLSPSERVER_SAMLMESSAGEPREPARED 21

virtual INT SECUREBLACKBOX_CALL FireSAMLMessagePrepared(LONG64 &lConnectionID, LPSTR &lpszSessionID, LPSTR &lpszInResponseTo, LPSTR &lpszRequestBody, LPSTR &lpszMessageType, LPSTR &lpszMessageBody, BOOL &bSuccess);

class SAMLSPServerSAMLMessagePreparedEventParams {
public:
  qint64 ConnectionID();

  const QString &SessionID();

  const QString &InResponseTo();

  const QString &RequestBody();

  const QString &MessageType();

  const QString &MessageBody();
  void SetMessageBody(const QString &qsMessageBody);

  bool Success();
  void SetSuccess(bool bSuccess);

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

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

// Or, subclass SAMLSPServer and override this emitter function.
virtual int FireSAMLMessagePrepared(SAMLSPServerSAMLMessagePreparedEventParams *e) {...}

#define EID_SAMLSPSERVER_SAMLMESSAGERECEIVED 22

virtual INT SECUREBLACKBOX_CALL FireSAMLMessageReceived(LONG64 &lConnectionID, LPSTR &lpszSessionID, LPSTR &lpszMessageType, LPSTR &lpszMessageID, LPSTR &lpszIssuer, LPSTR &lpszIssueInstant, LPSTR &lpszMessageBody, LPSTR &lpszRelayState, INT &iAction);

class SAMLSPServerSAMLMessageReceivedEventParams {
public:
  qint64 ConnectionID();

  const QString &SessionID();

  const QString &MessageType();

  const QString &MessageID();

  const QString &Issuer();

  const QString &IssueInstant();

  const QString &MessageBody();

  const QString &RelayState();

  int Action();
  void SetAction(int iAction);

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

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

// Or, subclass SAMLSPServer and override this emitter function.
virtual int FireSAMLMessageReceived(SAMLSPServerSAMLMessageReceivedEventParams *e) {...}

#define EID_SAMLSPSERVER_SESSIONCREATED 23

virtual INT SECUREBLACKBOX_CALL FireSessionCreated(LONG64 &lConnectionID, LPSTR &lpszSessionID);

class SAMLSPServerSessionCreatedEventParams {
public:
  qint64 ConnectionID();

  const QString &SessionID();

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

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

// Or, subclass SAMLSPServer and override this emitter function.
virtual int FireSessionCreated(SAMLSPServerSessionCreatedEventParams *e) {...}

#define EID_SAMLSPSERVER_SESSIONDESTROYED 24

virtual INT SECUREBLACKBOX_CALL FireSessionDestroyed(LONG64 &lConnectionID, LPSTR &lpszSessionID);

class SAMLSPServerSessionDestroyedEventParams {
public:
  qint64 ConnectionID();

  const QString &SessionID();

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

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

// Or, subclass SAMLSPServer and override this emitter function.
virtual int FireSessionDestroyed(SAMLSPServerSessionDestroyedEventParams *e) {...}

#define EID_SAMLSPSERVER_SESSIONEVENT 25

virtual INT SECUREBLACKBOX_CALL FireSessionEvent(LONG64 &lConnectionID, LPSTR &lpszSessionID, LPSTR &lpszEventText);

class SAMLSPServerSessionEventEventParams {
public:
  qint64 ConnectionID();

  const QString &SessionID();

  const QString &EventText();

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

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

// Or, subclass SAMLSPServer and override this emitter function.
virtual int FireSessionEvent(SAMLSPServerSessionEventEventParams *e) {...}

#define EID_SAMLSPSERVER_SESSIONINFONEEDED 26

virtual INT SECUREBLACKBOX_CALL FireSessionInfoNeeded(LONG64 &lConnectionID, LPSTR &lpszSessionID);

class SAMLSPServerSessionInfoNeededEventParams {
public:
  qint64 ConnectionID();

  const QString &SessionID();
  void SetSessionID(const QString &qsSessionID);

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

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

// Or, subclass SAMLSPServer and override this emitter function.
virtual int FireSessionInfoNeeded(SAMLSPServerSessionInfoNeededEventParams *e) {...}

#define EID_SAMLSPSERVER_SESSIONSTATERETRIEVE 27

virtual INT SECUREBLACKBOX_CALL FireSessionStateRetrieve(LONG64 &lConnectionID, LPSTR &lpszSessionID, LPSTR &lpszSessionState);

class SAMLSPServerSessionStateRetrieveEventParams {
public:
  qint64 ConnectionID();

  const QString &SessionID();

  const QString &SessionState();
  void SetSessionState(const QString &qsSessionState);

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

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

// Or, subclass SAMLSPServer and override this emitter function.
virtual int FireSessionStateRetrieve(SAMLSPServerSessionStateRetrieveEventParams *e) {...}

#define EID_SAMLSPSERVER_SESSIONSTATESAVE 28

virtual INT SECUREBLACKBOX_CALL FireSessionStateSave(LONG64 &lConnectionID, LPSTR &lpszSessionID, LPSTR &lpszSessionState);

class SAMLSPServerSessionStateSaveEventParams {
public:
  qint64 ConnectionID();

  const QString &SessionID();

  const QString &SessionState();

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

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

// Or, subclass SAMLSPServer and override this emitter function.
virtual int FireSessionStateSave(SAMLSPServerSessionStateSaveEventParams *e) {...}

#define EID_SAMLSPSERVER_SIGNATUREFOUND 29

virtual INT SECUREBLACKBOX_CALL FireSignatureFound(LONG64 &lConnectionID, LPSTR &lpszSessionID, LPSTR &lpszMessageType, LPSTR &lpszMessageID, INT &iScope, LPSTR &lpszIssuerRDN, LPSTR &lpSerialNumber, INT &lenSerialNumber, LPSTR &lpSubjectKeyID, INT &lenSubjectKeyID, LPSTR &lpszSigMethod, LPSTR &lpszDigestMethod, BOOL &bCertFound, BOOL &bValidate);

class SAMLSPServerSignatureFoundEventParams {
public:
  qint64 ConnectionID();

  const QString &SessionID();

  const QString &MessageType();

  const QString &MessageID();

  int Scope();

  const QString &IssuerRDN();

  const QByteArray &SerialNumber();

  const QByteArray &SubjectKeyID();

  const QString &SigMethod();

  const QString &DigestMethod();

  bool CertFound();

  bool Validate();
  void SetValidate(bool bValidate);

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

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

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

#define EID_SAMLSPSERVER_SIGNATUREVALIDATED 30

virtual INT SECUREBLACKBOX_CALL FireSignatureValidated(LONG64 &lConnectionID, LPSTR &lpszSessionID, LPSTR &lpszMessageType, LPSTR &lpszMessageID, INT &iScope, LPSTR &lpszIssuerRDN, LPSTR &lpSerialNumber, INT &lenSerialNumber, LPSTR &lpSubjectKeyID, INT &lenSubjectKeyID, LPSTR &lpszSigMethod, LPSTR &lpszDigestMethod, INT &iValidationResult);

class SAMLSPServerSignatureValidatedEventParams {
public:
  qint64 ConnectionID();

  const QString &SessionID();

  const QString &MessageType();

  const QString &MessageID();

  int Scope();

  const QString &IssuerRDN();

  const QByteArray &SerialNumber();

  const QByteArray &SubjectKeyID();

  const QString &SigMethod();

  const QString &DigestMethod();

  int ValidationResult();
  void SetValidationResult(int iValidationResult);

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

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

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

#define EID_SAMLSPSERVER_TLSCERTVALIDATE 31

virtual INT SECUREBLACKBOX_CALL FireTLSCertValidate(LONG64 &lConnectionID, BOOL &bAccept);

class SAMLSPServerTLSCertValidateEventParams {
public:
  qint64 ConnectionID();

  bool Accept();
  void SetAccept(bool bAccept);

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

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

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

#define EID_SAMLSPSERVER_TLSESTABLISHED 32

virtual INT SECUREBLACKBOX_CALL FireTLSEstablished(LONG64 &lConnectionID);

class SAMLSPServerTLSEstablishedEventParams {
public:
  qint64 ConnectionID();

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

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

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

#define EID_SAMLSPSERVER_TLSHANDSHAKE 33

virtual INT SECUREBLACKBOX_CALL FireTLSHandshake(LONG64 &lConnectionID, LPSTR &lpszServerName, BOOL &bAbort);

class SAMLSPServerTLSHandshakeEventParams {
public:
  qint64 ConnectionID();

  const QString &ServerName();

  bool Abort();
  void SetAbort(bool bAbort);

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

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

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

#define EID_SAMLSPSERVER_TLSPSK 34

virtual INT SECUREBLACKBOX_CALL FireTLSPSK(LONG64 &lConnectionID, LPSTR &lpszIdentity, LPSTR &lpszPSK, LPSTR &lpszCiphersuite);

class SAMLSPServerTLSPSKEventParams {
public:
  qint64 ConnectionID();

  const QString &Identity();

  const QString &PSK();
  void SetPSK(const QString &qsPSK);

  const QString &Ciphersuite();
  void SetCiphersuite(const QString &qsCiphersuite);

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

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

// Or, subclass SAMLSPServer and override this emitter function.
virtual int FireTLSPSK(SAMLSPServerTLSPSKEventParams *e) {...}

#define EID_SAMLSPSERVER_TLSSHUTDOWN 35

virtual INT SECUREBLACKBOX_CALL FireTLSShutdown(LONG64 &lConnectionID);

class SAMLSPServerTLSShutdownEventParams {
public:
  qint64 ConnectionID();

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

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

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