storybook 10.0.0-beta.1 → 10.0.0-beta.11

package/dist/bin/dispatcher.js

@@ -1,31 +1,31 @@
 #!/usr/bin/env node
-import CJS_COMPAT_NODE_URL_nodb7gfupnb from 'node:url';
-import CJS_COMPAT_NODE_PATH_nodb7gfupnb from 'node:path';
-import CJS_COMPAT_NODE_MODULE_nodb7gfupnb from "node:module";
+import CJS_COMPAT_NODE_URL_91hxho9jtpf from 'node:url';
+import CJS_COMPAT_NODE_PATH_91hxho9jtpf from 'node:path';
+import CJS_COMPAT_NODE_MODULE_91hxho9jtpf from "node:module";
 
-var __filename = CJS_COMPAT_NODE_URL_nodb7gfupnb.fileURLToPath(import.meta.url);
-var __dirname = CJS_COMPAT_NODE_PATH_nodb7gfupnb.dirname(__filename);
-var require = CJS_COMPAT_NODE_MODULE_nodb7gfupnb.createRequire(import.meta.url);
+var __filename = CJS_COMPAT_NODE_URL_91hxho9jtpf.fileURLToPath(import.meta.url);
+var __dirname = CJS_COMPAT_NODE_PATH_91hxho9jtpf.dirname(__filename);
+var require = CJS_COMPAT_NODE_MODULE_91hxho9jtpf.createRequire(import.meta.url);
 
 // ------------------------------------------------------------
 // end of CJS compatibility banner, injected by Storybook's esbuild configuration
 // ------------------------------------------------------------
 import {
   versions_default
-} from "../_node-chunks/chunk-GE6I3YYG.js";
+} from "../_node-chunks/chunk-YAEIMHFX.js";
 import {
   resolvePackageDir
-} from "../_node-chunks/chunk-32JYCD74.js";
+} from "../_node-chunks/chunk-7QAAJL75.js";
 import {
   join
-} from "../_node-chunks/chunk-ICPKUV5G.js";
+} from "../_node-chunks/chunk-U2UIPLJI.js";
 import {
   require_dist
-} from "../_node-chunks/chunk-WDKWVNL2.js";
+} from "../_node-chunks/chunk-EBLOP2C5.js";
 import {
   __name,
   __toESM
-} from "../_node-chunks/chunk-SUMFFLGF.js";
+} from "../_node-chunks/chunk-Q5IJJX3T.js";
 
 // src/bin/dispatcher.ts
 import { spawn } from "node:child_process";

package/dist/bin/loader.js

@@ -1,42 +1,107 @@
-import CJS_COMPAT_NODE_URL_nodb7gfupnb from 'node:url';
-import CJS_COMPAT_NODE_PATH_nodb7gfupnb from 'node:path';
-import CJS_COMPAT_NODE_MODULE_nodb7gfupnb from "node:module";
+import CJS_COMPAT_NODE_URL_91hxho9jtpf from 'node:url';
+import CJS_COMPAT_NODE_PATH_91hxho9jtpf from 'node:path';
+import CJS_COMPAT_NODE_MODULE_91hxho9jtpf from "node:module";
 
-var __filename = CJS_COMPAT_NODE_URL_nodb7gfupnb.fileURLToPath(import.meta.url);
-var __dirname = CJS_COMPAT_NODE_PATH_nodb7gfupnb.dirname(__filename);
-var require = CJS_COMPAT_NODE_MODULE_nodb7gfupnb.createRequire(import.meta.url);
+var __filename = CJS_COMPAT_NODE_URL_91hxho9jtpf.fileURLToPath(import.meta.url);
+var __dirname = CJS_COMPAT_NODE_PATH_91hxho9jtpf.dirname(__filename);
+var require = CJS_COMPAT_NODE_MODULE_91hxho9jtpf.createRequire(import.meta.url);
 
 // ------------------------------------------------------------
 // end of CJS compatibility banner, injected by Storybook's esbuild configuration
 // ------------------------------------------------------------
 import {
   NODE_TARGET
-} from "../_node-chunks/chunk-VNLBDN2Z.js";
+} from "../_node-chunks/chunk-SGJZDMJW.js";
 import {
-  __name
-} from "../_node-chunks/chunk-SUMFFLGF.js";
+  require_dist
+} from "../_node-chunks/chunk-EBLOP2C5.js";
+import {
+  __name,
+  __toESM
+} from "../_node-chunks/chunk-Q5IJJX3T.js";
 
 // src/bin/loader.ts
+var import_ts_dedent = __toESM(require_dist(), 1);
+import { existsSync } from "node:fs";
 import { readFile } from "node:fs/promises";
+import * as path from "node:path";
 import { fileURLToPath } from "node:url";
+import { deprecate } from "storybook/internal/node-logger";
 import { transform } from "esbuild";
+var supportedExtensions = [
+  ".js",
+  ".mjs",
+  ".cjs",
+  ".jsx",
+  ".ts",
+  ".mts",
+  ".cts",
+  ".tsx"
+];
+function resolveWithExtension(importPath, currentFilePath) {
+  if (path.extname(importPath)) {
+    return importPath;
+  }
+  deprecate(import_ts_dedent.dedent`One or more extensionless imports detected: "${importPath}" in file "${currentFilePath}".
+    For maximum compatibility, you should add an explicit file extension to this import.
+    Storybook will attempt to resolve it automatically, but this may change in the future.
+    If adding the extension results in an error from TypeScript, we recommend setting moduleResolution to "bundler" in tsconfig.json
+    or alternatively look into the allowImportingTsExtensions option.`);
+  const currentDir = path.dirname(currentFilePath);
+  const absolutePath = path.resolve(currentDir, importPath);
+  for (const ext of supportedExtensions) {
+    const candidatePath = `${absolutePath}${ext}`;
+    if (existsSync(candidatePath)) {
+      return `${importPath}${ext}`;
+    }
+  }
+  return importPath;
+}
+__name(resolveWithExtension, "resolveWithExtension");
+function addExtensionsToRelativeImports(source, filePath) {
+  const patterns = [
+    // import/export ... from './path' or "../path" (including side-effect imports)
+    /(\b(?:import|export)\s+(?:[^'"]*?\s+from\s+)?['"])(\.[^'"]+)(['"])/g,
+    // import('./path') or import("../path") - dynamic imports with quotes (with closing paren, no concatenation)
+    /(\bimport\s*\(\s*['"])(\.[^'"]+)(['"]\s*\))/g,
+    // import(`./path`) - dynamic imports with backticks (with closing paren, no template interpolation)
+    /(\bimport\s*\(\s*`)(\.[^`$]+)(`\s*\))/g
+  ];
+  let result = source;
+  for (const pattern of patterns) {
+    result = result.replace(pattern, (match, prefix, path2, suffix) => {
+      if (path2.startsWith("./") || path2.startsWith("../")) {
+        const resolvedPath = resolveWithExtension(path2, filePath);
+        return `${prefix}${resolvedPath}${suffix}`;
+      }
+      return match;
+    });
+  }
+  return result;
+}
+__name(addExtensionsToRelativeImports, "addExtensionsToRelativeImports");
 var load = /* @__PURE__ */ __name(async (url, context, nextLoad) => {
   if (url.endsWith(".ts") || url.endsWith(".tsx") || url.endsWith(".mts") || url.endsWith(".cts") || url.endsWith(".mtsx") || url.endsWith(".ctsx")) {
-    const rawSource = await readFile(fileURLToPath(url), "utf-8");
+    const filePath = fileURLToPath(url);
+    const rawSource = await readFile(filePath, "utf-8");
     const transformedSource = await transform(rawSource, {
       loader: "ts",
       target: NODE_TARGET,
       format: "esm",
       platform: "neutral"
     });
+    const sourceWithExtensions = addExtensionsToRelativeImports(transformedSource.code, filePath);
     return {
       format: "module",
       shortCircuit: true,
-      source: transformedSource.code
+      source: sourceWithExtensions
     };
   }
   return nextLoad(url, context);
 }, "load");
 export {
-  load
+  addExtensionsToRelativeImports,
+  load,
+  resolveWithExtension,
+  supportedExtensions
 };

package/dist/cli/index.d.ts

@@ -891,7 +891,7 @@ declare abstract class JsPackageManager {
 type NpmOptions = Parameters<JsPackageManager['addDependencies']>[0];
 
 declare const SUPPORTED_ESLINT_EXTENSIONS: string[];
-declare const findEslintFile: (instanceDir: string) => Promise<string | undefined>;
+declare const findEslintFile: (instanceDir: string) => string | undefined;
 declare const configureFlatConfig: (code: string) => Promise<string>;
 declare function extractEslintInfo(packageManager: JsPackageManager$1): Promise<{
     hasEslint: boolean;
@@ -913,13 +913,16 @@ type Primitive = string | number | symbol | bigint | boolean | null | undefined;
 declare namespace util {
     type AssertEqual<T, U> = (<V>() => V extends T ? 1 : 2) extends <V>() => V extends U ? 1 : 2 ? true : false;
     export type isAny<T> = 0 extends 1 & T ? true : false;
-    export const assertEqual: <A, B>(val: AssertEqual<A, B>) => AssertEqual<A, B>;
+    export const assertEqual: <A, B>(_: AssertEqual<A, B>) => void;
     export function assertIs<T>(_arg: T): void;
     export function assertNever(_x: never): never;
     export type Omit<T, K extends keyof T> = Pick<T, Exclude<keyof T, K>>;
     export type OmitKeys<T, K extends string> = Pick<T, Exclude<keyof T, K>>;
     export type MakePartial<T, K extends keyof T> = Omit<T, K> & Partial<Pick<T, K>>;
     export type Exactly<T, X> = T & Record<Exclude<keyof X, keyof T>, never>;
+    export type InexactPartial<T> = {
+        [k in keyof T]?: T[k] | undefined;
+    };
     export const arrayToEnum: <T extends string, U extends [T, ...T[]]>(items: U) => { [k in U[number]]: k; };
     export const getValidEnumValues: (obj: any) => any[];
     export const objectValues: (obj: any) => any[];
@@ -970,24 +973,24 @@ declare namespace objectUtil {
 }
 declare const ZodParsedType: {
     string: "string";
-    number: "number";
-    bigint: "bigint";
-    boolean: "boolean";
-    symbol: "symbol";
-    undefined: "undefined";
-    object: "object";
-    function: "function";
-    map: "map";
     nan: "nan";
+    number: "number";
     integer: "integer";
     float: "float";
+    boolean: "boolean";
     date: "date";
+    bigint: "bigint";
+    symbol: "symbol";
+    function: "function";
+    undefined: "undefined";
     null: "null";
     array: "array";
+    object: "object";
     unknown: "unknown";
     promise: "promise";
     void: "void";
     never: "never";
+    map: "map";
     set: "set";
 };
 type ZodParsedType = keyof typeof ZodParsedType;
@@ -1020,7 +1023,7 @@ declare const ZodIssueCode: {
 type ZodIssueCode = keyof typeof ZodIssueCode;
 type ZodIssueBase = {
     path: (string | number)[];
-    message?: string;
+    message?: string | undefined;
 };
 interface ZodInvalidTypeIssue extends ZodIssueBase {
     code: typeof ZodIssueCode.invalid_type;
@@ -1062,7 +1065,7 @@ interface ZodInvalidDateIssue extends ZodIssueBase {
 }
 type StringValidation = "email" | "url" | "emoji" | "uuid" | "nanoid" | "regex" | "cuid" | "cuid2" | "ulid" | "datetime" | "date" | "time" | "duration" | "ip" | "cidr" | "base64" | "jwt" | "base64url" | {
     includes: string;
-    position?: number;
+    position?: number | undefined;
 } | {
     startsWith: string;
 } | {
@@ -1104,7 +1107,7 @@ interface ZodCustomIssue extends ZodIssueBase {
 }
 type ZodIssueOptionalMessage = ZodInvalidTypeIssue | ZodInvalidLiteralIssue | ZodUnrecognizedKeysIssue | ZodInvalidUnionIssue | ZodInvalidUnionDiscriminatorIssue | ZodInvalidEnumValueIssue | ZodInvalidArgumentsIssue | ZodInvalidReturnTypeIssue | ZodInvalidDateIssue | ZodInvalidStringIssue | ZodTooSmallIssue | ZodTooBigIssue | ZodInvalidIntersectionTypesIssue | ZodNotMultipleOfIssue | ZodNotFiniteIssue | ZodCustomIssue;
 type ZodIssue = ZodIssueOptionalMessage & {
-    fatal?: boolean;
+    fatal?: boolean | undefined;
     message: string;
 };
 type recursiveZodFormattedError<T> = T extends [any, ...any[]] ? {
@@ -1137,7 +1140,7 @@ declare class ZodError<T = any> extends Error {
 type stripPath<T extends object> = T extends any ? util.OmitKeys<T, "path"> : never;
 type IssueData = stripPath<ZodIssueOptionalMessage> & {
     path?: (string | number)[];
-    fatal?: boolean;
+    fatal?: boolean | undefined;
 };
 type ErrorMapCtx = {
     defaultError: string;
@@ -1157,11 +1160,11 @@ type ParsePath = ParsePathComponent[];
 interface ParseContext {
     readonly common: {
         readonly issues: ZodIssue[];
-        readonly contextualErrorMap?: ZodErrorMap;
+        readonly contextualErrorMap?: ZodErrorMap | undefined;
         readonly async: boolean;
     };
     readonly path: ParsePath;
-    readonly schemaErrorMap?: ZodErrorMap;
+    readonly schemaErrorMap?: ZodErrorMap | undefined;
     readonly parent: ParseContext | null;
     readonly data: any;
     readonly parsedType: ZodParsedType;
@@ -1215,7 +1218,7 @@ declare namespace enumUtil {
 
 declare namespace errorUtil {
     type ErrMessage = string | {
-        message?: string;
+        message?: string | undefined;
     };
     const errToObj: (message?: ErrMessage) => {
         message?: string | undefined;
@@ -1348,15 +1351,15 @@ type output<T extends ZodType<any, any, any>> = T["_output"];
 
 type CustomErrorParams = Partial<util.Omit<ZodCustomIssue, "code">>;
 interface ZodTypeDef {
-    errorMap?: ZodErrorMap;
-    description?: string;
+    errorMap?: ZodErrorMap | undefined;
+    description?: string | undefined;
 }
 type RawCreateParams = {
-    errorMap?: ZodErrorMap;
-    invalid_type_error?: string;
-    required_error?: string;
-    message?: string;
-    description?: string;
+    errorMap?: ZodErrorMap | undefined;
+    invalid_type_error?: string | undefined;
+    required_error?: string | undefined;
+    message?: string | undefined;
+    description?: string | undefined;
 } | undefined;
 type SafeParseSuccess<Output> = {
     success: true;
@@ -1385,13 +1388,13 @@ declare abstract class ZodType<Output = any, Def extends ZodTypeDef = ZodTypeDef
     };
     _parseSync(input: ParseInput): SyncParseReturnType<Output>;
     _parseAsync(input: ParseInput): AsyncParseReturnType<Output>;
-    parse(data: unknown, params?: Partial<ParseParams>): Output;
-    safeParse(data: unknown, params?: Partial<ParseParams>): SafeParseReturnType<Input, Output>;
+    parse(data: unknown, params?: util.InexactPartial<ParseParams>): Output;
+    safeParse(data: unknown, params?: util.InexactPartial<ParseParams>): SafeParseReturnType<Input, Output>;
     "~validate"(data: unknown): StandardSchemaV1.Result<Output> | Promise<StandardSchemaV1.Result<Output>>;
-    parseAsync(data: unknown, params?: Partial<ParseParams>): Promise<Output>;
-    safeParseAsync(data: unknown, params?: Partial<ParseParams>): Promise<SafeParseReturnType<Input, Output>>;
+    parseAsync(data: unknown, params?: util.InexactPartial<ParseParams>): Promise<Output>;
+    safeParseAsync(data: unknown, params?: util.InexactPartial<ParseParams>): Promise<SafeParseReturnType<Input, Output>>;
     /** Alias of safeParseAsync */
-    spa: (data: unknown, params?: Partial<ParseParams>) => Promise<SafeParseReturnType<Input, Output>>;
+    spa: (data: unknown, params?: util.InexactPartial<ParseParams>) => Promise<SafeParseReturnType<Input, Output>>;
     refine<RefinedOutput extends Output>(check: (arg: Output) => arg is RefinedOutput, message?: string | CustomErrorParams | ((arg: Output) => CustomErrorParams)): ZodEffects<this, RefinedOutput, Input>;
     refine(check: (arg: Output) => unknown | Promise<unknown>, message?: string | CustomErrorParams | ((arg: Output) => CustomErrorParams)): ZodEffects<this, Output, Input>;
     refinement<RefinedOutput extends Output>(check: (arg: Output) => arg is RefinedOutput, refinementData: IssueData | ((arg: Output, ctx: RefinementCtx) => IssueData)): ZodEffects<this, RefinedOutput, Input>;
@@ -1427,22 +1430,22 @@ type ZodNumberCheck = {
     kind: "min";
     value: number;
     inclusive: boolean;
-    message?: string;
+    message?: string | undefined;
 } | {
     kind: "max";
     value: number;
     inclusive: boolean;
-    message?: string;
+    message?: string | undefined;
 } | {
     kind: "int";
-    message?: string;
+    message?: string | undefined;
 } | {
     kind: "multipleOf";
     value: number;
-    message?: string;
+    message?: string | undefined;
 } | {
     kind: "finite";
-    message?: string;
+    message?: string | undefined;
 };
 interface ZodNumberDef extends ZodTypeDef {
     checks: ZodNumberCheck[];
@@ -1491,15 +1494,15 @@ interface ZodArrayDef<T extends ZodTypeAny = ZodTypeAny> extends ZodTypeDef {
     typeName: ZodFirstPartyTypeKind.ZodArray;
     exactLength: {
         value: number;
-        message?: string;
+        message?: string | undefined;
     } | null;
     minLength: {
         value: number;
-        message?: string;
+        message?: string | undefined;
     } | null;
     maxLength: {
         value: number;
-        message?: string;
+        message?: string | undefined;
     } | null;
 }
 type ArrayCardinality = "many" | "atleastone";
@@ -1511,7 +1514,7 @@ declare class ZodArray<T extends ZodTypeAny, Cardinality extends ArrayCardinalit
     max(maxLength: number, message?: errorUtil.ErrMessage): this;
     length(len: number, message?: errorUtil.ErrMessage): this;
     nonempty(message?: errorUtil.ErrMessage): ZodArray<T, "atleastone">;
-    static create: <T_1 extends ZodTypeAny>(schema: T_1, params?: RawCreateParams) => ZodArray<T_1, "many">;
+    static create: <El extends ZodTypeAny>(schema: El, params?: RawCreateParams) => ZodArray<El>;
 }
 type UnknownKeysParam = "passthrough" | "strict" | "strip";
 interface ZodObjectDef<T extends ZodRawShape = ZodRawShape, UnknownKeys extends UnknownKeysParam = UnknownKeysParam, Catchall extends ZodTypeAny = ZodTypeAny> extends ZodTypeDef {
@@ -1596,24 +1599,20 @@ declare class ZodObject<T extends ZodRawShape, UnknownKeys extends UnknownKeysPa
         [k in keyof T]: k extends keyof Mask ? deoptional<T[k]> : T[k];
     }>, UnknownKeys, Catchall>;
     keyof(): ZodEnum<enumUtil.UnionToTupleString<keyof T>>;
-    static create: <T_1 extends ZodRawShape>(shape: T_1, params?: RawCreateParams) => ZodObject<T_1, "strip", ZodTypeAny, objectUtil.addQuestionMarks<baseObjectOutputType<T_1>, any> extends infer T_2 ? { [k in keyof T_2]: objectUtil.addQuestionMarks<baseObjectOutputType<T_1>, any>[k]; } : never, baseObjectInputType<T_1> extends infer T_3 ? { [k_1 in keyof T_3]: baseObjectInputType<T_1>[k_1]; } : never>;
-    static strictCreate: <T_1 extends ZodRawShape>(shape: T_1, params?: RawCreateParams) => ZodObject<T_1, "strict", ZodTypeAny, objectUtil.addQuestionMarks<baseObjectOutputType<T_1>, any> extends infer T_2 ? { [k in keyof T_2]: objectUtil.addQuestionMarks<baseObjectOutputType<T_1>, any>[k]; } : never, baseObjectInputType<T_1> extends infer T_3 ? { [k_1 in keyof T_3]: baseObjectInputType<T_1>[k_1]; } : never>;
-    static lazycreate: <T_1 extends ZodRawShape>(shape: () => T_1, params?: RawCreateParams) => ZodObject<T_1, "strip", ZodTypeAny, objectUtil.addQuestionMarks<baseObjectOutputType<T_1>, any> extends infer T_2 ? { [k in keyof T_2]: objectUtil.addQuestionMarks<baseObjectOutputType<T_1>, any>[k]; } : never, baseObjectInputType<T_1> extends infer T_3 ? { [k_1 in keyof T_3]: baseObjectInputType<T_1>[k_1]; } : never>;
+    static create: <Shape extends ZodRawShape>(shape: Shape, params?: RawCreateParams) => ZodObject<Shape, "strip", ZodTypeAny, objectOutputType<Shape, ZodTypeAny, "strip">, objectInputType<Shape, ZodTypeAny, "strip">>;
+    static strictCreate: <Shape extends ZodRawShape>(shape: Shape, params?: RawCreateParams) => ZodObject<Shape, "strict">;
+    static lazycreate: <Shape extends ZodRawShape>(shape: () => Shape, params?: RawCreateParams) => ZodObject<Shape, "strip">;
 }
 type AnyZodObject = ZodObject<any, any, any>;
 type ZodUnionOptions = Readonly<[ZodTypeAny, ...ZodTypeAny[]]>;
-interface ZodUnionDef<T extends ZodUnionOptions = Readonly<[
-    ZodTypeAny,
-    ZodTypeAny,
-    ...ZodTypeAny[]
-]>> extends ZodTypeDef {
+interface ZodUnionDef<T extends ZodUnionOptions = Readonly<[ZodTypeAny, ZodTypeAny, ...ZodTypeAny[]]>> extends ZodTypeDef {
     options: T;
     typeName: ZodFirstPartyTypeKind.ZodUnion;
 }
 declare class ZodUnion<T extends ZodUnionOptions> extends ZodType<T[number]["_output"], ZodUnionDef<T>, T[number]["_input"]> {
     _parse(input: ParseInput): ParseReturnType<this["_output"]>;
     get options(): T;
-    static create: <T_1 extends readonly [ZodTypeAny, ZodTypeAny, ...ZodTypeAny[]]>(types: T_1, params?: RawCreateParams) => ZodUnion<T_1>;
+    static create: <Options extends Readonly<[ZodTypeAny, ZodTypeAny, ...ZodTypeAny[]]>>(types: Options, params?: RawCreateParams) => ZodUnion<Options>;
 }
 interface ZodIntersectionDef<T extends ZodTypeAny = ZodTypeAny, U extends ZodTypeAny = ZodTypeAny> extends ZodTypeDef {
     left: T;
@@ -1622,7 +1621,7 @@ interface ZodIntersectionDef<T extends ZodTypeAny = ZodTypeAny, U extends ZodTyp
 }
 declare class ZodIntersection<T extends ZodTypeAny, U extends ZodTypeAny> extends ZodType<T["_output"] & U["_output"], ZodIntersectionDef<T, U>, T["_input"] & U["_input"]> {
     _parse(input: ParseInput): ParseReturnType<this["_output"]>;
-    static create: <T_1 extends ZodTypeAny, U_1 extends ZodTypeAny>(left: T_1, right: U_1, params?: RawCreateParams) => ZodIntersection<T_1, U_1>;
+    static create: <TSchema extends ZodTypeAny, USchema extends ZodTypeAny>(left: TSchema, right: USchema, params?: RawCreateParams) => ZodIntersection<TSchema, USchema>;
 }
 type ZodTupleItems = [ZodTypeAny, ...ZodTypeAny[]];
 type AssertArray<T> = T extends any[] ? T : never;
@@ -1639,11 +1638,11 @@ interface ZodTupleDef<T extends ZodTupleItems | [] = ZodTupleItems, Rest extends
     rest: Rest;
     typeName: ZodFirstPartyTypeKind.ZodTuple;
 }
-declare class ZodTuple<T extends [ZodTypeAny, ...ZodTypeAny[]] | [] = [ZodTypeAny, ...ZodTypeAny[]], Rest extends ZodTypeAny | null = null> extends ZodType<OutputTypeOfTupleWithRest<T, Rest>, ZodTupleDef<T, Rest>, InputTypeOfTupleWithRest<T, Rest>> {
+declare class ZodTuple<T extends ZodTupleItems | [] = ZodTupleItems, Rest extends ZodTypeAny | null = null> extends ZodType<OutputTypeOfTupleWithRest<T, Rest>, ZodTupleDef<T, Rest>, InputTypeOfTupleWithRest<T, Rest>> {
     _parse(input: ParseInput): ParseReturnType<this["_output"]>;
     get items(): T;
-    rest<Rest extends ZodTypeAny>(rest: Rest): ZodTuple<T, Rest>;
-    static create: <T_1 extends [] | [ZodTypeAny, ...ZodTypeAny[]]>(schemas: T_1, params?: RawCreateParams) => ZodTuple<T_1, null>;
+    rest<RestSchema extends ZodTypeAny>(rest: RestSchema): ZodTuple<T, RestSchema>;
+    static create: <Items extends [ZodTypeAny, ...ZodTypeAny[]] | []>(schemas: Items, params?: RawCreateParams) => ZodTuple<Items, null>;
 }
 type EnumValues<T extends string = string> = readonly [T, ...T[]];
 type Values<T extends EnumValues> = {
@@ -1661,7 +1660,7 @@ type typecast<A, T> = A extends T ? A : never;
 declare function createZodEnum<U extends string, T extends Readonly<[U, ...U[]]>>(values: T, params?: RawCreateParams): ZodEnum<Writeable<T>>;
 declare function createZodEnum<U extends string, T extends [U, ...U[]]>(values: T, params?: RawCreateParams): ZodEnum<T>;
 declare class ZodEnum<T extends [string, ...string[]]> extends ZodType<T[number], ZodEnumDef<T>, T[number]> {
-    #private;
+    _cache: Set<T[number]> | undefined;
     _parse(input: ParseInput): ParseReturnType<this["_output"]>;
     get options(): T;
     get enum(): Values<T>;
@@ -1678,7 +1677,7 @@ interface ZodPromiseDef<T extends ZodTypeAny = ZodTypeAny> extends ZodTypeDef {
 declare class ZodPromise<T extends ZodTypeAny> extends ZodType<Promise<T["_output"]>, ZodPromiseDef<T>, Promise<T["_input"]>> {
     unwrap(): T;
     _parse(input: ParseInput): ParseReturnType<this["_output"]>;
-    static create: <T_1 extends ZodTypeAny>(schema: T_1, params?: RawCreateParams) => ZodPromise<T_1>;
+    static create: <Inner extends ZodTypeAny>(schema: Inner, params?: RawCreateParams) => ZodPromise<Inner>;
 }
 type RefinementEffect<T> = {
     type: "refinement";
@@ -1713,7 +1712,7 @@ interface ZodOptionalDef<T extends ZodTypeAny = ZodTypeAny> extends ZodTypeDef {
 declare class ZodOptional<T extends ZodTypeAny> extends ZodType<T["_output"] | undefined, ZodOptionalDef<T>, T["_input"] | undefined> {
     _parse(input: ParseInput): ParseReturnType<this["_output"]>;
     unwrap(): T;
-    static create: <T_1 extends ZodTypeAny>(type: T_1, params?: RawCreateParams) => ZodOptional<T_1>;
+    static create: <Inner extends ZodTypeAny>(type: Inner, params?: RawCreateParams) => ZodOptional<Inner>;
 }
 interface ZodNullableDef<T extends ZodTypeAny = ZodTypeAny> extends ZodTypeDef {
     innerType: T;
@@ -1722,7 +1721,7 @@ interface ZodNullableDef<T extends ZodTypeAny = ZodTypeAny> extends ZodTypeDef {
 declare class ZodNullable<T extends ZodTypeAny> extends ZodType<T["_output"] | null, ZodNullableDef<T>, T["_input"] | null> {
     _parse(input: ParseInput): ParseReturnType<this["_output"]>;
     unwrap(): T;
-    static create: <T_1 extends ZodTypeAny>(type: T_1, params?: RawCreateParams) => ZodNullable<T_1>;
+    static create: <Inner extends ZodTypeAny>(type: Inner, params?: RawCreateParams) => ZodNullable<Inner>;
 }
 interface ZodDefaultDef<T extends ZodTypeAny = ZodTypeAny> extends ZodTypeDef {
     innerType: T;
@@ -1732,15 +1731,9 @@ interface ZodDefaultDef<T extends ZodTypeAny = ZodTypeAny> extends ZodTypeDef {
 declare class ZodDefault<T extends ZodTypeAny> extends ZodType<util.noUndefined<T["_output"]>, ZodDefaultDef<T>, T["_input"] | undefined> {
     _parse(input: ParseInput): ParseReturnType<this["_output"]>;
     removeDefault(): T;
-    static create: <T_1 extends ZodTypeAny>(type: T_1, params: {
-        errorMap?: ZodErrorMap | undefined;
-        invalid_type_error?: string | undefined;
-        required_error?: string | undefined;
-        message?: string | undefined;
-        description?: string | undefined;
-    } & {
-        default: T_1["_input"] | (() => util.noUndefined<T_1["_input"]>);
-    }) => ZodDefault<T_1>;
+    static create: <Inner extends ZodTypeAny>(type: Inner, params: RawCreateParams & {
+        default: Inner["_input"] | (() => util.noUndefined<Inner["_input"]>);
+    }) => ZodDefault<Inner>;
 }
 interface ZodCatchDef<T extends ZodTypeAny = ZodTypeAny> extends ZodTypeDef {
     innerType: T;
@@ -1753,15 +1746,9 @@ interface ZodCatchDef<T extends ZodTypeAny = ZodTypeAny> extends ZodTypeDef {
 declare class ZodCatch<T extends ZodTypeAny> extends ZodType<T["_output"], ZodCatchDef<T>, unknown> {
     _parse(input: ParseInput): ParseReturnType<this["_output"]>;
     removeCatch(): T;
-    static create: <T_1 extends ZodTypeAny>(type: T_1, params: {
-        errorMap?: ZodErrorMap | undefined;
-        invalid_type_error?: string | undefined;
-        required_error?: string | undefined;
-        message?: string | undefined;
-        description?: string | undefined;
-    } & {
-        catch: T_1["_output"] | (() => T_1["_output"]);
-    }) => ZodCatch<T_1>;
+    static create: <Inner extends ZodTypeAny>(type: Inner, params: RawCreateParams & {
+        catch: Inner["_output"] | (() => Inner["_output"]);
+    }) => ZodCatch<Inner>;
 }
 interface ZodBrandedDef<T extends ZodTypeAny> extends ZodTypeDef {
     type: T;
@@ -1784,7 +1771,7 @@ interface ZodPipelineDef<A extends ZodTypeAny, B extends ZodTypeAny> extends Zod
 }
 declare class ZodPipeline<A extends ZodTypeAny, B extends ZodTypeAny> extends ZodType<B["_output"], ZodPipelineDef<A, B>, A["_input"]> {
     _parse(input: ParseInput): ParseReturnType<any>;
-    static create<A extends ZodTypeAny, B extends ZodTypeAny>(a: A, b: B): ZodPipeline<A, B>;
+    static create<ASchema extends ZodTypeAny, BSchema extends ZodTypeAny>(a: ASchema, b: BSchema): ZodPipeline<ASchema, BSchema>;
 }
 type BuiltIn = (((...args: any[]) => any) | (new (...args: any[]) => any)) | {
     readonly [Symbol.toStringTag]: string;
@@ -1796,7 +1783,7 @@ interface ZodReadonlyDef<T extends ZodTypeAny = ZodTypeAny> extends ZodTypeDef {
 }
 declare class ZodReadonly<T extends ZodTypeAny> extends ZodType<MakeReadonly<T["_output"]>, ZodReadonlyDef<T>, MakeReadonly<T["_input"]>> {
     _parse(input: ParseInput): ParseReturnType<this["_output"]>;
-    static create: <T_1 extends ZodTypeAny>(type: T_1, params?: RawCreateParams) => ZodReadonly<T_1>;
+    static create: <Inner extends ZodTypeAny>(type: Inner, params?: RawCreateParams) => ZodReadonly<Inner>;
     unwrap(): T;
 }
 declare enum ZodFirstPartyTypeKind {