@navservice/core 1.116.0 → 1.120.0

package/build/es/helpers.js

@@ -46,7 +46,7 @@ const _logger = new RequestLoggerClass();
 const helpers_logger = _logger;
 const set_response = new class {
     c = new class {
-        SUCCESS({ message, results, c }) {
+        SUCCESS({ message, results, c, fn }) {
             const payload = {
                 status: 200,
                 code: "SUCCESS",
@@ -55,7 +55,7 @@ const set_response = new class {
                 results: results || []
             };
             helpers_logger.add({
-                fn: "SUCCESS",
+                fn: `${fn}_SUCCESS`,
                 level: "info",
                 message: payload?.message,
                 results: payload?.results
@@ -64,7 +64,7 @@ const set_response = new class {
                 status: 200
             });
         }
-        ACTION_REQUIRED({ message, results, c }) {
+        ACTION_REQUIRED({ message, results, c, fn }) {
             const payload = {
                 status: 428,
                 code: "ACTION_REQUIRED",
@@ -73,7 +73,7 @@ const set_response = new class {
                 results: results || []
             };
             helpers_logger.add({
-                fn: "ACTION_REQUIRED",
+                fn: `${fn}_ACTION_REQUIRED`,
                 level: "info",
                 message: payload?.message,
                 results: payload?.results
@@ -82,7 +82,7 @@ const set_response = new class {
                 status: 428
             });
         }
-        CREATED({ message, results, c }) {
+        CREATED({ message, results, c, fn }) {
             const payload = {
                 status: 201,
                 code: "CREATED",
@@ -91,7 +91,7 @@ const set_response = new class {
                 results: results || []
             };
             helpers_logger.add({
-                fn: "CREATED",
+                fn: `${fn}_CREATED`,
                 level: "info",
                 message: payload?.message,
                 results: payload?.results
@@ -100,7 +100,7 @@ const set_response = new class {
                 status: 201
             });
         }
-        WARNING({ message, results, c }) {
+        WARNING({ message, results, c, fn }) {
             const payload = {
                 status: 400,
                 code: "WARNING",
@@ -109,7 +109,7 @@ const set_response = new class {
                 results: results || []
             };
             helpers_logger.add({
-                fn: "WARNING",
+                fn: `${fn}_WARNING`,
                 level: "info",
                 message: payload?.message,
                 results: payload?.results
@@ -118,7 +118,7 @@ const set_response = new class {
                 status: 400
             });
         }
-        AUTHORIZATION_ERROR({ message, results, c }) {
+        AUTHORIZATION_ERROR({ message, results, c, fn }) {
             const payload = {
                 status: 405,
                 code: "WARNING",
@@ -127,7 +127,7 @@ const set_response = new class {
                 results: results || []
             };
             helpers_logger.add({
-                fn: "AUTHORIZATION_ERROR",
+                fn: `${fn}_AUTHORIZATION_ERROR`,
                 level: "error",
                 message: payload?.message,
                 results: payload?.results
@@ -136,7 +136,7 @@ const set_response = new class {
                 status: 405
             });
         }
-        SERVER_ERROR({ error, c }) {
+        SERVER_ERROR({ error, c, fn }) {
             if (error instanceof v4.ZodError) {
                 const payload = {
                     status: 500,
@@ -146,7 +146,7 @@ const set_response = new class {
                     results: v4.treeifyError(error)
                 };
                 helpers_logger.add({
-                    fn: "SCHEMA_VALIDATION",
+                    fn: `${fn}_SCHEMA_VALIDATION`,
                     level: "error",
                     message: payload?.message,
                     results: payload?.results
@@ -163,7 +163,7 @@ const set_response = new class {
                 results: error?.results || []
             };
             if (payload?.type === "error") helpers_logger.add({
-                fn: "SERVER_ERROR",
+                fn: `${fn}_SERVER_ERROR`,
                 level: payload?.type,
                 message: payload?.message,
                 results: payload?.results
@@ -172,7 +172,7 @@ const set_response = new class {
                 status: error?.status || error?.status || 500
             });
         }
-        UNAUTHORIZED({ message, c }) {
+        UNAUTHORIZED({ message, c, fn }) {
             const payload = {
                 status: 401,
                 code: "UNAUTHORIZED",
@@ -181,7 +181,7 @@ const set_response = new class {
                 results: []
             };
             helpers_logger.add({
-                fn: "UNAUTHORIZED",
+                fn: `${fn}_UNAUTHORIZED`,
                 level: "error",
                 message: payload?.message,
                 results: payload?.results
@@ -190,7 +190,7 @@ const set_response = new class {
                 status: 401
             });
         }
-        INVALID_TOKEN({ message, c }) {
+        INVALID_TOKEN({ message, c, fn }) {
             const payload = {
                 status: 409,
                 code: "INVALID_TOKEN",
@@ -199,7 +199,7 @@ const set_response = new class {
                 results: []
             };
             helpers_logger.add({
-                fn: "INVALID_TOKEN",
+                fn: `${fn}_INVALID_TOKEN`,
                 level: "error",
                 message: payload?.message,
                 results: payload?.results
@@ -208,7 +208,7 @@ const set_response = new class {
                 status: 409
             });
         }
-        NOT_FOUND({ message, c }) {
+        NOT_FOUND({ message, c, fn }) {
             const payload = {
                 status: 404,
                 code: "NOT_FOUND",
@@ -217,7 +217,7 @@ const set_response = new class {
                 results: []
             };
             helpers_logger.add({
-                fn: "NOT_FOUND",
+                fn: `${fn}_NOT_FOUND`,
                 level: "info",
                 message: payload?.message,
                 results: payload?.results
@@ -226,14 +226,14 @@ const set_response = new class {
                 status: 404
             });
         }
-        async SUCCESS_FILE({ message, file_buffer, content_type, filename, c }) {
+        async SUCCESS_FILE({ message, file_buffer, content_type, filename, c, fn }) {
             if (c && content_type) {
                 const headers = {
                     "Content-Type": content_type,
                     "Content-Disposition": filename ? `inline; filename="${filename}"` : "inline"
                 };
                 helpers_logger.add({
-                    fn: "SUCCESS_FILE",
+                    fn: `${fn}_SUCCESS_FILE`,
                     level: "info",
                     message: "",
                     results: headers
@@ -251,7 +251,7 @@ const set_response = new class {
                 results: []
             };
             helpers_logger.add({
-                fn: "SUCCESS_FILE",
+                fn: `${fn}_SUCCESS_FILE`,
                 level: "info",
                 message: payload?.message,
                 results: payload?.results
@@ -262,7 +262,7 @@ const set_response = new class {
         }
     };
     error = new class {
-        ACTION_REQUIRED({ message, results }) {
+        ACTION_REQUIRED({ message, results, fn }) {
             const payload = {
                 status: 428,
                 code: "ACTION_REQUIRED",
@@ -271,14 +271,14 @@ const set_response = new class {
                 results: results || []
             };
             helpers_logger.add({
-                fn: "ACTION_REQUIRED",
+                fn: `${fn}_ACTION_REQUIRED`,
                 level: "info",
                 message: payload?.message,
                 results: payload?.results
             });
             throw payload;
         }
-        WARNING({ message, results }) {
+        WARNING({ message, results, fn }) {
             const payload = {
                 status: 400,
                 code: "WARNING",
@@ -287,14 +287,46 @@ const set_response = new class {
                 results: results || []
             };
             helpers_logger.add({
-                fn: "WARNING",
+                fn: `${fn}_WARNING`,
                 level: "info",
                 message: payload?.message,
                 results: payload?.results
             });
             throw payload;
         }
-        AUTHORIZATION_ERROR({ message, results }) {
+        ERROR({ message, results, fn }) {
+            const payload = {
+                status: 400,
+                code: "ERROR",
+                type: "error",
+                message: message || "Aviso!",
+                results: results || []
+            };
+            helpers_logger.add({
+                fn: `${fn}_ERROR`,
+                level: "info",
+                message: payload?.message,
+                results: payload?.results
+            });
+            throw payload;
+        }
+        TOKEN_AUTH_USER({ message, results, fn }) {
+            const payload = {
+                status: 410,
+                code: "TOKEN_AUTH_USER",
+                type: "warning",
+                message: message || "Erro processo de auth token!",
+                results: results || []
+            };
+            helpers_logger.add({
+                fn: `${fn}_REFRESH_TOKEN_AUTH_USER`,
+                level: "error",
+                message: payload?.message,
+                results: payload?.results
+            });
+            throw payload;
+        }
+        AUTHORIZATION_ERROR({ message, results, fn }) {
             const payload = {
                 status: 400,
                 code: "WARNING",
@@ -303,14 +335,14 @@ const set_response = new class {
                 results: results || []
             };
             helpers_logger.add({
-                fn: "AUTHORIZATION_ERROR",
+                fn: `${fn}_AUTHORIZATION_ERROR`,
                 level: "error",
                 message: payload?.message,
                 results: payload?.results
             });
             throw payload;
         }
-        DATABASE_ERROR({ message, erro }) {
+        DATABASE_ERROR({ message, erro, fn }) {
             const errorCode = erro?.cause?.code || erro?.cause?.cause?.code || erro?.code || "";
             const map = {
                 SQLITE_CONSTRAINT_UNIQUE: {
@@ -354,14 +386,14 @@ const set_response = new class {
                 results: []
             };
             helpers_logger.add({
-                fn: "DATABASE_ERROR",
+                fn: `${fn}_DATABASE_ERROR`,
                 level: "error",
                 message: payload?.message,
                 results: erro
             });
             throw payload;
         }
-        SCHEMA_VALIDATION({ results }) {
+        SCHEMA_VALIDATION({ results, fn }) {
             const payload = {
                 status: 500,
                 code: "SCHEMA_VALIDATION",
@@ -370,14 +402,14 @@ const set_response = new class {
                 results: results || []
             };
             helpers_logger.add({
-                fn: "SCHEMA_VALIDATION",
+                fn: `${fn}_SCHEMA_VALIDATION`,
                 level: "error",
                 message: payload?.message,
                 results: payload?.results
             });
             throw payload;
         }
-        UNAUTHORIZED({ message }) {
+        UNAUTHORIZED({ message, fn }) {
             const payload = {
                 status: 401,
                 code: "UNAUTHORIZED",
@@ -385,60 +417,62 @@ const set_response = new class {
                 message: message || "Não autorizado!"
             };
             helpers_logger.add({
-                fn: "UNAUTHORIZED",
+                fn: `${fn}_UNAUTHORIZED`,
                 level: "error",
                 message: payload?.message,
                 results: payload?.results
             });
             throw payload;
         }
-        INTEGRATION_ERROR({ message }) {
+        INTEGRATION_ERROR({ message, fn, erro }) {
             const payload = {
                 status: 401,
                 code: "INTEGRATION_ERROR",
                 type: "error",
-                message: message || "Erro na camada de integração!"
+                message: message || "Erro na camada de integração!",
+                results: erro
             };
             helpers_logger.add({
-                fn: "INTEGRATION_ERROR",
+                fn: `${fn}_INTEGRATION_ERROR`,
                 level: "error",
                 message: payload?.message,
-                results: payload?.results
+                results: erro
             });
             throw payload;
         }
-        INVALID_TOKEN({ message }) {
+        INVALID_TOKEN({ message, fn, results }) {
             const payload = {
                 status: 401,
                 code: "INVALID_TOKEN",
                 type: "warning",
                 message: message || "Token inválido!",
-                results: []
+                results: results || []
             };
             helpers_logger.add({
-                fn: "INVALID_TOKEN",
+                fn: `${fn}_INVALID_TOKEN`,
                 level: "error",
                 message: payload?.message,
                 results: payload?.results
             });
             throw payload;
         }
-        NOT_FOUND({ message }) {
+        NOT_FOUND({ message, fn, results }) {
             const payload = {
                 status: 404,
                 code: "NOT_FOUND",
                 type: "error",
-                message: message || "Recurso não encontrado!"
+                message: message || "Recurso não encontrado!",
+                results: results || []
             };
             helpers_logger.add({
-                fn: "NOT_FOUND",
+                fn: `${fn}_NOT_FOUND`,
                 level: "info",
                 message: payload?.message,
                 results: payload?.results
             });
             throw payload;
         }
-        BUSINESS_RULE_VIOLATION({ message, results }) {
+        BUSINESS_RULE_VIOLATION({ message, results, fn }) {
             const payload = {
                 status: 422,
                 code: "BUSINESS_RULE_VIOLATION",
@@ -447,14 +481,14 @@ const set_response = new class {
                 results: results || []
             };
             helpers_logger.add({
-                fn: "BUSINESS_RULE_VIOLATION",
+                fn: `${fn}_BUSINESS_RULE_VIOLATION`,
                 level: "info",
                 message: payload?.message,
                 results: payload?.results
             });
             throw payload;
         }
-        PLAN_FORBIDDEN({ message, results }) {
+        PLAN_FORBIDDEN({ message, results, fn }) {
             const payload = {
                 status: 403,
                 code: "PLAN_FORBIDDEN",
@@ -463,7 +497,7 @@ const set_response = new class {
                 results: results || []
             };
             helpers_logger.add({
-                fn: "PLAN_FORBIDDEN",
+                fn: `${fn}_PLAN_FORBIDDEN`,
                 level: "info",
                 message: payload?.message,
                 results: payload?.results
@@ -473,6 +507,7 @@ const set_response = new class {
     };
 };
 const _set_response = set_response;
+const _token_fn = 'token';
 const _token = new class {
     async verificar_token(c, next) {
         try {
@@ -480,20 +515,23 @@ const _token = new class {
             if (!authHeader) return _set_response.c.INVALID_TOKEN({
                 message: 'token não enviado!!!',
                 c: c,
-                results: []
+                results: [],
+                fn: _token_fn
             });
             const token = authHeader.split(" ")[1];
             if (!token) return _set_response.c.INVALID_TOKEN({
                 message: 'Acesso negado!!!',
                 c: c,
-                results: []
+                results: [],
+                fn: _token_fn
             });
             const secret = new TextEncoder().encode(c.env.JSON_WEB_TOKEN_AUTH_USER);
             const { payload } = await jwtVerify(token, secret);
             if (!payload._id || !payload.email) return _set_response.c.INVALID_TOKEN({
                 message: 'Token inválido!!!!',
                 c: c,
-                results: []
+                results: [],
+                fn: _token_fn
             });
             const setar_token = {
                 _id: payload._id,
@@ -513,14 +551,16 @@ const _token = new class {
             return _set_response.c.INVALID_TOKEN({
                 message: 'Token inválido!!!',
                 c: c,
-                results: []
+                results: [],
+                fn: _token_fn
             });
         }
     }
     async criar_token_login_usuario(props) {
         if (!props?.c.env.JSON_WEB_TOKEN_AUTH_USER) _set_response.error.WARNING({
-            message: "Erro ao gerar token!!",
-            results: []
+            message: "Erro ao gerar token auth!!",
+            results: [],
+            fn: _token_fn
         });
         const token = await new SignJWT({
             _id: props?._id,
@@ -534,9 +574,10 @@ const _token = new class {
             plano_status: props?.plano_status
         }).setProtectedHeader({
             alg: "HS256"
-        }).setIssuedAt().setExpirationTime("1h").sign(new TextEncoder().encode(props?.c.env.JSON_WEB_TOKEN_AUTH_USER)).catch((error)=>_set_response.error.WARNING({
-                message: "Erro ao gerar token!",
-                results: error?.message
+        }).setIssuedAt().setExpirationTime("1h").sign(new TextEncoder().encode(props?.c.env.JSON_WEB_TOKEN_AUTH_USER)).catch((error)=>_set_response.error.TOKEN_AUTH_USER({
+                message: "Erro ao gerar token auth user!",
+                results: error?.message,
+                fn: _token_fn
             }));
         return token;
     }
@@ -546,20 +587,23 @@ const _token = new class {
             if (!authHeader) return _set_response.c.INVALID_TOKEN({
                 message: 'token service não enviado!',
                 c: c,
-                results: []
+                results: [],
+                fn: _token_fn
             });
             const token = authHeader.split(" ")[1];
             if (!token) return _set_response.c.INVALID_TOKEN({
                 message: 'Acesso negado ao serviço!',
                 c: c,
-                results: []
+                results: [],
+                fn: _token_fn
             });
             const secret = new TextEncoder().encode(c.env.JSON_WEB_TOKEN_AUTH_MICRO_SERVICO);
             const { payload } = await jwtVerify(token, secret);
             if (!payload._id || !payload.email) return _set_response.c.INVALID_TOKEN({
                 message: 'Token inválido para o serviço!',
                 c: c,
-                results: []
+                results: [],
+                fn: _token_fn
             });
             const setar_token = {
                 _id: payload._id,
@@ -578,14 +622,16 @@ const _token = new class {
             return _set_response.c.INVALID_TOKEN({
                 message: 'Erro token inválido!',
                 c: c,
-                results: []
+                results: [],
+                fn: _token_fn
             });
         }
     }
     async criar_token_micro_servico({ c }) {
-        if (!c.env.JSON_WEB_TOKEN_AUTH_MICRO_SERVICO) return _set_response.error.WARNING({
+        if (!c.env.JSON_WEB_TOKEN_AUTH_MICRO_SERVICO) _set_response.error.WARNING({
             message: "Erro ao gerar token!!",
-            results: []
+            results: [],
+            fn: _token_fn
         });
         const usuario_auth = c.get("usuario_auth");
         const token = await new SignJWT({
@@ -600,23 +646,26 @@ const _token = new class {
             plano_status: usuario_auth?.plano_status
         }).setProtectedHeader({
             alg: "HS256"
-        }).setIssuedAt().setExpirationTime("30s").sign(new TextEncoder().encode(c.env.JSON_WEB_TOKEN_AUTH_MICRO_SERVICO)).catch((error)=>_set_response.error.WARNING({
-                message: "Erro ao gerar token!",
-                results: error?.message
+        }).setIssuedAt().setExpirationTime("30s").sign(new TextEncoder().encode(c.env.JSON_WEB_TOKEN_AUTH_MICRO_SERVICO)).catch((error)=>_set_response.error.TOKEN_AUTH_USER({
+                message: "Erro ao gerar token micro serviço!",
+                results: error?.message,
+                fn: _token_fn
             }));
         return token;
     }
     async criar_refresh_token({ env, usuario_id }) {
-        if (!env.JSON_WEB_REFRESH_TOKEN_AUTH_USER) return _set_response.error.WARNING({
+        if (!env.JSON_WEB_REFRESH_TOKEN_AUTH_USER) _set_response.error.TOKEN_AUTH_USER({
             message: "Erro ao gerar refresh token!!",
-            results: []
+            results: [],
+            fn: _token_fn
         });
         const token = await new SignJWT({
             usuario_id: usuario_id
         }).setProtectedHeader({
             alg: "HS256"
-        }).setIssuedAt().setExpirationTime("2h").sign(new TextEncoder().encode(env.JSON_WEB_REFRESH_TOKEN_AUTH_USER)).catch((error)=>_set_response.error.WARNING({
-                message: "Erro ao gerar refresh token!"
+        }).setIssuedAt().setExpirationTime("2h").sign(new TextEncoder().encode(env.JSON_WEB_REFRESH_TOKEN_AUTH_USER)).catch((error)=>_set_response.error.TOKEN_AUTH_USER({
+                message: "Erro ao gerar refresh token!",
+                fn: _token_fn
             }));
         return token;
     }

package/build/es/index.js

@@ -82,6 +82,7 @@ var _usuario_TypeControllerUsuario;
         v4.literal("ACTION_REQUIRED"),
         v4.literal("CREATED"),
         v4.literal("WARNING"),
+        v4.literal("ERROR"),
         v4.literal("AUTHORIZATION_ERROR"),
         v4.literal("SCHEMA_VALIDATION"),
         v4.literal("SERVER_ERROR"),
@@ -92,7 +93,8 @@ var _usuario_TypeControllerUsuario;
         v4.literal("DATABASE_ERROR"),
         v4.literal("BUSINESS_RULE_VIOLATION"),
         v4.literal("PLAN_FORBIDDEN"),
-        v4.literal("INTEGRATION_ERROR")
+        v4.literal("INTEGRATION_ERROR"),
+        v4.literal("TOKEN_AUTH_USER")
     ]);
     v4.object({
         status: StatusSchema,
@@ -114,6 +116,7 @@ var _usuario_TypeControllerUsuario;
         v4.object({
             status: StatusSchema,
             message: v4.string().optional(),
+            fn: v4.string(),
             file_buffer: v4.union([
                 v4["instanceof"](Blob),
                 v4["instanceof"](ArrayBuffer),
@@ -133,8 +136,7 @@ var _usuario_TypeControllerUsuario;
             ]).optional(),
             type: TypeSchema.optional().default("success"),
             code: CodeSchema,
-            status: v4.number().optional().default(200),
-            fn: v4.string().optional()
+            status: v4.number().optional().default(200)
         });
     })(TypeControllerResponse.Error || (TypeControllerResponse.Error = {}));
 })(_type_response_TypeControllerResponse || (_type_response_TypeControllerResponse = {}));

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

@@ -3,7 +3,7 @@ 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">, z4.ZodLiteral<"BUSINESS_RULE_VIOLATION">, z4.ZodLiteral<"PLAN_FORBIDDEN">, z4.ZodLiteral<"INTEGRATION_ERROR">]>;
+        code: z4.ZodUnion<readonly [z4.ZodLiteral<"SUCCESS">, z4.ZodLiteral<"ACTION_REQUIRED">, z4.ZodLiteral<"CREATED">, z4.ZodLiteral<"WARNING">, z4.ZodLiteral<"ERROR">, 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">, z4.ZodLiteral<"BUSINESS_RULE_VIOLATION">, z4.ZodLiteral<"PLAN_FORBIDDEN">, z4.ZodLiteral<"INTEGRATION_ERROR">, z4.ZodLiteral<"TOKEN_AUTH_USER">]>;
         type: z4.ZodDefault<z4.ZodUnion<readonly [z4.ZodLiteral<"success">, z4.ZodLiteral<"warning">, z4.ZodLiteral<"error">]>>;
         message: z4.ZodString;
         results: z4.ZodOptional<z4.ZodUnknown>;
@@ -15,7 +15,7 @@ declare namespace TypeControllerResponse {
     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">, z4.ZodLiteral<"BUSINESS_RULE_VIOLATION">, z4.ZodLiteral<"PLAN_FORBIDDEN">, z4.ZodLiteral<"INTEGRATION_ERROR">]>;
+            code: z4.ZodUnion<readonly [z4.ZodLiteral<"SUCCESS">, z4.ZodLiteral<"ACTION_REQUIRED">, z4.ZodLiteral<"CREATED">, z4.ZodLiteral<"WARNING">, z4.ZodLiteral<"ERROR">, 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">, z4.ZodLiteral<"BUSINESS_RULE_VIOLATION">, z4.ZodLiteral<"PLAN_FORBIDDEN">, z4.ZodLiteral<"INTEGRATION_ERROR">, z4.ZodLiteral<"TOKEN_AUTH_USER">]>;
             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;
@@ -28,6 +28,7 @@ declare namespace TypeControllerResponse {
         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>;
+            fn: 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>;
@@ -41,9 +42,8 @@ declare namespace TypeControllerResponse {
             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">, z4.ZodLiteral<"BUSINESS_RULE_VIOLATION">, z4.ZodLiteral<"PLAN_FORBIDDEN">, z4.ZodLiteral<"INTEGRATION_ERROR">]>;
+            code: z4.ZodUnion<readonly [z4.ZodLiteral<"SUCCESS">, z4.ZodLiteral<"ACTION_REQUIRED">, z4.ZodLiteral<"CREATED">, z4.ZodLiteral<"WARNING">, z4.ZodLiteral<"ERROR">, 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">, z4.ZodLiteral<"BUSINESS_RULE_VIOLATION">, z4.ZodLiteral<"PLAN_FORBIDDEN">, z4.ZodLiteral<"INTEGRATION_ERROR">, z4.ZodLiteral<"TOKEN_AUTH_USER">]>;
             status: z4.ZodDefault<z4.ZodOptional<z4.ZodNumber>>;
-            fn: z4.ZodOptional<z4.ZodString>;
         }, z4.core.$strip>;
         type Input<T = unknown> = z4.infer<typeof InputSchema> & {
             results?: T;