Interface ZodObject<Shape, Config>

interface ZodObject<
    out Shape extends $ZodShape = $ZodLooseShape,
    out Config extends $ZodObjectConfig = $strip,
> {
    _def: $ZodObjectDef<Shape>;
    _input: $InferObjectInput<Shape, Config["in"]>;
    _output: $InferObjectOutput<Shape, Config["out"]>;
    _zod: $ZodObjectInternals;
    "~standard": $ZodStandardSchema<z.ZodObject<Shape, Config>>;
    def: $ZodObjectDef<Shape>;
    description?: string;
    shape: Shape;
    spa: (
        data: unknown,
        params?: ParseContext<$ZodIssue>,
    ) => Promise<ZodSafeParseResult<$InferObjectOutput<Shape, Config["out"]>>>;
    type: "object";
    and<T extends SomeType>(
        incoming: T,
    ): z.ZodIntersection<z.ZodObject<Shape, Config>, T>;
    array(): z.ZodArray<z.ZodObject<Shape, Config>>;
    brand<T extends PropertyKey = PropertyKey>(
        value?: T,
    ): PropertyKey extends T
        ? z.ZodObject<Shape, Config>
        : $ZodBranded<z.ZodObject<Shape, Config>, T>;
    catch(
        def: $InferObjectOutput<Shape>,
    ): z.ZodCatch<z.ZodObject<Shape, Config>>;
    catch(
        def: (ctx: $ZodCatchCtx) => $InferObjectOutput<Shape>,
    ): z.ZodCatch<z.ZodObject<Shape, Config>>;
    catchall<T extends SomeType>(schema: T): z.ZodObject<Shape, $catchall<T>>;
    check(
        ...checks: (
            | CheckFn<$InferObjectOutput<Shape, Config["out"]>>
            | z.core.$ZodCheck<$InferObjectOutput<Shape, Config["out"]>>
        )[],
    ): this;
    clone(def?: $ZodObjectDef<Shape>, params?: { parent: boolean }): this;
    decode(
        data: $InferObjectInput<Shape>,
        params?: ParseContext<$ZodIssue>,
    ): $InferObjectOutput<Shape>;
    decodeAsync(
        data: $InferObjectInput<Shape>,
        params?: ParseContext<$ZodIssue>,
    ): Promise<$InferObjectOutput<Shape, Config["out"]>>;
    default(
        def: NoUndefined<$InferObjectOutput<Shape, Config["out"]>>,
    ): z.ZodDefault<z.ZodObject<Shape, Config>>;
    default(
        def: () => NoUndefined<$InferObjectOutput<Shape, Config["out"]>>,
    ): z.ZodDefault<z.ZodObject<Shape, Config>>;
    describe(description: string): this;
    encode(
        data: $InferObjectOutput<Shape>,
        params?: ParseContext<$ZodIssue>,
    ): $InferObjectInput<Shape>;
    encodeAsync(
        data: $InferObjectOutput<Shape>,
        params?: ParseContext<$ZodIssue>,
    ): Promise<$InferObjectInput<Shape, Config["in"]>>;
    extend<U extends $ZodLooseShape>(
        shape: U,
    ): z.ZodObject<
        {
            [k in string
            | number
            | symbol]: (
                (keyof Shape & keyof U) extends never
                    ? Shape & U
                    : {
                        [K in string | number | symbol as K extends keyof U ? never : K]: Shape[K]
                    } & { [K in string
                    | number
                    | symbol]: U[K] }
            )[k]
        },
        Config,
    >;
    isNullable(): boolean;
    isOptional(): boolean;
    keyof(): z.ZodEnum<{ [k in string]: { [k in string]: k }[k] }>;
    loose(): z.ZodObject<Shape, $loose>;
    merge<U extends z.ZodObject<$ZodLooseShape, $strip>>(
        other: U,
    ): z.ZodObject<
        {
            [k in string
            | number
            | symbol]: (
                (keyof Shape & keyof U["shape"]) extends never
                    ? Shape & U["shape"]
                    : {
                        [K in string | number | symbol as K extends keyof U["shape"]
                            ? never
                            : K]: Shape[K]
                    } & { [K in string
                    | number
                    | symbol]: U["shape"][K] }
            )[k]
        },
        U["_zod"]["config"],
    >;
    meta(): | {
        deprecated?: boolean;
        description?: string;
        id?: string;
        title?: string;
        [key: string]: unknown;
    }
    | undefined;
    meta(
        data: {
            deprecated?: boolean;
            description?: string;
            id?: string;
            title?: string;
            [key: string]: unknown;
        },
    ): this;
    nonoptional(
        params?:
            | string
            | {
                error?: string
                | $ZodErrorMap<$ZodIssueInvalidType<unknown>>;
                message?: string;
            },
    ): z.ZodNonOptional<z.ZodObject<Shape, Config>>;
    nullable(): z.ZodNullable<z.ZodObject<Shape, Config>>;
    nullish(): z.ZodOptional<z.ZodNullable<z.ZodObject<Shape, Config>>>;
    omit<M extends Mask<keyof Shape>>(
        mask: M,
    ): z.ZodObject<
        {
            [k in string
            | number
            | symbol]: Omit<Shape, Extract<keyof Shape, keyof M>>[k]
        },
        Config,
    >;
    optional(): z.ZodOptional<z.ZodObject<Shape, Config>>;
    or<T extends SomeType>(
        option: T,
    ): z.ZodUnion<[z.ZodObject<Shape, Config>, T]>;
    overwrite(
        fn: (x: $InferObjectOutput<Shape>) => $InferObjectOutput<Shape>,
    ): this;
    parse(
        data: unknown,
        params?: ParseContext<$ZodIssue>,
    ): $InferObjectOutput<Shape>;
    parseAsync(
        data: unknown,
        params?: ParseContext<$ZodIssue>,
    ): Promise<$InferObjectOutput<Shape, Config["out"]>>;
    partial(): z.ZodObject<
        { [k in string
        | number
        | symbol]: z.ZodOptional<Shape[k]> },
        Config,
    >;
    partial<M extends Mask<keyof Shape>>(
        mask: M,
    ): z.ZodObject<
        {
            [k in string
            | number
            | symbol]: k extends keyof M ? z.ZodOptional<Shape[k<k>]> : Shape[k]
        },
        Config,
    >;
    passthrough(): z.ZodObject<Shape, $loose>;
    pick<M extends Mask<keyof Shape>>(
        mask: M,
    ): z.ZodObject<
        {
            [k in string
            | number
            | symbol]: Pick<Shape, Extract<keyof Shape, keyof M>>[k]
        },
        Config,
    >;
    pipe<
        T extends
            z.core.$ZodType<
                any,
                $InferObjectOutput<Shape, Config["out"]>,
                $ZodTypeInternals<any, $InferObjectOutput<Shape, Config["out"]>>,
            >,
    >(
        target:
            | T
            | z.core.$ZodType<
                any,
                $InferObjectOutput<Shape, Config["out"]>,
                $ZodTypeInternals<any, $InferObjectOutput<Shape, Config["out"]>>,
            >,
    ): z.ZodPipe<z.ZodObject<Shape, Config>, T>;
    prefault(
        def: () => $InferObjectInput<Shape>,
    ): z.ZodPrefault<z.ZodObject<Shape, Config>>;
    prefault(
        def: $InferObjectInput<Shape>,
    ): z.ZodPrefault<z.ZodObject<Shape, Config>>;
    readonly(): z.ZodReadonly<z.ZodObject<Shape, Config>>;
    refine(
        check: (arg: $InferObjectOutput<Shape>) => unknown,
        params?:
            | string
            | {
                abort?: boolean;
                error?: string
                | $ZodErrorMap<NonNullable<$ZodIssue>>;
                message?: string;
                params?: Record<string, any>;
                path?: PropertyKey[];
                when?: (payload: ParsePayload) => boolean;
            },
    ): this;
    register<
        R extends
            $ZodRegistry<
                MetadataType,
                z.core.$ZodType<unknown, unknown, $ZodTypeInternals<unknown, unknown>>,
            >,
    >(
        registry: R,
        ...meta: z.ZodObject<Shape, Config> extends R["_schema"]
            ? undefined extends R["_meta"]
                ? [$replace<R["_meta"], R["_schema"] & z.ZodObject<Shape, Config>>?]
                : [$replace<R["_meta"], R["_schema"] & z.ZodObject<Shape, Config>>]
            : ["Incompatible schema"],
    ): this;
    required(): z.ZodObject<
        { [k in string
        | number
        | symbol]: z.ZodNonOptional<Shape[k]> },
        Config,
    >;
    required<M extends Mask<keyof Shape>>(
        mask: M,
    ): z.ZodObject<
        {
            [k in string
            | number
            | symbol]: k extends keyof M ? z.ZodNonOptional<Shape[k<k>]> : Shape[k]
        },
        Config,
    >;
    safeDecode(
        data: $InferObjectInput<Shape>,
        params?: ParseContext<$ZodIssue>,
    ): ZodSafeParseResult<$InferObjectOutput<Shape, Config["out"]>>;
    safeDecodeAsync(
        data: $InferObjectInput<Shape>,
        params?: ParseContext<$ZodIssue>,
    ): Promise<ZodSafeParseResult<$InferObjectOutput<Shape, Config["out"]>>>;
    safeEncode(
        data: $InferObjectOutput<Shape>,
        params?: ParseContext<$ZodIssue>,
    ): ZodSafeParseResult<$InferObjectInput<Shape, Config["in"]>>;
    safeEncodeAsync(
        data: $InferObjectOutput<Shape>,
        params?: ParseContext<$ZodIssue>,
    ): Promise<ZodSafeParseResult<$InferObjectInput<Shape, Config["in"]>>>;
    safeExtend<U extends $ZodLooseShape>(
        shape: SafeExtendShape<Shape, U> & Partial<
            Record<keyof Shape, SomeType>,
        >,
    ): z.ZodObject<
        {
            [k in string
            | number
            | symbol]: (
                (keyof Shape & keyof U) extends never
                    ? Shape & U
                    : {
                        [K in string | number | symbol as K extends keyof U ? never : K]: Shape[K]
                    } & { [K in string
                    | number
                    | symbol]: U[K] }
            )[k]
        },
        Config,
    >;
    safeParse(
        data: unknown,
        params?: ParseContext<$ZodIssue>,
    ): ZodSafeParseResult<$InferObjectOutput<Shape, Config["out"]>>;
    safeParseAsync(
        data: unknown,
        params?: ParseContext<$ZodIssue>,
    ): Promise<ZodSafeParseResult<$InferObjectOutput<Shape, Config["out"]>>>;
    strict(): z.ZodObject<Shape, $strict>;
    strip(): z.ZodObject<Shape, $strip>;
    superRefine(
        refinement: (
            arg: $InferObjectOutput<Shape>,
            ctx: $RefinementCtx<$InferObjectOutput<Shape, Config["out"]>>,
        ) => void | Promise<void>,
    ): this;
    transform<NewOut>(
        transform: (
            arg: $InferObjectOutput<Shape>,
            ctx: $RefinementCtx<$InferObjectOutput<Shape, Config["out"]>>,
        ) => NewOut | Promise<NewOut>,
    ): z.ZodPipe<
        z.ZodObject<Shape, Config>,
        z.ZodTransform<Awaited<NewOut>, $InferObjectOutput<Shape, Config["out"]>>,
    >;
}