@storybook/react 10.6.0-alpha.0 → 10.6.0-alpha.1

package/dist/index.d.ts

@@ -1,1030 +1,7 @@
-import { ComponentType, JSX, ComponentProps } from 'react';
-import { WebRenderer, Canvas, Args, ComponentAnnotations, AnnotatedStoryFn, ArgsStoryFn, ArgsFromMeta, StoryAnnotations, StrictArgs, DecoratorFunction, LoaderFunction, StoryContext as StoryContext$1, ProjectAnnotations, NamedOrDefaultProjectAnnotations, NormalizedProjectAnnotations, StoryAnnotationsOrFn, ComposedStoryFn, Store_CSFExports, StoriesWithPartialProps, Renderer } from 'storybook/internal/types';
-export { ArgTypes, Args, Parameters, StrictArgs } from 'storybook/internal/types';
-import { RootOptions } from 'react-dom/client';
-import { PreviewAddon, InferTypes, AddonTypes, Preview as Preview$1, Meta as Meta$1, Story } from 'storybook/internal/csf';
-
-/**
-Convert a union type to an intersection type.
-
-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}
-```
-
-@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)
-	// The `& Union` is to ensure result of `UnionToIntersection<A | B>` is always assignable to `A | B`
-	? Intersection & Union
-	: never;
-
-/**
-Create a union of all keys from a given type, even those exclusive to specific union members.
-
-Unlike the native `keyof` keyword, which returns keys present in **all** union members, this type returns keys from **any** member.
-
-@link https://stackoverflow.com/a/49402091
-
-@example
-```
-import type {KeysOfUnion} from 'type-fest';
-
-type A = {
-	common: string;
-	a: number;
-};
-
-type B = {
-	common: string;
-	b: string;
-};
-
-type C = {
-	common: string;
-	c: boolean;
-};
-
-type Union = A | B | C;
-
-type CommonKeys = keyof Union;
-//=> 'common'
-
-type AllKeys = KeysOfUnion<Union>;
-//=> 'common' | 'a' | 'b' | 'c'
-```
-
-@category Object
-*/
-type KeysOfUnion<ObjectType> =
-	// Hack to fix https://github.com/sindresorhus/type-fest/issues/1008
-	keyof UnionToIntersection<ObjectType extends unknown ? Record<keyof ObjectType, never> : never>;
-
-/**
-Returns a boolean for whether the given type is `any`.
-
-@link https://stackoverflow.com/a/49928360/1490091
-
-Useful in type utilities, such as disallowing `any`s to be passed to a function.
-
-@example
-```
-import type {IsAny} from 'type-fest';
-
-const typedObject = {a: 1, b: 2} as const;
-const anyObject: any = {a: 1, b: 2};
-
-function get<O extends (IsAny<O> extends true ? {} : Record<string, number>), K extends keyof O = keyof O>(object: O, key: K) {
-	return object[key];
-}
-
-const typedA = get(typedObject, 'a');
-//=> 1
-
-const anyA = get(anyObject, 'a');
-//=> any
-```
-
-@category Type Guard
-@category Utilities
-*/
-type IsAny<T> = 0 extends 1 & NoInfer<T> ? true : false;
-
-/**
-Returns a boolean for whether the given key is an optional key of type.
-
-This is useful when writing utility types or schema validators that need to differentiate `optional` keys.
-
-@example
-```
-import type {IsOptionalKeyOf} from 'type-fest';
-
-type User = {
-	name: string;
-	surname: string;
-
-	luckyNumber?: number;
-};
-
-type Admin = {
-	name: string;
-	surname?: string;
-};
-
-type T1 = IsOptionalKeyOf<User, 'luckyNumber'>;
-//=> true
-
-type T2 = IsOptionalKeyOf<User, 'name'>;
-//=> false
-
-type T3 = IsOptionalKeyOf<User, 'name' | 'luckyNumber'>;
-//=> boolean
-
-type T4 = IsOptionalKeyOf<User | Admin, 'name'>;
-//=> false
-
-type T5 = IsOptionalKeyOf<User | Admin, 'surname'>;
-//=> boolean
-```
-
-@category Type Guard
-@category Utilities
-*/
-type IsOptionalKeyOf<Type extends object, Key extends keyof Type> =
-	IsAny<Type | Key> extends true ? never
-		: Key extends keyof Type
-			? Type extends Record<Key, Type[Key]>
-				? false
-				: true
-			: false;
-
-/**
-Extract all optional keys from the given type.
-
-This is useful when you want to create a new type that contains different type values for the optional keys only.
-
-@example
-```
-import type {OptionalKeysOf, Except} from 'type-fest';
-
-type User = {
-	name: string;
-	surname: string;
-
-	luckyNumber?: number;
-};
-
-const REMOVE_FIELD = Symbol('remove field symbol');
-type UpdateOperation<Entity extends object> = Except<Partial<Entity>, OptionalKeysOf<Entity>> & {
-	[Key in OptionalKeysOf<Entity>]?: Entity[Key] | typeof REMOVE_FIELD;
-};
-
-const update1: UpdateOperation<User> = {
-	name: 'Alice',
-};
-
-const update2: UpdateOperation<User> = {
-	name: 'Bob',
-	luckyNumber: REMOVE_FIELD,
-};
-```
-
-@category Utilities
-*/
-type OptionalKeysOf<Type extends object> =
-	Type extends unknown // For distributing `Type`
-		? (keyof {[Key in keyof Type as
-			IsOptionalKeyOf<Type, Key> extends false
-				? never
-				: Key
-			]: never
-		}) & keyof Type // Intersect with `keyof Type` to ensure result of `OptionalKeysOf<Type>` is always assignable to `keyof Type`
-		: never; // Should never happen
-
-/**
-Extract all required keys from the given type.
-
-This is useful when you want to create a new type that contains different type values for the required keys only or use the list of keys for validation purposes, etc...
-
-@example
-```
-import type {RequiredKeysOf} from 'type-fest';
-
-declare function createValidation<
-	Entity extends object,
-	Key extends RequiredKeysOf<Entity> = RequiredKeysOf<Entity>,
->(field: Key, validator: (value: Entity[Key]) => boolean): (entity: Entity) => boolean;
-
-type User = {
-	name: string;
-	surname: string;
-	luckyNumber?: number;
-};
-
-const validator1 = createValidation<User>('name', value => value.length < 25);
-const validator2 = createValidation<User>('surname', value => value.length < 25);
-
-// @ts-expect-error
-const validator3 = createValidation<User>('luckyNumber', value => value > 0);
-// Error: Argument of type '"luckyNumber"' is not assignable to parameter of type '"name" | "surname"'.
-```
-
-@category Utilities
-*/
-type RequiredKeysOf<Type extends object> =
-	Type extends unknown // For distributing `Type`
-		? Exclude<keyof Type, OptionalKeysOf<Type>>
-		: never; // Should never happen
-
-/**
-Returns a boolean for whether the given type is `never`.
-
-@link https://github.com/microsoft/TypeScript/issues/31751#issuecomment-498526919
-@link https://stackoverflow.com/a/53984913/10292952
-@link https://www.zhenghao.io/posts/ts-never
-
-Useful in type utilities, such as checking if something does not occur.
-
-@example
-```
-import type {IsNever, And} from 'type-fest';
-
-type A = IsNever<never>;
-//=> true
-
-type B = IsNever<any>;
-//=> false
-
-type C = IsNever<unknown>;
-//=> false
-
-type D = IsNever<never[]>;
-//=> false
-
-type E = IsNever<object>;
-//=> false
-
-type F = IsNever<string>;
-//=> false
-```
-
-@example
-```
-import type {IsNever} from 'type-fest';
-
-type IsTrue<T> = T extends true ? true : false;
-
-// When a distributive conditional is instantiated with `never`, the entire conditional results in `never`.
-type A = IsTrue<never>;
-//=> never
-
-// If you don't want that behaviour, you can explicitly add an `IsNever` check before the distributive conditional.
-type IsTrueFixed<T> =
-	IsNever<T> extends true ? false : T extends true ? true : false;
-
-type B = IsTrueFixed<never>;
-//=> false
-```
-
-@category Type Guard
-@category Utilities
-*/
-type IsNever<T> = [T] extends [never] ? true : false;
-
-/**
-An if-else-like type that resolves depending on whether the given `boolean` type is `true` or `false`.
-
-Use-cases:
-- You can use this in combination with `Is*` types to create an if-else-like experience. For example, `If<IsAny<any>, 'is any', 'not any'>`.
-
-Note:
-- Returns a union of if branch and else branch if the given type is `boolean` or `any`. For example, `If<boolean, 'Y', 'N'>` will return `'Y' | 'N'`.
-- Returns the else branch if the given type is `never`. For example, `If<never, 'Y', 'N'>` will return `'N'`.
-
-@example
-```
-import type {If} from 'type-fest';
-
-type A = If<true, 'yes', 'no'>;
-//=> 'yes'
-
-type B = If<false, 'yes', 'no'>;
-//=> 'no'
-
-type C = If<boolean, 'yes', 'no'>;
-//=> 'yes' | 'no'
-
-type D = If<any, 'yes', 'no'>;
-//=> 'yes' | 'no'
-
-type E = If<never, 'yes', 'no'>;
-//=> 'no'
-```
-
-@example
-```
-import type {If, IsAny, IsNever} from 'type-fest';
-
-type A = If<IsAny<unknown>, 'is any', 'not any'>;
-//=> 'not any'
-
-type B = If<IsNever<never>, 'is never', 'not never'>;
-//=> 'is never'
-```
-
-@example
-```
-import type {If, IsEqual} from 'type-fest';
-
-type IfEqual<T, U, IfBranch, ElseBranch> = If<IsEqual<T, U>, IfBranch, ElseBranch>;
-
-type A = IfEqual<string, string, 'equal', 'not equal'>;
-//=> 'equal'
-
-type B = IfEqual<string, number, 'equal', 'not equal'>;
-//=> 'not equal'
-```
-
-Note: Sometimes using the `If` type can make an implementation non–tail-recursive, which can impact performance. In such cases, it’s better to use a conditional directly. Refer to the following example:
-
-@example
-```
-import type {If, IsEqual, StringRepeat} from 'type-fest';
-
-type HundredZeroes = StringRepeat<'0', 100>;
-
-// The following implementation is not tail recursive
-type Includes<S extends string, Char extends string> =
-	S extends `${infer First}${infer Rest}`
-		? If<IsEqual<First, Char>,
-			'found',
-			Includes<Rest, Char>>
-		: 'not found';
-
-// Hence, instantiations with long strings will fail
-// @ts-expect-error
-type Fails = Includes<HundredZeroes, '1'>;
-//           ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-// Error: Type instantiation is excessively deep and possibly infinite.
-
-// However, if we use a simple conditional instead of `If`, the implementation becomes tail-recursive
-type IncludesWithoutIf<S extends string, Char extends string> =
-	S extends `${infer First}${infer Rest}`
-		? IsEqual<First, Char> extends true
-			? 'found'
-			: IncludesWithoutIf<Rest, Char>
-		: 'not found';
-
-// Now, instantiations with long strings will work
-type Works = IncludesWithoutIf<HundredZeroes, '1'>;
-//=> 'not found'
-```
-
-@category Type Guard
-@category Utilities
-*/
-type If<Type extends boolean, IfBranch, ElseBranch> =
-	IsNever<Type> extends true
-		? ElseBranch
-		: Type extends true
-			? IfBranch
-			: ElseBranch;
-
-/**
-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;
-
-declare function fn(object: Record<string, unknown>): void;
-
-fn(literal); // Good: literal object type is sealed
-fn(someType); // Good: type is sealed
-// @ts-expect-error
-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
-@see {@link SimplifyDeep}
-@category Object
-*/
-type Simplify<T> = {[KeyType in keyof T]: T[KeyType]} & {};
-
-/**
-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
-
-Use-cases:
-- If you want to make a conditional branch based on the result of a comparison of two types.
-
-@example
-```
-import type {IsEqual} from 'type-fest';
-
-// This type returns a boolean for whether the given array includes the given item.
-// `IsEqual` is used to compare the given array at position 0 and the given item and then return true if they are equal.
-type Includes<Value extends readonly any[], Item> =
-	Value extends readonly [Value[0], ...infer rest]
-		? IsEqual<Value[0], Item> extends true
-			? true
-			: Includes<rest, Item>
-		: false;
-```
-
-@category Type Guard
-@category Utilities
-*/
-type IsEqual<A, B> =
-	[A] extends [B]
-		? [B] extends [A]
-			? _IsEqual<A, B>
-			: false
-		: false;
-
-// This version fails the `equalWrappedTupleIntersectionToBeNeverAndNeverExpanded` test in `test-d/is-equal.ts`.
-type _IsEqual<A, B> =
-	(<G>() => G extends A & G | G ? 1 : 2) extends
-	(<G>() => G extends B & G | G ? 1 : 2)
-		? true
-		: false;
-
-/**
-Omit any index signatures from the given object type, leaving only explicitly defined properties.
-
-This is the counterpart of `PickIndexSignature`.
-
-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
-
-// @ts-expect-error
-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>`';
-
-type IndexedResult = Indexed;
-//=> '✅ `{}` 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>`';
-
-type KeyedResult = Keyed;
-//=> '❌ `{}` 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`...
-
-```
-type OmitIndexSignature<ObjectType> = {
-	[KeyType in keyof ObjectType // Map each key of `ObjectType`...
-	]: ObjectType[KeyType]; // ...to its original value, i.e. `OmitIndexSignature<Foo> == Foo`.
-};
-```
-
-...whether an empty object (`{}`) would be assignable to an object with that `KeyType` (`Record<KeyType, unknown>`)...
-
-```
-type OmitIndexSignature<ObjectType> = {
-	[KeyType in keyof ObjectType
-	// Is `{}` assignable to `Record<KeyType, unknown>`?
-	as {} extends Record<KeyType, unknown>
-		? never // ✅ `{}` is assignable to `Record<KeyType, unknown>`
-		: KeyType // ❌ `{}` 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.
-
-@example
-```
-import type {OmitIndexSignature} from 'type-fest';
-
-type 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 = OmitIndexSignature<Example>;
-//=> {foo: 'bar'; qux?: 'baz'}
-```
-
-@see {@link PickIndexSignature}
-@category Object
-*/
-type OmitIndexSignature<ObjectType> = {
-	[KeyType in keyof ObjectType as {} extends Record<KeyType, unknown>
-		? never
-		: KeyType]: ObjectType[KeyType];
-};
-
-/**
-Pick only index signatures from the given object type, leaving out all explicitly defined properties.
-
-This is the counterpart of `OmitIndexSignature`.
-
-@example
-```
-import type {PickIndexSignature} from 'type-fest';
-
-declare const symbolKey: unique symbol;
-
-type Example = {
-	// These index signatures will remain.
-	[x: string]: unknown;
-	[x: number]: unknown;
-	[x: symbol]: unknown;
-	[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 be removed.
-	['kebab-case-key']: string;
-	[symbolKey]: string;
-	foo: 'bar';
-	qux?: 'baz';
-};
-
-type ExampleIndexSignature = PickIndexSignature<Example>;
-// {
-// 	[x: string]: unknown;
-// 	[x: number]: unknown;
-// 	[x: symbol]: unknown;
-// 	[x: `head-${string}`]: string;
-// 	[x: `${string}-tail`]: string;
-// 	[x: `head-${string}-tail`]: string;
-// 	[x: `${bigint}`]: string;
-// 	[x: `embedded-${number}`]: string;
-// }
-```
-
-@see {@link OmitIndexSignature}
-@category Object
-*/
-type PickIndexSignature<ObjectType> = {
-	[KeyType in keyof ObjectType as {} extends Record<KeyType, unknown>
-		? KeyType
-		: never]: ObjectType[KeyType];
-};
-
-// Merges two objects without worrying about index signatures.
-type SimpleMerge<Destination, Source> = Simplify<{
-	[Key in keyof Destination as Key extends keyof Source ? never : Key]: Destination[Key];
-} & Source>;
-
-/**
-Merge two types into a new type. Keys of the second type overrides keys of the first type.
-
-This is different from the TypeScript `&` (intersection) operator. With `&`, conflicting property types are intersected, which often results in `never`. For example, `{a: string} & {a: number}` makes `a` become `string & number`, which resolves to `never`. With `Merge`, the second type's keys cleanly override the first, so `Merge<{a: string}, {a: number}>` gives `{a: number}` as expected. `Merge` also produces a flattened type (via `Simplify`), making it more readable in IDE tooltips compared to `A & B`.
-
-@example
-```
-import type {Merge} from 'type-fest';
-
-type Foo = {
-	a: string;
-	b: number;
-};
-
-type Bar = {
-	a: number; // Conflicts with Foo['a']
-	c: boolean;
-};
-
-// With `&`, `a` becomes `string & number` which is `never`. Not what you want.
-type WithIntersection = (Foo & Bar)['a'];
-//=> never
-
-// With `Merge`, `a` is cleanly overridden to `number`.
-type WithMerge = Merge<Foo, Bar>['a'];
-//=> number
-```
-
-@example
-```
-import type {Merge} from 'type-fest';
-
-type Foo = {
-	[x: string]: unknown;
-	[x: number]: unknown;
-	foo: string;
-	bar: symbol;
-};
-
-type Bar = {
-	[x: number]: number;
-	[x: symbol]: unknown;
-	bar: Date;
-	baz: boolean;
-};
-
-export type FooBar = Merge<Foo, Bar>;
-//=> {
-// 	[x: string]: unknown;
-// 	[x: number]: number;
-// 	[x: symbol]: unknown;
-// 	foo: string;
-// 	bar: Date;
-// 	baz: boolean;
-// }
-```
-
-Note: If you want a merge type that more accurately reflects the runtime behavior of object spread or `Object.assign`, refer to the {@link ObjectMerge} type.
-
-@see {@link ObjectMerge}
-@category Object
-*/
-type Merge<Destination, Source> =
-	Destination extends unknown // For distributing `Destination`
-		? Source extends unknown // For distributing `Source`
-			? If<IsEqual<Destination, Source>, Destination, _Merge<Destination, Source>>
-			: never // Should never happen
-		: never; // Should never happen
-
-type _Merge<Destination, Source> =
-	Simplify<
-		SimpleMerge<PickIndexSignature<Destination>, PickIndexSignature<Source>>
-		& SimpleMerge<OmitIndexSignature<Destination>, OmitIndexSignature<Source>>
-	>;
-
-/**
-Works similar to the built-in `Pick` utility type, except for the following differences:
-- Distributes over union types and allows picking keys from any member of the union type.
-- Primitives types are returned as-is.
-- Picks all keys if `Keys` is `any`.
-- Doesn't pick `number` from a `string` index signature.
-
-@example
-```
-type ImageUpload = {
-	url: string;
-	size: number;
-	thumbnailUrl: string;
-};
-
-type VideoUpload = {
-	url: string;
-	duration: number;
-	encodingFormat: string;
-};
-
-// Distributes over union types and allows picking keys from any member of the union type
-type MediaDisplay = HomomorphicPick<ImageUpload | VideoUpload, "url" | "size" | "duration">;
-//=> {url: string; size: number} | {url: string; duration: number}
-
-// Primitive types are returned as-is
-type Primitive = HomomorphicPick<string | number, 'toUpperCase' | 'toString'>;
-//=> string | number
-
-// Picks all keys if `Keys` is `any`
-type Any = HomomorphicPick<{a: 1; b: 2} | {c: 3}, any>;
-//=> {a: 1; b: 2} | {c: 3}
-
-// Doesn't pick `number` from a `string` index signature
-type IndexSignature = HomomorphicPick<{[k: string]: unknown}, number>;
-//=> {}
-*/
-type HomomorphicPick<T, Keys extends KeysOfUnion<T>> = {
-	[P in keyof T as Extract<P, Keys>]: T[P]
-};
-
-/**
-Merges user specified options with default options.
-
-@example
-```
-type PathsOptions = {maxRecursionDepth?: number; leavesOnly?: boolean};
-type DefaultPathsOptions = {maxRecursionDepth: 10; leavesOnly: false};
-type SpecifiedOptions = {leavesOnly: true};
-
-type Result = ApplyDefaultOptions<PathsOptions, DefaultPathsOptions, SpecifiedOptions>;
-//=> {maxRecursionDepth: 10; leavesOnly: true}
-```
-
-@example
-```
-// Complains if default values are not provided for optional options
-
-type PathsOptions = {maxRecursionDepth?: number; leavesOnly?: boolean};
-type DefaultPathsOptions = {maxRecursionDepth: 10};
-type SpecifiedOptions = {};
-
-type Result = ApplyDefaultOptions<PathsOptions, DefaultPathsOptions, SpecifiedOptions>;
-//                                              ~~~~~~~~~~~~~~~~~~~
-// Property 'leavesOnly' is missing in type 'DefaultPathsOptions' but required in type '{ maxRecursionDepth: number; leavesOnly: boolean; }'.
-```
-
-@example
-```
-// Complains if an option's default type does not conform to the expected type
-
-type PathsOptions = {maxRecursionDepth?: number; leavesOnly?: boolean};
-type DefaultPathsOptions = {maxRecursionDepth: 10; leavesOnly: 'no'};
-type SpecifiedOptions = {};
-
-type Result = ApplyDefaultOptions<PathsOptions, DefaultPathsOptions, SpecifiedOptions>;
-//                                              ~~~~~~~~~~~~~~~~~~~
-// Types of property 'leavesOnly' are incompatible. Type 'string' is not assignable to type 'boolean'.
-```
-
-@example
-```
-// Complains if an option's specified type does not conform to the expected type
-
-type PathsOptions = {maxRecursionDepth?: number; leavesOnly?: boolean};
-type DefaultPathsOptions = {maxRecursionDepth: 10; leavesOnly: false};
-type SpecifiedOptions = {leavesOnly: 'yes'};
-
-type Result = ApplyDefaultOptions<PathsOptions, DefaultPathsOptions, SpecifiedOptions>;
-//                                                                   ~~~~~~~~~~~~~~~~
-// Types of property 'leavesOnly' are incompatible. Type 'string' is not assignable to type 'boolean'.
-```
-*/
-type ApplyDefaultOptions<
-	Options extends object,
-	Defaults extends Simplify<Omit<Required<Options>, RequiredKeysOf<Options>> & Partial<Record<RequiredKeysOf<Options>, never>>>,
-	SpecifiedOptions extends Options,
-> =
-	If<IsAny<SpecifiedOptions>, Defaults,
-		If<IsNever<SpecifiedOptions>, Defaults,
-			Simplify<Merge<Defaults, {
-				[Key in keyof SpecifiedOptions
-				as Key extends OptionalKeysOf<Options> ? undefined extends SpecifiedOptions[Key] ? never : Key : Key
-				]: SpecifiedOptions[Key]
-			}> & Required<Options>>>>;
-
-/**
-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);
-
-type ExceptOptions = {
-	/**
-	Disallow assigning non-specified properties.
-
-	Note that any omitted properties in the resulting type will be present in autocomplete as `undefined`.
-
-	@default false
-	*/
-	requireExactProps?: boolean;
-};
-
-type DefaultExceptOptions = {
-	requireExactProps: false;
-};
-
-/**
-Create a type from an object type without certain keys.
-
-We recommend setting the `requireExactProps` option to `true`.
-
-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;
-};
-
-type FooWithoutA = Except<Foo, 'a'>;
-//=> {b: string}
-
-// @ts-expect-error
-const fooWithoutA: FooWithoutA = {a: 1, b: '2'};
-// errors: 'a' does not exist in type '{ b: string; }'
-
-type FooWithoutB = Except<Foo, 'b', {requireExactProps: true}>;
-//=> {a: number} & Partial<Record<'b', never>>
-
-// @ts-expect-error
-const fooWithoutB: FooWithoutB = {a: 1, b: '2'};
-// errors at 'b': Type 'string' is not assignable to type 'undefined'.
-
-// The `Omit` utility type doesn't work when omitting specific keys from objects containing index signatures.
-
-// Consider the following example:
-
-type UserData = {
-	[metadata: string]: string;
-	email: string;
-	name: string;
-	role: 'admin' | 'user';
-};
-
-// `Omit` clearly doesn't behave as expected in this case:
-type PostPayload = Omit<UserData, 'email'>;
-//=> {[x: string]: string; [x: number]: string}
-
-// In situations like this, `Except` works better.
-// It simply removes the `email` key while preserving all the other keys.
-type PostPayloadFixed = Except<UserData, 'email'>;
-//=> {[x: string]: string; name: string; role: 'admin' | 'user'}
-```
-
-@category Object
-*/
-type Except<ObjectType, KeysType extends keyof ObjectType, Options extends ExceptOptions = {}> =
-	_Except<ObjectType, KeysType, ApplyDefaultOptions<ExceptOptions, DefaultExceptOptions, Options>>;
-
-type _Except<ObjectType, KeysType extends keyof ObjectType, Options extends Required<ExceptOptions>> = {
-	[KeyType in keyof ObjectType as Filter<KeyType, KeysType>]: ObjectType[KeyType];
-} & (Options['requireExactProps'] extends true
-	? Partial<Record<KeysType, never>>
-	: {});
-
-/**
-Create a type that makes the given keys optional, while keeping the remaining keys as is.
-
-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'>;
-//=> {a: number; b?: string; c?: boolean}
-```
-
-@category Object
-*/
-type SetOptional<BaseType, Keys extends keyof BaseType> =
-	(BaseType extends (...arguments_: never) => any
-		? (...arguments_: Parameters<BaseType>) => ReturnType<BaseType>
-		: unknown)
-	& _SetOptional<BaseType, Keys>;
-
-type _SetOptional<BaseType, Keys extends keyof BaseType> =
-	BaseType extends unknown // To distribute `BaseType` when it's a union type.
-		? 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<HomomorphicPick<BaseType, Keys>>
-		>
-		: 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;
-
-/**
- * Metadata to configure the stories for a component.
- *
- * @see [Default export](https://storybook.js.org/docs/api/csf#default-export)
- */
-type Meta<TCmpOrArgs = Args> = [TCmpOrArgs] extends [ComponentType<any>] ? ComponentAnnotations<ReactRenderer, ComponentProps<TCmpOrArgs>> : ComponentAnnotations<ReactRenderer, TCmpOrArgs>;
-/**
- * Story function that represents a CSFv2 component example.
- *
- * @see [Named Story exports](https://storybook.js.org/docs/api/csf#named-story-exports)
- */
-type StoryFn<TCmpOrArgs = Args> = [TCmpOrArgs] extends [ComponentType<any>] ? AnnotatedStoryFn<ReactRenderer, ComponentProps<TCmpOrArgs>> : AnnotatedStoryFn<ReactRenderer, TCmpOrArgs>;
-/**
- * Story object that represents a CSFv3 component example.
- *
- * @see [Named Story exports](https://storybook.js.org/docs/api/csf#named-story-exports)
- */
-type StoryObj<TMetaOrCmpOrArgs = Args> = [TMetaOrCmpOrArgs] extends [
-    {
-        render?: ArgsStoryFn<ReactRenderer, any>;
-        component?: infer Component;
-        args?: infer DefaultArgs;
-    }
-] ? Simplify<(Component extends ComponentType<any> ? ComponentProps<Component> : unknown) & ArgsFromMeta<ReactRenderer, TMetaOrCmpOrArgs>> extends infer TArgs ? StoryAnnotations<ReactRenderer, AddMocks<TArgs, DefaultArgs>, SetOptional<TArgs, keyof TArgs & keyof DefaultArgs>> : never : TMetaOrCmpOrArgs extends ComponentType<any> ? StoryAnnotations<ReactRenderer, ComponentProps<TMetaOrCmpOrArgs>> : StoryAnnotations<ReactRenderer, TMetaOrCmpOrArgs>;
-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];
-}>;
-type Decorator<TArgs = StrictArgs> = DecoratorFunction<ReactRenderer, TArgs>;
-type Loader<TArgs = StrictArgs> = LoaderFunction<ReactRenderer, TArgs>;
-type StoryContext<TArgs = StrictArgs> = StoryContext$1<ReactRenderer, TArgs>;
-type Preview = ProjectAnnotations<ReactRenderer>;
+import { _ as ReactRenderer, a as AddMocks, c as Decorator, d as Parameters, f as Preview, g as StrictArgs, h as StoryObj, i as __definePreview, l as Loader, m as StoryFn, n as ReactPreview, o as ArgTypes, p as StoryContext, r as ReactStory, s as Args, t as ReactMeta, u as Meta, v as ReactTypes } from "./chunk-ojHmM-yX.js";
+import { Args as Args$1, ComposedStoryFn, NamedOrDefaultProjectAnnotations, NormalizedProjectAnnotations, ProjectAnnotations, Store_CSFExports, StoriesWithPartialProps, StoryAnnotationsOrFn } from "storybook/internal/types";
 
+//#region code/renderers/react/.dts-emit/code/renderers/react/src/portable-stories.d.ts
 /**
  * Function that sets the globalConfig of your storybook. The global config is the preview module of
  * your .storybook folder.
@@ -1075,7 +52,7 @@ declare const INTERNAL_DEFAULT_PROJECT_ANNOTATIONS: ProjectAnnotations<ReactRend
  *   this can be applied automatically if you use `setProjectAnnotations` in your setup files.
  * @param [exportsName] - In case your story does not contain a name and you want it to have a name.
  */
-declare function composeStory<TArgs extends Args = Args>(story: StoryAnnotationsOrFn<ReactRenderer, TArgs>, componentAnnotations: Meta<TArgs | any>, projectAnnotations?: ProjectAnnotations<ReactRenderer>, exportsName?: string): ComposedStoryFn<ReactRenderer, Partial<TArgs>>;
+declare function composeStory<TArgs extends Args$1 = Args$1>(story: StoryAnnotationsOrFn<ReactRenderer, TArgs>, componentAnnotations: Meta<TArgs | any>, projectAnnotations?: ProjectAnnotations<ReactRenderer>, exportsName?: string): ComposedStoryFn<ReactRenderer, Partial<TArgs>>;
 /**
  * Function that will receive a stories import (e.g. `import * as stories from './Button.stories'`)
  * and optionally projectAnnotations (e.g. `import * as projectAnnotations from
@@ -1104,160 +81,5 @@ declare function composeStory<TArgs extends Args = Args>(story: StoryAnnotations
  *   this can be applied automatically if you use `setProjectAnnotations` in your setup files.
  */
 declare function composeStories<TModule extends Store_CSFExports<ReactRenderer, any>>(csfExports: TModule, projectAnnotations?: ProjectAnnotations<ReactRenderer>): Omit<StoriesWithPartialProps<ReactRenderer, TModule>, keyof Store_CSFExports>;
-
-/** Extracts and unions all args types from an array of decorators. */
-type DecoratorsArgs<TRenderer extends Renderer, Decorators> = UnionToIntersection<Decorators extends DecoratorFunction<TRenderer, infer TArgs> ? TArgs : unknown>;
-type InferArgs<TArgs, T, Decorators> = Simplify<TArgs & Simplify<OmitIndexSignature<DecoratorsArgs<ReactTypes & T, Decorators>>>>;
-type InferReactTypes<T, TArgs, Decorators> = ReactTypes & T & {
-    args: Simplify<InferArgs<TArgs, T, Decorators>>;
-};
-/**
- * Creates a React-specific preview configuration with CSF factories support.
- *
- * This function wraps the base `definePreview` and adds React-specific annotations for rendering
- * and documentation. It returns a `ReactPreview` that provides type-safe `meta()` and `story()`
- * factory methods.
- *
- * @example
- *
- * ```ts
- * // .storybook/preview.ts
- * import { definePreview } from '@storybook/react';
- *
- * export const preview = definePreview({
- *   addons: [],
- *   parameters: { layout: 'centered' },
- * });
- * ```
- */
-declare function __definePreview<Addons extends PreviewAddon<never>[]>(input: {
-    addons: Addons;
-} & ProjectAnnotations<ReactTypes & InferTypes<Addons>>): ReactPreview<ReactTypes & InferTypes<Addons>>;
-/**
- * React-specific Preview interface that provides type-safe CSF factory methods.
- *
- * Use `preview.meta()` to create a meta configuration for a component, and then `meta.story()` to
- * create individual stories. The type system will infer args from the component props, decorators,
- * and any addon types.
- *
- * @example
- *
- * ```ts
- * const meta = preview.meta({ component: Button });
- * export const Primary = meta.story({ args: { label: 'Click me' } });
- * ```
- */
-/** @ts-expect-error We cannot implement the meta faithfully here, but that is okay. */
-interface ReactPreview<T extends AddonTypes> extends Preview$1<ReactTypes & T> {
-    /**
-     * Narrows the type of the preview to include additional type information. This is useful when you
-     * need to add args that aren't inferred from the component.
-     *
-     * @example
-     *
-     * ```ts
-     * const meta = preview.type<{ args: { theme: 'light' | 'dark' } }>().meta({
-     *   component: Button,
-     * });
-     * ```
-     */
-    type<R>(): ReactPreview<T & R>;
-    meta<TArgs extends Args, Decorators extends DecoratorFunction<ReactTypes & T, any>, TMetaArgs extends Partial<TArgs & T['args']>>(meta: {
-        render?: ArgsStoryFn<ReactTypes & T, TArgs & T['args']>;
-        component?: ComponentType<TArgs>;
-        decorators?: Decorators | Decorators[];
-        args?: TMetaArgs;
-    } & Omit<ComponentAnnotations<ReactTypes & T, TArgs>, 'decorators' | 'component' | 'args' | 'render'>): ReactMeta<InferReactTypes<T, TArgs, Decorators>, Omit<ComponentAnnotations<InferReactTypes<T, TArgs, Decorators>>, 'args'> & {
-        args: Partial<TArgs> extends TMetaArgs ? {} : TMetaArgs;
-    }>;
-}
-/**
- * React-specific Meta interface returned by `preview.meta()`.
- *
- * Provides the `story()` method to create individual stories with proper type inference. Args
- * provided in meta become optional in stories, while missing required args must be provided at the
- * story level.
- */
-interface ReactMeta<T extends ReactTypes, MetaInput extends ComponentAnnotations<T>>
-/** @ts-expect-error ReactMeta requires two type parameters, but Meta's constraints differ */
- extends Meta$1<T, MetaInput> {
-    /**
-     * Creates a story with a custom render function that takes no args.
-     *
-     * This overload allows you to define a story using just a render function or an object with a
-     * render function that doesn't depend on args. Since the render function doesn't use args, no
-     * args need to be provided regardless of what's required by the component.
-     *
-     * @example
-     *
-     * ```ts
-     * // Using just a render function
-     * export const CustomRender = meta.story(() => <div>Custom content</div>);
-     *
-     * // Using an object with render
-     * export const WithRender = meta.story({
-     *   render: () => <MyComponent prop="static" />,
-     * });
-     * ```
-     */
-    story<TInput extends (() => ReactTypes['storyResult']) | (StoryAnnotations<T, T['args']> & {
-        render: () => ReactTypes['storyResult'];
-    })>(story: TInput): ReactStory<T, TInput extends () => ReactTypes['storyResult'] ? {
-        render: TInput;
-    } : TInput>;
-    /**
-     * Creates a story with custom configuration including args, decorators, or other annotations.
-     *
-     * This is the primary overload for defining stories. Args that were already provided in meta
-     * become optional, while any remaining required args must be specified here.
-     *
-     * @example
-     *
-     * ```ts
-     * // Provide required args not in meta
-     * export const Primary = meta.story({
-     *   args: { label: 'Click me', disabled: false },
-     * });
-     *
-     * // Override meta args and add story-specific configuration
-     * export const Disabled = meta.story({
-     *   args: { disabled: true },
-     *   decorators: [withCustomWrapper],
-     * });
-     * ```
-     */
-    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>;
-    /**
-     * Creates a story with no additional configuration.
-     *
-     * This overload is only available when all required args have been provided in meta. The
-     * conditional type `Partial<T['args']> extends SetOptional<...>` checks if the remaining required
-     * args (after accounting for args provided in meta) are all optional. If so, the function accepts
-     * zero arguments `[]`. Otherwise, it requires `[never]` which makes this overload unmatchable,
-     * forcing the user to provide args.
-     *
-     * @example
-     *
-     * ```ts
-     * // When meta provides all required args, story() can be called with no arguments
-     * const meta = preview.meta({ component: Button, args: { label: 'Hi', disabled: false } });
-     * export const Default = meta.story(); // Valid - all args provided in meta
-     * ```
-     */
-    story(..._args: Partial<T['args']> extends SetOptional<T['args'], keyof T['args'] & keyof MetaInput['args']> ? [] : [never]): ReactStory<T, {}>;
-}
-/**
- * React-specific Story interface returned by `meta.story()`.
- *
- * Represents a single story with its configuration and provides access to the composed story for
- * testing via `story.run()`.
- *
- * Also includes a `Component` property for portable story compatibility.
- */
-interface ReactStory<T extends ReactTypes, TInput extends StoryAnnotations<T, T['args']>> extends Story<T, TInput> {
-    Component: ComponentType<Partial<T['args']>>;
-}
-
-export { type AddMocks, type Decorator, INTERNAL_DEFAULT_PROJECT_ANNOTATIONS, type Loader, type Meta, type Preview, type ReactMeta, type ReactPreview, type ReactRenderer, type ReactStory, type ReactTypes, type StoryContext, type StoryFn, type StoryObj, __definePreview, composeStories, composeStory, setProjectAnnotations };
+//#endregion
+export { AddMocks, type ArgTypes, type Args, Decorator, INTERNAL_DEFAULT_PROJECT_ANNOTATIONS, Loader, Meta, type Parameters, Preview, ReactMeta, ReactPreview, type ReactRenderer, ReactStory, type ReactTypes, StoryContext, StoryFn, StoryObj, type StrictArgs, __definePreview, composeStories, composeStory, setProjectAnnotations };