zod 4.0.0-beta.20250430T185432 → 4.0.0-beta.20250504T215252

package/dist/commonjs/schemas.d.ts

@@ -10,14 +10,12 @@ export interface ZodType<out Output = unknown, out Input = unknown> extends core
     def: this["_zod"]["def"];
     /** @deprecated Use `.def` instead. */
     _def: this["_zod"]["def"];
-    /** @deprecated Use `z.output<typeof schema>` instead. */
-    _output: this["_zod"]["output"];
-    /** @deprecated Use `z.input<typeof schema>` instead. */
-    _input: this["_zod"]["input"];
-    check(...checks: (core.CheckFn<this["_zod"]["output"]> | core.$ZodCheck<this["_zod"]["output"]>)[]): this;
+    _output: core.output<this>;
+    _input: core.input<this>;
+    check(...checks: (core.CheckFn<core.output<this>> | core.$ZodCheck<core.output<this>>)[]): this;
     clone(def?: this["_zod"]["def"]): this;
     register<R extends core.$ZodRegistry>(registry: R, ...meta: this extends R["_schema"] ? undefined extends R["_meta"] ? [core.$ZodRegistry<R["_meta"], this>["_meta"]?] : [core.$ZodRegistry<R["_meta"], this>["_meta"]] : ["Incompatible schema"]): this;
-    brand<T extends PropertyKey = PropertyKey>(value?: T): this & Record<"_zod", Record<"output", this["_zod"]["output"] & core.$brand<T>>>;
+    brand<T extends PropertyKey = PropertyKey>(value?: T): PropertyKey extends T ? this : this & Record<"_zod", Record<"~output", core.output<this> & core.$brand<T>>>;
     parse(data: unknown, params?: core.ParseContext<core.$ZodIssue>): core.output<this>;
     safeParse(data: unknown, params?: core.ParseContext<core.$ZodIssue>): parse.ZodSafeParseResult<core.output<this>>;
     parseAsync(data: unknown, params?: core.ParseContext<core.$ZodIssue>): Promise<core.output<this>>;
@@ -248,7 +246,7 @@ export interface _ZodNumber<Input = unknown> extends ZodType {
     max(value: number, params?: string | core.$ZodCheckLessThanParams): this;
     /** Consider `z.int()` instead. This API is considered *legacy*; it will never be removed but a better alternative exists. */
     int(params?: string | core.$ZodCheckNumberFormatParams): this;
-    /** @deprecated This is now identical to `.int()` instead. Only numbers in the safe integer range are accepted. */
+    /** @deprecated This is now identical to `.int()`. Only numbers in the safe integer range are accepted. */
     safe(params?: string | core.$ZodCheckNumberFormatParams): this;
     positive(params?: string | core.$ZodCheckGreaterThanParams): this;
     nonnegative(params?: string | core.$ZodCheckGreaterThanParams): this;
@@ -387,175 +385,67 @@ export interface ZodArray<T extends core.$ZodType = core.$ZodType> extends ZodTy
 }
 export declare const ZodArray: core.$constructor<ZodArray>;
 export declare function array<T extends core.$ZodType>(element: T, params?: string | core.$ZodArrayParams): ZodArray<T>;
-export interface ZodObjectLike<out O = object, out I = object> extends ZodType {
-    _zod: core.$ZodObjectLikeInternals<O, I>;
-}
-export declare const ZodObjectLike: core.$constructor<ZodObjectLike>;
-export declare function keyof<T extends ZodObject>(schema: T): ZodLiteral<keyof T["_zod"]["def"]["shape"]>;
-export declare function keyof<T extends ZodInterface>(schema: T): ZodLiteral<keyof T["_zod"]["output"]>;
-type ZodInterfacePartial<T extends ZodInterface, Keys extends keyof T["_zod"]["def"]["shape"] = keyof T["_zod"]["def"]["shape"]> = ZodInterface<util.Extend<T["_zod"]["def"]["shape"], {
-    [k in Keys]: ZodOptional<T["_zod"]["def"]["shape"][k]>;
-}>, {
-    optional: T["_zod"]["optional"] | (string & Keys);
-    defaulted: T["_zod"]["defaulted"];
-    extra: T["_zod"]["extra"];
-}>;
-type ZodInterfaceRequired<T extends ZodInterface, Keys extends keyof T["_zod"]["def"]["shape"] = keyof T["_zod"]["def"]["shape"]> = ZodInterface<util.Extend<T["_zod"]["def"]["shape"], {
-    [k in Keys]: ZodNonOptional<T["_zod"]["def"]["shape"][k]>;
-}>, {
-    optional: never;
-    defaulted: T["_zod"]["defaulted"];
-    extra: T["_zod"]["extra"];
-}>;
-export type MergeInterfaces<A extends ZodInterface, B extends ZodInterface> = ZodInterface<util.Extend<A["_zod"]["def"]["shape"], B["_zod"]["def"]["shape"]>, util.MergeInterfaceParams<A, B>>;
-export interface ZodInterface<out Shape extends core.$ZodLooseShape = core.$ZodLooseShape, out Params extends core.$ZodInterfaceNamedParams = core.$ZodInterfaceNamedParams> extends ZodType {
-    _zod: core.$ZodInterfaceInternals<Shape, Params>;
-    keyof(): ZodEnum<util.ToEnum<util.InterfaceKeys<string & keyof Shape>>>;
-    catchall<T extends core.$ZodType>(schema: T): ZodInterface<Shape, {
-        optional: Params["optional"];
-        defaulted: Params["defaulted"];
-        extra: Record<string, T["_zod"]["output"]>;
-    }>;
-    strict(): ZodInterface<Shape, {
-        optional: Params["optional"];
-        defaulted: Params["defaulted"];
-        extra: {};
-    }>;
-    loose(): ZodInterface<Shape, {
-        optional: Params["optional"];
-        defaulted: Params["defaulted"];
-        extra: Record<string, unknown>;
-    }>;
-    strip(): ZodInterface<Shape, {
-        optional: Params["optional"];
-        defaulted: Params["defaulted"];
-        extra: {};
-    }>;
-    extend<U extends ZodInterface>(int: U): MergeInterfaces<this, U>;
-    extend<U extends core.$ZodLooseShape>(shape: U): MergeInterfaces<this, ZodInterface<U, util.InitInterfaceParams<U, {}>>>;
-    /** @deprecated Use `A.extend(B)` */
-    merge<U extends ZodInterface>(incoming: U): MergeInterfaces<this, U>;
-    pick<const M extends util.Exactly<util.Mask<string & keyof Shape>, M>>(mask: M): ZodInterface<util.Flatten<Pick<Shape, keyof Shape & keyof M>>, {
-        optional: Extract<Params["optional"], keyof M>;
-        defaulted: Extract<Params["defaulted"], keyof M>;
-        extra: Params["extra"];
-    }>;
-    omit<const M extends util.Exactly<util.Mask<string & keyof Shape>, M>>(mask: M): ZodInterface<util.Flatten<Omit<Shape, keyof M>>, {
-        optional: Exclude<Params["optional"], keyof M>;
-        defaulted: Exclude<Params["defaulted"], keyof M>;
-        extra: Params["extra"];
-    }>;
-    partial(): ZodInterfacePartial<this>;
-    partial<M extends util.Mask<string & keyof Shape>>(mask: M): ZodInterfacePartial<this, string & keyof M>;
-    required(): ZodInterfaceRequired<this, string & keyof Shape>;
-    required<M extends util.Mask<string & keyof Shape>>(mask: M): ZodInterfaceRequired<this, string & keyof M>;
-}
-export declare const ZodInterface: core.$constructor<ZodInterface>;
-declare function _interface<T extends core.$ZodLooseShape>(shape: T, params?: string | core.$ZodInterfaceParams, Class?: util.Constructor<ZodInterface>): ZodInterface<util.CleanInterfaceShape<T>, util.InitInterfaceParams<T, {}>>;
-export { _interface as interface };
-export declare function strictInterface<T extends core.$ZodLooseShape>(shape: T, params?: string | core.$ZodInterfaceParams): ZodInterface<util.CleanInterfaceShape<T>, util.InitInterfaceParams<T, {}>>;
-export declare function looseInterface<T extends core.$ZodLooseShape>(shape: T, params?: string | core.$ZodInterfaceParams): ZodInterface<util.CleanInterfaceShape<T>, util.InitInterfaceParams<T, Record<string, unknown>>>;
-export interface ZodObject<out Shape extends core.$ZodShape = core.$ZodShape, Extra extends Record<string, unknown> = Record<string, unknown>> extends ZodType {
-    _zod: core.$ZodObjectInternals<Shape, Extra>;
+export declare function keyof<T extends ZodObject>(schema: T): ZodLiteral<keyof T["_zod"]["output"]>;
+export interface ZodObject<out Shape extends core.$ZodShape = core.$ZodLooseShape, OutExtra extends Record<string, unknown> = Record<string, unknown>, InExtra extends Record<string, unknown> = Record<string, unknown>> extends ZodType {
+    _zod: core.$ZodObjectInternals<Shape, OutExtra, InExtra>;
     shape: Shape;
     keyof(): ZodEnum<util.ToEnum<keyof Shape & string>>;
+    /** Define a schema to validate all unrecognized keys. This overrides the existing strict/loose behavior. */
     catchall<T extends core.$ZodType>(schema: T): ZodObject<Shape, Record<string, T["_zod"]["output"]>>;
     /** @deprecated Use `z.looseObject()` or `.loose()` instead. */
     passthrough(): ZodObject<Shape, Record<string, unknown>>;
+    /** Consider `z.looseObject(A.shape)` instead */
     loose(): ZodObject<Shape, Record<string, unknown>>;
-    /** The `z.strictObject()` API is preferred. */
+    /** Consider `z.strictObject(A.shape)` instead */
     strict(): ZodObject<Shape, {}>;
-    /** @deprecated This is the default behavior. This method call is likely unnecessary. */
+    /** This is the default behavior. This method call is likely unnecessary. */
     strip(): ZodObject<Shape, {}>;
-    extend<const U extends ZodObject>(schema: U): ZodObject<util.Extend<Shape, U["_zod"]["def"]["shape"]>, Extra>;
-    extend<U extends core.$ZodShape>(shape: U): ZodObject<util.Extend<Shape, U>, Extra>;
-    /** @deprecated Use `A.extend(B)` */
-    merge<U extends ZodObject<any, any>>(other: U): ZodObject<util.Flatten<util.Extend<Shape, U["_zod"]["def"]["shape"]>>, Extra>;
-    pick<M extends util.Exactly<util.Mask<string & keyof Shape>, M>>(mask: M): ZodObject<util.Flatten<Pick<Shape, Extract<keyof Shape, keyof M>>>, Extra>;
-    omit<M extends util.Exactly<util.Mask<string & keyof Shape>, M>>(mask: M): ZodObject<util.Flatten<Omit<Shape, Extract<keyof Shape, keyof M>>>, Extra>;
+    extend<U extends core.$ZodLooseShape>(shape: U): ZodObject<util.Extend<Shape, U>, OutExtra, InExtra>;
+    /**
+     * @deprecated Use destructuring to merge the shapes:
+     *
+     * ```ts
+     * z.object({
+     *    ...A.shape,
+     *    ...B.shape
+     * });
+     * ```
+     */
+    merge<U extends ZodObject>(other: U): ZodObject<util.Extend<Shape, U["shape"]>, U["_zod"]["outextra"], U["_zod"]["inextra"]>;
+    /**
+     * @deprecated Use destructuring to merge the shapes:
+     *
+     * ```ts
+     * z.object({
+     *    ...A.shape,
+     *    ...B.shape
+     * });
+     * ```
+     */
+    pick<M extends util.Exactly<util.Mask<string & keyof Shape>, M>>(mask: M): ZodObject<util.Flatten<Pick<Shape, Extract<keyof Shape, keyof M>>>, OutExtra, InExtra>;
+    omit<M extends util.Exactly<util.Mask<string & keyof Shape>, M>>(mask: M): ZodObject<util.Flatten<Omit<Shape, Extract<keyof Shape, keyof M>>>, OutExtra, InExtra>;
     partial(): ZodObject<{
         [k in keyof Shape]: ZodOptional<Shape[k]>;
-    }, Extra>;
+    }, OutExtra, InExtra>;
     partial<M extends util.Exactly<util.Mask<string & keyof Shape>, M>>(mask: M): ZodObject<{
         [k in keyof Shape]: k extends keyof M ? ZodOptional<Shape[k]> : Shape[k];
-    }, Extra>;
+    }, OutExtra, InExtra>;
     required(): ZodObject<{
         [k in keyof Shape]: ZodNonOptional<Shape[k]>;
-    }, Extra>;
+    }, OutExtra, InExtra>;
     required<M extends util.Exactly<util.Mask<string & keyof Shape>, M>>(mask: M): ZodObject<{
         [k in keyof Shape]: k extends keyof M ? ZodNonOptional<Shape[k]> : Shape[k];
-    }, Extra>;
+    }, OutExtra, InExtra>;
 }
 export declare const ZodObject: core.$constructor<ZodObject>;
-export declare function object<T extends core.$ZodShape = Record<never, core.$ZodType>>(shape?: T, params?: string | core.$ZodObjectLikeParams): ZodObject<T, {}>;
-export declare function strictObject<T extends core.$ZodShape>(shape: T, params?: string | core.$ZodObjectParams): ZodObject<T, {}>;
-export declare function looseObject<T extends core.$ZodShape>(shape: T, params?: string | core.$ZodObjectParams): ZodObject<T, {
+export declare function object<T extends core.$ZodLooseShape = Record<never, core.$ZodType>>(shape?: T, params?: string | core.$ZodObjectParams): ZodObject<util.Writeable<T> & {}, {}, {}>;
+export declare function strictObject<T extends core.$ZodLooseShape>(shape: T, params?: string | core.$ZodObjectParams): ZodObject<T, {}, {}>;
+export declare function looseObject<T extends core.$ZodLooseShape>(shape: T, params?: string | core.$ZodObjectParams): ZodObject<T, {
     [k: string]: unknown;
-}>;
-export declare function extend<T extends ZodInterface, U extends ZodInterface>(a: T, b: U): ZodInterface<util.Extend<T["_zod"]["def"]["shape"], U["_zod"]["def"]["shape"]>, util.MergeInterfaceParams<T, U>>;
-export declare function extend<T extends ZodObject, U extends ZodObject>(a: T, b: U): ZodObject<util.Extend<T["_zod"]["def"]["shape"], U["_zod"]["def"]["shape"]>, U["_zod"]["extra"] & T["_zod"]["extra"]>;
-export declare function extend<T extends ZodObjectLike, U extends core.$ZodLooseShape>(schema: T, shape: U): T extends ZodInterface<infer TShape, infer TParams> ? ZodInterface<util.ExtendInterfaceShape<TShape, U>, util.ExtendInterfaceParams<ZodInterface<TShape, TParams>, U>> : ZodObject<util.Extend<T["_zod"]["def"]["shape"], U>, T["_zod"]["extra"]>;
-export declare function merge<T extends ZodObjectLike, U extends core.$ZodLooseShape>(schema: T, shape: U): T["_zod"]["def"]["type"] extends "interface" ? ZodInterface<util.Extend<T["_zod"]["def"]["shape"], U["_zod"]["def"]["shape"]>, {
-    extra: T["_zod"]["extra"] & U["_zod"]["extra"];
-    optional: Exclude<T["_zod"]["optional"], keyof U["_zod"]["def"]["shape"]> | U["_zod"]["optional"];
-    defaulted: Exclude<T["_zod"]["defaulted"], keyof U["_zod"]["def"]["shape"]> | U["_zod"]["defaulted"];
-}> : ZodObject<util.Extend<T["_zod"]["def"]["shape"], U>, T["_zod"]["extra"]>;
-export declare function pick<T extends ZodObjectLike, M extends util.Exactly<util.Mask<keyof T["_zod"]["def"]["shape"]>, M>>(schema: T, mask: M): T["_zod"]["def"]["type"] extends "interface" ? ZodInterface<util.Flatten<Pick<T["_zod"]["def"]["shape"], keyof T["_zod"]["def"]["shape"] & keyof M>>, {
-    optional: Extract<T["_zod"]["optional"], keyof M>;
-    defaulted: Extract<T["_zod"]["defaulted"], keyof M>;
-    extra: T["_zod"]["extra"];
-}> : ZodObject<util.Flatten<Pick<T["_zod"]["def"]["shape"], keyof T["_zod"]["def"]["shape"] & keyof M>>, T["_zod"]["extra"]>;
-export declare function omit<T extends ZodObjectLike, const M extends util.Exactly<util.Mask<keyof T["_zod"]["def"]["shape"]>, M>>(schema: T, mask: M): T["_zod"]["def"]["type"] extends "interface" ? ZodInterface<util.Flatten<Omit<T["_zod"]["def"]["shape"], keyof M>>, {
-    optional: Exclude<T["_zod"]["optional"], keyof M>;
-    defaulted: Exclude<T["_zod"]["defaulted"], keyof M>;
-    extra: T["_zod"]["extra"];
-}> : ZodObject<util.Flatten<Omit<T["_zod"]["def"]["shape"], keyof M>>, T["_zod"]["extra"]>;
-export declare function partial<T extends ZodObjectLike>(schema: T): T["_zod"]["def"]["type"] extends "interface" ? ZodInterface<{
-    [k in keyof T["_zod"]["def"]["shape"]]: ZodOptional<T["_zod"]["def"]["shape"][k]>;
 }, {
-    optional: string & keyof T["_zod"]["def"]["shape"];
-    defaulted: never;
-    extra: T["_zod"]["extra"];
-}> : ZodObject<{
-    [k in keyof T["_zod"]["def"]["shape"]]: ZodOptional<T["_zod"]["def"]["shape"][k]>;
-}, T["_zod"]["extra"]>;
-export declare function partial<T extends ZodObjectLike, M extends util.Exactly<util.Mask<keyof T["_zod"]["def"]["shape"]>, M>>(schema: T, mask: M): T["_zod"]["def"]["type"] extends "interface" ? ZodInterface<util.Extend<T["_zod"]["def"]["shape"], {
-    [k in keyof M & keyof T["_zod"]["def"]["shape"]]: ZodOptional<T["_zod"]["def"]["shape"][k]>;
-}>, {
-    optional: string & (T["_zod"]["optional"] | keyof M);
-    defaulted: T["_zod"]["defaulted"];
-    extra: T["_zod"]["extra"];
-}> : ZodObject<{
-    [k in keyof T["_zod"]["def"]["shape"]]: k extends keyof M ? ZodOptional<T["_zod"]["def"]["shape"][k]> : T["_zod"]["def"]["shape"][k];
-}, T["_zod"]["extra"]>;
-export declare function required<T extends {
-    _subtype: "object";
-} & ZodObject>(schema: T): ZodObject<{
-    [k in keyof T["_zod"]["def"]["shape"]]: ZodNonOptional<T["_zod"]["def"]["shape"][k]>;
-}>;
-export declare function required<T extends {
-    _subtype: "object";
-} & ZodObject, M extends util.Exactly<util.Mask<keyof T["_zod"]["def"]["shape"]>, M>>(schema: T, mask: M): ZodObject<util.Extend<T["_zod"]["def"]["shape"], {
-    [k in keyof M & keyof T["_zod"]["def"]["shape"]]: ZodNonOptional<T["_zod"]["def"]["shape"][k]>;
-}>>;
-export declare function required<T extends {
-    _subtype: "interface";
-} & ZodInterface>(schema: T): ZodInterface<{
-    [k in keyof T["_zod"]["def"]["shape"]]: ZodNonOptional<T["_zod"]["def"]["shape"][k]>;
-}, {
-    optional: never;
-    defaulted: T["_zod"]["defaulted"];
-    extra: T["_zod"]["extra"];
-}>;
-export declare function required<T extends {
-    _subtype: "interface";
-} & ZodInterface, M extends util.Mask<keyof T["_zod"]["output"]>>(schema: T, mask: M): ZodInterface<util.Extend<T["_zod"]["def"]["shape"], {
-    [k in keyof M & keyof T["_zod"]["def"]["shape"]]: ZodNonOptional<T["_zod"]["def"]["shape"][k]>;
-}>, {
-    optional: Exclude<T["_zod"]["optional"], keyof M>;
-    defaulted: T["_zod"]["defaulted"];
-    extra: T["_zod"]["extra"];
+    [k: string]: unknown;
 }>;
+export declare function partial<T>(shape: T): Partial<T>;
 export interface ZodUnion<T extends readonly core.$ZodType[] = readonly core.$ZodType[]> extends ZodType {
     _zod: core.$ZodUnionInternals<T>;
     options: T;

package/dist/commonjs/schemas.js

@@ -23,8 +23,8 @@ var __importStar = (this && this.__importStar) || function (mod) {
     return result;
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ZodEnum = exports.ZodSet = exports.ZodMap = exports.ZodRecord = exports.ZodTuple = exports.ZodIntersection = exports.ZodDiscriminatedUnion = exports.ZodUnion = exports.ZodObject = exports.ZodInterface = exports.ZodObjectLike = exports.ZodArray = exports.ZodDate = exports.ZodVoid = exports.ZodNever = exports.ZodUnknown = exports.ZodAny = exports.ZodNull = exports.ZodUndefined = exports.ZodSymbol = exports.ZodBigIntFormat = exports.ZodBigInt = exports.ZodBoolean = exports.ZodNumberFormat = exports.ZodNumber = exports.ZodJWT = exports.ZodE164 = exports.ZodBase64URL = exports.ZodBase64 = exports.ZodCIDRv6 = exports.ZodCIDRv4 = exports.ZodIPv6 = exports.ZodIPv4 = exports.ZodKSUID = exports.ZodXID = exports.ZodULID = exports.ZodCUID2 = exports.ZodCUID = exports.ZodNanoID = exports.ZodEmoji = exports.ZodURL = exports.ZodUUID = exports.ZodGUID = exports.ZodEmail = exports.ZodStringFormat = exports.ZodString = exports._ZodString = exports.ZodType = exports.coerce = exports.iso = void 0;
-exports.stringbool = exports.ZodCustom = exports.ZodPromise = exports.ZodLazy = exports.ZodTemplateLiteral = exports.ZodReadonly = exports.ZodPipe = exports.ZodNaN = exports.ZodCatch = exports.ZodSuccess = exports.ZodNonOptional = exports.ZodDefault = exports.ZodNullable = exports.ZodOptional = exports.ZodTransform = exports.ZodFile = exports.ZodLiteral = void 0;
+exports.ZodFile = exports.ZodLiteral = exports.ZodEnum = exports.ZodSet = exports.ZodMap = exports.ZodRecord = exports.ZodTuple = exports.ZodIntersection = exports.ZodDiscriminatedUnion = exports.ZodUnion = exports.ZodObject = exports.ZodArray = exports.ZodDate = exports.ZodVoid = exports.ZodNever = exports.ZodUnknown = exports.ZodAny = exports.ZodNull = exports.ZodUndefined = exports.ZodSymbol = exports.ZodBigIntFormat = exports.ZodBigInt = exports.ZodBoolean = exports.ZodNumberFormat = exports.ZodNumber = exports.ZodJWT = exports.ZodE164 = exports.ZodBase64URL = exports.ZodBase64 = exports.ZodCIDRv6 = exports.ZodCIDRv4 = exports.ZodIPv6 = exports.ZodIPv4 = exports.ZodKSUID = exports.ZodXID = exports.ZodULID = exports.ZodCUID2 = exports.ZodCUID = exports.ZodNanoID = exports.ZodEmoji = exports.ZodURL = exports.ZodUUID = exports.ZodGUID = exports.ZodEmail = exports.ZodStringFormat = exports.ZodString = exports._ZodString = exports.ZodType = exports.coerce = exports.iso = void 0;
+exports.stringbool = exports.ZodCustom = exports.ZodPromise = exports.ZodLazy = exports.ZodTemplateLiteral = exports.ZodReadonly = exports.ZodPipe = exports.ZodNaN = exports.ZodCatch = exports.ZodSuccess = exports.ZodNonOptional = exports.ZodDefault = exports.ZodNullable = exports.ZodOptional = exports.ZodTransform = void 0;
 exports.string = string;
 exports.email = email;
 exports.guid = guid;
@@ -68,18 +68,10 @@ exports.void = _void;
 exports.date = date;
 exports.array = array;
 exports.keyof = keyof;
-exports.interface = _interface;
-exports.strictInterface = strictInterface;
-exports.looseInterface = looseInterface;
 exports.object = object;
 exports.strictObject = strictObject;
 exports.looseObject = looseObject;
-exports.extend = extend;
-exports.merge = merge;
-exports.pick = pick;
-exports.omit = omit;
 exports.partial = partial;
-exports.required = required;
 exports.union = union;
 exports.discriminatedUnion = discriminatedUnion;
 exports.intersection = intersection;
@@ -576,95 +568,17 @@ exports.ZodArray = core.$constructor("ZodArray", (inst, def) => {
 function array(element, params) {
     return core._array(exports.ZodArray, element, params);
 }
-exports.ZodObjectLike = core.$constructor("ZodObjectLike", (inst, def) => {
-    core.$ZodObjectLike.init(inst, def);
-    exports.ZodType.init(inst, def);
-});
+// .keyof
 function keyof(schema) {
-    const shape = schema._zod.def.type === "interface"
-        ? core_1.util.cleanInterfaceShape(schema._zod.def.shape).shape
-        : schema._zod.def.shape;
+    const shape = schema._zod.def.shape;
     return literal(Object.keys(shape));
 }
-exports.ZodInterface = core.$constructor("ZodInterface", (inst, def) => {
-    core.$ZodInterface.init(inst, def);
-    exports.ZodType.init(inst, def);
-    // util.defineLazy(inst._zod, "shape", () => def.shape);
-    inst.keyof = () => _enum(Object.keys(inst._zod.def.shape));
-    inst.catchall = (catchall) => inst.clone({ ...inst._zod.def, catchall });
-    inst.loose = () => inst.clone({ ...inst._zod.def, catchall: unknown() });
-    inst.strict = () => inst.clone({ ...inst._zod.def, catchall: never() });
-    inst.strip = () => inst.clone({ ...inst._zod.def, catchall: undefined });
-    inst.extend = (incoming) => {
-        if (incoming instanceof core.$ZodInterface)
-            return core_1.util.extendObjectLike(inst, incoming);
-        return core_1.util.extendObjectLike(inst, _interface(incoming));
-    };
-    inst.merge = (other) => core_1.util.mergeObjectLike(inst, other);
-    inst.pick = (mask) => core_1.util.pick(inst, mask);
-    inst.omit = (mask) => core_1.util.omit(inst, mask);
-    inst.partial = (...args) => core_1.util.partialObjectLike(exports.ZodOptional, inst, args[0]);
-    inst.required = (...args) => core_1.util.requiredObjectLike(exports.ZodNonOptional, inst, args[0]);
-});
-function _interface(shape, params, Class = exports.ZodInterface) {
-    const cleaned = core_1.util.cached(() => core_1.util.cleanInterfaceShape(shape));
-    const def = {
-        type: "interface",
-        get shape() {
-            // return cleaned.value.shape;
-            const _shape = cleaned.value.shape;
-            core_1.util.assignProp(this, "shape", _shape);
-            return _shape;
-        },
-        get optional() {
-            return cleaned.value.optional;
-        },
-        ...core_1.util.normalizeParams(params),
-    };
-    return new Class(def);
-}
-// strictInterface
-function strictInterface(shape, params) {
-    const cleaned = core_1.util.cached(() => core_1.util.cleanInterfaceShape(shape));
-    const def = {
-        type: "interface",
-        get shape() {
-            // return cleaned.value.shape;
-            const _shape = cleaned.value.shape;
-            core_1.util.assignProp(this, "shape", _shape);
-            return _shape;
-        },
-        get optional() {
-            return cleaned.value.optional;
-        },
-        catchall: never(),
-        ...core_1.util.normalizeParams(params),
-    };
-    return new exports.ZodInterface(def);
-}
-// looseInterface
-function looseInterface(shape, params) {
-    const cleaned = core_1.util.cached(() => core_1.util.cleanInterfaceShape(shape));
-    const def = {
-        type: "interface",
-        get optional() {
-            return cleaned.value.optional;
-        },
-        get shape() {
-            // return cleaned.value.shape;
-            const _shape = cleaned.value.shape;
-            core_1.util.assignProp(this, "shape", _shape);
-            return _shape;
-        },
-        catchall: unknown(),
-        ...core_1.util.normalizeParams(params),
-    };
-    return new exports.ZodInterface(def);
-}
 exports.ZodObject = core.$constructor("ZodObject", (inst, def) => {
     core.$ZodObject.init(inst, def);
     exports.ZodType.init(inst, def);
-    inst.shape = def.shape;
+    core_1.util.defineLazy(inst, "shape", () => {
+        return Object.fromEntries(Object.entries(inst._zod.def.shape));
+    });
     inst.keyof = () => _enum(Object.keys(inst._zod.def.shape));
     inst.catchall = (catchall) => inst.clone({ ...inst._zod.def, catchall });
     inst.passthrough = () => inst.clone({ ...inst._zod.def, catchall: unknown() });
@@ -673,22 +587,20 @@ exports.ZodObject = core.$constructor("ZodObject", (inst, def) => {
     inst.strict = () => inst.clone({ ...inst._zod.def, catchall: never() });
     inst.strip = () => inst.clone({ ...inst._zod.def, catchall: undefined });
     inst.extend = (incoming) => {
-        if (incoming instanceof exports.ZodObject)
-            return core_1.util.extendObjectLike(inst, incoming);
-        return core_1.util.extendObjectLike(inst, object(incoming));
+        return core_1.util.extend(inst, incoming);
     };
-    inst.merge = (other) => core_1.util.mergeObjectLike(inst, other);
+    inst.merge = (other) => core_1.util.merge(inst, other);
     inst.pick = (mask) => core_1.util.pick(inst, mask);
     inst.omit = (mask) => core_1.util.omit(inst, mask);
-    inst.partial = (...args) => core_1.util.partialObjectLike(exports.ZodOptional, inst, args[0]);
-    inst.required = (...args) => core_1.util.requiredObjectLike(exports.ZodNonOptional, inst, args[0]);
+    inst.partial = (...args) => core_1.util.partial(exports.ZodOptional, inst, args[0]);
+    inst.required = (...args) => core_1.util.required(exports.ZodNonOptional, inst, args[0]);
 });
 function object(shape, params) {
     const def = {
         type: "object",
-        shape: shape ?? {},
-        get optional() {
-            return core_1.util.optionalObjectKeys(shape ?? {});
+        get shape() {
+            core_1.util.assignProp(this, "shape", { ...shape });
+            return this.shape;
         },
         ...core_1.util.normalizeParams(params),
     };
@@ -698,9 +610,9 @@ function object(shape, params) {
 function strictObject(shape, params) {
     return new exports.ZodObject({
         type: "object",
-        shape: shape,
-        get optional() {
-            return core_1.util.optionalObjectKeys(shape);
+        get shape() {
+            core_1.util.assignProp(this, "shape", { ...shape });
+            return this.shape;
         },
         catchall: never(),
         ...core_1.util.normalizeParams(params),
@@ -710,39 +622,16 @@ function strictObject(shape, params) {
 function looseObject(shape, params) {
     return new exports.ZodObject({
         type: "object",
-        shape: shape,
-        get optional() {
-            return core_1.util.optionalObjectKeys(shape);
+        get shape() {
+            core_1.util.assignProp(this, "shape", { ...shape });
+            return this.shape;
         },
         catchall: unknown(),
         ...core_1.util.normalizeParams(params),
     });
 }
-function extend(schema, shape) {
-    if (shape instanceof core.$ZodType)
-        return core_1.util.mergeObjectLike(schema, shape);
-    if (schema instanceof exports.ZodInterface) {
-        return core_1.util.mergeObjectLike(schema, _interface(shape));
-    }
-    if (schema instanceof exports.ZodObject)
-        return core_1.util.mergeObjectLike(schema, object(shape));
-    return core_1.util.extend(schema, shape);
-}
-function merge(a, b) {
-    return core_1.util.mergeObjectLike(a, b);
-}
-function pick(schema, mask) {
-    // const picked = util.pick(schema, mask);
-    return core_1.util.pick(schema, mask);
-}
-function omit(schema, mask) {
-    return core_1.util.omit(schema, mask);
-}
-function partial(schema, mask) {
-    return core_1.util.partialObjectLike(exports.ZodOptional, schema, mask);
-}
-function required(schema, mask) {
-    return core_1.util.requiredObjectLike(exports.ZodNonOptional, schema, mask);
+function partial(shape) {
+    return shape;
 }
 exports.ZodUnion = core.$constructor("ZodUnion", (inst, def) => {
     core.$ZodUnion.init(inst, def);