dymo-api 1.2.29 → 1.2.31

package/dist/cjs/lib/resilience/index.cjs

@@ -0,0 +1,135 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ResilienceManager = void 0;
+class RateLimitManager {
+    constructor() {
+        this.tracker = {};
+    }
+    static getInstance() {
+        if (!RateLimitManager.instance)
+            RateLimitManager.instance = new RateLimitManager();
+        return RateLimitManager.instance;
+    }
+    ;
+    updateRateLimit(clientId, headers) {
+        if (!this.tracker[clientId])
+            this.tracker[clientId] = {};
+        const limitInfo = this.tracker[clientId];
+        if (headers["x-ratelimit-limit-requests"])
+            limitInfo.limit = parseInt(headers["x-ratelimit-limit-requests"]);
+        if (headers["x-ratelimit-remaining-requests"])
+            limitInfo.remaining = parseInt(headers["x-ratelimit-remaining-requests"]);
+        if (headers["x-ratelimit-reset-requests"])
+            limitInfo.resetTime = headers["x-ratelimit-reset-requests"];
+        if (headers["retry-after"])
+            limitInfo.retryAfter = parseInt(headers["retry-after"]);
+        limitInfo.lastUpdated = Date.now();
+    }
+    ;
+    isRateLimited(clientId) {
+        const limitInfo = this.tracker[clientId];
+        return limitInfo?.remaining !== undefined && limitInfo.remaining <= 0;
+    }
+    ;
+    getRetryAfter(clientId) {
+        return this.tracker[clientId]?.retryAfter;
+    }
+    ;
+    clearExpiredLimits() {
+        const now = Date.now();
+        Object.keys(this.tracker).forEach(clientId => {
+            const limitInfo = this.tracker[clientId];
+            if (limitInfo.lastUpdated && (now - limitInfo.lastUpdated) > 300000)
+                delete this.tracker[clientId];
+        });
+    }
+    ;
+}
+;
+class ResilienceManager {
+    constructor(config = {}, clientId = "default") {
+        this.config = {
+            fallbackEnabled: config.fallbackEnabled ?? false,
+            retryAttempts: Math.max(0, config.retryAttempts ?? 2), // Number of additional retries
+            retryDelay: Math.max(0, config.retryDelay ?? 1000)
+        };
+        this.clientId = clientId;
+        this.rateLimitManager = RateLimitManager.getInstance();
+    }
+    ;
+    async executeWithResilience(axiosClient, requestConfig, fallbackData) {
+        let lastError;
+        const totalAttempts = 1 + this.config.retryAttempts; // 1 normal + N retries
+        // Clean up expired rate limits periodically
+        this.rateLimitManager.clearExpiredLimits();
+        // Check if client is currently rate limited
+        if (this.rateLimitManager.isRateLimited(this.clientId)) {
+            const retryAfter = this.rateLimitManager.getRetryAfter(this.clientId);
+            if (retryAfter) {
+                console.warn(`[Dymo API] Client ${this.clientId} is rate limited. Waiting ${retryAfter} seconds...`);
+                await this.sleep(retryAfter * 1000);
+            }
+        }
+        for (let attempt = 1; attempt <= totalAttempts; attempt++) {
+            try {
+                const response = await axiosClient.request(requestConfig);
+                // Update rate limit tracking
+                this.rateLimitManager.updateRateLimit(this.clientId, response.headers);
+                // Check for rate limiting
+                if (response.status === 429) {
+                    const retryAfter = this.rateLimitManager.getRetryAfter(this.clientId);
+                    if (retryAfter) {
+                        console.warn(`[Dymo API] Rate limited. Waiting ${retryAfter} seconds (no retries)`);
+                        await this.sleep(retryAfter * 1000);
+                    }
+                    throw new Error(`Rate limited (429) - not retrying`);
+                }
+                return response.data;
+            }
+            catch (error) {
+                lastError = error;
+                let shouldRetry = this.shouldRetry(error);
+                const isLastAttempt = attempt === totalAttempts;
+                // Don't retry on rate limiting (429)
+                if (error.response?.status === 429)
+                    shouldRetry = false;
+                if (!shouldRetry || isLastAttempt) {
+                    if (this.config.fallbackEnabled && fallbackData) {
+                        console.warn(`[Dymo API] Request failed after ${attempt} attempts. Using fallback data.`);
+                        return fallbackData;
+                    }
+                    throw error;
+                }
+                const delay = this.config.retryDelay * Math.pow(2, attempt - 1);
+                console.warn(`[Dymo API] Attempt ${attempt} failed. Retrying in ${delay}ms...`);
+                await this.sleep(delay);
+            }
+        }
+        throw lastError;
+    }
+    ;
+    shouldRetry(error) {
+        const statusCode = error.response?.status;
+        const isNetworkError = !error.response && error.code !== "ECONNABORTED";
+        const isServerError = statusCode && statusCode >= 500;
+        // Retry on: network errors, server errors (5xx)
+        // DON'T retry on: rate limiting (429) - handled separately
+        // DON'T retry on: client errors (4xx except 429)
+        return isNetworkError || isServerError;
+    }
+    ;
+    sleep(ms) {
+        return new Promise(resolve => setTimeout(resolve, ms));
+    }
+    ;
+    getConfig() {
+        return { ...this.config };
+    }
+    ;
+    getClientId() {
+        return this.clientId;
+    }
+    ;
+}
+exports.ResilienceManager = ResilienceManager;
+;

package/dist/esm/branches/private/functions/isValidPhone/index.js

@@ -49,6 +49,14 @@ export const isValidPhone = async (axiosClient, phone, rules) => {
             reasons.push("FRAUD");
         if (rules.deny.includes("HIGH_RISK_SCORE") && responsePhone.plugins.riskScore >= 80)
             reasons.push("HIGH_RISK_SCORE");
+        // Country block rules.
+        for (const rule of rules.deny) {
+            if (rule.startsWith("COUNTRY:")) {
+                const block = rule.split(":")[1]; // Extract country code.
+                if (responsePhone.countryCode === block)
+                    reasons.push(`COUNTRY:${block}`);
+            }
+        }
         return {
             phone: responsePhone.phone,
             allow: reasons.length === 0,

package/dist/esm/dymo-api.js

@@ -3,25 +3,29 @@ import axios from "axios";
 import { validBaseURL } from "./utils/basics.js";
 import * as PublicAPI from "./branches/public/index.js";
 import * as PrivateAPI from "./branches/private/index.js";
+import { ResilienceManager } from "./lib/resilience/index.js";
+import { FallbackDataGenerator } from "./lib/resilience/fallback.js";
 class DymoAPI {
     /**
-     * @param {Object} options - Options to create the DymoAPI instance.
-     * @param {string} [options.rootApiKey] - The root API key.
-     * @param {string} [options.apiKey] - The API key.
-     * @param {string} [options.baseUrl] - Whether to use a local server instead of the cloud server.
-     * @param {Object} [options.serverEmailConfig] - The server email config.
-     * @description
-     * This is the main class to interact with the Dymo API. It should be
-     * instantiated with the root API key and the API key. The root API key is
-     * used to fetch the tokens and the API key is used to authenticate the
-     * requests.
-     * @example
-     * const dymoApi = new DymoAPI({
-     *     rootApiKey: "6bfb7675-6b69-4f8d-9f43-5a6f7f02c6c5",
-     *     apiKey: "dm_4c8b7675-6b69-4f8d-9f43-5a6f7f02c6c5"
-     * });
-     */
-    constructor({ rootApiKey = null, apiKey = null, baseUrl = "https://api.tpeoficial.com", serverEmailConfig = undefined, rules = {} } = {}) {
+         * @param {Object} options - Options to create the DymoAPI instance.
+         * @param {string} [options.rootApiKey] - The root API key.
+         * @param {string} [options.apiKey] - The API key.
+         * @param {string} [options.baseUrl] - Whether to use a local server instead of the cloud server.
+         * @param {Object} [options.serverEmailConfig] - The server email config.
+         * @param {Object} [options.rules] - The rules.
+         * @param {Object} [options.resilience] - The resilience config.
+         * @description
+         * This is the main class to interact with the Dymo API. It should be
+         * instantiated with the root API key and the API key. The root API key is
+         * used to fetch the tokens and the API key is used to authenticate the
+         * requests. Requests are retried once by default with exponential backoff.
+         * @example
+         * const dymoApi = new DymoAPI({
+         *     rootApiKey: "6bfb7675-6b69-4f8d-9f43-5a6f7f02c6c5",
+         *     apiKey: "dm_4c8b7675-6b69-4f8d-9f43-5a6f7f02c6c5"
+         * });
+         */
+    constructor({ rootApiKey = null, apiKey = null, baseUrl = "https://api.tpeoficial.com", serverEmailConfig = undefined, rules = {}, resilience = {} } = {}) {
         this.rules = {
             email: { mode: "LIVE", deny: ["FRAUD", "INVALID", "NO_MX_RECORDS", "NO_REPLY_EMAIL"] },
             ip: { mode: "LIVE", deny: ["FRAUD", "INVALID", "TOR_NETWORK"] },
@@ -34,13 +38,16 @@ class DymoAPI {
         this.apiKey = apiKey;
         this.serverEmailConfig = serverEmailConfig;
         this.baseUrl = baseUrl;
+        // Initialize resilience system with client ID
+        const clientId = this.apiKey || this.rootApiKey || "anonymous";
+        this.resilienceManager = new ResilienceManager(resilience, clientId);
         // We created the Axios client with the appropriate settings.
         this.axiosClient = axios.create({
             baseURL: `${validBaseURL(this.baseUrl)}/v1`,
             headers: {
                 "User-Agent": "DymoAPISDK/1.0.0",
                 "X-Dymo-SDK-Env": "Node",
-                "X-Dymo-SDK-Version": "1.2.29"
+                "X-Dymo-SDK-Version": "1.2.31"
             }
         });
         // We set the authorization in the Axios client to make requests.
@@ -48,6 +55,14 @@ class DymoAPI {
             this.axiosClient.defaults.headers.Authorization = `Bearer ${this.rootApiKey || this.apiKey}`;
     }
     ;
+    getEmailPlugins(rules) {
+        return [
+            rules.deny.includes("NO_MX_RECORDS") ? "mxRecords" : undefined,
+            rules.deny.includes("NO_REACHABLE") ? "reachable" : undefined,
+            rules.deny.includes("HIGH_RISK_SCORE") ? "riskScore" : undefined,
+            rules.deny.includes("NO_GRAVATAR") ? "gravatar" : undefined
+        ].filter(Boolean);
+    }
     // FUNCTIONS / Private.
     /**
      * Validates the given data against the configured validation settings.
@@ -73,7 +88,12 @@ class DymoAPI {
      * [Documentation](https://docs.tpeoficial.com/docs/dymo-api/private/data-verifier)
      */
     async isValidData(data) {
-        return await PrivateAPI.isValidDataRaw(this.axiosClient, data);
+        const fallbackData = FallbackDataGenerator.generateFallbackData("isValidData", data);
+        return await this.resilienceManager.executeWithResilience(this.axiosClient, {
+            method: "POST",
+            url: "/private/secure/verify",
+            data
+        }, this.resilienceManager.getConfig().fallbackEnabled ? fallbackData : undefined);
     }
     ;
     /**
@@ -99,7 +119,12 @@ class DymoAPI {
      * [Documentation](https://docs.tpeoficial.com/docs/dymo-api/private/data-verifier)
      */
     async isValidDataRaw(data) {
-        return await PrivateAPI.isValidDataRaw(this.axiosClient, data);
+        const fallbackData = FallbackDataGenerator.generateFallbackData("isValidDataRaw", data);
+        return await this.resilienceManager.executeWithResilience(this.axiosClient, {
+            method: "POST",
+            url: "/private/secure/verify",
+            data
+        }, this.resilienceManager.getConfig().fallbackEnabled ? fallbackData : undefined);
     }
     ;
     /**
@@ -121,7 +146,12 @@ class DymoAPI {
      * @see [Documentation](https://docs.tpeoficial.com/docs/dymo-api/private/email-validation)
      */
     async isValidEmail(email, rules = this.rules.email) {
-        return await PrivateAPI.isValidEmail(this.axiosClient, email, rules);
+        const fallbackData = FallbackDataGenerator.generateFallbackData("isValidEmail", email);
+        return await this.resilienceManager.executeWithResilience(this.axiosClient, {
+            method: "POST",
+            url: "/private/secure/verify",
+            data: { email, plugins: this.getEmailPlugins(rules) }
+        }, this.resilienceManager.getConfig().fallbackEnabled ? fallbackData : undefined);
     }
     ;
     /**

package/dist/esm/lib/resilience/fallback.js

@@ -0,0 +1,423 @@
+export class FallbackDataGenerator {
+    static generateFallbackData(method, inputData) {
+        switch (method) {
+            case "isValidData": return this.generateDataValidationAnalysis(inputData);
+            case "isValidEmail": return this.generateEmailValidatorResponse(inputData);
+            case "isValidIP": return this.generateIPValidatorResponse(inputData);
+            case "isValidPhone": return this.generatePhoneValidatorResponse(inputData);
+            case "protectReq": return this.generateHTTPRequest(inputData);
+            case "sendEmail": return this.generateEmailStatus();
+            case "getRandom": return this.generateSRNSummary(inputData);
+            case "extractWithTextly": return this.generateExtractWithTextly(inputData);
+            case "getPrayerTimes": return this.generatePrayerTimes(inputData);
+            case "satinize": return this.generateSatinizedInputAnalysis(inputData);
+            case "isValidPwd": return this.generatePasswordValidationResult(inputData);
+            default: throw new Error(`Unknown method for fallback: ${method}`);
+        }
+    }
+    ;
+    static validateURL(url) {
+        if (!url)
+            return false;
+        const urlRegex = /^https?:\/\/(?:[-\w.])+(?:\:[0-9]+)?(?:\/(?:[\w\/_.])*(?:\?(?:[\w&=%.])*)?(?:\#(?:[\w.])*)?)?$/;
+        return urlRegex.test(url);
+    }
+    ;
+    static validateEmail(email) {
+        if (!email)
+            return false;
+        const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+        return emailRegex.test(email);
+    }
+    ;
+    static validateDomain(domain) {
+        if (!domain)
+            return false;
+        const domainRegex = /^[a-zA-Z0-9][a-zA-Z0-9-]{0,61}[a-zA-Z0-9](?:\.[a-zA-Z0-9][a-zA-Z0-9-]{0,61}[a-zA-Z0-9])*$/;
+        if (!domainRegex.test(domain))
+            return false;
+        // Validar que tenga un TLD (último punto + contenido)
+        const parts = domain.split('.');
+        return parts.length >= 2 && parts[parts.length - 1].length > 0;
+    }
+    ;
+    static validateCreditCard(creditCard) {
+        if (!creditCard)
+            return false;
+        const cardNumber = typeof creditCard === "string" ? creditCard : creditCard?.pan || "";
+        if (!cardNumber)
+            return false;
+        const cardRegex = /^\d{13,19}$/;
+        if (!cardRegex.test(cardNumber.replace(/\s/g, "")))
+            return false;
+        // Luhn algorithm
+        const digits = cardNumber.replace(/\s/g, "").split("").map(Number);
+        let sum = 0;
+        let isEven = false;
+        for (let i = digits.length - 1; i >= 0; i--) {
+            let digit = digits[i];
+            if (isEven) {
+                digit *= 2;
+                if (digit > 9)
+                    digit -= 9;
+            }
+            sum += digit;
+            isEven = !isEven;
+        }
+        return sum % 10 === 0;
+    }
+    ;
+    static validateIP(ip) {
+        if (!ip)
+            return false;
+        const ipv4Regex = /^(?:(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.){3}(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)$/;
+        const ipv6Regex = /^(?:[0-9a-fA-F]{1,4}:){7}[0-9a-fA-F]{1,4}$/;
+        return ipv4Regex.test(ip) || ipv6Regex.test(ip);
+    }
+    ;
+    static validatePhone(phone) {
+        if (!phone)
+            return false;
+        const phoneRegex = /^\+?[1-9]\d{1,14}$/;
+        return phoneRegex.test(phone.replace(/[^\d+]/g, ""));
+    }
+    ;
+    static validateWallet(wallet) {
+        if (!wallet)
+            return false;
+        const bitcoinRegex = /^[13][a-km-zA-HJ-NP-Z1-9]{25,34}$/;
+        const ethereumRegex = /^0x[a-fA-F0-9]{40}$/;
+        return bitcoinRegex.test(wallet) || ethereumRegex.test(wallet);
+    }
+    ;
+    static validateIBAN(iban) {
+        if (!iban)
+            return false;
+        const ibanRegex = /^[A-Z]{2}\d{2}[A-Z0-9]{11,30}$/;
+        return ibanRegex.test(iban.replace(/\s/g, "").toUpperCase());
+    }
+    ;
+    static extractDomain(url) {
+        if (!url)
+            return "";
+        try {
+            return new URL(url).hostname;
+        }
+        catch {
+            return "";
+        }
+    }
+    ;
+    static generateDataValidationAnalysis(inputData) {
+        return {
+            url: {
+                valid: this.validateURL(inputData?.url),
+                fraud: false,
+                freeSubdomain: false,
+                customTLD: false,
+                url: inputData?.url || "",
+                domain: this.extractDomain(inputData?.url),
+                plugins: {
+                    blocklist: false,
+                    compromiseDetector: false,
+                    mxRecords: [],
+                    nsfw: false,
+                    reputation: "unknown",
+                    riskScore: 0,
+                    torNetwork: false,
+                    typosquatting: 0,
+                    urlShortener: false
+                }
+            },
+            email: this.generateEmailDataAnalysis(inputData?.email),
+            phone: this.generatePhoneDataAnalysis(inputData?.phone),
+            domain: {
+                valid: this.validateDomain(inputData?.domain),
+                fraud: false,
+                freeSubdomain: false,
+                customTLD: false,
+                domain: inputData?.domain || "",
+                plugins: {
+                    blocklist: false,
+                    compromiseDetector: false,
+                    mxRecords: [],
+                    nsfw: false,
+                    reputation: "unknown",
+                    riskScore: 0,
+                    torNetwork: false,
+                    typosquatting: 0,
+                    urlShortener: false
+                }
+            },
+            creditCard: {
+                valid: this.validateCreditCard(inputData?.creditCard),
+                fraud: false,
+                test: false,
+                type: "unknown",
+                creditCard: typeof inputData?.creditCard === "string" ? inputData.creditCard : inputData?.creditCard?.pan || "",
+                plugins: {
+                    blocklist: false,
+                    riskScore: 0
+                }
+            },
+            ip: this.generateIPDataAnalysis(inputData?.ip),
+            wallet: {
+                valid: this.validateWallet(inputData?.wallet),
+                fraud: false,
+                wallet: inputData?.wallet || "",
+                type: "unknown",
+                plugins: {
+                    blocklist: false,
+                    riskScore: 0,
+                    torNetwork: false
+                }
+            },
+            userAgent: {
+                valid: false,
+                fraud: false,
+                userAgent: inputData?.userAgent || "",
+                bot: true,
+                device: { type: "unknown", brand: "unknown" },
+                plugins: {
+                    blocklist: false,
+                    riskScore: 0
+                }
+            },
+            iban: {
+                valid: this.validateIBAN(inputData?.iban),
+                fraud: false,
+                iban: inputData?.iban || "",
+                plugins: {
+                    blocklist: false,
+                    riskScore: 0
+                }
+            }
+        };
+    }
+    ;
+    static generateEmailValidatorResponse(inputData) {
+        return {
+            email: inputData?.email || "",
+            allow: this.validateEmail(inputData?.email),
+            reasons: this.validateEmail(inputData?.email) ? [] : ["INVALID"],
+            response: this.generateEmailDataAnalysis(inputData?.email)
+        };
+    }
+    ;
+    static generateEmailDataAnalysis(email) {
+        return {
+            valid: this.validateEmail(email),
+            fraud: false,
+            proxiedEmail: false,
+            freeSubdomain: false,
+            corporate: false,
+            email: email || "",
+            realUser: "",
+            didYouMean: null,
+            noReply: false,
+            customTLD: false,
+            domain: "",
+            roleAccount: false,
+            plugins: {
+                mxRecords: [],
+                blocklist: false,
+                compromiseDetector: false,
+                nsfw: false,
+                reputation: "unknown",
+                riskScore: 0,
+                torNetwork: false,
+                typosquatting: 0,
+                urlShortener: false
+            }
+        };
+    }
+    ;
+    static generateIPValidatorResponse(inputData) {
+        return {
+            ip: inputData?.ip || "",
+            allow: this.validateIP(inputData?.ip),
+            reasons: this.validateIP(inputData?.ip) ? [] : ["INVALID"],
+            response: this.generateIPDataAnalysis(inputData?.ip)
+        };
+    }
+    ;
+    static generateIPDataAnalysis(ip) {
+        const isValid = this.validateIP(ip);
+        return {
+            valid: isValid,
+            type: isValid ? "IPv4" : "Invalid",
+            class: isValid ? "A" : "Unknown",
+            fraud: false,
+            ip: ip || "",
+            continent: "",
+            continentCode: "",
+            country: "",
+            countryCode: "",
+            region: "",
+            regionName: "",
+            city: "",
+            district: "",
+            zipCode: "",
+            lat: 0,
+            lon: 0,
+            timezone: "",
+            offset: 0,
+            currency: "",
+            isp: "",
+            org: "",
+            as: "",
+            asname: "",
+            mobile: false,
+            proxy: true,
+            hosting: false,
+            plugins: {
+                blocklist: false,
+                riskScore: 0
+            }
+        };
+    }
+    ;
+    static generatePhoneValidatorResponse(inputData) {
+        return {
+            phone: inputData?.phone || "",
+            allow: this.validatePhone(inputData?.phone),
+            reasons: this.validatePhone(inputData?.phone) ? [] : ["INVALID"],
+            response: this.generatePhoneDataAnalysis(inputData?.phone)
+        };
+    }
+    ;
+    static generatePhoneDataAnalysis(phone) {
+        const phoneNumber = phone?.phone || phone;
+        const isValid = this.validatePhone(phoneNumber);
+        return {
+            valid: isValid,
+            fraud: false,
+            phone: phone?.phone || "",
+            prefix: "",
+            number: "",
+            lineType: "Unknown",
+            carrierInfo: {
+                carrierName: "",
+                accuracy: 0,
+                carrierCountry: "",
+                carrierCountryCode: ""
+            },
+            country: "",
+            countryCode: "",
+            plugins: {
+                blocklist: false,
+                riskScore: 0
+            }
+        };
+    }
+    ;
+    static generateHTTPRequest(inputData) {
+        return {
+            method: inputData?.method || "GET",
+            url: inputData?.url || "",
+            headers: inputData?.headers || {},
+            body: inputData?.body || null,
+            allow: false,
+            reasons: ["FRAUD"],
+            protected: true
+        };
+    }
+    ;
+    static generateEmailStatus() {
+        return {
+            status: false,
+            error: "API unavailable - using fallback response"
+        };
+    }
+    ;
+    static generateSRNSummary(inputData) {
+        const quantity = inputData?.quantity || 1;
+        const values = Array.from({ length: quantity }, () => ({
+            integer: 0,
+            float: 0.0
+        }));
+        return {
+            values,
+            executionTime: 0
+        };
+    }
+    ;
+    static generateExtractWithTextly(inputData) {
+        return {
+            data: inputData?.data || "",
+            extracted: {},
+            error: "API unavailable - using fallback response"
+        };
+    }
+    ;
+    static generatePrayerTimes(inputData) {
+        return {
+            error: "API unavailable - using fallback response"
+        };
+    }
+    ;
+    static generateSatinizedInputAnalysis(inputData) {
+        return {
+            input: inputData?.input || "",
+            formats: {
+                ascii: false,
+                bitcoinAddress: false,
+                cLikeIdentifier: false,
+                coordinates: false,
+                crediCard: false,
+                date: false,
+                discordUsername: false,
+                doi: false,
+                domain: false,
+                e164Phone: false,
+                email: false,
+                emoji: false,
+                hanUnification: false,
+                hashtag: false,
+                hyphenWordBreak: false,
+                ipv6: false,
+                ip: false,
+                jiraTicket: false,
+                macAddress: false,
+                name: false,
+                number: false,
+                panFromGstin: false,
+                password: false,
+                port: false,
+                tel: false,
+                text: false,
+                semver: false,
+                ssn: false,
+                uuid: false,
+                url: false,
+                urlSlug: false,
+                username: false
+            },
+            includes: {
+                spaces: false,
+                hasSql: false,
+                hasNoSql: false,
+                letters: false,
+                uppercase: false,
+                lowercase: false,
+                symbols: false,
+                digits: false
+            }
+        };
+    }
+    ;
+    static generatePasswordValidationResult(inputData) {
+        return {
+            valid: false,
+            password: inputData?.password || "",
+            details: [
+                {
+                    validation: "length",
+                    message: "API unavailable - using fallback response"
+                }
+            ]
+        };
+    }
+    ;
+}
+;