@chilkat/react-native 11.6.1

package/src/specs/Mime.nitro.ts

@@ -0,0 +1,1745 @@
+// 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 { JsonObject } from './JsonObject.nitro'
+import type { PrivateKey } from './PrivateKey.nitro'
+import type { StringBuilder } from './StringBuilder.nitro'
+import type { StringTable } from './StringTable.nitro'
+import type { XmlCertVault } from './XmlCertVault.nitro'
+
+/**
+ * Build, parse, modify, serialize, secure, and inspect MIME and S/MIME data.
+ *
+ * `Mime` provides low-level MIME and S/MIME handling for
+ * applications that need direct control over MIME structure, headers, body
+ * content, encodings, multipart relationships, attachments, and PKCS7/CMS
+ * security layers. It can load, create, inspect, modify, serialize, and save
+ * MIME messages; build multipart structures; manage headers and content-transfer
+ * encodings; extract attachments; convert MIME to and from XML; and sign,
+ * verify, encrypt, decrypt, or unwrap S/MIME content.
+ *
+ * **Create and load MIME**
+ *
+ * Build MIME content programmatically or load existing MIME from strings,
+ * files, byte data, or other application sources.
+ *
+ * **Headers and body content**
+ *
+ * Read, add, replace, or remove MIME headers, set body content, and control
+ * content types, charsets, and transfer encodings.
+ *
+ * **Multipart structures**
+ *
+ * Create and inspect multipart MIME trees such as mixed, alternative,
+ * related, signed, encrypted, and nested MIME structures.
+ *
+ * **Attachments and parts**
+ *
+ * Add, locate, extract, remove, or inspect MIME parts and attachments,
+ * including filenames and encoded body data.
+ *
+ * **S/MIME security**
+ *
+ * Sign, verify, encrypt, decrypt, unwrap, and inspect PKCS7/CMS S/MIME
+ * layers using certificates and private keys.
+ *
+ * **Serialization and XML**
+ *
+ * Emit MIME text, save MIME to files, or convert MIME to and from XML for
+ * structured inspection, transformation, or storage.
+ *
+ * **Common pattern:**
+ * Use `Mime` when an application needs low-level control
+ * over MIME parts, headers, encodings, multipart layout, or S/MIME security.
+ * For ordinary email composition and message-level operations, use
+ * `Email`; use `Mime` when you need to work
+ * closer to the raw MIME structure.
+ *
+ * **Initial state:** A new `Mime` object has no headers or child parts. Its string serialization
+ * consists only of the blank header/body separator (`CRLF CRLF`) until content is added.
+ *
+ * **MIME parsing is semantic, not byte-preserving.** Loading and reserializing can unfold headers,
+ * normalize parameter quoting and transfer encodings, use CRLF for generated headers and multipart
+ * framing, and discard multipart preamble or epilogue text. Use byte-oriented methods such as
+ * {@link Mime.loadMimeBd} and {@link Mime.getMimeBd} when arbitrary 8-bit bytes or embedded NUL
+ * bytes must be preserved.
+ *
+ * For an extended overview, see
+ * [Mime Class Overview](https://www.chilkatsoft.com/mime_class_overview.asp).
+ *
+ * Each `Mime` 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 Mime()`.
+ */
+export interface Mime 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
+
+  /**
+   * Gets or sets the raw boundary token used by a multipart MIME entity. Do not include surrounding
+   * quotation marks.
+   *
+   * ```
+   * Content-Type: multipart/mixed; boundary="example-boundary"
+   * ```
+   *
+   * For this example, `Boundary` is `example-boundary`. Chilkat automatically quotes the parameter
+   * when the token contains characters such as spaces or semicolons.
+   *
+   * **Normally automatic.** Methods such as {@link Mime.newMultipartMixed}, {@link
+   * Mime.newMultipartAlternative}, and {@link Mime.newMultipartRelated} generate a nonempty
+   * boundary.
+   *
+   * **Caller-supplied boundaries are not validated.** Chilkat does not detect collisions with body
+   * text. An empty value is permitted but produces invalid multipart delimiters, and supplying
+   * quotation marks as part of the property value causes those quotation marks to become part of
+   * the boundary. The property can also be set on a nonmultipart entity, where it is simply added
+   * as a `Content-Type` parameter.
+   */
+  boundary: string
+
+  /**
+   * Gets or sets the `charset` parameter of the `Content-Type` header field.
+   *
+   * ```
+   * Content-Type: text/plain; charset=utf-8
+   * ```
+   *
+   * Changing this property preserves the media type and other parameters. Setting it when no
+   * `Content-Type` exists creates a `Content-Type` field, although the media type remains empty
+   * until {@link Mime.contentType} is set.
+   *
+   * **Charset versus transfer encoding.** The charset identifies how text characters are
+   * represented as bytes. {@link Mime.encoding} controls the MIME transport representation of those
+   * bytes.
+   *
+   * **Empty-string behavior.** Setting `Charset` to an empty string does not remove the parameter.
+   * It selects the platform default ANSI charset; on Windows this is typically `windows-1252`.
+   */
+  charset: string
+
+  /**
+   * Gets or sets the MIME media type of the current part, excluding all parameters. Supply a value
+   * such as `text/plain`, `text/html`, `application/pdf`, or `multipart/mixed`; do not include
+   * `charset`, `boundary`, or other parameters in this property.
+   *
+   * Changing the media type preserves the existing `charset` and unrecognized parameters, but may
+   * remove parameters that are specific to the previous media type, such as `format=flowed`.
+   * Setting an empty string leaves an empty media type and can therefore produce an invalid-looking
+   * header if other parameters remain.
+   *
+   * **Classification methods use this value.** Methods such as {@link Mime.isText}, {@link
+   * Mime.isImage}, and {@link Mime.isMultipart} classify the media type stored here. Parameters
+   * must be set through their dedicated properties or header attributes, not appended to
+   * `ContentType`.
+   */
+  contentType: string
+
+  /**
+   * Returns the current local date and time formatted as an Internet message date, including the
+   * numeric UTC offset. For example:
+   *
+   * ```
+   * Fri, 21 Nov 1997 09:55:06 -0600
+   * ```
+   *
+   * This property is read-only.
+   */
+  readonly currentDateTime: string
+
+  /**
+   * Gets or sets the disposition value from the `Content-Disposition` header field, excluding
+   * parameters such as `filename`.
+   *
+   * ```
+   * Content-Disposition: attachment; filename="report.pdf"
+   * ```
+   *
+   * Changing this property preserves an existing `filename` parameter. Typical values are
+   * `attachment` and `inline`.
+   */
+  disposition: string
+
+  /**
+   * Gets or sets the value of the `Content-Transfer-Encoding` header field for the current part.
+   * Common values include `base64`, `quoted-printable`, `7bit`, `8bit`, and `binary`.
+   *
+   * **Transfer encoding is not compression.** It determines how the body bytes are represented in
+   * serialized MIME. {@link Mime.getBodyEncoded} returns the transfer-encoded form, while {@link
+   * Mime.getBodyBd}, `GetBodyBinary`, and {@link Mime.saveBody} return or save decoded bytes.
+   */
+  encoding: string
+
+  /**
+   * Gets or sets the `filename` parameter of the `Content-Disposition` header field. The value is a
+   * receiver-facing filename, not a local filesystem path.
+   *
+   * Changing this property preserves the disposition value but removes other `Content-Disposition`
+   * parameters such as `size`. Setting an empty string removes the `filename` parameter.
+   *
+   * **International filenames.** When setting a non-ASCII filename, Chilkat emits an RFC 2047
+   * encoded-word in `filename=`. When reading a header containing both `filename=` and
+   * `filename*=`, this property returns `filename=`. Use {@link Mime.getHeaderFieldAttribute} to
+   * retrieve the raw `filename*` value.
+   */
+  filename: string
+
+  /**
+   * Gets or sets the `micalg` parameter of a `multipart/signed` `Content-Type` header field.
+   *
+   * ```
+   * Content-Type: multipart/signed;
+   *   protocol="application/pkcs7-signature";
+   *   micalg=sha-256;
+   *   boundary="example-boundary"
+   * ```
+   *
+   * The parameter advertises the message-digest algorithm used by the detached signature.
+   *
+   * **SigningHashAlg is authoritative.** When a detached signature is created, {@link
+   * Mime.signingHashAlg} selects the digest and Chilkat replaces any conflicting `Micalg` value
+   * with the corresponding MIME token, such as `sha-1`, `sha-256`, `sha-384`, or `sha-512`. Setting
+   * `Micalg` alone does not select the cryptographic digest.
+   */
+  micalg: string
+
+  /**
+   * Gets or sets the `name` parameter of the `Content-Type` header field. For attachments, {@link
+   * Mime.filename} is generally the primary receiver-facing name.
+   *
+   * Setting a non-ASCII value causes Chilkat to emit an RFC 2047 encoded-word in the `name=`
+   * parameter. Setting this property when no media type exists creates a `Content-Type` field with
+   * an empty media type.
+   */
+  nameParam: string
+
+  /**
+   * Returns the number of header-field occurrences in the current part. Duplicate names count
+   * separately and retain their order. Valid indexes range from `0` through `NumHeaderFields - 1`
+   * for use with {@link Mime.getHeaderFieldName} and {@link Mime.getHeaderFieldValue}.
+   *
+   * During MIME parsing, duplicate ordinary fields are retained. Duplicate `Content-Type` fields
+   * are collapsed, with the last value taking effect.
+   *
+   * This property is read-only.
+   */
+  readonly numHeaderFields: number
+
+  /**
+   * Returns the number of direct child parts. It does not include deeper descendants. Iterate from
+   * `0` through `NumParts - 1` and call {@link Mime.partAt} to traverse the tree.
+   *
+   * The object returned by `PartAt` provides live access to the stored child. Modifying that
+   * returned object modifies the parent MIME tree.
+   *
+   * This property is read-only.
+   */
+  readonly numParts: number
+
+  /**
+   * Returns the number of signer certificates currently recorded by the most recent S/MIME signing,
+   * signature-verification, or security-unwrapping operation. A new object returns `0`. A
+   * single-certificate signing method records `1`; {@link Mime.verify} and {@link
+   * Mime.unwrapSecurity} replace the count with the signer results from that operation.
+   *
+   * A failed call to {@link Mime.verify} clears the signer results and sets this property to `0`.
+   * Use {@link Mime.lastSignerCert} with a zero-based index to retrieve a recorded signer
+   * certificate.
+   *
+   * This property is read-only.
+   */
+  readonly numSignerCerts: number
+
+  /**
+   * Gets or sets the symmetric content-encryption algorithm used when creating CMS/PKCS #7
+   * encrypted MIME. Supported input values are `aes`, `aes-gcm`, `des`, `3des`, and `rc2`. The
+   * default is `aes`. The `aes-gcm` option was added in version 10.0.0.
+   *
+   * The getter returns normalized names: after setting `aes-gcm` it returns `aes`, and after
+   * setting `3des` it returns `des`. The generated CMS data nevertheless uses AES-GCM or 3DES-CBC
+   * respectively.
+   *
+   * **Hybrid encryption.** S/MIME encrypts the MIME content with a symmetric content-encryption
+   * key. The recipient certificate then protects that content-encryption key. This property selects
+   * the symmetric algorithm; {@link Mime.pkcs7KeyLength} selects its key length.
+   */
+  pkcs7CryptAlg: string
+
+  /**
+   * Gets or sets the content-encryption key length, in bits, used when creating CMS/PKCS #7
+   * encrypted MIME. The default is `128`.
+   *
+   * Because this property may be set before {@link Mime.pkcs7CryptAlg}, the setter accepts the
+   * union of key lengths that can be valid for any supported symmetric algorithm: `40`, `56`, `64`,
+   * `128`, `192`, and `256`. A value outside this set is rejected and the previous value is
+   * retained.
+   *
+   * AlgorithmNormal key lengths
+   *
+   * | `aes` or `aes-gcm` |  | `128`, `192`, or `256` |
+   *
+   * | `3des` |  | `192` |
+   *
+   * | `des` |  | `40` |
+   *
+   * | `rc2` |  | `40`, `56`, `64`, or `128` |
+   *
+   * **Set both properties before encrypting.** The property setter rejects only lengths that cannot
+   * be valid for any supported algorithm. Applications should select the algorithm and its
+   * appropriate key length before calling {@link Mime.encrypt} or {@link Mime.encryptN}.
+   */
+  pkcs7KeyLength: number
+
+  /**
+   * Gets or sets the `protocol` parameter of the `Content-Type` header field. This parameter is
+   * commonly used by `multipart/signed` to identify the media type of the detached signature part.
+   *
+   * ```
+   * Content-Type: multipart/signed;
+   *   protocol="application/pkcs7-signature";
+   *   micalg=sha-256;
+   *   boundary="example-boundary"
+   * ```
+   *
+   * For this example, `Protocol` is `application/pkcs7-signature`.
+   */
+  protocol: string
+
+  /**
+   * Gets or sets the message-digest algorithm used when creating CMS/PKCS #7 signatures. The
+   * default is `sha256`. Supported values are `sha1`, `sha256`, `sha384`, `sha512`, `md5`, and
+   * `md2`. Names are case-insensitive and are returned in lowercase.
+   *
+   * An empty or unrecognized value selects `sha1`. This property controls signature creation only
+   * and is not changed when a signature is verified. After verification, call {@link
+   * Mime.getLastJsonData} to inspect the digest algorithm found in the signed data.
+   *
+   * **Security guidance.** Use a SHA-2 algorithm such as `sha256` unless interoperability with a
+   * legacy system requires otherwise. MD2, MD5, and SHA-1 are retained for compatibility with older
+   * signed messages. Because invalid input falls back to SHA-1, applications should set this
+   * property to a known supported value.
+   */
+  signingHashAlg: string
+
+  /**
+   * Controls whether {@link Mime.unwrapSecurity} adds informative header fields describing the
+   * security layers removed. The default is `true`.
+   *
+   * HeaderExample value
+   *
+   * | `X-NumPartsSigned` |  | `1` |
+   *
+   * | `X-SignaturesValid` |  | `yes` |
+   *
+   * | `X-NumPartsEncrypted` |  | `1` |
+   *
+   * | `X-Decrypted` |  | `yes` |
+   *
+   * Set to `false` when the application requires the unwrapped MIME without these additional status
+   * headers.
+   */
+  unwrapExtras: boolean
+
+  /**
+   * Controls whether Chilkat uses the conventional multipart preamble text `This is a multi-part
+   * message in MIME format.` when serializing a multipart entity. The default is `false`. The
+   * preamble is meaningful only when the multipart has content and is ignored by MIME-aware
+   * readers.
+   */
+  useMmDescription: boolean
+
+  /**
+   * Controls whether newly created S/MIME media types use the historical `x-pkcs7` names.
+   *
+   * ValueGenerated media types
+   *
+   * | `true` (default) |  | `application/x-pkcs7-mime` and `application/x-pkcs7-signature` |
+   *
+   * | `false` |  | `application/pkcs7-mime` and `application/pkcs7-signature` |
+   *
+   * For detached signatures, the selected signature media type is used both for the outer
+   * `protocol` parameter and for the signature part. For opaque signed or encrypted MIME, it
+   * controls the `application/...pkcs7-mime` content type.
+   *
+   * **Interoperability.** The `x-` forms are widely encountered in existing S/MIME messages.
+   * Chilkat recognizes both naming forms.
+   */
+  useXPkcs7: boolean
+
+  /**
+   * Gets or sets the RSA signature scheme used when creating CMS/PKCS #7 signed MIME. The default
+   * and normalized PKCS #1 v1.5 value is `PKCS1-V1_5`. Set the property to `RSASSA-PSS` or `pss` to
+   * use RSASSA-PSS; the getter returns `RSASSA-PSS`.
+   *
+   * An empty or unrecognized value selects `PKCS1-V1_5`. This setting applies only when the signing
+   * private key is RSA. It does not select the signature scheme for EC or DSA keys. The property
+   * controls signature creation and is not updated during verification; use {@link
+   * Mime.getLastJsonData} to inspect a verified signature.
+   */
+  signingAlg: string
+
+  /**
+   * Gets or sets the hash algorithm used by RSAES-OAEP when encrypting the CMS content-encryption
+   * key. Supported values are `sha1`, `sha256`, `sha384`, and `sha512`. The default is `sha256`. An
+   * empty or unrecognized value leaves the current valid setting unchanged.
+   *
+   * This property is used only when {@link Mime.oaepPadding} is `true`. It is independent of {@link
+   * Mime.oaepMgfHash}; for example, OAEP may use SHA-256 while MGF1 uses SHA-1.
+   */
+  oaepHash: string
+
+  /**
+   * Selects the RSA key-transport padding used when creating encrypted MIME. The default is
+   * `false`, which uses RSAES-PKCS1-v1_5. Set to `true` to use RSAES-OAEP.
+   *
+   * **Scope.** This setting protects the symmetric content-encryption key for an RSA recipient. It
+   * does not change the symmetric content algorithm selected by {@link Mime.pkcs7CryptAlg}.
+   */
+  oaepPadding: boolean
+
+  /**
+   * Gets or sets the hash algorithm used by the MGF1 mask generation function within RSAES-OAEP.
+   * Supported values are `sha1`, `sha256`, `sha384`, and `sha512`. The default is `sha256`. An
+   * empty or unrecognized value leaves the current valid setting unchanged.
+   *
+   * This property is used only when {@link Mime.oaepPadding} is `true` and is independent of {@link
+   * Mime.oaepHash}.
+   */
+  oaepMgfHash: string
+
+  /**
+   * Gets or sets a JSON string containing advanced CMS/PKCS #7 signing and validation options. The
+   * default is an empty string, which selects normal behavior. A valid empty JSON object may also
+   * be supplied as `{}`.
+   *
+   * Unknown JSON members are retained but ignored. Malformed JSON is normalized to `{}`. This
+   * property is intended for specialized interoperability requirements; applications should leave
+   * it empty unless a documented option is specifically needed.
+   */
+  cmsOptions: string
+
+  /**
+   * Gets or sets a semicolon-delimited or implementation-specific option string used for uncommon
+   * compatibility requirements. The default is the empty string, and normal applications should
+   * leave it empty. Options placed here may be version-specific and should be used only when
+   * directed by Chilkat documentation or support.
+   */
+  uncommonOptions: string
+
+  /**
+   * Returns the number of recipient or decryption certificates currently recorded by the most
+   * recent S/MIME encryption, decryption, or security-unwrapping operation. A new object returns
+   * `0`. A successful single-recipient {@link Mime.encrypt} records `1`, and successful decryption
+   * records the certificate whose private key was used.
+   *
+   * Use {@link Mime.lastDecryptCert} with a zero-based index to retrieve a recorded certificate.
+   * This is a result count; it is not the number of PFX sources or decryption certificates
+   * configured on the object.
+   *
+   * This property is read-only.
+   */
+  readonly numDecryptCerts: number
+
+  // ---- Methods ----
+
+  /**
+   * Computes the byte length of the current entity's serialized MIME body and adds or updates its
+   * `Content-Length` header. The count is based on the transfer-encoded serialized body, not the
+   * decoded payload.
+   *
+   * For a multipart entity, the count includes boundary delimiter lines, child headers, child
+   * bodies, and the closing boundary. Only the current entity's header is updated; child parts do
+   * not receive `Content-Length` fields. Repeated calls recompute the value and leave a single
+   * header occurrence.
+   */
+  addContentLength(): void
+
+  /**
+   * Adds `cert` to the internal collection of certificates available for S/MIME decryption. The
+   * certificate must have access to its corresponding private key. Call this method once for each
+   * candidate certificate.
+   *
+   * The collection is searched by {@link Mime.decrypt} and {@link Mime.unwrapSecurity}. Other ways
+   * to provide decryption credentials include {@link Mime.addPfxSourceFile}, {@link
+   * Mime.addPfxSourceBd}, and {@link Mime.useCertVault}.
+   *
+   * @throws Error if the call fails (the message names the reason); the full log is in
+   * {@link Mime.lastErrorText}.
+   */
+  addDecryptCert(cert: Cert): void
+
+  /**
+   * Creates an S/MIME detached signature using `cert`. The certificate itself must have access to
+   * its private key. On success, the current object becomes a `multipart/signed` entity with two
+   * direct children:
+   *
+   * PartContents
+   *
+   * | First |  | The original MIME entity being signed. |
+   *
+   * | Second |  | The CMS/PKCS #7 signature data, normally named `smime.p7s`. |
+   *
+   * {@link Mime.signingHashAlg} selects the digest and generated `micalg` parameter. For RSA keys,
+   * {@link Mime.signingAlg} selects PKCS #1 v1.5 or RSASSA-PSS. {@link Mime.useXPkcs7} selects the
+   * signature media-type spelling.
+   *
+   * **Private-key requirement.** Adding a matching PFX source does not supply a missing signing key
+   * for a public-only `Cert`. Load the private key into `cert` or use {@link
+   * Mime.addDetachedSignaturePk}.
+   *
+   * **Signing an already signed MIME.** Calling this method again creates a new outer
+   * `multipart/signed` layer. It does not add another signer to the existing CMS signer-information
+   * set.
+   *
+   * @throws Error if the call fails (the message names the reason); the full log is in
+   * {@link Mime.lastErrorText}.
+   */
+  addDetachedSignature(cert: Cert): void
+
+  /**
+   * Creates the same detached `multipart/signed` structure as {@link Mime.addDetachedSignature}.
+   * `cert` is the signing certificate and must have access to its private key.
+   *
+   * `transferHeaderFields`Header placement
+   *
+   * | `false` | | Existing message header fields, such as `Subject` and `From`, remain on the first
+   * signed content part. The new outer multipart has no copies of those fields. |
+   *
+   * | `true` | | Existing message header fields are moved to the new outer `multipart/signed`
+   * entity and removed from the first content part. |
+   *
+   * @throws Error if the call fails (the message names the reason); the full log is in
+   * {@link Mime.lastErrorText}.
+   */
+  addDetachedSignature2(cert: Cert, transferHeaderFields: boolean): void
+
+  /**
+   * Creates a detached S/MIME signature using `cert` as the signer certificate and `privateKey` as
+   * its associated private key. Use this method when the certificate and private key are supplied
+   * separately.
+   *
+   * On success, the current object becomes the same two-part `multipart/signed` structure described
+   * by {@link Mime.addDetachedSignature}. {@link Mime.signingHashAlg}, {@link Mime.signingAlg}, and
+   * {@link Mime.useXPkcs7} control the generated signature.
+   *
+   * @throws Error if the call fails (the message names the reason); the full log is in
+   * {@link Mime.lastErrorText}.
+   */
+  addDetachedSignaturePk(cert: Cert, privateKey: PrivateKey): void
+
+  /**
+   * Creates a detached S/MIME signature using the certificate in `cert` and the corresponding
+   * private key in `privateKey`. `transferHeaderFields` controls placement of the existing message
+   * header fields:
+   *
+   * `transferHeaderFields`Header placement
+   *
+   * | `false` |  | Headers remain on the first signed content part. |
+   *
+   * | `true` | | Headers are moved to the new outer `multipart/signed` entity and removed from the
+   * first content part. |
+   *
+   * This is the separate-private-key counterpart of {@link Mime.addDetachedSignature2}.
+   *
+   * @throws Error if the call fails (the message names the reason); the full log is in
+   * {@link Mime.lastErrorText}.
+   */
+  addDetachedSignaturePk2(cert: Cert, privateKey: PrivateKey, transferHeaderFields: boolean): void
+
+  /**
+   * Adds `cert` to the internal recipient-certificate list used by {@link Mime.encryptN}. Call this
+   * method once for each intended recipient. Encryption uses the public key in each certificate, so
+   * recipient private keys are not required at encryption time.
+   *
+   * Call {@link Mime.clearEncryptCerts} to empty the list.
+   *
+   * @throws Error if the call fails (the message names the reason); the full log is in
+   * {@link Mime.lastErrorText}.
+   */
+  addEncryptCert(cert: Cert): void
+
+  /**
+   * Appends a new header field named by `name` with the value in `value`. Existing fields having
+   * the same case-insensitive name are preserved. An empty `value` creates a legal empty-valued
+   * field.
+   *
+   * Chilkat converts spaces in a header name to hyphens, removes embedded CR and LF characters from
+   * the value to prevent header injection, and folds long values when serializing.
+   *
+   * **Replacing versus appending.** Use {@link Mime.setHeaderField} to remove all existing
+   * occurrences and set one replacement value.
+   *
+   * @throws Error if the call fails (the message names the reason); the full log is in
+   * {@link Mime.lastErrorText}.
+   */
+  addHeaderField(name: string, value: string): void
+
+  /**
+   * Adds the PFX/P12 file at the local filesystem path in `pfxFilePath` to the internal collection
+   * of credential sources used by later S/MIME decryption operations. `password` is the password
+   * protecting the file. Call the method once for each PFX source that should be searched.
+   *
+   * The source remains configured across subsequent `LoadMime` calls and repeated decryptions.
+   * Chilkat continues searching after a PFX that does not contain the required recipient key.
+   *
+   * **Not a signing-key fallback.** Adding a PFX source does not make a public-only certificate
+   * usable by the signing methods. The signing certificate itself must have its private key, or the
+   * private key must be supplied explicitly by a method whose name ends in `Pk`.
+   *
+   * @throws Error if the call fails (the message names the reason); the full log is in
+   * {@link Mime.lastErrorText}.
+   */
+  addPfxSourceFile(pfxFilePath: string, password: string): void
+
+  /**
+   * Appends a copy of `mime` as the last direct child. Chilkat does not retain a reference to
+   * `mime`, so later changes to `mime` do not affect the appended part. The same source object may
+   * be appended more than once.
+   *
+   * If the current object is not multipart, it is converted to `multipart/mixed`. The complete
+   * original entity, including its existing headers and body, becomes part 0; the copy of `mime`
+   * becomes part 1. The new outer entity contains its generated multipart `Content-Type`.
+   *
+   * **Editing an appended child.** Retrieve it with {@link Mime.partAt}. The object returned by
+   * `PartAt` is a live child, unlike the copied input to this method.
+   *
+   * @throws Error if the call fails (the message names the reason); the full log is in
+   * {@link Mime.lastErrorText}.
+   */
+  appendPart(mime: Mime): void
+
+  /**
+   * Reads the local file at `filename`, creates an attachment part, and appends it.
+   * Filename-extension matching is case-insensitive.
+   *
+   * File kindGenerated headers
+   *
+   * | `.txt` | | `text/plain; charset=windows-1252; format=flowed`, `7bit`, attachment filename and
+   * name |
+   *
+   * | Known binary type, such as `.PNG` | | Inferred media type such as `image/png`, `base64`,
+   * attachment filename and name |
+   *
+   * | Unknown extension |  | `application/octet-stream`, `base64`, attachment filename and name |
+   *
+   * If the current object is not multipart, the same conversion described by {@link
+   * Mime.appendPart} occurs. Calling this method on a new empty object therefore creates an empty
+   * part 0 and the file attachment as part 1.
+   *
+   * @throws Error if the call fails (the message names the reason); the full log is in
+   * {@link Mime.lastErrorText}.
+   */
+  appendPartFromFile(filename: string): void
+
+  /**
+   * Parses the current part's decoded body as ASN.1 DER and returns an XML representation of the
+   * ASN.1 structure. This is primarily useful for inspecting CMS/PKCS #7 bodies such as
+   * `application/pkcs7-mime` or `application/x-pkcs7-mime`.
+   *
+   * ```
+   * Content-Type: application/pkcs7-mime; smime-type=signed-data
+   * Content-Transfer-Encoding: base64
+   *
+   * MII...
+   * ```
+   *
+   * **Diagnostic conversion.** The returned XML exposes ASN.1 tags, object identifiers, and values
+   * for inspection. It is not the MIME-to-XML representation returned by {@link Mime.getXml}.
+   *
+   * @throws Error if the call fails (the message names the reason); the full log is in
+   * {@link Mime.lastErrorText}.
+   */
+  asnBodyToXml(): string
+
+  /**
+   * Clears the internal recipient-certificate list populated by {@link Mime.addEncryptCert}. A
+   * subsequent call to {@link Mime.encryptN} requires certificates to be added again.
+   */
+  clearEncryptCerts(): void
+
+  /**
+   * Returns `true` if the currently visible MIME tree contains a CMS/PKCS #7 encrypted entity. Both
+   * `application/pkcs7-mime` and `application/x-pkcs7-mime` forms are recognized.
+   *
+   * **Encrypted layers hide their contents.** This method examines the MIME structure as it
+   * currently exists. It cannot report signed or encrypted entities inside ciphertext until the
+   * enclosing encrypted layer is successfully removed.
+   */
+  containsEncryptedParts(): boolean
+
+  /**
+   * Returns `true` if the currently visible MIME tree contains a complete detached or opaque
+   * CMS/PKCS #7 signed entity. A standalone `application/pkcs7-signature` or
+   * `application/x-pkcs7-signature` leaf part is not by itself classified as a signed message.
+   *
+   * **Encrypted layers hide their contents.** A signature nested inside encrypted data is not
+   * visible until the encrypted layer is removed. After a signature is successfully verified and
+   * unwrapped, this method returns `false` because the signed wrapper no longer exists.
+   */
+  containsSignedParts(): boolean
+
+  /**
+   * Recursively converts every part whose `Content-Transfer-Encoding` is `8bit` or `binary` to
+   * `base64`. Both the child object's `Encoding` property and the serialized header are updated.
+   * Parts using `7bit` or another encoding are unchanged.
+   */
+  convert8Bit(): void
+
+  /**
+   * Wraps the current entity in a new outer `multipart/alternative` entity. The original entity
+   * becomes the first and initially only child.
+   *
+   * The new outer entity retains message-level and custom headers such as `MIME-Version`, `Date`,
+   * `Subject`, `From`, `To`, `Content-ID`, `Content-Location`, and custom fields. The original
+   * `Content-Type`, `Content-Transfer-Encoding`, `Content-Disposition`, and body move to the first
+   * child. An existing `charset` parameter is retained on the new multipart `Content-Type`. Calling
+   * the method again wraps the existing multipart in another multipart layer; the operation is not
+   * idempotent.
+   *
+   * **Alternative ordering.** Additional representations can be appended with {@link
+   * Mime.appendPart}. Conventionally, alternatives are ordered from least rich to most rich, such
+   * as `text/plain` followed by `text/html`.
+   *
+   * @throws Error if the call fails (the message names the reason); the full log is in
+   * {@link Mime.lastErrorText}.
+   */
+  convertToMultipartAlt(): void
+
+  /**
+   * Wraps the current entity in a new outer `multipart/mixed` entity. The original entity becomes
+   * the first and initially only child.
+   *
+   * The new outer entity retains message-level and custom headers such as `MIME-Version`, `Date`,
+   * `Subject`, `From`, `To`, `Content-ID`, `Content-Location`, and custom fields. The original
+   * `Content-Type`, `Content-Transfer-Encoding`, `Content-Disposition`, and body move to the first
+   * child. An existing `charset` parameter is retained on the new multipart `Content-Type`. Calling
+   * the method again wraps the existing multipart in another multipart layer; the operation is not
+   * idempotent.
+   *
+   * @throws Error if the call fails (the message names the reason); the full log is in
+   * {@link Mime.lastErrorText}.
+   */
+  convertToMultipartMixed(): void
+
+  /**
+   * Creates an opaque (attached) S/MIME signature using `cert`. The certificate itself must have
+   * access to its private key. On success, the current MIME entity is replaced by CMS/PKCS #7
+   * `signed-data` containing both the original MIME bytes and the signature.
+   *
+   * The result has no MIME child parts, uses Base64 content-transfer encoding, and has an
+   * `application/x-pkcs7-mime` or `application/pkcs7-mime` content type according to {@link
+   * Mime.useXPkcs7}. {@link Mime.signingHashAlg} and, for RSA keys, {@link Mime.signingAlg} select
+   * the signing algorithms.
+   *
+   * This differs from {@link Mime.addDetachedSignature}, which creates a visible `multipart/signed`
+   * wrapper with a separate signature part.
+   *
+   * @throws Error if the call fails (the message names the reason); the full log is in
+   * {@link Mime.lastErrorText}.
+   */
+  convertToSigned(cert: Cert): void
+
+  /**
+   * Creates an opaque (attached) S/MIME signature using `cert` as the signer certificate and
+   * `privateKey` as its associated private key. Use this method when the certificate and private
+   * key are supplied separately.
+   *
+   * The resulting CMS/PKCS #7 `signed-data` contains the original MIME entity and its signature,
+   * has no MIME child parts, and uses Base64 content-transfer encoding. For a detached
+   * `multipart/signed` result, use {@link Mime.addDetachedSignaturePk}.
+   *
+   * @throws Error if the call fails (the message names the reason); the full log is in
+   * {@link Mime.lastErrorText}.
+   */
+  convertToSignedPk(cert: Cert, privateKey: PrivateKey): void
+
+  /**
+   * Decrypts the current CMS/PKCS #7 encrypted MIME entity and replaces it with the recovered MIME
+   * content. Chilkat identifies the intended recipient from the CMS recipient information and
+   * searches configured credential sources for the matching certificate and private key.
+   *
+   * SourceHow it is supplied
+   *
+   * | Explicit certificate |  | {@link Mime.addDecryptCert} or {@link Mime.decryptUsingCert} |
+   *
+   * | PFX/P12 | | {@link Mime.addPfxSourceFile}, {@link Mime.addPfxSourceBd}, or a
+   * `DecryptUsingPfx...` method |
+   *
+   * | Certificate vault |  | {@link Mime.useCertVault} |
+   *
+   * | Platform certificate store | | Windows certificate stores and the macOS Keychain are searched
+   * automatically where supported |
+   *
+   * On success, {@link Mime.numDecryptCerts} and {@link Mime.lastDecryptCert} identify the
+   * certificate used, and {@link Mime.getLastJsonData} reports the content-encryption algorithm and
+   * key size. On failure, the encrypted MIME remains unchanged.
+   *
+   * **Serialization after decryption.** The recovered MIME content is restored semantically, but
+   * its generated serialization is not guaranteed to be byte-for-byte identical to the bytes that
+   * existed before encryption.
+   *
+   * @throws Error if the call fails (the message names the reason); the full log is in
+   * {@link Mime.lastErrorText}.
+   */
+  decrypt(): void
+
+  /**
+   * Decrypts the current CMS/PKCS #7 encrypted MIME entity using the certificate in `cert` and its
+   * associated private key in `privateKey`. On success, the encrypted wrapper is replaced by the
+   * recovered MIME content, the decryption certificate is available through {@link
+   * Mime.lastDecryptCert}, and operation details are available through {@link
+   * Mime.getLastJsonData}. On failure, the encrypted MIME remains unchanged.
+   *
+   * Use this method when the certificate and private key are stored separately. Use {@link
+   * Mime.decrypt} when Chilkat should locate the credential from configured sources.
+   *
+   * @throws Error if the call fails (the message names the reason); the full log is in
+   * {@link Mime.lastErrorText}.
+   */
+  decrypt2(cert: Cert, privateKey: PrivateKey): void
+
+  /**
+   * Decrypts the current CMS/PKCS #7 encrypted MIME entity using `cert`. The certificate must have
+   * access to its corresponding private key; a public-only certificate is insufficient. On success,
+   * the encrypted wrapper is replaced by the recovered MIME content and `cert` is recorded in the
+   * decryption results. On failure, the encrypted MIME remains unchanged.
+   *
+   * @throws Error if the call fails (the message names the reason); the full log is in
+   * {@link Mime.lastErrorText}.
+   */
+  decryptUsingCert(cert: Cert): void
+
+  /**
+   * Decrypts the current CMS/PKCS #7 encrypted MIME entity using certificates and private keys from
+   * the PFX/P12 file at the local filesystem path in `pfxFilePath`. `pfxPassword` is the password
+   * protecting the file.
+   *
+   * On success, the encrypted wrapper is replaced by the recovered MIME content and the matching
+   * certificate is available through {@link Mime.lastDecryptCert}. {@link Mime.getLastJsonData} may
+   * include both CMS decryption details and information produced while reading the PFX. On failure,
+   * the encrypted MIME remains unchanged.
+   *
+   * @throws Error if the call fails (the message names the reason); the full log is in
+   * {@link Mime.lastErrorText}.
+   */
+  decryptUsingPfxFile(pfxFilePath: string, pfxPassword: string): void
+
+  /**
+   * Encrypts the current MIME entity for the recipient certificate in `cert` and replaces it with
+   * CMS/PKCS #7 encrypted S/MIME. `cert` must be RSA-based. Only the recipient's public key is
+   * needed to encrypt; the matching private key is required later to decrypt.
+   *
+   * The default content encryption is AES-128-CBC. {@link Mime.pkcs7CryptAlg} and {@link
+   * Mime.pkcs7KeyLength} select the symmetric algorithm and key length. By default,
+   * RSAES-PKCS1-v1_5 transports the content-encryption key; set {@link Mime.oaepPadding} to `true`
+   * to use RSAES-OAEP, with {@link Mime.oaepHash} and {@link Mime.oaepMgfHash} controlling its
+   * parameters.
+   *
+   * The generated MIME uses Base64 transfer encoding, the filename `smime.p7m`, and an
+   * `application/x-pkcs7-mime` or `application/pkcs7-mime` content type according to {@link
+   * Mime.useXPkcs7}. After encryption, {@link Mime.getDecryptCertInfo} can report the recipient
+   * identifiers stored in the CMS data. If encryption fails, the original MIME remains unchanged.
+   *
+   * @throws Error if the call fails (the message names the reason); the full log is in
+   * {@link Mime.lastErrorText}.
+   */
+  encrypt(cert: Cert): void
+
+  /**
+   * Encrypts the current MIME entity for every certificate previously added with {@link
+   * Mime.addEncryptCert}. Each recipient receives independently protected access to the same
+   * encrypted content.
+   *
+   * Add one certificate per intended recipient, call this method, and use {@link
+   * Mime.clearEncryptCerts} before preparing a different recipient set.
+   *
+   * @throws Error if the call fails (the message names the reason); the full log is in
+   * {@link Mime.lastErrorText}.
+   */
+  encryptN(): void
+
+  /**
+   * Returns the decoded body as text. Chilkat first decodes the `Content-Transfer-Encoding` and
+   * then interprets text according to the declared charset.
+   *
+   * **Use a byte-oriented getter for binary content.** A string result cannot reliably represent
+   * arbitrary binary bytes or embedded NUL bytes. Use {@link Mime.getBodyBd} or `GetBodyBinary` for
+   * binary payloads.
+   *
+   * @throws Error if the call fails (the message names the reason); the full log is in
+   * {@link Mime.lastErrorText}.
+   */
+  getBodyDecoded(): string
+
+  /**
+   * Returns the current part's transfer-encoded body text without decoding Base64 or
+   * quoted-printable. The returned value is Chilkat's normalized serialization of the body, not
+   * necessarily the exact text that appeared in the loaded MIME. For example, Base64 padding and
+   * line wrapping or quoted-printable spelling may be regenerated.
+   *
+   * @throws Error if the call fails (the message names the reason); the full log is in
+   * {@link Mime.lastErrorText}.
+   */
+  getBodyEncoded(): string
+
+  /**
+   * Returns the complete serialized body of the current MIME entity. For multipart MIME, this
+   * includes boundary delimiters, each child part's headers and body, and the closing boundary. The
+   * current entity's own header fields are not included.
+   *
+   * Use {@link Mime.getBodyDecoded} when the decoded payload of a single part is needed.
+   *
+   * @throws Error if the call fails (the message names the reason); the full log is in
+   * {@link Mime.lastErrorText}.
+   */
+  getEntireBody(): string
+
+  /**
+   * Returns the complete serialized header section of the current MIME entity. The body and any
+   * multipart child content are not included.
+   *
+   * @throws Error if the call fails (the message names the reason); the full log is in
+   * {@link Mime.lastErrorText}.
+   */
+  getEntireHead(): string
+
+  /**
+   * Returns the value of the first header field whose name matches `fieldName` case-insensitively.
+   * Duplicate later occurrences are not combined. Returns null when no matching field exists.
+   *
+   * @throws Error if the call fails (the message names the reason); the full log is in
+   * {@link Mime.lastErrorText}.
+   */
+  getHeaderField(fieldName: string): string
+
+  /**
+   * Returns an attribute value parsed from the first header field named by `name`. Both the header
+   * name and `attrName` attribute name are matched case-insensitively. Surrounding quotation marks
+   * are removed, and semicolons inside a quoted value are handled as part of the value.
+   *
+   * Extended parameters such as `filename*=utf-8''r%C3%A9sum%C3%A9.txt` are returned in their raw
+   * encoded form; this method does not percent-decode or apply the declared charset. Returns null
+   * when the field or attribute is absent.
+   *
+   * @throws Error if the call fails (the message names the reason); the full log is in
+   * {@link Mime.lastErrorText}.
+   */
+  getHeaderFieldAttribute(name: string, attrName: string): string
+
+  /**
+   * Returns the name of the header-field occurrence at zero-based `index`. Header order and
+   * original casing are preserved for ordinary loaded headers. Use {@link Mime.numHeaderFields} to
+   * determine the valid range.
+   *
+   * @throws Error if the call fails (the message names the reason); the full log is in
+   * {@link Mime.lastErrorText}.
+   */
+  getHeaderFieldName(index: number): string
+
+  /**
+   * Returns the unfolded value of the header-field occurrence at zero-based `index`. Continuation
+   * lines are combined into a single value. Use {@link Mime.numHeaderFields} to determine the valid
+   * range.
+   *
+   * @throws Error if the call fails (the message names the reason); the full log is in
+   * {@link Mime.lastErrorText}.
+   */
+  getHeaderFieldValue(index: number): string
+
+  /**
+   * Serializes and returns the complete MIME entity, including headers, body, multipart boundaries,
+   * and all descendants.
+   *
+   * **Serialization is normalized.** The result is semantically equivalent MIME, not a
+   * byte-for-byte copy of loaded input. Chilkat can unfold headers, normalize parameter quoting and
+   * transfer encodings, discard multipart preamble and epilogue text, and generate CRLF for headers
+   * and multipart framing. Existing body line endings may not always be rewritten.
+   *
+   * @throws Error if the call fails (the message names the reason); the full log is in
+   * {@link Mime.lastErrorText}.
+   */
+  getMime(): string
+
+  /**
+   * Returns the CMS `signingTime` signed attribute for the signer at zero-based `index`, formatted
+   * as an RFC 822-style date string in GMT. For example:
+   *
+   * ```
+   * Wed, 29 Jul 2026 14:32:58 GMT
+   * ```
+   *
+   * Call {@link Mime.hasSignatureSigningTime} first because the attribute is optional. Use {@link
+   * Mime.numSignerCerts} for the signer count.
+   *
+   * **Signing time is not a trusted timestamp.** The CMS `signingTime` value is supplied by the
+   * signer. It is different from a timestamp token issued and signed by a trusted timestamp
+   * authority.
+   *
+   * @throws Error if the call fails (the message names the reason); the full log is in
+   * {@link Mime.lastErrorText}.
+   */
+  getSignatureSigningTimeStr(index: number): string
+
+  /**
+   * Converts the MIME tree to Chilkat's XML representation and returns it as a string. Header names
+   * become XML element names, structured header parameters become XML attributes, duplicate headers
+   * become repeated elements, multipart children are nested in `subpart` elements, and binary
+   * bodies are represented in an encoded textual form.
+   *
+   * **XML round-tripping is semantic.** Loading this XML reconstructs an equivalent MIME tree, but
+   * it is not byte-preserving and header names are normalized to lowercase.
+   *
+   * @throws Error if the call fails (the message names the reason); the full log is in
+   * {@link Mime.lastErrorText}.
+   */
+  getXml(): string
+
+  /**
+   * Returns `true` if the signer at zero-based `index` has a CMS `signingTime` signed attribute.
+   * Use {@link Mime.numSignerCerts} for the signer count and {@link
+   * Mime.getSignatureSigningTimeStr} to retrieve the value.
+   */
+  hasSignatureSigningTime(index: number): boolean
+
+  /**
+   * Returns `true` when {@link Mime.contentType} begins with `application/`. It returns `false` for
+   * an empty or malformed media type.
+   */
+  isApplicationData(): boolean
+
+  /**
+   * Returns `true` when the current part's disposition value is `attachment`, matched
+   * case-insensitively. Parameters such as `filename` do not affect the test. An `inline` part
+   * remains non-attachment even when it has a filename.
+   */
+  isAttachment(): boolean
+
+  /**
+   * Returns `true` when {@link Mime.contentType} begins with `audio/`.
+   */
+  isAudio(): boolean
+
+  /**
+   * Returns `true` when the current MIME entity is a CMS/PKCS #7 encrypted S/MIME wrapper. Both
+   * `application/pkcs7-mime` and `application/x-pkcs7-mime` forms are recognized. To search the
+   * visible MIME tree rather than only the current entity, use {@link Mime.containsEncryptedParts}.
+   */
+  isEncrypted(): boolean
+
+  /**
+   * Returns `true` when {@link Mime.contentType} is `text/html`. The `ContentType` property must
+   * contain only the media type; set parameters such as `charset` separately.
+   */
+  isHtml(): boolean
+
+  /**
+   * Returns `true` when {@link Mime.contentType} begins with `image/`, including values such as
+   * `image/svg+xml`.
+   */
+  isImage(): boolean
+
+  /**
+   * Returns `true` when {@link Mime.contentType} begins with `multipart/`.
+   */
+  isMultipart(): boolean
+
+  /**
+   * Returns `true` when {@link Mime.contentType} is `multipart/alternative`.
+   */
+  isMultipartAlternative(): boolean
+
+  /**
+   * Returns `true` when {@link Mime.contentType} is `multipart/mixed`.
+   */
+  isMultipartMixed(): boolean
+
+  /**
+   * Returns `true` when {@link Mime.contentType} is `multipart/related`.
+   */
+  isMultipartRelated(): boolean
+
+  /**
+   * Returns `true` when {@link Mime.contentType} is `text/plain`.
+   */
+  isPlainText(): boolean
+
+  /**
+   * Returns `true` when the current MIME entity is a complete CMS/PKCS #7 signed S/MIME wrapper,
+   * including detached `multipart/signed` and opaque signed-data forms. A standalone
+   * `application/pkcs7-signature` or `application/x-pkcs7-signature` leaf part is not by itself
+   * classified as a signed message. To search the visible MIME tree, use {@link
+   * Mime.containsSignedParts}.
+   */
+  isSigned(): boolean
+
+  /**
+   * Returns `true` when {@link Mime.contentType} begins with `text/`.
+   */
+  isText(): boolean
+
+  /**
+   * Returns `true` when {@link Mime.contentType} begins with `video/`.
+   */
+  isVideo(): boolean
+
+  /**
+   * Returns `true` only for `text/xml` or `application/xml`. It does not classify structured-suffix
+   * media types such as `application/soap+xml`, `application/atom+xml`, or `image/svg+xml` as XML.
+   */
+  isXml(): boolean
+
+  /**
+   * Parses the complete MIME text in `mimeMsg` and replaces the current object's headers, body, and
+   * multipart tree. A successful call always replaces the previous MIME.
+   *
+   * If no blank line separates headers from the body, lines that appear header-like are parsed as
+   * headers and the body is empty. Data after the header/body separator belongs to the body.
+   *
+   * **Permissive parser and normalized output.** Chilkat accepts many imperfect messages. Observed
+   * behavior includes ignoring malformed header lines and leading non-header text, using the last
+   * duplicate `Content-Type`, repairing a missing multipart closing delimiter during serialization,
+   * treating unmatched boundary-like text as an ordinary body, and tolerating malformed Base64 or
+   * quoted-printable. LF-only and CR-only input are accepted; generated headers and multipart
+   * framing use CRLF. Loading and reserializing is therefore not guaranteed to reproduce the
+   * original bytes, and multipart preamble and epilogue text are not retained.
+   *
+   * **Text input is not a raw-byte container.** Use {@link Mime.loadMimeBd} or `LoadMimeBytes` for
+   * arbitrary 8-bit bytes or embedded NUL bytes.
+   *
+   * @throws Error if the call fails (the message names the reason); the full log is in
+   * {@link Mime.lastErrorText}.
+   */
+  loadMime(mimeMsg: string): void
+
+  /**
+   * Reads and parses the complete MIME entity from the local file at `fileName`. A successful call
+   * replaces the current MIME. If the file cannot be opened, the method returns `false` and
+   * preserves the existing object unchanged.
+   *
+   * Parsing tolerance and serialization normalization are the same as {@link Mime.loadMime}.
+   *
+   * @throws Error if the call fails (the message names the reason); the full log is in
+   * {@link Mime.lastErrorText}.
+   */
+  loadMimeFile(fileName: string): void
+
+  /**
+   * Reconstructs a MIME tree from Chilkat's MIME XML in `xml`. On success, the current object is
+   * replaced. If the XML is invalid, the method returns `false` and preserves the existing MIME
+   * unchanged.
+   *
+   * The reconstructed MIME is semantically equivalent but not byte-identical to the MIME that
+   * produced the XML. Header names are normalized to lowercase.
+   *
+   * @throws Error if the call fails (the message names the reason); the full log is in
+   * {@link Mime.lastErrorText}.
+   */
+  loadXml(xml: string): void
+
+  /**
+   * Reads Chilkat MIME XML from the local file at `fileName` and reconstructs the MIME tree. On
+   * success, the current object is replaced. If the file cannot be opened or the XML is invalid,
+   * the method returns `false` and preserves the existing MIME unchanged. Header names are
+   * normalized to lowercase during reconstruction.
+   *
+   * @throws Error if the call fails (the message names the reason); the full log is in
+   * {@link Mime.lastErrorText}.
+   */
+  loadXmlFile(fileName: string): void
+
+  /**
+   * Clears the current object and initializes it as `message/rfc822`. Its body is a serialized copy
+   * of `mimeObject` at the time of the call. Later modifications to `mimeObject` do not change the
+   * embedded message.
+   *
+   * @throws Error if the call fails (the message names the reason); the full log is in
+   * {@link Mime.lastErrorText}.
+   */
+  newMessageRfc822(mimeObject: Mime): void
+
+  /**
+   * Initializes an empty `multipart/alternative` entity. Clears all existing headers, body content,
+   * and child parts. The new object contains only a multipart `Content-Type` with an automatically
+   * generated boundary, has zero parts, and does not automatically add `MIME-Version`.
+   *
+   * @throws Error if the call fails (the message names the reason); the full log is in
+   * {@link Mime.lastErrorText}.
+   */
+  newMultipartAlternative(): void
+
+  /**
+   * Initializes an empty `multipart/mixed` entity. Clears all existing headers, body content, and
+   * child parts. The new object contains only a multipart `Content-Type` with an automatically
+   * generated boundary, has zero parts, and does not automatically add `MIME-Version`.
+   *
+   * @throws Error if the call fails (the message names the reason); the full log is in
+   * {@link Mime.lastErrorText}.
+   */
+  newMultipartMixed(): void
+
+  /**
+   * Initializes an empty `multipart/related` entity. Clears all existing headers, body content, and
+   * child parts. The new object contains only a multipart `Content-Type` with an automatically
+   * generated boundary, has zero parts, and does not automatically add `MIME-Version`.
+   *
+   * @throws Error if the call fails (the message names the reason); the full log is in
+   * {@link Mime.lastErrorText}.
+   */
+  newMultipartRelated(): void
+
+  /**
+   * Removes fields whose name matches `fieldName` case-insensitively. If `bAllOccurrences` is
+   * `false`, only the first matching occurrence is removed. If `bAllOccurrences` is `true`, all
+   * matching occurrences are removed. Remaining fields retain their relative order.
+   */
+  removeHeaderField(fieldName: string, bAllOccurrences: boolean): void
+
+  /**
+   * Removes the direct child at zero-based `index`. Valid indexes range from `0` through {@link
+   * Mime.numParts} `- 1`. An out-of-range index returns `false` and leaves the tree unchanged.
+   *
+   * @throws Error if the call fails (the message names the reason); the full log is in
+   * {@link Mime.lastErrorText}.
+   */
+  removePart(index: number): void
+
+  /**
+   * Writes the decoded body bytes of the current part to the local path in `filename`. Base64 and
+   * quoted-printable are decoded. MIME headers and multipart framing are not written.
+   *
+   * **File behavior.** Existing files are overwritten. Parent directories are not created, and
+   * passing a directory as the destination fails. On Windows, an existing read-only file is
+   * replaced and the read-only attribute is removed.
+   *
+   * @throws Error if the call fails (the message names the reason); the full log is in
+   * {@link Mime.lastErrorText}.
+   */
+  saveBody(filename: string): void
+
+  /**
+   * Serializes the complete MIME entity and writes it to the local path in `filename`, including
+   * headers, body, multipart boundaries, and all descendants.
+   *
+   * **Serialization is normalized.** The result is semantically equivalent MIME, not a
+   * byte-for-byte copy of loaded input. Chilkat can unfold headers, normalize parameter quoting and
+   * transfer encodings, discard multipart preamble and epilogue text, and generate CRLF for headers
+   * and multipart framing. Existing body line endings may not always be rewritten.
+   *
+   * **File behavior.** Existing files are overwritten. Parent directories are not created, and
+   * passing a directory as the destination fails. On Windows, an existing read-only file is
+   * replaced and the read-only attribute is removed.
+   *
+   * @throws Error if the call fails (the message names the reason); the full log is in
+   * {@link Mime.lastErrorText}.
+   */
+  saveMime(filename: string): void
+
+  /**
+   * Writes Chilkat's MIME XML representation to the local path in `filename`. The file can be
+   * loaded by {@link Mime.loadXmlFile}.
+   *
+   * **File behavior.** Existing files are overwritten. Parent directories are not created, and
+   * passing a directory as the destination fails. On Windows, an existing read-only file is
+   * replaced and the read-only attribute is removed.
+   *
+   * @throws Error if the call fails (the message names the reason); the full log is in
+   * {@link Mime.lastErrorText}.
+   */
+  saveXml(filename: string): void
+
+  /**
+   * Sets the current part's body from `str` while preserving existing content headers such as
+   * `Content-Type`, `charset`, and `Content-Transfer-Encoding`.
+   *
+   * **Multipart entities serialize their child parts.** Calling this method on a multipart object
+   * changes what the body getter methods return, but the assigned body is not included in the
+   * serialized multipart output while child parts are present. Build multipart content through
+   * {@link Mime.appendPart} and {@link Mime.partAt}.
+   */
+  setBody(str: string): void
+
+  /**
+   * Sets the body from transfer-encoded text. `encoding` must be `base64` or `quoted-printable`;
+   * other values, including `7bit`, `8bit`, `binary`, an unknown name, or an empty string, cause
+   * failure.
+   *
+   * Base64 whitespace is accepted and the stored representation is normalized. Invalid Base64
+   * causes the method to return `false`. On any failure, all existing headers and body content are
+   * preserved unchanged.
+   *
+   * **Do not encode twice.** `str` must already be in the encoding named by `encoding`. To provide
+   * decoded bytes, use {@link Mime.setBodyBd} or `SetBodyFromBinary`.
+   *
+   * @throws Error if the call fails (the message names the reason); the full log is in
+   * {@link Mime.lastErrorText}.
+   */
+  setBodyFromEncoded(encoding: string, str: string): void
+
+  /**
+   * Reads the local file at `fileName` and replaces the current part's body and content headers
+   * according to the filename extension.
+   *
+   * File kindResult
+   *
+   * | `.txt` |  | `text/plain; charset=windows-1252; format=flowed`, `7bit` |
+   *
+   * | `.html` |  | `text/html; charset=windows-1252`, `7bit` |
+   *
+   * | Unknown extension | | `application/octet-stream`, `base64`, `attachment`, and filename/name
+   * parameters based on the local filename |
+   *
+   * If the file cannot be opened, the method returns `false` and preserves the existing MIME
+   * unchanged.
+   *
+   * @throws Error if the call fails (the message names the reason); the full log is in
+   * {@link Mime.lastErrorText}.
+   */
+  setBodyFromFile(fileName: string): void
+
+  /**
+   * Sets `str` as HTML and changes the media type to `text/html`. For ASCII input, Chilkat uses
+   * `Content-Transfer-Encoding: 7bit` and does not add a charset. Existing unrelated headers are
+   * preserved.
+   *
+   * @throws Error if the call fails (the message names the reason); the full log is in
+   * {@link Mime.lastErrorText}.
+   */
+  setBodyFromHtml(str: string): void
+
+  /**
+   * Sets `str` as plain text. For ASCII input, Chilkat sets `Content-Type: text/plain;
+   * format=flowed` and `Content-Transfer-Encoding: 7bit` without a charset. For non-ASCII UTF-8
+   * input, it sets `charset=utf-8` and uses `8bit`. Existing unrelated headers are preserved.
+   *
+   * @throws Error if the call fails (the message names the reason); the full log is in
+   * {@link Mime.lastErrorText}.
+   */
+  setBodyFromPlainText(str: string): void
+
+  /**
+   * Sets `str` as XML, changes the media type to `text/xml`, and selects a transfer encoding
+   * appropriate for the text. For ASCII input, Chilkat uses `7bit` and does not add a charset.
+   *
+   * The XML declaration's `encoding` value is not copied to the MIME `charset` parameter.
+   *
+   * **Different from LoadXml.** This method places an XML document in the MIME body. {@link
+   * Mime.loadXml} reconstructs an entire MIME object from Chilkat MIME XML.
+   *
+   * @throws Error if the call fails (the message names the reason); the full log is in
+   * {@link Mime.lastErrorText}.
+   */
+  setBodyFromXml(str: string): void
+
+  /**
+   * Sets one header field named by `name`. Matching is case-insensitive. All existing occurrences
+   * are removed and one replacement is inserted. If no field exists, a new one is added. Passing an
+   * empty `value` removes all matching occurrences rather than creating an empty-valued field.
+   *
+   * Use {@link Mime.addHeaderField} to append another occurrence or to create an empty-valued
+   * field.
+   *
+   * @throws Error if the call fails (the message names the reason); the full log is in
+   * {@link Mime.lastErrorText}.
+   */
+  setHeaderField(name: string, value: string): void
+
+  /**
+   * Supplies `cert` as a signer-certificate fallback for subsequent signature verification. This is
+   * useful when the CMS/PKCS #7 signature does not embed the signer certificate and Chilkat cannot
+   * otherwise locate it. Only the public key is required.
+   *
+   * **This does not require a particular signer.** An embedded signer certificate takes precedence.
+   * If the CMS signature embeds the correct signer certificate, verification can succeed even when
+   * `cert` is an unrelated certificate, and {@link Mime.lastSignerCert} returns the embedded
+   * certificate. To enforce signer identity, verify first and then compare the returned signer
+   * certificate using application-defined criteria such as its serial number, fingerprint, subject,
+   * issuer, or trusted chain.
+   *
+   * @throws Error if the call fails (the message names the reason); the full log is in
+   * {@link Mime.lastErrorText}.
+   */
+  setVerifyCert(cert: Cert): void
+
+  /**
+   * Removes supported S/MIME security layers and restores the underlying MIME content. It handles
+   * both common layer orders: a message signed and then encrypted, and a message encrypted and then
+   * signed. It continues through nested top-level layers until no additional supported security
+   * wrapper remains.
+   *
+   * After a successful call, {@link Mime.numSignerCerts} and {@link Mime.lastSignerCert} identify
+   * verified signers, while {@link Mime.numDecryptCerts} and {@link Mime.lastDecryptCert} identify
+   * decryption certificates. {@link Mime.getLastJsonData} may contain both `pkcs7.verify` and
+   * `pkcs7.decrypt` details.
+   *
+   * **Additional result headers.** When {@link Mime.unwrapExtras} is `true`, Chilkat adds headers
+   * such as `X-NumPartsSigned`, `X-SignaturesValid`, `X-NumPartsEncrypted`, and `X-Decrypted`. Set
+   * it to `false` to omit these headers.
+   *
+   * @throws Error if the call fails (the message names the reason); the full log is in
+   * {@link Mime.lastErrorText}.
+   */
+  unwrapSecurity(): void
+
+  /**
+   * Replaces the current body with an `application/x-www-form-urlencoded`-style representation
+   * using the character set named by `charset`. Spaces become `+`, a literal plus becomes `%2B`,
+   * non-ASCII bytes become `%HH` sequences, and separators such as `&` and `=` remain unchanged.
+   *
+   * ```
+   * Input:  a b+c&d=e
+   * Output: a+b%2Bc&d=e
+   * ```
+   *
+   * The MIME content headers are not changed. If the named character set is unsupported, the body
+   * remains unchanged.
+   *
+   * **Not a MIME transfer encoding.** This operation is distinct from `base64` and
+   * `quoted-printable`.
+   */
+  urlEncodeBody(charset: string): void
+
+  /**
+   * Sets `vault` as the certificate vault used to locate certificates and private keys for S/MIME
+   * encryption, decryption, signing, and verification. Only one vault is active; each call replaces
+   * the previously configured vault.
+   *
+   * Use `XmlCertVault` when credentials are maintained independently of platform certificate stores
+   * or individual PFX sources.
+   *
+   * @throws Error if the call fails (the message names the reason); the full log is in
+   * {@link Mime.lastErrorText}.
+   */
+  useCertVault(vault: XmlCertVault): void
+
+  /**
+   * Verifies the current CMS/PKCS #7 signed MIME entity and removes the signature wrapper. Both
+   * detached `multipart/signed` messages and opaque CMS `signed-data` are supported. The method
+   * works with signed MIME loaded from serialized input as well as MIME signed by the current
+   * object.
+   *
+   * On success, the object is restored to the MIME structure and content that was signed, {@link
+   * Mime.numSignerCerts} reports the verified signer count, {@link Mime.lastSignerCert} returns the
+   * signer certificate, and {@link Mime.getLastJsonData} reports CMS verification details. A
+   * detached signature can restore the original serialization exactly, but opaque signed-data
+   * restoration is semantic and is not guaranteed to reproduce byte-for-byte identical MIME
+   * serialization.
+   *
+   * On failure, the signed wrapper remains unchanged, no content is unwrapped, and the
+   * signer-result count is cleared to `0`.
+   *
+   * **SetVerifyCert is a fallback, not a signer restriction.** When the CMS data embeds a usable
+   * signer certificate, Chilkat uses that embedded certificate. Verification can therefore succeed
+   * even when {@link Mime.setVerifyCert} was given an unrelated certificate. Enforce signer
+   * identity after verification by examining {@link Mime.lastSignerCert}.
+   *
+   * **What verification proves.** Cryptographic verification establishes that the signed bytes have
+   * not changed and that the signature matches the signer certificate. Application trust decisions
+   * may additionally require validating the certificate chain, identity, usage, validity period,
+   * and revocation status.
+   *
+   * @throws Error if the call fails (the message names the reason); the full log is in
+   * {@link Mime.lastErrorText}.
+   */
+  verify(): void
+
+  /**
+   * Returns a concise MIME-tree summary. `fmt` is case-insensitive. The value `xml` selects XML
+   * output; all other values, including `text`, an empty string, or an unrecognized value, select
+   * the indented text format.
+   *
+   * ```
+   * multipart/mixed
+   *     text/plain
+   *     application/octet-stream
+   * ```
+   *
+   * ```
+   * <multipart-mixed>
+   *     <text-plain />
+   *     <application-octet-stream />
+   * </multipart-mixed>
+   * ```
+   *
+   * @throws Error if the call fails (the message names the reason); the full log is in
+   * {@link Mime.lastErrorText}.
+   */
+  getStructure(fmt: string): string
+
+  /**
+   * Serializes the complete MIME entity and appends it to `sb`. Existing `StringBuilder` content is
+   * preserved.
+   *
+   * **Serialization is normalized.** The result is semantically equivalent MIME, not a
+   * byte-for-byte copy of loaded input. Chilkat can unfold headers, normalize parameter quoting and
+   * transfer encodings, discard multipart preamble and epilogue text, and generate CRLF for headers
+   * and multipart framing. Existing body line endings may not always be rewritten.
+   *
+   * @throws Error if the call fails (the message names the reason); the full log is in
+   * {@link Mime.lastErrorText}.
+   */
+  getMimeSb(sb: StringBuilder): void
+
+  /**
+   * Serializes the complete MIME entity and appends its bytes to `bindat`. Existing `BinData` bytes
+   * are preserved. Use this method when arbitrary binary body bytes must not pass through a text
+   * string.
+   *
+   * **Serialization is normalized.** The result is semantically equivalent MIME, not a
+   * byte-for-byte copy of loaded input. Chilkat can unfold headers, normalize parameter quoting and
+   * transfer encodings, discard multipart preamble and epilogue text, and generate CRLF for headers
+   * and multipart framing. Existing body line endings may not always be rewritten.
+   *
+   * @throws Error if the call fails (the message names the reason); the full log is in
+   * {@link Mime.lastErrorText}.
+   */
+  getMimeBd(bindat: BinData): void
+
+  /**
+   * Parses complete MIME text from `sb` and replaces the current MIME on success. Parsing tolerance
+   * and serialization normalization are the same as {@link Mime.loadMime}.
+   *
+   * **Use byte input for arbitrary MIME bytes.** A `StringBuilder` is text-oriented. Use {@link
+   * Mime.loadMimeBd} for binary MIME containing arbitrary 8-bit values or NUL bytes.
+   *
+   * @throws Error if the call fails (the message names the reason); the full log is in
+   * {@link Mime.lastErrorText}.
+   */
+  loadMimeSb(sb: StringBuilder): void
+
+  /**
+   * Parses complete MIME bytes from `bindat` and replaces the current MIME on success. This is the
+   * preferred loader when the MIME can contain arbitrary 8-bit body bytes or embedded NUL bytes.
+   * Parsing tolerance and serialization normalization are the same as {@link Mime.loadMime}.
+   *
+   * @throws Error if the call fails (the message names the reason); the full log is in
+   * {@link Mime.lastErrorText}.
+   */
+  loadMimeBd(bindat: BinData): void
+
+  /**
+   * Replaces the contents of `binDat` with the decoded body bytes of the current part. Existing
+   * bytes in `binDat` are discarded. Base64 and quoted-printable are decoded. MIME headers,
+   * multipart boundaries, and child parts are not included.
+   *
+   * @throws Error if the call fails (the message names the reason); the full log is in
+   * {@link Mime.lastErrorText}.
+   */
+  getBodyBd(binDat: BinData): void
+
+  /**
+   * Copies structured details from the most recent operation into `json` when such details are
+   * available. Many methods do not produce JSON data.
+   *
+   * OperationTypical result
+   *
+   * | Signing or encryption |  | An empty JSON object. |
+   *
+   * | {@link Mime.verify} | | `pkcs7.verify` details such as embedded certificates, digest
+   * algorithms, signer information, signature algorithm, signing time, message digest, and
+   * authenticated attributes. |
+   *
+   * | Decryption | | `pkcs7.decrypt` details including the content algorithm and key size. A
+   * PFX-based method may also include PKCS #12 parsing details. |
+   *
+   * | {@link Mime.unwrapSecurity} | | May contain both verification and decryption sections when
+   * both kinds of security layer were removed. |
+   *
+   * **Read immediately.** The information describes the most recent applicable call on this object
+   * and can be replaced by a later operation.
+   */
+  getLastJsonData(json: JsonObject): void
+
+  /**
+   * Loads into `cert` the decryption certificate at zero-based `index` from the most recent
+   * successful decryption or security-unwrapping operation. Valid indexes range from `0` through
+   * {@link Mime.numDecryptCerts} `- 1`. The returned certificate has access to the private key used
+   * for decryption.
+   *
+   * An invalid index returns `false` and leaves `cert` unchanged.
+   *
+   * @throws Error if the call fails (the message names the reason); the full log is in
+   * {@link Mime.lastErrorText}.
+   */
+  lastDecryptCert(index: number, cert: Cert): void
+
+  /**
+   * Loads into `cert` the signer certificate at zero-based `index` from the most recent successful
+   * signature-verification or security-unwrapping operation. Valid indexes range from `0` through
+   * {@link Mime.numSignerCerts} `- 1`. The returned certificate normally contains only the public
+   * key; it does not gain access to the signer's private key.
+   *
+   * An invalid index returns `false` and leaves `cert` unchanged. A later failed call to {@link
+   * Mime.verify} clears the signer results.
+   *
+   * @throws Error if the call fails (the message names the reason); the full log is in
+   * {@link Mime.lastErrorText}.
+   */
+  lastSignerCert(index: number, cert: Cert): void
+
+  /**
+   * Provides live access to the direct child at zero-based `index` through `subPart`. Modifying
+   * `subPart` after a successful call modifies the child stored in the parent MIME tree.
+   *
+   * Valid indexes range from `0` through {@link Mime.numParts} `- 1`. An invalid index returns
+   * `false` and preserves `subPart` unchanged.
+   *
+   * **Different from AppendPart.** {@link Mime.appendPart} stores a copy of its argument. This
+   * method exposes the actual stored child.
+   *
+   * @throws Error if the call fails (the message names the reason); the full log is in
+   * {@link Mime.lastErrorText}.
+   */
+  partAt(index: number, subPart: Mime): void
+
+  /**
+   * Recursively traverses the MIME tree and saves each part having a nonempty `filename` parameter
+   * to the existing directory in `path`. A `name` parameter alone is not used as a fallback. The
+   * disposition may be `attachment` or `inline`; a filename is what controls extraction.
+   *
+   * - Only the final path component of a MIME filename is used. Directory components, absolute
+   *   paths, and `..` traversal are discarded.
+   *
+   * - On Windows, invalid filename characters are replaced with underscores.
+   *
+   * - Duplicate filenames target the same path; later parts overwrite earlier parts.
+   *
+   * - `st` is appended to rather than cleared. Each added entry is the full path actually written,
+   *   including any sanitized filename.
+   *
+   * - The destination directory is not created. If it does not exist, the method returns `false`,
+   *   creates no files, and appends nothing to `st`.
+   *
+   * **Treat MIME filenames as untrusted.** Use a controlled destination directory and apply any
+   * application-specific policy for file types, size limits, overwriting, and renaming.
+   *
+   * @throws Error if the call fails (the message names the reason); the full log is in
+   * {@link Mime.lastErrorText}.
+   */
+  partsToFiles(path: string, st: StringTable): void
+
+  /**
+   * Adds the PKCS #12/PFX bytes in `bd` to the internal collection of credential sources used by
+   * later S/MIME decryption operations. `password` is the password protecting the PFX data. Call
+   * the method once for each PFX source that should be searched.
+   *
+   * The source remains configured across subsequent `LoadMime` calls and repeated decryptions.
+   * Chilkat continues searching after a PFX that does not contain the required recipient key.
+   *
+   * **Not a signing-key fallback.** Adding a PFX source does not make a public-only certificate
+   * usable by the signing methods. The signing certificate itself must have its private key, or the
+   * private key must be supplied explicitly by a method whose name ends in `Pk`.
+   *
+   * @throws Error if the call fails (the message names the reason); the full log is in
+   * {@link Mime.lastErrorText}.
+   */
+  addPfxSourceBd(bd: BinData, password: string): void
+
+  /**
+   * Sets the decoded body bytes from `bd`, changes `Content-Transfer-Encoding` to `base64`, and
+   * preserves the bytes exactly. It does not set a `Content-Type`, disposition, filename, or name;
+   * set those separately when needed.
+   *
+   * @throws Error if the call fails (the message names the reason); the full log is in
+   * {@link Mime.lastErrorText}.
+   */
+  setBodyBd(bd: BinData): void
+
+  /**
+   * Examines the current encrypted S/MIME entity and writes recipient-certificate identifiers to
+   * the `JsonObject` in `certInfo`. This can be used to identify which certificate and private key
+   * must be made available before calling {@link Mime.decrypt} or {@link Mime.unwrapSecurity}. A
+   * typical result is:
+   *
+   * ```
+   * {
+   *   "recipientInfo": [
+   *     {
+   *       "serial": "166FC256FC66A64B20C710F15BFAB63E",
+   *       "issuerCN": "Example Issuing CA"
+   *     }
+   *   ]
+   * }
+   * ```
+   *
+   * The method returns `false` and writes an empty JSON object when the current MIME entity is not
+   * encrypted, including after it has already been decrypted.
+   *
+   * **No private key is revealed.** The encrypted message contains recipient identifiers and
+   * encrypted key material, not recipient private keys.
+   *
+   * @throws Error if the call fails (the message names the reason); the full log is in
+   * {@link Mime.lastErrorText}.
+   */
+  getDecryptCertInfo(certInfo: JsonObject): void
+}