@jmlq/auth 0.0.1-alpha.1 → 0.0.1-alpha.2

package/dist/src/infrastructure/jwt/factory/signature-strategy.factory.d.ts

@@ -1,21 +0,0 @@
-import { ISignatureStrategy, ISignatureStrategyFactory } from "../../../domain/ports";
-import { AlgorithmName, AnyAlgorithm, Base64UrlEncoder } from "../../../shared";
-/**
- * Selector de estrategia de firma JWT (HMAC, RSA, ECDSA).
- * Infraestructura: implementa el port del dominio.
- */
-export declare class SignatureStrategyFactory implements ISignatureStrategyFactory {
-    private readonly encoder;
-    constructor(encoder?: Base64UrlEncoder);
-    /**
-     * Devuelve la lista de algoritmos soportados por este factory.
-     */
-    supported(): ReadonlyArray<AlgorithmName>;
-    /**
-     * Crea la estrategia adecuada según el algoritmo (HS*, RS*, ES*).
-     */
-    create(algorithm: AnyAlgorithm): ISignatureStrategy;
-    private isHmacAlgorithm;
-    private isRsaAlgorithm;
-    private isEcdsaAlgorithm;
-}

package/dist/src/infrastructure/jwt/factory/signature-strategy.factory.js

@@ -1,61 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.SignatureStrategyFactory = void 0;
-const domain_1 = require("../../../domain");
-const shared_1 = require("../../../shared");
-const strategies_1 = require("../strategies");
-// Prepara sets para membership rápido (evita recalcular Object.values en cada llamada)
-const HMAC_SET = new Set(Object.values(shared_1.algorithms.hmac));
-const RSA_SET = new Set([
-    ...Object.values(shared_1.algorithms.rsa),
-    // Si soportas PSS (PS256, PS384, PS512), añádelos aquí:
-    // ...Object.values(algoritms.rsaPss),
-]);
-const ECDSA_SET = new Set(Object.values(shared_1.algorithms.ecdsa));
-/**
- * Selector de estrategia de firma JWT (HMAC, RSA, ECDSA).
- * Infraestructura: implementa el port del dominio.
- */
-class SignatureStrategyFactory {
-    constructor(encoder = new shared_1.Base64UrlEncoder()) {
-        this.encoder = encoder;
-    }
-    /**
-     * Devuelve la lista de algoritmos soportados por este factory.
-     */
-    supported() {
-        return [
-            ...Object.values(shared_1.algorithms.hmac),
-            ...Object.values(shared_1.algorithms.rsa),
-            ...Object.values(shared_1.algorithms.ecdsa),
-            // Si más adelante agregas PSS:
-            // ...Object.values(algorithms.rsaPss),
-        ];
-    }
-    /**
-     * Crea la estrategia adecuada según el algoritmo (HS*, RS*, ES*).
-     */
-    create(algorithm) {
-        const alg = algorithm.toUpperCase(); // defensivo
-        if (this.isHmacAlgorithm(alg)) {
-            return new strategies_1.HmacSignatureStrategy(alg, this.encoder);
-        }
-        if (this.isRsaAlgorithm(alg)) {
-            return new strategies_1.RsaSignatureStrategy(alg, this.encoder);
-        }
-        if (this.isEcdsaAlgorithm(alg)) {
-            return new strategies_1.EcdsaSignatureStrategy(alg, this.encoder);
-        }
-        throw new domain_1.UnsupportedAlgorithmError(`Unsupported algorithm: ${algorithm}`);
-    }
-    isHmacAlgorithm(algorithm) {
-        return HMAC_SET.has(algorithm);
-    }
-    isRsaAlgorithm(algorithm) {
-        return RSA_SET.has(algorithm);
-    }
-    isEcdsaAlgorithm(algorithm) {
-        return ECDSA_SET.has(algorithm);
-    }
-}
-exports.SignatureStrategyFactory = SignatureStrategyFactory;

package/dist/src/infrastructure/jwt/index.d.ts

@@ -1,3 +0,0 @@
-export * from "./factory";
-export * from "./strategies";
-export * from "./token";

package/dist/src/infrastructure/jwt/signature-strategy.factory.d.ts

@@ -1,21 +0,0 @@
-import { ISignatureStrategy, ISignatureStrategyFactory } from "../../domain/ports";
-import { AlgorithmName, AnyAlgorithm, Base64UrlEncoder } from "../../shared";
-/**
- * Selector de estrategia de firma JWT (HMAC, RSA, ECDSA).
- * Infraestructura: implementa el port del dominio.
- */
-export declare class SignatureStrategyFactory implements ISignatureStrategyFactory {
-    private readonly encoder;
-    constructor(encoder?: Base64UrlEncoder);
-    /**
-     * Devuelve la lista de algoritmos soportados por este factory.
-     */
-    supported(): ReadonlyArray<AlgorithmName>;
-    /**
-     * Crea la estrategia adecuada según el algoritmo (HS*, RS*, ES*).
-     */
-    create(algorithm: AnyAlgorithm): ISignatureStrategy;
-    private isHmacAlgorithm;
-    private isRsaAlgorithm;
-    private isEcdsaAlgorithm;
-}

package/dist/src/infrastructure/jwt/signature-strategy.factory.js

@@ -1,61 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.SignatureStrategyFactory = void 0;
-const domain_1 = require("../../domain");
-const shared_1 = require("../../shared");
-const strategies_1 = require("./strategies");
-// Prepara sets para membership rápido (evita recalcular Object.values en cada llamada)
-const HMAC_SET = new Set(Object.values(shared_1.algorithms.hmac));
-const RSA_SET = new Set([
-    ...Object.values(shared_1.algorithms.rsa),
-    // Si soportas PSS (PS256, PS384, PS512), añádelos aquí:
-    // ...Object.values(algoritms.rsaPss),
-]);
-const ECDSA_SET = new Set(Object.values(shared_1.algorithms.ecdsa));
-/**
- * Selector de estrategia de firma JWT (HMAC, RSA, ECDSA).
- * Infraestructura: implementa el port del dominio.
- */
-class SignatureStrategyFactory {
-    constructor(encoder = new shared_1.Base64UrlEncoder()) {
-        this.encoder = encoder;
-    }
-    /**
-     * Devuelve la lista de algoritmos soportados por este factory.
-     */
-    supported() {
-        return [
-            ...Object.values(shared_1.algorithms.hmac),
-            ...Object.values(shared_1.algorithms.rsa),
-            ...Object.values(shared_1.algorithms.ecdsa),
-            // Si más adelante agregas PSS:
-            // ...Object.values(algorithms.rsaPss),
-        ];
-    }
-    /**
-     * Crea la estrategia adecuada según el algoritmo (HS*, RS*, ES*).
-     */
-    create(algorithm) {
-        const alg = algorithm.toUpperCase(); // defensivo
-        if (this.isHmacAlgorithm(alg)) {
-            return new strategies_1.HmacSignatureStrategy(alg, this.encoder);
-        }
-        if (this.isRsaAlgorithm(alg)) {
-            return new strategies_1.RsaSignatureStrategy(alg, this.encoder);
-        }
-        if (this.isEcdsaAlgorithm(alg)) {
-            return new strategies_1.EcdsaSignatureStrategy(alg, this.encoder);
-        }
-        throw new domain_1.UnsupportedAlgorithmError(`Unsupported algorithm: ${algorithm}`);
-    }
-    isHmacAlgorithm(algorithm) {
-        return HMAC_SET.has(algorithm);
-    }
-    isRsaAlgorithm(algorithm) {
-        return RSA_SET.has(algorithm);
-    }
-    isEcdsaAlgorithm(algorithm) {
-        return ECDSA_SET.has(algorithm);
-    }
-}
-exports.SignatureStrategyFactory = SignatureStrategyFactory;

package/dist/src/infrastructure/jwt/strategies/ecdsa-signature-strategy.d.ts

@@ -1,47 +0,0 @@
-import { SignatureStrategy } from "../../../domain/ports";
-import { Base64UrlEncoder, EcdsaAlgorithm } from "../../../shared";
-/**
- *Esta clase implementa la estrategia de firma digital usando ECDSA (Elliptic Curve Digital Signature Algorithm) para JWT.
- *Maneja la firma y verificación de tokens JWT usando algoritmos ECDSA con curvas elípticas, que son más eficientes que RSA para el mismo nivel de seguridad.
- */
-export declare class EcdsaSignatureStrategy implements SignatureStrategy {
-    private readonly algorithm;
-    private readonly encoder;
-    /**
-     * Mapea los algoritmos JWT ECDSA a los algoritmos hash de Node.js crypto.
-     * Por ejemplo, 'ES256' → 'sha256'
-     */
-    private static readonly ALGORITHM_MAP;
-    /**
-     * Crea una nueva instancia de EcdsaSignatureStrategy
-     * @param algorithm El algoritmo ECDSA a usar (por ejemplo, 'ES256')
-     * @param encoder El codificador Base64 URL-safe a usar
-     */
-    constructor(algorithm: EcdsaAlgorithm, encoder: Base64UrlEncoder);
-    /**
-     * Firma digitalmente los datos usando la clave privada ECDSA
-     * @param data Los datos a firmar (normalmente el header + payload del JWT)
-     * @param privateKey La clave privada para firmar
-     * @returns La firma digital como string codificado
-     */
-    sign(data: string, privateKey: string): string;
-    /**
-     * Verifica si una firma es válida para los datos dados usando la clave pública ECDSA
-     * @param data Los datos a firmar (normalmente el header + payload del JWT)
-     * @param signature La firma digital a verificar
-     * @param publicKey La clave pública para verificar
-     * @returns true si la firma es válida, false si no
-     */
-    verify(data: string, signature: string, publicKey: string): boolean;
-    /**
-     * Retorna el algoritmo que soporta esta estrategia específica.
-     * @returns El nombre del algoritmo soportado
-     */
-    getSupportedAlgorithm(): string;
-    /**
-     * Convierte el algoritmo JWT ECDSA (como 'ES256') al algoritmo hash correspondiente que entiende Node.js crypto (como 'sha256').
-     * @returns El algoritmo hash correspondiente
-     * @throws Error si el algoritmo ECDSA no es soportado
-     */
-    private getHashAlgorithm;
-}

package/dist/src/infrastructure/jwt/strategies/ecdsa-signature-strategy.js

@@ -1,124 +0,0 @@
-"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 __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.EcdsaSignatureStrategy = void 0;
-const crypto = __importStar(require("crypto"));
-const shared_1 = require("../../../shared");
-/**
- *Esta clase implementa la estrategia de firma digital usando ECDSA (Elliptic Curve Digital Signature Algorithm) para JWT.
- *Maneja la firma y verificación de tokens JWT usando algoritmos ECDSA con curvas elípticas, que son más eficientes que RSA para el mismo nivel de seguridad.
- */
-class EcdsaSignatureStrategy {
-    /**
-     * Crea una nueva instancia de EcdsaSignatureStrategy
-     * @param algorithm El algoritmo ECDSA a usar (por ejemplo, 'ES256')
-     * @param encoder El codificador Base64 URL-safe a usar
-     */
-    constructor(algorithm, encoder) {
-        this.algorithm = algorithm;
-        this.encoder = encoder;
-    }
-    /**
-     * Firma digitalmente los datos usando la clave privada ECDSA
-     * @param data Los datos a firmar (normalmente el header + payload del JWT)
-     * @param privateKey La clave privada para firmar
-     * @returns La firma digital como string codificado
-     */
-    sign(data, privateKey) {
-        // Obtiene el algoritmo hash correspondiente (sha256, sha384, sha512)
-        const hashAlgorithm = this.getHashAlgorithm();
-        // Crea un firmador
-        const sign = crypto.createSign(hashAlgorithm);
-        // Alimenta los datos al firmador
-        sign.update(data);
-        // Genera la firma usando la clave privada ECDSA
-        const signature = sign.sign(privateKey, "base64");
-        // Codifica en Base64URL para JWT
-        return this.encoder.encode(signature);
-    }
-    /**
-     * Verifica si una firma es válida para los datos dados usando la clave pública ECDSA
-     * @param data Los datos a firmar (normalmente el header + payload del JWT)
-     * @param signature La firma digital a verificar
-     * @param publicKey La clave pública para verificar
-     * @returns true si la firma es válida, false si no
-     */
-    verify(data, signature, publicKey) {
-        try {
-            // Decodifica la firma desde Base64URL
-            const hashAlgorithm = this.getHashAlgorithm();
-            // Crea un verificador
-            const verify = crypto.createVerify(hashAlgorithm);
-            // Alimenta los datos originales
-            verify.update(data);
-            // Verifica usando la clave pública ECDSA
-            const decodedSignature = this.encoder.decode(signature);
-            // Retorna true si válida, false si no
-            return verify.verify(publicKey, decodedSignature, "base64");
-        }
-        catch (error) {
-            return false;
-        }
-    }
-    /**
-     * Retorna el algoritmo que soporta esta estrategia específica.
-     * @returns El nombre del algoritmo soportado
-     */
-    getSupportedAlgorithm() {
-        return this.algorithm;
-    }
-    /**
-     * Convierte el algoritmo JWT ECDSA (como 'ES256') al algoritmo hash correspondiente que entiende Node.js crypto (como 'sha256').
-     * @returns El algoritmo hash correspondiente
-     * @throws Error si el algoritmo ECDSA no es soportado
-     */
-    getHashAlgorithm() {
-        const hashAlgorithm = EcdsaSignatureStrategy.ALGORITHM_MAP[this.algorithm];
-        if (!hashAlgorithm) {
-            throw new Error(`Unsupported ECDSA algorithm: ${this.algorithm}`);
-        }
-        return hashAlgorithm;
-    }
-}
-exports.EcdsaSignatureStrategy = EcdsaSignatureStrategy;
-/**
- * Mapea los algoritmos JWT ECDSA a los algoritmos hash de Node.js crypto.
- * Por ejemplo, 'ES256' → 'sha256'
- */
-EcdsaSignatureStrategy.ALGORITHM_MAP = {
-    [shared_1.algorithms.ecdsa.ES256]: "sha256",
-    [shared_1.algorithms.ecdsa.ES384]: "sha384",
-    [shared_1.algorithms.ecdsa.ES512]: "sha512",
-};

package/dist/src/infrastructure/jwt/strategies/ecdsa-signature.strategy.d.ts

@@ -1,47 +0,0 @@
-import { ISignatureStrategy } from "../../../domain/ports";
-import { Base64UrlEncoder, EcdsaAlgorithm, AlgorithmName } from "../../../shared";
-/**
- *Esta clase implementa la estrategia de firma digital usando ECDSA (Elliptic Curve Digital Signature Algorithm) para JWT.
- *Maneja la firma y verificación de tokens JWT usando algoritmos ECDSA con curvas elípticas, que son más eficientes que RSA para el mismo nivel de seguridad.
- */
-export declare class EcdsaSignatureStrategy implements ISignatureStrategy {
-    private readonly algorithm;
-    private readonly encoder;
-    /**
-     * Mapea los algoritmos JWT ECDSA a los algoritmos hash de Node.js crypto.
-     * Por ejemplo, 'ES256' → 'sha256'
-     */
-    private static readonly ALGORITHM_MAP;
-    /**
-     * Crea una nueva instancia de EcdsaSignatureStrategy
-     * @param algorithm El algoritmo ECDSA a usar (por ejemplo, 'ES256')
-     * @param encoder El codificador Base64 URL-safe a usar
-     */
-    constructor(algorithm: EcdsaAlgorithm, encoder: Base64UrlEncoder);
-    /**
-     * Firma digitalmente los datos usando la clave privada ECDSA
-     * @param data Los datos a firmar (normalmente el header + payload del JWT)
-     * @param privateKey La clave privada para firmar
-     * @returns La firma digital como string codificado
-     */
-    sign(data: string, privateKey: string): string;
-    /**
-     * Verifica si una firma es válida para los datos dados usando la clave pública ECDSA
-     * @param data Los datos a firmar (normalmente el header + payload del JWT)
-     * @param signature La firma digital a verificar
-     * @param publicKey La clave pública para verificar
-     * @returns true si la firma es válida, false si no
-     */
-    verify(data: string, signature: string, publicKey: string): boolean;
-    /**
-     * Retorna el algoritmo que soporta esta estrategia específica.
-     * @returns El nombre del algoritmo soportado
-     */
-    getSupportedAlgorithm(): AlgorithmName;
-    /**
-     * Convierte el algoritmo JWT ECDSA (como 'ES256') al algoritmo hash correspondiente que entiende Node.js crypto (como 'sha256').
-     * @returns El algoritmo hash correspondiente
-     * @throws Error si el algoritmo ECDSA no es soportado
-     */
-    private getHashAlgorithm;
-}

package/dist/src/infrastructure/jwt/strategies/ecdsa-signature.strategy.js

@@ -1,124 +0,0 @@
-"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 __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.EcdsaSignatureStrategy = void 0;
-const crypto = __importStar(require("crypto"));
-const shared_1 = require("../../../shared");
-/**
- *Esta clase implementa la estrategia de firma digital usando ECDSA (Elliptic Curve Digital Signature Algorithm) para JWT.
- *Maneja la firma y verificación de tokens JWT usando algoritmos ECDSA con curvas elípticas, que son más eficientes que RSA para el mismo nivel de seguridad.
- */
-class EcdsaSignatureStrategy {
-    /**
-     * Crea una nueva instancia de EcdsaSignatureStrategy
-     * @param algorithm El algoritmo ECDSA a usar (por ejemplo, 'ES256')
-     * @param encoder El codificador Base64 URL-safe a usar
-     */
-    constructor(algorithm, encoder) {
-        this.algorithm = algorithm;
-        this.encoder = encoder;
-    }
-    /**
-     * Firma digitalmente los datos usando la clave privada ECDSA
-     * @param data Los datos a firmar (normalmente el header + payload del JWT)
-     * @param privateKey La clave privada para firmar
-     * @returns La firma digital como string codificado
-     */
-    sign(data, privateKey) {
-        // Obtiene el algoritmo hash correspondiente (sha256, sha384, sha512)
-        const hashAlgorithm = this.getHashAlgorithm();
-        // Crea un firmador
-        const sign = crypto.createSign(hashAlgorithm);
-        // Alimenta los datos al firmador
-        sign.update(data);
-        // Genera la firma usando la clave privada ECDSA
-        const signature = sign.sign(privateKey, "base64");
-        // Codifica en Base64URL para JWT
-        return this.encoder.encode(signature);
-    }
-    /**
-     * Verifica si una firma es válida para los datos dados usando la clave pública ECDSA
-     * @param data Los datos a firmar (normalmente el header + payload del JWT)
-     * @param signature La firma digital a verificar
-     * @param publicKey La clave pública para verificar
-     * @returns true si la firma es válida, false si no
-     */
-    verify(data, signature, publicKey) {
-        try {
-            // Decodifica la firma desde Base64URL
-            const hashAlgorithm = this.getHashAlgorithm();
-            // Crea un verificador
-            const verify = crypto.createVerify(hashAlgorithm);
-            // Alimenta los datos originales
-            verify.update(data);
-            // Verifica usando la clave pública ECDSA
-            const decodedSignature = this.encoder.decode(signature);
-            // Retorna true si válida, false si no
-            return verify.verify(publicKey, decodedSignature, "base64");
-        }
-        catch (error) {
-            return false;
-        }
-    }
-    /**
-     * Retorna el algoritmo que soporta esta estrategia específica.
-     * @returns El nombre del algoritmo soportado
-     */
-    getSupportedAlgorithm() {
-        return this.algorithm;
-    }
-    /**
-     * Convierte el algoritmo JWT ECDSA (como 'ES256') al algoritmo hash correspondiente que entiende Node.js crypto (como 'sha256').
-     * @returns El algoritmo hash correspondiente
-     * @throws Error si el algoritmo ECDSA no es soportado
-     */
-    getHashAlgorithm() {
-        const hashAlgorithm = EcdsaSignatureStrategy.ALGORITHM_MAP[this.algorithm];
-        if (!hashAlgorithm) {
-            throw new Error(`Unsupported ECDSA algorithm: ${this.algorithm}`);
-        }
-        return hashAlgorithm;
-    }
-}
-exports.EcdsaSignatureStrategy = EcdsaSignatureStrategy;
-/**
- * Mapea los algoritmos JWT ECDSA a los algoritmos hash de Node.js crypto.
- * Por ejemplo, 'ES256' → 'sha256'
- */
-EcdsaSignatureStrategy.ALGORITHM_MAP = {
-    [shared_1.algorithms.ecdsa.ES256]: "sha256",
-    [shared_1.algorithms.ecdsa.ES384]: "sha384",
-    [shared_1.algorithms.ecdsa.ES512]: "sha512",
-};

package/dist/src/infrastructure/jwt/strategies/hmac-signature-strategy.d.ts

@@ -1,54 +0,0 @@
-import { SignatureStrategy } from "../../../domain/ports";
-import { Base64UrlEncoder, HmacAlgorithm } from "../../../shared";
-/**
- *Esta clase implementa la estrategia de firma digital usando HMAC (Hash-based Message Authentication Code) para JWT.
- *Maneja la firma y verificación de tokens JWT usando algoritmos HMAC con funciones hash SHA, que utilizan una clave secreta compartida.
- */
-export declare class HmacSignatureStrategy implements SignatureStrategy {
-    private readonly algorithm;
-    private readonly encoder;
-    /**
-     * Mapea los algoritmos JWT HMAC a los algoritmos hash de Node.js crypto.
-     * Por ejemplo, 'HS256' → 'sha256'
-     */
-    private static readonly ALGORITHM_MAP;
-    /**
-     * Crea una nueva instancia de HmacSignatureStrategy
-     * @param algorithm El algoritmo HMAC a usar (por ejemplo, 'HS256')
-     * @param encoder El codificador Base64 URL-safe a usar
-     */
-    constructor(algorithm: HmacAlgorithm, encoder: Base64UrlEncoder);
-    /**
-     * Firma digitalmente los datos usando la clave secreta HMAC
-     * @param data Los datos a firmar (normalmente el header + payload del JWT)
-     * @param secret La clave secreta para firmar
-     * @returns La firma digital como string codificado
-     */
-    sign(data: string, secret: string): string;
-    /**
-     * Verifica si una firma es válida para los datos dados usando la clave secreta HMAC
-     * @param data Los datos a firmar (normalmente el header + payload del JWT)
-     * @param signature La firma digital a verificar
-     * @param secret La clave secreta para verificar
-     * @returns true si la firma es válida, false si no
-     */
-    verify(data: string, signature: string, secret: string): boolean;
-    /**
-     * Retorna el algoritmo que soporta esta estrategia específica.
-     * @returns El nombre del algoritmo soportado
-     */
-    getSupportedAlgorithm(): string;
-    /**
-     * Convierte el algoritmo JWT HMAC (como 'HS256') al algoritmo hash correspondiente que entiende Node.js crypto (como 'sha256').
-     * @returns El algoritmo hash correspondiente
-     * @throws Error si el algoritmo HMAC no es soportado
-     */
-    private getHashAlgorithm;
-    /**
-     * Compara dos strings de forma segura para evitar timing attacks
-     * @param a El primer string a comparar
-     * @param b El segundo string a comparar
-     * @returns true si son iguales, false si no lo son
-     */
-    private secureCompare;
-}