jose 4.15.4 → 5.0.1

package/dist/node/esm/runtime/key_to_jwk.js

@@ -1,13 +1,10 @@
-import { KeyObject, createPublicKey } from 'crypto';
+import { KeyObject } from 'node:crypto';
 import { encode as base64url } from './base64url.js';
-import Asn1SequenceDecoder from './asn1_sequence_decoder.js';
 import { JOSENotSupported } from '../util/errors.js';
-import getNamedCurve from './get_named_curve.js';
 import { isCryptoKey } from './webcrypto.js';
 import isKeyObject from './is_key_object.js';
 import invalidKeyInput from '../lib/invalid_key_input.js';
 import { types } from './is_key_like.js';
-import { jwkExport } from './flags.js';
 const keyToJWK = (key) => {
     let keyObject;
     if (isCryptoKey(key)) {
@@ -28,131 +25,10 @@ const keyToJWK = (key) => {
     else {
         throw new TypeError(invalidKeyInput(key, ...types, 'Uint8Array'));
     }
-    if (jwkExport) {
-        if (keyObject.type !== 'secret' &&
-            !['rsa', 'ec', 'ed25519', 'x25519', 'ed448', 'x448'].includes(keyObject.asymmetricKeyType)) {
-            throw new JOSENotSupported('Unsupported key asymmetricKeyType');
-        }
-        return keyObject.export({ format: 'jwk' });
-    }
-    switch (keyObject.type) {
-        case 'secret':
-            return {
-                kty: 'oct',
-                k: base64url(keyObject.export()),
-            };
-        case 'private':
-        case 'public': {
-            switch (keyObject.asymmetricKeyType) {
-                case 'rsa': {
-                    const der = keyObject.export({ format: 'der', type: 'pkcs1' });
-                    const dec = new Asn1SequenceDecoder(der);
-                    if (keyObject.type === 'private') {
-                        dec.unsignedInteger();
-                    }
-                    const n = base64url(dec.unsignedInteger());
-                    const e = base64url(dec.unsignedInteger());
-                    let jwk;
-                    if (keyObject.type === 'private') {
-                        jwk = {
-                            d: base64url(dec.unsignedInteger()),
-                            p: base64url(dec.unsignedInteger()),
-                            q: base64url(dec.unsignedInteger()),
-                            dp: base64url(dec.unsignedInteger()),
-                            dq: base64url(dec.unsignedInteger()),
-                            qi: base64url(dec.unsignedInteger()),
-                        };
-                    }
-                    dec.end();
-                    return { kty: 'RSA', n, e, ...jwk };
-                }
-                case 'ec': {
-                    const crv = getNamedCurve(keyObject);
-                    let len;
-                    let offset;
-                    let correction;
-                    switch (crv) {
-                        case 'secp256k1':
-                            len = 64;
-                            offset = 31 + 2;
-                            correction = -1;
-                            break;
-                        case 'P-256':
-                            len = 64;
-                            offset = 34 + 2;
-                            correction = -1;
-                            break;
-                        case 'P-384':
-                            len = 96;
-                            offset = 33 + 2;
-                            correction = -3;
-                            break;
-                        case 'P-521':
-                            len = 132;
-                            offset = 33 + 2;
-                            correction = -3;
-                            break;
-                        default:
-                            throw new JOSENotSupported('Unsupported curve');
-                    }
-                    if (keyObject.type === 'public') {
-                        const der = keyObject.export({ type: 'spki', format: 'der' });
-                        return {
-                            kty: 'EC',
-                            crv,
-                            x: base64url(der.subarray(-len, -len / 2)),
-                            y: base64url(der.subarray(-len / 2)),
-                        };
-                    }
-                    const der = keyObject.export({ type: 'pkcs8', format: 'der' });
-                    if (der.length < 100) {
-                        offset += correction;
-                    }
-                    return {
-                        ...keyToJWK(createPublicKey(keyObject)),
-                        d: base64url(der.subarray(offset, offset + len / 2)),
-                    };
-                }
-                case 'ed25519':
-                case 'x25519': {
-                    const crv = getNamedCurve(keyObject);
-                    if (keyObject.type === 'public') {
-                        const der = keyObject.export({ type: 'spki', format: 'der' });
-                        return {
-                            kty: 'OKP',
-                            crv,
-                            x: base64url(der.subarray(-32)),
-                        };
-                    }
-                    const der = keyObject.export({ type: 'pkcs8', format: 'der' });
-                    return {
-                        ...keyToJWK(createPublicKey(keyObject)),
-                        d: base64url(der.subarray(-32)),
-                    };
-                }
-                case 'ed448':
-                case 'x448': {
-                    const crv = getNamedCurve(keyObject);
-                    if (keyObject.type === 'public') {
-                        const der = keyObject.export({ type: 'spki', format: 'der' });
-                        return {
-                            kty: 'OKP',
-                            crv,
-                            x: base64url(der.subarray(crv === 'Ed448' ? -57 : -56)),
-                        };
-                    }
-                    const der = keyObject.export({ type: 'pkcs8', format: 'der' });
-                    return {
-                        ...keyToJWK(createPublicKey(keyObject)),
-                        d: base64url(der.subarray(crv === 'Ed448' ? -57 : -56)),
-                    };
-                }
-                default:
-                    throw new JOSENotSupported('Unsupported key asymmetricKeyType');
-            }
-        }
-        default:
-            throw new JOSENotSupported('Unsupported key type');
+    if (keyObject.type !== 'secret' &&
+        !['rsa', 'ec', 'ed25519', 'x25519', 'ed448', 'x448'].includes(keyObject.asymmetricKeyType)) {
+        throw new JOSENotSupported('Unsupported key asymmetricKeyType');
     }
+    return keyObject.export({ format: 'jwk' });
 };
 export default keyToJWK;

package/dist/node/esm/runtime/node_key.js

@@ -1,8 +1,7 @@
-import { constants } from 'crypto';
+import { constants } from 'node:crypto';
 import getNamedCurve from './get_named_curve.js';
 import { JOSENotSupported } from '../util/errors.js';
-import checkModulusLength from './check_modulus_length.js';
-import { rsaPssParams } from './flags.js';
+import checkKeyLength from './check_key_length.js';
 const PSS = {
     padding: constants.RSA_PKCS1_PSS_PADDING,
     saltLength: constants.RSA_PSS_SALTLEN_DIGEST,
@@ -26,11 +25,11 @@ export default function keyForCrypto(alg, key) {
             if (key.asymmetricKeyType !== 'rsa') {
                 throw new TypeError('Invalid key for this operation, its asymmetricKeyType must be rsa');
             }
-            checkModulusLength(key, alg);
+            checkKeyLength(key, alg);
             return key;
-        case rsaPssParams && 'PS256':
-        case rsaPssParams && 'PS384':
-        case rsaPssParams && 'PS512':
+        case 'PS256':
+        case 'PS384':
+        case 'PS512':
             if (key.asymmetricKeyType === 'rsa-pss') {
                 const { hashAlgorithm, mgf1HashAlgorithm, saltLength } = key.asymmetricKeyDetails;
                 const length = parseInt(alg.slice(-3), 10);
@@ -45,15 +44,7 @@ export default function keyForCrypto(alg, key) {
             else if (key.asymmetricKeyType !== 'rsa') {
                 throw new TypeError('Invalid key for this operation, its asymmetricKeyType must be rsa or rsa-pss');
             }
-            checkModulusLength(key, alg);
-            return { key, ...PSS };
-        case !rsaPssParams && 'PS256':
-        case !rsaPssParams && 'PS384':
-        case !rsaPssParams && 'PS512':
-            if (key.asymmetricKeyType !== 'rsa') {
-                throw new TypeError('Invalid key for this operation, its asymmetricKeyType must be rsa');
-            }
-            checkModulusLength(key, alg);
+            checkKeyLength(key, alg);
             return { key, ...PSS };
         case 'ES256':
         case 'ES256K':

package/dist/node/esm/runtime/pbes2kw.js

@@ -1,5 +1,5 @@
-import { promisify } from 'util';
-import { KeyObject, pbkdf2 as pbkdf2cb } from 'crypto';
+import { promisify } from 'node:util';
+import { KeyObject, pbkdf2 as pbkdf2cb } from 'node:crypto';
 import random from './random.js';
 import { p2s as concatSalt } from '../lib/buffer_utils.js';
 import { encode as base64url } from './base64url.js';

package/dist/node/esm/runtime/random.js

@@ -1 +1 @@
-export { randomFillSync as default } from 'crypto';
+export { randomFillSync as default } from 'node:crypto';

package/dist/node/esm/runtime/rsaes.js

@@ -1,5 +1,5 @@
-import { KeyObject, publicEncrypt, constants, privateDecrypt } from 'crypto';
-import checkModulusLength from './check_modulus_length.js';
+import { KeyObject, publicEncrypt, constants, privateDecrypt } from 'node:crypto';
+import checkKeyLength from './check_key_length.js';
 import { isCryptoKey } from './webcrypto.js';
 import { checkEncCryptoKey } from '../lib/crypto_key.js';
 import isKeyObject from './is_key_object.js';
@@ -9,7 +9,7 @@ const checkKey = (key, alg) => {
     if (key.asymmetricKeyType !== 'rsa') {
         throw new TypeError('Invalid key for this operation, its asymmetricKeyType must be rsa');
     }
-    checkModulusLength(key, alg);
+    checkKeyLength(key, alg);
 };
 const resolvePadding = (alg) => {
     switch (alg) {

package/dist/node/esm/runtime/sign.js

@@ -1,16 +1,10 @@
-import * as crypto from 'crypto';
-import { promisify } from 'util';
+import * as crypto from 'node:crypto';
+import { promisify } from 'node:util';
 import nodeDigest from './dsa_digest.js';
 import hmacDigest from './hmac_digest.js';
 import nodeKey from './node_key.js';
 import getSignKey from './get_sign_verify_key.js';
-let oneShotSign;
-if (crypto.sign.length > 3) {
-    oneShotSign = promisify(crypto.sign);
-}
-else {
-    oneShotSign = crypto.sign;
-}
+const oneShotSign = promisify(crypto.sign);
 const sign = async (alg, key, data) => {
     const keyObject = getSignKey(alg, key, 'sign');
     if (alg.startsWith('HS')) {

package/dist/node/esm/runtime/timing_safe_equal.js

@@ -1,3 +1,3 @@
-import { timingSafeEqual as impl } from 'crypto';
+import { timingSafeEqual as impl } from 'node:crypto';
 const timingSafeEqual = impl;
 export default timingSafeEqual;

package/dist/node/esm/runtime/verify.js

@@ -1,17 +1,10 @@
-import * as crypto from 'crypto';
-import { promisify } from 'util';
+import * as crypto from 'node:crypto';
+import { promisify } from 'node:util';
 import nodeDigest from './dsa_digest.js';
 import nodeKey from './node_key.js';
 import sign from './sign.js';
 import getVerifyKey from './get_sign_verify_key.js';
-import { oneShotCallback } from './flags.js';
-let oneShotVerify;
-if (crypto.verify.length > 4 && oneShotCallback) {
-    oneShotVerify = promisify(crypto.verify);
-}
-else {
-    oneShotVerify = crypto.verify;
-}
+const oneShotVerify = promisify(crypto.verify);
 const verify = async (alg, key, signature, data) => {
     const keyObject = getVerifyKey(alg, key, 'verify');
     if (alg.startsWith('HS')) {

package/dist/node/esm/runtime/webcrypto.js

@@ -1,8 +1,5 @@
-import * as crypto from 'crypto';
-import * as util from 'util';
+import * as crypto from 'node:crypto';
+import * as util from 'node:util';
 const webcrypto = crypto.webcrypto;
 export default webcrypto;
-export const isCryptoKey = util.types.isCryptoKey
-    ? (key) => util.types.isCryptoKey(key)
-    :
-        (key) => false;
+export const isCryptoKey = (key) => util.types.isCryptoKey(key);

package/dist/node/esm/util/errors.js

@@ -2,21 +2,22 @@ export class JOSEError extends Error {
     static get code() {
         return 'ERR_JOSE_GENERIC';
     }
+    code = 'ERR_JOSE_GENERIC';
     constructor(message) {
-        var _a;
         super(message);
-        this.code = 'ERR_JOSE_GENERIC';
         this.name = this.constructor.name;
-        (_a = Error.captureStackTrace) === null || _a === void 0 ? void 0 : _a.call(Error, this, this.constructor);
+        Error.captureStackTrace?.(this, this.constructor);
     }
 }
 export class JWTClaimValidationFailed extends JOSEError {
     static get code() {
         return 'ERR_JWT_CLAIM_VALIDATION_FAILED';
     }
+    code = 'ERR_JWT_CLAIM_VALIDATION_FAILED';
+    claim;
+    reason;
     constructor(message, claim = 'unspecified', reason = 'unspecified') {
         super(message);
-        this.code = 'ERR_JWT_CLAIM_VALIDATION_FAILED';
         this.claim = claim;
         this.reason = reason;
     }
@@ -25,124 +26,90 @@ export class JWTExpired extends JOSEError {
     static get code() {
         return 'ERR_JWT_EXPIRED';
     }
+    code = 'ERR_JWT_EXPIRED';
+    claim;
+    reason;
     constructor(message, claim = 'unspecified', reason = 'unspecified') {
         super(message);
-        this.code = 'ERR_JWT_EXPIRED';
         this.claim = claim;
         this.reason = reason;
     }
 }
 export class JOSEAlgNotAllowed extends JOSEError {
-    constructor() {
-        super(...arguments);
-        this.code = 'ERR_JOSE_ALG_NOT_ALLOWED';
-    }
     static get code() {
         return 'ERR_JOSE_ALG_NOT_ALLOWED';
     }
+    code = 'ERR_JOSE_ALG_NOT_ALLOWED';
 }
 export class JOSENotSupported extends JOSEError {
-    constructor() {
-        super(...arguments);
-        this.code = 'ERR_JOSE_NOT_SUPPORTED';
-    }
     static get code() {
         return 'ERR_JOSE_NOT_SUPPORTED';
     }
+    code = 'ERR_JOSE_NOT_SUPPORTED';
 }
 export class JWEDecryptionFailed extends JOSEError {
-    constructor() {
-        super(...arguments);
-        this.code = 'ERR_JWE_DECRYPTION_FAILED';
-        this.message = 'decryption operation failed';
-    }
     static get code() {
         return 'ERR_JWE_DECRYPTION_FAILED';
     }
+    code = 'ERR_JWE_DECRYPTION_FAILED';
+    message = 'decryption operation failed';
 }
 export class JWEInvalid extends JOSEError {
-    constructor() {
-        super(...arguments);
-        this.code = 'ERR_JWE_INVALID';
-    }
     static get code() {
         return 'ERR_JWE_INVALID';
     }
+    code = 'ERR_JWE_INVALID';
 }
 export class JWSInvalid extends JOSEError {
-    constructor() {
-        super(...arguments);
-        this.code = 'ERR_JWS_INVALID';
-    }
     static get code() {
         return 'ERR_JWS_INVALID';
     }
+    code = 'ERR_JWS_INVALID';
 }
 export class JWTInvalid extends JOSEError {
-    constructor() {
-        super(...arguments);
-        this.code = 'ERR_JWT_INVALID';
-    }
     static get code() {
         return 'ERR_JWT_INVALID';
     }
+    code = 'ERR_JWT_INVALID';
 }
 export class JWKInvalid extends JOSEError {
-    constructor() {
-        super(...arguments);
-        this.code = 'ERR_JWK_INVALID';
-    }
     static get code() {
         return 'ERR_JWK_INVALID';
     }
+    code = 'ERR_JWK_INVALID';
 }
 export class JWKSInvalid extends JOSEError {
-    constructor() {
-        super(...arguments);
-        this.code = 'ERR_JWKS_INVALID';
-    }
     static get code() {
         return 'ERR_JWKS_INVALID';
     }
+    code = 'ERR_JWKS_INVALID';
 }
 export class JWKSNoMatchingKey extends JOSEError {
-    constructor() {
-        super(...arguments);
-        this.code = 'ERR_JWKS_NO_MATCHING_KEY';
-        this.message = 'no applicable key found in the JSON Web Key Set';
-    }
     static get code() {
         return 'ERR_JWKS_NO_MATCHING_KEY';
     }
+    code = 'ERR_JWKS_NO_MATCHING_KEY';
+    message = 'no applicable key found in the JSON Web Key Set';
 }
 export class JWKSMultipleMatchingKeys extends JOSEError {
-    constructor() {
-        super(...arguments);
-        this.code = 'ERR_JWKS_MULTIPLE_MATCHING_KEYS';
-        this.message = 'multiple matching keys found in the JSON Web Key Set';
-    }
+    [Symbol.asyncIterator];
     static get code() {
         return 'ERR_JWKS_MULTIPLE_MATCHING_KEYS';
     }
+    code = 'ERR_JWKS_MULTIPLE_MATCHING_KEYS';
+    message = 'multiple matching keys found in the JSON Web Key Set';
 }
-Symbol.asyncIterator;
 export class JWKSTimeout extends JOSEError {
-    constructor() {
-        super(...arguments);
-        this.code = 'ERR_JWKS_TIMEOUT';
-        this.message = 'request timed out';
-    }
     static get code() {
         return 'ERR_JWKS_TIMEOUT';
     }
+    code = 'ERR_JWKS_TIMEOUT';
+    message = 'request timed out';
 }
 export class JWSSignatureVerificationFailed extends JOSEError {
-    constructor() {
-        super(...arguments);
-        this.code = 'ERR_JWS_SIGNATURE_VERIFICATION_FAILED';
-        this.message = 'signature verification failed';
-    }
     static get code() {
         return 'ERR_JWS_SIGNATURE_VERIFICATION_FAILED';
     }
+    code = 'ERR_JWS_SIGNATURE_VERIFICATION_FAILED';
+    message = 'signature verification failed';
 }

package/dist/types/index.d.ts

@@ -44,5 +44,5 @@ export type { GenerateKeyPairResult, GenerateKeyPairOptions } from './key/genera
 export { generateSecret } from './key/generate_secret';
 export type { GenerateSecretOptions } from './key/generate_secret';
 export * as base64url from './util/base64url';
-export type { KeyLike, JWK, FlattenedJWSInput, GeneralJWSInput, FlattenedJWS, GeneralJWS, JoseHeaderParameters, JWSHeaderParameters, JWEKeyManagementHeaderParameters, FlattenedJWE, GeneralJWE, JWEHeaderParameters, CritOption, DeflateOption, DecryptOptions, EncryptOptions, JWTClaimVerificationOptions, VerifyOptions, SignOptions, JWTPayload, DeflateFunction, InflateFunction, FlattenedDecryptResult, GeneralDecryptResult, CompactDecryptResult, FlattenedVerifyResult, GeneralVerifyResult, CompactVerifyResult, JWTVerifyResult, JWTDecryptResult, ResolvedKey, CompactJWEHeaderParameters, CompactJWSHeaderParameters, JWTHeaderParameters, JSONWebKeySet, CryptoRuntime, GetKeyFunction, } from './types';
+export type { KeyLike, JWK, FlattenedJWSInput, GeneralJWSInput, FlattenedJWS, GeneralJWS, JoseHeaderParameters, JWSHeaderParameters, JWEKeyManagementHeaderParameters, FlattenedJWE, GeneralJWE, JWEHeaderParameters, CritOption, DecryptOptions, EncryptOptions, JWTClaimVerificationOptions, VerifyOptions, SignOptions, JWTPayload, FlattenedDecryptResult, GeneralDecryptResult, CompactDecryptResult, FlattenedVerifyResult, GeneralVerifyResult, CompactVerifyResult, JWTVerifyResult, JWTDecryptResult, ResolvedKey, CompactJWEHeaderParameters, CompactJWSHeaderParameters, JWTHeaderParameters, JSONWebKeySet, CryptoRuntime, GetKeyFunction, } from './types';
 export { default as cryptoRuntime } from './util/runtime';

package/dist/types/jwe/compact/decrypt.d.ts

@@ -20,4 +20,4 @@ export declare function compactDecrypt(jwe: string | Uint8Array, key: KeyLike |
  *   {@link https://github.com/panva/jose/issues/210#jwe-alg Algorithm Key Requirements}.
  * @param options JWE Decryption options.
  */
-export declare function compactDecrypt<T extends KeyLike = KeyLike>(jwe: string | Uint8Array, getKey: CompactDecryptGetKey, options?: DecryptOptions): Promise<CompactDecryptResult & ResolvedKey<T>>;
+export declare function compactDecrypt<KeyLikeType extends KeyLike = KeyLike>(jwe: string | Uint8Array, getKey: CompactDecryptGetKey, options?: DecryptOptions): Promise<CompactDecryptResult & ResolvedKey<KeyLikeType>>;

package/dist/types/jwe/flattened/decrypt.d.ts

@@ -20,4 +20,4 @@ export declare function flattenedDecrypt(jwe: FlattenedJWE, key: KeyLike | Uint8
  *   {@link https://github.com/panva/jose/issues/210#jwe-alg Algorithm Key Requirements}.
  * @param options JWE Decryption options.
  */
-export declare function flattenedDecrypt<T extends KeyLike = KeyLike>(jwe: FlattenedJWE, getKey: FlattenedDecryptGetKey, options?: DecryptOptions): Promise<FlattenedDecryptResult & ResolvedKey<T>>;
+export declare function flattenedDecrypt<KeyLikeType extends KeyLike = KeyLike>(jwe: FlattenedJWE, getKey: FlattenedDecryptGetKey, options?: DecryptOptions): Promise<FlattenedDecryptResult & ResolvedKey<KeyLikeType>>;

package/dist/types/jwe/general/decrypt.d.ts

@@ -20,4 +20,4 @@ export declare function generalDecrypt(jwe: GeneralJWE, key: KeyLike | Uint8Arra
  *   {@link https://github.com/panva/jose/issues/210#jwe-alg Algorithm Key Requirements}.
  * @param options JWE Decryption options.
  */
-export declare function generalDecrypt<T extends KeyLike = KeyLike>(jwe: GeneralJWE, getKey: GeneralDecryptGetKey, options?: DecryptOptions): Promise<GeneralDecryptResult & ResolvedKey<T>>;
+export declare function generalDecrypt<KeyLikeType extends KeyLike = KeyLike>(jwe: GeneralJWE, getKey: GeneralDecryptGetKey, options?: DecryptOptions): Promise<GeneralDecryptResult & ResolvedKey<KeyLikeType>>;

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

@@ -1,4 +1,4 @@
-import type { KeyLike, GeneralJWE, JWEHeaderParameters, CritOption, DeflateOption } from '../../types';
+import type { KeyLike, GeneralJWE, JWEHeaderParameters, CritOption } from '../../types';
 export interface Recipient {
     /**
      * Sets the JWE Per-Recipient Unprotected Header on the Recipient object.
@@ -51,10 +51,6 @@ export declare class GeneralEncrypt {
      * @param aad Additional Authenticated Data.
      */
     setAdditionalAuthenticatedData(aad: Uint8Array): this;
-    /**
-     * Encrypts and resolves the value of the General JWE object.
-     *
-     * @param options JWE Encryption options.
-     */
-    encrypt(options?: DeflateOption): Promise<GeneralJWE>;
+    /** Encrypts and resolves the value of the General JWE object. */
+    encrypt(): Promise<GeneralJWE>;
 }

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

@@ -6,4 +6,4 @@ import type { KeyLike, FlattenedJWSInput, JWSHeaderParameters } from '../types';
  * function's `algorithms` option to define accepted JWS "alg" (Algorithm) Header Parameter values.
  *
  */
-export declare function EmbeddedJWK<T extends KeyLike = KeyLike>(protectedHeader?: JWSHeaderParameters, token?: FlattenedJWSInput): Promise<T>;
+export declare function EmbeddedJWK<KeyLikeType extends KeyLike = KeyLike>(protectedHeader?: JWSHeaderParameters, token?: FlattenedJWSInput): Promise<KeyLikeType>;

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

@@ -2,11 +2,11 @@ import type { KeyLike, JWSHeaderParameters, JSONWebKeySet, FlattenedJWSInput } f
 /** @private */
 export declare function isJWKSLike(jwks: unknown): jwks is JSONWebKeySet;
 /** @private */
-export declare class LocalJWKSet<T extends KeyLike = KeyLike> {
+export declare class LocalJWKSet<KeyLikeType extends KeyLike = KeyLike> {
     protected _jwks?: JSONWebKeySet;
     private _cached;
     constructor(jwks: unknown);
-    getKey(protectedHeader?: JWSHeaderParameters, token?: FlattenedJWSInput): Promise<T>;
+    getKey(protectedHeader?: JWSHeaderParameters, token?: FlattenedJWSInput): Promise<KeyLikeType>;
 }
 /**
  * Returns a function that resolves to a key object from a locally stored, or otherwise available,
@@ -23,4 +23,4 @@ export declare class LocalJWKSet<T extends KeyLike = KeyLike> {
  *
  * @param jwks JSON Web Key Set formatted object.
  */
-export declare function createLocalJWKSet<T extends KeyLike = KeyLike>(jwks: JSONWebKeySet): (protectedHeader?: JWSHeaderParameters, token?: FlattenedJWSInput) => Promise<T>;
+export declare function createLocalJWKSet<KeyLikeType extends KeyLike = KeyLike>(jwks: JSONWebKeySet): (protectedHeader?: JWSHeaderParameters, token?: FlattenedJWSInput) => Promise<KeyLikeType>;

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

@@ -46,4 +46,4 @@ export interface RemoteJWKSetOptions {
  * @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<T extends KeyLike = KeyLike>(url: URL, options?: RemoteJWKSetOptions): (protectedHeader?: JWSHeaderParameters, token?: FlattenedJWSInput) => Promise<T>;
+export declare function createRemoteJWKSet<KeyLikeType extends KeyLike = KeyLike>(url: URL, options?: RemoteJWKSetOptions): (protectedHeader?: JWSHeaderParameters, token?: FlattenedJWSInput) => Promise<KeyLikeType>;

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

@@ -22,4 +22,4 @@ export declare function compactVerify(jws: string | Uint8Array, key: KeyLike | U
  *   {@link https://github.com/panva/jose/issues/210#jws-alg Algorithm Key Requirements}.
  * @param options JWS Verify options.
  */
-export declare function compactVerify<T extends KeyLike = KeyLike>(jws: string | Uint8Array, getKey: CompactVerifyGetKey, options?: VerifyOptions): Promise<CompactVerifyResult & ResolvedKey<T>>;
+export declare function compactVerify<KeyLikeType extends KeyLike = KeyLike>(jws: string | Uint8Array, getKey: CompactVerifyGetKey, options?: VerifyOptions): Promise<CompactVerifyResult & ResolvedKey<KeyLikeType>>;

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

@@ -22,4 +22,4 @@ export declare function flattenedVerify(jws: FlattenedJWSInput, key: KeyLike | U
  *   {@link https://github.com/panva/jose/issues/210#jws-alg Algorithm Key Requirements}.
  * @param options JWS Verify options.
  */
-export declare function flattenedVerify<T extends KeyLike = KeyLike>(jws: FlattenedJWSInput, getKey: FlattenedVerifyGetKey, options?: VerifyOptions): Promise<FlattenedVerifyResult & ResolvedKey<T>>;
+export declare function flattenedVerify<KeyLikeType extends KeyLike = KeyLike>(jws: FlattenedJWSInput, getKey: FlattenedVerifyGetKey, options?: VerifyOptions): Promise<FlattenedVerifyResult & ResolvedKey<KeyLikeType>>;

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

@@ -22,4 +22,4 @@ export declare function generalVerify(jws: GeneralJWSInput, key: KeyLike | Uint8
  *   {@link https://github.com/panva/jose/issues/210#jws-alg Algorithm Key Requirements}.
  * @param options JWS Verify options.
  */
-export declare function generalVerify<T extends KeyLike = KeyLike>(jws: GeneralJWSInput, getKey: GeneralVerifyGetKey, options?: VerifyOptions): Promise<GeneralVerifyResult & ResolvedKey<T>>;
+export declare function generalVerify<KeyLikeType extends KeyLike = KeyLike>(jws: GeneralJWSInput, getKey: GeneralVerifyGetKey, options?: VerifyOptions): Promise<GeneralVerifyResult & ResolvedKey<KeyLikeType>>;

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

@@ -1,4 +1,4 @@
-import type { KeyLike, DecryptOptions, JWTClaimVerificationOptions, GetKeyFunction, CompactJWEHeaderParameters, FlattenedJWE, JWTDecryptResult, ResolvedKey } from '../types';
+import type { JWTPayload, KeyLike, DecryptOptions, JWTClaimVerificationOptions, GetKeyFunction, CompactJWEHeaderParameters, FlattenedJWE, JWTDecryptResult, ResolvedKey } from '../types';
 /** Combination of JWE Decryption options and JWT Claims Set verification options. */
 export interface JWTDecryptOptions extends DecryptOptions, JWTClaimVerificationOptions {
 }
@@ -17,11 +17,11 @@ export interface JWTDecryptGetKey extends GetKeyFunction<CompactJWEHeaderParamet
  *   {@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(jwt: string | Uint8Array, key: KeyLike | Uint8Array, options?: JWTDecryptOptions): Promise<JWTDecryptResult>;
+export declare function jwtDecrypt<PayloadType = JWTPayload>(jwt: string | Uint8Array, key: KeyLike | Uint8Array, options?: JWTDecryptOptions): Promise<JWTDecryptResult<PayloadType>>;
 /**
  * @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.
  */
-export declare function jwtDecrypt<T extends KeyLike = KeyLike>(jwt: string | Uint8Array, getKey: JWTDecryptGetKey, options?: JWTDecryptOptions): Promise<JWTDecryptResult & ResolvedKey<T>>;
+export declare function jwtDecrypt<PayloadType = JWTPayload, KeyLikeType extends KeyLike = KeyLike>(jwt: string | Uint8Array, getKey: JWTDecryptGetKey, options?: JWTDecryptOptions): Promise<JWTDecryptResult<PayloadType> & ResolvedKey<KeyLikeType>>;