zod 3.20.2 → 3.20.6

package/lib/types.d.ts

@@ -72,7 +72,7 @@ export declare abstract class ZodType<Output = any, Def extends ZodTypeDef = Zod
     constructor(def: Def);
     optional(): ZodOptional<this>;
     nullable(): ZodNullable<this>;
-    nullish(): ZodNullable<ZodOptional<this>>;
+    nullish(): ZodOptional<ZodNullable<this>>;
     array(): ZodArray<this>;
     promise(): ZodPromise<this>;
     or<T extends ZodTypeAny>(option: T): ZodUnion<[this, T]>;
@@ -81,8 +81,8 @@ export declare abstract class ZodType<Output = any, Def extends ZodTypeDef = Zod
     default(def: util.noUndefined<Input>): ZodDefault<this>;
     default(def: () => util.noUndefined<Input>): ZodDefault<this>;
     brand<B extends string | number | symbol>(brand?: B): ZodBranded<this, B>;
-    catch(def: Input): ZodCatch<this>;
-    catch(def: () => Input): ZodCatch<this>;
+    catch(def: Output): ZodCatch<this>;
+    catch(def: () => Output): ZodCatch<this>;
     describe(description: string): this;
     pipe<T extends ZodTypeAny>(target: T): ZodPipeline<this, T>;
     isOptional(): boolean;
@@ -112,6 +112,9 @@ export declare type ZodStringCheck = {
 } | {
     kind: "cuid";
     message?: string;
+} | {
+    kind: "cuid2";
+    message?: string;
 } | {
     kind: "startsWith";
     value: string;
@@ -146,6 +149,7 @@ export declare class ZodString extends ZodType<string, ZodStringDef> {
     url(message?: errorUtil.ErrMessage): ZodString;
     uuid(message?: errorUtil.ErrMessage): ZodString;
     cuid(message?: errorUtil.ErrMessage): ZodString;
+    cuid2(message?: errorUtil.ErrMessage): ZodString;
     datetime(options?: string | {
         message?: string | undefined;
         precision?: number | null;
@@ -168,6 +172,7 @@ export declare class ZodString extends ZodType<string, ZodStringDef> {
     get isURL(): boolean;
     get isUUID(): boolean;
     get isCUID(): boolean;
+    get isCUID2(): boolean;
     get minLength(): number | null;
     get maxLength(): number | null;
     static create: (params?: ({
@@ -234,6 +239,7 @@ export declare class ZodNumber extends ZodType<number, ZodNumberDef> {
     get minValue(): number | null;
     get maxValue(): number | null;
     get isInt(): boolean;
+    get isFinite(): boolean;
 }
 export interface ZodBigIntDef extends ZodTypeDef {
     typeName: ZodFirstPartyTypeKind.ZodBigInt;
@@ -399,7 +405,7 @@ export declare namespace objectUtil {
     export const mergeShapes: <U extends ZodRawShape, T extends ZodRawShape>(first: U, second: T) => T & U;
     export {};
 }
-export declare type extendShape<A, B> = Omit<A, keyof B> & B;
+export declare type extendShape<A, B> = util.flatten<Omit<A, keyof B> & B>;
 export declare 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;
@@ -407,10 +413,14 @@ export interface ZodObjectDef<T extends ZodRawShape = ZodRawShape, UnknownKeys e
     catchall: Catchall;
     unknownKeys: UnknownKeys;
 }
-export declare type baseObjectOutputType<Shape extends ZodRawShape> = objectUtil.flatten<objectUtil.addQuestionMarks<{
+export declare 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 processType<T extends object> = util.flatten<objectUtil.addQuestionMarks<T>>;
+export declare type baseObjectOutputType<Shape extends ZodRawShape> = objectUtil.addQuestionMarks<{
     [k in keyof Shape]: Shape[k]["_output"];
-}>>;
-export declare type objectOutputType<Shape extends ZodRawShape, Catchall extends ZodTypeAny> = ZodTypeAny extends Catchall ? baseObjectOutputType<Shape> : objectUtil.flatten<baseObjectOutputType<Shape> & {
+}>;
+export declare type objectOutputType<Shape extends ZodRawShape, Catchall extends ZodTypeAny> = ZodTypeAny extends Catchall ? objectUtil.flatten<baseObjectOutputType<Shape>> : objectUtil.flatten<baseObjectOutputType<Shape> & {
     [k: string]: Catchall["_output"];
 }>;
 export declare type baseObjectInputType<Shape extends ZodRawShape> = objectUtil.flatten<objectUtil.addQuestionMarks<{
@@ -420,8 +430,14 @@ export declare type objectInputType<Shape extends ZodRawShape, Catchall extends
     [k: string]: Catchall["_input"];
 }>;
 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, any, any>;
-export declare class ZodObject<T extends ZodRawShape, UnknownKeys extends UnknownKeysParam = "strip", Catchall extends ZodTypeAny = ZodTypeAny, Output = objectOutputType<T, Catchall>, Input = objectInputType<T, Catchall>> extends ZodType<Output, ZodObjectDef<T, UnknownKeys, Catchall>, Input> {
+export declare type SomeZodObject = ZodObject<ZodRawShape, UnknownKeysParam, ZodTypeAny>;
+export declare type objectKeyMask<Obj> = {
+    [k in keyof Obj]?: true;
+};
+export declare 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>, Input = objectInputType<T, Catchall>> extends ZodType<Output, ZodObjectDef<T, UnknownKeys, Catchall>, Input> {
     private _cached;
     _getCached(): {
         shape: T;
@@ -437,45 +453,40 @@ export declare class ZodObject<T extends ZodRawShape, UnknownKeys extends Unknow
      * If you want to pass through unknown properties, use `.passthrough()` instead.
      */
     nonstrict: () => ZodObject<T, "passthrough", Catchall>;
-    augment: <Augmentation extends ZodRawShape>(augmentation: Augmentation) => ZodObject<extendShape<T, Augmentation>, UnknownKeys, Catchall, objectOutputType<extendShape<T, Augmentation>, Catchall>, objectInputType<extendShape<T, Augmentation>, Catchall>>;
-    extend: <Augmentation extends ZodRawShape>(augmentation: Augmentation) => ZodObject<extendShape<T, Augmentation>, UnknownKeys, Catchall, objectOutputType<extendShape<T, Augmentation>, Catchall>, objectInputType<extendShape<T, Augmentation>, Catchall>>;
-    setKey<Key extends string, Schema extends ZodTypeAny>(key: Key, schema: Schema): ZodObject<T & {
-        [k in Key]: Schema;
-    }, UnknownKeys, Catchall>;
+    extend<Augmentation extends ZodRawShape>(augmentation: Augmentation): ZodObject<extendShape<T, Augmentation>, UnknownKeys, Catchall>;
+    /**
+     * @deprecated Use `.extend` instead
+     *  */
+    augment: <Augmentation extends ZodRawShape>(augmentation: Augmentation) => ZodObject<{ [k in keyof (Omit<T, keyof Augmentation> & Augmentation)]: (Omit<T, keyof Augmentation> & Augmentation)[k]; }, UnknownKeys, Catchall, objectOutputType<{ [k in keyof (Omit<T, keyof Augmentation> & Augmentation)]: (Omit<T, keyof Augmentation> & Augmentation)[k]; }, Catchall>, objectInputType<{ [k in keyof (Omit<T, keyof Augmentation> & Augmentation)]: (Omit<T, keyof Augmentation> & Augmentation)[k]; }, Catchall>>;
     /**
      * Prior to zod@1.0.12 there was a bug in the
      * inferred type of merged objects. Please
      * upgrade if you are experiencing issues.
      */
-    merge<Incoming extends AnyZodObject>(merging: Incoming): ZodObject<extendShape<T, ReturnType<Incoming["_def"]["shape"]>>, Incoming["_def"]["unknownKeys"], Incoming["_def"]["catchall"]>;
+    merge<Incoming extends AnyZodObject, Augmentation extends Incoming["shape"]>(merging: Incoming): ZodObject<extendShape<T, Augmentation>, Incoming["_def"]["unknownKeys"], Incoming["_def"]["catchall"]>;
+    setKey<Key extends string, Schema extends ZodTypeAny>(key: Key, schema: Schema): ZodObject<T & {
+        [k in Key]: Schema;
+    }, UnknownKeys, Catchall>;
     catchall<Index extends ZodTypeAny>(index: Index): ZodObject<T, UnknownKeys, Index>;
-    pick<Mask extends {
-        [k in keyof T]?: true;
-    }>(mask: Mask): ZodObject<Pick<T, Extract<keyof T, keyof Mask>>, UnknownKeys, Catchall>;
-    omit<Mask extends {
-        [k in keyof T]?: true;
-    }>(mask: Mask): ZodObject<Omit<T, keyof Mask>, UnknownKeys, Catchall>;
+    pick<Mask extends objectKeyMask<T>>(mask: noUnrecognized<Mask, T>): ZodObject<Pick<T, Extract<keyof T, keyof Mask>>, UnknownKeys, Catchall>;
+    omit<Mask extends objectKeyMask<T>>(mask: noUnrecognized<Mask, objectKeyMask<T>>): ZodObject<Omit<T, keyof Mask>, UnknownKeys, Catchall>;
     deepPartial(): partialUtil.DeepPartial<this>;
     partial(): ZodObject<{
         [k in keyof T]: ZodOptional<T[k]>;
     }, UnknownKeys, Catchall>;
-    partial<Mask extends {
-        [k in keyof T]?: true;
-    }>(mask: Mask): ZodObject<objectUtil.noNever<{
+    partial<Mask extends objectKeyMask<T>>(mask: noUnrecognized<Mask, objectKeyMask<T>>): ZodObject<objectUtil.noNever<{
         [k in keyof T]: k extends keyof Mask ? ZodOptional<T[k]> : T[k];
     }>, UnknownKeys, Catchall>;
     required(): ZodObject<{
         [k in keyof T]: deoptional<T[k]>;
     }, UnknownKeys, Catchall>;
-    required<Mask extends {
-        [k in keyof T]?: true;
-    }>(mask: Mask): ZodObject<objectUtil.noNever<{
+    required<Mask extends objectKeyMask<T>>(mask: noUnrecognized<Mask, objectKeyMask<T>>): ZodObject<objectUtil.noNever<{
         [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_1 in keyof objectUtil.addQuestionMarks<{ [k in keyof T_1]: T_1[k]["_output"]; }>]: objectUtil.addQuestionMarks<{ [k in keyof T_1]: T_1[k]["_output"]; }>[k_1]; }, { [k_3 in keyof objectUtil.addQuestionMarks<{ [k_2 in keyof T_1]: T_1[k_2]["_input"]; }>]: objectUtil.addQuestionMarks<{ [k_2 in keyof T_1]: T_1[k_2]["_input"]; }>[k_3]; }>;
-    static strictCreate: <T_1 extends ZodRawShape>(shape: T_1, params?: RawCreateParams) => ZodObject<T_1, "strict", ZodTypeAny, { [k_1 in keyof objectUtil.addQuestionMarks<{ [k in keyof T_1]: T_1[k]["_output"]; }>]: objectUtil.addQuestionMarks<{ [k in keyof T_1]: T_1[k]["_output"]; }>[k_1]; }, { [k_3 in keyof objectUtil.addQuestionMarks<{ [k_2 in keyof T_1]: T_1[k_2]["_input"]; }>]: objectUtil.addQuestionMarks<{ [k_2 in keyof T_1]: T_1[k_2]["_input"]; }>[k_3]; }>;
-    static lazycreate: <T_1 extends ZodRawShape>(shape: () => T_1, params?: RawCreateParams) => ZodObject<T_1, "strip", ZodTypeAny, { [k_1 in keyof objectUtil.addQuestionMarks<{ [k in keyof T_1]: T_1[k]["_output"]; }>]: objectUtil.addQuestionMarks<{ [k in keyof T_1]: T_1[k]["_output"]; }>[k_1]; }, { [k_3 in keyof objectUtil.addQuestionMarks<{ [k_2 in keyof T_1]: T_1[k_2]["_input"]; }>]: objectUtil.addQuestionMarks<{ [k_2 in keyof T_1]: T_1[k_2]["_input"]; }>[k_3]; }>;
+    static create: <T_1 extends ZodRawShape>(shape: T_1, params?: RawCreateParams) => ZodObject<T_1, "strip", ZodTypeAny, { [k in keyof baseObjectOutputType<T_1>]: baseObjectOutputType<T_1>[k]; }, { [k_2 in keyof objectUtil.addQuestionMarks<{ [k_1 in keyof T_1]: T_1[k_1]["_input"]; }>]: objectUtil.addQuestionMarks<{ [k_1 in keyof T_1]: T_1[k_1]["_input"]; }>[k_2]; }>;
+    static strictCreate: <T_1 extends ZodRawShape>(shape: T_1, params?: RawCreateParams) => ZodObject<T_1, "strict", ZodTypeAny, { [k in keyof baseObjectOutputType<T_1>]: baseObjectOutputType<T_1>[k]; }, { [k_2 in keyof objectUtil.addQuestionMarks<{ [k_1 in keyof T_1]: T_1[k_1]["_input"]; }>]: objectUtil.addQuestionMarks<{ [k_1 in keyof T_1]: T_1[k_1]["_input"]; }>[k_2]; }>;
+    static lazycreate: <T_1 extends ZodRawShape>(shape: () => T_1, params?: RawCreateParams) => ZodObject<T_1, "strip", ZodTypeAny, { [k in keyof baseObjectOutputType<T_1>]: baseObjectOutputType<T_1>[k]; }, { [k_2 in keyof objectUtil.addQuestionMarks<{ [k_1 in keyof T_1]: T_1[k_1]["_input"]; }>]: objectUtil.addQuestionMarks<{ [k_1 in keyof T_1]: T_1[k_1]["_input"]; }>[k_2]; }>;
 }
 export declare type AnyZodObject = ZodObject<any, any, any>;
 export declare type ZodUnionOptions = Readonly<[ZodTypeAny, ...ZodTypeAny[]]>;
@@ -494,8 +505,8 @@ export declare class ZodUnion<T extends ZodUnionOptions> extends ZodType<T[numbe
 }
 export declare type ZodDiscriminatedUnionOption<Discriminator extends string> = ZodObject<{
     [key in Discriminator]: ZodTypeAny;
-} & ZodRawShape, any, any>;
-export interface ZodDiscriminatedUnionDef<Discriminator extends string, Options extends ZodDiscriminatedUnionOption<any>[] = ZodDiscriminatedUnionOption<any>[]> extends ZodTypeDef {
+} & ZodRawShape, UnknownKeysParam, ZodTypeAny>;
+export interface ZodDiscriminatedUnionDef<Discriminator extends string, Options extends ZodDiscriminatedUnionOption<string>[] = ZodDiscriminatedUnionOption<string>[]> extends ZodTypeDef {
     discriminator: Discriminator;
     options: Options;
     optionsMap: Map<Primitive, ZodDiscriminatedUnionOption<any>>;
@@ -651,6 +662,8 @@ export interface ZodEnumDef<T extends EnumValues = EnumValues> extends ZodTypeDe
 export declare 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;
 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>> {
@@ -659,6 +672,8 @@ export declare class ZodEnum<T extends [string, ...string[]]> extends ZodType<T[
     get enum(): Values<T>;
     get Values(): Values<T>;
     get Enum(): Values<T>;
+    extract<ToExtract extends readonly [T[number], ...T[number][]]>(values: ToExtract): ZodEnum<Writeable<ToExtract>>;
+    exclude<ToExclude extends readonly [T[number], ...T[number][]]>(values: ToExclude): ZodEnum<typecast<Writeable<FilterEnum<T, ToExclude[number]>>, [string, ...string[]]>>;
     static create: typeof createZodEnum;
 }
 export interface ZodNativeEnumDef<T extends EnumLike = EnumLike> extends ZodTypeDef {
@@ -679,6 +694,7 @@ export interface ZodPromiseDef<T extends ZodTypeAny = ZodTypeAny> extends ZodTyp
     typeName: ZodFirstPartyTypeKind.ZodPromise;
 }
 export declare class ZodPromise<T extends ZodTypeAny> extends ZodType<Promise<T["_output"]>, ZodPromiseDef<T>, Promise<T["_input"]>> {
+    unwrap(): T;
     _parse(input: ParseInput): ParseReturnType<this["_output"]>;
     static create: <T_1 extends ZodTypeAny>(schema: T_1, params?: RawCreateParams) => ZodPromise<T_1>;
 }
@@ -747,21 +763,21 @@ export declare class ZodDefault<T extends ZodTypeAny> extends ZodType<util.noUnd
         default: T_1["_input"] | (() => util.noUndefined<T_1["_input"]>);
     }) => ZodDefault<T_1>;
 }
-export interface ZodCatchDef<T extends ZodTypeAny = ZodTypeAny> extends ZodTypeDef {
+export interface ZodCatchDef<T extends ZodTypeAny = ZodTypeAny, C extends T["_input"] = T["_input"]> extends ZodTypeDef {
     innerType: T;
-    defaultValue: () => T["_input"];
+    catchValue: () => C;
     typeName: ZodFirstPartyTypeKind.ZodCatch;
 }
-export declare class ZodCatch<T extends ZodTypeAny> extends ZodType<util.noUndefined<T["_output"]>, ZodCatchDef<T>, T["_input"] | undefined> {
+export declare class ZodCatch<T extends ZodTypeAny> extends ZodType<T["_output"], ZodCatchDef<T>, unknown> {
     _parse(input: ParseInput): ParseReturnType<this["_output"]>;
-    removeDefault(): T;
+    removeCatch(): T;
     static create: <T_1 extends ZodTypeAny>(type: T_1, params: {
         errorMap?: ZodErrorMap | undefined;
         invalid_type_error?: string | undefined;
         required_error?: string | undefined;
         description?: string | undefined;
     } & {
-        default: T_1["_input"] | (() => T_1["_input"]);
+        catch: T_1["_output"] | (() => T_1["_output"]);
     }) => ZodCatch<T_1>;
 }
 export interface ZodNaNDef extends ZodTypeDef {
@@ -797,7 +813,7 @@ export declare class ZodPipeline<A extends ZodTypeAny, B extends ZodTypeAny> ext
 export declare const custom: <T>(check?: ((data: unknown) => any) | undefined, params?: Parameters<ZodTypeAny["refine"]>[1], fatal?: boolean | undefined) => 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_1 in keyof objectUtil.addQuestionMarks<{ [k in keyof T]: T[k]["_output"]; }>]: objectUtil.addQuestionMarks<{ [k in keyof T]: T[k]["_output"]; }>[k_1]; }, { [k_3 in keyof objectUtil.addQuestionMarks<{ [k_2 in keyof T]: T[k_2]["_input"]; }>]: objectUtil.addQuestionMarks<{ [k_2 in keyof T]: T[k_2]["_input"]; }>[k_3]; }>;
+    object: <T extends ZodRawShape>(shape: () => T, params?: RawCreateParams) => ZodObject<T, "strip", ZodTypeAny, { [k in keyof baseObjectOutputType<T>]: baseObjectOutputType<T>[k]; }, { [k_2 in keyof objectUtil.addQuestionMarks<{ [k_1 in keyof T]: T[k_1]["_input"]; }>]: objectUtil.addQuestionMarks<{ [k_1 in keyof T]: T[k_1]["_input"]; }>[k_2]; }>;
 };
 export declare enum ZodFirstPartyTypeKind {
     ZodString = "ZodString",
@@ -836,7 +852,7 @@ export declare enum ZodFirstPartyTypeKind {
     ZodBranded = "ZodBranded",
     ZodPipeline = "ZodPipeline"
 }
-export declare type ZodFirstPartySchemaTypes = ZodString | ZodNumber | ZodNaN | ZodBigInt | ZodBoolean | ZodDate | ZodUndefined | ZodNull | ZodAny | ZodUnknown | ZodNever | ZodVoid | ZodArray<any, any> | ZodObject<any, any, 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>;
+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>;
 declare abstract class Class {
     constructor(..._: any[]);
 }
@@ -890,8 +906,8 @@ 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_1 in keyof objectUtil.addQuestionMarks<{ [k in keyof T]: T[k]["_output"]; }>]: objectUtil.addQuestionMarks<{ [k in keyof T]: T[k]["_output"]; }>[k_1]; }, { [k_3 in keyof objectUtil.addQuestionMarks<{ [k_2 in keyof T]: T[k_2]["_input"]; }>]: objectUtil.addQuestionMarks<{ [k_2 in keyof T]: T[k_2]["_input"]; }>[k_3]; }>;
-declare const strictObjectType: <T extends ZodRawShape>(shape: T, params?: RawCreateParams) => ZodObject<T, "strict", ZodTypeAny, { [k_1 in keyof objectUtil.addQuestionMarks<{ [k in keyof T]: T[k]["_output"]; }>]: objectUtil.addQuestionMarks<{ [k in keyof T]: T[k]["_output"]; }>[k_1]; }, { [k_3 in keyof objectUtil.addQuestionMarks<{ [k_2 in keyof T]: T[k_2]["_input"]; }>]: objectUtil.addQuestionMarks<{ [k_2 in keyof T]: T[k_2]["_input"]; }>[k_3]; }>;
+declare const objectType: <T extends ZodRawShape>(shape: T, params?: RawCreateParams) => ZodObject<T, "strip", ZodTypeAny, { [k in keyof baseObjectOutputType<T>]: baseObjectOutputType<T>[k]; }, { [k_2 in keyof objectUtil.addQuestionMarks<{ [k_1 in keyof T]: T[k_1]["_input"]; }>]: objectUtil.addQuestionMarks<{ [k_1 in keyof T]: T[k_1]["_input"]; }>[k_2]; }>;
+declare const strictObjectType: <T extends ZodRawShape>(shape: T, params?: RawCreateParams) => ZodObject<T, "strict", ZodTypeAny, { [k in keyof baseObjectOutputType<T>]: baseObjectOutputType<T>[k]; }, { [k_2 in keyof objectUtil.addQuestionMarks<{ [k_1 in keyof T]: T[k_1]["_input"]; }>]: objectUtil.addQuestionMarks<{ [k_1 in keyof T]: T[k_1]["_input"]; }>[k_2]; }>;
 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>;