int ipworksedi_as1sender_getattachmentcount(void* lpObj);
int ipworksedi_as1sender_setattachmentcount(void* lpObj, int iAttachmentCount);

char* ipworksedi_as1sender_getattachmentcontenttype(void* lpObj, int attachmentindex);
int ipworksedi_as1sender_setattachmentcontenttype(void* lpObj, int attachmentindex, const char* lpszAttachmentContentType);

int ipworksedi_as1sender_getattachmentdata(void* lpObj, int attachmentindex, char** lpAttachmentData, int* lenAttachmentData);
int ipworksedi_as1sender_setattachmentdata(void* lpObj, int attachmentindex, const char* lpAttachmentData, int lenAttachmentData);

char* ipworksedi_as1sender_getattachmentfilename(void* lpObj, int attachmentindex);
int ipworksedi_as1sender_setattachmentfilename(void* lpObj, int attachmentindex, const char* lpszAttachmentFileName);

char* ipworksedi_as1sender_getattachmentheaders(void* lpObj, int attachmentindex);
int ipworksedi_as1sender_setattachmentheaders(void* lpObj, int attachmentindex, const char* lpszAttachmentHeaders);

char* ipworksedi_as1sender_getattachmentname(void* lpObj, int attachmentindex);
int ipworksedi_as1sender_setattachmentname(void* lpObj, int attachmentindex, const char* lpszAttachmentName);

int getAttachmentCount();
int setAttachmentCount(int iAttachmentCount);

QString getAttachmentContentType(int iAttachmentIndex);
int setAttachmentContentType(int iAttachmentIndex, QString qsAttachmentContentType);

QByteArray getAttachmentData(int iAttachmentIndex);
int setAttachmentData(int iAttachmentIndex, QByteArray qbaAttachmentData);

QString getAttachmentFileName(int iAttachmentIndex);
int setAttachmentFileName(int iAttachmentIndex, QString qsAttachmentFileName);

QString getAttachmentHeaders(int iAttachmentIndex);
int setAttachmentHeaders(int iAttachmentIndex, QString qsAttachmentHeaders);

QString getAttachmentName(int iAttachmentIndex);
int setAttachmentName(int iAttachmentIndex, QString qsAttachmentName);

int ipworksedi_as1sender_getcompressionformat(void* lpObj);
int ipworksedi_as1sender_setcompressionformat(void* lpObj, int iCompressionFormat);

int getCompressionFormat();
int setCompressionFormat(int iCompressionFormat);

int ipworksedi_as1sender_getconnected(void* lpObj);

bool getConnected();

int ipworksedi_as1sender_getedidata(void* lpObj, char** lpEDIData, int* lenEDIData);
int ipworksedi_as1sender_setedidata(void* lpObj, const char* lpEDIData, int lenEDIData);

char* ipworksedi_as1sender_geteditype(void* lpObj);
int ipworksedi_as1sender_seteditype(void* lpObj, const char* lpszEDIType);

char* ipworksedi_as1sender_getediname(void* lpObj);
int ipworksedi_as1sender_setediname(void* lpObj, const char* lpszEDIName);

char* ipworksedi_as1sender_getedifilename(void* lpObj);
int ipworksedi_as1sender_setedifilename(void* lpObj, const char* lpszEDIFileName);

QByteArray getEDIData();
int setEDIData(QByteArray qbaEDIData);

QString getEDIType();
int setEDIType(QString qsEDIType);

QString getEDIName();
int setEDIName(QString qsEDIName);

QString getEDIFileName();
int setEDIFileName(QString qsEDIFileName);

char* ipworksedi_as1sender_getencryptionalgorithm(void* lpObj);
int ipworksedi_as1sender_setencryptionalgorithm(void* lpObj, const char* lpszEncryptionAlgorithm);

QString getEncryptionAlgorithm();
int setEncryptionAlgorithm(QString qsEncryptionAlgorithm);

int ipworksedi_as1sender_getfirewallautodetect(void* lpObj);
int ipworksedi_as1sender_setfirewallautodetect(void* lpObj, int bFirewallAutoDetect);

int ipworksedi_as1sender_getfirewalltype(void* lpObj);
int ipworksedi_as1sender_setfirewalltype(void* lpObj, int iFirewallType);

char* ipworksedi_as1sender_getfirewallhost(void* lpObj);
int ipworksedi_as1sender_setfirewallhost(void* lpObj, const char* lpszFirewallHost);

char* ipworksedi_as1sender_getfirewallpassword(void* lpObj);
int ipworksedi_as1sender_setfirewallpassword(void* lpObj, const char* lpszFirewallPassword);

int ipworksedi_as1sender_getfirewallport(void* lpObj);
int ipworksedi_as1sender_setfirewallport(void* lpObj, int iFirewallPort);

char* ipworksedi_as1sender_getfirewalluser(void* lpObj);
int ipworksedi_as1sender_setfirewalluser(void* lpObj, const char* lpszFirewallUser);

bool getFirewallAutoDetect();
int setFirewallAutoDetect(bool bFirewallAutoDetect);

int getFirewallType();
int setFirewallType(int iFirewallType);

QString getFirewallHost();
int setFirewallHost(QString qsFirewallHost);

QString getFirewallPassword();
int setFirewallPassword(QString qsFirewallPassword);

int getFirewallPort();
int setFirewallPort(int iFirewallPort);

QString getFirewallUser();
int setFirewallUser(QString qsFirewallUser);

char* ipworksedi_as1sender_getfrom(void* lpObj);
int ipworksedi_as1sender_setfrom(void* lpObj, const char* lpszFrom);

QString getFrom();
int setFrom(QString qsFrom);

char* ipworksedi_as1sender_getlocalhost(void* lpObj);
int ipworksedi_as1sender_setlocalhost(void* lpObj, const char* lpszLocalHost);

QString getLocalHost();
int setLocalHost(QString qsLocalHost);

char* ipworksedi_as1sender_getlogdirectory(void* lpObj);
int ipworksedi_as1sender_setlogdirectory(void* lpObj, const char* lpszLogDirectory);

QString getLogDirectory();
int setLogDirectory(QString qsLogDirectory);

char* ipworksedi_as1sender_getlogfile(void* lpObj);

QString getLogFile();

char* ipworksedi_as1sender_getmailmessagecc(void* lpObj);

QString getMailMessageCc();

int ipworksedi_as1sender_getmailmessagecount(void* lpObj);

int getMailMessageCount();

char* ipworksedi_as1sender_getmailmessagedate(void* lpObj);

QString getMailMessageDate();

char* ipworksedi_as1sender_getmailmessagefrom(void* lpObj);

QString getMailMessageFrom();

char* ipworksedi_as1sender_getmailmessageheaders(void* lpObj);

QString getMailMessageHeaders();

int ipworksedi_as1sender_getmailmessagenumber(void* lpObj);
int ipworksedi_as1sender_setmailmessagenumber(void* lpObj, int iMailMessageNumber);

int getMailMessageNumber();
int setMailMessageNumber(int iMailMessageNumber);

char* ipworksedi_as1sender_getmailmessagereplyto(void* lpObj);

QString getMailMessageReplyTo();

char* ipworksedi_as1sender_getmailmessagesubject(void* lpObj);

QString getMailMessageSubject();

char* ipworksedi_as1sender_getmailmessagetext(void* lpObj);

QString getMailMessageText();

char* ipworksedi_as1sender_getmailmessageto(void* lpObj);

QString getMailMessageTo();

char* ipworksedi_as1sender_getmailserver(void* lpObj);
int ipworksedi_as1sender_setmailserver(void* lpObj, const char* lpszMailServer);

QString getMailServer();
int setMailServer(QString qsMailServer);

char* ipworksedi_as1sender_getmdnoptions(void* lpObj);
int ipworksedi_as1sender_setmdnoptions(void* lpObj, const char* lpszMDNOptions);

QString getMDNOptions();
int setMDNOptions(QString qsMDNOptions);

int ipworksedi_as1sender_getmdnreceiptcontent(void* lpObj, char** lpMDNReceiptContent, int* lenMDNReceiptContent);
int ipworksedi_as1sender_setmdnreceiptcontent(void* lpObj, const char* lpMDNReceiptContent, int lenMDNReceiptContent);

int ipworksedi_as1sender_getmdnreceiptheadercount(void* lpObj);

char* ipworksedi_as1sender_getmdnreceiptheaderfield(void* lpObj);

int ipworksedi_as1sender_getmdnreceiptheaderindex(void* lpObj);
int ipworksedi_as1sender_setmdnreceiptheaderindex(void* lpObj, int iMDNReceiptHeaderIndex);

char* ipworksedi_as1sender_getmdnreceiptheaders(void* lpObj);
int ipworksedi_as1sender_setmdnreceiptheaders(void* lpObj, const char* lpszMDNReceiptHeaders);

char* ipworksedi_as1sender_getmdnreceiptheadervalue(void* lpObj);

char* ipworksedi_as1sender_getmdnreceiptmdn(void* lpObj);

char* ipworksedi_as1sender_getmdnreceiptmessage(void* lpObj);

char* ipworksedi_as1sender_getmdnreceiptmicvalue(void* lpObj);

char* ipworksedi_as1sender_getmdnreceiptsigningprotocol(void* lpObj);

QByteArray getMDNReceiptContent();
int setMDNReceiptContent(QByteArray qbaMDNReceiptContent);

int getMDNReceiptHeaderCount();

QString getMDNReceiptHeaderField();

int getMDNReceiptHeaderIndex();
int setMDNReceiptHeaderIndex(int iMDNReceiptHeaderIndex);

QString getMDNReceiptHeaders();
int setMDNReceiptHeaders(QString qsMDNReceiptHeaders);

QString getMDNReceiptHeaderValue();

QString getMDNReceiptMDN();

QString getMDNReceiptMessage();

QString getMDNReceiptMICValue();

QString getMDNReceiptSigningProtocol();

char* ipworksedi_as1sender_getmdnto(void* lpObj);
int ipworksedi_as1sender_setmdnto(void* lpObj, const char* lpszMDNTo);

QString getMDNTo();
int setMDNTo(QString qsMDNTo);

char* ipworksedi_as1sender_getmessageid(void* lpObj);
int ipworksedi_as1sender_setmessageid(void* lpObj, const char* lpszMessageId);

QString getMessageId();
int setMessageId(QString qsMessageId);

char* ipworksedi_as1sender_getoriginalcontentmic(void* lpObj);
int ipworksedi_as1sender_setoriginalcontentmic(void* lpObj, const char* lpszOriginalContentMIC);

QString getOriginalContentMIC();
int setOriginalContentMIC(QString qsOriginalContentMIC);

char* ipworksedi_as1sender_getpassword(void* lpObj);
int ipworksedi_as1sender_setpassword(void* lpObj, const char* lpszPassword);

QString getPassword();
int setPassword(QString qsPassword);

char* ipworksedi_as1sender_getreceiptsignercerteffectivedate(void* lpObj);

char* ipworksedi_as1sender_getreceiptsignercertexpirationdate(void* lpObj);

char* ipworksedi_as1sender_getreceiptsignercertextendedkeyusage(void* lpObj);

char* ipworksedi_as1sender_getreceiptsignercertfingerprint(void* lpObj);

char* ipworksedi_as1sender_getreceiptsignercertfingerprintsha1(void* lpObj);

char* ipworksedi_as1sender_getreceiptsignercertfingerprintsha256(void* lpObj);

char* ipworksedi_as1sender_getreceiptsignercertissuer(void* lpObj);

char* ipworksedi_as1sender_getreceiptsignercertprivatekey(void* lpObj);

int ipworksedi_as1sender_getreceiptsignercertprivatekeyavailable(void* lpObj);

char* ipworksedi_as1sender_getreceiptsignercertprivatekeycontainer(void* lpObj);

char* ipworksedi_as1sender_getreceiptsignercertpublickey(void* lpObj);

char* ipworksedi_as1sender_getreceiptsignercertpublickeyalgorithm(void* lpObj);

int ipworksedi_as1sender_getreceiptsignercertpublickeylength(void* lpObj);

char* ipworksedi_as1sender_getreceiptsignercertserialnumber(void* lpObj);

char* ipworksedi_as1sender_getreceiptsignercertsignaturealgorithm(void* lpObj);

int ipworksedi_as1sender_getreceiptsignercertstore(void* lpObj, char** lpReceiptSignerCertStore, int* lenReceiptSignerCertStore);
int ipworksedi_as1sender_setreceiptsignercertstore(void* lpObj, const char* lpReceiptSignerCertStore, int lenReceiptSignerCertStore);

char* ipworksedi_as1sender_getreceiptsignercertstorepassword(void* lpObj);
int ipworksedi_as1sender_setreceiptsignercertstorepassword(void* lpObj, const char* lpszReceiptSignerCertStorePassword);

int ipworksedi_as1sender_getreceiptsignercertstoretype(void* lpObj);
int ipworksedi_as1sender_setreceiptsignercertstoretype(void* lpObj, int iReceiptSignerCertStoreType);

char* ipworksedi_as1sender_getreceiptsignercertsubjectaltnames(void* lpObj);

char* ipworksedi_as1sender_getreceiptsignercertthumbprintmd5(void* lpObj);

char* ipworksedi_as1sender_getreceiptsignercertthumbprintsha1(void* lpObj);

char* ipworksedi_as1sender_getreceiptsignercertthumbprintsha256(void* lpObj);

char* ipworksedi_as1sender_getreceiptsignercertusage(void* lpObj);

int ipworksedi_as1sender_getreceiptsignercertusageflags(void* lpObj);

char* ipworksedi_as1sender_getreceiptsignercertversion(void* lpObj);

char* ipworksedi_as1sender_getreceiptsignercertsubject(void* lpObj);
int ipworksedi_as1sender_setreceiptsignercertsubject(void* lpObj, const char* lpszReceiptSignerCertSubject);

int ipworksedi_as1sender_getreceiptsignercertencoded(void* lpObj, char** lpReceiptSignerCertEncoded, int* lenReceiptSignerCertEncoded);
int ipworksedi_as1sender_setreceiptsignercertencoded(void* lpObj, const char* lpReceiptSignerCertEncoded, int lenReceiptSignerCertEncoded);

QString getReceiptSignerCertEffectiveDate();

QString getReceiptSignerCertExpirationDate();

QString getReceiptSignerCertExtendedKeyUsage();

QString getReceiptSignerCertFingerprint();

QString getReceiptSignerCertFingerprintSHA1();

QString getReceiptSignerCertFingerprintSHA256();

QString getReceiptSignerCertIssuer();

QString getReceiptSignerCertPrivateKey();

bool getReceiptSignerCertPrivateKeyAvailable();

QString getReceiptSignerCertPrivateKeyContainer();

QString getReceiptSignerCertPublicKey();

QString getReceiptSignerCertPublicKeyAlgorithm();

int getReceiptSignerCertPublicKeyLength();

QString getReceiptSignerCertSerialNumber();

QString getReceiptSignerCertSignatureAlgorithm();

QByteArray getReceiptSignerCertStore();
int setReceiptSignerCertStore(QByteArray qbaReceiptSignerCertStore);

QString getReceiptSignerCertStorePassword();
int setReceiptSignerCertStorePassword(QString qsReceiptSignerCertStorePassword);

int getReceiptSignerCertStoreType();
int setReceiptSignerCertStoreType(int iReceiptSignerCertStoreType);

QString getReceiptSignerCertSubjectAltNames();

QString getReceiptSignerCertThumbprintMD5();

QString getReceiptSignerCertThumbprintSHA1();

QString getReceiptSignerCertThumbprintSHA256();

QString getReceiptSignerCertUsage();

int getReceiptSignerCertUsageFlags();

QString getReceiptSignerCertVersion();

QString getReceiptSignerCertSubject();
int setReceiptSignerCertSubject(QString qsReceiptSignerCertSubject);

QByteArray getReceiptSignerCertEncoded();
int setReceiptSignerCertEncoded(QByteArray qbaReceiptSignerCertEncoded);

int ipworksedi_as1sender_getrecipientcertcount(void* lpObj);
int ipworksedi_as1sender_setrecipientcertcount(void* lpObj, int iRecipientCertCount);

char* ipworksedi_as1sender_getrecipientcerteffectivedate(void* lpObj, int recipientcertindex);

char* ipworksedi_as1sender_getrecipientcertexpirationdate(void* lpObj, int recipientcertindex);

char* ipworksedi_as1sender_getrecipientcertextendedkeyusage(void* lpObj, int recipientcertindex);

char* ipworksedi_as1sender_getrecipientcertfingerprint(void* lpObj, int recipientcertindex);

char* ipworksedi_as1sender_getrecipientcertfingerprintsha1(void* lpObj, int recipientcertindex);

char* ipworksedi_as1sender_getrecipientcertfingerprintsha256(void* lpObj, int recipientcertindex);

char* ipworksedi_as1sender_getrecipientcertissuer(void* lpObj, int recipientcertindex);

char* ipworksedi_as1sender_getrecipientcertprivatekey(void* lpObj, int recipientcertindex);

int ipworksedi_as1sender_getrecipientcertprivatekeyavailable(void* lpObj, int recipientcertindex);

char* ipworksedi_as1sender_getrecipientcertprivatekeycontainer(void* lpObj, int recipientcertindex);

char* ipworksedi_as1sender_getrecipientcertpublickey(void* lpObj, int recipientcertindex);

char* ipworksedi_as1sender_getrecipientcertpublickeyalgorithm(void* lpObj, int recipientcertindex);

int ipworksedi_as1sender_getrecipientcertpublickeylength(void* lpObj, int recipientcertindex);

char* ipworksedi_as1sender_getrecipientcertserialnumber(void* lpObj, int recipientcertindex);

char* ipworksedi_as1sender_getrecipientcertsignaturealgorithm(void* lpObj, int recipientcertindex);

int ipworksedi_as1sender_getrecipientcertstore(void* lpObj, int recipientcertindex, char** lpRecipientCertStore, int* lenRecipientCertStore);
int ipworksedi_as1sender_setrecipientcertstore(void* lpObj, int recipientcertindex, const char* lpRecipientCertStore, int lenRecipientCertStore);

char* ipworksedi_as1sender_getrecipientcertstorepassword(void* lpObj, int recipientcertindex);
int ipworksedi_as1sender_setrecipientcertstorepassword(void* lpObj, int recipientcertindex, const char* lpszRecipientCertStorePassword);

int ipworksedi_as1sender_getrecipientcertstoretype(void* lpObj, int recipientcertindex);
int ipworksedi_as1sender_setrecipientcertstoretype(void* lpObj, int recipientcertindex, int iRecipientCertStoreType);

char* ipworksedi_as1sender_getrecipientcertsubjectaltnames(void* lpObj, int recipientcertindex);

char* ipworksedi_as1sender_getrecipientcertthumbprintmd5(void* lpObj, int recipientcertindex);

char* ipworksedi_as1sender_getrecipientcertthumbprintsha1(void* lpObj, int recipientcertindex);

char* ipworksedi_as1sender_getrecipientcertthumbprintsha256(void* lpObj, int recipientcertindex);

char* ipworksedi_as1sender_getrecipientcertusage(void* lpObj, int recipientcertindex);

int ipworksedi_as1sender_getrecipientcertusageflags(void* lpObj, int recipientcertindex);

char* ipworksedi_as1sender_getrecipientcertversion(void* lpObj, int recipientcertindex);

char* ipworksedi_as1sender_getrecipientcertsubject(void* lpObj, int recipientcertindex);
int ipworksedi_as1sender_setrecipientcertsubject(void* lpObj, int recipientcertindex, const char* lpszRecipientCertSubject);

int ipworksedi_as1sender_getrecipientcertencoded(void* lpObj, int recipientcertindex, char** lpRecipientCertEncoded, int* lenRecipientCertEncoded);
int ipworksedi_as1sender_setrecipientcertencoded(void* lpObj, int recipientcertindex, const char* lpRecipientCertEncoded, int lenRecipientCertEncoded);

int getRecipientCertCount();
int setRecipientCertCount(int iRecipientCertCount);

QString getRecipientCertEffectiveDate(int iRecipientCertIndex);

QString getRecipientCertExpirationDate(int iRecipientCertIndex);

QString getRecipientCertExtendedKeyUsage(int iRecipientCertIndex);

QString getRecipientCertFingerprint(int iRecipientCertIndex);

QString getRecipientCertFingerprintSHA1(int iRecipientCertIndex);

QString getRecipientCertFingerprintSHA256(int iRecipientCertIndex);

QString getRecipientCertIssuer(int iRecipientCertIndex);

QString getRecipientCertPrivateKey(int iRecipientCertIndex);

bool getRecipientCertPrivateKeyAvailable(int iRecipientCertIndex);

QString getRecipientCertPrivateKeyContainer(int iRecipientCertIndex);

QString getRecipientCertPublicKey(int iRecipientCertIndex);

QString getRecipientCertPublicKeyAlgorithm(int iRecipientCertIndex);

int getRecipientCertPublicKeyLength(int iRecipientCertIndex);

QString getRecipientCertSerialNumber(int iRecipientCertIndex);

QString getRecipientCertSignatureAlgorithm(int iRecipientCertIndex);

QByteArray getRecipientCertStore(int iRecipientCertIndex);
int setRecipientCertStore(int iRecipientCertIndex, QByteArray qbaRecipientCertStore);

QString getRecipientCertStorePassword(int iRecipientCertIndex);
int setRecipientCertStorePassword(int iRecipientCertIndex, QString qsRecipientCertStorePassword);

int getRecipientCertStoreType(int iRecipientCertIndex);
int setRecipientCertStoreType(int iRecipientCertIndex, int iRecipientCertStoreType);

QString getRecipientCertSubjectAltNames(int iRecipientCertIndex);

QString getRecipientCertThumbprintMD5(int iRecipientCertIndex);

QString getRecipientCertThumbprintSHA1(int iRecipientCertIndex);

QString getRecipientCertThumbprintSHA256(int iRecipientCertIndex);

QString getRecipientCertUsage(int iRecipientCertIndex);

int getRecipientCertUsageFlags(int iRecipientCertIndex);

QString getRecipientCertVersion(int iRecipientCertIndex);

QString getRecipientCertSubject(int iRecipientCertIndex);
int setRecipientCertSubject(int iRecipientCertIndex, QString qsRecipientCertSubject);

QByteArray getRecipientCertEncoded(int iRecipientCertIndex);
int setRecipientCertEncoded(int iRecipientCertIndex, QByteArray qbaRecipientCertEncoded);

char* ipworksedi_as1sender_getsendto(void* lpObj);
int ipworksedi_as1sender_setsendto(void* lpObj, const char* lpszSendTo);

QString getSendTo();
int setSendTo(QString qsSendTo);

char* ipworksedi_as1sender_getsignaturealgorithm(void* lpObj);
int ipworksedi_as1sender_setsignaturealgorithm(void* lpObj, const char* lpszSignatureAlgorithm);

QString getSignatureAlgorithm();
int setSignatureAlgorithm(QString qsSignatureAlgorithm);

char* ipworksedi_as1sender_getsigningcerteffectivedate(void* lpObj);

char* ipworksedi_as1sender_getsigningcertexpirationdate(void* lpObj);

char* ipworksedi_as1sender_getsigningcertextendedkeyusage(void* lpObj);

char* ipworksedi_as1sender_getsigningcertfingerprint(void* lpObj);

char* ipworksedi_as1sender_getsigningcertfingerprintsha1(void* lpObj);

char* ipworksedi_as1sender_getsigningcertfingerprintsha256(void* lpObj);

char* ipworksedi_as1sender_getsigningcertissuer(void* lpObj);

char* ipworksedi_as1sender_getsigningcertprivatekey(void* lpObj);

int ipworksedi_as1sender_getsigningcertprivatekeyavailable(void* lpObj);

char* ipworksedi_as1sender_getsigningcertprivatekeycontainer(void* lpObj);

char* ipworksedi_as1sender_getsigningcertpublickey(void* lpObj);

char* ipworksedi_as1sender_getsigningcertpublickeyalgorithm(void* lpObj);

int ipworksedi_as1sender_getsigningcertpublickeylength(void* lpObj);

char* ipworksedi_as1sender_getsigningcertserialnumber(void* lpObj);

char* ipworksedi_as1sender_getsigningcertsignaturealgorithm(void* lpObj);

int ipworksedi_as1sender_getsigningcertstore(void* lpObj, char** lpSigningCertStore, int* lenSigningCertStore);
int ipworksedi_as1sender_setsigningcertstore(void* lpObj, const char* lpSigningCertStore, int lenSigningCertStore);

char* ipworksedi_as1sender_getsigningcertstorepassword(void* lpObj);
int ipworksedi_as1sender_setsigningcertstorepassword(void* lpObj, const char* lpszSigningCertStorePassword);

int ipworksedi_as1sender_getsigningcertstoretype(void* lpObj);
int ipworksedi_as1sender_setsigningcertstoretype(void* lpObj, int iSigningCertStoreType);

char* ipworksedi_as1sender_getsigningcertsubjectaltnames(void* lpObj);

char* ipworksedi_as1sender_getsigningcertthumbprintmd5(void* lpObj);

char* ipworksedi_as1sender_getsigningcertthumbprintsha1(void* lpObj);

char* ipworksedi_as1sender_getsigningcertthumbprintsha256(void* lpObj);

char* ipworksedi_as1sender_getsigningcertusage(void* lpObj);

int ipworksedi_as1sender_getsigningcertusageflags(void* lpObj);

char* ipworksedi_as1sender_getsigningcertversion(void* lpObj);

char* ipworksedi_as1sender_getsigningcertsubject(void* lpObj);
int ipworksedi_as1sender_setsigningcertsubject(void* lpObj, const char* lpszSigningCertSubject);

int ipworksedi_as1sender_getsigningcertencoded(void* lpObj, char** lpSigningCertEncoded, int* lenSigningCertEncoded);
int ipworksedi_as1sender_setsigningcertencoded(void* lpObj, const char* lpSigningCertEncoded, int lenSigningCertEncoded);

QString getSigningCertEffectiveDate();

QString getSigningCertExpirationDate();

QString getSigningCertExtendedKeyUsage();

QString getSigningCertFingerprint();

QString getSigningCertFingerprintSHA1();

QString getSigningCertFingerprintSHA256();

QString getSigningCertIssuer();

QString getSigningCertPrivateKey();

bool getSigningCertPrivateKeyAvailable();

QString getSigningCertPrivateKeyContainer();

QString getSigningCertPublicKey();

QString getSigningCertPublicKeyAlgorithm();

int getSigningCertPublicKeyLength();

QString getSigningCertSerialNumber();

QString getSigningCertSignatureAlgorithm();

QByteArray getSigningCertStore();
int setSigningCertStore(QByteArray qbaSigningCertStore);

QString getSigningCertStorePassword();
int setSigningCertStorePassword(QString qsSigningCertStorePassword);

int getSigningCertStoreType();
int setSigningCertStoreType(int iSigningCertStoreType);

QString getSigningCertSubjectAltNames();

QString getSigningCertThumbprintMD5();

QString getSigningCertThumbprintSHA1();

QString getSigningCertThumbprintSHA256();

QString getSigningCertUsage();

int getSigningCertUsageFlags();

QString getSigningCertVersion();

QString getSigningCertSubject();
int setSigningCertSubject(QString qsSigningCertSubject);

QByteArray getSigningCertEncoded();
int setSigningCertEncoded(QByteArray qbaSigningCertEncoded);

char* ipworksedi_as1sender_getsslacceptservercerteffectivedate(void* lpObj);

char* ipworksedi_as1sender_getsslacceptservercertexpirationdate(void* lpObj);

char* ipworksedi_as1sender_getsslacceptservercertextendedkeyusage(void* lpObj);

char* ipworksedi_as1sender_getsslacceptservercertfingerprint(void* lpObj);

char* ipworksedi_as1sender_getsslacceptservercertfingerprintsha1(void* lpObj);

char* ipworksedi_as1sender_getsslacceptservercertfingerprintsha256(void* lpObj);

char* ipworksedi_as1sender_getsslacceptservercertissuer(void* lpObj);

char* ipworksedi_as1sender_getsslacceptservercertprivatekey(void* lpObj);

int ipworksedi_as1sender_getsslacceptservercertprivatekeyavailable(void* lpObj);

char* ipworksedi_as1sender_getsslacceptservercertprivatekeycontainer(void* lpObj);

char* ipworksedi_as1sender_getsslacceptservercertpublickey(void* lpObj);

char* ipworksedi_as1sender_getsslacceptservercertpublickeyalgorithm(void* lpObj);

int ipworksedi_as1sender_getsslacceptservercertpublickeylength(void* lpObj);

char* ipworksedi_as1sender_getsslacceptservercertserialnumber(void* lpObj);

char* ipworksedi_as1sender_getsslacceptservercertsignaturealgorithm(void* lpObj);

int ipworksedi_as1sender_getsslacceptservercertstore(void* lpObj, char** lpSSLAcceptServerCertStore, int* lenSSLAcceptServerCertStore);
int ipworksedi_as1sender_setsslacceptservercertstore(void* lpObj, const char* lpSSLAcceptServerCertStore, int lenSSLAcceptServerCertStore);

char* ipworksedi_as1sender_getsslacceptservercertstorepassword(void* lpObj);
int ipworksedi_as1sender_setsslacceptservercertstorepassword(void* lpObj, const char* lpszSSLAcceptServerCertStorePassword);

int ipworksedi_as1sender_getsslacceptservercertstoretype(void* lpObj);
int ipworksedi_as1sender_setsslacceptservercertstoretype(void* lpObj, int iSSLAcceptServerCertStoreType);

char* ipworksedi_as1sender_getsslacceptservercertsubjectaltnames(void* lpObj);

char* ipworksedi_as1sender_getsslacceptservercertthumbprintmd5(void* lpObj);

char* ipworksedi_as1sender_getsslacceptservercertthumbprintsha1(void* lpObj);

char* ipworksedi_as1sender_getsslacceptservercertthumbprintsha256(void* lpObj);

char* ipworksedi_as1sender_getsslacceptservercertusage(void* lpObj);

int ipworksedi_as1sender_getsslacceptservercertusageflags(void* lpObj);

char* ipworksedi_as1sender_getsslacceptservercertversion(void* lpObj);

char* ipworksedi_as1sender_getsslacceptservercertsubject(void* lpObj);
int ipworksedi_as1sender_setsslacceptservercertsubject(void* lpObj, const char* lpszSSLAcceptServerCertSubject);

int ipworksedi_as1sender_getsslacceptservercertencoded(void* lpObj, char** lpSSLAcceptServerCertEncoded, int* lenSSLAcceptServerCertEncoded);
int ipworksedi_as1sender_setsslacceptservercertencoded(void* lpObj, const char* lpSSLAcceptServerCertEncoded, int lenSSLAcceptServerCertEncoded);

QString getSSLAcceptServerCertEffectiveDate();

QString getSSLAcceptServerCertExpirationDate();

QString getSSLAcceptServerCertExtendedKeyUsage();

QString getSSLAcceptServerCertFingerprint();

QString getSSLAcceptServerCertFingerprintSHA1();

QString getSSLAcceptServerCertFingerprintSHA256();

QString getSSLAcceptServerCertIssuer();

QString getSSLAcceptServerCertPrivateKey();

bool getSSLAcceptServerCertPrivateKeyAvailable();

QString getSSLAcceptServerCertPrivateKeyContainer();

QString getSSLAcceptServerCertPublicKey();

QString getSSLAcceptServerCertPublicKeyAlgorithm();

int getSSLAcceptServerCertPublicKeyLength();

QString getSSLAcceptServerCertSerialNumber();

QString getSSLAcceptServerCertSignatureAlgorithm();

QByteArray getSSLAcceptServerCertStore();
int setSSLAcceptServerCertStore(QByteArray qbaSSLAcceptServerCertStore);

QString getSSLAcceptServerCertStorePassword();
int setSSLAcceptServerCertStorePassword(QString qsSSLAcceptServerCertStorePassword);

int getSSLAcceptServerCertStoreType();
int setSSLAcceptServerCertStoreType(int iSSLAcceptServerCertStoreType);

QString getSSLAcceptServerCertSubjectAltNames();

QString getSSLAcceptServerCertThumbprintMD5();

QString getSSLAcceptServerCertThumbprintSHA1();

QString getSSLAcceptServerCertThumbprintSHA256();

QString getSSLAcceptServerCertUsage();

int getSSLAcceptServerCertUsageFlags();

QString getSSLAcceptServerCertVersion();

QString getSSLAcceptServerCertSubject();
int setSSLAcceptServerCertSubject(QString qsSSLAcceptServerCertSubject);

QByteArray getSSLAcceptServerCertEncoded();
int setSSLAcceptServerCertEncoded(QByteArray qbaSSLAcceptServerCertEncoded);

char* ipworksedi_as1sender_getsslcerteffectivedate(void* lpObj);

char* ipworksedi_as1sender_getsslcertexpirationdate(void* lpObj);

char* ipworksedi_as1sender_getsslcertextendedkeyusage(void* lpObj);

char* ipworksedi_as1sender_getsslcertfingerprint(void* lpObj);

char* ipworksedi_as1sender_getsslcertfingerprintsha1(void* lpObj);

char* ipworksedi_as1sender_getsslcertfingerprintsha256(void* lpObj);

char* ipworksedi_as1sender_getsslcertissuer(void* lpObj);

char* ipworksedi_as1sender_getsslcertprivatekey(void* lpObj);

int ipworksedi_as1sender_getsslcertprivatekeyavailable(void* lpObj);

char* ipworksedi_as1sender_getsslcertprivatekeycontainer(void* lpObj);

char* ipworksedi_as1sender_getsslcertpublickey(void* lpObj);

char* ipworksedi_as1sender_getsslcertpublickeyalgorithm(void* lpObj);

int ipworksedi_as1sender_getsslcertpublickeylength(void* lpObj);

char* ipworksedi_as1sender_getsslcertserialnumber(void* lpObj);

char* ipworksedi_as1sender_getsslcertsignaturealgorithm(void* lpObj);

int ipworksedi_as1sender_getsslcertstore(void* lpObj, char** lpSSLCertStore, int* lenSSLCertStore);
int ipworksedi_as1sender_setsslcertstore(void* lpObj, const char* lpSSLCertStore, int lenSSLCertStore);

char* ipworksedi_as1sender_getsslcertstorepassword(void* lpObj);
int ipworksedi_as1sender_setsslcertstorepassword(void* lpObj, const char* lpszSSLCertStorePassword);

int ipworksedi_as1sender_getsslcertstoretype(void* lpObj);
int ipworksedi_as1sender_setsslcertstoretype(void* lpObj, int iSSLCertStoreType);

char* ipworksedi_as1sender_getsslcertsubjectaltnames(void* lpObj);

char* ipworksedi_as1sender_getsslcertthumbprintmd5(void* lpObj);

char* ipworksedi_as1sender_getsslcertthumbprintsha1(void* lpObj);

char* ipworksedi_as1sender_getsslcertthumbprintsha256(void* lpObj);

char* ipworksedi_as1sender_getsslcertusage(void* lpObj);

int ipworksedi_as1sender_getsslcertusageflags(void* lpObj);

char* ipworksedi_as1sender_getsslcertversion(void* lpObj);

char* ipworksedi_as1sender_getsslcertsubject(void* lpObj);
int ipworksedi_as1sender_setsslcertsubject(void* lpObj, const char* lpszSSLCertSubject);

int ipworksedi_as1sender_getsslcertencoded(void* lpObj, char** lpSSLCertEncoded, int* lenSSLCertEncoded);
int ipworksedi_as1sender_setsslcertencoded(void* lpObj, const char* lpSSLCertEncoded, int lenSSLCertEncoded);

QString getSSLCertEffectiveDate();

QString getSSLCertExpirationDate();

QString getSSLCertExtendedKeyUsage();

QString getSSLCertFingerprint();

QString getSSLCertFingerprintSHA1();

QString getSSLCertFingerprintSHA256();

QString getSSLCertIssuer();

QString getSSLCertPrivateKey();

bool getSSLCertPrivateKeyAvailable();

QString getSSLCertPrivateKeyContainer();

QString getSSLCertPublicKey();

QString getSSLCertPublicKeyAlgorithm();

int getSSLCertPublicKeyLength();

QString getSSLCertSerialNumber();

QString getSSLCertSignatureAlgorithm();

QByteArray getSSLCertStore();
int setSSLCertStore(QByteArray qbaSSLCertStore);

QString getSSLCertStorePassword();
int setSSLCertStorePassword(QString qsSSLCertStorePassword);

int getSSLCertStoreType();
int setSSLCertStoreType(int iSSLCertStoreType);

QString getSSLCertSubjectAltNames();

QString getSSLCertThumbprintMD5();

QString getSSLCertThumbprintSHA1();

QString getSSLCertThumbprintSHA256();

QString getSSLCertUsage();

int getSSLCertUsageFlags();

QString getSSLCertVersion();

QString getSSLCertSubject();
int setSSLCertSubject(QString qsSSLCertSubject);

QByteArray getSSLCertEncoded();
int setSSLCertEncoded(QByteArray qbaSSLCertEncoded);

int ipworksedi_as1sender_getsslprovider(void* lpObj);
int ipworksedi_as1sender_setsslprovider(void* lpObj, int iSSLProvider);

int getSSLProvider();
int setSSLProvider(int iSSLProvider);

char* ipworksedi_as1sender_getsslservercerteffectivedate(void* lpObj);

char* ipworksedi_as1sender_getsslservercertexpirationdate(void* lpObj);

char* ipworksedi_as1sender_getsslservercertextendedkeyusage(void* lpObj);

char* ipworksedi_as1sender_getsslservercertfingerprint(void* lpObj);

char* ipworksedi_as1sender_getsslservercertfingerprintsha1(void* lpObj);

char* ipworksedi_as1sender_getsslservercertfingerprintsha256(void* lpObj);

char* ipworksedi_as1sender_getsslservercertissuer(void* lpObj);

char* ipworksedi_as1sender_getsslservercertprivatekey(void* lpObj);

int ipworksedi_as1sender_getsslservercertprivatekeyavailable(void* lpObj);

char* ipworksedi_as1sender_getsslservercertprivatekeycontainer(void* lpObj);

char* ipworksedi_as1sender_getsslservercertpublickey(void* lpObj);

char* ipworksedi_as1sender_getsslservercertpublickeyalgorithm(void* lpObj);

int ipworksedi_as1sender_getsslservercertpublickeylength(void* lpObj);

char* ipworksedi_as1sender_getsslservercertserialnumber(void* lpObj);

char* ipworksedi_as1sender_getsslservercertsignaturealgorithm(void* lpObj);

int ipworksedi_as1sender_getsslservercertstore(void* lpObj, char** lpSSLServerCertStore, int* lenSSLServerCertStore);

char* ipworksedi_as1sender_getsslservercertstorepassword(void* lpObj);

int ipworksedi_as1sender_getsslservercertstoretype(void* lpObj);

char* ipworksedi_as1sender_getsslservercertsubjectaltnames(void* lpObj);

char* ipworksedi_as1sender_getsslservercertthumbprintmd5(void* lpObj);

char* ipworksedi_as1sender_getsslservercertthumbprintsha1(void* lpObj);

char* ipworksedi_as1sender_getsslservercertthumbprintsha256(void* lpObj);

char* ipworksedi_as1sender_getsslservercertusage(void* lpObj);

int ipworksedi_as1sender_getsslservercertusageflags(void* lpObj);

char* ipworksedi_as1sender_getsslservercertversion(void* lpObj);

char* ipworksedi_as1sender_getsslservercertsubject(void* lpObj);

int ipworksedi_as1sender_getsslservercertencoded(void* lpObj, char** lpSSLServerCertEncoded, int* lenSSLServerCertEncoded);

QString getSSLServerCertEffectiveDate();

QString getSSLServerCertExpirationDate();

QString getSSLServerCertExtendedKeyUsage();

QString getSSLServerCertFingerprint();

QString getSSLServerCertFingerprintSHA1();

QString getSSLServerCertFingerprintSHA256();

QString getSSLServerCertIssuer();

QString getSSLServerCertPrivateKey();

bool getSSLServerCertPrivateKeyAvailable();

QString getSSLServerCertPrivateKeyContainer();

QString getSSLServerCertPublicKey();

QString getSSLServerCertPublicKeyAlgorithm();

int getSSLServerCertPublicKeyLength();

QString getSSLServerCertSerialNumber();

QString getSSLServerCertSignatureAlgorithm();

QByteArray getSSLServerCertStore();

QString getSSLServerCertStorePassword();

int getSSLServerCertStoreType();

QString getSSLServerCertSubjectAltNames();

QString getSSLServerCertThumbprintMD5();

QString getSSLServerCertThumbprintSHA1();

QString getSSLServerCertThumbprintSHA256();

QString getSSLServerCertUsage();

int getSSLServerCertUsageFlags();

QString getSSLServerCertVersion();

QString getSSLServerCertSubject();

QByteArray getSSLServerCertEncoded();

int ipworksedi_as1sender_getsslstartmode(void* lpObj);
int ipworksedi_as1sender_setsslstartmode(void* lpObj, int iSSLStartMode);

int getSSLStartMode();
int setSSLStartMode(int iSSLStartMode);

char* ipworksedi_as1sender_getsubject(void* lpObj);
int ipworksedi_as1sender_setsubject(void* lpObj, const char* lpszSubject);

QString getSubject();
int setSubject(QString qsSubject);

char* ipworksedi_as1sender_getuser(void* lpObj);
int ipworksedi_as1sender_setuser(void* lpObj, const char* lpszUser);

QString getUser();
int setUser(QString qsUser);

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

QString config(const QString& qsConfigurationString);

int ipworksedi_as1sender_connect(void* lpObj);

int connect();

int ipworksedi_as1sender_deletemessage(void* lpObj);

int deleteMessage();

int ipworksedi_as1sender_disconnect(void* lpObj);

int disconnect();

int ipworksedi_as1sender_processqueue(void* lpObj, const char* lpszDirectory);

int processQueue(const QString& qsDirectory);

int ipworksedi_as1sender_querymessagesize(void* lpObj);

int queryMessageSize();

char* ipworksedi_as1sender_querymessageuid(void* lpObj);

QString queryMessageUID();

int ipworksedi_as1sender_queue(void* lpObj, const char* lpszDirectory);

int queue(const QString& qsDirectory);

int ipworksedi_as1sender_readreceipt(void* lpObj);

int readReceipt();

int ipworksedi_as1sender_reset(void* lpObj);

int reset();

int ipworksedi_as1sender_selectmailmessage(void* lpObj);

int selectMailMessage();

int ipworksedi_as1sender_send(void* lpObj);

int send();

int ipworksedi_as1sender_setrequestheader(void* lpObj, const char* lpszHeaderName, const char* lpszHeaderValue);

int setRequestHeader(const QString& qsHeaderName, const QString& qsHeaderValue);

int ipworksedi_as1sender_verifyreceipt(void* lpObj);

int verifyReceipt();

#define EID_AS1SENDER_CONNECTIONSTATUS 1

virtual INT IPWORKSEDI_CALL FireConnectionStatus(LPSTR &lpszConnectionEvent, INT &iStatusCode, LPSTR &lpszDescription);

class AS1SenderConnectionStatusEventParams {
public:
  const QString &connectionEvent();

  int statusCode();

  const QString &description();

  int eventRetVal();
  void setEventRetVal(int iRetVal);
};

// To handle, subclass AS1Sender and override this emitter function.
virtual int fireConnectionStatus(AS1SenderConnectionStatusEventParams *e) {...}
// Or, connect one or more slots to this signal.
void connectionStatus(AS1SenderConnectionStatusEventParams *e);

#define EID_AS1SENDER_ENDTRANSFER 2

virtual INT IPWORKSEDI_CALL FireEndTransfer();

class AS1SenderEndTransferEventParams {
public:
  int eventRetVal();
  void setEventRetVal(int iRetVal);
};

// To handle, subclass AS1Sender and override this emitter function.
virtual int fireEndTransfer(AS1SenderEndTransferEventParams *e) {...}
// Or, connect one or more slots to this signal.
void endTransfer(AS1SenderEndTransferEventParams *e);

#define EID_AS1SENDER_ERROR 3

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

class AS1SenderErrorEventParams {
public:
  int errorCode();

  const QString &description();

  int eventRetVal();
  void setEventRetVal(int iRetVal);
};

// To handle, subclass AS1Sender and override this emitter function.
virtual int fireError(AS1SenderErrorEventParams *e) {...}
// Or, connect one or more slots to this signal.
void error(AS1SenderErrorEventParams *e);

#define EID_AS1SENDER_HEADER 4

virtual INT IPWORKSEDI_CALL FireHeader(LPSTR &lpszField, LPSTR &lpszValue);

class AS1SenderHeaderEventParams {
public:
  const QString &field();

  const QString &value();

  int eventRetVal();
  void setEventRetVal(int iRetVal);
};

// To handle, subclass AS1Sender and override this emitter function.
virtual int fireHeader(AS1SenderHeaderEventParams *e) {...}
// Or, connect one or more slots to this signal.
void header(AS1SenderHeaderEventParams *e);

#define EID_AS1SENDER_LOG 5

virtual INT IPWORKSEDI_CALL FireLog(LPSTR &lpszLogType, LPSTR &lpLogMessage, INT &lenLogMessage);

class AS1SenderLogEventParams {
public:
  const QString &logType();

  const QByteArray &logMessage();

  int eventRetVal();
  void setEventRetVal(int iRetVal);
};

// To handle, subclass AS1Sender and override this emitter function.
virtual int fireLog(AS1SenderLogEventParams *e) {...}
// Or, connect one or more slots to this signal.
void log(AS1SenderLogEventParams *e);

#define EID_AS1SENDER_PITRAIL 6

virtual INT IPWORKSEDI_CALL FirePITrail(INT &iDirection, LPSTR &lpszMessage);

class AS1SenderPITrailEventParams {
public:
  int direction();

  const QString &message();

  int eventRetVal();
  void setEventRetVal(int iRetVal);
};

// To handle, subclass AS1Sender and override this emitter function.
virtual int firePITrail(AS1SenderPITrailEventParams *e) {...}
// Or, connect one or more slots to this signal.
void PITrail(AS1SenderPITrailEventParams *e);

#define EID_AS1SENDER_SSLSERVERAUTHENTICATION 7

virtual INT IPWORKSEDI_CALL FireSSLServerAuthentication(LPSTR &lpCertEncoded, INT &lenCertEncoded, LPSTR &lpszCertSubject, LPSTR &lpszCertIssuer, LPSTR &lpszStatus, BOOL &bAccept);

class AS1SenderSSLServerAuthenticationEventParams {
public:
  const QByteArray &certEncoded();

  const QString &certSubject();

  const QString &certIssuer();

  const QString &status();

  bool accept();
  void setAccept(bool bAccept);

  int eventRetVal();
  void setEventRetVal(int iRetVal);
};

// To handle, subclass AS1Sender and override this emitter function.
virtual int fireSSLServerAuthentication(AS1SenderSSLServerAuthenticationEventParams *e) {...}
// Or, connect one or more slots to this signal.
void SSLServerAuthentication(AS1SenderSSLServerAuthenticationEventParams *e);

#define EID_AS1SENDER_SSLSTATUS 8

virtual INT IPWORKSEDI_CALL FireSSLStatus(LPSTR &lpszMessage);

class AS1SenderSSLStatusEventParams {
public:
  const QString &message();

  int eventRetVal();
  void setEventRetVal(int iRetVal);
};

// To handle, subclass AS1Sender and override this emitter function.
virtual int fireSSLStatus(AS1SenderSSLStatusEventParams *e) {...}
// Or, connect one or more slots to this signal.
void SSLStatus(AS1SenderSSLStatusEventParams *e);

#define EID_AS1SENDER_STARTTRANSFER 9

virtual INT IPWORKSEDI_CALL FireStartTransfer();

class AS1SenderStartTransferEventParams {
public:
  int eventRetVal();
  void setEventRetVal(int iRetVal);
};

// To handle, subclass AS1Sender and override this emitter function.
virtual int fireStartTransfer(AS1SenderStartTransferEventParams *e) {...}
// Or, connect one or more slots to this signal.
void startTransfer(AS1SenderStartTransferEventParams *e);

#define EID_AS1SENDER_TRANSFER 10

virtual INT IPWORKSEDI_CALL FireTransfer(LONG64 &lBytesTransferred);

class AS1SenderTransferEventParams {
public:
  qint64 bytesTransferred();

  int eventRetVal();
  void setEventRetVal(int iRetVal);
};

// To handle, subclass AS1Sender and override this emitter function.
virtual int fireTransfer(AS1SenderTransferEventParams *e) {...}
// Or, connect one or more slots to this signal.
void transfer(AS1SenderTransferEventParams *e);