@rspack/core 1.2.2 → 1.2.3

package/compiled/zod/index.d.ts

@@ -1,5 +1,5 @@
-declare type Primitive = string | number | symbol | bigint | boolean | null | undefined;
-declare type Scalars = Primitive | Primitive[];
+type Primitive = string | number | symbol | bigint | boolean | null | undefined;
+type Scalars = Primitive | Primitive[];
 
 declare namespace util {
     type AssertEqual<T, U> = (<V>() => V extends T ? 1 : 2) extends <V>() => V extends U ? 1 : 2 ? true : false;
@@ -60,33 +60,33 @@ declare namespace objectUtil {
     export {  };
 }
 declare const ZodParsedType: {
-    function: "function";
-    number: "number";
     string: "string";
+    number: "number";
+    bigint: "bigint";
+    boolean: "boolean";
+    symbol: "symbol";
+    undefined: "undefined";
+    object: "object";
+    function: "function";
+    map: "map";
     nan: "nan";
     integer: "integer";
     float: "float";
-    boolean: "boolean";
     date: "date";
-    bigint: "bigint";
-    symbol: "symbol";
-    undefined: "undefined";
     null: "null";
     array: "array";
-    object: "object";
     unknown: "unknown";
     promise: "promise";
     void: "void";
     never: "never";
-    map: "map";
     set: "set";
 };
-declare type ZodParsedType = keyof typeof ZodParsedType;
+type ZodParsedType = keyof typeof ZodParsedType;
 declare const getParsedType: (data: any) => ZodParsedType;
 
-declare type allKeys<T> = T extends any ? keyof T : never;
-declare type inferFlattenedErrors<T extends ZodType<any, any, any>, U = string> = typeToFlattenedError<TypeOf<T>, U>;
-declare type typeToFlattenedError<T, U = string> = {
+type allKeys<T> = T extends any ? keyof T : never;
+type inferFlattenedErrors<T extends ZodType<any, any, any>, U = string> = typeToFlattenedError<TypeOf<T>, U>;
+type typeToFlattenedError<T, U = string> = {
     formErrors: U[];
     fieldErrors: {
         [P in allKeys<T>]?: U[];
@@ -110,8 +110,8 @@ declare const ZodIssueCode: {
     not_multiple_of: "not_multiple_of";
     not_finite: "not_finite";
 };
-declare type ZodIssueCode = keyof typeof ZodIssueCode;
-declare type ZodIssueBase = {
+type ZodIssueCode = keyof typeof ZodIssueCode;
+type ZodIssueBase = {
     path: (string | number)[];
     message?: string;
 };
@@ -153,7 +153,7 @@ interface ZodInvalidReturnTypeIssue extends ZodIssueBase {
 interface ZodInvalidDateIssue extends ZodIssueBase {
     code: typeof ZodIssueCode.invalid_date;
 }
-declare type StringValidation = "email" | "url" | "emoji" | "uuid" | "nanoid" | "regex" | "cuid" | "cuid2" | "ulid" | "datetime" | "date" | "time" | "duration" | "ip" | "base64" | {
+type StringValidation = "email" | "url" | "emoji" | "uuid" | "nanoid" | "regex" | "cuid" | "cuid2" | "ulid" | "datetime" | "date" | "time" | "duration" | "ip" | "cidr" | "base64" | "jwt" | "base64url" | {
     includes: string;
     position?: number;
 } | {
@@ -195,26 +195,26 @@ interface ZodCustomIssue extends ZodIssueBase {
         [k: string]: any;
     };
 }
-declare type DenormalizedError = {
+type DenormalizedError = {
     [k: string]: DenormalizedError | string[];
 };
-declare type ZodIssueOptionalMessage = ZodInvalidTypeIssue | ZodInvalidLiteralIssue | ZodUnrecognizedKeysIssue | ZodInvalidUnionIssue | ZodInvalidUnionDiscriminatorIssue | ZodInvalidEnumValueIssue | ZodInvalidArgumentsIssue | ZodInvalidReturnTypeIssue | ZodInvalidDateIssue | ZodInvalidStringIssue | ZodTooSmallIssue | ZodTooBigIssue | ZodInvalidIntersectionTypesIssue | ZodNotMultipleOfIssue | ZodNotFiniteIssue | ZodCustomIssue;
-declare type ZodIssue = ZodIssueOptionalMessage & {
+type ZodIssueOptionalMessage = ZodInvalidTypeIssue | ZodInvalidLiteralIssue | ZodUnrecognizedKeysIssue | ZodInvalidUnionIssue | ZodInvalidUnionDiscriminatorIssue | ZodInvalidEnumValueIssue | ZodInvalidArgumentsIssue | ZodInvalidReturnTypeIssue | ZodInvalidDateIssue | ZodInvalidStringIssue | ZodTooSmallIssue | ZodTooBigIssue | ZodInvalidIntersectionTypesIssue | ZodNotMultipleOfIssue | ZodNotFiniteIssue | ZodCustomIssue;
+type ZodIssue = ZodIssueOptionalMessage & {
     fatal?: boolean;
     message: string;
 };
 declare const quotelessJson: (obj: any) => string;
-declare type recursiveZodFormattedError<T> = T extends [any, ...any[]] ? {
+type recursiveZodFormattedError<T> = T extends [any, ...any[]] ? {
     [K in keyof T]?: ZodFormattedError<T[K]>;
 } : T extends any[] ? {
     [k: number]: ZodFormattedError<T[number]>;
 } : T extends object ? {
     [K in keyof T]?: ZodFormattedError<T[K]>;
 } : unknown;
-declare type ZodFormattedError<T, U = string> = {
+type ZodFormattedError<T, U = string> = {
     _errors: U[];
 } & recursiveZodFormattedError<NonNullable<T>>;
-declare type inferFormattedError<T extends ZodType<any, any, any>, U = string> = ZodFormattedError<TypeOf<T>, U>;
+type inferFormattedError<T extends ZodType<any, any, any>, U = string> = ZodFormattedError<TypeOf<T>, U>;
 declare class ZodError<T = any> extends Error {
     issues: ZodIssue[];
     get errors(): ZodIssue[];
@@ -232,16 +232,16 @@ declare class ZodError<T = any> extends Error {
     flatten<U>(mapper?: (issue: ZodIssue) => U): typeToFlattenedError<T, U>;
     get formErrors(): typeToFlattenedError<T, string>;
 }
-declare type stripPath<T extends object> = T extends any ? util.OmitKeys<T, "path"> : never;
-declare type IssueData = stripPath<ZodIssueOptionalMessage> & {
+type stripPath<T extends object> = T extends any ? util.OmitKeys<T, "path"> : never;
+type IssueData = stripPath<ZodIssueOptionalMessage> & {
     path?: (string | number)[];
     fatal?: boolean;
 };
-declare type ErrorMapCtx = {
+type ErrorMapCtx = {
     defaultError: string;
     data: any;
 };
-declare type ZodErrorMap = (issue: ZodIssueOptionalMessage, _ctx: ErrorMapCtx) => {
+type ZodErrorMap = (issue: ZodIssueOptionalMessage, _ctx: ErrorMapCtx) => {
     message: string;
 };
 
@@ -256,13 +256,13 @@ declare const makeIssue: (params: {
     errorMaps: ZodErrorMap[];
     issueData: IssueData;
 }) => ZodIssue;
-declare type ParseParams = {
+type ParseParams = {
     path: (string | number)[];
     errorMap: ZodErrorMap;
     async: boolean;
 };
-declare type ParsePathComponent = string | number;
-declare type ParsePath = ParsePathComponent[];
+type ParsePathComponent = string | number;
+type ParsePath = ParsePathComponent[];
 declare const EMPTY_PATH: ParsePath;
 interface ParseContext {
     readonly common: {
@@ -276,13 +276,13 @@ interface ParseContext {
     readonly data: any;
     readonly parsedType: ZodParsedType;
 }
-declare type ParseInput = {
+type ParseInput = {
     data: any;
     path: (string | number)[];
     parent: ParseContext;
 };
 declare function addIssueToContext(ctx: ParseContext, issueData: IssueData): void;
-declare type ObjectPair = {
+type ObjectPair = {
     key: SyncParseReturnType<any>;
     value: SyncParseReturnType<any>;
 };
@@ -305,23 +305,23 @@ interface ParseResult {
     status: "aborted" | "dirty" | "valid";
     data: any;
 }
-declare type INVALID = {
+type INVALID = {
     status: "aborted";
 };
 declare const INVALID: INVALID;
-declare type DIRTY<T> = {
+type DIRTY<T> = {
     status: "dirty";
     value: T;
 };
 declare const DIRTY: <T>(value: T) => DIRTY<T>;
-declare type OK<T> = {
+type OK<T> = {
     status: "valid";
     value: T;
 };
 declare const OK: <T>(value: T) => OK<T>;
-declare type SyncParseReturnType<T = any> = OK<T> | DIRTY<T> | INVALID;
-declare type AsyncParseReturnType<T> = Promise<SyncParseReturnType<T>>;
-declare type ParseReturnType<T> = SyncParseReturnType<T> | AsyncParseReturnType<T>;
+type SyncParseReturnType<T = any> = OK<T> | DIRTY<T> | INVALID;
+type AsyncParseReturnType<T> = Promise<SyncParseReturnType<T>>;
+type ParseReturnType<T> = SyncParseReturnType<T> | AsyncParseReturnType<T>;
 declare const isAborted: (x: ParseReturnType<any>) => x is INVALID;
 declare const isDirty: <T>(x: ParseReturnType<T>) => x is OK<T> | DIRTY<T>;
 declare const isValid: <T>(x: ParseReturnType<T>) => x is OK<T>;
@@ -340,10 +340,10 @@ declare namespace errorUtil {
     type ErrMessage = string | {
         message?: string;
     };
-    const errToObj: (message?: ErrMessage | undefined) => {
+    const errToObj: (message?: ErrMessage) => {
         message?: string | undefined;
     };
-    const toString: (message?: ErrMessage | undefined) => string | undefined;
+    const toString: (message?: ErrMessage) => string | undefined;
 }
 
 declare namespace partialUtil {
@@ -354,51 +354,155 @@ declare namespace partialUtil {
     } extends infer PI ? PI extends ZodTupleItems ? ZodTuple<PI> : never : never : T;
 }
 
+/**
+ * The Standard Schema interface.
+ */
+type StandardSchemaV1<Input = unknown, Output = Input> = {
+    /**
+     * The Standard Schema properties.
+     */
+    readonly "~standard": StandardSchemaV1.Props<Input, Output>;
+};
+declare namespace StandardSchemaV1 {
+    /**
+     * The Standard Schema properties interface.
+     */
+    export interface Props<Input = unknown, Output = Input> {
+        /**
+         * The version number of the standard.
+         */
+        readonly version: 1;
+        /**
+         * The vendor name of the schema library.
+         */
+        readonly vendor: string;
+        /**
+         * Validates unknown input values.
+         */
+        readonly validate: (value: unknown) => Result<Output> | Promise<Result<Output>>;
+        /**
+         * Inferred types associated with the schema.
+         */
+        readonly types?: Types<Input, Output> | undefined;
+    }
+    /**
+     * The result interface of the validate function.
+     */
+    export type Result<Output> = SuccessResult<Output> | FailureResult;
+    /**
+     * The result interface if validation succeeds.
+     */
+    export interface SuccessResult<Output> {
+        /**
+         * The typed output value.
+         */
+        readonly value: Output;
+        /**
+         * The non-existent issues.
+         */
+        readonly issues?: undefined;
+    }
+    /**
+     * The result interface if validation fails.
+     */
+    export interface FailureResult {
+        /**
+         * The issues of failed validation.
+         */
+        readonly issues: ReadonlyArray<Issue>;
+    }
+    /**
+     * The issue interface of the failure output.
+     */
+    export interface Issue {
+        /**
+         * The error message of the issue.
+         */
+        readonly message: string;
+        /**
+         * The path of the issue, if any.
+         */
+        readonly path?: ReadonlyArray<PropertyKey | PathSegment> | undefined;
+    }
+    /**
+     * The path segment interface of the issue.
+     */
+    export interface PathSegment {
+        /**
+         * The key representing a path segment.
+         */
+        readonly key: PropertyKey;
+    }
+    /**
+     * The Standard Schema types interface.
+     */
+    export interface Types<Input = unknown, Output = Input> {
+        /**
+         * The input type of the schema.
+         */
+        readonly input: Input;
+        /**
+         * The output type of the schema.
+         */
+        readonly output: Output;
+    }
+    /**
+     * Infers the input type of a Standard Schema.
+     */
+    export type InferInput<Schema extends StandardSchemaV1> = NonNullable<Schema["~standard"]["types"]>["input"];
+    /**
+     * Infers the output type of a Standard Schema.
+     */
+    export type InferOutput<Schema extends StandardSchemaV1> = NonNullable<Schema["~standard"]["types"]>["output"];
+    export {  };
+}
+
 interface RefinementCtx {
     addIssue: (arg: IssueData) => void;
     path: (string | number)[];
 }
-declare type ZodRawShape = {
+type ZodRawShape = {
     [k: string]: ZodTypeAny;
 };
-declare type ZodTypeAny = ZodType<any, any, any>;
-declare type TypeOf<T extends ZodType<any, any, any>> = T["_output"];
-declare type input<T extends ZodType<any, any, any>> = T["_input"];
-declare type output<T extends ZodType<any, any, any>> = T["_output"];
+type ZodTypeAny = ZodType<any, any, any>;
+type TypeOf<T extends ZodType<any, any, any>> = T["_output"];
+type input<T extends ZodType<any, any, any>> = T["_input"];
+type output<T extends ZodType<any, any, any>> = T["_output"];
 
-declare type CustomErrorParams = Partial<util.Omit<ZodCustomIssue, "code">>;
+type CustomErrorParams = Partial<util.Omit<ZodCustomIssue, "code">>;
 interface ZodTypeDef {
     errorMap?: ZodErrorMap;
     description?: string;
 }
-declare type RawCreateParams = {
+type RawCreateParams = {
     errorMap?: ZodErrorMap;
     invalid_type_error?: string;
     required_error?: string;
     message?: string;
     description?: string;
 } | undefined;
-declare type ProcessedCreateParams = {
+type ProcessedCreateParams = {
     errorMap?: ZodErrorMap;
     description?: string;
 };
-declare type SafeParseSuccess<Output> = {
+type SafeParseSuccess<Output> = {
     success: true;
     data: Output;
     error?: never;
 };
-declare type SafeParseError<Input> = {
+type SafeParseError<Input> = {
     success: false;
     error: ZodError<Input>;
     data?: never;
 };
-declare type SafeParseReturnType<Input, Output> = SafeParseSuccess<Output> | SafeParseError<Input>;
+type SafeParseReturnType<Input, Output> = SafeParseSuccess<Output> | SafeParseError<Input>;
 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;
@@ -410,10 +514,11 @@ declare abstract class ZodType<Output = any, Def extends ZodTypeDef = ZodTypeDef
     _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>;
@@ -445,8 +550,8 @@ declare abstract class ZodType<Output = any, Def extends ZodTypeDef = ZodTypeDef
     isOptional(): boolean;
     isNullable(): boolean;
 }
-declare type IpVersion = "v4" | "v6";
-declare type ZodStringCheck = {
+type IpVersion = "v4" | "v6";
+type ZodStringCheck = {
     kind: "min";
     value: number;
     message?: string;
@@ -508,6 +613,10 @@ declare type ZodStringCheck = {
 } | {
     kind: "toUpperCase";
     message?: string;
+} | {
+    kind: "jwt";
+    alg?: string;
+    message?: string;
 } | {
     kind: "datetime";
     offset: boolean;
@@ -528,9 +637,16 @@ declare type ZodStringCheck = {
     kind: "ip";
     version?: IpVersion;
     message?: string;
+} | {
+    kind: "cidr";
+    version?: IpVersion;
+    message?: string;
 } | {
     kind: "base64";
     message?: string;
+} | {
+    kind: "base64url";
+    message?: string;
 };
 interface ZodStringDef extends ZodTypeDef {
     checks: ZodStringCheck[];
@@ -555,8 +671,17 @@ 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 | {
@@ -582,8 +707,7 @@ 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;
@@ -602,20 +726,16 @@ 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;
 }
-declare type ZodNumberCheck = {
+type ZodNumberCheck = {
     kind: "min";
     value: number;
     inclusive: boolean;
@@ -643,20 +763,14 @@ interface ZodNumberDef extends ZodTypeDef {
 }
 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;
@@ -666,7 +780,7 @@ 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;
@@ -674,7 +788,7 @@ declare class ZodNumber extends ZodType<number, ZodNumberDef, number> {
     get isInt(): boolean;
     get isFinite(): boolean;
 }
-declare type ZodBigIntCheck = {
+type ZodBigIntCheck = {
     kind: "min";
     value: bigint;
     inclusive: boolean;
@@ -696,20 +810,15 @@ interface ZodBigIntDef extends ZodTypeDef {
 }
 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;
@@ -727,17 +836,11 @@ interface ZodBooleanDef extends ZodTypeDef {
 }
 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;
 }
-declare type ZodDateCheck = {
+type ZodDateCheck = {
     kind: "min";
     value: number;
     message?: string;
@@ -758,15 +861,9 @@ 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;
 }
 interface ZodSymbolDef extends ZodTypeDef {
     typeName: ZodFirstPartyTypeKind.ZodSymbol;
@@ -836,8 +933,8 @@ interface ZodArrayDef<T extends ZodTypeAny = ZodTypeAny> extends ZodTypeDef {
         message?: string;
     } | null;
 }
-declare type ArrayCardinality = "many" | "atleastone";
-declare type arrayOutputType<T extends ZodTypeAny, Cardinality extends ArrayCardinality = "many"> = Cardinality extends "atleastone" ? [T["_output"], ...T["_output"][]] : T["_output"][];
+type ArrayCardinality = "many" | "atleastone";
+type arrayOutputType<T extends ZodTypeAny, Cardinality extends ArrayCardinality = "many"> = Cardinality extends "atleastone" ? [T["_output"], ...T["_output"][]] : T["_output"][];
 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;
@@ -847,37 +944,37 @@ declare class ZodArray<T extends ZodTypeAny, Cardinality extends ArrayCardinalit
     nonempty(message?: errorUtil.ErrMessage): ZodArray<T, "atleastone">;
     static create: <T_1 extends ZodTypeAny>(schema: T_1, params?: RawCreateParams) => ZodArray<T_1, "many">;
 }
-declare type ZodNonEmptyArray<T extends ZodTypeAny> = ZodArray<T, "atleastone">;
-declare type UnknownKeysParam = "passthrough" | "strict" | "strip";
+type ZodNonEmptyArray<T extends ZodTypeAny> = ZodArray<T, "atleastone">;
+type UnknownKeysParam = "passthrough" | "strict" | "strip";
 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;
 }
-declare type mergeTypes<A, B> = {
+type mergeTypes<A, B> = {
     [k in keyof A | keyof B]: k extends keyof B ? B[k] : k extends keyof A ? A[k] : never;
 };
-declare type objectOutputType<Shape extends ZodRawShape, Catchall extends ZodTypeAny, UnknownKeys extends UnknownKeysParam = UnknownKeysParam> = objectUtil.flatten<objectUtil.addQuestionMarks<baseObjectOutputType<Shape>>> & CatchallOutput<Catchall> & PassthroughType<UnknownKeys>;
-declare type baseObjectOutputType<Shape extends ZodRawShape> = {
+type objectOutputType<Shape extends ZodRawShape, Catchall extends ZodTypeAny, UnknownKeys extends UnknownKeysParam = UnknownKeysParam> = objectUtil.flatten<objectUtil.addQuestionMarks<baseObjectOutputType<Shape>>> & CatchallOutput<Catchall> & PassthroughType<UnknownKeys>;
+type baseObjectOutputType<Shape extends ZodRawShape> = {
     [k in keyof Shape]: Shape[k]["_output"];
 };
-declare type objectInputType<Shape extends ZodRawShape, Catchall extends ZodTypeAny, UnknownKeys extends UnknownKeysParam = UnknownKeysParam> = objectUtil.flatten<baseObjectInputType<Shape>> & CatchallInput<Catchall> & PassthroughType<UnknownKeys>;
-declare type baseObjectInputType<Shape extends ZodRawShape> = objectUtil.addQuestionMarks<{
+type objectInputType<Shape extends ZodRawShape, Catchall extends ZodTypeAny, UnknownKeys extends UnknownKeysParam = UnknownKeysParam> = objectUtil.flatten<baseObjectInputType<Shape>> & CatchallInput<Catchall> & PassthroughType<UnknownKeys>;
+type baseObjectInputType<Shape extends ZodRawShape> = objectUtil.addQuestionMarks<{
     [k in keyof Shape]: Shape[k]["_input"];
 }>;
-declare type CatchallOutput<T extends ZodType> = ZodType extends T ? unknown : {
+type CatchallOutput<T extends ZodType> = ZodType extends T ? unknown : {
     [k: string]: T["_output"];
 };
-declare type CatchallInput<T extends ZodType> = ZodType extends T ? unknown : {
+type CatchallInput<T extends ZodType> = ZodType extends T ? unknown : {
     [k: string]: T["_input"];
 };
-declare type PassthroughType<T extends UnknownKeysParam> = T extends "passthrough" ? {
+type PassthroughType<T extends UnknownKeysParam> = T extends "passthrough" ? {
     [k: string]: unknown;
 } : unknown;
-declare type deoptional<T extends ZodTypeAny> = T extends ZodOptional<infer U> ? deoptional<U> : T extends ZodNullable<infer U> ? ZodNullable<deoptional<U>> : T;
-declare type SomeZodObject = ZodObject<ZodRawShape, UnknownKeysParam, ZodTypeAny>;
-declare type noUnrecognized<Obj extends object, Shape extends object> = {
+type deoptional<T extends ZodTypeAny> = T extends ZodOptional<infer U> ? deoptional<U> : T extends ZodNullable<infer U> ? ZodNullable<deoptional<U>> : T;
+type SomeZodObject = ZodObject<ZodRawShape, UnknownKeysParam, ZodTypeAny>;
+type noUnrecognized<Obj extends object, Shape extends object> = {
     [k in keyof Obj]: k extends keyof Shape ? Obj[k] : never;
 };
 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> {
@@ -900,7 +997,7 @@ declare class ZodObject<T extends ZodRawShape, UnknownKeys extends UnknownKeysPa
     /**
      * @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
@@ -938,12 +1035,12 @@ declare class ZodObject<T extends ZodRawShape, UnknownKeys extends UnknownKeysPa
         [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>;
 }
-declare type AnyZodObject = ZodObject<any, any, any>;
-declare type ZodUnionOptions = Readonly<[ZodTypeAny, ...ZodTypeAny[]]>;
+type AnyZodObject = ZodObject<any, any, any>;
+type ZodUnionOptions = Readonly<[ZodTypeAny, ...ZodTypeAny[]]>;
 interface ZodUnionDef<T extends ZodUnionOptions = Readonly<[
     ZodTypeAny,
     ZodTypeAny,
@@ -957,16 +1054,16 @@ declare class ZodUnion<T extends ZodUnionOptions> extends ZodType<T[number]["_ou
     get options(): T;
     static create: <T_1 extends readonly [ZodTypeAny, ZodTypeAny, ...ZodTypeAny[]]>(types: T_1, params?: RawCreateParams) => ZodUnion<T_1>;
 }
-declare type ZodDiscriminatedUnionOption<Discriminator extends string> = ZodObject<{
+type ZodDiscriminatedUnionOption<Discriminator extends string> = ZodObject<{
     [key in Discriminator]: ZodTypeAny;
 } & ZodRawShape, UnknownKeysParam, ZodTypeAny>;
-interface ZodDiscriminatedUnionDef<Discriminator extends string, Options extends ZodDiscriminatedUnionOption<string>[] = ZodDiscriminatedUnionOption<string>[]> extends ZodTypeDef {
+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;
 }
-declare class ZodDiscriminatedUnion<Discriminator extends string, Options extends ZodDiscriminatedUnionOption<Discriminator>[]> extends ZodType<output<Options[number]>, ZodDiscriminatedUnionDef<Discriminator, Options>, input<Options[number]>> {
+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;
@@ -979,7 +1076,7 @@ declare class ZodDiscriminatedUnion<Discriminator extends string, Options extend
      * @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>;
@@ -993,22 +1090,22 @@ declare class ZodIntersection<T extends ZodTypeAny, U extends ZodTypeAny> extend
     _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>;
 }
-declare type ZodTupleItems = [ZodTypeAny, ...ZodTypeAny[]];
-declare type AssertArray<T> = T extends any[] ? T : never;
-declare type OutputTypeOfTuple<T extends ZodTupleItems | []> = AssertArray<{
+type ZodTupleItems = [ZodTypeAny, ...ZodTypeAny[]];
+type AssertArray<T> = T extends any[] ? T : never;
+type OutputTypeOfTuple<T extends ZodTupleItems | []> = AssertArray<{
     [k in keyof T]: T[k] extends ZodType<any, any, any> ? T[k]["_output"] : never;
 }>;
-declare type OutputTypeOfTupleWithRest<T extends ZodTupleItems | [], Rest extends ZodTypeAny | null = null> = Rest extends ZodTypeAny ? [...OutputTypeOfTuple<T>, ...Rest["_output"][]] : OutputTypeOfTuple<T>;
-declare type InputTypeOfTuple<T extends ZodTupleItems | []> = AssertArray<{
+type OutputTypeOfTupleWithRest<T extends ZodTupleItems | [], Rest extends ZodTypeAny | null = null> = Rest extends ZodTypeAny ? [...OutputTypeOfTuple<T>, ...Rest["_output"][]] : OutputTypeOfTuple<T>;
+type InputTypeOfTuple<T extends ZodTupleItems | []> = AssertArray<{
     [k in keyof T]: T[k] extends ZodType<any, any, any> ? T[k]["_input"] : never;
 }>;
-declare type InputTypeOfTupleWithRest<T extends ZodTupleItems | [], Rest extends ZodTypeAny | null = null> = Rest extends ZodTypeAny ? [...InputTypeOfTuple<T>, ...Rest["_input"][]] : InputTypeOfTuple<T>;
+type InputTypeOfTupleWithRest<T extends ZodTupleItems | [], Rest extends ZodTypeAny | null = null> = Rest extends ZodTypeAny ? [...InputTypeOfTuple<T>, ...Rest["_input"][]] : InputTypeOfTuple<T>;
 interface ZodTupleDef<T extends ZodTupleItems | [] = ZodTupleItems, Rest extends ZodTypeAny | null = null> extends ZodTypeDef {
     items: T;
     rest: Rest;
     typeName: ZodFirstPartyTypeKind.ZodTuple;
 }
-declare type AnyZodTuple = ZodTuple<[
+type AnyZodTuple = ZodTuple<[
     ZodTypeAny,
     ...ZodTypeAny[]
 ] | [], ZodTypeAny | null>;
@@ -1023,8 +1120,8 @@ interface ZodRecordDef<Key extends KeySchema = ZodString, Value extends ZodTypeA
     keyType: Key;
     typeName: ZodFirstPartyTypeKind.ZodRecord;
 }
-declare type KeySchema = ZodType<string | number | symbol, any, any>;
-declare type RecordType<K extends string | number | symbol, V> = [
+type KeySchema = ZodType<string | number | symbol, any, any>;
+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>>;
 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"]>> {
@@ -1071,8 +1168,8 @@ interface ZodFunctionDef<Args extends ZodTuple<any, any> = ZodTuple<any, any>, R
     returns: Returns;
     typeName: ZodFirstPartyTypeKind.ZodFunction;
 }
-declare type OuterTypeOfFunction<Args extends ZodTuple<any, any>, Returns extends ZodTypeAny> = Args["_input"] extends Array<any> ? (...args: Args["_input"]) => Returns["_output"] : never;
-declare type InnerTypeOfFunction<Args extends ZodTuple<any, any>, Returns extends ZodTypeAny> = Args["_output"] extends Array<any> ? (...args: Args["_output"]) => Returns["_input"] : never;
+type OuterTypeOfFunction<Args extends ZodTuple<any, any>, Returns extends ZodTypeAny> = Args["_input"] extends Array<any> ? (...args: Args["_input"]) => Returns["_output"] : never;
+type InnerTypeOfFunction<Args extends ZodTuple<any, any>, Returns extends ZodTypeAny> = Args["_output"] extends Array<any> ? (...args: Args["_output"]) => Returns["_input"] : never;
 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;
@@ -1105,21 +1202,21 @@ 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>;
 }
-declare type ArrayKeys = keyof any[];
-declare type Indices<T> = Exclude<keyof T, ArrayKeys>;
-declare type EnumValues<T extends string = string> = readonly [T, ...T[]];
-declare type Values<T extends EnumValues> = {
+type ArrayKeys = keyof any[];
+type Indices<T> = Exclude<keyof T, ArrayKeys>;
+type EnumValues<T extends string = string> = readonly [T, ...T[]];
+type Values<T extends EnumValues> = {
     [k in T[number]]: k;
 };
 interface ZodEnumDef<T extends EnumValues = EnumValues> extends ZodTypeDef {
     values: T;
     typeName: ZodFirstPartyTypeKind.ZodEnum;
 }
-declare type Writeable<T> = {
+type Writeable<T> = {
     -readonly [P in keyof T]: T[P];
 };
-declare type FilterEnum<Values, ToExclude> = Values extends [] ? [] : Values extends [infer Head, ...infer Rest] ? Head extends ToExclude ? FilterEnum<Rest, ToExclude> : [Head, ...FilterEnum<Rest, ToExclude>] : never;
-declare type typecast<A, T> = A extends T ? A : never;
+type FilterEnum<Values, ToExclude> = Values extends [] ? [] : Values extends [infer Head, ...infer Rest] ? Head extends ToExclude ? FilterEnum<Rest, ToExclude> : [Head, ...FilterEnum<Rest, ToExclude>] : never;
+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>;
 declare class ZodEnum<T extends [string, ...string[]]> extends ZodType<T[number], ZodEnumDef<T>, T[number]> {
@@ -1137,7 +1234,7 @@ interface ZodNativeEnumDef<T extends EnumLike = EnumLike> extends ZodTypeDef {
     values: T;
     typeName: ZodFirstPartyTypeKind.ZodNativeEnum;
 }
-declare type EnumLike = {
+type EnumLike = {
     [k: string]: string | number;
     [nu: number]: string;
 };
@@ -1156,21 +1253,21 @@ declare class ZodPromise<T extends ZodTypeAny> extends ZodType<Promise<T["_outpu
     _parse(input: ParseInput): ParseReturnType<this["_output"]>;
     static create: <T_1 extends ZodTypeAny>(schema: T_1, params?: RawCreateParams) => ZodPromise<T_1>;
 }
-declare type Refinement<T> = (arg: T, ctx: RefinementCtx) => any;
-declare type SuperRefinement<T> = (arg: T, ctx: RefinementCtx) => void | Promise<void>;
-declare type RefinementEffect<T> = {
+type Refinement<T> = (arg: T, ctx: RefinementCtx) => any;
+type SuperRefinement<T> = (arg: T, ctx: RefinementCtx) => void | Promise<void>;
+type RefinementEffect<T> = {
     type: "refinement";
     refinement: (arg: T, ctx: RefinementCtx) => any;
 };
-declare type TransformEffect<T> = {
+type TransformEffect<T> = {
     type: "transform";
     transform: (arg: T, ctx: RefinementCtx) => any;
 };
-declare type PreprocessEffect<T> = {
+type PreprocessEffect<T> = {
     type: "preprocess";
     transform: (arg: T, ctx: RefinementCtx) => any;
 };
-declare type Effect<T> = RefinementEffect<T> | TransformEffect<T> | PreprocessEffect<T>;
+type Effect<T> = RefinementEffect<T> | TransformEffect<T> | PreprocessEffect<T>;
 interface ZodEffectsDef<T extends ZodTypeAny = ZodTypeAny> extends ZodTypeDef {
     schema: T;
     typeName: ZodFirstPartyTypeKind.ZodEffects;
@@ -1180,7 +1277,7 @@ declare class ZodEffects<T extends ZodTypeAny, Output = output<T>, Input = 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>;
 }
 
@@ -1188,7 +1285,7 @@ interface ZodOptionalDef<T extends ZodTypeAny = ZodTypeAny> extends ZodTypeDef {
     innerType: T;
     typeName: ZodFirstPartyTypeKind.ZodOptional;
 }
-declare type ZodOptionalType<T extends ZodTypeAny> = ZodOptional<T>;
+type ZodOptionalType<T extends ZodTypeAny> = ZodOptional<T>;
 declare class ZodOptional<T extends ZodTypeAny> extends ZodType<T["_output"] | undefined, ZodOptionalDef<T>, T["_input"] | undefined> {
     _parse(input: ParseInput): ParseReturnType<this["_output"]>;
     unwrap(): T;
@@ -1198,7 +1295,7 @@ interface ZodNullableDef<T extends ZodTypeAny = ZodTypeAny> extends ZodTypeDef {
     innerType: T;
     typeName: ZodFirstPartyTypeKind.ZodNullable;
 }
-declare type ZodNullableType<T extends ZodTypeAny> = ZodNullable<T>;
+type ZodNullableType<T extends ZodTypeAny> = ZodNullable<T>;
 declare class ZodNullable<T extends ZodTypeAny> extends ZodType<T["_output"] | null, ZodNullableDef<T>, T["_input"] | null> {
     _parse(input: ParseInput): ParseReturnType<this["_output"]>;
     unwrap(): T;
@@ -1255,7 +1352,7 @@ interface ZodBrandedDef<T extends ZodTypeAny> extends ZodTypeDef {
     typeName: ZodFirstPartyTypeKind.ZodBranded;
 }
 declare const BRAND: unique symbol;
-declare type BRAND<T extends string | number | symbol> = {
+type BRAND<T extends string | number | symbol> = {
     [BRAND]: {
         [k in T]: true;
     };
@@ -1273,10 +1370,10 @@ declare class ZodPipeline<A extends ZodTypeAny, B extends ZodTypeAny> extends Zo
     _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>;
 interface ZodReadonlyDef<T extends ZodTypeAny = ZodTypeAny> extends ZodTypeDef {
     innerType: T;
     typeName: ZodFirstPartyTypeKind.ZodReadonly;
@@ -1286,7 +1383,7 @@ declare class ZodReadonly<T extends ZodTypeAny> extends ZodType<MakeReadonly<T["
     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;
 };
 declare function custom<T>(check?: (data: any) => any, params?: string | CustomParams | ((input: any) => CustomParams), 
@@ -1303,7 +1400,7 @@ declare function custom<T>(check?: (data: any) => any, params?: string | CustomP
 fatal?: boolean): ZodType<T, ZodTypeDef, T>;
 
 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">;
 };
 declare enum ZodFirstPartyTypeKind {
     ZodString = "ZodString",
@@ -1343,57 +1440,27 @@ declare enum ZodFirstPartyTypeKind {
     ZodPipeline = "ZodPipeline",
     ZodReadonly = "ZodReadonly"
 }
-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;
+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;
@@ -1401,9 +1468,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>;
@@ -1417,7 +1484,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>;
@@ -1426,51 +1493,21 @@ declare const ostring: () => ZodOptional<ZodString>;
 declare const onumber: () => ZodOptional<ZodNumber>;
 declare const oboolean: () => ZodOptional<ZodBoolean>;
 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;
 };
 
 declare const NEVER: never;
@@ -1565,9 +1602,9 @@ type z_ZodDateDef = ZodDateDef;
 type z_ZodDefault<T extends ZodTypeAny> = ZodDefault<T>;
 declare const z_ZodDefault: typeof ZodDefault;
 type z_ZodDefaultDef<T extends ZodTypeAny = ZodTypeAny> = ZodDefaultDef<T>;
-type z_ZodDiscriminatedUnion<Discriminator extends string, Options extends ZodDiscriminatedUnionOption<Discriminator>[]> = ZodDiscriminatedUnion<Discriminator, Options>;
+type z_ZodDiscriminatedUnion<Discriminator extends string, Options extends readonly ZodDiscriminatedUnionOption<Discriminator>[]> = ZodDiscriminatedUnion<Discriminator, Options>;
 declare const z_ZodDiscriminatedUnion: typeof ZodDiscriminatedUnion;
-type z_ZodDiscriminatedUnionDef<Discriminator extends string, Options extends ZodDiscriminatedUnionOption<string>[] = ZodDiscriminatedUnionOption<string>[]> = ZodDiscriminatedUnionDef<Discriminator, Options>;
+type z_ZodDiscriminatedUnionDef<Discriminator extends string, Options extends readonly ZodDiscriminatedUnionOption<string>[] = ZodDiscriminatedUnionOption<string>[]> = ZodDiscriminatedUnionDef<Discriminator, Options>;
 type z_ZodDiscriminatedUnionOption<Discriminator extends string> = ZodDiscriminatedUnionOption<Discriminator>;
 type z_ZodEffects<T extends ZodTypeAny, Output = output<T>, Input = input<T>> = ZodEffects<T, Output, Input>;
 declare const z_ZodEffects: typeof ZodEffects;