@rspack/core 1.3.15 → 1.4.0-beta.0

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

@@ -14,122 +14,106 @@ export interface ZodMiniType<out Output = unknown, out Input = unknown, out Inte
     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> {
+interface _ZodMiniType<out Internals extends core.$ZodTypeInternals = core.$ZodTypeInternals> extends ZodMiniType<any, any, Internals> {
 }
 export declare const ZodMiniType: core.$constructor<ZodMiniType>;
-export interface ZodMiniString<Input = unknown> extends _ZodMiniType<core.$ZodStringInternals<Input>>, core.$ZodString<Input> {
+export interface _ZodMiniString<T extends core.$ZodStringInternals<unknown> = core.$ZodStringInternals<unknown>> extends _ZodMiniType<T>, core.$ZodString<T["input"]> {
+    _zod: T;
+}
+export interface ZodMiniString<Input = unknown> extends _ZodMiniString<core.$ZodStringInternals<Input>>, core.$ZodString<Input> {
 }
 export declare const ZodMiniString: core.$constructor<ZodMiniString>;
 export declare function string(params?: string | core.$ZodStringParams): ZodMiniString<string>;
-export interface ZodMiniStringFormat<Format extends core.$ZodStringFormats = core.$ZodStringFormats> extends ZodMiniString {
-    _zod: core.$ZodStringFormatInternals<Format>;
+export interface ZodMiniStringFormat<Format extends core.$ZodStringFormats = core.$ZodStringFormats> extends _ZodMiniString<core.$ZodStringFormatInternals<Format>>, core.$ZodStringFormat<Format> {
 }
 export declare const ZodMiniStringFormat: core.$constructor<ZodMiniStringFormat>;
-export interface ZodMiniEmail extends ZodMiniStringFormat<"email"> {
-    _zod: core.$ZodEmailInternals;
+export interface ZodMiniEmail extends _ZodMiniString<core.$ZodEmailInternals> {
 }
 export declare const ZodMiniEmail: core.$constructor<ZodMiniEmail>;
 export declare function email(params?: string | core.$ZodEmailParams): ZodMiniEmail;
-export interface ZodMiniGUID extends ZodMiniStringFormat<"guid"> {
-    _zod: core.$ZodGUIDInternals;
+export interface ZodMiniGUID extends _ZodMiniString<core.$ZodGUIDInternals> {
 }
 export declare const ZodMiniGUID: core.$constructor<ZodMiniGUID>;
 export declare function guid(params?: string | core.$ZodGUIDParams): ZodMiniGUID;
-export interface ZodMiniUUID extends ZodMiniStringFormat<"uuid"> {
-    _zod: core.$ZodUUIDInternals;
+export interface ZodMiniUUID extends _ZodMiniString<core.$ZodUUIDInternals> {
 }
 export declare const ZodMiniUUID: core.$constructor<ZodMiniUUID>;
 export declare function uuid(params?: string | core.$ZodUUIDParams): ZodMiniUUID;
 export declare function uuidv4(params?: string | core.$ZodUUIDv4Params): ZodMiniUUID;
 export declare function uuidv6(params?: string | core.$ZodUUIDv6Params): ZodMiniUUID;
 export declare function uuidv7(params?: string | core.$ZodUUIDv7Params): ZodMiniUUID;
-export interface ZodMiniURL extends ZodMiniStringFormat<"url"> {
-    _zod: core.$ZodURLInternals;
+export interface ZodMiniURL extends _ZodMiniString<core.$ZodURLInternals> {
 }
 export declare const ZodMiniURL: core.$constructor<ZodMiniURL>;
 export declare function url(params?: string | core.$ZodURLParams): ZodMiniURL;
-export interface ZodMiniEmoji extends ZodMiniStringFormat<"emoji"> {
-    _zod: core.$ZodEmojiInternals;
+export interface ZodMiniEmoji extends _ZodMiniString<core.$ZodEmojiInternals> {
 }
 export declare const ZodMiniEmoji: core.$constructor<ZodMiniEmoji>;
 export declare function emoji(params?: string | core.$ZodEmojiParams): ZodMiniEmoji;
-export interface ZodMiniNanoID extends ZodMiniStringFormat<"nanoid"> {
-    _zod: core.$ZodNanoIDInternals;
+export interface ZodMiniNanoID extends _ZodMiniString<core.$ZodNanoIDInternals> {
 }
 export declare const ZodMiniNanoID: core.$constructor<ZodMiniNanoID>;
 export declare function nanoid(params?: string | core.$ZodNanoIDParams): ZodMiniNanoID;
-export interface ZodMiniCUID extends ZodMiniStringFormat<"cuid"> {
-    _zod: core.$ZodCUIDInternals;
+export interface ZodMiniCUID extends _ZodMiniString<core.$ZodCUIDInternals> {
 }
 export declare const ZodMiniCUID: core.$constructor<ZodMiniCUID>;
 export declare function cuid(params?: string | core.$ZodCUIDParams): ZodMiniCUID;
-export interface ZodMiniCUID2 extends ZodMiniStringFormat<"cuid2"> {
-    _zod: core.$ZodCUID2Internals;
+export interface ZodMiniCUID2 extends _ZodMiniString<core.$ZodCUID2Internals> {
 }
 export declare const ZodMiniCUID2: core.$constructor<ZodMiniCUID2>;
 export declare function cuid2(params?: string | core.$ZodCUID2Params): ZodMiniCUID2;
-export interface ZodMiniULID extends ZodMiniStringFormat<"ulid"> {
-    _zod: core.$ZodULIDInternals;
+export interface ZodMiniULID extends _ZodMiniString<core.$ZodULIDInternals> {
 }
 export declare const ZodMiniULID: core.$constructor<ZodMiniULID>;
 export declare function ulid(params?: string | core.$ZodULIDParams): ZodMiniULID;
-export interface ZodMiniXID extends ZodMiniStringFormat<"xid"> {
-    _zod: core.$ZodXIDInternals;
+export interface ZodMiniXID extends _ZodMiniString<core.$ZodXIDInternals> {
 }
 export declare const ZodMiniXID: core.$constructor<ZodMiniXID>;
 export declare function xid(params?: string | core.$ZodXIDParams): ZodMiniXID;
-export interface ZodMiniKSUID extends ZodMiniStringFormat<"ksuid"> {
-    _zod: core.$ZodKSUIDInternals;
+export interface ZodMiniKSUID extends _ZodMiniString<core.$ZodKSUIDInternals> {
 }
 export declare const ZodMiniKSUID: core.$constructor<ZodMiniKSUID>;
 export declare function ksuid(params?: string | core.$ZodKSUIDParams): ZodMiniKSUID;
-export interface ZodMiniIPv4 extends ZodMiniStringFormat<"ipv4"> {
-    _zod: core.$ZodIPv4Internals;
+export interface ZodMiniIPv4 extends _ZodMiniString<core.$ZodIPv4Internals> {
 }
 export declare const ZodMiniIPv4: core.$constructor<ZodMiniIPv4>;
 export declare function ipv4(params?: string | core.$ZodIPv4Params): ZodMiniIPv4;
-export interface ZodMiniIPv6 extends ZodMiniStringFormat<"ipv6"> {
-    _zod: core.$ZodIPv6Internals;
+export interface ZodMiniIPv6 extends _ZodMiniString<core.$ZodIPv6Internals> {
 }
 export declare const ZodMiniIPv6: core.$constructor<ZodMiniIPv6>;
 export declare function ipv6(params?: string | core.$ZodIPv6Params): ZodMiniIPv6;
-export interface ZodMiniCIDRv4 extends ZodMiniStringFormat<"cidrv4"> {
-    _zod: core.$ZodCIDRv4Internals;
+export interface ZodMiniCIDRv4 extends _ZodMiniString<core.$ZodCIDRv4Internals> {
 }
 export declare const ZodMiniCIDRv4: core.$constructor<ZodMiniCIDRv4>;
 export declare function cidrv4(params?: string | core.$ZodCIDRv4Params): ZodMiniCIDRv4;
-export interface ZodMiniCIDRv6 extends ZodMiniStringFormat<"cidrv6"> {
-    _zod: core.$ZodCIDRv6Internals;
+export interface ZodMiniCIDRv6 extends _ZodMiniString<core.$ZodCIDRv6Internals> {
 }
 export declare const ZodMiniCIDRv6: core.$constructor<ZodMiniCIDRv6>;
 export declare function cidrv6(params?: string | core.$ZodCIDRv6Params): ZodMiniCIDRv6;
-export interface ZodMiniBase64 extends ZodMiniStringFormat<"base64"> {
-    _zod: core.$ZodBase64Internals;
+export interface ZodMiniBase64 extends _ZodMiniString<core.$ZodBase64Internals> {
 }
 export declare const ZodMiniBase64: core.$constructor<ZodMiniBase64>;
 export declare function base64(params?: string | core.$ZodBase64Params): ZodMiniBase64;
-export interface ZodMiniBase64URL extends ZodMiniStringFormat<"base64url"> {
-    _zod: core.$ZodBase64URLInternals;
+export interface ZodMiniBase64URL extends _ZodMiniString<core.$ZodBase64URLInternals> {
 }
 export declare const ZodMiniBase64URL: core.$constructor<ZodMiniBase64URL>;
 export declare function base64url(params?: string | core.$ZodBase64URLParams): ZodMiniBase64URL;
-export interface ZodMiniE164 extends ZodMiniStringFormat<"e164"> {
-    _zod: core.$ZodE164Internals;
+export interface ZodMiniE164 extends _ZodMiniString<core.$ZodE164Internals> {
 }
 export declare const ZodMiniE164: core.$constructor<ZodMiniE164>;
 export declare function e164(params?: string | core.$ZodE164Params): ZodMiniE164;
-export interface ZodMiniJWT extends ZodMiniStringFormat<"jwt"> {
-    _zod: core.$ZodJWTInternals;
+export interface ZodMiniJWT extends _ZodMiniString<core.$ZodJWTInternals> {
 }
 export declare const ZodMiniJWT: core.$constructor<ZodMiniJWT>;
 export declare function jwt(params?: string | core.$ZodJWTParams): ZodMiniJWT;
-export interface ZodMiniNumber<Input = unknown> extends ZodMiniType {
-    _zod: core.$ZodNumberInternals<Input>;
+interface _ZodMiniNumber<T extends core.$ZodNumberInternals<unknown> = core.$ZodNumberInternals<unknown>> extends _ZodMiniType<T>, core.$ZodNumber<T["input"]> {
+    _zod: T;
+}
+export interface ZodMiniNumber<Input = unknown> extends _ZodMiniNumber<core.$ZodNumberInternals<Input>>, core.$ZodNumber<Input> {
 }
 export declare const ZodMiniNumber: core.$constructor<ZodMiniNumber>;
 export declare function number(params?: string | core.$ZodNumberParams): ZodMiniNumber<number>;
-export interface ZodMiniNumberFormat extends ZodMiniNumber {
-    _zod: core.$ZodNumberFormatInternals;
+export interface ZodMiniNumberFormat extends _ZodMiniNumber<core.$ZodNumberFormatInternals>, core.$ZodNumberFormat {
 }
 export declare const ZodMiniNumberFormat: core.$constructor<ZodMiniNumberFormat>;
 export declare function int(params?: string | core.$ZodCheckNumberFormatParams): ZodMiniNumberFormat;
@@ -137,62 +121,51 @@ export declare function float32(params?: string | core.$ZodCheckNumberFormatPara
 export declare function float64(params?: string | core.$ZodCheckNumberFormatParams): ZodMiniNumberFormat;
 export declare function int32(params?: string | core.$ZodCheckNumberFormatParams): ZodMiniNumberFormat;
 export declare function uint32(params?: string | core.$ZodCheckNumberFormatParams): ZodMiniNumberFormat;
-export interface ZodMiniBoolean<T = unknown> extends ZodMiniType {
-    _zod: core.$ZodBooleanInternals<T>;
+export interface ZodMiniBoolean<T = unknown> extends _ZodMiniType<core.$ZodBooleanInternals<T>> {
 }
 export declare const ZodMiniBoolean: core.$constructor<ZodMiniBoolean>;
 export declare function boolean(params?: string | core.$ZodBooleanParams): ZodMiniBoolean<boolean>;
-export interface ZodMiniBigInt<T = unknown> extends ZodMiniType {
-    _zod: core.$ZodBigIntInternals<T>;
+export interface ZodMiniBigInt<T = unknown> extends _ZodMiniType<core.$ZodBigIntInternals<T>>, core.$ZodBigInt<T> {
 }
 export declare const ZodMiniBigInt: core.$constructor<ZodMiniBigInt>;
 export declare function bigint(params?: string | core.$ZodBigIntParams): ZodMiniBigInt<bigint>;
-export interface ZodMiniBigIntFormat extends ZodMiniType {
-    _zod: core.$ZodBigIntFormatInternals;
+export interface ZodMiniBigIntFormat extends _ZodMiniType<core.$ZodBigIntFormatInternals> {
 }
 export declare const ZodMiniBigIntFormat: core.$constructor<ZodMiniBigIntFormat>;
 export declare function int64(params?: string | core.$ZodBigIntFormatParams): ZodMiniBigIntFormat;
 export declare function uint64(params?: string | core.$ZodBigIntFormatParams): ZodMiniBigIntFormat;
-export interface ZodMiniSymbol extends ZodMiniType {
-    _zod: core.$ZodSymbolInternals;
+export interface ZodMiniSymbol extends _ZodMiniType<core.$ZodSymbolInternals> {
 }
 export declare const ZodMiniSymbol: core.$constructor<ZodMiniSymbol>;
 export declare function symbol(params?: string | core.$ZodSymbolParams): ZodMiniSymbol;
-export interface ZodMiniUndefined extends ZodMiniType {
-    _zod: core.$ZodUndefinedInternals;
+export interface ZodMiniUndefined extends _ZodMiniType<core.$ZodUndefinedInternals> {
 }
 export declare const ZodMiniUndefined: core.$constructor<ZodMiniUndefined>;
 declare function _undefined(params?: string | core.$ZodUndefinedParams): ZodMiniUndefined;
 export { _undefined as undefined };
-export interface ZodMiniNull extends ZodMiniType {
-    _zod: core.$ZodNullInternals;
+export interface ZodMiniNull extends _ZodMiniType<core.$ZodNullInternals> {
 }
 export declare const ZodMiniNull: core.$constructor<ZodMiniNull>;
 declare function _null(params?: string | core.$ZodNullParams): ZodMiniNull;
 export { _null as null };
-export interface ZodMiniAny extends ZodMiniType {
-    _zod: core.$ZodAnyInternals;
+export interface ZodMiniAny extends _ZodMiniType<core.$ZodAnyInternals> {
 }
 export declare const ZodMiniAny: core.$constructor<ZodMiniAny>;
 export declare function any(): ZodMiniAny;
-export interface ZodMiniUnknown extends ZodMiniType {
-    _zod: core.$ZodUnknownInternals;
+export interface ZodMiniUnknown extends _ZodMiniType<core.$ZodUnknownInternals> {
 }
 export declare const ZodMiniUnknown: core.$constructor<ZodMiniUnknown>;
 export declare function unknown(): ZodMiniUnknown;
-export interface ZodMiniNever extends ZodMiniType {
-    _zod: core.$ZodNeverInternals;
+export interface ZodMiniNever extends _ZodMiniType<core.$ZodNeverInternals> {
 }
 export declare const ZodMiniNever: core.$constructor<ZodMiniNever>;
 export declare function never(params?: string | core.$ZodNeverParams): ZodMiniNever;
-export interface ZodMiniVoid extends ZodMiniType {
-    _zod: core.$ZodVoidInternals;
+export interface ZodMiniVoid extends _ZodMiniType<core.$ZodVoidInternals> {
 }
 export declare const ZodMiniVoid: core.$constructor<ZodMiniVoid>;
 declare function _void(params?: string | core.$ZodVoidParams): ZodMiniVoid;
 export { _void as void };
-export interface ZodMiniDate<T = unknown> extends ZodMiniType {
-    _zod: core.$ZodDateInternals<T>;
+export interface ZodMiniDate<T = unknown> extends _ZodMiniType<core.$ZodDateInternals<T>> {
 }
 export declare const ZodMiniDate: core.$constructor<ZodMiniDate>;
 export declare function date(params?: string | core.$ZodDateParams): ZodMiniDate<Date>;
@@ -232,8 +205,7 @@ 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 core.$ZodType[]> extends ZodMiniType {
-    _zod: core.$ZodUnionInternals<T>;
+export interface ZodMiniUnion<T extends readonly SomeType[] = readonly core.$ZodType[]> extends _ZodMiniType<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>;
@@ -242,36 +214,30 @@ export interface ZodMiniDiscriminatedUnion<Options extends readonly SomeType[] =
 }
 export declare const ZodMiniDiscriminatedUnion: core.$constructor<ZodMiniDiscriminatedUnion>;
 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 interface ZodMiniIntersection<A extends SomeType = core.$ZodType, B extends SomeType = core.$ZodType> extends _ZodMiniType<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 = readonly core.$ZodType[], Rest extends SomeType | null = core.$ZodType | null> extends ZodMiniType {
-    _zod: core.$ZodTupleInternals<T, Rest>;
+export interface ZodMiniTuple<T extends util.TupleItems = readonly core.$ZodType[], Rest extends SomeType | null = core.$ZodType | null> extends _ZodMiniType<core.$ZodTupleInternals<T, Rest>> {
 }
 export declare const ZodMiniTuple: core.$constructor<ZodMiniTuple>;
 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 = core.$ZodType> extends ZodMiniType {
-    _zod: core.$ZodRecordInternals<Key, Value>;
+export interface ZodMiniRecord<Key extends core.$ZodRecordKey = core.$ZodRecordKey, Value extends SomeType = core.$ZodType> extends _ZodMiniType<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 = core.$ZodType, Value extends SomeType = core.$ZodType> extends ZodMiniType {
-    _zod: core.$ZodMapInternals<Key, Value>;
+export interface ZodMiniMap<Key extends SomeType = core.$ZodType, Value extends SomeType = core.$ZodType> extends _ZodMiniType<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 = core.$ZodType> extends ZodMiniType {
-    _zod: core.$ZodSetInternals<T>;
+export interface ZodMiniSet<T extends SomeType = core.$ZodType> extends _ZodMiniType<core.$ZodSetInternals<T>> {
 }
 export declare const ZodMiniSet: core.$constructor<ZodMiniSet>;
 export declare function set<Value extends SomeType>(valueType: Value, params?: string | core.$ZodSetParams): ZodMiniSet<Value>;
-export interface ZodMiniEnum<T extends util.EnumLike = util.EnumLike> extends ZodMiniType {
-    _zod: core.$ZodEnumInternals<T>;
+export interface ZodMiniEnum<T extends util.EnumLike = util.EnumLike> extends _ZodMiniType<core.$ZodEnumInternals<T>> {
 }
 export declare const ZodMiniEnum: core.$constructor<ZodMiniEnum>;
 declare function _enum<const T extends readonly string[]>(values: T, params?: string | core.$ZodEnumParams): ZodMiniEnum<util.ToEnum<T[number]>>;
@@ -285,92 +251,75 @@ export { _enum as enum };
  * ```
  */
 export declare function nativeEnum<T extends util.EnumLike>(entries: T, params?: string | core.$ZodEnumParams): ZodMiniEnum<T>;
-export interface ZodMiniLiteral<T extends util.Primitive = util.Primitive> extends ZodMiniType {
-    _zod: core.$ZodLiteralInternals<T>;
+export interface ZodMiniLiteral<T extends util.Primitive = util.Primitive> extends _ZodMiniType<core.$ZodLiteralInternals<T>> {
 }
 export declare const ZodMiniLiteral: core.$constructor<ZodMiniLiteral>;
-export declare function literal<const T extends Array<util.Literal>>(value: T, params?: string | core.$ZodLiteralParams): ZodMiniLiteral<T[number]>;
+export declare function literal<const T extends ReadonlyArray<util.Literal>>(value: T, params?: string | core.$ZodLiteralParams): ZodMiniLiteral<T[number]>;
 export declare function literal<const T extends util.Literal>(value: T, params?: string | core.$ZodLiteralParams): ZodMiniLiteral<T>;
-export interface ZodMiniFile extends ZodMiniType {
-    _zod: core.$ZodFileInternals;
+export interface ZodMiniFile extends _ZodMiniType<core.$ZodFileInternals> {
 }
 export declare const ZodMiniFile: core.$constructor<ZodMiniFile>;
 export declare function file(params?: string | core.$ZodFileParams): ZodMiniFile;
-export interface ZodMiniTransform<O = unknown, I = unknown> extends ZodMiniType {
-    _zod: core.$ZodTransformInternals<O, I>;
+export interface ZodMiniTransform<O = unknown, I = unknown> extends _ZodMiniType<core.$ZodTransformInternals<O, I>> {
 }
 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 = core.$ZodType> extends ZodMiniType {
-    _zod: core.$ZodOptionalInternals<T>;
+export interface ZodMiniOptional<T extends SomeType = core.$ZodType> extends _ZodMiniType<core.$ZodOptionalInternals<T>>, core.$ZodOptional<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 = core.$ZodType> extends ZodMiniType {
-    _zod: core.$ZodNullableInternals<T>;
+export interface ZodMiniNullable<T extends SomeType = core.$ZodType> extends _ZodMiniType<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 = core.$ZodType> extends ZodMiniType {
-    _zod: core.$ZodDefaultInternals<T>;
+export interface ZodMiniDefault<T extends SomeType = core.$ZodType> extends _ZodMiniType<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 = core.$ZodType> extends ZodMiniType {
-    _zod: core.$ZodPrefaultInternals<T>;
+export interface ZodMiniPrefault<T extends SomeType = core.$ZodType> extends _ZodMiniType<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 = core.$ZodType> extends ZodMiniType {
-    _zod: core.$ZodNonOptionalInternals<T>;
+export interface ZodMiniNonOptional<T extends SomeType = core.$ZodType> extends _ZodMiniType<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 = core.$ZodType> extends ZodMiniType {
-    _zod: core.$ZodSuccessInternals<T>;
+export interface ZodMiniSuccess<T extends SomeType = core.$ZodType> extends _ZodMiniType<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 = core.$ZodType> extends ZodMiniType {
-    _zod: core.$ZodCatchInternals<T>;
+export interface ZodMiniCatch<T extends SomeType = core.$ZodType> extends _ZodMiniType<core.$ZodCatchInternals<T>> {
 }
 export declare const ZodMiniCatch: core.$constructor<ZodMiniCatch>;
 declare function _catch<T extends SomeType>(innerType: T, catchValue: core.output<T> | ((ctx: core.$ZodCatchCtx) => core.output<T>)): ZodMiniCatch<T>;
 export { _catch as catch };
-export interface ZodMiniNaN extends ZodMiniType {
-    _zod: core.$ZodNaNInternals;
+export interface ZodMiniNaN extends _ZodMiniType<core.$ZodNaNInternals> {
 }
 export declare const ZodMiniNaN: core.$constructor<ZodMiniNaN>;
 export declare function nan(params?: string | core.$ZodNaNParams): ZodMiniNaN;
-export interface ZodMiniPipe<A extends SomeType = core.$ZodType, B extends SomeType = core.$ZodType> extends ZodMiniType {
-    _zod: core.$ZodPipeInternals<A, B>;
+export interface ZodMiniPipe<A extends SomeType = core.$ZodType, B extends SomeType = core.$ZodType> extends _ZodMiniType<core.$ZodPipeInternals<A, B>> {
 }
 export declare const ZodMiniPipe: core.$constructor<ZodMiniPipe>;
 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 interface ZodMiniReadonly<T extends SomeType = core.$ZodType> extends _ZodMiniType<core.$ZodReadonlyInternals<T>> {
 }
 export declare const ZodMiniReadonly: core.$constructor<ZodMiniReadonly>;
 export declare function readonly<T extends SomeType>(innerType: T): ZodMiniReadonly<T>;
-export interface ZodMiniTemplateLiteral<Template extends string = string> extends ZodMiniType {
-    _zod: core.$ZodTemplateLiteralInternals<Template>;
+export interface ZodMiniTemplateLiteral<Template extends string = string> extends _ZodMiniType<core.$ZodTemplateLiteralInternals<Template>> {
 }
 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 = core.$ZodType> extends ZodMiniType {
-    _zod: core.$ZodLazyInternals<T>;
+export interface ZodMiniLazy<T extends SomeType = core.$ZodType> extends _ZodMiniType<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 = core.$ZodType> extends ZodMiniType {
-    _zod: core.$ZodPromiseInternals<T>;
+export interface ZodMiniPromise<T extends SomeType = core.$ZodType> extends _ZodMiniType<core.$ZodPromiseInternals<T>> {
 }
 export declare const ZodMiniPromise: core.$constructor<ZodMiniPromise>;
 export declare function promise<T extends SomeType>(innerType: T): ZodMiniPromise<T>;
-export interface ZodMiniCustom<O = unknown, I = unknown> extends ZodMiniType {
-    _zod: core.$ZodCustomInternals<O, I>;
+export interface ZodMiniCustom<O = unknown, I = unknown> extends _ZodMiniType<core.$ZodCustomInternals<O, I>> {
 }
 export declare const ZodMiniCustom: core.$constructor<ZodMiniCustom>;
 export declare function check<O = unknown>(fn: core.CheckFn<O>, params?: string | core.$ZodCustomParams): core.$ZodCheck<O>;
@@ -381,18 +330,21 @@ declare abstract class Class {
 }
 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 = ZodMiniUnion<[
+export declare const stringbool: (_params?: string | core.$ZodStringBoolParams) => ZodMiniPipe<ZodMiniPipe<ZodMiniString, ZodMiniTransform<boolean, string>>, ZodMiniBoolean>;
+type _ZodMiniJSONSchema = ZodMiniUnion<[
     ZodMiniString,
     ZodMiniNumber,
     ZodMiniBoolean,
     ZodMiniNull,
     ZodMiniArray<ZodMiniJSONSchema>,
     ZodMiniRecord<ZodMiniString<string>, ZodMiniJSONSchema>
-]> & {
-    _zod: {
-        input: util.JSONType;
-        output: util.JSONType;
-    };
-};
+]>;
+type _ZodMiniJSONSchemaInternals = _ZodMiniJSONSchema["_zod"];
+export interface ZodMiniJSONSchemaInternals extends _ZodMiniJSONSchemaInternals {
+    output: util.JSONType;
+    input: util.JSONType;
+}
+export interface ZodMiniJSONSchema extends _ZodMiniJSONSchema {
+    _zod: ZodMiniJSONSchemaInternals;
+}
 export declare function json(): ZodMiniJSONSchema;

package/compiled/zod/index.js

@@ -2,7 +2,7 @@
 /******/ 	"use strict";
 /******/ 	var __webpack_modules__ = ({
 
-/***/ 508:
+/***/ 684:
 /***/ (function(__unused_webpack_module, exports, __nccwpck_require__) {
 
 
@@ -24,20 +24,20 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", ({ value: true }));
-const index_js_1 = __importDefault(__nccwpck_require__(854));
-__exportStar(__nccwpck_require__(854), exports);
+const index_js_1 = __importDefault(__nccwpck_require__(750));
+__exportStar(__nccwpck_require__(750), exports);
 exports["default"] = index_js_1.default;
 
 
 /***/ }),
 
-/***/ 581:
+/***/ 757:
 /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => {
 
 
 Object.defineProperty(exports, "__esModule", ({ value: true }));
 exports.ZodError = exports.quotelessJson = exports.ZodIssueCode = void 0;
-const util_js_1 = __nccwpck_require__(378);
+const util_js_1 = __nccwpck_require__(426);
 exports.ZodIssueCode = util_js_1.util.arrayToEnum([
     "invalid_type",
     "invalid_literal",
@@ -175,7 +175,7 @@ ZodError.create = (issues) => {
 
 /***/ }),
 
-/***/ 947:
+/***/ 995:
 /***/ (function(__unused_webpack_module, exports, __nccwpck_require__) {
 
 
@@ -186,7 +186,7 @@ Object.defineProperty(exports, "__esModule", ({ value: true }));
 exports.defaultErrorMap = void 0;
 exports.setErrorMap = setErrorMap;
 exports.getErrorMap = getErrorMap;
-const en_js_1 = __importDefault(__nccwpck_require__(299));
+const en_js_1 = __importDefault(__nccwpck_require__(947));
 exports.defaultErrorMap = en_js_1.default;
 let overrideErrorMap = en_js_1.default;
 function setErrorMap(map) {
@@ -199,7 +199,7 @@ function getErrorMap() {
 
 /***/ }),
 
-/***/ 11:
+/***/ 979:
 /***/ (function(__unused_webpack_module, exports, __nccwpck_require__) {
 
 
@@ -218,17 +218,17 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", ({ value: true }));
-__exportStar(__nccwpck_require__(947), exports);
-__exportStar(__nccwpck_require__(727), exports);
-__exportStar(__nccwpck_require__(444), exports);
-__exportStar(__nccwpck_require__(378), exports);
-__exportStar(__nccwpck_require__(523), exports);
-__exportStar(__nccwpck_require__(581), exports);
+__exportStar(__nccwpck_require__(995), exports);
+__exportStar(__nccwpck_require__(335), exports);
+__exportStar(__nccwpck_require__(404), exports);
+__exportStar(__nccwpck_require__(426), exports);
+__exportStar(__nccwpck_require__(227), exports);
+__exportStar(__nccwpck_require__(757), exports);
 
 
 /***/ }),
 
-/***/ 814:
+/***/ 54:
 /***/ ((__unused_webpack_module, exports) => {
 
 
@@ -244,7 +244,7 @@ var errorUtil;
 
 /***/ }),
 
-/***/ 727:
+/***/ 335:
 /***/ (function(__unused_webpack_module, exports, __nccwpck_require__) {
 
 
@@ -254,8 +254,8 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", ({ value: true }));
 exports.isAsync = exports.isValid = exports.isDirty = exports.isAborted = exports.OK = exports.DIRTY = exports.INVALID = exports.ParseStatus = exports.EMPTY_PATH = exports.makeIssue = void 0;
 exports.addIssueToContext = addIssueToContext;
-const errors_js_1 = __nccwpck_require__(947);
-const en_js_1 = __importDefault(__nccwpck_require__(299));
+const errors_js_1 = __nccwpck_require__(995);
+const en_js_1 = __importDefault(__nccwpck_require__(947));
 const makeIssue = (params) => {
     const { data, path, errorMaps, issueData } = params;
     const fullPath = [...path, ...(issueData.path || [])];
@@ -375,7 +375,7 @@ exports.isAsync = isAsync;
 
 /***/ }),
 
-/***/ 444:
+/***/ 404:
 /***/ ((__unused_webpack_module, exports) => {
 
 
@@ -384,7 +384,7 @@ Object.defineProperty(exports, "__esModule", ({ value: true }));
 
 /***/ }),
 
-/***/ 378:
+/***/ 426:
 /***/ ((__unused_webpack_module, exports) => {
 
 
@@ -528,7 +528,7 @@ exports.getParsedType = getParsedType;
 
 /***/ }),
 
-/***/ 854:
+/***/ 750:
 /***/ (function(__unused_webpack_module, exports, __nccwpck_require__) {
 
 
@@ -560,21 +560,21 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 };
 Object.defineProperty(exports, "__esModule", ({ value: true }));
 exports.z = void 0;
-const z = __importStar(__nccwpck_require__(11));
+const z = __importStar(__nccwpck_require__(979));
 exports.z = z;
-__exportStar(__nccwpck_require__(11), exports);
+__exportStar(__nccwpck_require__(979), exports);
 exports["default"] = z;
 
 
 /***/ }),
 
-/***/ 299:
+/***/ 947:
 /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => {
 
 
 Object.defineProperty(exports, "__esModule", ({ value: true }));
-const ZodError_js_1 = __nccwpck_require__(581);
-const util_js_1 = __nccwpck_require__(378);
+const ZodError_js_1 = __nccwpck_require__(757);
+const util_js_1 = __nccwpck_require__(426);
 const errorMap = (issue, _ctx) => {
     let message;
     switch (issue.code) {
@@ -684,7 +684,7 @@ exports["default"] = errorMap;
 
 /***/ }),
 
-/***/ 523:
+/***/ 227:
 /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => {
 
 
@@ -693,11 +693,11 @@ exports.discriminatedUnion = exports.date = exports.boolean = exports.bigint = e
 exports.NEVER = exports["void"] = exports.unknown = exports.union = exports.undefined = exports.tuple = exports.transformer = exports.symbol = exports.string = exports.strictObject = exports.set = exports.record = exports.promise = exports.preprocess = exports.pipeline = exports.ostring = exports.optional = exports.onumber = exports.oboolean = exports.object = exports.number = exports.nullable = exports["null"] = exports.never = exports.nativeEnum = exports.nan = exports.map = exports.literal = exports.lazy = exports.intersection = exports["instanceof"] = exports["function"] = exports["enum"] = exports.effect = void 0;
 exports.datetimeRegex = datetimeRegex;
 exports.custom = custom;
-const ZodError_js_1 = __nccwpck_require__(581);
-const errors_js_1 = __nccwpck_require__(947);
-const errorUtil_js_1 = __nccwpck_require__(814);
-const parseUtil_js_1 = __nccwpck_require__(727);
-const util_js_1 = __nccwpck_require__(378);
+const ZodError_js_1 = __nccwpck_require__(757);
+const errors_js_1 = __nccwpck_require__(995);
+const errorUtil_js_1 = __nccwpck_require__(54);
+const parseUtil_js_1 = __nccwpck_require__(335);
+const util_js_1 = __nccwpck_require__(426);
 class ParseInputLazyPath {
     constructor(parent, value, path, key) {
         this._cachedPath = [];
@@ -4506,7 +4506,7 @@ exports.NEVER = parseUtil_js_1.INVALID;
 /******/ 	// startup
 /******/ 	// Load entry module and return exports
 /******/ 	// This entry module is referenced by other modules so it can't be inlined
-/******/ 	var __webpack_exports__ = __nccwpck_require__(508);
+/******/ 	var __webpack_exports__ = __nccwpck_require__(684);
 /******/ 	module.exports = __webpack_exports__;
 /******/ 	
 /******/ })()

package/compiled/zod/package.json

@@ -1 +1 @@
-{"name":"zod","author":"Colin McDonnell <zod@colinhacks.com>","version":"3.25.50","funding":"https://github.com/sponsors/colinhacks","license":"MIT","types":"./dist/types/index.d.ts","type":"commonjs"}
+{"name":"zod","author":"Colin McDonnell <zod@colinhacks.com>","version":"3.25.58","funding":"https://github.com/sponsors/colinhacks","license":"MIT","types":"./dist/types/index.d.ts","type":"commonjs"}

package/dist/BuildInfo.d.ts

@@ -0,0 +1,17 @@
+import * as binding from "@rspack/binding";
+import type { Source } from "../compiled/webpack-sources";
+declare const $assets: unique symbol;
+declare module "@rspack/binding" {
+    interface Assets {
+        [$assets]: Record<string, Source>;
+    }
+    interface KnownBuildInfo {
+        assets: Record<string, Source>;
+        fileDependencies: Set<string>;
+        contextDependencies: Set<string>;
+        missingDependencies: Set<string>;
+        buildDependencies: Set<string>;
+    }
+}
+export type { BuildInfo } from "@rspack/binding";
+export declare const commitCustomFieldsToRust: (buildInfo: binding.BuildInfo) => void;