@storybook/react 10.0.0-beta.6 → 10.0.0-beta.8

package/dist/_browser-chunks/{chunk-EH3IDVCQ.js → chunk-352EX3YB.js}

@@ -1,6 +1,6 @@
 import {
   entry_preview_exports
-} from "./chunk-XNNKYNNU.js";
+} from "./chunk-4WKCOEYI.js";
 import {
   entry_preview_argtypes_exports
 } from "./chunk-2SCDRHCG.js";

package/dist/_browser-chunks/{chunk-XNNKYNNU.js → chunk-4WKCOEYI.js}

@@ -1937,6 +1937,7 @@ __export(entry_preview_exports, {
 });
 var import_semver = __toESM(require_semver2(), 1);
 import * as React4 from "react";
+import { global as global2 } from "@storybook/global";
 import { configure } from "storybook/test";
 
 // src/act-compat.ts
@@ -2120,6 +2121,14 @@ var decorators = [
       throw new Error("React Server Components require React >= 18.3");
     }
     return React4.createElement(React4.Suspense, null, story());
+  },
+  (story, context) => {
+    if (context.tags?.includes("test-fn") && !global2.FEATURES?.experimentalTestSyntax) {
+      throw new Error(
+        "To use the experimental test function, you must enable the experimentalTestSyntax feature flag. See https://storybook.js.org/docs/10/api/main-config/main-config-features#experimentalTestSyntax"
+      );
+    }
+    return story();
   }
 ];
 var parameters = {

package/dist/entry-preview.js

@@ -5,7 +5,7 @@ import {
   parameters,
   render,
   renderToCanvas
-} from "./_browser-chunks/chunk-XNNKYNNU.js";
+} from "./_browser-chunks/chunk-4WKCOEYI.js";
 import {
   applyDecorators
 } from "./_browser-chunks/chunk-BUAOEMNB.js";

package/dist/index.js

@@ -1,10 +1,10 @@
 import {
   __definePreview
-} from "./_browser-chunks/chunk-EH3IDVCQ.js";
+} from "./_browser-chunks/chunk-352EX3YB.js";
 import {
   entry_preview_exports,
   renderToCanvas
-} from "./_browser-chunks/chunk-XNNKYNNU.js";
+} from "./_browser-chunks/chunk-4WKCOEYI.js";
 import {
   entry_preview_argtypes_exports
 } from "./_browser-chunks/chunk-2SCDRHCG.js";

package/dist/preset.js

@@ -1,10 +1,10 @@
-import CJS_COMPAT_NODE_URL_kp903wpinto from 'node:url';
-import CJS_COMPAT_NODE_PATH_kp903wpinto from 'node:path';
-import CJS_COMPAT_NODE_MODULE_kp903wpinto from "node:module";
+import CJS_COMPAT_NODE_URL_q1lvh4oqay from 'node:url';
+import CJS_COMPAT_NODE_PATH_q1lvh4oqay from 'node:path';
+import CJS_COMPAT_NODE_MODULE_q1lvh4oqay from "node:module";
 
-var __filename = CJS_COMPAT_NODE_URL_kp903wpinto.fileURLToPath(import.meta.url);
-var __dirname = CJS_COMPAT_NODE_PATH_kp903wpinto.dirname(__filename);
-var require = CJS_COMPAT_NODE_MODULE_kp903wpinto.createRequire(import.meta.url);
+var __filename = CJS_COMPAT_NODE_URL_q1lvh4oqay.fileURLToPath(import.meta.url);
+var __dirname = CJS_COMPAT_NODE_PATH_q1lvh4oqay.dirname(__filename);
+var require = CJS_COMPAT_NODE_MODULE_q1lvh4oqay.createRequire(import.meta.url);
 
 // ------------------------------------------------------------
 // end of CJS compatibility banner, injected by Storybook's esbuild configuration
@@ -18,6 +18,314 @@ import { fileURLToPath as fileURLToPath2 } from "node:url";
 // ../../core/src/shared/utils/module.ts
 import { fileURLToPath, pathToFileURL } from "node:url";
 
+// ../../node_modules/exsolve/dist/index.mjs
+import assert from "node:assert";
+import v8 from "node:v8";
+import { format, inspect } from "node:util";
+var own$1 = {}.hasOwnProperty;
+var classRegExp = /^([A-Z][a-z\d]*)+$/;
+var kTypes = /* @__PURE__ */ new Set([
+  "string",
+  "function",
+  "number",
+  "object",
+  // Accept 'Function' and 'Object' as alternative to the lower cased version.
+  "Function",
+  "Object",
+  "boolean",
+  "bigint",
+  "symbol"
+]);
+var messages = /* @__PURE__ */ new Map();
+var nodeInternalPrefix = "__node_internal_";
+var userStackTraceLimit;
+function formatList(array, type = "and") {
+  return array.length < 3 ? array.join(` ${type} `) : `${array.slice(0, -1).join(", ")}, ${type} ${array.at(-1)}`;
+}
+__name(formatList, "formatList");
+function createError(sym, value, constructor) {
+  messages.set(sym, value);
+  return makeNodeErrorWithCode(constructor, sym);
+}
+__name(createError, "createError");
+function makeNodeErrorWithCode(Base, key) {
+  return /* @__PURE__ */ __name(function NodeError(...parameters) {
+    const limit = Error.stackTraceLimit;
+    if (isErrorStackTraceLimitWritable()) Error.stackTraceLimit = 0;
+    const error = new Base();
+    if (isErrorStackTraceLimitWritable()) Error.stackTraceLimit = limit;
+    const message = getMessage(key, parameters, error);
+    Object.defineProperties(error, {
+      // Note: no need to implement `kIsNodeError` symbol, would be hard,
+      // probably.
+      message: {
+        value: message,
+        enumerable: false,
+        writable: true,
+        configurable: true
+      },
+      toString: {
+        /** @this {Error} */
+        value() {
+          return `${this.name} [${key}]: ${this.message}`;
+        },
+        enumerable: false,
+        writable: true,
+        configurable: true
+      }
+    });
+    captureLargerStackTrace(error);
+    error.code = key;
+    return error;
+  }, "NodeError");
+}
+__name(makeNodeErrorWithCode, "makeNodeErrorWithCode");
+function isErrorStackTraceLimitWritable() {
+  try {
+    if (v8.startupSnapshot.isBuildingSnapshot()) {
+      return false;
+    }
+  } catch {
+  }
+  const desc = Object.getOwnPropertyDescriptor(Error, "stackTraceLimit");
+  if (desc === void 0) {
+    return Object.isExtensible(Error);
+  }
+  return own$1.call(desc, "writable") && desc.writable !== void 0 ? desc.writable : desc.set !== void 0;
+}
+__name(isErrorStackTraceLimitWritable, "isErrorStackTraceLimitWritable");
+function hideStackFrames(wrappedFunction) {
+  const hidden = nodeInternalPrefix + wrappedFunction.name;
+  Object.defineProperty(wrappedFunction, "name", { value: hidden });
+  return wrappedFunction;
+}
+__name(hideStackFrames, "hideStackFrames");
+var captureLargerStackTrace = hideStackFrames(function(error) {
+  const stackTraceLimitIsWritable = isErrorStackTraceLimitWritable();
+  if (stackTraceLimitIsWritable) {
+    userStackTraceLimit = Error.stackTraceLimit;
+    Error.stackTraceLimit = Number.POSITIVE_INFINITY;
+  }
+  Error.captureStackTrace(error);
+  if (stackTraceLimitIsWritable) Error.stackTraceLimit = userStackTraceLimit;
+  return error;
+});
+function getMessage(key, parameters, self) {
+  const message = messages.get(key);
+  assert(message !== void 0, "expected `message` to be found");
+  if (typeof message === "function") {
+    assert(
+      message.length <= parameters.length,
+      // Default options do not count.
+      `Code: ${key}; The provided arguments length (${parameters.length}) does not match the required ones (${message.length}).`
+    );
+    return Reflect.apply(message, self, parameters);
+  }
+  const regex = /%[dfijoOs]/g;
+  let expectedLength = 0;
+  while (regex.exec(message) !== null) expectedLength++;
+  assert(
+    expectedLength === parameters.length,
+    `Code: ${key}; The provided arguments length (${parameters.length}) does not match the required ones (${expectedLength}).`
+  );
+  if (parameters.length === 0) return message;
+  parameters.unshift(message);
+  return Reflect.apply(format, null, parameters);
+}
+__name(getMessage, "getMessage");
+function determineSpecificType(value) {
+  if (value === null || value === void 0) {
+    return String(value);
+  }
+  if (typeof value === "function" && value.name) {
+    return `function ${value.name}`;
+  }
+  if (typeof value === "object") {
+    if (value.constructor && value.constructor.name) {
+      return `an instance of ${value.constructor.name}`;
+    }
+    return `${inspect(value, { depth: -1 })}`;
+  }
+  let inspected = inspect(value, { colors: false });
+  if (inspected.length > 28) {
+    inspected = `${inspected.slice(0, 25)}...`;
+  }
+  return `type ${typeof value} (${inspected})`;
+}
+__name(determineSpecificType, "determineSpecificType");
+createError(
+  "ERR_INVALID_ARG_TYPE",
+  (name, expected, actual) => {
+    assert(typeof name === "string", "'name' must be a string");
+    if (!Array.isArray(expected)) {
+      expected = [expected];
+    }
+    let message = "The ";
+    if (name.endsWith(" argument")) {
+      message += `${name} `;
+    } else {
+      const type = name.includes(".") ? "property" : "argument";
+      message += `"${name}" ${type} `;
+    }
+    message += "must be ";
+    const types = [];
+    const instances = [];
+    const other = [];
+    for (const value of expected) {
+      assert(
+        typeof value === "string",
+        "All expected entries have to be of type string"
+      );
+      if (kTypes.has(value)) {
+        types.push(value.toLowerCase());
+      } else if (classRegExp.exec(value) === null) {
+        assert(
+          value !== "object",
+          'The value "object" should be written as "Object"'
+        );
+        other.push(value);
+      } else {
+        instances.push(value);
+      }
+    }
+    if (instances.length > 0) {
+      const pos = types.indexOf("object");
+      if (pos !== -1) {
+        types.slice(pos, 1);
+        instances.push("Object");
+      }
+    }
+    if (types.length > 0) {
+      message += `${types.length > 1 ? "one of type" : "of type"} ${formatList(
+        types,
+        "or"
+      )}`;
+      if (instances.length > 0 || other.length > 0) message += " or ";
+    }
+    if (instances.length > 0) {
+      message += `an instance of ${formatList(instances, "or")}`;
+      if (other.length > 0) message += " or ";
+    }
+    if (other.length > 0) {
+      if (other.length > 1) {
+        message += `one of ${formatList(other, "or")}`;
+      } else {
+        if (other[0]?.toLowerCase() !== other[0]) message += "an ";
+        message += `${other[0]}`;
+      }
+    }
+    message += `. Received ${determineSpecificType(actual)}`;
+    return message;
+  },
+  TypeError
+);
+var ERR_INVALID_MODULE_SPECIFIER = createError(
+  "ERR_INVALID_MODULE_SPECIFIER",
+  /**
+   * @param {string} request
+   * @param {string} reason
+   * @param {string} [base]
+   */
+  (request, reason, base) => {
+    return `Invalid module "${request}" ${reason}${base ? ` imported from ${base}` : ""}`;
+  },
+  TypeError
+);
+var ERR_INVALID_PACKAGE_CONFIG = createError(
+  "ERR_INVALID_PACKAGE_CONFIG",
+  (path2, base, message) => {
+    return `Invalid package config ${path2}${base ? ` while importing ${base}` : ""}${message ? `. ${message}` : ""}`;
+  },
+  Error
+);
+var ERR_INVALID_PACKAGE_TARGET = createError(
+  "ERR_INVALID_PACKAGE_TARGET",
+  (packagePath, key, target, isImport = false, base) => {
+    const relatedError = typeof target === "string" && !isImport && target.length > 0 && !target.startsWith("./");
+    if (key === ".") {
+      assert(isImport === false);
+      return `Invalid "exports" main target ${JSON.stringify(target)} defined in the package config ${packagePath}package.json${base ? ` imported from ${base}` : ""}${relatedError ? '; targets must start with "./"' : ""}`;
+    }
+    return `Invalid "${isImport ? "imports" : "exports"}" target ${JSON.stringify(
+      target
+    )} defined for '${key}' in the package config ${packagePath}package.json${base ? ` imported from ${base}` : ""}${relatedError ? '; targets must start with "./"' : ""}`;
+  },
+  Error
+);
+var ERR_MODULE_NOT_FOUND = createError(
+  "ERR_MODULE_NOT_FOUND",
+  (path2, base, exactUrl = false) => {
+    return `Cannot find ${exactUrl ? "module" : "package"} '${path2}' imported from ${base}`;
+  },
+  Error
+);
+createError(
+  "ERR_NETWORK_IMPORT_DISALLOWED",
+  "import of '%s' by %s is not supported: %s",
+  Error
+);
+var ERR_PACKAGE_IMPORT_NOT_DEFINED = createError(
+  "ERR_PACKAGE_IMPORT_NOT_DEFINED",
+  (specifier, packagePath, base) => {
+    return `Package import specifier "${specifier}" is not defined${packagePath ? ` in package ${packagePath || ""}package.json` : ""} imported from ${base}`;
+  },
+  TypeError
+);
+var ERR_PACKAGE_PATH_NOT_EXPORTED = createError(
+  "ERR_PACKAGE_PATH_NOT_EXPORTED",
+  /**
+   * @param {string} packagePath
+   * @param {string} subpath
+   * @param {string} [base]
+   */
+  (packagePath, subpath, base) => {
+    if (subpath === ".")
+      return `No "exports" main defined in ${packagePath}package.json${base ? ` imported from ${base}` : ""}`;
+    return `Package subpath '${subpath}' is not defined by "exports" in ${packagePath}package.json${base ? ` imported from ${base}` : ""}`;
+  },
+  Error
+);
+var ERR_UNSUPPORTED_DIR_IMPORT = createError(
+  "ERR_UNSUPPORTED_DIR_IMPORT",
+  "Directory import '%s' is not supported resolving ES modules imported from %s",
+  Error
+);
+var ERR_UNSUPPORTED_RESOLVE_REQUEST = createError(
+  "ERR_UNSUPPORTED_RESOLVE_REQUEST",
+  'Failed to resolve module specifier "%s" from "%s": Invalid relative URL or base scheme is not hierarchical.',
+  TypeError
+);
+var ERR_UNKNOWN_FILE_EXTENSION = createError(
+  "ERR_UNKNOWN_FILE_EXTENSION",
+  (extension, path2) => {
+    return `Unknown file extension "${extension}" for ${path2}`;
+  },
+  TypeError
+);
+createError(
+  "ERR_INVALID_ARG_VALUE",
+  (name, value, reason = "is invalid") => {
+    let inspected = inspect(value);
+    if (inspected.length > 128) {
+      inspected = `${inspected.slice(0, 128)}...`;
+    }
+    const type = name.includes(".") ? "property" : "argument";
+    return `The ${type} '${name}' ${reason}. Received ${inspected}`;
+  },
+  TypeError
+  // Note: extra classes have been shaken out.
+  // , RangeError
+);
+var hasOwnProperty$1 = {}.hasOwnProperty;
+var hasOwnProperty = {}.hasOwnProperty;
+var RegExpPrototypeSymbolReplace = RegExp.prototype[Symbol.replace];
+var own = {}.hasOwnProperty;
+var isWindows = (() => process.platform === "win32")();
+var globalCache = (() => (
+  // eslint-disable-next-line unicorn/no-unreadable-iife
+  globalThis["__EXSOLVE_CACHE__"] ||= /* @__PURE__ */ new Map()
+))();
+
 // ../../node_modules/pathe/dist/shared/pathe.ff20891b.mjs
 var _DRIVE_LETTER_START_RE = /^[A-Za-z]:\//;
 function normalizeWindowsPath(input = "") {

package/dist/preview.d.ts

@@ -1,3 +1,425 @@
-// auto generated file from file:///home/runner/work/storybook/storybook/scripts/build/utils/generate-type-mappers.ts, do not edit
-export * from '../src/preview.tsx';
-export type * from '../src/preview.tsx';
+import { ComponentType, JSX } from 'react';
+import { PreviewAddon, InferTypes, AddonTypes, Preview, Meta, Story } from 'storybook/internal/csf';
+import { WebRenderer, Canvas, ProjectAnnotations, Args, DecoratorFunction, ArgsStoryFn, ComponentAnnotations, StoryAnnotations, Renderer } from 'storybook/internal/types';
+import { RootOptions } from 'react-dom/client';
+
+declare global {
+	interface SymbolConstructor {
+		readonly observable: symbol;
+	}
+}
+
+/**
+Returns a boolean for whether the two given types are equal.
+
+@link https://github.com/microsoft/TypeScript/issues/27024#issuecomment-421529650
+@link https://stackoverflow.com/questions/68961864/how-does-the-equals-work-in-typescript/68963796#68963796
+*/
+type IsEqual<T, U> =
+	(<G>() => G extends T ? 1 : 2) extends
+	(<G>() => G extends U ? 1 : 2)
+		? true
+		: false;
+
+/**
+Filter out keys from an object.
+
+Returns `never` if `Exclude` is strictly equal to `Key`.
+Returns `never` if `Key` extends `Exclude`.
+Returns `Key` otherwise.
+
+@example
+```
+type Filtered = Filter<'foo', 'foo'>;
+//=> never
+```
+
+@example
+```
+type Filtered = Filter<'bar', string>;
+//=> never
+```
+
+@example
+```
+type Filtered = Filter<'bar', 'foo'>;
+//=> 'bar'
+```
+
+@see {Except}
+*/
+type Filter<KeyType, ExcludeType> = IsEqual<KeyType, ExcludeType> extends true ? never : (KeyType extends ExcludeType ? never : KeyType);
+
+/**
+Create a type from an object type without certain keys.
+
+This type is a stricter version of [`Omit`](https://www.typescriptlang.org/docs/handbook/release-notes/typescript-3-5.html#the-omit-helper-type). The `Omit` type does not restrict the omitted keys to be keys present on the given type, while `Except` does. The benefits of a stricter type are avoiding typos and allowing the compiler to pick up on rename refactors automatically.
+
+This type was proposed to the TypeScript team, which declined it, saying they prefer that libraries implement stricter versions of the built-in types ([microsoft/TypeScript#30825](https://github.com/microsoft/TypeScript/issues/30825#issuecomment-523668235)).
+
+@example
+```
+import type {Except} from 'type-fest';
+
+type Foo = {
+	a: number;
+	b: string;
+	c: boolean;
+};
+
+type FooWithoutA = Except<Foo, 'a' | 'c'>;
+//=> {b: string};
+```
+
+@category Object
+*/
+type Except<ObjectType, KeysType extends keyof ObjectType> = {
+	[KeyType in keyof ObjectType as Filter<KeyType, KeysType>]: ObjectType[KeyType];
+};
+
+/**
+@see Simplify
+*/
+interface SimplifyOptions {
+	/**
+	Do the simplification recursively.
+
+	@default false
+	*/
+	deep?: boolean;
+}
+
+// Flatten a type without worrying about the result.
+type Flatten<
+	AnyType,
+	Options extends SimplifyOptions = {},
+> = Options['deep'] extends true
+	? {[KeyType in keyof AnyType]: Simplify<AnyType[KeyType], Options>}
+	: {[KeyType in keyof AnyType]: AnyType[KeyType]};
+
+/**
+Useful to flatten the type output to improve type hints shown in editors. And also to transform an interface into a type to aide with assignability.
+
+@example
+```
+import type {Simplify} from 'type-fest';
+
+type PositionProps = {
+	top: number;
+	left: number;
+};
+
+type SizeProps = {
+	width: number;
+	height: number;
+};
+
+// In your editor, hovering over `Props` will show a flattened object with all the properties.
+type Props = Simplify<PositionProps & SizeProps>;
+```
+
+Sometimes it is desired to pass a value as a function argument that has a different type. At first inspection it may seem assignable, and then you discover it is not because the `value`'s type definition was defined as an interface. In the following example, `fn` requires an argument of type `Record<string, unknown>`. If the value is defined as a literal, then it is assignable. And if the `value` is defined as type using the `Simplify` utility the value is assignable.  But if the `value` is defined as an interface, it is not assignable because the interface is not sealed and elsewhere a non-string property could be added to the interface.
+
+If the type definition must be an interface (perhaps it was defined in a third-party npm package), then the `value` can be defined as `const value: Simplify<SomeInterface> = ...`. Then `value` will be assignable to the `fn` argument.  Or the `value` can be cast as `Simplify<SomeInterface>` if you can't re-declare the `value`.
+
+@example
+```
+import type {Simplify} from 'type-fest';
+
+interface SomeInterface {
+	foo: number;
+	bar?: string;
+	baz: number | undefined;
+}
+
+type SomeType = {
+	foo: number;
+	bar?: string;
+	baz: number | undefined;
+};
+
+const literal = {foo: 123, bar: 'hello', baz: 456};
+const someType: SomeType = literal;
+const someInterface: SomeInterface = literal;
+
+function fn(object: Record<string, unknown>): void {}
+
+fn(literal); // Good: literal object type is sealed
+fn(someType); // Good: type is sealed
+fn(someInterface); // Error: Index signature for type 'string' is missing in type 'someInterface'. Because `interface` can be re-opened
+fn(someInterface as Simplify<SomeInterface>); // Good: transform an `interface` into a `type`
+```
+
+@link https://github.com/microsoft/TypeScript/issues/15300
+
+@category Object
+*/
+type Simplify<
+	AnyType,
+	Options extends SimplifyOptions = {},
+> = Flatten<AnyType> extends AnyType
+	? Flatten<AnyType, Options>
+	: AnyType;
+
+/**
+Remove any index signatures from the given object type, so that only explicitly defined properties remain.
+
+Use-cases:
+- Remove overly permissive signatures from third-party types.
+
+This type was taken from this [StackOverflow answer](https://stackoverflow.com/a/68261113/420747).
+
+It relies on the fact that an empty object (`{}`) is assignable to an object with just an index signature, like `Record<string, unknown>`, but not to an object with explicitly defined keys, like `Record<'foo' | 'bar', unknown>`.
+
+(The actual value type, `unknown`, is irrelevant and could be any type. Only the key type matters.)
+
+```
+const indexed: Record<string, unknown> = {}; // Allowed
+
+const keyed: Record<'foo', unknown> = {}; // Error
+// => TS2739: Type '{}' is missing the following properties from type 'Record<"foo" | "bar", unknown>': foo, bar
+```
+
+Instead of causing a type error like the above, you can also use a [conditional type](https://www.typescriptlang.org/docs/handbook/2/conditional-types.html) to test whether a type is assignable to another:
+
+```
+type Indexed = {} extends Record<string, unknown>
+	? '✅ `{}` is assignable to `Record<string, unknown>`'
+	: '❌ `{}` is NOT assignable to `Record<string, unknown>`';
+// => '✅ `{}` is assignable to `Record<string, unknown>`'
+
+type Keyed = {} extends Record<'foo' | 'bar', unknown>
+	? "✅ `{}` is assignable to `Record<'foo' | 'bar', unknown>`"
+	: "❌ `{}` is NOT assignable to `Record<'foo' | 'bar', unknown>`";
+// => "❌ `{}` is NOT assignable to `Record<'foo' | 'bar', unknown>`"
+```
+
+Using a [mapped type](https://www.typescriptlang.org/docs/handbook/2/mapped-types.html#further-exploration), you can then check for each `KeyType` of `ObjectType`...
+
+```
+import type {RemoveIndexSignature} from 'type-fest';
+
+type RemoveIndexSignature<ObjectType> = {
+	[KeyType in keyof ObjectType // Map each key of `ObjectType`...
+	]: ObjectType[KeyType]; // ...to its original value, i.e. `RemoveIndexSignature<Foo> == Foo`.
+};
+```
+
+...whether an empty object (`{}`) would be assignable to an object with that `KeyType` (`Record<KeyType, unknown>`)...
+
+```
+import type {RemoveIndexSignature} from 'type-fest';
+
+type RemoveIndexSignature<ObjectType> = {
+	[KeyType in keyof ObjectType
+		// Is `{}` assignable to `Record<KeyType, unknown>`?
+		as {} extends Record<KeyType, unknown>
+			? ... // ✅ `{}` is assignable to `Record<KeyType, unknown>`
+			: ... // ❌ `{}` is NOT assignable to `Record<KeyType, unknown>`
+	]: ObjectType[KeyType];
+};
+```
+
+If `{}` is assignable, it means that `KeyType` is an index signature and we want to remove it. If it is not assignable, `KeyType` is a "real" key and we want to keep it.
+
+```
+import type {RemoveIndexSignature} from 'type-fest';
+
+type RemoveIndexSignature<ObjectType> = {
+	[KeyType in keyof ObjectType
+		as {} extends Record<KeyType, unknown>
+			? never // => Remove this `KeyType`.
+			: KeyType // => Keep this `KeyType` as it is.
+	]: ObjectType[KeyType];
+};
+```
+
+@example
+```
+import type {RemoveIndexSignature} from 'type-fest';
+
+interface Example {
+	// These index signatures will be removed.
+	[x: string]: any
+	[x: number]: any
+	[x: symbol]: any
+	[x: `head-${string}`]: string
+	[x: `${string}-tail`]: string
+	[x: `head-${string}-tail`]: string
+	[x: `${bigint}`]: string
+	[x: `embedded-${number}`]: string
+
+	// These explicitly defined keys will remain.
+	foo: 'bar';
+	qux?: 'baz';
+}
+
+type ExampleWithoutIndexSignatures = RemoveIndexSignature<Example>;
+// => { foo: 'bar'; qux?: 'baz' | undefined; }
+```
+
+@category Object
+*/
+type RemoveIndexSignature<ObjectType> = {
+	[KeyType in keyof ObjectType as {} extends Record<KeyType, unknown>
+		? never
+		: KeyType]: ObjectType[KeyType];
+};
+
+/**
+Create a type that makes the given keys optional. The remaining keys are kept as is. The sister of the `SetRequired` type.
+
+Use-case: You want to define a single model where the only thing that changes is whether or not some of the keys are optional.
+
+@example
+```
+import type {SetOptional} from 'type-fest';
+
+type Foo = {
+	a: number;
+	b?: string;
+	c: boolean;
+}
+
+type SomeOptional = SetOptional<Foo, 'b' | 'c'>;
+// type SomeOptional = {
+// 	a: number;
+// 	b?: string; // Was already optional and still is.
+// 	c?: boolean; // Is now optional.
+// }
+```
+
+@category Object
+*/
+type SetOptional<BaseType, Keys extends keyof BaseType> =
+	Simplify<
+		// Pick just the keys that are readonly from the base type.
+		Except<BaseType, Keys> &
+		// Pick the keys that should be mutable from the base type and make them mutable.
+		Partial<Pick<BaseType, Keys>>
+	>;
+
+/**
+Convert a union type to an intersection type using [distributive conditional types](https://www.typescriptlang.org/docs/handbook/release-notes/typescript-2-8.html#distributive-conditional-types).
+
+Inspired by [this Stack Overflow answer](https://stackoverflow.com/a/50375286/2172153).
+
+@example
+```
+import type {UnionToIntersection} from 'type-fest';
+
+type Union = {the(): void} | {great(arg: string): void} | {escape: boolean};
+
+type Intersection = UnionToIntersection<Union>;
+//=> {the(): void; great(arg: string): void; escape: boolean};
+```
+
+A more applicable example which could make its way into your library code follows.
+
+@example
+```
+import type {UnionToIntersection} from 'type-fest';
+
+class CommandOne {
+	commands: {
+		a1: () => undefined,
+		b1: () => undefined,
+	}
+}
+
+class CommandTwo {
+	commands: {
+		a2: (argA: string) => undefined,
+		b2: (argB: string) => undefined,
+	}
+}
+
+const union = [new CommandOne(), new CommandTwo()].map(instance => instance.commands);
+type Union = typeof union;
+//=> {a1(): void; b1(): void} | {a2(argA: string): void; b2(argB: string): void}
+
+type Intersection = UnionToIntersection<Union>;
+//=> {a1(): void; b1(): void; a2(argA: string): void; b2(argB: string): void}
+```
+
+@category Type
+*/
+type UnionToIntersection<Union> = (
+	// `extends unknown` is always going to be the case and is used to convert the
+	// `Union` into a [distributive conditional
+	// type](https://www.typescriptlang.org/docs/handbook/release-notes/typescript-2-8.html#distributive-conditional-types).
+	Union extends unknown
+		// The union type is used as the only argument to a function since the union
+		// of function arguments is an intersection.
+		? (distributedUnion: Union) => void
+		// This won't happen.
+		: never
+		// Infer the `Intersection` type since TypeScript represents the positional
+		// arguments of unions of functions as an intersection of the union.
+	) extends ((mergedIntersection: infer Intersection) => void)
+		? Intersection
+		: never;
+
+interface ReactRenderer extends WebRenderer {
+    component: ComponentType<this['T']>;
+    storyResult: StoryFnReactReturnType;
+    mount: (ui?: JSX.Element) => Promise<Canvas>;
+}
+interface ReactParameters {
+    /** React renderer configuration */
+    react?: {
+        /**
+         * Whether to enable React Server Components
+         *
+         * @see https://storybook.js.org/docs/get-started/frameworks/nextjs#react-server-components-rsc
+         */
+        rsc?: boolean;
+        /** Options passed to React root creation */
+        rootOptions?: RootOptions;
+    };
+}
+interface ReactTypes extends ReactRenderer {
+    parameters: ReactParameters;
+}
+type StoryFnReactReturnType = JSX.Element;
+
+type AddMocks<TArgs, DefaultArgs> = Simplify<{
+    [T in keyof TArgs]: T extends keyof DefaultArgs ? DefaultArgs[T] extends (...args: any) => any & {
+        mock: {};
+    } ? DefaultArgs[T] : TArgs[T] : TArgs[T];
+}>;
+
+declare function __definePreview<Addons extends PreviewAddon<never>[]>(input: {
+    addons: Addons;
+} & ProjectAnnotations<ReactTypes & InferTypes<Addons>>): ReactPreview<ReactTypes & InferTypes<Addons>>;
+/** @ts-expect-error We cannot implement the meta faithfully here, but that is okay. */
+interface ReactPreview<T extends AddonTypes> extends Preview<ReactTypes & T> {
+    meta<TArgs extends Args, Decorators extends DecoratorFunction<ReactTypes & T, any>, TMetaArgs extends Partial<TArgs>>(meta: {
+        render?: ArgsStoryFn<ReactTypes & T, TArgs>;
+        component?: ComponentType<TArgs>;
+        decorators?: Decorators | Decorators[];
+        args?: TMetaArgs;
+    } & Omit<ComponentAnnotations<ReactTypes & T, TArgs>, 'decorators' | 'component' | 'args' | 'render'>): ReactMeta<ReactTypes & T & {
+        args: Simplify<TArgs & Simplify<RemoveIndexSignature<DecoratorsArgs<ReactTypes & T, Decorators>>>>;
+    }, {
+        args: Partial<TArgs> extends TMetaArgs ? {} : TMetaArgs;
+    }>;
+}
+type DecoratorsArgs<TRenderer extends Renderer, Decorators> = UnionToIntersection<Decorators extends DecoratorFunction<TRenderer, infer TArgs> ? TArgs : unknown>;
+interface ReactMeta<T extends ReactTypes, MetaInput extends ComponentAnnotations<T>>
+/** @ts-expect-error hard */
+ extends Meta<T, MetaInput> {
+    story<TInput extends (() => ReactTypes['storyResult']) | (StoryAnnotations<T, T['args']> & {
+        render: () => ReactTypes['storyResult'];
+    })>(story?: TInput): ReactStory<T, TInput extends () => ReactTypes['storyResult'] ? {
+        render: TInput;
+    } : TInput>;
+    story<TInput extends Simplify<StoryAnnotations<T, AddMocks<T['args'], MetaInput['args']>, SetOptional<T['args'], keyof T['args'] & keyof MetaInput['args']>>>>(story?: TInput
+    /** @ts-expect-error hard */
+    ): ReactStory<T, TInput>;
+}
+interface ReactStory<T extends ReactTypes, TInput extends StoryAnnotations<T, T['args']>> extends Story<T, TInput> {
+    Component: ComponentType<Partial<T['args']>>;
+}
+
+export { type ReactPreview, type ReactStory, __definePreview };

package/dist/preview.js

@@ -1,7 +1,7 @@
 import {
   __definePreview
-} from "./_browser-chunks/chunk-EH3IDVCQ.js";
-import "./_browser-chunks/chunk-XNNKYNNU.js";
+} from "./_browser-chunks/chunk-352EX3YB.js";
+import "./_browser-chunks/chunk-4WKCOEYI.js";
 import "./_browser-chunks/chunk-2SCDRHCG.js";
 import "./_browser-chunks/chunk-HBQ5Y6GW.js";
 import "./_browser-chunks/chunk-BUAOEMNB.js";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@storybook/react",
-  "version": "10.0.0-beta.6",
+  "version": "10.0.0-beta.8",
   "description": "Storybook React renderer",
   "keywords": [
     "storybook"
@@ -54,7 +54,7 @@
   },
   "dependencies": {
     "@storybook/global": "^5.0.0",
-    "@storybook/react-dom-shim": "10.0.0-beta.6"
+    "@storybook/react-dom-shim": "10.0.0-beta.8"
   },
   "devDependencies": {
     "@types/babel-plugin-react-docgen": "^4.2.3",
@@ -80,7 +80,7 @@
   "peerDependencies": {
     "react": "^16.8.0 || ^17.0.0 || ^18.0.0 || ^19.0.0",
     "react-dom": "^16.8.0 || ^17.0.0 || ^18.0.0 || ^19.0.0",
-    "storybook": "^10.0.0-beta.6",
+    "storybook": "^10.0.0-beta.8",
     "typescript": ">= 4.9.x"
   },
   "peerDependenciesMeta": {

package/dist/preview.d.tsx

@@ -1,425 +0,0 @@
-import { ComponentType, JSX } from 'react';
-import { PreviewAddon, InferTypes, AddonTypes, Preview, Meta, Story } from 'storybook/internal/csf';
-import { WebRenderer, Canvas, ProjectAnnotations, Args, DecoratorFunction, ArgsStoryFn, ComponentAnnotations, StoryAnnotations, Renderer } from 'storybook/internal/types';
-import { RootOptions } from 'react-dom/client';
-
-declare global {
-	interface SymbolConstructor {
-		readonly observable: symbol;
-	}
-}
-
-/**
-Returns a boolean for whether the two given types are equal.
-
-@link https://github.com/microsoft/TypeScript/issues/27024#issuecomment-421529650
-@link https://stackoverflow.com/questions/68961864/how-does-the-equals-work-in-typescript/68963796#68963796
-*/
-type IsEqual<T, U> =
-	(<G>() => G extends T ? 1 : 2) extends
-	(<G>() => G extends U ? 1 : 2)
-		? true
-		: false;
-
-/**
-Filter out keys from an object.
-
-Returns `never` if `Exclude` is strictly equal to `Key`.
-Returns `never` if `Key` extends `Exclude`.
-Returns `Key` otherwise.
-
-@example
-```
-type Filtered = Filter<'foo', 'foo'>;
-//=> never
-```
-
-@example
-```
-type Filtered = Filter<'bar', string>;
-//=> never
-```
-
-@example
-```
-type Filtered = Filter<'bar', 'foo'>;
-//=> 'bar'
-```
-
-@see {Except}
-*/
-type Filter<KeyType, ExcludeType> = IsEqual<KeyType, ExcludeType> extends true ? never : (KeyType extends ExcludeType ? never : KeyType);
-
-/**
-Create a type from an object type without certain keys.
-
-This type is a stricter version of [`Omit`](https://www.typescriptlang.org/docs/handbook/release-notes/typescript-3-5.html#the-omit-helper-type). The `Omit` type does not restrict the omitted keys to be keys present on the given type, while `Except` does. The benefits of a stricter type are avoiding typos and allowing the compiler to pick up on rename refactors automatically.
-
-This type was proposed to the TypeScript team, which declined it, saying they prefer that libraries implement stricter versions of the built-in types ([microsoft/TypeScript#30825](https://github.com/microsoft/TypeScript/issues/30825#issuecomment-523668235)).
-
-@example
-```
-import type {Except} from 'type-fest';
-
-type Foo = {
-	a: number;
-	b: string;
-	c: boolean;
-};
-
-type FooWithoutA = Except<Foo, 'a' | 'c'>;
-//=> {b: string};
-```
-
-@category Object
-*/
-type Except<ObjectType, KeysType extends keyof ObjectType> = {
-	[KeyType in keyof ObjectType as Filter<KeyType, KeysType>]: ObjectType[KeyType];
-};
-
-/**
-@see Simplify
-*/
-interface SimplifyOptions {
-	/**
-	Do the simplification recursively.
-
-	@default false
-	*/
-	deep?: boolean;
-}
-
-// Flatten a type without worrying about the result.
-type Flatten<
-	AnyType,
-	Options extends SimplifyOptions = {},
-> = Options['deep'] extends true
-	? {[KeyType in keyof AnyType]: Simplify<AnyType[KeyType], Options>}
-	: {[KeyType in keyof AnyType]: AnyType[KeyType]};
-
-/**
-Useful to flatten the type output to improve type hints shown in editors. And also to transform an interface into a type to aide with assignability.
-
-@example
-```
-import type {Simplify} from 'type-fest';
-
-type PositionProps = {
-	top: number;
-	left: number;
-};
-
-type SizeProps = {
-	width: number;
-	height: number;
-};
-
-// In your editor, hovering over `Props` will show a flattened object with all the properties.
-type Props = Simplify<PositionProps & SizeProps>;
-```
-
-Sometimes it is desired to pass a value as a function argument that has a different type. At first inspection it may seem assignable, and then you discover it is not because the `value`'s type definition was defined as an interface. In the following example, `fn` requires an argument of type `Record<string, unknown>`. If the value is defined as a literal, then it is assignable. And if the `value` is defined as type using the `Simplify` utility the value is assignable.  But if the `value` is defined as an interface, it is not assignable because the interface is not sealed and elsewhere a non-string property could be added to the interface.
-
-If the type definition must be an interface (perhaps it was defined in a third-party npm package), then the `value` can be defined as `const value: Simplify<SomeInterface> = ...`. Then `value` will be assignable to the `fn` argument.  Or the `value` can be cast as `Simplify<SomeInterface>` if you can't re-declare the `value`.
-
-@example
-```
-import type {Simplify} from 'type-fest';
-
-interface SomeInterface {
-	foo: number;
-	bar?: string;
-	baz: number | undefined;
-}
-
-type SomeType = {
-	foo: number;
-	bar?: string;
-	baz: number | undefined;
-};
-
-const literal = {foo: 123, bar: 'hello', baz: 456};
-const someType: SomeType = literal;
-const someInterface: SomeInterface = literal;
-
-function fn(object: Record<string, unknown>): void {}
-
-fn(literal); // Good: literal object type is sealed
-fn(someType); // Good: type is sealed
-fn(someInterface); // Error: Index signature for type 'string' is missing in type 'someInterface'. Because `interface` can be re-opened
-fn(someInterface as Simplify<SomeInterface>); // Good: transform an `interface` into a `type`
-```
-
-@link https://github.com/microsoft/TypeScript/issues/15300
-
-@category Object
-*/
-type Simplify<
-	AnyType,
-	Options extends SimplifyOptions = {},
-> = Flatten<AnyType> extends AnyType
-	? Flatten<AnyType, Options>
-	: AnyType;
-
-/**
-Remove any index signatures from the given object type, so that only explicitly defined properties remain.
-
-Use-cases:
-- Remove overly permissive signatures from third-party types.
-
-This type was taken from this [StackOverflow answer](https://stackoverflow.com/a/68261113/420747).
-
-It relies on the fact that an empty object (`{}`) is assignable to an object with just an index signature, like `Record<string, unknown>`, but not to an object with explicitly defined keys, like `Record<'foo' | 'bar', unknown>`.
-
-(The actual value type, `unknown`, is irrelevant and could be any type. Only the key type matters.)
-
-```
-const indexed: Record<string, unknown> = {}; // Allowed
-
-const keyed: Record<'foo', unknown> = {}; // Error
-// => TS2739: Type '{}' is missing the following properties from type 'Record<"foo" | "bar", unknown>': foo, bar
-```
-
-Instead of causing a type error like the above, you can also use a [conditional type](https://www.typescriptlang.org/docs/handbook/2/conditional-types.html) to test whether a type is assignable to another:
-
-```
-type Indexed = {} extends Record<string, unknown>
-	? '✅ `{}` is assignable to `Record<string, unknown>`'
-	: '❌ `{}` is NOT assignable to `Record<string, unknown>`';
-// => '✅ `{}` is assignable to `Record<string, unknown>`'
-
-type Keyed = {} extends Record<'foo' | 'bar', unknown>
-	? "✅ `{}` is assignable to `Record<'foo' | 'bar', unknown>`"
-	: "❌ `{}` is NOT assignable to `Record<'foo' | 'bar', unknown>`";
-// => "❌ `{}` is NOT assignable to `Record<'foo' | 'bar', unknown>`"
-```
-
-Using a [mapped type](https://www.typescriptlang.org/docs/handbook/2/mapped-types.html#further-exploration), you can then check for each `KeyType` of `ObjectType`...
-
-```
-import type {RemoveIndexSignature} from 'type-fest';
-
-type RemoveIndexSignature<ObjectType> = {
-	[KeyType in keyof ObjectType // Map each key of `ObjectType`...
-	]: ObjectType[KeyType]; // ...to its original value, i.e. `RemoveIndexSignature<Foo> == Foo`.
-};
-```
-
-...whether an empty object (`{}`) would be assignable to an object with that `KeyType` (`Record<KeyType, unknown>`)...
-
-```
-import type {RemoveIndexSignature} from 'type-fest';
-
-type RemoveIndexSignature<ObjectType> = {
-	[KeyType in keyof ObjectType
-		// Is `{}` assignable to `Record<KeyType, unknown>`?
-		as {} extends Record<KeyType, unknown>
-			? ... // ✅ `{}` is assignable to `Record<KeyType, unknown>`
-			: ... // ❌ `{}` is NOT assignable to `Record<KeyType, unknown>`
-	]: ObjectType[KeyType];
-};
-```
-
-If `{}` is assignable, it means that `KeyType` is an index signature and we want to remove it. If it is not assignable, `KeyType` is a "real" key and we want to keep it.
-
-```
-import type {RemoveIndexSignature} from 'type-fest';
-
-type RemoveIndexSignature<ObjectType> = {
-	[KeyType in keyof ObjectType
-		as {} extends Record<KeyType, unknown>
-			? never // => Remove this `KeyType`.
-			: KeyType // => Keep this `KeyType` as it is.
-	]: ObjectType[KeyType];
-};
-```
-
-@example
-```
-import type {RemoveIndexSignature} from 'type-fest';
-
-interface Example {
-	// These index signatures will be removed.
-	[x: string]: any
-	[x: number]: any
-	[x: symbol]: any
-	[x: `head-${string}`]: string
-	[x: `${string}-tail`]: string
-	[x: `head-${string}-tail`]: string
-	[x: `${bigint}`]: string
-	[x: `embedded-${number}`]: string
-
-	// These explicitly defined keys will remain.
-	foo: 'bar';
-	qux?: 'baz';
-}
-
-type ExampleWithoutIndexSignatures = RemoveIndexSignature<Example>;
-// => { foo: 'bar'; qux?: 'baz' | undefined; }
-```
-
-@category Object
-*/
-type RemoveIndexSignature<ObjectType> = {
-	[KeyType in keyof ObjectType as {} extends Record<KeyType, unknown>
-		? never
-		: KeyType]: ObjectType[KeyType];
-};
-
-/**
-Create a type that makes the given keys optional. The remaining keys are kept as is. The sister of the `SetRequired` type.
-
-Use-case: You want to define a single model where the only thing that changes is whether or not some of the keys are optional.
-
-@example
-```
-import type {SetOptional} from 'type-fest';
-
-type Foo = {
-	a: number;
-	b?: string;
-	c: boolean;
-}
-
-type SomeOptional = SetOptional<Foo, 'b' | 'c'>;
-// type SomeOptional = {
-// 	a: number;
-// 	b?: string; // Was already optional and still is.
-// 	c?: boolean; // Is now optional.
-// }
-```
-
-@category Object
-*/
-type SetOptional<BaseType, Keys extends keyof BaseType> =
-	Simplify<
-		// Pick just the keys that are readonly from the base type.
-		Except<BaseType, Keys> &
-		// Pick the keys that should be mutable from the base type and make them mutable.
-		Partial<Pick<BaseType, Keys>>
-	>;
-
-/**
-Convert a union type to an intersection type using [distributive conditional types](https://www.typescriptlang.org/docs/handbook/release-notes/typescript-2-8.html#distributive-conditional-types).
-
-Inspired by [this Stack Overflow answer](https://stackoverflow.com/a/50375286/2172153).
-
-@example
-```
-import type {UnionToIntersection} from 'type-fest';
-
-type Union = {the(): void} | {great(arg: string): void} | {escape: boolean};
-
-type Intersection = UnionToIntersection<Union>;
-//=> {the(): void; great(arg: string): void; escape: boolean};
-```
-
-A more applicable example which could make its way into your library code follows.
-
-@example
-```
-import type {UnionToIntersection} from 'type-fest';
-
-class CommandOne {
-	commands: {
-		a1: () => undefined,
-		b1: () => undefined,
-	}
-}
-
-class CommandTwo {
-	commands: {
-		a2: (argA: string) => undefined,
-		b2: (argB: string) => undefined,
-	}
-}
-
-const union = [new CommandOne(), new CommandTwo()].map(instance => instance.commands);
-type Union = typeof union;
-//=> {a1(): void; b1(): void} | {a2(argA: string): void; b2(argB: string): void}
-
-type Intersection = UnionToIntersection<Union>;
-//=> {a1(): void; b1(): void; a2(argA: string): void; b2(argB: string): void}
-```
-
-@category Type
-*/
-type UnionToIntersection<Union> = (
-	// `extends unknown` is always going to be the case and is used to convert the
-	// `Union` into a [distributive conditional
-	// type](https://www.typescriptlang.org/docs/handbook/release-notes/typescript-2-8.html#distributive-conditional-types).
-	Union extends unknown
-		// The union type is used as the only argument to a function since the union
-		// of function arguments is an intersection.
-		? (distributedUnion: Union) => void
-		// This won't happen.
-		: never
-		// Infer the `Intersection` type since TypeScript represents the positional
-		// arguments of unions of functions as an intersection of the union.
-	) extends ((mergedIntersection: infer Intersection) => void)
-		? Intersection
-		: never;
-
-interface ReactRenderer extends WebRenderer {
-    component: ComponentType<this['T']>;
-    storyResult: StoryFnReactReturnType;
-    mount: (ui?: JSX.Element) => Promise<Canvas>;
-}
-interface ReactParameters {
-    /** React renderer configuration */
-    react?: {
-        /**
-         * Whether to enable React Server Components
-         *
-         * @see https://storybook.js.org/docs/get-started/frameworks/nextjs#react-server-components-rsc
-         */
-        rsc?: boolean;
-        /** Options passed to React root creation */
-        rootOptions?: RootOptions;
-    };
-}
-interface ReactTypes extends ReactRenderer {
-    parameters: ReactParameters;
-}
-type StoryFnReactReturnType = JSX.Element;
-
-type AddMocks<TArgs, DefaultArgs> = Simplify<{
-    [T in keyof TArgs]: T extends keyof DefaultArgs ? DefaultArgs[T] extends (...args: any) => any & {
-        mock: {};
-    } ? DefaultArgs[T] : TArgs[T] : TArgs[T];
-}>;
-
-declare function __definePreview<Addons extends PreviewAddon<never>[]>(input: {
-    addons: Addons;
-} & ProjectAnnotations<ReactTypes & InferTypes<Addons>>): ReactPreview<ReactTypes & InferTypes<Addons>>;
-/** @ts-expect-error We cannot implement the meta faithfully here, but that is okay. */
-interface ReactPreview<T extends AddonTypes> extends Preview<ReactTypes & T> {
-    meta<TArgs extends Args, Decorators extends DecoratorFunction<ReactTypes & T, any>, TMetaArgs extends Partial<TArgs>>(meta: {
-        render?: ArgsStoryFn<ReactTypes & T, TArgs>;
-        component?: ComponentType<TArgs>;
-        decorators?: Decorators | Decorators[];
-        args?: TMetaArgs;
-    } & Omit<ComponentAnnotations<ReactTypes & T, TArgs>, 'decorators' | 'component' | 'args' | 'render'>): ReactMeta<ReactTypes & T & {
-        args: Simplify<TArgs & Simplify<RemoveIndexSignature<DecoratorsArgs<ReactTypes & T, Decorators>>>>;
-    }, {
-        args: Partial<TArgs> extends TMetaArgs ? {} : TMetaArgs;
-    }>;
-}
-type DecoratorsArgs<TRenderer extends Renderer, Decorators> = UnionToIntersection<Decorators extends DecoratorFunction<TRenderer, infer TArgs> ? TArgs : unknown>;
-interface ReactMeta<T extends ReactTypes, MetaInput extends ComponentAnnotations<T>>
-/** @ts-expect-error hard */
- extends Meta<T, MetaInput> {
-    story<TInput extends (() => ReactTypes['storyResult']) | (StoryAnnotations<T, T['args']> & {
-        render: () => ReactTypes['storyResult'];
-    })>(story?: TInput): ReactStory<T, TInput extends () => ReactTypes['storyResult'] ? {
-        render: TInput;
-    } : TInput>;
-    story<TInput extends Simplify<StoryAnnotations<T, AddMocks<T['args'], MetaInput['args']>, SetOptional<T['args'], keyof T['args'] & keyof MetaInput['args']>>>>(story?: TInput
-    /** @ts-expect-error hard */
-    ): ReactStory<T, TInput>;
-}
-interface ReactStory<T extends ReactTypes, TInput extends StoryAnnotations<T, T['args']>> extends Story<T, TInput> {
-    Component: ComponentType<Partial<T['args']>>;
-}
-
-export { type ReactPreview, type ReactStory, __definePreview };