@rspack/core 1.3.13 → 1.3.15

package/compiled/zod/dist/types/v4/core/core.d.ts

@@ -20,16 +20,20 @@ export type $brand<T extends string | number | symbol = string | number | symbol
         [k in T]: true;
     };
 };
-export type $ZodBranded<T extends schemas.$ZodType, Brand extends string | number | symbol> = T & Record<"_zod", Record<"~output", output<T> & $brand<Brand>>>;
+export type $ZodBranded<T extends schemas._$ZodType, Brand extends string | number | symbol> = T & Record<"_zod", Record<"output", output<T> & $brand<Brand>>>;
 export declare class $ZodAsyncError extends Error {
     constructor();
 }
-export type input<T extends schemas.$ZodType> = T["_zod"] extends {
-    "~input": any;
-} ? T["_zod"]["~input"] : T["_zod"]["input"];
-export type output<T extends schemas.$ZodType> = T["_zod"] extends {
-    "~output": any;
-} ? T["_zod"]["~output"] : T["_zod"]["output"];
+export type input<T> = T extends {
+    _zod: {
+        input: any;
+    };
+} ? Required<T["_zod"]>["input"] : unknown;
+export type output<T> = T extends {
+    _zod: {
+        output: any;
+    };
+} ? Required<T["_zod"]>["output"] : unknown;
 export type { output as infer };
 export interface $ZodConfig {
     /** Custom error map. Overrides `config().localeError`. */

package/compiled/zod/dist/types/v4/core/errors.d.ts

@@ -132,7 +132,6 @@ type _FlattenedError<T, U = string> = {
         [P in keyof T]?: U[];
     };
 };
-/** @deprecated Use `z.treeifyError()` instead. */
 export declare function flattenError<T>(error: $ZodError<T>): _FlattenedError<T>;
 export declare function flattenError<T, U>(error: $ZodError<T>, mapper?: (issue: $ZodIssue) => U): _FlattenedError<T, U>;
 type _ZodFormattedError<T, U = string> = T extends [any, ...any[]] ? {

package/compiled/zod/dist/types/v4/core/function.d.ts

@@ -1,3 +1,4 @@
+import type * as core from "./core.js";
 import * as schemas from "./schemas.js";
 import { $ZodTuple } from "./schemas.js";
 import type * as util from "./util.js";
@@ -7,12 +8,12 @@ export interface $ZodFunctionDef<In extends $ZodFunctionIn = $ZodFunctionIn, Out
     output: Out;
 }
 export type $ZodFunctionArgs = schemas.$ZodType<unknown[], unknown[]>;
-export type $ZodFunctionIn = $ZodFunctionArgs | null;
-export type $ZodFunctionOut = schemas.$ZodType | null;
-export type $InferInnerFunctionType<Args extends $ZodFunctionIn, Returns extends $ZodFunctionOut> = (...args: null extends Args ? never[] : NonNullable<Args>["_zod"]["output"]) => null extends Returns ? unknown : NonNullable<Returns>["_zod"]["input"];
-export type $InferInnerFunctionTypeAsync<Args extends $ZodFunctionIn, Returns extends $ZodFunctionOut> = (...args: null extends Args ? never[] : NonNullable<Args>["_zod"]["output"]) => null extends Returns ? unknown : util.MaybeAsync<NonNullable<Returns>["_zod"]["input"]>;
-export type $InferOuterFunctionType<Args extends $ZodFunctionIn, Returns extends $ZodFunctionOut> = (...args: null extends Args ? never[] : NonNullable<Args>["_zod"]["input"]) => null extends Returns ? unknown : NonNullable<Returns>["_zod"]["output"];
-export type $InferOuterFunctionTypeAsync<Args extends $ZodFunctionIn, Returns extends $ZodFunctionOut> = (...args: null extends Args ? never[] : NonNullable<Args>["_zod"]["input"]) => null extends Returns ? unknown : util.MaybeAsync<NonNullable<Returns>["_zod"]["output"]>;
+export type $ZodFunctionIn = $ZodFunctionArgs;
+export type $ZodFunctionOut = schemas.$ZodType;
+export type $InferInnerFunctionType<Args extends $ZodFunctionIn, Returns extends $ZodFunctionOut> = (...args: $ZodFunctionIn extends Args ? never[] : core.output<Args>) => core.input<Returns>;
+export type $InferInnerFunctionTypeAsync<Args extends $ZodFunctionIn, Returns extends $ZodFunctionOut> = (...args: $ZodFunctionIn extends Args ? never[] : core.output<Args>) => util.MaybeAsync<core.input<Returns>>;
+export type $InferOuterFunctionType<Args extends $ZodFunctionIn, Returns extends $ZodFunctionOut> = (...args: $ZodFunctionIn extends Args ? never[] : core.input<Args>) => core.output<Returns>;
+export type $InferOuterFunctionTypeAsync<Args extends $ZodFunctionIn, Returns extends $ZodFunctionOut> = (...args: $ZodFunctionIn extends Args ? never[] : core.input<Args>) => util.MaybeAsync<core.output<Returns>>;
 export declare class $ZodFunction<Args extends $ZodFunctionIn = $ZodFunctionIn, Returns extends $ZodFunctionOut = $ZodFunctionOut> {
     def: $ZodFunctionDef<Args, Returns>;
     /** @deprecated */
@@ -20,9 +21,9 @@ export declare class $ZodFunction<Args extends $ZodFunctionIn = $ZodFunctionIn,
     _input: $InferInnerFunctionType<Args, Returns>;
     _output: $InferOuterFunctionType<Args, Returns>;
     constructor(def: $ZodFunctionDef<Args, Returns>);
-    implement<F extends $InferInnerFunctionType<Args, Returns>>(func: F): F extends this["_output"] ? F : this["_output"];
+    implement<F extends $InferInnerFunctionType<Args, Returns>>(func: F): (...args: Parameters<this["_output"]>) => ReturnType<F> extends ReturnType<this["_output"]> ? ReturnType<F> : ReturnType<this["_output"]>;
     implementAsync<F extends $InferInnerFunctionTypeAsync<Args, Returns>>(func: F): F extends $InferOuterFunctionTypeAsync<Args, Returns> ? F : $InferOuterFunctionTypeAsync<Args, Returns>;
-    input<const Items extends util.TupleItems, const Rest extends $ZodFunctionOut = null>(args: Items, rest?: Rest): $ZodFunction<schemas.$ZodTuple<Items, Rest>, Returns>;
+    input<const Items extends util.TupleItems, const Rest extends $ZodFunctionOut = $ZodFunctionOut>(args: Items, rest?: Rest): $ZodFunction<schemas.$ZodTuple<Items, Rest>, Returns>;
     input<NewArgs extends $ZodFunctionIn>(args: NewArgs): $ZodFunction<NewArgs, Returns>;
     output<NewReturns extends schemas.$ZodType>(output: NewReturns): $ZodFunction<Args, NewReturns>;
 }
@@ -33,13 +34,17 @@ export interface $ZodFunctionParams<I extends $ZodFunctionIn, O extends schemas.
 declare function _function(): $ZodFunction;
 declare function _function<const In extends Array<schemas.$ZodType> = Array<schemas.$ZodType>>(params: {
     input: In;
-}): $ZodFunction<$ZodTuple<In, null>, null>;
+}): $ZodFunction<$ZodTuple<In, null>, $ZodFunctionOut>;
+declare function _function<const In extends Array<schemas.$ZodType> = Array<schemas.$ZodType>, const Out extends $ZodFunctionOut = $ZodFunctionOut>(params: {
+    input: In;
+    output: Out;
+}): $ZodFunction<$ZodTuple<In, null>, Out>;
 declare function _function<const In extends $ZodFunctionIn = $ZodFunctionIn>(params: {
     input: In;
-}): $ZodFunction<In, null>;
+}): $ZodFunction<In, $ZodFunctionOut>;
 declare function _function<const Out extends $ZodFunctionOut = $ZodFunctionOut>(params: {
     output: Out;
-}): $ZodFunction<null, Out>;
+}): $ZodFunction<$ZodFunctionIn, Out>;
 declare function _function<In extends $ZodFunctionIn = $ZodFunctionIn, Out extends schemas.$ZodType = schemas.$ZodType>(params?: {
     input: In;
     output: Out;

package/compiled/zod/dist/types/v4/core/regexes.d.ts

@@ -32,7 +32,6 @@ export declare const ipv4: RegExp;
 export declare const ipv6: RegExp;
 export declare const cidrv4: RegExp;
 export declare const cidrv6: RegExp;
-export declare const ip: RegExp;
 export declare const base64: RegExp;
 export declare const base64url: RegExp;
 export declare const hostname: RegExp;

package/compiled/zod/dist/types/v4/core/registries.d.ts

@@ -22,7 +22,12 @@ export interface JSONSchemaMeta {
     id?: string | undefined;
     title?: string | undefined;
     description?: string | undefined;
-    examples?: $output[] | undefined;
+    example?: unknown | undefined;
+    examples?: unknown[] | Record<string, {
+        value: unknown;
+        [k: string]: unknown;
+    }> | undefined;
+    deprecated?: boolean | undefined;
     [k: string]: unknown;
 }
 export interface GlobalMeta extends JSONSchemaMeta {