@psnext/slingcli 3.0.20260827-1 → 3.3.20260911-1

package/node_modules/jose/dist/types/jwks/remote.d.ts

@@ -1,38 +1,31 @@
-import type * as types from '../types.d.ts';
+import type * as t from '../types.d.ts';
 /**
- * When passed to {@link jwks/remote.createRemoteJWKSet createRemoteJWKSet} this allows the resolver
- * to make use of advanced fetch configurations, HTTP Proxies, retry on network errors, etc.
+ * Configures a custom fetch implementation for remote JWKS retrieval.
  *
- * > Note: Known caveat: Expect Type-related issues when passing the inputs through to fetch-like modules,
- * > they hardly ever get their typings inline with actual fetch, you should `@ts-expect-error` them.
+ * > Note: Fetch-like libraries may have incompatible TypeScript signatures even when they accept the
+ * > supplied arguments at runtime.
  */
 export declare const customFetch: unique symbol;
-/** See {@link customFetch}. */
+/** Custom fetch function. Must return HTTP 200 with a JSON JWKS. See {@link customFetch}. */
 export type FetchImplementation = (
-/** URL the request is being made sent to {@link !fetch} as the `resource` argument */
+/** JWKS URL, passed as the fetch resource. */
 url: string, 
-/** Options otherwise sent to {@link !fetch} as the `options` argument */
+/** Options passed to fetch. */
 options: {
-    /** HTTP Headers */
     headers: Headers;
-    /** The {@link https://developer.mozilla.org/en-US/docs/Web/HTTP/Methods request method} */
     method: 'GET';
     /** See {@link !Request.redirect} */
     redirect: 'manual';
     signal: AbortSignal;
 }) => Promise<Response>;
 /**
- * > Warning: This option has security implications that must be understood, assessed for applicability, and
- * > accepted before use. It is critical that the JSON Web Key Set cache only be writable by your own
- * > code.
+ * Symbol used to configure an externally persisted remote JWKS cache.
  *
- * This option is intended for cloud computing runtimes that cannot keep an in memory cache between
- * their code's invocations. The supplied writable object seeds the resolver's cache and is updated
- * with `jwks` and `uat` after a successful fetch; persist it whenever `uat` changes. Using this in
- * runtimes that can keep an in-memory cache between requests is not desirable.
+ * > Warning: Only trusted application code must be allowed to write this cache; its keys are trusted for
+ * > signature verification.
  */
 export declare const jwksCache: unique symbol;
-/** Options for the remote JSON Web Key Set. */
+/** Remote JWKS resolver options. */
 export interface RemoteJWKSetOptions {
     /**
      * Timeout (in milliseconds) for the HTTP request. When reached the request will be aborted and
@@ -40,13 +33,13 @@ export interface RemoteJWKSetOptions {
      */
     timeoutDuration?: number;
     /**
-     * Duration (in milliseconds) for which no more HTTP requests will be triggered after a previous
-     * successful fetch. Must not be `NaN`. Default is 30000 (30 seconds).
+     * Time in milliseconds after a successful fetch before a missing key can trigger another fetch.
+     * Must not be `NaN`. Defaults to 30000 (30 seconds).
      */
     cooldownDuration?: number;
     /**
-     * Maximum time (in milliseconds) between successful HTTP requests. Default is 600000 (10
-     * minutes). Must not be `NaN`.
+     * Maximum age of cached keys in milliseconds. Defaults to 600000 (10 minutes); `Infinity`
+     * disables expiry. Must not be `NaN`.
      */
     cacheMaxAge?: number | typeof Infinity;
     /** Headers to be sent with the HTTP request. */
@@ -56,18 +49,18 @@ export interface RemoteJWKSetOptions {
     /** See {@link customFetch}. */
     [customFetch]?: FetchImplementation;
 }
-/** See {@link jwksCache}. */
+/** Shape of an externally persisted remote JWKS cache. */
 export interface ExportedJWKSCache {
     /** Current cached JSON Web Key Set */
-    jwks: types.JSONWebKeySet;
-    /** Last updated at timestamp (milliseconds since epoch) */
+    jwks: t.JSONWebKeySet;
+    /** Last successful fetch, in milliseconds since Unix epoch. */
     uat: number;
 }
-/** See {@link jwksCache}. */
+/** Values accepted by the {@link jwksCache} option. */
 export type JWKSCacheInput = ExportedJWKSCache | Record<string, never>;
-/** The key resolution function returned by {@link createRemoteJWKSet}. */
+/** A key resolver created by {@link createRemoteJWKSet}. */
 export interface RemoteJWKSet {
-    (protectedHeader?: types.JWSHeaderParameters, token?: types.FlattenedJWSInput): Promise<types.CryptoKey>;
+    (protectedHeader?: t.JWSHeaderParameters, token?: t.FlattenedJWSInput): Promise<t.CryptoKey>;
     /** Whether the cooldown window following the last successful fetch is still in effect. */
     readonly coolingDown: boolean;
     /**
@@ -83,24 +76,19 @@ export interface RemoteJWKSet {
      */
     reload: () => Promise<void>;
     /**
-     * The currently cached JSON Web Key Set, or `undefined` when none has been fetched or seeded via
-     * {@link jwksCache} yet.
+     * Returns a structured clone of the cached JSON Web Key Set, or `undefined` before keys have been
+     * fetched or seeded via {@link jwksCache}.
      */
-    jwks: () => types.JSONWebKeySet | undefined;
+    jwks: () => t.JSONWebKeySet | undefined;
 }
 /**
- * Returns a function that resolves a JWS JOSE Header to a public key object downloaded from a
- * remote endpoint returning a JSON Web Key Set, that is, for example, an OAuth 2.0 or OIDC
- * jwks_uri. The JSON Web Key Set is fetched when no key matches the selection process but only as
- * frequently as the `cooldownDuration` option allows to prevent abuse. Selection respects the
- * header's "alg" (Algorithm) and "kid" (Key ID) as well as the JWK's "use" (Public Key Use) and
- * "key_ops" (Key Operations). Exactly one key must match; if multiple keys match, the thrown
- * `JWKSMultipleMatchingKeys` can be iterated.
+ * Creates a resolver for a JSON Web Key Set available at an HTTP(S) URL. Fetches the JSON Web Key
+ * Set when the cache is missing or stale. An unmatched key triggers another fetch only when
+ * `cooldownDuration` has elapsed since the last successful fetch. Selection uses the header's "alg"
+ * and "kid" and respects the JWK's "use" and "key_ops". Exactly one key must match.
  *
- * > Note: The function's purpose is to resolve public keys used for verifying signatures and will not work
- * > for public encryption keys.
+ * > Note: Only public signature verification keys are supported, not public encryption keys.
  *
  * @param url URL to fetch the JSON Web Key Set from.
- * @param options Options for the remote JSON Web Key Set.
  */
 export declare function createRemoteJWKSet(url: URL, options?: RemoteJWKSetOptions): RemoteJWKSet;

package/node_modules/jose/dist/types/jws/compact/sign.d.ts

@@ -1,25 +1,20 @@
-import type * as types from '../../types.d.ts';
-/** The CompactSign class is used to build and sign Compact JWS strings. */
+import type * as t from '../../types.d.ts';
+/** Builds and signs Compact JWS strings. */
 export declare class CompactSign {
     #private;
     /**
-     * {@link CompactSign} constructor
+     * Creates a Compact JWS signer.
      *
      * @param payload Binary representation of the payload to sign.
      */
     constructor(payload: Uint8Array);
+    /** Sets the JWS Protected Header. May only be called once. */
+    setProtectedHeader(protectedHeader: t.CompactJWSHeaderParameters): this;
     /**
-     * Sets the JWS Protected Header on the CompactSign object.
+     * Signs the payload as a Compact JWS.
      *
-     * @param protectedHeader JWS Protected Header.
-     */
-    setProtectedHeader(protectedHeader: types.CompactJWSHeaderParameters): this;
-    /**
-     * Signs and resolves the value of the Compact JWS string.
-     *
-     * @param key Private Key or Secret to sign the JWS with. See
+     * @param key Private key or shared secret. See
      *   {@link https://github.com/panva/jose/issues/210#jws-alg Algorithm Key Requirements}.
-     * @param options JWS Sign options.
      */
-    sign(key: types.KeyInput, options?: types.SignOptions): Promise<string>;
+    sign(key: t.KeyInput, options?: t.SignOptions): Promise<string>;
 }

package/node_modules/jose/dist/types/jws/compact/verify.d.ts

@@ -1,37 +1,25 @@
-import type * as types from '../../types.d.ts';
-/**
- * Interface for Compact JWS Verification dynamic key resolution. No token components have been
- * verified at the time of this function call.
- */
-export interface CompactVerifyGetKey<KeyType extends types.CryptoKey | Uint8Array = types.CryptoKey | Uint8Array> extends types.GetKeyFunction<types.CompactJWSHeaderParameters, types.FlattenedJWSInput, KeyType | types.KeyObject | types.JWK> {
+import type * as t from '../../types.d.ts';
+/** Resolves a key for Compact JWS verification from unverified headers and token data. */
+export interface CompactVerifyGetKey<KeyType extends t.CryptoKey | Uint8Array = t.CryptoKey | Uint8Array> extends t.GetKeyFunction<t.CompactJWSHeaderParameters, t.FlattenedJWSInput, KeyType | t.KeyObject | t.JWK> {
 }
 /**
- * Verifies the signature and format of and afterwards decodes the Compact JWS.
+ * Verifies a Compact JWS signature and decodes its payload.
  *
- * @param jws Compact JWS.
- * @param key Key to verify the JWS with. See
+ * @param key Public key or shared secret. See
  *   {@link https://github.com/panva/jose/issues/210#jws-alg Algorithm Key Requirements}.
- * @param options JWS Verify options.
  */
-export declare function compactVerify(jws: string | Uint8Array, key: types.KeyInput, options?: types.VerifyOptions): Promise<types.CompactVerifyResult>;
+export declare function compactVerify(jws: string | Uint8Array, key: t.KeyInput, options?: t.VerifyOptions): Promise<t.CompactVerifyResult>;
 /**
- * Verifies the signature and format of and afterwards decodes the Compact JWS, resolving the key
- * dynamically. The result additionally carries the {@link types.ResolvedKey.key resolved key}.
+ * Verifies a Compact JWS signature and decodes its payload with a dynamically resolved key,
+ * included in the result.
  *
- * @param jws Compact JWS.
- * @param getKey Function resolving a key to verify the JWS with. See
- *   {@link https://github.com/panva/jose/issues/210#jws-alg Algorithm Key Requirements}.
- * @param options JWS Verify options.
+ * @param getKey Resolves a public key or shared secret from unverified token data.
  */
-export declare function compactVerify<KeyType extends types.CryptoKey | Uint8Array = types.CryptoKey | Uint8Array>(jws: string | Uint8Array, getKey: CompactVerifyGetKey<KeyType>, options?: types.VerifyOptions): Promise<types.CompactVerifyResult & types.ResolvedKey<KeyType>>;
+export declare function compactVerify<KeyType extends t.CryptoKey | Uint8Array = t.CryptoKey | Uint8Array>(jws: string | Uint8Array, getKey: CompactVerifyGetKey<KeyType>, options?: t.VerifyOptions): Promise<t.CompactVerifyResult & t.ResolvedKey<KeyType>>;
 /**
- * Accepts either form of the `key` argument. Use this overload when forwarding a value that may be
- * either a key or a key resolution function; `key` is present on the result only when a resolution
- * function was used.
+ * Verifies a Compact JWS and decodes its payload using a key or key resolver. The result includes
+ * `key` only when a resolver is used.
  *
- * @param jws Compact JWS.
- * @param key Key, or function resolving a key, to verify the JWS with. See
- *   {@link https://github.com/panva/jose/issues/210#jws-alg Algorithm Key Requirements}.
- * @param options JWS Verify options.
+ * @param key Public key or shared secret, or a function resolving one.
  */
-export declare function compactVerify(jws: string | Uint8Array, key: types.KeyInput | CompactVerifyGetKey, options?: types.VerifyOptions): Promise<types.CompactVerifyResult & Partial<types.ResolvedKey>>;
+export declare function compactVerify(jws: string | Uint8Array, key: t.KeyInput | CompactVerifyGetKey, options?: t.VerifyOptions): Promise<t.CompactVerifyResult & Partial<t.ResolvedKey>>;

package/node_modules/jose/dist/types/jws/flattened/sign.d.ts

@@ -1,31 +1,22 @@
-import type * as types from '../../types.d.ts';
-/** The FlattenedSign class is used to build and sign Flattened JWS objects. */
+import type * as t from '../../types.d.ts';
+/** Builds and signs Flattened JWS objects. */
 export declare class FlattenedSign {
     #private;
     /**
-     * {@link FlattenedSign} constructor
+     * Creates a Flattened JWS signer.
      *
      * @param payload Binary representation of the payload to sign.
      */
     constructor(payload: Uint8Array);
+    /** Sets the JWS Protected Header. May only be called once. */
+    setProtectedHeader(protectedHeader: t.JWSHeaderParameters): this;
+    /** Sets the JWS Unprotected Header. May only be called once. */
+    setUnprotectedHeader(unprotectedHeader: t.JWSHeaderParameters): this;
     /**
-     * Sets the JWS Protected Header on the FlattenedSign object.
+     * Signs the payload as a Flattened JWS.
      *
-     * @param protectedHeader JWS Protected Header.
-     */
-    setProtectedHeader(protectedHeader: types.JWSHeaderParameters): this;
-    /**
-     * Sets the JWS Unprotected Header on the FlattenedSign object.
-     *
-     * @param unprotectedHeader JWS Unprotected Header.
-     */
-    setUnprotectedHeader(unprotectedHeader: types.JWSHeaderParameters): this;
-    /**
-     * Signs and resolves the value of the Flattened JWS object.
-     *
-     * @param key Private Key or Secret to sign the JWS with. See
+     * @param key Private key or shared secret. See
      *   {@link https://github.com/panva/jose/issues/210#jws-alg Algorithm Key Requirements}.
-     * @param options JWS Sign options.
      */
-    sign(key: types.KeyInput, options?: types.SignOptions): Promise<types.FlattenedJWS>;
+    sign(key: t.KeyInput, options?: t.SignOptions): Promise<t.FlattenedJWS>;
 }

package/node_modules/jose/dist/types/jws/flattened/verify.d.ts

@@ -1,37 +1,25 @@
-import type * as types from '../../types.d.ts';
-/**
- * Interface for Flattened JWS Verification dynamic key resolution. No token components have been
- * verified at the time of this function call.
- */
-export interface FlattenedVerifyGetKey<KeyType extends types.CryptoKey | Uint8Array = types.CryptoKey | Uint8Array> extends types.GetKeyFunction<types.JWSHeaderParameters, types.FlattenedJWSInput, KeyType | types.KeyObject | types.JWK> {
+import type * as t from '../../types.d.ts';
+/** Resolves a key for Flattened JWS verification from unverified headers and token data. */
+export interface FlattenedVerifyGetKey<KeyType extends t.CryptoKey | Uint8Array = t.CryptoKey | Uint8Array> extends t.GetKeyFunction<t.JWSHeaderParameters, t.FlattenedJWSInput, KeyType | t.KeyObject | t.JWK> {
 }
 /**
- * Verifies the signature and format of and afterwards decodes the Flattened JWS.
+ * Verifies a Flattened JWS signature and decodes its payload.
  *
- * @param jws Flattened JWS.
- * @param key Key to verify the JWS with. See
+ * @param key Public key or shared secret. See
  *   {@link https://github.com/panva/jose/issues/210#jws-alg Algorithm Key Requirements}.
- * @param options JWS Verify options.
  */
-export declare function flattenedVerify(jws: types.FlattenedJWSInput, key: types.KeyInput, options?: types.VerifyOptions): Promise<types.FlattenedVerifyResult>;
+export declare function flattenedVerify(jws: t.FlattenedJWSInput, key: t.KeyInput, options?: t.VerifyOptions): Promise<t.FlattenedVerifyResult>;
 /**
- * Verifies the signature and format of and afterwards decodes the Flattened JWS, resolving the key
- * dynamically. The result additionally carries the {@link types.ResolvedKey.key resolved key}.
+ * Verifies a Flattened JWS signature and decodes its payload with a dynamically resolved key,
+ * included in the result.
  *
- * @param jws Flattened JWS.
- * @param getKey Function resolving a key to verify the JWS with. See
- *   {@link https://github.com/panva/jose/issues/210#jws-alg Algorithm Key Requirements}.
- * @param options JWS Verify options.
+ * @param getKey Resolves a public key or shared secret from unverified token data.
  */
-export declare function flattenedVerify<KeyType extends types.CryptoKey | Uint8Array = types.CryptoKey | Uint8Array>(jws: types.FlattenedJWSInput, getKey: FlattenedVerifyGetKey<KeyType>, options?: types.VerifyOptions): Promise<types.FlattenedVerifyResult & types.ResolvedKey<KeyType>>;
+export declare function flattenedVerify<KeyType extends t.CryptoKey | Uint8Array = t.CryptoKey | Uint8Array>(jws: t.FlattenedJWSInput, getKey: FlattenedVerifyGetKey<KeyType>, options?: t.VerifyOptions): Promise<t.FlattenedVerifyResult & t.ResolvedKey<KeyType>>;
 /**
- * Accepts either form of the `key` argument. Use this overload when forwarding a value that may be
- * either a key or a key resolution function; `key` is present on the result only when a resolution
- * function was used.
+ * Verifies a Flattened JWS and decodes its payload using a key or key resolver. The result includes
+ * `key` only when a resolver is used.
  *
- * @param jws Flattened JWS.
- * @param key Key, or function resolving a key, to verify the JWS with. See
- *   {@link https://github.com/panva/jose/issues/210#jws-alg Algorithm Key Requirements}.
- * @param options JWS Verify options.
+ * @param key Public key or shared secret, or a function resolving one.
  */
-export declare function flattenedVerify(jws: types.FlattenedJWSInput, key: types.KeyInput | FlattenedVerifyGetKey, options?: types.VerifyOptions): Promise<types.FlattenedVerifyResult & Partial<types.ResolvedKey>>;
+export declare function flattenedVerify(jws: t.FlattenedJWSInput, key: t.KeyInput | FlattenedVerifyGetKey, options?: t.VerifyOptions): Promise<t.FlattenedVerifyResult & Partial<t.ResolvedKey>>;

package/node_modules/jose/dist/types/jws/general/sign.d.ts

@@ -1,52 +1,38 @@
-import type * as types from '../../types.d.ts';
-/** Used to build General JWS object's individual signatures. */
+import type * as t from '../../types.d.ts';
+/** Configures an individual signature in a General JWS. */
 export interface Signature {
+    /** Sets the JWS Protected Header. May only be called once. */
+    setProtectedHeader(protectedHeader: t.JWSHeaderParameters): Signature;
+    /** Sets the JWS Unprotected Header. May only be called once. */
+    setUnprotectedHeader(unprotectedHeader: t.JWSHeaderParameters): Signature;
     /**
-     * Sets the JWS Protected Header on the Signature object.
+     * Adds another signature to the enclosing {@link GeneralSign} and returns its configuration.
      *
-     * @param protectedHeader JWS Protected Header.
-     */
-    setProtectedHeader(protectedHeader: types.JWSHeaderParameters): Signature;
-    /**
-     * Sets the JWS Unprotected Header on the Signature object.
-     *
-     * @param unprotectedHeader JWS Unprotected Header.
-     */
-    setUnprotectedHeader(unprotectedHeader: types.JWSHeaderParameters): Signature;
-    /**
-     * A shorthand for calling {@link GeneralSign.addSignature addSignature()} on the enclosing
-     * {@link GeneralSign} instance.
-     *
-     * @param key Private Key or Secret to sign the individual JWS signature with. See
+     * @param key Private key or shared secret. See
      *   {@link https://github.com/panva/jose/issues/210#jws-alg Algorithm Key Requirements}.
-     * @param options JWS Sign options.
-     */
-    addSignature(key: types.KeyInput, options?: types.SignOptions): Signature;
-    /**
-     * A shorthand for calling {@link GeneralSign.sign sign()} on the enclosing {@link GeneralSign}
-     * instance. Takes no arguments — each signature's key is supplied to {@link addSignature}.
      */
-    sign(): Promise<types.GeneralJWS>;
-    /** Returns the enclosing {@link GeneralSign} instance */
+    addSignature(key: t.KeyInput, options?: t.SignOptions): Signature;
+    /** Creates all signatures on the enclosing {@link GeneralSign}, using their configured keys. */
+    sign(): Promise<t.GeneralJWS>;
+    /** Returns the enclosing {@link GeneralSign} instance. */
     done(): GeneralSign;
 }
-/** The GeneralSign class is used to build and sign General JWS objects. */
+/** Builds and signs General JWS objects. */
 export declare class GeneralSign {
     #private;
     /**
-     * {@link GeneralSign} constructor
+     * Creates a General JWS signer.
      *
      * @param payload Binary representation of the payload to sign.
      */
     constructor(payload: Uint8Array);
     /**
-     * Adds an additional signature for the General JWS object.
+     * Adds a signature and returns its configuration.
      *
-     * @param key Private Key or Secret to sign the individual JWS signature with. See
+     * @param key Private key or shared secret. See
      *   {@link https://github.com/panva/jose/issues/210#jws-alg Algorithm Key Requirements}.
-     * @param options JWS Sign options.
      */
-    addSignature(key: types.KeyInput, options?: types.SignOptions): Signature;
-    /** Signs and resolves the value of the General JWS object. */
-    sign(): Promise<types.GeneralJWS>;
+    addSignature(key: t.KeyInput, options?: t.SignOptions): Signature;
+    /** Signs the payload as a General JWS. */
+    sign(): Promise<t.GeneralJWS>;
 }

package/node_modules/jose/dist/types/jws/general/verify.d.ts

@@ -1,44 +1,29 @@
-import type * as types from '../../types.d.ts';
-/**
- * Interface for General JWS Verification dynamic key resolution. No token components have been
- * verified at the time of this function call.
- */
-export interface GeneralVerifyGetKey<KeyType extends types.CryptoKey | Uint8Array = types.CryptoKey | Uint8Array> extends types.GetKeyFunction<types.JWSHeaderParameters, types.FlattenedJWSInput, KeyType | types.KeyObject | types.JWK> {
+import type * as t from '../../types.d.ts';
+/** Resolves a key for General JWS verification from unverified headers and token data. */
+export interface GeneralVerifyGetKey<KeyType extends t.CryptoKey | Uint8Array = t.CryptoKey | Uint8Array> extends t.GetKeyFunction<t.JWSHeaderParameters, t.FlattenedJWSInput, KeyType | t.KeyObject | t.JWK> {
 }
 /**
- * Verifies the signature and format of and afterwards decodes the General JWS.
+ * Verifies a General JWS signature and decodes its payload.
  *
- * > Note: The function iterates over the `signatures` array in the General JWS and returns the verification
- * > result of the first signature entry that can be successfully verified. The result only contains
- * > the payload, protected header, and unprotected header of that successfully verified signature
- * > entry. Other signature entries' headers may be inspected solely to reject inconsistent use of the
- * > JWS Unencoded Payload Option, and their headers are not included in the returned result.
- * > Recipients of a General JWS should only rely on the returned (verified) data.
+ * > Note: Returns payload and headers from the first signature that verifies successfully. Other entries'
+ * > headers may be inspected to reject inconsistent use of the JWS Unencoded Payload Option, but are
+ * > not included in the result. Rely only on the returned data.
  *
- * @param jws General JWS.
- * @param key Key to verify the JWS with. See
+ * @param key Public key or shared secret. See
  *   {@link https://github.com/panva/jose/issues/210#jws-alg Algorithm Key Requirements}.
- * @param options JWS Verify options.
  */
-export declare function generalVerify(jws: types.GeneralJWSInput, key: types.KeyInput, options?: types.VerifyOptions): Promise<types.GeneralVerifyResult>;
+export declare function generalVerify(jws: t.GeneralJWSInput, key: t.KeyInput, options?: t.VerifyOptions): Promise<t.GeneralVerifyResult>;
 /**
- * Verifies the signature and format of and afterwards decodes the General JWS, resolving the key
- * dynamically. The result additionally carries the {@link types.ResolvedKey.key resolved key}.
+ * Verifies a General JWS signature and decodes its payload with a dynamically resolved key,
+ * included in the result.
  *
- * @param jws General JWS.
- * @param getKey Function resolving a key to verify the JWS with. See
- *   {@link https://github.com/panva/jose/issues/210#jws-alg Algorithm Key Requirements}.
- * @param options JWS Verify options.
+ * @param getKey Resolves a public key or shared secret from unverified token data.
  */
-export declare function generalVerify<KeyType extends types.CryptoKey | Uint8Array = types.CryptoKey | Uint8Array>(jws: types.GeneralJWSInput, getKey: GeneralVerifyGetKey<KeyType>, options?: types.VerifyOptions): Promise<types.GeneralVerifyResult & types.ResolvedKey<KeyType>>;
+export declare function generalVerify<KeyType extends t.CryptoKey | Uint8Array = t.CryptoKey | Uint8Array>(jws: t.GeneralJWSInput, getKey: GeneralVerifyGetKey<KeyType>, options?: t.VerifyOptions): Promise<t.GeneralVerifyResult & t.ResolvedKey<KeyType>>;
 /**
- * Accepts either form of the `key` argument. Use this overload when forwarding a value that may be
- * either a key or a key resolution function; `key` is present on the result only when a resolution
- * function was used.
+ * Verifies a General JWS and decodes its payload using a key or key resolver. The result includes
+ * `key` only when a resolver is used.
  *
- * @param jws General JWS.
- * @param key Key, or function resolving a key, to verify the JWS with. See
- *   {@link https://github.com/panva/jose/issues/210#jws-alg Algorithm Key Requirements}.
- * @param options JWS Verify options.
+ * @param key Public key or shared secret, or a function resolving one.
  */
-export declare function generalVerify(jws: types.GeneralJWSInput, key: types.KeyInput | GeneralVerifyGetKey, options?: types.VerifyOptions): Promise<types.GeneralVerifyResult & Partial<types.ResolvedKey>>;
+export declare function generalVerify(jws: t.GeneralJWSInput, key: t.KeyInput | GeneralVerifyGetKey, options?: t.VerifyOptions): Promise<t.GeneralVerifyResult & Partial<t.ResolvedKey>>;

package/node_modules/jose/dist/types/jwt/decrypt.d.ts

@@ -1,41 +1,34 @@
-import type * as types from '../types.d.ts';
-/** Combination of JWE Decryption options and JWT Claims Set verification options. */
-export interface JWTDecryptOptions extends types.DecryptOptions, types.JWTClaimVerificationOptions {
+import type * as t from '../types.d.ts';
+/** JWE decryption and JWT Claims Set validation options. */
+export interface JWTDecryptOptions extends t.DecryptOptions, t.JWTClaimVerificationOptions {
 }
 /**
- * Interface for JWT Decryption dynamic key resolution. No token components have been verified at
- * the time of this function call.
+ * Resolves a JWT decryption key. No token components have been authenticated when this function is
+ * called.
  */
-export interface JWTDecryptGetKey<KeyType extends types.CryptoKey | Uint8Array = types.CryptoKey | Uint8Array> extends types.GetKeyFunction<types.CompactJWEHeaderParameters, types.FlattenedJWE, KeyType | types.KeyObject | types.JWK> {
+export interface JWTDecryptGetKey<KeyType extends t.CryptoKey | Uint8Array = t.CryptoKey | Uint8Array> extends t.GetKeyFunction<t.CompactJWEHeaderParameters, t.FlattenedJWE, KeyType | t.KeyObject | t.JWK> {
 }
 /**
- * Verifies the JWT format (to be a JWE Compact format), decrypts the ciphertext, validates the JWT
- * Claims Set.
+ * Decrypts a Compact JWE-formatted JWT and validates its Claims Set.
  *
- * @param jwt JSON Web Token value (encoded as JWE).
- * @param key Private Key or Secret to decrypt and verify the JWT with. See
+ * @param key Private key or shared secret to decrypt and verify the JWT with. See
  *   {@link https://github.com/panva/jose/issues/210#jwe-alg Algorithm Key Requirements}.
- * @param options JWT Decryption and JWT Claims Set validation options.
  */
-export declare function jwtDecrypt<PayloadType = types.JWTPayload>(jwt: string | Uint8Array, key: types.KeyInput, options?: JWTDecryptOptions): Promise<types.JWTDecryptResult<PayloadType>>;
+export declare function jwtDecrypt<PayloadType = t.JWTPayload>(jwt: string | Uint8Array, key: t.KeyInput, options?: JWTDecryptOptions): Promise<t.JWTDecryptResult<PayloadType>>;
 /**
- * Decrypts a JWT and validates its JWT Claims Set, resolving the key dynamically. The result
- * additionally carries the {@link types.ResolvedKey.key resolved key}.
+ * Decrypts a JWT and validates its claims, returning the dynamically
+ * {@link t.ResolvedKey.key resolved key}.
  *
- * @param jwt JSON Web Token value (encoded as JWE).
- * @param getKey Function resolving Private Key or Secret to decrypt and verify the JWT with. See
- *   {@link https://github.com/panva/jose/issues/210#jwe-alg Algorithm Key Requirements}.
- * @param options JWT Decryption and JWT Claims Set validation options.
+ * @param getKey Function resolving a private key or shared secret to decrypt and verify the JWT
+ *   with. See {@link https://github.com/panva/jose/issues/210#jwe-alg Algorithm Key Requirements}.
  */
-export declare function jwtDecrypt<PayloadType = types.JWTPayload, KeyType extends types.CryptoKey | Uint8Array = types.CryptoKey | Uint8Array>(jwt: string | Uint8Array, getKey: JWTDecryptGetKey<KeyType>, options?: JWTDecryptOptions): Promise<types.JWTDecryptResult<PayloadType> & types.ResolvedKey<KeyType>>;
+export declare function jwtDecrypt<PayloadType = t.JWTPayload, KeyType extends t.CryptoKey | Uint8Array = t.CryptoKey | Uint8Array>(jwt: string | Uint8Array, getKey: JWTDecryptGetKey<KeyType>, options?: JWTDecryptOptions): Promise<t.JWTDecryptResult<PayloadType> & t.ResolvedKey<KeyType>>;
 /**
- * Accepts either form of the `key` argument. Use this overload when forwarding a value that may be
- * either a key or a key resolution function; `key` is present on the result only when a resolution
- * function was used.
+ * Accepts a key or key resolver. Use this overload when forwarding either form; the result includes
+ * `key` only when a resolver was used.
  *
- * @param jwt JSON Web Token value (encoded as JWE).
- * @param key Private Key or Secret, or a function resolving one, to decrypt and verify the JWT
- *   with. See {@link https://github.com/panva/jose/issues/210#jwe-alg Algorithm Key Requirements}.
- * @param options JWT Decryption and JWT Claims Set validation options.
+ * @param key Private key or shared secret, or a function resolving one, to decrypt and verify the
+ *   JWT with. See
+ *   {@link https://github.com/panva/jose/issues/210#jwe-alg Algorithm Key Requirements}.
  */
-export declare function jwtDecrypt<PayloadType = types.JWTPayload>(jwt: string | Uint8Array, key: types.KeyInput | JWTDecryptGetKey, options?: JWTDecryptOptions): Promise<types.JWTDecryptResult<PayloadType> & Partial<types.ResolvedKey>>;
+export declare function jwtDecrypt<PayloadType = t.JWTPayload>(jwt: string | Uint8Array, key: t.KeyInput | JWTDecryptGetKey, options?: JWTDecryptOptions): Promise<t.JWTDecryptResult<PayloadType> & Partial<t.ResolvedKey>>;

package/node_modules/jose/dist/types/jwt/encrypt.d.ts

@@ -1,62 +1,57 @@
-import type * as types from '../types.d.ts';
-/**
- * EncryptJWT constructor
- *
- * @param payload The JWT Claims Set object. Defaults to an empty object.
- */
-declare const EncryptJWT_base: new (payload?: types.JWTPayload) => types.ProduceJWT;
-/** The EncryptJWT class is used to build and encrypt Compact JWE formatted JSON Web Tokens. */
+import type * as t from '../types.d.ts';
+/** @param payload Initial JWT Claims Set. Defaults to an empty object. */
+declare const EncryptJWT_base: new (payload?: t.JWTPayload) => t.ProduceJWT;
+/** Builds and encrypts Compact JWE-formatted JSON Web Tokens. */
 export declare class EncryptJWT extends EncryptJWT_base {
     #private;
     /**
-     * Sets the JWE Protected Header on the EncryptJWT object.
+     * Sets the JWE Protected Header. May only be called once.
      *
      * @param protectedHeader JWE Protected Header. Must contain an "alg" (JWE Algorithm) and "enc"
      *   (JWE Encryption Algorithm) properties.
      */
-    setProtectedHeader(protectedHeader: types.CompactJWEHeaderParameters): this;
+    setProtectedHeader(protectedHeader: t.CompactJWEHeaderParameters): this;
     /**
-     * Sets the JWE Key Management parameters to be used when encrypting. Use this method instead of
-     * the header setters to configure algorithm inputs such as ECDH-ES "apu" (Agreement PartyUInfo)
-     * and "apv" (Agreement PartyVInfo), or PBES2 "p2c" (PBES2 Count). The parameters are added to the
-     * appropriate JOSE Header.
-     *
-     * @param parameters JWE Key Management parameters.
+     * Sets JWE Key Management parameters, such as ECDH-ES "apu" and "apv" or PBES2 "p2c", and adds
+     * them to the appropriate JOSE Header. Use this instead of the header setters for algorithm
+     * inputs. May only be called once.
      */
-    setKeyManagementParameters(parameters: types.JWEKeyManagementHeaderParameters): this;
+    setKeyManagementParameters(parameters: t.JWEKeyManagementHeaderParameters): this;
     /**
-     * Sets a content encryption key to use, by default a random suitable one is generated for the JWE
-     * "enc" (Encryption Algorithm) Header Parameter.
-     *
-     * @deprecated You should not use this method. It is only really intended for test and vector
-     *   validation purposes.
+     * Sets the content encryption key. By default, a suitable random key is generated for the JWE
+     * "enc" (Encryption Algorithm). May only be called once.
      *
-     * @param cek JWE Content Encryption Key.
+     * @deprecated For testing and vector validation only; allow random generation in production.
      */
     setContentEncryptionKey(cek: Uint8Array): this;
     /**
-     * Sets the JWE Initialization Vector to use for content encryption, by default a random suitable
-     * one is generated for the JWE "enc" (Encryption Algorithm) Header Parameter.
-     *
-     * @deprecated You should not use this method. It is only really intended for test and vector
-     *   validation purposes.
+     * Sets the Initialization Vector for content encryption. By default, a suitable random IV is
+     * generated for the JWE "enc" (Encryption Algorithm). May only be called once.
      *
-     * @param iv JWE Initialization Vector.
+     * @deprecated For testing and vector validation only; allow random generation in production.
      */
     setInitializationVector(iv: Uint8Array): this;
-    /** Replicates the "iss" (Issuer) Claim as a JWE Protected Header Parameter. */
+    /**
+     * Replicates the "iss" (Issuer) Claim in the JWE Protected Header, exposing it without
+     * decryption.
+     */
     replicateIssuerAsHeader(): this;
-    /** Replicates the "sub" (Subject) Claim as a JWE Protected Header Parameter. */
+    /**
+     * Replicates the "sub" (Subject) Claim in the JWE Protected Header, exposing it without
+     * decryption.
+     */
     replicateSubjectAsHeader(): this;
-    /** Replicates the "aud" (Audience) Claim as a JWE Protected Header Parameter. */
+    /**
+     * Replicates the "aud" (Audience) Claim in the JWE Protected Header, exposing it without
+     * decryption.
+     */
     replicateAudienceAsHeader(): this;
     /**
      * Encrypts and returns the JWT.
      *
-     * @param key Public Key or Secret to encrypt the JWT with. See
+     * @param key Public key or shared secret to encrypt the JWT with. See
      *   {@link https://github.com/panva/jose/issues/210#jwe-alg Algorithm Key Requirements}.
-     * @param options JWE Encryption options.
      */
-    encrypt(key: types.KeyInput, options?: types.EncryptOptions): Promise<string>;
+    encrypt(key: t.KeyInput, options?: t.EncryptOptions): Promise<string>;
 }
 export {};