@rspack/core 1.3.12 → 1.3.14

package/compiled/zod/dist/types/v4/locales/ar.d.ts

@@ -1,7 +1,4 @@
 import type * as errors from "../core/errors.js";
-export declare const parsedType: (data: any) => string;
-declare const error: errors.$ZodErrorMap;
-export { error };
 export default function (): {
     localeError: errors.$ZodErrorMap;
 };

package/compiled/zod/dist/types/v4/locales/az.d.ts

@@ -1,7 +1,4 @@
 import type * as errors from "../core/errors.js";
-export declare const parsedType: (data: any) => string;
-declare const error: errors.$ZodErrorMap;
-export { error };
 export default function (): {
     localeError: errors.$ZodErrorMap;
 };

package/compiled/zod/dist/types/v4/locales/be.d.ts

@@ -1,7 +1,4 @@
 import type * as errors from "../core/errors.js";
-export declare const parsedType: (data: any) => string;
-declare const error: errors.$ZodErrorMap;
-export { error };
 export default function (): {
     localeError: errors.$ZodErrorMap;
 };

package/compiled/zod/dist/types/v4/locales/ca.d.ts

@@ -1,7 +1,4 @@
 import type * as errors from "../core/errors.js";
-export declare const parsedType: (data: any) => string;
-declare const error: errors.$ZodErrorMap;
-export { error };
 export default function (): {
     localeError: errors.$ZodErrorMap;
 };

package/compiled/zod/dist/types/v4/locales/cs.d.ts

@@ -1,7 +1,4 @@
 import type * as errors from "../core/errors.js";
-export declare const parsedType: (data: any) => string;
-declare const error: errors.$ZodErrorMap;
-export { error };
 export default function (): {
     localeError: errors.$ZodErrorMap;
 };

package/compiled/zod/dist/types/v4/locales/de.d.ts

@@ -1,7 +1,4 @@
 import type * as errors from "../core/errors.js";
-export declare const parsedType: (data: any) => string;
-declare const error: errors.$ZodErrorMap;
-export { error };
 export default function (): {
     localeError: errors.$ZodErrorMap;
 };

package/compiled/zod/dist/types/v4/locales/en.d.ts

@@ -1,7 +1,5 @@
 import type * as errors from "../core/errors.js";
 export declare const parsedType: (data: any) => string;
-declare const error: errors.$ZodErrorMap;
-export { error };
 export default function (): {
     localeError: errors.$ZodErrorMap;
 };

package/compiled/zod/dist/types/v4/locales/es.d.ts

@@ -1,7 +1,4 @@
 import type * as errors from "../core/errors.js";
-export declare const parsedType: (data: any) => string;
-declare const error: errors.$ZodErrorMap;
-export { error };
 export default function (): {
     localeError: errors.$ZodErrorMap;
 };

package/compiled/zod/dist/types/v4/locales/fa.d.ts

@@ -1,7 +1,4 @@
 import type * as errors from "../core/errors.js";
-export declare const parsedType: (data: any) => string;
-declare const error: errors.$ZodErrorMap;
-export { error };
 export default function (): {
     localeError: errors.$ZodErrorMap;
 };

package/compiled/zod/dist/types/v4/locales/fi.d.ts

@@ -1,7 +1,4 @@
 import type * as errors from "../core/errors.js";
-export declare const parsedType: (data: any) => string;
-declare const error: errors.$ZodErrorMap;
-export { error };
 export default function (): {
     localeError: errors.$ZodErrorMap;
 };

package/compiled/zod/dist/types/v4/locales/{frCA.d.ts → fr-CA.d.ts}

@@ -1,7 +1,4 @@
 import type * as errors from "../core/errors.js";
-export declare const parsedType: (data: any) => string;
-declare const error: errors.$ZodErrorMap;
-export { error };
 export default function (): {
     localeError: errors.$ZodErrorMap;
 };

package/compiled/zod/dist/types/v4/locales/fr.d.ts

@@ -1,7 +1,4 @@
 import type * as errors from "../core/errors.js";
-export declare const parsedType: (data: any) => string;
-declare const error: errors.$ZodErrorMap;
-export { error };
 export default function (): {
     localeError: errors.$ZodErrorMap;
 };

package/compiled/zod/dist/types/v4/locales/he.d.ts

@@ -1,7 +1,4 @@
 import type * as errors from "../core/errors.js";
-export declare const parsedType: (data: any) => string;
-declare const error: errors.$ZodErrorMap;
-export { error };
 export default function (): {
     localeError: errors.$ZodErrorMap;
 };

package/compiled/zod/dist/types/v4/locales/hu.d.ts

@@ -1,7 +1,4 @@
 import type * as errors from "../core/errors.js";
-export declare const parsedType: (data: any) => string;
-declare const error: errors.$ZodErrorMap;
-export { error };
 export default function (): {
     localeError: errors.$ZodErrorMap;
 };

package/compiled/zod/dist/types/v4/locales/id.d.ts

@@ -1,7 +1,4 @@
 import type * as errors from "../core/errors.js";
-export declare const parsedType: (data: any) => string;
-declare const error: errors.$ZodErrorMap;
-export { error };
 export default function (): {
     localeError: errors.$ZodErrorMap;
 };

package/compiled/zod/dist/types/v4/locales/index.d.ts

@@ -9,21 +9,24 @@ export { default as es } from "./es.js";
 export { default as fa } from "./fa.js";
 export { default as fi } from "./fi.js";
 export { default as fr } from "./fr.js";
-export { default as frCA } from "./frCA.js";
+export { default as frCA } from "./fr-CA.js";
 export { default as he } from "./he.js";
 export { default as hu } from "./hu.js";
 export { default as id } from "./id.js";
 export { default as it } from "./it.js";
 export { default as ja } from "./ja.js";
+export { default as kh } from "./kh.js";
 export { default as ko } from "./ko.js";
 export { default as mk } from "./mk.js";
 export { default as ms } from "./ms.js";
+export { default as nl } from "./nl.js";
 export { default as no } from "./no.js";
 export { default as ota } from "./ota.js";
 export { default as pl } from "./pl.js";
 export { default as pt } from "./pt.js";
 export { default as ru } from "./ru.js";
 export { default as sl } from "./sl.js";
+export { default as sv } from "./sv.js";
 export { default as ta } from "./ta.js";
 export { default as th } from "./th.js";
 export { default as tr } from "./tr.js";
@@ -31,4 +34,4 @@ export { default as ua } from "./ua.js";
 export { default as ur } from "./ur.js";
 export { default as vi } from "./vi.js";
 export { default as zhCN } from "./zh-CN.js";
-export { default as zhTW } from "./zh-tw.js";
+export { default as zhTW } from "./zh-TW.js";

package/compiled/zod/dist/types/v4/locales/it.d.ts

@@ -1,7 +1,4 @@
 import type * as errors from "../core/errors.js";
-export declare const parsedType: (data: any) => string;
-declare const error: errors.$ZodErrorMap;
-export { error };
 export default function (): {
     localeError: errors.$ZodErrorMap;
 };

package/compiled/zod/dist/types/v4/locales/ja.d.ts

@@ -1,7 +1,4 @@
 import type * as errors from "../core/errors.js";
-export declare const parsedType: (data: any) => string;
-declare const error: errors.$ZodErrorMap;
-export { error };
 export default function (): {
     localeError: errors.$ZodErrorMap;
 };

package/compiled/zod/dist/types/v4/locales/{zh-tw.d.ts → kh.d.ts}

@@ -1,7 +1,4 @@
 import type * as errors from "../core/errors.js";
-export declare const parsedType: (data: any) => string;
-declare const error: errors.$ZodErrorMap;
-export { error };
 export default function (): {
     localeError: errors.$ZodErrorMap;
 };

package/compiled/zod/dist/types/v4/locales/ko.d.ts

@@ -1,7 +1,4 @@
 import type * as errors from "../core/errors.js";
-export declare const parsedType: (data: any) => string;
-declare const error: errors.$ZodErrorMap;
-export { error };
 export default function (): {
     localeError: errors.$ZodErrorMap;
 };

package/compiled/zod/dist/types/v4/locales/mk.d.ts

@@ -1,7 +1,4 @@
 import type * as errors from "../core/errors.js";
-export declare const parsedType: (data: any) => string;
-declare const error: errors.$ZodErrorMap;
-export { error };
 export default function (): {
     localeError: errors.$ZodErrorMap;
 };

package/compiled/zod/dist/types/v4/locales/ms.d.ts

@@ -1,7 +1,4 @@
 import type * as errors from "../core/errors.js";
-export declare const parsedType: (data: any) => string;
-declare const error: errors.$ZodErrorMap;
-export { error };
 export default function (): {
     localeError: errors.$ZodErrorMap;
 };

package/compiled/zod/dist/types/v4/locales/nl.d.ts

@@ -0,0 +1,4 @@
+import type * as errors from "../core/errors.js";
+export default function (): {
+    localeError: errors.$ZodErrorMap;
+};

package/compiled/zod/dist/types/v4/locales/no.d.ts

@@ -1,7 +1,4 @@
 import type * as errors from "../core/errors.js";
-export declare const parsedType: (data: any) => string;
-declare const error: errors.$ZodErrorMap;
-export { error };
 export default function (): {
     localeError: errors.$ZodErrorMap;
 };

package/compiled/zod/dist/types/v4/locales/ota.d.ts

@@ -1,7 +1,4 @@
 import type * as errors from "../core/errors.js";
-export declare const parsedType: (data: any) => string;
-declare const error: errors.$ZodErrorMap;
-export { error };
 export default function (): {
     localeError: errors.$ZodErrorMap;
 };

package/compiled/zod/dist/types/v4/locales/pl.d.ts

@@ -1,7 +1,4 @@
 import type * as errors from "../core/errors.js";
-export declare const parsedType: (data: any) => string;
-declare const error: errors.$ZodErrorMap;
-export { error };
 export default function (): {
     localeError: errors.$ZodErrorMap;
 };

package/compiled/zod/dist/types/v4/locales/pt.d.ts

@@ -1,7 +1,4 @@
 import type * as errors from "../core/errors.js";
-export declare const parsedType: (data: any) => string;
-declare const error: errors.$ZodErrorMap;
-export { error };
 export default function (): {
     localeError: errors.$ZodErrorMap;
 };

package/compiled/zod/dist/types/v4/locales/ru.d.ts

@@ -1,7 +1,4 @@
 import type * as errors from "../core/errors.js";
-export declare const parsedType: (data: any) => string;
-declare const error: errors.$ZodErrorMap;
-export { error };
 export default function (): {
     localeError: errors.$ZodErrorMap;
 };

package/compiled/zod/dist/types/v4/locales/sl.d.ts

@@ -1,7 +1,4 @@
 import type * as errors from "../core/errors.js";
-export declare const parsedType: (data: any) => string;
-declare const error: errors.$ZodErrorMap;
-export { error };
 export default function (): {
     localeError: errors.$ZodErrorMap;
 };

package/compiled/zod/dist/types/v4/locales/sv.d.ts

@@ -0,0 +1,4 @@
+import type * as errors from "../core/errors.js";
+export default function (): {
+    localeError: errors.$ZodErrorMap;
+};

package/compiled/zod/dist/types/v4/locales/ta.d.ts

@@ -1,7 +1,4 @@
 import type * as errors from "../core/errors.js";
-export declare const parsedType: (data: any) => string;
-declare const error: errors.$ZodErrorMap;
-export { error };
 export default function (): {
     localeError: errors.$ZodErrorMap;
 };

package/compiled/zod/dist/types/v4/locales/th.d.ts

@@ -1,7 +1,4 @@
 import type * as errors from "../core/errors.js";
-export declare const parsedType: (data: any) => string;
-declare const error: errors.$ZodErrorMap;
-export { error };
 export default function (): {
     localeError: errors.$ZodErrorMap;
 };

package/compiled/zod/dist/types/v4/locales/tr.d.ts

@@ -1,7 +1,5 @@
 import type * as errors from "../core/errors.js";
 export declare const parsedType: (data: any) => string;
-declare const error: errors.$ZodErrorMap;
-export { error };
 export default function (): {
     localeError: errors.$ZodErrorMap;
 };

package/compiled/zod/dist/types/v4/locales/ua.d.ts

@@ -1,7 +1,4 @@
 import type * as errors from "../core/errors.js";
-export declare const parsedType: (data: any) => string;
-declare const error: errors.$ZodErrorMap;
-export { error };
 export default function (): {
     localeError: errors.$ZodErrorMap;
 };

package/compiled/zod/dist/types/v4/locales/ur.d.ts

@@ -1,7 +1,4 @@
 import type * as errors from "../core/errors.js";
-export declare const parsedType: (data: any) => string;
-declare const error: errors.$ZodErrorMap;
-export { error };
 export default function (): {
     localeError: errors.$ZodErrorMap;
 };

package/compiled/zod/dist/types/v4/locales/vi.d.ts

@@ -1,7 +1,4 @@
 import type * as errors from "../core/errors.js";
-export declare const parsedType: (data: any) => string;
-declare const error: errors.$ZodErrorMap;
-export { error };
 export default function (): {
     localeError: errors.$ZodErrorMap;
 };

package/compiled/zod/dist/types/v4/locales/zh-CN.d.ts

@@ -1,7 +1,4 @@
 import type * as errors from "../core/errors.js";
-export declare const parsedType: (data: any) => string;
-declare const error: errors.$ZodErrorMap;
-export { error };
 export default function (): {
     localeError: errors.$ZodErrorMap;
 };

package/compiled/zod/dist/types/v4/locales/zh-TW.d.ts

@@ -0,0 +1,4 @@
+import type * as errors from "../core/errors.js";
+export default function (): {
+    localeError: errors.$ZodErrorMap;
+};

package/compiled/zod/dist/types/v4/mini/external.d.ts

@@ -3,5 +3,9 @@ export * from "./parse.js";
 export * from "./schemas.js";
 export * from "./checks.js";
 export type { infer, output, input } from "zod/v4/core";
-export { globalRegistry, registry, config, $output, $input, $brand, function, clone, regexes, treeifyError, prettifyError, formatError, flattenError, toJSONSchema, locales, } from "zod/v4/core";
+export { globalRegistry, registry, config, $output, $input, $brand, function, clone, regexes, treeifyError, prettifyError, formatError, flattenError, toJSONSchema, } from "zod/v4/core";
+export * as locales from "../locales/index.js";
 /** A special constant with type `never` */
+export * as iso from "./iso.js";
+export { ZodMiniISODateTime, ZodMiniISODate, ZodMiniISOTime, ZodMiniISODuration, } from "./iso.js";
+export * as coerce from "./coerce.js";

package/compiled/zod/dist/types/v4/mini/schemas.d.ts

@@ -1,24 +1,23 @@
 import * as core from "zod/v4/core";
 import { util } from "zod/v4/core";
-export * as coerce from "./coerce.js";
-export * as iso from "./iso.js";
-type SomeType = core.$ZodType;
-export interface ZodMiniType<out Output = unknown, out Input = unknown> extends core.$ZodType<Output, Input> {
-    check(...checks: (core.CheckFn<this["_zod"]["output"]> | core.$ZodCheck<this["_zod"]["output"]>)[]): this;
-    clone(def?: this["_zod"]["def"], params?: {
+type SomeType = core.SomeType;
+export interface ZodMiniType<out Output = unknown, out Input = unknown, out Internals extends core.$ZodTypeInternals<Output, Input> = core.$ZodTypeInternals<Output, Input>> extends core.$ZodType<Output, Input, Internals> {
+    check(...checks: (core.CheckFn<core.output<this>> | core.$ZodCheck<core.output<this>>)[]): this;
+    clone(def?: Internals["def"], params?: {
         parent: boolean;
     }): this;
     register<R extends core.$ZodRegistry>(registry: R, ...meta: this extends R["_schema"] ? undefined extends R["_meta"] ? [core.$replace<R["_meta"], this>?] : [core.$replace<R["_meta"], this>] : ["Incompatible schema"]): this;
-    brand<T extends PropertyKey = PropertyKey>(value?: T): PropertyKey extends T ? this : this & Record<"_zod", Record<"~output", core.output<this> & core.$brand<T>>>;
-    def: this["_zod"]["def"];
+    brand<T extends PropertyKey = PropertyKey>(value?: T): PropertyKey extends T ? this : this & Record<"_zod", Record<"output", core.output<this> & core.$brand<T>>>;
+    def: Internals["def"];
     parse(data: unknown, params?: core.ParseContext<core.$ZodIssue>): core.output<this>;
     safeParse(data: unknown, params?: core.ParseContext<core.$ZodIssue>): util.SafeParseResult<core.output<this>>;
     parseAsync(data: unknown, params?: core.ParseContext<core.$ZodIssue>): Promise<core.output<this>>;
     safeParseAsync(data: unknown, params?: core.ParseContext<core.$ZodIssue>): Promise<util.SafeParseResult<core.output<this>>>;
 }
+interface _ZodMiniType<out Internals extends core.$ZodTypeInternals = core.$ZodTypeInternals> extends ZodMiniType<Internals["output"], Internals["input"], Internals> {
+}
 export declare const ZodMiniType: core.$constructor<ZodMiniType>;
-export interface ZodMiniString<Input = unknown> extends ZodMiniType {
-    _zod: core.$ZodStringInternals<Input>;
+export interface ZodMiniString<Input = unknown> extends _ZodMiniType<core.$ZodStringInternals<Input>>, core.$ZodString<Input> {
 }
 export declare const ZodMiniString: core.$constructor<ZodMiniString>;
 export declare function string(params?: string | core.$ZodStringParams): ZodMiniString<string>;
@@ -197,16 +196,14 @@ export interface ZodMiniDate<T = unknown> extends ZodMiniType {
 }
 export declare const ZodMiniDate: core.$constructor<ZodMiniDate>;
 export declare function date(params?: string | core.$ZodDateParams): ZodMiniDate<Date>;
-export interface ZodMiniArray<T extends SomeType = SomeType> extends ZodMiniType {
-    _zod: core.$ZodArrayInternals<T>;
+export interface ZodMiniArray<T extends SomeType = core.$ZodType> extends _ZodMiniType<core.$ZodArrayInternals<T>>, core.$ZodArray<T> {
 }
 export declare const ZodMiniArray: core.$constructor<ZodMiniArray>;
 export declare function array<T extends SomeType>(element: T, params?: string | core.$ZodArrayParams): ZodMiniArray<T>;
 export declare function keyof<T extends ZodMiniObject>(schema: T): ZodMiniLiteral<keyof T["shape"]>;
 export interface ZodMiniObject<
 /** @ts-ignore Cast variance */
-out Shape extends core.$ZodShape = core.$ZodShape, out Config extends core.$ZodObjectConfig = core.$ZodObjectConfig> extends ZodMiniType {
-    _zod: core.$ZodObjectInternals<Shape, Config>;
+out Shape extends core.$ZodShape = core.$ZodShape, out Config extends core.$ZodObjectConfig = core.$ZodObjectConfig> extends ZodMiniType<any, any, core.$ZodObjectInternals<Shape, Config>>, core.$ZodObject<Shape, Config> {
     shape: Shape;
 }
 export declare const ZodMiniObject: core.$constructor<ZodMiniObject>;
@@ -235,46 +232,40 @@ export declare function required<T extends ZodMiniObject>(schema: T): ZodMiniObj
 export declare function required<T extends ZodMiniObject, M extends util.Mask<keyof T["shape"]>>(schema: T, mask: M): ZodMiniObject<util.Extend<T["shape"], {
     [k in keyof M & keyof T["shape"]]: ZodMiniNonOptional<T["shape"][k]>;
 }>, T["_zod"]["config"]>;
-export interface ZodMiniUnion<T extends readonly SomeType[] = readonly SomeType[]> extends ZodMiniType {
+export interface ZodMiniUnion<T extends readonly SomeType[] = readonly core.$ZodType[]> extends ZodMiniType {
     _zod: core.$ZodUnionInternals<T>;
 }
 export declare const ZodMiniUnion: core.$constructor<ZodMiniUnion>;
 export declare function union<const T extends readonly SomeType[]>(options: T, params?: string | core.$ZodUnionParams): ZodMiniUnion<T>;
-export interface ZodMiniDiscriminatedUnion<Options extends readonly SomeType[] = readonly SomeType[]> extends ZodMiniUnion<Options> {
+export interface ZodMiniDiscriminatedUnion<Options extends readonly SomeType[] = readonly core.$ZodType[]> extends ZodMiniUnion<Options> {
     _zod: core.$ZodDiscriminatedUnionInternals<Options>;
 }
 export declare const ZodMiniDiscriminatedUnion: core.$constructor<ZodMiniDiscriminatedUnion>;
-export interface $ZodTypeDiscriminableInternals extends core.$ZodTypeInternals {
-    disc: util.DiscriminatorMap;
-}
-export interface $ZodTypeDiscriminable extends ZodMiniType {
-    _zod: $ZodTypeDiscriminableInternals;
-}
-export declare function discriminatedUnion<Types extends readonly [$ZodTypeDiscriminable, ...$ZodTypeDiscriminable[]]>(discriminator: string, options: Types, params?: string | core.$ZodDiscriminatedUnionParams): ZodMiniDiscriminatedUnion<Types>;
-export interface ZodMiniIntersection<A extends SomeType = SomeType, B extends SomeType = SomeType> extends ZodMiniType {
+export declare function discriminatedUnion<Types extends readonly [core.$ZodTypeDiscriminable, ...core.$ZodTypeDiscriminable[]]>(discriminator: string, options: Types, params?: string | core.$ZodDiscriminatedUnionParams): ZodMiniDiscriminatedUnion<Types>;
+export interface ZodMiniIntersection<A extends SomeType = core.$ZodType, B extends SomeType = core.$ZodType> extends ZodMiniType {
     _zod: core.$ZodIntersectionInternals<A, B>;
 }
 export declare const ZodMiniIntersection: core.$constructor<ZodMiniIntersection>;
 export declare function intersection<T extends SomeType, U extends SomeType>(left: T, right: U): ZodMiniIntersection<T, U>;
-export interface ZodMiniTuple<T extends util.TupleItems = util.TupleItems, Rest extends SomeType | null = SomeType | null> extends ZodMiniType {
+export interface ZodMiniTuple<T extends util.TupleItems = readonly core.$ZodType[], Rest extends SomeType | null = core.$ZodType | null> extends ZodMiniType {
     _zod: core.$ZodTupleInternals<T, Rest>;
 }
 export declare const ZodMiniTuple: core.$constructor<ZodMiniTuple>;
-export declare function tuple<T extends readonly [SomeType, ...SomeType[]]>(items: T, params?: string | core.$ZodTupleParams): ZodMiniTuple<T, null>;
-export declare function tuple<T extends readonly [SomeType, ...SomeType[]], Rest extends SomeType>(items: T, rest: Rest, params?: string | core.$ZodTupleParams): ZodMiniTuple<T, Rest>;
+export declare function tuple<const T extends readonly [SomeType, ...SomeType[]]>(items: T, params?: string | core.$ZodTupleParams): ZodMiniTuple<T, null>;
+export declare function tuple<const T extends readonly [SomeType, ...SomeType[]], Rest extends SomeType>(items: T, rest: Rest, params?: string | core.$ZodTupleParams): ZodMiniTuple<T, Rest>;
 export declare function tuple(items: [], params?: string | core.$ZodTupleParams): ZodMiniTuple<[], null>;
-export interface ZodMiniRecord<Key extends core.$ZodRecordKey = core.$ZodRecordKey, Value extends SomeType = SomeType> extends ZodMiniType {
+export interface ZodMiniRecord<Key extends core.$ZodRecordKey = core.$ZodRecordKey, Value extends SomeType = core.$ZodType> extends ZodMiniType {
     _zod: core.$ZodRecordInternals<Key, Value>;
 }
 export declare const ZodMiniRecord: core.$constructor<ZodMiniRecord>;
 export declare function record<Key extends core.$ZodRecordKey, Value extends SomeType>(keyType: Key, valueType: Value, params?: string | core.$ZodRecordParams): ZodMiniRecord<Key, Value>;
 export declare function partialRecord<Key extends core.$ZodRecordKey, Value extends SomeType>(keyType: Key, valueType: Value, params?: string | core.$ZodRecordParams): ZodMiniRecord<ZodMiniUnion<[Key, ZodMiniNever]>, Value>;
-export interface ZodMiniMap<Key extends SomeType = SomeType, Value extends SomeType = SomeType> extends ZodMiniType {
+export interface ZodMiniMap<Key extends SomeType = core.$ZodType, Value extends SomeType = core.$ZodType> extends ZodMiniType {
     _zod: core.$ZodMapInternals<Key, Value>;
 }
 export declare const ZodMiniMap: core.$constructor<ZodMiniMap>;
 export declare function map<Key extends SomeType, Value extends SomeType>(keyType: Key, valueType: Value, params?: string | core.$ZodMapParams): ZodMiniMap<Key, Value>;
-export interface ZodMiniSet<T extends SomeType = SomeType> extends ZodMiniType {
+export interface ZodMiniSet<T extends SomeType = core.$ZodType> extends ZodMiniType {
     _zod: core.$ZodSetInternals<T>;
 }
 export declare const ZodMiniSet: core.$constructor<ZodMiniSet>;
@@ -310,38 +301,38 @@ export interface ZodMiniTransform<O = unknown, I = unknown> extends ZodMiniType
 }
 export declare const ZodMiniTransform: core.$constructor<ZodMiniTransform>;
 export declare function transform<I = unknown, O = I>(fn: (input: I, ctx: core.ParsePayload) => O): ZodMiniTransform<Awaited<O>, I>;
-export interface ZodMiniOptional<T extends SomeType = SomeType> extends ZodMiniType {
+export interface ZodMiniOptional<T extends SomeType = core.$ZodType> extends ZodMiniType {
     _zod: core.$ZodOptionalInternals<T>;
 }
 export declare const ZodMiniOptional: core.$constructor<ZodMiniOptional>;
 export declare function optional<T extends SomeType>(innerType: T): ZodMiniOptional<T>;
-export interface ZodMiniNullable<T extends SomeType = SomeType> extends ZodMiniType {
+export interface ZodMiniNullable<T extends SomeType = core.$ZodType> extends ZodMiniType {
     _zod: core.$ZodNullableInternals<T>;
 }
 export declare const ZodMiniNullable: core.$constructor<ZodMiniNullable>;
 export declare function nullable<T extends SomeType>(innerType: T): ZodMiniNullable<T>;
 export declare function nullish<T extends SomeType>(innerType: T): ZodMiniOptional<ZodMiniNullable<T>>;
-export interface ZodMiniDefault<T extends SomeType = SomeType> extends ZodMiniType {
+export interface ZodMiniDefault<T extends SomeType = core.$ZodType> extends ZodMiniType {
     _zod: core.$ZodDefaultInternals<T>;
 }
 export declare const ZodMiniDefault: core.$constructor<ZodMiniDefault>;
 export declare function _default<T extends SomeType>(innerType: T, defaultValue: util.NoUndefined<core.output<T>> | (() => util.NoUndefined<core.output<T>>)): ZodMiniDefault<T>;
-export interface ZodMiniPrefault<T extends SomeType = SomeType> extends ZodMiniType {
+export interface ZodMiniPrefault<T extends SomeType = core.$ZodType> extends ZodMiniType {
     _zod: core.$ZodPrefaultInternals<T>;
 }
 export declare const ZodMiniPrefault: core.$constructor<ZodMiniPrefault>;
 export declare function prefault<T extends SomeType>(innerType: T, defaultValue: util.NoUndefined<core.input<T>> | (() => util.NoUndefined<core.input<T>>)): ZodMiniPrefault<T>;
-export interface ZodMiniNonOptional<T extends SomeType = SomeType> extends ZodMiniType {
+export interface ZodMiniNonOptional<T extends SomeType = core.$ZodType> extends ZodMiniType {
     _zod: core.$ZodNonOptionalInternals<T>;
 }
 export declare const ZodMiniNonOptional: core.$constructor<ZodMiniNonOptional>;
 export declare function nonoptional<T extends SomeType>(innerType: T, params?: string | core.$ZodNonOptionalParams): ZodMiniNonOptional<T>;
-export interface ZodMiniSuccess<T extends SomeType = SomeType> extends ZodMiniType {
+export interface ZodMiniSuccess<T extends SomeType = core.$ZodType> extends ZodMiniType {
     _zod: core.$ZodSuccessInternals<T>;
 }
 export declare const ZodMiniSuccess: core.$constructor<ZodMiniSuccess>;
 export declare function success<T extends SomeType>(innerType: T): ZodMiniSuccess<T>;
-export interface ZodMiniCatch<T extends SomeType = SomeType> extends ZodMiniType {
+export interface ZodMiniCatch<T extends SomeType = core.$ZodType> extends ZodMiniType {
     _zod: core.$ZodCatchInternals<T>;
 }
 export declare const ZodMiniCatch: core.$constructor<ZodMiniCatch>;
@@ -352,12 +343,12 @@ export interface ZodMiniNaN extends ZodMiniType {
 }
 export declare const ZodMiniNaN: core.$constructor<ZodMiniNaN>;
 export declare function nan(params?: string | core.$ZodNaNParams): ZodMiniNaN;
-export interface ZodMiniPipe<A extends SomeType = SomeType, B extends SomeType = SomeType> extends ZodMiniType {
+export interface ZodMiniPipe<A extends SomeType = core.$ZodType, B extends SomeType = core.$ZodType> extends ZodMiniType {
     _zod: core.$ZodPipeInternals<A, B>;
 }
 export declare const ZodMiniPipe: core.$constructor<ZodMiniPipe>;
-export declare function pipe<const A extends core.$ZodType, B extends core.$ZodType<unknown, core.output<A>> = core.$ZodType<unknown, core.output<A>>>(in_: A, out: B | core.$ZodType<unknown, core.output<A>>, params?: string | core.$ZodPipeParams): ZodMiniPipe<A, B>;
-export interface ZodMiniReadonly<T extends SomeType = SomeType> extends ZodMiniType {
+export declare function pipe<const A extends SomeType, B extends core.$ZodType<unknown, core.output<A>> = core.$ZodType<unknown, core.output<A>>>(in_: A, out: B | core.$ZodType<unknown, core.output<A>>): ZodMiniPipe<A, B>;
+export interface ZodMiniReadonly<T extends SomeType = core.$ZodType> extends ZodMiniType {
     _zod: core.$ZodReadonlyInternals<T>;
 }
 export declare const ZodMiniReadonly: core.$constructor<ZodMiniReadonly>;
@@ -367,13 +358,13 @@ export interface ZodMiniTemplateLiteral<Template extends string = string> extend
 }
 export declare const ZodMiniTemplateLiteral: core.$constructor<ZodMiniTemplateLiteral>;
 export declare function templateLiteral<const Parts extends core.$ZodTemplateLiteralPart[]>(parts: Parts, params?: string | core.$ZodTemplateLiteralParams): ZodMiniTemplateLiteral<core.$PartsToTemplateLiteral<Parts>>;
-export interface ZodMiniLazy<T extends SomeType = SomeType> extends ZodMiniType {
+export interface ZodMiniLazy<T extends SomeType = core.$ZodType> extends ZodMiniType {
     _zod: core.$ZodLazyInternals<T>;
 }
 export declare const ZodMiniLazy: core.$constructor<ZodMiniLazy>;
 declare function _lazy<T extends SomeType>(getter: () => T): ZodMiniLazy<T>;
 export { _lazy as lazy };
-export interface ZodMiniPromise<T extends SomeType = SomeType> extends ZodMiniType {
+export interface ZodMiniPromise<T extends SomeType = core.$ZodType> extends ZodMiniType {
     _zod: core.$ZodPromiseInternals<T>;
 }
 export declare const ZodMiniPromise: core.$constructor<ZodMiniPromise>;
@@ -383,22 +374,22 @@ export interface ZodMiniCustom<O = unknown, I = unknown> extends ZodMiniType {
 }
 export declare const ZodMiniCustom: core.$constructor<ZodMiniCustom>;
 export declare function check<O = unknown>(fn: core.CheckFn<O>, params?: string | core.$ZodCustomParams): core.$ZodCheck<O>;
-export declare function refine<T>(fn: (arg: NoInfer<T>) => util.MaybeAsync<unknown>, _params?: string | core.$ZodCustomParams): core.$ZodCheck<T>;
 export declare function custom<O = unknown, I = O>(fn?: (data: O) => unknown, _params?: string | core.$ZodCustomParams | undefined): ZodMiniCustom<O, I>;
+export declare function refine<T>(fn: (arg: NoInfer<T>) => util.MaybeAsync<unknown>, _params?: string | core.$ZodCustomParams): core.$ZodCheck<T>;
 declare abstract class Class {
     constructor(..._args: any[]);
 }
-declare function _instanceof<T extends typeof Class>(cls: T, params?: core.$ZodCustomParams): ZodMiniCustom<InstanceType<T>>;
+declare function _instanceof<T extends typeof Class>(cls: T, params?: core.$ZodCustomParams): ZodMiniCustom<InstanceType<T>, InstanceType<T>>;
 export { _instanceof as instanceof };
 export declare const stringbool: (_params?: string | core.$ZodStringBoolParams) => ZodMiniPipe<ZodMiniUnknown, ZodMiniBoolean<boolean>>;
-export type ZodMiniJSONSchema = ZodMiniLazy<ZodMiniUnion<[
-    ZodMiniString<string>,
-    ZodMiniNumber<number>,
-    ZodMiniBoolean<boolean>,
+export type ZodMiniJSONSchema = ZodMiniUnion<[
+    ZodMiniString,
+    ZodMiniNumber,
+    ZodMiniBoolean,
     ZodMiniNull,
     ZodMiniArray<ZodMiniJSONSchema>,
     ZodMiniRecord<ZodMiniString<string>, ZodMiniJSONSchema>
-]>> & {
+]> & {
     _zod: {
         input: util.JSONType;
         output: util.JSONType;