@storybook/client-api

constructor({
    storyStore,
    decorateStory,
    noStoryModuleAddMethodHotDispose,
}: ClientApiParams);

addArgsEnhancer: (enhancer: ArgsEnhancer) => void;

addArgTypesEnhancer: (enhancer: ArgTypesEnhancer) => void;

addDecorator: (decorator: any) => void;

addLoader: (loader: any) => void;

addParameters: (parameters: any) => void;

clearDecorators: () => void;

getStorybook: () => import('./types').GetStorybookKind[];

globalRender: any;

raw: () => import('./types').PublishedStoreItem[];

setAddon: (addon: any) => void;

store: () => StoryStore;

storiesOf: <StoryFnReturnType = unknown>(kind: string, m: any) => any;

constructor({ storyStore }: { storyStore: StoryStore });

configure: (
    loaders: () => void,
    module: any,
    showDeprecationWarning?: boolean
) => void;

constructor(params: { channel: any });

fromId: (id: string) => PublishedStoreItem | null;

getDataForManager: () => {
    v: number;
    globalParameters: any;
    globals: any;
    error: ErrorLike;
    kindParameters: { [x: string]: any };
    stories: {};
};

getError: () => ErrorLike | undefined;

getSelection: () => StoreSelection;

getStoriesForKind: (kind: string) => PublishedStoreItem[];

getStoriesJsonData: () => {
    v: number;
    globalParameters: Pick<Parameters, string>;
    kindParameters: { [x: string]: Pick<any, string> };
    stories: {};
};

pushToManager: () => void;

remove: (id: string, { allowUnsafe }?: AllowUnsafeOption) => void;

setError: (err: ErrorLike) => void;

addArgsEnhancer: (argsEnhancer: ArgsEnhancer) => void;

addArgTypesEnhancer: (argTypesEnhancer: ArgTypesEnhancer) => void;

addGlobalMetadata: ({ parameters, decorators, loaders }: StoryMetadata) => void;

addKindMetadata: (
    kind: string,
    { parameters, decorators, loaders }: StoryMetadata
) => void;

addStory: (
    {
        id,
        kind,
        name,
        storyFn: original,
        parameters: storyParameters,
        decorators: storyDecorators,
        loaders: storyLoaders,
    }: AddStoryArgs,
    {
        applyDecorators,
        allowUnsafe,
    }: {
        applyDecorators: (fn: any, decorators: DecoratorFunction[]) => any;
    } & AllowUnsafeOption
) => void;

cleanHooks: (id: string) => void;

cleanHooksForKind: (kind: string) => void;

clearError: () => void;

clearGlobalDecorators: () => void;

combineStoryParameters: (parameters: any, kind: any) => any;

ensureKind: (kind: string) => void;

extract: (options?: StoryOptions & { normalizeParameters?: boolean }) => {};

finishConfiguring: () => void;

getRawStory: (kind: string, name: string) => PublishedStoreItem;

getStorybook: () => GetStorybookKind[];

getStoryKinds: () => string[];

isSingleStoryMode: () => boolean;

raw: (options?: StoryOptions) => PublishedStoreItem[];

removeStoryKind: (kind: string, { allowUnsafe }?: AllowUnsafeOption) => void;

resetStoryArgs: (id: string, argNames?: string[]) => void;

setSelection: (selection: StoreSelection) => void;

setSelectionSpecifier: (selectionSpecifier: StoreSelectionSpecifier) => void;

setupListeners: () => void;

shouldBlockAddingKindMetadata: (kind: string) => boolean;

shouldBlockAddingStory: (id: string) => boolean;

sortedStories: () => StoreItem[];

startConfiguring: () => void;

updateGlobals: (newGlobals: any) => void;

updateStoryArgs: (id: string, newArgs: any) => void;

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

[key: string]: ClientApiAddon<StoryFnReturnType>;

decorateStory?: DecorateStoryFunction;

noStoryModuleAddMethodHotDispose?: boolean;

storyStore: StoryStore;

message: string;

stack: string;

fileName: string;

kind: string;

stories: GetStorybookStory[];

name: string;

render: StoryFn;

[key: string]: StoreItem;

storyId: StoryId;

viewMode: ViewMode;

args?: Args;

globals?: Args;

singleStory?: boolean;

storySpecifier: StorySpecifier;

viewMode: ViewMode;

decorators?: DecoratorFunction[];

loaders?: LoaderFunction[];

parameters?: Parameters;