storybook-builder-rsbuild 2.1.4 → 2.1.6

package/compiled/@storybook/core-webpack/index.d.ts

@@ -0,0 +1,3118 @@
+import { FileSystemCache } from 'storybook/internal/common';
+import { Server } from 'http';
+
+declare global {
+	interface SymbolConstructor {
+		readonly observable: symbol;
+	}
+}
+
+/**
+@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;
+
+interface SBBaseType {
+    required?: boolean;
+    raw?: string;
+}
+type SBScalarType = SBBaseType & {
+    name: 'boolean' | 'string' | 'number' | 'function' | 'symbol';
+};
+type SBArrayType = SBBaseType & {
+    name: 'array';
+    value: SBType;
+};
+type SBObjectType = SBBaseType & {
+    name: 'object';
+    value: Record<string, SBType>;
+};
+type SBEnumType = SBBaseType & {
+    name: 'enum';
+    value: (string | number)[];
+};
+type SBIntersectionType = SBBaseType & {
+    name: 'intersection';
+    value: SBType[];
+};
+type SBUnionType = SBBaseType & {
+    name: 'union';
+    value: SBType[];
+};
+type SBOtherType = SBBaseType & {
+    name: 'other';
+    value: string;
+};
+type SBType = SBScalarType | SBEnumType | SBArrayType | SBObjectType | SBIntersectionType | SBUnionType | SBOtherType;
+
+interface ActionsParameters {
+    /**
+     * Actions configuration
+     *
+     * @see https://storybook.js.org/docs/essentials/actions#parameters
+     */
+    actions?: {
+        /**
+         * Create actions for each arg that matches the regex. (**NOT recommended, see below**)
+         *
+         * This is quite useful when your component has dozens (or hundreds) of methods and you do not
+         * want to manually apply the fn utility for each of those methods. However, this is not the
+         * recommended way of writing actions. That's because automatically inferred args are not
+         * available as spies in your play function. If you use argTypesRegex and your stories have play
+         * functions, you will need to also define args with the fn utility to test them in your play
+         * function.
+         *
+         * @example `argTypesRegex: '^on.*'`
+         */
+        argTypesRegex?: string;
+        /** Remove the addon panel and disable the addon's behavior */
+        disable?: boolean;
+        /**
+         * Binds a standard HTML event handler to the outermost HTML element rendered by your component
+         * and triggers an action when the event is called for a given selector. The format is
+         * `<eventname> <selector>`. The selector is optional; it defaults to all elements.
+         *
+         * **To enable this feature, you must use the `withActions` decorator.**
+         *
+         * @example `handles: ['mouseover', 'click .btn']`
+         *
+         * @see https://storybook.js.org/docs/essentials/actions#action-event-handlers
+         */
+        handles?: string[];
+    };
+}
+interface ActionsTypes {
+    parameters: ActionsParameters;
+}
+
+declare const PARAM_KEY = "backgrounds";
+
+interface Background {
+    name: string;
+    value: string;
+}
+type BackgroundMap = Record<string, Background>;
+interface GridConfig {
+    cellAmount: number;
+    cellSize: number;
+    opacity: number;
+    offsetX?: number;
+    offsetY?: number;
+}
+type GlobalState$1 = {
+    value: string | undefined;
+    grid?: boolean;
+};
+interface BackgroundsParameters {
+    /**
+     * Backgrounds configuration
+     *
+     * @see https://storybook.js.org/docs/essentials/backgrounds#parameters
+     */
+    backgrounds?: {
+        /** Default background color */
+        default?: string;
+        /** Remove the addon panel and disable the addon's behavior */
+        disable?: boolean;
+        /** Configuration for the background grid */
+        grid?: GridConfig;
+        /** Available background colors */
+        options?: BackgroundMap;
+    };
+}
+interface BackgroundsGlobals {
+    /**
+     * Backgrounds configuration
+     *
+     * @see https://storybook.js.org/docs/essentials/backgrounds#globals
+     */
+    [PARAM_KEY]?: GlobalState$1 | GlobalState$1['value'];
+}
+interface BackgroundTypes {
+    parameters: BackgroundsParameters;
+    globals: BackgroundsGlobals;
+}
+
+interface ControlsParameters {
+    /**
+     * Controls configuration
+     *
+     * @see https://storybook.js.org/docs/essentials/controls#parameters-1
+     */
+    controls?: {
+        /** Remove the addon panel and disable the addon's behavior */
+        disable?: boolean;
+        /** Disable the ability to create or edit stories from the Controls panel */
+        disableSaveFromUI?: boolean;
+        /** Exclude specific properties from the Controls panel */
+        exclude?: string[] | RegExp;
+        /**
+         * Show the full documentation for each property in the Controls addon panel, including the
+         * description and default value.
+         */
+        expanded?: boolean;
+        /** Exclude only specific properties in the Controls panel */
+        include?: string[] | RegExp;
+        /**
+         * Custom control type matchers
+         *
+         * @see https://storybook.js.org/docs/essentials/controls#custom-control-type-matchers
+         */
+        matchers?: {
+            date?: RegExp;
+            color?: RegExp;
+        };
+        /**
+         * Preset color swatches for the color picker control
+         *
+         * @example PresetColors: [{ color: '#ff4785', title: 'Coral' }, 'rgba(0, 159, 183, 1)',
+         * '#fe4a49']
+         */
+        presetColors?: Array<string | {
+            color: string;
+            title?: string;
+        }>;
+        /** Controls sorting order */
+        sort?: 'none' | 'alpha' | 'requiredFirst';
+    };
+}
+interface ControlsTypes {
+    parameters: ControlsParameters;
+}
+
+interface HighlightTypes {
+    parameters: HighlightParameters;
+}
+interface HighlightParameters {
+    /**
+     * Highlight configuration
+     *
+     * @see https://storybook.js.org/docs/essentials/highlight#parameters
+     */
+    highlight?: {
+        /** Remove the addon panel and disable the addon's behavior */
+        disable?: boolean;
+    };
+}
+
+interface MeasureParameters {
+    /**
+     * Measure configuration
+     *
+     * @see https://storybook.js.org/docs/essentials/measure-and-outline#parameters
+     */
+    measure?: {
+        /** Remove the addon panel and disable the addon's behavior */
+        disable?: boolean;
+    };
+}
+interface MeasureTypes {
+    parameters: MeasureParameters;
+}
+
+interface OutlineParameters {
+    /**
+     * Outline configuration
+     *
+     * @see https://storybook.js.org/docs/essentials/measure-and-outline#parameters
+     */
+    outline?: {
+        /** Remove the addon panel and disable the addon's behavior */
+        disable?: boolean;
+    };
+}
+interface OutlineTypes {
+    parameters: OutlineParameters;
+}
+
+interface TestParameters {
+    test?: {
+        /** Ignore unhandled errors during test execution */
+        dangerouslyIgnoreUnhandledErrors?: boolean;
+        /** Whether to throw exceptions coming from the play function */
+        throwPlayFunctionExceptions?: boolean;
+    };
+}
+interface TestTypes {
+    parameters: TestParameters;
+}
+
+interface Viewport {
+    name: string;
+    styles: ViewportStyles;
+    type?: 'desktop' | 'mobile' | 'tablet' | 'other';
+}
+interface ViewportStyles {
+    height: string;
+    width: string;
+}
+type GlobalState = {
+    /**
+     * When set, the viewport is applied and cannot be changed using the toolbar. Must match the key
+     * of one of the available viewports.
+     */
+    value: string | undefined;
+    /**
+     * When true the viewport applied will be rotated 90°, e.g. it will rotate from portrait to
+     * landscape orientation.
+     */
+    isRotated?: boolean;
+};
+interface ViewportParameters {
+    /**
+     * Viewport configuration
+     *
+     * @see https://storybook.js.org/docs/essentials/viewport#parameters
+     */
+    viewport?: {
+        /**
+         * Remove the addon panel and disable the addon's behavior . If you wish to turn off this addon
+         * for the entire Storybook, you should do so when registering addon-essentials
+         *
+         * @see https://storybook.js.org/docs/essentials/index#disabling-addons
+         */
+        disable?: boolean;
+        /**
+         * Specify the available viewports. The width and height values must include the unit, e.g.
+         * '320px'.
+         */
+        options: Record<string, Viewport>;
+    };
+}
+interface ViewportGlobals {
+    /**
+     * Viewport configuration
+     *
+     * @see https://storybook.js.org/docs/essentials/viewport#globals
+     */
+    viewport?: GlobalState | GlobalState['value'];
+}
+interface ViewportTypes {
+    parameters: ViewportParameters;
+    globals: ViewportGlobals;
+}
+
+type CoreTypes = StorybookTypes & ActionsTypes & BackgroundTypes & ControlsTypes & HighlightTypes & MeasureTypes & OutlineTypes & TestTypes & ViewportTypes;
+
+type StoryId = string;
+type ComponentId = string;
+type ComponentTitle = string;
+type StoryName = string;
+type Tag$1 = string;
+interface StoryIdentifier {
+    componentId: ComponentId;
+    title: ComponentTitle;
+    /** @deprecated */
+    kind: ComponentTitle;
+    id: StoryId;
+    name: StoryName;
+    /** @deprecated */
+    story: StoryName;
+    tags: Tag$1[];
+}
+interface Parameters {
+    [name: string]: any;
+}
+type ControlType = 'object' | 'boolean' | 'check' | 'inline-check' | 'radio' | 'inline-radio' | 'select' | 'multi-select' | 'number' | 'range' | 'file' | 'color' | 'date' | 'text';
+type ConditionalTest = {
+    truthy?: boolean;
+} | {
+    exists: boolean;
+} | {
+    eq: any;
+} | {
+    neq: any;
+};
+type ConditionalValue = {
+    arg: string;
+} | {
+    global: string;
+};
+type Conditional = ConditionalValue & ConditionalTest;
+interface ControlBase {
+    [key: string]: any;
+    /** @see https://storybook.js.org/docs/api/arg-types#controltype */
+    type?: ControlType;
+    disable?: boolean;
+}
+interface Report$1 {
+    type: string;
+    version?: number;
+    result: unknown;
+    status: 'failed' | 'passed' | 'warning';
+}
+interface ReportingAPI {
+    reports: Report$1[];
+    addReport: (report: Report$1) => void;
+}
+type Control = ControlType | false | (ControlBase & (ControlBase | {
+    type: 'color';
+    /** @see https://storybook.js.org/docs/api/arg-types#controlpresetcolors */
+    presetColors?: string[];
+} | {
+    type: 'file';
+    /** @see https://storybook.js.org/docs/api/arg-types#controlaccept */
+    accept?: string;
+} | {
+    type: 'inline-check' | 'radio' | 'inline-radio' | 'select' | 'multi-select';
+    /** @see https://storybook.js.org/docs/api/arg-types#controllabels */
+    labels?: {
+        [options: string]: string;
+    };
+} | {
+    type: 'number' | 'range';
+    /** @see https://storybook.js.org/docs/api/arg-types#controlmax */
+    max?: number;
+    /** @see https://storybook.js.org/docs/api/arg-types#controlmin */
+    min?: number;
+    /** @see https://storybook.js.org/docs/api/arg-types#controlstep */
+    step?: number;
+}));
+interface InputType {
+    /** @see https://storybook.js.org/docs/api/arg-types#control */
+    control?: Control;
+    /** @see https://storybook.js.org/docs/api/arg-types#description */
+    description?: string;
+    /** @see https://storybook.js.org/docs/api/arg-types#if */
+    if?: Conditional;
+    /** @see https://storybook.js.org/docs/api/arg-types#mapping */
+    mapping?: {
+        [key: string]: any;
+    };
+    /** @see https://storybook.js.org/docs/api/arg-types#name */
+    name?: string;
+    /** @see https://storybook.js.org/docs/api/arg-types#options */
+    options?: readonly any[];
+    /** @see https://storybook.js.org/docs/api/arg-types#table */
+    table?: {
+        [key: string]: unknown;
+        /** @see https://storybook.js.org/docs/api/arg-types#tablecategory */
+        category?: string;
+        /** @see https://storybook.js.org/docs/api/arg-types#tabledefaultvalue */
+        defaultValue?: {
+            summary?: string;
+            detail?: string;
+        };
+        /** @see https://storybook.js.org/docs/api/arg-types#tabledisable */
+        disable?: boolean;
+        /** @see https://storybook.js.org/docs/api/arg-types#tablesubcategory */
+        subcategory?: string;
+        /** @see https://storybook.js.org/docs/api/arg-types#tabletype */
+        type?: {
+            summary?: string;
+            detail?: string;
+        };
+    };
+    /** @see https://storybook.js.org/docs/api/arg-types#type */
+    type?: SBType | SBScalarType['name'];
+    /**
+     * @deprecated Use `table.defaultValue.summary` instead.
+     * @see https://storybook.js.org/docs/api/arg-types#defaultvalue
+     */
+    defaultValue?: any;
+    [key: string]: any;
+}
+interface StrictInputType extends InputType {
+    name: string;
+    type?: SBType;
+}
+interface Args {
+    [name: string]: any;
+}
+/** @see https://storybook.js.org/docs/api/arg-types#argtypes */
+type ArgTypes<TArgs = Args> = {
+    [name in keyof TArgs]: InputType;
+};
+type StrictArgTypes<TArgs = Args> = {
+    [name in keyof TArgs]: StrictInputType;
+};
+interface Globals {
+    [name: string]: any;
+}
+interface GlobalTypes {
+    [name: string]: InputType;
+}
+interface StrictGlobalTypes {
+    [name: string]: StrictInputType;
+}
+interface AddonTypes {
+    parameters?: Record<string, any>;
+    globals?: Record<string, any>;
+}
+interface Renderer extends AddonTypes {
+    /** What is the type of the `component` annotation in this renderer? */
+    component: any;
+    /** What does the story function return in this renderer? */
+    storyResult: any;
+    /** What type of element does this renderer render to? */
+    canvasElement: any;
+    mount(): Promise<Canvas>;
+    T?: unknown;
+    args: unknown;
+    csf4: boolean;
+}
+interface StoryContextForEnhancers<TRenderer extends Renderer = Renderer, TArgs = Args> extends StoryIdentifier {
+    component?: (TRenderer & {
+        T: any;
+    })['component'];
+    subcomponents?: Record<string, (TRenderer & {
+        T: any;
+    })['component']>;
+    parameters: Parameters;
+    initialArgs: TArgs;
+    argTypes: StrictArgTypes<TArgs>;
+}
+type ArgsEnhancer<TRenderer extends Renderer = Renderer, TArgs = Args> = (context: StoryContextForEnhancers<TRenderer, TArgs>) => TArgs;
+type ArgTypesEnhancer<TRenderer extends Renderer = Renderer, TArgs = Args> = ((context: StoryContextForEnhancers<TRenderer, TArgs>) => StrictArgTypes<TArgs>) & {
+    secondPass?: boolean;
+};
+interface StoryContextUpdate<TArgs = Args> {
+    args?: TArgs;
+    globals?: Globals;
+    [key: string]: any;
+}
+type ViewMode = 'story' | 'docs';
+type LoaderFunction$2<TRenderer extends Renderer = Renderer, TArgs = Args> = (context: StoryContextForLoaders<TRenderer, TArgs>) => Promise<Record<string, any> | void> | Record<string, any> | void;
+type Awaitable<T> = T | PromiseLike<T>;
+type CleanupCallback = () => Awaitable<unknown>;
+type BeforeAll = () => Awaitable<CleanupCallback | void>;
+type BeforeEach<TRenderer extends Renderer = Renderer, TArgs = Args> = (context: StoryContext<TRenderer, TArgs>) => Awaitable<CleanupCallback | void>;
+type AfterEach<TRenderer extends Renderer = Renderer, TArgs = Args> = (context: StoryContext<TRenderer, TArgs>) => Awaitable<void>;
+interface Canvas {
+}
+interface StoryContext<TRenderer extends Renderer = Renderer, TArgs = Args> extends StoryContextForEnhancers<TRenderer, TArgs>, Required<StoryContextUpdate<TArgs>> {
+    loaded: Record<string, any>;
+    abortSignal: AbortSignal;
+    canvasElement: TRenderer['canvasElement'];
+    hooks: unknown;
+    originalStoryFn: ArgsStoryFn<TRenderer>;
+    viewMode: ViewMode;
+    step: StepFunction<TRenderer, TArgs>;
+    context: this;
+    canvas: Canvas;
+    mount: TRenderer['mount'];
+    reporting: ReportingAPI;
+}
+/** @deprecated Use {@link StoryContext} instead. */
+interface StoryContextForLoaders<TRenderer extends Renderer = Renderer, TArgs = Args> extends StoryContext<TRenderer, TArgs> {
+}
+/** @deprecated Use {@link StoryContext} instead. */
+interface PlayFunctionContext<TRenderer extends Renderer = Renderer, TArgs = Args> extends StoryContext<TRenderer, TArgs> {
+}
+type StepLabel = string;
+type StepFunction<TRenderer extends Renderer = Renderer, TArgs = Args> = (label: StepLabel, play: PlayFunction<TRenderer, TArgs>) => Promise<void> | void;
+type PlayFunction<TRenderer extends Renderer = Renderer, TArgs = Args> = (context: PlayFunctionContext<TRenderer, TArgs>) => Promise<void> | void;
+type PartialStoryFn<TRenderer extends Renderer = Renderer, TArgs = Args> = (update?: StoryContextUpdate<Partial<TArgs>>) => TRenderer['storyResult'];
+type LegacyStoryFn<TRenderer extends Renderer = Renderer, TArgs = Args> = (context: StoryContext<TRenderer, TArgs>) => TRenderer['storyResult'];
+type ArgsStoryFn<TRenderer extends Renderer = Renderer, TArgs = Args> = (args: TArgs, context: StoryContext<TRenderer, TArgs>) => (TRenderer & {
+    T: TArgs;
+})['storyResult'];
+type DecoratorFunction<TRenderer extends Renderer = Renderer, TArgs = Args> = (fn: PartialStoryFn<TRenderer, TArgs>, c: StoryContext<TRenderer, TArgs>) => TRenderer['storyResult'];
+type DecoratorApplicator<TRenderer extends Renderer = Renderer, TArgs = Args> = (storyFn: LegacyStoryFn<TRenderer, TArgs>, decorators: DecoratorFunction<TRenderer, TArgs>[]) => LegacyStoryFn<TRenderer, TArgs>;
+type StepRunner<TRenderer extends Renderer = Renderer, TArgs = Args> = (label: StepLabel, play: PlayFunction<TRenderer, TArgs>, context: StoryContext<TRenderer, TArgs>) => Promise<void>;
+interface BaseAnnotations<TRenderer extends Renderer = Renderer, TArgs = Args> {
+    /**
+     * Wrapper components or Storybook decorators that wrap a story.
+     *
+     * Decorators defined in Meta will be applied to every story variation.
+     *
+     * @see [Decorators](https://storybook.js.org/docs/writing-stories/decorators)
+     */
+    decorators?: DecoratorFunction<TRenderer, Simplify<TArgs>>[] | DecoratorFunction<TRenderer, Simplify<TArgs>>;
+    /**
+     * Custom metadata for a story.
+     *
+     * @see [Parameters](https://storybook.js.org/docs/writing-stories/parameters)
+     */
+    parameters?: Parameters & (TRenderer['csf4'] extends true ? CoreTypes['parameters'] & TRenderer['parameters'] : unknown);
+    /**
+     * Dynamic data that are provided (and possibly updated by) Storybook and its addons.
+     *
+     * @see [Args](https://storybook.js.org/docs/writing-stories/args)
+     */
+    args?: Partial<TArgs>;
+    /**
+     * ArgTypes encode basic metadata for args, such as `name`, `description`, `defaultValue` for an
+     * arg. These get automatically filled in by Storybook Docs.
+     *
+     * @see [ArgTypes](https://storybook.js.org/docs/api/arg-types)
+     */
+    argTypes?: Partial<ArgTypes<TArgs>>;
+    /**
+     * Asynchronous functions which provide data for a story.
+     *
+     * @see [Loaders](https://storybook.js.org/docs/writing-stories/loaders)
+     */
+    loaders?: LoaderFunction$2<TRenderer, TArgs>[] | LoaderFunction$2<TRenderer, TArgs>;
+    /**
+     * Function to be called before each story. When the function is async, it will be awaited.
+     *
+     * `beforeEach` can be added to preview, the default export and to a specific story. They are run
+     * (and awaited) in the order: preview, default export, story
+     *
+     * A cleanup function can be returned.
+     */
+    beforeEach?: BeforeEach<TRenderer, TArgs>[] | BeforeEach<TRenderer, TArgs>;
+    /**
+     * Function to be called after each play function for post-test assertions. Don't use this
+     * function for cleaning up state. You can use the return callback of `beforeEach` for that, which
+     * is run when switching stories. When the function is async, it will be awaited.
+     *
+     * `afterEach` can be added to preview, the default export and to a specific story. They are run
+     * (and awaited) reverse order: preview, default export, story
+     */
+    afterEach?: AfterEach<TRenderer, TArgs>[] | AfterEach<TRenderer, TArgs>;
+    /**
+     * Define a custom render function for the story(ies). If not passed, a default render function by
+     * the renderer will be used.
+     */
+    render?: ArgsStoryFn<TRenderer, TArgs>;
+    /** Named tags for a story, used to filter stories in different contexts. */
+    tags?: Tag$1[];
+    mount?: (context: StoryContext<TRenderer, TArgs>) => TRenderer['mount'];
+}
+interface ProjectAnnotations$1<TRenderer extends Renderer = Renderer, TArgs = Args> extends BaseAnnotations<TRenderer, TArgs> {
+    argsEnhancers?: ArgsEnhancer<TRenderer, Args>[];
+    argTypesEnhancers?: ArgTypesEnhancer<TRenderer, Args>[];
+    /**
+     * Lifecycle hook which runs once, before any loaders, decorators or stories, and may rerun when
+     * configuration changes or when reinitializing (e.g. between test runs). The function may be
+     * synchronous or asynchronous, and may return a cleanup function which may also be synchronous or
+     * asynchronous. The cleanup function is not guaranteed to run (e.g. when the browser closes), but
+     * runs when configuration changes or when reinitializing. This hook may only be defined globally
+     * (i.e. not on component or story level). When multiple hooks are specified, they are to be
+     * executed sequentially (and awaited) in the following order:
+     *
+     * - Addon hooks (in order of addons array in e.g. .storybook/main.js)
+     * - Annotation hooks (in order of previewAnnotations array in e.g. .storybook/main.js)
+     * - Preview hook (via e.g. .storybook/preview.js) Cleanup functions are executed sequentially in
+     *   reverse order of initialization.
+     */
+    beforeAll?: BeforeAll;
+    initialGlobals?: Globals & (TRenderer['csf4'] extends true ? CoreTypes['globals'] & TRenderer['globals'] : unknown);
+    globalTypes?: GlobalTypes;
+    applyDecorators?: DecoratorApplicator<TRenderer, Args>;
+    runStep?: StepRunner<TRenderer, TArgs>;
+}
+
+/**
+ * Actions represent the type of change to a location value.
+ */
+declare enum Action$1 {
+    /**
+     * A POP indicates a change to an arbitrary index in the history stack, such
+     * as a back or forward navigation. It does not describe the direction of the
+     * navigation, only that the current index changed.
+     *
+     * Note: This is the default action for newly created history objects.
+     */
+    Pop = "POP",
+    /**
+     * A PUSH indicates a new entry being added to the history stack, such as when
+     * a link is clicked and a new page loads. When this happens, all subsequent
+     * entries in the stack are lost.
+     */
+    Push = "PUSH",
+    /**
+     * A REPLACE indicates the entry at the current index in the history stack
+     * being replaced by a new one.
+     */
+    Replace = "REPLACE"
+}
+/**
+ * The pathname, search, and hash values of a URL.
+ */
+interface Path$2 {
+    /**
+     * A URL pathname, beginning with a /.
+     */
+    pathname: string;
+    /**
+     * A URL search string, beginning with a ?.
+     */
+    search: string;
+    /**
+     * A URL fragment identifier, beginning with a #.
+     */
+    hash: string;
+}
+/**
+ * An entry in a history stack. A location contains information about the
+ * URL path, as well as possibly some arbitrary state and a key.
+ */
+interface Location$2 extends Path$2 {
+    /**
+     * A value of arbitrary data associated with this location.
+     */
+    state: any;
+    /**
+     * A unique string associated with this location. May be used to safely store
+     * and retrieve data in some other storage API, like `localStorage`.
+     *
+     * Note: This value is always "default" on the initial location.
+     */
+    key: string;
+}
+
+/**
+ * Map of routeId -> data returned from a loader/action/error
+ */
+interface RouteData$1 {
+    [routeId: string]: any;
+}
+declare enum ResultType$1 {
+    data = "data",
+    deferred = "deferred",
+    redirect = "redirect",
+    error = "error"
+}
+/**
+ * Successful result from a loader or action
+ */
+interface SuccessResult$1 {
+    type: ResultType$1.data;
+    data: any;
+    statusCode?: number;
+    headers?: Headers;
+}
+/**
+ * Successful defer() result from a loader or action
+ */
+interface DeferredResult$1 {
+    type: ResultType$1.deferred;
+    deferredData: DeferredData$1;
+    statusCode?: number;
+    headers?: Headers;
+}
+/**
+ * Redirect result from a loader or action
+ */
+interface RedirectResult$1 {
+    type: ResultType$1.redirect;
+    status: number;
+    location: string;
+    revalidate: boolean;
+    reloadDocument?: boolean;
+}
+/**
+ * Unsuccessful result from a loader or action
+ */
+interface ErrorResult$1 {
+    type: ResultType$1.error;
+    error: any;
+    headers?: Headers;
+}
+/**
+ * Result from a loader or action - potentially successful or unsuccessful
+ */
+type DataResult$1 = SuccessResult$1 | DeferredResult$1 | RedirectResult$1 | ErrorResult$1;
+type LowerCaseFormMethod$1 = "get" | "post" | "put" | "patch" | "delete";
+type UpperCaseFormMethod$1 = Uppercase<LowerCaseFormMethod$1>;
+/**
+ * Active navigation/fetcher form methods are exposed in lowercase on the
+ * RouterState
+ */
+type FormMethod$1 = LowerCaseFormMethod$1;
+/**
+ * In v7, active navigation/fetcher form methods are exposed in uppercase on the
+ * RouterState.  This is to align with the normalization done via fetch().
+ */
+type V7_FormMethod$1 = UpperCaseFormMethod$1;
+type FormEncType$1 = "application/x-www-form-urlencoded" | "multipart/form-data" | "application/json" | "text/plain";
+type JsonObject$1 = {
+    [Key in string]: JsonValue$1;
+} & {
+    [Key in string]?: JsonValue$1 | undefined;
+};
+type JsonArray$1 = JsonValue$1[] | readonly JsonValue$1[];
+type JsonPrimitive$1 = string | number | boolean | null;
+type JsonValue$1 = JsonPrimitive$1 | JsonObject$1 | JsonArray$1;
+/**
+ * @private
+ * Internal interface to pass around for action submissions, not intended for
+ * external consumption
+ */
+type Submission$1 = {
+    formMethod: FormMethod$1 | V7_FormMethod$1;
+    formAction: string;
+    formEncType: FormEncType$1;
+    formData: FormData;
+    json: undefined;
+    text: undefined;
+} | {
+    formMethod: FormMethod$1 | V7_FormMethod$1;
+    formAction: string;
+    formEncType: FormEncType$1;
+    formData: undefined;
+    json: JsonValue$1;
+    text: undefined;
+} | {
+    formMethod: FormMethod$1 | V7_FormMethod$1;
+    formAction: string;
+    formEncType: FormEncType$1;
+    formData: undefined;
+    json: undefined;
+    text: string;
+};
+/**
+ * @private
+ * Arguments passed to route loader/action functions.  Same for now but we keep
+ * this as a private implementation detail in case they diverge in the future.
+ */
+interface DataFunctionArgs$1 {
+    request: Request;
+    params: Params$1;
+    context?: any;
+}
+/**
+ * Arguments passed to loader functions
+ */
+interface LoaderFunctionArgs$1 extends DataFunctionArgs$1 {
+}
+/**
+ * Arguments passed to action functions
+ */
+interface ActionFunctionArgs$1 extends DataFunctionArgs$1 {
+}
+/**
+ * Loaders and actions can return anything except `undefined` (`null` is a
+ * valid return value if there is no data to return).  Responses are preferred
+ * and will ease any future migration to Remix
+ */
+type DataFunctionValue$1 = Response | NonNullable<unknown> | null;
+/**
+ * Route loader function signature
+ */
+interface LoaderFunction$1 {
+    (args: LoaderFunctionArgs$1): Promise<DataFunctionValue$1> | DataFunctionValue$1;
+}
+/**
+ * Route action function signature
+ */
+interface ActionFunction$1 {
+    (args: ActionFunctionArgs$1): Promise<DataFunctionValue$1> | DataFunctionValue$1;
+}
+/**
+ * Route shouldRevalidate function signature.  This runs after any submission
+ * (navigation or fetcher), so we flatten the navigation/fetcher submission
+ * onto the arguments.  It shouldn't matter whether it came from a navigation
+ * or a fetcher, what really matters is the URLs and the formData since loaders
+ * have to re-run based on the data models that were potentially mutated.
+ */
+interface ShouldRevalidateFunction$1 {
+    (args: {
+        currentUrl: URL;
+        currentParams: AgnosticDataRouteMatch$1["params"];
+        nextUrl: URL;
+        nextParams: AgnosticDataRouteMatch$1["params"];
+        formMethod?: Submission$1["formMethod"];
+        formAction?: Submission$1["formAction"];
+        formEncType?: Submission$1["formEncType"];
+        text?: Submission$1["text"];
+        formData?: Submission$1["formData"];
+        json?: Submission$1["json"];
+        actionResult?: DataResult$1;
+        defaultShouldRevalidate: boolean;
+    }): boolean;
+}
+/**
+ * Keys we cannot change from within a lazy() function. We spread all other keys
+ * onto the route. Either they're meaningful to the router, or they'll get
+ * ignored.
+ */
+type ImmutableRouteKey$1 = "lazy" | "caseSensitive" | "path" | "id" | "index" | "children";
+type RequireOne$1<T, Key = keyof T> = Exclude<{
+    [K in keyof T]: K extends Key ? Omit<T, K> & Required<Pick<T, K>> : never;
+}[keyof T], undefined>;
+/**
+ * lazy() function to load a route definition, which can add non-matching
+ * related properties to a route
+ */
+interface LazyRouteFunction$1<R extends AgnosticRouteObject$1> {
+    (): Promise<RequireOne$1<Omit<R, ImmutableRouteKey$1>>>;
+}
+/**
+ * Base RouteObject with common props shared by all types of routes
+ */
+type AgnosticBaseRouteObject$1 = {
+    caseSensitive?: boolean;
+    path?: string;
+    id?: string;
+    loader?: LoaderFunction$1;
+    action?: ActionFunction$1;
+    hasErrorBoundary?: boolean;
+    shouldRevalidate?: ShouldRevalidateFunction$1;
+    handle?: any;
+    lazy?: LazyRouteFunction$1<AgnosticBaseRouteObject$1>;
+};
+/**
+ * Index routes must not have children
+ */
+type AgnosticIndexRouteObject$1 = AgnosticBaseRouteObject$1 & {
+    children?: undefined;
+    index: true;
+};
+/**
+ * Non-index routes may have children, but cannot have index
+ */
+type AgnosticNonIndexRouteObject$1 = AgnosticBaseRouteObject$1 & {
+    children?: AgnosticRouteObject$1[];
+    index?: false;
+};
+/**
+ * A route object represents a logical route, with (optionally) its child
+ * routes organized in a tree-like structure.
+ */
+type AgnosticRouteObject$1 = AgnosticIndexRouteObject$1 | AgnosticNonIndexRouteObject$1;
+type AgnosticDataIndexRouteObject$1 = AgnosticIndexRouteObject$1 & {
+    id: string;
+};
+type AgnosticDataNonIndexRouteObject$1 = AgnosticNonIndexRouteObject$1 & {
+    children?: AgnosticDataRouteObject$1[];
+    id: string;
+};
+/**
+ * A data route object, which is just a RouteObject with a required unique ID
+ */
+type AgnosticDataRouteObject$1 = AgnosticDataIndexRouteObject$1 | AgnosticDataNonIndexRouteObject$1;
+/**
+ * The parameters that were parsed from the URL path.
+ */
+type Params$1<Key extends string = string> = {
+    readonly [key in Key]: string | undefined;
+};
+/**
+ * A RouteMatch contains info about how a route matched a URL.
+ */
+interface AgnosticRouteMatch$1<ParamKey extends string = string, RouteObjectType extends AgnosticRouteObject$1 = AgnosticRouteObject$1> {
+    /**
+     * The names and values of dynamic parameters in the URL.
+     */
+    params: Params$1<ParamKey>;
+    /**
+     * The portion of the URL pathname that was matched.
+     */
+    pathname: string;
+    /**
+     * The portion of the URL pathname that was matched before child routes.
+     */
+    pathnameBase: string;
+    /**
+     * The route object that was used to match.
+     */
+    route: RouteObjectType;
+}
+interface AgnosticDataRouteMatch$1 extends AgnosticRouteMatch$1<string, AgnosticDataRouteObject$1> {
+}
+declare class DeferredData$1 {
+    private pendingKeysSet;
+    private controller;
+    private abortPromise;
+    private unlistenAbortSignal;
+    private subscribers;
+    data: Record<string, unknown>;
+    init?: ResponseInit;
+    deferredKeys: string[];
+    constructor(data: Record<string, unknown>, responseInit?: ResponseInit);
+    private trackPromise;
+    private onSettle;
+    private emit;
+    subscribe(fn: (aborted: boolean, settledKey?: string) => void): () => boolean;
+    cancel(): void;
+    resolveData(signal: AbortSignal): Promise<boolean>;
+    get done(): boolean;
+    get unwrappedData(): {};
+    get pendingKeys(): string[];
+}
+
+/**
+ * State maintained internally by the router.  During a navigation, all states
+ * reflect the the "old" location unless otherwise noted.
+ */
+interface RouterState$1 {
+    /**
+     * The action of the most recent navigation
+     */
+    historyAction: Action$1;
+    /**
+     * The current location reflected by the router
+     */
+    location: Location$2;
+    /**
+     * The current set of route matches
+     */
+    matches: AgnosticDataRouteMatch$1[];
+    /**
+     * Tracks whether we've completed our initial data load
+     */
+    initialized: boolean;
+    /**
+     * Current scroll position we should start at for a new view
+     *  - number -> scroll position to restore to
+     *  - false -> do not restore scroll at all (used during submissions)
+     *  - null -> don't have a saved position, scroll to hash or top of page
+     */
+    restoreScrollPosition: number | false | null;
+    /**
+     * Indicate whether this navigation should skip resetting the scroll position
+     * if we are unable to restore the scroll position
+     */
+    preventScrollReset: boolean;
+    /**
+     * Tracks the state of the current navigation
+     */
+    navigation: Navigation$1;
+    /**
+     * Tracks any in-progress revalidations
+     */
+    revalidation: RevalidationState$1;
+    /**
+     * Data from the loaders for the current matches
+     */
+    loaderData: RouteData$1;
+    /**
+     * Data from the action for the current matches
+     */
+    actionData: RouteData$1 | null;
+    /**
+     * Errors caught from loaders for the current matches
+     */
+    errors: RouteData$1 | null;
+    /**
+     * Map of current fetchers
+     */
+    fetchers: Map<string, Fetcher$1>;
+    /**
+     * Map of current blockers
+     */
+    blockers: Map<string, Blocker$1>;
+}
+/**
+ * Data that can be passed into hydrate a Router from SSR
+ */
+type HydrationState$1 = Partial<Pick<RouterState$1, "loaderData" | "actionData" | "errors">>;
+/**
+ * Potential states for state.navigation
+ */
+type NavigationStates$1 = {
+    Idle: {
+        state: "idle";
+        location: undefined;
+        formMethod: undefined;
+        formAction: undefined;
+        formEncType: undefined;
+        formData: undefined;
+        json: undefined;
+        text: undefined;
+    };
+    Loading: {
+        state: "loading";
+        location: Location$2;
+        formMethod: Submission$1["formMethod"] | undefined;
+        formAction: Submission$1["formAction"] | undefined;
+        formEncType: Submission$1["formEncType"] | undefined;
+        formData: Submission$1["formData"] | undefined;
+        json: Submission$1["json"] | undefined;
+        text: Submission$1["text"] | undefined;
+    };
+    Submitting: {
+        state: "submitting";
+        location: Location$2;
+        formMethod: Submission$1["formMethod"];
+        formAction: Submission$1["formAction"];
+        formEncType: Submission$1["formEncType"];
+        formData: Submission$1["formData"];
+        json: Submission$1["json"];
+        text: Submission$1["text"];
+    };
+};
+type Navigation$1 = NavigationStates$1[keyof NavigationStates$1];
+type RevalidationState$1 = "idle" | "loading";
+/**
+ * Potential states for fetchers
+ */
+type FetcherStates$1<TData = any> = {
+    Idle: {
+        state: "idle";
+        formMethod: undefined;
+        formAction: undefined;
+        formEncType: undefined;
+        text: undefined;
+        formData: undefined;
+        json: undefined;
+        data: TData | undefined;
+        " _hasFetcherDoneAnything "?: boolean;
+    };
+    Loading: {
+        state: "loading";
+        formMethod: Submission$1["formMethod"] | undefined;
+        formAction: Submission$1["formAction"] | undefined;
+        formEncType: Submission$1["formEncType"] | undefined;
+        text: Submission$1["text"] | undefined;
+        formData: Submission$1["formData"] | undefined;
+        json: Submission$1["json"] | undefined;
+        data: TData | undefined;
+        " _hasFetcherDoneAnything "?: boolean;
+    };
+    Submitting: {
+        state: "submitting";
+        formMethod: Submission$1["formMethod"];
+        formAction: Submission$1["formAction"];
+        formEncType: Submission$1["formEncType"];
+        text: Submission$1["text"];
+        formData: Submission$1["formData"];
+        json: Submission$1["json"];
+        data: TData | undefined;
+        " _hasFetcherDoneAnything "?: boolean;
+    };
+};
+type Fetcher$1<TData = any> = FetcherStates$1<TData>[keyof FetcherStates$1<TData>];
+interface BlockerBlocked$1 {
+    state: "blocked";
+    reset(): void;
+    proceed(): void;
+    location: Location$2;
+}
+interface BlockerUnblocked$1 {
+    state: "unblocked";
+    reset: undefined;
+    proceed: undefined;
+    location: undefined;
+}
+interface BlockerProceeding$1 {
+    state: "proceeding";
+    reset: undefined;
+    proceed: undefined;
+    location: Location$2;
+}
+type Blocker$1 = BlockerUnblocked$1 | BlockerBlocked$1 | BlockerProceeding$1;
+
+/**
+ * NOTE: If you refactor this to split up the modules into separate files,
+ * you'll need to update the rollup config for react-router-dom-v5-compat.
+ */
+
+declare global {
+    var __staticRouterHydrationData: HydrationState$1 | undefined;
+}
+
+declare global {
+    var globalProjectAnnotations: NormalizedProjectAnnotations<any>;
+    var defaultProjectAnnotations: ProjectAnnotations<any>;
+}
+type WrappedStoryRef$1 = {
+    __pw_type: 'jsx';
+    props: Record<string, any>;
+} | {
+    __pw_type: 'importRef';
+};
+type UnwrappedJSXStoryRef$1 = {
+    __pw_type: 'jsx';
+    type: UnwrappedImportStoryRef$1;
+};
+type UnwrappedImportStoryRef$1 = ComposedStoryFn;
+declare global {
+    function __pwUnwrapObject(storyRef: WrappedStoryRef$1): Promise<UnwrappedJSXStoryRef$1 | UnwrappedImportStoryRef$1>;
+}
+
+declare global {
+	interface SymbolConstructor {
+		readonly observable: symbol;
+	}
+}
+
+/**
+ * Actions represent the type of change to a location value.
+ */
+declare enum Action {
+    /**
+     * A POP indicates a change to an arbitrary index in the history stack, such
+     * as a back or forward navigation. It does not describe the direction of the
+     * navigation, only that the current index changed.
+     *
+     * Note: This is the default action for newly created history objects.
+     */
+    Pop = "POP",
+    /**
+     * A PUSH indicates a new entry being added to the history stack, such as when
+     * a link is clicked and a new page loads. When this happens, all subsequent
+     * entries in the stack are lost.
+     */
+    Push = "PUSH",
+    /**
+     * A REPLACE indicates the entry at the current index in the history stack
+     * being replaced by a new one.
+     */
+    Replace = "REPLACE"
+}
+/**
+ * The pathname, search, and hash values of a URL.
+ */
+interface Path$1 {
+    /**
+     * A URL pathname, beginning with a /.
+     */
+    pathname: string;
+    /**
+     * A URL search string, beginning with a ?.
+     */
+    search: string;
+    /**
+     * A URL fragment identifier, beginning with a #.
+     */
+    hash: string;
+}
+/**
+ * An entry in a history stack. A location contains information about the
+ * URL path, as well as possibly some arbitrary state and a key.
+ */
+interface Location extends Path$1 {
+    /**
+     * A value of arbitrary data associated with this location.
+     */
+    state: any;
+    /**
+     * A unique string associated with this location. May be used to safely store
+     * and retrieve data in some other storage API, like `localStorage`.
+     *
+     * Note: This value is always "default" on the initial location.
+     */
+    key: string;
+}
+
+/**
+ * Map of routeId -> data returned from a loader/action/error
+ */
+interface RouteData {
+    [routeId: string]: any;
+}
+declare enum ResultType {
+    data = "data",
+    deferred = "deferred",
+    redirect = "redirect",
+    error = "error"
+}
+/**
+ * Successful result from a loader or action
+ */
+interface SuccessResult {
+    type: ResultType.data;
+    data: any;
+    statusCode?: number;
+    headers?: Headers;
+}
+/**
+ * Successful defer() result from a loader or action
+ */
+interface DeferredResult {
+    type: ResultType.deferred;
+    deferredData: DeferredData;
+    statusCode?: number;
+    headers?: Headers;
+}
+/**
+ * Redirect result from a loader or action
+ */
+interface RedirectResult {
+    type: ResultType.redirect;
+    status: number;
+    location: string;
+    revalidate: boolean;
+    reloadDocument?: boolean;
+}
+/**
+ * Unsuccessful result from a loader or action
+ */
+interface ErrorResult {
+    type: ResultType.error;
+    error: any;
+    headers?: Headers;
+}
+/**
+ * Result from a loader or action - potentially successful or unsuccessful
+ */
+type DataResult = SuccessResult | DeferredResult | RedirectResult | ErrorResult;
+type LowerCaseFormMethod = "get" | "post" | "put" | "patch" | "delete";
+type UpperCaseFormMethod = Uppercase<LowerCaseFormMethod>;
+/**
+ * Active navigation/fetcher form methods are exposed in lowercase on the
+ * RouterState
+ */
+type FormMethod = LowerCaseFormMethod;
+/**
+ * In v7, active navigation/fetcher form methods are exposed in uppercase on the
+ * RouterState.  This is to align with the normalization done via fetch().
+ */
+type V7_FormMethod = UpperCaseFormMethod;
+type FormEncType = "application/x-www-form-urlencoded" | "multipart/form-data" | "application/json" | "text/plain";
+type JsonObject = {
+    [Key in string]: JsonValue;
+} & {
+    [Key in string]?: JsonValue | undefined;
+};
+type JsonArray = JsonValue[] | readonly JsonValue[];
+type JsonPrimitive = string | number | boolean | null;
+type JsonValue = JsonPrimitive | JsonObject | JsonArray;
+/**
+ * @private
+ * Internal interface to pass around for action submissions, not intended for
+ * external consumption
+ */
+type Submission = {
+    formMethod: FormMethod | V7_FormMethod;
+    formAction: string;
+    formEncType: FormEncType;
+    formData: FormData;
+    json: undefined;
+    text: undefined;
+} | {
+    formMethod: FormMethod | V7_FormMethod;
+    formAction: string;
+    formEncType: FormEncType;
+    formData: undefined;
+    json: JsonValue;
+    text: undefined;
+} | {
+    formMethod: FormMethod | V7_FormMethod;
+    formAction: string;
+    formEncType: FormEncType;
+    formData: undefined;
+    json: undefined;
+    text: string;
+};
+/**
+ * @private
+ * Arguments passed to route loader/action functions.  Same for now but we keep
+ * this as a private implementation detail in case they diverge in the future.
+ */
+interface DataFunctionArgs {
+    request: Request;
+    params: Params;
+    context?: any;
+}
+/**
+ * Arguments passed to loader functions
+ */
+interface LoaderFunctionArgs extends DataFunctionArgs {
+}
+/**
+ * Arguments passed to action functions
+ */
+interface ActionFunctionArgs extends DataFunctionArgs {
+}
+/**
+ * Loaders and actions can return anything except `undefined` (`null` is a
+ * valid return value if there is no data to return).  Responses are preferred
+ * and will ease any future migration to Remix
+ */
+type DataFunctionValue = Response | NonNullable<unknown> | null;
+/**
+ * Route loader function signature
+ */
+interface LoaderFunction {
+    (args: LoaderFunctionArgs): Promise<DataFunctionValue> | DataFunctionValue;
+}
+/**
+ * Route action function signature
+ */
+interface ActionFunction {
+    (args: ActionFunctionArgs): Promise<DataFunctionValue> | DataFunctionValue;
+}
+/**
+ * Route shouldRevalidate function signature.  This runs after any submission
+ * (navigation or fetcher), so we flatten the navigation/fetcher submission
+ * onto the arguments.  It shouldn't matter whether it came from a navigation
+ * or a fetcher, what really matters is the URLs and the formData since loaders
+ * have to re-run based on the data models that were potentially mutated.
+ */
+interface ShouldRevalidateFunction {
+    (args: {
+        currentUrl: URL;
+        currentParams: AgnosticDataRouteMatch["params"];
+        nextUrl: URL;
+        nextParams: AgnosticDataRouteMatch["params"];
+        formMethod?: Submission["formMethod"];
+        formAction?: Submission["formAction"];
+        formEncType?: Submission["formEncType"];
+        text?: Submission["text"];
+        formData?: Submission["formData"];
+        json?: Submission["json"];
+        actionResult?: DataResult;
+        defaultShouldRevalidate: boolean;
+    }): boolean;
+}
+/**
+ * Keys we cannot change from within a lazy() function. We spread all other keys
+ * onto the route. Either they're meaningful to the router, or they'll get
+ * ignored.
+ */
+type ImmutableRouteKey = "lazy" | "caseSensitive" | "path" | "id" | "index" | "children";
+type RequireOne<T, Key = keyof T> = Exclude<{
+    [K in keyof T]: K extends Key ? Omit<T, K> & Required<Pick<T, K>> : never;
+}[keyof T], undefined>;
+/**
+ * lazy() function to load a route definition, which can add non-matching
+ * related properties to a route
+ */
+interface LazyRouteFunction<R extends AgnosticRouteObject> {
+    (): Promise<RequireOne<Omit<R, ImmutableRouteKey>>>;
+}
+/**
+ * Base RouteObject with common props shared by all types of routes
+ */
+type AgnosticBaseRouteObject = {
+    caseSensitive?: boolean;
+    path?: string;
+    id?: string;
+    loader?: LoaderFunction;
+    action?: ActionFunction;
+    hasErrorBoundary?: boolean;
+    shouldRevalidate?: ShouldRevalidateFunction;
+    handle?: any;
+    lazy?: LazyRouteFunction<AgnosticBaseRouteObject>;
+};
+/**
+ * Index routes must not have children
+ */
+type AgnosticIndexRouteObject = AgnosticBaseRouteObject & {
+    children?: undefined;
+    index: true;
+};
+/**
+ * Non-index routes may have children, but cannot have index
+ */
+type AgnosticNonIndexRouteObject = AgnosticBaseRouteObject & {
+    children?: AgnosticRouteObject[];
+    index?: false;
+};
+/**
+ * A route object represents a logical route, with (optionally) its child
+ * routes organized in a tree-like structure.
+ */
+type AgnosticRouteObject = AgnosticIndexRouteObject | AgnosticNonIndexRouteObject;
+type AgnosticDataIndexRouteObject = AgnosticIndexRouteObject & {
+    id: string;
+};
+type AgnosticDataNonIndexRouteObject = AgnosticNonIndexRouteObject & {
+    children?: AgnosticDataRouteObject[];
+    id: string;
+};
+/**
+ * A data route object, which is just a RouteObject with a required unique ID
+ */
+type AgnosticDataRouteObject = AgnosticDataIndexRouteObject | AgnosticDataNonIndexRouteObject;
+/**
+ * The parameters that were parsed from the URL path.
+ */
+type Params<Key extends string = string> = {
+    readonly [key in Key]: string | undefined;
+};
+/**
+ * A RouteMatch contains info about how a route matched a URL.
+ */
+interface AgnosticRouteMatch<ParamKey extends string = string, RouteObjectType extends AgnosticRouteObject = AgnosticRouteObject> {
+    /**
+     * The names and values of dynamic parameters in the URL.
+     */
+    params: Params<ParamKey>;
+    /**
+     * The portion of the URL pathname that was matched.
+     */
+    pathname: string;
+    /**
+     * The portion of the URL pathname that was matched before child routes.
+     */
+    pathnameBase: string;
+    /**
+     * The route object that was used to match.
+     */
+    route: RouteObjectType;
+}
+interface AgnosticDataRouteMatch extends AgnosticRouteMatch<string, AgnosticDataRouteObject> {
+}
+declare class DeferredData {
+    private pendingKeysSet;
+    private controller;
+    private abortPromise;
+    private unlistenAbortSignal;
+    private subscribers;
+    data: Record<string, unknown>;
+    init?: ResponseInit;
+    deferredKeys: string[];
+    constructor(data: Record<string, unknown>, responseInit?: ResponseInit);
+    private trackPromise;
+    private onSettle;
+    private emit;
+    subscribe(fn: (aborted: boolean, settledKey?: string) => void): () => boolean;
+    cancel(): void;
+    resolveData(signal: AbortSignal): Promise<boolean>;
+    get done(): boolean;
+    get unwrappedData(): {};
+    get pendingKeys(): string[];
+}
+
+/**
+ * State maintained internally by the router.  During a navigation, all states
+ * reflect the the "old" location unless otherwise noted.
+ */
+interface RouterState {
+    /**
+     * The action of the most recent navigation
+     */
+    historyAction: Action;
+    /**
+     * The current location reflected by the router
+     */
+    location: Location;
+    /**
+     * The current set of route matches
+     */
+    matches: AgnosticDataRouteMatch[];
+    /**
+     * Tracks whether we've completed our initial data load
+     */
+    initialized: boolean;
+    /**
+     * Current scroll position we should start at for a new view
+     *  - number -> scroll position to restore to
+     *  - false -> do not restore scroll at all (used during submissions)
+     *  - null -> don't have a saved position, scroll to hash or top of page
+     */
+    restoreScrollPosition: number | false | null;
+    /**
+     * Indicate whether this navigation should skip resetting the scroll position
+     * if we are unable to restore the scroll position
+     */
+    preventScrollReset: boolean;
+    /**
+     * Tracks the state of the current navigation
+     */
+    navigation: Navigation;
+    /**
+     * Tracks any in-progress revalidations
+     */
+    revalidation: RevalidationState;
+    /**
+     * Data from the loaders for the current matches
+     */
+    loaderData: RouteData;
+    /**
+     * Data from the action for the current matches
+     */
+    actionData: RouteData | null;
+    /**
+     * Errors caught from loaders for the current matches
+     */
+    errors: RouteData | null;
+    /**
+     * Map of current fetchers
+     */
+    fetchers: Map<string, Fetcher>;
+    /**
+     * Map of current blockers
+     */
+    blockers: Map<string, Blocker>;
+}
+/**
+ * Data that can be passed into hydrate a Router from SSR
+ */
+type HydrationState = Partial<Pick<RouterState, "loaderData" | "actionData" | "errors">>;
+/**
+ * Potential states for state.navigation
+ */
+type NavigationStates = {
+    Idle: {
+        state: "idle";
+        location: undefined;
+        formMethod: undefined;
+        formAction: undefined;
+        formEncType: undefined;
+        formData: undefined;
+        json: undefined;
+        text: undefined;
+    };
+    Loading: {
+        state: "loading";
+        location: Location;
+        formMethod: Submission["formMethod"] | undefined;
+        formAction: Submission["formAction"] | undefined;
+        formEncType: Submission["formEncType"] | undefined;
+        formData: Submission["formData"] | undefined;
+        json: Submission["json"] | undefined;
+        text: Submission["text"] | undefined;
+    };
+    Submitting: {
+        state: "submitting";
+        location: Location;
+        formMethod: Submission["formMethod"];
+        formAction: Submission["formAction"];
+        formEncType: Submission["formEncType"];
+        formData: Submission["formData"];
+        json: Submission["json"];
+        text: Submission["text"];
+    };
+};
+type Navigation = NavigationStates[keyof NavigationStates];
+type RevalidationState = "idle" | "loading";
+/**
+ * Potential states for fetchers
+ */
+type FetcherStates<TData = any> = {
+    Idle: {
+        state: "idle";
+        formMethod: undefined;
+        formAction: undefined;
+        formEncType: undefined;
+        text: undefined;
+        formData: undefined;
+        json: undefined;
+        data: TData | undefined;
+        " _hasFetcherDoneAnything "?: boolean;
+    };
+    Loading: {
+        state: "loading";
+        formMethod: Submission["formMethod"] | undefined;
+        formAction: Submission["formAction"] | undefined;
+        formEncType: Submission["formEncType"] | undefined;
+        text: Submission["text"] | undefined;
+        formData: Submission["formData"] | undefined;
+        json: Submission["json"] | undefined;
+        data: TData | undefined;
+        " _hasFetcherDoneAnything "?: boolean;
+    };
+    Submitting: {
+        state: "submitting";
+        formMethod: Submission["formMethod"];
+        formAction: Submission["formAction"];
+        formEncType: Submission["formEncType"];
+        text: Submission["text"];
+        formData: Submission["formData"];
+        json: Submission["json"];
+        data: TData | undefined;
+        " _hasFetcherDoneAnything "?: boolean;
+    };
+};
+type Fetcher<TData = any> = FetcherStates<TData>[keyof FetcherStates<TData>];
+interface BlockerBlocked {
+    state: "blocked";
+    reset(): void;
+    proceed(): void;
+    location: Location;
+}
+interface BlockerUnblocked {
+    state: "unblocked";
+    reset: undefined;
+    proceed: undefined;
+    location: undefined;
+}
+interface BlockerProceeding {
+    state: "proceeding";
+    reset: undefined;
+    proceed: undefined;
+    location: Location;
+}
+type Blocker = BlockerUnblocked | BlockerBlocked | BlockerProceeding;
+
+/**
+ * NOTE: If you refactor this to split up the modules into separate files,
+ * you'll need to update the rollup config for react-router-dom-v5-compat.
+ */
+
+declare global {
+    var __staticRouterHydrationData: HydrationState | undefined;
+}
+
+interface Options$1 {
+    allowRegExp: boolean;
+    allowSymbol: boolean;
+    allowDate: boolean;
+    allowUndefined: boolean;
+    allowError: boolean;
+    maxDepth: number;
+    space: number | undefined;
+}
+
+/**
+Matches any [primitive value](https://developer.mozilla.org/en-US/docs/Glossary/Primitive).
+
+@category Type
+*/
+type Primitive =
+	| null
+	| undefined
+	| string
+	| number
+	| boolean
+	| symbol
+	| bigint;
+
+declare global {
+	interface SymbolConstructor {
+		readonly observable: symbol;
+	}
+}
+
+/**
+Allows creating a union type by combining primitive types and literal types without sacrificing auto-completion in IDEs for the literal type part of the union.
+
+Currently, when a union type of a primitive type is combined with literal types, TypeScript loses all information about the combined literals. Thus, when such type is used in an IDE with autocompletion, no suggestions are made for the declared literals.
+
+This type is a workaround for [Microsoft/TypeScript#29729](https://github.com/Microsoft/TypeScript/issues/29729). It will be removed as soon as it's not needed anymore.
+
+@example
+```
+import type {LiteralUnion} from 'type-fest';
+
+// Before
+
+type Pet = 'dog' | 'cat' | string;
+
+const pet: Pet = '';
+// Start typing in your TypeScript-enabled IDE.
+// You **will not** get auto-completion for `dog` and `cat` literals.
+
+// After
+
+type Pet2 = LiteralUnion<'dog' | 'cat', string>;
+
+const pet: Pet2 = '';
+// You **will** get auto-completion for `dog` and `cat` literals.
+```
+
+@category Type
+*/
+type LiteralUnion<
+	LiteralType,
+	BaseType extends Primitive,
+> = LiteralType | (BaseType & Record<never, never>);
+
+declare namespace PackageJson$1 {
+	/**
+	A person who has been involved in creating or maintaining the package.
+	*/
+	export type Person =
+		| string
+		| {
+			name: string;
+			url?: string;
+			email?: string;
+		};
+
+	export type BugsLocation =
+		| string
+		| {
+			/**
+			The URL to the package's issue tracker.
+			*/
+			url?: string;
+
+			/**
+			The email address to which issues should be reported.
+			*/
+			email?: string;
+		};
+
+	export interface DirectoryLocations {
+		[directoryType: string]: unknown;
+
+		/**
+		Location for executable scripts. Sugar to generate entries in the `bin` property by walking the folder.
+		*/
+		bin?: string;
+
+		/**
+		Location for Markdown files.
+		*/
+		doc?: string;
+
+		/**
+		Location for example scripts.
+		*/
+		example?: string;
+
+		/**
+		Location for the bulk of the library.
+		*/
+		lib?: string;
+
+		/**
+		Location for man pages. Sugar to generate a `man` array by walking the folder.
+		*/
+		man?: string;
+
+		/**
+		Location for test files.
+		*/
+		test?: string;
+	}
+
+	export type Scripts = {
+		/**
+		Run **before** the package is published (Also run on local `npm install` without any arguments).
+		*/
+		prepublish?: string;
+
+		/**
+		Run both **before** the package is packed and published, and on local `npm install` without any arguments. This is run **after** `prepublish`, but **before** `prepublishOnly`.
+		*/
+		prepare?: string;
+
+		/**
+		Run **before** the package is prepared and packed, **only** on `npm publish`.
+		*/
+		prepublishOnly?: string;
+
+		/**
+		Run **before** a tarball is packed (on `npm pack`, `npm publish`, and when installing git dependencies).
+		*/
+		prepack?: string;
+
+		/**
+		Run **after** the tarball has been generated and moved to its final destination.
+		*/
+		postpack?: string;
+
+		/**
+		Run **after** the package is published.
+		*/
+		publish?: string;
+
+		/**
+		Run **after** the package is published.
+		*/
+		postpublish?: string;
+
+		/**
+		Run **before** the package is installed.
+		*/
+		preinstall?: string;
+
+		/**
+		Run **after** the package is installed.
+		*/
+		install?: string;
+
+		/**
+		Run **after** the package is installed and after `install`.
+		*/
+		postinstall?: string;
+
+		/**
+		Run **before** the package is uninstalled and before `uninstall`.
+		*/
+		preuninstall?: string;
+
+		/**
+		Run **before** the package is uninstalled.
+		*/
+		uninstall?: string;
+
+		/**
+		Run **after** the package is uninstalled.
+		*/
+		postuninstall?: string;
+
+		/**
+		Run **before** bump the package version and before `version`.
+		*/
+		preversion?: string;
+
+		/**
+		Run **before** bump the package version.
+		*/
+		version?: string;
+
+		/**
+		Run **after** bump the package version.
+		*/
+		postversion?: string;
+
+		/**
+		Run with the `npm test` command, before `test`.
+		*/
+		pretest?: string;
+
+		/**
+		Run with the `npm test` command.
+		*/
+		test?: string;
+
+		/**
+		Run with the `npm test` command, after `test`.
+		*/
+		posttest?: string;
+
+		/**
+		Run with the `npm stop` command, before `stop`.
+		*/
+		prestop?: string;
+
+		/**
+		Run with the `npm stop` command.
+		*/
+		stop?: string;
+
+		/**
+		Run with the `npm stop` command, after `stop`.
+		*/
+		poststop?: string;
+
+		/**
+		Run with the `npm start` command, before `start`.
+		*/
+		prestart?: string;
+
+		/**
+		Run with the `npm start` command.
+		*/
+		start?: string;
+
+		/**
+		Run with the `npm start` command, after `start`.
+		*/
+		poststart?: string;
+
+		/**
+		Run with the `npm restart` command, before `restart`. Note: `npm restart` will run the `stop` and `start` scripts if no `restart` script is provided.
+		*/
+		prerestart?: string;
+
+		/**
+		Run with the `npm restart` command. Note: `npm restart` will run the `stop` and `start` scripts if no `restart` script is provided.
+		*/
+		restart?: string;
+
+		/**
+		Run with the `npm restart` command, after `restart`. Note: `npm restart` will run the `stop` and `start` scripts if no `restart` script is provided.
+		*/
+		postrestart?: string;
+	} & Partial<Record<string, string>>;
+
+	/**
+	Dependencies of the package. The version range is a string which has one or more space-separated descriptors. Dependencies can also be identified with a tarball or Git URL.
+	*/
+	export type Dependency = Partial<Record<string, string>>;
+
+	/**
+	Conditions which provide a way to resolve a package entry point based on the environment.
+	*/
+	export type ExportCondition = LiteralUnion<
+		| 'import'
+		| 'require'
+		| 'node'
+		| 'node-addons'
+		| 'deno'
+		| 'browser'
+		| 'electron'
+		| 'react-native'
+		| 'default',
+		string
+	>;
+
+	type ExportConditions = {[condition in ExportCondition]: Exports};
+
+	/**
+	Entry points of a module, optionally with conditions and subpath exports.
+	*/
+	export type Exports =
+	| null
+	| string
+	| Array<string | ExportConditions>
+	| ExportConditions
+	| {[path: string]: Exports}; // eslint-disable-line @typescript-eslint/consistent-indexed-object-style
+
+	/**
+	Import map entries of a module, optionally with conditions.
+	*/
+	export type Imports = { // eslint-disable-line @typescript-eslint/consistent-indexed-object-style
+		[key: string]: string | {[key in ExportCondition]: Exports};
+	};
+
+	export interface NonStandardEntryPoints {
+		/**
+		An ECMAScript module ID that is the primary entry point to the program.
+		*/
+		module?: string;
+
+		/**
+		A module ID with untranspiled code that is the primary entry point to the program.
+		*/
+		esnext?:
+		| string
+		| {
+			[moduleName: string]: string | undefined;
+			main?: string;
+			browser?: string;
+		};
+
+		/**
+		A hint to JavaScript bundlers or component tools when packaging modules for client side use.
+		*/
+		browser?:
+		| string
+		| Partial<Record<string, string | false>>;
+
+		/**
+		Denote which files in your project are "pure" and therefore safe for Webpack to prune if unused.
+
+		[Read more.](https://webpack.js.org/guides/tree-shaking/)
+		*/
+		sideEffects?: boolean | string[];
+	}
+
+	export interface TypeScriptConfiguration {
+		/**
+		Location of the bundled TypeScript declaration file.
+		*/
+		types?: string;
+
+		/**
+		Version selection map of TypeScript.
+		*/
+		typesVersions?: Partial<Record<string, Partial<Record<string, string[]>>>>;
+
+		/**
+		Location of the bundled TypeScript declaration file. Alias of `types`.
+		*/
+		typings?: string;
+	}
+
+	/**
+	An alternative configuration for Yarn workspaces.
+	*/
+	export interface WorkspaceConfig {
+		/**
+		An array of workspace pattern strings which contain the workspace packages.
+		*/
+		packages?: WorkspacePattern[];
+
+		/**
+		Designed to solve the problem of packages which break when their `node_modules` are moved to the root workspace directory - a process known as hoisting. For these packages, both within your workspace, and also some that have been installed via `node_modules`, it is important to have a mechanism for preventing the default Yarn workspace behavior. By adding workspace pattern strings here, Yarn will resume non-workspace behavior for any package which matches the defined patterns.
+
+		[Read more](https://classic.yarnpkg.com/blog/2018/02/15/nohoist/)
+		*/
+		nohoist?: WorkspacePattern[];
+	}
+
+	/**
+	A workspace pattern points to a directory or group of directories which contain packages that should be included in the workspace installation process.
+
+	The patterns are handled with [minimatch](https://github.com/isaacs/minimatch).
+
+	@example
+	`docs` → Include the docs directory and install its dependencies.
+	`packages/*` → Include all nested directories within the packages directory, like `packages/cli` and `packages/core`.
+	*/
+	type WorkspacePattern = string;
+
+	export interface YarnConfiguration {
+		/**
+		Used to configure [Yarn workspaces](https://classic.yarnpkg.com/docs/workspaces/).
+
+		Workspaces allow you to manage multiple packages within the same repository in such a way that you only need to run `yarn install` once to install all of them in a single pass.
+
+		Please note that the top-level `private` property of `package.json` **must** be set to `true` in order to use workspaces.
+		*/
+		workspaces?: WorkspacePattern[] | WorkspaceConfig;
+
+		/**
+		If your package only allows one version of a given dependency, and you’d like to enforce the same behavior as `yarn install --flat` on the command-line, set this to `true`.
+
+		Note that if your `package.json` contains `"flat": true` and other packages depend on yours (e.g. you are building a library rather than an app), those other packages will also need `"flat": true` in their `package.json` or be installed with `yarn install --flat` on the command-line.
+		*/
+		flat?: boolean;
+
+		/**
+		Selective version resolutions. Allows the definition of custom package versions inside dependencies without manual edits in the `yarn.lock` file.
+		*/
+		resolutions?: Dependency;
+	}
+
+	export interface JSPMConfiguration {
+		/**
+		JSPM configuration.
+		*/
+		jspm?: PackageJson$1;
+	}
+
+	/**
+	Type for [npm's `package.json` file](https://docs.npmjs.com/creating-a-package-json-file). Containing standard npm properties.
+	*/
+	export interface PackageJsonStandard {
+		/**
+		The name of the package.
+		*/
+		name?: string;
+
+		/**
+		Package version, parseable by [`node-semver`](https://github.com/npm/node-semver).
+		*/
+		version?: string;
+
+		/**
+		Package description, listed in `npm search`.
+		*/
+		description?: string;
+
+		/**
+		Keywords associated with package, listed in `npm search`.
+		*/
+		keywords?: string[];
+
+		/**
+		The URL to the package's homepage.
+		*/
+		homepage?: LiteralUnion<'.', string>;
+
+		/**
+		The URL to the package's issue tracker and/or the email address to which issues should be reported.
+		*/
+		bugs?: BugsLocation;
+
+		/**
+		The license for the package.
+		*/
+		license?: string;
+
+		/**
+		The licenses for the package.
+		*/
+		licenses?: Array<{
+			type?: string;
+			url?: string;
+		}>;
+
+		author?: Person;
+
+		/**
+		A list of people who contributed to the package.
+		*/
+		contributors?: Person[];
+
+		/**
+		A list of people who maintain the package.
+		*/
+		maintainers?: Person[];
+
+		/**
+		The files included in the package.
+		*/
+		files?: string[];
+
+		/**
+		Resolution algorithm for importing ".js" files from the package's scope.
+
+		[Read more.](https://nodejs.org/api/esm.html#esm_package_json_type_field)
+		*/
+		type?: 'module' | 'commonjs';
+
+		/**
+		The module ID that is the primary entry point to the program.
+		*/
+		main?: string;
+
+		/**
+		Subpath exports to define entry points of the package.
+
+		[Read more.](https://nodejs.org/api/packages.html#subpath-exports)
+		*/
+		exports?: Exports;
+
+		/**
+		Subpath imports to define internal package import maps that only apply to import specifiers from within the package itself.
+
+		[Read more.](https://nodejs.org/api/packages.html#subpath-imports)
+		*/
+		imports?: Imports;
+
+		/**
+		The executable files that should be installed into the `PATH`.
+		*/
+		bin?:
+		| string
+		| Partial<Record<string, string>>;
+
+		/**
+		Filenames to put in place for the `man` program to find.
+		*/
+		man?: string | string[];
+
+		/**
+		Indicates the structure of the package.
+		*/
+		directories?: DirectoryLocations;
+
+		/**
+		Location for the code repository.
+		*/
+		repository?:
+		| string
+		| {
+			type: string;
+			url: string;
+
+			/**
+			Relative path to package.json if it is placed in non-root directory (for example if it is part of a monorepo).
+
+			[Read more.](https://github.com/npm/rfcs/blob/latest/implemented/0010-monorepo-subdirectory-declaration.md)
+			*/
+			directory?: string;
+		};
+
+		/**
+		Script commands that are run at various times in the lifecycle of the package. The key is the lifecycle event, and the value is the command to run at that point.
+		*/
+		scripts?: Scripts;
+
+		/**
+		Is used to set configuration parameters used in package scripts that persist across upgrades.
+		*/
+		config?: Record<string, unknown>;
+
+		/**
+		The dependencies of the package.
+		*/
+		dependencies?: Dependency;
+
+		/**
+		Additional tooling dependencies that are not required for the package to work. Usually test, build, or documentation tooling.
+		*/
+		devDependencies?: Dependency;
+
+		/**
+		Dependencies that are skipped if they fail to install.
+		*/
+		optionalDependencies?: Dependency;
+
+		/**
+		Dependencies that will usually be required by the package user directly or via another dependency.
+		*/
+		peerDependencies?: Dependency;
+
+		/**
+		Indicate peer dependencies that are optional.
+		*/
+		peerDependenciesMeta?: Partial<Record<string, {optional: true}>>;
+
+		/**
+		Package names that are bundled when the package is published.
+		*/
+		bundledDependencies?: string[];
+
+		/**
+		Alias of `bundledDependencies`.
+		*/
+		bundleDependencies?: string[];
+
+		/**
+		Engines that this package runs on.
+		*/
+		engines?: {
+			[EngineName in 'npm' | 'node' | string]?: string;
+		};
+
+		/**
+		@deprecated
+		*/
+		engineStrict?: boolean;
+
+		/**
+		Operating systems the module runs on.
+		*/
+		os?: Array<LiteralUnion<
+		| 'aix'
+		| 'darwin'
+		| 'freebsd'
+		| 'linux'
+		| 'openbsd'
+		| 'sunos'
+		| 'win32'
+		| '!aix'
+		| '!darwin'
+		| '!freebsd'
+		| '!linux'
+		| '!openbsd'
+		| '!sunos'
+		| '!win32',
+		string
+		>>;
+
+		/**
+		CPU architectures the module runs on.
+		*/
+		cpu?: Array<LiteralUnion<
+		| 'arm'
+		| 'arm64'
+		| 'ia32'
+		| 'mips'
+		| 'mipsel'
+		| 'ppc'
+		| 'ppc64'
+		| 's390'
+		| 's390x'
+		| 'x32'
+		| 'x64'
+		| '!arm'
+		| '!arm64'
+		| '!ia32'
+		| '!mips'
+		| '!mipsel'
+		| '!ppc'
+		| '!ppc64'
+		| '!s390'
+		| '!s390x'
+		| '!x32'
+		| '!x64',
+		string
+		>>;
+
+		/**
+		If set to `true`, a warning will be shown if package is installed locally. Useful if the package is primarily a command-line application that should be installed globally.
+
+		@deprecated
+		*/
+		preferGlobal?: boolean;
+
+		/**
+		If set to `true`, then npm will refuse to publish it.
+		*/
+		private?: boolean;
+
+		/**
+		A set of config values that will be used at publish-time. It's especially handy to set the tag, registry or access, to ensure that a given package is not tagged with 'latest', published to the global public registry or that a scoped module is private by default.
+		*/
+		publishConfig?: PublishConfig;
+
+		/**
+		Describes and notifies consumers of a package's monetary support information.
+
+		[Read more.](https://github.com/npm/rfcs/blob/latest/accepted/0017-add-funding-support.md)
+		*/
+		funding?: string | {
+			/**
+			The type of funding.
+			*/
+			type?: LiteralUnion<
+			| 'github'
+			| 'opencollective'
+			| 'patreon'
+			| 'individual'
+			| 'foundation'
+			| 'corporation',
+			string
+			>;
+
+			/**
+			The URL to the funding page.
+			*/
+			url: string;
+		};
+	}
+
+	export interface PublishConfig {
+		/**
+		Additional, less common properties from the [npm docs on `publishConfig`](https://docs.npmjs.com/cli/v7/configuring-npm/package-json#publishconfig).
+		*/
+		[additionalProperties: string]: unknown;
+
+		/**
+		When publishing scoped packages, the access level defaults to restricted. If you want your scoped package to be publicly viewable (and installable) set `--access=public`. The only valid values for access are public and restricted. Unscoped packages always have an access level of public.
+		*/
+		access?: 'public' | 'restricted';
+
+		/**
+		The base URL of the npm registry.
+
+		Default: `'https://registry.npmjs.org/'`
+		*/
+		registry?: string;
+
+		/**
+		The tag to publish the package under.
+
+		Default: `'latest'`
+		*/
+		tag?: string;
+	}
+}
+
+/**
+Type for [npm's `package.json` file](https://docs.npmjs.com/creating-a-package-json-file). Also includes types for fields used by other popular projects, like TypeScript and Yarn.
+
+@category File
+*/
+type PackageJson$1 =
+PackageJson$1.PackageJsonStandard &
+PackageJson$1.NonStandardEntryPoints &
+PackageJson$1.TypeScriptConfiguration &
+PackageJson$1.YarnConfiguration &
+PackageJson$1.JSPMConfiguration;
+
+type ExportName = string;
+type MetaId = string;
+interface StoriesSpecifier {
+    /** When auto-titling, what to prefix all generated titles with (default: '') */
+    titlePrefix?: string;
+    /** Where to start looking for story files */
+    directory: string;
+    /**
+     * What does the filename of a story file look like? (a glob, relative to directory, no leading
+     * `./`) If unset, we use `** / *.@(mdx|stories.@(mdx|js|jsx|mjs|ts|tsx))` (no spaces)
+     */
+    files?: string;
+}
+type StoriesEntry = string | StoriesSpecifier;
+type NormalizedStoriesSpecifier = Required<StoriesSpecifier> & {
+    importPathMatcher: RegExp;
+};
+interface IndexerOptions {
+    makeTitle: (userTitle?: string) => string;
+}
+/**
+ * FIXME: This is a temporary type to allow us to deprecate the old indexer API. We should remove
+ * this type and the deprecated indexer API in 8.0.
+ */
+type BaseIndexer = {
+    /** A regular expression that should match all files to be handled by this indexer */
+    test: RegExp;
+};
+/**
+ * An indexer describes which filenames it handles, and how to index each individual file - turning
+ * it into an entry in the index.
+ */
+type Indexer = BaseIndexer & {
+    /**
+     * Indexes a file containing stories or docs.
+     *
+     * @param fileName The name of the file to index.
+     * @param options {@link IndexerOptions} for indexing the file.
+     * @returns A promise that resolves to an array of {@link IndexInput} objects.
+     */
+    createIndex: (fileName: string, options: IndexerOptions) => Promise<IndexInput[]>;
+};
+interface BaseIndexEntry {
+    id: StoryId;
+    name: StoryName;
+    title: ComponentTitle;
+    tags?: Tag$1[];
+    importPath: Path;
+}
+type StoryIndexEntry = BaseIndexEntry & {
+    type: 'story';
+};
+type DocsIndexEntry = BaseIndexEntry & {
+    storiesImports: Path[];
+    type: 'docs';
+};
+type IndexEntry = StoryIndexEntry | DocsIndexEntry;
+interface IndexInputStats {
+    loaders?: boolean;
+    play?: boolean;
+    render?: boolean;
+    storyFn?: boolean;
+    mount?: boolean;
+    beforeEach?: boolean;
+    moduleMock?: boolean;
+    globals?: boolean;
+    factory?: boolean;
+    tags?: boolean;
+}
+/** The base input for indexing a story or docs entry. */
+type BaseIndexInput = {
+    /** The file to import from e.g. the story file. */
+    importPath: Path;
+    /** The raw path/package of the file that provides meta.component, if one exists */
+    rawComponentPath?: Path;
+    /** The name of the export to import. */
+    exportName: ExportName;
+    /** The name of the entry, auto-generated from {@link exportName} if unspecified. */
+    name?: StoryName;
+    /** The location in the sidebar, auto-generated from {@link importPath} if unspecified. */
+    title?: ComponentTitle;
+    /**
+     * The custom id optionally set at `meta.id` if it needs to differ from the id generated via
+     * {@link title}. If unspecified, the meta id will be auto-generated from {@link title}. If
+     * specified, the meta in the CSF file _must_ have a matching id set at `meta.id`, to be correctly
+     * matched.
+     */
+    metaId?: MetaId;
+    /** Tags for filtering entries in Storybook and its tools. */
+    tags?: Tag$1[];
+    /**
+     * The id of the entry, auto-generated from {@link title}/{@link metaId} and {@link exportName} if
+     * unspecified. If specified, the story in the CSF file _must_ have a matching id set at
+     * `parameters.__id`, to be correctly matched. Only use this if you need to override the
+     * auto-generated id.
+     */
+    __id?: StoryId;
+    /** Stats about language feature usage that the indexer can optionally report */
+    __stats?: IndexInputStats;
+};
+/** The input for indexing a story entry. */
+type StoryIndexInput = BaseIndexInput & {
+    type: 'story';
+};
+/** The input for indexing a docs entry. */
+type DocsIndexInput = BaseIndexInput & {
+    type: 'docs';
+    /** Paths to story files that must be pre-loaded for this docs entry. */
+    storiesImports?: Path[];
+};
+type IndexInput = StoryIndexInput | DocsIndexInput;
+
+/** ⚠️ This file contains internal WIP types they MUST NOT be exported outside this package for now! */
+type BuilderName = 'webpack5' | '@storybook/builder-webpack5' | string;
+type RendererName = string;
+interface CoreConfig {
+    builder?: BuilderName | {
+        name: BuilderName;
+        options?: Record<string, any>;
+    };
+    renderer?: RendererName;
+    disableWebpackDefaults?: boolean;
+    channelOptions?: Partial<Options$1>;
+    /** Disables the generation of project.json, a file containing Storybook metadata */
+    disableProjectJson?: boolean;
+    /**
+     * Disables Storybook telemetry
+     *
+     * @see https://storybook.js.org/telemetry
+     */
+    disableTelemetry?: boolean;
+    /** Disables notifications for Storybook updates. */
+    disableWhatsNewNotifications?: boolean;
+    /**
+     * Enable crash reports to be sent to Storybook telemetry
+     *
+     * @see https://storybook.js.org/telemetry
+     */
+    enableCrashReports?: boolean;
+    /**
+     * Enable CORS headings to run document in a "secure context" see:
+     * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/SharedArrayBuffer#security_requirements
+     * This enables these headers in development-mode: Cross-Origin-Opener-Policy: same-origin
+     *
+     * ```text
+     * Cross-Origin-Embedder-Policy: require-corp
+     * ```
+     */
+    crossOriginIsolated?: boolean;
+}
+interface DirectoryMapping {
+    from: string;
+    to: string;
+}
+interface Presets {
+    apply(extension: 'typescript', config: TypescriptOptions, args?: Options): Promise<TypescriptOptions>;
+    apply(extension: 'framework', config?: {}, args?: any): Promise<Preset>;
+    apply(extension: 'babel', config?: {}, args?: any): Promise<any>;
+    apply(extension: 'swc', config?: {}, args?: any): Promise<any>;
+    apply(extension: 'entries', config?: [], args?: any): Promise<unknown>;
+    apply(extension: 'env', config?: {}, args?: any): Promise<any>;
+    apply(extension: 'stories', config?: [], args?: any): Promise<StoriesEntry[]>;
+    apply(extension: 'managerEntries', config: [], args?: any): Promise<string[]>;
+    apply(extension: 'refs', config?: [], args?: any): Promise<StorybookConfigRaw['refs']>;
+    apply(extension: 'core', config?: StorybookConfigRaw['core'], args?: any): Promise<NonNullable<StorybookConfigRaw['core']>>;
+    apply(extension: 'docs', config?: StorybookConfigRaw['docs'], args?: any): Promise<NonNullable<StorybookConfigRaw['docs']>>;
+    apply(extension: 'features', config?: StorybookConfigRaw['features'], args?: any): Promise<NonNullable<StorybookConfigRaw['features']>>;
+    apply(extension: 'typescript', config?: StorybookConfigRaw['typescript'], args?: any): Promise<NonNullable<StorybookConfigRaw['typescript']>>;
+    apply(extension: 'build', config?: StorybookConfigRaw['build'], args?: any): Promise<NonNullable<StorybookConfigRaw['build']>>;
+    apply(extension: 'staticDirs', config?: StorybookConfigRaw['staticDirs'], args?: any): Promise<StorybookConfigRaw['staticDirs']>;
+    apply<T>(extension: string, config?: T, args?: unknown): Promise<T>;
+}
+interface LoadedPreset {
+    name: string;
+    preset: any;
+    options: any;
+}
+interface VersionCheck {
+    success: boolean;
+    cached: boolean;
+    data?: any;
+    error?: any;
+    time: number;
+}
+interface Stats {
+    toJson: () => any;
+}
+interface BuilderResult {
+    totalTime?: ReturnType<typeof process.hrtime>;
+    stats?: Stats;
+}
+type PackageJson = PackageJson$1 & Record<string, any>;
+interface LoadOptions {
+    packageJson?: PackageJson;
+    outputDir?: string;
+    configDir?: string;
+    cacheKey?: string;
+    ignorePreview?: boolean;
+    extendServer?: (server: Server) => void;
+}
+interface CLIBaseOptions {
+    disableTelemetry?: boolean;
+    enableCrashReports?: boolean;
+    configDir?: string;
+    loglevel?: string;
+    quiet?: boolean;
+}
+interface CLIOptions extends CLIBaseOptions {
+    port?: number;
+    ignorePreview?: boolean;
+    previewUrl?: string;
+    forceBuildPreview?: boolean;
+    host?: string;
+    initialPath?: string;
+    exactPort?: boolean;
+    https?: boolean;
+    sslCa?: string[];
+    sslCert?: string;
+    sslKey?: string;
+    smokeTest?: boolean;
+    managerCache?: boolean;
+    open?: boolean;
+    ci?: boolean;
+    versionUpdates?: boolean;
+    docs?: boolean;
+    test?: boolean;
+    debugWebpack?: boolean;
+    webpackStatsJson?: string | boolean;
+    statsJson?: string | boolean;
+    outputDir?: string;
+    previewOnly?: boolean;
+}
+interface BuilderOptions$1 {
+    configType?: 'DEVELOPMENT' | 'PRODUCTION';
+    ignorePreview?: boolean;
+    cache?: FileSystemCache;
+    configDir: string;
+    docsMode?: boolean;
+    features?: StorybookConfigRaw['features'];
+    versionCheck?: VersionCheck;
+    disableWebpackDefaults?: boolean;
+    serverChannelUrl?: string;
+}
+interface StorybookConfigOptions {
+    presets: Presets;
+    presetsList?: LoadedPreset[];
+}
+type Options = LoadOptions & StorybookConfigOptions & CLIOptions & BuilderOptions$1 & {
+    build?: TestBuildConfig;
+};
+/** Options for TypeScript usage within Storybook. */
+interface TypescriptOptions {
+    /**
+     * Enables type checking within Storybook.
+     *
+     * @default false
+     */
+    check: boolean;
+    /**
+     * Disable parsing TypeScript files through compiler.
+     *
+     * @default false
+     */
+    skipCompiler: boolean;
+}
+type Preset = string | {
+    name: string;
+    options?: any;
+};
+/** An additional script that gets injected into the preview or the manager, */
+type Entry = string;
+type CoreCommon_StorybookRefs = Record<string, {
+    title: string;
+    url: string;
+} | {
+    disable: boolean;
+    expanded?: boolean;
+}>;
+type DocsOptions = {
+    /** What should we call the generated docs entries? */
+    defaultName?: string;
+    /** Only show doc entries in the side bar (usually set with the `--docs` CLI flag) */
+    docsMode?: boolean;
+};
+interface TestBuildFlags {
+    /**
+     * The package @storybook/blocks will be excluded from the bundle, even when imported in e.g. the
+     * preview.
+     */
+    disableBlocks?: boolean;
+    /** Disable specific addons */
+    disabledAddons?: string[];
+    /** Filter out .mdx stories entries */
+    disableMDXEntries?: boolean;
+    /** Override autodocs to be disabled */
+    disableAutoDocs?: boolean;
+    /** Override docgen to be disabled. */
+    disableDocgen?: boolean;
+    /** Override sourcemaps generation to be disabled. */
+    disableSourcemaps?: boolean;
+    /** Override tree-shaking (dead code elimination) to be disabled. */
+    disableTreeShaking?: boolean;
+    /** Minify with ESBuild when using webpack. */
+    esbuildMinify?: boolean;
+}
+interface TestBuildConfig {
+    test?: TestBuildFlags;
+}
+type Tag = string;
+interface TagOptions {
+    excludeFromSidebar: boolean;
+    excludeFromDocsStories: boolean;
+}
+type TagsOptions = Record<Tag, Partial<TagOptions>>;
+/**
+ * The interface for Storybook configuration used internally in presets The difference is that these
+ * values are the raw values, AKA, not wrapped with `PresetValue<>`
+ */
+interface StorybookConfigRaw {
+    /**
+     * Sets the addons you want to use with Storybook.
+     *
+     * @example
+     *
+     * ```ts
+     * addons = ['@storybook/addon-essentials'];
+     * addons = [{ name: '@storybook/addon-essentials', options: { backgrounds: false } }];
+     * ```
+     */
+    addons?: Preset[];
+    core?: CoreConfig;
+    staticDirs?: (DirectoryMapping | string)[];
+    logLevel?: string;
+    features?: {
+        /**
+         * Enable the integrated viewport addon
+         *
+         * @default true
+         */
+        viewport?: boolean;
+        /**
+         * Enable the integrated highlight addon
+         *
+         * @default true
+         */
+        highlight?: boolean;
+        /**
+         * Enable the integrated backgrounds addon
+         *
+         * @default true
+         */
+        backgrounds?: boolean;
+        /**
+         * Enable the integrated measure addon
+         *
+         * @default true
+         */
+        measure?: boolean;
+        /**
+         * Enable the integrated outline addon
+         *
+         * @default true
+         */
+        outline?: boolean;
+        /**
+         * Enable the integrated controls addon
+         *
+         * @default true
+         */
+        controls?: boolean;
+        /**
+         * Enable the integrated interactions addon
+         *
+         * @default true
+         */
+        interactions?: boolean;
+        /**
+         * Enable the integrated actions addon
+         *
+         * @default true
+         */
+        actions?: boolean;
+        /**
+         * @temporary This feature flag is a migration assistant, and is scheduled to be removed.
+         *
+         * Filter args with a "target" on the type from the render function (EXPERIMENTAL)
+         */
+        argTypeTargetsV7?: boolean;
+        /**
+         * @temporary This feature flag is a migration assistant, and is scheduled to be removed.
+         *
+         * Apply decorators from preview.js before decorators from addons or frameworks
+         */
+        legacyDecoratorFileOrder?: boolean;
+        /**
+         * @temporary This feature flag is a migration assistant, and is scheduled to be removed.
+         *
+         * Disallow implicit actions during rendering. This will be the default in Storybook 8.
+         *
+         * This will make sure that your story renders the same no matter if docgen is enabled or not.
+         */
+        disallowImplicitActionsInRenderV8?: boolean;
+        /**
+         * @temporary This feature flag is a migration assistant, and is scheduled to be removed.
+         *
+         * Enable asynchronous component rendering in React renderer
+         */
+        experimentalRSC?: boolean;
+        /**
+         * @temporary This feature flag is a migration assistant, and is scheduled to be removed.
+         *
+         * Set NODE_ENV to development in built Storybooks for better testability and debuggability
+         */
+        developmentModeForBuild?: boolean;
+        /** Only show input controls in Angular */
+        angularFilterNonInputControls?: boolean;
+    };
+    build?: TestBuildConfig;
+    stories: StoriesEntry[];
+    framework?: Preset;
+    typescript?: Partial<TypescriptOptions>;
+    refs?: CoreCommon_StorybookRefs;
+    babel?: any;
+    swc?: any;
+    env?: Record<string, string>;
+    babelDefault?: any;
+    previewAnnotations?: Entry[];
+    experimental_indexers?: Indexer[];
+    docs?: DocsOptions;
+    previewHead?: string;
+    previewBody?: string;
+    previewMainTemplate?: string;
+    managerHead?: string;
+    tags?: TagsOptions;
+}
+/**
+ * The interface for Storybook configuration in `main.ts` files. This interface is public All values
+ * should be wrapped with `PresetValue<>`, though there are a few exceptions: `addons`, `framework`
+ */
+interface StorybookConfig$1 {
+    /**
+     * Sets the addons you want to use with Storybook.
+     *
+     * @example
+     *
+     * ```
+     * addons = ['@storybook/addon-essentials'];
+     * addons = [{ name: '@storybook/addon-essentials', options: { backgrounds: false } }];
+     * ```
+     */
+    addons?: StorybookConfigRaw['addons'];
+    core?: PresetValue<StorybookConfigRaw['core']>;
+    /**
+     * Sets a list of directories of static files to be loaded by Storybook server
+     *
+     * @example
+     *
+     * ```ts
+     * staticDirs = ['./public'];
+     * staticDirs = [{ from: './public', to: '/assets' }];
+     * ```
+     */
+    staticDirs?: PresetValue<StorybookConfigRaw['staticDirs']>;
+    logLevel?: PresetValue<StorybookConfigRaw['logLevel']>;
+    features?: PresetValue<StorybookConfigRaw['features']>;
+    build?: PresetValue<StorybookConfigRaw['build']>;
+    /**
+     * Tells Storybook where to find stories.
+     *
+     * @example
+     *
+     * ```ts
+     * stories = ['./src/*.stories.@(j|t)sx?'];
+     * stories = async () => [...(await myCustomStoriesEntryBuilderFunc())];
+     * ```
+     */
+    stories: PresetValue<StorybookConfigRaw['stories']>;
+    /** Framework, e.g. '@storybook/react-vite', required in v7 */
+    framework?: StorybookConfigRaw['framework'];
+    /** Controls how Storybook handles TypeScript files. */
+    typescript?: PresetValue<StorybookConfigRaw['typescript']>;
+    /** References external Storybooks */
+    refs?: PresetValue<StorybookConfigRaw['refs']>;
+    /** Modify or return babel config. */
+    babel?: PresetValue<StorybookConfigRaw['babel']>;
+    /** Modify or return swc config. */
+    swc?: PresetValue<StorybookConfigRaw['swc']>;
+    /** Modify or return env config. */
+    env?: PresetValue<StorybookConfigRaw['env']>;
+    /** Modify or return babel config. */
+    babelDefault?: PresetValue<StorybookConfigRaw['babelDefault']>;
+    /** Add additional scripts to run in the preview a la `.storybook/preview.js` */
+    previewAnnotations?: PresetValue<StorybookConfigRaw['previewAnnotations']>;
+    /** Process CSF files for the story index. */
+    experimental_indexers?: PresetValue<StorybookConfigRaw['experimental_indexers']>;
+    /** Docs related features in index generation */
+    docs?: PresetValue<StorybookConfigRaw['docs']>;
+    /**
+     * Programmatically modify the preview head/body HTML. The previewHead and previewBody functions
+     * accept a string, which is the existing head/body, and return a modified string.
+     */
+    previewHead?: PresetValue<StorybookConfigRaw['previewHead']>;
+    previewBody?: PresetValue<StorybookConfigRaw['previewBody']>;
+    /**
+     * Programmatically override the preview's main page template. This should return a reference to a
+     * file containing an `.ejs` template that will be interpolated with environment variables.
+     *
+     * @example
+     *
+     * ```ts
+     * previewMainTemplate = '.storybook/index.ejs';
+     * ```
+     */
+    previewMainTemplate?: PresetValue<StorybookConfigRaw['previewMainTemplate']>;
+    /**
+     * Programmatically modify the preview head/body HTML. The managerHead function accept a string,
+     * which is the existing head content, and return a modified string.
+     */
+    managerHead?: PresetValue<StorybookConfigRaw['managerHead']>;
+    /** Configure non-standard tag behaviors */
+    tags?: PresetValue<StorybookConfigRaw['tags']>;
+}
+type PresetValue<T> = T | ((config: T, options: Options) => T | Promise<T>);
+type Addon_Comparator<T> = ((a: T, b: T) => boolean) | ((a: T, b: T) => number);
+type Addon_StorySortMethod = 'configure' | 'alphabetical';
+interface Addon_StorySortObjectParameter {
+    method?: Addon_StorySortMethod;
+    order?: any[];
+    locales?: string;
+    includeNames?: boolean;
+}
+type Addon_StorySortComparatorV7 = Addon_Comparator<IndexEntry>;
+type Addon_StorySortParameterV7 = Addon_StorySortComparatorV7 | Addon_StorySortObjectParameter;
+interface Addon_OptionsParameterV7 extends Object {
+    storySort?: Addon_StorySortParameterV7;
+    theme?: {
+        base: string;
+        brandTitle?: string;
+    };
+    [key: string]: any;
+}
+type Layout = 'centered' | 'fullscreen' | 'padded' | 'none';
+interface StorybookParameters {
+    options?: Addon_OptionsParameterV7;
+    /**
+     * The layout property defines basic styles added to the preview body where the story is rendered.
+     *
+     * If you pass `none`, no styles are applied.
+     */
+    layout?: Layout;
+}
+interface StorybookTypes {
+    parameters: StorybookParameters;
+}
+type Path = string;
+type MaybePromise<T> = Promise<T> | T;
+type TeardownRenderToCanvas = () => MaybePromise<void>;
+type RenderToCanvas<TRenderer extends Renderer> = (context: RenderContext<TRenderer>, element: TRenderer['canvasElement']) => MaybePromise<void | TeardownRenderToCanvas>;
+interface ProjectAnnotations<TRenderer extends Renderer> extends ProjectAnnotations$1<TRenderer> {
+    testingLibraryRender?: (...args: never[]) => {
+        unmount: () => void;
+    };
+    renderToCanvas?: RenderToCanvas<TRenderer>;
+}
+type NormalizedProjectAnnotations<TRenderer extends Renderer = Renderer> = Omit<ProjectAnnotations<TRenderer>, 'decorators' | 'loaders' | 'runStep' | 'beforeAll'> & {
+    argTypes?: StrictArgTypes;
+    globalTypes?: StrictGlobalTypes;
+    decorators?: DecoratorFunction<TRenderer>[];
+    loaders?: LoaderFunction$2<TRenderer>[];
+    runStep: StepRunner<TRenderer>;
+    beforeAll: BeforeAll;
+};
+declare type RenderContext<TRenderer extends Renderer = Renderer> = StoryIdentifier & {
+    showMain: () => void;
+    showError: (error: {
+        title: string;
+        description: string;
+    }) => void;
+    showException: (err: Error) => void;
+    forceRemount: boolean;
+    storyContext: StoryContext<TRenderer>;
+    storyFn: PartialStoryFn<TRenderer>;
+    unboundStoryFn: LegacyStoryFn<TRenderer>;
+};
+
+declare global {
+    var globalProjectAnnotations: NormalizedProjectAnnotations<any>;
+    var defaultProjectAnnotations: ProjectAnnotations<any>;
+}
+type WrappedStoryRef = {
+    __pw_type: 'jsx';
+    props: Record<string, any>;
+} | {
+    __pw_type: 'importRef';
+};
+type UnwrappedJSXStoryRef = {
+    __pw_type: 'jsx';
+    type: UnwrappedImportStoryRef;
+};
+type UnwrappedImportStoryRef = ComposedStoryFn;
+declare global {
+    function __pwUnwrapObject(storyRef: WrappedStoryRef): Promise<UnwrappedJSXStoryRef | UnwrappedImportStoryRef>;
+}
+
+interface Report<T = unknown> {
+    type: string;
+    version?: number;
+    result: T;
+    status: 'failed' | 'passed' | 'warning';
+}
+declare class ReporterAPI {
+    reports: Report[];
+    addReport(report: Report): Promise<void>;
+}
+/** A story function with partial args, used internally by composeStory */
+type PartialArgsStoryFn<TRenderer extends Renderer = Renderer, TArgs = Args> = (args?: TArgs) => (TRenderer & {
+    T: TArgs;
+})['storyResult'];
+/**
+ * A story that got recomposed for portable stories, containing all the necessary data to be
+ * rendered in external environments
+ */
+type ComposedStoryFn<TRenderer extends Renderer = Renderer, TArgs = Args> = PartialArgsStoryFn<TRenderer, TArgs> & {
+    args: TArgs;
+    id: StoryId;
+    play?: (context?: Partial<StoryContext<TRenderer, Partial<TArgs>>>) => Promise<void>;
+    run: (context?: Partial<StoryContext<TRenderer, Partial<TArgs>>>) => Promise<void>;
+    load: () => Promise<void>;
+    storyName: string;
+    parameters: Parameters;
+    argTypes: StrictArgTypes<TArgs>;
+    reporting: ReporterAPI;
+    tags: Tag$1[];
+    globals: Globals;
+};
+
+type RulesConfig = any;
+type ModuleConfig = {
+    rules?: RulesConfig[];
+};
+type ResolveConfig = {
+    extensions?: string[];
+    mainFields?: (string | string[])[] | undefined;
+    alias?: any;
+};
+interface WebpackConfiguration {
+    plugins?: any[];
+    module?: ModuleConfig;
+    resolve?: ResolveConfig;
+    optimization?: any;
+    devtool?: false | string;
+}
+type BuilderOptions = {
+    fsCache?: boolean;
+    lazyCompilation?: boolean;
+};
+type StorybookConfig<TWebpackConfiguration = WebpackConfiguration> = StorybookConfig$1 & {
+    /**
+     * Modify or return a custom Webpack config after the Storybook's default configuration has run
+     * (mostly used by addons).
+     */
+    webpack?: (config: TWebpackConfiguration, options: Options) => TWebpackConfiguration | Promise<TWebpackConfiguration>;
+    /** Modify or return a custom Webpack config after every addon has run. */
+    webpackFinal?: (config: TWebpackConfiguration, options: Options) => TWebpackConfiguration | Promise<TWebpackConfiguration>;
+};
+
+declare const loadCustomWebpackConfig: (configDir: string) => any;
+
+declare const checkWebpackVersion: (webpack: {
+    version?: string;
+}, specifier: string, caption: string) => void;
+
+declare function mergeConfigs(config: WebpackConfiguration, customConfig: WebpackConfiguration): WebpackConfiguration;
+
+declare function webpackIncludeRegexp(specifier: NormalizedStoriesSpecifier): RegExp;
+declare function toImportFnPart(specifier: NormalizedStoriesSpecifier): string;
+declare function toImportFn(stories: NormalizedStoriesSpecifier[], { needPipelinedImport }?: {
+    needPipelinedImport?: boolean;
+}): string;
+
+declare const toRequireContext: (specifier: NormalizedStoriesSpecifier) => {
+    path: string;
+    recursive: boolean;
+    match: RegExp;
+};
+declare const toRequireContextString: (specifier: NormalizedStoriesSpecifier) => string;
+
+export { checkWebpackVersion, loadCustomWebpackConfig, mergeConfigs, toImportFn, toImportFnPart, toRequireContext, toRequireContextString, webpackIncludeRegexp };
+export type { BuilderOptions, BuilderResult, ModuleConfig, Options, Preset, ResolveConfig, RulesConfig, StorybookConfig, TypescriptOptions, WebpackConfiguration };