// CkMailManW.h: interface for the CkMailManW class.
//
//////////////////////////////////////////////////////////////////////

// This header is generated for Chilkat 11.5.0

#ifndef _CkMailManW_H
#define _CkMailManW_H
	
#include "chilkatDefs.h"
#include "CkString.h"
#include "CkClassWithCallbacksW.h"

class CkBinDataW;
class CkByteData;
class CkTaskW;
class CkEmailBundleW;
class CkEmailW;
class CkStringArrayW;
class CkStringTableW;
class CkJsonObjectW;
class CkCertW;
class CkStringBuilderW;
class CkPrivateKeyW;
class CkSecureStringW;
class CkSshKeyW;
class CkXmlCertVaultW;
class CkSshW;
class CkSocketW;
class CkMailManProgressW;



#if !defined(__sun__) && !defined(__sun)
#pragma pack (push, 8)
#endif
 

// CLASS: CkMailManW
class CK_VISIBLE_PUBLIC CkMailManW  : public CkClassWithCallbacksW
{
	private:
	bool m_cbOwned;

	private:
	
	// Don't allow assignment or copying these objects.
	CkMailManW(const CkMailManW &);
	CkMailManW &operator=(const CkMailManW &);

    public:
	CkMailManW(void);
	virtual ~CkMailManW(void);

	

	static CkMailManW *createNew(void);
	

	CkMailManW(bool bCallbackOwned);
	static CkMailManW *createNew(bool bCallbackOwned);

	
	void CK_VISIBLE_PRIVATE inject(void *impl);

	// May be called when finished with the object to free/dispose of any
	// internal resources held by the object. 
	void dispose(void);

	CkMailManProgressW *get_EventCallbackObject(void) const;
	void put_EventCallbackObject(CkMailManProgressW *progress);


	// BEGIN PUBLIC INTERFACE

	// ----------------------
	// Properties
	// ----------------------
	// 
	// 
	// Set this property to true to request that the currently running operation be
	// aborted.
	// 
	// This applies to methods that may take time to complete, such as methods that
	// perform network communication or lengthy file operations. Methods that always
	// complete quickly are generally not affected.
	// 
	// If no method is currently running, the property is automatically reset to
	// false when the next method call begins. When an abort actually occurs, Chilkat
	// resets this property to false .
	// 
	// Both synchronous and asynchronous method calls can be aborted. A synchronous
	// method can be aborted by setting this property from another thread.
	// 
	bool get_AbortCurrent(void);
	// 
	// 
	// Set this property to true to request that the currently running operation be
	// aborted.
	// 
	// This applies to methods that may take time to complete, such as methods that
	// perform network communication or lengthy file operations. Methods that always
	// complete quickly are generally not affected.
	// 
	// If no method is currently running, the property is automatically reset to
	// false when the next method call begins. When an abort actually occurs, Chilkat
	// resets this property to false .
	// 
	// Both synchronous and asynchronous method calls can be aborted. A synchronous
	// method can be aborted by setting this property from another thread.
	// 
	void put_AbortCurrent(bool newVal);

	// 
	// 
	// Controls whether an email should be sent when one or more recipients are
	// rejected by the SMTP server.
	// 
	// The default value is false , which means Chilkat continues sending even if
	// some recipients are rejected.
	// 
	// When set to true , the email is not sent to any recipients if the SMTP server
	// rejects any recipient address.
	// 
	// Important: This property only works when SMTP pipelining is disabled. Because
	// SmtpPipelining is true by default, set SmtpPipelining = false when
	// all-or-none behavior is required.
	// 
	// Note: SMTP servers do not always verify recipient addresses. Even when they do,
	// the server can usually verify only addresses within domains it controls.
	// 
	bool get_AllOrNone(void);
	// 
	// 
	// Controls whether an email should be sent when one or more recipients are
	// rejected by the SMTP server.
	// 
	// The default value is false , which means Chilkat continues sending even if
	// some recipients are rejected.
	// 
	// When set to true , the email is not sent to any recipients if the SMTP server
	// rejects any recipient address.
	// 
	// Important: This property only works when SMTP pipelining is disabled. Because
	// SmtpPipelining is true by default, set SmtpPipelining = false when
	// all-or-none behavior is required.
	// 
	// Note: SMTP servers do not always verify recipient addresses. Even when they do,
	// the server can usually verify only addresses within domains it controls.
	// 
	void put_AllOrNone(bool newVal);

	// 
	// 
	// When true , Chilkat automatically adjusts common SMTP and POP3 SSL/TLS
	// settings based on the configured port numbers.
	// 
	//     * If SmtpPort = 465 , Chilkat sets StartTLS = false and SmtpSsl = true .
	//     * If SmtpPort = 25 , Chilkat sets SmtpSsl = false .
	//     * If MailPort = 995 , Chilkat sets PopSsl = true .
	//     * If MailPort = 110 , Chilkat sets PopSsl = false .
	// 
	// The default value is true .
	// 
	bool get_AutoFix(void);
	// 
	// 
	// When true , Chilkat automatically adjusts common SMTP and POP3 SSL/TLS
	// settings based on the configured port numbers.
	// 
	//     * If SmtpPort = 465 , Chilkat sets StartTLS = false and SmtpSsl = true .
	//     * If SmtpPort = 25 , Chilkat sets SmtpSsl = false .
	//     * If MailPort = 995 , Chilkat sets PopSsl = true .
	//     * If MailPort = 110 , Chilkat sets PopSsl = false .
	// 
	// The default value is true .
	// 
	void put_AutoFix(bool newVal);

	// 
	// 
	// Controls whether Chilkat automatically generates a unique Message-ID header when
	// an email is sent.
	// 
	// The default behavior is to generate a new unique Message-ID at send time. This
	// allows the same Email object to be reused without accidentally sending duplicate
	// message IDs.
	// 
	// If duplicate message IDs are used, some SMTP servers may treat the message as a
	// duplicate and discard it.
	// 
	// When automatic generation is enabled, calling GetHeaderField("Message-ID")
	// before sending will not necessarily show the actual message ID that Chilkat
	// sends.
	// 
	// Set this property to false to prevent Chilkat from automatically generating
	// the Message-ID header.
	// 
	bool get_AutoGenMessageId(void);
	// 
	// 
	// Controls whether Chilkat automatically generates a unique Message-ID header when
	// an email is sent.
	// 
	// The default behavior is to generate a new unique Message-ID at send time. This
	// allows the same Email object to be reused without accidentally sending duplicate
	// message IDs.
	// 
	// If duplicate message IDs are used, some SMTP servers may treat the message as a
	// duplicate and discard it.
	// 
	// When automatic generation is enabled, calling GetHeaderField("Message-ID")
	// before sending will not necessarily show the actual message ID that Chilkat
	// sends.
	// 
	// Set this property to false to prevent Chilkat from automatically generating
	// the Message-ID header.
	// 
	void put_AutoGenMessageId(bool newVal);

	// 
	// 
	// When true , Chilkat automatically sends the SMTP RSET command before sending a
	// new email over an already-open SMTP connection.
	// 
	// This helps ensure the SMTP session is in a clean state before the next email is
	// sent.
	// 
	// The default value is false .
	// 
	// Note: This property only applies when reusing an existing SMTP connection.
	// 
	bool get_AutoSmtpRset(void);
	// 
	// 
	// When true , Chilkat automatically sends the SMTP RSET command before sending a
	// new email over an already-open SMTP connection.
	// 
	// This helps ensure the SMTP session is in a clean state before the next email is
	// sent.
	// 
	// The default value is false .
	// 
	// Note: This property only applies when reusing an existing SMTP connection.
	// 
	void put_AutoSmtpRset(bool newVal);

	// 
	// 
	// Controls whether Chilkat automatically unwraps digitally signed or encrypted
	// email when the message is downloaded or loaded from MIME.
	// 
	// The default value is true . When enabled, Chilkat verifies signatures and
	// decrypts encrypted content when possible. The results are made available through
	// the email object's security-related properties and methods.
	// 
	// Set this property to false if you want signed or encrypted attachments, such
	// as .p7m or .p7s files, to remain as ordinary attachments.
	// 
	// Important: Signature verification and decryption must occur when the original
	// MIME is first loaded. After MIME is parsed into Chilkat's internal email object
	// format, the exact original MIME bytes are no longer available, and the signature
	// can no longer be verified.
	// 
	bool get_AutoUnwrapSecurity(void);
	// 
	// 
	// Controls whether Chilkat automatically unwraps digitally signed or encrypted
	// email when the message is downloaded or loaded from MIME.
	// 
	// The default value is true . When enabled, Chilkat verifies signatures and
	// decrypts encrypted content when possible. The results are made available through
	// the email object's security-related properties and methods.
	// 
	// Set this property to false if you want signed or encrypted attachments, such
	// as .p7m or .p7s files, to remain as ordinary attachments.
	// 
	// Important: Signature verification and decryption must occur when the original
	// MIME is first loaded. After MIME is parsed into Chilkat's internal email object
	// format, the exact original MIME bytes are no longer available, and the signature
	// can no longer be verified.
	// 
	void put_AutoUnwrapSecurity(bool newVal);

	// 
	// 
	// Specifies the local IP address to use when connecting from a computer that has
	// multiple network interfaces or multiple IP addresses.
	// 
	// For most computers, this property should be left unset. Chilkat will
	// automatically use the default local IP address.
	// 
	// The value should be a numeric IP address, such as 165.164.55.124 , not a
	// hostname.
	// 
	void get_ClientIpAddress(CkString &str);
	// 
	// 
	// Specifies the local IP address to use when connecting from a computer that has
	// multiple network interfaces or multiple IP addresses.
	// 
	// For most computers, this property should be left unset. Chilkat will
	// automatically use the default local IP address.
	// 
	// The value should be a numeric IP address, such as 165.164.55.124 , not a
	// hostname.
	// 
	const wchar_t *clientIpAddress(void);
	// 
	// 
	// Specifies the local IP address to use when connecting from a computer that has
	// multiple network interfaces or multiple IP addresses.
	// 
	// For most computers, this property should be left unset. Chilkat will
	// automatically use the default local IP address.
	// 
	// The value should be a numeric IP address, such as 165.164.55.124 , not a
	// hostname.
	// 
	void put_ClientIpAddress(const wchar_t *newVal);

	// 
	// 
	// Contains a numeric code describing the result of the last connection attempt.
	// This applies to the last connection made, or attempted, by any method.
	// 
	// Code
	// Meaning
	// 
	// 0
	// Success.
	// 
	// 1
	// Empty hostname.
	// 
	// 2
	// DNS lookup failed.
	// 
	// 3
	// DNS timeout.
	// 
	// 4
	// Aborted by the application.
	// 
	// 5
	// Internal failure.
	// 
	// 6
	// Connection timed out.
	// 
	// 7
	// Connection rejected, or failed for another reason.
	// 
	// 100
	// TLS internal error.
	// 
	// 101
	// Failed to send the TLS client hello.
	// 
	// 102
	// Unexpected TLS handshake message.
	// 
	// 103
	// Failed to read the TLS server hello.
	// 
	// 104
	// No server certificate was received.
	// 
	// 105
	// Unexpected TLS protocol version.
	// 
	// 106
	// Server certificate verification failed.
	// 
	// 107
	// Unacceptable TLS protocol version.
	// 
	// 109
	// Failed to read TLS handshake messages.
	// 
	// 110
	// Failed to send client certificate handshake message.
	// 
	// 111
	// Failed to send client key exchange handshake message.
	// 
	// 112
	// Client certificate private key is not accessible.
	// 
	// 113
	// Failed to send client certificate verify handshake message.
	// 
	// 114
	// Failed to send change cipher spec handshake message.
	// 
	// 115
	// Failed to send finished handshake message.
	// 
	// 116
	// The server's finished message is invalid.
	// 
	int get_ConnectFailReason(void);

	// 
	// 
	// The maximum number of seconds to wait while attempting to connect to an SMTP or
	// POP3 server.
	// 
	// The default value is 30 seconds.
	// 
	int get_ConnectTimeout(void);
	// 
	// 
	// The maximum number of seconds to wait while attempting to connect to an SMTP or
	// POP3 server.
	// 
	// The default value is 30 seconds.
	// 
	void put_ConnectTimeout(int newVal);

	// 
	// 
	// The DsnEnvid property specifies the SMTP DSN ENVID value, which is an arbitrary
	// identifier attached to the SMTP envelope. The same value is typically returned
	// in DSN responses so the sending application can correlate delivery notifications
	// with the original outbound email.
	// 
	// Common choices for DsnEnvid include:
	// 
	//     * An internal message ID:
	// 
	//         MSG-10004521
	// 
	//     * A GUID or UUID:
	// 
	//         550e8400-e29b-41d4-a716-446655440000
	// 
	//     * An order or transaction number:
	// 
	//         ORDER-847291
	// 
	//     * A timestamp-based identifier:
	// 
	//         MAIL-20260515-153045-001
	// 
	//     * A composite identifier combining application, customer, and message IDs:
	// 
	//         billing|cust-9182|invoice-44381
	// 
	// The value should uniquely identify the outbound email within your application.
	// It does not need to match the MIME Message-ID header, although some applications
	// choose to use the same identifier for both.
	// 
	// --------------------------------------------------------------------------------
	// 
	// About SMTP DSN
	// 
	// SMTP DSN means Delivery Status Notification. It is an optional SMTP service
	// extension defined by RFC 3461 that allows the sender to request delivery-status
	// reports from the SMTP server.
	// 
	// DSN allows an application to request notifications such as:
	// 
	//     * Successful delivery
	//     * Delivery failure
	//     * Delayed delivery
	// 
	// It also allows the sender to specify whether the returned notification should
	// include the full original message or only the message headers.
	// 
	// In Chilkat.MailMan , DSN behavior is controlled using:
	// 
	//     * DsnEnvid — sets the SMTP ENVID envelope identifier.
	//     * DsnNotify — controls when notifications are requested, such as SUCCESS ,
	//     FAILURE , DELAY , or NEVER .
	//     * DsnRet — controls whether DSN responses include the full message or only
	//     headers.
	// 
	// DSN is an optional SMTP extension and is not supported by all SMTP servers. A
	// server supports DSN only if it advertises the DSN capability in response to the
	// SMTP EHLO command.
	// 
	// The IsSmtpDsnCapable method can be used to determine whether the SMTP server
	// supports DSN.
	// 
	// Even when DSN is supported, some SMTP servers or downstream mail systems may
	// ignore or partially honor DSN requests.
	// 
	void get_DsnEnvid(CkString &str);
	// 
	// 
	// The DsnEnvid property specifies the SMTP DSN ENVID value, which is an arbitrary
	// identifier attached to the SMTP envelope. The same value is typically returned
	// in DSN responses so the sending application can correlate delivery notifications
	// with the original outbound email.
	// 
	// Common choices for DsnEnvid include:
	// 
	//     * An internal message ID:
	// 
	//         MSG-10004521
	// 
	//     * A GUID or UUID:
	// 
	//         550e8400-e29b-41d4-a716-446655440000
	// 
	//     * An order or transaction number:
	// 
	//         ORDER-847291
	// 
	//     * A timestamp-based identifier:
	// 
	//         MAIL-20260515-153045-001
	// 
	//     * A composite identifier combining application, customer, and message IDs:
	// 
	//         billing|cust-9182|invoice-44381
	// 
	// The value should uniquely identify the outbound email within your application.
	// It does not need to match the MIME Message-ID header, although some applications
	// choose to use the same identifier for both.
	// 
	// --------------------------------------------------------------------------------
	// 
	// About SMTP DSN
	// 
	// SMTP DSN means Delivery Status Notification. It is an optional SMTP service
	// extension defined by RFC 3461 that allows the sender to request delivery-status
	// reports from the SMTP server.
	// 
	// DSN allows an application to request notifications such as:
	// 
	//     * Successful delivery
	//     * Delivery failure
	//     * Delayed delivery
	// 
	// It also allows the sender to specify whether the returned notification should
	// include the full original message or only the message headers.
	// 
	// In Chilkat.MailMan , DSN behavior is controlled using:
	// 
	//     * DsnEnvid — sets the SMTP ENVID envelope identifier.
	//     * DsnNotify — controls when notifications are requested, such as SUCCESS ,
	//     FAILURE , DELAY , or NEVER .
	//     * DsnRet — controls whether DSN responses include the full message or only
	//     headers.
	// 
	// DSN is an optional SMTP extension and is not supported by all SMTP servers. A
	// server supports DSN only if it advertises the DSN capability in response to the
	// SMTP EHLO command.
	// 
	// The IsSmtpDsnCapable method can be used to determine whether the SMTP server
	// supports DSN.
	// 
	// Even when DSN is supported, some SMTP servers or downstream mail systems may
	// ignore or partially honor DSN requests.
	// 
	const wchar_t *dsnEnvid(void);
	// 
	// 
	// The DsnEnvid property specifies the SMTP DSN ENVID value, which is an arbitrary
	// identifier attached to the SMTP envelope. The same value is typically returned
	// in DSN responses so the sending application can correlate delivery notifications
	// with the original outbound email.
	// 
	// Common choices for DsnEnvid include:
	// 
	//     * An internal message ID:
	// 
	//         MSG-10004521
	// 
	//     * A GUID or UUID:
	// 
	//         550e8400-e29b-41d4-a716-446655440000
	// 
	//     * An order or transaction number:
	// 
	//         ORDER-847291
	// 
	//     * A timestamp-based identifier:
	// 
	//         MAIL-20260515-153045-001
	// 
	//     * A composite identifier combining application, customer, and message IDs:
	// 
	//         billing|cust-9182|invoice-44381
	// 
	// The value should uniquely identify the outbound email within your application.
	// It does not need to match the MIME Message-ID header, although some applications
	// choose to use the same identifier for both.
	// 
	// --------------------------------------------------------------------------------
	// 
	// About SMTP DSN
	// 
	// SMTP DSN means Delivery Status Notification. It is an optional SMTP service
	// extension defined by RFC 3461 that allows the sender to request delivery-status
	// reports from the SMTP server.
	// 
	// DSN allows an application to request notifications such as:
	// 
	//     * Successful delivery
	//     * Delivery failure
	//     * Delayed delivery
	// 
	// It also allows the sender to specify whether the returned notification should
	// include the full original message or only the message headers.
	// 
	// In Chilkat.MailMan , DSN behavior is controlled using:
	// 
	//     * DsnEnvid — sets the SMTP ENVID envelope identifier.
	//     * DsnNotify — controls when notifications are requested, such as SUCCESS ,
	//     FAILURE , DELAY , or NEVER .
	//     * DsnRet — controls whether DSN responses include the full message or only
	//     headers.
	// 
	// DSN is an optional SMTP extension and is not supported by all SMTP servers. A
	// server supports DSN only if it advertises the DSN capability in response to the
	// SMTP EHLO command.
	// 
	// The IsSmtpDsnCapable method can be used to determine whether the SMTP server
	// supports DSN.
	// 
	// Even when DSN is supported, some SMTP servers or downstream mail systems may
	// ignore or partially honor DSN requests.
	// 
	void put_DsnEnvid(const wchar_t *newVal);

	// 
	// 
	// Specifies the SMTP DSN NOTIFY parameter used when sending email.
	// 
	// The value may be left empty, set to NEVER , or set to a comma-separated
	// combination of SUCCESS , FAILURE , and DELAY .
	// 
	void get_DsnNotify(CkString &str);
	// 
	// 
	// Specifies the SMTP DSN NOTIFY parameter used when sending email.
	// 
	// The value may be left empty, set to NEVER , or set to a comma-separated
	// combination of SUCCESS , FAILURE , and DELAY .
	// 
	const wchar_t *dsnNotify(void);
	// 
	// 
	// Specifies the SMTP DSN NOTIFY parameter used when sending email.
	// 
	// The value may be left empty, set to NEVER , or set to a comma-separated
	// combination of SUCCESS , FAILURE , and DELAY .
	// 
	void put_DsnNotify(const wchar_t *newVal);

	// 
	// 
	// Specifies the SMTP DSN RET parameter used when sending email.
	// 
	// The value may be left empty, set to FULL to request the full message in DSN
	// notifications, or set to HDRS to request only the message headers.
	// 
	void get_DsnRet(CkString &str);
	// 
	// 
	// Specifies the SMTP DSN RET parameter used when sending email.
	// 
	// The value may be left empty, set to FULL to request the full message in DSN
	// notifications, or set to HDRS to request only the message headers.
	// 
	const wchar_t *dsnRet(void);
	// 
	// 
	// Specifies the SMTP DSN RET parameter used when sending email.
	// 
	// The value may be left empty, set to FULL to request the full message in DSN
	// notifications, or set to HDRS to request only the message headers.
	// 
	void put_DsnRet(const wchar_t *newVal);

	// 
	// 
	// When true , Chilkat embeds the signing certificate chain in signed email.
	// 
	// Certificates are included up to, but not including, the root certificate. If
	// IncludeRootCert is also true , the root CA certificate is included as well.
	// 
	// The default value is false
	// 
	bool get_EmbedCertChain(void);
	// 
	// 
	// When true , Chilkat embeds the signing certificate chain in signed email.
	// 
	// Certificates are included up to, but not including, the root certificate. If
	// IncludeRootCert is also true , the root CA certificate is included as well.
	// 
	// The default value is false
	// 
	void put_EmbedCertChain(bool newVal);

	// 
	// 
	// Enables automatic resolution of passwords and credentials from secure local
	// storage.
	// 
	// When set to true , supported properties and methods can accept a Chilkat
	// secret specification string instead of a literal password. Secret specification
	// strings begin with !! .
	// 
	// Chilkat resolves secrets from:
	// 
	//     * Windows Credential Manager on Windows.
	//     * Apple Keychain on macOS.
	// 
	// The secret specification format is: !![appName|]service[|domain]|username
	// 
	// This applies to PopPassword , SmtpPassword , HttpProxyPassword , SocksPassword ,
	// PopPasswordBase64 , and SshAuthenticatePw .
	// 
	// The default value is false .
	// 
	bool get_EnableSecrets(void);
	// 
	// 
	// Enables automatic resolution of passwords and credentials from secure local
	// storage.
	// 
	// When set to true , supported properties and methods can accept a Chilkat
	// secret specification string instead of a literal password. Secret specification
	// strings begin with !! .
	// 
	// Chilkat resolves secrets from:
	// 
	//     * Windows Credential Manager on Windows.
	//     * Apple Keychain on macOS.
	// 
	// The secret specification format is: !![appName|]service[|domain]|username
	// 
	// This applies to PopPassword , SmtpPassword , HttpProxyPassword , SocksPassword ,
	// PopPasswordBase64 , and SshAuthenticatePw .
	// 
	// The default value is false .
	// 
	void put_EnableSecrets(bool newVal);

	// 
	// 
	// Specifies a filter expression applied by methods such as LoadXmlFile ,
	// LoadXmlString , LoadMbx , CopyMail , and TransferMail .
	// 
	// When a filter is present, only emails matching the expression are returned. For
	// TransferMail , only matching emails are removed from the mail server.
	// 
	// Example expressions:
	// 
	//     Body like "mortgage rates*"
	//     Subject contains "update" and From contains "chilkat"
	//     To = "info@chilkatsoft.com"
	// 
	// Rules for filter expressions:
	// 
	//     * Any MIME header field name may be used. Header names are case-insensitive.
	//     * Literal strings are enclosed in double quotes.
	//     * String matching is case-insensitive.
	//     * The * wildcard matches zero or more characters.
	//     * Parentheses may be used to control precedence.
	//     * Logical operators are AND , OR , and NOT .
	//     * String comparison operators include CONTAINS and LIKE .
	// 
	// Note: Filtering works on text strings only, not dates or numbers.
	// 
	void get_Filter(CkString &str);
	// 
	// 
	// Specifies a filter expression applied by methods such as LoadXmlFile ,
	// LoadXmlString , LoadMbx , CopyMail , and TransferMail .
	// 
	// When a filter is present, only emails matching the expression are returned. For
	// TransferMail , only matching emails are removed from the mail server.
	// 
	// Example expressions:
	// 
	//     Body like "mortgage rates*"
	//     Subject contains "update" and From contains "chilkat"
	//     To = "info@chilkatsoft.com"
	// 
	// Rules for filter expressions:
	// 
	//     * Any MIME header field name may be used. Header names are case-insensitive.
	//     * Literal strings are enclosed in double quotes.
	//     * String matching is case-insensitive.
	//     * The * wildcard matches zero or more characters.
	//     * Parentheses may be used to control precedence.
	//     * Logical operators are AND , OR , and NOT .
	//     * String comparison operators include CONTAINS and LIKE .
	// 
	// Note: Filtering works on text strings only, not dates or numbers.
	// 
	const wchar_t *filter(void);
	// 
	// 
	// Specifies a filter expression applied by methods such as LoadXmlFile ,
	// LoadXmlString , LoadMbx , CopyMail , and TransferMail .
	// 
	// When a filter is present, only emails matching the expression are returned. For
	// TransferMail , only matching emails are removed from the mail server.
	// 
	// Example expressions:
	// 
	//     Body like "mortgage rates*"
	//     Subject contains "update" and From contains "chilkat"
	//     To = "info@chilkatsoft.com"
	// 
	// Rules for filter expressions:
	// 
	//     * Any MIME header field name may be used. Header names are case-insensitive.
	//     * Literal strings are enclosed in double quotes.
	//     * String matching is case-insensitive.
	//     * The * wildcard matches zero or more characters.
	//     * Parentheses may be used to control precedence.
	//     * Logical operators are AND , OR , and NOT .
	//     * String comparison operators include CONTAINS and LIKE .
	// 
	// Note: Filtering works on text strings only, not dates or numbers.
	// 
	void put_Filter(const wchar_t *newVal);

	// 
	// 
	// Specifies the interval, in milliseconds, between AbortCheck event callbacks.
	// 
	// This allows an application to periodically decide whether a long-running
	// operation should be aborted.
	// 
	// The default value is 0 , which means no AbortCheck callbacks are generated.
	// 
	int get_HeartbeatMs(void);
	// 
	// 
	// Specifies the interval, in milliseconds, between AbortCheck event callbacks.
	// 
	// This allows an application to periodically decide whether a long-running
	// operation should be aborted.
	// 
	// The default value is 0 , which means no AbortCheck callbacks are generated.
	// 
	void put_HeartbeatMs(int newVal);

	// 
	// 
	// Specifies the hostname sent in the SMTP EHLO or HELO command.
	// 
	// The default value is an empty string, which causes Chilkat to use the local
	// computer's hostname.
	// 
	void get_HeloHostname(CkString &str);
	// 
	// 
	// Specifies the hostname sent in the SMTP EHLO or HELO command.
	// 
	// The default value is an empty string, which causes Chilkat to use the local
	// computer's hostname.
	// 
	const wchar_t *heloHostname(void);
	// 
	// 
	// Specifies the hostname sent in the SMTP EHLO or HELO command.
	// 
	// The default value is an empty string, which causes Chilkat to use the local
	// computer's hostname.
	// 
	void put_HeloHostname(const wchar_t *newVal);

	// 
	// 
	// HttpProxyAuthMethod
	// 
	// Specifies the authentication method used when connecting through an HTTP proxy
	// that requires authentication.
	// 
	// Valid values are Basic and NTLM .
	// 
	void get_HttpProxyAuthMethod(CkString &str);
	// 
	// 
	// HttpProxyAuthMethod
	// 
	// Specifies the authentication method used when connecting through an HTTP proxy
	// that requires authentication.
	// 
	// Valid values are Basic and NTLM .
	// 
	const wchar_t *httpProxyAuthMethod(void);
	// 
	// 
	// HttpProxyAuthMethod
	// 
	// Specifies the authentication method used when connecting through an HTTP proxy
	// that requires authentication.
	// 
	// Valid values are Basic and NTLM .
	// 
	void put_HttpProxyAuthMethod(const wchar_t *newVal);

	// 
	// 
	// Specifies the optional NTLM domain when using NTLM authentication with an HTTP
	// proxy.
	// 
	void get_HttpProxyDomain(CkString &str);
	// 
	// 
	// Specifies the optional NTLM domain when using NTLM authentication with an HTTP
	// proxy.
	// 
	const wchar_t *httpProxyDomain(void);
	// 
	// 
	// Specifies the optional NTLM domain when using NTLM authentication with an HTTP
	// proxy.
	// 
	void put_HttpProxyDomain(const wchar_t *newVal);

	// 
	// 
	// Specifies the hostname or IPv4 address of the HTTP proxy to use.
	// 
	void get_HttpProxyHostname(CkString &str);
	// 
	// 
	// Specifies the hostname or IPv4 address of the HTTP proxy to use.
	// 
	const wchar_t *httpProxyHostname(void);
	// 
	// 
	// Specifies the hostname or IPv4 address of the HTTP proxy to use.
	// 
	void put_HttpProxyHostname(const wchar_t *newVal);

	// 
	// 
	// Specifies the password used when authenticating to an HTTP proxy.
	// 
	void get_HttpProxyPassword(CkString &str);
	// 
	// 
	// Specifies the password used when authenticating to an HTTP proxy.
	// 
	const wchar_t *httpProxyPassword(void);
	// 
	// 
	// Specifies the password used when authenticating to an HTTP proxy.
	// 
	void put_HttpProxyPassword(const wchar_t *newVal);

	// 
	// 
	// Specifies the port number of the HTTP proxy.
	// 
	// Common HTTP proxy ports include 8080 and 3128 .
	// 
	int get_HttpProxyPort(void);
	// 
	// 
	// Specifies the port number of the HTTP proxy.
	// 
	// Common HTTP proxy ports include 8080 and 3128 .
	// 
	void put_HttpProxyPort(int newVal);

	// 
	// 
	// Specifies the username used when authenticating to an HTTP proxy.
	// 
	void get_HttpProxyUsername(CkString &str);
	// 
	// 
	// Specifies the username used when authenticating to an HTTP proxy.
	// 
	const wchar_t *httpProxyUsername(void);
	// 
	// 
	// Specifies the username used when authenticating to an HTTP proxy.
	// 
	void put_HttpProxyUsername(const wchar_t *newVal);

	// 
	// 
	// Controls whether POP3 deletions are finalized immediately.
	// 
	// The default value is true . When enabled, any method that deletes email from
	// the POP3 server also sends a QUIT command and closes the POP3 session so the
	// deletion is committed immediately.
	// 
	// In POP3, the DELE command only marks a message for deletion. The message is not
	// actually deleted until the session ends with QUIT .
	// 
	// If ImmediateDelete is set to false , your application must call Pop3EndSession
	// to finalize the deletions.
	// 
	bool get_ImmediateDelete(void);
	// 
	// 
	// Controls whether POP3 deletions are finalized immediately.
	// 
	// The default value is true . When enabled, any method that deletes email from
	// the POP3 server also sends a QUIT command and closes the POP3 session so the
	// deletion is committed immediately.
	// 
	// In POP3, the DELE command only marks a message for deletion. The message is not
	// actually deleted until the session ends with QUIT .
	// 
	// If ImmediateDelete is set to false , your application must call Pop3EndSession
	// to finalize the deletions.
	// 
	void put_ImmediateDelete(bool newVal);

	// 
	// 
	// Controls whether the root CA certificate is included in the S/MIME signature of
	// a signed email.
	// 
	// This property only applies when EmbedCertChain is true .
	// 
	bool get_IncludeRootCert(void);
	// 
	// 
	// Controls whether the root CA certificate is included in the S/MIME signature of
	// a signed email.
	// 
	// This property only applies when EmbedCertChain is true .
	// 
	void put_IncludeRootCert(bool newVal);

	// 
	// 
	// Returns true if Chilkat believes the POP3 connection is still open.
	// 
	// Accessing this property does not send any command to the POP3 server. If the
	// server has disconnected but Chilkat has not yet attempted further communication,
	// this property may still return true .
	// 
	// To verify that the POP3 connection is actually alive, call Pop3Noop .
	// 
	bool get_IsPop3Connected(void);

	// 
	// 
	// Returns true if Chilkat believes the SMTP connection is still open.
	// 
	// Accessing this property does not communicate with the SMTP server. A lost
	// connection may not be detected until the next SMTP command is sent.
	// 
	// To verify that the SMTP connection is actually alive, call SmtpNoop .
	// 
	bool get_IsSmtpConnected(void);

	// 
	// 
	// Contains the last SMTP status code returned by the SMTP server during the most
	// recent SMTP operation.
	// 
	// SMTP status codes are numeric reply codes defined by the SMTP protocol. They
	// indicate the result of SMTP protocol commands such as EHLO , AUTH , MAIL FROM ,
	// RCPT TO , and DATA .
	// 
	// In general:
	// 
	//     * 2xx — Success. The requested action completed successfully.
	//     * 3xx — Intermediate success. Additional information or authentication data
	//     is required.
	//     * 4xx — Temporary failure. The operation failed, but retrying later may
	//     succeed.
	//     * 5xx — Permanent failure. The request was rejected and retrying will
	//     usually not help unless something changes.
	int get_LastSmtpStatus(void);

	// 
	// 
	// Contains the text message associated with the last SMTP status code received
	// from the server.
	// 
	void get_LastSmtpStatusMsg(CkString &str);
	// 
	// 
	// Contains the text message associated with the last SMTP status code received
	// from the server.
	// 
	const wchar_t *lastSmtpStatusMsg(void);

	// 
	// 
	// Specifies a local file path where Chilkat writes each message exactly as it was
	// received from the POP3 server.
	// 
	// This is useful for debugging problems involving MIME structure, encodings,
	// attachments, or server behavior.
	// 
	void get_LogMailReceivedFilename(CkString &str);
	// 
	// 
	// Specifies a local file path where Chilkat writes each message exactly as it was
	// received from the POP3 server.
	// 
	// This is useful for debugging problems involving MIME structure, encodings,
	// attachments, or server behavior.
	// 
	const wchar_t *logMailReceivedFilename(void);
	// 
	// 
	// Specifies a local file path where Chilkat writes each message exactly as it was
	// received from the POP3 server.
	// 
	// This is useful for debugging problems involving MIME structure, encodings,
	// attachments, or server behavior.
	// 
	void put_LogMailReceivedFilename(const wchar_t *newVal);

	// 
	// 
	// Specifies a local file path where Chilkat writes the exact MIME message sent to
	// the SMTP server.
	// 
	// This is useful for inspecting the final MIME produced by Chilkat.
	// 
	void get_LogMailSentFilename(CkString &str);
	// 
	// 
	// Specifies a local file path where Chilkat writes the exact MIME message sent to
	// the SMTP server.
	// 
	// This is useful for inspecting the final MIME produced by Chilkat.
	// 
	const wchar_t *logMailSentFilename(void);
	// 
	// 
	// Specifies a local file path where Chilkat writes the exact MIME message sent to
	// the SMTP server.
	// 
	// This is useful for inspecting the final MIME produced by Chilkat.
	// 
	void put_LogMailSentFilename(const wchar_t *newVal);

	// 
	// 
	// Specifies the POP3 server hostname or IP address.
	// 
	// Do not include http:// or https:// . The value should be a hostname such as
	// pop.example.com or an IPv4/IPv6 address.
	// 
	void get_MailHost(CkString &str);
	// 
	// 
	// Specifies the POP3 server hostname or IP address.
	// 
	// Do not include http:// or https:// . The value should be a hostname such as
	// pop.example.com or an IPv4/IPv6 address.
	// 
	const wchar_t *mailHost(void);
	// 
	// 
	// Specifies the POP3 server hostname or IP address.
	// 
	// Do not include http:// or https:// . The value should be a hostname such as
	// pop.example.com or an IPv4/IPv6 address.
	// 
	void put_MailHost(const wchar_t *newVal);

	// 
	// 
	// Specifies the POP3 server port number.
	// 
	// The default value is 110 .
	// 
	// The standard POP3 ports and their associated Chilkat.MailMan property settings
	// are described below.
	// 
	// Port 995 — POP3 over Implicit SSL/TLS
	// 
	// Uses implicit SSL/TLS, meaning the TLS connection is established immediately
	// when the TCP connection is opened.
	// 
	// mailman.MailPort = 995;
	// mailman.PopSsl = true;
	//  
	// 
	// Port 110 — Standard Unencrypted POP3
	// 
	// Uses a normal unencrypted POP3 connection.
	// 
	// mailman.MailPort = 110;
	// mailman.PopSsl = false;
	// mailman.Pop3Stls = false;
	// mailman.Pop3StlsIfPossible = false;
	//  
	// 
	// Port 110 — POP3 with Explicit TLS via STLS
	// 
	// The connection begins unencrypted and is upgraded to TLS using the POP3 STLS
	// command.
	// 
	// mailman.MailPort = 110;
	// mailman.PopSsl = false;
	// mailman.Pop3Stls = true;
	//  
	// 
	// Port 110 — Opportunistic STLS
	// 
	// Attempts to upgrade the connection to TLS using STLS if the POP3 server supports
	// it. Otherwise, the connection remains unencrypted.
	// 
	// mailman.MailPort = 110;
	// mailman.PopSsl = false;
	// mailman.Pop3StlsIfPossible = true;
	//  
	// 
	// Important: PopSsl and Pop3Stls represent two different approaches to TLS
	// security:
	// 
	//     * PopSsl = true means the connection begins as SSL/TLS from the very start
	//     (implicit TLS).
	//     * Pop3Stls = true means the connection begins unencrypted and is later
	//     upgraded to TLS using the POP3 STLS command (explicit TLS).
	// 
	// These two approaches are mutually exclusive and should not both be enabled at
	// the same time.
	// 
	// Modern POP3 servers most commonly use either:
	// 
	//     * 995 with PopSsl = true , or
	//     * 110 with Pop3Stls = true .
	int get_MailPort(void);
	// 
	// 
	// Specifies the POP3 server port number.
	// 
	// The default value is 110 .
	// 
	// The standard POP3 ports and their associated Chilkat.MailMan property settings
	// are described below.
	// 
	// Port 995 — POP3 over Implicit SSL/TLS
	// 
	// Uses implicit SSL/TLS, meaning the TLS connection is established immediately
	// when the TCP connection is opened.
	// 
	// mailman.MailPort = 995;
	// mailman.PopSsl = true;
	//  
	// 
	// Port 110 — Standard Unencrypted POP3
	// 
	// Uses a normal unencrypted POP3 connection.
	// 
	// mailman.MailPort = 110;
	// mailman.PopSsl = false;
	// mailman.Pop3Stls = false;
	// mailman.Pop3StlsIfPossible = false;
	//  
	// 
	// Port 110 — POP3 with Explicit TLS via STLS
	// 
	// The connection begins unencrypted and is upgraded to TLS using the POP3 STLS
	// command.
	// 
	// mailman.MailPort = 110;
	// mailman.PopSsl = false;
	// mailman.Pop3Stls = true;
	//  
	// 
	// Port 110 — Opportunistic STLS
	// 
	// Attempts to upgrade the connection to TLS using STLS if the POP3 server supports
	// it. Otherwise, the connection remains unencrypted.
	// 
	// mailman.MailPort = 110;
	// mailman.PopSsl = false;
	// mailman.Pop3StlsIfPossible = true;
	//  
	// 
	// Important: PopSsl and Pop3Stls represent two different approaches to TLS
	// security:
	// 
	//     * PopSsl = true means the connection begins as SSL/TLS from the very start
	//     (implicit TLS).
	//     * Pop3Stls = true means the connection begins unencrypted and is later
	//     upgraded to TLS using the POP3 STLS command (explicit TLS).
	// 
	// These two approaches are mutually exclusive and should not both be enabled at
	// the same time.
	// 
	// Modern POP3 servers most commonly use either:
	// 
	//     * 995 with PopSsl = true , or
	//     * 110 with Pop3Stls = true .
	void put_MailPort(int newVal);

	// 
	// 
	// Limits the number of messages Chilkat attempts to retrieve from the POP3 server
	// in a single method call.
	// 
	// This is useful for large mailboxes. For example, setting MaxCount = 100 allows
	// an application to download messages in batches of 100.
	// 
	int get_MaxCount(void);
	// 
	// 
	// Limits the number of messages Chilkat attempts to retrieve from the POP3 server
	// in a single method call.
	// 
	// This is useful for large mailboxes. For example, setting MaxCount = 100 allows
	// an application to download messages in batches of 100.
	// 
	void put_MaxCount(int newVal);

	// 
	// 
	// Specifies the OAuth2 access token to be used for POP3 or SMTP XOAUTH2
	// authentication.
	// 
	// When this property is set, Chilkat will use the SMTP or POP3 AUTH XOAUTH2
	// authentication mechanism if supported by the server.
	// 
	// For POP3 XOAUTH2 authentication:
	// 
	//     * PopPassword should be left empty, or explicitly set to the empty string.
	//     * SmtpPassword should be left unset, or set to the empty string.
	// 
	// The OAuth2 access token is sent as a bearer token during the AUTH XOAUTH2
	// authentication exchange.
	// 
	void get_OAuth2AccessToken(CkString &str);
	// 
	// 
	// Specifies the OAuth2 access token to be used for POP3 or SMTP XOAUTH2
	// authentication.
	// 
	// When this property is set, Chilkat will use the SMTP or POP3 AUTH XOAUTH2
	// authentication mechanism if supported by the server.
	// 
	// For POP3 XOAUTH2 authentication:
	// 
	//     * PopPassword should be left empty, or explicitly set to the empty string.
	//     * SmtpPassword should be left unset, or set to the empty string.
	// 
	// The OAuth2 access token is sent as a bearer token during the AUTH XOAUTH2
	// authentication exchange.
	// 
	const wchar_t *oAuth2AccessToken(void);
	// 
	// 
	// Specifies the OAuth2 access token to be used for POP3 or SMTP XOAUTH2
	// authentication.
	// 
	// When this property is set, Chilkat will use the SMTP or POP3 AUTH XOAUTH2
	// authentication mechanism if supported by the server.
	// 
	// For POP3 XOAUTH2 authentication:
	// 
	//     * PopPassword should be left empty, or explicitly set to the empty string.
	//     * SmtpPassword should be left unset, or set to the empty string.
	// 
	// The OAuth2 access token is sent as a bearer token during the AUTH XOAUTH2
	// authentication exchange.
	// 
	void put_OAuth2AccessToken(const wchar_t *newVal);

	// 
	// 
	// Controls the MIME format used for digitally signed email.
	// 
	// When set to false , Chilkat creates a multipart/signed email. In this format,
	// the original email content remains visible as a normal MIME body part, and the
	// digital signature is included as a separate MIME part.
	// 
	// The top-level MIME Content-Type header will look similar to:
	// 
	// Content-Type: multipart/signed;
	//     protocol="application/pkcs7-signature";
	//     micalg=sha-256;
	//     boundary="------------040808030405050402070604"
	// 
	// This is commonly referred to as a detached signature because the signed content
	// exists separately from the signature itself.
	// 
	// When set to true , Chilkat creates an opaque signed email using PKCS#7
	// signed-data format. In this case, the original MIME content is encapsulated
	// inside the PKCS#7 signature structure.
	// 
	// The top-level MIME Content-Type header will look similar to:
	// 
	// Content-Type: application/pkcs7-mime;
	//     smime-type="signed-data";
	//     name="smime.p7m"; micalg=sha-256
	// 
	// This format is historically known as opaque signing because the original message
	// content is wrapped inside the PKCS#7 signed object and is not directly visible
	// as ordinary MIME body parts.
	// 
	// The default value is true .
	// 
	bool get_OpaqueSigning(void);
	// 
	// 
	// Controls the MIME format used for digitally signed email.
	// 
	// When set to false , Chilkat creates a multipart/signed email. In this format,
	// the original email content remains visible as a normal MIME body part, and the
	// digital signature is included as a separate MIME part.
	// 
	// The top-level MIME Content-Type header will look similar to:
	// 
	// Content-Type: multipart/signed;
	//     protocol="application/pkcs7-signature";
	//     micalg=sha-256;
	//     boundary="------------040808030405050402070604"
	// 
	// This is commonly referred to as a detached signature because the signed content
	// exists separately from the signature itself.
	// 
	// When set to true , Chilkat creates an opaque signed email using PKCS#7
	// signed-data format. In this case, the original MIME content is encapsulated
	// inside the PKCS#7 signature structure.
	// 
	// The top-level MIME Content-Type header will look similar to:
	// 
	// Content-Type: application/pkcs7-mime;
	//     smime-type="signed-data";
	//     name="smime.p7m"; micalg=sha-256
	// 
	// This format is historically known as opaque signing because the original message
	// content is wrapped inside the PKCS#7 signed object and is not directly visible
	// as ordinary MIME body parts.
	// 
	// The default value is true .
	// 
	void put_OpaqueSigning(bool newVal);

	// 
	// 
	// Specifies the filename used in the Content-Disposition header when sending a
	// PKCS#7 encrypted email.
	// 
	// The default value is smime.p7m .
	// 
	void get_P7mEncryptAttachFilename(CkString &str);
	// 
	// 
	// Specifies the filename used in the Content-Disposition header when sending a
	// PKCS#7 encrypted email.
	// 
	// The default value is smime.p7m .
	// 
	const wchar_t *p7mEncryptAttachFilename(void);
	// 
	// 
	// Specifies the filename used in the Content-Disposition header when sending a
	// PKCS#7 encrypted email.
	// 
	// The default value is smime.p7m .
	// 
	void put_P7mEncryptAttachFilename(const wchar_t *newVal);

	// 
	// 
	// Specifies the filename used in the Content-Disposition header when sending an
	// opaque signed PKCS#7 email.
	// 
	// The default value is smime.p7m .
	// 
	void get_P7mSigAttachFilename(CkString &str);
	// 
	// 
	// Specifies the filename used in the Content-Disposition header when sending an
	// opaque signed PKCS#7 email.
	// 
	// The default value is smime.p7m .
	// 
	const wchar_t *p7mSigAttachFilename(void);
	// 
	// 
	// Specifies the filename used in the Content-Disposition header when sending an
	// opaque signed PKCS#7 email.
	// 
	// The default value is smime.p7m .
	// 
	void put_P7mSigAttachFilename(const wchar_t *newVal);

	// 
	// 
	// Specifies the filename used in the Content-Disposition header when sending a
	// signed email with a detached PKCS#7 signature.
	// 
	// The default value is smime.p7s .
	// 
	void get_P7sSigAttachFilename(CkString &str);
	// 
	// 
	// Specifies the filename used in the Content-Disposition header when sending a
	// signed email with a detached PKCS#7 signature.
	// 
	// The default value is smime.p7s .
	// 
	const wchar_t *p7sSigAttachFilename(void);
	// 
	// 
	// Specifies the filename used in the Content-Disposition header when sending a
	// signed email with a detached PKCS#7 signature.
	// 
	// The default value is smime.p7s .
	// 
	void put_P7sSigAttachFilename(const wchar_t *newVal);

	// 
	// 
	// This property is only valid in programming environments and languages that allow
	// for event callbacks.
	// 
	// Sets the value that represents 100% completion for PercentDone event callbacks.
	// 
	// The default value is 100 , meaning progress values range from 0 to 100 . Setting
	// this property to a larger value provides finer granularity. For example, setting
	// PercentDoneScale = 1000 allows progress to be reported in tenths of a percent.
	// 
	// For example, if PercentDoneScale = 1000 , then a callback value of 453
	// represents 45.3% complete.
	// 
	// The value is clamped to a minimum of 10 and a maximum of 100000 .
	// 
	int get_PercentDoneScale(void);
	// 
	// 
	// This property is only valid in programming environments and languages that allow
	// for event callbacks.
	// 
	// Sets the value that represents 100% completion for PercentDone event callbacks.
	// 
	// The default value is 100 , meaning progress values range from 0 to 100 . Setting
	// this property to a larger value provides finer granularity. For example, setting
	// PercentDoneScale = 1000 allows progress to be reported in tenths of a percent.
	// 
	// For example, if PercentDoneScale = 1000 , then a callback value of 453
	// represents 45.3% complete.
	// 
	// The value is clamped to a minimum of 10 and a maximum of 100000 .
	// 
	void put_PercentDoneScale(int newVal);

	// 
	// 
	// Returns 0 when no POP3 session is active.
	// 
	// Otherwise, returns a positive integer that increments each time a new POP3
	// session is established. This can be used to detect whether a new session has
	// started.
	// 
	int get_Pop3SessionId(void);

	// 
	// 
	// Contains the accumulated raw POP3 commands sent to the server and the raw
	// responses received from the server.
	// 
	// This property is read-only. To clear it, call ClearPop3SessionLog .
	// 
	void get_Pop3SessionLog(CkString &str);
	// 
	// 
	// Contains the accumulated raw POP3 commands sent to the server and the raw
	// responses received from the server.
	// 
	// This property is read-only. To clear it, call ClearPop3SessionLog .
	// 
	const wchar_t *pop3SessionLog(void);

	// 
	// 
	// Controls whether SPA, also known as NTLM authentication, is used for POP3.
	// 
	// Set this property to true to use SPA authentication. No other programming
	// changes are required.
	// 
	// The default value is false .
	// 
	// Note: If SPA/NTLM authentication fails, set Global.DefaultNtlmVersion = 1 and
	// retry.
	// 
	bool get_Pop3SPA(void);
	// 
	// 
	// Controls whether SPA, also known as NTLM authentication, is used for POP3.
	// 
	// Set this property to true to use SPA authentication. No other programming
	// changes are required.
	// 
	// The default value is false .
	// 
	// Note: If SPA/NTLM authentication fails, set Global.DefaultNtlmVersion = 1 and
	// retry.
	// 
	void put_Pop3SPA(bool newVal);

	// 
	// 
	// Indicates whether the POP3 server's SSL/TLS certificate was successfully
	// verified during the connection.
	// 
	// This property is meaningful only when connecting via SSL/TLS.
	// 
	bool get_Pop3SslServerCertVerified(void);

	// 
	// 
	// Controls whether Chilkat requires the POP3 connection to be upgraded to TLS
	// using the STLS command.
	// 
	// When set to true , Chilkat initially connects without encryption, typically on
	// port 110 , and then sends STLS to convert the connection to TLS.
	// 
	// Use this only with POP3 servers known to support STLS . When this property is
	// true , PopSsl should be false .
	// 
	// The default value is false .
	// 
	bool get_Pop3Stls(void);
	// 
	// 
	// Controls whether Chilkat requires the POP3 connection to be upgraded to TLS
	// using the STLS command.
	// 
	// When set to true , Chilkat initially connects without encryption, typically on
	// port 110 , and then sends STLS to convert the connection to TLS.
	// 
	// Use this only with POP3 servers known to support STLS . When this property is
	// true , PopSsl should be false .
	// 
	// The default value is false .
	// 
	void put_Pop3Stls(bool newVal);

	// 
	// 
	// Controls whether Chilkat uses POP3 STLS automatically when the server supports
	// it.
	// 
	// If the server supports STLS , the connection is upgraded to TLS. If the server
	// does not support STLS , the connection remains unencrypted.
	// 
	// The default value is false .
	// 
	bool get_Pop3StlsIfPossible(void);
	// 
	// 
	// Controls whether Chilkat uses POP3 STLS automatically when the server supports
	// it.
	// 
	// If the server supports STLS , the connection is upgraded to TLS. If the server
	// does not support STLS , the connection remains unencrypted.
	// 
	// The default value is false .
	// 
	void put_Pop3StlsIfPossible(bool newVal);

	// 
	// 
	// Specifies the POP3 password.
	// 
	// On Windows, if Pop3SPA is enabled, both PopUsername and PopPassword may be set
	// to "default" to use the credentials of the current logged-on Windows user.
	// 
	void get_PopPassword(CkString &str);
	// 
	// 
	// Specifies the POP3 password.
	// 
	// On Windows, if Pop3SPA is enabled, both PopUsername and PopPassword may be set
	// to "default" to use the credentials of the current logged-on Windows user.
	// 
	const wchar_t *popPassword(void);
	// 
	// 
	// Specifies the POP3 password.
	// 
	// On Windows, if Pop3SPA is enabled, both PopUsername and PopPassword may be set
	// to "default" to use the credentials of the current logged-on Windows user.
	// 
	void put_PopPassword(const wchar_t *newVal);

	// 
	// 
	// Provides a way to specify the POP3 password as a Base64-encoded string.
	// 
	void get_PopPasswordBase64(CkString &str);
	// 
	// 
	// Provides a way to specify the POP3 password as a Base64-encoded string.
	// 
	const wchar_t *popPasswordBase64(void);
	// 
	// 
	// Provides a way to specify the POP3 password as a Base64-encoded string.
	// 
	void put_PopPasswordBase64(const wchar_t *newVal);

	// 
	// 
	// Controls whether implicit SSL/TLS is used when connecting to the POP3 server.
	// 
	// When set to true , the TLS connection is established immediately when
	// connecting. The POP3 SSL/TLS port is typically 995 .
	// 
	// The default value is false .
	// 
	bool get_PopSsl(void);
	// 
	// 
	// Controls whether implicit SSL/TLS is used when connecting to the POP3 server.
	// 
	// When set to true , the TLS connection is established immediately when
	// connecting. The POP3 SSL/TLS port is typically 995 .
	// 
	// The default value is false .
	// 
	void put_PopSsl(bool newVal);

	// 
	// 
	// Specifies the POP3 login name.
	// 
	// On Windows, if Pop3SPA is enabled, both PopUsername and PopPassword may be set
	// to "default" to use the credentials of the current logged-on Windows user.
	// 
	void get_PopUsername(CkString &str);
	// 
	// 
	// Specifies the POP3 login name.
	// 
	// On Windows, if Pop3SPA is enabled, both PopUsername and PopPassword may be set
	// to "default" to use the credentials of the current logged-on Windows user.
	// 
	const wchar_t *popUsername(void);
	// 
	// 
	// Specifies the POP3 login name.
	// 
	// On Windows, if Pop3SPA is enabled, both PopUsername and PopPassword may be set
	// to "default" to use the credentials of the current logged-on Windows user.
	// 
	void put_PopUsername(const wchar_t *newVal);

	// 
	// 
	// Controls whether IPv6 is preferred over IPv4 when both are available for a
	// hostname.
	// 
	// The default value is false , which means IPv4 is preferred.
	// 
	bool get_PreferIpv6(void);
	// 
	// 
	// Controls whether IPv6 is preferred over IPv4 when both are available for a
	// hostname.
	// 
	// The default value is false , which means IPv4 is preferred.
	// 
	void put_PreferIpv6(bool newVal);

	// 
	// 
	// Specifies the maximum number of seconds to wait when the SMTP or POP3 server
	// stops responding.
	// 
	// The default value is 30 seconds.
	// 
	int get_ReadTimeout(void);
	// 
	// 
	// Specifies the maximum number of seconds to wait when the SMTP or POP3 server
	// stops responding.
	// 
	// The default value is 30 seconds.
	// 
	void put_ReadTimeout(int newVal);

	// 
	// 
	// Controls whether Chilkat requires SMTP and POP3 SSL/TLS server certificates to
	// be successfully verified.
	// 
	// When set to true , Chilkat rejects the connection if the server certificate is
	// expired or if the certificate signature cannot be verified.
	// 
	// The default value is false .
	// 
	// This property applies only to SSL/TLS connections.
	// 
	bool get_RequireSslCertVerify(void);
	// 
	// 
	// Controls whether Chilkat requires SMTP and POP3 SSL/TLS server certificates to
	// be successfully verified.
	// 
	// When set to true , Chilkat rejects the connection if the server certificate is
	// expired or if the certificate signature cannot be verified.
	// 
	// The default value is false .
	// 
	// This property applies only to SSL/TLS connections.
	// 
	void put_RequireSslCertVerify(bool newVal);

	// 
	// 
	// Controls whether the email's Date header is reset to the current date and time
	// when an email is loaded.
	// 
	// This applies to methods such as LoadMbx , LoadEml , LoadMime , LoadXml , and
	// LoadXmlString .
	// 
	// The default value is false .
	// 
	bool get_ResetDateOnLoad(void);
	// 
	// 
	// Controls whether the email's Date header is reset to the current date and time
	// when an email is loaded.
	// 
	// This applies to methods such as LoadMbx , LoadEml , LoadMime , LoadXml , and
	// LoadXmlString .
	// 
	// The default value is false .
	// 
	void put_ResetDateOnLoad(bool newVal);

	// 
	// 
	// Specifies the buffer size used by the underlying TCP/IP socket when sending
	// data.
	// 
	// The default value is 32767 .
	// 
	int get_SendBufferSize(void);
	// 
	// 
	// Specifies the buffer size used by the underlying TCP/IP socket when sending
	// data.
	// 
	// The default value is 32767 .
	// 
	void put_SendBufferSize(int newVal);

	// 
	// 
	// Controls how email is sent to distribution lists.
	// 
	// When true , Chilkat sends one email per recipient. Each message has the
	// recipient's address in the To header.
	// 
	// When false , Chilkat sends messages in batches of up to 100 BCC recipients at
	// a time.
	// 
	// For example, a distribution list with 350 recipients would result in four
	// messages: three with 100 BCC recipients, and one with 50 BCC recipients.
	// 
	// The default value is true .
	// 
	bool get_SendIndividual(void);
	// 
	// 
	// Controls how email is sent to distribution lists.
	// 
	// When true , Chilkat sends one email per recipient. Each message has the
	// recipient's address in the To header.
	// 
	// When false , Chilkat sends messages in batches of up to 100 BCC recipients at
	// a time.
	// 
	// For example, a distribution list with 350 recipients would result in four
	// messages: three with 100 BCC recipients, and one with 50 BCC recipients.
	// 
	// The default value is true .
	// 
	void put_SendIndividual(bool newVal);

	// 
	// 
	// Specifies the maximum size, in bytes, of messages Chilkat will retrieve from a
	// POP3 server.
	// 
	// Messages larger than this limit are not downloaded.
	// 
	// The default value is 0 , which means no size limit.
	// 
	int get_SizeLimit(void);
	// 
	// 
	// Specifies the maximum size, in bytes, of messages Chilkat will retrieve from a
	// POP3 server.
	// 
	// Messages larger than this limit are not downloaded.
	// 
	// The default value is 0 , which means no size limit.
	// 
	void put_SizeLimit(int newVal);

	// 
	// 
	// Specifies the SMTP authentication method to use.
	// 
	// This property should usually be left empty so Chilkat can automatically choose
	// the most secure method advertised by the SMTP server.
	// 
	// If the server does not advertise authentication methods, or if a specific method
	// must be forced, set this property to one of: NONE , LOGIN , PLAIN , CRAM-MD5 ,
	// or NTLM .
	// 
	// Note: If NTLM authentication fails, set Global.DefaultNtlmVersion = 1 and retry.
	// 
	void get_SmtpAuthMethod(CkString &str);
	// 
	// 
	// Specifies the SMTP authentication method to use.
	// 
	// This property should usually be left empty so Chilkat can automatically choose
	// the most secure method advertised by the SMTP server.
	// 
	// If the server does not advertise authentication methods, or if a specific method
	// must be forced, set this property to one of: NONE , LOGIN , PLAIN , CRAM-MD5 ,
	// or NTLM .
	// 
	// Note: If NTLM authentication fails, set Global.DefaultNtlmVersion = 1 and retry.
	// 
	const wchar_t *smtpAuthMethod(void);
	// 
	// 
	// Specifies the SMTP authentication method to use.
	// 
	// This property should usually be left empty so Chilkat can automatically choose
	// the most secure method advertised by the SMTP server.
	// 
	// If the server does not advertise authentication methods, or if a specific method
	// must be forced, set this property to one of: NONE , LOGIN , PLAIN , CRAM-MD5 ,
	// or NTLM .
	// 
	// Note: If NTLM authentication fails, set Global.DefaultNtlmVersion = 1 and retry.
	// 
	void put_SmtpAuthMethod(const wchar_t *newVal);

	// 
	// 
	// Contains a keyword describing the result or failure reason for the last SMTP
	// operation.
	// 
	// Success : The method succeeded.
	// Failed : A general failure occurred.
	// NoValidRecipients : The SMTP server rejected all recipients.
	// NoRecipients : No To, CC, or BCC recipients were provided.
	// SomeBadRecipients : AllOrNone is true and some recipients were rejected.
	// Aborted : The application aborted the operation.
	// NoFrom : No FROM address was provided.
	// FromFailure : The server rejected the MAIL FROM command.
	// NoCredentials : Required credentials were not provided.
	// AuthFailure : SMTP authentication failed.
	// DataFailure : The server returned an error in response to DATA .
	// NoSmtpHostname : No SMTP hostname or IP address was provided.
	// StartTlsFailed : Failed to upgrade the connection using STARTTLS.
	// ConnectFailed : Could not establish the TCP or TLS connection.
	// GreetingError : The SMTP server returned an error in the initial greeting.
	// ConnectionLost : The SMTP connection was lost during the operation.
	// Timeout : A socket read or write timeout occurred.
	// RenderFailed : The email could not be rendered for sending.
	// NotUnlocked : UnlockBundle was not called on at least one MailMan instance.
	// InternalFailure : An internal failure occurred and should be reported to Chilkat
	// support.
	void get_SmtpFailReason(CkString &str);
	// 
	// 
	// Contains a keyword describing the result or failure reason for the last SMTP
	// operation.
	// 
	// Success : The method succeeded.
	// Failed : A general failure occurred.
	// NoValidRecipients : The SMTP server rejected all recipients.
	// NoRecipients : No To, CC, or BCC recipients were provided.
	// SomeBadRecipients : AllOrNone is true and some recipients were rejected.
	// Aborted : The application aborted the operation.
	// NoFrom : No FROM address was provided.
	// FromFailure : The server rejected the MAIL FROM command.
	// NoCredentials : Required credentials were not provided.
	// AuthFailure : SMTP authentication failed.
	// DataFailure : The server returned an error in response to DATA .
	// NoSmtpHostname : No SMTP hostname or IP address was provided.
	// StartTlsFailed : Failed to upgrade the connection using STARTTLS.
	// ConnectFailed : Could not establish the TCP or TLS connection.
	// GreetingError : The SMTP server returned an error in the initial greeting.
	// ConnectionLost : The SMTP connection was lost during the operation.
	// Timeout : A socket read or write timeout occurred.
	// RenderFailed : The email could not be rendered for sending.
	// NotUnlocked : UnlockBundle was not called on at least one MailMan instance.
	// InternalFailure : An internal failure occurred and should be reported to Chilkat
	// support.
	const wchar_t *smtpFailReason(void);

	// 
	// 
	// Specifies the SMTP server hostname or IP address.
	// 
	// Do not include http:// or https:// . The value may be a hostname, IPv4 address,
	// or IPv6 address.
	// 
	void get_SmtpHost(CkString &str);
	// 
	// 
	// Specifies the SMTP server hostname or IP address.
	// 
	// Do not include http:// or https:// . The value may be a hostname, IPv4 address,
	// or IPv6 address.
	// 
	const wchar_t *smtpHost(void);
	// 
	// 
	// Specifies the SMTP server hostname or IP address.
	// 
	// Do not include http:// or https:// . The value may be a hostname, IPv4 address,
	// or IPv6 address.
	// 
	void put_SmtpHost(const wchar_t *newVal);

	// 
	// 
	// Specifies the Windows domain to use when logging in to an SMTP server with NTLM
	// authentication.
	// 
	// Leave this property empty if no domain is required.
	// 
	void get_SmtpLoginDomain(CkString &str);
	// 
	// 
	// Specifies the Windows domain to use when logging in to an SMTP server with NTLM
	// authentication.
	// 
	// Leave this property empty if no domain is required.
	// 
	const wchar_t *smtpLoginDomain(void);
	// 
	// 
	// Specifies the Windows domain to use when logging in to an SMTP server with NTLM
	// authentication.
	// 
	// Leave this property empty if no domain is required.
	// 
	void put_SmtpLoginDomain(const wchar_t *newVal);

	// 
	// 
	// Specifies the SMTP envelope sender address used in the MAIL FROM command.
	// 
	// This address receives bounce messages and identifies the originator of the SMTP
	// transaction. It may differ from the From MIME header.
	// 
	// If left empty, Chilkat uses the email address from the message's From header.
	// 
	// SMTP servers may reject the envelope sender based on DNS, SPF, or other server
	// policy checks.
	// 
	void get_SmtpMailFrom(CkString &str);
	// 
	// 
	// Specifies the SMTP envelope sender address used in the MAIL FROM command.
	// 
	// This address receives bounce messages and identifies the originator of the SMTP
	// transaction. It may differ from the From MIME header.
	// 
	// If left empty, Chilkat uses the email address from the message's From header.
	// 
	// SMTP servers may reject the envelope sender based on DNS, SPF, or other server
	// policy checks.
	// 
	const wchar_t *smtpMailFrom(void);
	// 
	// 
	// Specifies the SMTP envelope sender address used in the MAIL FROM command.
	// 
	// This address receives bounce messages and identifies the originator of the SMTP
	// transaction. It may differ from the From MIME header.
	// 
	// If left empty, Chilkat uses the email address from the message's From header.
	// 
	// SMTP servers may reject the envelope sender based on DNS, SPF, or other server
	// policy checks.
	// 
	void put_SmtpMailFrom(const wchar_t *newVal);

	// 
	// 
	// Specifies the password used for SMTP authentication.
	// 
	// Chilkat supports SMTP authentication methods such as LOGIN , PLAIN , CRAM-MD5 ,
	// and NTLM , and normally chooses the most secure available method automatically.
	// 
	// If NTLM authentication is used, SmtpUsername and SmtpPassword may be set to the
	// keyword "default" to use the current Windows logged-on credentials.
	// 
	void get_SmtpPassword(CkString &str);
	// 
	// 
	// Specifies the password used for SMTP authentication.
	// 
	// Chilkat supports SMTP authentication methods such as LOGIN , PLAIN , CRAM-MD5 ,
	// and NTLM , and normally chooses the most secure available method automatically.
	// 
	// If NTLM authentication is used, SmtpUsername and SmtpPassword may be set to the
	// keyword "default" to use the current Windows logged-on credentials.
	// 
	const wchar_t *smtpPassword(void);
	// 
	// 
	// Specifies the password used for SMTP authentication.
	// 
	// Chilkat supports SMTP authentication methods such as LOGIN , PLAIN , CRAM-MD5 ,
	// and NTLM , and normally chooses the most secure available method automatically.
	// 
	// If NTLM authentication is used, SmtpUsername and SmtpPassword may be set to the
	// keyword "default" to use the current Windows logged-on credentials.
	// 
	void put_SmtpPassword(const wchar_t *newVal);

	// 
	// 
	// Controls whether SMTP pipelining is used when the server advertises support for
	// it.
	// 
	// The default value is true .
	// 
	// Set this property to false to prevent SMTP pipelining. This is required when
	// using AllOrNone .
	// 
	bool get_SmtpPipelining(void);
	// 
	// 
	// Controls whether SMTP pipelining is used when the server advertises support for
	// it.
	// 
	// The default value is true .
	// 
	// Set this property to false to prevent SMTP pipelining. This is required when
	// using AllOrNone .
	// 
	void put_SmtpPipelining(bool newVal);

	// 
	// 
	// Specifies the SMTP server port.
	// 
	// The default value is 25 . If using implicit SSL/TLS with SmtpSsl = true , the
	// common port is 465 .
	// 
	int get_SmtpPort(void);
	// 
	// 
	// Specifies the SMTP server port.
	// 
	// The default value is 25 . If using implicit SSL/TLS with SmtpSsl = true , the
	// common port is 465 .
	// 
	void put_SmtpPort(int newVal);

	// 
	// 
	// Contains the accumulated raw SMTP commands sent to the server and raw responses
	// received from the server.
	// 
	// This property is read-only. To clear it, call ClearSmtpSessionLog .
	// 
	void get_SmtpSessionLog(CkString &str);
	// 
	// 
	// Contains the accumulated raw SMTP commands sent to the server and raw responses
	// received from the server.
	// 
	// This property is read-only. To clear it, call ClearSmtpSessionLog .
	// 
	const wchar_t *smtpSessionLog(void);

	// 
	// 
	// Controls whether Chilkat uses implicit SSL/TLS when connecting to the SMTP
	// server.
	// 
	// When set to true , the TLS connection is established immediately when the TCP
	// connection is opened.
	// 
	bool get_SmtpSsl(void);
	// 
	// 
	// Controls whether Chilkat uses implicit SSL/TLS when connecting to the SMTP
	// server.
	// 
	// When set to true , the TLS connection is established immediately when the TCP
	// connection is opened.
	// 
	void put_SmtpSsl(bool newVal);

	// 
	// 
	// Indicates whether the SMTP server's SSL/TLS certificate was successfully
	// verified during the connection.
	// 
	// This property is meaningful only when an SSL/TLS SMTP connection is used.
	// 
	bool get_SmtpSslServerCertVerified(void);

	// 
	// 
	// Specifies the username used for SMTP authentication.
	// 
	// If SmtpAuthMethod is NTLM , SmtpUsername and SmtpPassword may be set to the
	// keyword "default" to use the current Windows logged-on credentials.
	// 
	void get_SmtpUsername(CkString &str);
	// 
	// 
	// Specifies the username used for SMTP authentication.
	// 
	// If SmtpAuthMethod is NTLM , SmtpUsername and SmtpPassword may be set to the
	// keyword "default" to use the current Windows logged-on credentials.
	// 
	const wchar_t *smtpUsername(void);
	// 
	// 
	// Specifies the username used for SMTP authentication.
	// 
	// If SmtpAuthMethod is NTLM , SmtpUsername and SmtpPassword may be set to the
	// keyword "default" to use the current Windows logged-on credentials.
	// 
	void put_SmtpUsername(const wchar_t *newVal);

	// 
	// 
	// Specifies the SOCKS4 or SOCKS5 proxy hostname or IPv4 address.
	// 
	// This property is used only when SocksVersion is set to 4 or 5 .
	// 
	void get_SocksHostname(CkString &str);
	// 
	// 
	// Specifies the SOCKS4 or SOCKS5 proxy hostname or IPv4 address.
	// 
	// This property is used only when SocksVersion is set to 4 or 5 .
	// 
	const wchar_t *socksHostname(void);
	// 
	// 
	// Specifies the SOCKS4 or SOCKS5 proxy hostname or IPv4 address.
	// 
	// This property is used only when SocksVersion is set to 4 or 5 .
	// 
	void put_SocksHostname(const wchar_t *newVal);

	// 
	// 
	// Specifies the SOCKS5 proxy password, if authentication is required.
	// 
	// SOCKS4 does not use passwords, so this property applies only to SOCKS5.
	// 
	void get_SocksPassword(CkString &str);
	// 
	// 
	// Specifies the SOCKS5 proxy password, if authentication is required.
	// 
	// SOCKS4 does not use passwords, so this property applies only to SOCKS5.
	// 
	const wchar_t *socksPassword(void);
	// 
	// 
	// Specifies the SOCKS5 proxy password, if authentication is required.
	// 
	// SOCKS4 does not use passwords, so this property applies only to SOCKS5.
	// 
	void put_SocksPassword(const wchar_t *newVal);

	// 
	// 
	// Specifies the SOCKS proxy port.
	// 
	// The default value is 1080 . This property applies only when SocksVersion is set
	// to 4 or 5 .
	// 
	int get_SocksPort(void);
	// 
	// 
	// Specifies the SOCKS proxy port.
	// 
	// The default value is 1080 . This property applies only when SocksVersion is set
	// to 4 or 5 .
	// 
	void put_SocksPort(int newVal);

	// 
	// 
	// Specifies the SOCKS4 or SOCKS5 proxy username.
	// 
	// This property is used only when SocksVersion is set to 4 or 5 .
	// 
	void get_SocksUsername(CkString &str);
	// 
	// 
	// Specifies the SOCKS4 or SOCKS5 proxy username.
	// 
	// This property is used only when SocksVersion is set to 4 or 5 .
	// 
	const wchar_t *socksUsername(void);
	// 
	// 
	// Specifies the SOCKS4 or SOCKS5 proxy username.
	// 
	// This property is used only when SocksVersion is set to 4 or 5 .
	// 
	void put_SocksUsername(const wchar_t *newVal);

	// 
	// 
	// Specifies whether a SOCKS proxy is used.
	// 
	//     * 0 — no SOCKS proxy is used. This is the default.
	//     * 4 — connect through a SOCKS4 proxy.
	//     * 5 — connect through a SOCKS5 proxy.
	int get_SocksVersion(void);
	// 
	// 
	// Specifies whether a SOCKS proxy is used.
	// 
	//     * 0 — no SOCKS proxy is used. This is the default.
	//     * 4 — connect through a SOCKS4 proxy.
	//     * 5 — connect through a SOCKS5 proxy.
	void put_SocksVersion(int newVal);

	// 
	// 
	// Sets the socket receive buffer size.
	// 
	// The default value is 4194304 .
	// 
	// This property should normally be left unchanged. It may be increased if download
	// performance is slow. Values should preferably be multiples of 4096 .
	// 
	int get_SoRcvBuf(void);
	// 
	// 
	// Sets the socket receive buffer size.
	// 
	// The default value is 4194304 .
	// 
	// This property should normally be left unchanged. It may be increased if download
	// performance is slow. Values should preferably be multiples of 4096 .
	// 
	void put_SoRcvBuf(int newVal);

	// 
	// 
	// Sets the socket send buffer size.
	// 
	// The default value is 262144 .
	// 
	// This property should normally be left unchanged. It may be increased if upload
	// performance is slow. Testing values such as 512K or 1MB is reasonable. Values
	// should preferably be multiples of 4096 .
	// 
	int get_SoSndBuf(void);
	// 
	// 
	// Sets the socket send buffer size.
	// 
	// The default value is 262144 .
	// 
	// This property should normally be left unchanged. It may be increased if upload
	// performance is slow. Testing values such as 512K or 1MB is reasonable. Values
	// should preferably be multiples of 4096 .
	// 
	void put_SoSndBuf(int newVal);

	// 
	// 
	// Specifies the TLS cipher suites Chilkat is allowed to offer when establishing
	// SSL/TLS connections.
	// 
	// The default value is an empty string, meaning Chilkat may offer all implemented
	// cipher suites. To restrict the allowed ciphers, set this property to a
	// comma-separated list of cipher suite names, ordered by preference.
	// 
	// The cipher suites supported by Chilkat are:
	// 
	// TLS 1.3 Cipher Suites
	// 
	//     * TLS_AES_128_GCM_SHA256
	//     * TLS_CHACHA20_POLY1305_SHA256
	//     * TLS_AES_256_GCM_SHA384
	// 
	// ChaCha20-Poly1305 Cipher Suites
	// 
	//     * TLS_ECDHE_RSA_WITH_CHACHA20_POLY1305_SHA256
	//     * TLS_ECDHE_ECDSA_WITH_CHACHA20_POLY1305_SHA256
	//     * TLS_DHE_RSA_WITH_CHACHA20_POLY1305_SHA256
	// 
	// AES-GCM Cipher Suites
	// 
	//     * TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256
	//     * TLS_DHE_RSA_WITH_AES_128_GCM_SHA256
	//     * TLS_RSA_WITH_AES_128_GCM_SHA256
	//     * TLS_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256
	//     * TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384
	//     * TLS_DHE_RSA_WITH_AES_256_GCM_SHA384
	//     * TLS_RSA_WITH_AES_256_GCM_SHA384
	//     * TLS_ECDHE_ECDSA_WITH_AES_256_GCM_SHA384
	// 
	// AES-128 CBC Cipher Suites
	// 
	//     * TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA
	//     * TLS_DHE_RSA_WITH_AES_128_CBC_SHA
	//     * TLS_RSA_WITH_AES_128_CBC_SHA
	//     * TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA256
	//     * TLS_DHE_RSA_WITH_AES_128_CBC_SHA256
	//     * TLS_RSA_WITH_AES_128_CBC_SHA256
	//     * TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA
	//     * TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA256
	// 
	// AES-256 CBC Cipher Suites
	// 
	//     * TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA
	//     * TLS_DHE_RSA_WITH_AES_256_CBC_SHA
	//     * TLS_RSA_WITH_AES_256_CBC_SHA
	//     * TLS_DHE_RSA_WITH_AES_256_CBC_SHA256
	//     * TLS_RSA_WITH_AES_256_CBC_SHA256
	//     * TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA384
	//     * TLS_ECDHE_ECDSA_WITH_AES_256_CBC_SHA
	//     * TLS_ECDHE_ECDSA_WITH_AES_256_CBC_SHA384
	// 
	// Important: The client offers a list of allowed cipher suites, but the server
	// chooses the final cipher suite from that list.
	// 
	// This property can also include special keywords:
	// 
	//     * rsa1024 — reject server certificates with RSA keys smaller than 1024 bits.
	//     * rsa2048 — reject server certificates with RSA keys smaller than 2048 bits.
	//     * secure-renegotiation — require secure renegotiation as defined by RFC
	//     5746.
	//     * best-practices — use Chilkat's current best-practice cipher policy.
	// 
	// The best-practices setting currently requires RSA server keys of at least 1024
	// bits, requires secure renegotiation, and disallows RC4, DES, and 3DES ciphers.
	// 
	// Example:
	// 
	//     TLS_DHE_RSA_WITH_AES_256_CBC_SHA256, TLS_RSA_WITH_AES_256_CBC_SHA, rsa1024,
	//     secure-renegotiation
	// 
	void get_SslAllowedCiphers(CkString &str);
	// 
	// 
	// Specifies the TLS cipher suites Chilkat is allowed to offer when establishing
	// SSL/TLS connections.
	// 
	// The default value is an empty string, meaning Chilkat may offer all implemented
	// cipher suites. To restrict the allowed ciphers, set this property to a
	// comma-separated list of cipher suite names, ordered by preference.
	// 
	// The cipher suites supported by Chilkat are:
	// 
	// TLS 1.3 Cipher Suites
	// 
	//     * TLS_AES_128_GCM_SHA256
	//     * TLS_CHACHA20_POLY1305_SHA256
	//     * TLS_AES_256_GCM_SHA384
	// 
	// ChaCha20-Poly1305 Cipher Suites
	// 
	//     * TLS_ECDHE_RSA_WITH_CHACHA20_POLY1305_SHA256
	//     * TLS_ECDHE_ECDSA_WITH_CHACHA20_POLY1305_SHA256
	//     * TLS_DHE_RSA_WITH_CHACHA20_POLY1305_SHA256
	// 
	// AES-GCM Cipher Suites
	// 
	//     * TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256
	//     * TLS_DHE_RSA_WITH_AES_128_GCM_SHA256
	//     * TLS_RSA_WITH_AES_128_GCM_SHA256
	//     * TLS_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256
	//     * TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384
	//     * TLS_DHE_RSA_WITH_AES_256_GCM_SHA384
	//     * TLS_RSA_WITH_AES_256_GCM_SHA384
	//     * TLS_ECDHE_ECDSA_WITH_AES_256_GCM_SHA384
	// 
	// AES-128 CBC Cipher Suites
	// 
	//     * TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA
	//     * TLS_DHE_RSA_WITH_AES_128_CBC_SHA
	//     * TLS_RSA_WITH_AES_128_CBC_SHA
	//     * TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA256
	//     * TLS_DHE_RSA_WITH_AES_128_CBC_SHA256
	//     * TLS_RSA_WITH_AES_128_CBC_SHA256
	//     * TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA
	//     * TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA256
	// 
	// AES-256 CBC Cipher Suites
	// 
	//     * TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA
	//     * TLS_DHE_RSA_WITH_AES_256_CBC_SHA
	//     * TLS_RSA_WITH_AES_256_CBC_SHA
	//     * TLS_DHE_RSA_WITH_AES_256_CBC_SHA256
	//     * TLS_RSA_WITH_AES_256_CBC_SHA256
	//     * TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA384
	//     * TLS_ECDHE_ECDSA_WITH_AES_256_CBC_SHA
	//     * TLS_ECDHE_ECDSA_WITH_AES_256_CBC_SHA384
	// 
	// Important: The client offers a list of allowed cipher suites, but the server
	// chooses the final cipher suite from that list.
	// 
	// This property can also include special keywords:
	// 
	//     * rsa1024 — reject server certificates with RSA keys smaller than 1024 bits.
	//     * rsa2048 — reject server certificates with RSA keys smaller than 2048 bits.
	//     * secure-renegotiation — require secure renegotiation as defined by RFC
	//     5746.
	//     * best-practices — use Chilkat's current best-practice cipher policy.
	// 
	// The best-practices setting currently requires RSA server keys of at least 1024
	// bits, requires secure renegotiation, and disallows RC4, DES, and 3DES ciphers.
	// 
	// Example:
	// 
	//     TLS_DHE_RSA_WITH_AES_256_CBC_SHA256, TLS_RSA_WITH_AES_256_CBC_SHA, rsa1024,
	//     secure-renegotiation
	// 
	const wchar_t *sslAllowedCiphers(void);
	// 
	// 
	// Specifies the TLS cipher suites Chilkat is allowed to offer when establishing
	// SSL/TLS connections.
	// 
	// The default value is an empty string, meaning Chilkat may offer all implemented
	// cipher suites. To restrict the allowed ciphers, set this property to a
	// comma-separated list of cipher suite names, ordered by preference.
	// 
	// The cipher suites supported by Chilkat are:
	// 
	// TLS 1.3 Cipher Suites
	// 
	//     * TLS_AES_128_GCM_SHA256
	//     * TLS_CHACHA20_POLY1305_SHA256
	//     * TLS_AES_256_GCM_SHA384
	// 
	// ChaCha20-Poly1305 Cipher Suites
	// 
	//     * TLS_ECDHE_RSA_WITH_CHACHA20_POLY1305_SHA256
	//     * TLS_ECDHE_ECDSA_WITH_CHACHA20_POLY1305_SHA256
	//     * TLS_DHE_RSA_WITH_CHACHA20_POLY1305_SHA256
	// 
	// AES-GCM Cipher Suites
	// 
	//     * TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256
	//     * TLS_DHE_RSA_WITH_AES_128_GCM_SHA256
	//     * TLS_RSA_WITH_AES_128_GCM_SHA256
	//     * TLS_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256
	//     * TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384
	//     * TLS_DHE_RSA_WITH_AES_256_GCM_SHA384
	//     * TLS_RSA_WITH_AES_256_GCM_SHA384
	//     * TLS_ECDHE_ECDSA_WITH_AES_256_GCM_SHA384
	// 
	// AES-128 CBC Cipher Suites
	// 
	//     * TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA
	//     * TLS_DHE_RSA_WITH_AES_128_CBC_SHA
	//     * TLS_RSA_WITH_AES_128_CBC_SHA
	//     * TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA256
	//     * TLS_DHE_RSA_WITH_AES_128_CBC_SHA256
	//     * TLS_RSA_WITH_AES_128_CBC_SHA256
	//     * TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA
	//     * TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA256
	// 
	// AES-256 CBC Cipher Suites
	// 
	//     * TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA
	//     * TLS_DHE_RSA_WITH_AES_256_CBC_SHA
	//     * TLS_RSA_WITH_AES_256_CBC_SHA
	//     * TLS_DHE_RSA_WITH_AES_256_CBC_SHA256
	//     * TLS_RSA_WITH_AES_256_CBC_SHA256
	//     * TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA384
	//     * TLS_ECDHE_ECDSA_WITH_AES_256_CBC_SHA
	//     * TLS_ECDHE_ECDSA_WITH_AES_256_CBC_SHA384
	// 
	// Important: The client offers a list of allowed cipher suites, but the server
	// chooses the final cipher suite from that list.
	// 
	// This property can also include special keywords:
	// 
	//     * rsa1024 — reject server certificates with RSA keys smaller than 1024 bits.
	//     * rsa2048 — reject server certificates with RSA keys smaller than 2048 bits.
	//     * secure-renegotiation — require secure renegotiation as defined by RFC
	//     5746.
	//     * best-practices — use Chilkat's current best-practice cipher policy.
	// 
	// The best-practices setting currently requires RSA server keys of at least 1024
	// bits, requires secure renegotiation, and disallows RC4, DES, and 3DES ciphers.
	// 
	// Example:
	// 
	//     TLS_DHE_RSA_WITH_AES_256_CBC_SHA256, TLS_RSA_WITH_AES_256_CBC_SHA, rsa1024,
	//     secure-renegotiation
	// 
	void put_SslAllowedCiphers(const wchar_t *newVal);

	// 
	// 
	// Selects the SSL/TLS protocol version used for secure SMTP and POP3 connections.
	// 
	// Possible values include:
	// 
	//     * default
	//     * TLS 1.3
	//     * TLS 1.2
	//     * TLS 1.1
	//     * TLS 1.0
	//     * SSL 3.0
	//     * TLS 1.3 or higher
	//     * TLS 1.2 or higher
	//     * TLS 1.1 or higher
	//     * TLS 1.0 or higher
	// 
	// The default value is default , which allows Chilkat to choose the protocol
	// dynamically based on the server's requirements.
	// 
	// Choosing an exact protocol version can cause the connection to fail unless that
	// exact version is negotiated. In most cases, using an or higher setting is
	// preferable.
	// 
	void get_SslProtocol(CkString &str);
	// 
	// 
	// Selects the SSL/TLS protocol version used for secure SMTP and POP3 connections.
	// 
	// Possible values include:
	// 
	//     * default
	//     * TLS 1.3
	//     * TLS 1.2
	//     * TLS 1.1
	//     * TLS 1.0
	//     * SSL 3.0
	//     * TLS 1.3 or higher
	//     * TLS 1.2 or higher
	//     * TLS 1.1 or higher
	//     * TLS 1.0 or higher
	// 
	// The default value is default , which allows Chilkat to choose the protocol
	// dynamically based on the server's requirements.
	// 
	// Choosing an exact protocol version can cause the connection to fail unless that
	// exact version is negotiated. In most cases, using an or higher setting is
	// preferable.
	// 
	const wchar_t *sslProtocol(void);
	// 
	// 
	// Selects the SSL/TLS protocol version used for secure SMTP and POP3 connections.
	// 
	// Possible values include:
	// 
	//     * default
	//     * TLS 1.3
	//     * TLS 1.2
	//     * TLS 1.1
	//     * TLS 1.0
	//     * SSL 3.0
	//     * TLS 1.3 or higher
	//     * TLS 1.2 or higher
	//     * TLS 1.1 or higher
	//     * TLS 1.0 or higher
	// 
	// The default value is default , which allows Chilkat to choose the protocol
	// dynamically based on the server's requirements.
	// 
	// Choosing an exact protocol version can cause the connection to fail unless that
	// exact version is negotiated. In most cases, using an or higher setting is
	// preferable.
	// 
	void put_SslProtocol(const wchar_t *newVal);

	// 
	// 
	// Controls whether Chilkat requires SMTP STARTTLS.
	// 
	// When set to true , Chilkat connects to the SMTP server normally and then sends
	// the STARTTLS command to upgrade the connection to SSL/TLS before authenticating
	// and sending email.
	// 
	// The default value is false .
	// 
	// This property applies to SMTP only, not POP3.
	// 
	bool get_StartTLS(void);
	// 
	// 
	// Controls whether Chilkat requires SMTP STARTTLS.
	// 
	// When set to true , Chilkat connects to the SMTP server normally and then sends
	// the STARTTLS command to upgrade the connection to SSL/TLS before authenticating
	// and sending email.
	// 
	// The default value is false .
	// 
	// This property applies to SMTP only, not POP3.
	// 
	void put_StartTLS(bool newVal);

	// 
	// 
	// Controls whether Chilkat uses SMTP STARTTLS automatically when the server
	// supports it.
	// 
	// When set to true , Chilkat upgrades the SMTP connection to TLS if the server
	// advertises STARTTLS support. If STARTTLS is not supported, the connection
	// remains unencrypted.
	// 
	// The default value is true .
	// 
	// Use StartTLS = true instead when encryption is required and the connection
	// should fail if STARTTLS is unavailable.
	// 
	// This property applies to SMTP only, not POP3.
	// 
	bool get_StartTLSifPossible(void);
	// 
	// 
	// Controls whether Chilkat uses SMTP STARTTLS automatically when the server
	// supports it.
	// 
	// When set to true , Chilkat upgrades the SMTP connection to TLS if the server
	// advertises STARTTLS support. If STARTTLS is not supported, the connection
	// remains unencrypted.
	// 
	// The default value is true .
	// 
	// Use StartTLS = true instead when encryption is required and the connection
	// should fail if STARTTLS is unavailable.
	// 
	// This property applies to SMTP only, not POP3.
	// 
	void put_StartTLSifPossible(bool newVal);

	// 
	// 
	// Contains the current or most recently negotiated TLS cipher suite.
	// 
	// If no TLS connection has been established, or if the TLS connection attempt
	// failed, this property is empty.
	// 
	// Example value:
	// 
	//     TLS_DHE_RSA_WITH_AES_256_CBC_SHA256
	// 
	void get_TlsCipherSuite(CkString &str);
	// 
	// 
	// Contains the current or most recently negotiated TLS cipher suite.
	// 
	// If no TLS connection has been established, or if the TLS connection attempt
	// failed, this property is empty.
	// 
	// Example value:
	// 
	//     TLS_DHE_RSA_WITH_AES_256_CBC_SHA256
	// 
	const wchar_t *tlsCipherSuite(void);

	// 
	// 
	// Specifies the expected SPKI fingerprints for TLS public key pinning.
	// 
	// During the TLS handshake, Chilkat compares the server certificate's public key
	// fingerprint against this pin set. If none of the pins match, the TLS handshake
	// is aborted and the connection fails.
	// 
	// The format is:
	// 
	//     hash_algorithm, encoding, SPKI_fingerprint_1, SPKI_fingerprint_2, ...
	// 
	// Example with one SHA-256 Base64 pin:
	// 
	//     sha256, base64, lKg1SIqyhPSK19tlPbjl8s02yChsVTDklQpkMCHvsTE=
	// 
	// Example with two SHA-256 Base64 pins:
	// 
	//     sha256, base64, 4t37LpnGmrMEAG8HEz9yIrnvJV2euVRwCLb9EH5WZyI=,
	//     68b0G5iqMvWVWvUCjMuhLEyekM5729PadtnU5tdXZKs=
	// 
	// Supported hash algorithms include sha1 , sha256 , sha384 , sha512 , md2 , md5 ,
	// haval , ripemd128 , ripemd160 , ripemd256 , and ripemd320 .
	// 
	// Supported encodings include base64 , hex , and other Chilkat-supported
	// encodings.
	// 
	void get_TlsPinSet(CkString &str);
	// 
	// 
	// Specifies the expected SPKI fingerprints for TLS public key pinning.
	// 
	// During the TLS handshake, Chilkat compares the server certificate's public key
	// fingerprint against this pin set. If none of the pins match, the TLS handshake
	// is aborted and the connection fails.
	// 
	// The format is:
	// 
	//     hash_algorithm, encoding, SPKI_fingerprint_1, SPKI_fingerprint_2, ...
	// 
	// Example with one SHA-256 Base64 pin:
	// 
	//     sha256, base64, lKg1SIqyhPSK19tlPbjl8s02yChsVTDklQpkMCHvsTE=
	// 
	// Example with two SHA-256 Base64 pins:
	// 
	//     sha256, base64, 4t37LpnGmrMEAG8HEz9yIrnvJV2euVRwCLb9EH5WZyI=,
	//     68b0G5iqMvWVWvUCjMuhLEyekM5729PadtnU5tdXZKs=
	// 
	// Supported hash algorithms include sha1 , sha256 , sha384 , sha512 , md2 , md5 ,
	// haval , ripemd128 , ripemd160 , ripemd256 , and ripemd320 .
	// 
	// Supported encodings include base64 , hex , and other Chilkat-supported
	// encodings.
	// 
	const wchar_t *tlsPinSet(void);
	// 
	// 
	// Specifies the expected SPKI fingerprints for TLS public key pinning.
	// 
	// During the TLS handshake, Chilkat compares the server certificate's public key
	// fingerprint against this pin set. If none of the pins match, the TLS handshake
	// is aborted and the connection fails.
	// 
	// The format is:
	// 
	//     hash_algorithm, encoding, SPKI_fingerprint_1, SPKI_fingerprint_2, ...
	// 
	// Example with one SHA-256 Base64 pin:
	// 
	//     sha256, base64, lKg1SIqyhPSK19tlPbjl8s02yChsVTDklQpkMCHvsTE=
	// 
	// Example with two SHA-256 Base64 pins:
	// 
	//     sha256, base64, 4t37LpnGmrMEAG8HEz9yIrnvJV2euVRwCLb9EH5WZyI=,
	//     68b0G5iqMvWVWvUCjMuhLEyekM5729PadtnU5tdXZKs=
	// 
	// Supported hash algorithms include sha1 , sha256 , sha384 , sha512 , md2 , md5 ,
	// haval , ripemd128 , ripemd160 , ripemd256 , and ripemd320 .
	// 
	// Supported encodings include base64 , hex , and other Chilkat-supported
	// encodings.
	// 
	void put_TlsPinSet(const wchar_t *newVal);

	// 
	// 
	// Contains the current or most recently negotiated TLS protocol version.
	// 
	// If no TLS connection has been established, or if the TLS connection attempt
	// failed, this property is empty.
	// 
	// Possible values include SSL 3.0 , TLS 1.0 , TLS 1.1 , TLS 1.2 , and TLS 1.3 .
	// 
	void get_TlsVersion(CkString &str);
	// 
	// 
	// Contains the current or most recently negotiated TLS protocol version.
	// 
	// If no TLS connection has been established, or if the TLS connection attempt
	// failed, this property is empty.
	// 
	// Possible values include SSL 3.0 , TLS 1.0 , TLS 1.1 , TLS 1.2 , and TLS 1.3 .
	// 
	const wchar_t *tlsVersion(void);

	// 
	// 
	// Provides a comma-separated list of uncommon option keywords.
	// 
	// This property defaults to an empty string and should normally remain empty.
	// 
	//     * ProtectFromVpn — introduced in v9.5.0.80. On Android, bypasses any
	//     installed or active VPN.
	//     * SmtpLoginAnsi — introduced in v9.5.0.97. Causes SMTP login and password
	//     strings containing non-ASCII characters to be sent using ANSI encoding instead
	//     of UTF-8. This restores the older Chilkat behavior for SMTP servers that expect
	//     ANSI credentials.
	void get_UncommonOptions(CkString &str);
	// 
	// 
	// Provides a comma-separated list of uncommon option keywords.
	// 
	// This property defaults to an empty string and should normally remain empty.
	// 
	//     * ProtectFromVpn — introduced in v9.5.0.80. On Android, bypasses any
	//     installed or active VPN.
	//     * SmtpLoginAnsi — introduced in v9.5.0.97. Causes SMTP login and password
	//     strings containing non-ASCII characters to be sent using ANSI encoding instead
	//     of UTF-8. This restores the older Chilkat behavior for SMTP servers that expect
	//     ANSI credentials.
	const wchar_t *uncommonOptions(void);
	// 
	// 
	// Provides a comma-separated list of uncommon option keywords.
	// 
	// This property defaults to an empty string and should normally remain empty.
	// 
	//     * ProtectFromVpn — introduced in v9.5.0.80. On Android, bypasses any
	//     installed or active VPN.
	//     * SmtpLoginAnsi — introduced in v9.5.0.97. Causes SMTP login and password
	//     strings containing non-ASCII characters to be sent using ANSI encoding instead
	//     of UTF-8. This restores the older Chilkat behavior for SMTP servers that expect
	//     ANSI credentials.
	void put_UncommonOptions(const wchar_t *newVal);

	// 
	// 
	// Controls whether Chilkat automatically uses APOP authentication when the POP3
	// server supports it.
	// 
	// The default value is false .
	// 
	bool get_UseApop(void);
	// 
	// 
	// Controls whether Chilkat automatically uses APOP authentication when the POP3
	// server supports it.
	// 
	// The default value is false .
	// 
	void put_UseApop(bool newVal);



	// ----------------------
	// Methods
	// ----------------------
	// 
	// 
	// Adds a PFX/PKCS#12 certificate store to the MailMan object's internal list of
	// sources used for locating certificates and private keys.
	// 
	// The PFX data is supplied in the bd object, which should contain the bytes of a
	// .pfx or .p12 file.
	// 
	// The added PFX source is searched when Chilkat needs a certificate and private
	// key for operations such as:
	// 
	//     * Decrypting S/MIME encrypted email
	//     * Creating digitally signed email
	// 
	// Multiple PFX sources can be added by calling this method once for each PFX.
	// 
	// On Windows, the registry-based Windows certificate stores are automatically
	// searched when locating certificates and private keys. Therefore, if the required
	// certificate and private key are already installed in the Windows certificate
	// store, explicitly adding a PFX source is often unnecessary.
	// 
	// On macOS, the Apple Keychain is also searched automatically. If the required
	// certificate and private key are already available in the Apple Keychain, it is
	// likewise unnecessary to explicitly add a PFX source.
	// 
	// The password argument specifies the password required to open the PFX.
	// 
	bool AddPfxSourceBd(CkBinDataW &bd, const wchar_t *password);

	// 
	// 
	// Adds a PFX/PKCS#12 certificate store to the MailMan object's internal list of
	// sources used for locating certificates and private keys.
	// 
	// The pfxData argument contains the bytes of a .pfx / .p12 file.
	// 
	// The added PFX source is searched when Chilkat needs a certificate and private
	// key for operations such as:
	// 
	//     * Decrypting S/MIME encrypted email
	//     * Creating digitally signed email
	// 
	// Multiple PFX sources can be added by calling this method once for each PFX.
	// 
	// On Windows, the registry-based Windows certificate stores are automatically
	// searched when locating certificates and private keys. Therefore, if the required
	// certificate and private key are already installed in the Windows certificate
	// store, explicitly adding a PFX source is often unnecessary.
	// 
	// On macOS, the Apple Keychain is also searched automatically. If the required
	// certificate and private key are already available in the Apple Keychain, it is
	// likewise unnecessary to explicitly add a PFX source.
	// 
	// The password argument specifies the password required to open the PFX.
	// 
	bool AddPfxSourceData(CkByteData &pfxData, const wchar_t *password);

	// 
	// 
	// Adds a PFX/PKCS#12 file to the MailMan object's internal list of sources used
	// for locating certificates and private keys. The pfxFilePath argument is the path
	// to a .pfx or .p12 file.
	// 
	// The added PFX source is searched when Chilkat needs a certificate and private
	// key for operations such as:
	// 
	//     * Decrypting S/MIME encrypted email
	//     * Creating digitally signed email
	// 
	// Multiple PFX sources can be added by calling this method once for each PFX.
	// 
	// On Windows, the registry-based Windows certificate stores are automatically
	// searched when locating certificates and private keys. Therefore, if the required
	// certificate and private key are already installed in the Windows certificate
	// store, explicitly adding a PFX source is often unnecessary.
	// 
	// On macOS, the Apple Keychain is also searched automatically. If the required
	// certificate and private key are already available in the Apple Keychain, it is
	// likewise unnecessary to explicitly add a PFX source.
	// 
	// The password argument specifies the password required to open the PFX.
	// 
	bool AddPfxSourceFile(const wchar_t *pfxFilePath, const wchar_t *password);

	// 
	// 
	// Returns the number of emails currently available in the POP3 mailbox. Returns -1
	// if an error occurs.
	// 
	// If this method fails, use VerifyPopConnection to test basic TCP/IP connectivity
	// to the POP3 server, and VerifyPopLogin to test whether the POP3 login succeeds.
	// The Verify* methods are intended as diagnostic helpers when a POP3 operation
	// returns an error.
	// 
	int CheckMail(void);

	// Creates an asynchronous task to call the CheckMail method with the arguments
	// provided.
	// The caller is responsible for deleting the object returned by this method.
	CkTaskW *CheckMailAsync(void);

	// 
	// 
	// Clears the MailMan object's in-memory list of bad email addresses.
	// 
	// When an email-sending method is called, email addresses rejected by the SMTP
	// server are cached in the MailMan object. These rejected addresses can be
	// retrieved by calling GetBadEmailAddresses . This method clears that cached list
	// so the object starts with no remembered bad addresses.
	// 
	void ClearBadEmailAddresses(void);

	// 
	// 
	// Clears the current contents of the Pop3SessionLog property.
	// 
	void ClearPop3SessionLog(void);

	// 
	// 
	// Clears the current contents of the SmtpSessionLog property.
	// 
	void ClearSmtpSessionLog(void);

	// 
	// 
	// Explicitly closes the current SMTP connection. Before closing the socket
	// connection, Chilkat sends the SMTP QUIT command to the server.
	// 
	// Calling this method is optional in most applications. The MailMan object
	// automatically opens an SMTP connection when an email-sending method is called
	// and no connection is already open. The connection is then kept open so
	// subsequent sends can reuse it. For example, if an application calls SendEmail
	// ten times, the first call opens the SMTP connection, and the following calls
	// send over the same connection.
	// 
	// If an SMTP-related property changes, such as the hostname, username, password,
	// port, or SSL/TLS settings, the existing connection is closed and a new
	// connection is established the next time an email-sending method is called.
	// 
	// The SMTP connection is also closed automatically when the MailMan object is
	// destroyed.
	// 
	bool CloseSmtpConnection(void);

	// Creates an asynchronous task to call the CloseSmtpConnection method with the
	// arguments provided.
	// The caller is responsible for deleting the object returned by this method.
	CkTaskW *CloseSmtpConnectionAsync(void);

	// This method is deprecated. Applications should instead call FetchAll .
	// 
	// Copy the email from a POP3 server into a EmailBundle. This does not remove the
	// email from the POP3 server.
	// 
	// The caller is responsible for deleting the object returned by this method.
	CkEmailBundleW *CopyMail(void);

	// Creates an asynchronous task to call the CopyMail method with the arguments
	// provided.
	// The caller is responsible for deleting the object returned by this method.
	CkTaskW *CopyMailAsync(void);

	// 
	// 
	// Marks multiple emails on the POP3 server for deletion. Each email in emailBundle
	// that is still present in the POP3 mailbox is marked for deletion.
	// 
	// In POP3, messages marked for deletion are not permanently removed until the
	// session ends with the QUIT command. If the ImmediateDelete property is true ,
	// which is the default, Chilkat sends QUIT and ends the POP3 session automatically
	// so the deletions are completed immediately. If ImmediateDelete is false , call
	// Pop3EndSession when finished to send QUIT and finalize the deletions.
	// 
	// When making multiple calls to Delete* methods, it is usually better to set
	// ImmediateDelete to false , perform all deletion markings, and then call
	// Pop3EndSession once.
	// 
	// Any method that requires communication with the POP3 server will automatically
	// re-establish a session using the current property settings if a session is not
	// already open.
	// 
	bool DeleteBundle(CkEmailBundleW &emailBundle);

	// Creates an asynchronous task to call the DeleteBundle method with the arguments
	// provided.
	// The caller is responsible for deleting the object returned by this method.
	CkTaskW *DeleteBundleAsync(CkEmailBundleW &emailBundle);

	// 
	// 
	// Marks an email for deletion by its POP3 message number.
	// 
	// Important: Message numbers are specific to a single POP3 session and can change
	// from one session to the next. For example, if a mailbox contains ten messages,
	// they are numbered 1 through 10 . If message 1 is deleted and a new POP3 session
	// is opened, the remaining messages are renumbered 1 through 9 .
	// 
	// A POP3 session must already be established before this method is called, either
	// explicitly by calling Pop3BeginSession or implicitly by calling another method
	// that opens the session. This method does not automatically begin a new session
	// because doing so could change the message numbers and cause the application to
	// delete a different message than intended.
	// 
	// This method only marks the message for deletion. The message is not removed from
	// the POP3 mailbox until the session is ended by calling Pop3EndSession , which
	// sends the QUIT command.
	// 
	bool DeleteByMsgnum(int msgnum);

	// Creates an asynchronous task to call the DeleteByMsgnum method with the
	// arguments provided.
	// The caller is responsible for deleting the object returned by this method.
	CkTaskW *DeleteByMsgnumAsync(int msgnum);

	// 
	// 
	// Marks an email on the POP3 server for deletion using its UIDL. UIDLs are
	// generally preferred over POP3 message numbers because UIDLs remain stable across
	// sessions for as long as the message remains in the mailbox.
	// 
	// In POP3, messages marked for deletion are not permanently removed until the
	// session ends with the QUIT command. If the ImmediateDelete property is true ,
	// which is the default, Chilkat sends QUIT and ends the POP3 session automatically
	// so the deletion is completed immediately. If ImmediateDelete is false , call
	// Pop3EndSession when finished to send QUIT and finalize the deletion.
	// 
	// When making multiple calls to Delete* methods, it is usually better to set
	// ImmediateDelete to false , perform all deletion markings, and then call
	// Pop3EndSession once.
	// 
	// Any method that requires communication with the POP3 server will automatically
	// re-establish a session using the current property settings if a session is not
	// already open.
	// 
	bool DeleteByUidl(const wchar_t *uidl);

	// Creates an asynchronous task to call the DeleteByUidl method with the arguments
	// provided.
	// The caller is responsible for deleting the object returned by this method.
	CkTaskW *DeleteByUidlAsync(const wchar_t *uidl);

	// 
	// 
	// Marks the specified email for deletion on the POP3 server. The email object
	// should represent a message that was retrieved from the same POP3 mailbox and can
	// be matched to a message still present on the server.
	// 
	// In POP3, messages marked for deletion are not permanently removed until the
	// session ends with the QUIT command. If the ImmediateDelete property is true ,
	// which is the default, Chilkat sends QUIT and ends the POP3 session automatically
	// so the deletion is completed immediately. If ImmediateDelete is false , call
	// Pop3EndSession when finished to send QUIT and finalize the deletion.
	// 
	// When making multiple calls to Delete* methods, it is usually better to set
	// ImmediateDelete to false , perform all deletion markings, and then call
	// Pop3EndSession once.
	// 
	// Any method that requires communication with the POP3 server will automatically
	// re-establish a session using the current property settings if a session is not
	// already open.
	// 
	bool DeleteEmail(CkEmailW &email);

	// Creates an asynchronous task to call the DeleteEmail method with the arguments
	// provided.
	// The caller is responsible for deleting the object returned by this method.
	CkTaskW *DeleteEmailAsync(CkEmailW &email);

	// Marks multiple emails on the POP3 server for deletion. (Any email on the server
	// having a UIDL equal to a UIDL found in uidlArray is marked for deletion.) To complete
	// the deletion of the emails, a QUIT message must be sent and the POP3 session
	// ended. This will happen automatically when the ImmediateDelete property equals
	// true, which is the default. If ImmediateDelete equals false, then the
	// Pop3EndSession method can be called to send the QUIT and end the session (i.e.
	// disconnect.)
	// 
	// Note: When making multiple calls to a Delete* method, it's best to turn off
	// ImmediateDelete, and then manually call Pop3EndSession to finalize the
	// deletions.
	// 
	// Also, any method call requiring communication with the POP3 server will
	// automatically re-establish a session based on the current property settings.
	// 
	bool DeleteMultiple(CkStringArrayW &uidlArray);

	// Creates an asynchronous task to call the DeleteMultiple method with the
	// arguments provided.
	// The caller is responsible for deleting the object returned by this method.
	CkTaskW *DeleteMultipleAsync(CkStringArrayW &uidlArray);

	// 
	// 
	// Marks multiple emails on the POP3 server for deletion. Each message whose UIDL
	// matches an entry in stUidls is marked for deletion.
	// 
	// In POP3, messages marked for deletion are not permanently removed until the
	// session ends with the QUIT command. If the ImmediateDelete property is true ,
	// which is the default, Chilkat sends QUIT and ends the POP3 session automatically
	// so the deletions are completed immediately. If ImmediateDelete is false , call
	// Pop3EndSession when finished to send QUIT and finalize the deletions.
	// 
	// When making multiple calls to Delete* methods, it is usually better to set
	// ImmediateDelete to false , perform all deletion markings, and then call
	// Pop3EndSession once.
	// 
	// Any method that requires communication with the POP3 server will automatically
	// re-establish a session using the current property settings if a session is not
	// already open.
	// 
	bool DeleteUidlSet(CkStringTableW &stUidls);

	// Creates an asynchronous task to call the DeleteUidlSet method with the arguments
	// provided.
	// The caller is responsible for deleting the object returned by this method.
	CkTaskW *DeleteUidlSetAsync(CkStringTableW &stUidls);

	// 
	// 
	// Retrieves all emails from the POP3 mailbox and stores them in bundle .
	// 
	// If headersOnly is true , Chilkat downloads only the message headers and the
	// first numBodyLines lines of the message body. Attachments are not downloaded. If
	// headersOnly is false , Chilkat downloads the complete messages, including
	// attachments.
	// 
	// If keepOnServer is true , the downloaded emails remain on the POP3 server. If
	// keepOnServer is false , the messages may be deleted from the server after full
	// download, depending on the POP3 deletion/session behavior.
	// 
	// Note: keepOnServer applies only when downloading full emails. Header-only
	// downloads do not delete messages from the server, regardless of the value of
	// keepOnServer .
	// 
	bool FetchAll(bool keepOnServer, bool headersOnly, int numBodyLines, CkEmailBundleW &bundle);

	// Creates an asynchronous task to call the FetchAll method with the arguments
	// provided.
	// The caller is responsible for deleting the object returned by this method.
	CkTaskW *FetchAllAsync(bool keepOnServer, bool headersOnly, int numBodyLines, CkEmailBundleW &bundle);

	// This method is deprecated. Applications should instead call FetchOne .
	// 
	// Fetches an email by message number. WARNING: Be very careful if calling this
	// method. Message numbers are specific to a POP3 session. If a maildrop has (for
	// example) 10 messages, the message numbers will be 1, 2, 3, ... 10. If message
	// number 1 is deleted and a new POP3 session is established, there will be 9
	// messages numbered 1, 2, 3, ... 9.
	// 
	// IMPORTANT: A POP3 connection must first be established by either calling
	// Pop3BeginSession explicitly, or implicitly by calling some other method that
	// automatically establishes the session. This method will not automatically
	// establish a new POP3 session (because if it did, the message numbers would
	// potentially be different than what the application expects).
	// 
	// The caller is responsible for deleting the object returned by this method.
	CkEmailW *FetchByMsgnum(int msgnum);

	// Creates an asynchronous task to call the FetchByMsgnum method with the arguments
	// provided.
	// The caller is responsible for deleting the object returned by this method.
	CkTaskW *FetchByMsgnumAsync(int msgnum);

	// 
	// 
	// Retrieves an email from the POP3 server by UIDL and stores it in email . The
	// message is not deleted from the server.
	// 
	// If headerOnly is true , Chilkat downloads only the message headers and the
	// first numBodyLines lines of the message body. Attachments are not downloaded. If
	// headerOnly is false , Chilkat downloads the complete message, including
	// attachments.
	// 
	bool FetchByUidl(const wchar_t *uidl, bool headerOnly, int numBodyLines, CkEmailW &email);

	// Creates an asynchronous task to call the FetchByUidl method with the arguments
	// provided.
	// The caller is responsible for deleting the object returned by this method.
	CkTaskW *FetchByUidlAsync(const wchar_t *uidl, bool headerOnly, int numBodyLines, CkEmailW &email);

	// This method is deprecated. Applications should instead call FetchByUidl .
	// 
	// Fetches an email from the POP3 mail server given its UIDL. Calling this method
	// does not remove the email from the server. A typical program might get the email
	// headers from the POP3 server by calling GetAllHeaders or GetHeaders, and then
	// fetch individual emails by UIDL.
	// 
	// Returns a null reference on failure.
	// 
	// The caller is responsible for deleting the object returned by this method.
	CkEmailW *FetchEmail(const wchar_t *uidl);

	// Creates an asynchronous task to call the FetchEmail method with the arguments
	// provided.
	// The caller is responsible for deleting the object returned by this method.
	CkTaskW *FetchEmailAsync(const wchar_t *uidl);

	// 
	// 
	// Downloads the full version of an email when partialEmail contains a previously
	// retrieved header-only or partial message. The complete message is stored in
	// fullEmail .
	// 
	// This is useful when an application first downloads headers or partial bodies to
	// display a message list, and later needs to retrieve the complete message,
	// including attachments, for one selected email.
	// 
	bool FetchFull(CkEmailW &partialEmail, CkEmailW &fullEmail);

	// Creates an asynchronous task to call the FetchFull method with the arguments
	// provided.
	// The caller is responsible for deleting the object returned by this method.
	CkTaskW *FetchFullAsync(CkEmailW &partialEmail, CkEmailW &fullEmail);

	// 
	// 
	// Fetches an email from the POP3 server by UIDL and returns the raw MIME source
	// bytes of the message.
	// 
	bool FetchMime(const wchar_t *uidl, CkByteData &outData);

	// Creates an asynchronous task to call the FetchMime method with the arguments
	// provided.
	// The caller is responsible for deleting the object returned by this method.
	CkTaskW *FetchMimeAsync(const wchar_t *uidl);

	// 
	// 
	// Fetches an email from the POP3 server by UIDL and stores the raw MIME source
	// bytes in mimeData .
	// 
	bool FetchMimeBd(const wchar_t *uidl, CkBinDataW &mimeData);

	// Creates an asynchronous task to call the FetchMimeBd method with the arguments
	// provided.
	// The caller is responsible for deleting the object returned by this method.
	CkTaskW *FetchMimeBdAsync(const wchar_t *uidl, CkBinDataW &mimeData);

	// 
	// 
	// Retrieves an email by POP3 message number and returns the raw MIME source bytes.
	// 
	// Important: Message numbers are specific to a single POP3 session and can change
	// from one session to the next. For example, if a mailbox contains ten messages,
	// they are numbered 1 through 10 . If message 1 is deleted and a new POP3 session
	// is opened, the remaining messages are renumbered 1 through 9 .
	// 
	// A POP3 session must already be established before this method is called, either
	// explicitly by calling Pop3BeginSession or implicitly by calling another method
	// that opens the session. This method does not automatically begin a new POP3
	// session because doing so could change the message numbers.
	// 
	bool FetchMimeByMsgnum(int msgnum, CkByteData &outBytes);

	// Creates an asynchronous task to call the FetchMimeByMsgnum method with the
	// arguments provided.
	// The caller is responsible for deleting the object returned by this method.
	CkTaskW *FetchMimeByMsgnumAsync(int msgnum);

	// 
	// 
	// Retrieves an email by POP3 message number and stores the raw MIME source bytes
	// in bd .
	// 
	// Important: Message numbers are specific to a single POP3 session and can change
	// from one session to the next. For example, if a mailbox contains ten messages,
	// they are numbered 1 through 10 . If message 1 is deleted and a new POP3 session
	// is opened, the remaining messages are renumbered 1 through 9 .
	// 
	// A POP3 session must already be established before this method is called, either
	// explicitly by calling Pop3BeginSession or implicitly by calling another method
	// that opens the session. This method does not automatically begin a new POP3
	// session because doing so could change the message numbers.
	// 
	bool FetchMimeByMsgnumBd(int msgnum, CkBinDataW &bd);

	// Creates an asynchronous task to call the FetchMimeByMsgnumBd method with the
	// arguments provided.
	// The caller is responsible for deleting the object returned by this method.
	CkTaskW *FetchMimeByMsgnumBdAsync(int msgnum, CkBinDataW &bd);

	// This method is deprecated. Applications should instead call FetchUidlSet .
	// 
	// Given an array of UIDL strings, fetchs all the emails from the POP3 server whose
	// UIDL is present in the array, and returns the emails in a bundle.
	// 
	// The caller is responsible for deleting the object returned by this method.
	CkEmailBundleW *FetchMultiple(CkStringArrayW &uidlArray);

	// Creates an asynchronous task to call the FetchMultiple method with the arguments
	// provided.
	// The caller is responsible for deleting the object returned by this method.
	CkTaskW *FetchMultipleAsync(CkStringArrayW &uidlArray);

	// This method is deprecated. Applications should instead call FetchUidlSet .
	// 
	// Given an array of UIDL strings, fetchs all the email headers from the POP3
	// server whose UIDL is present in the array.
	// 
	// Note: The email objects returned in the bundle contain only headers. The
	// attachments will be missing, and the bodies will be mostly missing (only the 1st
	// numBodyLines lines of either the plain-text or HTML body will be present).
	// 
	// The caller is responsible for deleting the object returned by this method.
	CkEmailBundleW *FetchMultipleHeaders(CkStringArrayW &uidlArray, int numBodyLines);

	// Creates an asynchronous task to call the FetchMultipleHeaders method with the
	// arguments provided.
	// The caller is responsible for deleting the object returned by this method.
	CkTaskW *FetchMultipleHeadersAsync(CkStringArrayW &uidlArray, int numBodyLines);

	// This deprecated method will be removed in a future major release of Chilkat.
	// MIME can potentially include non-encoded binary data and mixed character
	// encodings, so downloading emails as a simple MIME string often requires
	// processing and modifications, making it impractical. Instead, applications
	// should use FetchMimeBd or methods that download emails to email objects.
	// 
	// This method downloads emails from the POP3 server for each UIDL in uidlArray and
	// returns an object containing the collection of downloaded MIME strings.
	// 
	// The caller is responsible for deleting the object returned by this method.
	CkStringArrayW *FetchMultipleMime(CkStringArrayW &uidlArray);

	// Creates an asynchronous task to call the FetchMultipleMime method with the
	// arguments provided.
	// The caller is responsible for deleting the object returned by this method.
	CkTaskW *FetchMultipleMimeAsync(CkStringArrayW &uidlArray);

	// 
	// 
	// Retrieves a single email by POP3 message number and stores it in email . The
	// first message in the POP3 mailbox has message number 1 . Messages fetched by
	// this method remain on the server.
	// 
	// If headerOnly is true , Chilkat downloads only the message headers and the
	// first numBodyLines lines of the message body. Attachments are not downloaded. If
	// headerOnly is false , Chilkat downloads the complete message, including
	// attachments.
	// 
	// Note: Message numbers are specific to a single POP3 session and can change from
	// one session to the next. Use UIDLs when messages need to be identified reliably
	// across sessions.
	// 
	bool FetchOne(bool headerOnly, int numBodyLines, int msgNum, CkEmailW &email);

	// Creates an asynchronous task to call the FetchOne method with the arguments
	// provided.
	// The caller is responsible for deleting the object returned by this method.
	CkTaskW *FetchOneAsync(bool headerOnly, int numBodyLines, int msgNum, CkEmailW &email);

	// 
	// 
	// Retrieves a range of emails from the POP3 mailbox and stores them in bundle .
	// 
	// The range is specified by startIndex and endIndex . The first email has index 0
	// . The GetMailboxCount method returns the total number of messages in the POP3
	// mailbox.
	// 
	// If headersOnly is true , Chilkat downloads only the message headers and the
	// first numBodyLines lines of each message body. Attachments are not downloaded.
	// If headersOnly is false , Chilkat downloads the complete messages, including
	// attachments.
	// 
	// If keepOnServer is true , the downloaded emails remain on the POP3 server. If
	// keepOnServer is false , the messages may be deleted from the server after full
	// download, depending on the POP3 deletion/session behavior.
	// 
	// Note: keepOnServer applies only when downloading full emails. Header-only
	// downloads do not delete messages from the server, regardless of the value of
	// keepOnServer .
	// 
	bool FetchRange(bool keepOnServer, bool headersOnly, int numBodyLines, int startIndex, int endIndex, CkEmailBundleW &bundle);

	// Creates an asynchronous task to call the FetchRange method with the arguments
	// provided.
	// The caller is responsible for deleting the object returned by this method.
	CkTaskW *FetchRangeAsync(bool keepOnServer, bool headersOnly, int numBodyLines, int startIndex, int endIndex, CkEmailBundleW &bundle);

	// This method is deprecated. Applications should instead call FetchOne .
	// 
	// Fetches a single header by message number. Returns an email object on success,
	// or a null reference on failure.
	// 
	// The caller is responsible for deleting the object returned by this method.
	CkEmailW *FetchSingleHeader(int numBodyLines, int messageNumber);

	// Creates an asynchronous task to call the FetchSingleHeader method with the
	// arguments provided.
	// The caller is responsible for deleting the object returned by this method.
	CkTaskW *FetchSingleHeaderAsync(int numBodyLines, int messageNumber);

	// This method is deprecated. Applications should instead call FetchByUidl .
	// 
	// Fetches a single header by UIDL. Returns an email object on success, or a null
	// reference on failure.
	// 
	// Note: The email objects returned in the bundle contain only headers. The
	// attachments will be missing, and the bodies will be mostly missing (only the 1st
	// uidl lines of either the plain-text or HTML body will be present).
	// 
	// The caller is responsible for deleting the object returned by this method.
	CkEmailW *FetchSingleHeaderByUidl(int numBodyLines, const wchar_t *uidl);

	// Creates an asynchronous task to call the FetchSingleHeaderByUidl method with the
	// arguments provided.
	// The caller is responsible for deleting the object returned by this method.
	CkTaskW *FetchSingleHeaderByUidlAsync(int numBodyLines, const wchar_t *uidl);

	// 
	// 
	// Retrieves the UIDLs of the messages currently stored in the POP3 mailbox and
	// stores them in uidls .
	// 
	// A POP3 UIDL, or Unique ID Listing, is a persistent identifier assigned by the
	// mail server to a message. Unlike POP3 message numbers, which can change between
	// sessions, UIDLs remain consistent for as long as the message remains in the
	// mailbox. This allows an application to track which messages have already been
	// downloaded without relying on message numbers.
	// 
	bool FetchUidls(CkStringTableW &uidls);

	// Creates an asynchronous task to call the FetchUidls method with the arguments
	// provided.
	// The caller is responsible for deleting the object returned by this method.
	CkTaskW *FetchUidlsAsync(CkStringTableW &uidls);

	// 
	// 
	// Retrieves the emails whose UIDLs are present in uidls and stores them in bundle
	// . The downloaded messages are not deleted from the server.
	// 
	// If headersOnly is true , Chilkat downloads only the message headers and the
	// first numBodyLines lines of each message body. Attachments are not downloaded.
	// If headersOnly is false , Chilkat downloads the complete messages, including
	// attachments.
	// 
	bool FetchUidlSet(CkStringTableW &uidls, bool headersOnly, int numBodyLines, CkEmailBundleW &bundle);

	// Creates an asynchronous task to call the FetchUidlSet method with the arguments
	// provided.
	// The caller is responsible for deleting the object returned by this method.
	CkTaskW *FetchUidlSetAsync(CkStringTableW &uidls, bool headersOnly, int numBodyLines, CkEmailBundleW &bundle);

	// This method is deprecated. Applications should instead call FetchAll .
	// 
	// Retrieves all emails from the POP3 server, limiting the body to the first numBodyLines
	// lines and excluding attachments. The returned emails are valid objects with
	// truncated bodies and no attachments.
	// 
	// The caller is responsible for deleting the object returned by this method.
	CkEmailBundleW *GetAllHeaders(int numBodyLines);

	// Creates an asynchronous task to call the GetAllHeaders method with the arguments
	// provided.
	// The caller is responsible for deleting the object returned by this method.
	CkTaskW *GetAllHeadersAsync(int numBodyLines);

	// This method is deprecated and applications should instead call SmtpRecipientsLog
	// 
	// Returns a list of email addresses rejected by the SMTP server from the last call
	// of an email-sending method, like SendEmail. Invalid email addresses identified
	// by the SMTP server are stored in a bad email addresses list, while valid ones
	// are stored in a good email addresses list within the object. Both lists reset
	// automatically at the beginning of each new mail-sending call, allowing you to
	// track which addresses were accepted or rejected.
	// 
	// Note: A the time of the SMTP session, the SMTP server can only verify the
	// validity of an email address within its own domain because it has access to its
	// internal user database or mailbox configuration. Addresses outside its domain,
	// are implicitly accepted and the validity of the email address won't be
	// discovered until arrives at the destination mail server.
	// 
	// The caller is responsible for deleting the object returned by this method.
	CkStringArrayW *GetBadEmailAddrs(void);

	// This method is deprecated. Applications should instead call FetchFull .
	// 
	// If a partial email (header-only) is retrieved using GetHeaders or GetAllHeaders,
	// this method will download and return the full email from the server using the
	// partial email as an argument.
	// 
	// The caller is responsible for deleting the object returned by this method.
	CkEmailW *GetFullEmail(CkEmailW &email);

	// Creates an asynchronous task to call the GetFullEmail method with the arguments
	// provided.
	// The caller is responsible for deleting the object returned by this method.
	CkTaskW *GetFullEmailAsync(CkEmailW &email);

	// This method is deprecated. Applications should instead call FetchRange .
	// 
	// The same as the GetAllHeaders method, except only the emails from fromIndex to toIndex
	// on the POP3 server are returned. The first email on the server is at index 0.
	// 
	// The caller is responsible for deleting the object returned by this method.
	CkEmailBundleW *GetHeaders(int numBodyLines, int fromIndex, int toIndex);

	// Creates an asynchronous task to call the GetHeaders method with the arguments
	// provided.
	// The caller is responsible for deleting the object returned by this method.
	CkTaskW *GetHeadersAsync(int numBodyLines, int fromIndex, int toIndex);

	// Provides information about what transpired in the last method called on this
	// object instance. For many methods, there is no information. However, for some
	// methods, details about what occurred can be obtained by getting the LastJsonData
	// right after the method call returns.
	void GetLastJsonData(CkJsonObjectW &json);

	// 
	// 
	// Returns the number of emails currently available in the POP3 mailbox. Returns -1
	// if an error occurs.
	// 
	// This method is functionally identical to CheckMail .
	// 
	int GetMailboxCount(void);

	// Creates an asynchronous task to call the GetMailboxCount method with the
	// arguments provided.
	// The caller is responsible for deleting the object returned by this method.
	CkTaskW *GetMailboxCountAsync(void);

	// 
	// 
	// Returns an XML document containing information about the messages currently
	// stored in the POP3 mailbox.
	// 
	// The XML includes the UIDL and size, in bytes, for each message in the mailbox.
	// This is useful for scanning mailbox state without downloading the full messages.
	// 
	bool GetMailboxInfoXml(CkString &outXml);
	// 
	// 
	// Returns an XML document containing information about the messages currently
	// stored in the POP3 mailbox.
	// 
	// The XML includes the UIDL and size, in bytes, for each message in the mailbox.
	// This is useful for scanning mailbox state without downloading the full messages.
	// 
	const wchar_t *getMailboxInfoXml(void);
	// 
	// 
	// Returns an XML document containing information about the messages currently
	// stored in the POP3 mailbox.
	// 
	// The XML includes the UIDL and size, in bytes, for each message in the mailbox.
	// This is useful for scanning mailbox state without downloading the full messages.
	// 
	const wchar_t *mailboxInfoXml(void);

	// Creates an asynchronous task to call the GetMailboxInfoXml method with the
	// arguments provided.
	// The caller is responsible for deleting the object returned by this method.
	CkTaskW *GetMailboxInfoXmlAsync(void);

	// 
	// 
	// Returns the total combined size, in bytes, of all emails currently stored in the
	// POP3 mailbox. This is also known as the POP3 maildrop size.
	// 
	// Returns -1 on failure.
	// 
	unsigned long GetMailboxSize(void);

	// Creates an asynchronous task to call the GetMailboxSize method with the
	// arguments provided.
	// The caller is responsible for deleting the object returned by this method.
	CkTaskW *GetMailboxSizeAsync(void);

	// This method is deprecated. Applications should instead call GetServerCert .
	// 
	// Returns the POP3 server's SSL certificate. This is available after connecting
	// via SSL to a POP3 server. (To use POP3 SSL, set the PopSsl property = true.)
	// 
	// Returns a null reference if no POP3 SSL certificate is available.
	// 
	// The caller is responsible for deleting the object returned by this method.
	CkCertW *GetPop3SslServerCert(void);

	// This method is deprecated and applications should instead call SmtpRecipientsLog
	// 
	// Returns a list of email addresses accepted by the SMTP server from the last call
	// of an email-sending method, like SendEmail. Invalid email addresses identified
	// by the SMTP server are stored in a bad email addresses list, while valid ones
	// are stored in a good email addresses list within the object. Both lists reset
	// automatically at the beginning of each new mail-sending call, allowing you to
	// track which addresses were accepted or rejected.
	// 
	// Note: A the time of the SMTP session, the SMTP server can only verify the
	// validity of an email address within its own domain because it has access to its
	// internal user database or mailbox configuration. Addresses outside its domain,
	// are implicitly accepted and the validity of the email address won't be
	// discovered until arrives at the destination mail server.
	// 
	// The caller is responsible for deleting the object returned by this method.
	CkStringArrayW *GetSentToEmailAddrs(void);

	// 
	// 
	// Gets the digital certificate presented by the SMTP or POP3 server for the
	// current SSL/TLS connection and stores it in cert .
	// 
	// If useSmtp is true , Chilkat returns the certificate for the SMTP connection.
	// If useSmtp is false , Chilkat returns the certificate for the POP3 connection.
	// 
	// This method applies only when the current connection uses SSL/TLS.
	// 
	bool GetServerCert(bool useSmtp, CkCertW &cert);

	// 
	// 
	// Returns the size, in bytes, of the email on the POP3 server identified by uidl .
	// The size includes the full message content, including attachments.
	// 
	// Returns -1 if an error occurs.
	// 
	int GetSizeByUidl(const wchar_t *uidl);

	// Creates an asynchronous task to call the GetSizeByUidl method with the arguments
	// provided.
	// The caller is responsible for deleting the object returned by this method.
	CkTaskW *GetSizeByUidlAsync(const wchar_t *uidl);

	// This method is deprecated. Applications should instead call GetServerCert .
	// 
	// If using SSL/TLS, this method returns the SMTP server's digital certificate used
	// with the secure connection.
	// 
	// The caller is responsible for deleting the object returned by this method.
	CkCertW *GetSmtpSslServerCert(void);

	// This method is deprecated. Applications should instead call FetchUidls .
	// 
	// Returns the UIDLs of the emails currently stored on the POP3 server.
	// 
	// The caller is responsible for deleting the object returned by this method.
	CkStringArrayW *GetUidls(void);

	// Creates an asynchronous task to call the GetUidls method with the arguments
	// provided.
	// The caller is responsible for deleting the object returned by this method.
	CkTaskW *GetUidlsAsync(void);

	// 
	// 
	// Contacts the SMTP server and determines whether it supports the DSN, or Delivery
	// Status Notification, extension defined by RFC 3461.
	// 
	// DSN support is used with properties such as DsnEnvid , DsnNotify , and DsnRet .
	// Returns true if the SMTP server advertises DSN support, otherwise returns
	// false .
	// 
	bool IsSmtpDsnCapable(void);

	// Creates an asynchronous task to call the IsSmtpDsnCapable method with the
	// arguments provided.
	// The caller is responsible for deleting the object returned by this method.
	CkTaskW *IsSmtpDsnCapableAsync(void);

	// This method is deprecated. Call GetLastJsonData instead.
	// 
	// Provides information about what transpired in the last method called on this
	// object instance. For many methods, there is no information. However, for some
	// methods, details about what occurred can be obtained by getting the LastJsonData
	// right after the method call returns.
	// 
	// The caller is responsible for deleting the object returned by this method.
	CkJsonObjectW *LastJsonData(void);

	// This deprecated method will be removed in a future Chilkat major version.
	// Applications should instead call the email object's LoadEml method.
	// 
	// Loads a .eml file containing an email.
	// 
	// The caller is responsible for deleting the object returned by this method.
	CkEmailW *LoadEml(const wchar_t *emlFilename);

	// This method is deprecated. Applications should instead call LoadMbxFile .
	// 
	// Loads a .mbx file containing emails and returns an email bundle. If a Filter is
	// present, only emails matching the filter are returned.
	// 
	// The caller is responsible for deleting the object returned by this method.
	CkEmailBundleW *LoadMbx(const wchar_t *mbxFileName);

	// 
	// 
	// Loads emails from a .mbx mailbox file and stores them in bundle .
	// 
	// If a filter has been configured, only the emails matching the filter are
	// returned. Returns true for success and false for failure.
	// 
	bool LoadMbxFile(const wchar_t *mbxPath, CkEmailBundleW &bundle);

	// This deprecated method will be removed in a future Chilkat major version.
	// Applications should instead call the email object's SetFromMimeText method.
	// 
	// Creates and loads an email from a MIME string. Returns a null reference on
	// failure.
	// 
	// The caller is responsible for deleting the object returned by this method.
	CkEmailW *LoadMime(const wchar_t *mimeText);

	// Loads the caller of the task's async method.
	bool LoadTaskCaller(CkTaskW &task);

	// This deprecated method will be removed in a future Chilkat major version.
	// Applications should instead call the email object's SetFromXmlText method.
	// 
	// Loads an XML file containing a single email and returns an email object. Returns
	// a null reference on failure.
	// 
	// The caller is responsible for deleting the object returned by this method.
	CkEmailW *LoadXmlEmail(const wchar_t *filename);

	// This deprecated method will be removed in a future Chilkat major version.
	// Applications should instead call the email object's SetFromXmlText method.
	// 
	// Loads an XML string containing a single email and returns an email object.
	// Returns a null reference on failure.
	// 
	// The caller is responsible for deleting the object returned by this method.
	CkEmailW *LoadXmlEmailString(const wchar_t *xmlString);

	// This deprecated method will be removed in a future Chilkat major version.
	// Applications should instead call the email bundle object's LoadXml method.
	// 
	// Loads an XML file containing one or more emails and returns an email bundle. If
	// a Filter is present, only emails matching the filter are returned. Returns a
	// null reference on failure.
	// 
	// The caller is responsible for deleting the object returned by this method.
	CkEmailBundleW *LoadXmlFile(const wchar_t *filename);

	// This deprecated method will be removed in a future Chilkat major version.
	// Applications should instead call the email bundle object's LoadXmlString method.
	// 
	// Loads from an XML string containing emails and returns an email bundle. If a
	// Filter is present, only emails matching the filter are returned.
	// 
	// The caller is responsible for deleting the object returned by this method.
	CkEmailBundleW *LoadXmlString(const wchar_t *xmlString);

	// This deprecated method will be removed in a future Chilkat major version.
	// Applications should instead use the Chilkat Dns class to do MX lookups.
	// 
	// Performs a DNS MX lookup to return the mail server hostname based on an email
	// address.
	// 
	bool MxLookup(const wchar_t *emailAddress, CkString &outStrHostname);
	// This deprecated method will be removed in a future Chilkat major version.
	// Applications should instead use the Chilkat Dns class to do MX lookups.
	// 
	// Performs a DNS MX lookup to return the mail server hostname based on an email
	// address.
	// 
	const wchar_t *mxLookup(const wchar_t *emailAddress);

	// This deprecated method will be removed in a future Chilkat major version.
	// Applications should instead use the Chilkat Dns class to do MX lookups.
	// 
	// Performs a DNS MX lookup to return the list of mail server hostnames based on an
	// email address. The primary server is at index 0. In most cases, there is only
	// one mail server for a given email address.
	// 
	// The caller is responsible for deleting the object returned by this method.
	CkStringArrayW *MxLookupAll(const wchar_t *emailAddress);

	// 
	// 
	// Explicitly opens a connection to the SMTP server and authenticates if a username
	// and password, OAuth2 token, or other applicable authentication settings have
	// been provided.
	// 
	// Calling this method is optional. Email-sending methods such as SendEmail
	// automatically open and authenticate the SMTP connection when needed.
	// 
	// This method is equivalent to calling SmtpConnect followed by SmtpAuthenticate .
	// 
	bool OpenSmtpConnection(void);

	// Creates an asynchronous task to call the OpenSmtpConnection method with the
	// arguments provided.
	// The caller is responsible for deleting the object returned by this method.
	CkTaskW *OpenSmtpConnectionAsync(void);

	// 
	// 
	// Authenticates with the POP3 server using the current POP3 property settings,
	// such as PopUsername , PopPassword , and any authentication-related options.
	// 
	// This method should be called only after a successful call to Pop3Connect . The
	// Pop3BeginSession method performs both steps and is equivalent to calling
	// Pop3Connect followed by Pop3Authenticate .
	// 
	// Calling this method is optional in most applications because POP3 methods that
	// communicate with the server automatically connect and authenticate if no
	// authenticated session is already open.
	// 
	bool Pop3Authenticate(void);

	// Creates an asynchronous task to call the Pop3Authenticate method with the
	// arguments provided.
	// The caller is responsible for deleting the object returned by this method.
	CkTaskW *Pop3AuthenticateAsync(void);

	// 
	// 
	// Explicitly begins a POP3 session by connecting to the POP3 server and
	// authenticating using the current POP3 property settings.
	// 
	// Calling this method is optional. Any method that requires an established POP3
	// session automatically connects and logs in if a session is not already open.
	// 
	bool Pop3BeginSession(void);

	// Creates an asynchronous task to call the Pop3BeginSession method with the
	// arguments provided.
	// The caller is responsible for deleting the object returned by this method.
	CkTaskW *Pop3BeginSessionAsync(void);

	// 
	// 
	// Explicitly connects to the POP3 server. If SSL/TLS is required by the current
	// property settings, the secure TLS channel is established as part of this call.
	// This method receives the server's initial greeting but does not authenticate.
	// 
	// After Pop3Connect succeeds, call Pop3Authenticate to log in. The
	// Pop3BeginSession method performs both steps and is equivalent to calling
	// Pop3Connect followed by Pop3Authenticate .
	// 
	// Calling this method is optional in most applications because POP3 methods that
	// communicate with the server automatically connect and authenticate if no
	// authenticated session is already open. When finished with the POP3 server, call
	// Pop3EndSession or Pop3EndSessionNoQuit to disconnect.
	// 
	bool Pop3Connect(void);

	// Creates an asynchronous task to call the Pop3Connect method with the arguments
	// provided.
	// The caller is responsible for deleting the object returned by this method.
	CkTaskW *Pop3ConnectAsync(void);

	// 
	// 
	// Explicitly ends the current POP3 session. Chilkat sends the POP3 QUIT command
	// and then closes the connection to the POP3 server.
	// 
	// If ImmediateDelete is false , any messages previously marked for deletion are
	// deleted when this method sends QUIT and the POP3 session ends.
	// 
	bool Pop3EndSession(void);

	// Creates an asynchronous task to call the Pop3EndSession method with the
	// arguments provided.
	// The caller is responsible for deleting the object returned by this method.
	CkTaskW *Pop3EndSessionAsync(void);

	// 
	// 
	// Closes the POP3 connection without sending the QUIT command.
	// 
	// This differs from Pop3EndSession , which sends QUIT before disconnecting.
	// Because POP3 deletions are normally finalized when QUIT is sent, use this method
	// only when the application intentionally wants to disconnect without completing
	// the normal session-ending command sequence.
	// 
	// This method should always return true .
	// 
	bool Pop3EndSessionNoQuit(void);

	// Creates an asynchronous task to call the Pop3EndSessionNoQuit method with the
	// arguments provided.
	// The caller is responsible for deleting the object returned by this method.
	CkTaskW *Pop3EndSessionNoQuitAsync(void);

	// 
	// 
	// Sends a POP3 NOOP command to the server.
	// 
	// This can be useful for keeping a POP3 session alive or for verifying that the
	// current POP3 connection is still open and functioning.
	// 
	bool Pop3Noop(void);

	// Creates an asynchronous task to call the Pop3Noop method with the arguments
	// provided.
	// The caller is responsible for deleting the object returned by this method.
	CkTaskW *Pop3NoopAsync(void);

	// 
	// 
	// Sends a POP3 RSET command to the server.
	// 
	// If any messages have been marked for deletion during the current POP3 session,
	// RSET unmarks them. This resets the deletion state of the POP3 session to a known
	// valid starting point.
	// 
	bool Pop3Reset(void);

	// Creates an asynchronous task to call the Pop3Reset method with the arguments
	// provided.
	// The caller is responsible for deleting the object returned by this method.
	CkTaskW *Pop3ResetAsync(void);

	// 
	// 
	// Sends a raw command to the POP3 server and returns the server's response.
	// 
	// If command contains non-US-ASCII characters, charset specifies the character set
	// used to encode the command before it is sent. Examples include utf-8 , ansi ,
	// iso-8859-1 , and Shift_JIS .
	// 
	// This method is intended for advanced use, diagnostics, or issuing POP3 commands
	// not directly exposed by higher-level MailMan methods.
	// 
	bool Pop3SendRawCommand(const wchar_t *command, const wchar_t *charset, CkString &outStr);
	// 
	// 
	// Sends a raw command to the POP3 server and returns the server's response.
	// 
	// If command contains non-US-ASCII characters, charset specifies the character set
	// used to encode the command before it is sent. Examples include utf-8 , ansi ,
	// iso-8859-1 , and Shift_JIS .
	// 
	// This method is intended for advanced use, diagnostics, or issuing POP3 commands
	// not directly exposed by higher-level MailMan methods.
	// 
	const wchar_t *pop3SendRawCommand(const wchar_t *command, const wchar_t *charset);

	// Creates an asynchronous task to call the Pop3SendRawCommand method with the
	// arguments provided.
	// The caller is responsible for deleting the object returned by this method.
	CkTaskW *Pop3SendRawCommandAsync(const wchar_t *command, const wchar_t *charset);

	// 
	// 
	// Sends a simple email to a single recipient without requiring the application to
	// explicitly create an Email object.
	// 
	// The fromAddr argument is the sender address, toAddr is the recipient address,
	// subject is the message subject, body is the plain-text body, and smtpServer is
	// the SMTP server hostname.
	// 
	// This method is convenient for simple cases. For attachments, HTML email, CC/BCC
	// recipients, alternate bodies, signing, encryption, or more control over headers
	// and SMTP behavior, create an Email object and use SendEmail instead.
	// 
	bool QuickSend(const wchar_t *fromAddr, const wchar_t *toAddr, const wchar_t *subject, const wchar_t *body, const wchar_t *smtpServer);

	// Creates an asynchronous task to call the QuickSend method with the arguments
	// provided.
	// The caller is responsible for deleting the object returned by this method.
	CkTaskW *QuickSendAsync(const wchar_t *fromAddr, const wchar_t *toAddr, const wchar_t *subject, const wchar_t *body, const wchar_t *smtpServer);

	// 
	// 
	// Renders an Email object into the MIME text that would be sent to the SMTP
	// server, without actually sending the email.
	// 
	// When SendEmail is called, Chilkat first renders the email using the current
	// MailMan and Email settings. This rendering may include MIME formatting, header
	// encoding, placeholder substitution, digital signing, encryption, and other
	// transformations required before transmission. RenderToMime performs that
	// rendering step and returns the resulting MIME text.
	// 
	// Conceptually, SendEmail is equivalent to calling RenderToMime followed by
	// SendMime . If successful, the rendered MIME string is returned.
	// 
	// Note: If the MIME may contain 8bit or binary content, use RenderToMimeBytes or
	// RenderToMimeBd instead. Returning binary MIME as a string can corrupt data that
	// is not valid text.
	// 
	bool RenderToMime(CkEmailW &email, CkString &outStr);
	// 
	// 
	// Renders an Email object into the MIME text that would be sent to the SMTP
	// server, without actually sending the email.
	// 
	// When SendEmail is called, Chilkat first renders the email using the current
	// MailMan and Email settings. This rendering may include MIME formatting, header
	// encoding, placeholder substitution, digital signing, encryption, and other
	// transformations required before transmission. RenderToMime performs that
	// rendering step and returns the resulting MIME text.
	// 
	// Conceptually, SendEmail is equivalent to calling RenderToMime followed by
	// SendMime . If successful, the rendered MIME string is returned.
	// 
	// Note: If the MIME may contain 8bit or binary content, use RenderToMimeBytes or
	// RenderToMimeBd instead. Returning binary MIME as a string can corrupt data that
	// is not valid text.
	// 
	const wchar_t *renderToMime(CkEmailW &email);

	// 
	// 
	// Renders an Email object into MIME bytes and appends the result to renderedMime .
	// 
	// This method is the BinData version of RenderToMimeBytes . It is useful when the
	// rendered MIME must be preserved exactly as bytes, especially if the message may
	// contain 8bit or binary MIME content.
	// 
	bool RenderToMimeBd(CkEmailW &email, CkBinDataW &renderedMime);

	// 
	// 
	// Renders an Email object into the MIME bytes that would be sent to the SMTP
	// server, without actually sending the email.
	// 
	// This method is similar to RenderToMime , except the rendered MIME is returned as
	// a byte array. Use this method when the MIME may contain 8bit or binary content,
	// or when the exact bytes must be preserved.
	// 
	// Returning MIME as a string can introduce errors if the message contains non-text
	// binary data. For that reason, RenderToMimeBytes is recommended unless it is
	// certain that the rendered MIME is entirely safe to represent as text.
	// 
	bool RenderToMimeBytes(CkEmailW &email, CkByteData &outBytes);

	// 
	// 
	// Renders an Email object into MIME text and appends the result to renderedMime .
	// 
	// This method is the StringBuilder version of RenderToMime . It is useful when the
	// application wants to accumulate or inspect the rendered MIME text without
	// immediately sending the email.
	// 
	// Note: If the MIME may contain 8bit or binary content, use RenderToMimeBytes or
	// RenderToMimeBd instead. Returning binary MIME as text can corrupt data that is
	// not valid text.
	// 
	bool RenderToMimeSb(CkEmailW &email, CkStringBuilderW &renderedMime);

	// 
	// 
	// Sends each email in bundle . This is equivalent to calling SendEmail once for
	// each email in the bundle.
	// 
	// If an error occurs while sending one email, Chilkat continues attempting to send
	// the remaining emails unless a fatal error occurs that requires the send
	// operation to stop.
	// 
	// Because it can be difficult or impossible to programmatically determine exactly
	// which emails succeeded and which failed after a bundle send, applications that
	// need detailed per-message status should loop through the bundle and call
	// SendEmail for each message individually.
	// 
	bool SendBundle(CkEmailBundleW &bundle);

	// Creates an asynchronous task to call the SendBundle method with the arguments
	// provided.
	// The caller is responsible for deleting the object returned by this method.
	CkTaskW *SendBundleAsync(CkEmailBundleW &bundle);

	// 
	// 
	// Sends a single email through the configured SMTP server.
	// 
	// Chilkat automatically opens the SMTP connection when needed. After the email is
	// sent, the connection remains open so a subsequent call to SendEmail or another
	// email-sending method can reuse the same SMTP connection. If an SMTP-related
	// property changes, such as SmtpHost , SmtpUsername , password, port, or SSL/TLS
	// settings, Chilkat automatically closes the existing connection and establishes a
	// new one using the updated settings on the next send.
	// 
	// Important: Some SMTP servers do not complete final delivery processing until the
	// SMTP connection is closed. In these cases, call CloseSmtpConnection after
	// sending. Most SMTP servers process the message immediately, so explicitly
	// closing the connection is usually not required.
	// 
	// After sending, additional information about the SMTP transaction may be
	// available by calling GetLastJsonData .
	// 
	// This method returns true if the final SMTP status code in the SMTP session is
	// in the 200 or 300 range. Returns false for failure.
	// 
	bool SendEmail(CkEmailW &email);

	// Creates an asynchronous task to call the SendEmail method with the arguments
	// provided.
	// The caller is responsible for deleting the object returned by this method.
	CkTaskW *SendEmailAsync(CkEmailW &email);

	// 
	// 
	// Sends an email from caller-supplied MIME text. The MIME source in mimeSource is
	// passed to the SMTP server as the message content.
	// 
	// This method provides complete control over the MIME that is sent. It is useful
	// when the application already has a fully formed MIME message, or when the MIME
	// was created externally and should not be rebuilt from an Email object.
	// 
	// The fromAddr argument is the SMTP reverse-path address used in the MAIL FROM
	// command. This is where bounced email and non-delivery reports are normally
	// delivered. It can be different from the From header in the MIME.
	// 
	// The recipients argument is a comma-separated list of recipient email addresses
	// used in SMTP RCPT TO commands. These are usually the same addresses found in the
	// MIME To , Cc , and Bcc headers, but they do not have to be the same unless the
	// SMTP server enforces such a policy.
	// 
	// This method returns true if the final SMTP status code in the SMTP session is
	// in the 200 or 300 range. Returns false for failure.
	// 
	bool SendMime(const wchar_t *fromAddr, const wchar_t *recipients, const wchar_t *mimeSource);

	// Creates an asynchronous task to call the SendMime method with the arguments
	// provided.
	// The caller is responsible for deleting the object returned by this method.
	CkTaskW *SendMimeAsync(const wchar_t *fromAddr, const wchar_t *recipients, const wchar_t *mimeSource);

	// 
	// 
	// Sends an email from caller-supplied MIME bytes contained in mimeData .
	// 
	// This method is the BinData version of SendMimeBytes . It is useful when the MIME
	// must be sent exactly as bytes, such as when it contains binary MIME content,
	// 8bit encodings, or a DKIM/DomainKey signature where byte preservation matters.
	// 
	// The fromAddr argument is the SMTP reverse-path address used in the MAIL FROM
	// command. The recipients argument is a comma-separated list of recipient
	// addresses used in SMTP RCPT TO commands.
	// 
	// This method returns true if the final SMTP status code in the SMTP session is
	// in the 200 or 300 range. Returns false for failure.
	// 
	bool SendMimeBd(const wchar_t *fromAddr, const wchar_t *recipients, CkBinDataW &mimeData);

	// Creates an asynchronous task to call the SendMimeBd method with the arguments
	// provided.
	// The caller is responsible for deleting the object returned by this method.
	CkTaskW *SendMimeBdAsync(const wchar_t *fromAddr, const wchar_t *recipients, CkBinDataW &mimeData);

	// 
	// 
	// Sends an email from caller-supplied MIME bytes.
	// 
	// This method is similar to SendMime , except the MIME is supplied as a byte
	// array. Use this method when the MIME contains binary data, 8bit content, or a
	// DKIM/DomainKey signature where preserving the exact bytes is important.
	// 
	// The fromAddr argument is the SMTP reverse-path address used in the MAIL FROM
	// command. This is where bounced email and non-delivery reports are normally
	// delivered. It can be different from the From header in the MIME.
	// 
	// The recipients argument is a comma-separated list of recipient email addresses
	// used in SMTP RCPT TO commands. These are usually the same addresses found in the
	// MIME To , Cc , and Bcc headers, but they do not have to be the same unless the
	// SMTP server enforces such a policy.
	// 
	// This method returns true if the final SMTP status code in the SMTP session is
	// in the 200 or 300 range. Returns false for failure.
	// 
	bool SendMimeBytes(const wchar_t *fromAddr, const wchar_t *recipients, CkByteData &mimeSource);

	// Creates an asynchronous task to call the SendMimeBytes method with the arguments
	// provided.
	// The caller is responsible for deleting the object returned by this method.
	CkTaskW *SendMimeBytesAsync(const wchar_t *fromAddr, const wchar_t *recipients, CkByteData &mimeSource);

	// 
	// 
	// Sends caller-supplied MIME text to a distribution list read from a text file.
	// 
	// This method is similar to SendMime , except the recipient list is read from
	// distListFilename . The distribution list file should contain one email address
	// per line.
	// 
	// The fromAddr argument is the SMTP reverse-path address used in the MAIL FROM
	// command. The MIME text in mimeSource is used as the message content.
	// 
	bool SendMimeToList(const wchar_t *fromAddr, const wchar_t *distListFilename, const wchar_t *mimeSource);

	// Creates an asynchronous task to call the SendMimeToList method with the
	// arguments provided.
	// The caller is responsible for deleting the object returned by this method.
	CkTaskW *SendMimeToListAsync(const wchar_t *fromAddr, const wchar_t *distListFilename, const wchar_t *mimeSource);

	// 
	// 
	// Explicitly specifies the certificate to use when decrypting encrypted email.
	// 
	// The certificate must correspond to the recipient certificate used to encrypt the
	// message, and the associated private key must be available to Chilkat through the
	// certificate itself, an added PFX source, an XML certificate vault, or the
	// platform certificate store where applicable.
	// 
	bool SetDecryptCert(CkCertW &cert);

	// 
	// 
	// Explicitly specifies both the certificate and its associated private key to use
	// when decrypting S/MIME encrypted email.
	// 
	// In most cases, it is simpler to call AddPfxSourceFile or AddPfxSourceData to
	// provide the certificate and private key together in a PFX/PKCS#12 source. On
	// Windows, if the certificate and private key are already installed in the default
	// certificate store, no explicit setup may be needed because MailMan automatically
	// searches the Windows certificate stores.
	// 
	bool SetDecryptCert2(CkCertW &cert, CkPrivateKeyW &privateKey);

	// 
	// 
	// Sets the POP3 or SMTP password from a SecureString .
	// 
	// The protocol argument specifies which password is being set. Use pop3 to set the
	// POP3 password, which is equivalent to setting the PopPassword property. Use smtp
	// to set the SMTP password, which is equivalent to setting the SmtpPassword
	// property.
	// 
	bool SetPassword(const wchar_t *protocol, CkSecureStringW &password);

	// 
	// 
	// Sets the client-side certificate to use for SSL/TLS connections.
	// 
	// This is typically not required. Most SSL/TLS connections authenticate the server
	// only, while the client remains unauthenticated at the TLS layer. Use this method
	// only when the SMTP or POP3 server requires TLS client certificate
	// authentication.
	// 
	bool SetSslClientCert(CkCertW &cert);

	// 
	// 
	// Sets the client-side certificate to use for SSL/TLS connections, loading it from
	// PEM data or from a PEM file.
	// 
	// The pemDataOrFilename argument may contain PEM text or the path to a PEM file.
	// The pemPassword argument supplies the password if the PEM private key is
	// encrypted.
	// 
	// TLS client certificates are typically required only when the server uses mutual
	// TLS. Most SMTP and POP3 SSL/TLS connections do not require a client certificate.
	// 
	bool SetSslClientCertPem(const wchar_t *pemDataOrFilename, const wchar_t *pemPassword);

	// 
	// 
	// Sets the client-side certificate to use for SSL/TLS connections, loading it from
	// a PFX/PKCS#12 file.
	// 
	// The pfxPath argument is the path to the PFX file, and pfxPassword is the
	// password required to open it.
	// 
	// TLS client certificates are typically required only when the server uses mutual
	// TLS. Most SMTP and POP3 SSL/TLS connections do not require a client certificate.
	// 
	bool SetSslClientCertPfx(const wchar_t *pfxPath, const wchar_t *pfxPassword);

	// 
	// 
	// Authenticates with the SMTP server using the current SMTP property settings,
	// such as SmtpUsername , SmtpPassword , OAuth2 token settings, and other
	// authentication-related options.
	// 
	// This method should be called only after a successful call to SmtpConnect . The
	// OpenSmtpConnection method performs both steps and is equivalent to calling
	// SmtpConnect followed by SmtpAuthenticate .
	// 
	// Calling this method is optional in most applications because SMTP methods that
	// communicate with the server, such as SendEmail , automatically connect and
	// authenticate if no authenticated SMTP connection is already open.
	// 
	bool SmtpAuthenticate(void);

	// Creates an asynchronous task to call the SmtpAuthenticate method with the
	// arguments provided.
	// The caller is responsible for deleting the object returned by this method.
	CkTaskW *SmtpAuthenticateAsync(void);

	// 
	// 
	// Explicitly connects to the SMTP server. If SSL/TLS is required by the current
	// property settings, the secure TLS channel is established as part of this call.
	// This method receives the server's initial greeting but does not authenticate.
	// 
	// After SmtpConnect succeeds, call SmtpAuthenticate to authenticate. The
	// OpenSmtpConnection method performs both steps and is equivalent to calling
	// SmtpConnect followed by SmtpAuthenticate .
	// 
	// Calling this method is optional in most applications because SMTP methods that
	// communicate with the server, such as SendEmail , automatically connect and
	// authenticate if no authenticated SMTP connection is already open.
	// 
	bool SmtpConnect(void);

	// Creates an asynchronous task to call the SmtpConnect method with the arguments
	// provided.
	// The caller is responsible for deleting the object returned by this method.
	CkTaskW *SmtpConnectAsync(void);

	// 
	// 
	// Sends an SMTP NOOP command to the server.
	// 
	// This can be useful for testing whether the SMTP connection is working and still
	// valid. If an SMTP connection is not already open, SmtpNoop automatically
	// establishes the connection using the current SMTP property settings.
	// 
	bool SmtpNoop(void);

	// Creates an asynchronous task to call the SmtpNoop method with the arguments
	// provided.
	// The caller is responsible for deleting the object returned by this method.
	CkTaskW *SmtpNoopAsync(void);

	// 
	// 
	// Sends an SMTP RSET command to the server.
	// 
	// The RSET command resets the server-side state of the current SMTP transaction so
	// the connection can be used to begin a new mail transaction. This method is
	// rarely needed. It would normally only be useful if a mail-sending method failed
	// and left the SMTP connection open in a non-initial state, a situation that
	// should generally not occur with the Chilkat MailMan object.
	// 
	bool SmtpReset(void);

	// Creates an asynchronous task to call the SmtpReset method with the arguments
	// provided.
	// The caller is responsible for deleting the object returned by this method.
	CkTaskW *SmtpResetAsync(void);

	// 
	// 
	// Sends a raw command to the SMTP server and returns the server's response.
	// 
	// If command contains non-US-ASCII characters, charset specifies the character set
	// used to encode the command before it is sent. Examples include utf-8 , ansi ,
	// iso-8859-1 , and Shift_JIS .
	// 
	// If bEncodeBase64 is true , the response is returned in Base64-encoded form. If
	// bEncodeBase64 is false , the raw response text is returned.
	// 
	// This method is intended for advanced use, diagnostics, or issuing SMTP commands
	// not directly exposed by higher-level MailMan methods.
	// 
	bool SmtpSendRawCommand(const wchar_t *command, const wchar_t *charset, bool bEncodeBase64, CkString &outStr);
	// 
	// 
	// Sends a raw command to the SMTP server and returns the server's response.
	// 
	// If command contains non-US-ASCII characters, charset specifies the character set
	// used to encode the command before it is sent. Examples include utf-8 , ansi ,
	// iso-8859-1 , and Shift_JIS .
	// 
	// If bEncodeBase64 is true , the response is returned in Base64-encoded form. If
	// bEncodeBase64 is false , the raw response text is returned.
	// 
	// This method is intended for advanced use, diagnostics, or issuing SMTP commands
	// not directly exposed by higher-level MailMan methods.
	// 
	const wchar_t *smtpSendRawCommand(const wchar_t *command, const wchar_t *charset, bool bEncodeBase64);

	// Creates an asynchronous task to call the SmtpSendRawCommand method with the
	// arguments provided.
	// The caller is responsible for deleting the object returned by this method.
	CkTaskW *SmtpSendRawCommandAsync(const wchar_t *command, const wchar_t *charset, bool bEncodeBase64);

	// 
	// 
	// Authenticates with the SSH server using public-key authentication after an SSH
	// tunnel has been opened.
	// 
	// The sshLogin argument is the SSH account name. The sshUsername argument, despite
	// its name in this signature, is the SshKey containing the private key used for
	// authentication. The matching public key must already be installed for the SSH
	// account on the server.
	// 
	// An SSH tunneling session begins by calling SshOpenTunnel to connect to the SSH
	// server, followed by either SshAuthenticatePk or SshAuthenticatePw to
	// authenticate.
	// 
	// After the SSH tunnel is established and authenticated, MailMan's underlying SMTP
	// or POP3 communication uses the SSH tunnel. No other programming changes are
	// required beyond the initial tunnel setup calls.
	// 
	bool SshAuthenticatePk(const wchar_t *sshLogin, CkSshKeyW &sshUsername);

	// Creates an asynchronous task to call the SshAuthenticatePk method with the
	// arguments provided.
	// The caller is responsible for deleting the object returned by this method.
	CkTaskW *SshAuthenticatePkAsync(const wchar_t *sshLogin, CkSshKeyW &sshUsername);

	// 
	// 
	// Authenticates with the SSH server using an SSH username and password after an
	// SSH tunnel has been opened.
	// 
	// The sshLogin argument is the SSH account name, and sshPassword is the
	// corresponding SSH password.
	// 
	// An SSH tunneling session begins by calling SshOpenTunnel to connect to the SSH
	// server, followed by either SshAuthenticatePw or SshAuthenticatePk to
	// authenticate.
	// 
	// After the SSH tunnel is established and authenticated, MailMan's underlying SMTP
	// or POP3 communication uses the SSH tunnel. No other programming changes are
	// required beyond the initial tunnel setup calls.
	// 
	bool SshAuthenticatePw(const wchar_t *sshLogin, const wchar_t *sshPassword);

	// Creates an asynchronous task to call the SshAuthenticatePw method with the
	// arguments provided.
	// The caller is responsible for deleting the object returned by this method.
	CkTaskW *SshAuthenticatePwAsync(const wchar_t *sshLogin, const wchar_t *sshPassword);

	// 
	// 
	// Closes the SSH tunnel used for SMTP or POP3 communication.
	// 
	bool SshCloseTunnel(void);

	// Creates an asynchronous task to call the SshCloseTunnel method with the
	// arguments provided.
	// The caller is responsible for deleting the object returned by this method.
	CkTaskW *SshCloseTunnelAsync(void);

	// 
	// 
	// Connects to an SSH server and opens an SSH tunnel for MailMan's SMTP or POP3
	// connections.
	// 
	// The sshHostname argument is the hostname or IP address of the SSH server. The
	// sshPort argument is the SSH port, typically 22 .
	// 
	// An SSH tunneling session begins by calling SshOpenTunnel , followed by either
	// SshAuthenticatePw or SshAuthenticatePk to authenticate.
	// 
	// After the SSH tunnel is established and authenticated, MailMan's underlying SMTP
	// or POP3 communication uses the SSH tunnel. No other programming changes are
	// required beyond the initial tunnel setup calls.
	// 
	bool SshOpenTunnel(const wchar_t *sshHostname, int sshPort);

	// Creates an asynchronous task to call the SshOpenTunnel method with the arguments
	// provided.
	// The caller is responsible for deleting the object returned by this method.
	CkTaskW *SshOpenTunnelAsync(const wchar_t *sshHostname, int sshPort);

	// This method is deprecated. Applications should instead call FetchAll .
	// 
	// Downloads and removes all email from a POP3 server. A bundle containing the
	// emails is returned. A null reference is returned on failure.
	// 
	// The caller is responsible for deleting the object returned by this method.
	CkEmailBundleW *TransferMail(void);

	// Creates an asynchronous task to call the TransferMail method with the arguments
	// provided.
	// The caller is responsible for deleting the object returned by this method.
	CkTaskW *TransferMailAsync(void);

	// This deprecated method will be removed in a future major release of Chilkat.
	// MIME can potentially include non-encoded binary data and mixed character
	// encodings, so downloading emails as a simple MIME string often requires
	// processing and modifications, making it impractical. Instead, applications
	// should use FetchMimeBd or methods that download emails to email objects.
	// 
	// Same as FetchMultipleMime except that the downloaded emails are also deleted
	// from the server. Returns a null reference on failure.
	// 
	// The caller is responsible for deleting the object returned by this method.
	CkStringArrayW *TransferMultipleMime(CkStringArrayW &uidlArray);

	// Creates an asynchronous task to call the TransferMultipleMime method with the
	// arguments provided.
	// The caller is responsible for deleting the object returned by this method.
	CkTaskW *TransferMultipleMimeAsync(CkStringArrayW &uidlArray);

	// 
	// 
	// Provides an XML certificate vault to be searched for certificates and private
	// keys when MailMan performs operations such as encryption, decryption, signing,
	// or signature verification.
	// 
	// Unlike PFX sources added with AddPfxSourceData , AddPfxSourceBd , or
	// AddPfxSourceFile , only one XML certificate vault can be used at a time. If
	// UseCertVault is called more than once, the most recent vault replaces the
	// previously supplied vault.
	// 
	bool UseCertVault(CkXmlCertVaultW &vault);

	// 
	// 
	// Configures MailMan to use an existing SSH tunnel provided by an Ssh object for
	// SMTP and POP3 connections.
	// 
	// This method is similar to UseSshTunnel , except the SSH tunnel is supplied by an
	// Ssh object rather than a Socket object.
	// 
	// Sharing an existing SSH tunnel is useful when multiple objects need to
	// communicate through the same SSH connection. SSH supports multiple logical
	// channels within one tunnel, so SMTP and POP3 connections can exist
	// simultaneously as separate SSH channels.
	// 
	bool UseSsh(CkSshW &ssh);

	// 
	// 
	// Configures MailMan to use an existing SSH tunnel provided by a Socket object for
	// SMTP and POP3 connections.
	// 
	// Sharing an existing SSH tunnel is useful when multiple objects need to
	// communicate through the same SSH connection. SSH supports multiple logical
	// channels within one tunnel, so SMTP and POP3 connections can exist
	// simultaneously as separate SSH channels.
	// 
	bool UseSshTunnel(CkSocketW &tunnel);

	// 
	// 
	// Tests whether a TCP/IP connection can be established with the configured POP3
	// server.
	// 
	// This method verifies connectivity only. It does not prove that POP3
	// authentication will succeed. Use VerifyPopLogin to test both connection and
	// login.
	// 
	// Returns true if the connection can be established, otherwise returns false .
	// 
	bool VerifyPopConnection(void);

	// Creates an asynchronous task to call the VerifyPopConnection method with the
	// arguments provided.
	// The caller is responsible for deleting the object returned by this method.
	CkTaskW *VerifyPopConnectionAsync(void);

	// 
	// 
	// Tests whether Chilkat can connect to the configured POP3 server and successfully
	// log in using the current POP3 authentication settings.
	// 
	// Use this method to diagnose whether POP3 credentials and authentication settings
	// are correct. If only the TCP/IP connection needs to be tested, use
	// VerifyPopConnection .
	// 
	// Returns true if the connection and login succeed, otherwise returns false .
	// 
	bool VerifyPopLogin(void);

	// Creates an asynchronous task to call the VerifyPopLogin method with the
	// arguments provided.
	// The caller is responsible for deleting the object returned by this method.
	CkTaskW *VerifyPopLoginAsync(void);

	// 
	// 
	// Begins the SMTP send process for email , sends the recipient addresses to the
	// SMTP server, and then aborts before sending the message content. Recipient
	// addresses rejected by the SMTP server are returned in badAddrs .
	// 
	// This method can help identify addresses the SMTP server rejects during the SMTP
	// RCPT TO stage. However, it cannot guarantee that all accepted addresses are
	// valid. SMTP servers often accept addresses outside their own domains and only
	// later discover delivery failures when relaying or delivering to the final
	// destination.
	// 
	bool VerifyRecips(CkEmailW &email, CkStringArrayW &badAddrs);

	// Creates an asynchronous task to call the VerifyRecips method with the arguments
	// provided.
	// The caller is responsible for deleting the object returned by this method.
	CkTaskW *VerifyRecipsAsync(CkEmailW &email, CkStringArrayW &badAddrs);

	// 
	// 
	// Tests whether a TCP/IP connection can be established with the configured SMTP
	// server.
	// 
	// This method verifies connectivity only. It does not prove that SMTP
	// authentication will succeed. Use VerifySmtpLogin to test both connection and
	// login.
	// 
	// Returns true if the connection can be established, otherwise returns false .
	// 
	bool VerifySmtpConnection(void);

	// Creates an asynchronous task to call the VerifySmtpConnection method with the
	// arguments provided.
	// The caller is responsible for deleting the object returned by this method.
	CkTaskW *VerifySmtpConnectionAsync(void);

	// 
	// 
	// Tests whether Chilkat can connect to the configured SMTP server and successfully
	// authenticate using the current SMTP authentication settings.
	// 
	// Use this method to diagnose whether SMTP credentials and authentication settings
	// are correct. If only the TCP/IP connection needs to be tested, use
	// VerifySmtpConnection .
	// 
	// Returns true if the connection and login succeed, otherwise returns false .
	// 
	bool VerifySmtpLogin(void);

	// Creates an asynchronous task to call the VerifySmtpLogin method with the
	// arguments provided.
	// The caller is responsible for deleting the object returned by this method.
	CkTaskW *VerifySmtpLoginAsync(void);





	// END PUBLIC INTERFACE


};
#if !defined(__sun__) && !defined(__sun)
#pragma pack (pop)
#endif
	
#endif
