unjwt 0.8.5 → 0.9.1

package/dist/_chunks/index2.d.mts

@@ -1,206 +1,99 @@
 import "./error.mjs";
-import { ContentEncryptionAlgorithm, DeriveJWKOptions, DeriveJWKReturn, DeriveKeyOptions, DeriveKeyReturn, GenerateJWKOptions, GenerateJWKReturn, GenerateKeyAlgorithm, GenerateKeyOptions, GenerateKeyReturn, ImportedKey, ImportedPEMJWK, JWK, JWKAlgorithm, JWKCacheAdapter, JWKMetadata, JWKPEMAlgorithm, JWKSet, JWK_Asymmetric, JWK_ECDH_ES, JWK_EC_Private, JWK_EC_Public, JWK_PBES2, JWK_oct, KeyManagementAlgorithm, PEMType, ToPublicJWKReturn, UnwrapKeyOptions, UnwrapKeyResult, UnwrappingKeyFor, WrapKeyOptions, WrapKeyResult, WrappingKeyFor } from "./index.mjs";
-import "./index3.mjs";
+import { ContentEncryptionAlgorithm, JOSEPayload, JOSEPayloadMode, JWEDecryptJWK, JWEDecryptOptions, JWEDecryptResult, JWEEncryptJWK, JWEEncryptOptions, JWEFlattenedSerialization, JWEGeneralSerialization, JWEKeyLookup, JWEMultiDecryptKey, JWEMultiDecryptOptions, JWEMultiDecryptResult, JWEMultiEncryptOptions, JWEMultiRecipient, JWKSet, JWTClaims, KeyManagementAlgorithm, PayloadOf } from "./index.mjs";
+import "./limits.mjs";
 /**
- * Default JWK import cache, keyed by JWK object identity: a copied JWK misses it, and a JWK
- * mutated in place keeps serving the old `CryptoKey`. Rotate by replacing the object.
- */
-export declare class WeakMapJWKCache implements JWKCacheAdapter {
-  private readonly _map;
-  get(jwk: JWK, alg: JWKAlgorithm): CryptoKey | undefined;
-  set(jwk: JWK, alg: JWKAlgorithm, key: CryptoKey): void;
-}
-/**
- * Replaces the JWK import cache used by `importKey`, or disables it with `false`.
- *
- * A cache shared across JWK objects keys on the RFC 7638 thumbprint, the pair half (`d` present)
- * and `alg`: the thumbprint covers public members only, and a `kid` may name different keys.
- * `get` and `set` may return promises.
- *
- * @example
- * ```ts
- * const cacheKey = async (jwk: JWK, alg: JWKAlgorithm) =>
- *   `${await thumbprint(jwk)}:${"d" in jwk ? "private" : "public"}:${alg}`;
- * const map = new Map<string, CryptoKey>();
- * configureJWKCache({
- *   get: async (jwk, alg) => map.get(await cacheKey(jwk, alg)),
- *   set: async (jwk, alg, key) => {
- *     map.set(await cacheKey(jwk, alg), key);
- *   },
- * });
- * ```
- */
-export declare function configureJWKCache(cache: JWKCacheAdapter | false): void;
-/** Resets the JWK import cache to a fresh `WeakMapJWKCache`. */
-export declare function clearJWKCache(): void;
-/** Imports the secret of an `oct` JWK as a `CryptoKey` under `algorithm` and `usage`. */
-export declare function importKey(key: JWK_oct, options: {
-  asCryptoKey: true;
-  /** Algorithm to import the key as (e.g. `{ name: "AES-GCM", length: 256 }`). */
-  algorithm: Parameters<typeof crypto.subtle.importKey>[2];
-  usage: KeyUsage[];
-  /** Mark the key as extractable. Defaults to `false`. */
-  extractable?: boolean;
-}): Promise<CryptoKey>;
-/**
- * Imports key material: a `CryptoKey` or `Uint8Array` is returned as is, an `oct` JWK as its raw
- * bytes, an asymmetric JWK as a `CryptoKey` under its own `alg` or the hint. A string throws
- * `ERR_JWK_INVALID`.
- *
- * `expect` and `extractable` apply to asymmetric keys only; `expect` rejects the other pair half
- * with `ERR_JWK_INVALID`. A JWK's `alg` is authoritative (RFC 7517 §4.4): a different requested
- * `alg` throws `ERR_JWK_INVALID`, except an `oct` JWK declaring a content encryption `alg` under
- * `"dir"`.
- */
-export declare function importKey<K extends CryptoKey | JWK | Uint8Array<ArrayBuffer>>(key: K, options?: JWKAlgorithm | {
-  /** Algorithm hint. Required when `key.alg` is absent on an asymmetric JWK. */
-  alg?: JWKAlgorithm;
-  /** Reject on shape mismatch instead of silently importing. */
-  expect?: "public" | "private";
-  /** Defaults to `false` for private, `true` for public material; JWK `ext: false` wins. */
-  extractable?: boolean;
-}): Promise<ImportedKey<K>>;
-/**
- * Returns the JWKs of a JWK Set, dropping non-JWK entries, optionally narrowed by `filter`.
- * An invalid set throws `ERR_JWK_INVALID`.
- */
-export declare function getJWKsFromSet(jwkSet: JWKSet, filter?: (jwk: JWK) => boolean): JWK[];
-/**
- * Generates a key for a JWA algorithm: a `CryptoKey` for symmetric algorithms, raw bytes for
- * the `A*CBC-HS*` composites, a `CryptoKeyPair` for asymmetric ones; with `toJWK: true`, a JWK
- * (or JWK pair) named by the `kid` option or its RFC 7638 thumbprint. PBES2, `"dir"` and `"none"` are refused.
- *
- * @param options
- *   - `extractable?` — defaults to `true`; ignored when `toJWK` is set.
- *   - `kid?` — with `toJWK`, a string set verbatim or `false` for no `kid`, either skipping the
- *     thumbprint digest; anything else throws `ERR_INVALID_OPTION`.
- *   - `keyUsage?` — narrows the usages derived from `alg`; leaving either half of a pair with
- *     no usage throws `ERR_INVALID_OPTION`.
- *   - `modulusLength?` — RSA only; defaults to `2048`.
- *   - `publicExponent?` — RSA only; big-endian bytes, defaults to `0x010001`.
- *   - `namedCurve?` — EC/OKP only; defaults to `"P-256"` / `"Ed25519"`. One that contradicts
- *     the curve `ES*` or `Ed25519` names throws `ERR_INVALID_OPTION`.
- */
-export declare function generateKey<TAlg extends GenerateKeyAlgorithm, ToJWK extends boolean = false, Kid extends string | false = string>(alg: TAlg, options?: GenerateKeyOptions<ToJWK, Kid>): Promise<GenerateKeyReturn<TAlg, GenerateKeyOptions<ToJWK, Kid>>>;
-/**
- * Generates a JWK (or JWK pair) for a JWA algorithm, its `kid` the caller's, none with
- * `kid: false`, or else its RFC 7638 thumbprint. PBES2, `"dir"` and `"none"` are refused.
- *
- * @param options
- *   - `keyUsage?`, `modulusLength?` (default `2048`), `publicExponent?` (default `0x010001`),
- *     `namedCurve?` (default `"P-256"` / `"Ed25519"`); a narrowing that empties a pair half or
- *     a curve that contradicts `alg` throws `ERR_INVALID_OPTION`.
- *   - `kid?` — a string set verbatim or `false` for no `kid`, either skipping the thumbprint
- *     digest; anything else throws `ERR_INVALID_OPTION`.
- *   - JWK metadata (`use`, `x5c`, `x5t`, `x5t#S256`, `x5u`) is merged onto the result;
- *     `alg`, `kty`, `key_ops`, `ext` and key-material members are reserved (`ERR_INVALID_OPTION`).
- */
-export declare function generateJWK<TAlg extends GenerateKeyAlgorithm, Kid extends string | false = string>(alg: TAlg, options?: GenerateJWKOptions<Kid> & Omit<JWKMetadata, "kid">): Promise<GenerateJWKReturn<TAlg, Kid>>;
-/**
- * Derives an AES-KW key from a password with PBKDF2 per PBES2 (RFC 7518 §4.8).
- *
- * @param options
- *   - `alg` — a PBES2 algorithm; any other throws `ERR_JWK_UNSUPPORTED`.
- *   - `salt` — PBKDF2 salt (`p2s`), at least 8 octets (RFC 7518 §4.8.1.1).
- *   - `iterations` — PBKDF2 count (`p2c`), an integer of at least 1000 (RFC 7518 §4.8.1.2);
- *     anything else throws `ERR_INVALID_OPTION`.
- *   - `keyUsage?` — defaults to `["wrapKey", "unwrapKey"]`.
- *   - `extractable?` — defaults to `false`; ignored when `toJWK` is set.
- *   - `toJWK?` — return a `JWK_oct` carrying the inner AES-KW `alg` instead of a `CryptoKey`.
- */
-export declare function deriveKeyFromPassword<TOptions extends DeriveKeyOptions>(password: string | Uint8Array<ArrayBuffer>, options: TOptions): Promise<DeriveKeyReturn<TOptions, TOptions["alg"]>>;
-/**
- * Derives a `JWK_oct` from a password per PBES2 (RFC 7518 §4.8); its `alg` is the inner AES-KW
- * variant and its `kid` the caller's, none with `kid: false`, or else its RFC 7638 thumbprint.
- *
- * @param options
- *   - `alg` (PBES2 only, else `ERR_JWK_UNSUPPORTED`), `salt` (at least 8 octets), `iterations`
- *     (integer of at least 1000, else `ERR_INVALID_OPTION`), `keyUsage?` (default
- *     `["wrapKey", "unwrapKey"]`).
- *   - `kid?` — a string set verbatim or `false` for no `kid`, either skipping the thumbprint
- *     digest; anything else throws `ERR_INVALID_OPTION`.
- *   - JWK metadata (`use`, `x5c`, `x5t`, `x5t#S256`, `x5u`) is merged onto the result;
- *     `alg`, `kty`, `key_ops`, `ext` and key-material members are reserved (`ERR_INVALID_OPTION`).
- */
-export declare function deriveJWKFromPassword<TAlg extends JWK_PBES2, Kid extends string | false = string>(password: string | Uint8Array<ArrayBuffer>, options: DeriveJWKOptions<TAlg, Kid> & Omit<JWKMetadata, "kid">): Promise<DeriveJWKReturn<TAlg, Kid>>;
-/**
- * Exports an extractable `CryptoKey` as a JWK, merging optional `jwkParams` metadata.
- *
- * The `alg` is WebCrypto's, which knows no JOSE roles: an AES-GCM key minted for `A128GCMKW`
- * exports as `A128GCM`, so key-wrapping keys are minted with `generateJWK` instead.
+ * Encrypts `payload` once for several recipients and returns a JWE General JSON Serialization (RFC 7516 §7.2.1).
+ * Each recipient's `alg` comes from its JWK's `alg`. `enc` defaults to `A256GCM`.
+ * A non-empty `aad` is authenticated with the content and written as the `aad` member.
  *
- * @throws `ERR_INVALID_OPTION` if `key` is not a `CryptoKey` or `jwkParams` sets a reserved member
- *   (`alg`, `kty`, `key_ops`, `ext`, key material); `ERR_JWK_INVALID` for a non-extractable key.
+ * @throws `ERR_JWE_INVALID` if `recipients` is empty or not an array, or `enc` is unsupported.
+ * @throws `ERR_JWE_RECIPIENT_ALG_INFERENCE` if a recipient key is not a JWK or has no `alg`.
+ * @throws `ERR_JWE_ALG_FORBIDDEN_IN_MULTI` if a recipient uses `dir` or bare `ECDH-ES`.
+ * @throws `ERR_JWE_ALG_NOT_ALLOWED` if a recipient `alg` is not a supported key management algorithm.
+ * @throws `ERR_JWE_HEADER_PARAMS_NOT_DISJOINT` if one parameter is set in more than one header.
+ * @throws `ERR_JWK_INVALID` if a recipient key cannot serve its `alg`.
+ * @throws `ERR_INVALID_OPTION` if an option is malformed, a header sets `zip`, `cek` or `contentEncryptionIV` has the wrong length, or a time option is set on a string or bytes payload.
+ * @throws `ERR_JWT_CLAIM_INVALID` if both members of a time option pair are set, or `cnf.jwk` is not a public JWK.
  */
-export declare function exportJWK<T extends JWK = JWK>(key: CryptoKey, jwkParams?: JWKMetadata): Promise<T>;
-/** @deprecated Use `exportJWK`; removed in 0.9.0. */
-export declare function exportKey<T extends JWK = JWK>(key: CryptoKey, jwkParams?: JWKMetadata): Promise<T>;
+export declare function encryptMulti(payload: JOSEPayload, recipients: JWEMultiRecipient[], options?: JWEMultiEncryptOptions): Promise<JWEGeneralSerialization>;
 /**
- * Utility to derive the public half of an asymmetric JWK, or throw if the input is not asymmetric.
+ * Decrypts a JWE General (RFC 7516 §7.2.1) or Flattened (§7.2.2) JSON Serialization and returns the first recipient that opens.
+ * The protected header, the shared unprotected header and the content segments are checked first and throw at once.
+ * Recipients are then tried in order, and a failure scoped to one recipient moves on to the next.
+ * Once a recipient opens, a payload or claim failure throws at once.
+ * The payload type follows `options.payload`.
  *
- * @param jwk An asymmetric JWK (EC, OKP, RSA) with a private scalar (`d`).
- * @throws `ERR_JWK_INVALID` if the input is not an asymmetric JWK.
- * @returns A JWK with the same public members, without the private scalar or a `k` member.
+ * @throws its own error if the only recipient fails, as `decrypt` would.
+ * @throws `ERR_JWE_DECRYPTION_FAILED` if none of several recipients opens, with one `JWTError` per recipient as `cause`, in order.
+ * @throws `ERR_JWE_NO_MATCHING_RECIPIENT` if `strictRecipientMatch` is set and no recipient fits the key.
+ * @throws `ERR_JWE_INVALID_SERIALIZATION` if the object is not a General or Flattened JWE.
+ * @throws `ERR_JWE_INVALID` if the recipients exceed `limits.recipients`, or a shared header or content segment is invalid.
+ * @throws `ERR_JWE_ALG_NOT_ALLOWED` if `enc` is outside `encryptionAlgorithms`.
+ * @throws `ERR_JWK_KEY_NOT_FOUND` if the key trials exceed `limits.keyAttempts`.
+ * @throws `ERR_INVALID_OPTION` if an option is malformed, a claim option is set where claims are not validated, or `returnCek` meets a non-extractable CEK.
+ * @throws `ERR_JWT_EXPIRED` if `exp` has passed or the token is older than `maxTokenAge`.
+ * @throws `ERR_JWT_NBF` if `nbf` is in the future.
+ * @throws `ERR_JWT_CLAIM_INVALID` if a claim does not match its option or has the wrong type.
+ * @throws `ERR_JWT_CLAIM_MISSING` if a claim in `requiredClaims` or one an option checks is absent.
  */
-export declare function toPublicJWK<T extends JWK_Asymmetric>(jwk: T): ToPublicJWKReturn<T>;
+export declare function decryptMulti<T extends object = JWTClaims>(jwe: JWEGeneralSerialization | JWEFlattenedSerialization, keyOrLookup: JWEMultiDecryptKey, options?: JWEMultiDecryptOptions<"json">): Promise<JWEMultiDecryptResult<T>>;
+/** Decrypts a JWE JSON Serialization whose plaintext decodes under `options.payload`. See {@link PayloadOf}. */
+export declare function decryptMulti<Mode extends JOSEPayloadMode = JOSEPayloadMode>(jwe: JWEGeneralSerialization | JWEFlattenedSerialization, keyOrLookup: JWEMultiDecryptKey, options?: JWEMultiDecryptOptions<Mode>): Promise<JWEMultiDecryptResult<PayloadOf<Mode>>>;
 /**
- * Wraps a CEK under a JWA key management algorithm; the result shape follows `alg`.
+ * Converts a General JWE with exactly one recipient to the Flattened form (RFC 7516 §7.2.2).
  *
- * @param wrappingKey A `CryptoKey`, a JWK, or for PBES2 a password string or bytes.
- * @param options `alg` plus its parameters (`p2s`/`p2c` for PBES2, `ecdh` for ECDH-ES, …).
+ * @throws `ERR_JWE_INVALID_SERIALIZATION` if the input has no `recipients` array, or not exactly one recipient.
  */
-export declare function wrapKey<TAlg extends KeyManagementAlgorithm>(keyToWrap: CryptoKey | Uint8Array<ArrayBuffer>, wrappingKey: WrappingKeyFor<TAlg>, options: WrapKeyOptions<TAlg>): Promise<WrapKeyResult<TAlg>>;
+export declare function generalToFlattened(jwe: JWEGeneralSerialization): JWEFlattenedSerialization;
 /**
- * Unwraps a CEK under a JWA key management algorithm.
+ * Encrypts `payload` and returns a JWE Compact Serialization (RFC 7516 §7.1).
+ * `key` is a `CryptoKey`, a JWK, raw bytes, or a password string for PBES2.
+ * Without `alg`, a password uses `PBES2-HS256+A128KW` and an `oct` JWK whose `alg` is an `enc` uses `dir`.
+ * Any other JWK uses its own `alg`.
+ * Without `enc`, the JWK's `enc` applies, else `A256GCM`. For `dir`, `enc` comes from the CEK JWK.
  *
- * @param unwrappingKey A `CryptoKey`, a JWK, or for PBES2 a password string or bytes.
- * @param options `alg`, `format?` (`"cryptokey"` by default, or `"raw"`), plus the algorithm's
- *   parameters (`iv`/`tag`, `p2s`/`p2c`, `epk`, …).
- * @throws `ERR_JWE_DECRYPTION_FAILED` for any failed unwrap, its cause undisclosed (RFC 7516
- *   §11.5); `ERR_INVALID_OPTION` for a malformed `wrappedKey` or `options`; `ERR_JWE_INVALID` for
- *   missing or malformed algorithm parameters.
+ * @throws `ERR_JWE_ALG_MISSING` if no `alg` is given and none can be inferred.
+ * @throws `ERR_JWE_ENC_MISSING` if `alg` is `dir` and neither `enc` nor the JWK names one.
+ * @throws `ERR_JWE_ALG_NOT_ALLOWED` if `alg` is `"none"` or not a supported key management algorithm.
+ * @throws `ERR_JWE_INVALID` if `enc` is not a supported content encryption algorithm.
+ * @throws `ERR_JWK_INVALID` if the key cannot serve `alg`, or a string key is used without PBES2.
+ * @throws `ERR_INVALID_OPTION` if an option is malformed, `cek` or `contentEncryptionIV` has the wrong length, or a time option is set on a string or bytes payload.
+ * @throws `ERR_JWT_CLAIM_INVALID` if both members of a time option pair are set, or `cnf.jwk` is not a public JWK.
  */
-export declare function unwrapKey<TOptions extends UnwrapKeyOptions>(wrappedKey: Uint8Array<ArrayBuffer>, unwrappingKey: UnwrappingKeyFor<TOptions["alg"]>, options: TOptions): Promise<UnwrapKeyResult<TOptions>>;
-/**
- * Imports a PEM key as a JWK carrying `alg`. The type follows the label — `PRIVATE KEY`
- * (PKCS#8), `PUBLIC KEY` (SPKI), `CERTIFICATE` (X.509, only its SPKI kept) — unless
- * `options.pemType` overrides it. The JWK holds the key material in plain JavaScript.
- *
- * @throws `ERR_JWK_INVALID` if the type cannot be inferred or does not match the label;
- *   `ERR_JWK_UNSUPPORTED` for an unknown `pemType`; `ERR_INVALID_OPTION` if `jwkParams` sets
- *   `alg`, `kty`, `key_ops`, `ext` or a key-material member.
- */
-export declare function importPEM<A extends JWKPEMAlgorithm, Type extends PEMType | undefined = undefined>(pem: string, alg: A, options?: {
-  /** PEM type. Inferred from the PEM label when omitted, which leaves the result public or private. */
-  pemType?: Type;
-  /** Additional JWK properties merged into the exported key (e.g. `kid`). */
-  jwkParams?: JWKMetadata;
-}): Promise<ImportedPEMJWK<A, Type>>;
-/**
- * Exports an asymmetric JWK as PEM: PKCS#8 when it carries `d`, SPKI otherwise.
- *
- * @throws `ERR_JWK_UNSUPPORTED` for `oct` JWKs or an unknown format or algorithm;
- *   `ERR_JWK_INVALID` for a missing `alg` or a `pemFormat` that contradicts the JWK's half.
- */
-export declare function exportPEM(jwk: JWK, options?: {
-  /** PEM format. Inferred from the JWK shape when omitted. */
-  pemFormat?: "pkcs8" | "spki";
-  /** Algorithm hint used when `jwk.alg` is absent. */
-  alg?: JWKPEMAlgorithm;
+export declare function encrypt(payload: JOSEPayload, key: JWEEncryptJWK | string | Uint8Array<ArrayBuffer>, options?: JWEEncryptOptions): Promise<string>;
+export declare function encrypt(payload: JOSEPayload, key: CryptoKey | Extract<JWEEncryptJWK, {
+  kty: "oct";
+}> | Uint8Array<ArrayBuffer>, options: JWEEncryptOptions & {
+  alg: "dir";
+  enc: ContentEncryptionAlgorithm;
+}): Promise<string>;
+export declare function encrypt(payload: JOSEPayload, key: CryptoKey, options: JWEEncryptOptions & {
+  alg: KeyManagementAlgorithm;
+  enc: ContentEncryptionAlgorithm;
+}): Promise<string>;
+export declare function encrypt(payload: JOSEPayload, key: CryptoKey | JWEEncryptJWK | string | Uint8Array<ArrayBuffer>, options: JWEEncryptOptions & {
+  alg: KeyManagementAlgorithm;
+  enc: ContentEncryptionAlgorithm;
 }): Promise<string>;
 /**
- * Derives ECDH-ES key material (RFC 7518 §4.6): ECDH followed by the Concat KDF.
+ * Decrypts a JWE Compact Serialization (RFC 7516 §7.1) with a key, a JWK Set, a password or a key lookup function.
+ * The header `alg` must be in `algorithms`, else match the JWK's `alg`, else fit the key type.
+ * `encryptionAlgorithms` restricts the header `enc`.
+ * The payload type follows `options.payload`: claims `T` for `"json"` (default), `string`, or `Uint8Array`.
+ * With `returnCek`, the result includes the CEK and the AAD.
  *
- * @param publicKey The recipient's static public key (the ephemeral one when decrypting).
- * @param privateKey The ephemeral private key (the recipient's static one when decrypting).
+ * @throws `ERR_JWE_INVALID` if the token is malformed, uses `zip`, has the wrong `typ`, an unrecognized `crit` member, or an unsupported `enc`.
+ * @throws `ERR_JWE_INVALID` if a PBES2 `p2c` is outside the iteration bounds or `limits.pbes2Iterations`.
+ * @throws `ERR_JWE_ALG_NOT_ALLOWED` if the header `alg` is unsupported or not allowed, or `enc` is outside `encryptionAlgorithms`.
+ * @throws `ERR_JWE_DECRYPTION_FAILED` if the CEK does not unwrap or the content does not decrypt.
+ * @throws `ERR_JWK_INVALID` if no key is given, or the key cannot serve the header `alg`.
+ * @throws `ERR_JWK_KEY_NOT_FOUND` if the lookup returns `undefined` or throws an error that is not a `JWTError` (as `cause`), or a JWK Set has no candidate.
+ * @throws `ERR_INVALID_OPTION` if an option is malformed, a claim option is set where claims are not validated, or `returnCek` meets a non-extractable CEK.
+ * @throws `ERR_JWT_EXPIRED` if `exp` has passed or the token is older than `maxTokenAge`.
+ * @throws `ERR_JWT_NBF` if `nbf` is in the future.
+ * @throws `ERR_JWT_CLAIM_INVALID` if a claim does not match its option or has the wrong type.
+ * @throws `ERR_JWT_CLAIM_MISSING` if a claim in `requiredClaims` or one an option checks is absent.
  */
-export declare function deriveSharedSecret(publicKey: CryptoKey | JWK_EC_Public, privateKey: CryptoKey | JWK_EC_Private, options: {
-  /** Algorithm identifier fed to the concat KDF as `AlgorithmID`. */
-  enc: JWK_ECDH_ES | ContentEncryptionAlgorithm;
-  /** Derived length in bits. Defaults to `enc`'s length; required for `"ECDH-ES"`. */
-  keyLength?: number;
-  /** Agreement PartyUInfo (apu). */
-  partyUInfo?: Uint8Array<ArrayBuffer>;
-  /** Agreement PartyVInfo (apv). */
-  partyVInfo?: Uint8Array<ArrayBuffer>;
-}): Promise<Uint8Array<ArrayBuffer>>;
+export declare function decrypt<T extends object = JWTClaims>(jwe: string, key: CryptoKey | JWKSet | JWEDecryptJWK | string | Uint8Array<ArrayBuffer> | JWEKeyLookup, options?: JWEDecryptOptions<"json">): Promise<JWEDecryptResult<T>>;
+/** Decrypts a JWE Compact Serialization whose plaintext decodes under `options.payload`. See {@link PayloadOf}. */
+export declare function decrypt<Mode extends JOSEPayloadMode = JOSEPayloadMode>(jwe: string, key: CryptoKey | JWKSet | JWEDecryptJWK | string | Uint8Array<ArrayBuffer> | JWEKeyLookup, options?: JWEDecryptOptions<Mode>): Promise<JWEDecryptResult<PayloadOf<Mode>>>;

package/dist/_chunks/index4.d.mts

@@ -1,63 +1,226 @@
 import "./error.mjs";
-import { ContentEncryptionAlgorithm, JOSEPayload, JOSEPayloadMode, JWEDecryptJWK, JWEDecryptOptions, JWEDecryptResult, JWEEncryptJWK, JWEEncryptOptions, JWEFlattenedSerialization, JWEGeneralSerialization, JWEKeyLookup, JWEMultiDecryptKey, JWEMultiDecryptOptions, JWEMultiDecryptResult, JWEMultiEncryptOptions, JWEMultiRecipient, JWKSet, JWTClaims, KeyManagementAlgorithm, PayloadOf } from "./index.mjs";
-import "./limits.mjs";
-/**
- * Encrypt a payload to multiple recipients as JWE General JSON Serialization (RFC 7516 §7.2.1).
- * Each recipient's `alg` comes from `key.alg` (`ERR_JWE_RECIPIENT_ALG_INFERENCE` when absent);
- * `dir` and bare `ECDH-ES` throw `ERR_JWE_ALG_FORBIDDEN_IN_MULTI`.
- */
-export declare function encryptMulti(payload: JOSEPayload, recipients: JWEMultiRecipient[], options?: JWEMultiEncryptOptions): Promise<JWEGeneralSerialization>;
-/**
- * Decrypt a JWE General (RFC 7516 §7.2.1) or Flattened (§7.2.2) JSON Serialization.
- * Recipients are tried in order; per-recipient failures surface only when none unwraps.
- * `strictRecipientMatch` skips recipients the key cannot open and throws
- * `ERR_JWE_NO_MATCHING_RECIPIENT` when none qualifies; a JWK Set with no `kid` candidate
- * throws `ERR_JWK_KEY_NOT_FOUND`. The payload type follows `options.payload`.
- */
-export declare function decryptMulti<T extends object = JWTClaims>(jwe: JWEGeneralSerialization | JWEFlattenedSerialization, keyOrLookup: JWEMultiDecryptKey, options?: JWEMultiDecryptOptions<"json"> & {
-  forceUint8Array?: false;
-}): Promise<JWEMultiDecryptResult<T>>;
-/** @deprecated `forceUint8Array` is replaced by `payload: "bytes"`; removed in v0.9.0. */
-export declare function decryptMulti(jwe: JWEGeneralSerialization | JWEFlattenedSerialization, keyOrLookup: JWEMultiDecryptKey, options: JWEMultiDecryptOptions & {
-  forceUint8Array: true;
-}): Promise<JWEMultiDecryptResult<Uint8Array<ArrayBuffer>>>;
-/** Decrypts a JWE JSON Serialization whose plaintext decodes under `options.payload`; see {@link PayloadOf}. */
-export declare function decryptMulti<Mode extends JOSEPayloadMode = JOSEPayloadMode>(jwe: JWEGeneralSerialization | JWEFlattenedSerialization, keyOrLookup: JWEMultiDecryptKey, options?: JWEMultiDecryptOptions<Mode>): Promise<JWEMultiDecryptResult<PayloadOf<Mode>>>;
-/**
- * Convert a single-recipient General JWE to the Flattened form (RFC 7516 §7.2.2).
- * Throws `ERR_JWE_INVALID_SERIALIZATION` for zero or multiple recipients.
- */
-export declare function generalToFlattened(jwe: JWEGeneralSerialization): JWEFlattenedSerialization;
-/**
- * Encrypt a payload into a JWE Compact Serialization string. `key` is a CryptoKey, a JWK, or
- * a PBES2 password; `alg` is inferred from it when omitted and `enc` defaults to `A256GCM`.
- */
-export declare function encrypt(payload: JOSEPayload, key: JWEEncryptJWK | string | Uint8Array<ArrayBuffer>, options?: JWEEncryptOptions): Promise<string>;
-export declare function encrypt(payload: JOSEPayload, key: CryptoKey | Extract<JWEEncryptJWK, {
-  kty: "oct";
-}> | Uint8Array<ArrayBuffer>, options: JWEEncryptOptions & {
-  alg: "dir";
-  enc: ContentEncryptionAlgorithm;
-}): Promise<string>;
-export declare function encrypt(payload: JOSEPayload, key: CryptoKey, options: JWEEncryptOptions & {
-  alg: KeyManagementAlgorithm;
-  enc: ContentEncryptionAlgorithm;
-}): Promise<string>;
-export declare function encrypt(payload: JOSEPayload, key: CryptoKey | JWEEncryptJWK | string | Uint8Array<ArrayBuffer>, options: JWEEncryptOptions & {
-  alg: KeyManagementAlgorithm;
-  enc: ContentEncryptionAlgorithm;
+import { ContentEncryptionAlgorithm, DeriveJWKOptions, DeriveJWKReturn, DeriveKeyOptions, DeriveKeyReturn, GenerateJWKOptions, GenerateJWKReturn, GenerateKeyAlgorithm, GenerateKeyOptions, GenerateKeyReturn, ImportedKey, ImportedPEMJWK, JWK, JWKAlgorithm, JWKCacheAdapter, JWKMetadata, JWKPEMAlgorithm, JWKSet, JWK_Asymmetric, JWK_ECDH_ES, JWK_EC_Private, JWK_EC_Public, JWK_OKP_Private, JWK_OKP_Public, JWK_PBES2, JWK_oct, KeyManagementAlgorithm, PEMType, ToPublicJWKReturn, UnwrapKeyOptions, UnwrapKeyResult, UnwrappingKeyFor, WrapKeyOptions, WrapKeyResult, WrappingKeyFor } from "./index.mjs";
+import "./index3.mjs";
+/**
+ * The default JWK import cache, keyed by JWK object identity and `alg`. A copied JWK misses it.
+ * A JWK mutated in place keeps returning the old `CryptoKey`: rotate a key by replacing the object.
+ */
+export declare class WeakMapJWKCache implements JWKCacheAdapter {
+  private readonly _map;
+  get(jwk: JWK, alg: JWKAlgorithm): CryptoKey | undefined;
+  set(jwk: JWK, alg: JWKAlgorithm, key: CryptoKey): void;
+}
+/**
+ * Replaces the JWK import cache `importKey` uses, or disables it with `false`.
+ *
+ * A cache shared across JWK objects keys on the RFC 7638 thumbprint, the pair half (`d` present)
+ * and `alg`. The thumbprint covers public members only, and one `kid` may name different keys.
+ * `get` and `set` may return promises.
+ *
+ * @example
+ * ```ts
+ * const cacheKey = async (jwk: JWK, alg: JWKAlgorithm) =>
+ *   `${await thumbprint(jwk)}:${"d" in jwk ? "private" : "public"}:${alg}`;
+ * const map = new Map<string, CryptoKey>();
+ * configureJWKCache({
+ *   get: async (jwk, alg) => map.get(await cacheKey(jwk, alg)),
+ *   set: async (jwk, alg, key) => {
+ *     map.set(await cacheKey(jwk, alg), key);
+ *   },
+ * });
+ * ```
+ */
+export declare function configureJWKCache(cache: JWKCacheAdapter | false): void;
+/** Resets the JWK import cache to a fresh `WeakMapJWKCache`. */
+export declare function clearJWKCache(): void;
+/**
+ * Imports the secret of an `oct` JWK as a `CryptoKey` under `algorithm` and `usage`.
+ * @throws `ERR_JWK_INVALID` if `algorithm` or `usage` is absent, or the secret is too short for the HMAC hash or the JWK `alg`.
+ */
+export declare function importKey(key: JWK_oct, options: {
+  asCryptoKey: true;
+  /** The Web Crypto algorithm to import the key as, such as `{ name: "AES-GCM", length: 256 }`. */
+  algorithm: Parameters<typeof crypto.subtle.importKey>[2];
+  usage: KeyUsage[];
+  /** Whether the key is extractable. @default false */
+  extractable?: boolean;
+}): Promise<CryptoKey>;
+/**
+ * Imports key material. A `CryptoKey` or `Uint8Array` is returned as is, an `oct` JWK as its raw
+ * bytes, an asymmetric JWK as a `CryptoKey` under its own `alg` or the requested one.
+ *
+ * A JWK's `alg` is authoritative (RFC 7517 §4.4). An `oct` JWK with a content encryption `alg`
+ * also serves `"dir"`. A JWK without `alg` must have a `kty` that can serve the requested `alg`.
+ * An `oct` secret must be long enough for its `alg`. A non-`oct` JWK must not have a `k` member.
+ * `expect` and `extractable` apply to asymmetric keys only. Passing `extractable` skips the import cache.
+ *
+ * @throws `ERR_JWK_INVALID` if `key` is a string or not key material, or breaks one of the rules above.
+ */
+export declare function importKey<K extends CryptoKey | JWK | Uint8Array<ArrayBuffer>>(key: K, options?: JWKAlgorithm | {
+  /** The algorithm to import under. Required for an asymmetric JWK without `alg`. */
+  alg?: JWKAlgorithm;
+  /** The pair half the key must be. The other half is `ERR_JWK_INVALID`. */
+  expect?: "public" | "private";
+  /** Whether the `CryptoKey` is extractable. A JWK `ext: false` overrides it. @default false for private keys, true for public keys */
+  extractable?: boolean;
+}): Promise<ImportedKey<K>>;
+/**
+ * Returns the JWKs of a JWK Set without its non-JWK entries, narrowed by `filter` when given.
+ *
+ * @throws `ERR_JWK_INVALID` if `jwkSet` is not a JWK Set.
+ */
+export declare function getJWKsFromSet(jwkSet: JWKSet, filter?: (jwk: JWK) => boolean): JWK[];
+/**
+ * Generates a key for a JWA algorithm. Returns a `CryptoKey` for a symmetric algorithm,
+ * raw bytes for the `A*CBC-HS*` composites and a `CryptoKeyPair` for an asymmetric one.
+ * With `toJWK: true` it returns a JWK, or a `{ privateKey, publicKey }` JWK pair sharing one `kid`.
+ *
+ * @param options
+ *   - `extractable?`: ignored with `toJWK`. Defaults to `true`.
+ *   - `kid?`: with `toJWK`, a string used as is or `false` for no `kid`. Defaults to the RFC 7638 thumbprint.
+ *   - `keyUsage?`: narrows the usages `alg` admits and is written as `key_ops`. Without it the JWK has no `key_ops`.
+ *   - `modulusLength?`: RSA only, at least 2048 bits. Defaults to `2048`.
+ *   - `publicExponent?`: RSA only, big-endian bytes. Defaults to `0x010001`.
+ *   - `namedCurve?`: `ECDH-ES*` and `EdDSA` only. Defaults to `"P-256"` and `"Ed25519"`.
+ *     `ES*` and `Ed25519` fix their curve and accept only that one.
+ * @throws `ERR_JWK_UNSUPPORTED` if `alg` cannot be generated (PBES2, `"dir"`, `"none"`) or `namedCurve` is unsupported.
+ * @throws `ERR_INVALID_OPTION` if an option is invalid for `alg`, or `keyUsage` leaves either half of a pair with no usage.
+ */
+export declare function generateKey<TAlg extends GenerateKeyAlgorithm, ToJWK extends boolean = false, Kid extends string | false = string>(alg: TAlg, options?: GenerateKeyOptions<ToJWK, Kid>): Promise<GenerateKeyReturn<TAlg, GenerateKeyOptions<ToJWK, Kid>>>;
+/**
+ * Generates a JWK for a JWA algorithm, or a `{ privateKey, publicKey }` JWK pair sharing one `kid`.
+ *
+ * @param options
+ *   - `keyUsage?`, `modulusLength?`, `publicExponent?`, `namedCurve?`: as on `generateKey`.
+ *   - `kid?`: a string used as is or `false` for no `kid`. Defaults to the RFC 7638 thumbprint.
+ *   - JWK metadata (`use`, `x5c`, `x5t`, `x5t#S256`, `x5u`) is copied onto each JWK.
+ * @throws `ERR_JWK_UNSUPPORTED` if `alg` cannot be generated (PBES2, `"dir"`, `"none"`) or `namedCurve` is unsupported.
+ * @throws `ERR_INVALID_OPTION` if an option is invalid for `alg`, `keyUsage` leaves a pair half with no usage,
+ *   or the metadata sets `alg`, `kty`, `key_ops`, `ext` or a key material member.
+ */
+export declare function generateJWK<TAlg extends GenerateKeyAlgorithm, Kid extends string | false = string>(alg: TAlg, options?: GenerateJWKOptions<Kid> & Omit<JWKMetadata, "kid">): Promise<GenerateJWKReturn<TAlg, Kid>>;
+/**
+ * Derives an AES-KW key from a password with PBKDF2, as PBES2 does (RFC 7518 §4.8).
+ * A string password or salt is encoded as UTF-8.
+ *
+ * @param options
+ *   - `alg`: a PBES2 algorithm.
+ *   - `salt`: the PBKDF2 salt (`p2s`), at least 8 octets (RFC 7518 §4.8.1.1).
+ *   - `iterations`: the PBKDF2 count (`p2c`), an integer of at least 1000 (RFC 7518 §4.8.1.2).
+ *   - `keyUsage?`: AES-KW usages, written as `key_ops` with `toJWK`. Defaults to `["wrapKey", "unwrapKey"]`.
+ *   - `extractable?`: ignored with `toJWK`. Defaults to `false`.
+ *   - `toJWK?`: returns a `JWK_oct` with the inner AES-KW `alg` (`A128KW` for `PBES2-HS256+A128KW`) instead of a `CryptoKey`.
+ * @throws `ERR_JWK_UNSUPPORTED` if `alg` is not a PBES2 algorithm.
+ * @throws `ERR_INVALID_OPTION` if `password`, `salt` or `iterations` is invalid.
+ */
+export declare function deriveKeyFromPassword<TOptions extends DeriveKeyOptions>(password: string | Uint8Array<ArrayBuffer>, options: TOptions): Promise<DeriveKeyReturn<TOptions, TOptions["alg"]>>;
+/**
+ * Derives a `JWK_oct` from a password, as PBES2 does (RFC 7518 §4.8).
+ * Its `alg` is the inner AES-KW algorithm (`A128KW` for `PBES2-HS256+A128KW`).
+ *
+ * @param options
+ *   - `alg`, `salt`, `iterations`, `keyUsage?`: as on `deriveKeyFromPassword`.
+ *   - `kid?`: a string used as is or `false` for no `kid`. Defaults to the RFC 7638 thumbprint.
+ *   - JWK metadata (`use`, `x5c`, `x5t`, `x5t#S256`, `x5u`) is copied onto the JWK.
+ * @throws `ERR_JWK_UNSUPPORTED` if `alg` is not a PBES2 algorithm.
+ * @throws `ERR_INVALID_OPTION` if `password`, `salt`, `iterations` or `kid` is invalid,
+ *   or the metadata sets `alg`, `kty`, `key_ops`, `ext` or a key material member.
+ */
+export declare function deriveJWKFromPassword<TAlg extends JWK_PBES2, Kid extends string | false = string>(password: string | Uint8Array<ArrayBuffer>, options: DeriveJWKOptions<TAlg, Kid> & Omit<JWKMetadata, "kid">): Promise<DeriveJWKReturn<TAlg, Kid>>;
+/**
+ * Exports an extractable `CryptoKey` as a JWK and copies the `jwkParams` metadata onto it.
+ * The JWK has no `ext` or `key_ops` member.
+ *
+ * The `alg` is the one Web Crypto exports: an AES-GCM key exports as `A128GCM`, even one meant
+ * for `A128GCMKW`. Use `generateJWK` for a key wrapping JWK.
+ *
+ * @throws `ERR_INVALID_OPTION` if `key` is not a `CryptoKey`, or `jwkParams` holds a non-JSON value
+ *   or sets `alg`, `kty`, `key_ops`, `ext` or a key material member.
+ * @throws `ERR_JWK_INVALID` if the key is not extractable.
+ */
+export declare function exportJWK<T extends JWK = JWK>(key: CryptoKey, jwkParams?: JWKMetadata): Promise<T>;
+/**
+ * Returns the public half of an asymmetric JWK.
+ *
+ * @param jwk An asymmetric JWK (EC, OKP, RSA), private or public.
+ * @throws `ERR_JWK_INVALID` if `jwk` is not an asymmetric JWK, holds a non-JSON value, or lacks the public members of its key type.
+ * @returns A copy without the private members. `key_ops` keeps the public operations only (`sign` becomes `verify`).
+ */
+export declare function toPublicJWK<T extends JWK_Asymmetric>(jwk: T): ToPublicJWKReturn<T>;
+/**
+ * Wraps a CEK under a JWA key management algorithm. The result members follow `alg`:
+ * `iv` and `tag` for AES-GCMKW, `p2s` and `p2c` for PBES2, `epk`, `apu` and `apv` for ECDH-ES.
+ *
+ * @param wrappingKey A `CryptoKey` or a JWK. For PBES2, also a password string or bytes.
+ * @param options `alg` plus its parameters (`p2s` and `p2c` for PBES2, `ecdh` for ECDH-ES, …).
+ * @throws `ERR_INVALID_OPTION` if `keyToWrap` is not bytes or a `CryptoKey`, an AES-KW CEK is not
+ *   16 bytes or more in whole 8-byte blocks, or `p2s` or `p2c` is out of range.
+ * @throws `ERR_JWE_INVALID` if PBES2 lacks `p2s` or `p2c`, or `ecdh.enc` is unsupported.
+ * @throws `ERR_JWK_INVALID` if the key does not fit `alg`, a string key is given outside PBES2, or `"ECDH-ES"` lacks `ecdh.enc`.
+ * @throws `ERR_JWK_UNSUPPORTED` if `alg` is not a key management algorithm.
+ */
+export declare function wrapKey<TAlg extends KeyManagementAlgorithm>(keyToWrap: CryptoKey | Uint8Array<ArrayBuffer>, wrappingKey: WrappingKeyFor<TAlg>, options: WrapKeyOptions<TAlg>): Promise<WrapKeyResult<TAlg>>;
+/**
+ * Unwraps a CEK under a JWA key management algorithm. Returns an AES-GCM `CryptoKey` unless
+ * `format` is `"raw"` or `unwrappedKeyAlgorithm` says otherwise. Pass `format: "raw"` for an `A*CBC-HS*` CEK.
+ *
+ * @param unwrappingKey A `CryptoKey` or a JWK. For PBES2, also a password string or bytes.
+ * @param options `alg`, `format?` (`"cryptokey"` by default, or `"raw"`), plus the algorithm's
+ *   parameters (`iv` and `tag`, `p2s` and `p2c`, `epk`, …).
+ * @throws `ERR_JWE_DECRYPTION_FAILED` if the unwrap fails. The cause is not disclosed (RFC 7516 §11.5).
+ * @throws `ERR_INVALID_OPTION` if `wrappedKey` is not a `Uint8Array` or `options` is not an object.
+ * @throws `ERR_JWE_INVALID` if an algorithm parameter is missing or malformed.
+ * @throws `ERR_JWK_INVALID` if the key does not fit `alg`.
+ * @throws `ERR_JWK_UNSUPPORTED` if `alg` is not a key management algorithm.
+ */
+export declare function unwrapKey<TOptions extends UnwrapKeyOptions>(wrappedKey: Uint8Array<ArrayBuffer>, unwrappingKey: UnwrappingKeyFor<TOptions["alg"]>, options: TOptions): Promise<UnwrapKeyResult<TOptions>>;
+/**
+ * Imports a PEM key as a JWK with `alg` set. The type follows the label: `PRIVATE KEY` is
+ * PKCS#8, `PUBLIC KEY` is SPKI, `CERTIFICATE` is X.509 with only its public key kept.
+ * Pass `pemType` to require a type. The returned JWK holds the key material as plain values.
+ *
+ * @throws `ERR_INVALID_OPTION` if `pem` is not a string, `options` is not an object,
+ *   or `jwkParams` sets `alg`, `kty`, `key_ops`, `ext` or a key material member.
+ * @throws `ERR_JWK_INVALID` if the type cannot be inferred, the label does not match `pemType`, or the body is not a key for `alg`.
+ * @throws `ERR_JWK_UNSUPPORTED` if `pemType` is unknown.
+ */
+export declare function importPEM<A extends JWKPEMAlgorithm, Type extends PEMType | undefined = undefined>(pem: string, alg: A, options?: {
+  /** The PEM type. Inferred from the label when omitted, so the result type is either half. */
+  pemType?: Type;
+  /** JWK metadata copied onto the result, such as `kid`. */
+  jwkParams?: JWKMetadata;
+}): Promise<ImportedPEMJWK<A, Type>>;
+/**
+ * Exports an asymmetric JWK as PEM: PKCS#8 when it has a `d` member, SPKI otherwise.
+ *
+ * @throws `ERR_JWK_UNSUPPORTED` if `jwk` is an `oct` JWK, or the format or algorithm is unsupported.
+ * @throws `ERR_JWK_INVALID` if neither `jwk.alg` nor `options.alg` is set, the algorithm does not fit `kty`,
+ *   or `pemFormat` names the other half of the pair.
+ */
+export declare function exportPEM(jwk: JWK, options?: {
+  /** The PEM format. Inferred from the JWK when omitted. */
+  pemFormat?: "pkcs8" | "spki";
+  /** The algorithm used when `jwk.alg` is absent. */
+  alg?: JWKPEMAlgorithm;
 }): Promise<string>;
 /**
- * Decrypt a JWE Compact Serialization string; `key` may be a lookup function.
- * The payload type follows `options.payload` (claims `T` by default).
- * A compact JWE has five sections (RFC 7516 §3).
- */
-export declare function decrypt<T extends object = JWTClaims>(jwe: string, key: CryptoKey | JWKSet | JWEDecryptJWK | string | Uint8Array<ArrayBuffer> | JWEKeyLookup, options?: JWEDecryptOptions<"json"> & {
-  forceUint8Array?: false;
-}): Promise<JWEDecryptResult<T>>;
-/** @deprecated `forceUint8Array` is replaced by `payload: "bytes"`; removed in v0.9.0. */
-export declare function decrypt(jwe: string, key: CryptoKey | JWKSet | JWEDecryptJWK | string | Uint8Array<ArrayBuffer> | JWEKeyLookup, options: JWEDecryptOptions & {
-  forceUint8Array: true;
-}): Promise<JWEDecryptResult<Uint8Array<ArrayBuffer>>>;
-/** Decrypts a compact JWE whose plaintext decodes under `options.payload`; see {@link PayloadOf}. */
-export declare function decrypt<Mode extends JOSEPayloadMode = JOSEPayloadMode>(jwe: string, key: CryptoKey | JWKSet | JWEDecryptJWK | string | Uint8Array<ArrayBuffer> | JWEKeyLookup, options?: JWEDecryptOptions<Mode>): Promise<JWEDecryptResult<PayloadOf<Mode>>>;
+ * Derives ECDH-ES key material (RFC 7518 §4.6): ECDH on an EC or OKP pair, then the Concat KDF.
+ * A JWK is imported under `enc` when `enc` is an `ECDH-ES*` algorithm, else under `"ECDH-ES"`.
+ *
+ * @param publicKey The recipient's static public key, or the ephemeral one when decrypting.
+ * @param privateKey The ephemeral private key, or the recipient's static one when decrypting.
+ * @throws `ERR_JWE_INVALID` if `enc` is neither an `ECDH-ES*` nor a content encryption algorithm.
+ * @throws `ERR_INVALID_OPTION` if `keyLength` is not a positive multiple of 8 up to 8192.
+ * @throws `ERR_JWK_INVALID` if `enc` is `"ECDH-ES"` without `keyLength`, a key is the wrong half or has another `alg`,
+ *   or the keys are not agreement keys on one curve.
+ */
+export declare function deriveSharedSecret(publicKey: CryptoKey | JWK_EC_Public | JWK_OKP_Public, privateKey: CryptoKey | JWK_EC_Private | JWK_OKP_Private, options: {
+  /** The algorithm identifier the Concat KDF uses as `AlgorithmID`. */
+  enc: JWK_ECDH_ES | ContentEncryptionAlgorithm;
+  /** The derived length in bits. Required for `"ECDH-ES"`. @default the key length of `enc` */
+  keyLength?: number;
+  /** The agreement PartyUInfo (`apu`). @default empty */
+  partyUInfo?: Uint8Array<ArrayBuffer>;
+  /** The agreement PartyVInfo (`apv`). @default empty */
+  partyVInfo?: Uint8Array<ArrayBuffer>;
+}): Promise<Uint8Array<ArrayBuffer>>;