@navservice/core 1.25.0

package/build/es/index.node.js

@@ -0,0 +1,341 @@
+import v4 from "zod/v4";
+import { SignJWT, jwtVerify } from "jose";
+import { randomBytes, scrypt, timingSafeEqual } from "node:crypto";
+import { promisify } from "node:util";
+const set_response = class {
+    static c = class {
+        static SUCCESS({ message, results, c }) {
+            const payload = {
+                status: 200,
+                code: "SUCCESS",
+                type: "success",
+                message: message || "Realizado com sucesso!",
+                results: results || []
+            };
+            if (c) return c.json(payload, {
+                status: 200
+            });
+            return payload;
+        }
+        static ACTION_REQUIRED({ message, results, c }) {
+            const payload = {
+                status: 428,
+                code: "ACTION_REQUIRED",
+                type: "warning",
+                message: message || "Ação adicional necessária!",
+                results: results || []
+            };
+            if (c) return c.json(payload, {
+                status: 428
+            });
+            return payload;
+        }
+        static CREATED({ message, results, c }) {
+            const payload = {
+                status: 201,
+                code: "CREATED",
+                type: "success",
+                message: message || "Criado com sucesso!",
+                results: results || []
+            };
+            return c ? c.json(payload, {
+                status: 201
+            }) : payload;
+        }
+        static WARNING({ message, results, c }) {
+            const payload = {
+                status: 400,
+                code: "WARNING",
+                type: "warning",
+                message: message || "Aviso!",
+                results: results || []
+            };
+            if (c) c.json(payload, {
+                status: 400
+            });
+            throw payload;
+        }
+        static AUTHORIZATION_ERROR({ message, results, c }) {
+            const payload = {
+                status: 405,
+                code: "WARNING",
+                type: "warning",
+                message: message || "Aviso!",
+                results: results || []
+            };
+            if (c) c.json(payload, {
+                status: 405
+            });
+            throw payload;
+        }
+        static DATABASE_ERROR({ message, results, c }) {
+            const payload = {
+                status: 500,
+                code: "DATABASE_ERROR",
+                type: "error",
+                message: message || "Erro no banco de dados!",
+                results: results || []
+            };
+            return c ? c.json(payload, {
+                status: 500
+            }) : payload;
+        }
+        static SERVER_ERROR({ error, c }) {
+            if (error instanceof v4.ZodError) {
+                const payload = {
+                    status: 500,
+                    code: "SCHEMA_VALIDATION",
+                    type: "warning",
+                    message: "Erro ao validar dados!",
+                    results: v4.treeifyError(error)
+                };
+                return c.json(payload, {
+                    status: 500
+                });
+            }
+            const payload = {
+                status: error?.status || 500,
+                code: error?.code || "SERVER_ERROR",
+                type: error?.type || "error",
+                message: error?.message || "Erro interno no servidor!",
+                results: error?.results || []
+            };
+            return c.json(payload, {
+                status: error?.status || error?.status || 500
+            });
+        }
+        static UNAUTHORIZED({ message, c }) {
+            const payload = {
+                status: 401,
+                code: "UNAUTHORIZED",
+                type: "error",
+                message: message || "Não autorizado!",
+                results: []
+            };
+            return c ? c.json(payload, {
+                status: 401
+            }) : payload;
+        }
+        static INVALID_TOKEN({ message, c }) {
+            const payload = {
+                status: 401,
+                code: "INVALID_TOKEN",
+                type: "warning",
+                message: message || "Token inválido!",
+                results: []
+            };
+            return c ? c.json(payload, {
+                status: 401
+            }) : payload;
+        }
+        static NOT_FOUND({ message, c }) {
+            const payload = {
+                status: 404,
+                code: "NOT_FOUND",
+                type: "error",
+                message: message || "Recurso não encontrado!",
+                results: []
+            };
+            return c ? c.json(payload, {
+                status: 404
+            }) : payload;
+        }
+        static async SUCCESS_FILE({ message, file_buffer, content_type, filename, c }) {
+            if (c && content_type) {
+                const headers = {
+                    "Content-Type": content_type,
+                    "Content-Disposition": filename ? `inline; filename="${filename}"` : "inline"
+                };
+                return new Response(file_buffer, {
+                    status: 200,
+                    headers
+                });
+            }
+            const payload = {
+                status: 200,
+                code: "SUCCESS_FILE",
+                type: "success",
+                message: message || "Erro ao retornar arquivo!",
+                results: []
+            };
+            return c ? c.json(payload, {
+                status: 200
+            }) : payload;
+        }
+    };
+    static error = class {
+        static ACTION_REQUIRED({ message, results }) {
+            const payload = {
+                status: 428,
+                code: "ACTION_REQUIRED",
+                type: "warning",
+                message: message || "Ação adicional necessária!",
+                results: results || []
+            };
+            throw payload;
+        }
+        static WARNING({ message, results }) {
+            const payload = {
+                status: 400,
+                code: "WARNING",
+                type: "warning",
+                message: message || "Aviso!",
+                results: results || []
+            };
+            throw payload;
+        }
+        static AUTHORIZATION_ERROR({ message, results }) {
+            const payload = {
+                status: 400,
+                code: "WARNING",
+                type: "warning",
+                message: message || "Aviso!",
+                results: results || []
+            };
+            throw payload;
+        }
+        static DATABASE_ERROR({ message, results }) {
+            const payload = {
+                status: 405,
+                code: "DATABASE_ERROR",
+                type: "error",
+                message: message || "Erro no banco de dados!",
+                results: results || []
+            };
+            throw payload;
+        }
+        static SCHEMA_VALIDATION({ results }) {
+            const payload = {
+                status: 500,
+                code: "SCHEMA_VALIDATION",
+                type: "error",
+                message: "Erro ao validar dados!",
+                results: results || []
+            };
+            throw payload;
+        }
+        static UNAUTHORIZED({ message }) {
+            const payload = {
+                status: 401,
+                code: "UNAUTHORIZED",
+                type: "error",
+                message: message || "Não autorizado!"
+            };
+            throw payload;
+        }
+        static INVALID_TOKEN({ message }) {
+            const payload = {
+                status: 401,
+                code: "INVALID_TOKEN",
+                type: "warning",
+                message: message || "Token inválido!",
+                results: []
+            };
+            throw payload;
+        }
+        static NOT_FOUND({ message }) {
+            const payload = {
+                status: 404,
+                code: "NOT_FOUND",
+                type: "error",
+                message: message || "Recurso não encontrado!"
+            };
+            throw payload;
+        }
+    };
+};
+const _set_response = set_response;
+const _token = class {
+    static async verificar_token(c, next) {
+        try {
+            const authHeader = c.req.header("Authorization");
+            if (!authHeader) return src_helpers.set_response.c.INVALID_TOKEN({
+                message: 'token não enviado!!!',
+                c: c,
+                results: []
+            });
+            const token = authHeader.split(" ")[1];
+            if (!token) return src_helpers.set_response.c.INVALID_TOKEN({
+                message: 'Acesso negado!!!',
+                c: c,
+                results: []
+            });
+            const secret = new TextEncoder().encode(c.env.JSON_WEB_TOKEN_AUTH_USER);
+            const { payload } = await jwtVerify(token, secret);
+            if (!payload._id || !payload.email) return src_helpers.set_response.c.INVALID_TOKEN({
+                message: 'Token inválido!!!!',
+                c: c,
+                results: []
+            });
+            const setar_token = {
+                _id: payload._id,
+                email: payload.email,
+                ativo: payload.ativo,
+                data_criacao: payload.data_criacao,
+                nome: payload.nome,
+                app: payload.app,
+                usuario_tipo: payload.usuario_tipo
+            };
+            c.set("usuario_auth", setar_token);
+            return await next();
+        } catch (error) {
+            return src_helpers.set_response.c.INVALID_TOKEN({
+                message: 'Token inválido!!!',
+                c: c,
+                results: []
+            });
+        }
+    }
+    static async criar_token_login_usuario({ _id, email, app, usuario_tipo, ativo, data_criacao, nome, c }) {
+        if (!c.env.JSON_WEB_TOKEN_AUTH_USER) return src_helpers.set_response.error.WARNING({
+            message: "Erro ao gerar token!!",
+            results: []
+        });
+        const token = await new SignJWT({
+            _id: _id,
+            email: email,
+            app: app,
+            usuario_tipo: usuario_tipo,
+            ativo: ativo,
+            data_criacao: data_criacao,
+            nome: nome
+        }).setProtectedHeader({
+            alg: "HS256"
+        }).setIssuedAt().sign(new TextEncoder().encode(c.env.JSON_WEB_TOKEN_AUTH_USER)).catch((error)=>src_helpers.set_response.error.WARNING({
+                message: "Erro ao gerar token!",
+                results: error?.message
+            }));
+        return token;
+    }
+};
+const helpers_token = _token;
+const scryptAsync = promisify(scrypt);
+class _secret {
+    static SALT_LENGTH = 22;
+    static KEY_LENGTH = 35;
+    static async gerar_hash_senha(password) {
+        const salt = randomBytes(this.SALT_LENGTH);
+        const derivedKey = await scryptAsync(password, salt, this.KEY_LENGTH);
+        return salt.toString('base64') + '.' + derivedKey.toString('base64');
+    }
+    static async verify({ password, dashed_senha }) {
+        try {
+            const [saltBase64, hashBase64] = dashed_senha.split('.');
+            if (!saltBase64 || !hashBase64) return false;
+            const salt = Buffer.from(saltBase64, 'base64');
+            const storedHash = Buffer.from(hashBase64, 'base64');
+            const derivedKey = await scryptAsync(password, salt, this.KEY_LENGTH);
+            return timingSafeEqual(storedHash, derivedKey);
+        } catch  {
+            return false;
+        }
+    }
+}
+const helpers_secret = _secret;
+class helpers {
+    static set_response = _set_response;
+    static token = helpers_token;
+    static secret = helpers_secret;
+}
+const src_helpers = helpers;
+export { src_helpers as helpers };

package/build/es/types/_type_response.d.ts

@@ -0,0 +1,54 @@
+import t from ".";
+import z4 from "zod/v4";
+declare namespace TypeControllerResponse {
+    const BaseResponseSchema: z4.ZodObject<{
+        status: z4.ZodUnion<readonly [z4.ZodLiteral<200>, z4.ZodLiteral<201>, z4.ZodLiteral<202>, z4.ZodLiteral<204>, z4.ZodLiteral<400>, z4.ZodLiteral<401>, z4.ZodLiteral<403>, z4.ZodLiteral<404>, z4.ZodLiteral<409>, z4.ZodLiteral<422>, z4.ZodLiteral<500>, z4.ZodLiteral<428>, z4.ZodLiteral<405>]>;
+        code: z4.ZodUnion<readonly [z4.ZodLiteral<"SUCCESS">, z4.ZodLiteral<"ACTION_REQUIRED">, z4.ZodLiteral<"CREATED">, z4.ZodLiteral<"WARNING">, z4.ZodLiteral<"AUTHORIZATION_ERROR">, z4.ZodLiteral<"SCHEMA_VALIDATION">, z4.ZodLiteral<"SERVER_ERROR">, z4.ZodLiteral<"UNAUTHORIZED">, z4.ZodLiteral<"INVALID_TOKEN">, z4.ZodLiteral<"NOT_FOUND">, z4.ZodLiteral<"SUCCESS_FILE">, z4.ZodLiteral<"DATABASE_ERROR">]>;
+        type: z4.ZodDefault<z4.ZodUnion<readonly [z4.ZodLiteral<"success">, z4.ZodLiteral<"warning">, z4.ZodLiteral<"error">]>>;
+        message: z4.ZodString;
+        results: z4.ZodOptional<z4.ZodUnknown>;
+        error: z4.ZodOptional<z4.ZodUnknown>;
+    }, z4.core.$strip>;
+    type BaseResponse<T = unknown> = z4.infer<typeof BaseResponseSchema> & {
+        results?: T;
+    };
+    export namespace C {
+        export const InputSchema: z4.ZodObject<{
+            status: z4.ZodUnion<readonly [z4.ZodLiteral<200>, z4.ZodLiteral<201>, z4.ZodLiteral<202>, z4.ZodLiteral<204>, z4.ZodLiteral<400>, z4.ZodLiteral<401>, z4.ZodLiteral<403>, z4.ZodLiteral<404>, z4.ZodLiteral<409>, z4.ZodLiteral<422>, z4.ZodLiteral<500>, z4.ZodLiteral<428>, z4.ZodLiteral<405>]>;
+            code: z4.ZodUnion<readonly [z4.ZodLiteral<"SUCCESS">, z4.ZodLiteral<"ACTION_REQUIRED">, z4.ZodLiteral<"CREATED">, z4.ZodLiteral<"WARNING">, z4.ZodLiteral<"AUTHORIZATION_ERROR">, z4.ZodLiteral<"SCHEMA_VALIDATION">, z4.ZodLiteral<"SERVER_ERROR">, z4.ZodLiteral<"UNAUTHORIZED">, z4.ZodLiteral<"INVALID_TOKEN">, z4.ZodLiteral<"NOT_FOUND">, z4.ZodLiteral<"SUCCESS_FILE">, z4.ZodLiteral<"DATABASE_ERROR">]>;
+            type: z4.ZodDefault<z4.ZodOptional<z4.ZodDefault<z4.ZodUnion<readonly [z4.ZodLiteral<"success">, z4.ZodLiteral<"warning">, z4.ZodLiteral<"error">]>>>>;
+            message: z4.ZodOptional<z4.ZodString>;
+            results: z4.ZodAny;
+            c: z4.ZodCustom<t.Context, t.Context>;
+        }, z4.core.$strip>;
+        export type Input<T = unknown> = z4.infer<typeof InputSchema> & {
+            results?: T;
+        };
+        export type Output<T = unknown> = BaseResponse<T>;
+        const FileResponseParamsSchema: z4.ZodObject<{
+            status: z4.ZodUnion<readonly [z4.ZodLiteral<200>, z4.ZodLiteral<201>, z4.ZodLiteral<202>, z4.ZodLiteral<204>, z4.ZodLiteral<400>, z4.ZodLiteral<401>, z4.ZodLiteral<403>, z4.ZodLiteral<404>, z4.ZodLiteral<409>, z4.ZodLiteral<422>, z4.ZodLiteral<500>, z4.ZodLiteral<428>, z4.ZodLiteral<405>]>;
+            message: z4.ZodOptional<z4.ZodString>;
+            file_buffer: z4.ZodUnion<readonly [z4.ZodCustom<Blob, Blob>, z4.ZodCustom<ArrayBuffer, ArrayBuffer>, z4.ZodCustom<Uint8Array<ArrayBuffer>, Uint8Array<ArrayBuffer>>]>;
+            content_type: z4.ZodString;
+            filename: z4.ZodOptional<z4.ZodString>;
+            c: z4.ZodOptional<z4.ZodCustom<t.Context, t.Context>>;
+        }, z4.core.$strip>;
+        export type FileResponseParams = z4.infer<typeof FileResponseParamsSchema>;
+        export {};
+    }
+    export namespace Error {
+        const InputSchema: z4.ZodObject<{
+            message: z4.ZodOptional<z4.ZodString>;
+            results: z4.ZodOptional<z4.ZodUnion<readonly [z4.ZodArray<z4.ZodUnknown>, z4.ZodUnknown]>>;
+            type: z4.ZodDefault<z4.ZodOptional<z4.ZodDefault<z4.ZodUnion<readonly [z4.ZodLiteral<"success">, z4.ZodLiteral<"warning">, z4.ZodLiteral<"error">]>>>>;
+            code: z4.ZodUnion<readonly [z4.ZodLiteral<"SUCCESS">, z4.ZodLiteral<"ACTION_REQUIRED">, z4.ZodLiteral<"CREATED">, z4.ZodLiteral<"WARNING">, z4.ZodLiteral<"AUTHORIZATION_ERROR">, z4.ZodLiteral<"SCHEMA_VALIDATION">, z4.ZodLiteral<"SERVER_ERROR">, z4.ZodLiteral<"UNAUTHORIZED">, z4.ZodLiteral<"INVALID_TOKEN">, z4.ZodLiteral<"NOT_FOUND">, z4.ZodLiteral<"SUCCESS_FILE">, z4.ZodLiteral<"DATABASE_ERROR">]>;
+            status: z4.ZodDefault<z4.ZodOptional<z4.ZodNumber>>;
+        }, z4.core.$strip>;
+        type Input<T = unknown> = z4.infer<typeof InputSchema> & {
+            results?: T;
+        };
+        type Output<T = unknown> = BaseResponse<T>;
+    }
+    export {};
+}
+export default TypeControllerResponse;

package/build/es/types/_usuario.d.ts

@@ -0,0 +1,39 @@
+import z4 from "zod/v4";
+declare namespace TypeControllerUsuario {
+    export const AppEnum: readonly ["service-usuario", "service-financeiro", "service-pages-ai"];
+    export const UsuarioTipoEnum: readonly ["padrao"];
+    const AppEnumZod: z4.ZodEnum<{
+        "service-usuario": "service-usuario";
+        "service-financeiro": "service-financeiro";
+        "service-pages-ai": "service-pages-ai";
+    }>;
+    const UsuarioTipoEnumZod: z4.ZodEnum<{
+        padrao: "padrao";
+    }>;
+    type App = z4.infer<typeof AppEnumZod>;
+    type UsuarioTipo = z4.infer<typeof UsuarioTipoEnumZod>;
+    export interface Auth {
+        data: {
+            usuario: {
+                _id: string;
+                email: string;
+                nome?: string;
+                imagem?: string;
+                token?: string;
+                data_criacao?: number;
+                ativo?: 0 | 1;
+            };
+        };
+    }
+    export interface TokenPayload {
+        _id: string;
+        email: string;
+        nome: string;
+        data_criacao: number;
+        ativo: 1 | 0;
+        app: App;
+        usuario_tipo: UsuarioTipo;
+    }
+    export {};
+}
+export default TypeControllerUsuario;

package/build/es/types/index.d.ts

@@ -0,0 +1,20 @@
+import { Context as HonoContext } from "hono";
+import TypeControllerUsuario from "./_usuario";
+import TypeControllerResponse from "./_type_response";
+declare namespace t {
+    namespace Controller {
+        export import Usuario = TypeControllerUsuario;
+    }
+    namespace Geral {
+        export import Response = TypeControllerResponse;
+    }
+    interface Context extends HonoContext {
+        env: {
+            AMBIENTE: "PRODUCAO" | "SANDBOX";
+            JSON_WEB_TOKEN_AUTH_USER: string;
+        };
+        set(key: "usuario_auth", params: TypeControllerUsuario.TokenPayload): TypeControllerUsuario.TokenPayload;
+        get(key: "usuario_auth"): TypeControllerUsuario.TokenPayload;
+    }
+}
+export default t;

package/build/es/utils/_api.d.ts

@@ -0,0 +1,41 @@
+import { AxiosResponse } from "axios";
+declare const _api: {
+    new (): {};
+    servidor_service_usuario: {
+        new (): {};
+        get "__#private@#axios"(): import("axios").AxiosInstance;
+        post({ url, data, setToken }: {
+            url: string;
+            data: any;
+            setToken?: boolean;
+        }): Promise<AxiosResponse<any, any, {}>>;
+        get({ url, params, setToken }: {
+            url: string;
+            params?: any;
+            setToken?: boolean;
+        }): Promise<AxiosResponse<any, any, {}>>;
+        patch({ url, data, setToken }: {
+            url: string;
+            data: any;
+            setToken?: boolean;
+        }): Promise<AxiosResponse<any, any, {}>>;
+        delete({ url }: {
+            url: string;
+            setToken?: boolean;
+        }): Promise<AxiosResponse<any, any, {}>>;
+    };
+    headers({ setToken }: {
+        setToken?: boolean;
+    }): {
+        headers: {
+            Authorization: string;
+            "Content-type": string;
+        };
+    } | {
+        headers: {
+            "Content-type": string;
+            Authorization?: undefined;
+        };
+    };
+};
+export default _api;

package/build/es/utils/_data.d.ts

@@ -0,0 +1,11 @@
+declare const _data: {
+    new (): {};
+    YYYY_MM_DD_00_00_00(newData: string): string;
+    DD_MM_YYYY_00_00_00(newData: string): string;
+    DD_MM_YYYY_00_00(newData: string): string;
+    DD_MM_YYYY(newData: string): string;
+    YYYY_MM_DD(newData: string): string;
+    DIFERENCA_SEGUNDOS(data: string): number;
+    DIFERENCA_DIAS(data: string): number;
+};
+export default _data;

package/build/es/utils/_form.d.ts

@@ -0,0 +1,11 @@
+declare class _form {
+    static regex_cpf_cnpj(value: string): string;
+    static formatar_cpf(value: string): string;
+    static formatar_cnpj(value: string): string;
+    static formatar_cep(value: string): string;
+    static formatar_telefone_fixo(value: string): string;
+    static formatar_celular(value: string): string;
+    static formatar_nome(name: string): string;
+    static formatar_reais_br(value: string): string;
+}
+export default _form;

package/build/es/utils/_geral.d.ts

@@ -0,0 +1,9 @@
+declare const geral: {
+    new (): {};
+    slice_file_name(filename: string, maxLength?: number): string;
+    extrair_id(array_enviado: Array<{
+        _id?: string;
+    }>): string[];
+    gerar_id: (length?: number) => string;
+};
+export default geral;

package/build/es/utils/_local_storage.d.ts

@@ -0,0 +1,8 @@
+declare const _local_storage: {
+    new (): {};
+    adicionar_item_local_storage(chave: string, novoItem: any): void;
+    set_local_storage_sem_incremento(chave: string, novoItem: any): void;
+    get_item_local_storage(chave: string): any;
+    remover_item_local_storage(chave: string): void;
+};
+export default _local_storage;

package/build/es/utils/_session_storage.d.ts

@@ -0,0 +1,14 @@
+declare const _session_storage: {
+    new (): {};
+    adicionar_item_session_storage({ chave, novoItem }: {
+        chave: string;
+        novoItem: any;
+    }): void;
+    set_session_storage_sem_incremento({ chave, novoItem }: {
+        chave: string;
+        novoItem: any;
+    }): void;
+    get_item_session_storage(chave: string): any;
+    remover_item_session_storage(chave: string): void;
+};
+export default _session_storage;

package/build/es/utils/_update_context.d.ts

@@ -0,0 +1,21 @@
+type ParamsPadrao = {
+    oldArray: any[];
+    newItem: any;
+    key?: string | "_id" | "id";
+};
+type RemoveArrayItems = {
+    oldArray: any[];
+    itemsToRemove: any[];
+    key?: string | "_id" | "id";
+};
+declare const _update_context: {
+    new (): {};
+    set_new_item_end: ({ oldArray, newItem, key }: ParamsPadrao) => any;
+    update_array_itens: ({ oldArray, newItem, key }: ParamsPadrao) => any;
+    remove_array_items: ({ oldArray, itemsToRemove, key }: RemoveArrayItems) => any[];
+    compare_arrays({ arrayAntigo, arrayNovo }: {
+        arrayAntigo: any;
+        arrayNovo: any;
+    }): any[];
+};
+export default _update_context;

package/build/es/utils/index.d.ts

@@ -0,0 +1,105 @@
+import _form from "./_form";
+declare const utils: {
+    new (): {};
+    api: {
+        new (): {};
+        servidor_service_usuario: {
+            new (): {};
+            get "__#private@#axios"(): import("axios").AxiosInstance;
+            post({ url, data, setToken }: {
+                url: string;
+                data: any;
+                setToken?: boolean;
+            }): Promise<import("axios").AxiosResponse<any, any, {}>>;
+            get({ url, params, setToken }: {
+                url: string;
+                params?: any;
+                setToken?: boolean;
+            }): Promise<import("axios").AxiosResponse<any, any, {}>>;
+            patch({ url, data, setToken }: {
+                url: string;
+                data: any;
+                setToken?: boolean;
+            }): Promise<import("axios").AxiosResponse<any, any, {}>>;
+            delete({ url }: {
+                url: string;
+                setToken?: boolean;
+            }): Promise<import("axios").AxiosResponse<any, any, {}>>;
+        };
+        headers({ setToken }: {
+            setToken?: boolean;
+        }): {
+            headers: {
+                Authorization: string;
+                "Content-type": string;
+            };
+        } | {
+            headers: {
+                "Content-type": string;
+                Authorization?: undefined;
+            };
+        };
+    };
+    data: {
+        new (): {};
+        YYYY_MM_DD_00_00_00(newData: string): string;
+        DD_MM_YYYY_00_00_00(newData: string): string;
+        DD_MM_YYYY_00_00(newData: string): string;
+        DD_MM_YYYY(newData: string): string;
+        YYYY_MM_DD(newData: string): string;
+        DIFERENCA_SEGUNDOS(data: string): number;
+        DIFERENCA_DIAS(data: string): number;
+    };
+    form: typeof _form;
+    geral: {
+        new (): {};
+        slice_file_name(filename: string, maxLength?: number): string;
+        extrair_id(array_enviado: Array<{
+            _id?: string;
+        }>): string[];
+        gerar_id: (length?: number) => string;
+    };
+    local_storage: {
+        new (): {};
+        adicionar_item_local_storage(chave: string, novoItem: any): void;
+        set_local_storage_sem_incremento(chave: string, novoItem: any): void;
+        get_item_local_storage(chave: string): any;
+        remover_item_local_storage(chave: string): void;
+    };
+    update_context: {
+        new (): {};
+        set_new_item_end: ({ oldArray, newItem, key }: {
+            oldArray: any[];
+            newItem: any;
+            key?: string | "_id" | "id";
+        }) => any;
+        update_array_itens: ({ oldArray, newItem, key }: {
+            oldArray: any[];
+            newItem: any;
+            key?: string | "_id" | "id";
+        }) => any;
+        remove_array_items: ({ oldArray, itemsToRemove, key }: {
+            oldArray: any[];
+            itemsToRemove: any[];
+            key?: string | "_id" | "id";
+        }) => any[];
+        compare_arrays({ arrayAntigo, arrayNovo }: {
+            arrayAntigo: any;
+            arrayNovo: any;
+        }): any[];
+    };
+    session_sorage: {
+        new (): {};
+        adicionar_item_session_storage({ chave, novoItem }: {
+            chave: string;
+            novoItem: any;
+        }): void;
+        set_session_storage_sem_incremento({ chave, novoItem }: {
+            chave: string;
+            novoItem: any;
+        }): void;
+        get_item_session_storage(chave: string): any;
+        remover_item_session_storage(chave: string): void;
+    };
+};
+export default utils;