@chilkat/react-native 11.6.1

package/src/specs/Dkim.nitro.ts

@@ -0,0 +1,595 @@
+// Generated by ReactNativeNs.RnGenerator -- do not edit.
+import type { HybridObject } from 'react-native-nitro-modules'
+import type { BinData } from './BinData.nitro'
+import type { PrivateKey } from './PrivateKey.nitro'
+
+/**
+ * Sign and verify MIME email with DKIM signatures.
+ *
+ * `Dkim` is the Chilkat class for applying and verifying
+ * DKIM signatures on MIME email data. It supports DKIM signing with
+ * `rsa-sha256` or `rsa-sha1`, configurable
+ * canonicalization, selectable signed headers, signature counting, DNS
+ * public-key lookup, public-key caching, public-key prefetching, and detailed
+ * verification reporting through `VerifyInfo`.
+ *
+ * **DKIM signing**
+ *
+ * Add DKIM signatures to MIME messages using a private key, selector,
+ * signing domain, canonicalization settings, and selected headers.
+ *
+ * **Signed header selection**
+ *
+ * Choose which message headers are protected by the signature and control
+ * their order in the generated `h=` tag.
+ *
+ * **Signature verification**
+ *
+ * Verify one or more signatures in a MIME message and determine whether the
+ * signed content, headers, and public key match.
+ *
+ * **Canonicalization control**
+ *
+ * Configure body and header canonicalization so signing and verification
+ * match the requirements of the sending domain and receiving systems.
+ *
+ * **DNS public keys**
+ *
+ * Retrieve DKIM public keys from DNS, prefetch keys when useful, and cache
+ * public keys to reduce repeated DNS lookups.
+ *
+ * **Verification diagnostics**
+ *
+ * Use `VerifyInfo` and related status information to understand
+ * which signatures were found, which were checked, and why verification
+ * succeeded or failed.
+ *
+ * **Common pattern:**
+ * To sign, provide the MIME message, signing domain, selector, private key,
+ * canonicalization choices, and the headers to include in the signature. To
+ * verify, pass the received MIME message to `Dkim`, allow the class
+ * to locate the signature and public key, and inspect `VerifyInfo`
+ * for detailed results.
+ *
+ * For an extended overview, see
+ * [Dkim Class Overview](https://www.chilkatsoft.com/dkim_class_overview.asp).
+ *
+ * Each `Dkim` 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 Dkim()`.
+ *
+ * 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 Dkim.abort} and assigning {@link Dkim.onPercentDone} / {@link Dkim.onProgressInfo}.
+ */
+export interface Dkim 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
+
+  /**
+   * Specifies the signing algorithm written to the `a=` tag of a newly created `DKIM-Signature`
+   * header. The default is `rsa-sha256`.
+   *
+   * ValueBehavior
+   *
+   * | `rsa-sha256` |  | RSA signing with a SHA-256 digest. This is the recommended value. |
+   *
+   * | `rsa-sha1` | | Legacy RSA signing with a SHA-1 digest. Use only when an older system
+   * specifically requires it. |
+   *
+   * The value is trimmed and compared case-insensitively. The recognized values are `rsa-sha256`
+   * and `rsa-sha1`. An empty or unrecognized value is normalized to `rsa-sha256` rather than
+   * rejected.
+   */
+  dkimAlg: string
+
+  /**
+   * Controls the maximum number of bytes from the canonicalized message body used when computing
+   * the DKIM body hash. The default is `0`.
+   *
+   * ValueBehavior
+   *
+   * | `0` |  | Hashes the complete canonicalized body and omits the DKIM `l=` tag. |
+   *
+   * | Positive and less than the canonicalized body length | | Hashes the specified number of bytes
+   * and emits `l=` with that value. |
+   *
+   * | Positive and greater than the canonicalized body length | | Hashes the complete canonicalized
+   * body and emits `l=` containing the actual canonicalized body length. |
+   *
+   * | Negative | | `-1` hashes the complete canonicalized body and emits `l=` containing the actual
+   * canonicalized body length. |
+   *
+   * When a generated signature contains `l=`, verification hashes only the indicated prefix of the
+   * canonicalized body. Content appended after that signed prefix does not invalidate the
+   * signature.
+   *
+   * **Security note:** Partial-body signatures allow unsigned content to be appended after the
+   * signed portion. Signing the complete body by using `0` is normally preferred.
+   */
+  dkimBodyLengthCount: number
+
+  /**
+   * Specifies one DKIM canonicalization algorithm to use for both the signed header fields and the
+   * message body. The default is `relaxed`.
+   *
+   * ValueGenerated `c=` valueBehavior
+   *
+   * | `simple` | | `simple/simple` | | Preserves formatting closely. Small changes in whitespace or
+   * header folding can invalidate the signature. |
+   *
+   * | `relaxed` | | `relaxed/relaxed` | | Normalizes defined whitespace and header-name
+   * differences. |
+   *
+   * The value is trimmed and compared case-insensitively. This property does not accept a
+   * header/body pair such as `relaxed/simple` or `simple/relaxed`. Pair values, an empty string,
+   * and other unrecognized values are normalized to `relaxed` rather than rejected.
+   *
+   * **Canonicalization background:** DKIM signs a canonicalized representation of the message. The
+   * signer and verifier must apply the same header and body canonicalization rules.
+   */
+  dkimCanon: string
+
+  /**
+   * Specifies the signing domain written verbatim to the `d=` tag of the generated `DKIM-Signature`
+   * header. The corresponding public key is normally published beneath the DNS name formed from
+   * {@link Dkim.dkimSelector} and this domain.
+   *
+   * Set this property to a nonempty, syntactically valid domain before calling {@link
+   * Dkim.dkimSign}. If this property is empty, `DkimSign` returns `false` without modifying the
+   * MIME data. A nonempty value is not otherwise validated or normalized during signing; uppercase
+   * letters, surrounding whitespace, a trailing dot, and Unicode characters are emitted as
+   * supplied.
+   *
+   * **Caller responsibility:** Supply the domain in the exact form required in the signature. For
+   * an internationalized domain, use its ASCII/Punycode form. `DkimSign` does not check DNS and
+   * does not confirm that the configured private key matches the public key published for this
+   * domain.
+   *
+   * **DKIM and DMARC:** DKIM verification does not require `d=` to equal the visible `From` domain.
+   * DMARC separately evaluates alignment between the authenticated DKIM domain and the message's
+   * `From` domain.
+   */
+  dkimDomain: string
+
+  /**
+   * A colon-separated list of header field names to include in the DKIM signature. The list is
+   * written to the signature's `h=` tag in the same order. The default is:
+   *
+   * ```
+   * mime-version:date:message-id:subject:from:to:content-type
+   * ```
+   *
+   * Header-name matching is case-insensitive. For each occurrence of a name in this list, Chilkat
+   * selects the next matching header field from the bottom of the message header block upward, as
+   * required by DKIM. For example, if the message contains two `Subject` fields, listing `subject`
+   * once signs the bottommost field, while listing it twice signs both fields.
+   *
+   * If a listed occurrence has no corresponding field in the message, the absent field is still
+   * included in the signing calculation. Repeating a name more times than it occurs can therefore
+   * implement DKIM oversigning and prevent a matching field from being inserted later without
+   * invalidating the signature.
+   *
+   * - Use colon-separated field names without surrounding spaces.
+   *
+   * - Include `from`; DKIM requires the `From` field to be signed, but {@link Dkim.dkimSign} does
+   *   not enforce this requirement or add it automatically.
+   *
+   * - An empty list and names of missing fields are accepted rather than rejected.
+   *
+   * - Avoid transport-added or frequently modified fields such as `Received` and `Return-Path`.
+   *
+   * **Repeated names:** Repeated existing headers are signed successively from bottom to top.
+   * Repeated absent occurrences are useful for oversigning.
+   */
+  dkimHeaders: string
+
+  /**
+   * Specifies the selector written verbatim to the `s=` tag of a generated DKIM signature. The
+   * selector and {@link Dkim.dkimDomain} form the DNS name used to locate the public key:
+   *
+   * ```
+   * selector._domainkey.signing-domain
+   * ```
+   *
+   * For example, selector `brisbane` and domain `chilkatsoft.com` produce
+   * `brisbane._domainkey.chilkatsoft.com`.
+   *
+   * Supply only the selector. Do not include `._domainkey.` or the signing domain. If this property
+   * is empty, {@link Dkim.dkimSign} returns `false` without modifying the MIME data. A nonempty
+   * value is not otherwise validated or normalized during signing; for example, a complete DNS name
+   * is emitted as supplied rather than reduced to a selector.
+   *
+   * **Caller responsibility:** Use a nonempty selector consisting of valid DNS selector labels. The
+   * private key configured by {@link Dkim.setDkimPrivateKey} must match the public key published
+   * for this selector and domain.
+   */
+  dkimSelector: string
+
+  /**
+   * Specifies the interval, in milliseconds, between `AbortCheck` callbacks during methods that
+   * support periodic cancellation checks. Set to `0` to disable these callbacks. The default is
+   * `0`.
+   *
+   * {@link Dkim.prefetchPublicKey} invokes `AbortCheck` while performing its DNS lookup. Setting
+   * this property to `1` and requesting cancellation from the first callback causes
+   * `PrefetchPublicKey` to return `false`.
+   *
+   * **Responsiveness and overhead:** A smaller interval can make cancellation more responsive, but
+   * it also increases callback overhead. Methods that finish quickly may complete before any
+   * callback occurs.
+   */
+  heartbeatMs: number
+
+  /**
+   * Set to `true` to request cancellation of a currently running operation. A synchronous operation
+   * can be cancelled from another thread by setting this property on the same object. Methods that
+   * complete quickly or do not periodically check for cancellation may finish before the request is
+   * observed.
+   *
+   * **Cancellation behavior:** Treat this as a cancellation request rather than a guarantee of
+   * immediate termination. After the method returns, use the method's normal return value and
+   * diagnostic properties to determine the outcome.
+   */
+  abortCurrent: boolean
+
+  /**
+   * Contains JSON describing the most recent call to {@link Dkim.dkimVerify}. The property is
+   * initially an empty string and is replaced or cleared by each verification attempt.
+   *
+   * MemberMeaning
+   *
+   * | `domain` |  | The signature's `d=` value. |
+   *
+   * | `selector` |  | The signature's `s=` value. |
+   *
+   * | `publicKey` | | The Base64 public-key value obtained from DNS. This member is present when
+   * verification performs an automatic DNS lookup and may be absent when a preloaded or prefetched
+   * key is used. |
+   *
+   * | `canonicalization` |  | The header/body canonicalization pair from `c=`. |
+   *
+   * | `algorithm` |  | The signature algorithm from `a=`. |
+   *
+   * | `signedHeaders` |  | The signed-header list from `h=`. |
+   *
+   * | `fromSigned` | | Indicates whether the required `From` field name is included in the
+   * signed-header list. |
+   *
+   * | `expectedBodyHash` |  | The Base64 body hash obtained from the signature's `bh=` tag. |
+   *
+   * | `computedBodyHash` | | The Base64 body hash computed from the received message, applying the
+   * signature's canonicalization and optional `l=` body-length limit. |
+   *
+   * | `bodyHashVerified` | | The string `"yes"` when the computed body hash matches `bh=`, or
+   * `"no"` when it does not. |
+   *
+   * | `verified` | | The string `"yes"` for a valid signature or `"no"` for a completed
+   * verification that failed. |
+   *
+   * ```
+   * {
+   *   "domain": "chilkatsoft.com",
+   *   "selector": "brisbane",
+   *   "canonicalization": "relaxed/relaxed",
+   *   "algorithm": "rsa-sha256",
+   *   "signedHeaders": "from:to:subject:date:message-id",
+   *   "fromSigned": "yes",
+   *   "expectedBodyHash": "...",
+   *   "computedBodyHash": "...",
+   *   "bodyHashVerified": "yes",
+   *   "verified": "yes"
+   * }
+   * ```
+   *
+   * Not every member is present in every result. For malformed signatures, unsupported algorithms,
+   * missing signatures, DNS failures, or an out-of-range index, the value may be an empty string,
+   * `{}`, or a partial object without `verified`. Therefore, first check the return value of
+   * `DkimVerify`, and then treat individual JSON members as optional.
+   *
+   * **Authentication scope:** A valid DKIM signature shows that the verified signed content was
+   * produced by an entity possessing the private key for the authenticated domain. It does not by
+   * itself prove the identity of the human sender or establish DMARC alignment.
+   *
+   * This property is read-only.
+   */
+  readonly verifyInfo: string
+
+  // ---- Methods ----
+
+  /**
+   * Loads and caches an RSA public key in this `Dkim` object for the exact `selector` and `domain`
+   * strings. A later {@link Dkim.dkimVerify} uses the cached key when the signature contains the
+   * same selector and domain; otherwise verification falls back to DNS.
+   *
+   * `publicKey` contains a textual key representation. Supported formats include:
+   *
+   * - PEM X.509 SubjectPublicKeyInfo (`-----BEGIN PUBLIC KEY-----`)
+   *
+   * - PEM PKCS#1 RSA public key (`-----BEGIN RSA PUBLIC KEY-----`)
+   *
+   * - XML RSA key data
+   *
+   * - RSA JWK JSON
+   *
+   * The selector/domain cache key is case-sensitive. Loading a key for uppercase values does not
+   * satisfy a lowercase signature. A successful later load for the same pair replaces the earlier
+   * key. If a later load fails because the supplied key text is invalid, the previously cached key
+   * remains available.
+   *
+   * **Typical use:** Preload a trusted public key for testing before DNS publication or for a
+   * controlled verification environment. The key data is copied into the cache; the input string
+   * does not need to remain available after this method returns.
+   *
+   * @throws Error if the call fails (the message names the reason); the full log is in
+   * {@link Dkim.lastErrorText}.
+   */
+  loadPublicKey(selector: string, domain: string, publicKey: string): void
+
+  /**
+   * Loads an RSA public key from the local file at `publicKeyFilepath` and caches it in this `Dkim`
+   * object for the exact `selector` and `domain` strings. The file is read during this call.
+   *
+   * Supported formats include PEM X.509 SubjectPublicKeyInfo, PEM PKCS#1 RSA public key, binary DER
+   * PKCS#1 RSA public key, XML RSA key data, and RSA JWK JSON. The selector/domain cache key is
+   * case-sensitive.
+   *
+   * A later successful load for the same selector/domain pair replaces the earlier cached key. If
+   * no exact cached key is present when {@link Dkim.dkimVerify} runs, Chilkat performs its normal
+   * DNS lookup.
+   *
+   * **Path and trust:** `publicKeyFilepath` is a path in the local filesystem. Load only keys from
+   * a trusted source because the cached key determines which signatures are accepted for that
+   * selector and domain.
+   *
+   * @throws Error if the call fails (the message names the reason); the full log is in
+   * {@link Dkim.lastErrorText}.
+   */
+  loadPublicKeyFile(selector: string, domain: string, publicKeyFilepath: string): void
+
+  /**
+   * Retrieves the DKIM public key from DNS and caches it in this `Dkim` object for the exact
+   * `selector` and `domain` strings. The TXT lookup is made for:
+   *
+   * ```
+   * selector._domainkey.domain
+   * ```
+   *
+   * The method returns `true` when the DNS lookup and public-key loading succeed. Repeated calls
+   * for a cached pair can complete without another observable lookup. A successful prefetch
+   * replaces an existing manually loaded key for the same selector/domain pair.
+   *
+   * {@link Dkim.dkimVerify} also performs this DNS lookup automatically when no exact cached key is
+   * available. Prefetching is useful when several messages will be verified for the same selector
+   * and domain.
+   *
+   * **Cancellation:** This method supports `AbortCheck` callbacks according to {@link
+   * Dkim.heartbeatMs}. When the callback requests cancellation, the method returns `false` and the
+   * DNS lookup is aborted.
+   *
+   * **Key rotation:** The selector identifies a particular published key. When a sender begins
+   * using a new selector, prefetch the new selector separately.
+   *
+   * This call blocks the JavaScript thread until Chilkat returns; from UI code prefer
+   * {@link Dkim.prefetchPublicKeyAsync}.
+   *
+   * @throws Error if the call fails (the message names the reason); the full log is in
+   * {@link Dkim.lastErrorText}.
+   */
+  prefetchPublicKey(selector: string, domain: string): void
+
+  /**
+   * Asynchronous form of {@link Dkim.prefetchPublicKey}: 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 Dkim.abort} (which cancels it) and the {@link Dkim.onPercentDone} /
+   * {@link Dkim.onProgressInfo} callbacks, which report progress while it runs.
+   *
+   * The promise rejects with an Error if the call fails; the full log is in
+   * {@link Dkim.lastErrorText}.
+   */
+  prefetchPublicKeyAsync(selector: string, domain: string): Promise<void>
+
+  /**
+   * Creates a `DKIM-Signature` header and prepends it to the complete MIME message stored in
+   * `mimeData`. The `BinData` is modified in place.
+   *
+   * Before calling this method:
+   *
+   * - Construct the final MIME message, including all headers, transfer encodings, MIME boundaries,
+   *   and body bytes.
+   *
+   * - Use RFC 5322 line endings. The MIME header and body must use CRLF and be separated by.
+   *   LF-only and CR-only MIME are not normalized and cause the method to fail.
+   *
+   * - Set {@link Dkim.dkimDomain}, {@link Dkim.dkimSelector}, {@link Dkim.dkimAlg}, {@link
+   *   Dkim.dkimCanon}, and {@link Dkim.dkimHeaders}.
+   *
+   * - Load the RSA private key by calling {@link Dkim.setDkimPrivateKey}.
+   *
+   * On success, the generated header contains `v=1`, `a=`, `c=`, `q=dns/txt`, `d=`, `s=`, `h=`,
+   * `bh=`, and `b=`. When {@link Dkim.dkimBodyLengthCount} is nonzero, the header also contains
+   * `l=`. The generated header does not include `t=`, `x=`, or `i=`. Signing the same bytes twice
+   * with the same settings and key produced identical output.
+   *
+   * An empty body, a body without a final newline, and body data containing NUL or other binary
+   * bytes are accepted. An empty {@link Dkim.dkimDomain}, an empty {@link Dkim.dkimSelector},
+   * missing or invalid private-key state, or malformed MIME causes the method to return `false`
+   * without changing `mimeData`.
+   *
+   * **Existing signatures:** A new signature is prepended and existing `DKIM-Signature` fields are
+   * preserved. Signature indexes therefore follow top-to-bottom order: the newly added signature is
+   * index `0`, and older signatures shift to higher indexes. Each signature can be verified
+   * independently.
+   *
+   * **Sign the final representation:** Send the signed bytes directly. Parsing and regenerating the
+   * message, changing line endings, refolding signed headers, changing transfer encodings, or
+   * editing the signed body can invalidate the signature.
+   *
+   * @throws Error if the call fails (the message names the reason); the full log is in
+   * {@link Dkim.lastErrorText}.
+   */
+  dkimSign(mimeData: BinData): void
+
+  /**
+   * Copies the RSA key from `privateKey` into this object for subsequent calls to {@link
+   * Dkim.dkimSign}. The source `PrivateKey` object may be destroyed after this method returns
+   * successfully, and the configured key can be reused for multiple signatures.
+   *
+   * A later successful call replaces the previously configured signing key. A failed call with an
+   * empty or unrecognized key clears the usable signing-key state; a subsequent `DkimSign` fails
+   * until a valid key is set again.
+   *
+   * **Key matching:** The private key must correspond to the public key published at
+   * `selector._domainkey.domain`, using {@link Dkim.dkimSelector} and {@link Dkim.dkimDomain}. This
+   * method does not check DNS or confirm the match.
+   *
+   * @throws Error if the call fails (the message names the reason); the full log is in
+   * {@link Dkim.lastErrorText}.
+   */
+  setDkimPrivateKey(privateKey: PrivateKey): void
+
+  /**
+   * Verifies the `DKIM-Signature` header at zero-based `sigIndex` in the complete MIME message
+   * stored in `mimeData`. Signatures are indexed in top-to-bottom header order. Use {@link
+   * Dkim.numDkimSigs} to obtain the count.
+   *
+   * Chilkat first looks for a public key cached under the exact selector/domain strings. If no
+   * exact match exists, it synchronously retrieves the TXT record at `selector._domainkey.domain`.
+   * The method does not modify `mimeData`.
+   *
+   * Return valueMeaning
+   *
+   * | `true` | | The selected signature was successfully verified, including its body hash and
+   * signed headers. |
+   *
+   * | `false` | | The signature was invalid, or verification could not be completed because of an
+   * invalid index, malformed signature, unsupported algorithm, missing key, DNS failure, or another
+   * operational error. |
+   *
+   * Verification compares the signature's `bh=` value with the hash computed from the canonicalized
+   * body. When the signature contains `l=`, only the indicated number of canonicalized body bytes
+   * are included, so content appended after the signed prefix does not cause a body-hash failure.
+   *
+   * After the call, inspect {@link Dkim.verifyInfo}. A completed verification failure normally
+   * contains `"verified":"no"`. A body-hash mismatch also contains `"bodyHashVerified":"no"` with
+   * the expected and computed hashes. Operational and parsing failures may leave an empty string,
+   * `{}`, or a partial JSON object; use `LastErrorText` for the detailed reason.
+   *
+   * **Multiple signatures:** Verify each signature independently. One valid signature does not
+   * imply that every signature on the message is valid.
+   *
+   * @throws Error if the call fails (the message names the reason); the full log is in
+   * {@link Dkim.lastErrorText}.
+   */
+  dkimVerify(sigIndex: number, mimeData: BinData): void
+
+  /**
+   * Returns the number of header fields named `DKIM-Signature` in `mimeData`. Header-name matching
+   * is case-insensitive. The method counts matching fields without validating the signature syntax;
+   * for example, a malformed `DKIM-Signature: nonsense` field is still counted.
+   *
+   * The indexes used by {@link Dkim.dkimVerify} are zero-based and follow top-to-bottom header
+   * order. The method returns `0` when no matching header is found, including for an empty message.
+   * It does not modify `mimeData`.
+   *
+   * **Counting versus validation:** This method is a header count, not a MIME or DKIM validation
+   * step. A positive result does not mean that any counted signature is well formed or verifiable.
+   */
+  numDkimSigs(mimeData: BinData): number
+
+  // ---- 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 Dkim.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
+}