@chilkat/react-native 11.6.1

package/src/specs/Jwt.nitro.ts

@@ -0,0 +1,380 @@
+// Generated by ReactNativeNs.RnGenerator -- do not edit.
+import type { HybridObject } from 'react-native-nitro-modules'
+import type { Cert } from './Cert.nitro'
+import type { PrivateKey } from './PrivateKey.nitro'
+import type { PublicKey } from './PublicKey.nitro'
+
+/**
+ * Create, decode, verify, and time-validate compact JSON Web Tokens.
+ *
+ * `Jwt` is the Chilkat class for working with compact JSON
+ * Web Tokens. It can create signed JWTs, decode JWT headers and payloads,
+ * verify signatures, validate time-based claims, generate NumericDate values,
+ * and work with HMAC shared-secret tokens, RSA public/private-key tokens,
+ * ECC public/private-key tokens, and certificate-backed signing workflows.
+ *
+ * **Create compact JWTs**
+ *
+ * Build JWTs from JSON header and payload data, then sign them using the
+ * algorithm and key material required by the application or API.
+ *
+ * **Decode headers and claims**
+ *
+ * Decode the JWT header and payload without verification when an
+ * application needs to inspect claims, algorithms, key IDs, or token
+ * metadata.
+ *
+ * **Verify signatures**
+ *
+ * Verify JWT signatures using HMAC shared secrets, RSA public keys, ECC
+ * public keys, or certificates.
+ *
+ * **Sign with keys or certs**
+ *
+ * Create tokens using shared secrets, private keys, or certificates that
+ * have access to the associated private key.
+ *
+ * **Time validation**
+ *
+ * Validate `exp` and `nbf` claims and generate
+ * NumericDate values for token expiration, not-before, and issued-at
+ * timestamps.
+ *
+ * **API authentication workflows**
+ *
+ * Use JWTs for bearer-token style authentication, service-account flows,
+ * assertion-based OAuth flows, and other compact token formats.
+ *
+ * **Common pattern:**
+ * To create a JWT, prepare the JSON header and payload, set claims such as
+ * `iss`, `sub`, `aud`, `iat`,
+ * `nbf`, or `exp`, then sign with the required shared
+ * secret, private key, or certificate. To consume a JWT, decode it as needed,
+ * verify the signature with the matching key, and separately validate the
+ * time-based claims required by the application.
+ *
+ * For an extended overview, see
+ * [Jwt Class Overview](https://www.chilkatsoft.com/jwt_class_overview.asp).
+ *
+ * Each `Jwt` 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 Jwt()`.
+ */
+export interface Jwt extends HybridObject<{ ios: 'c++', android: 'c++' }> {
+  // ---- Properties ----
+
+  /**
+   * Provides HTML-formatted information about the last called method or property. If a method call
+   * fails or behaves unexpectedly, check this property for details. Note that information is
+   * available regardless of the method call's success.
+   *
+   * This property is read-only.
+   */
+  readonly lastErrorHtml: string
+
+  /**
+   * Provides plain text information about the last called method or property. If a method call
+   * fails or behaves unexpectedly, check this property for details. Note that information is
+   * available regardless of the method call's success.
+   *
+   * This property is read-only.
+   */
+  readonly lastErrorText: string
+
+  /**
+   * Provides XML-formatted information about the last called method or property. If a method call
+   * fails or behaves unexpectedly, check this property for details. Note that information is
+   * available regardless of the method call's success.
+   *
+   * This property is read-only.
+   */
+  readonly lastErrorXml: string
+
+  /**
+   * Version of the component/library, such as "10.1.0"
+   *
+   * This property is read-only.
+   */
+  readonly version: string
+
+  /**
+   * If set to a file path, this property logs the LastErrorText of each Chilkat method or property
+   * call to the specified file. This logging helps identify the context and history of Chilkat
+   * calls leading up to any crash or hang, aiding in debugging.
+   *
+   * Enabling the VerboseLogging property provides more detailed information.
+   *
+   * This property is mainly used for debugging rare instances where a Chilkat method call causes a
+   * hang or crash, which should generally not happen.
+   *
+   * Possible causes of hangs include:
+   *
+   * - A timeout property set to 0, indicating an infinite timeout.
+   *
+   * - A hang occurring within an event callback in the application code.
+   *
+   * - An internal bug in the Chilkat code causing the hang.
+   */
+  debugLogFilePath: string
+
+  /**
+   * If set to `true`, then the contents of LastErrorText (or LastErrorXml, or LastErrorHtml) may
+   * contain more verbose information. The default value is `false`. Verbose logging should only be
+   * used for debugging. The potentially large quantity of logged information may adversely affect
+   * peformance.
+   */
+  verboseLogging: boolean
+
+  /**
+   * Indicates the success or failure of the most recent method call: `true` means success, `false`
+   * means failure. This property remains unchanged by property setters or getters. This method is
+   * present to address challenges in checking for null or Nothing returns in certain programming
+   * languages. Note: This property does not apply to methods that return integer values or to
+   * boolean-returning methods where the boolean does not indicate success or failure.
+   */
+  lastMethodSuccess: boolean
+
+  /**
+   * Controls whether Chilkat removes insignificant JSON whitespace from the `header` and `payload`
+   * passed to `CreateJwt` and `CreateJwtPk` before Base64URL encoding and signing. The default is
+   * `true`.
+   *
+   * Compaction reduces token size without changing the JSON data model. Because the exact header
+   * and payload bytes are part of the signing input, changing this property changes the encoded
+   * token and its signature even when the JSON values are equivalent.
+   *
+   * **Whitespace inside JSON strings is preserved:** Compaction removes formatting whitespace
+   * between JSON tokens; it does not remove spaces that are part of a quoted string value.
+   */
+  autoCompact: boolean
+
+  /**
+   * Provides a catch-all string for specialized compatibility options that are not exposed as
+   * ordinary properties. The default is the empty string, which is appropriate for normal use.
+   *
+   * **Leave empty unless instructed:** Set this property only when a Chilkat example, release note,
+   * or support response documents a specific option needed for an unusual interoperability case.
+   */
+  uncommonOptions: string
+
+  // ---- Methods ----
+
+  /**
+   * Creates a signed JWT using an HMAC shared secret. `header` may be a complete JOSE header JSON
+   * object or the shorthand `HS256`, `HS384`, or `HS512`. A shorthand value produces a standard
+   * header containing the corresponding `alg` value.
+   *
+   * `payload` is the JSON claims set. Chilkat signs the JSON supplied by the application; it does
+   * not automatically add claims such as `iss`, `sub`, `aud`, `iat`, `nbf`, or `exp`. `password` is
+   * the shared secret used by both the signer and verifier.
+   *
+   * AlgorithmOperation
+   *
+   * | `HS256` |  | HMAC with SHA-256. |
+   *
+   * | `HS384` |  | HMAC with SHA-384. |
+   *
+   * | `HS512` |  | HMAC with SHA-512. |
+   *
+   * On success, the result is a compact JWS in the form
+   * `base64url(header).base64url(payload).base64url(signature)`. The Base64URL segments do not use
+   * padding.
+   *
+   * **Signed, not encrypted:** Anyone who receives the token can decode its header and payload. The
+   * HMAC protects integrity and authenticity only; do not place confidential information in the
+   * claims unless the token is protected separately.
+   *
+   * **Shared-secret guidance:** Use a high-entropy secret appropriate for the selected HMAC
+   * algorithm. A human password is usually weaker than a randomly generated key. Use `CreateJwtPk`
+   * when the trust model requires an asymmetric private key.
+   *
+   * @throws Error if the call fails (the message names the reason); the full log is in
+   * {@link Jwt.lastErrorText}.
+   */
+  createJwt(header: string, payload: string, password: string): string
+
+  /**
+   * Creates a signed JWT using an asymmetric private key. `header` may be a complete JOSE header
+   * JSON object or one of the documented shorthand algorithm names. `payload` is the JSON claims
+   * set, and `key` must be a private key compatible with the selected `alg`.
+   *
+   * JOSE algorithmRequired key and signature scheme
+   *
+   * | `RS256`, `RS384`, `RS512` | | RSA private key; RSASSA-PKCS1-v1_5 with the corresponding SHA-2
+   * digest. |
+   *
+   * | `PS256`, `PS384`, `PS512` | | RSA private key; RSASSA-PSS with the corresponding SHA-2 digest
+   * and MGF1. |
+   *
+   * | `ES256`, `ES384`, `ES512` | | EC private key compatible with the requested ECDSA algorithm. |
+   *
+   * | `EdDSA` |  | Ed25519 private key. Use a full JOSE header containing `"alg":"EdDSA"`. |
+   *
+   * The shorthand forms documented for this method are `RS256`, `RS384`, `RS512`, `PS256`, `PS384`,
+   * `PS512`, `ES256`, `ES384`, and `ES512`. PS256/384/512 support was added in Chilkat v10.0.0;
+   * Ed25519 signing with `EdDSA` requires Chilkat v9.5.0.95 or later.
+   *
+   * On success, the result is a compact JWS in the form
+   * `base64url(header).base64url(payload).base64url(signature)`.
+   *
+   * **Key compatibility:** The private-key type must agree with `alg`. Do not select an algorithm
+   * solely from untrusted input. Choose the algorithm as part of the application protocol and use a
+   * key intended for that algorithm.
+   *
+   * **Claims remain application-defined:** This method creates the cryptographic signature. The
+   * application is responsible for constructing and later validating issuer, audience, subject,
+   * lifetime, nonce, and other required claims.
+   *
+   * @throws Error if the call fails (the message names the reason); the full log is in
+   * {@link Jwt.lastErrorText}.
+   */
+  createJwtPk(header: string, payload: string, key: PrivateKey): string
+
+  /**
+   * Returns a JWT \*NumericDate\* equal to the current system time plus `numSecOffset`. The result
+   * is the number of whole seconds elapsed since `1970-01-01T00:00:00Z`, ignoring leap seconds.
+   *
+   * A positive offset produces a future time and a negative offset produces a past time. Typical
+   * uses include generating values for `iat`, `nbf`, and `exp` claims. The method returns the
+   * numeric value only; it does not insert the value into a JSON payload.
+   *
+   * **System-clock dependency:** The result is based on the computer's current clock. Token
+   * lifetimes and validation can be incorrect when the system clock is inaccurate.
+   */
+  genNumericDate(numSecOffset: number): number
+
+  /**
+   * Decodes and returns the JOSE header JSON from the first segment of the compact JWT. For a token
+   * in the form `header.payload.signature`, this method Base64URL-decodes the `header` segment and
+   * interprets it as JSON text.
+   *
+   * **No verification is performed:** Decoding a header does not prove that the token is authentic.
+   * Until `VerifyJwt` or `VerifyJwtPk` succeeds, treat every header value—including `alg`, `kid`,
+   * `jku`, and `x5u`—as attacker-controlled input.
+   *
+   * The method fails if the token does not contain a decodable compact-JWT header.
+   *
+   * @throws Error if the call fails (the message names the reason); the full log is in
+   * {@link Jwt.lastErrorText}.
+   */
+  getHeader(token: string): string
+
+  /**
+   * Decodes and returns the claims-set JSON from the second segment of the compact JWT. For a token
+   * in the form `header.payload.signature`, this method Base64URL-decodes the `payload` segment and
+   * returns the resulting JSON text.
+   *
+   * **Decoding is not validation:** This method does not verify the signature, token lifetime,
+   * issuer, audience, nonce, or any other claim. Use the appropriate signature-verification method
+   * first, then apply the claim checks required by the application.
+   *
+   * The method fails if the token does not contain a decodable compact-JWT payload.
+   *
+   * @throws Error if the call fails (the message names the reason); the full log is in
+   * {@link Jwt.lastErrorText}.
+   */
+  getPayload(token: string): string
+
+  /**
+   * Checks the JWT `exp` (expiration time) and `nbf` (not before) claims against the current system
+   * time. It returns `true` when every present time constraint permits the token to be used, and
+   * `false` when the token is expired, is not yet valid, or its relevant time data cannot be
+   * processed.
+   *
+   * ClaimValidity rule
+   *
+   * | `exp` |  | The token is not accepted on or after the expiration time. |
+   *
+   * | `nbf` |  | The token is not accepted before the not-before time. |
+   *
+   * `leeway` is a number of seconds allowed for clock skew. Keep it small; a few minutes is
+   * typical. The method checks whichever of `exp` and `nbf` are present and does not require either
+   * claim to exist.
+   *
+   * **Time checking is separate from signature verification:** `IsTimeValid` does not verify the
+   * JWT signature and does not validate `iss`, `aud`, `sub`, `iat`, `jti`, nonce values, or
+   * application-specific claims. A normal validation workflow verifies the signature, checks time
+   * constraints, and then validates all required claims.
+   */
+  isTimeValid(jwt: string, leeway: number): boolean
+
+  /**
+   * Verifies the signature of a compact JWT signed with the shared secret in `password`. This
+   * method accepts only the HMAC algorithms `HS256`, `HS384`, and `HS512`. It rejects `none` and
+   * algorithms intended for asymmetric keys.
+   *
+   * Chilkat reads the token's `alg` value, computes the corresponding HMAC over the encoded header
+   * and payload, and compares the result with the signature segment. The method returns `true` only
+   * when the signature matches.
+   *
+   * **Signature verification only:** A successful result does not validate expiration, not-before
+   * time, issuer, audience, subject, or any other claim. Call `IsTimeValid` and perform the
+   * application's required claim checks separately.
+   *
+   * **Enforce the expected algorithm:** Applications should inspect the verified header and require
+   * the specific HMAC algorithm allowed by their protocol rather than accepting any algorithm
+   * merely because this method supports it.
+   *
+   * @throws Error if the call fails (the message names the reason); the full log is in
+   * {@link Jwt.lastErrorText}.
+   */
+  verifyJwt(token: string, password: string): void
+
+  /**
+   * Verifies the signature of a compact JWT using `key`. The public key must match the private key
+   * that created the signature and must be compatible with the algorithm named by the token's `alg`
+   * header.
+   *
+   * JOSE algorithmVerification key
+   *
+   * | `RS256`, `RS384`, `RS512` |  | RSA public key for RSASSA-PKCS1-v1_5. |
+   *
+   * | `PS256`, `PS384`, `PS512` |  | RSA public key for RSASSA-PSS. |
+   *
+   * | `ES256`, `ES384`, `ES512` |  | EC public key compatible with the ECDSA algorithm. |
+   *
+   * | `EdDSA` |  | Ed25519 public key. Ed25519 verification requires Chilkat v9.5.0.84 or later. |
+   *
+   * The method returns `true` only when the signature is valid. It returns `false` for a malformed
+   * token, unsupported or incompatible algorithm/key combination, incorrect key, or invalid
+   * signature. The unsecured `none` algorithm is rejected.
+   *
+   * **Use a trusted key-selection process:** Do not automatically trust a key URL or key identifier
+   * taken from an unverified JWT header. Select the verification key from trusted configuration or
+   * a securely obtained and validated key set, and enforce the expected algorithm.
+   *
+   * **Claims are not checked:** Signature validity proves only that the token was signed by the
+   * holder of the corresponding private key and was not modified. Validate time, issuer, audience,
+   * nonce, and all other required claims separately.
+   *
+   * @throws Error if the call fails (the message names the reason); the full log is in
+   * {@link Jwt.lastErrorText}.
+   */
+  verifyJwtPk(token: string, key: PublicKey): void
+
+  /**
+   * Creates a signed JWT using the private key associated with `cert`. The certificate must provide
+   * access to an RSA or EC private key compatible with the `alg` value in `header`.
+   *
+   * `header` may be a complete JOSE header JSON object or the shorthand `RS256`, `RS384`, `RS512`,
+   * `PS256`, `PS384`, `PS512`, `ES256`, `ES384`, or `ES512`. `payload` is the JSON claims set.
+   * PS256/384/512 support was added in Chilkat v10.0.0.
+   *
+   * On success, the result is a compact JWS in the form
+   * `base64url(header).base64url(payload).base64url(signature)`.
+   *
+   * **Private-key access is required:** A certificate containing only the public key cannot create
+   * a signature. Signing can also fail when the private key exists but is not accessible, is
+   * nonfunctional, requires unavailable user interaction, or is incompatible with the selected
+   * algorithm.
+   *
+   * **Certificate trust is a verifier decision:** Creating a JWT with a certificate-backed key does
+   * not by itself establish that recipients should trust that certificate. The verifier must obtain
+   * the correct public key or certificate through a trusted mechanism and apply any required
+   * certificate validation policy.
+   *
+   * @throws Error if the call fails (the message names the reason); the full log is in
+   * {@link Jwt.lastErrorText}.
+   */
+  createJwtCert(header: string, payload: string, cert: Cert): string
+}

package/src/specs/Log.nitro.ts

@@ -0,0 +1,258 @@
+// Generated by ReactNativeNs.RnGenerator -- do not edit.
+import type { HybridObject } from 'react-native-nitro-modules'
+
+/**
+ * Build readable structured diagnostic logs with nested context and tagged values.
+ *
+ * `Log` is a lightweight structured logging helper for
+ * creating readable diagnostic logs from application code. It can record nested
+ * operation contexts, informational messages, error messages, timestamps,
+ * integers, 64-bit integers, tagged values, binary data, Base64 data, hex data,
+ * shortened data previews, and computed hashes. It is useful when code needs a
+ * clear step-by-step record of operations, inputs, outputs, and diagnostic
+ * values for troubleshooting.
+ *
+ * **Nested operation context**
+ *
+ * Use `EnterContext` and `LeaveContext` to group log
+ * entries under readable operation names.
+ *
+ * **Messages and errors**
+ *
+ * Add informational messages, error messages, and tagged text values to
+ * explain what the application is doing.
+ *
+ * **Numbers and timestamps**
+ *
+ * Log integers, 64-bit integers, timestamps, and date/time values when
+ * tracing state changes or timing-sensitive workflows.
+ *
+ * **Binary diagnostics**
+ *
+ * Record binary data as Base64, hex, or shortened previews so byte-level
+ * values can be inspected safely in text logs.
+ *
+ * **Hash logging**
+ *
+ * Compute and log hashes of data when comparing content, verifying
+ * transformations, or avoiding full data dumps.
+ *
+ * **Clear and reuse**
+ *
+ * Clear the log and continue building new diagnostic output during
+ * repeated operations or test runs.
+ *
+ * **Common pattern:**
+ * Create a `Log` object, enter a named context for the operation,
+ * log the important values and decisions as the code runs, leave the context,
+ * and inspect the resulting text if troubleshooting is needed. Use
+ * `Log` for application-level diagnostic output; use
+ * `LastErrorText` on Chilkat objects for detailed diagnostics from
+ * Chilkat method calls.
+ *
+ * For an extended overview, see
+ * [Log Class Overview](https://www.chilkatsoft.com/log_class_overview.asp).
+ *
+ * Each `Log` 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 Log()`.
+ */
+export interface Log 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
+
+  // ---- Methods ----
+
+  /**
+   * Clears all existing log entries and starts a new log whose top-level context is named
+   * `initialTag`.
+   *
+   * **Typical use:** Call this at the beginning of an operation or test run, then add entries with
+   * the other `Log*` methods. The completed structured log can be inspected through the Log
+   * object's diagnostic text, such as `LastErrorText`.
+   */
+  clear(initialTag: string): void
+
+  /**
+   * Begins a nested logging context named `tag`. Entries written after this call are grouped inside
+   * the new context until a matching `LeaveContext` is called.
+   *
+   * **Balanced contexts:** Pair each `EnterContext` with `LeaveContext`. Contexts may be nested to
+   * reflect operation hierarchy.
+   */
+  enterContext(tag: string): void
+
+  /**
+   * Ends the current nested logging context and returns logging to its parent context.
+   *
+   * **Empty contexts are omitted:** If nothing was logged after entering the current context,
+   * Chilkat automatically removes that empty context when it is left.
+   */
+  leaveContext(): void
+
+  /**
+   * Adds a tagged text value to the current context. The output associates `tag` with `message`,
+   * making this useful for named values such as filenames, paths, IDs, states, or protocol fields.
+   *
+   * **Sensitive data:** Avoid logging passwords, private keys, access tokens, session secrets, or
+   * other sensitive values unless disclosure is intentional.
+   */
+  logData(tag: string, message: string): void
+
+  /**
+   * Adds a tagged text value to the current context, but limits the logged value to at most the
+   * first `maxNumChars` characters of `message`.
+   *
+   * **Diagnostic previews:** Use this when a value may be very large and only a leading preview is
+   * needed. The original input string is not modified.
+   */
+  logDataMax(tag: string, message: string, maxNumChars: number): void
+
+  /**
+   * Logs the current date and time under `tag` using an RFC 822-style date/time representation. If
+   * `gmt` is `true`, the logged time is GMT/UTC; otherwise local system time is used.
+   *
+   * **Date/time vs. timestamp:** Use `LogDateTime` for a calendar date with timezone context. Use
+   * `LogTimestamp` for a time-of-day marker.
+   */
+  logDateTime(tag: string, gmt: boolean): void
+
+  /**
+   * Adds `message` as an error entry in the current logging context.
+   *
+   * **Application diagnostics:** This is application-defined logging. It is separate from
+   * `LastErrorText` produced by other Chilkat objects when their operations fail.
+   */
+  logError(message: string): void
+
+  /**
+   * Adds `message` as an informational entry in the current logging context.
+   *
+   * **Structured tracing:** Use informational entries for significant steps and decisions. Use
+   * `LogData` when the entry is better represented as a named value.
+   */
+  logInfo(message: string): void
+
+  /**
+   * Adds the integer `value` to the current log under `tag`.
+   */
+  logInt(tag: string, value: number): void
+
+  /**
+   * Adds the signed 64-bit integer `value` to the current log under `tag`.
+   *
+   * **64-bit values:** Useful for values such as large byte counts, file sizes, sequence numbers,
+   * or timestamps that can exceed ordinary integer ranges.
+   *
+   * 64-bit integers are passed as JavaScript numbers (exact up to 2^53).
+   */
+  logInt64(tag: string, value: number): void
+
+  /**
+   * Logs the current time-of-day under `tag` in `HH:MM:SS:mmm` form, where `mmm` represents
+   * milliseconds.
+   *
+   * **Timing note:** This is a time-of-day marker, not a monotonic elapsed-time measurement.
+   */
+  logTimestamp(tag: string): void
+
+  /**
+   * Encodes `szByteData` bytes beginning at `pByteData` as hexadecimal text and logs the result
+   * under `tag`.
+   *
+   * **C++ byte buffer:** This form accepts a pointer and explicit byte count. The caller must
+   * supply a valid buffer containing at least `szByteData` readable bytes.
+   */
+  logDataHex2(tag: string, byteData: ArrayBuffer): void
+
+  /**
+   * Encodes `szByteData` bytes beginning at `pByteData` as Base64 and logs the result under `tag`.
+   *
+   * **C++ byte buffer:** This form accepts a pointer and explicit byte count. Base64 is printable
+   * encoding only; it does not protect the logged data.
+   */
+  logDataBase64_2(tag: string, byteData: ArrayBuffer): void
+
+  /**
+   * Computes a hash of `szByteData` bytes beginning at `pByteData` and logs the digest as
+   * hexadecimal text under `tag`. Supported values for `hashAlg` are `SHA1`, `SHA256`, `SHA384`,
+   * `SHA512`, and `MD5`.
+   *
+   * **Useful for comparison:** A digest is often preferable to dumping a large binary value when
+   * the goal is to determine whether two byte sequences are identical.
+   *
+   * **Security note:** `MD5` and `SHA1` are not suitable when cryptographic collision resistance is
+   * required. Prefer SHA-256 or stronger for security-sensitive hashing.
+   */
+  logHash2(tag: string, hashAlg: string, byteData: ArrayBuffer): void
+}