ts-packages 1.0.0 → 3.0.0

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

@@ -0,0 +1,212 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PasswordManager = void 0;
+const crypto_1 = __importDefault(require("crypto"));
+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 = {
+            saltRounds: 10,
+            minLength: 8,
+            maxLength: 128,
+            requireUppercase: true,
+            requireLowercase: true,
+            requireNumbers: true,
+            requireSpecialChars: false,
+            ...config,
+        };
+    }
+    /**
+     * Hash a password asynchronously using bcrypt
+     */
+    async hash(password, salt) {
+        try {
+            (0, utils_1.ensureValidPassword)(password);
+            this.validate(password);
+            const saltRounds = this.defaultConfig.saltRounds;
+            let finalSalt = salt;
+            if (!finalSalt) {
+                finalSalt = await bcryptjs_1.default.genSalt(saltRounds);
+            }
+            const hash = await bcryptjs_1.default.hash(password, finalSalt);
+            return { hash, salt: finalSalt };
+        }
+        catch (error) {
+            if (error instanceof errors_utils_1.BadRequestError ||
+                error instanceof errors_utils_1.ValidationError) {
+                throw error;
+            }
+            throw new errors_utils_1.BadRequestError({ reason: 'Failed to hash password' }, error instanceof Error ? error : undefined);
+        }
+    }
+    /**
+     * Verify password against hash and salt
+     */
+    async verify(password, hash, salt) {
+        try {
+            if (!password || !hash || !salt)
+                return false;
+            // bcrypt compare works directly with hash
+            return await bcryptjs_1.default.compare(password, hash);
+        }
+        catch {
+            return false;
+        }
+    }
+    /**
+     * Generate a random password
+     */
+    generate(length = 16, options = {}) {
+        const config = { ...this.defaultConfig, ...options };
+        if (length < config.minLength || length > config.maxLength) {
+            throw new errors_utils_1.ValidationError({
+                reason: `Password length must be between ${config.minLength} and ${config.maxLength}`,
+            });
+        }
+        let charset = 'abcdefghijklmnopqrstuvwxyz';
+        if (config.requireUppercase)
+            charset += 'ABCDEFGHIJKLMNOPQRSTUVWXYZ';
+        if (config.requireNumbers)
+            charset += '0123456789';
+        if (config.requireSpecialChars)
+            charset += '!@#$%^&*()_+-=[]{}|;:,.<>?';
+        const randomBytes = crypto_1.default.randomBytes(length);
+        let password = '';
+        for (let i = 0; i < length; i++) {
+            password += charset[randomBytes[i] % charset.length];
+        }
+        // Ensure requirements
+        if (config.requireUppercase && !/[A-Z]/.test(password))
+            password = password.replace(/[a-z]/, 'A');
+        if (config.requireLowercase && !/[a-z]/.test(password))
+            password = password.replace(/[A-Z]/, 'a');
+        if (config.requireNumbers && !/[0-9]/.test(password))
+            password = password.replace(/[A-Za-z]/, '0');
+        if (config.requireSpecialChars && !/[^A-Za-z0-9]/.test(password))
+            password = password.replace(/[A-Za-z0-9]/, '!');
+        return password;
+    }
+    /**
+     * Validate password against configuration
+     */
+    validate(password, config = {}) {
+        const finalConfig = { ...this.defaultConfig, ...config };
+        const errors = [];
+        if (!password || typeof password !== 'string')
+            errors.push('Password must be a non-empty string');
+        if (password.length < finalConfig.minLength)
+            errors.push(`Password must be at least ${finalConfig.minLength} characters`);
+        if (password.length > finalConfig.maxLength)
+            errors.push(`Password must not exceed ${finalConfig.maxLength} characters`);
+        if (finalConfig.requireUppercase && !/[A-Z]/.test(password))
+            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');
+        if (finalConfig.requireNumbers && !/[0-9]/.test(password))
+            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');
+        if (finalConfig.customRules) {
+            finalConfig.customRules.forEach((rule) => {
+                if (!rule.test(password))
+                    errors.push(rule.message);
+            });
+        }
+        return {
+            isValid: errors.length === 0,
+            errors,
+            strength: this.checkStrength(password),
+        };
+    }
+    /**
+     * Check password strength
+     */
+    checkStrength(password) {
+        const entropy = (0, utils_1.estimatePasswordEntropy)(password);
+        let score = 0;
+        const feedback = [];
+        const suggestions = [];
+        if (entropy < 28) {
+            feedback.push('Password is easy to guess');
+            suggestions.push('Use more unique characters and length');
+        }
+        else if (entropy < 36)
+            score++;
+        else if (entropy < 60)
+            score += 2;
+        else
+            score += 3;
+        if (password.length >= 12)
+            score++;
+        if (password.length >= 16)
+            score++;
+        if (/[a-z]/.test(password))
+            score++;
+        if (/[A-Z]/.test(password))
+            score++;
+        if (/[0-9]/.test(password))
+            score++;
+        if (/[^A-Za-z0-9]/.test(password))
+            score++;
+        if (/^[A-Za-z]+$/.test(password)) {
+            score--;
+            feedback.push('Consider adding numbers or symbols');
+        }
+        if (/^[0-9]+$/.test(password)) {
+            score -= 2;
+            feedback.push('Avoid using only numbers');
+        }
+        if (/([a-zA-Z0-9])\1{2,}/.test(password)) {
+            score--;
+            feedback.push('Avoid repeated characters');
+        }
+        if (/(?:012|123|234|345|456|567|678|789)/.test(password)) {
+            score--;
+            feedback.push('Avoid sequential patterns');
+        }
+        const commonPasswords = ['password', '123456', 'qwerty', 'admin', 'letmein'];
+        if (commonPasswords.some((common) => password.toLowerCase().includes(common))) {
+            score = 0;
+            feedback.push('Avoid common passwords');
+        }
+        score = Math.max(0, Math.min(4, score));
+        let label;
+        switch (score) {
+            case 0:
+                label = 'very-weak';
+                suggestions.push('Use a longer password with mixed characters');
+                break;
+            case 1:
+                label = 'weak';
+                suggestions.push('Add more character variety');
+                break;
+            case 2:
+                label = 'fair';
+                suggestions.push('Consider increasing length or randomness');
+                break;
+            case 3:
+                label = 'good';
+                suggestions.push('Your password is reasonably secure');
+                break;
+            case 4:
+                label = 'strong';
+                suggestions.push('Your password is very secure');
+                break;
+            default:
+                label = 'very-weak';
+        }
+        return { score, label, feedback, suggestions };
+    }
+    /**
+     * Check if password hash needs upgrade (saltRounds change)
+     */
+    needsUpgrade(_hash, _currentConfig) {
+        return false;
+    }
+}
+exports.PasswordManager = PasswordManager;

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

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

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

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isPasswordStrong = void 0;
+const errors_utils_1 = require("@naman_deep_singh/errors-utils");
+const isPasswordStrong = (password, options = {}) => {
+    if (!password)
+        throw new errors_utils_1.BadRequestError({ reason: 'Invalid password provided' });
+    const { minLength = 8, requireUppercase = true, requireLowercase = true, requireNumbers = true, requireSymbols = false, } = options;
+    if (password.length < minLength)
+        throw new errors_utils_1.ValidationError({
+            reason: `Password must be at least ${minLength} characters long`,
+        });
+    if (requireUppercase && !/[A-Z]/.test(password))
+        throw new errors_utils_1.ValidationError({
+            reason: 'Password must include uppercase letters',
+        });
+    if (requireLowercase && !/[a-z]/.test(password))
+        throw new errors_utils_1.ValidationError({
+            reason: 'Password must include lowercase letters',
+        });
+    if (requireNumbers && !/[0-9]/.test(password))
+        throw new errors_utils_1.ValidationError({ reason: 'Password must include numbers' });
+    if (requireSymbols && !/[^A-Za-z0-9]/.test(password))
+        throw new errors_utils_1.ValidationError({ reason: 'Password must include symbols' });
+    return true;
+};
+exports.isPasswordStrong = isPasswordStrong;

package/packages/security/dist/cjs/core/password/types.d.ts

@@ -0,0 +1,7 @@
+export interface PasswordStrengthOptions {
+    minLength?: number;
+    requireUppercase?: boolean;
+    requireLowercase?: boolean;
+    requireNumbers?: boolean;
+    requireSymbols?: boolean;
+}

package/packages/security/dist/cjs/core/password/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/packages/security/dist/cjs/core/password/utils.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Ensure password is a valid non-empty string
+ */
+export declare function ensureValidPassword(password: string): void;
+/**
+ * Timing-safe comparison between two strings
+ */
+export declare function safeCompare(a: string, b: string): boolean;
+/**
+ * Estimate password entropy based on character pool
+ */
+export declare function estimatePasswordEntropy(password: string): number;
+/**
+ * Normalize password string to a consistent form
+ */
+export declare function normalizePassword(password: string): string;

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

@@ -0,0 +1,53 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ensureValidPassword = ensureValidPassword;
+exports.safeCompare = safeCompare;
+exports.estimatePasswordEntropy = estimatePasswordEntropy;
+exports.normalizePassword = normalizePassword;
+const crypto_1 = __importDefault(require("crypto"));
+const errors_utils_1 = require("@naman_deep_singh/errors-utils");
+/**
+ * Ensure password is a valid non-empty string
+ */
+function ensureValidPassword(password) {
+    if (!password || typeof password !== 'string') {
+        throw new errors_utils_1.BadRequestError({ reason: 'Invalid password provided' });
+    }
+}
+/**
+ * Timing-safe comparison between two strings
+ */
+function safeCompare(a, b) {
+    const bufA = Buffer.from(a);
+    const bufB = Buffer.from(b);
+    if (bufA.length !== bufB.length)
+        return false;
+    return crypto_1.default.timingSafeEqual(bufA, bufB);
+}
+/**
+ * Estimate password entropy based on character pool
+ */
+function estimatePasswordEntropy(password) {
+    let pool = 0;
+    if (/[a-z]/.test(password))
+        pool += 26;
+    if (/[A-Z]/.test(password))
+        pool += 26;
+    if (/[0-9]/.test(password))
+        pool += 10;
+    if (/[^A-Za-z0-9]/.test(password))
+        pool += 32;
+    // If no characters matched, fallback to 1 to avoid log2(0)
+    if (pool === 0)
+        pool = 1;
+    return password.length * Math.log2(pool);
+}
+/**
+ * Normalize password string to a consistent form
+ */
+function normalizePassword(password) {
+    return password.normalize('NFKC');
+}

package/packages/security/dist/cjs/core/password/verify.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Compare a password with a stored hash asynchronously.
+ */
+export declare const verifyPassword: (password: string, hash: string) => Promise<boolean>;
+export declare function verifyPasswordWithPepper(password: string, pepper: string, hash: string): Promise<boolean>;
+/**
+ * Compare a password with a stored hash synchronously.
+ */
+export declare const verifyPasswordSync: (password: string, hash: string) => boolean;
+export declare function verifyPasswordWithPepperSync(password: string, pepper: string, hash: string): Promise<boolean>;

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

@@ -0,0 +1,46 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.verifyPasswordSync = exports.verifyPassword = void 0;
+exports.verifyPasswordWithPepper = verifyPasswordWithPepper;
+exports.verifyPasswordWithPepperSync = verifyPasswordWithPepperSync;
+const errors_utils_1 = require("@naman_deep_singh/errors-utils");
+const bcryptjs_1 = __importDefault(require("bcryptjs"));
+/**
+ * Compare a password with a stored hash asynchronously.
+ */
+const verifyPassword = async (password, hash) => {
+    try {
+        const result = await bcryptjs_1.default.compare(password, hash);
+        if (!result)
+            throw new errors_utils_1.UnauthorizedError({ reason: 'Password verification failed' });
+        return result;
+    }
+    catch {
+        throw new errors_utils_1.UnauthorizedError({ reason: 'Password verification failed' });
+    }
+};
+exports.verifyPassword = verifyPassword;
+async function verifyPasswordWithPepper(password, pepper, hash) {
+    return (0, exports.verifyPassword)(password + pepper, hash);
+}
+/**
+ * Compare a password with a stored hash synchronously.
+ */
+const verifyPasswordSync = (password, hash) => {
+    try {
+        const result = bcryptjs_1.default.compareSync(password, hash);
+        if (!result)
+            throw new errors_utils_1.UnauthorizedError({ reason: 'Password verification failed' });
+        return result;
+    }
+    catch (_error) {
+        throw new errors_utils_1.UnauthorizedError({ reason: 'Password verification failed' });
+    }
+};
+exports.verifyPasswordSync = verifyPasswordSync;
+async function verifyPasswordWithPepperSync(password, pepper, hash) {
+    return (0, exports.verifyPasswordSync)(password + pepper, hash);
+}

package/packages/security/dist/cjs/index.d.ts

@@ -0,0 +1,40 @@
+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;
+    hmacSign: (message: string, secret: string) => string;
+    hmacVerify: (message: string, secret: string, signature: string) => boolean;
+    randomToken: (length?: number) => string;
+    generateStrongPassword: (length?: number) => string;
+    CryptoManager: typeof CryptoUtils.CryptoManager;
+    createCryptoManager: (config?: CryptoUtils.CryptoManagerConfig) => CryptoUtils.CryptoManager;
+    cryptoManager: CryptoUtils.CryptoManager;
+    decodeToken(token: string): null | string | import("node_modules/@types/jsonwebtoken").JwtPayload;
+    decodeTokenStrict(token: string): import("node_modules/@types/jsonwebtoken").JwtPayload;
+    extractToken(sources: JWTUtils.TokenSources): string | null;
+    rotateRefreshToken(oldToken: string, secret: import("node_modules/@types/jsonwebtoken").Secret): JWTUtils.RefreshToken;
+    generateTokens: (payload: Record<string, unknown>, accessSecret: import("node_modules/@types/jsonwebtoken").Secret, refreshSecret: import("node_modules/@types/jsonwebtoken").Secret, accessExpiry?: string | number, refreshExpiry?: string | number) => JWTUtils.TokenPair;
+    parseDuration(input: string | number): number;
+    signToken: (payload: Record<string, unknown>, secret: import("node_modules/@types/jsonwebtoken").Secret, expiresIn?: string | number, options?: import("node_modules/@types/jsonwebtoken").SignOptions) => string;
+    validateTokenPayload(payload: Record<string, unknown>, rules?: JWTUtils.TokenRequirements): void;
+    isTokenExpired(payload: import("node_modules/@types/jsonwebtoken").JwtPayload): boolean;
+    verifyToken: (token: string, secret: import("node_modules/@types/jsonwebtoken").Secret) => string | import("node_modules/@types/jsonwebtoken").JwtPayload;
+    verifyTokenWithOptions: (token: string, secret: import("node_modules/@types/jsonwebtoken").Secret, options?: import("node_modules/@types/jsonwebtoken").VerifyOptions) => string | import("node_modules/@types/jsonwebtoken").JwtPayload;
+    safeVerifyToken: (token: string, secret: import("node_modules/@types/jsonwebtoken").Secret) => JWTUtils.VerificationResult;
+    safeVerifyTokenWithOptions: (token: string, secret: import("node_modules/@types/jsonwebtoken").Secret, options?: import("node_modules/@types/jsonwebtoken").VerifyOptions) => JWTUtils.VerificationResult;
+    hashPasswordWithPepper(password: string, pepper: string): Promise<string>;
+    hashPasswordWithPepperSync(password: string, pepper: string): string;
+    hashPassword: (password: string, saltRounds?: number) => Promise<string>;
+    hashPasswordSync: (password: string, saltRounds?: number) => string;
+    isPasswordStrong: (password: string, options?: import("./core/password/types").PasswordStrengthOptions) => boolean;
+    verifyPasswordWithPepper(password: string, pepper: string, hash: string): Promise<boolean>;
+    verifyPasswordWithPepperSync(password: string, pepper: string, hash: string): Promise<boolean>;
+    verifyPassword: (password: string, hash: string) => Promise<boolean>;
+    verifyPasswordSync: (password: string, hash: string) => boolean;
+};
+export default _default;

package/packages/security/dist/cjs/index.js

@@ -0,0 +1,56 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InternalServerError = exports.ValidationError = exports.UnauthorizedError = exports.BadRequestError = void 0;
+__exportStar(require("./core/password"), exports);
+__exportStar(require("./core/jwt"), exports);
+__exportStar(require("./core/crypto"), exports);
+// Re-export common errors for convenience
+var errors_utils_1 = require("@naman_deep_singh/errors-utils");
+Object.defineProperty(exports, "BadRequestError", { enumerable: true, get: function () { return errors_utils_1.BadRequestError; } });
+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 CryptoUtils = __importStar(require("./core/crypto"));
+const JWTUtils = __importStar(require("./core/jwt"));
+const PasswordUtils = __importStar(require("./core/password"));
+exports.default = {
+    ...PasswordUtils,
+    ...JWTUtils,
+    ...CryptoUtils,
+};

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

@@ -0,0 +1,47 @@
+import type { JwtPayload, Secret } from 'jsonwebtoken';
+export interface AccessToken extends String {
+    readonly __type: 'AccessToken';
+}
+export interface RefreshToken extends String {
+    readonly __type: 'RefreshToken';
+}
+export interface TokenPair {
+    accessToken: AccessToken;
+    refreshToken: RefreshToken;
+}
+export interface JWTConfig {
+    accessSecret: Secret;
+    refreshSecret: Secret;
+    accessExpiry?: string | number;
+    refreshExpiry?: string | number;
+    enableCaching?: boolean;
+    maxCacheSize?: number;
+}
+export interface TokenValidationOptions {
+    ignoreExpiration?: boolean;
+    ignoreNotBefore?: boolean;
+    audience?: string | string[];
+    issuer?: string;
+    algorithms?: string[];
+}
+export interface TokenGenerationOptions {
+    algorithm?: string;
+    expiresIn?: string | number;
+    audience?: string | string[];
+    issuer?: string;
+    subject?: string;
+    kid?: string;
+}
+export interface ITokenManager {
+    generateTokens(payload: Record<string, unknown>): Promise<TokenPair>;
+    generateAccessToken(payload: Record<string, unknown>): Promise<AccessToken>;
+    generateRefreshToken(payload: Record<string, unknown>): Promise<RefreshToken>;
+    verifyAccessToken(token: string): Promise<JwtPayload | string>;
+    verifyRefreshToken(token: string): Promise<JwtPayload | string>;
+    decodeToken(token: string, complete?: boolean): JwtPayload | string | null;
+    extractTokenFromHeader(authHeader: string): string | null;
+    validateToken(token: string, secret: Secret, options?: TokenValidationOptions): boolean;
+    rotateRefreshToken(oldToken: string): Promise<RefreshToken>;
+    isTokenExpired(token: string): boolean;
+    getTokenExpiration(token: string): Date | null;
+}

package/packages/security/dist/cjs/interfaces/jwt.interface.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/packages/security/dist/cjs/interfaces/password.interface.d.ts

@@ -0,0 +1,60 @@
+export interface PasswordConfig {
+    saltRounds?: number;
+    minLength?: number;
+    maxLength?: number;
+    requireUppercase?: boolean;
+    requireLowercase?: boolean;
+    requireNumbers?: boolean;
+    requireSpecialChars?: boolean;
+    customRules?: PasswordRule[];
+}
+export interface PasswordRule {
+    test: (password: string) => boolean;
+    message: string;
+}
+export interface PasswordStrength {
+    score: number;
+    label: 'very-weak' | 'weak' | 'fair' | 'good' | 'strong';
+    feedback: string[];
+    suggestions: string[];
+}
+export interface PasswordValidationResult {
+    isValid: boolean;
+    errors: string[];
+    strength: PasswordStrength;
+}
+export interface HashedPassword {
+    hash: string;
+    salt: string;
+}
+export interface IPasswordManager {
+    hash(password: string, salt?: string): Promise<HashedPassword>;
+    verify(password: string, hash: string, salt: string): Promise<boolean>;
+    generate(length?: number, options?: PasswordConfig): string;
+    validate(password: string, config?: PasswordConfig): PasswordValidationResult;
+    checkStrength(password: string): PasswordStrength;
+    needsUpgrade(hash: string, currentConfig: PasswordConfig): boolean;
+}
+export interface IPasswordStrengthChecker {
+    analyze(password: string): PasswordStrength;
+    checkLength(password: string): {
+        valid: boolean;
+        message: string;
+    };
+    checkComplexity(password: string, config: PasswordConfig): {
+        valid: boolean;
+        message: string;
+    }[];
+    checkCommonPasswords(password: string): {
+        valid: boolean;
+        message: string;
+    };
+    checkSequential(password: string): {
+        valid: boolean;
+        message: string;
+    };
+    checkRepetition(password: string): {
+        valid: boolean;
+        message: string;
+    };
+}

package/packages/security/dist/cjs/interfaces/password.interface.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });