@openclaw/msteams 2026.5.27 → 2026.5.28-beta.2

package/node_modules/jose/dist/types/jwe/general/encrypt.d.ts

@@ -1,47 +1,29 @@
-/**
- * Encrypting JSON Web Encryption (JWE) in General JSON Serialization
- *
- * @module
- */
-import type * as types from '../../types.d.ts';
-/** Used to build General JWE object's individual recipients. */
+import type { KeyLike, GeneralJWE, JWEHeaderParameters, CritOption, DeflateOption } from '../../types';
 export interface Recipient {
     /**
      * Sets the JWE Per-Recipient Unprotected Header on the Recipient object.
      *
      * @param unprotectedHeader JWE Per-Recipient Unprotected Header.
      */
-    setUnprotectedHeader(unprotectedHeader: types.JWEHeaderParameters): Recipient;
-    /**
-     * Sets the JWE Key Management parameters to be used when encrypting.
-     *
-     * (ECDH-ES) Use of this method is needed for ECDH based algorithms to set the "apu" (Agreement
-     * PartyUInfo) or "apv" (Agreement PartyVInfo) parameters.
-     *
-     * @param parameters JWE Key Management parameters.
-     */
-    setKeyManagementParameters(parameters: types.JWEKeyManagementHeaderParameters): Recipient;
-    /** A shorthand for calling addRecipient() on the enclosing {@link GeneralEncrypt} instance */
+    setUnprotectedHeader(unprotectedHeader: JWEHeaderParameters): Recipient;
+    /** A shorthand for calling addRecipient() on the enclosing GeneralEncrypt instance */
     addRecipient(...args: Parameters<GeneralEncrypt['addRecipient']>): Recipient;
-    /** A shorthand for calling encrypt() on the enclosing {@link GeneralEncrypt} instance */
-    encrypt(...args: Parameters<GeneralEncrypt['encrypt']>): Promise<types.GeneralJWE>;
-    /** Returns the enclosing {@link GeneralEncrypt} instance */
+    /** A shorthand for calling encrypt() on the enclosing GeneralEncrypt instance */
+    encrypt(...args: Parameters<GeneralEncrypt['encrypt']>): Promise<GeneralJWE>;
+    /** Returns the enclosing GeneralEncrypt */
     done(): GeneralEncrypt;
 }
 /**
  * The GeneralEncrypt class is used to build and encrypt General JWE objects.
  *
- * This class is exported (as a named export) from the main `'jose'` module entry point as well as
- * from its subpath export `'jose/jwe/general/encrypt'`.
- *
  */
 export declare class GeneralEncrypt {
-    #private;
-    /**
-     * {@link GeneralEncrypt} constructor
-     *
-     * @param plaintext Binary representation of the plaintext to encrypt.
-     */
+    private _plaintext;
+    private _recipients;
+    private _protectedHeader;
+    private _unprotectedHeader;
+    private _aad;
+    /** @param plaintext Binary representation of the plaintext to encrypt. */
     constructor(plaintext: Uint8Array);
     /**
      * Adds an additional recipient for the General JWE object.
@@ -50,25 +32,29 @@ export declare class GeneralEncrypt {
      *   See {@link https://github.com/panva/jose/issues/210#jwe-alg Algorithm Key Requirements}.
      * @param options JWE Encryption options.
      */
-    addRecipient(key: types.CryptoKey | types.KeyObject | types.JWK | Uint8Array, options?: types.CritOption): Recipient;
+    addRecipient(key: KeyLike | Uint8Array, options?: CritOption): Recipient;
     /**
      * Sets the JWE Protected Header on the GeneralEncrypt object.
      *
      * @param protectedHeader JWE Protected Header object.
      */
-    setProtectedHeader(protectedHeader: types.JWEHeaderParameters): this;
+    setProtectedHeader(protectedHeader: JWEHeaderParameters): this;
     /**
      * Sets the JWE Shared Unprotected Header on the GeneralEncrypt object.
      *
      * @param sharedUnprotectedHeader JWE Shared Unprotected Header object.
      */
-    setSharedUnprotectedHeader(sharedUnprotectedHeader: types.JWEHeaderParameters): this;
+    setSharedUnprotectedHeader(sharedUnprotectedHeader: JWEHeaderParameters): this;
     /**
      * Sets the Additional Authenticated Data on the GeneralEncrypt object.
      *
      * @param aad Additional Authenticated Data.
      */
     setAdditionalAuthenticatedData(aad: Uint8Array): this;
-    /** Encrypts and resolves the value of the General JWE object. */
-    encrypt(): Promise<types.GeneralJWE>;
+    /**
+     * Encrypts and resolves the value of the General JWE object.
+     *
+     * @param options JWE Encryption options.
+     */
+    encrypt(options?: DeflateOption): Promise<GeneralJWE>;
 }

package/node_modules/jose/dist/types/jwk/embedded.d.ts

@@ -1,17 +1,9 @@
-/**
- * Verification using a JWK Embedded in a JWS Header
- *
- * @module
- */
-import type * as types from '../types.d.ts';
+import type { KeyLike, FlattenedJWSInput, JWSHeaderParameters } from '../types';
 /**
  * EmbeddedJWK is an implementation of a GetKeyFunction intended to be used with the JWS/JWT verify
  * operations whenever you need to opt-in to verify signatures with a public key embedded in the
  * token's "jwk" (JSON Web Key) Header Parameter. It is recommended to combine this with the verify
  * function's `algorithms` option to define accepted JWS "alg" (Algorithm) Header Parameter values.
  *
- * This function is exported (as a named export) from the main `'jose'` module entry point as well
- * as from its subpath export `'jose/jwk/embedded'`.
- *
  */
-export declare function EmbeddedJWK(protectedHeader?: types.JWSHeaderParameters, token?: types.FlattenedJWSInput): Promise<types.CryptoKey>;
+export declare function EmbeddedJWK<T extends KeyLike = KeyLike>(protectedHeader?: JWSHeaderParameters, token?: FlattenedJWSInput): Promise<T>;

package/node_modules/jose/dist/types/jwk/thumbprint.d.ts

@@ -1,32 +1,21 @@
-/**
- * JSON Web Key Thumbprint and JSON Web Key Thumbprint URI
- *
- * @module
- */
-import type * as types from '../types.d.ts';
+import type { JWK } from '../types';
 /**
  * Calculates a base64url-encoded JSON Web Key (JWK) Thumbprint
  *
- * This function is exported (as a named export) from the main `'jose'` module entry point as well
- * as from its subpath export `'jose/jwk/thumbprint'`.
- *
- * @param key Key to calculate the thumbprint for.
+ * @param jwk JSON Web Key.
  * @param digestAlgorithm Digest Algorithm to use for calculating the thumbprint. Default is
  *   "sha256".
  *
  * @see {@link https://www.rfc-editor.org/rfc/rfc7638 RFC7638}
  */
-export declare function calculateJwkThumbprint(key: types.JWK | types.CryptoKey | types.KeyObject, digestAlgorithm?: 'sha256' | 'sha384' | 'sha512'): Promise<string>;
+export declare function calculateJwkThumbprint(jwk: JWK, digestAlgorithm?: 'sha256' | 'sha384' | 'sha512'): Promise<string>;
 /**
  * Calculates a JSON Web Key (JWK) Thumbprint URI
  *
- * This function is exported (as a named export) from the main `'jose'` module entry point as well
- * as from its subpath export `'jose/jwk/thumbprint'`.
- *
- * @param key Key to calculate the thumbprint for.
+ * @param jwk JSON Web Key.
  * @param digestAlgorithm Digest Algorithm to use for calculating the thumbprint. Default is
  *   "sha256".
  *
  * @see {@link https://www.rfc-editor.org/rfc/rfc9278 RFC9278}
  */
-export declare function calculateJwkThumbprintUri(key: types.CryptoKey | types.KeyObject | types.JWK, digestAlgorithm?: 'sha256' | 'sha384' | 'sha512'): Promise<string>;
+export declare function calculateJwkThumbprintUri(jwk: JWK, digestAlgorithm?: 'sha256' | 'sha384' | 'sha512'): Promise<string>;

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

@@ -1,12 +1,16 @@
+import type { KeyLike, JWSHeaderParameters, JSONWebKeySet, FlattenedJWSInput } from '../types';
+/** @private */
+export declare function isJWKSLike(jwks: unknown): jwks is JSONWebKeySet;
+/** @private */
+export declare class LocalJWKSet<T extends KeyLike = KeyLike> {
+    protected _jwks?: JSONWebKeySet;
+    private _cached;
+    constructor(jwks: unknown);
+    getKey(protectedHeader?: JWSHeaderParameters, token?: FlattenedJWSInput): Promise<T>;
+}
 /**
- * Verification using a JSON Web Key Set (JWKS) available locally
- *
- * @module
- */
-import type * as types from '../types.d.ts';
-/**
- * Returns a function that resolves a JWS JOSE Header to a public key object from a locally stored,
- * or otherwise available, JSON Web Key Set.
+ * Returns a function that resolves to a key object from a locally stored, or otherwise available,
+ * JSON Web Key Set.
  *
  * It uses the "alg" (JWS Algorithm) Header Parameter to determine the right JWK "kty" (Key Type),
  * then proceeds to match the JWK "kid" (Key ID) with one found in the JWS Header Parameters (if
@@ -17,13 +21,6 @@ import type * as types from '../types.d.ts';
  * multiple keys get matched it is possible to opt-in to iterate over the matched keys and attempt
  * verification in an iterative manner.
  *
- * > [!NOTE]\
- * > The function's purpose is to resolve public keys used for verifying signatures and will not work
- * > for public encryption keys.
- *
- * This function is exported (as a named export) from the main `'jose'` module entry point as well
- * as from its subpath export `'jose/jwks/local'`.
- *
  * @param jwks JSON Web Key Set formatted object.
  */
-export declare function createLocalJWKSet(jwks: types.JSONWebKeySet): (protectedHeader?: types.JWSHeaderParameters, token?: types.FlattenedJWSInput) => Promise<types.CryptoKey>;
+export declare function createLocalJWKSet<T extends KeyLike = KeyLike>(jwks: JSONWebKeySet): (protectedHeader?: JWSHeaderParameters, token?: FlattenedJWSInput) => Promise<T>;

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

@@ -1,169 +1,4 @@
-/**
- * Verification using a JSON Web Key Set (JWKS) available on an HTTP(S) URL
- *
- * @module
- */
-import type * as types 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.
- *
- * > [!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.
- *
- * import ky from 'ky'
- *
- * let logRequest!: (request: Request) => void
- * let logResponse!: (request: Request, response: Response) => void
- * let logRetry!: (request: Request, error: Error, retryCount: number) => void
- *
- * const JWKS = jose.createRemoteJWKSet(url, {
- *   [jose.customFetch]: (...args) =>
- *     ky(args[0], {
- *       ...args[1],
- *       hooks: {
- *         beforeRequest: [
- *           (request) => {
- *             logRequest(request)
- *           },
- *         ],
- *         beforeRetry: [
- *           ({ request, error, retryCount }) => {
- *             logRetry(request, error, retryCount)
- *           },
- *         ],
- *         afterResponse: [
- *           (request, _, response) => {
- *             logResponse(request, response)
- *           },
- *         ],
- *       },
- *     }),
- * })
- * ```
- *
- * import * as undici from 'undici'
- *
- * // see https://undici.nodejs.org/#/docs/api/EnvHttpProxyAgent
- * let envHttpProxyAgent = new undici.EnvHttpProxyAgent()
- *
- * // @ts-ignore
- * const JWKS = jose.createRemoteJWKSet(url, {
- *   [jose.customFetch]: (...args) => {
- *     // @ts-ignore
- *     return undici.fetch(args[0], { ...args[1], dispatcher: envHttpProxyAgent }) // prettier-ignore
- *   },
- * })
- * ```
- *
- * import * as undici from 'undici'
- *
- * // see https://undici.nodejs.org/#/docs/api/RetryAgent
- * let retryAgent = new undici.RetryAgent(new undici.Agent(), {
- *   statusCodes: [],
- *   errorCodes: [
- *     'ECONNRESET',
- *     'ECONNREFUSED',
- *     'ENOTFOUND',
- *     'ENETDOWN',
- *     'ENETUNREACH',
- *     'EHOSTDOWN',
- *     'UND_ERR_SOCKET',
- *   ],
- * })
- *
- * // @ts-ignore
- * const JWKS = jose.createRemoteJWKSet(url, {
- *   [jose.customFetch]: (...args) => {
- *     // @ts-ignore
- *     return undici.fetch(args[0], { ...args[1], dispatcher: retryAgent }) // prettier-ignore
- *   },
- * })
- * ```
- *
- * import * as undici from 'undici'
- *
- * // see https://undici.nodejs.org/#/docs/api/MockAgent
- * let mockAgent = new undici.MockAgent()
- * mockAgent.disableNetConnect()
- *
- * // @ts-ignore
- * const JWKS = jose.createRemoteJWKSet(url, {
- *   [jose.customFetch]: (...args) => {
- *     // @ts-ignore
- *     return undici.fetch(args[0], { ...args[1], dispatcher: mockAgent }) // prettier-ignore
- *   },
- * })
- * ```
- */
-export declare const customFetch: unique symbol;
-/** See {@link customFetch}. */
-export type FetchImplementation = (
-/** URL the request is being made sent to {@link !fetch} as the `resource` argument */
-url: string, 
-/** Options otherwise sent to {@link !fetch} as the `options` argument */
-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.
- *
- * This option is intended for cloud computing runtimes that cannot keep an in memory cache between
- * their code's invocations. Use in runtimes where an in memory cache between requests is available
- * is not desirable.
- *
- * When passed to {@link jwks/remote.createRemoteJWKSet createRemoteJWKSet} this allows the passed in
- * object to:
- *
- * - Serve as an initial value for the JSON Web Key Set that the module would otherwise need to
- *   trigger an HTTP request for
- * - Have the JSON Web Key Set the function optionally ended up triggering an HTTP request for
- *   assigned to it as properties
- *
- * The intended use pattern is:
- *
- * - Before verifying with {@link jwks/remote.createRemoteJWKSet createRemoteJWKSet} you pull the
- *   previously cached object from a low-latency key-value store offered by the cloud computing
- *   runtime it is executed on;
- * - Default to an empty object `{}` instead when there's no previously cached value;
- * - Pass it in as {@link RemoteJWKSetOptions[jwksCache]};
- * - Afterwards, update the key-value storage if the {@link ExportedJWKSCache.uat `uat`} property of
- *   the object has changed.
- *
- * // Prerequisites
- * let url!: URL
- * let jwt!: string
- * let getPreviouslyCachedJWKS!: () => Promise<jose.ExportedJWKSCache>
- * let storeNewJWKScache!: (cache: jose.ExportedJWKSCache) => Promise<void>
- *
- * // Load JSON Web Key Set cache
- * const jwksCache: jose.JWKSCacheInput = (await getPreviouslyCachedJWKS()) || {}
- * const { uat } = jwksCache
- *
- * const JWKS = jose.createRemoteJWKSet(url, {
- *   [jose.jwksCache]: jwksCache,
- * })
- *
- * // Use JSON Web Key Set cache
- * await jose.jwtVerify(jwt, JWKS)
- *
- * if (uat !== jwksCache.uat) {
- *   // Update JSON Web Key Set cache
- *   await storeNewJWKScache(jwksCache)
- * }
- * ```
- */
-export declare const jwksCache: unique symbol;
+import type { KeyLike, JWSHeaderParameters, FlattenedJWSInput } from '../types';
 /** Options for the remote JSON Web Key Set. */
 export interface RemoteJWKSetOptions {
     /**
@@ -181,27 +16,23 @@ export interface RemoteJWKSetOptions {
      * minutes).
      */
     cacheMaxAge?: number | typeof Infinity;
-    /** Headers to be sent with the HTTP request. */
+    /**
+     * An instance of {@link https://nodejs.org/api/http.html#class-httpagent http.Agent} or
+     * {@link https://nodejs.org/api/https.html#class-httpsagent https.Agent} to pass to the
+     * {@link https://nodejs.org/api/http.html#httpgetoptions-callback http.get} or
+     * {@link https://nodejs.org/api/https.html#httpsgetoptions-callback https.get} method's options.
+     * Use when behind an http(s) proxy. This is a Node.js runtime specific option, it is ignored when
+     * used outside of Node.js runtime.
+     */
+    agent?: any;
+    /** Optional headers to be sent with the HTTP request. */
     headers?: Record<string, string>;
-    /** See {@link jwksCache}. */
-    [jwksCache]?: JWKSCacheInput;
-    /** See {@link customFetch}. */
-    [customFetch]?: FetchImplementation;
-}
-/** See {@link jwksCache}. */
-export interface ExportedJWKSCache {
-    /** Current cached JSON Web Key Set */
-    jwks: types.JSONWebKeySet;
-    /** Last updated at timestamp (seconds since epoch) */
-    uat: number;
 }
-/** See {@link jwksCache}. */
-export type JWKSCacheInput = ExportedJWKSCache | Record<string, never>;
 /**
- * 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.
+ * Returns a function that resolves to a 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.
  *
  * It uses the "alg" (JWS Algorithm) Header Parameter to determine the right JWK "kty" (Key Type),
  * then proceeds to match the JWK "kid" (Key ID) with one found in the JWS Header Parameters (if
@@ -212,26 +43,7 @@ export type JWKSCacheInput = ExportedJWKSCache | Record<string, never>;
  * multiple keys get matched it is possible to opt-in to iterate over the matched keys and attempt
  * verification in an iterative manner.
  *
- * > [!NOTE]\
- * > The function's purpose is to resolve public keys used for verifying signatures and will not work
- * > for public encryption keys.
- *
- * This function is exported (as a named export) from the main `'jose'` module entry point as well
- * as from its subpath export `'jose/jwks/remote'`.
- *
  * @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): {
-    (protectedHeader?: types.JWSHeaderParameters, token?: types.FlattenedJWSInput): Promise<types.CryptoKey>;
-    /** @ignore */
-    coolingDown: boolean;
-    /** @ignore */
-    fresh: boolean;
-    /** @ignore */
-    reloading: boolean;
-    /** @ignore */
-    reload: () => Promise<void>;
-    /** @ignore */
-    jwks: () => types.JSONWebKeySet | undefined;
-};
+export declare function createRemoteJWKSet<T extends KeyLike = KeyLike>(url: URL, options?: RemoteJWKSetOptions): (protectedHeader?: JWSHeaderParameters, token?: FlattenedJWSInput) => Promise<T>;

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

@@ -1,30 +1,18 @@
-/**
- * Signing JSON Web Signature (JWS) in Compact Serialization
- *
- * @module
- */
-import type * as types from '../../types.d.ts';
+import type { CompactJWSHeaderParameters, KeyLike, SignOptions } from '../../types';
 /**
  * The CompactSign class is used to build and sign Compact JWS strings.
  *
- * This class is exported (as a named export) from the main `'jose'` module entry point as well as
- * from its subpath export `'jose/jws/compact/sign'`.
- *
  */
 export declare class CompactSign {
-    #private;
-    /**
-     * {@link CompactSign} constructor
-     *
-     * @param payload Binary representation of the payload to sign.
-     */
+    private _flattened;
+    /** @param payload Binary representation of the payload to sign. */
     constructor(payload: Uint8Array);
     /**
-     * Sets the JWS Protected Header on the CompactSign object.
+     * Sets the JWS Protected Header on the Sign object.
      *
      * @param protectedHeader JWS Protected Header.
      */
-    setProtectedHeader(protectedHeader: types.CompactJWSHeaderParameters): this;
+    setProtectedHeader(protectedHeader: CompactJWSHeaderParameters): this;
     /**
      * Signs and resolves the value of the Compact JWS string.
      *
@@ -32,5 +20,5 @@ export declare class CompactSign {
      *   {@link https://github.com/panva/jose/issues/210#jws-alg Algorithm Key Requirements}.
      * @param options JWS Sign options.
      */
-    sign(key: types.CryptoKey | types.KeyObject | types.JWK | Uint8Array, options?: types.SignOptions): Promise<string>;
+    sign(key: KeyLike | Uint8Array, options?: SignOptions): Promise<string>;
 }

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

@@ -1,33 +1,25 @@
-/**
- * Verifying JSON Web Signature (JWS) in Compact Serialization
- *
- * @module
- */
-import type * as types from '../../types.d.ts';
+import type { CompactVerifyResult, FlattenedJWSInput, GetKeyFunction, CompactJWSHeaderParameters, KeyLike, VerifyOptions, ResolvedKey } from '../../types';
 /**
  * Interface for Compact JWS Verification dynamic key resolution. No token components have been
  * verified at the time of this function call.
  *
- * @see {@link jwks/remote.createRemoteJWKSet createRemoteJWKSet} to verify using a remote JSON Web Key Set.
+ * @see [createRemoteJWKSet](../functions/jwks_remote.createRemoteJWKSet.md#function-createremotejwkset) to verify using a remote JSON Web Key Set.
  */
-export interface CompactVerifyGetKey extends types.GenericGetKeyFunction<types.CompactJWSHeaderParameters, types.FlattenedJWSInput, types.CryptoKey | types.KeyObject | types.JWK | Uint8Array> {
+export interface CompactVerifyGetKey extends GetKeyFunction<CompactJWSHeaderParameters, FlattenedJWSInput> {
 }
 /**
  * Verifies the signature and format of and afterwards decodes the Compact JWS.
  *
- * This function is exported (as a named export) from the main `'jose'` module entry point as well
- * as from its subpath export `'jose/jws/compact/verify'`.
- *
  * @param jws Compact JWS.
  * @param key 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.
  */
-export declare function compactVerify(jws: string | Uint8Array, key: types.CryptoKey | types.KeyObject | types.JWK | Uint8Array, options?: types.VerifyOptions): Promise<types.CompactVerifyResult>;
+export declare function compactVerify(jws: string | Uint8Array, key: KeyLike | Uint8Array, options?: VerifyOptions): Promise<CompactVerifyResult>;
 /**
  * @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.
  */
-export declare function compactVerify(jws: string | Uint8Array, getKey: CompactVerifyGetKey, options?: types.VerifyOptions): Promise<types.CompactVerifyResult & types.ResolvedKey>;
+export declare function compactVerify<T extends KeyLike = KeyLike>(jws: string | Uint8Array, getKey: CompactVerifyGetKey, options?: VerifyOptions): Promise<CompactVerifyResult & ResolvedKey<T>>;

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

@@ -1,36 +1,26 @@
-/**
- * Signing JSON Web Signature (JWS) in Flattened JSON Serialization
- *
- * @module
- */
-import type * as types from '../../types.d.ts';
+import type { KeyLike, FlattenedJWS, JWSHeaderParameters, SignOptions } from '../../types';
 /**
  * The FlattenedSign class is used to build and sign Flattened JWS objects.
  *
- * This class is exported (as a named export) from the main `'jose'` module entry point as well as
- * from its subpath export `'jose/jws/flattened/sign'`.
- *
  */
 export declare class FlattenedSign {
-    #private;
-    /**
-     * {@link FlattenedSign} constructor
-     *
-     * @param payload Binary representation of the payload to sign.
-     */
+    private _payload;
+    private _protectedHeader;
+    private _unprotectedHeader;
+    /** @param payload Binary representation of the payload to sign. */
     constructor(payload: Uint8Array);
     /**
      * Sets the JWS Protected Header on the FlattenedSign object.
      *
      * @param protectedHeader JWS Protected Header.
      */
-    setProtectedHeader(protectedHeader: types.JWSHeaderParameters): this;
+    setProtectedHeader(protectedHeader: JWSHeaderParameters): this;
     /**
      * Sets the JWS Unprotected Header on the FlattenedSign object.
      *
      * @param unprotectedHeader JWS Unprotected Header.
      */
-    setUnprotectedHeader(unprotectedHeader: types.JWSHeaderParameters): this;
+    setUnprotectedHeader(unprotectedHeader: JWSHeaderParameters): this;
     /**
      * Signs and resolves the value of the Flattened JWS object.
      *
@@ -38,5 +28,5 @@ export declare class FlattenedSign {
      *   {@link https://github.com/panva/jose/issues/210#jws-alg Algorithm Key Requirements}.
      * @param options JWS Sign options.
      */
-    sign(key: types.CryptoKey | types.KeyObject | types.JWK | Uint8Array, options?: types.SignOptions): Promise<types.FlattenedJWS>;
+    sign(key: KeyLike | Uint8Array, options?: SignOptions): Promise<FlattenedJWS>;
 }

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

@@ -1,33 +1,25 @@
-/**
- * Verifying JSON Web Signature (JWS) in Flattened JSON Serialization
- *
- * @module
- */
-import type * as types from '../../types.d.ts';
+import type { FlattenedVerifyResult, KeyLike, FlattenedJWSInput, JWSHeaderParameters, VerifyOptions, GetKeyFunction, ResolvedKey } from '../../types';
 /**
  * Interface for Flattened JWS Verification dynamic key resolution. No token components have been
  * verified at the time of this function call.
  *
- * @see {@link jwks/remote.createRemoteJWKSet createRemoteJWKSet} to verify using a remote JSON Web Key Set.
+ * @see [createRemoteJWKSet](../functions/jwks_remote.createRemoteJWKSet.md#function-createremotejwkset) to verify using a remote JSON Web Key Set.
  */
-export interface FlattenedVerifyGetKey extends types.GenericGetKeyFunction<types.JWSHeaderParameters | undefined, types.FlattenedJWSInput, types.CryptoKey | types.KeyObject | types.JWK | Uint8Array> {
+export interface FlattenedVerifyGetKey extends GetKeyFunction<JWSHeaderParameters | undefined, FlattenedJWSInput> {
 }
 /**
  * Verifies the signature and format of and afterwards decodes the Flattened JWS.
  *
- * This function is exported (as a named export) from the main `'jose'` module entry point as well
- * as from its subpath export `'jose/jws/flattened/verify'`.
- *
  * @param jws Flattened JWS.
  * @param key 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.
  */
-export declare function flattenedVerify(jws: types.FlattenedJWSInput, key: types.CryptoKey | types.KeyObject | types.JWK | Uint8Array, options?: types.VerifyOptions): Promise<types.FlattenedVerifyResult>;
+export declare function flattenedVerify(jws: FlattenedJWSInput, key: KeyLike | Uint8Array, options?: VerifyOptions): Promise<FlattenedVerifyResult>;
 /**
  * @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.
  */
-export declare function flattenedVerify(jws: types.FlattenedJWSInput, getKey: FlattenedVerifyGetKey, options?: types.VerifyOptions): Promise<types.FlattenedVerifyResult & types.ResolvedKey>;
+export declare function flattenedVerify<T extends KeyLike = KeyLike>(jws: FlattenedJWSInput, getKey: FlattenedVerifyGetKey, options?: VerifyOptions): Promise<FlattenedVerifyResult & ResolvedKey<T>>;