int secureblackbox_samlidpserver_getactive(void* lpObj);

bool GetActive();

int secureblackbox_samlidpserver_getallowidpsso(void* lpObj);
int secureblackbox_samlidpserver_setallowidpsso(void* lpObj, int bAllowIDPSSO);

bool GetAllowIDPSSO();
int SetAllowIDPSSO(bool bAllowIDPSSO);

char* secureblackbox_samlidpserver_getbasedir(void* lpObj);
int secureblackbox_samlidpserver_setbasedir(void* lpObj, const char* lpszBaseDir);

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

int64 secureblackbox_samlidpserver_getbindingkeyhandle(void* lpObj);
int secureblackbox_samlidpserver_setbindingkeyhandle(void* lpObj, int64 lBindingKeyHandle);

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

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

QByteArray GetBindingKeyKey();

int secureblackbox_samlidpserver_getencryptioncertbytes(void* lpObj, char** lpEncryptionCertBytes, int* lenEncryptionCertBytes);

int64 secureblackbox_samlidpserver_getencryptioncerthandle(void* lpObj);
int secureblackbox_samlidpserver_setencryptioncerthandle(void* lpObj, int64 lEncryptionCertHandle);

QByteArray GetEncryptionCertBytes();

qint64 GetEncryptionCertHandle();
int SetEncryptionCertHandle(qint64 lEncryptionCertHandle);

char* secureblackbox_samlidpserver_getexternalcryptoasyncdocumentid(void* lpObj);
int secureblackbox_samlidpserver_setexternalcryptoasyncdocumentid(void* lpObj, const char* lpszExternalCryptoAsyncDocumentID);

char* secureblackbox_samlidpserver_getexternalcryptocustomparams(void* lpObj);
int secureblackbox_samlidpserver_setexternalcryptocustomparams(void* lpObj, const char* lpszExternalCryptoCustomParams);

char* secureblackbox_samlidpserver_getexternalcryptodata(void* lpObj);
int secureblackbox_samlidpserver_setexternalcryptodata(void* lpObj, const char* lpszExternalCryptoData);

int secureblackbox_samlidpserver_getexternalcryptoexternalhashcalculation(void* lpObj);
int secureblackbox_samlidpserver_setexternalcryptoexternalhashcalculation(void* lpObj, int bExternalCryptoExternalHashCalculation);

char* secureblackbox_samlidpserver_getexternalcryptohashalgorithm(void* lpObj);
int secureblackbox_samlidpserver_setexternalcryptohashalgorithm(void* lpObj, const char* lpszExternalCryptoHashAlgorithm);

char* secureblackbox_samlidpserver_getexternalcryptokeyid(void* lpObj);
int secureblackbox_samlidpserver_setexternalcryptokeyid(void* lpObj, const char* lpszExternalCryptoKeyID);

char* secureblackbox_samlidpserver_getexternalcryptokeysecret(void* lpObj);
int secureblackbox_samlidpserver_setexternalcryptokeysecret(void* lpObj, const char* lpszExternalCryptoKeySecret);

int secureblackbox_samlidpserver_getexternalcryptomethod(void* lpObj);
int secureblackbox_samlidpserver_setexternalcryptomethod(void* lpObj, int iExternalCryptoMethod);

int secureblackbox_samlidpserver_getexternalcryptomode(void* lpObj);
int secureblackbox_samlidpserver_setexternalcryptomode(void* lpObj, int iExternalCryptoMode);

char* secureblackbox_samlidpserver_getexternalcryptopublickeyalgorithm(void* lpObj);
int secureblackbox_samlidpserver_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_samlidpserver_getfipsmode(void* lpObj);
int secureblackbox_samlidpserver_setfipsmode(void* lpObj, int bFIPSMode);

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

int secureblackbox_samlidpserver_gethandshaketimeout(void* lpObj);
int secureblackbox_samlidpserver_sethandshaketimeout(void* lpObj, int iHandshakeTimeout);

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

char* secureblackbox_samlidpserver_gethost(void* lpObj);
int secureblackbox_samlidpserver_sethost(void* lpObj, const char* lpszHost);

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

int secureblackbox_samlidpserver_getidpservicecount(void* lpObj);

int secureblackbox_samlidpserver_getidpservicebindingtype(void* lpObj, int idpserviceindex);

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

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

int secureblackbox_samlidpserver_getidpservicepriority(void* lpObj, int idpserviceindex);

int secureblackbox_samlidpserver_getidpserviceservice(void* lpObj, int idpserviceindex);

int secureblackbox_samlidpserver_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_samlidpserver_getidpcontactperson(void* lpObj);
int secureblackbox_samlidpserver_setidpcontactperson(void* lpObj, const char* lpszIdPContactPerson);

char* secureblackbox_samlidpserver_getidpencryptionkey(void* lpObj);
int secureblackbox_samlidpserver_setidpencryptionkey(void* lpObj, const char* lpszIdPEncryptionKey);

char* secureblackbox_samlidpserver_getidpencryptionmethods(void* lpObj);
int secureblackbox_samlidpserver_setidpencryptionmethods(void* lpObj, const char* lpszIdPEncryptionMethods);

char* secureblackbox_samlidpserver_getidpentityid(void* lpObj);
int secureblackbox_samlidpserver_setidpentityid(void* lpObj, const char* lpszIdPEntityID);

int secureblackbox_samlidpserver_getidpflags(void* lpObj);
int secureblackbox_samlidpserver_setidpflags(void* lpObj, int iIdPFlags);

char* secureblackbox_samlidpserver_getidpidpssolink(void* lpObj);
int secureblackbox_samlidpserver_setidpidpssolink(void* lpObj, const char* lpszIdPIdPSSOLink);

char* secureblackbox_samlidpserver_getidpnameidformats(void* lpObj);
int secureblackbox_samlidpserver_setidpnameidformats(void* lpObj, const char* lpszIdPNameIDFormats);

char* secureblackbox_samlidpserver_getidporganizationdisplayname(void* lpObj);
int secureblackbox_samlidpserver_setidporganizationdisplayname(void* lpObj, const char* lpszIdPOrganizationDisplayName);

char* secureblackbox_samlidpserver_getidporganizationlang(void* lpObj);
int secureblackbox_samlidpserver_setidporganizationlang(void* lpObj, const char* lpszIdPOrganizationLang);

char* secureblackbox_samlidpserver_getidporganizationname(void* lpObj);
int secureblackbox_samlidpserver_setidporganizationname(void* lpObj, const char* lpszIdPOrganizationName);

char* secureblackbox_samlidpserver_getidporganizationurl(void* lpObj);
int secureblackbox_samlidpserver_setidporganizationurl(void* lpObj, const char* lpszIdPOrganizationURL);

int secureblackbox_samlidpserver_getidpsignaturevalidationresult(void* lpObj);

int secureblackbox_samlidpserver_getidpsigned(void* lpObj);

char* secureblackbox_samlidpserver_getidpsignedwith(void* lpObj);

char* secureblackbox_samlidpserver_getidpsigningkey(void* lpObj);
int secureblackbox_samlidpserver_setidpsigningkey(void* lpObj, const char* lpszIdPSigningKey);

char* secureblackbox_samlidpserver_getidpvaliduntil(void* lpObj);
int secureblackbox_samlidpserver_setidpvaliduntil(void* lpObj, const char* lpszIdPValidUntil);

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

QString GetIdPEncryptionKey();
int SetIdPEncryptionKey(QString qsIdPEncryptionKey);

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

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

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

QString GetIdPIdPSSOLink();
int SetIdPIdPSSOLink(QString qsIdPIdPSSOLink);

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

QString GetIdPSignedWith();

QString GetIdPSigningKey();
int SetIdPSigningKey(QString qsIdPSigningKey);

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

char* secureblackbox_samlidpserver_getidpssopage(void* lpObj);
int secureblackbox_samlidpserver_setidpssopage(void* lpObj, const char* lpszIdPSSOPage);

QString GetIdPSSOPage();
int SetIdPSSOPage(QString qsIdPSSOPage);

char* secureblackbox_samlidpserver_getidpssopagetemplate(void* lpObj);
int secureblackbox_samlidpserver_setidpssopagetemplate(void* lpObj, const char* lpszIdPSSOPageTemplate);

QString GetIdPSSOPageTemplate();
int SetIdPSSOPageTemplate(QString qsIdPSSOPageTemplate);

int secureblackbox_samlidpserver_getknowncertcount(void* lpObj);
int secureblackbox_samlidpserver_setknowncertcount(void* lpObj, int iKnownCertCount);

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

int64 secureblackbox_samlidpserver_getknowncerthandle(void* lpObj, int knowncertindex);
int secureblackbox_samlidpserver_setknowncerthandle(void* lpObj, int knowncertindex, int64 lKnownCertHandle);

int GetKnownCertCount();
int SetKnownCertCount(int iKnownCertCount);

QByteArray GetKnownCertBytes(int iKnownCertIndex);

qint64 GetKnownCertHandle(int iKnownCertIndex);
int SetKnownCertHandle(int iKnownCertIndex, qint64 lKnownCertHandle);

int secureblackbox_samlidpserver_getknownkeycount(void* lpObj);
int secureblackbox_samlidpserver_setknownkeycount(void* lpObj, int iKnownKeyCount);

int64 secureblackbox_samlidpserver_getknownkeyhandle(void* lpObj, int knownkeyindex);
int secureblackbox_samlidpserver_setknownkeyhandle(void* lpObj, int knownkeyindex, int64 lKnownKeyHandle);

int GetKnownKeyCount();
int SetKnownKeyCount(int iKnownKeyCount);

qint64 GetKnownKeyHandle(int iKnownKeyIndex);
int SetKnownKeyHandle(int iKnownKeyIndex, qint64 lKnownKeyHandle);

int secureblackbox_samlidpserver_getloginattemptslimit(void* lpObj);
int secureblackbox_samlidpserver_setloginattemptslimit(void* lpObj, int iLoginAttemptsLimit);

int GetLoginAttemptsLimit();
int SetLoginAttemptsLimit(int iLoginAttemptsLimit);

char* secureblackbox_samlidpserver_getmetadataurl(void* lpObj);
int secureblackbox_samlidpserver_setmetadataurl(void* lpObj, const char* lpszMetadataURL);

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

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

int64 secureblackbox_samlidpserver_getmetasigningcerthandle(void* lpObj);
int secureblackbox_samlidpserver_setmetasigningcerthandle(void* lpObj, int64 lMetaSigningCertHandle);

QByteArray GetMetaSigningCertBytes();

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

int secureblackbox_samlidpserver_getofflinemode(void* lpObj);
int secureblackbox_samlidpserver_setofflinemode(void* lpObj, int bOfflineMode);

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

int secureblackbox_samlidpserver_getpinnedclientaeadcipher(void* lpObj);

int secureblackbox_samlidpserver_getpinnedclientchainvalidationdetails(void* lpObj);

int secureblackbox_samlidpserver_getpinnedclientchainvalidationresult(void* lpObj);

char* secureblackbox_samlidpserver_getpinnedclientciphersuite(void* lpObj);

int secureblackbox_samlidpserver_getpinnedclientclientauthenticated(void* lpObj);

int secureblackbox_samlidpserver_getpinnedclientclientauthrequested(void* lpObj);

int secureblackbox_samlidpserver_getpinnedclientconnectionestablished(void* lpObj);

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

char* secureblackbox_samlidpserver_getpinnedclientdigestalgorithm(void* lpObj);

char* secureblackbox_samlidpserver_getpinnedclientencryptionalgorithm(void* lpObj);

int secureblackbox_samlidpserver_getpinnedclientexportable(void* lpObj);

int64 secureblackbox_samlidpserver_getpinnedclientid(void* lpObj);

char* secureblackbox_samlidpserver_getpinnedclientkeyexchangealgorithm(void* lpObj);

int secureblackbox_samlidpserver_getpinnedclientkeyexchangekeybits(void* lpObj);

char* secureblackbox_samlidpserver_getpinnedclientnamedeccurve(void* lpObj);

int secureblackbox_samlidpserver_getpinnedclientpfscipher(void* lpObj);

char* secureblackbox_samlidpserver_getpinnedclientpresharedidentity(void* lpObj);

char* secureblackbox_samlidpserver_getpinnedclientpresharedidentityhint(void* lpObj);

int secureblackbox_samlidpserver_getpinnedclientpublickeybits(void* lpObj);

char* secureblackbox_samlidpserver_getpinnedclientremoteaddress(void* lpObj);

int secureblackbox_samlidpserver_getpinnedclientremoteport(void* lpObj);

int secureblackbox_samlidpserver_getpinnedclientresumedsession(void* lpObj);

int secureblackbox_samlidpserver_getpinnedclientsecureconnection(void* lpObj);

int secureblackbox_samlidpserver_getpinnedclientserverauthenticated(void* lpObj);

char* secureblackbox_samlidpserver_getpinnedclientsignaturealgorithm(void* lpObj);

int secureblackbox_samlidpserver_getpinnedclientsymmetricblocksize(void* lpObj);

int secureblackbox_samlidpserver_getpinnedclientsymmetrickeybits(void* lpObj);

int64 secureblackbox_samlidpserver_getpinnedclienttotalbytesreceived(void* lpObj);

int64 secureblackbox_samlidpserver_getpinnedclienttotalbytessent(void* lpObj);

char* secureblackbox_samlidpserver_getpinnedclientvalidationlog(void* lpObj);

char* secureblackbox_samlidpserver_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_samlidpserver_getpinnedclientcertcount(void* lpObj);

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

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

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

int64 secureblackbox_samlidpserver_getpinnedclientcerthandle(void* lpObj, int pinnedclientcertindex);

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

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

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

int secureblackbox_samlidpserver_getpinnedclientcertkeybits(void* lpObj, int pinnedclientcertindex);

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

int secureblackbox_samlidpserver_getpinnedclientcertkeyusage(void* lpObj, int pinnedclientcertindex);

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

int secureblackbox_samlidpserver_getpinnedclientcertselfsigned(void* lpObj, int pinnedclientcertindex);

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

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

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

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

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

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

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

int GetPinnedClientCertCount();

QByteArray GetPinnedClientCertBytes(int iPinnedClientCertIndex);

QByteArray GetPinnedClientCertCAKeyID(int iPinnedClientCertIndex);

QString GetPinnedClientCertFingerprint(int iPinnedClientCertIndex);

qint64 GetPinnedClientCertHandle(int iPinnedClientCertIndex);

QString GetPinnedClientCertIssuer(int iPinnedClientCertIndex);

QString GetPinnedClientCertIssuerRDN(int iPinnedClientCertIndex);

QString GetPinnedClientCertKeyAlgorithm(int iPinnedClientCertIndex);

int GetPinnedClientCertKeyBits(int iPinnedClientCertIndex);

QString 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_samlidpserver_getport(void* lpObj);
int secureblackbox_samlidpserver_setport(void* lpObj, int iPort);

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

char* secureblackbox_samlidpserver_getsecuritycanonicalizationmethod(void* lpObj);
int secureblackbox_samlidpserver_setsecuritycanonicalizationmethod(void* lpObj, const char* lpszSecurityCanonicalizationMethod);

char* secureblackbox_samlidpserver_getsecuritydigestmethod(void* lpObj);
int secureblackbox_samlidpserver_setsecuritydigestmethod(void* lpObj, const char* lpszSecurityDigestMethod);

char* secureblackbox_samlidpserver_getsecurityencryptionmethod(void* lpObj);
int secureblackbox_samlidpserver_setsecurityencryptionmethod(void* lpObj, const char* lpszSecurityEncryptionMethod);

int secureblackbox_samlidpserver_getsecurityflags(void* lpObj);
int secureblackbox_samlidpserver_setsecurityflags(void* lpObj, int iSecurityFlags);

char* secureblackbox_samlidpserver_getsecuritysigmethod(void* lpObj);
int secureblackbox_samlidpserver_setsecuritysigmethod(void* lpObj, const char* lpszSecuritySigMethod);

int secureblackbox_samlidpserver_getsecuritysignaturepolicy(void* lpObj);
int secureblackbox_samlidpserver_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_samlidpserver_getsendercertcount(void* lpObj);

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

int64 secureblackbox_samlidpserver_getsenderchainhandle(void* lpObj, int sendercertindex);

int GetSenderCertCount();

QByteArray GetSenderChainBytes(int iSenderCertIndex);

qint64 GetSenderChainHandle(int iSenderCertIndex);

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

int64 secureblackbox_samlidpserver_getsigningcerthandle(void* lpObj);
int secureblackbox_samlidpserver_setsigningcerthandle(void* lpObj, int64 lSigningCertHandle);

QByteArray GetSigningCertBytes();

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

int secureblackbox_samlidpserver_getsigningchaincount(void* lpObj);
int secureblackbox_samlidpserver_setsigningchaincount(void* lpObj, int iSigningChainCount);

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

int64 secureblackbox_samlidpserver_getsigningchainhandle(void* lpObj, int signingchainindex);
int secureblackbox_samlidpserver_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);

char* secureblackbox_samlidpserver_getsignonpagetemplate(void* lpObj);
int secureblackbox_samlidpserver_setsignonpagetemplate(void* lpObj, const char* lpszSignOnPageTemplate);

QString GetSignOnPageTemplate();
int SetSignOnPageTemplate(QString qsSignOnPageTemplate);

int secureblackbox_samlidpserver_getsocketincomingspeedlimit(void* lpObj);
int secureblackbox_samlidpserver_setsocketincomingspeedlimit(void* lpObj, int iSocketIncomingSpeedLimit);

char* secureblackbox_samlidpserver_getsocketlocaladdress(void* lpObj);
int secureblackbox_samlidpserver_setsocketlocaladdress(void* lpObj, const char* lpszSocketLocalAddress);

int secureblackbox_samlidpserver_getsocketlocalport(void* lpObj);
int secureblackbox_samlidpserver_setsocketlocalport(void* lpObj, int iSocketLocalPort);

int secureblackbox_samlidpserver_getsocketoutgoingspeedlimit(void* lpObj);
int secureblackbox_samlidpserver_setsocketoutgoingspeedlimit(void* lpObj, int iSocketOutgoingSpeedLimit);

int secureblackbox_samlidpserver_getsockettimeout(void* lpObj);
int secureblackbox_samlidpserver_setsockettimeout(void* lpObj, int iSocketTimeout);

int secureblackbox_samlidpserver_getsocketuseipv6(void* lpObj);
int secureblackbox_samlidpserver_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_samlidpserver_getspservicecount(void* lpObj);

int secureblackbox_samlidpserver_getspservicebindingtype(void* lpObj, int spserviceindex);

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

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

int secureblackbox_samlidpserver_getspservicepriority(void* lpObj, int spserviceindex);

int secureblackbox_samlidpserver_getspserviceservice(void* lpObj, int spserviceindex);

int secureblackbox_samlidpserver_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);

int secureblackbox_samlidpserver_getspcount(void* lpObj);
int secureblackbox_samlidpserver_setspcount(void* lpObj, int iSPCount);

char* secureblackbox_samlidpserver_getspcontactperson(void* lpObj, int spindex);
int secureblackbox_samlidpserver_setspcontactperson(void* lpObj, int spindex, const char* lpszSPContactPerson);

char* secureblackbox_samlidpserver_getspencryptionkey(void* lpObj, int spindex);
int secureblackbox_samlidpserver_setspencryptionkey(void* lpObj, int spindex, const char* lpszSPEncryptionKey);

char* secureblackbox_samlidpserver_getspencryptionmethods(void* lpObj, int spindex);
int secureblackbox_samlidpserver_setspencryptionmethods(void* lpObj, int spindex, const char* lpszSPEncryptionMethods);

char* secureblackbox_samlidpserver_getspentityid(void* lpObj, int spindex);
int secureblackbox_samlidpserver_setspentityid(void* lpObj, int spindex, const char* lpszSPEntityID);

int secureblackbox_samlidpserver_getspflags(void* lpObj, int spindex);
int secureblackbox_samlidpserver_setspflags(void* lpObj, int spindex, int iSPFlags);

char* secureblackbox_samlidpserver_getspidpssolink(void* lpObj, int spindex);
int secureblackbox_samlidpserver_setspidpssolink(void* lpObj, int spindex, const char* lpszSPIdPSSOLink);

char* secureblackbox_samlidpserver_getspnameidformats(void* lpObj, int spindex);
int secureblackbox_samlidpserver_setspnameidformats(void* lpObj, int spindex, const char* lpszSPNameIDFormats);

char* secureblackbox_samlidpserver_getsporganizationdisplayname(void* lpObj, int spindex);
int secureblackbox_samlidpserver_setsporganizationdisplayname(void* lpObj, int spindex, const char* lpszSPOrganizationDisplayName);

char* secureblackbox_samlidpserver_getsporganizationlang(void* lpObj, int spindex);
int secureblackbox_samlidpserver_setsporganizationlang(void* lpObj, int spindex, const char* lpszSPOrganizationLang);

char* secureblackbox_samlidpserver_getsporganizationname(void* lpObj, int spindex);
int secureblackbox_samlidpserver_setsporganizationname(void* lpObj, int spindex, const char* lpszSPOrganizationName);

char* secureblackbox_samlidpserver_getsporganizationurl(void* lpObj, int spindex);
int secureblackbox_samlidpserver_setsporganizationurl(void* lpObj, int spindex, const char* lpszSPOrganizationURL);

int secureblackbox_samlidpserver_getspsignaturevalidationresult(void* lpObj, int spindex);

int secureblackbox_samlidpserver_getspsigned(void* lpObj, int spindex);

char* secureblackbox_samlidpserver_getspsignedwith(void* lpObj, int spindex);

char* secureblackbox_samlidpserver_getspsigningkey(void* lpObj, int spindex);
int secureblackbox_samlidpserver_setspsigningkey(void* lpObj, int spindex, const char* lpszSPSigningKey);

char* secureblackbox_samlidpserver_getspvaliduntil(void* lpObj, int spindex);
int secureblackbox_samlidpserver_setspvaliduntil(void* lpObj, int spindex, const char* lpszSPValidUntil);

int GetSPCount();
int SetSPCount(int iSPCount);

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

QString GetSPEncryptionKey(int iSPIndex);
int SetSPEncryptionKey(int iSPIndex, QString qsSPEncryptionKey);

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

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

int GetSPFlags(int iSPIndex);
int SetSPFlags(int iSPIndex, int iSPFlags);

QString GetSPIdPSSOLink(int iSPIndex);
int SetSPIdPSSOLink(int iSPIndex, QString qsSPIdPSSOLink);

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

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

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

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

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

int GetSPSignatureValidationResult(int iSPIndex);

bool GetSPSigned(int iSPIndex);

QString GetSPSignedWith(int iSPIndex);

QString GetSPSigningKey(int iSPIndex);
int SetSPSigningKey(int iSPIndex, QString qsSPSigningKey);

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

int secureblackbox_samlidpserver_gettlsservercertcount(void* lpObj);
int secureblackbox_samlidpserver_settlsservercertcount(void* lpObj, int iTLSServerCertCount);

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

int64 secureblackbox_samlidpserver_gettlsservercerthandle(void* lpObj, int tlsservercertindex);
int secureblackbox_samlidpserver_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_samlidpserver_gettlsautovalidatecertificates(void* lpObj);
int secureblackbox_samlidpserver_settlsautovalidatecertificates(void* lpObj, int bTLSAutoValidateCertificates);

int secureblackbox_samlidpserver_gettlsbaseconfiguration(void* lpObj);
int secureblackbox_samlidpserver_settlsbaseconfiguration(void* lpObj, int iTLSBaseConfiguration);

char* secureblackbox_samlidpserver_gettlsciphersuites(void* lpObj);
int secureblackbox_samlidpserver_settlsciphersuites(void* lpObj, const char* lpszTLSCiphersuites);

int secureblackbox_samlidpserver_gettlsclientauth(void* lpObj);
int secureblackbox_samlidpserver_settlsclientauth(void* lpObj, int iTLSClientAuth);

char* secureblackbox_samlidpserver_gettlseccurves(void* lpObj);
int secureblackbox_samlidpserver_settlseccurves(void* lpObj, const char* lpszTLSECCurves);

char* secureblackbox_samlidpserver_gettlsextensions(void* lpObj);
int secureblackbox_samlidpserver_settlsextensions(void* lpObj, const char* lpszTLSExtensions);

int secureblackbox_samlidpserver_gettlsforceresumeifdestinationchanges(void* lpObj);
int secureblackbox_samlidpserver_settlsforceresumeifdestinationchanges(void* lpObj, int bTLSForceResumeIfDestinationChanges);

char* secureblackbox_samlidpserver_gettlspresharedidentity(void* lpObj);
int secureblackbox_samlidpserver_settlspresharedidentity(void* lpObj, const char* lpszTLSPreSharedIdentity);

char* secureblackbox_samlidpserver_gettlspresharedkey(void* lpObj);
int secureblackbox_samlidpserver_settlspresharedkey(void* lpObj, const char* lpszTLSPreSharedKey);

char* secureblackbox_samlidpserver_gettlspresharedkeyciphersuite(void* lpObj);
int secureblackbox_samlidpserver_settlspresharedkeyciphersuite(void* lpObj, const char* lpszTLSPreSharedKeyCiphersuite);

int secureblackbox_samlidpserver_gettlsrenegotiationattackpreventionmode(void* lpObj);
int secureblackbox_samlidpserver_settlsrenegotiationattackpreventionmode(void* lpObj, int iTLSRenegotiationAttackPreventionMode);

int secureblackbox_samlidpserver_gettlsrevocationcheck(void* lpObj);
int secureblackbox_samlidpserver_settlsrevocationcheck(void* lpObj, int iTLSRevocationCheck);

int secureblackbox_samlidpserver_gettlsssloptions(void* lpObj);
int secureblackbox_samlidpserver_settlsssloptions(void* lpObj, int iTLSSSLOptions);

int secureblackbox_samlidpserver_gettlstlsmode(void* lpObj);
int secureblackbox_samlidpserver_settlstlsmode(void* lpObj, int iTLSTLSMode);

int secureblackbox_samlidpserver_gettlsuseextendedmastersecret(void* lpObj);
int secureblackbox_samlidpserver_settlsuseextendedmastersecret(void* lpObj, int bTLSUseExtendedMasterSecret);

int secureblackbox_samlidpserver_gettlsusesessionresumption(void* lpObj);
int secureblackbox_samlidpserver_settlsusesessionresumption(void* lpObj, int bTLSUseSessionResumption);

int secureblackbox_samlidpserver_gettlsversions(void* lpObj);
int secureblackbox_samlidpserver_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_samlidpserver_geturl(void* lpObj);
int secureblackbox_samlidpserver_seturl(void* lpObj, const char* lpszURL);

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

int secureblackbox_samlidpserver_getusercount(void* lpObj);
int secureblackbox_samlidpserver_setusercount(void* lpObj, int iUserCount);

int secureblackbox_samlidpserver_getuserassociateddata(void* lpObj, int userindex, char** lpUserAssociatedData, int* lenUserAssociatedData);
int secureblackbox_samlidpserver_setuserassociateddata(void* lpObj, int userindex, const char* lpUserAssociatedData, int lenUserAssociatedData);

char* secureblackbox_samlidpserver_getuserbasepath(void* lpObj, int userindex);
int secureblackbox_samlidpserver_setuserbasepath(void* lpObj, int userindex, const char* lpszUserBasePath);

int secureblackbox_samlidpserver_getusercertificate(void* lpObj, int userindex, char** lpUserCertificate, int* lenUserCertificate);
int secureblackbox_samlidpserver_setusercertificate(void* lpObj, int userindex, const char* lpUserCertificate, int lenUserCertificate);

char* secureblackbox_samlidpserver_getuserdata(void* lpObj, int userindex);
int secureblackbox_samlidpserver_setuserdata(void* lpObj, int userindex, const char* lpszUserData);

char* secureblackbox_samlidpserver_getuseremail(void* lpObj, int userindex);
int secureblackbox_samlidpserver_setuseremail(void* lpObj, int userindex, const char* lpszUserEmail);

int64 secureblackbox_samlidpserver_getuserhandle(void* lpObj, int userindex);
int secureblackbox_samlidpserver_setuserhandle(void* lpObj, int userindex, int64 lUserHandle);

char* secureblackbox_samlidpserver_getuserhashalgorithm(void* lpObj, int userindex);
int secureblackbox_samlidpserver_setuserhashalgorithm(void* lpObj, int userindex, const char* lpszUserHashAlgorithm);

int secureblackbox_samlidpserver_getuserincomingspeedlimit(void* lpObj, int userindex);
int secureblackbox_samlidpserver_setuserincomingspeedlimit(void* lpObj, int userindex, int iUserIncomingSpeedLimit);

int secureblackbox_samlidpserver_getuserotpalgorithm(void* lpObj, int userindex);
int secureblackbox_samlidpserver_setuserotpalgorithm(void* lpObj, int userindex, int iUserOtpAlgorithm);

int secureblackbox_samlidpserver_getuserotplen(void* lpObj, int userindex);
int secureblackbox_samlidpserver_setuserotplen(void* lpObj, int userindex, int iUserOTPLen);

int secureblackbox_samlidpserver_getuserotpvalue(void* lpObj, int userindex);
int secureblackbox_samlidpserver_setuserotpvalue(void* lpObj, int userindex, int iUserOtpValue);

int secureblackbox_samlidpserver_getuseroutgoingspeedlimit(void* lpObj, int userindex);
int secureblackbox_samlidpserver_setuseroutgoingspeedlimit(void* lpObj, int userindex, int iUserOutgoingSpeedLimit);

char* secureblackbox_samlidpserver_getuserpassword(void* lpObj, int userindex);
int secureblackbox_samlidpserver_setuserpassword(void* lpObj, int userindex, const char* lpszUserPassword);

int secureblackbox_samlidpserver_getusersharedsecret(void* lpObj, int userindex, char** lpUserSharedSecret, int* lenUserSharedSecret);
int secureblackbox_samlidpserver_setusersharedsecret(void* lpObj, int userindex, const char* lpUserSharedSecret, int lenUserSharedSecret);

int secureblackbox_samlidpserver_getusersshkey(void* lpObj, int userindex, char** lpUserSSHKey, int* lenUserSSHKey);
int secureblackbox_samlidpserver_setusersshkey(void* lpObj, int userindex, const char* lpUserSSHKey, int lenUserSSHKey);

char* secureblackbox_samlidpserver_getuserusername(void* lpObj, int userindex);
int secureblackbox_samlidpserver_setuserusername(void* lpObj, int userindex, const char* lpszUserUsername);

int GetUserCount();
int SetUserCount(int iUserCount);

QByteArray GetUserAssociatedData(int iUserIndex);
int SetUserAssociatedData(int iUserIndex, QByteArray qbaUserAssociatedData);

QString GetUserBasePath(int iUserIndex);
int SetUserBasePath(int iUserIndex, QString qsUserBasePath);

QByteArray GetUserCertificate(int iUserIndex);
int SetUserCertificate(int iUserIndex, QByteArray qbaUserCertificate);

QString GetUserData(int iUserIndex);
int SetUserData(int iUserIndex, QString qsUserData);

QString GetUserEmail(int iUserIndex);
int SetUserEmail(int iUserIndex, QString qsUserEmail);

qint64 GetUserHandle(int iUserIndex);
int SetUserHandle(int iUserIndex, qint64 lUserHandle);

QString GetUserHashAlgorithm(int iUserIndex);
int SetUserHashAlgorithm(int iUserIndex, QString qsUserHashAlgorithm);

int GetUserIncomingSpeedLimit(int iUserIndex);
int SetUserIncomingSpeedLimit(int iUserIndex, int iUserIncomingSpeedLimit);

int GetUserOtpAlgorithm(int iUserIndex);
int SetUserOtpAlgorithm(int iUserIndex, int iUserOtpAlgorithm);

int GetUserOTPLen(int iUserIndex);
int SetUserOTPLen(int iUserIndex, int iUserOTPLen);

int GetUserOtpValue(int iUserIndex);
int SetUserOtpValue(int iUserIndex, int iUserOtpValue);

int GetUserOutgoingSpeedLimit(int iUserIndex);
int SetUserOutgoingSpeedLimit(int iUserIndex, int iUserOutgoingSpeedLimit);

QString GetUserPassword(int iUserIndex);
int SetUserPassword(int iUserIndex, QString qsUserPassword);

QByteArray GetUserSharedSecret(int iUserIndex);
int SetUserSharedSecret(int iUserIndex, QByteArray qbaUserSharedSecret);

QByteArray GetUserSSHKey(int iUserIndex);
int SetUserSSHKey(int iUserIndex, QByteArray qbaUserSSHKey);

QString GetUserUsername(int iUserIndex);
int SetUserUsername(int iUserIndex, QString qsUserUsername);

int secureblackbox_samlidpserver_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_samlidpserver_addsp(void* lpObj, const char* lpszEntityID, const char* lpszIdPSSOLink);

int AddSP(const QString& qsEntityID, const QString& qsIdPSSOLink);

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

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

int secureblackbox_samlidpserver_completeauth(void* lpObj, int64 lConnectionID, const char* lpszSessionID, const char* lpszSP, const char* lpszRelayState, const char* lpszTag);

int CompleteAuth(qint64 lConnectionID, const QString& qsSessionID, const QString& qsSP, const QString& qsRelayState, const QString& qsTag);

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

QString Config(const QString& qsConfigurationString);

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

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

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

int DropClient(qint64 lConnectionId, bool bForced);

char* secureblackbox_samlidpserver_exportsettings(void* lpObj, int bIdP, int iIndex);

QString ExportSettings(bool bIdP, int iIndex);

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

QString GetProviderProperty(const QString& qsName);

char* secureblackbox_samlidpserver_getrequestbytes(void* lpObj, int64 lConnectionID, const char* lpszRequestFilter, int *lpSize);

QByteArray GetRequestBytes(qint64 lConnectionID, const QString& qsRequestFilter);

char* secureblackbox_samlidpserver_getrequestheader(void* lpObj, int64 lConnectionId, const char* lpszHeaderName);

QString GetRequestHeader(qint64 lConnectionId, const QString& qsHeaderName);

char* secureblackbox_samlidpserver_getresponseheader(void* lpObj, int64 lConnectionId, const char* lpszHeaderName);

QString GetResponseHeader(qint64 lConnectionId, const QString& qsHeaderName);

char* secureblackbox_samlidpserver_getsessionproperty(void* lpObj, const char* lpszSessionID, const char* lpszName);

QString GetSessionProperty(const QString& qsSessionID, const QString& qsName);

int secureblackbox_samlidpserver_importsettings(void* lpObj, const char* lpszMetadata, int bIdP);

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

int secureblackbox_samlidpserver_initiateauth(void* lpObj, int64 lConnectionID, const char* lpszSessionID, const char* lpszTag);

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

int secureblackbox_samlidpserver_initiatelogout(void* lpObj, int64 lConnectionID, const char* lpszSessionID, const char* lpszSP, const char* lpszTag);

int InitiateLogout(qint64 lConnectionID, const QString& qsSessionID, const QString& qsSP, const QString& qsTag);

char* secureblackbox_samlidpserver_listclients(void* lpObj);

QString ListClients();

int secureblackbox_samlidpserver_pinclient(void* lpObj, int64 lConnectionId);

int PinClient(qint64 lConnectionId);

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

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

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

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

int secureblackbox_samlidpserver_processgenericrequest(void* lpObj, int64 lConnectionID, const char* lpszSessionID, const char* lpszURL, const char* lpszHttpMethod, const char* lpszRequest, const char* lpszTag);

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

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

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

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

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

int secureblackbox_samlidpserver_processsignonresponse(void* lpObj, int64 lConnectionID, const char* lpszSessionID, const char* lpszResponse, const char* lpszTag);

int ProcessSignOnResponse(qint64 lConnectionID, const QString& qsSessionID, const QString& qsResponse, const QString& qsTag);

int secureblackbox_samlidpserver_removesp(void* lpObj, int iIndex);

int RemoveSP(int iIndex);

int secureblackbox_samlidpserver_reset(void* lpObj);

int Reset();

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

int SetClientBuffer(qint64 lConnectionID, QByteArray qbaValue);

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

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

bool secureblackbox_samlidpserver_setresponseheader(void* lpObj, int64 lConnectionId, const char* lpszHeaderName, const char* lpszValue);

bool SetResponseHeader(qint64 lConnectionId, const QString& qsHeaderName, const QString& qsValue);

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

int SetSessionProperty(const QString& qsSessionID, const QString& qsName, const QString& qsValue);

int secureblackbox_samlidpserver_start(void* lpObj);

int Start();

int secureblackbox_samlidpserver_stop(void* lpObj);

int Stop();

#define EID_SAMLIDPSERVER_ACCEPT 1

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

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

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

#define EID_SAMLIDPSERVER_ARTIFACTRESOLVEREQUESTPREPARED 2

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

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

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

#define EID_SAMLIDPSERVER_ARTIFACTRESOLVEREQUESTRECEIVED 3

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

class SAMLIdPServerArtifactResolveRequestReceivedEventParams {
public:
  qint64 ConnectionID();

  const QString &SessionID();

  const QString &RequestID();

  const QString &SP();

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

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

#define EID_SAMLIDPSERVER_ASSERTIONPREPARED 4

virtual INT SECUREBLACKBOX_CALL FireAssertionPrepared(LONG64 &lConnectionID, LPSTR &lpszSessionID, LPSTR &lpszRequestID, LPSTR &lpszSP, LPSTR &lpszBody, LPSTR &lpszAuth, LPSTR &lpszNameID, LPSTR &lpszNameIDFormat, LPSTR &lpszSessionIndex, LPSTR &lpszValidFrom, LPSTR &lpszValidTo);

class SAMLIdPServerAssertionPreparedEventParams {
public:
  qint64 ConnectionID();

  const QString &SessionID();

  const QString &RequestID();

  const QString &SP();

  const QString &Body();

  const QString &Auth();

  const QString &NameID();

  const QString &NameIDFormat();

  const QString &SessionIndex();

  const QString &ValidFrom();

  const QString &ValidTo();

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

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

// Or, subclass SAMLIdPServer and override this emitter function.
virtual int FireAssertionPrepared(SAMLIdPServerAssertionPreparedEventParams *e) {...}

#define EID_SAMLIDPSERVER_ATTRIBUTEQUERYRECEIVED 5

virtual INT SECUREBLACKBOX_CALL FireAttributeQueryReceived(LONG64 &lConnectionID, LPSTR &lpszSessionID, LPSTR &lpszRequestID, LPSTR &lpszSP, BOOL &bIsEncrypted, BOOL &bIsSigned, LPSTR &lpszAttributes, INT &iAction);

class SAMLIdPServerAttributeQueryReceivedEventParams {
public:
  qint64 ConnectionID();

  const QString &SessionID();

  const QString &RequestID();

  const QString &SP();

  bool IsEncrypted();

  bool IsSigned();

  const QString &Attributes();

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

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

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

// Or, subclass SAMLIdPServer and override this emitter function.
virtual int FireAttributeQueryReceived(SAMLIdPServerAttributeQueryReceivedEventParams *e) {...}

#define EID_SAMLIDPSERVER_AUTHNREQUESTRECEIVED 6

virtual INT SECUREBLACKBOX_CALL FireAuthnRequestReceived(LONG64 &lConnectionID, LPSTR &lpszSessionID, LPSTR &lpszRequestID, LPSTR &lpszSP, BOOL &bIsEncrypted, BOOL &bIsSigned, BOOL &bForceAuthn, BOOL &bNonInteractive, BOOL &bAuthenticated, INT &iAction);

class SAMLIdPServerAuthnRequestReceivedEventParams {
public:
  qint64 ConnectionID();

  const QString &SessionID();

  const QString &RequestID();

  const QString &SP();

  bool IsEncrypted();

  bool IsSigned();

  bool ForceAuthn();
  void SetForceAuthn(bool bForceAuthn);

  bool NonInteractive();
  void SetNonInteractive(bool bNonInteractive);

  bool Authenticated();
  void SetAuthenticated(bool bAuthenticated);

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

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

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

// Or, subclass SAMLIdPServer and override this emitter function.
virtual int FireAuthnRequestReceived(SAMLIdPServerAuthnRequestReceivedEventParams *e) {...}

#define EID_SAMLIDPSERVER_CONNECT 7

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

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

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

#define EID_SAMLIDPSERVER_DISCONNECT 8

virtual INT SECUREBLACKBOX_CALL FireDisconnect(LONG64 &lConnectionID);

class SAMLIdPServerDisconnectEventParams {
public:
  qint64 ConnectionID();

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

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

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

#define EID_SAMLIDPSERVER_ERROR 9

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

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

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

#define EID_SAMLIDPSERVER_EXTERNALSIGN 10

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

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

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

#define EID_SAMLIDPSERVER_LOGOUTREQUESTRECEIVED 11

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

class SAMLIdPServerLogoutRequestReceivedEventParams {
public:
  qint64 ConnectionID();

  const QString &SessionID();

  const QString &RequestID();

  const QString &SP();

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

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

#define EID_SAMLIDPSERVER_LOGOUTRESPONSEPREPARED 12

virtual INT SECUREBLACKBOX_CALL FireLogoutResponsePrepared(LONG64 &lConnectionID, LPSTR &lpszSessionID, LPSTR &lpszRequestID, LPSTR &lpszSP, LPSTR &lpszBody, LPSTR &lpszNameID);

class SAMLIdPServerLogoutResponsePreparedEventParams {
public:
  qint64 ConnectionID();

  const QString &SessionID();

  const QString &RequestID();

  const QString &SP();

  const QString &Body();

  const QString &NameID();

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

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

// Or, subclass SAMLIdPServer and override this emitter function.
virtual int FireLogoutResponsePrepared(SAMLIdPServerLogoutResponsePreparedEventParams *e) {...}

#define EID_SAMLIDPSERVER_METADATAPREPARED 13

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

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

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

#define EID_SAMLIDPSERVER_NOTIFICATION 14

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

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

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

#define EID_SAMLIDPSERVER_PROCESSINGCOMPLETED 15

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

class SAMLIdPServerProcessingCompletedEventParams {
public:
  qint64 ConnectionID();

  const QString &SessionID();

  const QString &Tag();

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

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

#define EID_SAMLIDPSERVER_RESOURCECLOSE 16

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

class SAMLIdPServerResourceCloseEventParams {
public:
  qint64 ConnectionID();

  const QString &SessionID();

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

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

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

#define EID_SAMLIDPSERVER_RESOURCEOPEN 17

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

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

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

#define EID_SAMLIDPSERVER_RESOURCEREAD 18

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

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

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

#define EID_SAMLIDPSERVER_RESOURCEREQUEST 19

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

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

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

#define EID_SAMLIDPSERVER_SAMLMESSAGEPREPARED 20

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

class SAMLIdPServerSAMLMessagePreparedEventParams {
public:
  qint64 ConnectionID();

  const QString &SessionID();

  const QString &Destination();

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

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

#define EID_SAMLIDPSERVER_SAMLMESSAGERECEIVED 21

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

class SAMLIdPServerSAMLMessageReceivedEventParams {
public:
  qint64 ConnectionID();

  const QString &SessionID();

  const QString &MessageType();

  const QString &MessageID();

  const QString &Issuer();

  const QString &IssueInstant();

  const QString &MessageBody();

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

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

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

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

#define EID_SAMLIDPSERVER_SESSIONCREATED 22

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

class SAMLIdPServerSessionCreatedEventParams {
public:
  qint64 ConnectionID();

  const QString &SessionID();

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

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

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