npm - @cristian-israel/giganet_lib_conecta - Versions diffs - 1.0.45 → 1.0.46 - Mend

@cristian-israel/giganet_lib_conecta 1.0.45 → 1.0.46

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (5) hide show

package/dist/index.d.mts CHANGED Viewed

@@ -36753,18 +36753,765 @@ interface SuOssChamadoListFilters {
     sortorder: "asc" | "desc";
 }
 declare const IxcSuOssChamadoResponseSchema: z.ZodObject<{
-    type: z.ZodEnum<{
-        success: "success";
-        error: "error";
-    }>;
     message: z.ZodString;
     id: z.ZodOptional<z.ZodString>;
-    atualiza_campos: z.ZodOptional<z.ZodArray<z.ZodObject<{
-        tipo: z.ZodString;
-        campo: z.ZodString;
-        valor: 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>>>;
-}, 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 {
@@ -36821,7 +37568,7 @@ declare const MonthlyFeesForClientResponseSchema: z.ZodObject<{
     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.$strip>;
+}, z.core.$catchall<z.ZodAny>>;
 type MonthlyFeesForClientResponse = z.infer<typeof MonthlyFeesForClientResponseSchema>;
 declare class MonthlyFeesForClientResource {