storybook 9.0.0-alpha.12 → 9.0.0-alpha.14

package/dist/preview-api/index.d.ts

@@ -1,7 +1,7 @@
 import { Channel } from 'storybook/internal/channels';
 import * as storybook_internal_types from 'storybook/internal/types';
-import { ProjectAnnotations as ProjectAnnotations$1, Renderer as Renderer$1, Args, StoryContext, DecoratorApplicator, StoryId, Addon_StoryWrapper, PreparedStory, Globals, GlobalTypes, StoryIndex, StoryName, ComponentTitle, IndexEntry, Path, StoryAnnotationsOrFn, NormalizedComponentAnnotations, NormalizedStoryAnnotations, ModuleExports, CSFFile, NormalizedProjectAnnotations as NormalizedProjectAnnotations$1, ModuleExport, PreparedMeta, StepRunner, ComposedStoryFn, Store_CSFExports, ComposeStoryFn, LegacyStoryAnnotationsOrFn, ComponentAnnotations, NamedOrDefaultProjectAnnotations, ModuleImportFn, Parameters, StoryContextForEnhancers, StrictArgTypes, ArgTypesEnhancer, LegacyStoryFn, DecoratorFunction, PartialStoryFn, StoryContextUpdate, NormalizedStoriesSpecifier, Addon_StorySortParameterV7, DocsContextProps, ResolvedModuleExportType, ResolvedModuleExportFromType, StoryRenderOptions, RenderContextCallbacks, RenderToCanvas as RenderToCanvas$1, ViewMode } from 'storybook/internal/types';
-import { CleanupCallback, Renderer as Renderer$2, ProjectAnnotations as ProjectAnnotations$2, StoryIdentifier, StoryContext as StoryContext$1, PartialStoryFn as PartialStoryFn$1, LegacyStoryFn as LegacyStoryFn$1, StrictArgTypes as StrictArgTypes$1, StrictGlobalTypes, DecoratorFunction as DecoratorFunction$1, LoaderFunction, StepRunner as StepRunner$1, BeforeAll } from 'storybook/internal/csf';
+import { ProjectAnnotations, Renderer as Renderer$1, Args as Args$1, StoryContext as StoryContext$1, DecoratorApplicator, StoryId as StoryId$1, Addon_StoryWrapper, PreparedStory, Globals as Globals$1, GlobalTypes, StoryIndex, StoryName as StoryName$1, ComponentTitle as ComponentTitle$1, IndexEntry, Path, StoryAnnotationsOrFn, NormalizedComponentAnnotations, NormalizedStoryAnnotations, ModuleExports, CSFFile, NormalizedProjectAnnotations, ModuleExport, PreparedMeta, StepRunner, ComposedStoryFn, Store_CSFExports, ComposeStoryFn, LegacyStoryAnnotationsOrFn, ComponentAnnotations, NamedOrDefaultProjectAnnotations, ModuleImportFn, StoryContextForEnhancers as StoryContextForEnhancers$1, Parameters as Parameters$1, StrictArgTypes as StrictArgTypes$1, ArgTypesEnhancer, LegacyStoryFn as LegacyStoryFn$1, DecoratorFunction, PartialStoryFn, StoryContextUpdate as StoryContextUpdate$1, NormalizedStoriesSpecifier, Addon_StorySortParameterV7, DocsContextProps, ResolvedModuleExportType, ResolvedModuleExportFromType, StoryRenderOptions, RenderContextCallbacks, RenderToCanvas, ViewMode as ViewMode$1 } from 'storybook/internal/types';
+import { CleanupCallback } from 'storybook/internal/csf';
 import { RequestData, ArgTypesRequestPayload } from 'storybook/internal/core-events';
 
 declare class AddonStore {
@@ -16,7 +16,7 @@ declare class AddonStore {
 }
 declare const addons: AddonStore;
 
-declare function definePreview(config: ProjectAnnotations$1<Renderer$1>): ProjectAnnotations$1<Renderer$1>;
+declare function definePreview(config: ProjectAnnotations<Renderer$1>): ProjectAnnotations<Renderer$1>;
 
 interface Hook {
     name: string;
@@ -28,7 +28,7 @@ interface Effect {
     destroy?: (() => void) | void;
 }
 type AbstractFunction = (...args: any[]) => any;
-declare class HooksContext<TRenderer extends Renderer$1, TArgs extends Args = Args> {
+declare class HooksContext<TRenderer extends Renderer$1, TArgs extends Args$1 = Args$1> {
     hookListsMap: WeakMap<AbstractFunction, Hook[]>;
     mountedDecorators: Set<AbstractFunction>;
     prevMountedDecorators: Set<AbstractFunction>;
@@ -39,8 +39,8 @@ declare class HooksContext<TRenderer extends Renderer$1, TArgs extends Args = Ar
     prevEffects: Effect[];
     currentDecoratorName: string | null;
     hasUpdates: boolean;
-    currentContext: StoryContext<TRenderer, TArgs> | null;
-    renderListener: (storyId: StoryId) => void;
+    currentContext: StoryContext$1<TRenderer, TArgs> | null;
+    renderListener: (storyId: StoryId$1) => void;
     constructor();
     init(): void;
     clean(): void;
@@ -215,7 +215,7 @@ declare function useChannel(eventMap: EventMap, deps?: any[]): (eventName: strin
  * @template TArgs The type of the story's args.
  * @returns {StoryContext<TRenderer>} The current story context.
  */
-declare function useStoryContext<TRenderer extends Renderer$1, TArgs extends Args = Args>(): StoryContext<TRenderer>;
+declare function useStoryContext<TRenderer extends Renderer$1, TArgs extends Args$1 = Args$1>(): StoryContext$1<TRenderer>;
 /**
  * Returns the value of a specific parameter for the current story, or a default value if the
  * parameter is not set.
@@ -251,7 +251,7 @@ declare function useParameter<S>(parameterKey: string, defaultValue?: S): S | un
  * @returns {[TArgs, (newArgs: Partial<TArgs>) => void, (argNames?: (keyof TArgs)[]) => void]} An
  *   array containing the current args, a function to update them, and a function to reset them.
  */
-declare function useArgs<TArgs extends Args = Args>(): [
+declare function useArgs<TArgs extends Args$1 = Args$1>(): [
     TArgs,
     (newArgs: Partial<TArgs>) => void,
     (argNames?: (keyof TArgs)[]) => void
@@ -270,7 +270,7 @@ declare function useArgs<TArgs extends Args = Args>(): [
  * @returns {[Args, (newGlobals: Args) => void]} An array containing the current global args, and a
  *   function to update them.
  */
-declare function useGlobals(): [Args, (newGlobals: Args) => void];
+declare function useGlobals(): [Args$1, (newGlobals: Args$1) => void];
 
 type MakeDecoratorResult = (...args: any) => any;
 interface MakeDecoratorOptions {
@@ -312,55 +312,55 @@ declare const makeDecorator: ({ name, parameterName, wrapper, skipIfNoParameters
 declare function mockChannel(): Channel;
 
 declare class ArgsStore {
-    initialArgsByStoryId: Record<StoryId, Args>;
-    argsByStoryId: Record<StoryId, Args>;
-    get(storyId: StoryId): Args;
+    initialArgsByStoryId: Record<StoryId$1, Args$1>;
+    argsByStoryId: Record<StoryId$1, Args$1>;
+    get(storyId: StoryId$1): Args$1;
     setInitial(story: PreparedStory<any>): void;
-    updateFromDelta(story: PreparedStory<any>, delta: Args): void;
-    updateFromPersisted(story: PreparedStory<any>, persisted: Args): void;
-    update(storyId: StoryId, argsUpdate: Partial<Args>): void;
+    updateFromDelta(story: PreparedStory<any>, delta: Args$1): void;
+    updateFromPersisted(story: PreparedStory<any>, persisted: Args$1): void;
+    update(storyId: StoryId$1, argsUpdate: Partial<Args$1>): void;
 }
 
 declare class GlobalsStore {
     allowedGlobalNames: Set<string>;
-    initialGlobals: Globals;
-    globals: Globals;
+    initialGlobals: Globals$1;
+    globals: Globals$1;
     constructor({ globals, globalTypes, }: {
-        globals?: Globals;
+        globals?: Globals$1;
         globalTypes?: GlobalTypes;
     });
     set({ globals, globalTypes }: {
-        globals?: Globals;
+        globals?: Globals$1;
         globalTypes?: GlobalTypes;
     }): void;
-    filterAllowedGlobals(globals: Globals): Globals;
-    updateFromPersisted(persisted: Globals): void;
-    get(): Globals;
-    update(newGlobals: Globals): void;
+    filterAllowedGlobals(globals: Globals$1): Globals$1;
+    updateFromPersisted(persisted: Globals$1): void;
+    get(): Globals$1;
+    update(newGlobals: Globals$1): void;
 }
 
-type StorySpecifier = StoryId | {
-    name: StoryName;
-    title: ComponentTitle;
+type StorySpecifier = StoryId$1 | {
+    name: StoryName$1;
+    title: ComponentTitle$1;
 } | '*';
 declare class StoryIndexStore {
     entries: StoryIndex['entries'];
     constructor({ entries }?: StoryIndex);
     entryFromSpecifier(specifier: StorySpecifier): IndexEntry | undefined;
-    storyIdToEntry(storyId: StoryId): IndexEntry;
+    storyIdToEntry(storyId: StoryId$1): IndexEntry;
     importPathToEntry(importPath: Path): IndexEntry;
 }
 
-declare function normalizeStory<TRenderer extends Renderer$1>(key: StoryId, storyAnnotations: StoryAnnotationsOrFn<TRenderer>, meta: NormalizedComponentAnnotations<TRenderer>): NormalizedStoryAnnotations<TRenderer>;
+declare function normalizeStory<TRenderer extends Renderer$1>(key: StoryId$1, storyAnnotations: StoryAnnotationsOrFn<TRenderer>, meta: NormalizedComponentAnnotations<TRenderer>): NormalizedStoryAnnotations<TRenderer>;
 
-declare function processCSFFile<TRenderer extends Renderer$1>(moduleExports: ModuleExports, importPath: Path, title: ComponentTitle): CSFFile<TRenderer>;
+declare function processCSFFile<TRenderer extends Renderer$1>(moduleExports: ModuleExports, importPath: Path, title: ComponentTitle$1): CSFFile<TRenderer>;
 
-declare function prepareStory<TRenderer extends Renderer$1>(storyAnnotations: NormalizedStoryAnnotations<TRenderer>, componentAnnotations: NormalizedComponentAnnotations<TRenderer>, projectAnnotations: NormalizedProjectAnnotations$1<TRenderer>): PreparedStory<TRenderer>;
-declare function prepareMeta<TRenderer extends Renderer$1>(componentAnnotations: NormalizedComponentAnnotations<TRenderer>, projectAnnotations: NormalizedProjectAnnotations$1<TRenderer>, moduleExport: ModuleExport): PreparedMeta<TRenderer>;
+declare function prepareStory<TRenderer extends Renderer$1>(storyAnnotations: NormalizedStoryAnnotations<TRenderer>, componentAnnotations: NormalizedComponentAnnotations<TRenderer>, projectAnnotations: NormalizedProjectAnnotations<TRenderer>): PreparedStory<TRenderer>;
+declare function prepareMeta<TRenderer extends Renderer$1>(componentAnnotations: NormalizedComponentAnnotations<TRenderer>, projectAnnotations: NormalizedProjectAnnotations<TRenderer>, moduleExport: ModuleExport): PreparedMeta<TRenderer>;
 
-declare function normalizeProjectAnnotations<TRenderer extends Renderer$1>({ argTypes, globalTypes, argTypesEnhancers, decorators, loaders, beforeEach, experimental_afterEach, initialGlobals, ...annotations }: ProjectAnnotations$1<TRenderer>): NormalizedProjectAnnotations$1<TRenderer>;
+declare function normalizeProjectAnnotations<TRenderer extends Renderer$1>({ argTypes, globalTypes, argTypesEnhancers, decorators, loaders, beforeEach, experimental_afterEach, initialGlobals, ...annotations }: ProjectAnnotations<TRenderer>): NormalizedProjectAnnotations<TRenderer>;
 
-declare function composeConfigs<TRenderer extends Renderer$1>(moduleExportList: ModuleExports[]): NormalizedProjectAnnotations$1<TRenderer>;
+declare function composeConfigs<TRenderer extends Renderer$1>(input: ModuleExports[]): NormalizedProjectAnnotations<TRenderer>;
 
 /**
  * Compose step runners to create a single step runner that applies each step runner in order.
@@ -389,13 +389,13 @@ declare function composeConfigs<TRenderer extends Renderer$1>(moduleExportList:
 declare function composeStepRunners<TRenderer extends Renderer$1>(stepRunners: StepRunner<TRenderer>[]): StepRunner<TRenderer>;
 
 declare global {
-    var globalProjectAnnotations: NormalizedProjectAnnotations$1<any>;
-    var defaultProjectAnnotations: ProjectAnnotations$1<any>;
+    var globalProjectAnnotations: NormalizedProjectAnnotations<any>;
+    var defaultProjectAnnotations: ProjectAnnotations<any>;
 }
-declare function setDefaultProjectAnnotations<TRenderer extends Renderer$1 = Renderer$1>(_defaultProjectAnnotations: ProjectAnnotations$1<TRenderer>): void;
-declare function setProjectAnnotations<TRenderer extends Renderer$1 = Renderer$1>(projectAnnotations: NamedOrDefaultProjectAnnotations<TRenderer> | NamedOrDefaultProjectAnnotations<TRenderer>[]): NormalizedProjectAnnotations$1<TRenderer>;
-declare function composeStory<TRenderer extends Renderer$1 = Renderer$1, TArgs extends Args = Args>(storyAnnotations: LegacyStoryAnnotationsOrFn<TRenderer>, componentAnnotations: ComponentAnnotations<TRenderer, TArgs>, projectAnnotations?: ProjectAnnotations$1<TRenderer>, defaultConfig?: ProjectAnnotations$1<TRenderer>, exportsName?: string): ComposedStoryFn<TRenderer, Partial<TArgs>>;
-declare function composeStories<TModule extends Store_CSFExports>(storiesImport: TModule, globalConfig: ProjectAnnotations$1<Renderer$1>, composeStoryFn?: ComposeStoryFn): {};
+declare function setDefaultProjectAnnotations<TRenderer extends Renderer$1 = Renderer$1>(_defaultProjectAnnotations: ProjectAnnotations<TRenderer>): void;
+declare function setProjectAnnotations<TRenderer extends Renderer$1 = Renderer$1>(projectAnnotations: NamedOrDefaultProjectAnnotations<TRenderer> | NamedOrDefaultProjectAnnotations<TRenderer>[]): NormalizedProjectAnnotations<TRenderer>;
+declare function composeStory<TRenderer extends Renderer$1 = Renderer$1, TArgs extends Args$1 = Args$1>(storyAnnotations: LegacyStoryAnnotationsOrFn<TRenderer>, componentAnnotations: ComponentAnnotations<TRenderer, TArgs>, projectAnnotations?: ProjectAnnotations<TRenderer>, defaultConfig?: ProjectAnnotations<TRenderer>, exportsName?: string): ComposedStoryFn<TRenderer, Partial<TArgs>>;
+declare function composeStories<TModule extends Store_CSFExports>(storiesImport: TModule, globalConfig: ProjectAnnotations<Renderer$1>, composeStoryFn?: ComposeStoryFn): {};
 type WrappedStoryRef = {
     __pw_type: 'jsx' | 'importRef';
 };
@@ -411,63 +411,63 @@ declare function createPlaywrightTest<TFixture extends {
     extend: any;
 }>(baseTest: TFixture): TFixture;
 
-declare function getCsfFactoryAnnotations<TRenderer extends Renderer$1 = Renderer$1, TArgs extends Args = Args>(story: LegacyStoryAnnotationsOrFn<TRenderer>, meta?: ComponentAnnotations<TRenderer, TArgs>, projectAnnotations?: ProjectAnnotations$1<TRenderer>): {
-    story: storybook_internal_types.StoryAnnotations<Renderer$1, Args>;
-    meta: ComponentAnnotations<Renderer$1, Args>;
+declare function getCsfFactoryAnnotations<TRenderer extends Renderer$1 = Renderer$1, TArgs extends Args$1 = Args$1>(story: LegacyStoryAnnotationsOrFn<TRenderer>, meta?: ComponentAnnotations<TRenderer, TArgs>, projectAnnotations?: ProjectAnnotations<TRenderer>): {
+    story: storybook_internal_types.StoryAnnotations<Renderer$1, Args$1>;
+    meta: ComponentAnnotations<Renderer$1, Args$1>;
     preview: storybook_internal_types.NormalizedProjectAnnotations<Renderer$1>;
 } | {
     story: LegacyStoryAnnotationsOrFn<TRenderer>;
     meta: ComponentAnnotations<TRenderer, TArgs> | undefined;
-    preview: ProjectAnnotations$1<TRenderer> | undefined;
+    preview: ProjectAnnotations<TRenderer> | undefined;
 };
 
-interface Report<T = unknown> {
+interface Report$1<T = unknown> {
     type: string;
     version?: number;
     result: T;
     status: 'failed' | 'passed' | 'warning';
 }
 declare class ReporterAPI {
-    reports: Report[];
-    addReport(report: Report): Promise<void>;
+    reports: Report$1[];
+    addReport(report: Report$1): Promise<void>;
 }
 
 declare class StoryStore<TRenderer extends Renderer$1> {
     importFn: ModuleImportFn;
     storyIndex: StoryIndexStore;
-    projectAnnotations: NormalizedProjectAnnotations$1<TRenderer>;
+    projectAnnotations: NormalizedProjectAnnotations<TRenderer>;
     userGlobals: GlobalsStore;
     args: ArgsStore;
-    hooks: Record<StoryId, HooksContext<TRenderer>>;
-    cleanupCallbacks: Record<StoryId, CleanupCallback[] | undefined>;
+    hooks: Record<StoryId$1, HooksContext<TRenderer>>;
+    cleanupCallbacks: Record<StoryId$1, CleanupCallback[] | undefined>;
     cachedCSFFiles?: Record<Path, CSFFile<TRenderer>>;
     processCSFFileWithCache: typeof processCSFFile;
     prepareMetaWithCache: typeof prepareMeta;
     prepareStoryWithCache: typeof prepareStory;
-    constructor(storyIndex: StoryIndex, importFn: ModuleImportFn, projectAnnotations: ProjectAnnotations$1<TRenderer>);
-    setProjectAnnotations(projectAnnotations: ProjectAnnotations$1<TRenderer>): void;
+    constructor(storyIndex: StoryIndex, importFn: ModuleImportFn, projectAnnotations: ProjectAnnotations<TRenderer>);
+    setProjectAnnotations(projectAnnotations: ProjectAnnotations<TRenderer>): void;
     onStoriesChanged({ importFn, storyIndex, }: {
         importFn?: ModuleImportFn;
         storyIndex?: StoryIndex;
     }): Promise<void>;
-    storyIdToEntry(storyId: StoryId): Promise<IndexEntry>;
-    loadCSFFileByStoryId(storyId: StoryId): Promise<CSFFile<TRenderer>>;
+    storyIdToEntry(storyId: StoryId$1): Promise<IndexEntry>;
+    loadCSFFileByStoryId(storyId: StoryId$1): Promise<CSFFile<TRenderer>>;
     loadAllCSFFiles(): Promise<StoryStore<TRenderer>['cachedCSFFiles']>;
     cacheAllCSFFiles(): Promise<void>;
     preparedMetaFromCSFFile({ csfFile }: {
         csfFile: CSFFile<TRenderer>;
     }): PreparedMeta<TRenderer>;
     loadStory({ storyId }: {
-        storyId: StoryId;
+        storyId: StoryId$1;
     }): Promise<PreparedStory<TRenderer>>;
     storyFromCSFFile({ storyId, csfFile, }: {
-        storyId: StoryId;
+        storyId: StoryId$1;
         csfFile: CSFFile<TRenderer>;
     }): PreparedStory<TRenderer>;
     componentStoriesFromCSFFile({ csfFile, }: {
         csfFile: CSFFile<TRenderer>;
     }): PreparedStory<TRenderer>[];
-    loadEntry(id: StoryId): Promise<{
+    loadEntry(id: StoryId$1): Promise<{
         entryExports: ModuleExports;
         csfFiles: CSFFile<TRenderer>[];
     }>;
@@ -489,13 +489,13 @@ declare class StoryStore<TRenderer extends Renderer$1> {
         subcomponents?: Record<string, (TRenderer & {
             T: any;
         })["component"]> | undefined;
-        parameters: Parameters;
+        parameters: storybook_internal_types.Parameters;
         initialArgs: storybook_internal_types.Args;
         argTypes: storybook_internal_types.StrictArgTypes<storybook_internal_types.Args>;
         componentId: storybook_internal_types.ComponentId;
-        title: ComponentTitle;
-        kind: ComponentTitle;
-        id: StoryId;
+        title: storybook_internal_types.ComponentTitle;
+        kind: storybook_internal_types.ComponentTitle;
+        id: StoryId$1;
         name: storybook_internal_types.StoryName;
         story: storybook_internal_types.StoryName;
         tags: storybook_internal_types.Tag[];
@@ -518,7 +518,7 @@ declare class StoryStore<TRenderer extends Renderer$1> {
     cleanupStory(story: PreparedStory<TRenderer>): Promise<void>;
     extract(options?: {
         includeDocsOnly?: boolean;
-    }): Record<StoryId, StoryContextForEnhancers<TRenderer>>;
+    }): Record<StoryId$1, StoryContextForEnhancers$1<TRenderer>>;
 }
 
 /**
@@ -526,14 +526,14 @@ declare class StoryStore<TRenderer extends Renderer$1> {
  * overwrite the existing value UNLESS both values are plain objects. In this case flag the key as
  * "special" and handle it with a heuristic.
  */
-declare const combineParameters: (...parameterSets: (Parameters | undefined)[]) => Parameters;
+declare const combineParameters: (...parameterSets: (Parameters$1 | undefined)[]) => Parameters$1;
 
 type PropDescriptor = string[] | RegExp;
-declare const filterArgTypes: (argTypes: StrictArgTypes, include?: PropDescriptor, exclude?: PropDescriptor) => Partial<StrictArgTypes<storybook_internal_types.Args>>;
+declare const filterArgTypes: (argTypes: StrictArgTypes$1, include?: PropDescriptor, exclude?: PropDescriptor) => Partial<StrictArgTypes$1<storybook_internal_types.Args>>;
 
 declare const inferControls: ArgTypesEnhancer<Renderer$1>;
 
-declare function decorateStory<TRenderer extends Renderer$1>(storyFn: LegacyStoryFn<TRenderer>, decorator: DecoratorFunction<TRenderer>, bindWithContext: (storyFn: LegacyStoryFn<TRenderer>) => PartialStoryFn<TRenderer>): LegacyStoryFn<TRenderer>;
+declare function decorateStory<TRenderer extends Renderer$1>(storyFn: LegacyStoryFn$1<TRenderer>, decorator: DecoratorFunction<TRenderer>, bindWithContext: (storyFn: LegacyStoryFn$1<TRenderer>) => PartialStoryFn<TRenderer>): LegacyStoryFn$1<TRenderer>;
 /**
  * Currently StoryContextUpdates are allowed to have any key in the type. However, you cannot
  * overwrite any of the build-it "static" keys.
@@ -541,10 +541,10 @@ declare function decorateStory<TRenderer extends Renderer$1>(storyFn: LegacyStor
  * @param inputContextUpdate StoryContextUpdate
  * @returns StoryContextUpdate
  */
-declare function sanitizeStoryContextUpdate({ componentId, title, kind, id, name, story, parameters, initialArgs, argTypes, ...update }?: StoryContextUpdate): StoryContextUpdate;
-declare function defaultDecorateStory<TRenderer extends Renderer$1>(storyFn: LegacyStoryFn<TRenderer>, decorators: DecoratorFunction<TRenderer>[]): LegacyStoryFn<TRenderer>;
+declare function sanitizeStoryContextUpdate({ componentId, title, kind, id, name, story, parameters, initialArgs, argTypes, ...update }?: StoryContextUpdate$1): StoryContextUpdate$1;
+declare function defaultDecorateStory<TRenderer extends Renderer$1>(storyFn: LegacyStoryFn$1<TRenderer>, decorators: DecoratorFunction<TRenderer>[]): LegacyStoryFn$1<TRenderer>;
 
-declare const combineArgs: (value: any, update: any) => Args;
+declare const combineArgs: (value: any, update: any) => Args$1;
 
 declare const userOrAutoTitleFromSpecifier: (fileName: string | number, entry: NormalizedStoriesSpecifier, userTitle?: string) => string | undefined;
 declare const userOrAutoTitle: (fileName: string, storiesEntries: NormalizedStoriesSpecifier[], userTitle?: string) => string | undefined;
@@ -572,10 +572,10 @@ declare class DocsContext<TRenderer extends Renderer$1> implements DocsContextPr
     private resolveAttachedModuleExportType;
     private resolveModuleExport;
     resolveOf<TType extends ResolvedModuleExportType>(moduleExportOrType: ModuleExport | TType, validTypes?: TType[]): ResolvedModuleExportFromType<TType, TRenderer>;
-    storyIdByName: (storyName: StoryName) => string;
+    storyIdByName: (storyName: StoryName$1) => string;
     componentStories: () => PreparedStory<TRenderer>[];
     componentStoriesFromCSFFile: (csfFile: CSFFile<TRenderer>) => PreparedStory<TRenderer>[];
-    storyById: (storyId?: StoryId) => PreparedStory<TRenderer>;
+    storyById: (storyId?: StoryId$1) => PreparedStory<TRenderer>;
     getStoryContext: (story: PreparedStory<TRenderer>) => {
         loaded: {};
         viewMode: string;
@@ -600,9 +600,9 @@ declare class DocsContext<TRenderer extends Renderer$1> implements DocsContextPr
         componentId: storybook_internal_types.ComponentId;
         title: storybook_internal_types.ComponentTitle;
         kind: storybook_internal_types.ComponentTitle;
-        id: StoryId;
-        name: StoryName;
-        story: StoryName;
+        id: StoryId$1;
+        name: StoryName$1;
+        story: StoryName$1;
         tags: storybook_internal_types.Tag[];
         moduleExport: ModuleExport;
         originalStoryFn: storybook_internal_types.ArgsStoryFn<TRenderer>;
@@ -622,7 +622,7 @@ declare class DocsContext<TRenderer extends Renderer$1> implements DocsContextPr
         argsByTarget: any;
         unmappedArgs: any;
     };
-    loadStory: (id: StoryId) => Promise<PreparedStory<TRenderer>>;
+    loadStory: (id: StoryId$1) => Promise<PreparedStory<TRenderer>>;
 }
 
 type RenderType = 'story' | 'docs';
@@ -636,7 +636,7 @@ type RenderType = 'story' | 'docs';
  */
 interface Render<TRenderer extends Renderer$1> {
     type: RenderType;
-    id: StoryId;
+    id: StoryId$1;
     isPreparing: () => boolean;
     isEqual: (other: Render<TRenderer>) => boolean;
     disableKeyListeners: boolean;
@@ -665,7 +665,7 @@ declare class CsfDocsRender<TRenderer extends Renderer$1> implements Render<TRen
     private callbacks;
     readonly type: RenderType;
     readonly subtype = "csf";
-    readonly id: StoryId;
+    readonly id: StoryId$1;
     story?: PreparedStory<TRenderer>;
     rerender?: () => Promise<void>;
     teardownRender?: (options: {
@@ -703,7 +703,7 @@ declare class MdxDocsRender<TRenderer extends Renderer$1> implements Render<TRen
     private callbacks;
     readonly type: RenderType;
     readonly subtype = "mdx";
-    readonly id: StoryId;
+    readonly id: StoryId$1;
     private exports?;
     rerender?: () => Promise<void>;
     teardownRender?: (options: {
@@ -730,8 +730,8 @@ declare class StoryRender<TRenderer extends Renderer$1> implements Render<TRende
     store: StoryStore<TRenderer>;
     private renderToScreen;
     private callbacks;
-    id: StoryId;
-    viewMode: StoryContext<TRenderer>['viewMode'];
+    id: StoryId$1;
+    viewMode: StoryContext$1<TRenderer>['viewMode'];
     renderOptions: StoryRenderOptions;
     type: RenderType;
     story?: PreparedStory<TRenderer>;
@@ -743,9 +743,9 @@ declare class StoryRender<TRenderer extends Renderer$1> implements Render<TRende
     disableKeyListeners: boolean;
     private teardownRender;
     torndown: boolean;
-    constructor(channel: Channel, store: StoryStore<TRenderer>, renderToScreen: RenderToCanvas$1<TRenderer>, callbacks: RenderContextCallbacks<TRenderer> & {
+    constructor(channel: Channel, store: StoryStore<TRenderer>, renderToScreen: RenderToCanvas<TRenderer>, callbacks: RenderContextCallbacks<TRenderer> & {
         showStoryDuringRender?: () => void;
-    }, id: StoryId, viewMode: StoryContext<TRenderer>['viewMode'], renderOptions?: StoryRenderOptions, story?: PreparedStory<TRenderer>);
+    }, id: StoryId$1, viewMode: StoryContext$1<TRenderer>['viewMode'], renderOptions?: StoryRenderOptions, story?: PreparedStory<TRenderer>);
     private runPhase;
     private checkIfAborted;
     prepare(): Promise<void>;
@@ -770,13 +770,13 @@ declare class StoryRender<TRenderer extends Renderer$1> implements Render<TRende
     teardown(): Promise<void>;
 }
 
-type MaybePromise$1<T> = Promise<T> | T;
+type MaybePromise<T> = Promise<T> | T;
 declare class Preview<TRenderer extends Renderer$1> {
     importFn: ModuleImportFn;
-    getProjectAnnotations: () => MaybePromise$1<ProjectAnnotations$1<TRenderer>>;
+    getProjectAnnotations: () => MaybePromise<ProjectAnnotations<TRenderer>>;
     protected channel: Channel;
     protected storyStoreValue?: StoryStore<TRenderer>;
-    renderToCanvas?: RenderToCanvas$1<TRenderer>;
+    renderToCanvas?: RenderToCanvas<TRenderer>;
     storyRenders: StoryRender<TRenderer>[];
     previewEntryError?: Error;
     private projectAnnotationsBeforeInitialization?;
@@ -784,20 +784,20 @@ declare class Preview<TRenderer extends Renderer$1> {
     protected storeInitializationPromise: Promise<void>;
     protected resolveStoreInitializationPromise: () => void;
     protected rejectStoreInitializationPromise: (err: Error) => void;
-    constructor(importFn: ModuleImportFn, getProjectAnnotations: () => MaybePromise$1<ProjectAnnotations$1<TRenderer>>, channel?: Channel, shouldInitialize?: boolean);
+    constructor(importFn: ModuleImportFn, getProjectAnnotations: () => MaybePromise<ProjectAnnotations<TRenderer>>, channel?: Channel, shouldInitialize?: boolean);
     get storyStore(): StoryStore<TRenderer>;
     protected initialize(): Promise<void>;
     ready(): Promise<void>;
     setupListeners(): void;
-    getProjectAnnotationsOrRenderError(): Promise<ProjectAnnotations$1<TRenderer>>;
-    initializeWithProjectAnnotations(projectAnnotations: ProjectAnnotations$1<TRenderer>): Promise<void>;
-    runBeforeAllHook(projectAnnotations: ProjectAnnotations$1<TRenderer>): Promise<void>;
+    getProjectAnnotationsOrRenderError(): Promise<ProjectAnnotations<TRenderer>>;
+    initializeWithProjectAnnotations(projectAnnotations: ProjectAnnotations<TRenderer>): Promise<void>;
+    runBeforeAllHook(projectAnnotations: ProjectAnnotations<TRenderer>): Promise<void>;
     getStoryIndexFromServer(): Promise<StoryIndex>;
     protected initializeWithStoryIndex(storyIndex: StoryIndex): void;
     setInitialGlobals(): Promise<void>;
     emitGlobals(): void;
     onGetProjectAnnotationsChanged({ getProjectAnnotations, }: {
-        getProjectAnnotations: () => MaybePromise$1<ProjectAnnotations$1<TRenderer>>;
+        getProjectAnnotations: () => MaybePromise<ProjectAnnotations<TRenderer>>;
     }): Promise<void>;
     onStoryIndexChanged(): Promise<void>;
     onStoriesChanged({ importFn, storyIndex, }: {
@@ -805,12 +805,12 @@ declare class Preview<TRenderer extends Renderer$1> {
         storyIndex?: StoryIndex;
     }): Promise<void>;
     onUpdateGlobals({ globals: updatedGlobals, currentStory, }: {
-        globals: Globals;
+        globals: Globals$1;
         currentStory?: PreparedStory<TRenderer>;
     }): Promise<void>;
     onUpdateArgs({ storyId, updatedArgs }: {
-        storyId: StoryId;
-        updatedArgs: Args;
+        storyId: StoryId$1;
+        updatedArgs: Args$1;
     }): Promise<void>;
     onRequestArgTypesInfo({ id, payload }: RequestData<ArgTypesRequestPayload>): Promise<void>;
     onResetArgs({ storyId, argNames }: {
@@ -819,22 +819,22 @@ declare class Preview<TRenderer extends Renderer$1> {
     }): Promise<void>;
     onForceReRender(): Promise<void>;
     onForceRemount({ storyId }: {
-        storyId: StoryId;
+        storyId: StoryId$1;
     }): Promise<void>;
     renderStoryToElement(story: PreparedStory<TRenderer>, element: TRenderer['canvasElement'], callbacks: RenderContextCallbacks<TRenderer>, options: StoryRenderOptions): () => Promise<void>;
     teardownRender(render: StoryRender<TRenderer> | CsfDocsRender<TRenderer> | MdxDocsRender<TRenderer>, { viewModeChanged }?: {
         viewModeChanged?: boolean;
     }): Promise<void>;
     loadStory({ storyId }: {
-        storyId: StoryId;
+        storyId: StoryId$1;
     }): Promise<PreparedStory<TRenderer>>;
     getStoryContext(story: PreparedStory<TRenderer>, { forceInitialArgs }?: {
         forceInitialArgs?: boolean | undefined;
     }): {
-        args: Args;
-        initialGlobals: Globals;
+        args: Args$1;
+        initialGlobals: Globals$1;
         globalTypes: (storybook_internal_types.GlobalTypes & storybook_internal_types.StrictGlobalTypes) | undefined;
-        userGlobals: Globals;
+        userGlobals: Globals$1;
         reporting: ReporterAPI;
         globals: {
             [x: string]: any;
@@ -847,12 +847,12 @@ declare class Preview<TRenderer extends Renderer$1> {
             T: any;
         })["component"]> | undefined;
         parameters: storybook_internal_types.Parameters;
-        initialArgs: Args;
-        argTypes: storybook_internal_types.StrictArgTypes<Args>;
+        initialArgs: Args$1;
+        argTypes: storybook_internal_types.StrictArgTypes<Args$1>;
         componentId: storybook_internal_types.ComponentId;
         title: storybook_internal_types.ComponentTitle;
         kind: storybook_internal_types.ComponentTitle;
-        id: StoryId;
+        id: StoryId$1;
         name: storybook_internal_types.StoryName;
         story: storybook_internal_types.StoryName;
         tags: storybook_internal_types.Tag[];
@@ -860,32 +860,32 @@ declare class Preview<TRenderer extends Renderer$1> {
         originalStoryFn: storybook_internal_types.ArgsStoryFn<TRenderer>;
         undecoratedStoryFn: storybook_internal_types.LegacyStoryFn<TRenderer>;
         unboundStoryFn: storybook_internal_types.LegacyStoryFn<TRenderer>;
-        applyLoaders: (context: storybook_internal_types.StoryContext<TRenderer, Args>) => Promise<Record<string, any>>;
-        applyBeforeEach: (context: storybook_internal_types.StoryContext<TRenderer, Args>) => Promise<CleanupCallback[]>;
-        applyAfterEach: (context: storybook_internal_types.StoryContext<TRenderer, Args>) => Promise<void>;
-        playFunction?: ((context: storybook_internal_types.StoryContext<TRenderer, Args>) => Promise<void> | void) | undefined;
+        applyLoaders: (context: storybook_internal_types.StoryContext<TRenderer, Args$1>) => Promise<Record<string, any>>;
+        applyBeforeEach: (context: storybook_internal_types.StoryContext<TRenderer, Args$1>) => Promise<CleanupCallback[]>;
+        applyAfterEach: (context: storybook_internal_types.StoryContext<TRenderer, Args$1>) => Promise<void>;
+        playFunction?: ((context: storybook_internal_types.StoryContext<TRenderer, Args$1>) => Promise<void> | void) | undefined;
         runStep: storybook_internal_types.StepRunner<TRenderer>;
-        mount: (context: storybook_internal_types.StoryContext<TRenderer, Args>) => () => Promise<storybook_internal_types.Canvas>;
+        mount: (context: storybook_internal_types.StoryContext<TRenderer, Args$1>) => () => Promise<storybook_internal_types.Canvas>;
         testingLibraryRender?: (...args: never[]) => unknown;
-        renderToCanvas?: RenderToCanvas$1<TRenderer> | undefined;
+        renderToCanvas?: RenderToCanvas<TRenderer> | undefined;
         usesMount: boolean;
-        storyGlobals: Globals;
-    } & Pick<storybook_internal_types.StoryContextForLoaders<Renderer$1, Args>, "allArgs" | "argsByTarget" | "unmappedArgs">;
+        storyGlobals: Globals$1;
+    } & Pick<storybook_internal_types.StoryContextForLoaders<Renderer$1, Args$1>, "allArgs" | "argsByTarget" | "unmappedArgs">;
     extract(options?: {
         includeDocsOnly: boolean;
-    }): Promise<Record<string, storybook_internal_types.StoryContextForEnhancers<TRenderer, Args>>>;
+    }): Promise<Record<string, storybook_internal_types.StoryContextForEnhancers<TRenderer, Args$1>>>;
     renderPreviewEntryError(reason: string, err: Error): void;
 }
 
 interface SelectionSpecifier {
     storySpecifier: StorySpecifier;
-    viewMode: ViewMode;
-    args?: Args;
-    globals?: Args;
+    viewMode: ViewMode$1;
+    args?: Args$1;
+    globals?: Args$1;
 }
 interface Selection {
-    storyId: StoryId;
-    viewMode: ViewMode;
+    storyId: StoryId$1;
+    viewMode: ViewMode$1;
 }
 interface SelectionStore {
     selectionSpecifier: SelectionSpecifier | null;
@@ -917,18 +917,18 @@ interface View<TStorybookRoot> {
 type PossibleRender<TRenderer extends Renderer$1> = StoryRender<TRenderer> | CsfDocsRender<TRenderer> | MdxDocsRender<TRenderer>;
 declare class PreviewWithSelection<TRenderer extends Renderer$1> extends Preview<TRenderer> {
     importFn: ModuleImportFn;
-    getProjectAnnotations: () => MaybePromise$1<ProjectAnnotations$1<TRenderer>>;
+    getProjectAnnotations: () => MaybePromise<ProjectAnnotations<TRenderer>>;
     selectionStore: SelectionStore;
     view: View<TRenderer['canvasElement']>;
     currentSelection?: Selection;
     currentRender?: PossibleRender<TRenderer>;
-    constructor(importFn: ModuleImportFn, getProjectAnnotations: () => MaybePromise$1<ProjectAnnotations$1<TRenderer>>, selectionStore: SelectionStore, view: View<TRenderer['canvasElement']>);
+    constructor(importFn: ModuleImportFn, getProjectAnnotations: () => MaybePromise<ProjectAnnotations<TRenderer>>, selectionStore: SelectionStore, view: View<TRenderer['canvasElement']>);
     setupListeners(): void;
     setInitialGlobals(): Promise<void>;
     initializeWithStoryIndex(storyIndex: StoryIndex): Promise<void>;
     selectSpecifiedStory(): Promise<void>;
     onGetProjectAnnotationsChanged({ getProjectAnnotations, }: {
-        getProjectAnnotations: () => MaybePromise$1<ProjectAnnotations$1<TRenderer>>;
+        getProjectAnnotations: () => MaybePromise<ProjectAnnotations<TRenderer>>;
     }): Promise<void>;
     onStoriesChanged({ importFn, storyIndex, }: {
         importFn?: ModuleImportFn;
@@ -936,27 +936,27 @@ declare class PreviewWithSelection<TRenderer extends Renderer$1> extends Preview
     }): Promise<void>;
     onKeydown(event: KeyboardEvent): void;
     onSetCurrentStory(selection: {
-        storyId: StoryId;
-        viewMode?: ViewMode;
+        storyId: StoryId$1;
+        viewMode?: ViewMode$1;
     }): Promise<void>;
     onUpdateQueryParams(queryParams: any): void;
     onUpdateGlobals({ globals }: {
-        globals: Globals;
+        globals: Globals$1;
     }): Promise<void>;
     onUpdateArgs({ storyId, updatedArgs }: {
-        storyId: StoryId;
-        updatedArgs: Args;
+        storyId: StoryId$1;
+        updatedArgs: Args$1;
     }): Promise<void>;
     onPreloadStories({ ids }: {
         ids: string[];
     }): Promise<void>;
     protected renderSelection({ persistedArgs }?: {
-        persistedArgs?: Args;
+        persistedArgs?: Args$1;
     }): Promise<void>;
     teardownRender(render: PossibleRender<TRenderer>, { viewModeChanged }?: {
         viewModeChanged?: boolean;
     }): Promise<void>;
-    mainStoryCallbacks(storyId: StoryId): {
+    mainStoryCallbacks(storyId: StoryId$1): {
         showStoryDuringRender: () => void;
         showMain: () => void;
         showError: (err: {
@@ -968,8 +968,8 @@ declare class PreviewWithSelection<TRenderer extends Renderer$1> extends Preview
     renderPreviewEntryError(reason: string, err: Error): void;
     renderMissingStory(): void;
     renderStoryLoadingException(storySpecifier: StorySpecifier, err: Error): void;
-    renderException(storyId: StoryId, error: Error): void;
-    renderError(storyId: StoryId, { title, description }: {
+    renderException(storyId: StoryId$1, error: Error): void;
+    renderError(storyId: StoryId$1, { title, description }: {
         title: string;
         description: string;
     }): void;
@@ -977,8 +977,8 @@ declare class PreviewWithSelection<TRenderer extends Renderer$1> extends Preview
 
 declare class PreviewWeb<TRenderer extends Renderer$1> extends PreviewWithSelection<TRenderer> {
     importFn: ModuleImportFn;
-    getProjectAnnotations: () => MaybePromise$1<ProjectAnnotations$1<TRenderer>>;
-    constructor(importFn: ModuleImportFn, getProjectAnnotations: () => MaybePromise$1<ProjectAnnotations$1<TRenderer>>);
+    getProjectAnnotations: () => MaybePromise<ProjectAnnotations<TRenderer>>;
+    constructor(importFn: ModuleImportFn, getProjectAnnotations: () => MaybePromise<ProjectAnnotations<TRenderer>>);
 }
 
 declare class UrlStore implements SelectionStore {
@@ -1040,41 +1040,268 @@ declare global {
 	}
 }
 
-interface Renderer extends Renderer$2 {
+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;
 
-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$2<TRenderer> {
-    addons?: ProjectAnnotations<TRenderer>[];
-    testingLibraryRender?: (...args: never[]) => {
-        unmount: () => void;
-    };
-    renderToCanvas?: RenderToCanvas<TRenderer>;
+type StoryId = string;
+type ComponentId = string;
+type ComponentTitle = string;
+type StoryName = string;
+type Tag = string;
+interface StoryIdentifier {
+    componentId: ComponentId;
+    title: ComponentTitle;
+    /** @deprecated */
+    kind: ComponentTitle;
+    id: StoryId;
+    name: StoryName;
+    /** @deprecated */
+    story: StoryName;
+    tags: Tag[];
+}
+interface Parameters {
+    [name: string]: any;
 }
-type NormalizedProjectAnnotations<TRenderer extends Renderer = Renderer> = Omit<ProjectAnnotations<TRenderer>, 'decorators' | 'loaders' | 'runStep' | 'beforeAll'> & {
-    argTypes?: StrictArgTypes$1;
-    globalTypes?: StrictGlobalTypes;
-    decorators?: DecoratorFunction$1<TRenderer>[];
-    loaders?: LoaderFunction<TRenderer>[];
-    runStep: StepRunner$1<TRenderer>;
-    beforeAll: BeforeAll;
+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;
 };
-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$1<TRenderer>;
-    storyFn: PartialStoryFn$1<TRenderer>;
-    unboundStoryFn: LegacyStoryFn$1<TRenderer>;
+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 {
+    type: string;
+    version?: number;
+    result: unknown;
+    status: 'failed' | 'passed' | 'warning';
+}
+interface ReportingAPI {
+    reports: Report[];
+    addReport: (report: Report) => 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'];
+    /**
+     * @see https://storybook.js.org/docs/api/arg-types#defaultvalue
+     *
+     * @deprecated Use `table.defaultValue.summary` instead.
+     */
+    defaultValue?: any;
+    [key: string]: any;
+}
+interface StrictInputType extends InputType {
+    name: string;
+    type?: SBType;
+}
+interface Args {
+    [name: string]: any;
+}
+type StrictArgTypes<TArgs = Args> = {
+    [name in keyof TArgs]: StrictInputType;
+};
+interface Globals {
+    [name: string]: any;
+}
+interface Renderer {
+    /** What is the type of the `component` annotation in this renderer? */
+    component: unknown;
+    /** What does the story function return in this renderer? */
+    storyResult: unknown;
+    /** What type of element does this renderer render to? */
+    canvasElement: unknown;
+    mount(): Promise<Canvas>;
+    T?: unknown;
+}
+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>;
+}
+interface StoryContextUpdate<TArgs = Args> {
+    args?: TArgs;
+    globals?: Globals;
+    [key: string]: any;
+}
+type ViewMode = 'story' | 'docs';
+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: StoryFn<TRenderer>;
+    viewMode: ViewMode;
+    step: StepFunction<TRenderer, TArgs>;
+    context: this;
+    canvas: Canvas;
+    mount: TRenderer['mount'];
+    reporting: ReportingAPI;
+}
+/** @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 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 StoryFn<TRenderer extends Renderer = Renderer, TArgs = Args> = LegacyStoryFn<TRenderer, TArgs> | ArgsStoryFn<TRenderer, TArgs>;
+
+type ReducedStoryContext = Omit<StoryContext<any, Args>, 'abortSignal' | 'canvasElement' | 'step' | 'context'>;
+declare function emitTransformCode(source: string | undefined, context: ReducedStoryContext): Promise<void>;
 
 declare function getCoreAnnotations(): any[];
-declare function getComposedCoreAnnotations<TRenderer extends Renderer$1>(): NormalizedProjectAnnotations<TRenderer>;
 
-export { DocsContext, HooksContext, Preview, PreviewWeb, PreviewWithSelection, type PropDescriptor, type Report, ReporterAPI, type SelectionStore, StoryStore, UrlStore, type View, WebView, addons, applyHooks, combineArgs, combineParameters, composeConfigs, composeStepRunners, composeStories, composeStory, createPlaywrightTest, decorateStory, defaultDecorateStory, definePreview, filterArgTypes, getComposedCoreAnnotations, getCoreAnnotations, getCsfFactoryAnnotations, inferControls, makeDecorator, mockChannel, normalizeProjectAnnotations, normalizeStory, prepareMeta, prepareStory, sanitizeStoryContextUpdate, setDefaultProjectAnnotations, setProjectAnnotations, simulateDOMContentLoaded, simulatePageLoad, sortStoriesV7, useArgs, useCallback, useChannel, useEffect, useGlobals, useMemo, useParameter, useReducer, useRef, useState, useStoryContext, userOrAutoTitle, userOrAutoTitleFromSpecifier };
+export { DocsContext, HooksContext, Preview, PreviewWeb, PreviewWithSelection, type PropDescriptor, type Report$1 as Report, ReporterAPI, type SelectionStore, StoryStore, UrlStore, type View, WebView, addons, applyHooks, combineArgs, combineParameters, composeConfigs, composeStepRunners, composeStories, composeStory, createPlaywrightTest, decorateStory, defaultDecorateStory, definePreview, emitTransformCode, filterArgTypes, getCoreAnnotations, getCsfFactoryAnnotations, inferControls, makeDecorator, mockChannel, normalizeProjectAnnotations, normalizeStory, prepareMeta, prepareStory, sanitizeStoryContextUpdate, setDefaultProjectAnnotations, setProjectAnnotations, simulateDOMContentLoaded, simulatePageLoad, sortStoriesV7, useArgs, useCallback, useChannel, useEffect, useGlobals, useMemo, useParameter, useReducer, useRef, useState, useStoryContext, userOrAutoTitle, userOrAutoTitleFromSpecifier };