dymo-api 1.2.31 → 1.2.33

package/dist/esm/dymo-api.js

@@ -1,370 +1,1139 @@
-import config from "./config/index.js";
 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.
-         * @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"] },
-            phone: { mode: "LIVE", deny: ["FRAUD", "INVALID"] },
-            sensitiveInfo: { mode: "LIVE", deny: ["EMAIL", "PHONE", "CREDIT_CARD"] },
-            waf: { mode: "LIVE", allowBots: ["CURL", "CATEGORY:SEARCH_ENGINE", "CATEGORY:PREVIEW"], deny: ["FRAUD", "TOR_NETWORK"] },
-            ...rules
-        };
-        this.rootApiKey = rootApiKey;
-        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.31"
-            }
-        });
-        // We set the authorization in the Axios client to make requests.
-        if (this.rootApiKey || this.apiKey)
-            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.
-     *
-     * This method requires either the root API key or the API key to be set.
-     * If neither is set, it will throw an error.
-     *
-     * @deprecated Use `isValidDataRaw` instead. This feature will be modified soon.
-     * @param {Object} data - The data to be validated.
-     * @param {string} [data.url] - Optional URL to be validated.
-     * @param {string} [data.email] - Optional email address to be validated.
-     * @param {Interfaces.PhoneData} [data.phone] - Optional phone number data to be validated.
-     * @param {string} [data.domain] - Optional domain name to be validated.
-     * @param {string|Interfaces.CreditCardData} [data.creditCard] - Optional credit card number or data to be validated.
-     * @param {string} [data.ip] - Optional IP address to be validated.
-     * @param {string} [data.wallet] - Optional wallet address to be validated.
-     * @param {string} [data.userAgent] - Optional user agent string to be validated.
-     * @param {string} [data.iban] - Optional IBAN to be validated.
-     * @param {Interfaces.VerifyPlugins[]} [data.plugins] - Optional array of verification plugins to be used.
-     * @returns {Promise<Interfaces.DataValidationAnalysis>} A promise that resolves to the response from the server.
-     * @throws Will throw an error if there is an issue with the validation process.
-     *
-     * [Documentation](https://docs.tpeoficial.com/docs/dymo-api/private/data-verifier)
-     */
-    async isValidData(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);
-    }
-    ;
-    /**
-     * Validates the given data against the configured validation settings.
-     *
-     * This method requires either the root API key or the API key to be set.
-     * If neither is set, it will throw an error.
-     *
-     * @param {Object} data - The data to be validated.
-     * @param {string} [data.url] - Optional URL to be validated.
-     * @param {string} [data.email] - Optional email address to be validated.
-     * @param {Interfaces.PhoneData} [data.phone] - Optional phone number data to be validated.
-     * @param {string} [data.domain] - Optional domain name to be validated.
-     * @param {string|Interfaces.CreditCardData} [data.creditCard] - Optional credit card number or data to be validated.
-     * @param {string} [data.ip] - Optional IP address to be validated.
-     * @param {string} [data.wallet] - Optional wallet address to be validated.
-     * @param {string} [data.userAgent] - Optional user agent string to be validated.
-     * @param {string} [data.iban] - Optional IBAN to be validated.
-     * @param {Interfaces.VerifyPlugins[]} [data.plugins] - Optional array of verification plugins to be used.
-     * @returns {Promise<Interfaces.DataValidationAnalysis>} A promise that resolves to the response from the server.
-     * @throws Will throw an error if there is an issue with the validation process.
-     *
-     * [Documentation](https://docs.tpeoficial.com/docs/dymo-api/private/data-verifier)
-     */
-    async isValidDataRaw(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);
+import path from "path";
+import React from "react";
+import { twi } from "tw-to-css";
+import { render } from "@react-email/render";
+const config = {
+  lib: {
+    name: "Dymo API"
+  }
+};
+const customError = (code, message) => {
+  return Object.assign(new Error(), { code, message: `[${config.lib.name}] ${message}` });
+};
+const validBaseURL = (baseUrl) => {
+  if (/^(https:\/\/api\.tpeoficial\.com$|http:\/\/(localhost:\d+|dymoapi:\d+))$/.test(baseUrl)) return baseUrl;
+  else throw new Error("[Dymo API] Invalid URL. It must be https://api.tpeoficial.com or start with http://localhost or http://dymoapi followed by a port.");
+};
+const getPrayerTimes = async (axiosClient, data) => {
+  const { lat, lon } = data;
+  if (lat === void 0 || lon === void 0) throw customError(1e3, "You must provide a latitude and longitude.");
+  try {
+    const response = await axiosClient.get("/public/islam/prayertimes", { params: data });
+    return response.data;
+  } catch (error) {
+    throw customError(5e3, error.response?.data?.message || error.message);
+  }
+};
+const isValidPwd = async (axiosClient, data) => {
+  let { email, password, bannedWords, min, max } = data;
+  if (password === void 0) throw customError(1e3, "You must specify at least the password.");
+  const params = { password: encodeURIComponent(password) };
+  if (email) {
+    if (!/^[a-zA-Z0-9._\-+]+@?[a-zA-Z0-9.-]+\.[a-zA-Z]{2,4}$/.test(email)) throw customError(1500, "If you provide an email address it must be valid.");
+    params.email = encodeURIComponent(email);
+  }
+  if (bannedWords) {
+    if (typeof bannedWords === "string") bannedWords = bannedWords.slice(1, -1).trim().split(",").map((item) => item.trim());
+    if (!Array.isArray(bannedWords) || bannedWords.length > 10) throw customError(1500, "If you provide a list of banned words; the list may not exceed 10 words and must be of array type.");
+    if (!bannedWords.every((word) => typeof word === "string") || new Set(bannedWords).size !== bannedWords.length) throw customError(1500, "If you provide a list of banned words; all elements must be non-repeated strings.");
+    params.bannedWords = bannedWords;
+  }
+  if (min !== void 0 && (!Number.isInteger(min) || min < 8 || min > 32)) throw customError(1500, "If you provide a minimum it must be valid.");
+  if (max !== void 0 && (!Number.isInteger(max) || max < 32 || max > 100)) throw customError(1500, "If you provide a maximum it must be valid.");
+  if (min !== void 0) params.min = min;
+  if (max !== void 0) params.max = max;
+  try {
+    const response = await axiosClient.get("/public/validPwd", { params });
+    return response.data;
+  } catch (error) {
+    throw customError(5e3, error.response?.data?.message || error.message);
+  }
+};
+const satinize = async (axiosClient, input) => {
+  if (input === void 0) throw customError(1e3, "You must specify at least the input.");
+  try {
+    const response = await axiosClient.get("/public/inputSatinizer", { params: { input: encodeURIComponent(input) } });
+    return response.data;
+  } catch (error) {
+    throw customError(5e3, error.response?.data?.message || error.message);
+  }
+};
+const extractWithTextly = async (axiosClient, data) => {
+  if (!axiosClient.defaults.headers?.Authorization) throw customError(3e3, "Invalid private token.");
+  if (!data.data) throw customError(1500, "No data provided.");
+  if (!data.format) throw customError(1500, "No format provided.");
+  try {
+    const response = await axiosClient.post("/private/textly/extract", data, { headers: { "Content-Type": "application/json" } });
+    return response.data;
+  } catch (error) {
+    throw customError(5e3, error.response?.data?.message || error.message);
+  }
+};
+const getRandom = async (axiosClient, data) => {
+  if (!axiosClient.defaults.headers?.Authorization) throw customError(3e3, "Invalid private token.");
+  if (!data.min || !data.max) throw customError(1500, "Both 'min' and 'max' parameters must be defined.");
+  if (data.min >= data.max) throw customError(1500, "'min' must be less than 'max'.");
+  if (data.min < -1e9 || data.min > 1e9) throw customError(1500, "'min' must be an integer in the interval [-1000000000}, 1000000000].");
+  if (data.max < -1e9 || data.max > 1e9) throw customError(1500, "'max' must be an integer in the interval [-1000000000}, 1000000000].");
+  try {
+    const response = await axiosClient.post("/private/srng", data, { headers: { "Content-Type": "application/json" } });
+    return response.data;
+  } catch (error) {
+    throw customError(5e3, error.response?.data?.message || error.message);
+  }
+};
+const isValidIP = async (axiosClient, ip, rules) => {
+  if (!axiosClient.defaults.headers?.Authorization) throw customError(3e3, "Invalid private token.");
+  if (rules.deny.length === 0) throw customError(1500, "You must provide at least one deny rule.");
+  if (rules.mode === "DRY_RUN") {
+    console.warn("[Dymo API] DRY_RUN mode is enabled. No requests with real data will be processed until you switch to LIVE mode.");
+    return {
+      ip,
+      allow: true,
+      reasons: [],
+      response: "CHANGE TO LIVE MODE"
+    };
+  }
+  try {
+    const responseIP = (await axiosClient.post("/private/secure/verify", {
+      ip,
+      plugins: [
+        rules.deny.includes("TOR_NETWORK") ? "torNetwork" : void 0,
+        rules.deny.includes("HIGH_RISK_SCORE") ? "riskScore" : void 0
+      ].filter(Boolean)
+    }, { headers: { "Content-Type": "application/json" } })).data.ip;
+    let reasons = [];
+    if (rules.deny.includes("INVALID") && !responseIP.valid) {
+      return {
+        ip: responseIP.ip,
+        allow: false,
+        reasons: ["INVALID"],
+        response: responseIP
+      };
     }
-    ;
-    /**
-     * Validates the given email against the configured rules.
-     *
-     * This method requires either the root API key or the API key to be set.
-     * If neither is set, it will throw an error.
-     *
-     * @param {string} [email] - Email address to validate.
-     * @param {NegativeEmailRules[]} [rules] - Optional rules for validation. Some rules are premium features.
-     * @important
-     * **⚠️ NO_MX_RECORDS, HIGH_RISK_SCORE and NO_REACHABLE are [PREMIUM](https://docs.tpeoficial.com/docs/dymo-api/private/data-verifier) features.**
-     * @returns {Promise<Interfaces.EmailValidatorResponse>} Resolves with the validation response.
-     * @throws Will throw an error if validation cannot be performed.
-     *
-     * @example
-     * const valid = await dymoClient.isValidEmail("user@example.com", { deny: ["FRAUD", "NO_MX_RECORDS"] });
-     *
-     * @see [Documentation](https://docs.tpeoficial.com/docs/dymo-api/private/email-validation)
-     */
-    async isValidEmail(email, rules = this.rules.email) {
-        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);
+    if (rules.deny.includes("FRAUD") && responseIP.fraud) reasons.push("FRAUD");
+    if (rules.deny.includes("TOR_NETWORK") && responseIP.plugins.torNetwork) reasons.push("TOR_NETWORK");
+    if (rules.deny.includes("HIGH_RISK_SCORE") && responseIP.plugins.riskScore >= 80) reasons.push("HIGH_RISK_SCORE");
+    for (const rule of rules.deny) {
+      if (rule.startsWith("COUNTRY:")) {
+        const block = rule.split(":")[1];
+        if (responseIP.countryCode === block) reasons.push(`COUNTRY:${block}`);
+      }
     }
-    ;
-    /**
-     * Validates the given IP against the configured rules.
-     *
-     * This method requires either the root API key or the API key to be set.
-     * If neither is set, it will throw an error.
-     *
-     * @param {string} [ip] - IP address to validate.
-     * @param {NegativeEmailRules[]} [rules] - Optional rules for validation. Some rules are premium features.
-     * @important
-     * **⚠️ TOR_NETWORK and HIGH_RISK_SCORE are [PREMIUM](https://docs.tpeoficial.com/docs/dymo-api/private/data-verifier) features.**
-     * @returns {Promise<Interfaces.IPValidatorResponse>} Resolves with the validation response.
-     * @throws Will throw an error if validation cannot be performed.
-     *
-     * @example
-     * const valid = await isValidIP("52.94.236.248", { deny: ["FRAUD", "TOR_NETWORK", "COUNTRY:RU"] });
-     *
-     * @see [Documentation](https://docs.tpeoficial.com/docs/dymo-api/private/ip-validation)
-     */
-    async isValidIP(ip, rules = this.rules.ip) {
-        return await PrivateAPI.isValidIP(this.axiosClient, ip, rules);
+    return {
+      ip: responseIP.ip,
+      allow: reasons.length === 0,
+      reasons,
+      response: responseIP
+    };
+  } catch (error) {
+    const statusCode = error.response?.status || 500;
+    const errorMessage = error.response?.data?.message || error.message;
+    const errorDetails = JSON.stringify(error.response?.data || {});
+    throw customError(5e3, `Error ${statusCode}: ${errorMessage}. Details: ${errorDetails}`);
+  }
+};
+const isValidPhone = async (axiosClient, phone, rules) => {
+  if (!axiosClient.defaults.headers?.Authorization) throw customError(3e3, "Invalid private token.");
+  if (rules.deny.length === 0) throw customError(1500, "You must provide at least one deny rule.");
+  if (rules.mode === "DRY_RUN") {
+    console.warn("[Dymo API] DRY_RUN mode is enabled. No requests with real data will be processed until you switch to LIVE mode.");
+    return {
+      phone,
+      allow: true,
+      reasons: [],
+      response: "CHANGE TO LIVE MODE"
+    };
+  }
+  try {
+    const responsePhone = (await axiosClient.post("/private/secure/verify", {
+      phone,
+      plugins: [
+        rules.deny.includes("HIGH_RISK_SCORE") ? "riskScore" : void 0
+      ].filter(Boolean)
+    }, { headers: { "Content-Type": "application/json" } })).data.phone;
+    let reasons = [];
+    if (rules.deny.includes("INVALID") && !responsePhone.valid) {
+      return {
+        phone: responsePhone.phone,
+        allow: false,
+        reasons: ["INVALID"],
+        response: responsePhone
+      };
     }
-    ;
-    /**
-     * Validates the given email against the configured rules.
-     *
-     * This method requires either the root API key or the API key to be set.
-     * If neither is set, it will throw an error.
-     *
-     * @param {string} [phone] - Phone number to validate.
-     * @param {NegativePhoneRules[]} [rules] - Optional rules for validation. Some rules are premium features.
-     * @important
-     * **⚠️ HIGH_RISK_SCORE is a [PREMIUM](https://docs.tpeoficial.com/docs/dymo-api/private/data-verifier) feature.**
-     * @returns {Promise<Interfaces.EmailValidatorResponse>} Resolves with the validation response.
-     * @throws Will throw an error if validation cannot be performed.
-     *
-     * @example
-     * const valid = await dymoClient.isValidPhone("+34617509462", { deny: ["FRAUD", "INVALID"] });
-     *
-     * @see [Documentation](https://docs.tpeoficial.com/docs/dymo-api/private/phone-validation)
-     */
-    async isValidPhone(phone, rules = this.rules.phone) {
-        return await PrivateAPI.isValidPhone(this.axiosClient, phone, rules);
+    if (rules.deny.includes("FRAUD") && responsePhone.fraud) reasons.push("FRAUD");
+    if (rules.deny.includes("HIGH_RISK_SCORE") && responsePhone.plugins.riskScore >= 80) reasons.push("HIGH_RISK_SCORE");
+    for (const rule of rules.deny) {
+      if (rule.startsWith("COUNTRY:")) {
+        const block = rule.split(":")[1];
+        if (responsePhone.countryCode === block) reasons.push(`COUNTRY:${block}`);
+      }
     }
-    ;
-    /**
-     * Protects the given request against the configured rules.
-     *
-     * This method requires either the root API key or the API key to be set.
-     * If neither is set, it will throw an error.
-     *
-     * @param {Object} req - The request object to be protected.
-     * @param {Interfaces.WafRules} [rules] - Optional rules for protection. Some rules are premium features.
-     * @returns {Promise<Interfaces.HTTPRequest>} Resolves with the protected request.
-     * @important
-     * **⚠️ This is a [PREMIUM](https://docs.tpeoficial.com/docs/dymo-api/private/data-verifier) and BETA feature.**
-     * @throws Will throw an error if protection cannot be performed.
-     *
-     * @example
-     * const protectedReq = await dymoClient.protectReq(req);
-     *
-     * @see [Documentation](https://docs.tpeoficial.com/docs/dymo-api/private/data-verifier)
-    */
-    async protectReq(req, rules = this.rules.waf) {
-        return await PrivateAPI.protectReq(this.axiosClient, req, rules);
+    return {
+      phone: responsePhone.phone,
+      allow: reasons.length === 0,
+      reasons,
+      response: responsePhone
+    };
+  } catch (error) {
+    const statusCode = error.response?.status || 500;
+    const errorMessage = error.response?.data?.message || error.message;
+    const errorDetails = JSON.stringify(error.response?.data || {});
+    throw customError(5e3, `Error ${statusCode}: ${errorMessage}. Details: ${errorDetails}`);
+  }
+};
+const getUserAgent = (req) => {
+  return req.headers?.["user-agent"] || req.headers?.["User-Agent"];
+};
+const getIp = (req) => {
+  return req.ip || req.headers?.["x-forwarded-for"] || req.connection?.remoteAddress || req.socket?.remoteAddress || req.req?.socket?.remoteAddress;
+};
+const handleRequest = (req) => {
+  return {
+    body: req.body,
+    userAgent: getUserAgent(req),
+    ip: getIp(req)
+  };
+};
+const protectReq = async (axiosClient, req, rules) => {
+  if (!axiosClient.defaults.headers?.Authorization) throw customError(3e3, "Invalid private token.");
+  const reqData = handleRequest(req);
+  if (!reqData.userAgent || !reqData.ip) throw customError(1500, "You must provide user agent and ip.");
+  if (rules.mode === "DRY_RUN") {
+    console.warn("[Dymo API] DRY_RUN mode is enabled. No requests with real data will be processed until you switch to LIVE mode.");
+    return {
+      ip: reqData.ip,
+      userAgent: reqData.userAgent,
+      allow: true,
+      reasons: []
+    };
+  }
+  try {
+    const response = await axiosClient.post("/private/waf/verifyRequest", {
+      ip: reqData.ip,
+      userAgent: reqData.userAgent,
+      allowBots: rules.allowBots,
+      deny: rules.deny
+    }, { headers: { "Content-Type": "application/json" } });
+    return response.data;
+  } catch (error) {
+    const statusCode = error.response?.status || 500;
+    const errorMessage = error.response?.data?.message || error.message;
+    const errorDetails = JSON.stringify(error.response?.data || {});
+    throw customError(5e3, `Error ${statusCode}: ${errorMessage}. Details: ${errorDetails}`);
+  }
+};
+const fs = {};
+const convertTailwindToInlineCss = (htmlContent) => {
+  return htmlContent.replace(/class="([^"]+)"( style="([^"]+)")?/g, (match, classList, _, existingStyle) => {
+    const compiledStyles = twi(classList, { minify: true, merge: true });
+    return match.replace(/class="[^"]+"/, "").replace(/ style="[^"]+"/, "").concat(` style="${existingStyle ? `${existingStyle.trim().slice(0, -1)}; ${compiledStyles}` : compiledStyles}"`);
+  });
+};
+const sendEmail = async (axiosClient, data) => {
+  if (!axiosClient.defaults.headers?.Authorization) throw customError(3e3, "Invalid private token.");
+  if (!data.from) throw customError(1500, "You must provide an email address from which the following will be sent.");
+  if (!data.to) throw customError(1500, "You must provide an email to be sent to.");
+  if (!data.subject) throw customError(1500, "You must provide a subject for the email to be sent.");
+  if (!data.html && !data.react && !React.isValidElement(data.react)) throw customError(1500, "You must provide HTML or a React component.");
+  if (data.html && data.react) throw customError(1500, "You must provide only HTML or a React component, not both.");
+  try {
+    if (data.react) {
+      data.html = await render(data.react);
+      delete data.react;
     }
-    /**
-     * Sends an email using the configured email client settings.
-     *
-     * This method requires either the root API key or the server email config to be set.
-     * If neither is set, it will throw an error.
-     *
-     * @param {Object} data - The email data to be sent.
-     * @param {string} data.from - The email address from which the email will be sent.
-     * @param {string} data.to - The email address to which the email will be sent.
-     * @param {string} data.subject - The subject of the email.
-     * @param {string} [data.html] - The HTML content of the email.
-     * @param {React.ReactElement} [data.react] - The React component to be rendered as the email content.
-     * @param {Object} [data.options] - Content configuration options.
-     * @param {"high" | "normal" | "low" | undefined} [data.options.priority="normal"] - Email priority (default: normal).
-     * @param {boolean} [data.options.waitToResponse=true] - Wait until the email is sent (default: true).
-     * @param {boolean} [data.options.composeTailwindClasses] - Whether to compose tailwind classes.
-     * @param {Attachment[]} [data.attachments] - An array of attachments to be included in the email.
-     * @param {string} data.attachments[].filename - The name of the attached file.
-     * @param {string} [data.attachments[].path] - The path or URL of the attached file. Either this or `content` must be provided.
-     * @param {Buffer} [data.attachments[].content] - The content of the attached file as a Buffer. Either this or `path` must be provided.
-     * @param {string} [data.attachments[].cid] - The CID (Content-ID) of the attached file, used for inline images.
-     * @returns {Promise<Interfaces.EmailStatus>} A promise that resolves to the response from the server.
-     * @throws Will throw an error if there is an issue with the email sending process.
-     *
-     * [Documentation](https://docs.tpeoficial.com/docs/dymo-api/private/sender-send-email/getting-started)
-     */
-    async sendEmail(data) {
-        if (!this.serverEmailConfig && !this.rootApiKey)
-            console.error(`[${config.lib.name}] You must configure the email client settings.`);
-        return await PrivateAPI.sendEmail(this.axiosClient, { serverEmailConfig: this.serverEmailConfig, ...data });
+    if (data.options && data.options.composeTailwindClasses) {
+      data.html = convertTailwindToInlineCss(data.html);
+      delete data.options.composeTailwindClasses;
     }
-    ;
-    /**
-     * Generates a random number between the provided min and max values.
-     *
-     * This method requires either the root API key or the API key to be set.
-     * If neither is set, it will throw an error.
-     *
-     * @param {Interfaces.SRNG} data - The data to be sent.
-     * @param {number} data.min - The minimum value of the range.
-     * @param {number} data.max - The maximum value of the range.
-     * @param {number} [data.quantity] - The number of random values to generate. Defaults to 1 if not provided.
-     * @returns {Promise<Interfaces.SRNSummary>} A promise that resolves to the response from the server.
-     * @throws Will throw an error if there is an issue with the random number generation process.
-     *
-     * [Documentation](https://docs.tpeoficial.com/docs/dymo-api/private/secure-random-number-generator)
-     */
-    async getRandom(data) {
-        return await PrivateAPI.getRandom(this.axiosClient, data);
+  } catch (error) {
+    throw customError(1500, `An error occurred while rendering your React component. Details: ${error}`);
+  }
+  try {
+    let totalSize = 0;
+    if (data.attachments && Array.isArray(data.attachments)) {
+      const processedAttachments = await Promise.all(
+        data.attachments.map(async (attachment) => {
+          if (attachment.path && attachment.content || !attachment.path && !attachment.content) throw customError(1500, "You must provide either 'path' or 'content', not both.");
+          let contentBuffer;
+          if (attachment.path) contentBuffer = await fs.readFile(path.resolve(attachment.path));
+          else if (attachment.content) contentBuffer = attachment.content instanceof Buffer ? attachment.content : Buffer.from(attachment.content);
+          totalSize += Buffer.byteLength(contentBuffer);
+          if (totalSize > 40 * 1024 * 1024) throw customError(1500, "Attachments exceed the maximum allowed size of 40 MB.");
+          return {
+            filename: attachment.filename || path.basename(attachment.path || ""),
+            content: contentBuffer,
+            cid: attachment.cid || attachment.filename
+          };
+        })
+      );
+      data.attachments = processedAttachments;
     }
-    ;
-    /**
-     * Extracts structured data from a given string using Textly.
-     *
-     * This method requires either the root API key or the API key to be set.
-     * If neither is set, it will throw an error.
-     *
-     * @param {Interfaces.ExtractWithTextly} data - The data to be sent, containing the string to be processed and the format schema.
-     * @returns {Promise<any>} A promise that resolves to the extracted structured data.
-     * @throws Will throw an error if there is an issue with the extraction process.
-     *
-     * [Documentation](https://docs.tpeoficial.com/docs/dymo-api/private/textly/text-extraction)
-     */
-    async extractWithTextly(data) {
-        return await PrivateAPI.extractWithTextly(this.axiosClient, data);
+    const response = await axiosClient.post("/private/sender/sendEmail", data);
+    return response.data;
+  } catch (error) {
+    throw customError(5e3, error.response?.data?.message || error.message);
+  }
+};
+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 !== void 0 && 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 > 3e5) delete this.tracker[clientId];
+    });
+  }
+}
+class ResilienceManager {
+  constructor(config2 = {}, clientId = "default") {
+    this.config = {
+      fallbackEnabled: config2.fallbackEnabled ?? false,
+      retryAttempts: Math.max(0, config2.retryAttempts ?? 2),
+      // Number of additional retries
+      retryDelay: Math.max(0, config2.retryDelay ?? 1e3)
+    };
+    this.clientId = clientId;
+    this.rateLimitManager = RateLimitManager.getInstance();
+  }
+  async executeWithResilience(axiosClient, requestConfig, fallbackData) {
+    let lastError;
+    const totalAttempts = 1 + this.config.retryAttempts;
+    this.rateLimitManager.clearExpiredLimits();
+    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 * 1e3);
+      }
     }
-    ;
-    // FUNCTIONS / Public.
-    /**
-     * Retrieves the prayer times for the given location.
-     *
-     * This method requires a latitude and longitude to be provided in the
-     * data object. If either of these are not provided, it will throw an error.
-     *
-     * @param {Object} data - The data to be sent.
-     * @param {number} data.lat - The latitude of the location.
-     * @param {number} data.lon - The longitude of the location.
-     * @returns {Promise<Interfaces.CountryPrayerTimes | { error: string }>} A promise that resolves to the response from the server.
-     * @throws Will throw an error if there is an issue with the prayer times retrieval process.
-     *
-     * [Documentation](https://docs.tpeoficial.com/docs/dymo-api/public/prayertimes)
-     */
-    async getPrayerTimes(data) {
-        return await PublicAPI.getPrayerTimes(this.axiosClient, data);
+    for (let attempt = 1; attempt <= totalAttempts; attempt++) {
+      try {
+        const response = await axiosClient.request(requestConfig);
+        this.rateLimitManager.updateRateLimit(this.clientId, response.headers);
+        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 * 1e3);
+          }
+          throw new Error(`Rate limited (429) - not retrying`);
+        }
+        return response.data;
+      } catch (error) {
+        lastError = error;
+        let shouldRetry = this.shouldRetry(error);
+        const isLastAttempt = attempt === totalAttempts;
+        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);
+      }
     }
-    ;
-    /**
-     * Satinizes the input, replacing any special characters with their HTML
-     * entities.
-     *
-     * @deprecated Use `satinize` instead. This feature will be removed soon.
-     * @param {Object} data - The data to be sent.
-     * @param {string} data.input - The input to be satinized.
-     * @returns {Promise<Interfaces.SatinizedInputAnalysis>} A promise that resolves to the response from the server.
-     * @throws Will throw an error if there is an issue with the satinization process.
-     *
-     * [Documentation](https://docs.tpeoficial.com/docs/dymo-api/public/input-satinizer)
-     */
-    async satinizer(data) {
-        return await PublicAPI.satinize(this.axiosClient, data.input);
+    throw lastError;
+  }
+  shouldRetry(error) {
+    const statusCode = error.response?.status;
+    const isNetworkError = !error.response && error.code !== "ECONNABORTED";
+    const isServerError = statusCode && statusCode >= 500;
+    return isNetworkError || isServerError;
+  }
+  sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+  }
+  getConfig() {
+    return { ...this.config };
+  }
+  getClientId() {
+    return this.clientId;
+  }
+}
+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}`);
     }
-    ;
-    /**
-     * Satinizes the input, replacing any special characters with their HTML
-     * entities.
-     *
-     * @param {Object} data - The data to be sent.
-     * @param {string} data.input - The input to be satinized.
-     * @returns {Promise<Interfaces.SatinizedInputAnalysis>} A promise that resolves to the response from the server.
-     * @throws Will throw an error if there is an issue with the satinization process.
-     *
-     * [Documentation](https://docs.tpeoficial.com/docs/dymo-api/public/input-satinizer)
-     */
-    async satinize(input) {
-        return await PublicAPI.satinize(this.axiosClient, input);
+  }
+  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;
+    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;
+    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;
     }
-    ;
-    /**
-     * Validates a password based on the given parameters.
-     *
-     * This method requires the password to be provided in the data object.
-     * If the password is not provided, it will throw an error. The method
-     * will validate the password against the following rules:
-     *  - The password must be at least 8 characters long.
-     *  - The password must be at most 32 characters long.
-     *  - The password must contain at least one uppercase letter.
-     *  - The password must contain at least one lowercase letter.
-     *  - The password must contain at least one number.
-     *  - The password must contain at least one special character.
-     *  - The password must not contain any of the given banned words.
-     *
-     * @param {Object} data - The data to be sent.
-     * @param {number} [data.min] - Minimum length of the password. Defaults to 8 if not provided.
-     * @param {number} [data.max] - Maximum length of the password. Defaults to 32 if not provided.
-     * @param {string} [data.email] - Optional email associated with the password.
-     * @param {string} data.password - The password to be validated.
-     * @param {string | string[]} [data.bannedWords] - The list of banned words that the password must not contain.
-     * @returns {Promise<Interfaces.PasswordValidationResult>} A promise that resolves to the response from the server.
-     * @throws Will throw an error if there is an issue with the password validation process.
-     *
-     * [Documentation](https://docs.tpeoficial.com/docs/dymo-api/public/password-validator)
-     */
-    async isValidPwd(data) {
-        return await PublicAPI.isValidPwd(this.axiosClient, data);
+    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
+    }));
+    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"
+        }
+      ]
+    };
+  }
+}
+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.
+       * @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 = void 0,
+    rules = {},
+    resilience = {}
+  } = {}) {
+    this.rules = {
+      email: { mode: "LIVE", deny: ["FRAUD", "INVALID", "NO_MX_RECORDS", "NO_REPLY_EMAIL"] },
+      ip: { mode: "LIVE", deny: ["FRAUD", "INVALID", "TOR_NETWORK"] },
+      phone: { mode: "LIVE", deny: ["FRAUD", "INVALID"] },
+      sensitiveInfo: { mode: "LIVE", deny: ["EMAIL", "PHONE", "CREDIT_CARD"] },
+      waf: { mode: "LIVE", allowBots: ["CURL", "CATEGORY:SEARCH_ENGINE", "CATEGORY:PREVIEW"], deny: ["FRAUD", "TOR_NETWORK"] },
+      ...rules
+    };
+    this.rootApiKey = rootApiKey;
+    this.apiKey = apiKey;
+    this.serverEmailConfig = serverEmailConfig;
+    this.baseUrl = baseUrl;
+    const clientId = this.apiKey || this.rootApiKey || "anonymous";
+    this.resilienceManager = new ResilienceManager(resilience, clientId);
+    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.33"
+      }
+    });
+    if (this.rootApiKey || this.apiKey) this.axiosClient.defaults.headers.Authorization = `Bearer ${this.rootApiKey || this.apiKey}`;
+  }
+  getEmailPlugins(rules) {
+    return [
+      rules.deny.includes("NO_MX_RECORDS") ? "mxRecords" : void 0,
+      rules.deny.includes("NO_REACHABLE") ? "reachable" : void 0,
+      rules.deny.includes("HIGH_RISK_SCORE") ? "riskScore" : void 0,
+      rules.deny.includes("NO_GRAVATAR") ? "gravatar" : void 0
+    ].filter(Boolean);
+  }
+  // FUNCTIONS / Private.
+  /**
+   * Validates the given data against the configured validation settings.
+   *
+   * This method requires either the root API key or the API key to be set.
+   * If neither is set, it will throw an error.
+   *
+   * @deprecated Use `isValidDataRaw` instead. This feature will be modified soon.
+   * @param {Object} data - The data to be validated.
+   * @param {string} [data.url] - Optional URL to be validated.
+   * @param {string} [data.email] - Optional email address to be validated.
+   * @param {Interfaces.PhoneData} [data.phone] - Optional phone number data to be validated.
+   * @param {string} [data.domain] - Optional domain name to be validated.
+   * @param {string|Interfaces.CreditCardData} [data.creditCard] - Optional credit card number or data to be validated.
+   * @param {string} [data.ip] - Optional IP address to be validated.
+   * @param {string} [data.wallet] - Optional wallet address to be validated.
+   * @param {string} [data.userAgent] - Optional user agent string to be validated.
+   * @param {string} [data.iban] - Optional IBAN to be validated.
+   * @param {Interfaces.VerifyPlugins[]} [data.plugins] - Optional array of verification plugins to be used.
+   * @returns {Promise<Interfaces.DataValidationAnalysis>} A promise that resolves to the response from the server.
+   * @throws Will throw an error if there is an issue with the validation process.
+   *
+   * [Documentation](https://docs.tpeoficial.com/docs/dymo-api/private/data-verifier)
+   */
+  async isValidData(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 : void 0
+    );
+  }
+  /**
+   * Validates the given data against the configured validation settings.
+   *
+   * This method requires either the root API key or the API key to be set.
+   * If neither is set, it will throw an error.
+   *
+   * @param {Object} data - The data to be validated.
+   * @param {string} [data.url] - Optional URL to be validated.
+   * @param {string} [data.email] - Optional email address to be validated.
+   * @param {Interfaces.PhoneData} [data.phone] - Optional phone number data to be validated.
+   * @param {string} [data.domain] - Optional domain name to be validated.
+   * @param {string|Interfaces.CreditCardData} [data.creditCard] - Optional credit card number or data to be validated.
+   * @param {string} [data.ip] - Optional IP address to be validated.
+   * @param {string} [data.wallet] - Optional wallet address to be validated.
+   * @param {string} [data.userAgent] - Optional user agent string to be validated.
+   * @param {string} [data.iban] - Optional IBAN to be validated.
+   * @param {Interfaces.VerifyPlugins[]} [data.plugins] - Optional array of verification plugins to be used.
+   * @returns {Promise<Interfaces.DataValidationAnalysis>} A promise that resolves to the response from the server.
+   * @throws Will throw an error if there is an issue with the validation process.
+   *
+   * [Documentation](https://docs.tpeoficial.com/docs/dymo-api/private/data-verifier)
+   */
+  async isValidDataRaw(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 : void 0
+    );
+  }
+  /**
+   * Validates the given email against the configured rules.
+   *
+   * This method requires either the root API key or the API key to be set.
+   * If neither is set, it will throw an error.
+   *
+   * @param {string} [email] - Email address to validate.
+   * @param {NegativeEmailRules[]} [rules] - Optional rules for validation. Some rules are premium features.
+   * @important
+   * **⚠️ NO_MX_RECORDS, HIGH_RISK_SCORE and NO_REACHABLE are [PREMIUM](https://docs.tpeoficial.com/docs/dymo-api/private/data-verifier) features.**
+   * @returns {Promise<Interfaces.EmailValidatorResponse>} Resolves with the validation response.
+   * @throws Will throw an error if validation cannot be performed.
+   *
+   * @example
+   * const valid = await dymoClient.isValidEmail("user@example.com", { deny: ["FRAUD", "NO_MX_RECORDS"] });
+   * 
+   * @see [Documentation](https://docs.tpeoficial.com/docs/dymo-api/private/email-validation)
+   */
+  async isValidEmail(email, rules = this.rules.email) {
+    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 : void 0
+    );
+  }
+  /**
+   * Validates the given IP against the configured rules.
+   *
+   * This method requires either the root API key or the API key to be set.
+   * If neither is set, it will throw an error.
+   *
+   * @param {string} [ip] - IP address to validate.
+   * @param {NegativeEmailRules[]} [rules] - Optional rules for validation. Some rules are premium features.
+   * @important
+   * **⚠️ TOR_NETWORK and HIGH_RISK_SCORE are [PREMIUM](https://docs.tpeoficial.com/docs/dymo-api/private/data-verifier) features.**
+   * @returns {Promise<Interfaces.IPValidatorResponse>} Resolves with the validation response.
+   * @throws Will throw an error if validation cannot be performed.
+   *
+   * @example
+   * const valid = await isValidIP("52.94.236.248", { deny: ["FRAUD", "TOR_NETWORK", "COUNTRY:RU"] });
+   * 
+   * @see [Documentation](https://docs.tpeoficial.com/docs/dymo-api/private/ip-validation)
+   */
+  async isValidIP(ip, rules = this.rules.ip) {
+    return await isValidIP(this.axiosClient, ip, rules);
+  }
+  /**
+   * Validates the given email against the configured rules.
+   *
+   * This method requires either the root API key or the API key to be set.
+   * If neither is set, it will throw an error.
+   *
+   * @param {string} [phone] - Phone number to validate.
+   * @param {NegativePhoneRules[]} [rules] - Optional rules for validation. Some rules are premium features.
+   * @important
+   * **⚠️ HIGH_RISK_SCORE is a [PREMIUM](https://docs.tpeoficial.com/docs/dymo-api/private/data-verifier) feature.**
+   * @returns {Promise<Interfaces.EmailValidatorResponse>} Resolves with the validation response.
+   * @throws Will throw an error if validation cannot be performed.
+   *
+   * @example
+   * const valid = await dymoClient.isValidPhone("+34617509462", { deny: ["FRAUD", "INVALID"] });
+   * 
+   * @see [Documentation](https://docs.tpeoficial.com/docs/dymo-api/private/phone-validation)
+   */
+  async isValidPhone(phone, rules = this.rules.phone) {
+    return await isValidPhone(this.axiosClient, phone, rules);
+  }
+  /**
+   * Protects the given request against the configured rules.
+   *
+   * This method requires either the root API key or the API key to be set.
+   * If neither is set, it will throw an error.
+   *
+   * @param {Object} req - The request object to be protected.
+   * @param {Interfaces.WafRules} [rules] - Optional rules for protection. Some rules are premium features.
+   * @returns {Promise<Interfaces.HTTPRequest>} Resolves with the protected request.
+   * @important
+   * **⚠️ This is a [PREMIUM](https://docs.tpeoficial.com/docs/dymo-api/private/data-verifier) and BETA feature.**
+   * @throws Will throw an error if protection cannot be performed.
+   *
+   * @example
+   * const protectedReq = await dymoClient.protectReq(req);
+   * 
+   * @see [Documentation](https://docs.tpeoficial.com/docs/dymo-api/private/data-verifier)
+  */
+  async protectReq(req, rules = this.rules.waf) {
+    return await protectReq(this.axiosClient, req, rules);
+  }
+  /**
+   * Sends an email using the configured email client settings.
+   *
+   * This method requires either the root API key or the server email config to be set.
+   * If neither is set, it will throw an error.
+   *
+   * @param {Object} data - The email data to be sent.
+   * @param {string} data.from - The email address from which the email will be sent.
+   * @param {string} data.to - The email address to which the email will be sent.
+   * @param {string} data.subject - The subject of the email.
+   * @param {string} [data.html] - The HTML content of the email.
+   * @param {React.ReactElement} [data.react] - The React component to be rendered as the email content.
+   * @param {Object} [data.options] - Content configuration options.
+   * @param {"high" | "normal" | "low" | undefined} [data.options.priority="normal"] - Email priority (default: normal).
+   * @param {boolean} [data.options.waitToResponse=true] - Wait until the email is sent (default: true).
+   * @param {boolean} [data.options.composeTailwindClasses] - Whether to compose tailwind classes.
+   * @param {Attachment[]} [data.attachments] - An array of attachments to be included in the email.
+   * @param {string} data.attachments[].filename - The name of the attached file.
+   * @param {string} [data.attachments[].path] - The path or URL of the attached file. Either this or `content` must be provided.
+   * @param {Buffer} [data.attachments[].content] - The content of the attached file as a Buffer. Either this or `path` must be provided.
+   * @param {string} [data.attachments[].cid] - The CID (Content-ID) of the attached file, used for inline images.
+   * @returns {Promise<Interfaces.EmailStatus>} A promise that resolves to the response from the server.
+   * @throws Will throw an error if there is an issue with the email sending process.
+   *
+   * [Documentation](https://docs.tpeoficial.com/docs/dymo-api/private/sender-send-email/getting-started)
+   */
+  async sendEmail(data) {
+    if (!this.serverEmailConfig && !this.rootApiKey) console.error(`[${config.lib.name}] You must configure the email client settings.`);
+    return await sendEmail(this.axiosClient, { serverEmailConfig: this.serverEmailConfig, ...data });
+  }
+  /**
+   * Generates a random number between the provided min and max values.
+   *
+   * This method requires either the root API key or the API key to be set.
+   * If neither is set, it will throw an error.
+   *
+   * @param {Interfaces.SRNG} data - The data to be sent.
+   * @param {number} data.min - The minimum value of the range.
+   * @param {number} data.max - The maximum value of the range.
+   * @param {number} [data.quantity] - The number of random values to generate. Defaults to 1 if not provided.
+   * @returns {Promise<Interfaces.SRNSummary>} A promise that resolves to the response from the server.
+   * @throws Will throw an error if there is an issue with the random number generation process.
+   *
+   * [Documentation](https://docs.tpeoficial.com/docs/dymo-api/private/secure-random-number-generator)
+   */
+  async getRandom(data) {
+    return await getRandom(this.axiosClient, data);
+  }
+  /**
+   * Extracts structured data from a given string using Textly.
+   *
+   * This method requires either the root API key or the API key to be set.
+   * If neither is set, it will throw an error.
+   *
+   * @param {Interfaces.ExtractWithTextly} data - The data to be sent, containing the string to be processed and the format schema.
+   * @returns {Promise<any>} A promise that resolves to the extracted structured data.
+   * @throws Will throw an error if there is an issue with the extraction process.
+   *
+   * [Documentation](https://docs.tpeoficial.com/docs/dymo-api/private/textly/text-extraction)
+   */
+  async extractWithTextly(data) {
+    return await extractWithTextly(this.axiosClient, data);
+  }
+  // FUNCTIONS / Public.
+  /**
+   * Retrieves the prayer times for the given location.
+   *
+   * This method requires a latitude and longitude to be provided in the
+   * data object. If either of these are not provided, it will throw an error.
+   *
+   * @param {Object} data - The data to be sent.
+   * @param {number} data.lat - The latitude of the location.
+   * @param {number} data.lon - The longitude of the location.
+   * @returns {Promise<Interfaces.CountryPrayerTimes | { error: string }>} A promise that resolves to the response from the server.
+   * @throws Will throw an error if there is an issue with the prayer times retrieval process.
+   *
+   * [Documentation](https://docs.tpeoficial.com/docs/dymo-api/public/prayertimes)
+   */
+  async getPrayerTimes(data) {
+    return await getPrayerTimes(this.axiosClient, data);
+  }
+  /**
+   * Satinizes the input, replacing any special characters with their HTML
+   * entities.
+   *
+   * @deprecated Use `satinize` instead. This feature will be removed soon.
+   * @param {Object} data - The data to be sent.
+   * @param {string} data.input - The input to be satinized.
+   * @returns {Promise<Interfaces.SatinizedInputAnalysis>} A promise that resolves to the response from the server.
+   * @throws Will throw an error if there is an issue with the satinization process.
+   *
+   * [Documentation](https://docs.tpeoficial.com/docs/dymo-api/public/input-satinizer)
+   */
+  async satinizer(data) {
+    return await satinize(this.axiosClient, data.input);
+  }
+  /**
+   * Satinizes the input, replacing any special characters with their HTML
+   * entities.
+   *
+   * @param {Object} data - The data to be sent.
+   * @param {string} data.input - The input to be satinized.
+   * @returns {Promise<Interfaces.SatinizedInputAnalysis>} A promise that resolves to the response from the server.
+   * @throws Will throw an error if there is an issue with the satinization process.
+   *
+   * [Documentation](https://docs.tpeoficial.com/docs/dymo-api/public/input-satinizer)
+   */
+  async satinize(input) {
+    return await satinize(this.axiosClient, input);
+  }
+  /**
+   * Validates a password based on the given parameters.
+   *
+   * This method requires the password to be provided in the data object.
+   * If the password is not provided, it will throw an error. The method
+   * will validate the password against the following rules:
+   *  - The password must be at least 8 characters long.
+   *  - The password must be at most 32 characters long.
+   *  - The password must contain at least one uppercase letter.
+   *  - The password must contain at least one lowercase letter.
+   *  - The password must contain at least one number.
+   *  - The password must contain at least one special character.
+   *  - The password must not contain any of the given banned words.
+   *
+   * @param {Object} data - The data to be sent.
+   * @param {number} [data.min] - Minimum length of the password. Defaults to 8 if not provided.
+   * @param {number} [data.max] - Maximum length of the password. Defaults to 32 if not provided.
+   * @param {string} [data.email] - Optional email associated with the password.
+   * @param {string} data.password - The password to be validated.
+   * @param {string | string[]} [data.bannedWords] - The list of banned words that the password must not contain.
+   * @returns {Promise<Interfaces.PasswordValidationResult>} A promise that resolves to the response from the server.
+   * @throws Will throw an error if there is an issue with the password validation process.
+   *
+   * [Documentation](https://docs.tpeoficial.com/docs/dymo-api/public/password-validator)
+   */
+  async isValidPwd(data) {
+    return await isValidPwd(this.axiosClient, data);
+  }
 }
-;
-export default DymoAPI;
+export {
+  DymoAPI as default
+};