@chilkat/react-native 11.6.1

package/src/specs/Imap.nitro.ts

@@ -0,0 +1,2991 @@
+// Generated by ReactNativeNs.RnGenerator -- do not edit.
+import type { HybridObject } from 'react-native-nitro-modules'
+import type { BinData } from './BinData.nitro'
+import type { Cert } from './Cert.nitro'
+import type { Email } from './Email.nitro'
+import type { EmailBundle } from './EmailBundle.nitro'
+import type { JsonObject } from './JsonObject.nitro'
+import type { Mailboxes } from './Mailboxes.nitro'
+import type { MessageSet } from './MessageSet.nitro'
+import type { PrivateKey } from './PrivateKey.nitro'
+import type { SecureString } from './SecureString.nitro'
+import type { Socket } from './Socket.nitro'
+import type { Ssh } from './Ssh.nitro'
+import type { SshKey } from './SshKey.nitro'
+import type { StringBuilder } from './StringBuilder.nitro'
+import type { XmlCertVault } from './XmlCertVault.nitro'
+
+/**
+ * Access, search, download, organize, and monitor email on IMAP servers.
+ *
+ * `Imap` is a full-featured IMAP client class for
+ * applications that need reliable server-side email access and mailbox
+ * management. It supports secure connections, authentication, mailbox
+ * selection, message searching, downloading email and attachments, flag
+ * management, moving and copying messages, appending MIME, IDLE-based change
+ * monitoring, and detailed diagnostics for troubleshooting server behavior.
+ *
+ * **Secure IMAP connections**
+ *
+ * Connect with SSL/TLS, STARTTLS, OAuth2, password authentication, proxy
+ * settings, timeouts, and connection diagnostics.
+ *
+ * **Mailbox selection and listing**
+ *
+ * List mailboxes, select folders, inspect mailbox state, and work with
+ * server-side folders such as Inbox, Sent, Archive, or custom folders.
+ *
+ * **Search and fetch messages**
+ *
+ * Search by IMAP criteria, work with UIDs or sequence numbers, download
+ * full messages, headers, MIME, body text, or selected message parts.
+ *
+ * **Message management**
+ *
+ * Set and clear flags, mark messages read or unread, copy or move messages,
+ * delete messages, expunge mailboxes, and append MIME to folders.
+ *
+ * **Attachments and MIME**
+ *
+ * Retrieve email as Chilkat `Email` objects, process MIME
+ * content, and save or inspect attachments as needed.
+ *
+ * **IDLE and diagnostics**
+ *
+ * Monitor mailbox changes with IMAP IDLE and use detailed logging,
+ * response text, and `LastErrorText` to troubleshoot servers.
+ *
+ * **Common pattern:**
+ * Connect securely, authenticate, select a mailbox, search or fetch messages
+ * using UIDs when possible, perform message or folder operations, then
+ * disconnect cleanly. Use detailed diagnostics when working with provider-
+ * specific IMAP behavior.
+ *
+ * For an extended overview, see
+ * [Imap Class Overview](https://www.chilkatsoft.com/imap_class_overview.asp).
+ *
+ * Each `Imap` instance owns a native Chilkat object. It is released when the JavaScript object is
+ * garbage collected, or immediately by `dispose()`; any use after `dispose()` throws.
+ * Create one with `new Imap()`.
+ *
+ * Methods that can take a while (network, files, compression, key generation) also have an
+ * `...Async` form returning a `Promise`; it runs on a native worker thread so the UI keeps
+ * rendering. While such a call is pending, every other call on this object throws, except
+ * {@link Imap.abort} and assigning {@link Imap.onPercentDone} / {@link Imap.onProgressInfo}.
+ */
+export interface Imap extends HybridObject<{ ios: 'c++', android: 'c++' }> {
+  // ---- Properties ----
+
+  /**
+   * Provides HTML-formatted information about the last called method or property. If a method call
+   * fails or behaves unexpectedly, check this property for details. Note that information is
+   * available regardless of the method call's success.
+   *
+   * This property is read-only.
+   */
+  readonly lastErrorHtml: string
+
+  /**
+   * Provides plain text information about the last called method or property. If a method call
+   * fails or behaves unexpectedly, check this property for details. Note that information is
+   * available regardless of the method call's success.
+   *
+   * This property is read-only.
+   */
+  readonly lastErrorText: string
+
+  /**
+   * Provides XML-formatted information about the last called method or property. If a method call
+   * fails or behaves unexpectedly, check this property for details. Note that information is
+   * available regardless of the method call's success.
+   *
+   * This property is read-only.
+   */
+  readonly lastErrorXml: string
+
+  /**
+   * Version of the component/library, such as "10.1.0"
+   *
+   * This property is read-only.
+   */
+  readonly version: string
+
+  /**
+   * If set to a file path, this property logs the LastErrorText of each Chilkat method or property
+   * call to the specified file. This logging helps identify the context and history of Chilkat
+   * calls leading up to any crash or hang, aiding in debugging.
+   *
+   * Enabling the VerboseLogging property provides more detailed information.
+   *
+   * This property is mainly used for debugging rare instances where a Chilkat method call causes a
+   * hang or crash, which should generally not happen.
+   *
+   * Possible causes of hangs include:
+   *
+   * - A timeout property set to 0, indicating an infinite timeout.
+   *
+   * - A hang occurring within an event callback in the application code.
+   *
+   * - An internal bug in the Chilkat code causing the hang.
+   */
+  debugLogFilePath: string
+
+  /**
+   * If set to `true`, then the contents of LastErrorText (or LastErrorXml, or LastErrorHtml) may
+   * contain more verbose information. The default value is `false`. Verbose logging should only be
+   * used for debugging. The potentially large quantity of logged information may adversely affect
+   * peformance.
+   */
+  verboseLogging: boolean
+
+  /**
+   * Indicates the success or failure of the most recent method call: `true` means success, `false`
+   * means failure. This property remains unchanged by property setters or getters. This method is
+   * present to address challenges in checking for null or Nothing returns in certain programming
+   * languages. Note: This property does not apply to methods that return integer values or to
+   * boolean-returning methods where the boolean does not indicate success or failure.
+   */
+  lastMethodSuccess: boolean
+
+  /**
+   * Controls cancellation of the method currently running on this `Imap` object.
+   *
+   * - Set this property to `true` to request that a long-running network operation abort.
+   *
+   * - Short methods that do not perform lengthy processing or network communication are generally
+   *   unaffected.
+   *
+   * - Both synchronous and asynchronous calls can be aborted. A synchronous call may be canceled by
+   *   setting this property from another thread.
+   *
+   * The property is automatically reset to `false` when the abort is processed. If no method is
+   * running, it is reset when the next method begins.
+   *
+   * Canceling an operation can leave the connection in an uncertain state. Close the connection,
+   * reconnect, authenticate again, and reselect the mailbox before continuing. Output objects may
+   * contain partial results, and a server-side operation may already have been partially applied
+   * before cancellation.
+   */
+  abortCurrent: boolean
+
+  /**
+   * Controls the initial `\Seen` flag for these methods:
+   *
+   * - {@link Imap.appendMail}
+   *
+   * - {@link Imap.appendMime}
+   *
+   * - {@link Imap.appendMimeWithDateStr}
+   *
+   * - `true` (the default): the appended message is marked as seen.
+   *
+   * - `false`: the appended message is initially unseen.
+   *
+   * The flag-specific append methods use their explicit arguments and do not use this property.
+   */
+  appendSeen: boolean
+
+  /**
+   * Contains the UID assigned by the server to the message most recently appended successfully.
+   *
+   * The default is `0`. After any successful append, this property is set to the UID reported by
+   * the server, or to `0` if the server succeeds but does not report an appended UID. A failed
+   * append leaves the previous value unchanged.
+   *
+   * This property is read-only.
+   */
+  readonly appendUid: number
+
+  /**
+   * Selects the IMAP authentication mechanism. Matching is case-insensitive, but spelling matters.
+   *
+   * ValuePurpose
+   *
+   * | `LOGIN` |  | Username and password authentication. |
+   *
+   * | `PLAIN` |  | SASL PLAIN authentication. {@link Imap.authzId} may also be used. |
+   *
+   * | `CRAM-MD5` |  | Challenge-response authentication when supported by the server. |
+   *
+   * | `NTLM` |  | Windows Integrated Authentication. |
+   *
+   * | `XOAUTH2` |  | OAuth 2.0 access-token authentication. |
+   *
+   * The default is `LOGIN`, and an empty or unrecognized value also uses the LOGIN method. If the
+   * selected mechanism fails or is not supported by the server, Chilkat does not fall back to
+   * another authentication method.
+   *
+   * If NTLM authentication fails because of an NTLM-version compatibility issue, set
+   * `Global.DefaultNtlmVersion` to `1` and retry.
+   */
+  authMethod: string
+
+  /**
+   * Specifies the optional authorization identity used with the `PLAIN` authentication mechanism.
+   *
+   * Leave this property empty unless the IMAP server requires an authorization identity that
+   * differs from the login identity supplied to {@link Imap.login}.
+   */
+  authzId: string
+
+  /**
+   * Controls whether methods that download a complete email also download ordinary attachment
+   * bodies. The default is `true`.
+   *
+   * - `true`: complete-email fetches include attachment bodies.
+   *
+   * - `false`: complete-email fetches omit ordinary attachment bodies, whether the result is
+   *   returned as an `Email` object or as MIME.
+   *
+   * Header-only methods never download attachment bodies. They add `ckx-imap-*` metadata describing
+   * the attachments, which can be read with {@link Imap.getMailNumAttach}, {@link
+   * Imap.getMailAttachFilename}, and {@link Imap.getMailAttachSize}. In this state, the `Email`
+   * object's ordinary attachment count can still be `0`.
+   *
+   * Related MIME parts used by an HTML body are not treated as ordinary attachments. Signed or
+   * encrypted messages are always downloaded in full because their complete MIME is required for
+   * verification or decryption.
+   */
+  autoDownloadAttachments: boolean
+
+  /**
+   * When `true` (the default), changes the public {@link Imap.ssl} and {@link Imap.startTls}
+   * property values when {@link Imap.connect} is called for a standard IMAP port:
+   *
+   * - Port `993`: sets `Ssl` to `true` and `StartTls` to `false` for implicit TLS.
+   *
+   * - Port `143`: sets `Ssl` to `false`. The existing `StartTls` value determines whether the
+   *   connection is upgraded explicitly.
+   *
+   * For a nonstandard port, this property makes no changes. Set it to `false` when the application
+   * must preserve an unusual port and TLS combination exactly as configured.
+   */
+  autoFix: boolean
+
+  /**
+   * Specifies the local IP address to bind when the computer has multiple network interfaces or
+   * addresses.
+   *
+   * Leave this property empty for the usual case. The operating system will select the default
+   * local interface. When set, use a numeric IP address such as `165.164.55.124`, not a hostname.
+   */
+  clientIpAddress: string
+
+  /**
+   * The maximum number of seconds to wait while establishing the TCP connection to the IMAP server.
+   *
+   * The default is `30` seconds. This timeout applies to connection establishment, not to later
+   * reads from the server.
+   */
+  connectTimeout: number
+
+  /**
+   * Contains the hostname or IP address of the IMAP server to which the object is currently
+   * connected.
+   *
+   * Returns an empty string when no connection is active.
+   *
+   * This property is read-only.
+   */
+  readonly connectedToHost: string
+
+  /**
+   * Specifies the Windows domain used for NTLM authentication.
+   *
+   * This property is optional and may be left empty when the login name already identifies the
+   * domain or when NTLM is not used.
+   */
+  domain: string
+
+  /**
+   * Sets the interval, in milliseconds, between `AbortCheck` event callbacks during operations that
+   * support cancellation.
+   *
+   * The default is `0`, which disables periodic `AbortCheck` callbacks.
+   */
+  heartbeatMs: number
+
+  /**
+   * Specifies the authentication mechanism used by an HTTP proxy.
+   *
+   * Valid values are `Basic` and `NTLM`. This property is used only when {@link
+   * Imap.httpProxyHostname} identifies an HTTP proxy that requires authentication.
+   */
+  httpProxyAuthMethod: string
+
+  /**
+   * Specifies the optional Windows domain for HTTP-proxy NTLM authentication.
+   *
+   * It is ignored when the proxy does not use NTLM authentication.
+   */
+  httpProxyDomain: string
+
+  /**
+   * Specifies the hostname or numeric IPv4 address of an HTTP proxy through which the IMAP
+   * connection is established.
+   *
+   * Leave this property empty to connect directly or to use another configured transport such as
+   * SOCKS or SSH tunneling.
+   */
+  httpProxyHostname: string
+
+  /**
+   * Specifies the password used to authenticate with the configured HTTP proxy.
+   *
+   * It is used only when the proxy requires authentication.
+   */
+  httpProxyPassword: string
+
+  /**
+   * Specifies the TCP port of the configured HTTP proxy.
+   *
+   * Common values include `8080` and `3128`, but the correct value is determined by the proxy
+   * server configuration.
+   */
+  httpProxyPort: number
+
+  /**
+   * Specifies the username used to authenticate with the configured HTTP proxy.
+   *
+   * It is used only when the proxy requires authentication.
+   */
+  httpProxyUsername: string
+
+  /**
+   * Enables or disables the in-memory IMAP protocol log. The default is `false`.
+   *
+   * When enabled, {@link Imap.sessionLog} contains the raw commands sent to the server and the raw
+   * responses received. Use {@link Imap.clearSessionLog} to reset it.
+   */
+  keepSessionLog: boolean
+
+  /**
+   * Contains the MIME source sent by the most recent successful call to one of the following
+   * methods:
+   *
+   * - {@link Imap.appendMail}
+   *
+   * - {@link Imap.appendMime}
+   *
+   * - {@link Imap.appendMimeWithDateStr}
+   *
+   * - {@link Imap.appendMimeWithFlags}
+   *
+   * - {@link Imap.appendMimeWithFlagsSb}
+   *
+   * A failed append leaves the previous value unchanged. Therefore, read this property only after
+   * confirming that the append method succeeded.
+   *
+   * This property is read-only.
+   */
+  readonly lastAppendedMime: string
+
+  /**
+   * Contains the most recent raw IMAP command sent to the server.
+   *
+   * This property is primarily intended for diagnostics when an IMAP operation fails or produces an
+   * unexpected response.
+   *
+   * This property is read-only.
+   */
+  readonly lastCommand: string
+
+  /**
+   * Contains the most recent intermediate response received from the IMAP server while a command
+   * was in progress.
+   *
+   * Use it for protocol-level diagnostics when a command involves continuations or multiple
+   * response stages.
+   *
+   * This property is read-only.
+   */
+  readonly lastIntermediateResponse: string
+
+  /**
+   * Contains the raw response most recently received from the IMAP server.
+   *
+   * This property is cleared when Chilkat sends a new command. If a method fails during local
+   * argument validation or before a command is sent, the previous response can remain here. Also, a
+   * method can return failure even when the last tagged server response is `OK`, such as when a
+   * syntactically successful `FETCH` returns no matching message. Use the method return value or
+   * `LastMethodSuccess` as the authoritative success indicator.
+   *
+   * This property is read-only.
+   */
+  readonly lastResponse: string
+
+  /**
+   * Contains the optional IMAP response code from the most recent server response, such as
+   * `NONEXISTENT` or `AUTHENTICATIONFAILED`. Response-code strings vary by server.
+   *
+   * If a method fails before sending an IMAP command, this property can still contain the response
+   * code from an earlier command. Use the method return value or `LastMethodSuccess` to determine
+   * whether the current operation succeeded.
+   *
+   * This property is read-only.
+   */
+  readonly lastResponseCode: string
+
+  /**
+   * Contains the username of the authenticated IMAP session.
+   *
+   * Returns an empty string when the object is not logged in.
+   *
+   * This property is read-only.
+   */
+  readonly loggedInUser: string
+
+  /**
+   * Contains the number of messages reported when the current mailbox was selected.
+   *
+   * The value is updated by {@link Imap.selectMailbox} and {@link Imap.examineMailbox}. Unsolicited
+   * `EXISTS` notifications returned by {@link Imap.idleCheck} do not automatically update this
+   * property; use the notification value or reselect/query the mailbox when a refreshed count is
+   * needed.
+   *
+   * This property is read-only.
+   */
+  readonly numMessages: number
+
+  /**
+   * Controls whether fetching full message content marks the message as seen.
+   *
+   * - `false` (the default): fetching a full message or its raw MIME may set the `\Seen` flag.
+   *
+   * - `true`: full message data and raw MIME are fetched without setting `\Seen`, using IMAP peek
+   *   semantics.
+   *
+   * Fetching headers only does not set `\Seen`, regardless of this property.
+   */
+  peekMode: boolean
+
+  /**
+   * Sets the scale used by `PercentDone` event callbacks. The default is `100`.
+   *
+   * For example, a scale of `1000` gives tenths-of-a-percent precision, so a callback value of
+   * `453` represents 45.3% complete. Values are limited to the range `10` through `100000`.
+   *
+   * This property applies only to languages and environments that support event callbacks and only
+   * to operations for which progress can be measured.
+   */
+  percentDoneScale: number
+
+  /**
+   * Specifies the IMAP server port. The default is `143`.
+   *
+   * - `993` is the standard port for implicit TLS and is normally used with {@link Imap.ssl} set to
+   *   `true`.
+   *
+   * - `143` is the standard port for ordinary IMAP and for explicit TLS requested with {@link
+   *   Imap.startTls}.
+   *
+   * When {@link Imap.autoFix} is enabled, standard port values are used to adjust the effective TLS
+   * configuration when connecting.
+   */
+  port: number
+
+  /**
+   * Controls address-family preference when a hostname resolves to both IPv4 and IPv6 addresses.
+   *
+   * - `false` (the default): prefer IPv4.
+   *
+   * - `true`: prefer IPv6.
+   *
+   * The other address family may still be used when the preferred one is unavailable.
+   */
+  preferIpv6: boolean
+
+  /**
+   * The maximum number of seconds that an incoming IMAP response may stall with no additional bytes
+   * received.
+   *
+   * The default is `60` seconds. This is an inactivity timeout, not a limit on the total time
+   * allowed for a large response.
+   */
+  readTimeout: number
+
+  /**
+   * Controls verification of the IMAP server's TLS certificate chain.
+   *
+   * - `false` (the default): a connection is not rejected solely because normal certificate-chain
+   *   verification fails.
+   *
+   * - `true`: the connection fails when the certificate is expired, is not yet valid, its signature
+   *   is invalid, or its chain cannot be verified to a trusted root.
+   *
+   * Certificate-chain verification is separate from hostname matching and public-key pinning.
+   * Hostname matching, when required, is enforced independently even when this property is `false`.
+   * {@link Imap.tlsPinSet} supplements rather than replaces normal certificate verification.
+   *
+   * The hostname used for the TLS connection is also used for Server Name Indication (SNI) and
+   * certificate hostname comparison.
+   */
+  requireSslCertVerify: boolean
+
+  /**
+   * Specifies the IMAP `CHARSET` used by `Search`, {@link Imap.queryMbx}, and {@link
+   * Imap.queryThread} when search criteria contain non-ASCII characters. The default is `UTF-8`.
+   *
+   * If the criteria contain only 7-bit ASCII characters, no `CHARSET` is needed and this property
+   * has no effect. The value `AUTO` enables the legacy behavior of selecting a charset by examining
+   * the criteria text.
+   *
+   * Most applications should leave this property unchanged unless a particular server rejects
+   * non-English search text.
+   */
+  searchCharset: string
+
+  /**
+   * Contains the name of the currently selected or examined mailbox.
+   *
+   * Returns an empty string when no mailbox is selected.
+   *
+   * This property is read-only.
+   */
+  readonly selectedMailbox: string
+
+  /**
+   * Specifies the application-level buffer size used when sending data through the underlying TCP
+   * connection.
+   *
+   * The default is `32767` bytes. Most applications should leave this setting unchanged.
+   */
+  sendBufferSize: number
+
+  /**
+   * Contains the mailbox-hierarchy delimiter reported by the IMAP server, typically `/` or `.`.
+   *
+   * {@link Imap.mbxList} and the legacy mailbox-listing methods update this property from the
+   * server's LIST response. The value is a string containing one character.
+   */
+  separatorChar: string
+
+  /**
+   * Contains the in-memory log of raw IMAP commands and server responses.
+   *
+   * {@link Imap.keepSessionLog} must be `true` for logging to occur. Call {@link
+   * Imap.clearSessionLog} to remove previously collected entries.
+   *
+   * Chilkat redacts sensitive credentials, including passwords and OAuth access tokens, from
+   * session logs, diagnostic logs, and `LastErrorText`.
+   *
+   * This property is read-only.
+   */
+  readonly sessionLog: string
+
+  /**
+   * Sets the operating system's TCP receive-buffer size. The default is `4194304` bytes.
+   *
+   * Most applications should leave this unchanged. Increasing it may improve download throughput on
+   * high-latency or high-bandwidth networks. Values that are multiples of `4096` are recommended.
+   */
+  soRcvBuf: number
+
+  /**
+   * Sets the operating system's TCP send-buffer size. The default is `262144` bytes.
+   *
+   * Most applications should leave this unchanged. Increasing it may improve upload throughput;
+   * values such as `524288` or `1048576` may be tested when needed.
+   */
+  soSndBuf: number
+
+  /**
+   * Specifies the hostname or numeric IP address of the SOCKS proxy.
+   *
+   * This property is used only when {@link Imap.socksVersion} is `4` or `5`.
+   */
+  socksHostname: string
+
+  /**
+   * Specifies the SOCKS5 proxy password.
+   *
+   * It is ignored for SOCKS4 because SOCKS4 does not define password authentication.
+   */
+  socksPassword: string
+
+  /**
+   * Specifies the SOCKS proxy port. The default is `1080`.
+   *
+   * This property is used only when {@link Imap.socksVersion} is `4` or `5`.
+   */
+  socksPort: number
+
+  /**
+   * Specifies the username sent to a SOCKS4 or SOCKS5 proxy.
+   *
+   * This property is used only when {@link Imap.socksVersion} is `4` or `5`.
+   */
+  socksUsername: string
+
+  /**
+   * Selects whether the IMAP connection uses a SOCKS proxy.
+   *
+   * ValueBehavior
+   *
+   * | `0` |  | Do not use a SOCKS proxy. This is the default. |
+   *
+   * | `4` |  | Connect through a SOCKS4 proxy. |
+   *
+   * | `5` |  | Connect through a SOCKS5 proxy. |
+   */
+  socksVersion: number
+
+  /**
+   * Controls implicit TLS for the IMAP connection. The default is `false`.
+   *
+   * - `true`: begin the connection with a TLS handshake, typically on port `993`.
+   *
+   * - `false`: begin with ordinary IMAP. Use {@link Imap.startTls} when the server requires an
+   *   explicit STARTTLS upgrade.
+   *
+   * If both this property and {@link Imap.startTls} are `true`, implicit TLS takes precedence and
+   * STARTTLS is not used.
+   */
+  ssl: boolean
+
+  /**
+   * Restricts the cipher suites and selected TLS security requirements offered for an IMAP TLS
+   * connection.
+   *
+   * Leave this property empty to allow all cipher suites implemented by the installed Chilkat
+   * version. To restrict negotiation, provide a comma-separated list in preference order, for
+   * example:
+   *
+   * ```
+   * TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384, TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256
+   * ```
+   *
+   * The server chooses from the cipher suites offered by the client; the client cannot force a
+   * suite the server does not support.
+   *
+   * The list may also contain these policy keywords:
+   *
+   * - `rsa1024` or `rsa2048` to require a minimum RSA server-key size.
+   *
+   * - `secure-renegotiation` to require secure TLS renegotiation.
+   *
+   * - `best-practices` to use the security policy recommended by the installed Chilkat version.
+   *
+   * Legacy keywords such as `aes256-cbc`, `aes128-cbc`, `3des-cbc`, and `rc4` remain recognized for
+   * compatibility, but explicitly listing acceptable suites is preferred.
+   */
+  sslAllowedCiphers: string
+
+  /**
+   * Selects the TLS protocol version or minimum version allowed for secure IMAP connections.
+   *
+   * The complete list of accepted values is:
+   *
+   * - `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 is `default`, which allows Chilkat to negotiate a protocol supported by both client
+   * and server. A minimum-version setting is generally more interoperable than requiring one exact
+   * version.
+   */
+  sslProtocol: string
+
+  /**
+   * Indicates whether the IMAP server certificate chain was successfully verified for the current
+   * or most recent TLS connection.
+   *
+   * This property reports certificate-chain verification only. It does not report hostname matching
+   * or public-key pinning. If hostname matching or pinning is required and the check fails, the
+   * connection itself fails.
+   *
+   * This property is read-only.
+   */
+  readonly sslServerCertVerified: boolean
+
+  /**
+   * Controls explicit TLS using the IMAP `STARTTLS` command. The default is `false`.
+   *
+   * - `true`: connect in clear text, issue `STARTTLS`, and then continue through an encrypted
+   *   channel.
+   *
+   * - `false`: do not request an explicit TLS upgrade.
+   *
+   * Explicit TLS is commonly used on port `143`. For implicit TLS, set {@link Imap.ssl} to `true`
+   * and normally use port `993`. If both properties are `true`, {@link Imap.ssl} takes precedence.
+   */
+  startTls: boolean
+
+  /**
+   * Contains the cipher suite negotiated for the current or most recent TLS connection, for example
+   * `TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384`.
+   *
+   * The value is empty before a TLS connection has been established or after a failed TLS
+   * negotiation.
+   *
+   * This property is read-only.
+   */
+  readonly tlsCipherSuite: string
+
+  /**
+   * Specifies one or more expected SPKI fingerprints for TLS public-key pinning. If none of the
+   * configured pins matches the server certificate, the TLS handshake fails.
+   *
+   * Pinning supplements normal certificate-chain verification; it does not replace it. A matching
+   * pin does not make an expired or otherwise invalid certificate acceptable. When a pin set is
+   * configured, pin matching is enforced even if {@link Imap.requireSslCertVerify} is `false`.
+   *
+   * The format is:
+   *
+   * ```
+   * hashAlgorithm, encoding, fingerprint1, fingerprint2, ...
+   * ```
+   *
+   * Example:
+   *
+   * ```
+   * sha256, base64, lKg1SIqyhPSK19tlPbjl8s02yChsVTDklQpkMCHvsTE=
+   * ```
+   *
+   * 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 binary encodings.
+   */
+  tlsPinSet: string
+
+  /**
+   * Contains the protocol version negotiated for the current or most recent TLS connection, such as
+   * `TLS 1.2` or `TLS 1.3`.
+   *
+   * The value is empty before a TLS connection has been established or after a failed TLS
+   * negotiation.
+   *
+   * This property is read-only.
+   */
+  readonly tlsVersion: string
+
+  /**
+   * Contains the mailbox's reported `UIDNEXT` value—the UID expected to be assigned to the next
+   * appended message.
+   *
+   * The value is `0` when no mailbox is selected or when the server did not provide `UIDNEXT`.
+   *
+   * This property is read-only.
+   */
+  readonly uidNext: number
+
+  /**
+   * Contains the `UIDVALIDITY` value of the currently selected mailbox, or `0` when no mailbox is
+   * selected.
+   *
+   * An application that stores message UIDs should also store this value. If `UIDVALIDITY` changes
+   * in a later session, previously stored UIDs must no longer be assumed to identify the same
+   * messages.
+   *
+   * This property is read-only.
+   */
+  readonly uidValidity: number
+
+  /**
+   * Provides comma-separated compatibility or platform-specific options for uncommon cases. The
+   * default is an empty string, and most applications should leave it unchanged.
+   *
+   * - `ProtectFromVpn`: on Android, bypasses an installed or active VPN.
+   *
+   * - `EnableTls13`: legacy option that enabled offering TLS 1.3 in versions where it was not yet
+   *   enabled by default.
+   */
+  uncommonOptions: string
+
+  /**
+   * Contains the `HIGHESTMODSEQ` value of the currently selected mailbox as a decimal string.
+   *
+   * The value is `0` when no mailbox is selected or the server does not provide this information. A
+   * string is used because the value may exceed the integer range of some programming languages.
+   *
+   * This property is read-only.
+   */
+  readonly highestModSeq: string
+
+  /**
+   * Specifies the sort order used by {@link Imap.queryMbx}. The default is the empty string, which
+   * uses an ordinary IMAP `SEARCH`.
+   *
+   * Set this property to a space-separated list of sort keys. Sorting is ascending unless `REVERSE`
+   * precedes a key. Supported keys are `ARRIVAL`, `CC`, `DATE`, `FROM`, `SIZE`, `SUBJECT`, and
+   * `TO`.
+   *
+   * Examples:
+   *
+   * - `SUBJECT REVERSE DATE`
+   *
+   * - `REVERSE SIZE`
+   *
+   * - `ARRIVAL`
+   *
+   * If the server does not support the IMAP `SORT` extension, Chilkat automatically falls back to
+   * an ordinary `SEARCH`.
+   */
+  sortCriteria: string
+
+  /**
+   * Enables automatic resolution of credential values from secure operating-system storage. The
+   * default is `false`.
+   *
+   * When `true`, supported password arguments and properties may contain a secret specification
+   * beginning with `!!` instead of a literal secret. Chilkat resolves the value from Windows
+   * Credential Manager or Apple Keychain.
+   *
+   * ```
+   * !![appName|]service[|domain]|username
+   * ```
+   *
+   * This applies to {@link Imap.httpProxyPassword}, {@link Imap.socksPassword}, the password
+   * supplied to {@link Imap.login}, and the password supplied to {@link Imap.sshAuthenticatePw}.
+   */
+  enableSecrets: boolean
+
+  // ---- Methods ----
+
+  /**
+   * Adds a PKCS #12/PFX file that may be searched for certificates and private keys needed for
+   * S/MIME decryption or signature processing.
+   *
+   * `pfxFilePath` is the local filesystem path of the PFX file, and `pfxPassword` contains its
+   * password. Call this method once for each additional source.
+   *
+   * On Windows, system certificate stores are also searched automatically. On macOS, the Keychain
+   * is searched automatically.
+   *
+   * @throws Error if the call fails (the message names the reason); the full log is in
+   * {@link Imap.lastErrorText}.
+   */
+  addPfxSourceFile(pfxFilePath: string, pfxPassword: string): void
+
+  /**
+   * Appends the `Email` in `email` to the mailbox named by `mailbox`.
+   *
+   * {@link Imap.appendSeen} controls the initial `\Seen` flag. After success, {@link
+   * Imap.appendUid} contains the UID reported by the server, or `0` if no UID was reported, and
+   * {@link Imap.lastAppendedMime} contains the MIME sent.
+   *
+   * Rendering for the append does not generate or replace `email`'s `Date`, `Message-ID`, or MIME
+   * boundary values. If `email` uses an `8bit` or `binary` transfer encoding that would produce
+   * non-text binary bytes, Chilkat changes the rendered transfer encoding to a text-safe encoding
+   * such as Base64.
+   *
+   * Mailbox names may be supplied as normal Unicode strings. Chilkat automatically handles IMAP
+   * modified UTF-7 or UTF-8 mailbox-name encoding as required by the server.
+   *
+   * This call blocks the JavaScript thread until Chilkat returns; from UI code prefer
+   * {@link Imap.appendMailAsync}.
+   *
+   * @throws Error if the call fails (the message names the reason); the full log is in
+   * {@link Imap.lastErrorText}.
+   */
+  appendMail(mailbox: string, email: Email): void
+
+  /**
+   * Asynchronous form of {@link Imap.appendMail}: the same call on a native worker thread,
+   * settling on the JavaScript thread. While it is pending, other calls on this object throw,
+   * except {@link Imap.abort} (which cancels it) and the {@link Imap.onPercentDone} /
+   * {@link Imap.onProgressInfo} callbacks, which report progress while it runs.
+   *
+   * The promise rejects with an Error if the call fails; the full log is in
+   * {@link Imap.lastErrorText}.
+   */
+  appendMailAsync(mailbox: string, email: Email): Promise<void>
+
+  /**
+   * Appends the complete RFC 822/MIME message in `mimeText` to the mailbox named by `mailbox`.
+   *
+   * {@link Imap.appendSeen} controls the initial `\Seen` flag. After success, {@link
+   * Imap.appendUid} contains the UID reported by the server, or `0` if no UID was reported, and
+   * {@link Imap.lastAppendedMime} contains the MIME sent.
+   *
+   * The MIME text is sent exactly as supplied. Chilkat does not normalize line endings, add a final
+   * CRLF, or re-encode headers or body content. The supplied text must not contain non-text binary
+   * bytes.
+   *
+   * Mailbox names may be supplied as normal Unicode strings. Chilkat automatically handles IMAP
+   * modified UTF-7 or UTF-8 mailbox-name encoding as required by the server.
+   *
+   * This call blocks the JavaScript thread until Chilkat returns; from UI code prefer
+   * {@link Imap.appendMimeAsync}.
+   *
+   * @throws Error if the call fails (the message names the reason); the full log is in
+   * {@link Imap.lastErrorText}.
+   */
+  appendMime(mailbox: string, mimeText: string): void
+
+  /**
+   * Asynchronous form of {@link Imap.appendMime}: the same call on a native worker thread,
+   * settling on the JavaScript thread. While it is pending, other calls on this object throw,
+   * except {@link Imap.abort} (which cancels it) and the {@link Imap.onPercentDone} /
+   * {@link Imap.onProgressInfo} callbacks, which report progress while it runs.
+   *
+   * The promise rejects with an Error if the call fails; the full log is in
+   * {@link Imap.lastErrorText}.
+   */
+  appendMimeAsync(mailbox: string, mimeText: string): Promise<void>
+
+  /**
+   * Appends the MIME message in `mimeText` to the mailbox named by `mailbox` while explicitly
+   * setting the server-side internal date from `internalDateStr`.
+   *
+   * `internalDateStr` is an RFC 822 date/time string, for example `Fri, 10 Jul 2026 20:15:30 GMT`.
+   * The internal date is mailbox metadata and is distinct from the message's `Date` header. {@link
+   * Imap.appendSeen} controls the initial `\Seen` flag.
+   *
+   * The MIME text is sent exactly as supplied. Chilkat does not normalize line endings, add a final
+   * CRLF, or re-encode headers or body content. The supplied text must not contain non-text binary
+   * bytes.
+   *
+   * Mailbox names may be supplied as normal Unicode strings. Chilkat automatically handles IMAP
+   * modified UTF-7 or UTF-8 mailbox-name encoding as required by the server.
+   *
+   * This call blocks the JavaScript thread until Chilkat returns; from UI code prefer
+   * {@link Imap.appendMimeWithDateStrAsync}.
+   *
+   * @throws Error if the call fails (the message names the reason); the full log is in
+   * {@link Imap.lastErrorText}.
+   */
+  appendMimeWithDateStr(mailbox: string, mimeText: string, internalDateStr: string): void
+
+  /**
+   * Asynchronous form of {@link Imap.appendMimeWithDateStr}: the same call on a native worker
+   * thread,
+   * settling on the JavaScript thread. While it is pending, other calls on this object throw,
+   * except {@link Imap.abort} (which cancels it) and the {@link Imap.onPercentDone} /
+   * {@link Imap.onProgressInfo} callbacks, which report progress while it runs.
+   *
+   * The promise rejects with an Error if the call fails; the full log is in
+   * {@link Imap.lastErrorText}.
+   */
+  appendMimeWithDateStrAsync(mailbox: string, mimeText: string, internalDateStr: string): Promise<void>
+
+  /**
+   * Appends the MIME message in `mimeText` to the mailbox named by `mailbox` and sets its initial
+   * system flags.
+   *
+   * - `seen` controls `\Seen`.
+   *
+   * - `flagged` controls `\Flagged`.
+   *
+   * - `answered` controls `\Answered`.
+   *
+   * - `draft` controls `\Draft`.
+   *
+   * Use `true` to set a flag and `false` to leave it unset. The explicit flag arguments are used
+   * instead of {@link Imap.appendSeen}.
+   *
+   * The MIME text is sent exactly as supplied. Chilkat does not normalize line endings, add a final
+   * CRLF, or re-encode headers or body content. The supplied text must not contain non-text binary
+   * bytes.
+   *
+   * Mailbox names may be supplied as normal Unicode strings. Chilkat automatically handles IMAP
+   * modified UTF-7 or UTF-8 mailbox-name encoding as required by the server.
+   *
+   * This call blocks the JavaScript thread until Chilkat returns; from UI code prefer
+   * {@link Imap.appendMimeWithFlagsAsync}.
+   *
+   * @throws Error if the call fails (the message names the reason); the full log is in
+   * {@link Imap.lastErrorText}.
+   */
+  appendMimeWithFlags(mailbox: string, mimeText: string, seen: boolean, flagged: boolean, answered: boolean, draft: boolean): void
+
+  /**
+   * Asynchronous form of {@link Imap.appendMimeWithFlags}: the same call on a native worker thread,
+   * settling on the JavaScript thread. While it is pending, other calls on this object throw,
+   * except {@link Imap.abort} (which cancels it) and the {@link Imap.onPercentDone} /
+   * {@link Imap.onProgressInfo} callbacks, which report progress while it runs.
+   *
+   * The promise rejects with an Error if the call fails; the full log is in
+   * {@link Imap.lastErrorText}.
+   */
+  appendMimeWithFlagsAsync(mailbox: string, mimeText: string, seen: boolean, flagged: boolean, answered: boolean, draft: boolean): Promise<void>
+
+  /**
+   * Sends the IMAP `CAPABILITY` command and returns the server's raw capability response.
+   *
+   * Use {@link Imap.hasCapability} to test the returned text for a particular capability such as
+   * `IDLE`, `MOVE`, `SORT`, or `QUOTA`.
+   *
+   * This call blocks the JavaScript thread until Chilkat returns; from UI code prefer
+   * {@link Imap.capabilityAsync}.
+   *
+   * @throws Error if the call fails (the message names the reason); the full log is in
+   * {@link Imap.lastErrorText}.
+   */
+  capability(): string
+
+  /**
+   * Asynchronous form of {@link Imap.capability}: the same call on a native worker thread,
+   * settling on the JavaScript thread. While it is pending, other calls on this object throw,
+   * except {@link Imap.abort} (which cancels it) and the {@link Imap.onPercentDone} /
+   * {@link Imap.onProgressInfo} callbacks, which report progress while it runs.
+   *
+   * The promise rejects with an Error if the call fails; the full log is in
+   * {@link Imap.lastErrorText}.
+   */
+  capabilityAsync(): Promise<string>
+
+  /**
+   * Checks whether the underlying TCP socket is currently connected to the IMAP server.
+   *
+   * This performs a low-level socket-state check and does not send an IMAP command. To verify that
+   * the server is responsive and the session remains usable, call {@link Imap.noop}.
+   */
+  checkConnection(): boolean
+
+  /**
+   * Clears the in-memory text returned by {@link Imap.sessionLog}.
+   *
+   * Session logging remains enabled or disabled according to {@link Imap.keepSessionLog}.
+   */
+  clearSessionLog(): void
+
+  /**
+   * Closes the currently selected mailbox while keeping the authenticated IMAP connection open.
+   *
+   * `mailbox` is retained for backward compatibility but is ignored. It may be the empty string.
+   * Messages marked with `\Deleted` are permanently removed as part of the close operation. After
+   * success, {@link Imap.selectedMailbox} is empty, but another mailbox can be selected on the same
+   * connection.
+   *
+   * This call blocks the JavaScript thread until Chilkat returns; from UI code prefer
+   * {@link Imap.closeMailboxAsync}.
+   *
+   * @throws Error if the call fails (the message names the reason); the full log is in
+   * {@link Imap.lastErrorText}.
+   */
+  closeMailbox(mailbox: string): void
+
+  /**
+   * Asynchronous form of {@link Imap.closeMailbox}: the same call on a native worker thread,
+   * settling on the JavaScript thread. While it is pending, other calls on this object throw,
+   * except {@link Imap.abort} (which cancels it) and the {@link Imap.onPercentDone} /
+   * {@link Imap.onProgressInfo} callbacks, which report progress while it runs.
+   *
+   * The promise rejects with an Error if the call fails; the full log is in
+   * {@link Imap.lastErrorText}.
+   */
+  closeMailboxAsync(mailbox: string): Promise<void>
+
+  /**
+   * Establishes a TCP connection to the IMAP server identified by `domainName` but does not
+   * authenticate.
+   *
+   * `domainName` may be a hostname, IPv4 address, or IPv6 address. Configure {@link Imap.port},
+   * {@link Imap.ssl}, {@link Imap.startTls}, proxy settings, and timeouts before calling this
+   * method. The TLS hostname is used for Server Name Indication (SNI) and certificate hostname
+   * comparison. Call {@link Imap.login} after the connection succeeds.
+   *
+   * If this method is called while already connected, Chilkat tears down the existing connection
+   * and establishes a new connection to `domainName`. This applies even when `domainName` names the
+   * same server.
+   *
+   * Imap does not automatically reconnect after a connection is dropped. The application must call
+   * this method again, authenticate again, reselect a mailbox when needed, and retry the
+   * interrupted operation.
+   *
+   * Connection failures can also be caused by DNS, local or remote firewalls, antivirus software,
+   * routing, or other network infrastructure outside Chilkat.
+   *
+   * This call blocks the JavaScript thread until Chilkat returns; from UI code prefer
+   * {@link Imap.connectAsync}.
+   *
+   * @throws Error if the call fails (the message names the reason); the full log is in
+   * {@link Imap.lastErrorText}.
+   */
+  connect(domainName: string): void
+
+  /**
+   * Asynchronous form of {@link Imap.connect}: the same call on a native worker thread,
+   * settling on the JavaScript thread. While it is pending, other calls on this object throw,
+   * except {@link Imap.abort} (which cancels it) and the {@link Imap.onPercentDone} /
+   * {@link Imap.onProgressInfo} callbacks, which report progress while it runs.
+   *
+   * The promise rejects with an Error if the call fails; the full log is in
+   * {@link Imap.lastErrorText}.
+   */
+  connectAsync(domainName: string): Promise<void>
+
+  /**
+   * Copies one message from the currently selected mailbox to the destination mailbox in
+   * `copyToMailbox`.
+   *
+   * `msgId` identifies the source message. If `bUid` is `true`, `msgId` is a UID; otherwise,
+   * `msgId` is a sequence number. The original message remains in the selected mailbox.
+   *
+   * Mailbox names may be supplied as normal Unicode strings. Chilkat automatically handles IMAP
+   * modified UTF-7 or UTF-8 mailbox-name encoding as required by the server.
+   *
+   * This call blocks the JavaScript thread until Chilkat returns; from UI code prefer
+   * {@link Imap.copyAsync}.
+   *
+   * @throws Error if the call fails (the message names the reason); the full log is in
+   * {@link Imap.lastErrorText}.
+   */
+  copy(msgId: number, bUid: boolean, copyToMailbox: string): void
+
+  /**
+   * Asynchronous form of {@link Imap.copy}: the same call on a native worker thread,
+   * settling on the JavaScript thread. While it is pending, other calls on this object throw,
+   * except {@link Imap.abort} (which cancels it) and the {@link Imap.onPercentDone} /
+   * {@link Imap.onProgressInfo} callbacks, which report progress while it runs.
+   *
+   * The promise rejects with an Error if the call fails; the full log is in
+   * {@link Imap.lastErrorText}.
+   */
+  copyAsync(msgId: number, bUid: boolean, copyToMailbox: string): Promise<void>
+
+  /**
+   * Copies the messages identified by the `MessageSet` in `messageSet` from the selected mailbox to
+   * destination mailbox `copyToMailbox` using one IMAP command.
+   *
+   * `MessageSet.HasUids` determines whether `messageSet` contains UIDs or sequence numbers. For
+   * sequence numbers, one invalid value causes the entire command to fail and no messages are
+   * copied. For UIDs, nonexistent values are silently ignored and valid messages are copied. The
+   * original messages remain in the selected mailbox.
+   *
+   * Mailbox names may be supplied as normal Unicode strings. Chilkat automatically handles IMAP
+   * modified UTF-7 or UTF-8 mailbox-name encoding as required by the server.
+   *
+   * This call blocks the JavaScript thread until Chilkat returns; from UI code prefer
+   * {@link Imap.copyMultipleAsync}.
+   *
+   * @throws Error if the call fails (the message names the reason); the full log is in
+   * {@link Imap.lastErrorText}.
+   */
+  copyMultiple(messageSet: MessageSet, copyToMailbox: string): void
+
+  /**
+   * Asynchronous form of {@link Imap.copyMultiple}: the same call on a native worker thread,
+   * settling on the JavaScript thread. While it is pending, other calls on this object throw,
+   * except {@link Imap.abort} (which cancels it) and the {@link Imap.onPercentDone} /
+   * {@link Imap.onProgressInfo} callbacks, which report progress while it runs.
+   *
+   * The promise rejects with an Error if the call fails; the full log is in
+   * {@link Imap.lastErrorText}.
+   */
+  copyMultipleAsync(messageSet: MessageSet, copyToMailbox: string): Promise<void>
+
+  /**
+   * Copies a contiguous range of messages, identified by sequence number, from the selected mailbox
+   * to the destination mailbox in `copyToMailbox`.
+   *
+   * `startSeqNum` is the first sequence number and `count` is the number of messages to copy. IMAP
+   * sequence numbers begin at `1` and can change when messages are expunged.
+   *
+   * Mailbox names may be supplied as normal Unicode strings. Chilkat automatically handles IMAP
+   * modified UTF-7 or UTF-8 mailbox-name encoding as required by the server.
+   *
+   * This call blocks the JavaScript thread until Chilkat returns; from UI code prefer
+   * {@link Imap.copySequenceAsync}.
+   *
+   * @throws Error if the call fails (the message names the reason); the full log is in
+   * {@link Imap.lastErrorText}.
+   */
+  copySequence(startSeqNum: number, count: number, copyToMailbox: string): void
+
+  /**
+   * Asynchronous form of {@link Imap.copySequence}: the same call on a native worker thread,
+   * settling on the JavaScript thread. While it is pending, other calls on this object throw,
+   * except {@link Imap.abort} (which cancels it) and the {@link Imap.onPercentDone} /
+   * {@link Imap.onProgressInfo} callbacks, which report progress while it runs.
+   *
+   * The promise rejects with an Error if the call fails; the full log is in
+   * {@link Imap.lastErrorText}.
+   */
+  copySequenceAsync(startSeqNum: number, count: number, copyToMailbox: string): Promise<void>
+
+  /**
+   * Creates the mailbox named by `mailbox` on the IMAP server.
+   *
+   * Use the hierarchy delimiter reported in {@link Imap.separatorChar} when creating a nested
+   * mailbox. In IMAP terminology, \*mailbox\* and \*folder\* are synonymous.
+   *
+   * Mailbox names may be supplied as normal Unicode strings. Chilkat automatically handles IMAP
+   * modified UTF-7 or UTF-8 mailbox-name encoding as required by the server.
+   *
+   * This call blocks the JavaScript thread until Chilkat returns; from UI code prefer
+   * {@link Imap.createMailboxAsync}.
+   *
+   * @throws Error if the call fails (the message names the reason); the full log is in
+   * {@link Imap.lastErrorText}.
+   */
+  createMailbox(mailbox: string): void
+
+  /**
+   * Asynchronous form of {@link Imap.createMailbox}: the same call on a native worker thread,
+   * settling on the JavaScript thread. While it is pending, other calls on this object throw,
+   * except {@link Imap.abort} (which cancels it) and the {@link Imap.onPercentDone} /
+   * {@link Imap.onProgressInfo} callbacks, which report progress while it runs.
+   *
+   * The promise rejects with an Error if the call fails; the full log is in
+   * {@link Imap.lastErrorText}.
+   */
+  createMailboxAsync(mailbox: string): Promise<void>
+
+  /**
+   * Deletes the mailbox named by `mailbox` from the IMAP server.
+   *
+   * This deletes the mailbox itself, not merely the messages it contains. Server rules may require
+   * the mailbox to be empty first.
+   *
+   * Mailbox names may be supplied as normal Unicode strings. Chilkat automatically handles IMAP
+   * modified UTF-7 or UTF-8 mailbox-name encoding as required by the server.
+   *
+   * This call blocks the JavaScript thread until Chilkat returns; from UI code prefer
+   * {@link Imap.deleteMailboxAsync}.
+   *
+   * @throws Error if the call fails (the message names the reason); the full log is in
+   * {@link Imap.lastErrorText}.
+   */
+  deleteMailbox(mailbox: string): void
+
+  /**
+   * Asynchronous form of {@link Imap.deleteMailbox}: the same call on a native worker thread,
+   * settling on the JavaScript thread. While it is pending, other calls on this object throw,
+   * except {@link Imap.abort} (which cancels it) and the {@link Imap.onPercentDone} /
+   * {@link Imap.onProgressInfo} callbacks, which report progress while it runs.
+   *
+   * The promise rejects with an Error if the call fails; the full log is in
+   * {@link Imap.lastErrorText}.
+   */
+  deleteMailboxAsync(mailbox: string): Promise<void>
+
+  /**
+   * Closes the connection to the IMAP server.
+   *
+   * A failure indicates that the connection could not be closed cleanly; the socket is nevertheless
+   * no longer intended for further use. In many applications, a disconnect failure during shutdown
+   * can be treated as nonfatal.
+   *
+   * This call blocks the JavaScript thread until Chilkat returns; from UI code prefer
+   * {@link Imap.disconnectAsync}.
+   *
+   * @throws Error if the call fails (the message names the reason); the full log is in
+   * {@link Imap.lastErrorText}.
+   */
+  disconnect(): void
+
+  /**
+   * Asynchronous form of {@link Imap.disconnect}: the same call on a native worker thread,
+   * settling on the JavaScript thread. While it is pending, other calls on this object throw,
+   * except {@link Imap.abort} (which cancels it) and the {@link Imap.onPercentDone} /
+   * {@link Imap.onProgressInfo} callbacks, which report progress while it runs.
+   *
+   * The promise rejects with an Error if the call fails; the full log is in
+   * {@link Imap.lastErrorText}.
+   */
+  disconnectAsync(): Promise<void>
+
+  /**
+   * Opens the mailbox in `mailbox` as read-only.
+   *
+   * Use this instead of {@link Imap.selectMailbox} when the application must not change message
+   * flags or mailbox state. Successful examination updates properties such as {@link
+   * Imap.numMessages}, {@link Imap.uidValidity}, and {@link Imap.uidNext}.
+   *
+   * Mailbox names may be supplied as normal Unicode strings. Chilkat automatically handles IMAP
+   * modified UTF-7 or UTF-8 mailbox-name encoding as required by the server.
+   *
+   * This call blocks the JavaScript thread until Chilkat returns; from UI code prefer
+   * {@link Imap.examineMailboxAsync}.
+   *
+   * @throws Error if the call fails (the message names the reason); the full log is in
+   * {@link Imap.lastErrorText}.
+   */
+  examineMailbox(mailbox: string): void
+
+  /**
+   * Asynchronous form of {@link Imap.examineMailbox}: the same call on a native worker thread,
+   * settling on the JavaScript thread. While it is pending, other calls on this object throw,
+   * except {@link Imap.abort} (which cancels it) and the {@link Imap.onPercentDone} /
+   * {@link Imap.onProgressInfo} callbacks, which report progress while it runs.
+   *
+   * The promise rejects with an Error if the call fails; the full log is in
+   * {@link Imap.lastErrorText}.
+   */
+  examineMailboxAsync(mailbox: string): Promise<void>
+
+  /**
+   * Permanently removes all messages marked with the `\Deleted` flag from the currently selected
+   * mailbox.
+   *
+   * The mailbox remains selected and the authenticated connection remains open. Expunging can
+   * change sequence numbers for the remaining messages.
+   *
+   * This call blocks the JavaScript thread until Chilkat returns; from UI code prefer
+   * {@link Imap.expungeAsync}.
+   *
+   * @throws Error if the call fails (the message names the reason); the full log is in
+   * {@link Imap.lastErrorText}.
+   */
+  expunge(): void
+
+  /**
+   * Asynchronous form of {@link Imap.expunge}: the same call on a native worker thread,
+   * settling on the JavaScript thread. While it is pending, other calls on this object throw,
+   * except {@link Imap.abort} (which cancels it) and the {@link Imap.onPercentDone} /
+   * {@link Imap.onProgressInfo} callbacks, which report progress while it runs.
+   *
+   * The promise rejects with an Error if the call fails; the full log is in
+   * {@link Imap.lastErrorText}.
+   */
+  expungeAsync(): Promise<void>
+
+  /**
+   * Permanently removes all messages marked with `\Deleted` from the selected mailbox and then
+   * closes the mailbox.
+   *
+   * After success, {@link Imap.selectedMailbox} is empty. The authenticated IMAP connection remains
+   * open and can be used to select another mailbox.
+   *
+   * This call blocks the JavaScript thread until Chilkat returns; from UI code prefer
+   * {@link Imap.expungeAndCloseAsync}.
+   *
+   * @throws Error if the call fails (the message names the reason); the full log is in
+   * {@link Imap.lastErrorText}.
+   */
+  expungeAndClose(): void
+
+  /**
+   * Asynchronous form of {@link Imap.expungeAndClose}: the same call on a native worker thread,
+   * settling on the JavaScript thread. While it is pending, other calls on this object throw,
+   * except {@link Imap.abort} (which cancels it) and the {@link Imap.onPercentDone} /
+   * {@link Imap.onProgressInfo} callbacks, which report progress while it runs.
+   *
+   * The promise rejects with an Error if the call fails; the full log is in
+   * {@link Imap.lastErrorText}.
+   */
+  expungeAndCloseAsync(): Promise<void>
+
+  /**
+   * Obtains attachment `attachmentIndex` from the `Email` in `emailObject` and writes it to the
+   * filesystem path in `saveToPath`. Attachment indexes are zero-based.
+   *
+   * `saveToPath` may be a filename, a relative path ending in a filename, or an absolute path
+   * ending in a filename. Missing parent directories are not created. An existing file is
+   * overwritten. A failed operation should not leave a partial output file.
+   *
+   * If `emailObject` already contains the attachment bytes, the data is saved without contacting
+   * the IMAP server. If `emailObject` was fetched without attachment bodies, Chilkat uses its
+   * `ckx-imap-*` metadata to locate and download the requested MIME part. The same IMAP session is
+   * not required, and a copied `Email` can be used if the metadata is preserved.
+   *
+   * The corresponding mailbox must be selected when a server fetch is required. If `ckx-imap-isUid`
+   * is `YES`, the permanent UID is used and the operation can work after reconnecting. If it is
+   * `NO`, the stored value is a sequence number, which can identify a different message after an
+   * expunge. UID-based metadata is therefore preferred for deferred attachment operations. The
+   * method fails if the referenced message or MIME part no longer exists, such as after the message
+   * is moved or expunged.
+   *
+   * Related MIME parts used by an HTML body are not counted as ordinary attachments. Signed and
+   * encrypted messages are fetched in full because their complete MIME is required.
+   *
+   * This call blocks the JavaScript thread until Chilkat returns; from UI code prefer
+   * {@link Imap.fetchAttachmentAsync}.
+   *
+   * @throws Error if the call fails (the message names the reason); the full log is in
+   * {@link Imap.lastErrorText}.
+   */
+  fetchAttachment(emailObject: Email, attachmentIndex: number, saveToPath: string): void
+
+  /**
+   * Asynchronous form of {@link Imap.fetchAttachment}: the same call on a native worker thread,
+   * settling on the JavaScript thread. While it is pending, other calls on this object throw,
+   * except {@link Imap.abort} (which cancels it) and the {@link Imap.onPercentDone} /
+   * {@link Imap.onProgressInfo} callbacks, which report progress while it runs.
+   *
+   * The promise rejects with an Error if the call fails; the full log is in
+   * {@link Imap.lastErrorText}.
+   */
+  fetchAttachmentAsync(emailObject: Email, attachmentIndex: number, saveToPath: string): Promise<void>
+
+  /**
+   * Obtains text attachment `attachmentIndex` from the `Email` in `emailObject` and decodes its
+   * bytes using the character encoding named by `charset`.
+   *
+   * Use this only when the attachment contains text. Attachment indexes are zero-based. See {@link
+   * Imap.fetchAttachment} for information about downloading attachment data that is not already
+   * present in `emailObject`.
+   *
+   * This call blocks the JavaScript thread until Chilkat returns; from UI code prefer
+   * {@link Imap.fetchAttachmentStringAsync}.
+   *
+   * @throws Error if the call fails (the message names the reason); the full log is in
+   * {@link Imap.lastErrorText}.
+   */
+  fetchAttachmentString(emailObject: Email, attachmentIndex: number, charset: string): string
+
+  /**
+   * Asynchronous form of {@link Imap.fetchAttachmentString}: the same call on a native worker
+   * thread,
+   * settling on the JavaScript thread. While it is pending, other calls on this object throw,
+   * except {@link Imap.abort} (which cancels it) and the {@link Imap.onPercentDone} /
+   * {@link Imap.onProgressInfo} callbacks, which report progress while it runs.
+   *
+   * The promise rejects with an Error if the call fails; the full log is in
+   * {@link Imap.lastErrorText}.
+   */
+  fetchAttachmentStringAsync(emailObject: Email, attachmentIndex: number, charset: string): Promise<string>
+
+  /**
+   * Returns the space-separated IMAP flags for the message identified by `msgId`.
+   *
+   * If `bUid` is `true`, `msgId` is a UID; otherwise, it is a sequence number. A result might be
+   * `\Flagged \Seen $label1`.
+   *
+   * An existing message with no flags returns the empty string. A nonexistent message is an error.
+   *
+   * This call blocks the JavaScript thread until Chilkat returns; from UI code prefer
+   * {@link Imap.fetchFlagsAsync}.
+   *
+   * @throws Error if the call fails (the message names the reason); the full log is in
+   * {@link Imap.lastErrorText}.
+   */
+  fetchFlags(msgId: number, bUid: boolean): string
+
+  /**
+   * Asynchronous form of {@link Imap.fetchFlags}: the same call on a native worker thread,
+   * settling on the JavaScript thread. While it is pending, other calls on this object throw,
+   * except {@link Imap.abort} (which cancels it) and the {@link Imap.onPercentDone} /
+   * {@link Imap.onProgressInfo} callbacks, which report progress while it runs.
+   *
+   * The promise rejects with an Error if the call fails; the full log is in
+   * {@link Imap.lastErrorText}.
+   */
+  fetchFlagsAsync(msgId: number, bUid: boolean): Promise<string>
+
+  /**
+   * Downloads one message and returns its MIME source as a string.
+   *
+   * If `bUid` is `true`, `msgId` is a UID; otherwise, `msgId` is a sequence number. Ordinary
+   * attachment bodies are included according to {@link Imap.autoDownloadAttachments}.
+   *
+   * Chilkat interprets the received MIME bytes as UTF-8. MIME using Base64 or quoted-printable
+   * transfer encoding is safe because the encoded bytes are ASCII. Raw `8bit` or `binary` content,
+   * or unencoded text in another charset such as ISO-8859-1 or Shift_JIS, can be misinterpreted or
+   * cause an error. Use {@link Imap.fetchSingleBd} whenever byte-exact MIME is required.
+   *
+   * This call blocks the JavaScript thread until Chilkat returns; from UI code prefer
+   * {@link Imap.fetchSingleAsMimeAsync}.
+   *
+   * @throws Error if the call fails (the message names the reason); the full log is in
+   * {@link Imap.lastErrorText}.
+   */
+  fetchSingleAsMime(msgId: number, bUid: boolean): string
+
+  /**
+   * Asynchronous form of {@link Imap.fetchSingleAsMime}: the same call on a native worker thread,
+   * settling on the JavaScript thread. While it is pending, other calls on this object throw,
+   * except {@link Imap.abort} (which cancels it) and the {@link Imap.onPercentDone} /
+   * {@link Imap.onProgressInfo} callbacks, which report progress while it runs.
+   *
+   * The promise rejects with an Error if the call fails; the full log is in
+   * {@link Imap.lastErrorText}.
+   */
+  fetchSingleAsMimeAsync(msgId: number, bUid: boolean): Promise<string>
+
+  /**
+   * Downloads and returns the MIME header block for one message, without downloading the body.
+   *
+   * If `bUID` is `true`, `msgId` is a UID; otherwise, `msgId` is a sequence number.
+   *
+   * This call blocks the JavaScript thread until Chilkat returns; from UI code prefer
+   * {@link Imap.fetchSingleHeaderAsMimeAsync}.
+   *
+   * @throws Error if the call fails (the message names the reason); the full log is in
+   * {@link Imap.lastErrorText}.
+   */
+  fetchSingleHeaderAsMime(msgId: number, bUID: boolean): string
+
+  /**
+   * Asynchronous form of {@link Imap.fetchSingleHeaderAsMime}: the same call on a native worker
+   * thread,
+   * settling on the JavaScript thread. While it is pending, other calls on this object throw,
+   * except {@link Imap.abort} (which cancels it) and the {@link Imap.onPercentDone} /
+   * {@link Imap.onProgressInfo} callbacks, which report progress while it runs.
+   *
+   * The promise rejects with an Error if the call fails; the full log is in
+   * {@link Imap.lastErrorText}.
+   */
+  fetchSingleHeaderAsMimeAsync(msgId: number, bUID: boolean): Promise<string>
+
+  /**
+   * Returns the filename for attachment `attachIndex` represented by `email`. Attachment indexes
+   * are zero-based.
+   *
+   * This method can obtain the filename from `ckx-imap-*` metadata in a header-only email even when
+   * the attachment body has not been downloaded.
+   *
+   * @throws Error if the call fails (the message names the reason); the full log is in
+   * {@link Imap.lastErrorText}.
+   */
+  getMailAttachFilename(email: Email, attachIndex: number): string
+
+  /**
+   * Returns the size in bytes of attachment `attachIndex` represented by `email`. Attachment
+   * indexes are zero-based.
+   *
+   * This method can obtain the size from `ckx-imap-*` metadata in a header-only email even when the
+   * attachment body has not been downloaded.
+   */
+  getMailAttachSize(email: Email, attachIndex: number): number
+
+  /**
+   * Returns the state of the flag named by `flagName` from the IMAP metadata stored in the `Email`
+   * in `email`.
+   *
+   * - `1`: the flag is set.
+   *
+   * - `0`: the flag is not set.
+   *
+   * - `-1`: the required `ckx-imap-*` metadata is missing.
+   *
+   * Standard flags include `\Seen`, `\Answered`, `\Flagged`, `\Draft`, and `\Deleted`. Custom
+   * keywords such as `$label1` or `NonJunk` are also supported.
+   *
+   * Integer-returning methods do not use `LastMethodSuccess` to report this condition; test the
+   * return value directly.
+   */
+  getMailFlag(email: Email, flagName: string): number
+
+  /**
+   * Returns the number of ordinary attachments represented by `email`.
+   *
+   * This method also works with a header-only email or an email fetched while {@link
+   * Imap.autoDownloadAttachments} was `false`. In those cases it reads the `ckx-imap-numAttach`
+   * metadata, even though the `Email` object's downloaded attachment count can be `0`.
+   */
+  getMailNumAttach(email: Email): number
+
+  /**
+   * Returns the complete server-reported size of the `Email` in `email`, in bytes, including
+   * attachment data.
+   *
+   * This value may be available even when only the message headers were downloaded.
+   */
+  getMailSize(email: Email): number
+
+  /**
+   * Sends the IMAP `STATUS` command for the mailbox in `mailbox` and returns the reported values as
+   * XML attributes.
+   *
+   * - `messages`: total number of messages.
+   *
+   * - `recent`: messages having the `\Recent` flag.
+   *
+   * - `uidnext`: expected UID for the next appended message.
+   *
+   * - `uidvalidity`: mailbox UID-validity value.
+   *
+   * - `unseen`: messages without the `\Seen` flag.
+   *
+   * ```
+   * <status messages="240" recent="0" uidnext="3674" uidvalidity="3" unseen="213" />
+   * ```
+   *
+   * Mailbox names may be supplied as normal Unicode strings. Chilkat automatically handles IMAP
+   * modified UTF-7 or UTF-8 mailbox-name encoding as required by the server.
+   *
+   * This call blocks the JavaScript thread until Chilkat returns; from UI code prefer
+   * {@link Imap.getMailboxStatusAsync}.
+   *
+   * @throws Error if the call fails (the message names the reason); the full log is in
+   * {@link Imap.lastErrorText}.
+   */
+  getMailboxStatus(mailbox: string): string
+
+  /**
+   * Asynchronous form of {@link Imap.getMailboxStatus}: the same call on a native worker thread,
+   * settling on the JavaScript thread. While it is pending, other calls on this object throw,
+   * except {@link Imap.abort} (which cancels it) and the {@link Imap.onPercentDone} /
+   * {@link Imap.onProgressInfo} callbacks, which report progress while it runs.
+   *
+   * The promise rejects with an Error if the call fails; the full log is in
+   * {@link Imap.lastErrorText}.
+   */
+  getMailboxStatusAsync(mailbox: string): Promise<string>
+
+  /**
+   * Sends the IMAP `GETQUOTA` command for the quota root in `quotaRoot` and returns the server
+   * response as JSON.
+   *
+   * The server must advertise the IMAP `QUOTA` capability.
+   *
+   * This call blocks the JavaScript thread until Chilkat returns; from UI code prefer
+   * {@link Imap.getQuotaAsync}.
+   *
+   * @throws Error if the call fails (the message names the reason); the full log is in
+   * {@link Imap.lastErrorText}.
+   */
+  getQuota(quotaRoot: string): string
+
+  /**
+   * Asynchronous form of {@link Imap.getQuota}: the same call on a native worker thread,
+   * settling on the JavaScript thread. While it is pending, other calls on this object throw,
+   * except {@link Imap.abort} (which cancels it) and the {@link Imap.onPercentDone} /
+   * {@link Imap.onProgressInfo} callbacks, which report progress while it runs.
+   *
+   * The promise rejects with an Error if the call fails; the full log is in
+   * {@link Imap.lastErrorText}.
+   */
+  getQuotaAsync(quotaRoot: string): Promise<string>
+
+  /**
+   * Sends the IMAP `GETQUOTAROOT` command for the mailbox in `mailboxName` and returns the server
+   * response as JSON. The server must advertise the IMAP `QUOTA` capability.
+   *
+   * A response can contain both the mailbox-to-root mapping and the quota values:
+   *
+   * ```
+   * {
+   *   "QUOTAROOT": {"mailbox":"Inbox","root":"Mailbox"},
+   *   "QUOTA": {"root":"Mailbox","resource":"STORAGE","used":9,"max":256000}
+   * }
+   * ```
+   *
+   * Mailbox names may be supplied as normal Unicode strings. Chilkat automatically handles IMAP
+   * modified UTF-7 or UTF-8 mailbox-name encoding as required by the server.
+   *
+   * This call blocks the JavaScript thread until Chilkat returns; from UI code prefer
+   * {@link Imap.getQuotaRootAsync}.
+   *
+   * @throws Error if the call fails (the message names the reason); the full log is in
+   * {@link Imap.lastErrorText}.
+   */
+  getQuotaRoot(mailboxName: string): string
+
+  /**
+   * Asynchronous form of {@link Imap.getQuotaRoot}: the same call on a native worker thread,
+   * settling on the JavaScript thread. While it is pending, other calls on this object throw,
+   * except {@link Imap.abort} (which cancels it) and the {@link Imap.onPercentDone} /
+   * {@link Imap.onProgressInfo} callbacks, which report progress while it runs.
+   *
+   * The promise rejects with an Error if the call fails; the full log is in
+   * {@link Imap.lastErrorText}.
+   */
+  getQuotaRootAsync(mailboxName: string): Promise<string>
+
+  /**
+   * Tests whether the capability named by `name` appears in the raw capability response in
+   * `capabilityResponse`.
+   *
+   * `capabilityResponse` is typically the string returned by {@link Imap.capability}.
+   * Capability-name matching follows IMAP capability-token semantics.
+   */
+  hasCapability(name: string, capabilityResponse: string): boolean
+
+  /**
+   * Waits up to `timeoutMs` milliseconds for unsolicited mailbox updates after {@link
+   * Imap.idleStart} has entered IMAP IDLE mode.
+   *
+   * `timeoutMs` = `0` performs a strict poll: it checks for already available data and returns
+   * immediately. Positive values wait for up to the requested time, including very large values. If
+   * the connection is lost while waiting, the method fails.
+   *
+   * This method does not send a polling command. It consumes the notifications currently waiting on
+   * the existing connection and returns them as XML. A second call returns only notifications that
+   * arrived after the previous call.
+   *
+   * - `flags`: flags changed for a message.
+   *
+   * - `expunge`: a sequence number was removed.
+   *
+   * - `exists`: the mailbox message count changed.
+   *
+   * - `recent`: the recent-message count changed.
+   *
+   * - `raw`: an unrecognized response line retained for diagnostics.
+   *
+   * ```
+   * <idle><exists>115</exists><recent>1</recent></idle>
+   * ```
+   *
+   * When no update is available, the result is `<idle></idle>`. An `exists` notification does not
+   * automatically change {@link Imap.numMessages}.
+   *
+   * Chilkat does not automatically refresh IDLE. The application should periodically call {@link
+   * Imap.idleDone} and {@link Imap.idleStart}, typically before 29 minutes have elapsed, to prevent
+   * servers with a 30-minute limit from dropping the connection.
+   *
+   * This call blocks the JavaScript thread until Chilkat returns; from UI code prefer
+   * {@link Imap.idleCheckAsync}.
+   *
+   * @throws Error if the call fails (the message names the reason); the full log is in
+   * {@link Imap.lastErrorText}.
+   */
+  idleCheck(timeoutMs: number): string
+
+  /**
+   * Asynchronous form of {@link Imap.idleCheck}: the same call on a native worker thread,
+   * settling on the JavaScript thread. While it is pending, other calls on this object throw,
+   * except {@link Imap.abort} (which cancels it) and the {@link Imap.onPercentDone} /
+   * {@link Imap.onProgressInfo} callbacks, which report progress while it runs.
+   *
+   * The promise rejects with an Error if the call fails; the full log is in
+   * {@link Imap.lastErrorText}.
+   */
+  idleCheckAsync(timeoutMs: number): Promise<string>
+
+  /**
+   * Ends IMAP IDLE mode by sending the protocol's `DONE` continuation.
+   *
+   * The authenticated connection remains open and usable. Calling this method when IDLE is not
+   * active fails.
+   *
+   * Applications maintaining a long-lived IDLE connection should call this method shortly before
+   * the server's IDLE limit, commonly at about 29 minutes, and then immediately call {@link
+   * Imap.idleStart} again.
+   *
+   * This call blocks the JavaScript thread until Chilkat returns; from UI code prefer
+   * {@link Imap.idleDoneAsync}.
+   *
+   * @throws Error if the call fails (the message names the reason); the full log is in
+   * {@link Imap.lastErrorText}.
+   */
+  idleDone(): void
+
+  /**
+   * Asynchronous form of {@link Imap.idleDone}: the same call on a native worker thread,
+   * settling on the JavaScript thread. While it is pending, other calls on this object throw,
+   * except {@link Imap.abort} (which cancels it) and the {@link Imap.onPercentDone} /
+   * {@link Imap.onProgressInfo} callbacks, which report progress while it runs.
+   *
+   * The promise rejects with an Error if the call fails; the full log is in
+   * {@link Imap.lastErrorText}.
+   */
+  idleDoneAsync(): Promise<void>
+
+  /**
+   * Sends the IMAP `IDLE` command and begins listening for unsolicited mailbox updates.
+   *
+   * The session must be connected, authenticated, and have a mailbox selected with {@link
+   * Imap.selectMailbox} or {@link Imap.examineMailbox}. The server must advertise the `IDLE`
+   * capability.
+   *
+   * Calling this method while IDLE is already active fails. While IDLE is active, any other method
+   * that sends an IMAP command also fails; call {@link Imap.idleDone} first.
+   *
+   * Chilkat does not automatically renew IDLE. To avoid common server time limits, the application
+   * should end and restart IDLE before the server timeout, typically about every 29 minutes.
+   *
+   * This call blocks the JavaScript thread until Chilkat returns; from UI code prefer
+   * {@link Imap.idleStartAsync}.
+   *
+   * @throws Error if the call fails (the message names the reason); the full log is in
+   * {@link Imap.lastErrorText}.
+   */
+  idleStart(): void
+
+  /**
+   * Asynchronous form of {@link Imap.idleStart}: the same call on a native worker thread,
+   * settling on the JavaScript thread. While it is pending, other calls on this object throw,
+   * except {@link Imap.abort} (which cancels it) and the {@link Imap.onPercentDone} /
+   * {@link Imap.onProgressInfo} callbacks, which report progress while it runs.
+   *
+   * The promise rejects with an Error if the call fails; the full log is in
+   * {@link Imap.lastErrorText}.
+   */
+  idleStartAsync(): Promise<void>
+
+  /**
+   * Returns the last known connection state without sending data to the IMAP server.
+   *
+   * A `true` result does not prove that an idle connection is still usable. Call {@link Imap.noop}
+   * to send a command and verify that the server responds.
+   */
+  isConnected(): boolean
+
+  /**
+   * Indicates whether this object is in an authenticated IMAP session.
+   *
+   * This reports the last known state and does not send a command to the server.
+   */
+  isLoggedIn(): boolean
+
+  /**
+   * Authenticates the connected IMAP session using the login name in `loginName` and the credential
+   * in `password`.
+   *
+   * Call {@link Imap.connect} first. The mechanism is selected by {@link Imap.authMethod}.
+   *
+   * For `XOAUTH2`, `loginName` is the normal IMAP login name or email address and `password` is the
+   * raw OAuth 2.0 access token without a `Bearer` prefix. A failed XOAUTH2 login leaves the
+   * connection open so the application may correct the credentials and try again.
+   *
+   * Do not call this method again after the session is already authenticated. A repeated login
+   * attempt fails, although the existing authenticated session remains logged in.
+   *
+   * This call blocks the JavaScript thread until Chilkat returns; from UI code prefer
+   * {@link Imap.loginAsync}.
+   *
+   * @throws Error if the call fails (the message names the reason); the full log is in
+   * {@link Imap.lastErrorText}.
+   */
+  login(loginName: string, password: string): void
+
+  /**
+   * Asynchronous form of {@link Imap.login}: the same call on a native worker thread,
+   * settling on the JavaScript thread. While it is pending, other calls on this object throw,
+   * except {@link Imap.abort} (which cancels it) and the {@link Imap.onPercentDone} /
+   * {@link Imap.onProgressInfo} callbacks, which report progress while it runs.
+   *
+   * The promise rejects with an Error if the call fails; the full log is in
+   * {@link Imap.lastErrorText}.
+   */
+  loginAsync(loginName: string, password: string): Promise<void>
+
+  /**
+   * Sends the IMAP `LOGOUT` command and ends the authenticated session.
+   *
+   * The server normally closes the connection as part of a successful logout.
+   *
+   * This call blocks the JavaScript thread until Chilkat returns; from UI code prefer
+   * {@link Imap.logoutAsync}.
+   *
+   * @throws Error if the call fails (the message names the reason); the full log is in
+   * {@link Imap.lastErrorText}.
+   */
+  logout(): void
+
+  /**
+   * Asynchronous form of {@link Imap.logout}: the same call on a native worker thread,
+   * settling on the JavaScript thread. While it is pending, other calls on this object throw,
+   * except {@link Imap.abort} (which cancels it) and the {@link Imap.onPercentDone} /
+   * {@link Imap.onProgressInfo} callbacks, which report progress while it runs.
+   *
+   * The promise rejects with an Error if the call fails; the full log is in
+   * {@link Imap.lastErrorText}.
+   */
+  logoutAsync(): Promise<void>
+
+  /**
+   * Sends the IMAP `NOOP` command and waits for the server response.
+   *
+   * This is useful for verifying that an existing authenticated connection is still responsive and
+   * for receiving unsolicited mailbox-state updates.
+   *
+   * This call blocks the JavaScript thread until Chilkat returns; from UI code prefer
+   * {@link Imap.noopAsync}.
+   *
+   * @throws Error if the call fails (the message names the reason); the full log is in
+   * {@link Imap.lastErrorText}.
+   */
+  noop(): void
+
+  /**
+   * Asynchronous form of {@link Imap.noop}: the same call on a native worker thread,
+   * settling on the JavaScript thread. While it is pending, other calls on this object throw,
+   * except {@link Imap.abort} (which cancels it) and the {@link Imap.onPercentDone} /
+   * {@link Imap.onProgressInfo} callbacks, which report progress while it runs.
+   *
+   * The promise rejects with an Error if the call fails; the full log is in
+   * {@link Imap.lastErrorText}.
+   */
+  noopAsync(): Promise<void>
+
+  /**
+   * Fetches the current IMAP flags for the server message represented by `email` and updates its
+   * `ckx-imap-*` metadata headers.
+   *
+   * Chilkat reads the identifier from `ckx-imap-uid` and checks `ckx-imap-isUid` to determine
+   * whether it is a UID or sequence number. A copied `Email` can be used as long as this metadata
+   * is preserved.
+   *
+   * When `ckx-imap-isUid` is `NO`, the stored sequence number may identify a different message
+   * after an expunge. UID-based emails are preferred for later operations. Methods such as {@link
+   * Imap.getMailFlag} read the refreshed flag metadata.
+   *
+   * This call blocks the JavaScript thread until Chilkat returns; from UI code prefer
+   * {@link Imap.refetchMailFlagsAsync}.
+   *
+   * @throws Error if the call fails (the message names the reason); the full log is in
+   * {@link Imap.lastErrorText}.
+   */
+  refetchMailFlags(email: Email): void
+
+  /**
+   * Asynchronous form of {@link Imap.refetchMailFlags}: the same call on a native worker thread,
+   * settling on the JavaScript thread. While it is pending, other calls on this object throw,
+   * except {@link Imap.abort} (which cancels it) and the {@link Imap.onPercentDone} /
+   * {@link Imap.onProgressInfo} callbacks, which report progress while it runs.
+   *
+   * The promise rejects with an Error if the call fails; the full log is in
+   * {@link Imap.lastErrorText}.
+   */
+  refetchMailFlagsAsync(email: Email): Promise<void>
+
+  /**
+   * Renames the mailbox in `fromMailbox` to the name in `toMailbox`.
+   *
+   * Changing hierarchy components can also move a mailbox within the server's folder tree, for
+   * example from `INBOX.old.project` to `INBOX.archive.project`.
+   *
+   * Mailbox names may be supplied as normal Unicode strings. Chilkat automatically handles IMAP
+   * modified UTF-7 or UTF-8 mailbox-name encoding as required by the server.
+   *
+   * This call blocks the JavaScript thread until Chilkat returns; from UI code prefer
+   * {@link Imap.renameMailboxAsync}.
+   *
+   * @throws Error if the call fails (the message names the reason); the full log is in
+   * {@link Imap.lastErrorText}.
+   */
+  renameMailbox(fromMailbox: string, toMailbox: string): void
+
+  /**
+   * Asynchronous form of {@link Imap.renameMailbox}: the same call on a native worker thread,
+   * settling on the JavaScript thread. While it is pending, other calls on this object throw,
+   * except {@link Imap.abort} (which cancels it) and the {@link Imap.onPercentDone} /
+   * {@link Imap.onProgressInfo} callbacks, which report progress while it runs.
+   *
+   * The promise rejects with an Error if the call fails; the full log is in
+   * {@link Imap.lastErrorText}.
+   */
+  renameMailboxAsync(fromMailbox: string, toMailbox: string): Promise<void>
+
+  /**
+   * Opens the mailbox in `mailbox` for read-write access.
+   *
+   * A mailbox must be selected before message fetch, search, flag, copy, move, or expunge
+   * operations that act on mailbox contents. Successful selection updates {@link
+   * Imap.selectedMailbox}, {@link Imap.numMessages}, {@link Imap.uidValidity}, and related
+   * mailbox-state properties.
+   *
+   * Use {@link Imap.examineMailbox} when read-only access is required.
+   *
+   * Mailbox names may be supplied as normal Unicode strings. Chilkat automatically handles IMAP
+   * modified UTF-7 or UTF-8 mailbox-name encoding as required by the server.
+   *
+   * This call blocks the JavaScript thread until Chilkat returns; from UI code prefer
+   * {@link Imap.selectMailboxAsync}.
+   *
+   * @throws Error if the call fails (the message names the reason); the full log is in
+   * {@link Imap.lastErrorText}.
+   */
+  selectMailbox(mailbox: string): void
+
+  /**
+   * Asynchronous form of {@link Imap.selectMailbox}: the same call on a native worker thread,
+   * settling on the JavaScript thread. While it is pending, other calls on this object throw,
+   * except {@link Imap.abort} (which cancels it) and the {@link Imap.onPercentDone} /
+   * {@link Imap.onProgressInfo} callbacks, which report progress while it runs.
+   *
+   * The promise rejects with an Error if the call fails; the full log is in
+   * {@link Imap.lastErrorText}.
+   */
+  selectMailboxAsync(mailbox: string): Promise<void>
+
+  /**
+   * Sends the raw IMAP command text in `cmd` and returns the raw server response.
+   *
+   * Pass the command itself, such as `NOOP`, without an IMAP command tag or trailing CRLF. Chilkat
+   * generates the tag and command line termination.
+   *
+   * Use raw commands only for rare server extensions that are not otherwise exposed by the API,
+   * have an expected one-line response, and do not change Imap object state such as the selected
+   * mailbox, message count, `UidNext`, or `UidValidity`. State-changing raw commands can leave
+   * cached properties inconsistent with the server.
+   *
+   * This call blocks the JavaScript thread until Chilkat returns; from UI code prefer
+   * {@link Imap.sendRawCommandAsync}.
+   *
+   * @throws Error if the call fails (the message names the reason); the full log is in
+   * {@link Imap.lastErrorText}.
+   */
+  sendRawCommand(cmd: string): string
+
+  /**
+   * Asynchronous form of {@link Imap.sendRawCommand}: the same call on a native worker thread,
+   * settling on the JavaScript thread. While it is pending, other calls on this object throw,
+   * except {@link Imap.abort} (which cancels it) and the {@link Imap.onPercentDone} /
+   * {@link Imap.onProgressInfo} callbacks, which report progress while it runs.
+   *
+   * The promise rejects with an Error if the call fails; the full log is in
+   * {@link Imap.lastErrorText}.
+   */
+  sendRawCommandAsync(cmd: string): Promise<string>
+
+  /**
+   * Specifies the `Cert` in `cert` for decrypting S/MIME messages downloaded by this `Imap` object.
+   *
+   * The certificate must have access to its associated private key. Use {@link
+   * Imap.setDecryptCert2} when the private key is supplied separately.
+   *
+   * @throws Error if the call fails (the message names the reason); the full log is in
+   * {@link Imap.lastErrorText}.
+   */
+  setDecryptCert(cert: Cert): void
+
+  /**
+   * Specifies the certificate in `cert` and its separately supplied `PrivateKey` in `key` for
+   * decrypting S/MIME messages.
+   *
+   * Use this when the certificate object does not already provide access to the private key.
+   *
+   * @throws Error if the call fails (the message names the reason); the full log is in
+   * {@link Imap.lastErrorText}.
+   */
+  setDecryptCert2(cert: Cert, key: PrivateKey): void
+
+  /**
+   * Sets or clears one flag on the message identified by `msgId` in the selected mailbox.
+   *
+   * If `bUid` is `true`, `msgId` is a UID; otherwise, it is a sequence number. `flagName` is the
+   * flag name, and `value` is `1` to set the flag or `0` to clear it.
+   *
+   * Standard flags include `\Deleted`, `\Seen`, `\Answered`, `\Flagged`, and `\Draft`.
+   * Server-supported custom keywords may also be used.
+   *
+   * This call blocks the JavaScript thread until Chilkat returns; from UI code prefer
+   * {@link Imap.setFlagAsync}.
+   *
+   * @throws Error if the call fails (the message names the reason); the full log is in
+   * {@link Imap.lastErrorText}.
+   */
+  setFlag(msgId: number, bUid: boolean, flagName: string, value: number): void
+
+  /**
+   * Asynchronous form of {@link Imap.setFlag}: the same call on a native worker thread,
+   * settling on the JavaScript thread. While it is pending, other calls on this object throw,
+   * except {@link Imap.abort} (which cancels it) and the {@link Imap.onPercentDone} /
+   * {@link Imap.onProgressInfo} callbacks, which report progress while it runs.
+   *
+   * The promise rejects with an Error if the call fails; the full log is in
+   * {@link Imap.lastErrorText}.
+   */
+  setFlagAsync(msgId: number, bUid: boolean, flagName: string, value: number): Promise<void>
+
+  /**
+   * Sets or clears one flag for every identifier in the `MessageSet` supplied in `messageSet`.
+   *
+   * `flagName` is the flag name, and `value` is `1` to set it or `0` to clear it.
+   * `MessageSet.HasUids` determines whether the identifiers are UIDs or sequence numbers. Chilkat
+   * sends one IMAP `STORE` or `UID STORE` command containing the complete identifier set.
+   *
+   * IMAP bulk flag changes are not atomic and have no all-or-nothing rollback. Changes applied
+   * before a failure remain applied. For UID-based operations, nonexistent UIDs are silently
+   * ignored as required by IMAP. For sequence-number operations, an out-of-range sequence number
+   * causes the server to return an error; whether valid sequence numbers in the same command were
+   * changed before that error is server-dependent.
+   *
+   * This method changes server state only. It does not update metadata in any previously fetched
+   * `Email` objects.
+   *
+   * This call blocks the JavaScript thread until Chilkat returns; from UI code prefer
+   * {@link Imap.setFlagsAsync}.
+   *
+   * @throws Error if the call fails (the message names the reason); the full log is in
+   * {@link Imap.lastErrorText}.
+   */
+  setFlags(messageSet: MessageSet, flagName: string, value: number): void
+
+  /**
+   * Asynchronous form of {@link Imap.setFlags}: the same call on a native worker thread,
+   * settling on the JavaScript thread. While it is pending, other calls on this object throw,
+   * except {@link Imap.abort} (which cancels it) and the {@link Imap.onPercentDone} /
+   * {@link Imap.onProgressInfo} callbacks, which report progress while it runs.
+   *
+   * The promise rejects with an Error if the call fails; the full log is in
+   * {@link Imap.lastErrorText}.
+   */
+  setFlagsAsync(messageSet: MessageSet, flagName: string, value: number): Promise<void>
+
+  /**
+   * Sets or clears a flag for the server message represented by the `Email` in `email`.
+   *
+   * Chilkat reads the message identifier from `ckx-imap-uid` and uses `ckx-imap-isUid` to determine
+   * whether the value is a UID or sequence number. `flagName` is the flag name, and `value` is `1`
+   * to set it or `0` to clear it. The method fails if the required metadata is absent.
+   *
+   * A copied `Email` can be used as long as the metadata is preserved. When `ckx-imap-isUid` is
+   * `NO`, the stored value is a sequence number and may no longer identify the same message after
+   * an expunge. UID-based emails are preferred for operations performed later or after
+   * reconnecting.
+   *
+   * Setting `\Deleted` marks the message for deletion; call {@link Imap.expunge} to remove it
+   * permanently.
+   *
+   * This call blocks the JavaScript thread until Chilkat returns; from UI code prefer
+   * {@link Imap.setMailFlagAsync}.
+   *
+   * @throws Error if the call fails (the message names the reason); the full log is in
+   * {@link Imap.lastErrorText}.
+   */
+  setMailFlag(email: Email, flagName: string, value: number): void
+
+  /**
+   * Asynchronous form of {@link Imap.setMailFlag}: the same call on a native worker thread,
+   * settling on the JavaScript thread. While it is pending, other calls on this object throw,
+   * except {@link Imap.abort} (which cancels it) and the {@link Imap.onPercentDone} /
+   * {@link Imap.onProgressInfo} callbacks, which report progress while it runs.
+   *
+   * The promise rejects with an Error if the call fails; the full log is in
+   * {@link Imap.lastErrorText}.
+   */
+  setMailFlagAsync(email: Email, flagName: string, value: number): Promise<void>
+
+  /**
+   * Sends the IMAP `SETQUOTA` command for quota root `quotaRoot`.
+   *
+   * `resource` is `STORAGE` to set the combined message-storage limit or `MESSAGE` to set the
+   * message-count limit. For `STORAGE`, `quota` is measured in units of 1024 octets; for example,
+   * `500000` represents approximately 500,000,000 bytes.
+   *
+   * The server must support the IMAP `QUOTA` extension and the requested resource type.
+   *
+   * This call blocks the JavaScript thread until Chilkat returns; from UI code prefer
+   * {@link Imap.setQuotaAsync}.
+   *
+   * @throws Error if the call fails (the message names the reason); the full log is in
+   * {@link Imap.lastErrorText}.
+   */
+  setQuota(quotaRoot: string, resource: string, quota: number): void
+
+  /**
+   * Asynchronous form of {@link Imap.setQuota}: the same call on a native worker thread,
+   * settling on the JavaScript thread. While it is pending, other calls on this object throw,
+   * except {@link Imap.abort} (which cancels it) and the {@link Imap.onPercentDone} /
+   * {@link Imap.onProgressInfo} callbacks, which report progress while it runs.
+   *
+   * The promise rejects with an Error if the call fails; the full log is in
+   * {@link Imap.lastErrorText}.
+   */
+  setQuotaAsync(quotaRoot: string, resource: string, quota: number): Promise<void>
+
+  /**
+   * Specifies the client certificate in `cert` for TLS client-certificate authentication.
+   *
+   * Most IMAP servers do not require a client certificate. When one is required, `cert` must
+   * provide access to the corresponding private key.
+   *
+   * @throws Error if the call fails (the message names the reason); the full log is in
+   * {@link Imap.lastErrorText}.
+   */
+  setSslClientCert(cert: Cert): void
+
+  /**
+   * Specifies a TLS client certificate and private key from PEM data or a PEM file.
+   *
+   * `pemDataOrFilename` may contain the PEM text itself or a local filesystem path to the PEM file;
+   * Chilkat detects which form was supplied. `pemPassword` contains the password when the private
+   * key is encrypted.
+   *
+   * @throws Error if the call fails (the message names the reason); the full log is in
+   * {@link Imap.lastErrorText}.
+   */
+  setSslClientCertPem(pemDataOrFilename: string, pemPassword: string): void
+
+  /**
+   * Specifies a TLS client certificate and private key from a PKCS #12/PFX file.
+   *
+   * `pfxFilename` is the local filesystem path of the `.pfx` or `.p12` file, and `pfxPassword`
+   * contains its password.
+   *
+   * @throws Error if the call fails (the message names the reason); the full log is in
+   * {@link Imap.lastErrorText}.
+   */
+  setSslClientCertPfx(pfxFilename: string, pfxPassword: string): void
+
+  /**
+   * Authenticates the SSH tunnel using the username in `sshLogin` and the `SshKey` private key in
+   * `privateKey`.
+   *
+   * Call {@link Imap.sshOpenTunnel} first. The corresponding public key must already be authorized
+   * for `sshLogin` on the SSH server. After authentication, call {@link Imap.connect} and {@link
+   * Imap.login} for the IMAP server.
+   *
+   * This call blocks the JavaScript thread until Chilkat returns; from UI code prefer
+   * {@link Imap.sshAuthenticatePkAsync}.
+   *
+   * @throws Error if the call fails (the message names the reason); the full log is in
+   * {@link Imap.lastErrorText}.
+   */
+  sshAuthenticatePk(sshLogin: string, privateKey: SshKey): void
+
+  /**
+   * Asynchronous form of {@link Imap.sshAuthenticatePk}: the same call on a native worker thread,
+   * settling on the JavaScript thread. While it is pending, other calls on this object throw,
+   * except {@link Imap.abort} (which cancels it) and the {@link Imap.onPercentDone} /
+   * {@link Imap.onProgressInfo} callbacks, which report progress while it runs.
+   *
+   * The promise rejects with an Error if the call fails; the full log is in
+   * {@link Imap.lastErrorText}.
+   */
+  sshAuthenticatePkAsync(sshLogin: string, privateKey: SshKey): Promise<void>
+
+  /**
+   * Authenticates the SSH tunnel using the username in `sshLogin` and password in `sshPassword`.
+   *
+   * Call {@link Imap.sshOpenTunnel} first. After SSH authentication succeeds, call {@link
+   * Imap.connect} and {@link Imap.login}; the IMAP traffic then flows through the tunnel
+   * automatically.
+   *
+   * This call blocks the JavaScript thread until Chilkat returns; from UI code prefer
+   * {@link Imap.sshAuthenticatePwAsync}.
+   *
+   * @throws Error if the call fails (the message names the reason); the full log is in
+   * {@link Imap.lastErrorText}.
+   */
+  sshAuthenticatePw(sshLogin: string, sshPassword: string): void
+
+  /**
+   * Asynchronous form of {@link Imap.sshAuthenticatePw}: the same call on a native worker thread,
+   * settling on the JavaScript thread. While it is pending, other calls on this object throw,
+   * except {@link Imap.abort} (which cancels it) and the {@link Imap.onPercentDone} /
+   * {@link Imap.onProgressInfo} callbacks, which report progress while it runs.
+   *
+   * The promise rejects with an Error if the call fails; the full log is in
+   * {@link Imap.lastErrorText}.
+   */
+  sshAuthenticatePwAsync(sshLogin: string, sshPassword: string): Promise<void>
+
+  /**
+   * Closes the SSH tunnel opened by {@link Imap.sshOpenTunnel}.
+   *
+   * Any IMAP connection using that tunnel must no longer be used after the tunnel is closed.
+   *
+   * This call blocks the JavaScript thread until Chilkat returns; from UI code prefer
+   * {@link Imap.sshCloseTunnelAsync}.
+   *
+   * @throws Error if the call fails (the message names the reason); the full log is in
+   * {@link Imap.lastErrorText}.
+   */
+  sshCloseTunnel(): void
+
+  /**
+   * Asynchronous form of {@link Imap.sshCloseTunnel}: the same call on a native worker thread,
+   * settling on the JavaScript thread. While it is pending, other calls on this object throw,
+   * except {@link Imap.abort} (which cancels it) and the {@link Imap.onPercentDone} /
+   * {@link Imap.onProgressInfo} callbacks, which report progress while it runs.
+   *
+   * The promise rejects with an Error if the call fails; the full log is in
+   * {@link Imap.lastErrorText}.
+   */
+  sshCloseTunnelAsync(): Promise<void>
+
+  /**
+   * Connects to the SSH server in `sshHostname` on port `sshPort` and prepares an SSH tunnel for
+   * the later IMAP connection.
+   *
+   * Port `22` is the usual SSH port. After this succeeds, authenticate with {@link
+   * Imap.sshAuthenticatePw} or {@link Imap.sshAuthenticatePk}, then call {@link Imap.connect} and
+   * {@link Imap.login} for IMAP.
+   *
+   * This call blocks the JavaScript thread until Chilkat returns; from UI code prefer
+   * {@link Imap.sshOpenTunnelAsync}.
+   *
+   * @throws Error if the call fails (the message names the reason); the full log is in
+   * {@link Imap.lastErrorText}.
+   */
+  sshOpenTunnel(sshHostname: string, sshPort: number): void
+
+  /**
+   * Asynchronous form of {@link Imap.sshOpenTunnel}: the same call on a native worker thread,
+   * settling on the JavaScript thread. While it is pending, other calls on this object throw,
+   * except {@link Imap.abort} (which cancels it) and the {@link Imap.onPercentDone} /
+   * {@link Imap.onProgressInfo} callbacks, which report progress while it runs.
+   *
+   * The promise rejects with an Error if the call fails; the full log is in
+   * {@link Imap.lastErrorText}.
+   */
+  sshOpenTunnelAsync(sshHostname: string, sshPort: number): Promise<void>
+
+  /**
+   * Sets or clears multiple flags on one message in the selected mailbox.
+   *
+   * If `bUid` is `true`, `msgId` is a UID; otherwise, it is a sequence number. `flagNames` is a
+   * space-separated list such as `\Seen \Answered $label1`. `value` is `1` to set all listed flags
+   * or `0` to clear them.
+   *
+   * The operation uses IMAP `STORE` or `UID STORE` and is not transactional. A nonexistent UID can
+   * be silently ignored and the command can still succeed. An invalid sequence number causes
+   * failure. This method changes server state only and does not update metadata in previously
+   * fetched `Email` objects.
+   *
+   * This call blocks the JavaScript thread until Chilkat returns; from UI code prefer
+   * {@link Imap.storeFlagsAsync}.
+   *
+   * @throws Error if the call fails (the message names the reason); the full log is in
+   * {@link Imap.lastErrorText}.
+   */
+  storeFlags(msgId: number, bUid: boolean, flagNames: string, value: number): void
+
+  /**
+   * Asynchronous form of {@link Imap.storeFlags}: the same call on a native worker thread,
+   * settling on the JavaScript thread. While it is pending, other calls on this object throw,
+   * except {@link Imap.abort} (which cancels it) and the {@link Imap.onPercentDone} /
+   * {@link Imap.onProgressInfo} callbacks, which report progress while it runs.
+   *
+   * The promise rejects with an Error if the call fails; the full log is in
+   * {@link Imap.lastErrorText}.
+   */
+  storeFlagsAsync(msgId: number, bUid: boolean, flagNames: string, value: number): Promise<void>
+
+  /**
+   * Subscribes the authenticated IMAP account to the mailbox named by `mailbox`.
+   *
+   * Subscription controls which mailboxes are returned by subscribed-mailbox listing operations; it
+   * does not create the mailbox.
+   *
+   * Mailbox names may be supplied as normal Unicode strings. Chilkat automatically handles IMAP
+   * modified UTF-7 or UTF-8 mailbox-name encoding as required by the server.
+   *
+   * This call blocks the JavaScript thread until Chilkat returns; from UI code prefer
+   * {@link Imap.subscribeAsync}.
+   *
+   * @throws Error if the call fails (the message names the reason); the full log is in
+   * {@link Imap.lastErrorText}.
+   */
+  subscribe(mailbox: string): void
+
+  /**
+   * Asynchronous form of {@link Imap.subscribe}: the same call on a native worker thread,
+   * settling on the JavaScript thread. While it is pending, other calls on this object throw,
+   * except {@link Imap.abort} (which cancels it) and the {@link Imap.onPercentDone} /
+   * {@link Imap.onProgressInfo} callbacks, which report progress while it runs.
+   *
+   * The promise rejects with an Error if the call fails; the full log is in
+   * {@link Imap.lastErrorText}.
+   */
+  subscribeAsync(mailbox: string): Promise<void>
+
+  /**
+   * Removes the subscription to the mailbox named by `mailbox`.
+   *
+   * The mailbox itself and its messages are not deleted.
+   *
+   * Mailbox names may be supplied as normal Unicode strings. Chilkat automatically handles IMAP
+   * modified UTF-7 or UTF-8 mailbox-name encoding as required by the server.
+   *
+   * This call blocks the JavaScript thread until Chilkat returns; from UI code prefer
+   * {@link Imap.unsubscribeAsync}.
+   *
+   * @throws Error if the call fails (the message names the reason); the full log is in
+   * {@link Imap.lastErrorText}.
+   */
+  unsubscribe(mailbox: string): void
+
+  /**
+   * Asynchronous form of {@link Imap.unsubscribe}: the same call on a native worker thread,
+   * settling on the JavaScript thread. While it is pending, other calls on this object throw,
+   * except {@link Imap.abort} (which cancels it) and the {@link Imap.onPercentDone} /
+   * {@link Imap.onProgressInfo} callbacks, which report progress while it runs.
+   *
+   * The promise rejects with an Error if the call fails; the full log is in
+   * {@link Imap.lastErrorText}.
+   */
+  unsubscribeAsync(mailbox: string): Promise<void>
+
+  /**
+   * Associates the `XmlCertVault` in `vault` with this `Imap` object as a source of certificates
+   * and private keys for S/MIME operations.
+   *
+   * Only one vault can be associated at a time. Calling this method again replaces the previously
+   * associated vault.
+   *
+   * @throws Error if the call fails (the message names the reason); the full log is in
+   * {@link Imap.lastErrorText}.
+   */
+  useCertVault(vault: XmlCertVault): void
+
+  /**
+   * Uses an already connected and authenticated `Ssh` object as the transport for subsequent IMAP
+   * connections.
+   *
+   * SSH supports multiple logical channels, so the same SSH connection may be shared by IMAP and
+   * other Chilkat objects. Call this method before {@link Imap.connect}.
+   *
+   * @throws Error if the call fails (the message names the reason); the full log is in
+   * {@link Imap.lastErrorText}.
+   */
+  useSsh(ssh: Ssh): void
+
+  /**
+   * Uses the existing SSH tunnel represented by the `Socket` in `tunnel` for subsequent IMAP
+   * connections.
+   *
+   * This allows a tunnel to be shared with other objects. Call this method before {@link
+   * Imap.connect}.
+   *
+   * @throws Error if the call fails (the message names the reason); the full log is in
+   * {@link Imap.lastErrorText}.
+   */
+  useSshTunnel(tunnel: Socket): void
+
+  /**
+   * Downloads one message's MIME into the `StringBuilder` in `sbMime`.
+   *
+   * If `bUid` is `true`, `msgId` is a UID; otherwise, `msgId` is a sequence number. Ordinary
+   * attachment bodies are included according to {@link Imap.autoDownloadAttachments}. `sbMime` is
+   * cleared before the operation; on failure it remains empty.
+   *
+   * Chilkat interprets the received MIME bytes as UTF-8. MIME using Base64 or quoted-printable
+   * transfer encoding is safe because the encoded bytes are ASCII. Raw `8bit` or `binary` content,
+   * or unencoded text in another charset such as ISO-8859-1 or Shift_JIS, can be misinterpreted or
+   * cause an error. Use {@link Imap.fetchSingleBd} whenever byte-exact MIME is required.
+   *
+   * This call blocks the JavaScript thread until Chilkat returns; from UI code prefer
+   * {@link Imap.fetchSingleAsMimeSbAsync}.
+   *
+   * @throws Error if the call fails (the message names the reason); the full log is in
+   * {@link Imap.lastErrorText}.
+   */
+  fetchSingleAsMimeSb(msgId: number, bUid: boolean, sbMime: StringBuilder): void
+
+  /**
+   * Asynchronous form of {@link Imap.fetchSingleAsMimeSb}: the same call on a native worker thread,
+   * settling on the JavaScript thread. While it is pending, other calls on this object throw,
+   * except {@link Imap.abort} (which cancels it) and the {@link Imap.onPercentDone} /
+   * {@link Imap.onProgressInfo} callbacks, which report progress while it runs.
+   *
+   * The promise rejects with an Error if the call fails; the full log is in
+   * {@link Imap.lastErrorText}.
+   */
+  fetchSingleAsMimeSbAsync(msgId: number, bUid: boolean, sbMime: StringBuilder): Promise<void>
+
+  /**
+   * Obtains text attachment `attachmentIndex` from the `Email` in `email`, decodes it using the
+   * charset in `charset`, and stores the text in the `StringBuilder` in `sb`.
+   *
+   * Attachment indexes are zero-based. `sb` is always cleared first. On success it contains the
+   * complete decoded attachment text; on failure it remains empty. Use this method only for text
+   * attachments.
+   *
+   * See {@link Imap.fetchAttachment} for details about downloading data not already present in
+   * `email`.
+   *
+   * This call blocks the JavaScript thread until Chilkat returns; from UI code prefer
+   * {@link Imap.fetchAttachmentSbAsync}.
+   *
+   * @throws Error if the call fails (the message names the reason); the full log is in
+   * {@link Imap.lastErrorText}.
+   */
+  fetchAttachmentSb(email: Email, attachmentIndex: number, charset: string, sb: StringBuilder): void
+
+  /**
+   * Asynchronous form of {@link Imap.fetchAttachmentSb}: the same call on a native worker thread,
+   * settling on the JavaScript thread. While it is pending, other calls on this object throw,
+   * except {@link Imap.abort} (which cancels it) and the {@link Imap.onPercentDone} /
+   * {@link Imap.onProgressInfo} callbacks, which report progress while it runs.
+   *
+   * The promise rejects with an Error if the call fails; the full log is in
+   * {@link Imap.lastErrorText}.
+   */
+  fetchAttachmentSbAsync(email: Email, attachmentIndex: number, charset: string, sb: StringBuilder): Promise<void>
+
+  /**
+   * Obtains attachment `attachmentIndex` from the `Email` in `email` and stores its bytes in the
+   * `BinData` in `binData`.
+   *
+   * Attachment indexes are zero-based. `binData` is always cleared first. On success it contains
+   * the complete attachment bytes; on failure it remains empty.
+   *
+   * See {@link Imap.fetchAttachment} for details about downloading attachment data not already
+   * present in `email`.
+   *
+   * This call blocks the JavaScript thread until Chilkat returns; from UI code prefer
+   * {@link Imap.fetchAttachmentBdAsync}.
+   *
+   * @throws Error if the call fails (the message names the reason); the full log is in
+   * {@link Imap.lastErrorText}.
+   */
+  fetchAttachmentBd(email: Email, attachmentIndex: number, binData: BinData): void
+
+  /**
+   * Asynchronous form of {@link Imap.fetchAttachmentBd}: the same call on a native worker thread,
+   * settling on the JavaScript thread. While it is pending, other calls on this object throw,
+   * except {@link Imap.abort} (which cancels it) and the {@link Imap.onPercentDone} /
+   * {@link Imap.onProgressInfo} callbacks, which report progress while it runs.
+   *
+   * The promise rejects with an Error if the call fails; the full log is in
+   * {@link Imap.lastErrorText}.
+   */
+  fetchAttachmentBdAsync(email: Email, attachmentIndex: number, binData: BinData): Promise<void>
+
+  /**
+   * Appends the MIME contained in the `StringBuilder` in `sbMime` to mailbox `mailbox` and sets its
+   * initial system flags.
+   *
+   * - `seen` controls `\Seen`.
+   *
+   * - `flagged` controls `\Flagged`.
+   *
+   * - `answered` controls `\Answered`.
+   *
+   * - `draft` controls `\Draft`.
+   *
+   * The explicit flag arguments are used instead of {@link Imap.appendSeen}.
+   *
+   * The MIME text is sent exactly as supplied. Chilkat does not normalize line endings, add a final
+   * CRLF, or re-encode headers or body content. The supplied text must not contain non-text binary
+   * bytes.
+   *
+   * Mailbox names may be supplied as normal Unicode strings. Chilkat automatically handles IMAP
+   * modified UTF-7 or UTF-8 mailbox-name encoding as required by the server.
+   *
+   * This call blocks the JavaScript thread until Chilkat returns; from UI code prefer
+   * {@link Imap.appendMimeWithFlagsSbAsync}.
+   *
+   * @throws Error if the call fails (the message names the reason); the full log is in
+   * {@link Imap.lastErrorText}.
+   */
+  appendMimeWithFlagsSb(mailbox: string, sbMime: StringBuilder, seen: boolean, flagged: boolean, answered: boolean, draft: boolean): void
+
+  /**
+   * Asynchronous form of {@link Imap.appendMimeWithFlagsSb}: the same call on a native worker
+   * thread,
+   * settling on the JavaScript thread. While it is pending, other calls on this object throw,
+   * except {@link Imap.abort} (which cancels it) and the {@link Imap.onPercentDone} /
+   * {@link Imap.onProgressInfo} callbacks, which report progress while it runs.
+   *
+   * The promise rejects with an Error if the call fails; the full log is in
+   * {@link Imap.lastErrorText}.
+   */
+  appendMimeWithFlagsSbAsync(mailbox: string, sbMime: StringBuilder, seen: boolean, flagged: boolean, answered: boolean, draft: boolean): Promise<void>
+
+  /**
+   * Moves the messages identified by the `MessageSet` in `messageSet` from the selected mailbox to
+   * destination mailbox `destFolder` using one IMAP `MOVE` command.
+   *
+   * The server must advertise the `MOVE` capability. If it does not, this method fails and does not
+   * emulate the operation with copy, delete, and expunge commands.
+   *
+   * `MessageSet.HasUids` determines whether `messageSet` contains UIDs or sequence numbers. For
+   * sequence numbers, one invalid value causes complete failure and nothing is moved. For UIDs,
+   * nonexistent values are silently ignored and valid messages are moved.
+   *
+   * Mailbox names may be supplied as normal Unicode strings. Chilkat automatically handles IMAP
+   * modified UTF-7 or UTF-8 mailbox-name encoding as required by the server.
+   *
+   * This call blocks the JavaScript thread until Chilkat returns; from UI code prefer
+   * {@link Imap.moveMessagesAsync}.
+   *
+   * @throws Error if the call fails (the message names the reason); the full log is in
+   * {@link Imap.lastErrorText}.
+   */
+  moveMessages(messageSet: MessageSet, destFolder: string): void
+
+  /**
+   * Asynchronous form of {@link Imap.moveMessages}: the same call on a native worker thread,
+   * settling on the JavaScript thread. While it is pending, other calls on this object throw,
+   * except {@link Imap.abort} (which cancels it) and the {@link Imap.onPercentDone} /
+   * {@link Imap.onProgressInfo} callbacks, which report progress while it runs.
+   *
+   * The promise rejects with an Error if the call fails; the full log is in
+   * {@link Imap.lastErrorText}.
+   */
+  moveMessagesAsync(messageSet: MessageSet, destFolder: string): Promise<void>
+
+  /**
+   * Authenticates the connected IMAP session using the `SecureString` login name in `loginName` and
+   * credential in `password`.
+   *
+   * This is the secure-string counterpart of {@link Imap.login}. The authentication mechanism is
+   * selected by {@link Imap.authMethod}.
+   *
+   * For `XOAUTH2`, `loginName` contains the normal login name or email address and `password`
+   * contains the raw access token without a `Bearer` prefix.
+   *
+   * This call blocks the JavaScript thread until Chilkat returns; from UI code prefer
+   * {@link Imap.loginSecureAsync}.
+   *
+   * @throws Error if the call fails (the message names the reason); the full log is in
+   * {@link Imap.lastErrorText}.
+   */
+  loginSecure(loginName: SecureString, password: SecureString): void
+
+  /**
+   * Asynchronous form of {@link Imap.loginSecure}: the same call on a native worker thread,
+   * settling on the JavaScript thread. While it is pending, other calls on this object throw,
+   * except {@link Imap.abort} (which cancels it) and the {@link Imap.onPercentDone} /
+   * {@link Imap.onProgressInfo} callbacks, which report progress while it runs.
+   *
+   * The promise rejects with an Error if the call fails; the full log is in
+   * {@link Imap.lastErrorText}.
+   */
+  loginSecureAsync(loginName: SecureString, password: SecureString): Promise<void>
+
+  /**
+   * Downloads one message's MIME bytes into the `BinData` in `mimeData`.
+   *
+   * If `bUid` is `true`, `msgId` is a UID; otherwise, it is a sequence number. Ordinary attachment
+   * bodies are included according to {@link Imap.autoDownloadAttachments}, and {@link
+   * Imap.peekMode} controls whether the fetch sets `\Seen`.
+   *
+   * `mimeData` is cleared before the operation. On success it contains the downloaded MIME bytes;
+   * on failure it remains empty.
+   *
+   * This call blocks the JavaScript thread until Chilkat returns; from UI code prefer
+   * {@link Imap.fetchSingleBdAsync}.
+   *
+   * @throws Error if the call fails (the message names the reason); the full log is in
+   * {@link Imap.lastErrorText}.
+   */
+  fetchSingleBd(msgId: number, bUid: boolean, mimeData: BinData): void
+
+  /**
+   * Asynchronous form of {@link Imap.fetchSingleBd}: the same call on a native worker thread,
+   * settling on the JavaScript thread. While it is pending, other calls on this object throw,
+   * except {@link Imap.abort} (which cancels it) and the {@link Imap.onPercentDone} /
+   * {@link Imap.onProgressInfo} callbacks, which report progress while it runs.
+   *
+   * The promise rejects with an Error if the call fails; the full log is in
+   * {@link Imap.lastErrorText}.
+   */
+  fetchSingleBdAsync(msgId: number, bUid: boolean, mimeData: BinData): Promise<void>
+
+  /**
+   * Stores the certificate presented by the IMAP server for the current or most recent TLS
+   * connection in the `Cert` object supplied as `cert`.
+   *
+   * This is useful for certificate inspection, diagnostics, or implementing application-specific
+   * trust checks.
+   *
+   * @throws Error if the call fails (the message names the reason); the full log is in
+   * {@link Imap.lastErrorText}.
+   */
+  getServerCert(cert: Cert): void
+
+  /**
+   * Downloads the existing messages identified by the `MessageSet` in `msgSet` and appends them to
+   * the `EmailBundle` in `bundle`. `bundle` is not cleared.
+   *
+   * - `headersOnly` = `true`: download headers only.
+   *
+   * - `headersOnly` = `false`: download full messages, with ordinary attachments controlled by
+   *   {@link Imap.autoDownloadAttachments}.
+   *
+   * `MessageSet.HasUids` determines whether `msgSet` contains UIDs or sequence numbers. A
+   * `MessageSet` is a true set, so duplicate identifiers are collapsed before any command is sent.
+   * Identifiers that do not exist are omitted without causing the method to fail. Do not rely on
+   * insertion order; fetched messages are returned in the order supplied by the IMAP server,
+   * normally mailbox order.
+   *
+   * If a network failure occurs after some messages have been downloaded, those messages remain
+   * appended to `bundle`, fetching stops immediately, and the connection must be considered
+   * unusable. Reconnect, authenticate, and reselect the mailbox before retrying.
+   *
+   * This call blocks the JavaScript thread until Chilkat returns; from UI code prefer
+   * {@link Imap.fetchMsgSetAsync}.
+   *
+   * @throws Error if the call fails (the message names the reason); the full log is in
+   * {@link Imap.lastErrorText}.
+   */
+  fetchMsgSet(headersOnly: boolean, msgSet: MessageSet, bundle: EmailBundle): void
+
+  /**
+   * Asynchronous form of {@link Imap.fetchMsgSet}: the same call on a native worker thread,
+   * settling on the JavaScript thread. While it is pending, other calls on this object throw,
+   * except {@link Imap.abort} (which cancels it) and the {@link Imap.onPercentDone} /
+   * {@link Imap.onProgressInfo} callbacks, which report progress while it runs.
+   *
+   * The promise rejects with an Error if the call fails; the full log is in
+   * {@link Imap.lastErrorText}.
+   */
+  fetchMsgSetAsync(headersOnly: boolean, msgSet: MessageSet, bundle: EmailBundle): Promise<void>
+
+  /**
+   * Downloads `count` messages beginning with sequence number `seqnum` and appends them to the
+   * `EmailBundle` in `bundle`. `bundle` is not cleared.
+   *
+   * - `headersOnly` = `true`: download headers only.
+   *
+   * - `headersOnly` = `false`: download full messages, with ordinary attachments controlled by
+   *   {@link Imap.autoDownloadAttachments}.
+   *
+   * `seqnum` and `count` must both be greater than `0`. IMAP sequence numbers begin at `1`; passing
+   * `0` for `seqnum`, `0` for `count`, or a negative count fails without changing `bundle`. Only
+   * messages that exist in the requested sequence-number range are appended. Sequence numbers can
+   * change after messages are expunged.
+   *
+   * If a network failure occurs after some messages have been downloaded, those messages remain
+   * appended to `bundle`, fetching stops immediately, and the connection must be considered
+   * unusable.
+   *
+   * This call blocks the JavaScript thread until Chilkat returns; from UI code prefer
+   * {@link Imap.fetchRangeAsync}.
+   *
+   * @throws Error if the call fails (the message names the reason); the full log is in
+   * {@link Imap.lastErrorText}.
+   */
+  fetchRange(headersOnly: boolean, seqnum: number, count: number, bundle: EmailBundle): void
+
+  /**
+   * Asynchronous form of {@link Imap.fetchRange}: the same call on a native worker thread,
+   * settling on the JavaScript thread. While it is pending, other calls on this object throw,
+   * except {@link Imap.abort} (which cancels it) and the {@link Imap.onPercentDone} /
+   * {@link Imap.onProgressInfo} callbacks, which report progress while it runs.
+   *
+   * The promise rejects with an Error if the call fails; the full log is in
+   * {@link Imap.lastErrorText}.
+   */
+  fetchRangeAsync(headersOnly: boolean, seqnum: number, count: number, bundle: EmailBundle): Promise<void>
+
+  /**
+   * Downloads one message or its headers into the `Email` in `email`.
+   *
+   * - `headerOnly` = `true`: download headers only.
+   *
+   * - `headerOnly` = `false`: download the full message.
+   *
+   * - `bUid` = `true`: `msgId` is a UID.
+   *
+   * - `bUid` = `false`: `msgId` is a sequence number.
+   *
+   * On success, `email` is replaced with the fetched email. On failure, `email` remains unchanged.
+   *
+   * A header-only result contains no body or attachment bodies, but includes `ckx-imap-*` metadata
+   * for the message identifier, flags, total size, and attachment information. For a full download,
+   * ordinary attachment bodies are included according to {@link Imap.autoDownloadAttachments}.
+   * {@link Imap.peekMode} controls whether a full fetch sets `\Seen`; a header-only fetch does not
+   * set it.
+   *
+   * This call blocks the JavaScript thread until Chilkat returns; from UI code prefer
+   * {@link Imap.fetchEmailAsync}.
+   *
+   * @throws Error if the call fails (the message names the reason); the full log is in
+   * {@link Imap.lastErrorText}.
+   */
+  fetchEmail(headerOnly: boolean, msgId: number, bUid: boolean, email: Email): void
+
+  /**
+   * Asynchronous form of {@link Imap.fetchEmail}: the same call on a native worker thread,
+   * settling on the JavaScript thread. While it is pending, other calls on this object throw,
+   * except {@link Imap.abort} (which cancels it) and the {@link Imap.onPercentDone} /
+   * {@link Imap.onProgressInfo} callbacks, which report progress while it runs.
+   *
+   * The promise rejects with an Error if the call fails; the full log is in
+   * {@link Imap.lastErrorText}.
+   */
+  fetchEmailAsync(headerOnly: boolean, msgId: number, bUid: boolean, email: Email): Promise<void>
+
+  /**
+   * Lists matching mailboxes and appends them to the `Mailboxes` object in `mboxes`. `mboxes` is
+   * not cleared on success, so repeated calls on the same object can add duplicate entries. If the
+   * method fails, `mboxes` is unchanged.
+   *
+   * - `subscribed` = `true`: list only subscribed mailboxes.
+   *
+   * - `subscribed` = `false`: list all matching mailboxes.
+   *
+   * `reference` is the IMAP reference name, usually an empty string. `mbxPattern` is the mailbox
+   * pattern: `*` matches zero or more hierarchy levels, while `%` matches one hierarchy level.
+   *
+   * Applications may use normal Unicode mailbox names and patterns. Chilkat automatically handles
+   * IMAP modified UTF-7 or UTF-8 mailbox-name encoding as required by the server.
+   *
+   * The method also updates {@link Imap.separatorChar} from the server's response.
+   *
+   * This call blocks the JavaScript thread until Chilkat returns; from UI code prefer
+   * {@link Imap.mbxListAsync}.
+   *
+   * @throws Error if the call fails (the message names the reason); the full log is in
+   * {@link Imap.lastErrorText}.
+   */
+  mbxList(subscribed: boolean, reference: string, mbxPattern: string, mboxes: Mailboxes): void
+
+  /**
+   * Asynchronous form of {@link Imap.mbxList}: the same call on a native worker thread,
+   * settling on the JavaScript thread. While it is pending, other calls on this object throw,
+   * except {@link Imap.abort} (which cancels it) and the {@link Imap.onPercentDone} /
+   * {@link Imap.onProgressInfo} callbacks, which report progress while it runs.
+   *
+   * The promise rejects with an Error if the call fails; the full log is in
+   * {@link Imap.lastErrorText}.
+   */
+  mbxListAsync(subscribed: boolean, reference: string, mbxPattern: string, mboxes: Mailboxes): Promise<void>
+
+  /**
+   * Searches the selected mailbox using the IMAP criteria in `criteria` and stores matching
+   * identifiers in the `MessageSet` in `msgSet`.
+   *
+   * On success, `msgSet` is replaced with the result. If `bUid` is `true`, `msgSet` contains UIDs
+   * and `MessageSet.HasUids` is `true`; otherwise, `msgSet` contains sequence numbers and
+   * `MessageSet.HasUids` is `false`. If the method fails, `msgSet` is unchanged. {@link
+   * Imap.searchCharset} applies when the criteria contain non-ASCII text.
+   *
+   * For the special criterion `new-email`, Chilkat records each `UIDNEXT` received from `SELECT`,
+   * `EXAMINE`, or another IMAP response and uses it as the baseline for detecting later UIDs. If no
+   * `UIDNEXT` is available, Chilkat searches for messages having the `\Recent` flag. Results are
+   * always UIDs regardless of `bUid`, and an empty result clears `msgSet`.
+   *
+   * When {@link Imap.sortCriteria} is nonempty, Chilkat uses IMAP `SORT` if the server supports it.
+   * Otherwise, it automatically falls back to an ordinary `SEARCH`.
+   *
+   * This call blocks the JavaScript thread until Chilkat returns; from UI code prefer
+   * {@link Imap.queryMbxAsync}.
+   *
+   * @throws Error if the call fails (the message names the reason); the full log is in
+   * {@link Imap.lastErrorText}.
+   */
+  queryMbx(criteria: string, bUid: boolean, msgSet: MessageSet): void
+
+  /**
+   * Asynchronous form of {@link Imap.queryMbx}: the same call on a native worker thread,
+   * settling on the JavaScript thread. While it is pending, other calls on this object throw,
+   * except {@link Imap.abort} (which cancels it) and the {@link Imap.onPercentDone} /
+   * {@link Imap.onProgressInfo} callbacks, which report progress while it runs.
+   *
+   * The promise rejects with an Error if the call fails; the full log is in
+   * {@link Imap.lastErrorText}.
+   */
+  queryMbxAsync(criteria: string, bUid: boolean, msgSet: MessageSet): Promise<void>
+
+  /**
+   * Attempts to download `count` full messages beginning with sequence number `seqnum`.
+   *
+   * `failedSet` and `fetchedSet` are cleared before use. `failedSet` receives sequence numbers that
+   * failed or were not yet fetched, `fetchedSet` receives sequence numbers fetched successfully,
+   * and both sets have `MessageSet.HasUids` set to `false`. Downloaded messages are appended to the
+   * `EmailBundle` in `bundle`, which is not cleared.
+   *
+   * Sequence numbers beyond the end of the mailbox are added to `failedSet`. The method can return
+   * success even when `failedSet` is nonempty; success indicates that the requested range was
+   * processed, not that every sequence number existed.
+   *
+   * If a network failure occurs, messages already fetched remain in `bundle`, `fetchedSet` retains
+   * the successfully fetched sequence numbers, and `failedSet` contains the failed and
+   * not-yet-fetched sequence numbers. Processing stops and the connection must be considered
+   * unusable.
+   *
+   * This call blocks the JavaScript thread until Chilkat returns; from UI code prefer
+   * {@link Imap.fetchChunk2Async}.
+   *
+   * @throws Error if the call fails (the message names the reason); the full log is in
+   * {@link Imap.lastErrorText}.
+   */
+  fetchChunk2(seqnum: number, count: number, failedSet: MessageSet, fetchedSet: MessageSet, bundle: EmailBundle): void
+
+  /**
+   * Asynchronous form of {@link Imap.fetchChunk2}: the same call on a native worker thread,
+   * settling on the JavaScript thread. While it is pending, other calls on this object throw,
+   * except {@link Imap.abort} (which cancels it) and the {@link Imap.onPercentDone} /
+   * {@link Imap.onProgressInfo} callbacks, which report progress while it runs.
+   *
+   * The promise rejects with an Error if the call fails; the full log is in
+   * {@link Imap.lastErrorText}.
+   */
+  fetchChunk2Async(seqnum: number, count: number, failedSet: MessageSet, fetchedSet: MessageSet, bundle: EmailBundle): Promise<void>
+
+  /**
+   * Sends the IMAP `THREAD` command for the selected mailbox.
+   *
+   * `threadAlg` is the threading algorithm, commonly `ORDEREDSUBJECT` or `REFERENCES`.
+   * `searchCriteria` contains ordinary IMAP search criteria and is interpreted using {@link
+   * Imap.searchCharset}. If `bUid` is `true`, message identifiers in the result are UIDs;
+   * otherwise, they are sequence numbers.
+   *
+   * On success, `json` is completely replaced with the thread hierarchy. On failure, `json` is
+   * unchanged; there is no partial-success JSON result.
+   *
+   * The returned JSON has a top-level `threads` array. Each element represents one thread, and
+   * nested arrays encode parent/child relationships. For example:
+   *
+   * ```
+   * {"threads":[[1],[2],[3]]}
+   * ```
+   *
+   * The server must advertise the IMAP `THREAD` capability and support the selected algorithm.
+   *
+   * This call blocks the JavaScript thread until Chilkat returns; from UI code prefer
+   * {@link Imap.queryThreadAsync}.
+   *
+   * @throws Error if the call fails (the message names the reason); the full log is in
+   * {@link Imap.lastErrorText}.
+   */
+  queryThread(threadAlg: string, searchCriteria: string, bUid: boolean, json: JsonObject): void
+
+  /**
+   * Asynchronous form of {@link Imap.queryThread}: the same call on a native worker thread,
+   * settling on the JavaScript thread. While it is pending, other calls on this object throw,
+   * except {@link Imap.abort} (which cancels it) and the {@link Imap.onPercentDone} /
+   * {@link Imap.onProgressInfo} callbacks, which report progress while it runs.
+   *
+   * The promise rejects with an Error if the call fails; the full log is in
+   * {@link Imap.lastErrorText}.
+   */
+  queryThreadAsync(threadAlg: string, searchCriteria: string, bUid: boolean, json: JsonObject): Promise<void>
+
+  /**
+   * Adds the PKCS #12/PFX data in the `BinData` in `bd` as a source of certificates and private
+   * keys for S/MIME processing.
+   *
+   * `password` contains the PFX password. Call this method once for each additional source.
+   *
+   * @throws Error if the call fails (the message names the reason); the full log is in
+   * {@link Imap.lastErrorText}.
+   */
+  addPfxSourceBd(bd: BinData, password: string): void
+
+  /**
+   * Sends the raw IMAP command bytes in the `BinData` in `bdCmd` and stores the raw response bytes
+   * in `bdResp`.
+   *
+   * `bdCmd` contains the command without an IMAP command tag or trailing CRLF; Chilkat supplies
+   * both. `bdResp` is cleared and replaced with the response.
+   *
+   * Use raw commands only for rare server extensions that are not otherwise exposed by the API,
+   * have an expected one-line response, and do not change Imap object state such as the selected
+   * mailbox, message count, `UidNext`, or `UidValidity`. State-changing raw commands can leave
+   * cached properties inconsistent with the server.
+   *
+   * This call blocks the JavaScript thread until Chilkat returns; from UI code prefer
+   * {@link Imap.rawCommandBdAsync}.
+   *
+   * @throws Error if the call fails (the message names the reason); the full log is in
+   * {@link Imap.lastErrorText}.
+   */
+  rawCommandBd(bdCmd: BinData, bdResp: BinData): void
+
+  /**
+   * Asynchronous form of {@link Imap.rawCommandBd}: the same call on a native worker thread,
+   * settling on the JavaScript thread. While it is pending, other calls on this object throw,
+   * except {@link Imap.abort} (which cancels it) and the {@link Imap.onPercentDone} /
+   * {@link Imap.onProgressInfo} callbacks, which report progress while it runs.
+   *
+   * The promise rejects with an Error if the call fails; the full log is in
+   * {@link Imap.lastErrorText}.
+   */
+  rawCommandBdAsync(bdCmd: BinData, bdResp: BinData): Promise<void>
+
+  // ---- Events (ReactNativeGen_DESIGN.md §6) ----
+
+  /**
+   * Called with the percent completed (0..100) while a long-running method runs, when Chilkat
+   * can measure progress. Runs on the JavaScript thread, so it is only useful with the
+   * `...Async` methods (during a synchronous call the thread is busy and the events arrive
+   * after it returns). Assign `undefined` to remove.
+   */
+  onPercentDone?: (pctDone: number) => void
+
+  /**
+   * Called with a name/value pair of progress information while a long-running method runs
+   * (what is reported depends on the class and method). Runs on the JavaScript thread; see
+   * {@link Imap.onPercentDone}. Assign `undefined` to remove.
+   */
+  onProgressInfo?: (name: string, value: string) => void
+
+  /**
+   * Requests that the pending `...Async` call on this object stop at its next progress check.
+   * The promise then rejects with Chilkat's abort error. Chilkat checks at least every
+   * `heartbeatMs` milliseconds on the classes that have that property, so set it (e.g. 250)
+   * for a responsive cancel. Harmless when nothing is pending.
+   */
+  abort(): void
+}