@senior-agronegocio/angular-components 0.0.49

package/esm2015/common/agro-object-utils.class.js

@@ -0,0 +1,245 @@
+import { AGRO_NUMBERS } from "../enums";
+export { AgroObjectUtils as AOU, AgroObjectUtils as ObjectUtils };
+/**
+ * Classe utilitária para operações de objeto.
+ */
+export class AgroObjectUtils {
+    /**
+     * Verifica se um objeto é nulo ou indefinido.
+     * @param obj - O objeto a ser verificado.
+     * @returns True se o objeto for nulo ou indefinido, false caso contrário.
+     */
+    static isNullOrUndefined(obj) {
+        return obj === null || obj === undefined;
+    }
+    /**
+     * Verifica se um objeto não é nulo e não é indefinido.
+     * @param obj - O objeto a ser verificado.
+     * @returns True se o objeto não for nulo e não for indefinido, false caso contrário.
+     */
+    static isNotNullOrUndefined(obj) {
+        return !AgroObjectUtils.isNullOrUndefined(obj);
+    }
+    /**
+     * Verifica se um objeto é uma string.
+     * @param obj - O objeto a ser verificado.
+     * @returns True se o objeto for uma string, false caso contrário.
+     */
+    static isString(obj) {
+        return typeof obj === "string";
+    }
+    /**
+     * Verifica se um objeto é um número.
+     * @param obj - O objeto a ser verificado.
+     * @returns True se o objeto for um número, false caso contrário.
+     */
+    static isNumber(obj) {
+        return typeof obj === "number";
+    }
+    /**
+     * Verifica se um objeto é um booleano.
+     * @param obj - O objeto a ser verificado.
+     * @returns True se o objeto for um booleano, false caso contrário.
+     */
+    static isBoolean(obj) {
+        return typeof obj === "boolean";
+    }
+    /**
+     * Verifica se um objeto é uma função.
+     * @param obj - O objeto a ser verificado.
+     * @returns True se o objeto for uma função, false caso contrário.
+     */
+    static isFunction(obj) {
+        return typeof obj === "function";
+    }
+    /**
+     * Verifica se um objeto é um array.
+     * @param obj - O objeto a ser verificado.
+     * @returns True se o objeto for um array, false caso contrário.
+     */
+    static isArray(obj) {
+        return Array.isArray(obj);
+    }
+    /**
+     * Verifica se o valor informado é um objeto.
+     * @param obj - O objeto a ser verificado.
+     * @returns True se o objeto for um objeto, false caso contrário.
+     */
+    static isObject(obj) {
+        return typeof obj === "object";
+    }
+    /**
+     * Verifica se um objeto é uma data.
+     * @param obj - O objeto a ser verificado.
+     * @returns True se o objeto for uma data, false caso contrário.
+     */
+    static isDate(obj) {
+        return obj instanceof Date;
+    }
+    /**
+     * Verifica se um objeto é um erro.
+     * @param obj - O objeto a ser verificado.
+     * @returns True se o objeto for um erro, false caso contrário.
+     */
+    static isError(obj) {
+        return obj instanceof Error;
+    }
+    /**
+     * Verifica se um objeto é uma expressão regular.
+     * @param obj - O objeto a ser verificado.
+     * @returns True se o objeto for uma expressão regular, false caso contrário.
+     */
+    static isRegExp(obj) {
+        return obj instanceof RegExp;
+    }
+    /**
+     * Verifica se um objeto é um valor primitivo.
+     * @param obj - O objeto a ser verificado.
+     * @returns True se o objeto for um valor primitivo, false caso contrário.
+     */
+    static isPrimitive(obj) {
+        return AgroObjectUtils.isString(obj) || AgroObjectUtils.isNumber(obj) || AgroObjectUtils.isBoolean(obj);
+    }
+    /**
+     * Verifica se todos os valores de um objeto são nulos ou indefinidos.
+     * @param obj - O objeto a ser verificado.
+     * @returns True se todos os valores do objeto forem nulos ou indefinidos, false caso contrário.
+     */
+    static allNull(obj) {
+        if (!AgroObjectUtils.isObject(obj)) {
+            return false;
+        }
+        for (const key in obj) {
+            if (obj.hasOwnProperty(key) && !AgroObjectUtils.isNullOrUndefined(obj[key])) {
+                return false;
+            }
+        }
+        return true;
+    }
+    /**
+     * Compara dois objetos para verificar se são iguais.
+     * @param obj1 - O primeiro objeto a ser comparado.
+     * @param obj2 - O segundo objeto a ser comparado.
+     * @returns True se os objetos forem iguais, false caso contrário.
+     */
+    static isEqual(obj1, obj2) {
+        if (JSON.stringify(obj1) === JSON.stringify(obj2)) {
+            return true;
+        }
+        return false;
+    }
+    /**
+     * Verifica se um objeto é nulo.
+     * @param obj - O objeto a ser verificado.
+     * @returns True se o objeto for nulo ou um objeto vazio, false caso contrário.
+     */
+    static isNull(obj) {
+        return obj === null;
+    }
+    /**
+     * Verifica se um objeto não é nulo.
+     * @param obj - O objeto a ser verificado.
+     * @returns True se o objeto não for nulo, false caso contrário.
+     */
+    static isNotNull(obj) {
+        return !AgroObjectUtils.isNull(obj);
+    }
+    /**
+     * Converte um objeto para uma string JSON.
+     * @param obj - O objeto a ser convertido.
+     * @returns A string JSON representando o objeto.
+     */
+    static toJSON(obj) {
+        return JSON.stringify(obj);
+    }
+    /**
+     * Verifica se um objeto não é vazio.
+     * @param obj - O objeto a ser verificado.
+     * @returns True se o objeto não for vazio, false caso contrário.
+     */
+    static isNotEmpty(obj) {
+        if (!AgroObjectUtils.isObject(obj)) {
+            return false;
+        }
+        return Object.keys(obj).length !== 0;
+    }
+    /**
+     * Verifica se um objeto é vazio.
+     * @param obj - O objeto a ser verificado.
+     * @returns True se o objeto for vazio, false caso contrário.
+     */
+    static isEmpty(obj) {
+        return !AgroObjectUtils.isNotEmpty(obj);
+    }
+    /**
+     * Verifica se um objeto não está vazio e contém uma determinada propriedade.
+     * @param obj - O objeto a ser verificado.
+     * @param property - A propriedade a ser verificada.
+     * @returns True se o objeto não estiver vazio e contiver a propriedade, false caso contrário.
+     */
+    static containsProperty(obj, property) {
+        return AgroObjectUtils.isNotEmpty(obj) && obj.hasOwnProperty(property);
+    }
+    /**
+     * Verifica se o parâmetro recebido é um objeto e se ele contém a propriedade ID.
+     */
+    static hasId(obj) {
+        return AgroObjectUtils.isNotEmpty(obj) && obj.hasOwnProperty("id");
+    }
+    /**
+     * Verifica se o valor informado no parâmetro possui as propriedades de uma entidade SDL (id e createdAt).
+     * @param obj
+     * @returns
+     */
+    static isSDLEntity(obj) {
+        return AgroObjectUtils.isNotEmpty(obj) && obj.hasOwnProperty("id") && obj.hasOwnProperty("createdAt");
+    }
+    /**
+     * Verifica se um objeto é valido, considerando que haja no mínimo 1 propriedade
+     */
+    static isValid(obj) {
+        return Object.keys(obj).length > AGRO_NUMBERS.ZERO && AgroObjectUtils.isNotEmpty(obj);
+    }
+    /**
+     * Verifica se um objeto é inválido, considerando que não haja nenhuma propriedade
+     */
+    static isInvalid(obj) {
+        return !AgroObjectUtils.isValid(obj);
+    }
+    /**
+     * Encontra uma propriedade em um objeto pelo nome e retorna seu valor.
+     * Se o valor for um objeto, retorna o próprio objeto.
+     *
+     * @param obj O objeto onde buscar.
+     * @param key O nome da propriedade a ser encontrada.
+     * @param deepSearch Indica se a busca deve ser em profundidade (padrão: true).
+     * @returns O valor da propriedade, ou undefined se não for encontrada.
+     */
+    static findProperty(obj, key, deepSearch = true) {
+        if (AgroObjectUtils.isInvalid(obj)) {
+            throw new Error("O primeiro argumento deve ser um objeto.");
+        }
+        if (key in obj) {
+            return obj[key];
+        }
+        if (deepSearch) {
+            for (const prop in obj) {
+                if (obj.hasOwnProperty(prop) && typeof obj[prop] === "object") {
+                    const result = AgroObjectUtils.findProperty(obj[prop], key, deepSearch);
+                    if (result !== undefined) {
+                        return result;
+                    }
+                }
+            }
+        }
+        return undefined;
+    }
+    /**
+     * Recebe uma string (JSON) e tenta converter para um objeto.
+     * @param value
+     */
+    static fromString(value) {
+        return JSON.parse(value) || undefined;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"agro-object-utils.class.js","sourceRoot":"ng://@senior-agronegocio/angular-components/","sources":["common/agro-object-utils.class.ts"],"names":[],"mappings":"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","sourcesContent":["import { AGRO_NUMBERS } from \"../enums\";\r\n\r\nexport { AgroObjectUtils as AOU, AgroObjectUtils as ObjectUtils };\r\n\r\n/**\r\n * Classe utilitária para operações de objeto.\r\n */\r\nexport class AgroObjectUtils {\r\n    /**\r\n     * Verifica se um objeto é nulo ou indefinido.\r\n     * @param obj - O objeto a ser verificado.\r\n     * @returns True se o objeto for nulo ou indefinido, false caso contrário.\r\n     */\r\n    static isNullOrUndefined(obj: any): boolean {\r\n        return obj === null || obj === undefined;\r\n    }\r\n\r\n    /**\r\n     * Verifica se um objeto não é nulo e não é indefinido.\r\n     * @param obj - O objeto a ser verificado.\r\n     * @returns True se o objeto não for nulo e não for indefinido, false caso contrário.\r\n     */\r\n    static isNotNullOrUndefined(obj: any): boolean {\r\n        return !AgroObjectUtils.isNullOrUndefined(obj);\r\n    }\r\n\r\n    /**\r\n     * Verifica se um objeto é uma string.\r\n     * @param obj - O objeto a ser verificado.\r\n     * @returns True se o objeto for uma string, false caso contrário.\r\n     */\r\n    static isString(obj: any): boolean {\r\n        return typeof obj === \"string\";\r\n    }\r\n\r\n    /**\r\n     * Verifica se um objeto é um número.\r\n     * @param obj - O objeto a ser verificado.\r\n     * @returns True se o objeto for um número, false caso contrário.\r\n     */\r\n    static isNumber(obj: any): boolean {\r\n        return typeof obj === \"number\";\r\n    }\r\n\r\n    /**\r\n     * Verifica se um objeto é um booleano.\r\n     * @param obj - O objeto a ser verificado.\r\n     * @returns True se o objeto for um booleano, false caso contrário.\r\n     */\r\n    static isBoolean(obj: any): boolean {\r\n        return typeof obj === \"boolean\";\r\n    }\r\n\r\n    /**\r\n     * Verifica se um objeto é uma função.\r\n     * @param obj - O objeto a ser verificado.\r\n     * @returns True se o objeto for uma função, false caso contrário.\r\n     */\r\n    static isFunction(obj: any): boolean {\r\n        return typeof obj === \"function\";\r\n    }\r\n\r\n    /**\r\n     * Verifica se um objeto é um array.\r\n     * @param obj - O objeto a ser verificado.\r\n     * @returns True se o objeto for um array, false caso contrário.\r\n     */\r\n    static isArray(obj: any): boolean {\r\n        return Array.isArray(obj);\r\n    }\r\n\r\n    /**\r\n     * Verifica se o valor informado é um objeto.\r\n     * @param obj - O objeto a ser verificado.\r\n     * @returns True se o objeto for um objeto, false caso contrário.\r\n     */\r\n    static isObject(obj: any): boolean {\r\n        return typeof obj === \"object\";\r\n    }\r\n\r\n    /**\r\n     * Verifica se um objeto é uma data.\r\n     * @param obj - O objeto a ser verificado.\r\n     * @returns True se o objeto for uma data, false caso contrário.\r\n     */\r\n    static isDate(obj: any): boolean {\r\n        return obj instanceof Date;\r\n    }\r\n\r\n    /**\r\n     * Verifica se um objeto é um erro.\r\n     * @param obj - O objeto a ser verificado.\r\n     * @returns True se o objeto for um erro, false caso contrário.\r\n     */\r\n    static isError(obj: any): boolean {\r\n        return obj instanceof Error;\r\n    }\r\n\r\n    /**\r\n     * Verifica se um objeto é uma expressão regular.\r\n     * @param obj - O objeto a ser verificado.\r\n     * @returns True se o objeto for uma expressão regular, false caso contrário.\r\n     */\r\n    static isRegExp(obj: any): boolean {\r\n        return obj instanceof RegExp;\r\n    }\r\n\r\n    /**\r\n     * Verifica se um objeto é um valor primitivo.\r\n     * @param obj - O objeto a ser verificado.\r\n     * @returns True se o objeto for um valor primitivo, false caso contrário.\r\n     */\r\n    static isPrimitive(obj: any): boolean {\r\n        return AgroObjectUtils.isString(obj) || AgroObjectUtils.isNumber(obj) || AgroObjectUtils.isBoolean(obj);\r\n    }\r\n\r\n    /**\r\n     * Verifica se todos os valores de um objeto são nulos ou indefinidos.\r\n     * @param obj - O objeto a ser verificado.\r\n     * @returns True se todos os valores do objeto forem nulos ou indefinidos, false caso contrário.\r\n     */\r\n    static allNull(obj: any): boolean {\r\n        if (!AgroObjectUtils.isObject(obj)) {\r\n            return false;\r\n        }\r\n\r\n        for (const key in obj) {\r\n            if (obj.hasOwnProperty(key) && !AgroObjectUtils.isNullOrUndefined(obj[key])) {\r\n                return false;\r\n            }\r\n        }\r\n\r\n        return true;\r\n    }\r\n\r\n    /**\r\n     * Compara dois objetos para verificar se são iguais.\r\n     * @param obj1 - O primeiro objeto a ser comparado.\r\n     * @param obj2 - O segundo objeto a ser comparado.\r\n     * @returns True se os objetos forem iguais, false caso contrário.\r\n     */\r\n    static isEqual(obj1: any, obj2: any): boolean {\r\n        if (JSON.stringify(obj1) === JSON.stringify(obj2)) {\r\n            return true;\r\n        }\r\n\r\n        return false;\r\n    }\r\n\r\n    /**\r\n     * Verifica se um objeto é nulo.\r\n     * @param obj - O objeto a ser verificado.\r\n     * @returns True se o objeto for nulo ou um objeto vazio, false caso contrário.\r\n     */\r\n    static isNull(obj: any): boolean {\r\n        return obj === null;\r\n    }\r\n\r\n    /**\r\n     * Verifica se um objeto não é nulo.\r\n     * @param obj - O objeto a ser verificado.\r\n     * @returns True se o objeto não for nulo, false caso contrário.\r\n     */\r\n    static isNotNull(obj: any): boolean {\r\n        return !AgroObjectUtils.isNull(obj);\r\n    }\r\n\r\n    /**\r\n     * Converte um objeto para uma string JSON.\r\n     * @param obj - O objeto a ser convertido.\r\n     * @returns A string JSON representando o objeto.\r\n     */\r\n    static toJSON(obj: any): string {\r\n        return JSON.stringify(obj);\r\n    }\r\n\r\n    /**\r\n     * Verifica se um objeto não é vazio.\r\n     * @param obj - O objeto a ser verificado.\r\n     * @returns True se o objeto não for vazio, false caso contrário.\r\n     */\r\n    static isNotEmpty(obj: any): boolean {\r\n        if (!AgroObjectUtils.isObject(obj)) {\r\n            return false;\r\n        }\r\n\r\n        return Object.keys(obj).length !== 0;\r\n    }\r\n\r\n    /**\r\n     * Verifica se um objeto é vazio.\r\n     * @param obj - O objeto a ser verificado.\r\n     * @returns True se o objeto for vazio, false caso contrário.\r\n     */\r\n    static isEmpty(obj: any): boolean {\r\n        return !AgroObjectUtils.isNotEmpty(obj);\r\n    }\r\n\r\n    /**\r\n     * Verifica se um objeto não está vazio e contém uma determinada propriedade.\r\n     * @param obj - O objeto a ser verificado.\r\n     * @param property - A propriedade a ser verificada.\r\n     * @returns True se o objeto não estiver vazio e contiver a propriedade, false caso contrário.\r\n     */\r\n    static containsProperty(obj: any, property: string): boolean {\r\n        return AgroObjectUtils.isNotEmpty(obj) && obj.hasOwnProperty(property);\r\n    }\r\n\r\n    /**\r\n     * Verifica se o parâmetro recebido é um objeto e se ele contém a propriedade ID.\r\n     */\r\n    static hasId(obj: any): boolean {\r\n        return AgroObjectUtils.isNotEmpty(obj) && obj.hasOwnProperty(\"id\");\r\n    }\r\n\r\n    /**\r\n     * Verifica se o valor informado no parâmetro possui as propriedades de uma entidade SDL (id e createdAt).\r\n     * @param obj\r\n     * @returns\r\n     */\r\n    static isSDLEntity(obj: any): boolean {\r\n        return AgroObjectUtils.isNotEmpty(obj) && obj.hasOwnProperty(\"id\") && obj.hasOwnProperty(\"createdAt\");\r\n    }\r\n\r\n    /**\r\n     * Verifica se um objeto é valido, considerando que haja no mínimo 1 propriedade\r\n     */\r\n    static isValid(obj: any): boolean {\r\n        return Object.keys(obj).length > AGRO_NUMBERS.ZERO && AgroObjectUtils.isNotEmpty(obj);\r\n    }\r\n\r\n    /**\r\n     * Verifica se um objeto é inválido, considerando que não haja nenhuma propriedade\r\n     */\r\n    static isInvalid(obj: any): boolean {\r\n        return !AgroObjectUtils.isValid(obj);\r\n    }\r\n\r\n    /**\r\n     * Encontra uma propriedade em um objeto pelo nome e retorna seu valor.\r\n     * Se o valor for um objeto, retorna o próprio objeto.\r\n     *\r\n     * @param obj O objeto onde buscar.\r\n     * @param key O nome da propriedade a ser encontrada.\r\n     * @param deepSearch Indica se a busca deve ser em profundidade (padrão: true).\r\n     * @returns O valor da propriedade, ou undefined se não for encontrada.\r\n     */\r\n    static findProperty(obj: Record<string, any>, key: string, deepSearch: boolean = true): any {\r\n        if (AgroObjectUtils.isInvalid(obj)) {\r\n            throw new Error(\"O primeiro argumento deve ser um objeto.\");\r\n        }\r\n\r\n        if (key in obj) {\r\n            return obj[key];\r\n        }\r\n\r\n        if (deepSearch) {\r\n            for (const prop in obj) {\r\n                if (obj.hasOwnProperty(prop) && typeof obj[prop] === \"object\") {\r\n                    const result = AgroObjectUtils.findProperty(obj[prop], key, deepSearch);\r\n                    if (result !== undefined) {\r\n                        return result;\r\n                    }\r\n                }\r\n            }\r\n        }\r\n\r\n        return undefined;\r\n    }\r\n\r\n    /**\r\n     * Recebe uma string (JSON) e tenta converter para um objeto.\r\n     * @param value\r\n     */\r\n    static fromString(value: string): any {\r\n        return JSON.parse(value) || undefined;\r\n    }\r\n}\r\n"]}

package/esm2015/common/agro-platform-utils.class.js

@@ -0,0 +1,97 @@
+import { AgroCookieUtils } from "./agro-cookie-utils.class";
+import { AgroObjectUtils } from "./agro-object-utils.class";
+import { StringUtils } from "./agro-string-utils.class";
+export { AgroPlatformUtils as APU, AgroPlatformUtils as PlatformUtils };
+export class AgroPlatformUtils {
+    /**
+     * Retorna o tenant atual
+     * Caso contrário, retorna uma instância de Error
+     * @returns
+     */
+    static getCurrentTenant() {
+        var _a;
+        const cookie = AgroCookieUtils.getCookie('com.senior.token', true);
+        if (cookie) {
+            const str = (_a = AgroObjectUtils.fromString(cookie)) === null || _a === void 0 ? void 0 : _a.tenantName;
+            if (str) {
+                return str;
+            }
+        }
+        throw new Error('Cookie: "com.senior.token" não encontrado.');
+    }
+    /**
+     * Retorna o usuário logado
+     * Caso contrário, retorna uma instância de Error
+     * @returns string || instanceOf Error
+     */
+    static getCurrentUserName() {
+        var _a;
+        const cookie = AgroCookieUtils.getCookie('com.senior.token');
+        if (cookie) {
+            const str = (_a = AgroCookieUtils.parseCookieToObject(cookie)) === null || _a === void 0 ? void 0 : _a.fullName;
+            if (str) {
+                return str;
+            }
+        }
+        console.error('Cookie: "com.senior.token" não encontrado.');
+        return null;
+    }
+    /**
+     * Retorna o e-mail do usuário logado
+     * Caso contrário, retorna uma instância de Error
+     * @returns string
+     */
+    static getCurrentUserEmail() {
+        var _a;
+        const cookie = AgroCookieUtils.getCookie('com.senior.token');
+        if (cookie) {
+            const str = (_a = AgroCookieUtils.parseCookieToObject(cookie)) === null || _a === void 0 ? void 0 : _a.email;
+            if (str) {
+                return str;
+            }
+        }
+        console.error('Cookie: "com.senior.token" não encontrado.');
+        return null;
+    }
+    /**
+     * Retorna uma string com a baseURL atual
+     * Caso contrário, retorna uma instância de Error
+     * @example "https://cloud-leaf.senior.com.br" || "https://platform.senior.com.br"
+     */
+    static getBaseURL() {
+        const cookie = AgroCookieUtils.getCookie('com.senior.base.url');
+        if (cookie) {
+            return cookie;
+        }
+        throw new Error('Cookie: "com.senior.base.url" não encontrado.');
+    }
+    /**
+     * Retorna uma string com a URL dos serviços
+     * Caso contrário, retorna uma instância de Error
+     * @example "https://cloud-leaf.senior.com.br/t/senior.com.br/bridge/1.0/"
+     */
+    static getServicesURL() {
+        const cookie = AgroCookieUtils.getCookie('com.senior.services.url');
+        if (StringUtils.isNotEmpty(cookie)) {
+            return cookie;
+        }
+        throw new Error('Cookie: "com.senior.services.url" não encontrado.');
+    }
+    /**
+     * Retorna uma string com o token de acesso atual
+     * Caso contrário, retorna uma instância de Error
+     */
+    static getCurrentAccessToken() {
+        var _a;
+        const cookie = AgroCookieUtils.getCookie('com.senior.token');
+        if (cookie) {
+            const str = (_a = AgroCookieUtils.parseCookieToObject(cookie)) === null || _a === void 0 ? void 0 : _a.accessToken;
+            if (str) {
+                return str;
+            }
+        }
+        console.error('Cookie: "com.senior.token" não encontrado.');
+        return null;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/common/agro-regex.constant.js

@@ -0,0 +1,143 @@
+export const AGRO_REGEX = {
+    /**
+     * Validação de E-mail
+     */
+    isEmail: /^[^\s@]+@[^\s@]+\.[^\s@]+$/,
+    /**
+     * Validação de Números Inteiros Positivos
+     */
+    positiveInteger: /^[1-9]\d*$/,
+    /**
+     * Validação de Números Decimais Positivos
+     */
+    positiveDecimal: /^\d*\.?\d+$/,
+    /**
+     * Validação de string que consiste apenas em espaços em branco ou está vazia.
+     */
+    onlyBlankSpaces: /^\s*$/,
+    /**
+     * Validação de CEP (Código Postal)
+     */
+    zipCode: /^\d{8}$|^\d{5}-\d{3}$/,
+    /**
+     * Validação de String (qualquer caractere)
+     */
+    isString: /^[\s\S]*$/,
+    /**
+     * Validação de UUID
+     */
+    isUUID: /^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[1-5][0-9a-fA-F]{3}-[89abAB][0-9a-fA-F]{3}-[0-9a-fA-F]{12}$/,
+    /**
+     * Validação de Número
+     */
+    isNumber: /^-?\d+$/,
+    /**
+     * Validação de Número Decimal
+     */
+    isDecimal: /^\d*\.?\d+$/,
+    /**
+     * Validação de Placa de Veículo
+     */
+    isLicensePlate: /^[A-Za-z0-9]{1,7}-?[A-Za-z0-9]{1,7}$/,
+    /**
+     * Validação de Número de Telefone
+     */
+    isPhoneNumber: /^\+?\d{1,4}-?\d{6,11}$/,
+    /**
+     * Validação de Data (Formato YYYY-MM-DD)
+     */
+    isDate: /^\d{4}-\d{2}-\d{2}$/,
+    /**
+     * Validação de Hora (Formato HH:mm)
+     */
+    isTime: /^(0\d|1\d|2[0-3]):[0-5]\d$/,
+    /**
+     * Validação de Data e Hora (Formato YYYY-MM-DD HH:mm)
+     */
+    isDateTime: /^\d{4}-\d{2}-\d{2} (0\d|1\d|2[0-3]):[0-5]\d$/,
+    /**
+     * Validação de URL
+     */
+    isURL: /^(http|https):\/\/([\w-]+\.)+[\w-]+(\/[\w- ./?%&=]*)?$/,
+    /**
+     * Validação de Número Hexadecimal
+     */
+    isHexNumber: /^[0-9a-fA-F]+$/,
+    /**
+     * Validação de Base64
+     */
+    isBase64: /^[a-zA-Z0-9+/]+={0,2}$/,
+    /**
+     * Validação de Nome de Usuário (3 a 20 caracteres alfanuméricos)
+     */
+    isUsername: /^\w{3,20}$/,
+    /**
+     * Validação de Alfanumérico
+     */
+    isAlphanumeric: /^[a-zA-Z0-9]+$/,
+    /**
+     * Validação de Slug (letras minúsculas, números e traços)
+     */
+    isSlug: /^[a-z0-9-]+$/,
+    /**
+     * Validação de Número de Cartão de Crédito
+     */
+    isCreditCard: /^\d{4}-\d{4}-\d{4}-\d{4}$/,
+    /**
+     * Validação de Número Hexadecimal
+     */
+    isHexadecimal: /^[0-9a-fA-F]+$/,
+    /**
+     * Validação de Moeda
+     */
+    isCurrency: /^\d+(\.\d{1,2})?$/,
+    /**
+     * Validação de Porcentagem
+     */
+    isPercentage: /^(100(\.0{1,2})?|[1-9]?\d(\.\d{1,2})?)$/,
+    /**
+     * Validação de Tag HTML Simples
+     */
+    isHTMLTag: /^<([a-z]+)([^<]+)*(?:>(.*)<\/\1>|\s+\/>)$/,
+    /**
+     * Validação de Nome de Usuário com Espaços (3 a 20 caracteres alfanuméricos e espaços)
+     */
+    isUsernameWithSpaces: /^[a-zA-Z0-9_ ]{3,20}$/,
+    /**
+     * Validação de Senha Forte (mínimo 8 caracteres, uma letra minúscula, uma letra maiúscula, um número e um caractere especial)
+     */
+    isStrongPassword: /^(?=.*[a-z])(?=.*[A-Z])(?=.*\d)(?=.*[@$!%*?&])[A-Za-z\d@$!%*?&]{8,}$/,
+    /**
+     * Validação de String Alfabética
+     */
+    isAlphabetic: /^[a-zA-Z]+$/,
+    /**
+     * Validação de Hora no Formato de 12 Horas
+     */
+    isTime12Hour: /^(0?[1-9]|1[0-2]):\d{2} (AM|PM)$/i,
+    /**
+     * Validação de Latitude
+     */
+    isLatitude: /^[-+]?([1-8]?\d(\.\d+)?|90(\.0+)?)$/,
+    /**
+     * Validação de Longitude
+     */
+    isLongitude: /^[-+]?(180(\.0+)?|((1[0-7]\d)|([1-9]?\d))(\.\d+)?)$/,
+    /**
+     * Validação de Endereço MAC
+     */
+    isMACAddress: /^([0-9A-Fa-f]{2}[:-]){5}([0-9A-Fa-f]{2})$/,
+    /**
+     * Validação de Data de Expiração de Cartão de Crédito
+     */
+    isCreditCardExpiration: /^(0[1-9]|1[0-2])\/\d{2}$/,
+    /**
+     * Validação de Número de Seguro Social (SSN)
+     */
+    isSSN: /^\d{3}-\d{2}-\d{4}$/,
+    /**
+     * Validação se todos os dígitos são iguais
+     */
+    isAllDigitsEqual: /^(.)\1+$/,
+};
+//# sourceMappingURL=data:application/json;base64,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