@cristian-israel/giganet_lib_conecta 1.0.44 → 1.0.46

package/dist/index.d.mts

@@ -4,6 +4,7 @@ import * as mongoose from 'mongoose';
 import { Model as Model$1, InferSchemaType, HydratedDocument, Schema, Types } from 'mongoose';
 import * as bson from 'bson';
 import { AxiosRequestConfig, AxiosInstance } from 'axios';
+import { z } from 'zod';
 
 type LogLevel = "INFO" | "ERROR" | "WARN";
 type LoggerParams = {
@@ -36751,17 +36752,767 @@ interface SuOssChamadoListFilters {
     sortname: string;
     sortorder: "asc" | "desc";
 }
-interface IxcSuOssChamadoResponse {
-    type: "success" | "error";
-    message: string;
-    id?: string;
-    atualiza_campos?: {
-        tipo: string;
-        campo: string;
-        valor: string;
-    }[];
-    [key: string]: any;
-}
+declare const IxcSuOssChamadoResponseSchema: z.ZodObject<{
+    message: z.ZodString;
+    id: z.ZodOptional<z.ZodString>;
+    "~standard": z.ZodStandardSchemaWithJSON<z.ZodObject<{
+        atualiza_campos: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            tipo: z.ZodString;
+            campo: z.ZodString;
+            valor: z.ZodString;
+        }, z.core.$strip>>>;
+    }, z.core.$strip>>;
+    shape: {
+        atualiza_campos: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            tipo: z.ZodString;
+            campo: z.ZodString;
+            valor: z.ZodString;
+        }, z.core.$strip>>>;
+    };
+    keyof: () => z.ZodEnum<{
+        atualiza_campos: "atualiza_campos";
+    }>;
+    catchall: <T extends z.core.SomeType>(schema: T) => z.ZodObject<{
+        atualiza_campos: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            tipo: z.ZodString;
+            campo: z.ZodString;
+            valor: z.ZodString;
+        }, z.core.$strip>>>;
+    }, z.core.$catchall<T>>;
+    passthrough: () => z.ZodObject<{
+        atualiza_campos: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            tipo: z.ZodString;
+            campo: z.ZodString;
+            valor: z.ZodString;
+        }, z.core.$strip>>>;
+    }, z.core.$loose>;
+    loose: () => z.ZodObject<{
+        atualiza_campos: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            tipo: z.ZodString;
+            campo: z.ZodString;
+            valor: z.ZodString;
+        }, z.core.$strip>>>;
+    }, z.core.$loose>;
+    strict: () => z.ZodObject<{
+        atualiza_campos: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            tipo: z.ZodString;
+            campo: z.ZodString;
+            valor: z.ZodString;
+        }, z.core.$strip>>>;
+    }, z.core.$strict>;
+    strip: () => z.ZodObject<{
+        atualiza_campos: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            tipo: z.ZodString;
+            campo: z.ZodString;
+            valor: z.ZodString;
+        }, z.core.$strip>>>;
+    }, z.core.$strip>;
+    extend: <U extends z.core.$ZodLooseShape>(shape: U) => z.ZodObject<("atualiza_campos" & keyof U extends never ? {
+        atualiza_campos: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            tipo: z.ZodString;
+            campo: z.ZodString;
+            valor: z.ZodString;
+        }, z.core.$strip>>>;
+    } & U : ({
+        atualiza_campos: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            tipo: z.ZodString;
+            campo: z.ZodString;
+            valor: z.ZodString;
+        }, z.core.$strip>>>;
+    } extends infer T_1 extends z.core.util.SomeObject ? { [K in keyof T_1 as K extends keyof U ? never : K]: T_1[K]; } : never) & { [K_1 in keyof U]: U[K_1]; }) extends infer T ? { [k in keyof T]: T[k]; } : never, z.core.$strip>;
+    safeExtend: <U extends z.core.$ZodLooseShape>(shape: z.SafeExtendShape<{
+        atualiza_campos: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            tipo: z.ZodString;
+            campo: z.ZodString;
+            valor: z.ZodString;
+        }, z.core.$strip>>>;
+    }, U> & Partial<Record<"atualiza_campos", z.core.SomeType>>) => z.ZodObject<("atualiza_campos" & keyof U extends never ? {
+        atualiza_campos: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            tipo: z.ZodString;
+            campo: z.ZodString;
+            valor: z.ZodString;
+        }, z.core.$strip>>>;
+    } & U : ({
+        atualiza_campos: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            tipo: z.ZodString;
+            campo: z.ZodString;
+            valor: z.ZodString;
+        }, z.core.$strip>>>;
+    } extends infer T_1 extends z.core.util.SomeObject ? { [K in keyof T_1 as K extends keyof U ? never : K]: T_1[K]; } : never) & { [K_1 in keyof U]: U[K_1]; }) extends infer T ? { [k in keyof T]: T[k]; } : never, z.core.$strip>;
+    merge: <U extends z.ZodObject>(other: U) => z.ZodObject<("atualiza_campos" & keyof U["shape"] extends never ? {
+        atualiza_campos: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            tipo: z.ZodString;
+            campo: z.ZodString;
+            valor: z.ZodString;
+        }, z.core.$strip>>>;
+    } & U["shape"] : ({
+        atualiza_campos: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            tipo: z.ZodString;
+            campo: z.ZodString;
+            valor: z.ZodString;
+        }, z.core.$strip>>>;
+    } extends infer T_1 extends z.core.util.SomeObject ? { [K in keyof T_1 as K extends keyof U["shape"] ? never : K]: T_1[K]; } : never) & (U["shape"] extends infer T_2 extends z.core.util.SomeObject ? { [K_1 in keyof T_2]: T_2[K_1]; } : never)) extends infer T ? { [k in keyof T]: T[k]; } : never, U["_zod"]["config"]>;
+    pick: <M extends z.core.util.Mask<"atualiza_campos">>(mask: M & Record<Exclude<keyof M, "atualiza_campos">, never>) => z.ZodObject<Pick<{
+        atualiza_campos: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            tipo: z.ZodString;
+            campo: z.ZodString;
+            valor: z.ZodString;
+        }, z.core.$strip>>>;
+    }, Extract<"atualiza_campos", keyof M>> extends infer T ? { [k in keyof T]: T[k]; } : never, z.core.$strip>;
+    omit: <M extends z.core.util.Mask<"atualiza_campos">>(mask: M & Record<Exclude<keyof M, "atualiza_campos">, never>) => z.ZodObject<Omit<{
+        atualiza_campos: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            tipo: z.ZodString;
+            campo: z.ZodString;
+            valor: z.ZodString;
+        }, z.core.$strip>>>;
+    }, Extract<"atualiza_campos", keyof M>> extends infer T ? { [k in keyof T]: T[k]; } : never, z.core.$strip>;
+    partial: {
+        (): z.ZodObject<{
+            atualiza_campos: z.ZodOptional<z.ZodOptional<z.ZodArray<z.ZodObject<{
+                tipo: z.ZodString;
+                campo: z.ZodString;
+                valor: z.ZodString;
+            }, z.core.$strip>>>>;
+        }, z.core.$strip>;
+        <M extends z.core.util.Mask<"atualiza_campos">>(mask: M & Record<Exclude<keyof M, "atualiza_campos">, never>): z.ZodObject<{
+            atualiza_campos: "atualiza_campos" extends infer T ? T extends "atualiza_campos" ? T extends keyof M ? z.ZodOptional<{
+                atualiza_campos: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                    tipo: z.ZodString;
+                    campo: z.ZodString;
+                    valor: z.ZodString;
+                }, z.core.$strip>>>;
+            }[T]> : {
+                atualiza_campos: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                    tipo: z.ZodString;
+                    campo: z.ZodString;
+                    valor: z.ZodString;
+                }, z.core.$strip>>>;
+            }[T] : never : never;
+        }, z.core.$strip>;
+    };
+    required: {
+        (): z.ZodObject<{
+            atualiza_campos: z.ZodNonOptional<z.ZodOptional<z.ZodArray<z.ZodObject<{
+                tipo: z.ZodString;
+                campo: z.ZodString;
+                valor: z.ZodString;
+            }, z.core.$strip>>>>;
+        }, z.core.$strip>;
+        <M extends z.core.util.Mask<"atualiza_campos">>(mask: M & Record<Exclude<keyof M, "atualiza_campos">, never>): z.ZodObject<{
+            atualiza_campos: "atualiza_campos" extends infer T ? T extends "atualiza_campos" ? T extends keyof M ? z.ZodNonOptional<{
+                atualiza_campos: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                    tipo: z.ZodString;
+                    campo: z.ZodString;
+                    valor: z.ZodString;
+                }, z.core.$strip>>>;
+            }[T]> : {
+                atualiza_campos: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                    tipo: z.ZodString;
+                    campo: z.ZodString;
+                    valor: z.ZodString;
+                }, z.core.$strip>>>;
+            }[T] : never : never;
+        }, z.core.$strip>;
+    };
+    def: z.core.$ZodObjectDef<{
+        atualiza_campos: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            tipo: z.ZodString;
+            campo: z.ZodString;
+            valor: z.ZodString;
+        }, z.core.$strip>>>;
+    }>;
+    type: "object";
+    _def: z.core.$ZodObjectDef<{
+        atualiza_campos: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            tipo: z.ZodString;
+            campo: z.ZodString;
+            valor: z.ZodString;
+        }, z.core.$strip>>>;
+    }>;
+    _output: {
+        atualiza_campos?: {
+            tipo: string;
+            campo: string;
+            valor: string;
+        }[] | undefined;
+    };
+    _input: {
+        atualiza_campos?: {
+            tipo: string;
+            campo: string;
+            valor: string;
+        }[] | undefined;
+    };
+    toJSONSchema: (params?: z.core.ToJSONSchemaParams) => z.core.ZodStandardJSONSchemaPayload<z.ZodObject<{
+        atualiza_campos: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            tipo: z.ZodString;
+            campo: z.ZodString;
+            valor: z.ZodString;
+        }, z.core.$strip>>>;
+    }, z.core.$strip>>;
+    check: (...checks: (z.core.CheckFn<{
+        atualiza_campos?: {
+            tipo: string;
+            campo: string;
+            valor: string;
+        }[] | undefined;
+    }> | z.core.$ZodCheck<{
+        atualiza_campos?: {
+            tipo: string;
+            campo: string;
+            valor: string;
+        }[] | undefined;
+    }>)[]) => z.ZodObject<{
+        atualiza_campos: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            tipo: z.ZodString;
+            campo: z.ZodString;
+            valor: z.ZodString;
+        }, z.core.$strip>>>;
+    }, z.core.$strip>;
+    with: (...checks: (z.core.CheckFn<{
+        atualiza_campos?: {
+            tipo: string;
+            campo: string;
+            valor: string;
+        }[] | undefined;
+    }> | z.core.$ZodCheck<{
+        atualiza_campos?: {
+            tipo: string;
+            campo: string;
+            valor: string;
+        }[] | undefined;
+    }>)[]) => z.ZodObject<{
+        atualiza_campos: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            tipo: z.ZodString;
+            campo: z.ZodString;
+            valor: z.ZodString;
+        }, z.core.$strip>>>;
+    }, z.core.$strip>;
+    clone: (def?: z.core.$ZodObjectDef<{
+        atualiza_campos: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            tipo: z.ZodString;
+            campo: z.ZodString;
+            valor: z.ZodString;
+        }, z.core.$strip>>>;
+    }> | undefined, params?: {
+        parent: boolean;
+    } | undefined) => z.ZodObject<{
+        atualiza_campos: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            tipo: z.ZodString;
+            campo: z.ZodString;
+            valor: z.ZodString;
+        }, z.core.$strip>>>;
+    }, z.core.$strip>;
+    register: <R extends z.core.$ZodRegistry>(registry: R, ...meta: z.ZodObject<{
+        atualiza_campos: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            tipo: z.ZodString;
+            campo: z.ZodString;
+            valor: z.ZodString;
+        }, z.core.$strip>>>;
+    }, z.core.$strip> extends infer T ? T extends z.ZodObject<{
+        atualiza_campos: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            tipo: z.ZodString;
+            campo: z.ZodString;
+            valor: z.ZodString;
+        }, z.core.$strip>>>;
+    }, z.core.$strip> ? T extends R["_schema"] ? undefined extends R["_meta"] ? [(z.core.$replace<R["_meta"], R["_schema"] & z.ZodObject<{
+        atualiza_campos: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            tipo: z.ZodString;
+            campo: z.ZodString;
+            valor: z.ZodString;
+        }, z.core.$strip>>>;
+    }, z.core.$strip>> | undefined)?] : [z.core.$replace<R["_meta"], R["_schema"] & z.ZodObject<{
+        atualiza_campos: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            tipo: z.ZodString;
+            campo: z.ZodString;
+            valor: z.ZodString;
+        }, z.core.$strip>>>;
+    }, z.core.$strip>>] : ["Incompatible schema"] : never : never) => z.ZodObject<{
+        atualiza_campos: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            tipo: z.ZodString;
+            campo: z.ZodString;
+            valor: z.ZodString;
+        }, z.core.$strip>>>;
+    }, z.core.$strip>;
+    brand: <T extends PropertyKey = PropertyKey, Dir extends "in" | "out" | "inout" = "out">(value?: T | undefined) => PropertyKey extends T ? z.ZodObject<{
+        atualiza_campos: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            tipo: z.ZodString;
+            campo: z.ZodString;
+            valor: z.ZodString;
+        }, z.core.$strip>>>;
+    }, z.core.$strip> : z.core.$ZodBranded<z.ZodObject<{
+        atualiza_campos: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            tipo: z.ZodString;
+            campo: z.ZodString;
+            valor: z.ZodString;
+        }, z.core.$strip>>>;
+    }, z.core.$strip>, T, Dir>;
+    parse: (data: unknown, params?: z.core.ParseContext<z.core.$ZodIssue>) => {
+        atualiza_campos?: {
+            tipo: string;
+            campo: string;
+            valor: string;
+        }[] | undefined;
+    };
+    safeParse: (data: unknown, params?: z.core.ParseContext<z.core.$ZodIssue>) => z.ZodSafeParseResult<{
+        atualiza_campos?: {
+            tipo: string;
+            campo: string;
+            valor: string;
+        }[] | undefined;
+    }>;
+    parseAsync: (data: unknown, params?: z.core.ParseContext<z.core.$ZodIssue>) => Promise<{
+        atualiza_campos?: {
+            tipo: string;
+            campo: string;
+            valor: string;
+        }[] | undefined;
+    }>;
+    safeParseAsync: (data: unknown, params?: z.core.ParseContext<z.core.$ZodIssue>) => Promise<z.ZodSafeParseResult<{
+        atualiza_campos?: {
+            tipo: string;
+            campo: string;
+            valor: string;
+        }[] | undefined;
+    }>>;
+    spa: (data: unknown, params?: z.core.ParseContext<z.core.$ZodIssue>) => Promise<z.ZodSafeParseResult<{
+        atualiza_campos?: {
+            tipo: string;
+            campo: string;
+            valor: string;
+        }[] | undefined;
+    }>>;
+    encode: (data: {
+        atualiza_campos?: {
+            tipo: string;
+            campo: string;
+            valor: string;
+        }[] | undefined;
+    }, params?: z.core.ParseContext<z.core.$ZodIssue>) => {
+        atualiza_campos?: {
+            tipo: string;
+            campo: string;
+            valor: string;
+        }[] | undefined;
+    };
+    decode: (data: {
+        atualiza_campos?: {
+            tipo: string;
+            campo: string;
+            valor: string;
+        }[] | undefined;
+    }, params?: z.core.ParseContext<z.core.$ZodIssue>) => {
+        atualiza_campos?: {
+            tipo: string;
+            campo: string;
+            valor: string;
+        }[] | undefined;
+    };
+    encodeAsync: (data: {
+        atualiza_campos?: {
+            tipo: string;
+            campo: string;
+            valor: string;
+        }[] | undefined;
+    }, params?: z.core.ParseContext<z.core.$ZodIssue>) => Promise<{
+        atualiza_campos?: {
+            tipo: string;
+            campo: string;
+            valor: string;
+        }[] | undefined;
+    }>;
+    decodeAsync: (data: {
+        atualiza_campos?: {
+            tipo: string;
+            campo: string;
+            valor: string;
+        }[] | undefined;
+    }, params?: z.core.ParseContext<z.core.$ZodIssue>) => Promise<{
+        atualiza_campos?: {
+            tipo: string;
+            campo: string;
+            valor: string;
+        }[] | undefined;
+    }>;
+    safeEncode: (data: {
+        atualiza_campos?: {
+            tipo: string;
+            campo: string;
+            valor: string;
+        }[] | undefined;
+    }, params?: z.core.ParseContext<z.core.$ZodIssue>) => z.ZodSafeParseResult<{
+        atualiza_campos?: {
+            tipo: string;
+            campo: string;
+            valor: string;
+        }[] | undefined;
+    }>;
+    safeDecode: (data: {
+        atualiza_campos?: {
+            tipo: string;
+            campo: string;
+            valor: string;
+        }[] | undefined;
+    }, params?: z.core.ParseContext<z.core.$ZodIssue>) => z.ZodSafeParseResult<{
+        atualiza_campos?: {
+            tipo: string;
+            campo: string;
+            valor: string;
+        }[] | undefined;
+    }>;
+    safeEncodeAsync: (data: {
+        atualiza_campos?: {
+            tipo: string;
+            campo: string;
+            valor: string;
+        }[] | undefined;
+    }, params?: z.core.ParseContext<z.core.$ZodIssue>) => Promise<z.ZodSafeParseResult<{
+        atualiza_campos?: {
+            tipo: string;
+            campo: string;
+            valor: string;
+        }[] | undefined;
+    }>>;
+    safeDecodeAsync: (data: {
+        atualiza_campos?: {
+            tipo: string;
+            campo: string;
+            valor: string;
+        }[] | undefined;
+    }, params?: z.core.ParseContext<z.core.$ZodIssue>) => Promise<z.ZodSafeParseResult<{
+        atualiza_campos?: {
+            tipo: string;
+            campo: string;
+            valor: string;
+        }[] | undefined;
+    }>>;
+    refine: <Ch extends (arg: {
+        atualiza_campos?: {
+            tipo: string;
+            campo: string;
+            valor: string;
+        }[] | undefined;
+    }) => unknown | Promise<unknown>>(check: Ch, params?: string | {
+        path?: PropertyKey[] | undefined | undefined;
+        params?: Record<string, any> | undefined;
+        abort?: boolean | undefined | undefined;
+        when?: ((payload: z.core.ParsePayload) => boolean) | undefined | undefined;
+        error?: string | z.core.$ZodErrorMap<NonNullable<z.core.$ZodIssue>> | undefined;
+        message?: string | undefined | undefined;
+    } | undefined) => Ch extends (arg: any) => arg is infer R ? z.ZodObject<{
+        atualiza_campos: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            tipo: z.ZodString;
+            campo: z.ZodString;
+            valor: z.ZodString;
+        }, z.core.$strip>>>;
+    }, z.core.$strip> & z.ZodType<R, {
+        atualiza_campos?: {
+            tipo: string;
+            campo: string;
+            valor: string;
+        }[] | undefined;
+    }, z.core.$ZodTypeInternals<R, {
+        atualiza_campos?: {
+            tipo: string;
+            campo: string;
+            valor: string;
+        }[] | undefined;
+    }>> : z.ZodObject<{
+        atualiza_campos: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            tipo: z.ZodString;
+            campo: z.ZodString;
+            valor: z.ZodString;
+        }, z.core.$strip>>>;
+    }, z.core.$strip>;
+    superRefine: (refinement: (arg: {
+        atualiza_campos?: {
+            tipo: string;
+            campo: string;
+            valor: string;
+        }[] | undefined;
+    }, ctx: z.core.$RefinementCtx<{
+        atualiza_campos?: {
+            tipo: string;
+            campo: string;
+            valor: string;
+        }[] | undefined;
+    }>) => void | Promise<void>) => z.ZodObject<{
+        atualiza_campos: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            tipo: z.ZodString;
+            campo: z.ZodString;
+            valor: z.ZodString;
+        }, z.core.$strip>>>;
+    }, z.core.$strip>;
+    overwrite: (fn: (x: {
+        atualiza_campos?: {
+            tipo: string;
+            campo: string;
+            valor: string;
+        }[] | undefined;
+    }) => {
+        atualiza_campos?: {
+            tipo: string;
+            campo: string;
+            valor: string;
+        }[] | undefined;
+    }) => z.ZodObject<{
+        atualiza_campos: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            tipo: z.ZodString;
+            campo: z.ZodString;
+            valor: z.ZodString;
+        }, z.core.$strip>>>;
+    }, z.core.$strip>;
+    optional: () => z.ZodOptional<z.ZodObject<{
+        atualiza_campos: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            tipo: z.ZodString;
+            campo: z.ZodString;
+            valor: z.ZodString;
+        }, z.core.$strip>>>;
+    }, z.core.$strip>>;
+    exactOptional: () => z.ZodExactOptional<z.ZodObject<{
+        atualiza_campos: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            tipo: z.ZodString;
+            campo: z.ZodString;
+            valor: z.ZodString;
+        }, z.core.$strip>>>;
+    }, z.core.$strip>>;
+    nonoptional: (params?: string | z.core.$ZodNonOptionalParams) => z.ZodNonOptional<z.ZodObject<{
+        atualiza_campos: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            tipo: z.ZodString;
+            campo: z.ZodString;
+            valor: z.ZodString;
+        }, z.core.$strip>>>;
+    }, z.core.$strip>>;
+    nullable: () => z.ZodNullable<z.ZodObject<{
+        atualiza_campos: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            tipo: z.ZodString;
+            campo: z.ZodString;
+            valor: z.ZodString;
+        }, z.core.$strip>>>;
+    }, z.core.$strip>>;
+    nullish: () => z.ZodOptional<z.ZodNullable<z.ZodObject<{
+        atualiza_campos: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            tipo: z.ZodString;
+            campo: z.ZodString;
+            valor: z.ZodString;
+        }, z.core.$strip>>>;
+    }, z.core.$strip>>>;
+    default: {
+        (def: {
+            atualiza_campos?: {
+                tipo: string;
+                campo: string;
+                valor: string;
+            }[] | undefined;
+        }): z.ZodDefault<z.ZodObject<{
+            atualiza_campos: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                tipo: z.ZodString;
+                campo: z.ZodString;
+                valor: z.ZodString;
+            }, z.core.$strip>>>;
+        }, z.core.$strip>>;
+        (def: () => {
+            atualiza_campos?: {
+                tipo: string;
+                campo: string;
+                valor: string;
+            }[] | undefined;
+        }): z.ZodDefault<z.ZodObject<{
+            atualiza_campos: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                tipo: z.ZodString;
+                campo: z.ZodString;
+                valor: z.ZodString;
+            }, z.core.$strip>>>;
+        }, z.core.$strip>>;
+    };
+    prefault: {
+        (def: () => {
+            atualiza_campos?: {
+                tipo: string;
+                campo: string;
+                valor: string;
+            }[] | undefined;
+        }): z.ZodPrefault<z.ZodObject<{
+            atualiza_campos: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                tipo: z.ZodString;
+                campo: z.ZodString;
+                valor: z.ZodString;
+            }, z.core.$strip>>>;
+        }, z.core.$strip>>;
+        (def: {
+            atualiza_campos?: {
+                tipo: string;
+                campo: string;
+                valor: string;
+            }[] | undefined;
+        }): z.ZodPrefault<z.ZodObject<{
+            atualiza_campos: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                tipo: z.ZodString;
+                campo: z.ZodString;
+                valor: z.ZodString;
+            }, z.core.$strip>>>;
+        }, z.core.$strip>>;
+    };
+    array: () => z.ZodArray<z.ZodObject<{
+        atualiza_campos: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            tipo: z.ZodString;
+            campo: z.ZodString;
+            valor: z.ZodString;
+        }, z.core.$strip>>>;
+    }, z.core.$strip>>;
+    or: <T extends z.core.SomeType>(option: T) => z.ZodUnion<[z.ZodObject<{
+        atualiza_campos: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            tipo: z.ZodString;
+            campo: z.ZodString;
+            valor: z.ZodString;
+        }, z.core.$strip>>>;
+    }, z.core.$strip>, T]>;
+    and: <T extends z.core.SomeType>(incoming: T) => z.ZodIntersection<z.ZodObject<{
+        atualiza_campos: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            tipo: z.ZodString;
+            campo: z.ZodString;
+            valor: z.ZodString;
+        }, z.core.$strip>>>;
+    }, z.core.$strip>, T>;
+    transform: <NewOut>(transform: (arg: {
+        atualiza_campos?: {
+            tipo: string;
+            campo: string;
+            valor: string;
+        }[] | undefined;
+    }, ctx: z.core.$RefinementCtx<{
+        atualiza_campos?: {
+            tipo: string;
+            campo: string;
+            valor: string;
+        }[] | undefined;
+    }>) => NewOut | Promise<NewOut>) => z.ZodPipe<z.ZodObject<{
+        atualiza_campos: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            tipo: z.ZodString;
+            campo: z.ZodString;
+            valor: z.ZodString;
+        }, z.core.$strip>>>;
+    }, z.core.$strip>, z.ZodTransform<Awaited<NewOut>, {
+        atualiza_campos?: {
+            tipo: string;
+            campo: string;
+            valor: string;
+        }[] | undefined;
+    }>>;
+    catch: {
+        (def: {
+            atualiza_campos?: {
+                tipo: string;
+                campo: string;
+                valor: string;
+            }[] | undefined;
+        }): z.ZodCatch<z.ZodObject<{
+            atualiza_campos: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                tipo: z.ZodString;
+                campo: z.ZodString;
+                valor: z.ZodString;
+            }, z.core.$strip>>>;
+        }, z.core.$strip>>;
+        (def: (ctx: z.core.$ZodCatchCtx) => {
+            atualiza_campos?: {
+                tipo: string;
+                campo: string;
+                valor: string;
+            }[] | undefined;
+        }): z.ZodCatch<z.ZodObject<{
+            atualiza_campos: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                tipo: z.ZodString;
+                campo: z.ZodString;
+                valor: z.ZodString;
+            }, z.core.$strip>>>;
+        }, z.core.$strip>>;
+    };
+    pipe: <T extends z.core.$ZodType<any, {
+        atualiza_campos?: {
+            tipo: string;
+            campo: string;
+            valor: string;
+        }[] | undefined;
+    }, z.core.$ZodTypeInternals<any, {
+        atualiza_campos?: {
+            tipo: string;
+            campo: string;
+            valor: string;
+        }[] | undefined;
+    }>>>(target: T | z.core.$ZodType<any, {
+        atualiza_campos?: {
+            tipo: string;
+            campo: string;
+            valor: string;
+        }[] | undefined;
+    }, z.core.$ZodTypeInternals<any, {
+        atualiza_campos?: {
+            tipo: string;
+            campo: string;
+            valor: string;
+        }[] | undefined;
+    }>>) => z.ZodPipe<z.ZodObject<{
+        atualiza_campos: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            tipo: z.ZodString;
+            campo: z.ZodString;
+            valor: z.ZodString;
+        }, z.core.$strip>>>;
+    }, z.core.$strip>, T>;
+    readonly: () => z.ZodReadonly<z.ZodObject<{
+        atualiza_campos: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            tipo: z.ZodString;
+            campo: z.ZodString;
+            valor: z.ZodString;
+        }, z.core.$strip>>>;
+    }, z.core.$strip>>;
+    describe: (description: string) => z.ZodObject<{
+        atualiza_campos: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            tipo: z.ZodString;
+            campo: z.ZodString;
+            valor: z.ZodString;
+        }, z.core.$strip>>>;
+    }, z.core.$strip>;
+    description?: string | undefined;
+    meta: {
+        (): {
+            [x: string]: unknown;
+            id?: string | undefined | undefined;
+            title?: string | undefined | undefined;
+            description?: string | undefined | undefined;
+            deprecated?: boolean | undefined | undefined;
+        } | undefined;
+        (data: {
+            [x: string]: unknown;
+            id?: string | undefined | undefined;
+            title?: string | undefined | undefined;
+            description?: string | undefined | undefined;
+            deprecated?: boolean | undefined | undefined;
+        }): z.ZodObject<{
+            atualiza_campos: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                tipo: z.ZodString;
+                campo: z.ZodString;
+                valor: z.ZodString;
+            }, z.core.$strip>>>;
+        }, z.core.$strip>;
+    };
+    isOptional: () => boolean;
+    isNullable: () => boolean;
+    apply: <T>(fn: (schema: z.ZodObject<{
+        atualiza_campos: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            tipo: z.ZodString;
+            campo: z.ZodString;
+            valor: z.ZodString;
+        }, z.core.$strip>>>;
+    }, z.core.$strip>) => T) => T;
+    _zod: z.core.$ZodObjectInternals<{
+        atualiza_campos: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            tipo: z.ZodString;
+            campo: z.ZodString;
+            valor: z.ZodString;
+        }, z.core.$strip>>>;
+    }, z.core.$strip>;
+}, z.core.$catchall<z.ZodAny>>;
+type IxcSuOssChamadoResponse = z.infer<typeof IxcSuOssChamadoResponseSchema>;
 
 declare class SuOssChamadoResource {
     private readonly client;
@@ -36805,17 +37556,20 @@ interface MonthlyFeesForClientInput {
     id_cliente: number | string;
     tipo: string;
 }
-interface MonthlyFeesForClientResponse {
-    type: "success" | "error";
-    message: string;
-    id?: string;
-    id_contrato?: string | number;
-    tipo?: string;
-    id_cliente?: string | number;
-    id_tipo_documento?: string;
-    action?: string;
-    [key: string]: any;
-}
+declare const MonthlyFeesForClientResponseSchema: z.ZodObject<{
+    type: z.ZodEnum<{
+        success: "success";
+        error: "error";
+    }>;
+    message: z.ZodString;
+    id: z.ZodOptional<z.ZodString>;
+    id_contrato: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>;
+    tipo: z.ZodOptional<z.ZodString>;
+    id_cliente: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>;
+    id_tipo_documento: z.ZodOptional<z.ZodString>;
+    action: z.ZodOptional<z.ZodString>;
+}, z.core.$catchall<z.ZodAny>>;
+type MonthlyFeesForClientResponse = z.infer<typeof MonthlyFeesForClientResponseSchema>;
 
 declare class MonthlyFeesForClientResource {
     private readonly client;
@@ -36834,13 +37588,25 @@ declare class IXCSoftAPIClient extends APIClient {
     constructor(config: APIConfigType);
 }
 
+declare const IXCSoftResponseSchema: z.ZodObject<{
+    type: z.ZodEnum<{
+        success: "success";
+        error: "error";
+    }>;
+    message: z.ZodString;
+    id: z.ZodOptional<z.ZodString>;
+}, z.core.$catchall<z.ZodAny>>;
+
+declare const ixcSoftApi_types_IXCSoftResponseSchema: typeof IXCSoftResponseSchema;
 type ixcSoftApi_types_IxcSuOssChamadoResponse = IxcSuOssChamadoResponse;
+declare const ixcSoftApi_types_IxcSuOssChamadoResponseSchema: typeof IxcSuOssChamadoResponseSchema;
 type ixcSoftApi_types_MonthlyFeesForClientInput = MonthlyFeesForClientInput;
 type ixcSoftApi_types_MonthlyFeesForClientResponse = MonthlyFeesForClientResponse;
+declare const ixcSoftApi_types_MonthlyFeesForClientResponseSchema: typeof MonthlyFeesForClientResponseSchema;
 type ixcSoftApi_types_SuOssChamadoInput = SuOssChamadoInput;
 type ixcSoftApi_types_SuOssChamadoListFilters = SuOssChamadoListFilters;
 declare namespace ixcSoftApi_types {
-  export type { ixcSoftApi_types_IxcSuOssChamadoResponse as IxcSuOssChamadoResponse, ixcSoftApi_types_MonthlyFeesForClientInput as MonthlyFeesForClientInput, ixcSoftApi_types_MonthlyFeesForClientResponse as MonthlyFeesForClientResponse, ixcSoftApi_types_SuOssChamadoInput as SuOssChamadoInput, ixcSoftApi_types_SuOssChamadoListFilters as SuOssChamadoListFilters };
+  export { ixcSoftApi_types_IXCSoftResponseSchema as IXCSoftResponseSchema, type ixcSoftApi_types_IxcSuOssChamadoResponse as IxcSuOssChamadoResponse, ixcSoftApi_types_IxcSuOssChamadoResponseSchema as IxcSuOssChamadoResponseSchema, type ixcSoftApi_types_MonthlyFeesForClientInput as MonthlyFeesForClientInput, type ixcSoftApi_types_MonthlyFeesForClientResponse as MonthlyFeesForClientResponse, ixcSoftApi_types_MonthlyFeesForClientResponseSchema as MonthlyFeesForClientResponseSchema, type ixcSoftApi_types_SuOssChamadoInput as SuOssChamadoInput, type ixcSoftApi_types_SuOssChamadoListFilters as SuOssChamadoListFilters };
 }
 
 declare const RoutinesTasksSchema: Schema<any, mongoose.Model<any, any, any, any, any, any, any>, {}, {}, {}, {}, {