jose 6.0.8 → 6.0.10

package/dist/webapi/jws/flattened/sign.js

@@ -7,44 +7,44 @@ import checkKeyType from '../../lib/check_key_type.js';
 import validateCrit from '../../lib/validate_crit.js';
 import normalizeKey from '../../lib/normalize_key.js';
 export class FlattenedSign {
-    _payload;
-    _protectedHeader;
-    _unprotectedHeader;
+    #payload;
+    #protectedHeader;
+    #unprotectedHeader;
     constructor(payload) {
         if (!(payload instanceof Uint8Array)) {
             throw new TypeError('payload must be an instance of Uint8Array');
         }
-        this._payload = payload;
+        this.#payload = payload;
     }
     setProtectedHeader(protectedHeader) {
-        if (this._protectedHeader) {
+        if (this.#protectedHeader) {
             throw new TypeError('setProtectedHeader can only be called once');
         }
-        this._protectedHeader = protectedHeader;
+        this.#protectedHeader = protectedHeader;
         return this;
     }
     setUnprotectedHeader(unprotectedHeader) {
-        if (this._unprotectedHeader) {
+        if (this.#unprotectedHeader) {
             throw new TypeError('setUnprotectedHeader can only be called once');
         }
-        this._unprotectedHeader = unprotectedHeader;
+        this.#unprotectedHeader = unprotectedHeader;
         return this;
     }
     async sign(key, options) {
-        if (!this._protectedHeader && !this._unprotectedHeader) {
+        if (!this.#protectedHeader && !this.#unprotectedHeader) {
             throw new JWSInvalid('either setProtectedHeader or setUnprotectedHeader must be called before #sign()');
         }
-        if (!isDisjoint(this._protectedHeader, this._unprotectedHeader)) {
+        if (!isDisjoint(this.#protectedHeader, this.#unprotectedHeader)) {
             throw new JWSInvalid('JWS Protected and JWS Unprotected Header Parameter names must be disjoint');
         }
         const joseHeader = {
-            ...this._protectedHeader,
-            ...this._unprotectedHeader,
+            ...this.#protectedHeader,
+            ...this.#unprotectedHeader,
         };
-        const extensions = validateCrit(JWSInvalid, new Map([['b64', true]]), options?.crit, this._protectedHeader, joseHeader);
+        const extensions = validateCrit(JWSInvalid, new Map([['b64', true]]), options?.crit, this.#protectedHeader, joseHeader);
         let b64 = true;
         if (extensions.has('b64')) {
-            b64 = this._protectedHeader.b64;
+            b64 = this.#protectedHeader.b64;
             if (typeof b64 !== 'boolean') {
                 throw new JWSInvalid('The "b64" (base64url-encode payload) Header Parameter must be a boolean');
             }
@@ -54,13 +54,13 @@ export class FlattenedSign {
             throw new JWSInvalid('JWS "alg" (Algorithm) Header Parameter missing or invalid');
         }
         checkKeyType(alg, key, 'sign');
-        let payload = this._payload;
+        let payload = this.#payload;
         if (b64) {
             payload = encoder.encode(b64u(payload));
         }
         let protectedHeader;
-        if (this._protectedHeader) {
-            protectedHeader = encoder.encode(b64u(JSON.stringify(this._protectedHeader)));
+        if (this.#protectedHeader) {
+            protectedHeader = encoder.encode(b64u(JSON.stringify(this.#protectedHeader)));
         }
         else {
             protectedHeader = encoder.encode('');
@@ -75,10 +75,10 @@ export class FlattenedSign {
         if (b64) {
             jws.payload = decoder.decode(payload);
         }
-        if (this._unprotectedHeader) {
-            jws.header = this._unprotectedHeader;
+        if (this.#unprotectedHeader) {
+            jws.header = this.#unprotectedHeader;
         }
-        if (this._protectedHeader) {
+        if (this.#protectedHeader) {
             jws.protected = decoder.decode(protectedHeader);
         }
         return jws;

package/dist/webapi/jws/general/sign.js

@@ -1,13 +1,13 @@
 import { FlattenedSign } from '../flattened/sign.js';
 import { JWSInvalid } from '../../util/errors.js';
 class IndividualSignature {
-    parent;
+    #parent;
     protectedHeader;
     unprotectedHeader;
     options;
     key;
     constructor(sig, key, options) {
-        this.parent = sig;
+        this.#parent = sig;
         this.key = key;
         this.options = options;
     }
@@ -26,37 +26,37 @@ class IndividualSignature {
         return this;
     }
     addSignature(...args) {
-        return this.parent.addSignature(...args);
+        return this.#parent.addSignature(...args);
     }
     sign(...args) {
-        return this.parent.sign(...args);
+        return this.#parent.sign(...args);
     }
     done() {
-        return this.parent;
+        return this.#parent;
     }
 }
 export class GeneralSign {
-    _payload;
-    _signatures = [];
+    #payload;
+    #signatures = [];
     constructor(payload) {
-        this._payload = payload;
+        this.#payload = payload;
     }
     addSignature(key, options) {
         const signature = new IndividualSignature(this, key, options);
-        this._signatures.push(signature);
+        this.#signatures.push(signature);
         return signature;
     }
     async sign() {
-        if (!this._signatures.length) {
+        if (!this.#signatures.length) {
             throw new JWSInvalid('at least one signature must be added');
         }
         const jws = {
             signatures: [],
             payload: '',
         };
-        for (let i = 0; i < this._signatures.length; i++) {
-            const signature = this._signatures[i];
-            const flattened = new FlattenedSign(this._payload);
+        for (let i = 0; i < this.#signatures.length; i++) {
+            const signature = this.#signatures[i];
+            const flattened = new FlattenedSign(this.#payload);
             flattened.setProtectedHeader(signature.protectedHeader);
             flattened.setUnprotectedHeader(signature.unprotectedHeader);
             const { payload, ...rest } = await flattened.sign(signature.key, signature.options);

package/dist/webapi/jwt/decrypt.js

@@ -1,9 +1,9 @@
 import { compactDecrypt } from '../jwe/compact/decrypt.js';
-import jwtPayload from '../lib/jwt_claims_set.js';
+import { validateClaimsSet } from '../lib/jwt_claims_set.js';
 import { JWTClaimValidationFailed } from '../util/errors.js';
 export async function jwtDecrypt(jwt, key, options) {
     const decrypted = await compactDecrypt(jwt, key, options);
-    const payload = jwtPayload(decrypted.protectedHeader, decrypted.plaintext, options);
+    const payload = validateClaimsSet(decrypted.protectedHeader, decrypted.plaintext, options);
     const { protectedHeader } = decrypted;
     if (protectedHeader.iss !== undefined && protectedHeader.iss !== payload.iss) {
         throw new JWTClaimValidationFailed('replicated "iss" claim header parameter mismatch', payload, 'iss', 'mismatch');

package/dist/webapi/jwt/encrypt.js

@@ -1,74 +1,107 @@
 import { CompactEncrypt } from '../jwe/compact/encrypt.js';
-import { encoder } from '../lib/buffer_utils.js';
-import { ProduceJWT } from './produce.js';
-export class EncryptJWT extends ProduceJWT {
-    _cek;
-    _iv;
-    _keyManagementParameters;
-    _protectedHeader;
-    _replicateIssuerAsHeader;
-    _replicateSubjectAsHeader;
-    _replicateAudienceAsHeader;
+import { JWTClaimsBuilder } from '../lib/jwt_claims_set.js';
+export class EncryptJWT {
+    #cek;
+    #iv;
+    #keyManagementParameters;
+    #protectedHeader;
+    #replicateIssuerAsHeader;
+    #replicateSubjectAsHeader;
+    #replicateAudienceAsHeader;
+    #jwt;
+    constructor(payload = {}) {
+        this.#jwt = new JWTClaimsBuilder(payload);
+    }
+    setIssuer(issuer) {
+        this.#jwt.iss = issuer;
+        return this;
+    }
+    setSubject(subject) {
+        this.#jwt.sub = subject;
+        return this;
+    }
+    setAudience(audience) {
+        this.#jwt.aud = audience;
+        return this;
+    }
+    setJti(jwtId) {
+        this.#jwt.jti = jwtId;
+        return this;
+    }
+    setNotBefore(input) {
+        this.#jwt.nbf = input;
+        return this;
+    }
+    setExpirationTime(input) {
+        this.#jwt.exp = input;
+        return this;
+    }
+    setIssuedAt(input) {
+        this.#jwt.iat = input;
+        return this;
+    }
     setProtectedHeader(protectedHeader) {
-        if (this._protectedHeader) {
+        if (this.#protectedHeader) {
             throw new TypeError('setProtectedHeader can only be called once');
         }
-        this._protectedHeader = protectedHeader;
+        this.#protectedHeader = protectedHeader;
         return this;
     }
     setKeyManagementParameters(parameters) {
-        if (this._keyManagementParameters) {
+        if (this.#keyManagementParameters) {
             throw new TypeError('setKeyManagementParameters can only be called once');
         }
-        this._keyManagementParameters = parameters;
+        this.#keyManagementParameters = parameters;
         return this;
     }
     setContentEncryptionKey(cek) {
-        if (this._cek) {
+        if (this.#cek) {
             throw new TypeError('setContentEncryptionKey can only be called once');
         }
-        this._cek = cek;
+        this.#cek = cek;
         return this;
     }
     setInitializationVector(iv) {
-        if (this._iv) {
+        if (this.#iv) {
             throw new TypeError('setInitializationVector can only be called once');
         }
-        this._iv = iv;
+        this.#iv = iv;
         return this;
     }
     replicateIssuerAsHeader() {
-        this._replicateIssuerAsHeader = true;
+        this.#replicateIssuerAsHeader = true;
         return this;
     }
     replicateSubjectAsHeader() {
-        this._replicateSubjectAsHeader = true;
+        this.#replicateSubjectAsHeader = true;
         return this;
     }
     replicateAudienceAsHeader() {
-        this._replicateAudienceAsHeader = true;
+        this.#replicateAudienceAsHeader = true;
         return this;
     }
     async encrypt(key, options) {
-        const enc = new CompactEncrypt(encoder.encode(JSON.stringify(this._payload)));
-        if (this._replicateIssuerAsHeader) {
-            this._protectedHeader = { ...this._protectedHeader, iss: this._payload.iss };
-        }
-        if (this._replicateSubjectAsHeader) {
-            this._protectedHeader = { ...this._protectedHeader, sub: this._payload.sub };
-        }
-        if (this._replicateAudienceAsHeader) {
-            this._protectedHeader = { ...this._protectedHeader, aud: this._payload.aud };
+        const enc = new CompactEncrypt(this.#jwt.data());
+        if (this.#protectedHeader &&
+            (this.#replicateIssuerAsHeader ||
+                this.#replicateSubjectAsHeader ||
+                this.#replicateAudienceAsHeader)) {
+            this.#protectedHeader = {
+                ...this.#protectedHeader,
+                iss: this.#replicateIssuerAsHeader ? this.#jwt.iss : undefined,
+                sub: this.#replicateSubjectAsHeader ? this.#jwt.sub : undefined,
+                aud: this.#replicateAudienceAsHeader ? this.#jwt.aud : undefined,
+            };
         }
-        enc.setProtectedHeader(this._protectedHeader);
-        if (this._iv) {
-            enc.setInitializationVector(this._iv);
+        enc.setProtectedHeader(this.#protectedHeader);
+        if (this.#iv) {
+            enc.setInitializationVector(this.#iv);
         }
-        if (this._cek) {
-            enc.setContentEncryptionKey(this._cek);
+        if (this.#cek) {
+            enc.setContentEncryptionKey(this.#cek);
         }
-        if (this._keyManagementParameters) {
-            enc.setKeyManagementParameters(this._keyManagementParameters);
+        if (this.#keyManagementParameters) {
+            enc.setKeyManagementParameters(this.#keyManagementParameters);
         }
         return enc.encrypt(key, options);
     }

package/dist/webapi/jwt/sign.js

@@ -1,19 +1,50 @@
 import { CompactSign } from '../jws/compact/sign.js';
 import { JWTInvalid } from '../util/errors.js';
-import { encoder } from '../lib/buffer_utils.js';
-import { ProduceJWT } from './produce.js';
-export class SignJWT extends ProduceJWT {
-    _protectedHeader;
+import { JWTClaimsBuilder } from '../lib/jwt_claims_set.js';
+export class SignJWT {
+    #protectedHeader;
+    #jwt;
+    constructor(payload = {}) {
+        this.#jwt = new JWTClaimsBuilder(payload);
+    }
+    setIssuer(issuer) {
+        this.#jwt.iss = issuer;
+        return this;
+    }
+    setSubject(subject) {
+        this.#jwt.sub = subject;
+        return this;
+    }
+    setAudience(audience) {
+        this.#jwt.aud = audience;
+        return this;
+    }
+    setJti(jwtId) {
+        this.#jwt.jti = jwtId;
+        return this;
+    }
+    setNotBefore(input) {
+        this.#jwt.nbf = input;
+        return this;
+    }
+    setExpirationTime(input) {
+        this.#jwt.exp = input;
+        return this;
+    }
+    setIssuedAt(input) {
+        this.#jwt.iat = input;
+        return this;
+    }
     setProtectedHeader(protectedHeader) {
-        this._protectedHeader = protectedHeader;
+        this.#protectedHeader = protectedHeader;
         return this;
     }
     async sign(key, options) {
-        const sig = new CompactSign(encoder.encode(JSON.stringify(this._payload)));
-        sig.setProtectedHeader(this._protectedHeader);
-        if (Array.isArray(this._protectedHeader?.crit) &&
-            this._protectedHeader.crit.includes('b64') &&
-            this._protectedHeader.b64 === false) {
+        const sig = new CompactSign(this.#jwt.data());
+        sig.setProtectedHeader(this.#protectedHeader);
+        if (Array.isArray(this.#protectedHeader?.crit) &&
+            this.#protectedHeader.crit.includes('b64') &&
+            this.#protectedHeader.b64 === false) {
             throw new JWTInvalid('JWTs MUST NOT use unencoded payload');
         }
         return sig.sign(key, options);

package/dist/webapi/jwt/unsecured.js

@@ -1,14 +1,45 @@
 import * as b64u from '../util/base64url.js';
 import { decoder } from '../lib/buffer_utils.js';
 import { JWTInvalid } from '../util/errors.js';
-import jwtPayload from '../lib/jwt_claims_set.js';
-import { ProduceJWT } from './produce.js';
-export class UnsecuredJWT extends ProduceJWT {
+import { validateClaimsSet, JWTClaimsBuilder } from '../lib/jwt_claims_set.js';
+export class UnsecuredJWT {
+    #jwt;
+    constructor(payload = {}) {
+        this.#jwt = new JWTClaimsBuilder(payload);
+    }
     encode() {
         const header = b64u.encode(JSON.stringify({ alg: 'none' }));
-        const payload = b64u.encode(JSON.stringify(this._payload));
+        const payload = b64u.encode(this.#jwt.data());
         return `${header}.${payload}.`;
     }
+    setIssuer(issuer) {
+        this.#jwt.iss = issuer;
+        return this;
+    }
+    setSubject(subject) {
+        this.#jwt.sub = subject;
+        return this;
+    }
+    setAudience(audience) {
+        this.#jwt.aud = audience;
+        return this;
+    }
+    setJti(jwtId) {
+        this.#jwt.jti = jwtId;
+        return this;
+    }
+    setNotBefore(input) {
+        this.#jwt.nbf = input;
+        return this;
+    }
+    setExpirationTime(input) {
+        this.#jwt.exp = input;
+        return this;
+    }
+    setIssuedAt(input) {
+        this.#jwt.iat = input;
+        return this;
+    }
     static decode(jwt, options) {
         if (typeof jwt !== 'string') {
             throw new JWTInvalid('Unsecured JWT must be a string');
@@ -26,7 +57,7 @@ export class UnsecuredJWT extends ProduceJWT {
         catch {
             throw new JWTInvalid('Invalid Unsecured JWT');
         }
-        const payload = jwtPayload(header, b64u.decode(encodedPayload), options);
+        const payload = validateClaimsSet(header, b64u.decode(encodedPayload), options);
         return { payload, header };
     }
 }

package/dist/webapi/jwt/verify.js

@@ -1,12 +1,12 @@
 import { compactVerify } from '../jws/compact/verify.js';
-import jwtPayload from '../lib/jwt_claims_set.js';
+import { validateClaimsSet } from '../lib/jwt_claims_set.js';
 import { JWTInvalid } from '../util/errors.js';
 export async function jwtVerify(jwt, key, options) {
     const verified = await compactVerify(jwt, key, options);
     if (verified.protectedHeader.crit?.includes('b64') && verified.protectedHeader.b64 === false) {
         throw new JWTInvalid('JWTs MUST NOT use unencoded payload');
     }
-    const payload = jwtPayload(verified.protectedHeader, verified.payload, options);
+    const payload = validateClaimsSet(verified.protectedHeader, verified.payload, options);
     const result = { payload, protectedHeader: verified.protectedHeader };
     if (typeof key === 'function') {
         return { ...result, key: verified.key };

package/dist/webapi/lib/jwt_claims_set.js

@@ -3,6 +3,13 @@ import { decoder } from './buffer_utils.js';
 import epoch from './epoch.js';
 import secs from './secs.js';
 import isObject from './is_object.js';
+import { encoder } from './buffer_utils.js';
+function validateInput(label, input) {
+    if (!Number.isFinite(input)) {
+        throw new TypeError(`Invalid ${label} input`);
+    }
+    return input;
+}
 const normalizeTyp = (value) => value.toLowerCase().replace(/^application\//, '');
 const checkAudiencePresence = (audPayload, audOption) => {
     if (typeof audPayload === 'string') {
@@ -13,7 +20,7 @@ const checkAudiencePresence = (audPayload, audOption) => {
     }
     return false;
 };
-export default (protectedHeader, encodedPayload, options = {}) => {
+export function validateClaimsSet(protectedHeader, encodedPayload, options = {}) {
     let payload;
     try {
         payload = JSON.parse(decoder.decode(encodedPayload));
@@ -101,4 +108,73 @@ export default (protectedHeader, encodedPayload, options = {}) => {
         }
     }
     return payload;
-};
+}
+export class JWTClaimsBuilder {
+    #payload;
+    constructor(payload) {
+        if (!isObject(payload)) {
+            throw new TypeError('JWT Claims Set MUST be an object');
+        }
+        this.#payload = structuredClone(payload);
+    }
+    data() {
+        return encoder.encode(JSON.stringify(this.#payload));
+    }
+    get iss() {
+        return this.#payload.iss;
+    }
+    set iss(value) {
+        this.#payload.iss = value;
+    }
+    get sub() {
+        return this.#payload.sub;
+    }
+    set sub(value) {
+        this.#payload.sub = value;
+    }
+    get aud() {
+        return this.#payload.aud;
+    }
+    set aud(value) {
+        this.#payload.aud = value;
+    }
+    set jti(value) {
+        this.#payload.jti = value;
+    }
+    set nbf(value) {
+        if (typeof value === 'number') {
+            this.#payload.nbf = validateInput('setNotBefore', value);
+        }
+        else if (value instanceof Date) {
+            this.#payload.nbf = validateInput('setNotBefore', epoch(value));
+        }
+        else {
+            this.#payload.nbf = epoch(new Date()) + secs(value);
+        }
+    }
+    set exp(value) {
+        if (typeof value === 'number') {
+            this.#payload.exp = validateInput('setExpirationTime', value);
+        }
+        else if (value instanceof Date) {
+            this.#payload.exp = validateInput('setExpirationTime', epoch(value));
+        }
+        else {
+            this.#payload.exp = epoch(new Date()) + secs(value);
+        }
+    }
+    set iat(value) {
+        if (typeof value === 'undefined') {
+            this.#payload.iat = epoch(new Date());
+        }
+        else if (value instanceof Date) {
+            this.#payload.iat = validateInput('setIssuedAt', epoch(value));
+        }
+        else if (typeof value === 'string') {
+            this.#payload.iat = validateInput('setIssuedAt', epoch(new Date()) + secs(value));
+        }
+        else {
+            this.#payload.iat = validateInput('setIssuedAt', value);
+        }
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "jose",
-  "version": "6.0.8",
+  "version": "6.0.10",
   "description": "JWA, JWS, JWE, JWT, JWK, JWKS for Node.js, Browser, Cloudflare Workers, Deno, Bun, and other Web-interoperable runtimes",
   "keywords": [
     "browser",

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

@@ -1,104 +0,0 @@
-import type * as types from '../types.d.ts';
-/** Generic class for JWT producing. */
-export declare class ProduceJWT {
-    protected _payload: types.JWTPayload;
-    /** @param payload The JWT Claims Set object. Defaults to an empty object. */
-    constructor(payload?: types.JWTPayload);
-    /**
-     * Set the "iss" (Issuer) Claim.
-     *
-     * @param issuer "Issuer" Claim value to set on the JWT Claims Set.
-     */
-    setIssuer(issuer: string): this;
-    /**
-     * Set the "sub" (Subject) Claim.
-     *
-     * @param subject "sub" (Subject) Claim value to set on the JWT Claims Set.
-     */
-    setSubject(subject: string): this;
-    /**
-     * Set the "aud" (Audience) Claim.
-     *
-     * @param audience "aud" (Audience) Claim value to set on the JWT Claims Set.
-     */
-    setAudience(audience: string | string[]): this;
-    /**
-     * Set the "jti" (JWT ID) Claim.
-     *
-     * @param jwtId "jti" (JWT ID) Claim value to set on the JWT Claims Set.
-     */
-    setJti(jwtId: string): this;
-    /**
-     * Set the "nbf" (Not Before) Claim.
-     *
-     * - If a `number` is passed as an argument it is used as the claim directly.
-     * - If a `Date` instance is passed as an argument it is converted to unix timestamp and used as the
-     *   claim.
-     * - If a `string` is passed as an argument it is resolved to a time span, and then added to the
-     *   current unix timestamp and used as the claim.
-     *
-     * Format used for time span should be a number followed by a unit, such as "5 minutes" or "1
-     * day".
-     *
-     * Valid units are: "sec", "secs", "second", "seconds", "s", "minute", "minutes", "min", "mins",
-     * "m", "hour", "hours", "hr", "hrs", "h", "day", "days", "d", "week", "weeks", "w", "year",
-     * "years", "yr", "yrs", and "y". It is not possible to specify months. 365.25 days is used as an
-     * alias for a year.
-     *
-     * If the string is suffixed with "ago", or prefixed with a "-", the resulting time span gets
-     * subtracted from the current unix timestamp. A "from now" suffix can also be used for
-     * readability when adding to the current unix timestamp.
-     *
-     * @param input "nbf" (Not Before) Claim value to set on the JWT Claims Set.
-     */
-    setNotBefore(input: number | string | Date): this;
-    /**
-     * Set the "exp" (Expiration Time) Claim.
-     *
-     * - If a `number` is passed as an argument it is used as the claim directly.
-     * - If a `Date` instance is passed as an argument it is converted to unix timestamp and used as the
-     *   claim.
-     * - If a `string` is passed as an argument it is resolved to a time span, and then added to the
-     *   current unix timestamp and used as the claim.
-     *
-     * Format used for time span should be a number followed by a unit, such as "5 minutes" or "1
-     * day".
-     *
-     * Valid units are: "sec", "secs", "second", "seconds", "s", "minute", "minutes", "min", "mins",
-     * "m", "hour", "hours", "hr", "hrs", "h", "day", "days", "d", "week", "weeks", "w", "year",
-     * "years", "yr", "yrs", and "y". It is not possible to specify months. 365.25 days is used as an
-     * alias for a year.
-     *
-     * If the string is suffixed with "ago", or prefixed with a "-", the resulting time span gets
-     * subtracted from the current unix timestamp. A "from now" suffix can also be used for
-     * readability when adding to the current unix timestamp.
-     *
-     * @param input "exp" (Expiration Time) Claim value to set on the JWT Claims Set.
-     */
-    setExpirationTime(input: number | string | Date): this;
-    /**
-     * Set the "iat" (Issued At) Claim.
-     *
-     * - If no argument is used the current unix timestamp is used as the claim.
-     * - If a `number` is passed as an argument it is used as the claim directly.
-     * - If a `Date` instance is passed as an argument it is converted to unix timestamp and used as the
-     *   claim.
-     * - If a `string` is passed as an argument it is resolved to a time span, and then added to the
-     *   current unix timestamp and used as the claim.
-     *
-     * Format used for time span should be a number followed by a unit, such as "5 minutes" or "1
-     * day".
-     *
-     * Valid units are: "sec", "secs", "second", "seconds", "s", "minute", "minutes", "min", "mins",
-     * "m", "hour", "hours", "hr", "hrs", "h", "day", "days", "d", "week", "weeks", "w", "year",
-     * "years", "yr", "yrs", and "y". It is not possible to specify months. 365.25 days is used as an
-     * alias for a year.
-     *
-     * If the string is suffixed with "ago", or prefixed with a "-", the resulting time span gets
-     * subtracted from the current unix timestamp. A "from now" suffix can also be used for
-     * readability when adding to the current unix timestamp.
-     *
-     * @param input "iat" (Expiration Time) Claim value to set on the JWT Claims Set.
-     */
-    setIssuedAt(input?: number | string | Date): this;
-}