• Version 6.3.12
  • Published
  • 97.5 kB
  • 9 dependencies
  • MIT license


npm i @storybook/addons
yarn add @storybook/addons
pnpm add @storybook/addons


Storybook addons store







Type Aliases


variable addons

const addons: AddonStore;


    function applyHooks

    applyHooks: (
    applyDecorators: (getStory: StoryGetter, decorators: Decorator[]) => StoryGetter
    ) => (
    getStory: StoryGetter,
    decorators: Decorator[]
    ) => (context: StoryContext) => any;

      function isSupportedType

      isSupportedType: (type: Types) => boolean;

        function makeDecorator

        makeDecorator: ({
        }: MakeDecoratorOptions) => MakeDecoratorResult;

          function mockChannel

          mockChannel: () => any;

            function useArgs

            useArgs: () => [Args, (newArgs: Args) => void, (argNames?: [string]) => void];

              function useCallback

              useCallback: <T>(callback: T, deps?: any[]) => T;

                function useChannel

                useChannel: (eventMap: EventMap, deps?: any[]) => any;

                  function useEffect

                  useEffect: (create: () => (() => void) | void, deps?: any[]) => void;

                    function useGlobals

                    useGlobals: () => [Args, (newGlobals: Args) => void];

                      function useMemo

                      useMemo: <T>(nextCreate: () => T, deps?: any[]) => T;

                        function useParameter

                        useParameter: <S>(parameterKey: string, defaultValue?: S) => S | undefined;

                          function useReducer

                          useReducer: {
                          <S, A>(reducer: (state: S, action: A) => S, initialState: S): [
                          (action: A) => void
                          <S, I, A>(
                          reducer: (state: S, action: A) => S,
                          initialArg: I,
                          init: (initialArg: I) => S
                          ): [S, (action: A) => void];

                            function useRef

                            useRef: <T>(initialValue: T) => { current: T };

                              function useState

                              useState: <S>(
                              initialState: (() => S) | S
                              ) => [S, (update: S | ((prevState: S) => S)) => void];

                                function useStoryContext

                                useStoryContext: () => StoryContext;


                                  class AddonStore

                                  class AddonStore {}



                                      property add

                                      add: (name: string, addon: Addon) => void;

                                        property addPanel

                                        addPanel: (name: string, options: Addon) => void;

                                          property getChannel

                                          getChannel: () => any;

                                            property getConfig

                                            getConfig: () => Config;

                                              property getElements

                                              getElements: (type: Types) => Collection;

                                                property hasChannel

                                                hasChannel: () => boolean;

                                                  property loadAddons

                                                  loadAddons: (api: any) => void;

                                                    property ready

                                                    ready: () => Promise<Channel>;

                                                      property register

                                                      register: (name: string, registerCallback: (api: any) => void) => void;

                                                        property setChannel

                                                        setChannel: (channel: any) => void;

                                                          property setConfig

                                                          setConfig: (value: Config) => void;

                                                            class HooksContext

                                                            class HooksContext {}



                                                                property currentContext

                                                                currentContext: StoryContext;

                                                                  property currentDecoratorName

                                                                  currentDecoratorName: string;

                                                                    property currentEffects

                                                                    currentEffects: Effect[];

                                                                      property currentHooks

                                                                      currentHooks: Hook[];

                                                                        property currentPhase

                                                                        currentPhase: 'MOUNT' | 'UPDATE' | 'NONE';

                                                                          property hasUpdates

                                                                          hasUpdates: boolean;

                                                                            property hookListsMap

                                                                            hookListsMap: WeakMap<AbstractFunction, Hook[]>;

                                                                              property mountedDecorators

                                                                              mountedDecorators: Set<AbstractFunction>;

                                                                                property nextHookIndex

                                                                                nextHookIndex: number;

                                                                                  property prevEffects

                                                                                  prevEffects: Effect[];

                                                                                    property prevMountedDecorators

                                                                                    prevMountedDecorators: Set<AbstractFunction>;

                                                                                      property renderListener

                                                                                      renderListener: () => void;

                                                                                        method addRenderListeners

                                                                                        addRenderListeners: () => void;

                                                                                          method clean

                                                                                          clean: () => void;

                                                                                            method getNextHook

                                                                                            getNextHook: () => Hook;

                                                                                              method init

                                                                                              init: () => void;

                                                                                                method removeRenderListeners

                                                                                                removeRenderListeners: () => void;

                                                                                                  method triggerEffects

                                                                                                  triggerEffects: () => void;


                                                                                                    interface Addon

                                                                                                    interface Addon {}

                                                                                                      property disabled

                                                                                                      disabled?: boolean;

                                                                                                        property hidden

                                                                                                        hidden?: boolean;

                                                                                                          property id

                                                                                                          id?: string;

                                                                                                            property match

                                                                                                            match?: (matchOptions: RouterData) => boolean;

                                                                                                              property paramKey

                                                                                                              paramKey?: string;

                                                                                                                property render

                                                                                                                render: (renderOptions: RenderOptions) => ReactElement<any>;

                                                                                                                  property route

                                                                                                                  route?: (routeOptions: RouterData) => string;

                                                                                                                    property title

                                                                                                                    title: (() => string) | string;

                                                                                                                      property type

                                                                                                                      type?: Types;

                                                                                                                        interface AddStoryArgs

                                                                                                                        interface AddStoryArgs<StoryFnReturnType = unknown> {}

                                                                                                                          property id

                                                                                                                          id: StoryId;

                                                                                                                            property kind

                                                                                                                            kind: StoryKind;

                                                                                                                              property name

                                                                                                                              name: StoryName;

                                                                                                                                property parameters

                                                                                                                                parameters: Parameters;

                                                                                                                                  property storyFn

                                                                                                                                  storyFn: StoryFn<StoryFnReturnType>;

                                                                                                                                    interface Annotations

                                                                                                                                    interface Annotations<Args, StoryFnReturnType>
                                                                                                                                    extends BaseAnnotations<Args, StoryFnReturnType> {}

                                                                                                                                      property excludeStories

                                                                                                                                      excludeStories?: string[] | RegExp;
                                                                                                                                      • Used to exclude certain named exports. Useful when you want to have non-story exports such as mock data or ignore a few stories.

                                                                                                                                        Example 1

                                                                                                                                        excludeStories: ['simpleData', 'complexData'] excludeStories: /.*Data$/

                                                                                                                                        See Also

                                                                                                                                        • [Non-story exports](https://storybook.js.org/docs/formats/component-story-format/#non-story-exports)

                                                                                                                                      property includeStories

                                                                                                                                      includeStories?: string[] | RegExp;
                                                                                                                                      • Used to only include certain named exports as stories. Useful when you want to have non-story exports such as mock data or ignore a few stories.

                                                                                                                                        Example 1

                                                                                                                                        includeStories: ['SimpleStory', 'ComplexStory'] includeStories: /.*Story$/

                                                                                                                                        See Also

                                                                                                                                        • [Non-story exports](https://storybook.js.org/docs/formats/component-story-format/#non-story-exports)

                                                                                                                                      interface Args

                                                                                                                                      interface Args {}

                                                                                                                                        index signature

                                                                                                                                        [key: string]: any;

                                                                                                                                          interface ArgType

                                                                                                                                          interface ArgType {}

                                                                                                                                            property defaultValue

                                                                                                                                            defaultValue?: any;

                                                                                                                                              property description

                                                                                                                                              description?: string;

                                                                                                                                                property name

                                                                                                                                                name?: string;

                                                                                                                                                  index signature

                                                                                                                                                  [key: string]: any;

                                                                                                                                                    interface ArgTypes

                                                                                                                                                    interface ArgTypes {}

                                                                                                                                                      index signature

                                                                                                                                                      [key: string]: ArgType;

                                                                                                                                                        interface BaseAnnotations

                                                                                                                                                        interface BaseAnnotations<Args, StoryFnReturnType> {}

                                                                                                                                                          property args

                                                                                                                                                          args?: Partial<Args>;
                                                                                                                                                          • Dynamic data that are provided (and possibly updated by) Storybook and its addons.

                                                                                                                                                            See Also

                                                                                                                                                            • [Arg story inputs](https://storybook.js.org/docs/react/api/csf#args-story-inputs)

                                                                                                                                                          property argTypes

                                                                                                                                                          argTypes?: ArgTypes;
                                                                                                                                                          • ArgTypes encode basic metadata for args, such as name, description, defaultValue for an arg. These get automatically filled in by Storybook Docs.

                                                                                                                                                            See Also

                                                                                                                                                            • [Control annotations](https://github.com/storybookjs/storybook/blob/91e9dee33faa8eff0b342a366845de7100415367/addons/controls/README.md#control-annotations)

                                                                                                                                                          property decorators

                                                                                                                                                          decorators?: BaseDecorators<StoryFnReturnType>;
                                                                                                                                                          • Wrapper components or Storybook decorators that wrap a story.

                                                                                                                                                            Decorators defined in Meta will be applied to every story variation.

                                                                                                                                                            See Also

                                                                                                                                                            • [Decorators](https://storybook.js.org/docs/addons/introduction/#1-decorators)

                                                                                                                                                          property parameters

                                                                                                                                                          parameters?: Parameters;
                                                                                                                                                          • Custom metadata for a story.

                                                                                                                                                            See Also

                                                                                                                                                            • [Parameters](https://storybook.js.org/docs/basics/writing-stories/#parameters)

                                                                                                                                                          interface BaseMeta

                                                                                                                                                          interface BaseMeta<ComponentType> {}

                                                                                                                                                            property component

                                                                                                                                                            component?: ComponentType;
                                                                                                                                                            • The primary component for your story.

                                                                                                                                                              Used by addons for automatic prop table generation and display of other component metadata.

                                                                                                                                                            property subcomponents

                                                                                                                                                            subcomponents?: Record<string, ComponentType>;
                                                                                                                                                            • Auxiliary subcomponents that are part of the stories.

                                                                                                                                                              Used by addons for automatic prop table generation and display of other component metadata.

                                                                                                                                                              Example 1

                                                                                                                                                              import { Button, ButtonGroup } from './components';

                                                                                                                                                              export default { ... subcomponents: { Button, ButtonGroup } }

                                                                                                                                                              By defining them each component will have its tab in the args table.

                                                                                                                                                            property title

                                                                                                                                                            title: string;
                                                                                                                                                            • Title of the story which will be presented in the navigation. **Should be unique.**

                                                                                                                                                              Stories can be organized in a nested structure using "/" as a separator.

                                                                                                                                                              Example 1

                                                                                                                                                              export default { ... title: 'Design System/Atoms/Button' }

                                                                                                                                                              See Also

                                                                                                                                                              • [Story Hierarchy](https://storybook.js.org/docs/basics/writing-stories/#story-hierarchy)

                                                                                                                                                            interface BaseStory

                                                                                                                                                            interface BaseStory<Args, StoryFnReturnType> {}

                                                                                                                                                              property storyName

                                                                                                                                                              storyName?: string;
                                                                                                                                                              • Override the display name in the UI

                                                                                                                                                              call signature

                                                                                                                                                              (args: Args, context: StoryContext): StoryFnReturnType;

                                                                                                                                                                interface ClientApiAddon

                                                                                                                                                                interface ClientApiAddon<StoryFnReturnType = unknown> extends Addon {}

                                                                                                                                                                  property apply

                                                                                                                                                                  apply: (a: StoryApi<StoryFnReturnType>, b: any[]) => any;

                                                                                                                                                                    interface ClientApiAddons

                                                                                                                                                                    interface ClientApiAddons<StoryFnReturnType> {}

                                                                                                                                                                      index signature

                                                                                                                                                                      [key: string]: ClientApiAddon<StoryFnReturnType>;

                                                                                                                                                                        interface ClientStoryApi

                                                                                                                                                                        interface ClientStoryApi<StoryFnReturnType = unknown> {}

                                                                                                                                                                          method addDecorator

                                                                                                                                                                          addDecorator: (
                                                                                                                                                                          decorator: DecoratorFunction<StoryFnReturnType>
                                                                                                                                                                          ) => StoryApi<StoryFnReturnType>;

                                                                                                                                                                            method addParameters

                                                                                                                                                                            addParameters: (parameter: Parameters) => StoryApi<StoryFnReturnType>;

                                                                                                                                                                              method storiesOf

                                                                                                                                                                              storiesOf: (kind: StoryKind, module: any) => StoryApi<StoryFnReturnType>;

                                                                                                                                                                                interface Collection

                                                                                                                                                                                interface Collection {}

                                                                                                                                                                                  index signature

                                                                                                                                                                                  [key: string]: Addon;

                                                                                                                                                                                    interface Config

                                                                                                                                                                                    interface Config {}

                                                                                                                                                                                      property theme

                                                                                                                                                                                      theme?: ThemeVars;

                                                                                                                                                                                        property toolbar

                                                                                                                                                                                        toolbar?: {
                                                                                                                                                                                        [id: string]: ToolbarConfig;

                                                                                                                                                                                          index signature

                                                                                                                                                                                          [key: string]: any;

                                                                                                                                                                                            interface EventMap

                                                                                                                                                                                            interface EventMap {}

                                                                                                                                                                                              index signature

                                                                                                                                                                                              [eventId: string]: Listener;

                                                                                                                                                                                                interface Listener

                                                                                                                                                                                                interface Listener {}

                                                                                                                                                                                                  call signature

                                                                                                                                                                                                  (...args: any[]): void;

                                                                                                                                                                                                    interface OptionsParameter

                                                                                                                                                                                                    interface OptionsParameter extends Object {}

                                                                                                                                                                                                      property storySort

                                                                                                                                                                                                      storySort?: StorySortParameter;

                                                                                                                                                                                                        property theme

                                                                                                                                                                                                        theme?: {
                                                                                                                                                                                                        base: string;
                                                                                                                                                                                                        brandTitle?: string;

                                                                                                                                                                                                          index signature

                                                                                                                                                                                                          [key: string]: any;

                                                                                                                                                                                                            interface Parameters

                                                                                                                                                                                                            interface Parameters {}

                                                                                                                                                                                                              property docsOnly

                                                                                                                                                                                                              docsOnly?: boolean;

                                                                                                                                                                                                                property fileName

                                                                                                                                                                                                                fileName?: string;

                                                                                                                                                                                                                  property layout

                                                                                                                                                                                                                  layout?: 'centered' | 'fullscreen' | 'padded' | 'none';
                                                                                                                                                                                                                  • The layout property defines basic styles added to the preview body where the story is rendered. If you pass 'none', no styles are applied.

                                                                                                                                                                                                                  property options

                                                                                                                                                                                                                  options?: OptionsParameter;

                                                                                                                                                                                                                    index signature

                                                                                                                                                                                                                    [key: string]: any;

                                                                                                                                                                                                                      interface RenderOptions

                                                                                                                                                                                                                      interface RenderOptions {}

                                                                                                                                                                                                                        property active

                                                                                                                                                                                                                        active?: boolean;

                                                                                                                                                                                                                          property key

                                                                                                                                                                                                                          key?: string;

                                                                                                                                                                                                                            interface StoryApi

                                                                                                                                                                                                                            interface StoryApi<StoryFnReturnType = unknown> {}

                                                                                                                                                                                                                              property add

                                                                                                                                                                                                                              add: (
                                                                                                                                                                                                                              storyName: StoryName,
                                                                                                                                                                                                                              storyFn: StoryFn<StoryFnReturnType>,
                                                                                                                                                                                                                              parameters?: Parameters
                                                                                                                                                                                                                              ) => StoryApi<StoryFnReturnType>;

                                                                                                                                                                                                                                property addDecorator

                                                                                                                                                                                                                                addDecorator: (
                                                                                                                                                                                                                                decorator: DecoratorFunction<StoryFnReturnType>
                                                                                                                                                                                                                                ) => StoryApi<StoryFnReturnType>;

                                                                                                                                                                                                                                  property addLoader

                                                                                                                                                                                                                                  addLoader: (decorator: LoaderFunction) => StoryApi<StoryFnReturnType>;

                                                                                                                                                                                                                                    property addParameters

                                                                                                                                                                                                                                    addParameters: (parameters: Parameters) => StoryApi<StoryFnReturnType>;

                                                                                                                                                                                                                                      property kind

                                                                                                                                                                                                                                      kind: StoryKind;

                                                                                                                                                                                                                                        index signature

                                                                                                                                                                                                                                        [k: string]: string | ClientApiReturnFn<StoryFnReturnType>;

                                                                                                                                                                                                                                          interface StoryIdentifier

                                                                                                                                                                                                                                          interface StoryIdentifier {}

                                                                                                                                                                                                                                            property id

                                                                                                                                                                                                                                            id: StoryId;

                                                                                                                                                                                                                                              property kind

                                                                                                                                                                                                                                              kind: StoryKind;

                                                                                                                                                                                                                                                property name

                                                                                                                                                                                                                                                name: StoryName;

                                                                                                                                                                                                                                                  interface StorySortObjectParameter

                                                                                                                                                                                                                                                  interface StorySortObjectParameter {}

                                                                                                                                                                                                                                                    property includeNames

                                                                                                                                                                                                                                                    includeNames?: boolean;

                                                                                                                                                                                                                                                      property locales

                                                                                                                                                                                                                                                      locales?: string;

                                                                                                                                                                                                                                                        property method

                                                                                                                                                                                                                                                        method?: StorySortMethod;

                                                                                                                                                                                                                                                          property order

                                                                                                                                                                                                                                                          order?: any[];

                                                                                                                                                                                                                                                            interface WrapperSettings

                                                                                                                                                                                                                                                            interface WrapperSettings {}

                                                                                                                                                                                                                                                              property options

                                                                                                                                                                                                                                                              options: OptionsParameter;

                                                                                                                                                                                                                                                                property parameters

                                                                                                                                                                                                                                                                parameters: {
                                                                                                                                                                                                                                                                [key: string]: any;


                                                                                                                                                                                                                                                                  enum types

                                                                                                                                                                                                                                                                  enum types {
                                                                                                                                                                                                                                                                  TAB = 'tab',
                                                                                                                                                                                                                                                                  PANEL = 'panel',
                                                                                                                                                                                                                                                                  TOOL = 'tool',
                                                                                                                                                                                                                                                                  TOOLEXTRA = 'toolextra',
                                                                                                                                                                                                                                                                  PREVIEW = 'preview',
                                                                                                                                                                                                                                                                  NOTES_ELEMENT = 'notes-element',

                                                                                                                                                                                                                                                                    member NOTES_ELEMENT

                                                                                                                                                                                                                                                                    NOTES_ELEMENT = 'notes-element'

                                                                                                                                                                                                                                                                      member PANEL

                                                                                                                                                                                                                                                                      PANEL = 'panel'

                                                                                                                                                                                                                                                                        member PREVIEW

                                                                                                                                                                                                                                                                        PREVIEW = 'preview'

                                                                                                                                                                                                                                                                          member TAB

                                                                                                                                                                                                                                                                          TAB = 'tab'

                                                                                                                                                                                                                                                                            member TOOL

                                                                                                                                                                                                                                                                            TOOL = 'tool'

                                                                                                                                                                                                                                                                              member TOOLEXTRA

                                                                                                                                                                                                                                                                              TOOLEXTRA = 'toolextra'

                                                                                                                                                                                                                                                                                Type Aliases

                                                                                                                                                                                                                                                                                type ArgsStoryFn

                                                                                                                                                                                                                                                                                type ArgsStoryFn<ReturnType = unknown> = (a?: Args, p?: StoryContext) => ReturnType;

                                                                                                                                                                                                                                                                                  type BaseDecorators

                                                                                                                                                                                                                                                                                  type BaseDecorators<StoryFnReturnType> = Array<
                                                                                                                                                                                                                                                                                  (story: () => StoryFnReturnType, context: StoryContext) => StoryFnReturnType

                                                                                                                                                                                                                                                                                    type ClientApiReturnFn

                                                                                                                                                                                                                                                                                    type ClientApiReturnFn<StoryFnReturnType> = (
                                                                                                                                                                                                                                                                                    ...args: any[]
                                                                                                                                                                                                                                                                                    ) => StoryApi<StoryFnReturnType>;

                                                                                                                                                                                                                                                                                      type Comparator

                                                                                                                                                                                                                                                                                      type Comparator<T> = ((a: T, b: T) => boolean) | ((a: T, b: T) => number);

                                                                                                                                                                                                                                                                                        type DecorateStoryFunction

                                                                                                                                                                                                                                                                                        type DecorateStoryFunction<StoryFnReturnType = unknown> = (
                                                                                                                                                                                                                                                                                        storyFn: LegacyStoryFn<StoryFnReturnType>,
                                                                                                                                                                                                                                                                                        decorators: DecoratorFunction<StoryFnReturnType>[]
                                                                                                                                                                                                                                                                                        ) => LegacyStoryFn<StoryFnReturnType>;

                                                                                                                                                                                                                                                                                          type DecoratorFunction

                                                                                                                                                                                                                                                                                          type DecoratorFunction<StoryFnReturnType = unknown> = (
                                                                                                                                                                                                                                                                                          fn: PartialStoryFn<StoryFnReturnType>,
                                                                                                                                                                                                                                                                                          c: StoryContext
                                                                                                                                                                                                                                                                                          ) => ReturnType<LegacyStoryFn<StoryFnReturnType>>;

                                                                                                                                                                                                                                                                                            type LegacyStoryFn

                                                                                                                                                                                                                                                                                            type LegacyStoryFn<ReturnType = unknown> = (p?: StoryContext) => ReturnType;

                                                                                                                                                                                                                                                                                              type Loadable

                                                                                                                                                                                                                                                                                              type Loadable = RequireContext | [RequireContext] | LoadFn;

                                                                                                                                                                                                                                                                                                type Loader

                                                                                                                                                                                                                                                                                                type Loader = (api: API) => void;

                                                                                                                                                                                                                                                                                                  type LoaderFunction

                                                                                                                                                                                                                                                                                                  type LoaderFunction = (c: StoryContext) => Promise<Record<string, any>>;

                                                                                                                                                                                                                                                                                                    type MakeDecoratorResult

                                                                                                                                                                                                                                                                                                    type MakeDecoratorResult = (...args: any) => any;

                                                                                                                                                                                                                                                                                                      type PartialStoryFn

                                                                                                                                                                                                                                                                                                      type PartialStoryFn<ReturnType = unknown> = (p?: StoryContextUpdate) => ReturnType;

                                                                                                                                                                                                                                                                                                        type StoryContext

                                                                                                                                                                                                                                                                                                        type StoryContext = StoryIdentifier & {
                                                                                                                                                                                                                                                                                                        [key: string]: any;
                                                                                                                                                                                                                                                                                                        parameters: Parameters;
                                                                                                                                                                                                                                                                                                        args: Args;
                                                                                                                                                                                                                                                                                                        argTypes: ArgTypes;
                                                                                                                                                                                                                                                                                                        globals: Args;
                                                                                                                                                                                                                                                                                                        hooks?: HooksContext;
                                                                                                                                                                                                                                                                                                        viewMode?: ViewMode;
                                                                                                                                                                                                                                                                                                        originalStoryFn?: ArgsStoryFn;

                                                                                                                                                                                                                                                                                                          type StoryContextUpdate

                                                                                                                                                                                                                                                                                                          type StoryContextUpdate = Partial<StoryContext>;

                                                                                                                                                                                                                                                                                                            type StoryFn

                                                                                                                                                                                                                                                                                                            type StoryFn<ReturnType = unknown> =
                                                                                                                                                                                                                                                                                                            | LegacyStoryFn<ReturnType>
                                                                                                                                                                                                                                                                                                            | ArgsStoryFn<ReturnType>;

                                                                                                                                                                                                                                                                                                              type StoryGetter

                                                                                                                                                                                                                                                                                                              type StoryGetter = (context: StoryContext) => any;

                                                                                                                                                                                                                                                                                                                type StoryId

                                                                                                                                                                                                                                                                                                                type StoryId = string;

                                                                                                                                                                                                                                                                                                                  type StoryKind

                                                                                                                                                                                                                                                                                                                  type StoryKind = string;

                                                                                                                                                                                                                                                                                                                    type StoryName

                                                                                                                                                                                                                                                                                                                    type StoryName = string;

                                                                                                                                                                                                                                                                                                                      type StorySortComparator

                                                                                                                                                                                                                                                                                                                      type StorySortComparator = Comparator<[StoryId, any, Parameters, Parameters]>;

                                                                                                                                                                                                                                                                                                                        type StorySortMethod

                                                                                                                                                                                                                                                                                                                        type StorySortMethod = 'configure' | 'alphabetical';

                                                                                                                                                                                                                                                                                                                          type StorySortParameter

                                                                                                                                                                                                                                                                                                                          type StorySortParameter = StorySortComparator | StorySortObjectParameter;

                                                                                                                                                                                                                                                                                                                            type StoryWrapper

                                                                                                                                                                                                                                                                                                                            type StoryWrapper = (
                                                                                                                                                                                                                                                                                                                            getStory: StoryGetter,
                                                                                                                                                                                                                                                                                                                            context: StoryContext,
                                                                                                                                                                                                                                                                                                                            settings: WrapperSettings
                                                                                                                                                                                                                                                                                                                            ) => any;

                                                                                                                                                                                                                                                                                                                              type Types

                                                                                                                                                                                                                                                                                                                              type Types = types | string;

                                                                                                                                                                                                                                                                                                                                type ViewMode

                                                                                                                                                                                                                                                                                                                                type ViewMode = 'story' | 'docs';

                                                                                                                                                                                                                                                                                                                                  Package Files (6)

                                                                                                                                                                                                                                                                                                                                  Dependencies (9)

                                                                                                                                                                                                                                                                                                                                  Dev Dependencies (0)

                                                                                                                                                                                                                                                                                                                                  No dev dependencies.

                                                                                                                                                                                                                                                                                                                                  Peer Dependencies (2)


                                                                                                                                                                                                                                                                                                                                  To add a badge like this onejsDocs.io badgeto your package's README, use the codes available below.

                                                                                                                                                                                                                                                                                                                                  You may also use Shields.io to create a custom badge linking to https://www.jsdocs.io/package/@storybook/addons.

                                                                                                                                                                                                                                                                                                                                  • Markdown
                                                                                                                                                                                                                                                                                                                                  • HTML
                                                                                                                                                                                                                                                                                                                                    <a href="https://www.jsdocs.io/package/@storybook/addons"><img src="https://img.shields.io/badge/jsDocs.io-reference-blue" alt="jsDocs.io"></a>