@naman_deep_singh/security 1.6.0 → 1.7.0

package/dist/esm/interfaces/password.interface.d.ts

@@ -1,60 +0,0 @@
-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/dist/types/core/crypto/cryptoManager.d.ts

@@ -1,111 +0,0 @@
-/**
- * Configuration options for CryptoManager
- */
-export interface CryptoManagerConfig {
-    defaultAlgorithm?: string;
-    defaultEncoding?: BufferEncoding;
-    hmacAlgorithm?: string;
-}
-/**
- * CryptoManager - Class-based wrapper for all cryptographic operations
- * Provides a consistent interface for encryption, decryption, HMAC generation, and secure random generation
- */
-export declare class CryptoManager {
-    private config;
-    constructor(config?: CryptoManagerConfig);
-    /**
-     * Update configuration
-     */
-    updateConfig(config: Partial<CryptoManagerConfig>): void;
-    /**
-     * Get current configuration
-     */
-    getConfig(): Required<CryptoManagerConfig>;
-    /**
-     * Encrypt data using the default or specified algorithm
-     */
-    encrypt(plaintext: string, key: string, _options?: {
-        algorithm?: string;
-        encoding?: BufferEncoding;
-        iv?: string;
-    }): string;
-    /**
-     * Decrypt data using the default or specified algorithm
-     */
-    decrypt(encryptedData: string, key: string, _options?: {
-        algorithm?: string;
-        encoding?: BufferEncoding;
-        iv?: string;
-    }): string;
-    /**
-     * Generate HMAC signature
-     */
-    generateHmac(data: string, secret: string, _options?: {
-        algorithm?: string;
-        encoding?: BufferEncoding;
-    }): string;
-    /**
-     * Generate cryptographically secure random bytes
-     */
-    generateSecureRandom(length: number, _encoding?: BufferEncoding): string;
-    /**
-     * Verify HMAC signature
-     */
-    verifyHmac(data: string, secret: string, signature: string, _options?: {
-        algorithm?: string;
-        encoding?: BufferEncoding;
-    }): boolean;
-    /**
-     * Create a key derivation function using PBKDF2
-     */
-    deriveKey(password: string, salt: string, iterations?: number, keyLength?: number): Promise<string>;
-    /**
-     * Hash data using SHA-256
-     */
-    sha256(data: string, encoding?: BufferEncoding): string;
-    /**
-     * Hash data using SHA-512
-     */
-    sha512(data: string, encoding?: BufferEncoding): string;
-    /**
-     * Generate a secure key pair for asymmetric encryption
-     */
-    generateKeyPair(options?: {
-        modulusLength?: number;
-        publicKeyEncoding?: {
-            type: string;
-            format: string;
-        };
-        privateKeyEncoding?: {
-            type: string;
-            format: string;
-        };
-    }): Promise<{
-        publicKey: string;
-        privateKey: string;
-    }>;
-    /**
-     * Encrypt data using RSA public key
-     */
-    rsaEncrypt(data: string, publicKey: string): Promise<string>;
-    /**
-     * Decrypt data using RSA private key
-     */
-    rsaDecrypt(encryptedData: string, privateKey: string): Promise<string>;
-    /**
-     * Create digital signature using RSA private key
-     */
-    rsaSign(data: string, privateKey: string, algorithm?: string): Promise<string>;
-    /**
-     * Verify digital signature using RSA public key
-     */
-    rsaVerify(data: string, signature: string, publicKey: string, algorithm?: string): Promise<boolean>;
-}
-/**
- * Create a CryptoManager instance with default configuration
- */
-export declare const createCryptoManager: (config?: CryptoManagerConfig) => CryptoManager;
-/**
- * Default CryptoManager instance
- */
-export declare const cryptoManager: CryptoManager;

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

@@ -1,43 +0,0 @@
-import { type JwtPayload, type Secret } from 'jsonwebtoken';
-import type { AccessToken, ITokenManager, JWTConfig, RefreshToken, TokenPair } 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 */
-    generateTokens(payload: Record<string, unknown>): Promise<TokenPair>;
-    /** Generate access token */
-    generateAccessToken(payload: Record<string, unknown>): Promise<AccessToken>;
-    /** Generate refresh token */
-    generateRefreshToken(payload: Record<string, unknown>): Promise<RefreshToken>;
-    /** Verify access token */
-    verifyAccessToken(token: string): Promise<JwtPayload>;
-    /** Verify refresh token */
-    verifyRefreshToken(token: string): Promise<JwtPayload>;
-    /** Decode token without verification */
-    decodeToken(token: string, complete?: boolean): JwtPayload | string | null;
-    /** Extract token from Authorization header */
-    extractTokenFromHeader(authHeader: string): string | null;
-    /** Validate token without throwing exceptions */
-    validateToken(token: string, secret: Secret): boolean;
-    /** Rotate refresh token */
-    rotateRefreshToken(oldToken: string): Promise<RefreshToken>;
-    /** Check if token is expired */
-    isTokenExpired(token: string): boolean;
-    /** Get token expiration date */
-    getTokenExpiration(token: string): Date | null;
-    /** Clear token cache */
-    clearCache(): void;
-    /** Get cache statistics */
-    getCacheStats(): {
-        size: number;
-        maxSize: number;
-    } | null;
-    /** Private helper methods */
-    private validatePayload;
-    private verifyTokenWithCache;
-}