@aws-amplify/graphql-api-construct 1.19.1 → 1.20.0

package/node_modules/zod/lib/types.d.ts

@@ -1,55 +1,57 @@
 import { enumUtil } from "./helpers/enumUtil";
 import { errorUtil } from "./helpers/errorUtil";
-import { AsyncParseReturnType, ParseContext, ParseInput, ParseParams, ParseReturnType, ParseStatus, SyncParseReturnType } from "./helpers/parseUtil";
+import { AsyncParseReturnType, INVALID, ParseContext, ParseInput, ParseParams, ParseReturnType, ParseStatus, SyncParseReturnType } from "./helpers/parseUtil";
 import { partialUtil } from "./helpers/partialUtil";
 import { Primitive } from "./helpers/typeAliases";
 import { objectUtil, util } from "./helpers/util";
+import type { StandardSchemaV1 } from "./standard-schema";
 import { IssueData, StringValidation, ZodCustomIssue, ZodError, ZodErrorMap } from "./ZodError";
 export interface RefinementCtx {
     addIssue: (arg: IssueData) => void;
     path: (string | number)[];
 }
-export declare type ZodRawShape = {
+export type ZodRawShape = {
     [k: string]: ZodTypeAny;
 };
-export declare type ZodTypeAny = ZodType<any, any, any>;
-export declare type TypeOf<T extends ZodType<any, any, any>> = T["_output"];
-export declare type input<T extends ZodType<any, any, any>> = T["_input"];
-export declare type output<T extends ZodType<any, any, any>> = T["_output"];
+export type ZodTypeAny = ZodType<any, any, any>;
+export type TypeOf<T extends ZodType<any, any, any>> = T["_output"];
+export type input<T extends ZodType<any, any, any>> = T["_input"];
+export type output<T extends ZodType<any, any, any>> = T["_output"];
 export type { TypeOf as infer };
-export declare type CustomErrorParams = Partial<util.Omit<ZodCustomIssue, "code">>;
+export type CustomErrorParams = Partial<util.Omit<ZodCustomIssue, "code">>;
 export interface ZodTypeDef {
     errorMap?: ZodErrorMap;
     description?: string;
 }
-export declare type RawCreateParams = {
+export type RawCreateParams = {
     errorMap?: ZodErrorMap;
     invalid_type_error?: string;
     required_error?: string;
     message?: string;
     description?: string;
 } | undefined;
-export declare type ProcessedCreateParams = {
+export type ProcessedCreateParams = {
     errorMap?: ZodErrorMap;
     description?: string;
 };
-export declare type SafeParseSuccess<Output> = {
+export type SafeParseSuccess<Output> = {
     success: true;
     data: Output;
     error?: never;
 };
-export declare type SafeParseError<Input> = {
+export type SafeParseError<Input> = {
     success: false;
     error: ZodError<Input>;
     data?: never;
 };
-export declare type SafeParseReturnType<Input, Output> = SafeParseSuccess<Output> | SafeParseError<Input>;
+export type SafeParseReturnType<Input, Output> = SafeParseSuccess<Output> | SafeParseError<Input>;
 export declare abstract class ZodType<Output = any, Def extends ZodTypeDef = ZodTypeDef, Input = Output> {
     readonly _type: Output;
     readonly _output: Output;
     readonly _input: Input;
     readonly _def: Def;
     get description(): string | undefined;
+    "~standard": StandardSchemaV1.Props<Input, Output>;
     abstract _parse(input: ParseInput): ParseReturnType<Output>;
     _getType(input: ParseInput): string;
     _getOrReturnCtx(input: ParseInput, ctx?: ParseContext | undefined): ParseContext;
@@ -61,10 +63,11 @@ export declare abstract class ZodType<Output = any, Def extends ZodTypeDef = Zod
     _parseAsync(input: ParseInput): AsyncParseReturnType<Output>;
     parse(data: unknown, params?: Partial<ParseParams>): Output;
     safeParse(data: unknown, params?: Partial<ParseParams>): SafeParseReturnType<Input, Output>;
+    "~validate"(data: unknown): StandardSchemaV1.Result<Output> | Promise<StandardSchemaV1.Result<Output>>;
     parseAsync(data: unknown, params?: Partial<ParseParams>): Promise<Output>;
     safeParseAsync(data: unknown, params?: Partial<ParseParams>): Promise<SafeParseReturnType<Input, Output>>;
     /** Alias of safeParseAsync */
-    spa: (data: unknown, params?: Partial<ParseParams> | undefined) => Promise<SafeParseReturnType<Input, Output>>;
+    spa: (data: unknown, params?: Partial<ParseParams>) => Promise<SafeParseReturnType<Input, Output>>;
     refine<RefinedOutput extends Output>(check: (arg: Output) => arg is RefinedOutput, message?: string | CustomErrorParams | ((arg: Output) => CustomErrorParams)): ZodEffects<this, RefinedOutput, Input>;
     refine(check: (arg: Output) => unknown | Promise<unknown>, message?: string | CustomErrorParams | ((arg: Output) => CustomErrorParams)): ZodEffects<this, Output, Input>;
     refinement<RefinedOutput extends Output>(check: (arg: Output) => arg is RefinedOutput, refinementData: IssueData | ((arg: Output, ctx: RefinementCtx) => IssueData)): ZodEffects<this, RefinedOutput, Input>;
@@ -96,8 +99,8 @@ export declare abstract class ZodType<Output = any, Def extends ZodTypeDef = Zod
     isOptional(): boolean;
     isNullable(): boolean;
 }
-export declare type IpVersion = "v4" | "v6";
-export declare type ZodStringCheck = {
+export type IpVersion = "v4" | "v6";
+export type ZodStringCheck = {
     kind: "min";
     value: number;
     message?: string;
@@ -159,6 +162,10 @@ export declare type ZodStringCheck = {
 } | {
     kind: "toUpperCase";
     message?: string;
+} | {
+    kind: "jwt";
+    alg?: string;
+    message?: string;
 } | {
     kind: "datetime";
     offset: boolean;
@@ -179,9 +186,16 @@ export declare type ZodStringCheck = {
     kind: "ip";
     version?: IpVersion;
     message?: string;
+} | {
+    kind: "cidr";
+    version?: IpVersion;
+    message?: string;
 } | {
     kind: "base64";
     message?: string;
+} | {
+    kind: "base64url";
+    message?: string;
 };
 export interface ZodStringDef extends ZodTypeDef {
     checks: ZodStringCheck[];
@@ -206,8 +220,17 @@ export declare class ZodString extends ZodType<string, ZodStringDef, string> {
     cuid2(message?: errorUtil.ErrMessage): ZodString;
     ulid(message?: errorUtil.ErrMessage): ZodString;
     base64(message?: errorUtil.ErrMessage): ZodString;
+    base64url(message?: errorUtil.ErrMessage): ZodString;
+    jwt(options?: {
+        alg?: string;
+        message?: string;
+    }): ZodString;
     ip(options?: string | {
-        version?: "v4" | "v6";
+        version?: IpVersion;
+        message?: string;
+    }): ZodString;
+    cidr(options?: string | {
+        version?: IpVersion;
         message?: string;
     }): ZodString;
     datetime(options?: string | {
@@ -233,8 +256,7 @@ export declare class ZodString extends ZodType<string, ZodStringDef, string> {
     max(maxLength: number, message?: errorUtil.ErrMessage): ZodString;
     length(len: number, message?: errorUtil.ErrMessage): ZodString;
     /**
-     * @deprecated Use z.string().min(1) instead.
-     * @see {@link ZodString.min}
+     * Equivalent to `.min(1)`
      */
     nonempty(message?: errorUtil.ErrMessage): ZodString;
     trim(): ZodString;
@@ -253,20 +275,16 @@ export declare class ZodString extends ZodType<string, ZodStringDef, string> {
     get isCUID2(): boolean;
     get isULID(): boolean;
     get isIP(): boolean;
+    get isCIDR(): boolean;
     get isBase64(): boolean;
+    get isBase64url(): boolean;
     get minLength(): number | null;
     get maxLength(): number | null;
-    static create: (params?: ({
-        errorMap?: ZodErrorMap | undefined;
-        invalid_type_error?: string | undefined;
-        required_error?: string | undefined;
-        message?: string | undefined;
-        description?: string | undefined;
-    } & {
-        coerce?: true | undefined;
-    }) | undefined) => ZodString;
+    static create: (params?: RawCreateParams & {
+        coerce?: true;
+    }) => ZodString;
 }
-export declare type ZodNumberCheck = {
+export type ZodNumberCheck = {
     kind: "min";
     value: number;
     inclusive: boolean;
@@ -294,20 +312,14 @@ export interface ZodNumberDef extends ZodTypeDef {
 }
 export declare class ZodNumber extends ZodType<number, ZodNumberDef, number> {
     _parse(input: ParseInput): ParseReturnType<number>;
-    static create: (params?: ({
-        errorMap?: ZodErrorMap | undefined;
-        invalid_type_error?: string | undefined;
-        required_error?: string | undefined;
-        message?: string | undefined;
-        description?: string | undefined;
-    } & {
-        coerce?: boolean | undefined;
-    }) | undefined) => ZodNumber;
+    static create: (params?: RawCreateParams & {
+        coerce?: boolean;
+    }) => ZodNumber;
     gte(value: number, message?: errorUtil.ErrMessage): ZodNumber;
-    min: (value: number, message?: errorUtil.ErrMessage | undefined) => ZodNumber;
+    min: (value: number, message?: errorUtil.ErrMessage) => ZodNumber;
     gt(value: number, message?: errorUtil.ErrMessage): ZodNumber;
     lte(value: number, message?: errorUtil.ErrMessage): ZodNumber;
-    max: (value: number, message?: errorUtil.ErrMessage | undefined) => ZodNumber;
+    max: (value: number, message?: errorUtil.ErrMessage) => ZodNumber;
     lt(value: number, message?: errorUtil.ErrMessage): ZodNumber;
     protected setLimit(kind: "min" | "max", value: number, inclusive: boolean, message?: string): ZodNumber;
     _addCheck(check: ZodNumberCheck): ZodNumber;
@@ -317,7 +329,7 @@ export declare class ZodNumber extends ZodType<number, ZodNumberDef, number> {
     nonpositive(message?: errorUtil.ErrMessage): ZodNumber;
     nonnegative(message?: errorUtil.ErrMessage): ZodNumber;
     multipleOf(value: number, message?: errorUtil.ErrMessage): ZodNumber;
-    step: (value: number, message?: errorUtil.ErrMessage | undefined) => ZodNumber;
+    step: (value: number, message?: errorUtil.ErrMessage) => ZodNumber;
     finite(message?: errorUtil.ErrMessage): ZodNumber;
     safe(message?: errorUtil.ErrMessage): ZodNumber;
     get minValue(): number | null;
@@ -325,7 +337,7 @@ export declare class ZodNumber extends ZodType<number, ZodNumberDef, number> {
     get isInt(): boolean;
     get isFinite(): boolean;
 }
-export declare type ZodBigIntCheck = {
+export type ZodBigIntCheck = {
     kind: "min";
     value: bigint;
     inclusive: boolean;
@@ -347,20 +359,15 @@ export interface ZodBigIntDef extends ZodTypeDef {
 }
 export declare class ZodBigInt extends ZodType<bigint, ZodBigIntDef, bigint> {
     _parse(input: ParseInput): ParseReturnType<bigint>;
-    static create: (params?: ({
-        errorMap?: ZodErrorMap | undefined;
-        invalid_type_error?: string | undefined;
-        required_error?: string | undefined;
-        message?: string | undefined;
-        description?: string | undefined;
-    } & {
-        coerce?: boolean | undefined;
-    }) | undefined) => ZodBigInt;
+    _getInvalidInput(input: ParseInput): INVALID;
+    static create: (params?: RawCreateParams & {
+        coerce?: boolean;
+    }) => ZodBigInt;
     gte(value: bigint, message?: errorUtil.ErrMessage): ZodBigInt;
-    min: (value: bigint, message?: errorUtil.ErrMessage | undefined) => ZodBigInt;
+    min: (value: bigint, message?: errorUtil.ErrMessage) => ZodBigInt;
     gt(value: bigint, message?: errorUtil.ErrMessage): ZodBigInt;
     lte(value: bigint, message?: errorUtil.ErrMessage): ZodBigInt;
-    max: (value: bigint, message?: errorUtil.ErrMessage | undefined) => ZodBigInt;
+    max: (value: bigint, message?: errorUtil.ErrMessage) => ZodBigInt;
     lt(value: bigint, message?: errorUtil.ErrMessage): ZodBigInt;
     protected setLimit(kind: "min" | "max", value: bigint, inclusive: boolean, message?: string): ZodBigInt;
     _addCheck(check: ZodBigIntCheck): ZodBigInt;
@@ -378,17 +385,11 @@ export interface ZodBooleanDef extends ZodTypeDef {
 }
 export declare class ZodBoolean extends ZodType<boolean, ZodBooleanDef, boolean> {
     _parse(input: ParseInput): ParseReturnType<boolean>;
-    static create: (params?: ({
-        errorMap?: ZodErrorMap | undefined;
-        invalid_type_error?: string | undefined;
-        required_error?: string | undefined;
-        message?: string | undefined;
-        description?: string | undefined;
-    } & {
-        coerce?: boolean | undefined;
-    }) | undefined) => ZodBoolean;
+    static create: (params?: RawCreateParams & {
+        coerce?: boolean;
+    }) => ZodBoolean;
 }
-export declare type ZodDateCheck = {
+export type ZodDateCheck = {
     kind: "min";
     value: number;
     message?: string;
@@ -409,15 +410,9 @@ export declare class ZodDate extends ZodType<Date, ZodDateDef, Date> {
     max(maxDate: Date, message?: errorUtil.ErrMessage): ZodDate;
     get minDate(): Date | null;
     get maxDate(): Date | null;
-    static create: (params?: ({
-        errorMap?: ZodErrorMap | undefined;
-        invalid_type_error?: string | undefined;
-        required_error?: string | undefined;
-        message?: string | undefined;
-        description?: string | undefined;
-    } & {
-        coerce?: boolean | undefined;
-    }) | undefined) => ZodDate;
+    static create: (params?: RawCreateParams & {
+        coerce?: boolean;
+    }) => ZodDate;
 }
 export interface ZodSymbolDef extends ZodTypeDef {
     typeName: ZodFirstPartyTypeKind.ZodSymbol;
@@ -487,8 +482,8 @@ export interface ZodArrayDef<T extends ZodTypeAny = ZodTypeAny> extends ZodTypeD
         message?: string;
     } | null;
 }
-export declare type ArrayCardinality = "many" | "atleastone";
-export declare type arrayOutputType<T extends ZodTypeAny, Cardinality extends ArrayCardinality = "many"> = Cardinality extends "atleastone" ? [T["_output"], ...T["_output"][]] : T["_output"][];
+export type ArrayCardinality = "many" | "atleastone";
+export type arrayOutputType<T extends ZodTypeAny, Cardinality extends ArrayCardinality = "many"> = Cardinality extends "atleastone" ? [T["_output"], ...T["_output"][]] : T["_output"][];
 export declare class ZodArray<T extends ZodTypeAny, Cardinality extends ArrayCardinality = "many"> extends ZodType<arrayOutputType<T, Cardinality>, ZodArrayDef<T>, Cardinality extends "atleastone" ? [T["_input"], ...T["_input"][]] : T["_input"][]> {
     _parse(input: ParseInput): ParseReturnType<this["_output"]>;
     get element(): T;
@@ -498,37 +493,37 @@ export declare class ZodArray<T extends ZodTypeAny, Cardinality extends ArrayCar
     nonempty(message?: errorUtil.ErrMessage): ZodArray<T, "atleastone">;
     static create: <T_1 extends ZodTypeAny>(schema: T_1, params?: RawCreateParams) => ZodArray<T_1, "many">;
 }
-export declare type ZodNonEmptyArray<T extends ZodTypeAny> = ZodArray<T, "atleastone">;
-export declare type UnknownKeysParam = "passthrough" | "strict" | "strip";
+export type ZodNonEmptyArray<T extends ZodTypeAny> = ZodArray<T, "atleastone">;
+export type UnknownKeysParam = "passthrough" | "strict" | "strip";
 export interface ZodObjectDef<T extends ZodRawShape = ZodRawShape, UnknownKeys extends UnknownKeysParam = UnknownKeysParam, Catchall extends ZodTypeAny = ZodTypeAny> extends ZodTypeDef {
     typeName: ZodFirstPartyTypeKind.ZodObject;
     shape: () => T;
     catchall: Catchall;
     unknownKeys: UnknownKeys;
 }
-export declare type mergeTypes<A, B> = {
+export type mergeTypes<A, B> = {
     [k in keyof A | keyof B]: k extends keyof B ? B[k] : k extends keyof A ? A[k] : never;
 };
-export declare type objectOutputType<Shape extends ZodRawShape, Catchall extends ZodTypeAny, UnknownKeys extends UnknownKeysParam = UnknownKeysParam> = objectUtil.flatten<objectUtil.addQuestionMarks<baseObjectOutputType<Shape>>> & CatchallOutput<Catchall> & PassthroughType<UnknownKeys>;
-export declare type baseObjectOutputType<Shape extends ZodRawShape> = {
+export type objectOutputType<Shape extends ZodRawShape, Catchall extends ZodTypeAny, UnknownKeys extends UnknownKeysParam = UnknownKeysParam> = objectUtil.flatten<objectUtil.addQuestionMarks<baseObjectOutputType<Shape>>> & CatchallOutput<Catchall> & PassthroughType<UnknownKeys>;
+export type baseObjectOutputType<Shape extends ZodRawShape> = {
     [k in keyof Shape]: Shape[k]["_output"];
 };
-export declare type objectInputType<Shape extends ZodRawShape, Catchall extends ZodTypeAny, UnknownKeys extends UnknownKeysParam = UnknownKeysParam> = objectUtil.flatten<baseObjectInputType<Shape>> & CatchallInput<Catchall> & PassthroughType<UnknownKeys>;
-export declare type baseObjectInputType<Shape extends ZodRawShape> = objectUtil.addQuestionMarks<{
+export type objectInputType<Shape extends ZodRawShape, Catchall extends ZodTypeAny, UnknownKeys extends UnknownKeysParam = UnknownKeysParam> = objectUtil.flatten<baseObjectInputType<Shape>> & CatchallInput<Catchall> & PassthroughType<UnknownKeys>;
+export type baseObjectInputType<Shape extends ZodRawShape> = objectUtil.addQuestionMarks<{
     [k in keyof Shape]: Shape[k]["_input"];
 }>;
-export declare type CatchallOutput<T extends ZodType> = ZodType extends T ? unknown : {
+export type CatchallOutput<T extends ZodType> = ZodType extends T ? unknown : {
     [k: string]: T["_output"];
 };
-export declare type CatchallInput<T extends ZodType> = ZodType extends T ? unknown : {
+export type CatchallInput<T extends ZodType> = ZodType extends T ? unknown : {
     [k: string]: T["_input"];
 };
-export declare type PassthroughType<T extends UnknownKeysParam> = T extends "passthrough" ? {
+export type PassthroughType<T extends UnknownKeysParam> = T extends "passthrough" ? {
     [k: string]: unknown;
 } : unknown;
-export declare type deoptional<T extends ZodTypeAny> = T extends ZodOptional<infer U> ? deoptional<U> : T extends ZodNullable<infer U> ? ZodNullable<deoptional<U>> : T;
-export declare type SomeZodObject = ZodObject<ZodRawShape, UnknownKeysParam, ZodTypeAny>;
-export declare type noUnrecognized<Obj extends object, Shape extends object> = {
+export type deoptional<T extends ZodTypeAny> = T extends ZodOptional<infer U> ? deoptional<U> : T extends ZodNullable<infer U> ? ZodNullable<deoptional<U>> : T;
+export type SomeZodObject = ZodObject<ZodRawShape, UnknownKeysParam, ZodTypeAny>;
+export type noUnrecognized<Obj extends object, Shape extends object> = {
     [k in keyof Obj]: k extends keyof Shape ? Obj[k] : never;
 };
 export declare class ZodObject<T extends ZodRawShape, UnknownKeys extends UnknownKeysParam = UnknownKeysParam, Catchall extends ZodTypeAny = ZodTypeAny, Output = objectOutputType<T, Catchall, UnknownKeys>, Input = objectInputType<T, Catchall, UnknownKeys>> extends ZodType<Output, ZodObjectDef<T, UnknownKeys, Catchall>, Input> {
@@ -551,7 +546,7 @@ export declare class ZodObject<T extends ZodRawShape, UnknownKeys extends Unknow
     /**
      * @deprecated Use `.extend` instead
      *  */
-    augment: <Augmentation extends ZodRawShape>(augmentation: Augmentation) => ZodObject<objectUtil.extendShape<T, Augmentation>, UnknownKeys, Catchall, objectOutputType<objectUtil.extendShape<T, Augmentation>, Catchall, UnknownKeys>, objectInputType<objectUtil.extendShape<T, Augmentation>, Catchall, UnknownKeys>>;
+    augment: <Augmentation extends ZodRawShape>(augmentation: Augmentation) => ZodObject<objectUtil.extendShape<T, Augmentation>, UnknownKeys, Catchall>;
     /**
      * Prior to zod@1.0.12 there was a bug in the
      * inferred type of merged objects. Please
@@ -589,12 +584,12 @@ export declare class ZodObject<T extends ZodRawShape, UnknownKeys extends Unknow
         [k in keyof T]: k extends keyof Mask ? deoptional<T[k]> : T[k];
     }>, UnknownKeys, Catchall>;
     keyof(): ZodEnum<enumUtil.UnionToTupleString<keyof T>>;
-    static create: <T_1 extends ZodRawShape>(shape: T_1, params?: RawCreateParams) => ZodObject<T_1, "strip", ZodTypeAny, { [k in keyof objectUtil.addQuestionMarks<baseObjectOutputType<T_1>, any>]: objectUtil.addQuestionMarks<baseObjectOutputType<T_1>, any>[k]; }, { [k_1 in keyof baseObjectInputType<T_1>]: baseObjectInputType<T_1>[k_1]; }>;
-    static strictCreate: <T_1 extends ZodRawShape>(shape: T_1, params?: RawCreateParams) => ZodObject<T_1, "strict", ZodTypeAny, { [k in keyof objectUtil.addQuestionMarks<baseObjectOutputType<T_1>, any>]: objectUtil.addQuestionMarks<baseObjectOutputType<T_1>, any>[k]; }, { [k_1 in keyof baseObjectInputType<T_1>]: baseObjectInputType<T_1>[k_1]; }>;
-    static lazycreate: <T_1 extends ZodRawShape>(shape: () => T_1, params?: RawCreateParams) => ZodObject<T_1, "strip", ZodTypeAny, { [k in keyof objectUtil.addQuestionMarks<baseObjectOutputType<T_1>, any>]: objectUtil.addQuestionMarks<baseObjectOutputType<T_1>, any>[k]; }, { [k_1 in keyof baseObjectInputType<T_1>]: baseObjectInputType<T_1>[k_1]; }>;
+    static create: <T_1 extends ZodRawShape>(shape: T_1, params?: RawCreateParams) => ZodObject<T_1, "strip", ZodTypeAny, objectUtil.addQuestionMarks<baseObjectOutputType<T_1>, any> extends infer T_2 ? { [k in keyof T_2]: objectUtil.addQuestionMarks<baseObjectOutputType<T_1>, any>[k]; } : never, baseObjectInputType<T_1> extends infer T_3 ? { [k_1 in keyof T_3]: baseObjectInputType<T_1>[k_1]; } : never>;
+    static strictCreate: <T_1 extends ZodRawShape>(shape: T_1, params?: RawCreateParams) => ZodObject<T_1, "strict", ZodTypeAny, objectUtil.addQuestionMarks<baseObjectOutputType<T_1>, any> extends infer T_2 ? { [k in keyof T_2]: objectUtil.addQuestionMarks<baseObjectOutputType<T_1>, any>[k]; } : never, baseObjectInputType<T_1> extends infer T_3 ? { [k_1 in keyof T_3]: baseObjectInputType<T_1>[k_1]; } : never>;
+    static lazycreate: <T_1 extends ZodRawShape>(shape: () => T_1, params?: RawCreateParams) => ZodObject<T_1, "strip", ZodTypeAny, objectUtil.addQuestionMarks<baseObjectOutputType<T_1>, any> extends infer T_2 ? { [k in keyof T_2]: objectUtil.addQuestionMarks<baseObjectOutputType<T_1>, any>[k]; } : never, baseObjectInputType<T_1> extends infer T_3 ? { [k_1 in keyof T_3]: baseObjectInputType<T_1>[k_1]; } : never>;
 }
-export declare type AnyZodObject = ZodObject<any, any, any>;
-export declare type ZodUnionOptions = Readonly<[ZodTypeAny, ...ZodTypeAny[]]>;
+export type AnyZodObject = ZodObject<any, any, any>;
+export type ZodUnionOptions = Readonly<[ZodTypeAny, ...ZodTypeAny[]]>;
 export interface ZodUnionDef<T extends ZodUnionOptions = Readonly<[
     ZodTypeAny,
     ZodTypeAny,
@@ -608,16 +603,16 @@ export declare class ZodUnion<T extends ZodUnionOptions> extends ZodType<T[numbe
     get options(): T;
     static create: <T_1 extends readonly [ZodTypeAny, ZodTypeAny, ...ZodTypeAny[]]>(types: T_1, params?: RawCreateParams) => ZodUnion<T_1>;
 }
-export declare type ZodDiscriminatedUnionOption<Discriminator extends string> = ZodObject<{
+export type ZodDiscriminatedUnionOption<Discriminator extends string> = ZodObject<{
     [key in Discriminator]: ZodTypeAny;
 } & ZodRawShape, UnknownKeysParam, ZodTypeAny>;
-export interface ZodDiscriminatedUnionDef<Discriminator extends string, Options extends ZodDiscriminatedUnionOption<string>[] = ZodDiscriminatedUnionOption<string>[]> extends ZodTypeDef {
+export interface ZodDiscriminatedUnionDef<Discriminator extends string, Options extends readonly ZodDiscriminatedUnionOption<string>[] = ZodDiscriminatedUnionOption<string>[]> extends ZodTypeDef {
     discriminator: Discriminator;
     options: Options;
     optionsMap: Map<Primitive, ZodDiscriminatedUnionOption<any>>;
     typeName: ZodFirstPartyTypeKind.ZodDiscriminatedUnion;
 }
-export declare class ZodDiscriminatedUnion<Discriminator extends string, Options extends ZodDiscriminatedUnionOption<Discriminator>[]> extends ZodType<output<Options[number]>, ZodDiscriminatedUnionDef<Discriminator, Options>, input<Options[number]>> {
+export declare class ZodDiscriminatedUnion<Discriminator extends string, Options extends readonly ZodDiscriminatedUnionOption<Discriminator>[]> extends ZodType<output<Options[number]>, ZodDiscriminatedUnionDef<Discriminator, Options>, input<Options[number]>> {
     _parse(input: ParseInput): ParseReturnType<this["_output"]>;
     get discriminator(): Discriminator;
     get options(): Options;
@@ -630,7 +625,7 @@ export declare class ZodDiscriminatedUnion<Discriminator extends string, Options
      * @param types an array of object schemas
      * @param params
      */
-    static create<Discriminator extends string, Types extends [
+    static create<Discriminator extends string, Types extends readonly [
         ZodDiscriminatedUnionOption<Discriminator>,
         ...ZodDiscriminatedUnionOption<Discriminator>[]
     ]>(discriminator: Discriminator, options: Types, params?: RawCreateParams): ZodDiscriminatedUnion<Discriminator, Types>;
@@ -644,22 +639,22 @@ export declare class ZodIntersection<T extends ZodTypeAny, U extends ZodTypeAny>
     _parse(input: ParseInput): ParseReturnType<this["_output"]>;
     static create: <T_1 extends ZodTypeAny, U_1 extends ZodTypeAny>(left: T_1, right: U_1, params?: RawCreateParams) => ZodIntersection<T_1, U_1>;
 }
-export declare type ZodTupleItems = [ZodTypeAny, ...ZodTypeAny[]];
-export declare type AssertArray<T> = T extends any[] ? T : never;
-export declare type OutputTypeOfTuple<T extends ZodTupleItems | []> = AssertArray<{
+export type ZodTupleItems = [ZodTypeAny, ...ZodTypeAny[]];
+export type AssertArray<T> = T extends any[] ? T : never;
+export type OutputTypeOfTuple<T extends ZodTupleItems | []> = AssertArray<{
     [k in keyof T]: T[k] extends ZodType<any, any, any> ? T[k]["_output"] : never;
 }>;
-export declare type OutputTypeOfTupleWithRest<T extends ZodTupleItems | [], Rest extends ZodTypeAny | null = null> = Rest extends ZodTypeAny ? [...OutputTypeOfTuple<T>, ...Rest["_output"][]] : OutputTypeOfTuple<T>;
-export declare type InputTypeOfTuple<T extends ZodTupleItems | []> = AssertArray<{
+export type OutputTypeOfTupleWithRest<T extends ZodTupleItems | [], Rest extends ZodTypeAny | null = null> = Rest extends ZodTypeAny ? [...OutputTypeOfTuple<T>, ...Rest["_output"][]] : OutputTypeOfTuple<T>;
+export type InputTypeOfTuple<T extends ZodTupleItems | []> = AssertArray<{
     [k in keyof T]: T[k] extends ZodType<any, any, any> ? T[k]["_input"] : never;
 }>;
-export declare type InputTypeOfTupleWithRest<T extends ZodTupleItems | [], Rest extends ZodTypeAny | null = null> = Rest extends ZodTypeAny ? [...InputTypeOfTuple<T>, ...Rest["_input"][]] : InputTypeOfTuple<T>;
+export type InputTypeOfTupleWithRest<T extends ZodTupleItems | [], Rest extends ZodTypeAny | null = null> = Rest extends ZodTypeAny ? [...InputTypeOfTuple<T>, ...Rest["_input"][]] : InputTypeOfTuple<T>;
 export interface ZodTupleDef<T extends ZodTupleItems | [] = ZodTupleItems, Rest extends ZodTypeAny | null = null> extends ZodTypeDef {
     items: T;
     rest: Rest;
     typeName: ZodFirstPartyTypeKind.ZodTuple;
 }
-export declare type AnyZodTuple = ZodTuple<[
+export type AnyZodTuple = ZodTuple<[
     ZodTypeAny,
     ...ZodTypeAny[]
 ] | [], ZodTypeAny | null>;
@@ -674,8 +669,8 @@ export interface ZodRecordDef<Key extends KeySchema = ZodString, Value extends Z
     keyType: Key;
     typeName: ZodFirstPartyTypeKind.ZodRecord;
 }
-export declare type KeySchema = ZodType<string | number | symbol, any, any>;
-export declare type RecordType<K extends string | number | symbol, V> = [
+export type KeySchema = ZodType<string | number | symbol, any, any>;
+export type RecordType<K extends string | number | symbol, V> = [
     string
 ] extends [K] ? Record<K, V> : [number] extends [K] ? Record<K, V> : [symbol] extends [K] ? Record<K, V> : [BRAND<string | number | symbol>] extends [K] ? Record<K, V> : Partial<Record<K, V>>;
 export declare class ZodRecord<Key extends KeySchema = ZodString, Value extends ZodTypeAny = ZodTypeAny> extends ZodType<RecordType<Key["_output"], Value["_output"]>, ZodRecordDef<Key, Value>, RecordType<Key["_input"], Value["_input"]>> {
@@ -722,8 +717,8 @@ export interface ZodFunctionDef<Args extends ZodTuple<any, any> = ZodTuple<any,
     returns: Returns;
     typeName: ZodFirstPartyTypeKind.ZodFunction;
 }
-export declare type OuterTypeOfFunction<Args extends ZodTuple<any, any>, Returns extends ZodTypeAny> = Args["_input"] extends Array<any> ? (...args: Args["_input"]) => Returns["_output"] : never;
-export declare type InnerTypeOfFunction<Args extends ZodTuple<any, any>, Returns extends ZodTypeAny> = Args["_output"] extends Array<any> ? (...args: Args["_output"]) => Returns["_input"] : never;
+export type OuterTypeOfFunction<Args extends ZodTuple<any, any>, Returns extends ZodTypeAny> = Args["_input"] extends Array<any> ? (...args: Args["_input"]) => Returns["_output"] : never;
+export type InnerTypeOfFunction<Args extends ZodTuple<any, any>, Returns extends ZodTypeAny> = Args["_output"] extends Array<any> ? (...args: Args["_output"]) => Returns["_input"] : never;
 export declare class ZodFunction<Args extends ZodTuple<any, any>, Returns extends ZodTypeAny> extends ZodType<OuterTypeOfFunction<Args, Returns>, ZodFunctionDef<Args, Returns>, InnerTypeOfFunction<Args, Returns>> {
     _parse(input: ParseInput): ParseReturnType<any>;
     parameters(): Args;
@@ -756,21 +751,21 @@ export declare class ZodLiteral<T> extends ZodType<T, ZodLiteralDef<T>, T> {
     get value(): T;
     static create: <T_1 extends Primitive>(value: T_1, params?: RawCreateParams) => ZodLiteral<T_1>;
 }
-export declare type ArrayKeys = keyof any[];
-export declare type Indices<T> = Exclude<keyof T, ArrayKeys>;
-export declare type EnumValues<T extends string = string> = readonly [T, ...T[]];
-export declare type Values<T extends EnumValues> = {
+export type ArrayKeys = keyof any[];
+export type Indices<T> = Exclude<keyof T, ArrayKeys>;
+export type EnumValues<T extends string = string> = readonly [T, ...T[]];
+export type Values<T extends EnumValues> = {
     [k in T[number]]: k;
 };
 export interface ZodEnumDef<T extends EnumValues = EnumValues> extends ZodTypeDef {
     values: T;
     typeName: ZodFirstPartyTypeKind.ZodEnum;
 }
-export declare type Writeable<T> = {
+export type Writeable<T> = {
     -readonly [P in keyof T]: T[P];
 };
-export declare type FilterEnum<Values, ToExclude> = Values extends [] ? [] : Values extends [infer Head, ...infer Rest] ? Head extends ToExclude ? FilterEnum<Rest, ToExclude> : [Head, ...FilterEnum<Rest, ToExclude>] : never;
-export declare type typecast<A, T> = A extends T ? A : never;
+export type FilterEnum<Values, ToExclude> = Values extends [] ? [] : Values extends [infer Head, ...infer Rest] ? Head extends ToExclude ? FilterEnum<Rest, ToExclude> : [Head, ...FilterEnum<Rest, ToExclude>] : never;
+export type typecast<A, T> = A extends T ? A : never;
 declare function createZodEnum<U extends string, T extends Readonly<[U, ...U[]]>>(values: T, params?: RawCreateParams): ZodEnum<Writeable<T>>;
 declare function createZodEnum<U extends string, T extends [U, ...U[]]>(values: T, params?: RawCreateParams): ZodEnum<T>;
 export declare class ZodEnum<T extends [string, ...string[]]> extends ZodType<T[number], ZodEnumDef<T>, T[number]> {
@@ -788,7 +783,7 @@ export interface ZodNativeEnumDef<T extends EnumLike = EnumLike> extends ZodType
     values: T;
     typeName: ZodFirstPartyTypeKind.ZodNativeEnum;
 }
-export declare type EnumLike = {
+export type EnumLike = {
     [k: string]: string | number;
     [nu: number]: string;
 };
@@ -807,21 +802,21 @@ export declare class ZodPromise<T extends ZodTypeAny> extends ZodType<Promise<T[
     _parse(input: ParseInput): ParseReturnType<this["_output"]>;
     static create: <T_1 extends ZodTypeAny>(schema: T_1, params?: RawCreateParams) => ZodPromise<T_1>;
 }
-export declare type Refinement<T> = (arg: T, ctx: RefinementCtx) => any;
-export declare type SuperRefinement<T> = (arg: T, ctx: RefinementCtx) => void | Promise<void>;
-export declare type RefinementEffect<T> = {
+export type Refinement<T> = (arg: T, ctx: RefinementCtx) => any;
+export type SuperRefinement<T> = (arg: T, ctx: RefinementCtx) => void | Promise<void>;
+export type RefinementEffect<T> = {
     type: "refinement";
     refinement: (arg: T, ctx: RefinementCtx) => any;
 };
-export declare type TransformEffect<T> = {
+export type TransformEffect<T> = {
     type: "transform";
     transform: (arg: T, ctx: RefinementCtx) => any;
 };
-export declare type PreprocessEffect<T> = {
+export type PreprocessEffect<T> = {
     type: "preprocess";
     transform: (arg: T, ctx: RefinementCtx) => any;
 };
-export declare type Effect<T> = RefinementEffect<T> | TransformEffect<T> | PreprocessEffect<T>;
+export type Effect<T> = RefinementEffect<T> | TransformEffect<T> | PreprocessEffect<T>;
 export interface ZodEffectsDef<T extends ZodTypeAny = ZodTypeAny> extends ZodTypeDef {
     schema: T;
     typeName: ZodFirstPartyTypeKind.ZodEffects;
@@ -831,7 +826,7 @@ export declare class ZodEffects<T extends ZodTypeAny, Output = output<T>, Input
     innerType(): T;
     sourceType(): T;
     _parse(input: ParseInput): ParseReturnType<this["_output"]>;
-    static create: <I extends ZodTypeAny>(schema: I, effect: Effect<I["_output"]>, params?: RawCreateParams) => ZodEffects<I, I["_output"], input<I>>;
+    static create: <I extends ZodTypeAny>(schema: I, effect: Effect<I["_output"]>, params?: RawCreateParams) => ZodEffects<I, I["_output"]>;
     static createWithPreprocess: <I extends ZodTypeAny>(preprocess: (arg: unknown, ctx: RefinementCtx) => unknown, schema: I, params?: RawCreateParams) => ZodEffects<I, I["_output"], unknown>;
 }
 export { ZodEffects as ZodTransformer };
@@ -839,7 +834,7 @@ export interface ZodOptionalDef<T extends ZodTypeAny = ZodTypeAny> extends ZodTy
     innerType: T;
     typeName: ZodFirstPartyTypeKind.ZodOptional;
 }
-export declare type ZodOptionalType<T extends ZodTypeAny> = ZodOptional<T>;
+export type ZodOptionalType<T extends ZodTypeAny> = ZodOptional<T>;
 export declare class ZodOptional<T extends ZodTypeAny> extends ZodType<T["_output"] | undefined, ZodOptionalDef<T>, T["_input"] | undefined> {
     _parse(input: ParseInput): ParseReturnType<this["_output"]>;
     unwrap(): T;
@@ -849,7 +844,7 @@ export interface ZodNullableDef<T extends ZodTypeAny = ZodTypeAny> extends ZodTy
     innerType: T;
     typeName: ZodFirstPartyTypeKind.ZodNullable;
 }
-export declare type ZodNullableType<T extends ZodTypeAny> = ZodNullable<T>;
+export type ZodNullableType<T extends ZodTypeAny> = ZodNullable<T>;
 export declare class ZodNullable<T extends ZodTypeAny> extends ZodType<T["_output"] | null, ZodNullableDef<T>, T["_input"] | null> {
     _parse(input: ParseInput): ParseReturnType<this["_output"]>;
     unwrap(): T;
@@ -906,7 +901,7 @@ export interface ZodBrandedDef<T extends ZodTypeAny> extends ZodTypeDef {
     typeName: ZodFirstPartyTypeKind.ZodBranded;
 }
 export declare const BRAND: unique symbol;
-export declare type BRAND<T extends string | number | symbol> = {
+export type BRAND<T extends string | number | symbol> = {
     [BRAND]: {
         [k in T]: true;
     };
@@ -924,10 +919,10 @@ export declare class ZodPipeline<A extends ZodTypeAny, B extends ZodTypeAny> ext
     _parse(input: ParseInput): ParseReturnType<any>;
     static create<A extends ZodTypeAny, B extends ZodTypeAny>(a: A, b: B): ZodPipeline<A, B>;
 }
-declare type BuiltIn = (((...args: any[]) => any) | (new (...args: any[]) => any)) | {
+type BuiltIn = (((...args: any[]) => any) | (new (...args: any[]) => any)) | {
     readonly [Symbol.toStringTag]: string;
 } | Date | Error | Generator | Promise<unknown> | RegExp;
-declare type MakeReadonly<T> = T extends Map<infer K, infer V> ? ReadonlyMap<K, V> : T extends Set<infer V> ? ReadonlySet<V> : T extends [infer Head, ...infer Tail] ? readonly [Head, ...Tail] : T extends Array<infer V> ? ReadonlyArray<V> : T extends BuiltIn ? T : Readonly<T>;
+type MakeReadonly<T> = T extends Map<infer K, infer V> ? ReadonlyMap<K, V> : T extends Set<infer V> ? ReadonlySet<V> : T extends [infer Head, ...infer Tail] ? readonly [Head, ...Tail] : T extends Array<infer V> ? ReadonlyArray<V> : T extends BuiltIn ? T : Readonly<T>;
 export interface ZodReadonlyDef<T extends ZodTypeAny = ZodTypeAny> extends ZodTypeDef {
     innerType: T;
     typeName: ZodFirstPartyTypeKind.ZodReadonly;
@@ -937,10 +932,10 @@ export declare class ZodReadonly<T extends ZodTypeAny> extends ZodType<MakeReado
     static create: <T_1 extends ZodTypeAny>(type: T_1, params?: RawCreateParams) => ZodReadonly<T_1>;
     unwrap(): T;
 }
-declare type CustomParams = CustomErrorParams & {
+type CustomParams = CustomErrorParams & {
     fatal?: boolean;
 };
-export declare function custom<T>(check?: (data: any) => any, params?: string | CustomParams | ((input: any) => CustomParams), 
+export declare function custom<T>(check?: (data: any) => any, _params?: string | CustomParams | ((input: any) => CustomParams), 
 /**
  * @deprecated
  *
@@ -954,7 +949,7 @@ export declare function custom<T>(check?: (data: any) => any, params?: string |
 fatal?: boolean): ZodType<T, ZodTypeDef, T>;
 export { ZodType as Schema, ZodType as ZodSchema };
 export declare const late: {
-    object: <T extends ZodRawShape>(shape: () => T, params?: RawCreateParams) => ZodObject<T, "strip", ZodTypeAny, { [k in keyof objectUtil.addQuestionMarks<baseObjectOutputType<T>, any>]: objectUtil.addQuestionMarks<baseObjectOutputType<T>, any>[k]; }, { [k_1 in keyof baseObjectInputType<T>]: baseObjectInputType<T>[k_1]; }>;
+    object: <T extends ZodRawShape>(shape: () => T, params?: RawCreateParams) => ZodObject<T, "strip">;
 };
 export declare enum ZodFirstPartyTypeKind {
     ZodString = "ZodString",
@@ -994,57 +989,27 @@ export declare enum ZodFirstPartyTypeKind {
     ZodPipeline = "ZodPipeline",
     ZodReadonly = "ZodReadonly"
 }
-export declare type ZodFirstPartySchemaTypes = ZodString | ZodNumber | ZodNaN | ZodBigInt | ZodBoolean | ZodDate | ZodUndefined | ZodNull | ZodAny | ZodUnknown | ZodNever | ZodVoid | ZodArray<any, any> | ZodObject<any, any, any> | ZodUnion<any> | ZodDiscriminatedUnion<any, any> | ZodIntersection<any, any> | ZodTuple<any, any> | ZodRecord<any, any> | ZodMap<any> | ZodSet<any> | ZodFunction<any, any> | ZodLazy<any> | ZodLiteral<any> | ZodEnum<any> | ZodEffects<any, any, any> | ZodNativeEnum<any> | ZodOptional<any> | ZodNullable<any> | ZodDefault<any> | ZodCatch<any> | ZodPromise<any> | ZodBranded<any, any> | ZodPipeline<any, any> | ZodReadonly<any> | ZodSymbol;
+export type ZodFirstPartySchemaTypes = ZodString | ZodNumber | ZodNaN | ZodBigInt | ZodBoolean | ZodDate | ZodUndefined | ZodNull | ZodAny | ZodUnknown | ZodNever | ZodVoid | ZodArray<any, any> | ZodObject<any, any, any> | ZodUnion<any> | ZodDiscriminatedUnion<any, any> | ZodIntersection<any, any> | ZodTuple<any, any> | ZodRecord<any, any> | ZodMap<any> | ZodSet<any> | ZodFunction<any, any> | ZodLazy<any> | ZodLiteral<any> | ZodEnum<any> | ZodEffects<any, any, any> | ZodNativeEnum<any> | ZodOptional<any> | ZodNullable<any> | ZodDefault<any> | ZodCatch<any> | ZodPromise<any> | ZodBranded<any, any> | ZodPipeline<any, any> | ZodReadonly<any> | ZodSymbol;
 declare abstract class Class {
     constructor(..._: any[]);
 }
 declare const instanceOfType: <T extends typeof Class>(cls: T, params?: CustomParams) => ZodType<InstanceType<T>, ZodTypeDef, InstanceType<T>>;
-declare const stringType: (params?: ({
-    errorMap?: ZodErrorMap | undefined;
-    invalid_type_error?: string | undefined;
-    required_error?: string | undefined;
-    message?: string | undefined;
-    description?: string | undefined;
-} & {
-    coerce?: true | undefined;
-}) | undefined) => ZodString;
-declare const numberType: (params?: ({
-    errorMap?: ZodErrorMap | undefined;
-    invalid_type_error?: string | undefined;
-    required_error?: string | undefined;
-    message?: string | undefined;
-    description?: string | undefined;
-} & {
-    coerce?: boolean | undefined;
-}) | undefined) => ZodNumber;
+declare const stringType: (params?: RawCreateParams & {
+    coerce?: true;
+}) => ZodString;
+declare const numberType: (params?: RawCreateParams & {
+    coerce?: boolean;
+}) => ZodNumber;
 declare const nanType: (params?: RawCreateParams) => ZodNaN;
-declare const bigIntType: (params?: ({
-    errorMap?: ZodErrorMap | undefined;
-    invalid_type_error?: string | undefined;
-    required_error?: string | undefined;
-    message?: string | undefined;
-    description?: string | undefined;
-} & {
-    coerce?: boolean | undefined;
-}) | undefined) => ZodBigInt;
-declare const booleanType: (params?: ({
-    errorMap?: ZodErrorMap | undefined;
-    invalid_type_error?: string | undefined;
-    required_error?: string | undefined;
-    message?: string | undefined;
-    description?: string | undefined;
-} & {
-    coerce?: boolean | undefined;
-}) | undefined) => ZodBoolean;
-declare const dateType: (params?: ({
-    errorMap?: ZodErrorMap | undefined;
-    invalid_type_error?: string | undefined;
-    required_error?: string | undefined;
-    message?: string | undefined;
-    description?: string | undefined;
-} & {
-    coerce?: boolean | undefined;
-}) | undefined) => ZodDate;
+declare const bigIntType: (params?: RawCreateParams & {
+    coerce?: boolean;
+}) => ZodBigInt;
+declare const booleanType: (params?: RawCreateParams & {
+    coerce?: boolean;
+}) => ZodBoolean;
+declare const dateType: (params?: RawCreateParams & {
+    coerce?: boolean;
+}) => ZodDate;
 declare const symbolType: (params?: RawCreateParams) => ZodSymbol;
 declare const undefinedType: (params?: RawCreateParams) => ZodUndefined;
 declare const nullType: (params?: RawCreateParams) => ZodNull;
@@ -1052,9 +1017,9 @@ declare const anyType: (params?: RawCreateParams) => ZodAny;
 declare const unknownType: (params?: RawCreateParams) => ZodUnknown;
 declare const neverType: (params?: RawCreateParams) => ZodNever;
 declare const voidType: (params?: RawCreateParams) => ZodVoid;
-declare const arrayType: <T extends ZodTypeAny>(schema: T, params?: RawCreateParams) => ZodArray<T, "many">;
-declare const objectType: <T extends ZodRawShape>(shape: T, params?: RawCreateParams) => ZodObject<T, "strip", ZodTypeAny, { [k in keyof objectUtil.addQuestionMarks<baseObjectOutputType<T>, any>]: objectUtil.addQuestionMarks<baseObjectOutputType<T>, any>[k]; }, { [k_1 in keyof baseObjectInputType<T>]: baseObjectInputType<T>[k_1]; }>;
-declare const strictObjectType: <T extends ZodRawShape>(shape: T, params?: RawCreateParams) => ZodObject<T, "strict", ZodTypeAny, { [k in keyof objectUtil.addQuestionMarks<baseObjectOutputType<T>, any>]: objectUtil.addQuestionMarks<baseObjectOutputType<T>, any>[k]; }, { [k_1 in keyof baseObjectInputType<T>]: baseObjectInputType<T>[k_1]; }>;
+declare const arrayType: <T extends ZodTypeAny>(schema: T, params?: RawCreateParams) => ZodArray<T>;
+declare const objectType: <T extends ZodRawShape>(shape: T, params?: RawCreateParams) => ZodObject<T, "strip", ZodTypeAny, objectOutputType<T, ZodTypeAny, "strip">, objectInputType<T, ZodTypeAny, "strip">>;
+declare const strictObjectType: <T extends ZodRawShape>(shape: T, params?: RawCreateParams) => ZodObject<T, "strict">;
 declare const unionType: <T extends readonly [ZodTypeAny, ZodTypeAny, ...ZodTypeAny[]]>(types: T, params?: RawCreateParams) => ZodUnion<T>;
 declare const discriminatedUnionType: typeof ZodDiscriminatedUnion.create;
 declare const intersectionType: <T extends ZodTypeAny, U extends ZodTypeAny>(left: T, right: U, params?: RawCreateParams) => ZodIntersection<T, U>;
@@ -1068,7 +1033,7 @@ declare const literalType: <T extends Primitive>(value: T, params?: RawCreatePar
 declare const enumType: typeof createZodEnum;
 declare const nativeEnumType: <T extends EnumLike>(values: T, params?: RawCreateParams) => ZodNativeEnum<T>;
 declare const promiseType: <T extends ZodTypeAny>(schema: T, params?: RawCreateParams) => ZodPromise<T>;
-declare const effectsType: <I extends ZodTypeAny>(schema: I, effect: Effect<I["_output"]>, params?: RawCreateParams) => ZodEffects<I, I["_output"], input<I>>;
+declare const effectsType: <I extends ZodTypeAny>(schema: I, effect: Effect<I["_output"]>, params?: RawCreateParams) => ZodEffects<I, I["_output"]>;
 declare const optionalType: <T extends ZodTypeAny>(type: T, params?: RawCreateParams) => ZodOptional<T>;
 declare const nullableType: <T extends ZodTypeAny>(type: T, params?: RawCreateParams) => ZodNullable<T>;
 declare const preprocessType: <I extends ZodTypeAny>(preprocess: (arg: unknown, ctx: RefinementCtx) => unknown, schema: I, params?: RawCreateParams) => ZodEffects<I, I["_output"], unknown>;
@@ -1077,51 +1042,21 @@ declare const ostring: () => ZodOptional<ZodString>;
 declare const onumber: () => ZodOptional<ZodNumber>;
 declare const oboolean: () => ZodOptional<ZodBoolean>;
 export declare const coerce: {
-    string: (params?: ({
-        errorMap?: ZodErrorMap | undefined;
-        invalid_type_error?: string | undefined;
-        required_error?: string | undefined;
-        message?: string | undefined;
-        description?: string | undefined;
-    } & {
-        coerce?: true | undefined;
-    }) | undefined) => ZodString;
-    number: (params?: ({
-        errorMap?: ZodErrorMap | undefined;
-        invalid_type_error?: string | undefined;
-        required_error?: string | undefined;
-        message?: string | undefined;
-        description?: string | undefined;
-    } & {
-        coerce?: boolean | undefined;
-    }) | undefined) => ZodNumber;
-    boolean: (params?: ({
-        errorMap?: ZodErrorMap | undefined;
-        invalid_type_error?: string | undefined;
-        required_error?: string | undefined;
-        message?: string | undefined;
-        description?: string | undefined;
-    } & {
-        coerce?: boolean | undefined;
-    }) | undefined) => ZodBoolean;
-    bigint: (params?: ({
-        errorMap?: ZodErrorMap | undefined;
-        invalid_type_error?: string | undefined;
-        required_error?: string | undefined;
-        message?: string | undefined;
-        description?: string | undefined;
-    } & {
-        coerce?: boolean | undefined;
-    }) | undefined) => ZodBigInt;
-    date: (params?: ({
-        errorMap?: ZodErrorMap | undefined;
-        invalid_type_error?: string | undefined;
-        required_error?: string | undefined;
-        message?: string | undefined;
-        description?: string | undefined;
-    } & {
-        coerce?: boolean | undefined;
-    }) | undefined) => ZodDate;
+    string: (params?: RawCreateParams & {
+        coerce?: true;
+    }) => ZodString;
+    number: (params?: RawCreateParams & {
+        coerce?: boolean;
+    }) => ZodNumber;
+    boolean: (params?: RawCreateParams & {
+        coerce?: boolean;
+    }) => ZodBoolean;
+    bigint: (params?: RawCreateParams & {
+        coerce?: boolean;
+    }) => ZodBigInt;
+    date: (params?: RawCreateParams & {
+        coerce?: boolean;
+    }) => ZodDate;
 };
 export { anyType as any, arrayType as array, bigIntType as bigint, booleanType as boolean, dateType as date, discriminatedUnionType as discriminatedUnion, effectsType as effect, enumType as enum, functionType as function, instanceOfType as instanceof, intersectionType as intersection, lazyType as lazy, literalType as literal, mapType as map, nanType as nan, nativeEnumType as nativeEnum, neverType as never, nullType as null, nullableType as nullable, numberType as number, objectType as object, oboolean, onumber, optionalType as optional, ostring, pipelineType as pipeline, preprocessType as preprocess, promiseType as promise, recordType as record, setType as set, strictObjectType as strictObject, stringType as string, symbolType as symbol, effectsType as transformer, tupleType as tuple, undefinedType as undefined, unionType as union, unknownType as unknown, voidType as void, };
 export declare const NEVER: never;