storybook 9.0.0-alpha.2 → 9.0.0-alpha.20

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

@@ -2,11 +2,11 @@ import React, { FC, ReactNode, ReactElement, Component } from 'react';
 import { Channel, Listener as Listener$1 } from 'storybook/internal/channels';
 export { Listener as ChannelListener } from 'storybook/internal/channels';
 import { RouterData, NavigateOptions } from 'storybook/internal/router';
-import { Addon_Types, Addon_TypesEnum, Addon_Collection, Addon_TypesMapping, Addon_BaseType, Addon_SidebarTopType, Addon_SidebarBottomType, Addon_TestProviderType, Addon_PageType, Addon_WrapperType, Addon_Config, API_ProviderData, API_StateMerger, API_Provider, StoryId, Globals, GlobalTypes, API_PanelPositions, API_Layout, API_UI, API_Notification, API_IframeRenderer, API_ComposedRef, API_SetRefData, API_ComposedRefUpdate, API_Refs, API_Settings, API_HashEntry, API_ViewMode, API_LeafEntry, API_PreparedStoryIndex, API_StoryEntry, Args, API_IndexHash, API_DocsEntry, API_StatusObject, API_StatusUpdate, API_StatusState, API_FilterFunction, API_LoadedRefData, API_Version, API_Versions, API_UnknownEntries, API_OptionsData, Parameters, ArgTypes } from 'storybook/internal/types';
+import { Addon_Types, Addon_TypesEnum, Addon_Collection, Addon_TypesMapping, Addon_BaseType, Addon_TestProviderType, Addon_PageType, Addon_WrapperType, Addon_Config, API_ProviderData, API_StateMerger, API_Provider, Globals, GlobalTypes, API_PanelPositions, API_Layout, API_UI, API_Notification, API_IframeRenderer, API_ComposedRef, API_SetRefData, API_ComposedRefUpdate, API_Refs, StoryId, API_Settings, API_HashEntry, API_ViewMode, API_LeafEntry, API_PreparedStoryIndex, API_StoryEntry, Args, API_IndexHash, API_DocsEntry, API_FilterFunction, API_LoadedRefData, API_Version, API_Versions, API_UnknownEntries, API_OptionsData, Parameters, ArgTypes, NormalizedProjectAnnotations, ProjectAnnotations, ComposedStoryFn } from 'storybook/internal/types';
 export { Addon_Type as Addon, API_ComponentEntry as ComponentEntry, API_ComposedRef as ComposedRef, API_DocsEntry as DocsEntry, API_GroupEntry as GroupEntry, API_HashEntry as HashEntry, API_IndexHash as IndexHash, API_LeafEntry as LeafEntry, API_Refs as Refs, API_RootEntry as RootEntry, API_IndexHash as StoriesHash, API_StoryEntry as StoryEntry } from 'storybook/internal/types';
-import { TestProviderState, TestProviderId, TestProviders, WhatsNewData } from 'storybook/internal/core-events';
-import { ThemeVars } from 'storybook/internal/theming';
-import { toId } from 'storybook/internal/csf';
+import { ThemeVars } from 'storybook/theming';
+import { toId, StoryId as StoryId$1 } from 'storybook/internal/csf';
+import { WhatsNewData } from 'storybook/internal/core-events';
 
 declare function mockChannel(): Channel;
 
@@ -22,7 +22,7 @@ declare class AddonStore {
     ready: () => Promise<Channel>;
     hasChannel: () => boolean;
     setChannel: (channel: Channel) => void;
-    getElements<T extends Addon_Types | Addon_TypesEnum.experimental_PAGE | Addon_TypesEnum.experimental_SIDEBAR_BOTTOM | Addon_TypesEnum.experimental_SIDEBAR_TOP | Addon_TypesEnum.experimental_TEST_PROVIDER>(type: T): Addon_Collection<Addon_TypesMapping[T]> | any;
+    getElements<T extends Addon_Types | Addon_TypesEnum.experimental_PAGE | Addon_TypesEnum.experimental_TEST_PROVIDER>(type: T): Addon_Collection<Addon_TypesMapping[T]> | any;
     /**
      * Adds an addon to the addon store.
      *
@@ -30,7 +30,7 @@ declare class AddonStore {
      * @param {Addon_Type} addon - The addon to add.
      * @returns {void}
      */
-    add(id: string, addon: Addon_BaseType | Omit<Addon_SidebarTopType, 'id'> | Omit<Addon_SidebarBottomType, 'id'> | Omit<Addon_TestProviderType, 'id'> | Omit<Addon_PageType, 'id'> | Omit<Addon_WrapperType, 'id'>): void;
+    add(id: string, addon: Addon_BaseType | Omit<Addon_TestProviderType, 'id'> | Omit<Addon_PageType, 'id'> | Omit<Addon_WrapperType, 'id'>): void;
     setConfig: (value: Addon_Config) => void;
     getConfig: () => Addon_Config;
     /**
@@ -81,7 +81,7 @@ type ModuleArgs = RouterData & API_ProviderData<API> & {
     store: Store;
 };
 
-interface SubAPI$d {
+interface SubAPI$c {
     /**
      * Returns a collection of elements of a specific type.
      *
@@ -91,7 +91,7 @@ interface SubAPI$d {
      * @returns {Addon_Collection<T>} - A collection of elements of the specified type.
      * @protected This is used internally in storybook's manager.
      */
-    getElements: <T extends Addon_Types | Addon_TypesEnum.experimental_PAGE | Addon_TypesEnum.experimental_SIDEBAR_BOTTOM | Addon_TypesEnum.experimental_TEST_PROVIDER | Addon_TypesEnum.experimental_SIDEBAR_TOP = Addon_Types>(type: T) => Addon_Collection<Addon_TypesMapping[T]>;
+    getElements: <T extends Addon_Types | Addon_TypesEnum.experimental_PAGE | Addon_TypesEnum.experimental_TEST_PROVIDER>(type: T) => Addon_Collection<Addon_TypesMapping[T]>;
     /**
      * Returns the id of the currently selected panel.
      *
@@ -128,7 +128,7 @@ interface SubAPI$d {
     getAddonState<S>(addonId: string): S;
 }
 
-interface SubAPI$c {
+interface SubAPI$b {
     /**
      * Returns the channel object.
      *
@@ -171,20 +171,6 @@ interface SubAPI$c {
     once: (type: string, handler: Listener$1) => void;
 }
 
-type SubState$a = {
-    testProviders: TestProviders;
-};
-interface RunOptions {
-    entryId?: StoryId;
-}
-type SubAPI$b = {
-    getTestProviderState(id: string): TestProviderState | undefined;
-    updateTestProviderState(id: TestProviderId, update: Partial<TestProviderState>): void;
-    clearTestProviderState(id: TestProviderId): void;
-    runTestProvider(id: TestProviderId, options?: RunOptions): () => void;
-    cancelTestProvider(id: TestProviderId): void;
-};
-
 interface SubState$9 {
     globals?: Globals;
     userGlobals?: Globals;
@@ -391,7 +377,7 @@ interface SubState$5 {
 
 declare const isMacLike: () => boolean;
 declare const controlOrMetaSymbol: () => "⌘" | "ctrl";
-declare const controlOrMetaKey: () => "control" | "meta";
+declare const controlOrMetaKey: () => "meta" | "control";
 declare const optionOrAltSymbol: () => "⌥" | "alt";
 declare const isShortcutTaken: (arr1: string[], arr2: string[]) => boolean;
 type KeyboardEventLike = Pick<KeyboardEvent, 'altKey' | 'ctrlKey' | 'metaKey' | 'shiftKey' | 'key' | 'code' | 'keyCode' | 'preventDefault'>;
@@ -507,7 +493,6 @@ interface SubState$3 extends API_LoadedRefData {
     storyId: StoryId;
     internal_index?: API_PreparedStoryIndex;
     viewMode: API_ViewMode;
-    status: API_StatusState;
     filters: Record<string, API_FilterFunction>;
 }
 interface SubAPI$3 {
@@ -652,6 +637,14 @@ interface SubAPI$3 {
      * @returns {StoryId} The ID of the leaf story, or null if no leaf story was found.
      */
     findLeafStoryId(index: API_IndexHash, storyId: StoryId): StoryId;
+    /**
+     * Finds all the leaf story IDs for the given entry ID in the given index.
+     *
+     * @param {StoryId} entryId - The ID of the entry to find the leaf story IDs for.
+     * @returns {StoryId[]} The IDs of all the leaf stories, or an empty array if no leaf stories were
+     *   found.
+     */
+    findAllLeafStoryIds(entryId: string): StoryId[];
     /**
      * Finds the ID of the sibling story in the given direction for the given story ID in the given
      * story index.
@@ -694,20 +687,6 @@ interface SubAPI$3 {
      * @returns {Promise<void>} A promise that resolves when the preview has been set as initialized.
      */
     setPreviewInitialized: (ref?: API_ComposedRef) => Promise<void>;
-    /**
-     * Returns the current status of the stories.
-     *
-     * @returns {API_StatusState} The current status of the stories.
-     */
-    getCurrentStoryStatus: () => Record<string, API_StatusObject>;
-    /**
-     * Updates the status of a collection of stories.
-     *
-     * @param {string} addonId - The ID of the addon to update.
-     * @param {StatusUpdate} update - An object containing the updated status information.
-     * @returns {Promise<void>} A promise that resolves when the status has been updated.
-     */
-    experimental_updateStatus: (addonId: string, update: API_StatusUpdate | ((state: API_StatusState) => API_StatusUpdate)) => Promise<void>;
     /**
      * Updates the filtering of the index.
      *
@@ -833,6 +812,67 @@ declare const experimental_requestResponse: <RequestPayload, ResponsePayload = v
 
 declare const _default: <TObj = any>(a: TObj, ...b: Partial<TObj>[]) => TObj;
 
+declare const ActiveTabs: {
+    SIDEBAR: "sidebar";
+    CANVAS: "canvas";
+    ADDONS: "addons";
+};
+
+declare const ManagerContext: React.Context<{
+    api: API;
+    state: State;
+}>;
+type State = SubState$8 & SubState$3 & SubState$6 & SubState$7 & SubState$1 & SubState$2 & SubState$4 & SubState$5 & SubState$9 & SubState & RouterData & API_OptionsData & Other;
+type API = SubAPI$c & SubAPI$b & SubAPI$7 & SubAPI$3 & SubAPI$6 & SubAPI$a & SubAPI$9 & SubAPI$8 & SubAPI$4 & SubAPI$5 & SubAPI$1 & SubAPI$2 & SubAPI & Other;
+interface Other {
+    [key: string]: any;
+}
+interface Combo {
+    api: API;
+    state: State;
+}
+type ManagerProviderProps = RouterData & API_ProviderData<API> & {
+    children: ReactNode | FC<Combo>;
+};
+declare const combineParameters: (...parameterSets: Parameters[]) => {};
+declare class ManagerProvider extends Component<ManagerProviderProps, State> {
+    api: API;
+    modules: ReturnType<ModuleFn>[];
+    static displayName: string;
+    constructor(props: ManagerProviderProps);
+    static getDerivedStateFromProps(props: ManagerProviderProps, state: State): State;
+    shouldComponentUpdate(nextProps: ManagerProviderProps, nextState: State): boolean;
+    initModules: () => void;
+    render(): React.JSX.Element;
+}
+interface ManagerConsumerProps<P = unknown> {
+    filter?: (combo: Combo) => P;
+    children: FC<P> | ReactNode;
+}
+declare function ManagerConsumer<P = Combo>({ filter, children, }: ManagerConsumerProps<P>): ReactElement;
+declare function useStorybookState(): State;
+declare function useStorybookApi(): API;
+
+interface API_EventMap {
+    [eventId: string]: Listener$1;
+}
+declare const useChannel: (eventMap: API_EventMap, deps?: any[]) => (type: string, ...args: any[]) => void;
+declare function useStoryPrepared(storyId?: StoryId): boolean;
+declare function useParameter<S>(parameterKey: string, defaultValue?: S): S;
+declare function useSharedState<S>(stateId: string, defaultState?: S): [S, (newStateOrMerger: S | API_StateMerger<S>, options?: Options) => void];
+declare function useAddonState<S>(addonId: string, defaultState?: S): [S, (newStateOrMerger: S | API_StateMerger<S>, options?: Options) => void];
+declare function useArgs(): [Args, (newArgs: Args) => void, (argNames?: string[]) => void, Args];
+declare function useGlobals(): [
+    globals: Globals,
+    updateGlobals: (newGlobals: Globals) => void,
+    storyGlobals: Globals,
+    userGlobals: Globals
+];
+declare function useGlobalTypes(): ArgTypes;
+declare function useArgTypes(): ArgTypes;
+
+declare const typesX: typeof Addon_TypesEnum;
+
 type EnvironmentType = (typeof UniversalStore.Environment)[keyof typeof UniversalStore.Environment];
 type StatusType = (typeof UniversalStore.Status)[keyof typeof UniversalStore.Status];
 type StateUpdater<TState> = (prevState: TState) => TState;
@@ -1080,7 +1120,7 @@ declare class UniversalStore<State, CustomEvent extends {
  * @param universalStore The UniversalStore instance to use.
  * @param selector An optional selector function to select a subset of the store state.
  * @remark This hook is intended for use in the manager UI. For use in the preview, import from
- * `storybook/internal/preview-api` instead.
+ * `storybook/preview-api` instead.
  */
 declare const useUniversalStore: {
     <TUniversalStore extends UniversalStore<TState, any>, TState = TUniversalStore extends UniversalStore<infer S, any> ? S : never>(universalStore: TUniversalStore): [TState, TUniversalStore['setState']];
@@ -1103,7 +1143,7 @@ declare const useUniversalStore: {
  * @example
  *
  * ```ts
- * import * as testUtils from '@storybook/test'; // in stories
+ * import * as testUtils from 'storybook/test'; // in stories
  * import { vi as testUtils } from 'vitest'; // ... or in Vitest tests
  *
  * const initialState = { ... };
@@ -1139,73 +1179,329 @@ declare class MockUniversalStore<State, CustomEvent extends {
     unsubscribeAll(): void;
 }
 
-declare const ActiveTabs: {
-    SIDEBAR: "sidebar";
-    CANVAS: "canvas";
-    ADDONS: "addons";
+type StatusValue = 'status-value:pending' | 'status-value:success' | 'status-value:error' | 'status-value:warning' | 'status-value:unknown';
+type StatusTypeId = string;
+type StatusByTypeId = Record<StatusTypeId, Status>;
+type StatusesByStoryIdAndTypeId = Record<StoryId$1, StatusByTypeId>;
+interface Status {
+    value: StatusValue;
+    typeId: StatusTypeId;
+    storyId: StoryId$1;
+    title: string;
+    description: string;
+    data?: any;
+    sidebarContextMenu?: boolean;
+}
+declare const StatusStoreEventType: {
+    readonly SELECT: "select";
+};
+type StatusStoreEvent = {
+    type: typeof StatusStoreEventType.SELECT;
+    payload: Status[];
+};
+type StatusStore = {
+    getAll: () => StatusesByStoryIdAndTypeId;
+    set: (statuses: Status[]) => void;
+    onAllStatusChange: (listener: (statuses: StatusesByStoryIdAndTypeId, previousStatuses: StatusesByStoryIdAndTypeId) => void) => () => void;
+    onSelect: (listener: (selectedStatuses: Status[]) => void) => () => void;
+    unset: (storyIds?: StoryId$1[]) => void;
+};
+type StatusStoreByTypeId = StatusStore & {
+    typeId: StatusTypeId;
 };
+type UseStatusStore = <T = StatusesByStoryIdAndTypeId>(selector?: (statuses: StatusesByStoryIdAndTypeId) => T) => T;
 
-declare const ManagerContext: React.Context<{
-    api: API;
-    state: State;
-}>;
-type State = SubState$8 & SubState$3 & SubState$6 & SubState$7 & SubState$a & SubState$1 & SubState$2 & SubState$4 & SubState$5 & SubState$9 & SubState & RouterData & API_OptionsData & DeprecatedState & Other;
-type API = SubAPI$d & SubAPI$c & SubAPI$7 & SubAPI$3 & SubAPI$6 & SubAPI$a & SubAPI$9 & SubAPI$8 & SubAPI$b & SubAPI$4 & SubAPI$5 & SubAPI$1 & SubAPI$2 & SubAPI & Other;
-interface DeprecatedState {
-    /** @deprecated Use index */
-    storiesHash: API_IndexHash;
-    /** @deprecated Use previewInitialized */
-    storiesConfigured: boolean;
-    /** @deprecated Use indexError */
-    storiesFailed?: Error;
-}
-interface Other {
-    [key: string]: any;
+declare global {
+	interface SymbolConstructor {
+		readonly observable: symbol;
+	}
 }
-interface Combo {
-    api: API;
-    state: State;
+
+declare global {
+    var globalProjectAnnotations: NormalizedProjectAnnotations<any>;
+    var defaultProjectAnnotations: ProjectAnnotations<any>;
 }
-type ManagerProviderProps = RouterData & API_ProviderData<API> & {
-    children: ReactNode | FC<Combo>;
+type WrappedStoryRef = {
+    __pw_type: 'jsx' | 'importRef';
 };
-declare const combineParameters: (...parameterSets: Parameters[]) => {};
-declare class ManagerProvider extends Component<ManagerProviderProps, State> {
-    api: API;
-    modules: ReturnType<ModuleFn>[];
-    static displayName: string;
-    constructor(props: ManagerProviderProps);
-    static getDerivedStateFromProps(props: ManagerProviderProps, state: State): State;
-    shouldComponentUpdate(nextProps: ManagerProviderProps, nextState: State): boolean;
-    initModules: () => void;
-    render(): React.JSX.Element;
-}
-interface ManagerConsumerProps<P = unknown> {
-    filter?: (combo: Combo) => P;
-    children: FC<P> | ReactNode;
+type UnwrappedJSXStoryRef = {
+    __pw_type: 'jsx';
+    type: UnwrappedImportStoryRef;
+};
+type UnwrappedImportStoryRef = ComposedStoryFn;
+declare global {
+    function __pwUnwrapObject(storyRef: WrappedStoryRef): Promise<UnwrappedJSXStoryRef | UnwrappedImportStoryRef>;
 }
-declare function ManagerConsumer<P = Combo>({ filter, children, }: ManagerConsumerProps<P>): ReactElement;
-declare function useStorybookState(): State;
-declare function useStorybookApi(): API;
 
-interface API_EventMap {
-    [eventId: string]: Listener$1;
-}
-declare const useChannel: (eventMap: API_EventMap, deps?: any[]) => (type: string, ...args: any[]) => void;
-declare function useStoryPrepared(storyId?: StoryId): boolean;
-declare function useParameter<S>(parameterKey: string, defaultValue?: S): S;
-declare function useSharedState<S>(stateId: string, defaultState?: S): [S, (newStateOrMerger: S | API_StateMerger<S>, options?: Options) => void];
-declare function useAddonState<S>(addonId: string, defaultState?: S): [S, (newStateOrMerger: S | API_StateMerger<S>, options?: Options) => void];
-declare function useArgs(): [Args, (newArgs: Args) => void, (argNames?: string[]) => void, Args];
-declare function useGlobals(): [
-    globals: Globals,
-    updateGlobals: (newGlobals: Globals) => void,
-    storyGlobals: Globals,
-    userGlobals: Globals
-];
-declare function useGlobalTypes(): ArgTypes;
-declare function useArgTypes(): ArgTypes;
+type TestProviderState = 'test-provider-state:pending' | 'test-provider-state:running' | 'test-provider-state:succeeded' | 'test-provider-state:crashed';
+type TestProviderId = string;
+type TestProviderStateByProviderId = Record<TestProviderId, TestProviderState>;
+type TestProviderStoreEventType = 'run-all' | 'clear-all' | 'settings-changed';
+type TestProviderStoreEvent = BaseEvent & {
+    type: TestProviderStoreEventType;
+};
+type BaseTestProviderStore = {
+    /**
+     * Notifies all listeners that settings have changed for test providers. The Storybook UI will
+     * highlight the test providers to tell the user that settings has changed.
+     */
+    settingsChanged: () => void;
+    /**
+     * Subscribe to clicks on the "Run All" button, that is supposed to trigger all test providers to
+     * run. Your test provider should do the "main thing" when this happens, similar to when the user
+     * triggers your test provider specifically.
+     *
+     * @example
+     *
+     * ```typescript
+     * // Subscribe to run-all events
+     * const unsubscribe = myTestProviderStore.onRunAll(() => {
+     *   await runAllMyTests();
+     * });
+     * ```
+     */
+    onRunAll: (listener: () => void) => () => void;
+    /**
+     * Subscribe to clicks on the "Clear All" button, that is supposed to clear all state from test
+     * providers. Storybook already clears all statuses, but if your test provider has more
+     * non-status-based state, you can use this to clear that here.
+     *
+     * @remarks
+     * The purpose of this is _not_ to clear your test provider's settings, only the test results.
+     * @example
+     *
+     * ```typescript
+     * // Subscribe to clear-all events
+     * const unsubscribe = myTestProviderStore.onClearAll(() => {
+     *   clearMyTestResults();
+     * });
+     *
+     * // Later, when no longer needed
+     * unsubscribe();
+     * ```
+     */
+    onClearAll: (listener: () => void) => () => void;
+};
+/**
+ * Represents a store for a specific test provider, identified by its unique ID. This store provides
+ * methods to manage the state of an individual test provider, including getting and setting its
+ * state, running operations with automatic state management, and accessing its unique identifier.
+ *
+ * Each test provider has its own instance of this store, allowing for independent state management
+ * across different test providers in the application.
+ *
+ * @example
+ *
+ * ```typescript
+ * // Get a store for a specific test provider
+ * const grammarStore = getTestProviderStoreById('addon-grammar');
+ *
+ * // Check the current state
+ * if (grammarStore.getState() === 'test-provider-state:pending') {
+ *   console.log('Grammar tests are ready to run');
+ * }
+ *
+ * // Run tests with automatic state management
+ * grammarStore.runWithState(async () => {
+ *   await runGrammarTests();
+ * });
+ * ```
+ *
+ * @see {@link TestProviderState} for possible state values
+ * @see {@link BaseTestProviderStore} for methods inherited from the base store
+ */
+type TestProviderStoreById = BaseTestProviderStore & {
+    /**
+     * Gets the current state of this specific test provider
+     *
+     * The state represents the current execution status of the test provider, which can be one of the
+     * following:
+     *
+     * - 'test-provider-state:pending': Tests have not been run yet
+     * - 'test-provider-state:running': Tests are currently running
+     * - 'test-provider-state:succeeded': Tests completed successfully
+     * - 'test-provider-state:crashed': Running tests failed or encountered an error
+     *
+     * Storybook UI will use this state to determine what to show in the UI.
+     *
+     * @remarks
+     * The 'test-provider-state:crashed' is meant to signify that the test run as a whole failed to
+     * execute for some reason. It should _not_ be set just because a number of tests failed, use
+     * statuses and the status store for that. See {@link TestStatusStore} for managing individual test
+     * statuses.
+     * @example
+     *
+     * ```typescript
+     * // Get the current state of a specific test provider
+     * const state = testProviderStore.getState();
+     *
+     * // Conditionally render UI based on the state
+     * const TestStatus = () => {
+     *   const state = testProviderStore.getState();
+     *
+     *   if (state === 'test-provider-state:running') {
+     *     return <Spinner />;
+     *   } else if (state === 'test-provider-state:succeeded') {
+     *     return <SuccessIcon />;
+     *   } else if (state === 'test-provider-state:crashed') {
+     *     return <ErrorIcon />;
+     *   }
+     *
+     *   return <PendingIcon />;
+     * };
+     * ```
+     */
+    getState: () => TestProviderState;
+    /**
+     * Sets the state of this specific test provider
+     *
+     * This method allows you to manually update the execution state of the test provider. It's
+     * typically used when you need to reflect the current status of test execution in the UI or when
+     * you want to programmatically control the test provider's state.
+     *
+     * Common use cases include:
+     *
+     * - Setting to 'running' when tests start
+     * - Setting to 'succeeded' when tests complete successfully
+     * - Setting to 'crashed' when tests fail or encounter errors
+     * - Setting to 'pending' to reset the state
+     *
+     * The state represents the current execution status of the test provider, which can be one of the
+     * following:
+     *
+     * - 'test-provider-state:pending': Tests have not been run yet
+     * - 'test-provider-state:running': Tests are currently running
+     * - 'test-provider-state:succeeded': Tests completed successfully
+     * - 'test-provider-state:crashed': Running tests failed or encountered an error
+     *
+     * Storybook UI will use this state to determine what to show in the UI.
+     *
+     * @remarks
+     * The 'test-provider-state:crashed' is meant to signify that the test run as a whole failed to
+     * execute for some reason. It should _not_ be set just because a number of tests failed, use
+     * statuses and the status store for that. See {@link TestStatusStore} for managing individual test
+     * statuses.
+     *
+     * For most use cases, consider using {@link runWithState} instead, which provides automatic state
+     * management and error handling during test execution.
+     * @example
+     *
+     * ```typescript
+     * // Update the state when tests start running
+     * const startTests = async () => {
+     *   testProviderStore.setState('test-provider-state:running');
+     *   ... run tests ...
+     * };
+     * ```
+     */
+    setState: (state: TestProviderState) => void;
+    /**
+     * Runs a callback and automatically updates the test provider's state with running, succeeded or
+     * crashed, depending on the end result.
+     *
+     * - Immediately changes the state to 'running'
+     * - If the callback returns/resolves, change the state to 'succeeded'.
+     * - If the callback throws an error/rejects, change the state to 'crashed'.
+     *
+     * This approach helps prevent state inconsistencies that might occur if exceptions are thrown
+     * during test execution.
+     *
+     * @example
+     *
+     * ```typescript
+     * // Run tests with automatic state management
+     * const runTests = () => {
+     *   testProviderStore.runWithState(async () => {
+     *     // The state is automatically set to 'running' before this callback
+     *
+     *     // Run tests here...
+     *     const results = await executeTests();
+     *   });
+     * };
+     * ```
+     */
+    runWithState: (callback: () => void | Promise<void>) => Promise<void>;
+    /** The unique identifier for this test provider */
+    testProviderId: TestProviderId;
+};
+/**
+ * React OR preview hook for accessing the state of _all_ test providers. This hook will only
+ * trigger a re-render when the state changes. It is recommended to pass the optional selector, to
+ * get more fine-grained control of re-renders.
+ *
+ * @example
+ *
+ * ```typescript
+ * const TestStatus = () => {
+ *   const state = useTestProviderStore((state) => state['my-test-provider']);
+ * };
+ * ```
+ */
+type UseTestProviderStore = <T = TestProviderStateByProviderId>(
+/**
+ * Optional selector function to extract or transform specific parts of the state
+ *
+ * @example
+ *
+ * ```typescript
+ * // Use the entire state
+ * const allProviderStates = useTestProviderStore();
+ *
+ * // Get state for a specific provider
+ * const myProviderState = useTestProviderStore((state) => state['my-test-provider']);
+ *
+ * // Get a count of providers in each state
+ * const statusCounts = useTestProviderStore((state) => {
+ *   const counts = {
+ *     pending: 0,
+ *     running: 0,
+ *     succeeded: 0,
+ *     crashed: 0,
+ *   };
+ *
+ *   Object.values(state).forEach((status) => {
+ *     if (status === 'test-provider-state:pending') counts.pending++;
+ *     else if (status === 'test-provider-state:running') counts.running++;
+ *     else if (status === 'test-provider-state:succeeded') counts.succeeded++;
+ *     else if (status === 'test-provider-state:crashed') counts.crashed++;
+ *   });
+ *
+ *   return counts;
+ * });
+ *
+ * // Check if all tests have completed
+ * const allTestsCompleted = useTestProviderStore((state) => {
+ *   return Object.values(state).every(
+ *     (status) =>
+ *       status === 'test-provider-state:succeeded' ||
+ *       status === 'test-provider-state:crashed'
+ *   );
+ * });
+ * ```
+ */
+selector?: (state: TestProviderStateByProviderId) => T) => T;
 
-declare const typesX: typeof Addon_TypesEnum;
+declare const fullStatusStore: StatusStore & {
+    selectStatuses: (statuses: Status[]) => void;
+    typeId: undefined;
+};
+declare const getStatusStoreByTypeId: (typeId: StatusTypeId) => StatusStoreByTypeId;
+declare const useStatusStore: UseStatusStore;
+declare const universalStatusStore: UniversalStore<StatusesByStoryIdAndTypeId, StatusStoreEvent>;
+
+declare const fullTestProviderStore: {
+    settingsChanged: () => void;
+    onRunAll: (listener: () => void) => () => void;
+    onClearAll: (listener: () => void) => () => void;
+} & {
+    getFullState: UniversalStore<TestProviderStateByProviderId, TestProviderStoreEvent>["getState"];
+    setFullState: UniversalStore<TestProviderStateByProviderId, TestProviderStoreEvent>["setState"];
+    onSettingsChanged: (listener: (testProviderId: TestProviderId) => void) => () => void;
+    runAll: () => void;
+    clearAll: () => void;
+};
+declare const getTestProviderStoreById: (testProviderId: TestProviderId) => TestProviderStoreById;
+declare const useTestProviderStore: UseTestProviderStore;
+declare const universalTestProviderStore: UniversalStore<TestProviderStateByProviderId, TestProviderStoreEvent>;
 
-export { type API, type API_EventMap, ActiveTabs, AddonStore, type Combo, ManagerConsumer as Consumer, type KeyboardEventLike, ManagerContext, type ManagerProviderProps, ManagerProvider as Provider, RequestResponseError, type State, type Options as StoreOptions, addons, combineParameters, controlOrMetaKey, controlOrMetaSymbol, eventMatchesShortcut, eventToShortcut, MockUniversalStore as experimental_MockUniversalStore, UniversalStore as experimental_UniversalStore, experimental_requestResponse, useUniversalStore as experimental_useUniversalStore, isMacLike, isShortcutTaken, keyToSymbol, _default as merge, mockChannel, optionOrAltSymbol, shortcutMatchesShortcut, shortcutToHumanString, typesX as types, useAddonState, useArgTypes, useArgs, useChannel, useGlobalTypes, useGlobals, useParameter, useSharedState, useStoryPrepared, useStorybookApi, useStorybookState };
+export { type API, type API_EventMap, ActiveTabs, AddonStore, type Combo, ManagerConsumer as Consumer, type KeyboardEventLike, ManagerContext, type ManagerProviderProps, ManagerProvider as Provider, RequestResponseError, type State, type Options as StoreOptions, addons, combineParameters, controlOrMetaKey, controlOrMetaSymbol, eventMatchesShortcut, eventToShortcut, MockUniversalStore as experimental_MockUniversalStore, UniversalStore as experimental_UniversalStore, getStatusStoreByTypeId as experimental_getStatusStore, getTestProviderStoreById as experimental_getTestProviderStore, experimental_requestResponse, useStatusStore as experimental_useStatusStore, useTestProviderStore as experimental_useTestProviderStore, useUniversalStore as experimental_useUniversalStore, fullStatusStore as internal_fullStatusStore, fullTestProviderStore as internal_fullTestProviderStore, universalStatusStore as internal_universalStatusStore, universalTestProviderStore as internal_universalTestProviderStore, isMacLike, isShortcutTaken, keyToSymbol, _default as merge, mockChannel, optionOrAltSymbol, shortcutMatchesShortcut, shortcutToHumanString, typesX as types, useAddonState, useArgTypes, useArgs, useChannel, useGlobalTypes, useGlobals, useParameter, useSharedState, useStoryPrepared, useStorybookApi, useStorybookState };