@navservice/core 1.25.0 → 1.30.0

package/build/lib/index.browser.cjs

@@ -0,0 +1,805 @@
+"use strict";
+const __rslib_import_meta_url__ = /*#__PURE__*/ (function () {
+  return typeof document === 'undefined'
+    ? new (require('url'.replace('', '')).URL)('file:' + __filename).href
+    : (document.currentScript && document.currentScript.src) ||
+      new URL('main.js', document.baseURI).href;
+})();
+;
+var __webpack_modules__ = ({
+"./src/config_env/index.ts"(__unused_rspack_module, __webpack_exports__, __webpack_require__) {
+__webpack_require__.d(__webpack_exports__, {
+  A: () => (__rspack_default_export)
+});
+class config_env {
+    static SET_PUBLIC_BASE_URL_BACKEND_PRINCIPAL;
+    static init(config) {
+        config_env.SET_PUBLIC_BASE_URL_BACKEND_PRINCIPAL = config.SET_PUBLIC_BASE_URL_BACKEND_PRINCIPAL;
+    }
+    static get PUBLIC_BASE_URL_BACKEND_PRINCIPAL() {
+        return this.SET_PUBLIC_BASE_URL_BACKEND_PRINCIPAL;
+    }
+}
+/* export default */ const __rspack_default_export = (config_env);
+
+
+},
+"./src/utils/index.ts"(__unused_rspack_module, __webpack_exports__, __webpack_require__) {
+
+// EXPORTS
+__webpack_require__.d(__webpack_exports__, {
+  "default": () => (/* binding */ src_utils)
+});
+
+;// CONCATENATED MODULE: external "axios"
+const external_axios_namespaceObject = require("axios");
+var external_axios_default = /*#__PURE__*/__webpack_require__.n(external_axios_namespaceObject);
+// EXTERNAL MODULE: ./src/config_env/index.ts
+var config_env = __webpack_require__("./src/config_env/index.ts");
+;// CONCATENATED MODULE: ./src/utils/_api.ts
+
+
+
+const _api_api = class _api {
+    static servidor_service_usuario = class servidor_service_usuario {
+        static get #axios() {
+            return external_axios_default().create({
+                baseURL: config_env/* ["default"].PUBLIC_BASE_URL_BACKEND_PRINCIPAL */.A.PUBLIC_BASE_URL_BACKEND_PRINCIPAL
+            });
+        }
+        static async post({ url, data, setToken = true }) {
+            return await this.#axios.post(url, data, _api.headers({
+                setToken: setToken
+            }));
+        }
+        static async get({ url, params, setToken = true }) {
+            const queryParams = new URLSearchParams();
+            if (params) {
+                Object.entries(params).forEach(([key, value])=>{
+                    console.log('13');
+                    if (value !== null && value !== undefined) {
+                        console.log('14');
+                        queryParams.append(key, value);
+                        console.log('15');
+                    }
+                });
+            }
+            const queryString = queryParams.toString();
+            const fullUrl = queryString ? `${url}?${queryString}` : url;
+            return await this.#axios.get(fullUrl, _api.headers({
+                setToken: setToken
+            }));
+        }
+        static async patch({ url, data, setToken = true }) {
+            return await this.#axios.patch(url, data, _api.headers({
+                setToken: setToken
+            }));
+        }
+        static async delete({ url }) {
+            return await this.#axios.delete(url);
+        }
+    };
+    static headers({ setToken = true }) {
+        const get_auth_user = src_utils.session_sorage.get_item_session_storage("auth_user");
+        if (setToken === true) {
+            return {
+                headers: {
+                    Authorization: `Bearer ${get_auth_user?.data?.usuario?.token}`,
+                    "Content-type": "application/json"
+                }
+            };
+        } else {
+            return {
+                headers: {
+                    "Content-type": "application/json"
+                }
+            };
+        }
+    }
+};
+/* export default */ const utils_api = (_api_api);
+
+;// CONCATENATED MODULE: ./src/utils/_data.ts
+const _data = class _data {
+    static YYYY_MM_DD_00_00_00(newData) {
+        let dataAtual = new Date();
+        if (newData) {
+            dataAtual = new Date(newData);
+        }
+        const options = {
+            timeZone: "America/Sao_Paulo",
+            ano: "numeric",
+            mes: "numeric",
+            dia: "numeric",
+            hora: "numeric"
+        };
+        const horarioFormatado = dataAtual.toLocaleString("pt-BR", options);
+        const [data, hora] = horarioFormatado.split(",");
+        const [dia, mes, ano] = data.split("/");
+        return `${ano}-${mes}-${dia} ${hora}`;
+    }
+    static DD_MM_YYYY_00_00_00(newData) {
+        let dataAtual = new Date();
+        if (newData) {
+            dataAtual = new Date(newData);
+        }
+        const options = {
+            timeZone: "America/Sao_Paulo",
+            ano: "numeric",
+            mes: "numeric",
+            dia: "numeric",
+            hora: "numeric"
+        };
+        return dataAtual.toLocaleString("pt-BR", options);
+    }
+    static DD_MM_YYYY_00_00(newData) {
+        let dataAtual = new Date();
+        if (newData) {
+            dataAtual = new Date(newData);
+        }
+        const options = {
+            timeZone: "America/Sao_Paulo",
+            ano: "numeric",
+            mes: "numeric",
+            dia: "numeric",
+            hora: "numeric"
+        };
+        const dataFormatada = dataAtual.toLocaleString("pt-BR", options).replace(",", "");
+        return dataFormatada;
+    }
+    static DD_MM_YYYY(newData) {
+        let dataAtual = new Date();
+        if (newData) {
+            dataAtual = new Date(newData);
+        }
+        const options = {
+            timeZone: "America/Sao_Paulo",
+            ano: "numeric",
+            mes: "numeric",
+            dia: "numeric",
+            hora: "numeric"
+        };
+        return dataAtual.toLocaleString("pt-BR", options);
+    }
+    static YYYY_MM_DD(newData) {
+        let dataAtual = new Date();
+        if (newData) {
+            dataAtual = new Date(newData);
+        }
+        const options = {
+            timeZone: "America/Sao_Paulo",
+            ano: "numeric",
+            mes: "numeric",
+            dia: "numeric",
+            hora: "numeric"
+        };
+        const horarioFormatado = dataAtual.toLocaleString("pt-BR", options);
+        const [data] = horarioFormatado.split(",");
+        const [dia, mes, ano] = data.split("/");
+        return `${ano}-${mes}-${dia}`;
+    }
+    static DIFERENCA_SEGUNDOS(data) {
+        var dataInicial = new Date(data);
+        var dataAtual = new Date();
+        var diferenca = Number(dataAtual) - Number(dataInicial);
+        var diferencaEmSegundos = Math.floor(diferenca / 1000);
+        return diferencaEmSegundos;
+    }
+    static DIFERENCA_DIAS(data) {
+        var dataInicial = new Date(data);
+        var dataAtual = new Date();
+        var diferenca = dataAtual.getTime() - dataInicial.getTime(); // Obtém a diferença em milissegundos
+        var diferencaEmDias = Math.floor(diferenca / (1000 * 60 * 60 * 24)); // Calcula a diferença em dias
+        return diferencaEmDias;
+    }
+};
+/* export default */ const utils_data = (_data);
+
+;// CONCATENATED MODULE: ./src/utils/_form.ts
+class _form {
+    static regex_cpf_cnpj(value) {
+        let tempValue = value.replace(/\D/g, "");
+        if (tempValue.length > 14) {
+            tempValue = tempValue.slice(0, 14);
+        }
+        if (tempValue.length <= 11) {
+            tempValue = tempValue.replace(/^(\d{0,3})(\d{0,3})(\d{0,3})(\d{0,2})$/, (match, p1, p2, p3, p4)=>{
+                let result = p1;
+                if (p2) result += "." + p2;
+                if (p3) result += "." + p3;
+                if (p4) result += "-" + p4;
+                return result;
+            });
+        } else {
+            tempValue = tempValue.replace(/^(\d{0,2})(\d{0,3})(\d{0,3})(\d{0,4})(\d{0,2})$/, (match, p1, p2, p3, p4, p5)=>{
+                let result = p1;
+                if (p2) result += "." + p2;
+                if (p3) result += "." + p3;
+                if (p4) result += "/" + p4;
+                if (p5) result += "-" + p5;
+                return result;
+            });
+        }
+        return tempValue;
+    }
+    static formatar_cpf(value) {
+        const cpf = value.replace(/\D/g, "");
+        if (cpf.length > 11) {
+            return cpf.slice(0, 11);
+        }
+        return cpf.replace(/^(\d{0,3})(\d{0,3})(\d{0,3})(\d{0,2})$/, (match, p1, p2, p3, p4)=>{
+            let result = p1;
+            if (p2) result += "." + p2;
+            if (p3) result += "." + p3;
+            if (p4) result += "-" + p4;
+            return result;
+        });
+    }
+    static formatar_cnpj(value) {
+        const cnpj = value.replace(/\D/g, "");
+        if (cnpj.length > 14) {
+            return cnpj.slice(0, 14);
+        }
+        return cnpj.replace(/^(\d{0,2})(\d{0,3})(\d{0,3})(\d{0,4})(\d{0,2})$/, (match, p1, p2, p3, p4, p5)=>{
+            let result = p1;
+            if (p2) result += "." + p2;
+            if (p3) result += "." + p3;
+            if (p4) result += "/" + p4;
+            if (p5) result += "-" + p5;
+            return result;
+        });
+    }
+    static formatar_cep(value) {
+        const cep = value.replace(/\D/g, "");
+        if (cep.length > 8) {
+            return cep.slice(0, 8);
+        }
+        return cep.replace(/^(\d{0,5})(\d{0,3})$/, (match, p1, p2)=>{
+            if (p2) return `${p1}-${p2}`;
+            return p1;
+        });
+    }
+    static formatar_telefone_fixo(value) {
+        const telefone = value.replace(/\D/g, "");
+        if (telefone.length > 10) {
+            return telefone.slice(0, 10);
+        }
+        return telefone.replace(/^(\d{0,2})(\d{0,4})(\d{0,4})$/, (match, p1, p2, p3)=>{
+            let result = "";
+            if (p1) result += `(${p1}`;
+            if (p2) result += `) ${p2}`;
+            if (p3) result += `-${p3}`;
+            return result;
+        });
+    }
+    static formatar_celular(value) {
+        const celular = value.replace(/\D/g, "");
+        if (celular.length > 11) {
+            return celular.slice(0, 11);
+        }
+        return celular.replace(/^(\d{0,2})(\d{0,5})(\d{0,4})$/, (match, p1, p2, p3)=>{
+            let result = "";
+            if (p1) result += `(${p1}`;
+            if (p2) result += `) ${p2}`;
+            if (p3) result += `-${p3}`;
+            return result;
+        });
+    }
+    static formatar_nome(name) {
+        const lowercaseWords = [
+            "de",
+            "da",
+            "do",
+            "das",
+            "dos",
+            "e",
+            "a",
+            "o"
+        ];
+        const words = name.toLowerCase().split(" ");
+        const formattedWords = words.map((word, index)=>{
+            if (index === 0) {
+                return word.charAt(0).toUpperCase() + word.slice(1);
+            }
+            if (lowercaseWords.includes(word)) {
+                return word;
+            }
+            return word.charAt(0).toUpperCase() + word.slice(1);
+        });
+        return formattedWords.join(" ");
+    }
+    static formatar_reais_br(value) {
+        let num = value.replace(/\D/g, "");
+        return new Intl.NumberFormat("pt-BR", {
+            style: "currency",
+            currency: "BRL",
+            minimumFractionDigits: 2
+        }).format(Number(num) / 100);
+    }
+}
+/* export default */ const utils_form = (_form);
+
+;// CONCATENATED MODULE: ./src/utils/_geral.ts
+const geral = class geral {
+    static slice_file_name(filename, maxLength = 30) {
+        if (!filename || typeof filename !== "string") return "";
+        // Encontra a última ocorrência do ponto para identificar a extensão
+        const lastDotIndex = filename.lastIndexOf(".");
+        // Se não houver extensão, trunca diretamente
+        if (lastDotIndex === -1) {
+            return filename.length > maxLength ? filename.substring(0, maxLength - 3) + "..." : filename;
+        }
+        const name = filename.substring(0, lastDotIndex);
+        const extension = filename.substring(lastDotIndex);
+        // Se o nome + extensão é menor que o máximo, retorna completo
+        if (filename.length <= maxLength) return filename;
+        // Calcula quanto espaço temos para o nome
+        // Considerando: extensão + '...' + 1 caractere do nome
+        const availableLength = maxLength - extension.length - 3;
+        if (availableLength <= 0) {
+            // Se não há espaço suficiente nem para 1 caractere do nome
+            return name.substring(0, 1) + "..." + extension;
+        }
+        // Trunca o nome e mantém a extensão
+        return name.substring(0, availableLength) + "..." + extension;
+    }
+    static extrair_id(array_enviado) {
+        const ids = [];
+        for(let i = 0; i < array_enviado.length; i++){
+            if (array_enviado[i]?._id) ids.push(array_enviado[i]._id);
+        }
+        return ids;
+    }
+    static gerar_id = (length = 32)=>{
+        // Caracteres permitidos (apenas alfanuméricos)
+        const chars = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";
+        // Timestamp em formato hexadecimal (sem separadores)
+        const timestamp = Date.now().toString(16) + performance.now().toString(16).replace(".", "");
+        // Inicializa resultado com timestamp para garantir unicidade temporal
+        let result = timestamp;
+        // Adiciona caracteres aleatórios até atingir o comprimento desejado
+        while(result.length < length){
+            const randomIndex = Math.floor(Math.random() * chars.length);
+            result += chars[randomIndex];
+        }
+        // Combina com características do navegador para aumentar a unicidade
+        const navigatorData = (window.navigator.userAgent + screen.width + screen.height).split("").map((c)=>c.charCodeAt(0)).reduce((a, b)=>a + b, 0).toString(36);
+        // Combina os dados e corta para o tamanho correto
+        const finalResult = (result + navigatorData).replace(/[^a-zA-Z0-9]/g, "");
+        // Garante o comprimento exato
+        return finalResult.substring(0, length);
+    };
+};
+/* export default */ const _geral = (geral);
+
+;// CONCATENATED MODULE: ./src/utils/_local_storage.ts
+const _local_storage = class _local_storage {
+    static adicionar_item_local_storage(chave, novoItem) {
+        try {
+            const valorAtual = window.localStorage.getItem(chave);
+            const listaAtual = valorAtual ? JSON.parse(valorAtual) : [];
+            const newDataItem = {
+                ...listaAtual,
+                ...novoItem
+            };
+            window.localStorage.setItem(chave, JSON.stringify(newDataItem));
+        } catch (error) {
+            console.log(error);
+        }
+    }
+    static set_local_storage_sem_incremento(chave, novoItem) {
+        try {
+            window.localStorage.setItem(chave, JSON.stringify(novoItem));
+        } catch (error) {
+            console.log(error);
+        }
+    }
+    static get_item_local_storage(chave) {
+        try {
+            if (typeof window !== "undefined") {
+                const valorAtual = window.localStorage.getItem(chave);
+                return valorAtual ? JSON.parse(valorAtual) : valorAtual;
+            }
+            return;
+        } catch (error) {
+            console.log(error);
+        }
+    }
+    static remover_item_local_storage(chave) {
+        try {
+            window.localStorage.removeItem(chave);
+        } catch (error) {
+            console.log(error);
+        }
+    }
+};
+// Para usar a classe, você pode fazer:
+/* export default */ const utils_local_storage = (_local_storage);
+
+;// CONCATENATED MODULE: ./src/utils/_update_context.ts
+const _update_context = class _update_context {
+    static set_new_item_end = ({ oldArray = [], newItem = [], key = "_id" })=>{
+        try {
+            const hasValidIds = Array.isArray(newItem) ? newItem.every((item)=>item?.[key]) : newItem?.[key];
+            const newItemArray = hasValidIds ? Array.isArray(newItem) ? newItem : [
+                newItem
+            ] : oldArray;
+            if (oldArray?.length === 0) return newItemArray;
+            // Cria uma cópia rasa do array original
+            const updatedArray = [
+                ...oldArray
+            ];
+            // Itera sobre os novos itens
+            newItemArray.forEach((novoItem)=>{
+                const index = updatedArray.findIndex((oldItem)=>oldItem?.[key] === novoItem?.[key]);
+                if (index !== -1) {
+                    // Atualiza o item existente mantendo as propriedades antigas que não estão no novo item
+                    novoItem.new = false;
+                    updatedArray[index] = {
+                        ...updatedArray[index],
+                        ...novoItem
+                    };
+                } else {
+                    // Adiciona novo item no FINAL com a propriedade new = true
+                    novoItem.new = true;
+                    updatedArray.push(novoItem); // Usa push em vez de unshift
+                }
+            });
+            return updatedArray;
+        } catch (error) {
+            console.error("Erro ao atualizar array:", error);
+            return oldArray; // Retorna o array original em caso de erro
+        }
+    };
+    static update_array_itens = ({ oldArray = [], newItem = [], key = "_id" })=>{
+        try {
+            const hasValidIds = Array.isArray(newItem) ? newItem.every((item)=>item?.[key]) : newItem?.[key];
+            const newItemArray = hasValidIds ? Array.isArray(newItem) ? newItem : [
+                newItem
+            ] : oldArray;
+            if (oldArray?.length === 0) return newItemArray;
+            // Cria uma cópia rasa do array original
+            const updatedArray = [
+                ...oldArray
+            ];
+            // Itera sobre os novos itens
+            newItemArray.forEach((novoItem)=>{
+                const index = updatedArray.findIndex((oldItem)=>oldItem?.[key] === novoItem?.[key]);
+                if (index !== -1) {
+                    // Atualiza o item existente mantendo as propriedades antigas que não estão no novo item
+                    novoItem.new = false;
+                    updatedArray[index] = {
+                        ...updatedArray[index],
+                        ...novoItem
+                    };
+                } else {
+                    // Adiciona novo item no início com a propriedade new = true
+                    novoItem.new = true;
+                    updatedArray.unshift(novoItem);
+                }
+            });
+            return updatedArray;
+        } catch (error) {
+            console.error("Erro ao atualizar array:", error);
+            return oldArray; // Retorna o array original em caso de erro
+        }
+    };
+    static remove_array_items = ({ oldArray = [], itemsToRemove = [], key = "_id" })=>{
+        try {
+            // Verifica se os argumentos são válidos
+            if (!Array.isArray(oldArray) || oldArray.length === 0) return oldArray;
+            if (!itemsToRemove) return oldArray;
+            // Converte itemsToRemove para array se for um único item
+            const itemsArray = Array.isArray(itemsToRemove) ? itemsToRemove : [
+                itemsToRemove
+            ];
+            // Se não houver itens para remover, retorna o array original
+            if (itemsArray.length === 0) return oldArray;
+            // Cria um Set com os IDs dos itens a serem removidos para busca mais eficiente
+            const removeIds = new Set(itemsArray.filter((item)=>item?.[key]).map((item)=>item[key]));
+            // Filtra o array original removendo os itens cujos IDs estão no Set
+            const updatedArray = oldArray.filter((item)=>!removeIds.has(item?.[key]));
+            return updatedArray;
+        } catch (error) {
+            console.error("Erro ao remover itens do array:", error);
+            return oldArray; // Retorna o array original em caso de erro
+        }
+    };
+    static compare_arrays({ arrayAntigo, arrayNovo }) {
+        // Cria Sets para performance
+        const idsAntigos = new Set(arrayAntigo.map((item)=>item._id));
+        const idsNovos = new Set(arrayNovo.map((item)=>item._id));
+        // Mantém apenas os itens do array antigo que ainda existem no novo
+        const itensMantidos = arrayAntigo.filter((item)=>idsNovos.has(item._id));
+        // Adiciona os itens novos que não existiam no array antigo
+        const itensNovos = arrayNovo.filter((item)=>!idsAntigos.has(item._id));
+        // Combina os arrays
+        return [
+            ...itensMantidos,
+            ...itensNovos
+        ];
+    }
+};
+/* export default */ const utils_update_context = (_update_context);
+
+;// CONCATENATED MODULE: ./src/utils/_session_storage.ts
+const _session_storage = class _session_storage {
+    static adicionar_item_session_storage({ chave, novoItem }) {
+        try {
+            const valorAtual = window.sessionStorage.getItem(chave);
+            const listaAtual = valorAtual ? JSON.parse(valorAtual) : [];
+            const newDataItem = {
+                ...listaAtual,
+                ...novoItem
+            };
+            window.sessionStorage.setItem(chave, JSON.stringify(newDataItem));
+        } catch (error) {
+            console.error(error);
+        }
+    }
+    static set_session_storage_sem_incremento({ chave, novoItem }) {
+        try {
+            window.sessionStorage.setItem(chave, JSON.stringify(novoItem));
+        } catch (error) {
+            console.error(error);
+        }
+    }
+    static get_item_session_storage(chave) {
+        try {
+            if (typeof window !== "undefined") {
+                const valorAtual = window.sessionStorage.getItem(chave);
+                return valorAtual ? JSON.parse(valorAtual) : valorAtual;
+            }
+            return;
+        } catch (error) {
+            console.error(error);
+        }
+    }
+    static remover_item_session_storage(chave) {
+        try {
+            window.sessionStorage.removeItem(chave);
+        } catch (error) {
+            console.error(error);
+        }
+    }
+};
+/* export default */ const utils_session_storage = (_session_storage);
+
+;// CONCATENATED MODULE: ./src/utils/index.ts
+
+
+
+
+
+
+
+const utils = class utils {
+    static api = utils_api;
+    static data = utils_data;
+    static form = utils_form;
+    static geral = _geral;
+    static local_storage = utils_local_storage;
+    static update_context = utils_update_context;
+    static session_sorage = utils_session_storage;
+};
+/* export default */ const src_utils = (utils);
+
+
+},
+
+});
+// The module cache
+var __webpack_module_cache__ = {};
+
+// The require function
+function __webpack_require__(moduleId) {
+
+// Check if module is in cache
+var cachedModule = __webpack_module_cache__[moduleId];
+if (cachedModule !== undefined) {
+return cachedModule.exports;
+}
+// Create a new module (and put it into the cache)
+var module = (__webpack_module_cache__[moduleId] = {
+exports: {}
+});
+// Execute the module function
+__webpack_modules__[moduleId](module, module.exports, __webpack_require__);
+
+// Return the exports of the module
+return module.exports;
+
+}
+
+// webpack/runtime/compat_get_default_export
+(() => {
+// getDefaultExport function for compatibility with non-ESM modules
+__webpack_require__.n = (module) => {
+	var getter = module && module.__esModule ?
+		() => (module['default']) :
+		() => (module);
+	__webpack_require__.d(getter, { a: getter });
+	return getter;
+};
+
+})();
+// webpack/runtime/define_property_getters
+(() => {
+__webpack_require__.d = (exports, definition) => {
+	for(var key in definition) {
+        if(__webpack_require__.o(definition, key) && !__webpack_require__.o(exports, key)) {
+            Object.defineProperty(exports, key, { enumerable: true, get: definition[key] });
+        }
+    }
+};
+})();
+// webpack/runtime/has_own_property
+(() => {
+__webpack_require__.o = (obj, prop) => (Object.prototype.hasOwnProperty.call(obj, prop))
+})();
+// webpack/runtime/make_namespace_object
+(() => {
+// define __esModule on exports
+__webpack_require__.r = (exports) => {
+	if(typeof Symbol !== 'undefined' && Symbol.toStringTag) {
+		Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+	}
+	Object.defineProperty(exports, '__esModule', { value: true });
+};
+})();
+var __webpack_exports__ = {};
+// This entry needs to be wrapped in an IIFE because it needs to be isolated against other modules in the chunk.
+(() => {
+// ESM COMPAT FLAG
+__webpack_require__.r(__webpack_exports__);
+
+// EXPORTS
+__webpack_require__.d(__webpack_exports__, {
+  config_env_core: () => (/* reexport */ config_env/* ["default"] */.A),
+  TypesCore: () => (/* reexport */ types),
+  utils: () => (/* reexport */ utils["default"])
+});
+
+// EXTERNAL MODULE: ./src/config_env/index.ts
+var config_env = __webpack_require__("./src/config_env/index.ts");
+;// CONCATENATED MODULE: external "zod/v4"
+const v4_namespaceObject = require("zod/v4");
+var v4_default = /*#__PURE__*/__webpack_require__.n(v4_namespaceObject);
+;// CONCATENATED MODULE: ./src/types/_usuario.ts
+
+(function(TypeControllerUsuario) {
+    TypeControllerUsuario.AppEnum = [
+        "service-usuario",
+        "service-financeiro",
+        "service-pages-ai"
+    ];
+    TypeControllerUsuario.UsuarioTipoEnum = [
+        "padrao"
+    ];
+    const AppEnumZod = v4_default()["enum"]([
+        "service-usuario",
+        "service-financeiro",
+        "service-pages-ai"
+    ]);
+    const UsuarioTipoEnumZod = v4_default()["enum"](TypeControllerUsuario.UsuarioTipoEnum);
+})(_usuario_TypeControllerUsuario || (_usuario_TypeControllerUsuario = {}));
+/* export default */ const _usuario = (_usuario_TypeControllerUsuario);
+var _usuario_TypeControllerUsuario;
+
+;// CONCATENATED MODULE: ./src/types/_type_response.ts
+
+(function(TypeControllerResponse) {
+    const StatusSchema = v4_default().union([
+        v4_default().literal(200),
+        v4_default().literal(201),
+        v4_default().literal(202),
+        v4_default().literal(204),
+        v4_default().literal(400),
+        v4_default().literal(401),
+        v4_default().literal(403),
+        v4_default().literal(404),
+        v4_default().literal(409),
+        v4_default().literal(422),
+        v4_default().literal(500),
+        v4_default().literal(428),
+        v4_default().literal(405)
+    ]);
+    const TypeSchema = v4_default().union([
+        v4_default().literal("success"),
+        v4_default().literal("warning"),
+        v4_default().literal("error")
+    ]).default("success");
+    const CodeSchema = v4_default().union([
+        v4_default().literal("SUCCESS"),
+        v4_default().literal("ACTION_REQUIRED"),
+        v4_default().literal("CREATED"),
+        v4_default().literal("WARNING"),
+        v4_default().literal("AUTHORIZATION_ERROR"),
+        v4_default().literal("SCHEMA_VALIDATION"),
+        v4_default().literal("SERVER_ERROR"),
+        v4_default().literal("UNAUTHORIZED"),
+        v4_default().literal("INVALID_TOKEN"),
+        v4_default().literal("NOT_FOUND"),
+        v4_default().literal("SUCCESS_FILE"),
+        v4_default().literal("DATABASE_ERROR")
+    ]);
+    const BaseResponseSchema = v4_default().object({
+        status: StatusSchema,
+        code: CodeSchema,
+        type: TypeSchema,
+        message: v4_default().string(),
+        results: v4_default().unknown().optional(),
+        error: v4_default().unknown().optional()
+    });
+    (function(C) {
+        C.InputSchema = v4_default().object({
+            status: StatusSchema,
+            code: CodeSchema,
+            type: TypeSchema.optional().default("success"),
+            message: v4_default().string().optional(),
+            results: v4_default().any(),
+            c: v4_default().custom()
+        });
+        const FileResponseParamsSchema = v4_default().object({
+            status: StatusSchema,
+            message: v4_default().string().optional(),
+            file_buffer: v4_default().union([
+                v4_default()["instanceof"](Blob),
+                v4_default()["instanceof"](ArrayBuffer),
+                v4_default()["instanceof"](Uint8Array)
+            ]),
+            content_type: v4_default().string(),
+            filename: v4_default().string().optional(),
+            c: v4_default().custom().optional()
+        });
+    })(TypeControllerResponse.C || (TypeControllerResponse.C = {}));
+    (function(Error) {
+        Error.InputSchema = v4_default().object({
+            message: v4_default().string().optional(),
+            results: v4_default().union([
+                v4_default().array(v4_default().unknown()),
+                v4_default().unknown()
+            ]).optional(),
+            type: TypeSchema.optional().default("success"),
+            code: CodeSchema,
+            status: v4_default().number().optional().default(200)
+        });
+    })(TypeControllerResponse.Error || (TypeControllerResponse.Error = {}));
+})(_type_response_TypeControllerResponse || (_type_response_TypeControllerResponse = {}));
+/* export default */ const _type_response = (_type_response_TypeControllerResponse);
+var _type_response_TypeControllerResponse;
+
+;// CONCATENATED MODULE: ./src/types/index.ts
+// ENTIDADES TIPADAS
+
+//GERAL
+
+(function(t) {
+    (function(Controller) {
+        Controller.Usuario = _usuario;
+    })(t.Controller || (t.Controller = {}));
+    (function(Geral) {
+        Geral.Response = _type_response;
+    })(t.Geral || (t.Geral = {}));
+})(types_t || (types_t = {}));
+/* export default */ const types = (types_t);
+var types_t;
+
+// EXTERNAL MODULE: ./src/utils/index.ts + 8 modules
+var utils = __webpack_require__("./src/utils/index.ts");
+;// CONCATENATED MODULE: ./src/index.browser.ts
+
+
+
+
+})();
+
+exports.TypesCore = __webpack_exports__.TypesCore;
+exports.config_env_core = __webpack_exports__.config_env_core;
+exports.utils = __webpack_exports__.utils;
+for(var __rspack_i in __webpack_exports__) {
+  if(["TypesCore","config_env_core","utils"].indexOf(__rspack_i) === -1) {
+    exports[__rspack_i] = __webpack_exports__[__rspack_i];
+  }
+}
+Object.defineProperty(exports, '__esModule', { value: true });