dymo-api 1.0.11 → 1.0.13

package/.github/workflows/publish.yml

@@ -0,0 +1,30 @@
+name: Publish Package
+
+on:
+  push:
+    branches:
+      - main
+
+jobs:
+  publish:
+    runs-on: ubuntu-latest
+
+    steps:
+    - name: Checkout code
+      uses: actions/checkout@v3
+
+    - name: Set up Node.js
+      uses: actions/setup-node@v3
+      with:
+        node-version: "18"
+
+    - name: Install dependencies
+      run: npm install
+
+    - name: Build
+      run: npm run build
+
+    - name: Publish to npm
+      run: npm publish
+      env:
+        NODE_AUTH_TOKEN: ${{ secrets.NPM_TOKEN }}

package/dist/config.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const config = {
+    lib: {
+        name: "Dymo API",
+        dir: "dymo-api"
+    }
+};
+exports.default = config;

package/dist/dymo-api.js

@@ -0,0 +1,100 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DymoAPI = void 0;
+const axios_1 = __importDefault(require("axios"));
+const PrivateAPI = __importStar(require("./private-api"));
+const PublicAPI = __importStar(require("./public-api"));
+const config_1 = __importDefault(require("./config"));
+const customError = (code, message) => {
+    const error = new Error();
+    return Object.assign(error, { code, message: `[${config_1.default.lib.name}] ${message}` });
+};
+class DymoAPI {
+    constructor({ rootApiKey = null, apiKey = null }) {
+        this.rootApiKey = rootApiKey;
+        this.apiKey = apiKey;
+        this.tokensResponse = null;
+        this.lastFetchTime = null;
+        this.initializeTokens(); // Calls the function to obtain tokens when creating the object.
+    }
+    async getTokens() {
+        const currentTime = new Date();
+        if (this.tokensResponse && this.lastFetchTime && (currentTime.getTime() - this.lastFetchTime.getTime()) < 5 * 60 * 1000) {
+            console.log(`[${config_1.default.lib.name}] Using cached tokens response.`);
+            return this.tokensResponse;
+        }
+        const tokens = {};
+        if (this.rootApiKey)
+            tokens.root = `Bearer ${this.rootApiKey}`;
+        if (this.apiKey)
+            tokens.api = `Bearer ${this.apiKey}`;
+        try {
+            if (Object.keys(tokens).length === 0)
+                return;
+            const response = await axios_1.default.post("https://api.tpeoficial.com/v1/dvr/tokens", { tokens });
+            if (tokens.root && response.data.data.root === false)
+                throw customError(3000, "Invalid root token.");
+            if (tokens.api && response.data.data.api === false)
+                throw customError(3000, "Invalid API token.");
+            this.tokensResponse = response.data.data;
+            this.lastFetchTime = currentTime;
+            console.log(`[${config_1.default.lib.name}] Tokens initialized successfully.`);
+            return this.tokensResponse;
+        }
+        catch (error) {
+            throw customError(5000, error.message);
+        }
+    }
+    async initializeTokens() {
+        try {
+            await this.getTokens();
+        }
+        catch (error) {
+            throw customError(5000, `Error initializing tokens: ${error.message}`);
+        }
+    }
+    // FUNCTIONS / Private.
+    async isValidData(data) {
+        return await PrivateAPI.isValidData(this.apiKey, data);
+    }
+    // FUNCTIONS / Public.
+    async getPrayerTimes(data) {
+        return await PublicAPI.getPrayerTimes(data);
+    }
+    async inputSatinizer(data) {
+        return await PublicAPI.inputSatinizer(data);
+    }
+    async isValidPwd(data) {
+        return await PublicAPI.isValidPwd(data);
+    }
+    async newURLEncrypt(data) {
+        return await PublicAPI.newURLEncrypt(data);
+    }
+}
+exports.DymoAPI = DymoAPI;

package/dist/private-api.js

@@ -0,0 +1,38 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isValidData = void 0;
+const axios_1 = __importDefault(require("axios"));
+const config_1 = __importDefault(require("./config"));
+const customError = (code, message) => {
+    const error = new Error();
+    return Object.assign(error, { code, message: `[${config_1.default.lib.name}] ${message}` });
+};
+;
+;
+;
+const isValidData = async (token, data) => {
+    if (token === null)
+        throw customError(3000, "Invalid private token.");
+    let i = false;
+    for (const key in data) {
+        if (data.hasOwnProperty(key) && (key === "email" || key === "tel" || key === "domain" || key === "creditCard" || key === "ip")) {
+            i = true;
+            break;
+        }
+    }
+    if (!i)
+        throw customError(1500, "You must provide at least one parameter.");
+    try {
+        const response = await axios_1.default.post("https://api.tpeoficial.com/v1/private/secure/verify", data, {
+            headers: { "Authorization": token },
+        });
+        return response.data;
+    }
+    catch (error) {
+        throw customError(5000, error.message);
+    }
+};
+exports.isValidData = isValidData;

package/dist/public-api.js

@@ -0,0 +1,87 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.newURLEncrypt = exports.isValidPwd = exports.inputSatinizer = exports.getPrayerTimes = void 0;
+const axios_1 = __importDefault(require("axios"));
+const config_1 = __importDefault(require("./config"));
+const customError = (code, message) => {
+    const error = new Error();
+    return Object.assign(error, { code, message: `[${config_1.default.lib.name}] ${message}` });
+};
+const getPrayerTimes = async (data) => {
+    const { lat, lon } = data;
+    if (lat === undefined || lon === undefined)
+        throw customError(1000, "You must provide a latitude and longitude.");
+    try {
+        const response = await axios_1.default.get("https://api.tpeoficial.com/v1/public/islam/prayertimes", { params: data });
+        return response.data;
+    }
+    catch (error) {
+        throw customError(5000, error.message);
+    }
+};
+exports.getPrayerTimes = getPrayerTimes;
+const inputSatinizer = async (data) => {
+    const { input } = data;
+    if (input === undefined)
+        throw customError(1000, "You must specify at least the input.");
+    try {
+        const response = await axios_1.default.get("https://api.tpeoficial.com/v1/public/inputSatinizer", { params: { input: encodeURIComponent(input) } });
+        return response.data;
+    }
+    catch (error) {
+        throw customError(5000, error.message);
+    }
+};
+exports.inputSatinizer = inputSatinizer;
+const isValidPwd = async (data) => {
+    let { email, password, bannedWords, min, max } = data;
+    if (password === undefined)
+        throw customError(1000, "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 !== undefined && (!Number.isInteger(min) || min < 8 || min > 32))
+        throw customError(1500, "If you provide a minimum it must be valid.");
+    if (max !== undefined && (!Number.isInteger(max) || max < 32 || max > 100))
+        throw customError(1500, "If you provide a maximum it must be valid.");
+    if (min !== undefined)
+        params.min = min;
+    if (max !== undefined)
+        params.max = max;
+    try {
+        const response = await axios_1.default.get("https://api.tpeoficial.com/v1/public/validPwd", { params });
+        return response.data;
+    }
+    catch (error) {
+        throw customError(5000, error.message);
+    }
+};
+exports.isValidPwd = isValidPwd;
+const newURLEncrypt = async (data) => {
+    const { url } = data;
+    if (url === undefined || (!url.startsWith("https://") && !url.startsWith("http://")))
+        throw customError(1500, "You must provide a valid url.");
+    try {
+        const response = await axios_1.default.get("https://api.tpeoficial.com/v1/public/url-encrypt", { params: data });
+        return response.data;
+    }
+    catch (error) {
+        throw customError(5000, error.message);
+    }
+};
+exports.newURLEncrypt = newURLEncrypt;

package/index.d.ts

@@ -1,11 +1,11 @@
-declare module 'dymo-api' {
-    class Configuration {
-        constructor({ rootApiKey, apiKey }?: { rootApiKey?: string; apiKey?: string });
-        getTokens(): Promise<any>;
+declare module "dymo-api" {
+    interface ConfigurationOptions {
+        rootApiKey?: string;
+        apiKey?: string;
     }
 
     class DymoAPI {
-        constructor(configuration: Configuration);
+        constructor(configuration: ConfigurationOptions);
         initializeTokens(): Promise<void>;
         isValidData(data: any): Promise<any>;
         getPrayerTimes(data: any): Promise<any>;
@@ -14,5 +14,5 @@ declare module 'dymo-api' {
         newURLEncrypt(data: any): Promise<any>;
     }
 
-    export { Configuration, DymoAPI };
-}  
+    export { DymoAPI };
+};

package/index.js

@@ -1,20 +1,7 @@
-// This module is intended to unwrap Dymo API default export as named.
-// Keep top-level export same with static properties.
-// so that it can keep same with es module or cjs.
+import pkg from "./lib/dymo-api.cjs";
 
-/*const {
-    dymo
-} = dymoAPI;
+const { DymoAPI: _DymoAPI } = pkg;
 
-export {
-    dymoAPI as default
-}*/
-import pkg from './lib/dymo-api.cjs';
+export { _DymoAPI as DymoAPI };
 
-const { Configuration: _Configuration, DymoAPI: _DymoAPI } = pkg;
-
-export { _Configuration as Configuration, _DymoAPI as DymoAPI };
-
-if (typeof module !== 'undefined' && typeof module.exports !== 'undefined') {
-    module.exports = { Configuration: _Configuration, DymoAPI: _DymoAPI };
-}
+if (typeof module !== "undefined" && typeof module.exports !== "undefined") module.exports = { DymoAPI: _DymoAPI };

package/package.json

@@ -1,10 +1,12 @@
 {
   "name": "dymo-api",
-  "version": "1.0.11",
+  "version": "1.0.13",
   "description": "Flow system for Dymo API.",
-  "main": "index.js",
+  "main": "dist/index.js",
   "type": "module",
   "scripts": {
+    "build": "tsc",
+    "start": "ts-node src/dymo-api.ts",
     "test": "echo \"Error: no test specified\" && exit 1"
   },
   "repository": {
@@ -28,5 +30,11 @@
   "contributors": [
     "TPEOficial (https://github.com/TPEOficial)",
     "FJRG2007 (https://github.com/FJRG2007)"
-  ]
-}
+  ],
+  "devDependencies": {
+    "@types/axios": "^0.9.36",
+    "@types/node": "^22.0.2",
+    "ts-node": "^10.9.2",
+    "typescript": "^5.5.4"
+  }
+}

package/{config.cjs → src/config.ts}

@@ -1,6 +1,8 @@
-module.exports = {
+const config = {
     lib: {
         name: "Dymo API",
         dir: "dymo-api"
     }
-}
+};
+
+export default config;

package/src/dymo-api.ts

@@ -0,0 +1,97 @@
+import axios from "axios";
+import * as PrivateAPI from "./private-api";
+import * as PublicAPI from "./public-api";
+import config from "./config";
+
+const customError = (code: number, message: string): Error => {
+    const error = new Error();
+    return Object.assign(error, { code, message: `[${config.lib.name}] ${message}` });
+};
+
+interface TokensResponse {
+    root: boolean;
+    api: boolean;
+}
+
+interface Tokens {
+    root?: string;
+    api?: string;
+}
+
+class DymoAPI {
+    private rootApiKey: string | null;
+    private apiKey: string | null;
+    private tokensResponse: TokensResponse | null;
+    private lastFetchTime: Date | null;
+
+    constructor({ rootApiKey = null, apiKey = null }: { rootApiKey?: string | null; apiKey?: string | null }) {
+        this.rootApiKey = rootApiKey;
+        this.apiKey = apiKey;
+        this.tokensResponse = null;
+        this.lastFetchTime = null;
+        this.initializeTokens(); // Calls the function to obtain tokens when creating the object.
+    }
+
+    private async getTokens(): Promise<TokensResponse | undefined> {
+        const currentTime = new Date();
+        if (this.tokensResponse && this.lastFetchTime && (currentTime.getTime() - this.lastFetchTime.getTime()) < 5 * 60 * 1000) {
+            console.log(`[${config.lib.name}] Using cached tokens response.`);
+            return this.tokensResponse;
+        }
+
+        const tokens: Tokens = {};
+        if (this.rootApiKey) tokens.root = `Bearer ${this.rootApiKey}`;
+        if (this.apiKey) tokens.api = `Bearer ${this.apiKey}`;
+
+        try {
+            if (Object.keys(tokens).length === 0) return;
+
+            const response = await axios.post<{ data: TokensResponse }>(
+                "https://api.tpeoficial.com/v1/dvr/tokens",
+                { tokens }
+            );
+
+            if (tokens.root && response.data.data.root === false) throw customError(3000, "Invalid root token.");
+            if (tokens.api && response.data.data.api === false) throw customError(3000, "Invalid API token.");
+
+            this.tokensResponse = response.data.data;
+            this.lastFetchTime = currentTime;
+            console.log(`[${config.lib.name}] Tokens initialized successfully.`);
+            return this.tokensResponse;
+        } catch (error: any) {
+            throw customError(5000, error.message);
+        }
+    }
+
+    private async initializeTokens() {
+        try {
+            await this.getTokens();
+        } catch (error: any) {
+            throw customError(5000, `Error initializing tokens: ${error.message}`);
+        }
+    }
+
+    // FUNCTIONS / Private.
+    async isValidData(data: any): Promise<any> {
+        return await PrivateAPI.isValidData(this.apiKey, data);
+    }
+
+    // FUNCTIONS / Public.
+    async getPrayerTimes(data: any): Promise<any> {
+        return await PublicAPI.getPrayerTimes(data);
+    }
+
+    async inputSatinizer(data: any): Promise<any> {
+        return await PublicAPI.inputSatinizer(data);
+    }
+
+    async isValidPwd(data: any): Promise<any> {
+        return await PublicAPI.isValidPwd(data);
+    }
+
+    async newURLEncrypt(data: any): Promise<any> {
+        return await PublicAPI.newURLEncrypt(data);
+    }
+}
+
+export { DymoAPI };

package/src/private-api.ts

@@ -0,0 +1,49 @@
+import axios from "axios";
+import config from "./config";
+
+const customError = (code: number, message: string): Error => {
+    const error = new Error();
+    return Object.assign(error, { code, message: `[${config.lib.name}] ${message}` });
+};
+
+interface PhoneData {
+    iso: any;
+    phone: string;
+};
+
+interface CreditCardData {
+    pan: string | number;
+    expirationDate?: string;
+    cvc?: string | number;
+    cvv?: string | number;
+};
+
+interface Data {
+    email?: string;
+    phone?: PhoneData;
+    domain?: string;
+    creditCard?: string | CreditCardData;
+    ip?: string;
+};
+
+export const isValidData = async (token: string | null, data: Data): Promise<any> => {
+    if (token === null) throw customError(3000, "Invalid private token.");
+    
+    let i = false;
+    for (const key in data) {
+        if (data.hasOwnProperty(key) && (key === "email" || key === "tel" || key === "domain" || key === "creditCard" || key === "ip")) {
+            i = true;
+            break;
+        }
+    }
+    if (!i) throw customError(1500, "You must provide at least one parameter.");
+    
+    try {
+        const response = await axios.post("https://api.tpeoficial.com/v1/private/secure/verify", data, {
+            headers: { "Authorization": token },
+        });
+        return response.data;
+    } catch (error: any) {
+        throw customError(5000, error.message);
+    }
+};

package/src/public-api.ts

@@ -0,0 +1,94 @@
+import axios from "axios";
+import config from "./config";
+
+const customError = (code: number, message: string): Error => {
+    const error = new Error();
+    return Object.assign(error, { code, message: `[${config.lib.name}] ${message}` });
+};
+
+interface PrayerTimesData {
+    lat?: number;
+    lon?: number;
+}
+
+interface InputSatinizerData {
+    input?: string;
+}
+
+interface IsValidPwdData {
+    email?: string;
+    password?: string;
+    bannedWords?: string | string[];
+    min?: number;
+    max?: number;
+}
+
+interface NewURLEncryptData {
+    url?: string;
+}
+
+export const getPrayerTimes = async (data: PrayerTimesData): Promise<any> => {
+    const { lat, lon } = data;
+    if (lat === undefined || lon === undefined) throw customError(1000, "You must provide a latitude and longitude.");
+    try {
+        const response = await axios.get("https://api.tpeoficial.com/v1/public/islam/prayertimes", { params: data });
+        return response.data;
+    } catch (error: any) {
+        throw customError(5000, error.message);
+    }
+};
+
+export const inputSatinizer = async (data: InputSatinizerData): Promise<any> => {
+    const { input } = data;
+    if (input === undefined) throw customError(1000, "You must specify at least the input.");
+    try {
+        const response = await axios.get("https://api.tpeoficial.com/v1/public/inputSatinizer", { params: { input: encodeURIComponent(input) } });
+        return response.data;
+    } catch (error: any) {
+        throw customError(5000, error.message);
+    }
+};
+
+export const isValidPwd = async (data: IsValidPwdData): Promise<any> => {
+    let { email, password, bannedWords, min, max } = data;
+    if (password === undefined) throw customError(1000, "You must specify at least the password.");
+    const params: { [key: string]: any } = { 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 !== undefined && (!Number.isInteger(min) || min < 8 || min > 32)) throw customError(1500, "If you provide a minimum it must be valid.");
+    if (max !== undefined && (!Number.isInteger(max) || max < 32 || max > 100)) throw customError(1500, "If you provide a maximum it must be valid.");
+    if (min !== undefined) params.min = min;
+    if (max !== undefined) params.max = max;
+
+    try {
+        const response = await axios.get("https://api.tpeoficial.com/v1/public/validPwd", { params });
+        return response.data;
+    } catch (error: any) {
+        throw customError(5000, error.message);
+    }
+};
+
+export const newURLEncrypt = async (data: NewURLEncryptData): Promise<any> => {
+    const { url } = data;
+    if (url === undefined || (!url.startsWith("https://") && !url.startsWith("http://"))) throw customError(1500, "You must provide a valid url.");
+    try {
+        const response = await axios.get("https://api.tpeoficial.com/v1/public/url-encrypt", { params: data });
+        return response.data;
+    } catch (error: any) {
+        throw customError(5000, error.message);
+    }
+};

package/test/preview.js

@@ -1,18 +1,12 @@
-// npm install dymo-api
-// /* 1. */ const { Configuration, DymoAPI } = require("dymo-api");
-// /* 2. */ import { Configuration, DymoAPI } from "dymo-api"; // Coming Soon.
-// /* 3. */ import('dymo-api').then(({ Configuration, DymoAPI }) => { CODE HERE });
-// /* 4. */ const { Configuration, DymoAPI } = await import('dymo-api');
-import { Configuration, DymoAPI } from "../index.js";
 
-const configuration = new Configuration({
+import { DymoAPI } from "../index.js";
+
+// Creating the client for use.
+const dymo = new DymoAPI({
     /*rootApiKey: "ROOT_TOKEN_HERE",
     apiKey: "PRIVATE_TOKEN_HERE",*/
 });
 
-// Creating the client for use.
-const dymo = new DymoAPI(configuration);
-
 /*
 console.log(await dymo.isValidData({ email: "test@test.com", tel: "+34617509462", domain: "test.com", creditCard: "5110929780543845", ip: "52.94.236.248" })); // Private authorization required.
 console.log(await dymo.getPrayerTimes({ lat: "37.3755847689721", lon: "-4.457957889422379" })); // No authorization required.

package/tsconfig.json

@@ -0,0 +1,15 @@
+{
+    "compilerOptions": {
+        "target": "ES2020",
+        "module": "CommonJS",
+        "strict": true,
+        "esModuleInterop": true,
+        "skipLibCheck": true,
+        "forceConsistentCasingInFileNames": true,
+        "outDir": "./dist",
+        "rootDir": "./src"
+    },
+    "include": [
+        "src/**/*"
+    ]
+}

package/lib/dymo-api.cjs

@@ -1,64 +0,0 @@
-const axios = require("axios");
-const config = require("../config.cjs");
-const customError = (code, message) => Object.assign(new Error(), { code, message: `[${config.lib.name}] ${message}` });
-
-/* INTERNALS */
-const privateAPI = require("./private-api.cjs");
-const publicAPI = require("./public-api.cjs");
-
-class Configuration {
-    constructor({ rootApiKey, apiKey } = {}) {
-        // If neither is provided, set them as empty strings.
-        this.rootApiKey = rootApiKey || null;
-        this.apiKey = apiKey || null;
-        this.tokensResponse = null; // Variable to store the response.
-        this.lastFetchTime = null; // Variable to store the time of last request.
-    }
-    async getTokens() {
-        // Checks if the response is available and if 5 minutes have passed since the last request.
-        const currentTime = new Date();
-        if (this.tokensResponse && this.lastFetchTime && currentTime - this.lastFetchTime < 5 * 60 * 1000) {
-            console.log(`[${config.lib.name}] Using cached tokens response.`);
-            return this.tokensResponse;
-        }
-        const tokens = {};
-        if (this.rootApiKey !== null) tokens.root = `Bearer ${this.rootApiKey}`;
-        if (this.apiKey !== null) tokens.api = `Bearer ${this.apiKey}`;
-        try {
-            if (Object.keys(tokens).length < 1) return;
-            const response = await axios.post('https://api.tpeoficial.com/v1/dvr/tokens', { tokens });
-            if (tokens.root && response.data.root === false) throw customError(3000, "Invalid root token.");
-            if (tokens.private && response.data.private === false) throw customError(3000, "Invalid private token.");
-            // Saves the response and the current request time.
-            this.tokensResponse = response.data;
-            this.lastFetchTime = currentTime;
-            console.log(`[${config.lib.name}] Tokens initialized successfully.`);
-            return response.data;
-        } catch (error) {
-            throw customError(5000, error.message);
-        }
-    }
-}
-
-class DymoAPI {
-    constructor(configuration) {
-        this.configuration = configuration;
-        this.initializeTokens(); // Calls the function to obtain tokens when creating the object.
-    }
-    async initializeTokens() {
-        try {
-            await this.configuration.getTokens();
-        } catch (error) {
-            throw customError(5000, `Error initializing tokens: ${error.message}`);
-        }
-    }
-    // FUNCTIONS / Private.
-    async isValidData(data) { return await privateAPI.isValidData(this.configuration.apiKey, data); }
-    // FUNCTIONS / Public.
-    async getPrayerTimes(data) { return await publicAPI.getPrayerTimes(data); }
-    async inputSatinizer(data) { return await publicAPI.inputSatinizer(data); }
-    async isValidPwd(data) { return await publicAPI.isValidPwd(data); }
-    async newURLEncrypt(data) { return await publicAPI.newURLEncrypt(data); }
-}
-
-module.exports = { Configuration, DymoAPI };

package/lib/private-api.cjs

@@ -1,21 +0,0 @@
-const axios = require("axios");
-const config = require("../config.cjs");
-const customError = (code, message) => Object.assign(new Error(), { code, message: `[${config.lib.name}] ${message}` });
-
-exports.isValidData = async (token, data) => {
-    if (token === null) throw customError(3000, "Invalid private token.");
-    let i = false;
-    for (const key in data) {
-        if (data.hasOwnProperty(key) && (key === 'email' || key === 'tel' || key === 'domain' || key === 'creditCard' || key === 'ip')) {
-            i = true;
-            break;
-        }
-    }
-    if (!i) throw customError(1500, "You must provide at least one parameter.");
-    try {
-        const response = await axios.get(`https://api.tpeoficial.com/v1/private/secure/verify`, { params: data, headers: { 'Authorization': token } });
-        return response.data;
-    } catch (error) {
-        throw customError(5000, error.message);
-    }
-};

package/lib/public-api.cjs

@@ -1,62 +0,0 @@
-const axios = require("axios");
-const config = require("../config.cjs");
-const customError = (code, message) => Object.assign(new Error(), { code, message: `[${config.lib.name}] ${message}` });
-
-exports.getPrayerTimes = async (data) => {
-    const { lat, lon } = data;
-    if (!lat || !lon) throw customError(1000, "You must provide a latitude and longitude.");
-    try {
-        const response = await axios.get(`https://api.tpeoficial.com/v1/public/islam/prayertimes`, { params: data });
-        return response.data;
-    } catch (error) {
-        throw customError(5000, error.message);
-    }
-};
-
-exports.inputSatinizer = async (data) => {
-    const { input } = data;
-    if (!input) throw customError(1000, "You must specify at least the input.");
-    try {
-        const response = await axios.get('https://api.tpeoficial.com/v1/public/inputSatinizer', { params: { input: encodeURIComponent(input) } });
-        return response.data;
-    } catch (error) {
-        throw customError(5000, error.message);
-    }
-};
-
-exports.isValidPwd = async (data) => {
-    var { email, password, bannedWords, min, max } = data;
-    if (!password) throw customError(1000, "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 && typeof bannedWords === 'string') bannedWords = bannedWords.slice(1, -1).trim().split(',').map(item => item.trim());
-    if (bannedWords && (!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 && (!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.");
-    if (bannedWords) params.bannedWords = bannedWords;
-    if (min && (!Number.isInteger(min) && min < 8 && min > 32)) throw customError(1500, "If you provide a minimum it must be valid.");
-    if (max && (!Number.isInteger(max) && max < 32 && max > 100)) throw customError(1500, "If you provide a maximum it must be valid.");
-    if (min) params.min = min;
-    if (max) params.max = max;
-    try {
-        const response = await axios.get(`https://api.tpeoficial.com/v1/public/validPwd`, { params });
-        return response.data;
-    } catch (error) {
-        throw customError(5000, error.message);
-    }
-};
-
-exports.newURLEncrypt = async (data) => {
-    const { url } = data;
-    if (!url || (!url.startsWith("https://") && !url.startsWith("http://"))) throw customError(1500, "You must provide a valid url.");
-    try {
-        const response = await axios.get(`https://api.tpeoficial.com/v1/public/url-encrypt`, { params: data });
-        return response.data;
-    } catch (error) {
-        throw customError(5000, error.message);
-    }
-}