zod 3.25.49 → 3.25.50

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

@@ -1,22 +1,23 @@
 import * as core from "zod/v4/core";
 import { util } from "zod/v4/core";
-type SomeType = core.$ZodType;
-export interface ZodMiniType<out Output = unknown, out Input = unknown> extends core.$ZodType<Output, Input> {
+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?: this["_zod"]["def"], params?: {
+    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>;
@@ -195,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>;
@@ -233,40 +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 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 = SomeType, B extends SomeType = SomeType> extends ZodMiniType {
+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>;
@@ -302,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>;
@@ -344,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>;
@@ -359,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>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "zod",
-  "version": "3.25.49",
+  "version": "3.25.50",
   "type": "module",
   "author": "Colin McDonnell <zod@colinhacks.com>",
   "description": "TypeScript-first schema declaration and validation library with static type inference",