@naman_deep_singh/security 1.3.0 → 1.3.2

package/dist/cjs/core/jwt/validateToken.js

@@ -3,9 +3,9 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.validateTokenPayload = validateTokenPayload;
 exports.isTokenExpired = isTokenExpired;
 function validateTokenPayload(payload, rules = {
-    requiredFields: ["exp", "iat"]
+    requiredFields: ['exp', 'iat'],
 }) {
-    const { requiredFields = [], forbiddenFields = [], validateTypes = {} } = rules;
+    const { requiredFields = [], forbiddenFields = [], validateTypes = {}, } = rules;
     // 1. Required fields
     for (const field of requiredFields) {
         if (!(field in payload)) {
@@ -24,7 +24,7 @@ function validateTokenPayload(payload, rules = {
         if (key in payload && typeof payload[key] !== expectedType) {
             return {
                 valid: false,
-                error: `Invalid type for ${key}. Expected ${expectedType}.`
+                error: `Invalid type for ${key}. Expected ${expectedType}.`,
             };
         }
     }

package/dist/cjs/core/jwt/verify.d.ts

@@ -1,5 +1,6 @@
-import jwt, { Secret, JwtPayload } from "jsonwebtoken";
-import { VerificationResult } from "./types";
+import type jwt from 'jsonwebtoken';
+import { type JwtPayload, type Secret } from 'jsonwebtoken';
+import type { VerificationResult } from './types';
 /**
  * Verify token (throws if invalid or expired)
  */

package/dist/cjs/core/password/hash.js

@@ -6,9 +6,9 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.hashPasswordSync = exports.hashPassword = void 0;
 exports.hashPasswordWithPepper = hashPasswordWithPepper;
 exports.hashPasswordWithPepperSync = hashPasswordWithPepperSync;
+const errors_utils_1 = require("@naman_deep_singh/errors-utils");
 const bcryptjs_1 = __importDefault(require("bcryptjs"));
 const utils_1 = require("./utils");
-const errors_utils_1 = require("@naman_deep_singh/errors-utils");
 /**
  * Hash a password asynchronously using bcrypt.
  */

package/dist/cjs/core/password/index.d.ts

@@ -1,3 +1,3 @@
-export * from "./hash";
-export * from "./strength";
-export * from "./verify";
+export * from './hash';
+export * from './strength';
+export * from './verify';

package/dist/cjs/core/password/passwordManager.d.ts

@@ -1,4 +1,4 @@
-import { IPasswordManager, PasswordConfig, PasswordValidationResult, HashedPassword, PasswordStrength } from "../../interfaces/password.interface";
+import type { HashedPassword, IPasswordManager, PasswordConfig, PasswordStrength, PasswordValidationResult } from '../../interfaces/password.interface';
 export declare class PasswordManager implements IPasswordManager {
     private defaultConfig;
     constructor(config?: PasswordConfig);

package/dist/cjs/core/password/passwordManager.js

@@ -4,10 +4,10 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PasswordManager = void 0;
-const bcryptjs_1 = __importDefault(require("bcryptjs"));
 const crypto_1 = __importDefault(require("crypto"));
-const utils_1 = require("./utils");
+const bcryptjs_1 = __importDefault(require("bcryptjs"));
 const errors_utils_1 = require("@naman_deep_singh/errors-utils");
+const utils_1 = require("./utils");
 class PasswordManager {
     constructor(config = {}) {
         this.defaultConfig = {
@@ -18,7 +18,7 @@ class PasswordManager {
             requireLowercase: true,
             requireNumbers: true,
             requireSpecialChars: false,
-            ...config
+            ...config,
         };
     }
     /**
@@ -37,14 +37,15 @@ class PasswordManager {
             const hash = await bcryptjs_1.default.hash(password, passwordSalt);
             return {
                 hash,
-                salt: passwordSalt
+                salt: passwordSalt,
             };
         }
         catch (error) {
-            if (error instanceof errors_utils_1.BadRequestError || error instanceof errors_utils_1.ValidationError) {
+            if (error instanceof errors_utils_1.BadRequestError ||
+                error instanceof errors_utils_1.ValidationError) {
                 throw error;
             }
-            throw new errors_utils_1.BadRequestError("Failed to hash password");
+            throw new errors_utils_1.BadRequestError('Failed to hash password');
         }
     }
     /**
@@ -76,14 +77,14 @@ class PasswordManager {
         if (length < config.minLength || length > config.maxLength) {
             throw new errors_utils_1.ValidationError(`Password length must be between ${config.minLength} and ${config.maxLength}`);
         }
-        let charset = "abcdefghijklmnopqrstuvwxyz";
+        let charset = 'abcdefghijklmnopqrstuvwxyz';
         if (config.requireUppercase)
-            charset += "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
+            charset += 'ABCDEFGHIJKLMNOPQRSTUVWXYZ';
         if (config.requireNumbers)
-            charset += "0123456789";
+            charset += '0123456789';
         if (config.requireSpecialChars)
-            charset += "!@#$%^&*()_+-=[]{}|;:,.<>?";
-        let password = "";
+            charset += '!@#$%^&*()_+-=[]{}|;:,.<>?';
+        let password = '';
         const randomBytes = crypto_1.default.randomBytes(length);
         for (let i = 0; i < length; i++) {
             password += charset[randomBytes[i] % charset.length];
@@ -110,8 +111,8 @@ class PasswordManager {
         const finalConfig = { ...this.defaultConfig, ...config };
         const errors = [];
         // Basic validation
-        if (!password || typeof password !== "string") {
-            errors.push("Password must be a non-empty string");
+        if (!password || typeof password !== 'string') {
+            errors.push('Password must be a non-empty string');
         }
         // Length validation
         if (password.length < finalConfig.minLength) {
@@ -122,20 +123,20 @@ class PasswordManager {
         }
         // Complexity requirements
         if (finalConfig.requireUppercase && !/[A-Z]/.test(password)) {
-            errors.push("Password must contain at least one uppercase letter");
+            errors.push('Password must contain at least one uppercase letter');
         }
         if (finalConfig.requireLowercase && !/[a-z]/.test(password)) {
-            errors.push("Password must contain at least one lowercase letter");
+            errors.push('Password must contain at least one lowercase letter');
         }
         if (finalConfig.requireNumbers && !/[0-9]/.test(password)) {
-            errors.push("Password must contain at least one number");
+            errors.push('Password must contain at least one number');
         }
         if (finalConfig.requireSpecialChars && !/[^A-Za-z0-9]/.test(password)) {
-            errors.push("Password must contain at least one special character");
+            errors.push('Password must contain at least one special character');
         }
         // Custom rules
         if (finalConfig.customRules) {
-            finalConfig.customRules.forEach(rule => {
+            finalConfig.customRules.forEach((rule) => {
                 if (!rule.test(password)) {
                     errors.push(rule.message);
                 }
@@ -146,7 +147,7 @@ class PasswordManager {
         return {
             isValid,
             errors,
-            strength
+            strength,
         };
     }
     /**
@@ -176,25 +177,25 @@ class PasswordManager {
         // Common patterns deduction
         if (/^[A-Za-z]+$/.test(password)) {
             score--;
-            feedback.push("Consider adding numbers and symbols");
+            feedback.push('Consider adding numbers and symbols');
         }
         if (/^[0-9]+$/.test(password)) {
             score -= 2;
-            feedback.push("Avoid using only numbers");
+            feedback.push('Avoid using only numbers');
         }
         if (/([a-zA-Z0-9])\1{2,}/.test(password)) {
             score--;
-            feedback.push("Avoid repeated characters");
+            feedback.push('Avoid repeated characters');
         }
         if (/(?:012|123|234|345|456|567|678|789)/.test(password)) {
             score--;
-            feedback.push("Avoid sequential patterns");
+            feedback.push('Avoid sequential patterns');
         }
         // Common passwords check
         const commonPasswords = ['password', '123456', 'qwerty', 'admin', 'letmein'];
-        if (commonPasswords.some(common => password.toLowerCase().includes(common))) {
+        if (commonPasswords.some((common) => password.toLowerCase().includes(common))) {
             score = 0;
-            feedback.push("Avoid common passwords");
+            feedback.push('Avoid common passwords');
         }
         // Clamp score and determine label
         score = Math.max(0, Math.min(4, score));
@@ -202,23 +203,23 @@ class PasswordManager {
         switch (score) {
             case 0:
                 label = 'very-weak';
-                suggestions.push("Use a longer password with mixed characters");
+                suggestions.push('Use a longer password with mixed characters');
                 break;
             case 1:
                 label = 'weak';
-                suggestions.push("Add more character variety");
+                suggestions.push('Add more character variety');
                 break;
             case 2:
                 label = 'fair';
-                suggestions.push("Consider adding more length or character types");
+                suggestions.push('Consider adding more length or character types');
                 break;
             case 3:
                 label = 'good';
-                suggestions.push("Your password is reasonably secure");
+                suggestions.push('Your password is reasonably secure');
                 break;
             case 4:
                 label = 'strong';
-                suggestions.push("Your password is very secure");
+                suggestions.push('Your password is very secure');
                 break;
             default:
                 label = 'very-weak';
@@ -227,7 +228,7 @@ class PasswordManager {
             score,
             label,
             feedback,
-            suggestions
+            suggestions,
         };
     }
     /**

package/dist/cjs/core/password/strength.d.ts

@@ -1,2 +1,2 @@
-import { PasswordStrengthOptions } from "./types";
+import type { PasswordStrengthOptions } from './types';
 export declare const isPasswordStrong: (password: string, options?: PasswordStrengthOptions) => boolean;

package/dist/cjs/core/password/strength.js

@@ -9,13 +9,13 @@ const isPasswordStrong = (password, options = {}) => {
     if (password.length < minLength)
         throw new errors_utils_1.ValidationError(`Password must be at least ${minLength} characters`);
     if (requireUppercase && !/[A-Z]/.test(password))
-        throw new errors_utils_1.ValidationError("Password must include uppercase letters");
+        throw new errors_utils_1.ValidationError('Password must include uppercase letters');
     if (requireLowercase && !/[a-z]/.test(password))
-        throw new errors_utils_1.ValidationError("Password must include lowercase letters");
+        throw new errors_utils_1.ValidationError('Password must include lowercase letters');
     if (requireNumbers && !/[0-9]/.test(password))
-        throw new errors_utils_1.ValidationError("Password must include numbers");
+        throw new errors_utils_1.ValidationError('Password must include numbers');
     if (requireSymbols && !/[^A-Za-z0-9]/.test(password))
-        throw new errors_utils_1.ValidationError("Password must include symbols");
+        throw new errors_utils_1.ValidationError('Password must include symbols');
     return true;
 };
 exports.isPasswordStrong = isPasswordStrong;

package/dist/cjs/core/password/utils.js

@@ -10,7 +10,7 @@ exports.normalizePassword = normalizePassword;
 const crypto_1 = __importDefault(require("crypto"));
 const errors_utils_1 = require("@naman_deep_singh/errors-utils");
 function ensureValidPassword(password) {
-    if (!password || typeof password !== "string") {
+    if (!password || typeof password !== 'string') {
         throw new errors_utils_1.BadRequestError('Invalid password provided');
     }
 }
@@ -34,5 +34,5 @@ function estimatePasswordEntropy(password) {
     return password.length * Math.log2(pool);
 }
 function normalizePassword(password) {
-    return password.normalize("NFKC");
+    return password.normalize('NFKC');
 }

package/dist/cjs/core/password/verify.js

@@ -6,8 +6,8 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.verifyPasswordSync = exports.verifyPassword = void 0;
 exports.verifyPasswordWithPepper = verifyPasswordWithPepper;
 exports.verifyPasswordWithPepperSync = verifyPasswordWithPepperSync;
-const bcryptjs_1 = __importDefault(require("bcryptjs"));
 const errors_utils_1 = require("@naman_deep_singh/errors-utils");
+const bcryptjs_1 = __importDefault(require("bcryptjs"));
 /**
  * Compare a password with a stored hash asynchronously.
  */

package/dist/cjs/index.d.ts

@@ -1,9 +1,9 @@
-export * from "./core/password";
-export * from "./core/jwt";
-export * from "./core/crypto";
-export { BadRequestError, UnauthorizedError, ValidationError, InternalServerError } from "@naman_deep_singh/errors-utils";
-import * as JWTUtils from "./core/jwt";
-import * as CryptoUtils from "./core/crypto";
+export * from './core/password';
+export * from './core/jwt';
+export * from './core/crypto';
+export { BadRequestError, UnauthorizedError, ValidationError, InternalServerError, } from '@naman_deep_singh/errors-utils';
+import * as CryptoUtils from './core/crypto';
+import * as JWTUtils from './core/jwt';
 declare const _default: {
     decrypt: (data: string, secret: string) => string;
     encrypt: (text: string, secret: string) => string;

package/dist/cjs/index.js

@@ -46,9 +46,9 @@ Object.defineProperty(exports, "BadRequestError", { enumerable: true, get: funct
 Object.defineProperty(exports, "UnauthorizedError", { enumerable: true, get: function () { return errors_utils_1.UnauthorizedError; } });
 Object.defineProperty(exports, "ValidationError", { enumerable: true, get: function () { return errors_utils_1.ValidationError; } });
 Object.defineProperty(exports, "InternalServerError", { enumerable: true, get: function () { return errors_utils_1.InternalServerError; } });
-const PasswordUtils = __importStar(require("./core/password"));
-const JWTUtils = __importStar(require("./core/jwt"));
 const CryptoUtils = __importStar(require("./core/crypto"));
+const JWTUtils = __importStar(require("./core/jwt"));
+const PasswordUtils = __importStar(require("./core/password"));
 exports.default = {
     ...PasswordUtils,
     ...JWTUtils,

package/dist/cjs/interfaces/jwt.interface.d.ts

@@ -1,4 +1,4 @@
-import { JwtPayload, Secret } from "jsonwebtoken";
+import type { JwtPayload, Secret } from 'jsonwebtoken';
 export interface AccessToken extends String {
     readonly __type: 'AccessToken';
 }

package/dist/esm/core/crypto/cryptoManager.js

@@ -1,11 +1,11 @@
-import { encrypt as functionalEncrypt, decrypt as functionalDecrypt, hmacSign as functionalHmacSign, hmacVerify as functionalHmacVerify, randomToken as functionalRandomToken } from './index';
+import { decrypt as functionalDecrypt, encrypt as functionalEncrypt, hmacSign as functionalHmacSign, hmacVerify as functionalHmacVerify, randomToken as functionalRandomToken, } from './index';
 /**
  * Default configuration
  */
 const DEFAULT_CONFIG = {
     defaultAlgorithm: 'aes-256-gcm',
     defaultEncoding: 'utf8',
-    hmacAlgorithm: 'sha256'
+    hmacAlgorithm: 'sha256',
 };
 /**
  * CryptoManager - Class-based wrapper for all cryptographic operations
@@ -103,8 +103,14 @@ export class CryptoManager {
             const crypto = require('crypto');
             const keyPair = crypto.generateKeyPairSync('rsa', {
                 modulusLength: options?.modulusLength || 2048,
-                publicKeyEncoding: options?.publicKeyEncoding || { type: 'spki', format: 'pem' },
-                privateKeyEncoding: options?.privateKeyEncoding || { type: 'pkcs8', format: 'pem' }
+                publicKeyEncoding: options?.publicKeyEncoding || {
+                    type: 'spki',
+                    format: 'pem',
+                },
+                privateKeyEncoding: options?.privateKeyEncoding || {
+                    type: 'pkcs8',
+                    format: 'pem',
+                },
             });
             resolve(keyPair);
         });

package/dist/esm/core/crypto/decrypt.js

@@ -1,14 +1,14 @@
-import crypto from "crypto";
-const ALGO = "AES-256-GCM";
+import crypto from 'crypto';
+const ALGO = 'AES-256-GCM';
 export const decrypt = (data, secret) => {
-    const [ivHex, encryptedHex] = data.split(":");
-    const iv = Buffer.from(ivHex, "hex");
-    const encrypted = Buffer.from(encryptedHex, "hex");
-    const key = crypto.createHash("sha256").update(secret).digest();
+    const [ivHex, encryptedHex] = data.split(':');
+    const iv = Buffer.from(ivHex, 'hex');
+    const encrypted = Buffer.from(encryptedHex, 'hex');
+    const key = crypto.createHash('sha256').update(secret).digest();
     const decipher = crypto.createDecipheriv(ALGO, key, iv);
     const decrypted = Buffer.concat([
         decipher.update(encrypted),
         decipher.final(),
     ]);
-    return decrypted.toString("utf8");
+    return decrypted.toString('utf8');
 };

package/dist/esm/core/crypto/encrypt.js

@@ -1,9 +1,9 @@
-import crypto from "crypto";
-const ALGO = "AES-256-GCM";
+import crypto from 'crypto';
+const ALGO = 'AES-256-GCM';
 export const encrypt = (text, secret) => {
-    const key = crypto.createHash("sha256").update(secret).digest();
+    const key = crypto.createHash('sha256').update(secret).digest();
     const iv = crypto.randomBytes(16);
     const cipher = crypto.createCipheriv(ALGO, key, iv);
-    const encrypted = Buffer.concat([cipher.update(text, "utf8"), cipher.final()]);
-    return `${iv.toString("hex")}:${encrypted.toString("hex")}`;
+    const encrypted = Buffer.concat([cipher.update(text, 'utf8'), cipher.final()]);
+    return `${iv.toString('hex')}:${encrypted.toString('hex')}`;
 };

package/dist/esm/core/crypto/hmac.js

@@ -1,9 +1,9 @@
-import crypto from "crypto";
+import crypto from 'crypto';
 /**
  * Sign message using HMAC SHA-256
  */
 export const hmacSign = (message, secret) => {
-    return crypto.createHmac("sha256", secret).update(message).digest("hex");
+    return crypto.createHmac('sha256', secret).update(message).digest('hex');
 };
 /**
  * Verify HMAC signature

package/dist/esm/core/crypto/index.d.ts

@@ -1,5 +1,5 @@
-export { decrypt } from "./decrypt";
-export { encrypt } from "./encrypt";
-export { hmacSign, hmacVerify } from "./hmac";
-export { randomToken, generateStrongPassword } from "./random";
-export * from "./cryptoManager";
+export { decrypt } from './decrypt';
+export { encrypt } from './encrypt';
+export { hmacSign, hmacVerify } from './hmac';
+export { randomToken, generateStrongPassword } from './random';
+export * from './cryptoManager';

package/dist/esm/core/crypto/index.js

@@ -1,5 +1,5 @@
-export { decrypt } from "./decrypt";
-export { encrypt } from "./encrypt";
-export { hmacSign, hmacVerify } from "./hmac";
-export { randomToken, generateStrongPassword } from "./random";
-export * from "./cryptoManager";
+export { decrypt } from './decrypt';
+export { encrypt } from './encrypt';
+export { hmacSign, hmacVerify } from './hmac';
+export { randomToken, generateStrongPassword } from './random';
+export * from './cryptoManager';

package/dist/esm/core/crypto/random.js

@@ -1,13 +1,13 @@
-import crypto from "crypto";
+import crypto from 'crypto';
 /**
  * Generate cryptographically secure random string
  */
 export const randomToken = (length = 32) => {
-    return crypto.randomBytes(length).toString("hex");
+    return crypto.randomBytes(length).toString('hex');
 };
 /**
  * Generate a strong random password
  */
 export const generateStrongPassword = (length = 16) => {
-    return crypto.randomBytes(length).toString("hex").slice(0, length);
+    return crypto.randomBytes(length).toString('hex').slice(0, length);
 };

package/dist/esm/core/jwt/decode.d.ts

@@ -1,4 +1,4 @@
-import { JwtPayload } from "jsonwebtoken";
+import { type JwtPayload } from 'jsonwebtoken';
 /**
  * Flexible decode
  * Returns: null | string | JwtPayload

package/dist/esm/core/jwt/decode.js

@@ -1,5 +1,5 @@
 // src/jwt/decodeToken.ts
-import { decode } from "jsonwebtoken";
+import { decode } from 'jsonwebtoken';
 /**
  * Flexible decode
  * Returns: null | string | JwtPayload
@@ -14,8 +14,8 @@ export function decodeToken(token) {
  */
 export function decodeTokenStrict(token) {
     const decoded = decode(token);
-    if (!decoded || typeof decoded === "string") {
-        throw new Error("Invalid JWT payload structure");
+    if (!decoded || typeof decoded === 'string') {
+        throw new Error('Invalid JWT payload structure');
     }
     return decoded;
 }

package/dist/esm/core/jwt/extractToken.js

@@ -5,16 +5,16 @@ export function extractToken(sources) {
     const { header, cookies, query, body, wsMessage } = sources;
     // 1. Authorization: Bearer <token>
     if (header) {
-        const parts = header.split(" ");
-        if (parts.length === 2 && parts[0] === "Bearer")
+        const parts = header.split(' ');
+        if (parts.length === 2 && parts[0] === 'Bearer')
             return parts[1];
     }
     // 2. Cookies: token / accessToken
     if (cookies) {
-        if (cookies["token"])
-            return cookies["token"];
-        if (cookies["accessToken"])
-            return cookies["accessToken"];
+        if (cookies['token'])
+            return cookies['token'];
+        if (cookies['accessToken'])
+            return cookies['accessToken'];
     }
     // 3. Query params: ?token=xxx
     if (query?.token)
@@ -27,7 +27,7 @@ export function extractToken(sources) {
         try {
             let msg = wsMessage;
             // If it's a JSON string → parse safely
-            if (typeof wsMessage === "string") {
+            if (typeof wsMessage === 'string') {
                 msg = JSON.parse(wsMessage);
             }
             // Ensure msg is an object before property access

package/dist/esm/core/jwt/generateTokens.d.ts

@@ -1,4 +1,4 @@
-import { Secret } from "jsonwebtoken";
-import { RefreshToken, TokenPair } from "./types";
+import { type Secret } from 'jsonwebtoken';
+import type { RefreshToken, TokenPair } from './types';
 export declare const generateTokens: (payload: Record<string, unknown>, accessSecret: Secret, refreshSecret: Secret, accessExpiry?: string | number, refreshExpiry?: string | number) => TokenPair;
 export declare function rotateRefreshToken(oldToken: string, secret: Secret): RefreshToken;

package/dist/esm/core/jwt/generateTokens.js

@@ -1,12 +1,16 @@
-import { signToken } from "./signToken";
-import { verifyToken } from "./verify";
+import { signToken } from './signToken';
+import { verifyToken } from './verify';
 // Helper function to create branded tokens
 const createBrandedToken = (token, _brand) => {
     return token;
 };
-export const generateTokens = (payload, accessSecret, refreshSecret, accessExpiry = "15m", refreshExpiry = "7d") => {
-    const accessToken = signToken(payload, accessSecret, accessExpiry, { algorithm: "HS256" });
-    const refreshToken = signToken(payload, refreshSecret, refreshExpiry, { algorithm: "HS256" });
+export const generateTokens = (payload, accessSecret, refreshSecret, accessExpiry = '15m', refreshExpiry = '7d') => {
+    const accessToken = signToken(payload, accessSecret, accessExpiry, {
+        algorithm: 'HS256',
+    });
+    const refreshToken = signToken(payload, refreshSecret, refreshExpiry, {
+        algorithm: 'HS256',
+    });
     return {
         accessToken: accessToken,
         refreshToken: refreshToken,
@@ -14,12 +18,12 @@ export const generateTokens = (payload, accessSecret, refreshSecret, accessExpir
 };
 export function rotateRefreshToken(oldToken, secret) {
     const decoded = verifyToken(oldToken, secret);
-    if (typeof decoded === "string") {
-        throw new Error("Invalid token payload — expected JWT payload object");
+    if (typeof decoded === 'string') {
+        throw new Error('Invalid token payload — expected JWT payload object');
     }
     const payload = { ...decoded };
     delete payload.iat;
     delete payload.exp;
-    const newToken = signToken(payload, secret, "7d");
+    const newToken = signToken(payload, secret, '7d');
     return newToken;
 }

package/dist/esm/core/jwt/index.d.ts

@@ -1,8 +1,8 @@
-export * from "./decode";
-export * from "./extractToken";
-export * from "./generateTokens";
-export * from "./parseDuration";
-export * from "./signToken";
-export * from "./types";
-export * from "./validateToken";
-export * from "./verify";
+export * from './decode';
+export * from './extractToken';
+export * from './generateTokens';
+export * from './parseDuration';
+export * from './signToken';
+export * from './types';
+export * from './validateToken';
+export * from './verify';

package/dist/esm/core/jwt/index.js

@@ -1,8 +1,8 @@
-export * from "./decode";
-export * from "./extractToken";
-export * from "./generateTokens";
-export * from "./parseDuration";
-export * from "./signToken";
-export * from "./types";
-export * from "./validateToken";
-export * from "./verify";
+export * from './decode';
+export * from './extractToken';
+export * from './generateTokens';
+export * from './parseDuration';
+export * from './signToken';
+export * from './types';
+export * from './validateToken';
+export * from './verify';

package/dist/esm/core/jwt/jwtManager.d.ts

@@ -1,11 +1,12 @@
-import { JwtPayload, Secret } from "jsonwebtoken";
-import { ITokenManager, TokenPair, AccessToken, RefreshToken, JWTConfig, TokenValidationOptions } from "../../interfaces/jwt.interface";
+import { type JwtPayload, type Secret } from 'jsonwebtoken';
+import type { AccessToken, ITokenManager, JWTConfig, RefreshToken, TokenPair, TokenValidationOptions } from '../../interfaces/jwt.interface';
 export declare class JWTManager implements ITokenManager {
     private accessSecret;
     private refreshSecret;
     private accessExpiry;
     private refreshExpiry;
     private cache?;
+    private cacheTTL;
     constructor(config: JWTConfig);
     /**
      * Generate both access and refresh tokens