int secureblackbox_webdavserver_getactive(void* lpObj);

bool GetActive();

char* secureblackbox_webdavserver_getauthrealm(void* lpObj);
int secureblackbox_webdavserver_setauthrealm(void* lpObj, const char* lpszAuthRealm);

QString GetAuthRealm();
int SetAuthRealm(QString qsAuthRealm);

int secureblackbox_webdavserver_getauthtypes(void* lpObj);
int secureblackbox_webdavserver_setauthtypes(void* lpObj, int iAuthTypes);

int GetAuthTypes();
int SetAuthTypes(int iAuthTypes);

int secureblackbox_webdavserver_getboundport(void* lpObj);

int GetBoundPort();

char* secureblackbox_webdavserver_getclientfileentryatime(void* lpObj);
int secureblackbox_webdavserver_setclientfileentryatime(void* lpObj, const char* lpszClientFileEntryATime);

char* secureblackbox_webdavserver_getclientfileentrycontenttype(void* lpObj);
int secureblackbox_webdavserver_setclientfileentrycontenttype(void* lpObj, const char* lpszClientFileEntryContentType);

char* secureblackbox_webdavserver_getclientfileentryctime(void* lpObj);
int secureblackbox_webdavserver_setclientfileentryctime(void* lpObj, const char* lpszClientFileEntryCTime);

int secureblackbox_webdavserver_getclientfileentrydirectory(void* lpObj);
int secureblackbox_webdavserver_setclientfileentrydirectory(void* lpObj, int bClientFileEntryDirectory);

char* secureblackbox_webdavserver_getclientfileentrydisplayname(void* lpObj);
int secureblackbox_webdavserver_setclientfileentrydisplayname(void* lpObj, const char* lpszClientFileEntryDisplayName);

char* secureblackbox_webdavserver_getclientfileentryetag(void* lpObj);
int secureblackbox_webdavserver_setclientfileentryetag(void* lpObj, const char* lpszClientFileEntryETag);

char* secureblackbox_webdavserver_getclientfileentryfullurl(void* lpObj);
int secureblackbox_webdavserver_setclientfileentryfullurl(void* lpObj, const char* lpszClientFileEntryFullURL);

char* secureblackbox_webdavserver_getclientfileentrymtime(void* lpObj);
int secureblackbox_webdavserver_setclientfileentrymtime(void* lpObj, const char* lpszClientFileEntryMTime);

char* secureblackbox_webdavserver_getclientfileentryparenturl(void* lpObj);
int secureblackbox_webdavserver_setclientfileentryparenturl(void* lpObj, const char* lpszClientFileEntryParentURL);

int64 secureblackbox_webdavserver_getclientfileentrysize(void* lpObj);
int secureblackbox_webdavserver_setclientfileentrysize(void* lpObj, int64 lClientFileEntrySize);

int secureblackbox_webdavserver_getclientfileentrysupportsexclusivelock(void* lpObj);
int secureblackbox_webdavserver_setclientfileentrysupportsexclusivelock(void* lpObj, int bClientFileEntrySupportsExclusiveLock);

int secureblackbox_webdavserver_getclientfileentrysupportssharedlock(void* lpObj);
int secureblackbox_webdavserver_setclientfileentrysupportssharedlock(void* lpObj, int bClientFileEntrySupportsSharedLock);

char* secureblackbox_webdavserver_getclientfileentryurl(void* lpObj);
int secureblackbox_webdavserver_setclientfileentryurl(void* lpObj, const char* lpszClientFileEntryURL);

QString GetClientFileEntryATime();
int SetClientFileEntryATime(QString qsClientFileEntryATime);

QString GetClientFileEntryContentType();
int SetClientFileEntryContentType(QString qsClientFileEntryContentType);

QString GetClientFileEntryCTime();
int SetClientFileEntryCTime(QString qsClientFileEntryCTime);

bool GetClientFileEntryDirectory();
int SetClientFileEntryDirectory(bool bClientFileEntryDirectory);

QString GetClientFileEntryDisplayName();
int SetClientFileEntryDisplayName(QString qsClientFileEntryDisplayName);

QString GetClientFileEntryETag();
int SetClientFileEntryETag(QString qsClientFileEntryETag);

QString GetClientFileEntryFullURL();
int SetClientFileEntryFullURL(QString qsClientFileEntryFullURL);

QString GetClientFileEntryMTime();
int SetClientFileEntryMTime(QString qsClientFileEntryMTime);

QString GetClientFileEntryParentURL();
int SetClientFileEntryParentURL(QString qsClientFileEntryParentURL);

qint64 GetClientFileEntrySize();
int SetClientFileEntrySize(qint64 lClientFileEntrySize);

bool GetClientFileEntrySupportsExclusiveLock();
int SetClientFileEntrySupportsExclusiveLock(bool bClientFileEntrySupportsExclusiveLock);

bool GetClientFileEntrySupportsSharedLock();
int SetClientFileEntrySupportsSharedLock(bool bClientFileEntrySupportsSharedLock);

QString GetClientFileEntryURL();
int SetClientFileEntryURL(QString qsClientFileEntryURL);

char* secureblackbox_webdavserver_getdocumentroot(void* lpObj);
int secureblackbox_webdavserver_setdocumentroot(void* lpObj, const char* lpszDocumentRoot);

QString GetDocumentRoot();
int SetDocumentRoot(QString qsDocumentRoot);

char* secureblackbox_webdavserver_getexternalcryptoasyncdocumentid(void* lpObj);
int secureblackbox_webdavserver_setexternalcryptoasyncdocumentid(void* lpObj, const char* lpszExternalCryptoAsyncDocumentID);

char* secureblackbox_webdavserver_getexternalcryptocustomparams(void* lpObj);
int secureblackbox_webdavserver_setexternalcryptocustomparams(void* lpObj, const char* lpszExternalCryptoCustomParams);

char* secureblackbox_webdavserver_getexternalcryptodata(void* lpObj);
int secureblackbox_webdavserver_setexternalcryptodata(void* lpObj, const char* lpszExternalCryptoData);

int secureblackbox_webdavserver_getexternalcryptoexternalhashcalculation(void* lpObj);
int secureblackbox_webdavserver_setexternalcryptoexternalhashcalculation(void* lpObj, int bExternalCryptoExternalHashCalculation);

char* secureblackbox_webdavserver_getexternalcryptohashalgorithm(void* lpObj);
int secureblackbox_webdavserver_setexternalcryptohashalgorithm(void* lpObj, const char* lpszExternalCryptoHashAlgorithm);

char* secureblackbox_webdavserver_getexternalcryptokeyid(void* lpObj);
int secureblackbox_webdavserver_setexternalcryptokeyid(void* lpObj, const char* lpszExternalCryptoKeyID);

char* secureblackbox_webdavserver_getexternalcryptokeysecret(void* lpObj);
int secureblackbox_webdavserver_setexternalcryptokeysecret(void* lpObj, const char* lpszExternalCryptoKeySecret);

int secureblackbox_webdavserver_getexternalcryptomethod(void* lpObj);
int secureblackbox_webdavserver_setexternalcryptomethod(void* lpObj, int iExternalCryptoMethod);

int secureblackbox_webdavserver_getexternalcryptomode(void* lpObj);
int secureblackbox_webdavserver_setexternalcryptomode(void* lpObj, int iExternalCryptoMode);

char* secureblackbox_webdavserver_getexternalcryptopublickeyalgorithm(void* lpObj);
int secureblackbox_webdavserver_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_webdavserver_getfipsmode(void* lpObj);
int secureblackbox_webdavserver_setfipsmode(void* lpObj, int bFIPSMode);

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

char* secureblackbox_webdavserver_gethost(void* lpObj);
int secureblackbox_webdavserver_sethost(void* lpObj, const char* lpszHost);

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

int secureblackbox_webdavserver_getmetadataflushtimeout(void* lpObj);
int secureblackbox_webdavserver_setmetadataflushtimeout(void* lpObj, int iMetadataFlushTimeout);

int GetMetadataFlushTimeout();
int SetMetadataFlushTimeout(int iMetadataFlushTimeout);

char* secureblackbox_webdavserver_getmetadataroot(void* lpObj);
int secureblackbox_webdavserver_setmetadataroot(void* lpObj, const char* lpszMetadataRoot);

QString GetMetadataRoot();
int SetMetadataRoot(QString qsMetadataRoot);

int secureblackbox_webdavserver_getpinnedclientaeadcipher(void* lpObj);

int secureblackbox_webdavserver_getpinnedclientchainvalidationdetails(void* lpObj);

int secureblackbox_webdavserver_getpinnedclientchainvalidationresult(void* lpObj);

char* secureblackbox_webdavserver_getpinnedclientciphersuite(void* lpObj);

int secureblackbox_webdavserver_getpinnedclientclientauthenticated(void* lpObj);

int secureblackbox_webdavserver_getpinnedclientclientauthrequested(void* lpObj);

int secureblackbox_webdavserver_getpinnedclientconnectionestablished(void* lpObj);

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

char* secureblackbox_webdavserver_getpinnedclientdigestalgorithm(void* lpObj);

char* secureblackbox_webdavserver_getpinnedclientencryptionalgorithm(void* lpObj);

int secureblackbox_webdavserver_getpinnedclientexportable(void* lpObj);

int64 secureblackbox_webdavserver_getpinnedclientid(void* lpObj);

char* secureblackbox_webdavserver_getpinnedclientkeyexchangealgorithm(void* lpObj);

int secureblackbox_webdavserver_getpinnedclientkeyexchangekeybits(void* lpObj);

char* secureblackbox_webdavserver_getpinnedclientnamedeccurve(void* lpObj);

int secureblackbox_webdavserver_getpinnedclientpfscipher(void* lpObj);

char* secureblackbox_webdavserver_getpinnedclientpresharedidentity(void* lpObj);

char* secureblackbox_webdavserver_getpinnedclientpresharedidentityhint(void* lpObj);

int secureblackbox_webdavserver_getpinnedclientpublickeybits(void* lpObj);

char* secureblackbox_webdavserver_getpinnedclientremoteaddress(void* lpObj);

int secureblackbox_webdavserver_getpinnedclientremoteport(void* lpObj);

int secureblackbox_webdavserver_getpinnedclientresumedsession(void* lpObj);

int secureblackbox_webdavserver_getpinnedclientsecureconnection(void* lpObj);

int secureblackbox_webdavserver_getpinnedclientserverauthenticated(void* lpObj);

char* secureblackbox_webdavserver_getpinnedclientsignaturealgorithm(void* lpObj);

int secureblackbox_webdavserver_getpinnedclientsymmetricblocksize(void* lpObj);

int secureblackbox_webdavserver_getpinnedclientsymmetrickeybits(void* lpObj);

int64 secureblackbox_webdavserver_getpinnedclienttotalbytesreceived(void* lpObj);

int64 secureblackbox_webdavserver_getpinnedclienttotalbytessent(void* lpObj);

char* secureblackbox_webdavserver_getpinnedclientvalidationlog(void* lpObj);

char* secureblackbox_webdavserver_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_webdavserver_getpinnedclientcertcount(void* lpObj);

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

int secureblackbox_webdavserver_getpinnedclientcertca(void* lpObj, int pinnedclientcertindex);

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

int secureblackbox_webdavserver_getpinnedclientcertcerttype(void* lpObj, int pinnedclientcertindex);

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

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

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

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

int64 secureblackbox_webdavserver_getpinnedclientcerthandle(void* lpObj, int pinnedclientcertindex);

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

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

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

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

int secureblackbox_webdavserver_getpinnedclientcertkeybits(void* lpObj, int pinnedclientcertindex);

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

int secureblackbox_webdavserver_getpinnedclientcertkeyusage(void* lpObj, int pinnedclientcertindex);

int secureblackbox_webdavserver_getpinnedclientcertkeyvalid(void* lpObj, int pinnedclientcertindex);

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

int secureblackbox_webdavserver_getpinnedclientcertocspnocheck(void* lpObj, int pinnedclientcertindex);

int secureblackbox_webdavserver_getpinnedclientcertorigin(void* lpObj, int pinnedclientcertindex);

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

int secureblackbox_webdavserver_getpinnedclientcertprivatekeybytes(void* lpObj, int pinnedclientcertindex, char** lpPinnedClientCertPrivateKeyBytes, int* lenPinnedClientCertPrivateKeyBytes);

int secureblackbox_webdavserver_getpinnedclientcertprivatekeyexists(void* lpObj, int pinnedclientcertindex);

int secureblackbox_webdavserver_getpinnedclientcertprivatekeyextractable(void* lpObj, int pinnedclientcertindex);

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

int secureblackbox_webdavserver_getpinnedclientcertqualified(void* lpObj, int pinnedclientcertindex);

int secureblackbox_webdavserver_getpinnedclientcertqualifiedstatements(void* lpObj, int pinnedclientcertindex);

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

int secureblackbox_webdavserver_getpinnedclientcertselfsigned(void* lpObj, int pinnedclientcertindex);

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

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

int secureblackbox_webdavserver_getpinnedclientcertsource(void* lpObj, int pinnedclientcertindex);

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

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

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

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

int secureblackbox_webdavserver_getpinnedclientcertvalid(void* lpObj, int pinnedclientcertindex);

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

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

int GetPinnedClientCertCount();

QByteArray GetPinnedClientCertBytes(int iPinnedClientCertIndex);

bool GetPinnedClientCertCA(int iPinnedClientCertIndex);

QByteArray GetPinnedClientCertCAKeyID(int iPinnedClientCertIndex);

int GetPinnedClientCertCertType(int iPinnedClientCertIndex);

QString GetPinnedClientCertCRLDistributionPoints(int iPinnedClientCertIndex);

QString GetPinnedClientCertCurve(int iPinnedClientCertIndex);

QString GetPinnedClientCertFingerprint(int iPinnedClientCertIndex);

QString GetPinnedClientCertFriendlyName(int iPinnedClientCertIndex);

qint64 GetPinnedClientCertHandle(int iPinnedClientCertIndex);

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

bool GetPinnedClientCertKeyValid(int iPinnedClientCertIndex);

QString GetPinnedClientCertOCSPLocations(int iPinnedClientCertIndex);

bool GetPinnedClientCertOCSPNoCheck(int iPinnedClientCertIndex);

int GetPinnedClientCertOrigin(int iPinnedClientCertIndex);

QString GetPinnedClientCertPolicyIDs(int iPinnedClientCertIndex);

QByteArray GetPinnedClientCertPrivateKeyBytes(int iPinnedClientCertIndex);

bool GetPinnedClientCertPrivateKeyExists(int iPinnedClientCertIndex);

bool GetPinnedClientCertPrivateKeyExtractable(int iPinnedClientCertIndex);

QByteArray GetPinnedClientCertPublicKeyBytes(int iPinnedClientCertIndex);

bool GetPinnedClientCertQualified(int iPinnedClientCertIndex);

int GetPinnedClientCertQualifiedStatements(int iPinnedClientCertIndex);

QString GetPinnedClientCertQualifiers(int iPinnedClientCertIndex);

bool GetPinnedClientCertSelfSigned(int iPinnedClientCertIndex);

QByteArray GetPinnedClientCertSerialNumber(int iPinnedClientCertIndex);

QString GetPinnedClientCertSigAlgorithm(int iPinnedClientCertIndex);

int GetPinnedClientCertSource(int iPinnedClientCertIndex);

QString GetPinnedClientCertSubject(int iPinnedClientCertIndex);

QString GetPinnedClientCertSubjectAlternativeName(int iPinnedClientCertIndex);

QByteArray GetPinnedClientCertSubjectKeyID(int iPinnedClientCertIndex);

QString GetPinnedClientCertSubjectRDN(int iPinnedClientCertIndex);

bool GetPinnedClientCertValid(int iPinnedClientCertIndex);

QString GetPinnedClientCertValidFrom(int iPinnedClientCertIndex);

QString GetPinnedClientCertValidTo(int iPinnedClientCertIndex);

int secureblackbox_webdavserver_getport(void* lpObj);
int secureblackbox_webdavserver_setport(void* lpObj, int iPort);

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

int secureblackbox_webdavserver_getportrangefrom(void* lpObj);
int secureblackbox_webdavserver_setportrangefrom(void* lpObj, int iPortRangeFrom);

int GetPortRangeFrom();
int SetPortRangeFrom(int iPortRangeFrom);

int secureblackbox_webdavserver_getportrangeto(void* lpObj);
int secureblackbox_webdavserver_setportrangeto(void* lpObj, int iPortRangeTo);

int GetPortRangeTo();
int SetPortRangeTo(int iPortRangeTo);

int secureblackbox_webdavserver_getsocketincomingspeedlimit(void* lpObj);
int secureblackbox_webdavserver_setsocketincomingspeedlimit(void* lpObj, int iSocketIncomingSpeedLimit);

char* secureblackbox_webdavserver_getsocketlocaladdress(void* lpObj);
int secureblackbox_webdavserver_setsocketlocaladdress(void* lpObj, const char* lpszSocketLocalAddress);

int secureblackbox_webdavserver_getsocketlocalport(void* lpObj);
int secureblackbox_webdavserver_setsocketlocalport(void* lpObj, int iSocketLocalPort);

int secureblackbox_webdavserver_getsocketoutgoingspeedlimit(void* lpObj);
int secureblackbox_webdavserver_setsocketoutgoingspeedlimit(void* lpObj, int iSocketOutgoingSpeedLimit);

int secureblackbox_webdavserver_getsockettimeout(void* lpObj);
int secureblackbox_webdavserver_setsockettimeout(void* lpObj, int iSocketTimeout);

int secureblackbox_webdavserver_getsocketuseipv6(void* lpObj);
int secureblackbox_webdavserver_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_webdavserver_gettlsservercertcount(void* lpObj);
int secureblackbox_webdavserver_settlsservercertcount(void* lpObj, int iTLSServerCertCount);

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

int64 secureblackbox_webdavserver_gettlsservercerthandle(void* lpObj, int tlsservercertindex);
int secureblackbox_webdavserver_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_webdavserver_gettlsautovalidatecertificates(void* lpObj);
int secureblackbox_webdavserver_settlsautovalidatecertificates(void* lpObj, int bTLSAutoValidateCertificates);

int secureblackbox_webdavserver_gettlsbaseconfiguration(void* lpObj);
int secureblackbox_webdavserver_settlsbaseconfiguration(void* lpObj, int iTLSBaseConfiguration);

char* secureblackbox_webdavserver_gettlsciphersuites(void* lpObj);
int secureblackbox_webdavserver_settlsciphersuites(void* lpObj, const char* lpszTLSCiphersuites);

int secureblackbox_webdavserver_gettlsclientauth(void* lpObj);
int secureblackbox_webdavserver_settlsclientauth(void* lpObj, int iTLSClientAuth);

char* secureblackbox_webdavserver_gettlseccurves(void* lpObj);
int secureblackbox_webdavserver_settlseccurves(void* lpObj, const char* lpszTLSECCurves);

char* secureblackbox_webdavserver_gettlsextensions(void* lpObj);
int secureblackbox_webdavserver_settlsextensions(void* lpObj, const char* lpszTLSExtensions);

int secureblackbox_webdavserver_gettlsforceresumeifdestinationchanges(void* lpObj);
int secureblackbox_webdavserver_settlsforceresumeifdestinationchanges(void* lpObj, int bTLSForceResumeIfDestinationChanges);

char* secureblackbox_webdavserver_gettlspresharedidentity(void* lpObj);
int secureblackbox_webdavserver_settlspresharedidentity(void* lpObj, const char* lpszTLSPreSharedIdentity);

char* secureblackbox_webdavserver_gettlspresharedkey(void* lpObj);
int secureblackbox_webdavserver_settlspresharedkey(void* lpObj, const char* lpszTLSPreSharedKey);

char* secureblackbox_webdavserver_gettlspresharedkeyciphersuite(void* lpObj);
int secureblackbox_webdavserver_settlspresharedkeyciphersuite(void* lpObj, const char* lpszTLSPreSharedKeyCiphersuite);

int secureblackbox_webdavserver_gettlsrenegotiationattackpreventionmode(void* lpObj);
int secureblackbox_webdavserver_settlsrenegotiationattackpreventionmode(void* lpObj, int iTLSRenegotiationAttackPreventionMode);

int secureblackbox_webdavserver_gettlsrevocationcheck(void* lpObj);
int secureblackbox_webdavserver_settlsrevocationcheck(void* lpObj, int iTLSRevocationCheck);

int secureblackbox_webdavserver_gettlsssloptions(void* lpObj);
int secureblackbox_webdavserver_settlsssloptions(void* lpObj, int iTLSSSLOptions);

int secureblackbox_webdavserver_gettlstlsmode(void* lpObj);
int secureblackbox_webdavserver_settlstlsmode(void* lpObj, int iTLSTLSMode);

int secureblackbox_webdavserver_gettlsuseextendedmastersecret(void* lpObj);
int secureblackbox_webdavserver_settlsuseextendedmastersecret(void* lpObj, int bTLSUseExtendedMasterSecret);

int secureblackbox_webdavserver_gettlsusesessionresumption(void* lpObj);
int secureblackbox_webdavserver_settlsusesessionresumption(void* lpObj, int bTLSUseSessionResumption);

int secureblackbox_webdavserver_gettlsversions(void* lpObj);
int secureblackbox_webdavserver_settlsversions(void* lpObj, int iTLSVersions);

bool GetTLSAutoValidateCertificates();
int SetTLSAutoValidateCertificates(bool bTLSAutoValidateCertificates);

int GetTLSBaseConfiguration();
int SetTLSBaseConfiguration(int iTLSBaseConfiguration);

QString GetTLSCiphersuites();
int SetTLSCiphersuites(QString qsTLSCiphersuites);

int GetTLSClientAuth();
int SetTLSClientAuth(int iTLSClientAuth);

QString GetTLSECCurves();
int SetTLSECCurves(QString qsTLSECCurves);

QString GetTLSExtensions();
int SetTLSExtensions(QString qsTLSExtensions);

bool GetTLSForceResumeIfDestinationChanges();
int SetTLSForceResumeIfDestinationChanges(bool bTLSForceResumeIfDestinationChanges);

QString GetTLSPreSharedIdentity();
int SetTLSPreSharedIdentity(QString qsTLSPreSharedIdentity);

QString GetTLSPreSharedKey();
int SetTLSPreSharedKey(QString qsTLSPreSharedKey);

QString GetTLSPreSharedKeyCiphersuite();
int SetTLSPreSharedKeyCiphersuite(QString qsTLSPreSharedKeyCiphersuite);

int GetTLSRenegotiationAttackPreventionMode();
int SetTLSRenegotiationAttackPreventionMode(int iTLSRenegotiationAttackPreventionMode);

int GetTLSRevocationCheck();
int SetTLSRevocationCheck(int iTLSRevocationCheck);

int GetTLSSSLOptions();
int SetTLSSSLOptions(int iTLSSSLOptions);

int GetTLSTLSMode();
int SetTLSTLSMode(int iTLSTLSMode);

bool GetTLSUseExtendedMasterSecret();
int SetTLSUseExtendedMasterSecret(bool bTLSUseExtendedMasterSecret);

bool GetTLSUseSessionResumption();
int SetTLSUseSessionResumption(bool bTLSUseSessionResumption);

int GetTLSVersions();
int SetTLSVersions(int iTLSVersions);

int secureblackbox_webdavserver_getusercount(void* lpObj);
int secureblackbox_webdavserver_setusercount(void* lpObj, int iUserCount);

int secureblackbox_webdavserver_getuserassociateddata(void* lpObj, int userindex, char** lpUserAssociatedData, int* lenUserAssociatedData);
int secureblackbox_webdavserver_setuserassociateddata(void* lpObj, int userindex, const char* lpUserAssociatedData, int lenUserAssociatedData);

char* secureblackbox_webdavserver_getuserbasepath(void* lpObj, int userindex);
int secureblackbox_webdavserver_setuserbasepath(void* lpObj, int userindex, const char* lpszUserBasePath);

int secureblackbox_webdavserver_getusercertificate(void* lpObj, int userindex, char** lpUserCertificate, int* lenUserCertificate);
int secureblackbox_webdavserver_setusercertificate(void* lpObj, int userindex, const char* lpUserCertificate, int lenUserCertificate);

char* secureblackbox_webdavserver_getuserdata(void* lpObj, int userindex);
int secureblackbox_webdavserver_setuserdata(void* lpObj, int userindex, const char* lpszUserData);

char* secureblackbox_webdavserver_getuseremail(void* lpObj, int userindex);
int secureblackbox_webdavserver_setuseremail(void* lpObj, int userindex, const char* lpszUserEmail);

int64 secureblackbox_webdavserver_getuserhandle(void* lpObj, int userindex);
int secureblackbox_webdavserver_setuserhandle(void* lpObj, int userindex, int64 lUserHandle);

char* secureblackbox_webdavserver_getuserhashalgorithm(void* lpObj, int userindex);
int secureblackbox_webdavserver_setuserhashalgorithm(void* lpObj, int userindex, const char* lpszUserHashAlgorithm);

int secureblackbox_webdavserver_getuserincomingspeedlimit(void* lpObj, int userindex);
int secureblackbox_webdavserver_setuserincomingspeedlimit(void* lpObj, int userindex, int iUserIncomingSpeedLimit);

int secureblackbox_webdavserver_getuserotpalgorithm(void* lpObj, int userindex);
int secureblackbox_webdavserver_setuserotpalgorithm(void* lpObj, int userindex, int iUserOtpAlgorithm);

int secureblackbox_webdavserver_getuserotplen(void* lpObj, int userindex);
int secureblackbox_webdavserver_setuserotplen(void* lpObj, int userindex, int iUserOTPLen);

int secureblackbox_webdavserver_getuserotpvalue(void* lpObj, int userindex);
int secureblackbox_webdavserver_setuserotpvalue(void* lpObj, int userindex, int iUserOtpValue);

int secureblackbox_webdavserver_getuseroutgoingspeedlimit(void* lpObj, int userindex);
int secureblackbox_webdavserver_setuseroutgoingspeedlimit(void* lpObj, int userindex, int iUserOutgoingSpeedLimit);

char* secureblackbox_webdavserver_getuserpassword(void* lpObj, int userindex);
int secureblackbox_webdavserver_setuserpassword(void* lpObj, int userindex, const char* lpszUserPassword);

int secureblackbox_webdavserver_getusersharedsecret(void* lpObj, int userindex, char** lpUserSharedSecret, int* lenUserSharedSecret);
int secureblackbox_webdavserver_setusersharedsecret(void* lpObj, int userindex, const char* lpUserSharedSecret, int lenUserSharedSecret);

int secureblackbox_webdavserver_getusersshkey(void* lpObj, int userindex, char** lpUserSSHKey, int* lenUserSSHKey);
int secureblackbox_webdavserver_setusersshkey(void* lpObj, int userindex, const char* lpUserSSHKey, int lenUserSSHKey);

char* secureblackbox_webdavserver_getuserusername(void* lpObj, int userindex);
int secureblackbox_webdavserver_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);

char* secureblackbox_webdavserver_getwebsitename(void* lpObj);
int secureblackbox_webdavserver_setwebsitename(void* lpObj, const char* lpszWebsiteName);

QString GetWebsiteName();
int SetWebsiteName(QString qsWebsiteName);

int secureblackbox_webdavserver_cleanup(void* lpObj);

int Cleanup();

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

QString Config(const QString& qsConfigurationString);

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

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

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

int DropClient(qint64 lConnectionId, bool bForced);

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

QByteArray GetClientBuffer(qint64 lConnectionID);

char* secureblackbox_webdavserver_getrequestbytes(void* lpObj, int64 lConnectionId, const char* lpszRequestFilter, int *lpSize);

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

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

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

int secureblackbox_webdavserver_getrequeststream(void* lpObj, int64 lConnectionId, const char* lpszRequestFilter, SecureBlackboxStream* sOutputStream);

int GetRequestStream(qint64 lConnectionId, const QString& qsRequestFilter, SecureBlackboxStream* sOutputStream);

char* secureblackbox_webdavserver_getrequeststring(void* lpObj, int64 lConnectionId, const char* lpszRequestFilter);

QString GetRequestString(qint64 lConnectionId, const QString& qsRequestFilter);

char* secureblackbox_webdavserver_getrequestusername(void* lpObj, int64 lConnectionId);

QString GetRequestUsername(qint64 lConnectionId);

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

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

char* secureblackbox_webdavserver_listclients(void* lpObj);

QString ListClients();

int secureblackbox_webdavserver_pinclient(void* lpObj, int64 lConnectionId);

int PinClient(qint64 lConnectionId);

char* secureblackbox_webdavserver_processgenericrequest(void* lpObj, int64 lConnectionId, const char* lpRequestBytes, int lenRequestBytes, int *lpSize);

QByteArray ProcessGenericRequest(qint64 lConnectionId, QByteArray qbaRequestBytes);

int secureblackbox_webdavserver_processgenericrequeststream(void* lpObj, int64 lConnectionId, const char* lpszRequestHeaders, SecureBlackboxStream* sRequestData, SecureBlackboxStream* sResponseData);

int ProcessGenericRequestStream(qint64 lConnectionId, const QString& qsRequestHeaders, SecureBlackboxStream* sRequestData, SecureBlackboxStream* sResponseData);

int secureblackbox_webdavserver_reset(void* lpObj);

int Reset();

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

int SetClientBuffer(qint64 lConnectionID, QByteArray qbaValue);

int secureblackbox_webdavserver_setclientfileentry(void* lpObj, int64 lConnectionID);

int SetClientFileEntry(qint64 lConnectionID);

int secureblackbox_webdavserver_setresponsebytes(void* lpObj, int64 lConnectionId, const char* lpBytes, int lenBytes, const char* lpszContentType, const char* lpszResponseFilter);

int SetResponseBytes(qint64 lConnectionId, QByteArray qbaBytes, const QString& qsContentType, const QString& qsResponseFilter);

int secureblackbox_webdavserver_setresponsefile(void* lpObj, int64 lConnectionId, const char* lpszFileName, const char* lpszContentType, const char* lpszResponseFilter);

int SetResponseFile(qint64 lConnectionId, const QString& qsFileName, const QString& qsContentType, const QString& qsResponseFilter);

int secureblackbox_webdavserver_setresponseheader(void* lpObj, int64 lConnectionId, const char* lpszHeaderName, const char* lpszValue);

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

int secureblackbox_webdavserver_setresponsestatus(void* lpObj, int64 lConnectionId, int iStatusCode);

int SetResponseStatus(qint64 lConnectionId, int iStatusCode);

int secureblackbox_webdavserver_setresponsestream(void* lpObj, int64 lConnectionId, SecureBlackboxStream* sDataStream, int bCloseStream, const char* lpszContentType, const char* lpszResponseFilter);

int SetResponseStream(qint64 lConnectionId, SecureBlackboxStream* sDataStream, bool bCloseStream, const QString& qsContentType, const QString& qsResponseFilter);

int secureblackbox_webdavserver_setresponsestring(void* lpObj, int64 lConnectionId, const char* lpszDataStr, const char* lpszContentType, const char* lpszResponseFilter);

int SetResponseString(qint64 lConnectionId, const QString& qsDataStr, const QString& qsContentType, const QString& qsResponseFilter);

int secureblackbox_webdavserver_start(void* lpObj);

int Start();

int secureblackbox_webdavserver_stop(void* lpObj);

int Stop();

#define EID_WEBDAVSERVER_ACCEPT 1

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

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

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

#define EID_WEBDAVSERVER_AFTERBROWSE 2

virtual INT SECUREBLACKBOX_CALL FireAfterBrowse(LONG64 &lConnectionID, LPSTR &lpszPath, INT &iOperationStatus);

class WebDAVServerAfterBrowseEventParams {
public:
  qint64 ConnectionID();

  const QString &Path();

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

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

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

// Or, subclass WebDAVServer and override this emitter function.
virtual int FireAfterBrowse(WebDAVServerAfterBrowseEventParams *e) {...}

#define EID_WEBDAVSERVER_AFTERCOPYOBJECT 3

virtual INT SECUREBLACKBOX_CALL FireAfterCopyObject(LONG64 &lConnectionID, LPSTR &lpszOldPath, LPSTR &lpszNewPath, INT &iOperationStatus);

class WebDAVServerAfterCopyObjectEventParams {
public:
  qint64 ConnectionID();

  const QString &OldPath();

  const QString &NewPath();

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

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

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

// Or, subclass WebDAVServer and override this emitter function.
virtual int FireAfterCopyObject(WebDAVServerAfterCopyObjectEventParams *e) {...}

#define EID_WEBDAVSERVER_AFTERCREATECALENDAR 4

virtual INT SECUREBLACKBOX_CALL FireAfterCreateCalendar(LONG64 &lConnectionID, LPSTR &lpszPath, INT &iOperationStatus);

class WebDAVServerAfterCreateCalendarEventParams {
public:
  qint64 ConnectionID();

  const QString &Path();

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

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

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

// Or, subclass WebDAVServer and override this emitter function.
virtual int FireAfterCreateCalendar(WebDAVServerAfterCreateCalendarEventParams *e) {...}

#define EID_WEBDAVSERVER_AFTERCREATECOLLECTION 5

virtual INT SECUREBLACKBOX_CALL FireAfterCreateCollection(LONG64 &lConnectionID, LPSTR &lpszPath, INT &iOperationStatus);

class WebDAVServerAfterCreateCollectionEventParams {
public:
  qint64 ConnectionID();

  const QString &Path();

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

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

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

// Or, subclass WebDAVServer and override this emitter function.
virtual int FireAfterCreateCollection(WebDAVServerAfterCreateCollectionEventParams *e) {...}

#define EID_WEBDAVSERVER_AFTERCUSTOMREQUEST 6

virtual INT SECUREBLACKBOX_CALL FireAfterCustomRequest(LONG64 &lConnectionID, LPSTR &lpszRequestMethod, LPSTR &lpszPath, INT &iOperationStatus);

class WebDAVServerAfterCustomRequestEventParams {
public:
  qint64 ConnectionID();

  const QString &RequestMethod();

  const QString &Path();

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

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

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

// Or, subclass WebDAVServer and override this emitter function.
virtual int FireAfterCustomRequest(WebDAVServerAfterCustomRequestEventParams *e) {...}

#define EID_WEBDAVSERVER_AFTERLOCKOBJECT 7

virtual INT SECUREBLACKBOX_CALL FireAfterLockObject(LONG64 &lConnectionID, LPSTR &lpszPath, INT &iOperationStatus);

class WebDAVServerAfterLockObjectEventParams {
public:
  qint64 ConnectionID();

  const QString &Path();

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

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

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

// Or, subclass WebDAVServer and override this emitter function.
virtual int FireAfterLockObject(WebDAVServerAfterLockObjectEventParams *e) {...}

#define EID_WEBDAVSERVER_AFTERREFRESHLOCK 8

virtual INT SECUREBLACKBOX_CALL FireAfterRefreshLock(LONG64 &lConnectionID, LPSTR &lpszPath, INT &iOperationStatus);

class WebDAVServerAfterRefreshLockEventParams {
public:
  qint64 ConnectionID();

  const QString &Path();

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

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

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

// Or, subclass WebDAVServer and override this emitter function.
virtual int FireAfterRefreshLock(WebDAVServerAfterRefreshLockEventParams *e) {...}

#define EID_WEBDAVSERVER_AFTERREMOVEOBJECT 9

virtual INT SECUREBLACKBOX_CALL FireAfterRemoveObject(LONG64 &lConnectionID, LPSTR &lpszPath, INT &iOperationStatus);

class WebDAVServerAfterRemoveObjectEventParams {
public:
  qint64 ConnectionID();

  const QString &Path();

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

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

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

// Or, subclass WebDAVServer and override this emitter function.
virtual int FireAfterRemoveObject(WebDAVServerAfterRemoveObjectEventParams *e) {...}

#define EID_WEBDAVSERVER_AFTERRENAMEOBJECT 10

virtual INT SECUREBLACKBOX_CALL FireAfterRenameObject(LONG64 &lConnectionID, LPSTR &lpszOldPath, LPSTR &lpszNewPath, INT &iOperationStatus);

class WebDAVServerAfterRenameObjectEventParams {
public:
  qint64 ConnectionID();

  const QString &OldPath();

  const QString &NewPath();

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

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

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

// Or, subclass WebDAVServer and override this emitter function.
virtual int FireAfterRenameObject(WebDAVServerAfterRenameObjectEventParams *e) {...}

#define EID_WEBDAVSERVER_AFTERSETATTRIBUTES 11

virtual INT SECUREBLACKBOX_CALL FireAfterSetAttributes(LONG64 &lConnectionID, LPSTR &lpszPath, INT &iOperationStatus);

class WebDAVServerAfterSetAttributesEventParams {
public:
  qint64 ConnectionID();

  const QString &Path();

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

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

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

// Or, subclass WebDAVServer and override this emitter function.
virtual int FireAfterSetAttributes(WebDAVServerAfterSetAttributesEventParams *e) {...}

#define EID_WEBDAVSERVER_AFTERUNLOCKOBJECT 12

virtual INT SECUREBLACKBOX_CALL FireAfterUnlockObject(LONG64 &lConnectionID, LPSTR &lpszPath, INT &iOperationStatus);

class WebDAVServerAfterUnlockObjectEventParams {
public:
  qint64 ConnectionID();

  const QString &Path();

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

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

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

// Or, subclass WebDAVServer and override this emitter function.
virtual int FireAfterUnlockObject(WebDAVServerAfterUnlockObjectEventParams *e) {...}

#define EID_WEBDAVSERVER_AUTHATTEMPT 13

virtual INT SECUREBLACKBOX_CALL FireAuthAttempt(LONG64 &lConnectionID, LPSTR &lpszHTTPMethod, LPSTR &lpszURI, LPSTR &lpszAuthMethod, LPSTR &lpszUsername, LPSTR &lpszPassword, BOOL &bAllow);

class WebDAVServerAuthAttemptEventParams {
public:
  qint64 ConnectionID();

  const QString &HTTPMethod();

  const QString &URI();

  const QString &AuthMethod();

  const QString &Username();

  const QString &Password();

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

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

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

// Or, subclass WebDAVServer and override this emitter function.
virtual int FireAuthAttempt(WebDAVServerAuthAttemptEventParams *e) {...}

#define EID_WEBDAVSERVER_BEFOREBROWSE 14

virtual INT SECUREBLACKBOX_CALL FireBeforeBrowse(LONG64 &lConnectionID, LPSTR &lpszPath, INT &iAction);

class WebDAVServerBeforeBrowseEventParams {
public:
  qint64 ConnectionID();

  const QString &Path();

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

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

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

// Or, subclass WebDAVServer and override this emitter function.
virtual int FireBeforeBrowse(WebDAVServerBeforeBrowseEventParams *e) {...}

#define EID_WEBDAVSERVER_BEFORECOPYOBJECT 15

virtual INT SECUREBLACKBOX_CALL FireBeforeCopyObject(LONG64 &lConnectionID, LPSTR &lpszOldPath, LPSTR &lpszNewPath, INT &iAction);

class WebDAVServerBeforeCopyObjectEventParams {
public:
  qint64 ConnectionID();

  const QString &OldPath();

  const QString &NewPath();

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

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

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

// Or, subclass WebDAVServer and override this emitter function.
virtual int FireBeforeCopyObject(WebDAVServerBeforeCopyObjectEventParams *e) {...}

#define EID_WEBDAVSERVER_BEFORECREATECALENDAR 16

virtual INT SECUREBLACKBOX_CALL FireBeforeCreateCalendar(LONG64 &lConnectionID, LPSTR &lpszPath, INT &iAction);

class WebDAVServerBeforeCreateCalendarEventParams {
public:
  qint64 ConnectionID();

  const QString &Path();

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

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

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

// Or, subclass WebDAVServer and override this emitter function.
virtual int FireBeforeCreateCalendar(WebDAVServerBeforeCreateCalendarEventParams *e) {...}

#define EID_WEBDAVSERVER_BEFORECREATECOLLECTION 17

virtual INT SECUREBLACKBOX_CALL FireBeforeCreateCollection(LONG64 &lConnectionID, LPSTR &lpszPath, INT &iAction);

class WebDAVServerBeforeCreateCollectionEventParams {
public:
  qint64 ConnectionID();

  const QString &Path();

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

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

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

// Or, subclass WebDAVServer and override this emitter function.
virtual int FireBeforeCreateCollection(WebDAVServerBeforeCreateCollectionEventParams *e) {...}

#define EID_WEBDAVSERVER_BEFORECUSTOMREQUEST 18

virtual INT SECUREBLACKBOX_CALL FireBeforeCustomRequest(LONG64 &lConnectionID, LPSTR &lpszRequestMethod, LPSTR &lpszPath, INT &iAction);

class WebDAVServerBeforeCustomRequestEventParams {
public:
  qint64 ConnectionID();

  const QString &RequestMethod();

  const QString &Path();

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

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

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

// Or, subclass WebDAVServer and override this emitter function.
virtual int FireBeforeCustomRequest(WebDAVServerBeforeCustomRequestEventParams *e) {...}

#define EID_WEBDAVSERVER_BEFOREDOWNLOADOBJECT 19

virtual INT SECUREBLACKBOX_CALL FireBeforeDownloadObject(LONG64 &lConnectionID, LPSTR &lpszPath, INT &iAction);

class WebDAVServerBeforeDownloadObjectEventParams {
public:
  qint64 ConnectionID();

  const QString &Path();

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

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

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

// Or, subclass WebDAVServer and override this emitter function.
virtual int FireBeforeDownloadObject(WebDAVServerBeforeDownloadObjectEventParams *e) {...}

#define EID_WEBDAVSERVER_BEFORELOCKOBJECT 20

virtual INT SECUREBLACKBOX_CALL FireBeforeLockObject(LONG64 &lConnectionID, LPSTR &lpszPath, INT &iAction);

class WebDAVServerBeforeLockObjectEventParams {
public:
  qint64 ConnectionID();

  const QString &Path();

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

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

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

// Or, subclass WebDAVServer and override this emitter function.
virtual int FireBeforeLockObject(WebDAVServerBeforeLockObjectEventParams *e) {...}

#define EID_WEBDAVSERVER_BEFOREREFRESHLOCK 21

virtual INT SECUREBLACKBOX_CALL FireBeforeRefreshLock(LONG64 &lConnectionID, LPSTR &lpszPath, INT &iAction);

class WebDAVServerBeforeRefreshLockEventParams {
public:
  qint64 ConnectionID();

  const QString &Path();

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

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

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

// Or, subclass WebDAVServer and override this emitter function.
virtual int FireBeforeRefreshLock(WebDAVServerBeforeRefreshLockEventParams *e) {...}

#define EID_WEBDAVSERVER_BEFOREREMOVEOBJECT 22

virtual INT SECUREBLACKBOX_CALL FireBeforeRemoveObject(LONG64 &lConnectionID, LPSTR &lpszPath, INT &iAction);

class WebDAVServerBeforeRemoveObjectEventParams {
public:
  qint64 ConnectionID();

  const QString &Path();

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

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

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

// Or, subclass WebDAVServer and override this emitter function.
virtual int FireBeforeRemoveObject(WebDAVServerBeforeRemoveObjectEventParams *e) {...}

#define EID_WEBDAVSERVER_BEFORERENAMEOBJECT 23

virtual INT SECUREBLACKBOX_CALL FireBeforeRenameObject(LONG64 &lConnectionID, LPSTR &lpszOldPath, LPSTR &lpszNewPath, INT &iAction);

class WebDAVServerBeforeRenameObjectEventParams {
public:
  qint64 ConnectionID();

  const QString &OldPath();

  const QString &NewPath();

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

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

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

// Or, subclass WebDAVServer and override this emitter function.
virtual int FireBeforeRenameObject(WebDAVServerBeforeRenameObjectEventParams *e) {...}

#define EID_WEBDAVSERVER_BEFOREREQUEST 24

virtual INT SECUREBLACKBOX_CALL FireBeforeRequest(LONG64 &lConnectionID, LPSTR &lpszHTTPMethod, LPSTR &lpszURL, BOOL &bAccept);

class WebDAVServerBeforeRequestEventParams {
public:
  qint64 ConnectionID();

  const QString &HTTPMethod();

  const QString &URL();

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

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

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

// Or, subclass WebDAVServer and override this emitter function.
virtual int FireBeforeRequest(WebDAVServerBeforeRequestEventParams *e) {...}

#define EID_WEBDAVSERVER_BEFORESETATTRIBUTES 25

virtual INT SECUREBLACKBOX_CALL FireBeforeSetAttributes(LONG64 &lConnectionID, LPSTR &lpszPath, INT &iAction);

class WebDAVServerBeforeSetAttributesEventParams {
public:
  qint64 ConnectionID();

  const QString &Path();

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

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

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

// Or, subclass WebDAVServer and override this emitter function.
virtual int FireBeforeSetAttributes(WebDAVServerBeforeSetAttributesEventParams *e) {...}

#define EID_WEBDAVSERVER_BEFOREUNLOCKOBJECT 26

virtual INT SECUREBLACKBOX_CALL FireBeforeUnlockObject(LONG64 &lConnectionID, LPSTR &lpszPath, INT &iAction);

class WebDAVServerBeforeUnlockObjectEventParams {
public:
  qint64 ConnectionID();

  const QString &Path();

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

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

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

// Or, subclass WebDAVServer and override this emitter function.
virtual int FireBeforeUnlockObject(WebDAVServerBeforeUnlockObjectEventParams *e) {...}

#define EID_WEBDAVSERVER_BEFOREUPLOADOBJECT 27

virtual INT SECUREBLACKBOX_CALL FireBeforeUploadObject(LONG64 &lConnectionID, LPSTR &lpszPath, INT &iAction);

class WebDAVServerBeforeUploadObjectEventParams {
public:
  qint64 ConnectionID();

  const QString &Path();

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

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

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

// Or, subclass WebDAVServer and override this emitter function.
virtual int FireBeforeUploadObject(WebDAVServerBeforeUploadObjectEventParams *e) {...}

#define EID_WEBDAVSERVER_CLEARATTRIBUTE 28

virtual INT SECUREBLACKBOX_CALL FireClearAttribute(LONG64 &lConnectionID, LPSTR &lpszPath, LPSTR &lpszNS, LPSTR &lpszName, INT &iOperationStatus);

class WebDAVServerClearAttributeEventParams {
public:
  qint64 ConnectionID();

  const QString &Path();

  const QString &NS();

  const QString &Name();

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

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

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

// Or, subclass WebDAVServer and override this emitter function.
virtual int FireClearAttribute(WebDAVServerClearAttributeEventParams *e) {...}

#define EID_WEBDAVSERVER_CONNECT 29

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

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

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

#define EID_WEBDAVSERVER_COPYOBJECT 30

virtual INT SECUREBLACKBOX_CALL FireCopyObject(LONG64 &lConnectionID, LPSTR &lpszOldPath, LPSTR &lpszNewPath, BOOL &bOverwrite, INT &iDepth, INT &iOperationStatus);

class WebDAVServerCopyObjectEventParams {
public:
  qint64 ConnectionID();

  const QString &OldPath();

  const QString &NewPath();

  bool Overwrite();

  int Depth();

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

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

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

// Or, subclass WebDAVServer and override this emitter function.
virtual int FireCopyObject(WebDAVServerCopyObjectEventParams *e) {...}

#define EID_WEBDAVSERVER_CREATECALENDAR 31

virtual INT SECUREBLACKBOX_CALL FireCreateCalendar(LONG64 &lConnectionID, LPSTR &lpszPath, INT &iOperationStatus);

class WebDAVServerCreateCalendarEventParams {
public:
  qint64 ConnectionID();

  const QString &Path();

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

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

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

// Or, subclass WebDAVServer and override this emitter function.
virtual int FireCreateCalendar(WebDAVServerCreateCalendarEventParams *e) {...}

#define EID_WEBDAVSERVER_CREATECOLLECTION 32

virtual INT SECUREBLACKBOX_CALL FireCreateCollection(LONG64 &lConnectionID, LPSTR &lpszPath, INT &iOperationStatus);

class WebDAVServerCreateCollectionEventParams {
public:
  qint64 ConnectionID();

  const QString &Path();

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

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

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

// Or, subclass WebDAVServer and override this emitter function.
virtual int FireCreateCollection(WebDAVServerCreateCollectionEventParams *e) {...}

#define EID_WEBDAVSERVER_CUSTOMREQUEST 33

virtual INT SECUREBLACKBOX_CALL FireCustomRequest(LONG64 &lConnectionID, LPSTR &lpszRequestMethod, LPSTR &lpszPath, INT &iOperationStatus);

class WebDAVServerCustomRequestEventParams {
public:
  qint64 ConnectionID();

  const QString &RequestMethod();

  const QString &Path();

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

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

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

// Or, subclass WebDAVServer and override this emitter function.
virtual int FireCustomRequest(WebDAVServerCustomRequestEventParams *e) {...}

#define EID_WEBDAVSERVER_DATA 34

virtual INT SECUREBLACKBOX_CALL FireData(LONG64 &lConnectionID, LPSTR &lpBuffer, INT &lenBuffer);

class WebDAVServerDataEventParams {
public:
  qint64 ConnectionID();

  const QByteArray &Buffer();

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

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

// Or, subclass WebDAVServer and override this emitter function.
virtual int FireData(WebDAVServerDataEventParams *e) {...}

#define EID_WEBDAVSERVER_DISCONNECT 35

virtual INT SECUREBLACKBOX_CALL FireDisconnect(LONG64 &lConnectionID);

class WebDAVServerDisconnectEventParams {
public:
  qint64 ConnectionID();

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

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

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

#define EID_WEBDAVSERVER_DOWNLOADOBJECT 36

virtual INT SECUREBLACKBOX_CALL FireDownloadObject(LONG64 &lConnectionID, LPSTR &lpszPath, LONG64 &lRestartAt, INT &iOperationStatus);

class WebDAVServerDownloadObjectEventParams {
public:
  qint64 ConnectionID();

  const QString &Path();

  qint64 RestartAt();

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

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

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

// Or, subclass WebDAVServer and override this emitter function.
virtual int FireDownloadObject(WebDAVServerDownloadObjectEventParams *e) {...}