import { Channel as Channel$1 } from 'storybook/internal/channels';
import * as storybook_internal_types from 'storybook/internal/types';
import { Args as Args$1, Renderer, StoryContext, DecoratorApplicator, StoryId, Addon_StoryWrapper, PreparedStory, Globals, GlobalTypes, StoryIndex, StoryName, ComponentTitle, IndexEntry, Path as Path$1, StoryAnnotationsOrFn, NormalizedComponentAnnotations, NormalizedStoryAnnotations, ModuleExports, CSFFile, NormalizedProjectAnnotations, ModuleExport, PreparedMeta, ProjectAnnotations, StepRunner, ComposedStoryFn, Store_CSFExports, ComposeStoryFn, LegacyStoryAnnotationsOrFn, ComponentAnnotations, NamedOrDefaultProjectAnnotations, ModuleImportFn, StoryContextForEnhancers, Parameters, StrictArgTypes as StrictArgTypes$1, LegacyStoryFn, DecoratorFunction, PartialStoryFn, StoryContextUpdate, NormalizedStoriesSpecifier, Addon_StorySortParameterV7, DocsContextProps, ResolvedModuleExportType, ResolvedModuleExportFromType, StoryRenderOptions, RenderContextCallbacks, RenderToCanvas, ViewMode } from 'storybook/internal/types';
import * as storybook_internal_csf from 'storybook/internal/csf';
import { Story, Meta, CleanupCallback, StoryContext as StoryContext$1, Args as Args$2, StrictArgTypes as StrictArgTypes$2 } from 'storybook/internal/csf';
import { RequestData, ArgTypesRequestPayload } from 'storybook/internal/core-events';

declare class AddonStore {
    constructor();
    private channel;
    private promise;
    private resolve;
    getChannel: () => Channel$1;
    ready: () => Promise<Channel$1>;
    hasChannel: () => boolean;
    setChannel: (channel: Channel$1) => void;
}
declare const addons: AddonStore;

interface Hook {
    name: string;
    memoizedState?: any;
    deps?: any[] | undefined;
}
interface Effect {
    create: () => (() => void) | void;
    destroy?: (() => void) | void;
}
type AbstractFunction = (...args: any[]) => any;
declare class HooksContext<TRenderer extends Renderer, TArgs extends Args$1 = Args$1> {
    hookListsMap: WeakMap<AbstractFunction, Hook[]>;
    mountedDecorators: Set<AbstractFunction>;
    prevMountedDecorators: Set<AbstractFunction>;
    currentHooks: Hook[];
    nextHookIndex: number;
    currentPhase: 'MOUNT' | 'UPDATE' | 'NONE';
    currentEffects: Effect[];
    prevEffects: Effect[];
    currentDecoratorName: string | null;
    hasUpdates: boolean;
    currentContext: StoryContext<TRenderer, TArgs> | null;
    renderListener: (storyId: StoryId) => void;
    constructor();
    init(): void;
    clean(): void;
    getNextHook(): Hook;
    triggerEffects(): void;
    addRenderListeners(): void;
    removeRenderListeners(): void;
}
declare const applyHooks: <TRenderer extends Renderer>(applyDecorators: DecoratorApplicator<TRenderer>) => DecoratorApplicator<TRenderer>;
/**
 * Returns a memoized value.
 *
 * @example
 *
 * ```ts
 * const memoizedValue = useMemo(() => {
 *   return doExpensiveCalculation(a, b);
 * }, [a, b]);
 * ```
 *
 * @template T The type of the memoized value.
 * @param {() => T} nextCreate A function that returns the memoized value.
 * @param {any[]} [deps] An optional array of dependencies. If any of the dependencies change, the
 *   memoized value will be recomputed.
 * @returns {T} The memoized value.
 */
declare function useMemo<T>(nextCreate: () => T, deps?: any[]): T;
/**
 * Returns a memoized callback.
 *
 * @example
 *
 * ```ts
 * const memoizedCallback = useCallback(() => {
 *   doSomething(a, b);
 * }, [a, b]);
 * ```
 *
 * @template T The type of the callback function.
 * @param {T} callback The callback function to memoize.
 * @param {any[]} [deps] An optional array of dependencies. If any of the dependencies change, the
 *   memoized callback will be recomputed.
 * @returns {T} The memoized callback.
 */
declare function useCallback<T>(callback: T, deps?: any[]): T;
/**
 * Returns a mutable ref object.
 *
 * @example
 *
 * ```ts
 * const ref = useRef(0);
 * ref.current = 1;
 * ```
 *
 * @template T The type of the ref object.
 * @param {T} initialValue The initial value of the ref object.
 * @returns {{ current: T }} The mutable ref object.
 */
declare function useRef<T>(initialValue: T): {
    current: T;
};
/**
 * Returns a stateful value and a function to update it.
 *
 * @example
 *
 * ```ts
 * const [count, setCount] = useState(0);
 * setCount(count + 1);
 * ```
 *
 * @template S The type of the state.
 * @param {(() => S) | S} initialState The initial state value or a function that returns the
 *   initial state value.
 * @returns {[S, (update: ((prevState: S) => S) | S) => void]} An array containing the current state
 *   value and a function to update it.
 */
declare function useState<S>(initialState: (() => S) | S): [S, (update: ((prevState: S) => S) | S) => void];
/**
 * Given a file name, creates an object with utilities to manage a log file. It creates a temporary
 * log file which you can manage with the returned functions. You can then decide whether to move
 * the log file to the users project, or remove it.
 *
 * @example
 *
 * ```tsx
 *   const initialState = { count: 0 };
 *
 *   function reducer(state, action) {
 *     switch (action.type) {
 *       case 'increment':
 *         return { count: state.count + 1 };
 *       case 'decrement':
 *         return { count: state.count - 1 };
 *       default:
 *         throw new Error();
 *       }
 *     }
 *   }
 *   function Counter() {
 *     const [state, dispatch] = useReducer(reducer, initialState);
 *     return (
 *       <>
 *         Count: {state.count}
 *           <button onClick={() => dispatch({ type: 'increment' })}>+</button>
 *           <button onClick={() => dispatch({ type: 'decrement' })}>-</button>
 *       </>
 *     );
 *   }
 * ```
 */
declare function useReducer<S, A>(reducer: (state: S, action: A) => S, initialState: S): [S, (action: A) => void];
declare function useReducer<S, I, A>(reducer: (state: S, action: A) => S, initialArg: I, init: (initialArg: I) => S): [S, (action: A) => void];
/**
 * Triggers a side effect, see https://reactjs.org/docs/hooks-reference.html#usestate Effects are
 * triggered synchronously after rendering the story
 *
 * @example
 *
 * ```ts
 * useEffect(() => {
 *   // Do something after rendering the story
 *   return () => {
 *     // Do something when the component unmounts or the effect is re-run
 *   };
 * }, [dependency1, dependency2]);
 * ```
 *
 * @param {() => (() => void) | void} create A function that creates the effect. It should return a
 *   cleanup function, or nothing.
 * @param {any[]} [deps] An optional array of dependencies. If any of the dependencies change, the
 *   effect will be re-run.
 * @returns {void}
 */
declare function useEffect(create: () => (() => void) | void, deps?: any[]): void;
interface Listener$1 {
    (...args: any[]): void;
}
interface EventMap {
    [eventId: string]: Listener$1;
}
/**
 * Subscribes to events emitted by the Storybook channel and returns a function to emit events.
 *
 * @example
 *
 * ```ts
 * // Subscribe to an event and emit it
 * const emit = useChannel({ 'my-event': (arg1, arg2) => console.log(arg1, arg2) });
 * emit('my-event', 'Hello', 'world!');
 * ```
 *
 * @param {EventMap} eventMap A map of event listeners to subscribe to.
 * @param {any[]} [deps=[]] An optional array of dependencies. If any of the dependencies change,
 *   the event listeners will be re-subscribed. Default is `[]`
 * @returns {(...args: any[]) => void} A function to emit events to the Storybook channel.
 */
declare function useChannel(eventMap: EventMap, deps?: any[]): (eventName: string, ...args: any) => void;
/**
 * Returns the current story context, including the story's ID, parameters, and other metadata.
 *
 * @example
 *
 * ```ts
 * const { id, parameters } = useStoryContext();
 * console.log(`Current story ID: ${id}`);
 * console.log(`Current story parameters: ${JSON.stringify(parameters)}`);
 * ```
 *
 * @template TRenderer The type of the story's renderer.
 * @template TArgs The type of the story's args.
 * @returns {StoryContext<TRenderer>} The current story context.
 */
declare function useStoryContext<TRenderer extends Renderer, TArgs extends Args$1 = Args$1>(): StoryContext<TRenderer>;
/**
 * Returns the value of a specific parameter for the current story, or a default value if the
 * parameter is not set.
 *
 * @example
 *
 * ```ts
 * // Retrieve the value of a parameter named "myParam"
 * const myParamValue = useParameter<string>('myParam', 'default value');
 * console.log(`The value of myParam is: ${myParamValue}`);
 * ```
 *
 * @template S The type of the parameter value.
 * @param {string} parameterKey The key of the parameter to retrieve.
 * @param {S} [defaultValue] An optional default value to return if the parameter is not set.
 * @returns {S | undefined} The value of the parameter, or the default value if the parameter is not
 *   set.
 */
declare function useParameter<S>(parameterKey: string, defaultValue?: S): S | undefined;
/**
 * Returns the current args for the story, and functions to update and reset them.
 *
 * @example
 *
 * ```ts
 * const [args, updateArgs, resetArgs] = useArgs<{ name: string; age: number }>();
 * console.log(`Current args: ${JSON.stringify(args)}`);
 * updateArgs({ name: 'John' });
 * resetArgs(['name']);
 * ```
 *
 * @template TArgs The type of the story's args.
 * @returns {[TArgs, (newArgs: Partial<TArgs>) => void, (argNames?: (keyof TArgs)[]) => void]} An
 *   array containing the current args, a function to update them, and a function to reset them.
 */
declare function useArgs<TArgs extends Args$1 = Args$1>(): [
    TArgs,
    (newArgs: Partial<TArgs>) => void,
    (argNames?: (keyof TArgs)[]) => void
];
/**
 * Returns the current global args for the story, and a function to update them.
 *
 * @example
 *
 * ```ts
 * const [globals, updateGlobals] = useGlobals();
 * console.log(`Current globals: ${JSON.stringify(globals)}`);
 * updateGlobals({ theme: 'dark' });
 * ```
 *
 * @returns {[Args, (newGlobals: Args) => void]} An array containing the current global args, and a
 *   function to update them.
 */
declare function useGlobals(): [Args$1, (newGlobals: Args$1) => void];

type MakeDecoratorResult = (...args: any) => any;
interface MakeDecoratorOptions {
    name: string;
    parameterName: string;
    skipIfNoParametersOrOptions?: boolean;
    wrapper: Addon_StoryWrapper;
}
/**
 * Creates a Storybook decorator function that can be used to wrap stories with additional
 * functionality.
 *
 * @example
 *
 * ```jsx
 * const myDecorator = makeDecorator({
 *   name: 'My Decorator',
 *   parameterName: 'myDecorator',
 *   wrapper: (storyFn, context, { options }) => {
 *     const { myOption } = options;
 *     <div style={{ backgroundColor: myOption }}>{storyFn()}</div>;
 *   },
 * });
 *
 * export const decorators = [myDecorator];
 * ```
 *
 * @param {MakeDecoratorOptions} options - The options for the decorator.
 * @param {string} options.name - The name of the decorator.
 * @param {string} options.parameterName - The name of the parameter that will be used to pass
 *   options to the decorator.
 * @param {Addon_StoryWrapper} options.wrapper - The function that will be used to wrap the story.
 * @param {boolean} [options.skipIfNoParametersOrOptions=false] - Whether to skip the decorator if
 *   no options or parameters are provided. Default is `false`
 * @returns {MakeDecoratorResult} A function that can be used as a Storybook decorator.
 */
declare const makeDecorator: ({ name, parameterName, wrapper, skipIfNoParametersOrOptions, }: MakeDecoratorOptions) => MakeDecoratorResult;

type ChannelHandler = (event: ChannelEvent) => void;
interface ChannelTransport {
    send(event: ChannelEvent, options?: any): void;
    setHandler(handler: ChannelHandler): void;
}
interface ChannelEvent {
    type: string;
    from: string;
    args: any[];
}
interface Listener {
    (...args: any[]): void;
}
/**
 * Structural interface for Channel, used in type declarations to avoid nominal incompatibility
 * between source and dist Channel class declarations.
 */
interface ChannelLike {
    readonly isAsync: boolean;
    readonly hasTransport: boolean;
    addListener(eventName: string, listener: Listener): void;
    emit(eventName: string, ...args: any): void;
    last(eventName: string): any;
    eventNames(): string[];
    listenerCount(eventName: string): number;
    listeners(eventName: string): Listener[] | undefined;
    once(eventName: string, listener: Listener): void;
    removeAllListeners(eventName?: string): void;
    removeListener(eventName: string, listener: Listener): void;
    on(eventName: string, listener: Listener): void;
    off(eventName: string, listener: Listener): void;
}
interface ChannelArgsSingle {
    transport?: ChannelTransport;
    async?: boolean;
}
interface ChannelArgsMulti {
    transports: ChannelTransport[];
    async?: boolean;
}

declare class Channel implements ChannelLike {
    readonly isAsync: boolean;
    private sender;
    private events;
    private data;
    private readonly transports;
    constructor(input: ChannelArgsMulti);
    constructor(input: ChannelArgsSingle);
    get hasTransport(): boolean;
    addListener(eventName: string, listener: Listener): void;
    emit(eventName: string, ...args: any): void;
    last(eventName: string): any;
    eventNames(): string[];
    listenerCount(eventName: string): number;
    listeners(eventName: string): Listener[] | undefined;
    once(eventName: string, listener: Listener): void;
    removeAllListeners(eventName?: string): void;
    removeListener(eventName: string, listener: Listener): void;
    on(eventName: string, listener: Listener): void;
    off(eventName: string, listener: Listener): void;
    private handleEvent;
    private onceListener;
}

/** In-process channel with no transport — the default for unit tests and manager story mocks. */
declare function mockChannel(): Channel;

declare class ArgsStore {
    initialArgsByStoryId: Record<StoryId, Args$1>;
    argsByStoryId: Record<StoryId, Args$1>;
    get(storyId: StoryId): Args$1;
    setInitial(story: PreparedStory<any>): void;
    updateFromDelta(story: PreparedStory<any>, delta: Args$1): void;
    updateFromPersisted(story: PreparedStory<any>, persisted: Args$1): void;
    update(storyId: StoryId, argsUpdate: Partial<Args$1>): void;
}

declare class GlobalsStore {
    allowedGlobalNames: Set<string>;
    initialGlobals: Globals;
    globals: Globals;
    constructor({ globals, globalTypes, }: {
        globals?: Globals;
        globalTypes?: GlobalTypes;
    });
    set({ globals, globalTypes }: {
        globals?: Globals;
        globalTypes?: GlobalTypes;
    }): void;
    filterAllowedGlobals(globals: Globals): Globals;
    updateFromPersisted(persisted: Globals): void;
    get(): Globals;
    update(newGlobals: Globals): void;
}

type StorySpecifier = StoryId | {
    name: StoryName;
    title: ComponentTitle;
} | '*';
declare class StoryIndexStore {
    entries: StoryIndex['entries'];
    constructor({ entries }?: StoryIndex);
    entryFromSpecifier(specifier: StorySpecifier): IndexEntry | undefined;
    storyIdToEntry(storyId: StoryId): IndexEntry;
    importPathToEntry(importPath: Path$1): IndexEntry;
}

declare function normalizeStory<TRenderer extends Renderer>(key: StoryId, storyAnnotations: StoryAnnotationsOrFn<TRenderer>, meta: NormalizedComponentAnnotations<TRenderer>): NormalizedStoryAnnotations<TRenderer>;

declare function processCSFFile<TRenderer extends Renderer>(moduleExports: ModuleExports, importPath: Path$1, title: ComponentTitle): CSFFile<TRenderer>;

declare function prepareStory<TRenderer extends Renderer>(storyAnnotations: NormalizedStoryAnnotations<TRenderer>, componentAnnotations: NormalizedComponentAnnotations<TRenderer>, projectAnnotations: NormalizedProjectAnnotations<TRenderer>): PreparedStory<TRenderer>;
declare function prepareMeta<TRenderer extends Renderer>(componentAnnotations: NormalizedComponentAnnotations<TRenderer>, projectAnnotations: NormalizedProjectAnnotations<TRenderer>, moduleExport: ModuleExport): PreparedMeta<TRenderer>;

declare function normalizeProjectAnnotations<TRenderer extends Renderer>({ argTypes, argTypesEnhancers, decorators, loaders, beforeEach, afterEach, initialGlobals, ...annotations }: ProjectAnnotations<TRenderer>): NormalizedProjectAnnotations<TRenderer>;

declare const normalizeArrays: <T>(array: T[] | T | undefined) => T[];

declare function composeConfigs<TRenderer extends Renderer>(moduleExportList: ModuleExports[]): NormalizedProjectAnnotations<TRenderer>;

/**
 * Compose step runners to create a single step runner that applies each step runner in order.
 *
 * A step runner is a function that takes a defined step:
 *
 * @example
 *
 * ```ts
 * step('label', () => {});
 * ```
 *
 * ...and runs it. The prototypical example is from `core/interactions` where the step runner will
 * decorate all instrumented code inside the step with information about the label.
 *
 * In theory it is possible to have more than one addon that wants to run steps; they can be
 * composed together in a similar fashion to decorators. In some ways step runners are like
 * decorators except it is not intended that they change the context or the play function.
 *
 * The basic implementation of a step runner is `async (label, play, context) => play(context)` --
 * in fact this is what `composeStepRunners([])` will do.
 *
 * @param stepRunners An array of StepRunner
 * @returns A StepRunner that is the composition of the arguments
 */
declare function composeStepRunners<TRenderer extends Renderer>(stepRunners: StepRunner<TRenderer>[]): StepRunner<TRenderer>;

declare global {
    var globalProjectAnnotations: NormalizedProjectAnnotations<any>;
    var defaultProjectAnnotations: ProjectAnnotations<any>;
}
declare function setDefaultProjectAnnotations<TRenderer extends Renderer = Renderer>(_defaultProjectAnnotations: ProjectAnnotations<TRenderer>): void;
declare function setProjectAnnotations<TRenderer extends Renderer = Renderer>(projectAnnotations: NamedOrDefaultProjectAnnotations<TRenderer> | NamedOrDefaultProjectAnnotations<TRenderer>[]): NormalizedProjectAnnotations<TRenderer>;
declare function composeStory<TRenderer extends Renderer = Renderer, TArgs extends Args$1 = Args$1>(storyAnnotations: LegacyStoryAnnotationsOrFn<TRenderer>, componentAnnotations: ComponentAnnotations<TRenderer, TArgs>, projectAnnotations?: ProjectAnnotations<TRenderer>, defaultConfig?: ProjectAnnotations<TRenderer>, exportsName?: string): ComposedStoryFn<TRenderer, Partial<TArgs>>;
declare function composeStories<TModule extends Store_CSFExports>(storiesImport: TModule, globalConfig: ProjectAnnotations<Renderer>, composeStoryFn?: ComposeStoryFn): {};
type WrappedStoryRef = {
    __pw_type: 'jsx';
    props: Record<string, any>;
} | {
    __pw_type: 'importRef';
};
type UnwrappedJSXStoryRef = {
    __pw_type: 'jsx';
    type: UnwrappedImportStoryRef;
};
type UnwrappedImportStoryRef = ComposedStoryFn;
declare global {
    function __pwUnwrapObject(storyRef: WrappedStoryRef): Promise<UnwrappedJSXStoryRef | UnwrappedImportStoryRef>;
}
declare function createPlaywrightTest<TFixture extends {
    extend: any;
}>(baseTest: TFixture): TFixture;

declare function getCsfFactoryAnnotations<TRenderer extends Renderer = Renderer, TArgs extends Args$1 = Args$1>(story: LegacyStoryAnnotationsOrFn<TRenderer> | Story<Renderer>, meta?: ComponentAnnotations<TRenderer, TArgs> | Meta<Renderer>, projectAnnotations?: ProjectAnnotations<TRenderer>): {
    story: storybook_internal_csf.StoryAnnotations<Renderer, unknown>;
    meta: ComponentAnnotations<Renderer, unknown>;
    preview: storybook_internal_types.NormalizedProjectAnnotations<Renderer>;
} | {
    story: LegacyStoryAnnotationsOrFn<TRenderer>;
    meta: ComponentAnnotations<TRenderer, TArgs> | ComponentAnnotations<Renderer, unknown> | undefined;
    preview: ProjectAnnotations<TRenderer> | undefined;
};

interface Report<T = unknown> {
    type: string;
    version?: number;
    result: T;
    status: 'failed' | 'passed' | 'warning';
}
declare class ReporterAPI {
    reports: Report[];
    addReport(report: Report): Promise<void>;
}

declare class StoryStore<TRenderer extends Renderer> {
    importFn: ModuleImportFn;
    storyIndex: StoryIndexStore;
    projectAnnotations: NormalizedProjectAnnotations<TRenderer>;
    userGlobals: GlobalsStore;
    args: ArgsStore;
    hooks: Record<StoryId, HooksContext<TRenderer>>;
    cleanupCallbacks: Record<StoryId, CleanupCallback[] | undefined>;
    cachedCSFFiles?: Record<Path$1, CSFFile<TRenderer>>;
    processCSFFileWithCache: typeof processCSFFile;
    prepareMetaWithCache: typeof prepareMeta;
    prepareStoryWithCache: typeof prepareStory;
    constructor(storyIndex: StoryIndex, importFn: ModuleImportFn, projectAnnotations: ProjectAnnotations<TRenderer>);
    setProjectAnnotations(projectAnnotations: ProjectAnnotations<TRenderer>): void;
    onStoriesChanged({ importFn, storyIndex, }: {
        importFn?: ModuleImportFn;
        storyIndex?: StoryIndex;
    }): Promise<void>;
    storyIdToEntry(storyId: StoryId): Promise<IndexEntry>;
    loadCSFFileByStoryId(storyId: StoryId): Promise<CSFFile<TRenderer>>;
    loadAllCSFFiles(): Promise<StoryStore<TRenderer>['cachedCSFFiles']>;
    cacheAllCSFFiles(): Promise<void>;
    preparedMetaFromCSFFile({ csfFile }: {
        csfFile: CSFFile<TRenderer>;
    }): PreparedMeta<TRenderer>;
    loadStory({ storyId }: {
        storyId: StoryId;
    }): Promise<PreparedStory<TRenderer>>;
    storyFromCSFFile({ storyId, csfFile, }: {
        storyId: StoryId;
        csfFile: CSFFile<TRenderer>;
    }): PreparedStory<TRenderer>;
    componentStoriesFromCSFFile({ csfFile, }: {
        csfFile: CSFFile<TRenderer>;
    }): PreparedStory<TRenderer>[];
    loadEntry(id: StoryId): Promise<{
        entryExports: ModuleExports;
        csfFiles: CSFFile<TRenderer>[];
    }>;
    getStoryContext(story: PreparedStory<TRenderer>, { forceInitialArgs }?: {
        forceInitialArgs?: boolean | undefined;
    }): {
        args: storybook_internal_csf.Args;
        initialGlobals: storybook_internal_csf.Globals;
        globalTypes: storybook_internal_csf.GlobalTypes | undefined;
        userGlobals: storybook_internal_csf.Globals;
        reporting: ReporterAPI;
        globals: {
            [x: string]: any;
        };
        hooks: unknown;
        component?: (TRenderer & {
            T: any;
        })["component"] | undefined;
        subcomponents?: Record<string, (TRenderer & {
            T: any;
        })["component"]> | undefined;
        parameters: storybook_internal_csf.Parameters;
        initialArgs: storybook_internal_csf.Args;
        argTypes: storybook_internal_csf.StrictArgTypes<storybook_internal_csf.Args>;
        componentId: storybook_internal_csf.ComponentId;
        title: storybook_internal_csf.ComponentTitle;
        kind: storybook_internal_csf.ComponentTitle;
        id: StoryId;
        name: storybook_internal_csf.StoryName;
        story: storybook_internal_csf.StoryName;
        tags: storybook_internal_csf.Tag[];
        moduleExport: storybook_internal_types.ModuleExport;
        originalStoryFn: storybook_internal_csf.ArgsStoryFn<TRenderer>;
        undecoratedStoryFn: storybook_internal_csf.LegacyStoryFn<TRenderer>;
        unboundStoryFn: storybook_internal_csf.LegacyStoryFn<TRenderer>;
        applyLoaders: (context: storybook_internal_csf.StoryContext<TRenderer, storybook_internal_csf.Args>) => Promise<Record<string, any>>;
        applyBeforeEach: (context: storybook_internal_csf.StoryContext<TRenderer, storybook_internal_csf.Args>) => Promise<CleanupCallback[]>;
        applyAfterEach: (context: storybook_internal_csf.StoryContext<TRenderer, storybook_internal_csf.Args>) => Promise<void>;
        playFunction?: ((context: storybook_internal_csf.StoryContext<TRenderer, storybook_internal_csf.Args>) => Promise<void> | void) | undefined;
        runStep: storybook_internal_csf.StepRunner<TRenderer>;
        mount: (context: storybook_internal_csf.StoryContext<TRenderer, storybook_internal_csf.Args>) => () => Promise<storybook_internal_csf.Canvas>;
        testingLibraryRender?: (...args: never[]) => unknown;
        renderToCanvas?: storybook_internal_types.RenderToCanvas<TRenderer> | undefined;
        usesMount: boolean;
        storyGlobals: storybook_internal_csf.Globals;
    } & Pick<storybook_internal_csf.StoryContextForLoaders<Renderer, storybook_internal_csf.Args>, "allArgs" | "argsByTarget" | "unmappedArgs">;
    addCleanupCallbacks(story: PreparedStory<TRenderer>, ...callbacks: CleanupCallback[]): void;
    cleanupStory(story: PreparedStory<TRenderer>): Promise<void>;
    extract(options?: {
        includeDocsOnly?: boolean;
    }): Record<StoryId, StoryContextForEnhancers<TRenderer>>;
}

/**
 * Safely combine parameters recursively. Only copy objects when needed. Algorithm = always
 * overwrite the existing value UNLESS both values are plain objects. In this case flag the key as
 * "special" and handle it with a heuristic.
 */
declare const combineParameters: (...parameterSets: (Parameters | undefined)[]) => Parameters;

type PropDescriptor = string[] | RegExp;
declare const filterArgTypes: (argTypes: StrictArgTypes$1, include?: PropDescriptor, exclude?: PropDescriptor) => Partial<StrictArgTypes$1<storybook_internal_types.Args>>;

/** The fields {@link inferControls} reads; the full enhancer context is structurally assignable. */
type InferControlsContext<TRenderer extends Renderer = Renderer> = Pick<StoryContextForEnhancers<TRenderer>, 'argTypes' | 'parameters'>;
declare const inferControls: ((context: InferControlsContext) => StrictArgTypes$1) & {
    secondPass?: boolean;
};

declare function decorateStory<TRenderer extends Renderer>(storyFn: LegacyStoryFn<TRenderer>, decorator: DecoratorFunction<TRenderer>, bindWithContext: (storyFn: LegacyStoryFn<TRenderer>) => PartialStoryFn<TRenderer>): LegacyStoryFn<TRenderer>;
/**
 * Currently StoryContextUpdates are allowed to have any key in the type. However, you cannot
 * overwrite any of the build-it "static" keys.
 *
 * @param inputContextUpdate StoryContextUpdate
 * @returns StoryContextUpdate
 */
declare function sanitizeStoryContextUpdate({ componentId, title, kind, id, name, story, parameters, initialArgs, argTypes, ...update }?: StoryContextUpdate): StoryContextUpdate;
declare function defaultDecorateStory<TRenderer extends Renderer>(storyFn: LegacyStoryFn<TRenderer>, decorators: DecoratorFunction<TRenderer>[]): LegacyStoryFn<TRenderer>;

declare const combineArgs: (value: any, update: any) => Args$1;

declare const userOrAutoTitleFromSpecifier: (fileName: string | number, entry: NormalizedStoriesSpecifier, userTitle?: string) => string | undefined;
declare const userOrAutoTitle: (fileName: string, storiesEntries: NormalizedStoriesSpecifier[], userTitle?: string) => string | undefined;

declare const sortStoriesV7: (stories: IndexEntry[], storySortParameter: Addon_StorySortParameterV7, fileNameOrder: Path$1[]) => IndexEntry[];

declare class DocsContext<TRenderer extends Renderer> implements DocsContextProps<TRenderer> {
    channel: Channel$1;
    protected store: StoryStore<TRenderer>;
    renderStoryToElement: DocsContextProps<TRenderer>['renderStoryToElement'];
    private componentStoriesValue;
    private storyIdToCSFFile;
    private exportToStory;
    private exportsToCSFFile;
    private nameToStoryId;
    private attachedCSFFiles;
    private primaryStory?;
    filterByAutodocs?: boolean;
    constructor(channel: Channel$1, store: StoryStore<TRenderer>, renderStoryToElement: DocsContextProps<TRenderer>['renderStoryToElement'], 
    /** The CSF files known (via the index) to be refererenced by this docs file */
    csfFiles: CSFFile<TRenderer>[]);
    referenceCSFFile(csfFile: CSFFile<TRenderer>): void;
    attachCSFFile(csfFile: CSFFile<TRenderer>): void;
    referenceMeta(metaExports: ModuleExports, attach: boolean): void;
    get projectAnnotations(): storybook_internal_types.NormalizedProjectAnnotations<TRenderer>;
    private resolveAttachedModuleExportType;
    private resolveModuleExport;
    resolveOf<TType extends ResolvedModuleExportType>(moduleExportOrType: ModuleExport | TType, validTypes?: TType[]): ResolvedModuleExportFromType<TType, TRenderer>;
    storyIdByName: (storyName: StoryName) => string;
    componentStories: () => PreparedStory<TRenderer>[];
    getComponentId: (component: Renderer["component"]) => string | undefined;
    componentStoriesFromCSFFile: (csfFile: CSFFile<TRenderer>) => PreparedStory<TRenderer>[];
    storyById: (storyId?: StoryId) => PreparedStory<TRenderer>;
    getStoryContext: (story: PreparedStory<TRenderer>) => {
        loaded: {};
        viewMode: string;
        args: storybook_internal_csf.Args;
        initialGlobals: storybook_internal_csf.Globals;
        globalTypes: storybook_internal_csf.GlobalTypes | undefined;
        userGlobals: storybook_internal_csf.Globals;
        reporting: ReporterAPI;
        globals: {
            [x: string]: any;
        };
        hooks: unknown;
        component?: (TRenderer & {
            T: any;
        })["component"] | undefined;
        subcomponents?: Record<string, (TRenderer & {
            T: any;
        })["component"]> | undefined;
        parameters: storybook_internal_csf.Parameters;
        initialArgs: storybook_internal_csf.Args;
        argTypes: storybook_internal_csf.StrictArgTypes<storybook_internal_csf.Args>;
        componentId: storybook_internal_csf.ComponentId;
        title: storybook_internal_csf.ComponentTitle;
        kind: storybook_internal_csf.ComponentTitle;
        id: StoryId;
        name: StoryName;
        story: StoryName;
        tags: storybook_internal_csf.Tag[];
        moduleExport: ModuleExport;
        originalStoryFn: storybook_internal_csf.ArgsStoryFn<TRenderer>;
        undecoratedStoryFn: storybook_internal_csf.LegacyStoryFn<TRenderer>;
        unboundStoryFn: storybook_internal_csf.LegacyStoryFn<TRenderer>;
        applyLoaders: (context: storybook_internal_csf.StoryContext<TRenderer, storybook_internal_csf.Args>) => Promise<Record<string, any>>;
        applyBeforeEach: (context: storybook_internal_csf.StoryContext<TRenderer, storybook_internal_csf.Args>) => Promise<storybook_internal_csf.CleanupCallback[]>;
        applyAfterEach: (context: storybook_internal_csf.StoryContext<TRenderer, storybook_internal_csf.Args>) => Promise<void>;
        playFunction?: ((context: storybook_internal_csf.StoryContext<TRenderer, storybook_internal_csf.Args>) => Promise<void> | void) | undefined;
        runStep: storybook_internal_csf.StepRunner<TRenderer>;
        mount: (context: storybook_internal_csf.StoryContext<TRenderer, storybook_internal_csf.Args>) => () => Promise<storybook_internal_csf.Canvas>;
        testingLibraryRender?: (...args: never[]) => unknown;
        renderToCanvas?: storybook_internal_types.RenderToCanvas<TRenderer> | undefined;
        usesMount: boolean;
        storyGlobals: storybook_internal_csf.Globals;
        allArgs: any;
        argsByTarget: any;
        unmappedArgs: any;
    };
    loadStory: (id: StoryId) => Promise<PreparedStory<TRenderer>>;
}

type RenderType = 'story' | 'docs';
/**
 * A "Render" represents the rendering of a single entry to a single location
 *
 * The implementations of render are used for two key purposes:
 *
 * - Tracking the state of the rendering as it moves between preparing, rendering and tearing down.
 * - Tracking what is rendered to know if a change requires re-rendering or teardown + recreation.
 */
interface Render<TRenderer extends Renderer> {
    renderId: number;
    type: RenderType;
    id: StoryId;
    isPreparing: () => boolean;
    isEqual: (other: Render<TRenderer>) => boolean;
    disableKeyListeners: boolean;
    teardown?: (options: {
        viewModeChanged: boolean;
    }) => Promise<void>;
    torndown: boolean;
    renderToElement: (canvasElement: TRenderer['canvasElement'], renderStoryToElement?: any, options?: StoryRenderOptions) => Promise<void>;
}

/**
 * A CsfDocsRender is a render of a docs entry that is rendered based on a CSF file.
 *
 * The expectation is the primary CSF file which is the `importPath` for the entry will define a
 * story which may contain the actual rendered JSX code for the template in the `docs.page`
 * parameter.
 *
 * Use cases:
 *
 * - Autodocs, where there is no story, and we fall back to the globally defined template.
 */
declare class CsfDocsRender<TRenderer extends Renderer> implements Render<TRenderer> {
    protected channel: Channel$1;
    protected store: StoryStore<TRenderer>;
    entry: IndexEntry;
    private callbacks;
    readonly renderId: number;
    readonly type: RenderType;
    readonly subtype = "csf";
    readonly id: StoryId;
    story?: PreparedStory<TRenderer>;
    rerender?: () => Promise<void>;
    teardownRender?: (options: {
        viewModeChanged?: boolean;
    }) => Promise<void>;
    torndown: boolean;
    readonly disableKeyListeners = false;
    preparing: boolean;
    csfFiles?: CSFFile<TRenderer>[];
    constructor(channel: Channel$1, store: StoryStore<TRenderer>, entry: IndexEntry, callbacks: RenderContextCallbacks<TRenderer>);
    isPreparing(): boolean;
    prepare(): Promise<void>;
    isEqual(other: Render<TRenderer>): boolean;
    docsContext(renderStoryToElement: DocsContextProps<TRenderer>['renderStoryToElement']): DocsContext<TRenderer>;
    renderToElement(canvasElement: TRenderer['canvasElement'], renderStoryToElement: DocsContextProps<TRenderer>['renderStoryToElement']): Promise<void>;
    teardown({ viewModeChanged }?: {
        viewModeChanged?: boolean;
    }): Promise<void>;
}

/**
 * A MdxDocsRender is a render of a docs entry that comes from a true MDX file, that is a `.mdx`
 * file that doesn't get compiled to a CSF file.
 *
 * A MDX render can reference (import) zero or more CSF files that contain stories.
 *
 * Use cases:
 *
 * - *.mdx file that may or may not reference a specific CSF file with `<Meta of={} />`
 */
declare class MdxDocsRender<TRenderer extends Renderer> implements Render<TRenderer> {
    protected channel: Channel$1;
    protected store: StoryStore<TRenderer>;
    entry: IndexEntry;
    private callbacks;
    readonly renderId: number;
    readonly type: RenderType;
    readonly subtype = "mdx";
    readonly id: StoryId;
    private exports?;
    rerender?: () => Promise<void>;
    teardownRender?: (options: {
        viewModeChanged?: boolean;
    }) => Promise<void>;
    torndown: boolean;
    readonly disableKeyListeners = false;
    preparing: boolean;
    csfFiles?: CSFFile<TRenderer>[];
    attachedCsfFile?: CSFFile<TRenderer>;
    attachedStory?: PreparedStory<TRenderer>;
    constructor(channel: Channel$1, store: StoryStore<TRenderer>, entry: IndexEntry, callbacks: RenderContextCallbacks<TRenderer>);
    isPreparing(): boolean;
    prepare(): Promise<void>;
    isEqual(other: Render<TRenderer>): boolean;
    docsContext(renderStoryToElement: DocsContextProps<TRenderer>['renderStoryToElement']): DocsContext<TRenderer>;
    renderToElement(canvasElement: TRenderer['canvasElement'], renderStoryToElement: DocsContextProps<TRenderer>['renderStoryToElement']): Promise<void>;
    teardown({ viewModeChanged }?: {
        viewModeChanged?: boolean;
    }): Promise<void>;
}

type RenderPhase = 'preparing' | 'loading' | 'beforeEach' | 'rendering' | 'playing' | 'played' | 'completing' | 'completed' | 'afterEach' | 'finished' | 'aborted' | 'errored';
declare class StoryRender<TRenderer extends Renderer> implements Render<TRenderer> {
    channel: Channel$1;
    store: StoryStore<TRenderer>;
    private renderToScreen;
    private callbacks;
    id: StoryId;
    viewMode: StoryContext<TRenderer>['viewMode'];
    renderOptions: StoryRenderOptions;
    readonly renderId: number;
    type: RenderType;
    story?: PreparedStory<TRenderer>;
    phase?: RenderPhase;
    private abortController;
    private canvasElement?;
    private notYetRendered;
    private rerenderEnqueued;
    disableKeyListeners: boolean;
    private teardownRender;
    torndown: boolean;
    constructor(channel: Channel$1, store: StoryStore<TRenderer>, renderToScreen: RenderToCanvas<TRenderer>, callbacks: RenderContextCallbacks<TRenderer> & {
        showStoryDuringRender?: () => void;
    }, id: StoryId, viewMode: StoryContext<TRenderer>['viewMode'], renderOptions?: StoryRenderOptions, story?: PreparedStory<TRenderer>);
    private runPhase;
    private checkIfAborted;
    prepare(): Promise<void>;
    isEqual(other: Render<TRenderer>): boolean;
    isPreparing(): boolean;
    isPending(): boolean;
    renderToElement(canvasElement: TRenderer['canvasElement']): Promise<void>;
    private storyContext;
    render({ initial, forceRemount, }?: {
        initial?: boolean;
        forceRemount?: boolean;
    }): Promise<void>;
    /**
     * Rerender the story. If the story is currently pending (loading/rendering), the rerender will be
     * enqueued, and will be executed after the current render is completed. Rerendering while playing
     * will not be enqueued, and will be executed immediately, to support rendering args changes while
     * playing.
     */
    rerender(): Promise<void>;
    remount(): Promise<void>;
    cancelRender(): void;
    cancelPlayFunction(): void;
    teardown(): Promise<void>;
}

type MaybePromise$1<T> = Promise<T> | T;
declare class Preview<TRenderer extends Renderer> {
    importFn: ModuleImportFn;
    getProjectAnnotations: () => MaybePromise$1<ProjectAnnotations<TRenderer>>;
    protected channel: Channel$1;
    protected storyStoreValue?: StoryStore<TRenderer>;
    renderToCanvas?: RenderToCanvas<TRenderer>;
    storyRenders: StoryRender<TRenderer>[];
    previewEntryError?: Error;
    private projectAnnotationsBeforeInitialization?;
    private beforeAllCleanup?;
    protected storeInitializationPromise: Promise<void>;
    protected resolveStoreInitializationPromise: () => void;
    protected rejectStoreInitializationPromise: (err: Error) => void;
    constructor(importFn: ModuleImportFn, getProjectAnnotations: () => MaybePromise$1<ProjectAnnotations<TRenderer>>, channel?: Channel$1, shouldInitialize?: boolean);
    get storyStore(): StoryStore<TRenderer>;
    protected initialize(): Promise<void>;
    ready(): Promise<void>;
    setupListeners(): void;
    getProjectAnnotationsOrRenderError(): Promise<ProjectAnnotations<TRenderer>>;
    initializeWithProjectAnnotations(projectAnnotations: ProjectAnnotations<TRenderer>): Promise<void>;
    runBeforeAllHook(projectAnnotations: ProjectAnnotations<TRenderer>): Promise<void>;
    getStoryIndexFromServer(): Promise<StoryIndex>;
    protected initializeWithStoryIndex(storyIndex: StoryIndex): void;
    setInitialGlobals(): Promise<void>;
    emitGlobals(): void;
    onGetProjectAnnotationsChanged({ getProjectAnnotations, }: {
        getProjectAnnotations: () => MaybePromise$1<ProjectAnnotations<TRenderer>>;
    }): Promise<void>;
    onStoryIndexChanged(): Promise<void>;
    onStoriesChanged({ importFn, storyIndex, }: {
        importFn?: ModuleImportFn;
        storyIndex?: StoryIndex;
    }): Promise<void>;
    onUpdateGlobals({ globals: updatedGlobals, currentStory, }: {
        globals: Globals;
        currentStory?: PreparedStory<TRenderer>;
    }): Promise<void>;
    onUpdateArgs({ storyId, updatedArgs }: {
        storyId: StoryId;
        updatedArgs: Args$1;
    }): Promise<void>;
    onRequestArgTypesInfo({ id, payload }: RequestData<ArgTypesRequestPayload>): Promise<void>;
    onResetArgs({ storyId, argNames }: {
        storyId: string;
        argNames?: string[];
    }): Promise<void>;
    onForceReRender(): Promise<void>;
    onForceRemount({ storyId }: {
        storyId: StoryId;
    }): Promise<void>;
    onStoryHotUpdated(): Promise<void>;
    renderStoryToElement(story: PreparedStory<TRenderer>, element: TRenderer['canvasElement'], callbacks: RenderContextCallbacks<TRenderer>, options: StoryRenderOptions): () => Promise<void>;
    teardownRender(render: StoryRender<TRenderer> | CsfDocsRender<TRenderer> | MdxDocsRender<TRenderer>, { viewModeChanged }?: {
        viewModeChanged?: boolean;
    }): Promise<void>;
    loadStory({ storyId }: {
        storyId: StoryId;
    }): Promise<PreparedStory<TRenderer>>;
    getStoryContext(story: PreparedStory<TRenderer>, { forceInitialArgs }?: {
        forceInitialArgs?: boolean | undefined;
    }): {
        args: Args$1;
        initialGlobals: Globals;
        globalTypes: storybook_internal_csf.GlobalTypes | undefined;
        userGlobals: Globals;
        reporting: ReporterAPI;
        globals: {
            [x: string]: any;
        };
        hooks: unknown;
        component?: (TRenderer & {
            T: any;
        })["component"] | undefined;
        subcomponents?: Record<string, (TRenderer & {
            T: any;
        })["component"]> | undefined;
        parameters: storybook_internal_csf.Parameters;
        initialArgs: Args$1;
        argTypes: storybook_internal_csf.StrictArgTypes<Args$1>;
        componentId: storybook_internal_csf.ComponentId;
        title: storybook_internal_csf.ComponentTitle;
        kind: storybook_internal_csf.ComponentTitle;
        id: StoryId;
        name: storybook_internal_csf.StoryName;
        story: storybook_internal_csf.StoryName;
        tags: storybook_internal_csf.Tag[];
        moduleExport: storybook_internal_types.ModuleExport;
        originalStoryFn: storybook_internal_csf.ArgsStoryFn<TRenderer>;
        undecoratedStoryFn: storybook_internal_csf.LegacyStoryFn<TRenderer>;
        unboundStoryFn: storybook_internal_csf.LegacyStoryFn<TRenderer>;
        applyLoaders: (context: storybook_internal_csf.StoryContext<TRenderer, Args$1>) => Promise<Record<string, any>>;
        applyBeforeEach: (context: storybook_internal_csf.StoryContext<TRenderer, Args$1>) => Promise<CleanupCallback[]>;
        applyAfterEach: (context: storybook_internal_csf.StoryContext<TRenderer, Args$1>) => Promise<void>;
        playFunction?: ((context: storybook_internal_csf.StoryContext<TRenderer, Args$1>) => Promise<void> | void) | undefined;
        runStep: storybook_internal_csf.StepRunner<TRenderer>;
        mount: (context: storybook_internal_csf.StoryContext<TRenderer, Args$1>) => () => Promise<storybook_internal_csf.Canvas>;
        testingLibraryRender?: (...args: never[]) => unknown;
        renderToCanvas?: RenderToCanvas<TRenderer> | undefined;
        usesMount: boolean;
        storyGlobals: Globals;
    } & Pick<storybook_internal_csf.StoryContextForLoaders<Renderer, Args$1>, "allArgs" | "argsByTarget" | "unmappedArgs">;
    extract(options?: {
        includeDocsOnly: boolean;
    }): Promise<Record<string, storybook_internal_csf.StoryContextForEnhancers<TRenderer, Args$1>>>;
    renderPreviewEntryError(reason: string, err: Error): void;
}

interface SelectionSpecifier {
    storySpecifier: StorySpecifier;
    viewMode: ViewMode;
    args?: Args$1;
    globals?: Args$1;
}
interface Selection {
    storyId: StoryId;
    viewMode: ViewMode;
}
interface SelectionStore {
    selectionSpecifier: SelectionSpecifier | null;
    selection?: Selection;
    setSelection(selection: Selection): void;
    setQueryParams(queryParams: Record<PropertyKey, unknown>): void;
}

interface View<TStorybookRoot> {
    prepareForStory(story: PreparedStory<any>): TStorybookRoot;
    prepareForDocs(options?: {
        scrollReset?: boolean;
    }): TStorybookRoot;
    showErrorDisplay(err: {
        message?: string;
        stack?: string;
    }): void;
    showNoPreview(): void;
    showPreparingStory(options?: {
        immediate: boolean;
    }): void;
    showPreparingDocs(options?: {
        immediate: boolean;
    }): void;
    showMain(): void;
    showDocs(): void;
    showStory(): void;
    showStoryDuringRender(): void;
}

type PossibleRender<TRenderer extends Renderer> = StoryRender<TRenderer> | CsfDocsRender<TRenderer> | MdxDocsRender<TRenderer>;
declare class PreviewWithSelection<TRenderer extends Renderer> extends Preview<TRenderer> {
    importFn: ModuleImportFn;
    getProjectAnnotations: () => MaybePromise$1<ProjectAnnotations<TRenderer>>;
    selectionStore: SelectionStore;
    view: View<TRenderer['canvasElement']>;
    currentSelection?: Selection;
    currentRender?: PossibleRender<TRenderer>;
    constructor(importFn: ModuleImportFn, getProjectAnnotations: () => MaybePromise$1<ProjectAnnotations<TRenderer>>, selectionStore: SelectionStore, view: View<TRenderer['canvasElement']>);
    setupListeners(): void;
    setInitialGlobals(): Promise<void>;
    initializeWithStoryIndex(storyIndex: StoryIndex): Promise<void>;
    selectSpecifiedStory(): Promise<void>;
    onGetProjectAnnotationsChanged({ getProjectAnnotations, }: {
        getProjectAnnotations: () => MaybePromise$1<ProjectAnnotations<TRenderer>>;
    }): Promise<void>;
    onStoriesChanged({ importFn, storyIndex, }: {
        importFn?: ModuleImportFn;
        storyIndex?: StoryIndex;
    }): Promise<void>;
    onKeydown(event: KeyboardEvent): void;
    onSetCurrentStory(selection: {
        storyId: StoryId;
        viewMode?: ViewMode;
    }): Promise<void>;
    onUpdateQueryParams(queryParams: any): void;
    onUpdateGlobals({ globals }: {
        globals: Globals;
    }): Promise<void>;
    onUpdateArgs({ storyId, updatedArgs }: {
        storyId: StoryId;
        updatedArgs: Args$1;
    }): Promise<void>;
    onPreloadStories({ ids }: {
        ids: string[];
    }): Promise<void>;
    protected renderSelection({ persistedArgs }?: {
        persistedArgs?: Args$1;
    }): Promise<void>;
    teardownRender(render: PossibleRender<TRenderer>, { viewModeChanged }?: {
        viewModeChanged?: boolean;
    }): Promise<void>;
    mainStoryCallbacks(storyId: StoryId): {
        showStoryDuringRender: () => void;
        showMain: () => void;
        showError: (err: {
            title: string;
            description: string;
        }) => void;
        showException: (err: Error) => void;
    };
    renderPreviewEntryError(reason: string, err: Error): void;
    renderMissingStory(): void;
    renderStoryLoadingException(storySpecifier: StorySpecifier, err: Error): void;
    renderException(storyId: StoryId, error: Error): void;
    renderError(storyId: StoryId, { title, description }: {
        title: string;
        description: string;
    }): void;
}

declare class PreviewWeb<TRenderer extends Renderer> extends PreviewWithSelection<TRenderer> {
    importFn: ModuleImportFn;
    getProjectAnnotations: () => MaybePromise$1<ProjectAnnotations<TRenderer>>;
    constructor(importFn: ModuleImportFn, getProjectAnnotations: () => MaybePromise$1<ProjectAnnotations<TRenderer>>);
}

declare class UrlStore implements SelectionStore {
    selectionSpecifier: SelectionSpecifier | null;
    selection?: Selection;
    constructor();
    setSelection(selection: Selection): void;
    setQueryParams(queryParams: Record<PropertyKey, unknown>): void;
}

declare enum Mode {
    'MAIN' = "MAIN",
    'NOPREVIEW' = "NOPREVIEW",
    'PREPARING_STORY' = "PREPARING_STORY",
    'PREPARING_DOCS' = "PREPARING_DOCS",
    'ERROR' = "ERROR"
}
declare const layoutClassMap: {
    readonly centered: "sb-main-centered";
    readonly fullscreen: "sb-main-fullscreen";
    readonly padded: "sb-main-padded";
};
type Layout = keyof typeof layoutClassMap | 'none';
declare class WebView implements View<HTMLElement> {
    private currentLayoutClass?;
    private testing;
    private preparingTimeout?;
    constructor();
    prepareForStory(story: PreparedStory<any>): HTMLElement;
    storyRoot(): HTMLElement;
    prepareForDocs({ scrollReset }?: {
        scrollReset?: boolean;
    }): HTMLElement;
    docsRoot(): HTMLElement;
    applyLayout(layout?: Layout): void;
    /**
     * Injects a BCP-47 lang attribute to the story root, or removes it if `lang` is null.
     */
    applyHtmlLang(element: HTMLElement, lang?: string): void;
    checkIfLayoutExists(layout: keyof typeof layoutClassMap): void;
    showMode(mode: Mode): void;
    showErrorDisplay({ message, stack }: {
        message?: string | undefined;
        stack?: string | undefined;
    }): void;
    showNoPreview(): void;
    showPreparingStory({ immediate }?: {
        immediate?: boolean | undefined;
    }): void;
    showPreparingDocs({ immediate }?: {
        immediate?: boolean | undefined;
    }): void;
    showMain(): void;
    showDocs(): void;
    showStory(): void;
    showStoryDuringRender(): void;
}

declare function simulateDOMContentLoaded(): void;
declare function simulatePageLoad($container: any): void;

type ReducedStoryContext = Omit<StoryContext$1<any, Args$2>, 'abortSignal' | 'canvasElement' | 'step' | 'context'>;
declare function emitTransformCode(source: string | undefined, context: ReducedStoryContext): Promise<void>;

declare function pauseAnimations(atEnd?: boolean): CleanupCallback;
declare function waitForAnimations(signal?: AbortSignal): Promise<void>;

/**
 * Actions represent the type of change to a location value.
 */
declare enum Action {
    /**
     * A POP indicates a change to an arbitrary index in the history stack, such
     * as a back or forward navigation. It does not describe the direction of the
     * navigation, only that the current index changed.
     *
     * Note: This is the default action for newly created history objects.
     */
    Pop = "POP",
    /**
     * A PUSH indicates a new entry being added to the history stack, such as when
     * a link is clicked and a new page loads. When this happens, all subsequent
     * entries in the stack are lost.
     */
    Push = "PUSH",
    /**
     * A REPLACE indicates the entry at the current index in the history stack
     * being replaced by a new one.
     */
    Replace = "REPLACE"
}
/**
 * The pathname, search, and hash values of a URL.
 */
interface Path {
    /**
     * A URL pathname, beginning with a /.
     */
    pathname: string;
    /**
     * A URL search string, beginning with a ?.
     */
    search: string;
    /**
     * A URL fragment identifier, beginning with a #.
     */
    hash: string;
}
/**
 * An entry in a history stack. A location contains information about the
 * URL path, as well as possibly some arbitrary state and a key.
 */
interface Location extends Path {
    /**
     * A value of arbitrary data associated with this location.
     */
    state: any;
    /**
     * A unique string associated with this location. May be used to safely store
     * and retrieve data in some other storage API, like `localStorage`.
     *
     * Note: This value is always "default" on the initial location.
     */
    key: string;
}

/**
 * Map of routeId -> data returned from a loader/action/error
 */
interface RouteData {
    [routeId: string]: any;
}
declare enum ResultType {
    data = "data",
    deferred = "deferred",
    redirect = "redirect",
    error = "error"
}
/**
 * Successful result from a loader or action
 */
interface SuccessResult {
    type: ResultType.data;
    data: any;
    statusCode?: number;
    headers?: Headers;
}
/**
 * Successful defer() result from a loader or action
 */
interface DeferredResult {
    type: ResultType.deferred;
    deferredData: DeferredData;
    statusCode?: number;
    headers?: Headers;
}
/**
 * Redirect result from a loader or action
 */
interface RedirectResult {
    type: ResultType.redirect;
    status: number;
    location: string;
    revalidate: boolean;
    reloadDocument?: boolean;
}
/**
 * Unsuccessful result from a loader or action
 */
interface ErrorResult {
    type: ResultType.error;
    error: any;
    headers?: Headers;
}
/**
 * Result from a loader or action - potentially successful or unsuccessful
 */
type DataResult = SuccessResult | DeferredResult | RedirectResult | ErrorResult;
type LowerCaseFormMethod = "get" | "post" | "put" | "patch" | "delete";
type UpperCaseFormMethod = Uppercase<LowerCaseFormMethod>;
/**
 * Active navigation/fetcher form methods are exposed in lowercase on the
 * RouterState
 */
type FormMethod = LowerCaseFormMethod;
/**
 * In v7, active navigation/fetcher form methods are exposed in uppercase on the
 * RouterState.  This is to align with the normalization done via fetch().
 */
type V7_FormMethod = UpperCaseFormMethod;
type FormEncType = "application/x-www-form-urlencoded" | "multipart/form-data" | "application/json" | "text/plain";
type JsonObject = {
    [Key in string]: JsonValue;
} & {
    [Key in string]?: JsonValue | undefined;
};
type JsonArray = JsonValue[] | readonly JsonValue[];
type JsonPrimitive = string | number | boolean | null;
type JsonValue = JsonPrimitive | JsonObject | JsonArray;
/**
 * @private
 * Internal interface to pass around for action submissions, not intended for
 * external consumption
 */
type Submission = {
    formMethod: FormMethod | V7_FormMethod;
    formAction: string;
    formEncType: FormEncType;
    formData: FormData;
    json: undefined;
    text: undefined;
} | {
    formMethod: FormMethod | V7_FormMethod;
    formAction: string;
    formEncType: FormEncType;
    formData: undefined;
    json: JsonValue;
    text: undefined;
} | {
    formMethod: FormMethod | V7_FormMethod;
    formAction: string;
    formEncType: FormEncType;
    formData: undefined;
    json: undefined;
    text: string;
};
/**
 * @private
 * Arguments passed to route loader/action functions.  Same for now but we keep
 * this as a private implementation detail in case they diverge in the future.
 */
interface DataFunctionArgs {
    request: Request;
    params: Params;
    context?: any;
}
/**
 * Arguments passed to loader functions
 */
interface LoaderFunctionArgs extends DataFunctionArgs {
}
/**
 * Arguments passed to action functions
 */
interface ActionFunctionArgs extends DataFunctionArgs {
}
/**
 * Loaders and actions can return anything except `undefined` (`null` is a
 * valid return value if there is no data to return).  Responses are preferred
 * and will ease any future migration to Remix
 */
type DataFunctionValue = Response | NonNullable<unknown> | null;
/**
 * Route loader function signature
 */
interface LoaderFunction {
    (args: LoaderFunctionArgs): Promise<DataFunctionValue> | DataFunctionValue;
}
/**
 * Route action function signature
 */
interface ActionFunction {
    (args: ActionFunctionArgs): Promise<DataFunctionValue> | DataFunctionValue;
}
/**
 * Route shouldRevalidate function signature.  This runs after any submission
 * (navigation or fetcher), so we flatten the navigation/fetcher submission
 * onto the arguments.  It shouldn't matter whether it came from a navigation
 * or a fetcher, what really matters is the URLs and the formData since loaders
 * have to re-run based on the data models that were potentially mutated.
 */
interface ShouldRevalidateFunction {
    (args: {
        currentUrl: URL;
        currentParams: AgnosticDataRouteMatch["params"];
        nextUrl: URL;
        nextParams: AgnosticDataRouteMatch["params"];
        formMethod?: Submission["formMethod"];
        formAction?: Submission["formAction"];
        formEncType?: Submission["formEncType"];
        text?: Submission["text"];
        formData?: Submission["formData"];
        json?: Submission["json"];
        actionResult?: DataResult;
        defaultShouldRevalidate: boolean;
    }): boolean;
}
/**
 * Keys we cannot change from within a lazy() function. We spread all other keys
 * onto the route. Either they're meaningful to the router, or they'll get
 * ignored.
 */
type ImmutableRouteKey = "lazy" | "caseSensitive" | "path" | "id" | "index" | "children";
type RequireOne<T, Key = keyof T> = Exclude<{
    [K in keyof T]: K extends Key ? Omit<T, K> & Required<Pick<T, K>> : never;
}[keyof T], undefined>;
/**
 * lazy() function to load a route definition, which can add non-matching
 * related properties to a route
 */
interface LazyRouteFunction<R extends AgnosticRouteObject> {
    (): Promise<RequireOne<Omit<R, ImmutableRouteKey>>>;
}
/**
 * Base RouteObject with common props shared by all types of routes
 */
type AgnosticBaseRouteObject = {
    caseSensitive?: boolean;
    path?: string;
    id?: string;
    loader?: LoaderFunction;
    action?: ActionFunction;
    hasErrorBoundary?: boolean;
    shouldRevalidate?: ShouldRevalidateFunction;
    handle?: any;
    lazy?: LazyRouteFunction<AgnosticBaseRouteObject>;
};
/**
 * Index routes must not have children
 */
type AgnosticIndexRouteObject = AgnosticBaseRouteObject & {
    children?: undefined;
    index: true;
};
/**
 * Non-index routes may have children, but cannot have index
 */
type AgnosticNonIndexRouteObject = AgnosticBaseRouteObject & {
    children?: AgnosticRouteObject[];
    index?: false;
};
/**
 * A route object represents a logical route, with (optionally) its child
 * routes organized in a tree-like structure.
 */
type AgnosticRouteObject = AgnosticIndexRouteObject | AgnosticNonIndexRouteObject;
type AgnosticDataIndexRouteObject = AgnosticIndexRouteObject & {
    id: string;
};
type AgnosticDataNonIndexRouteObject = AgnosticNonIndexRouteObject & {
    children?: AgnosticDataRouteObject[];
    id: string;
};
/**
 * A data route object, which is just a RouteObject with a required unique ID
 */
type AgnosticDataRouteObject = AgnosticDataIndexRouteObject | AgnosticDataNonIndexRouteObject;
/**
 * The parameters that were parsed from the URL path.
 */
type Params<Key extends string = string> = {
    readonly [key in Key]: string | undefined;
};
/**
 * A RouteMatch contains info about how a route matched a URL.
 */
interface AgnosticRouteMatch<ParamKey extends string = string, RouteObjectType extends AgnosticRouteObject = AgnosticRouteObject> {
    /**
     * The names and values of dynamic parameters in the URL.
     */
    params: Params<ParamKey>;
    /**
     * The portion of the URL pathname that was matched.
     */
    pathname: string;
    /**
     * The portion of the URL pathname that was matched before child routes.
     */
    pathnameBase: string;
    /**
     * The route object that was used to match.
     */
    route: RouteObjectType;
}
interface AgnosticDataRouteMatch extends AgnosticRouteMatch<string, AgnosticDataRouteObject> {
}
declare class DeferredData {
    private pendingKeysSet;
    private controller;
    private abortPromise;
    private unlistenAbortSignal;
    private subscribers;
    data: Record<string, unknown>;
    init?: ResponseInit;
    deferredKeys: string[];
    constructor(data: Record<string, unknown>, responseInit?: ResponseInit);
    private trackPromise;
    private onSettle;
    private emit;
    subscribe(fn: (aborted: boolean, settledKey?: string) => void): () => boolean;
    cancel(): void;
    resolveData(signal: AbortSignal): Promise<boolean>;
    get done(): boolean;
    get unwrappedData(): {};
    get pendingKeys(): string[];
}

/**
 * State maintained internally by the router.  During a navigation, all states
 * reflect the the "old" location unless otherwise noted.
 */
interface RouterState {
    /**
     * The action of the most recent navigation
     */
    historyAction: Action;
    /**
     * The current location reflected by the router
     */
    location: Location;
    /**
     * The current set of route matches
     */
    matches: AgnosticDataRouteMatch[];
    /**
     * Tracks whether we've completed our initial data load
     */
    initialized: boolean;
    /**
     * Current scroll position we should start at for a new view
     *  - number -> scroll position to restore to
     *  - false -> do not restore scroll at all (used during submissions)
     *  - null -> don't have a saved position, scroll to hash or top of page
     */
    restoreScrollPosition: number | false | null;
    /**
     * Indicate whether this navigation should skip resetting the scroll position
     * if we are unable to restore the scroll position
     */
    preventScrollReset: boolean;
    /**
     * Tracks the state of the current navigation
     */
    navigation: Navigation;
    /**
     * Tracks any in-progress revalidations
     */
    revalidation: RevalidationState;
    /**
     * Data from the loaders for the current matches
     */
    loaderData: RouteData;
    /**
     * Data from the action for the current matches
     */
    actionData: RouteData | null;
    /**
     * Errors caught from loaders for the current matches
     */
    errors: RouteData | null;
    /**
     * Map of current fetchers
     */
    fetchers: Map<string, Fetcher>;
    /**
     * Map of current blockers
     */
    blockers: Map<string, Blocker>;
}
/**
 * Data that can be passed into hydrate a Router from SSR
 */
type HydrationState = Partial<Pick<RouterState, "loaderData" | "actionData" | "errors">>;
/**
 * Potential states for state.navigation
 */
type NavigationStates = {
    Idle: {
        state: "idle";
        location: undefined;
        formMethod: undefined;
        formAction: undefined;
        formEncType: undefined;
        formData: undefined;
        json: undefined;
        text: undefined;
    };
    Loading: {
        state: "loading";
        location: Location;
        formMethod: Submission["formMethod"] | undefined;
        formAction: Submission["formAction"] | undefined;
        formEncType: Submission["formEncType"] | undefined;
        formData: Submission["formData"] | undefined;
        json: Submission["json"] | undefined;
        text: Submission["text"] | undefined;
    };
    Submitting: {
        state: "submitting";
        location: Location;
        formMethod: Submission["formMethod"];
        formAction: Submission["formAction"];
        formEncType: Submission["formEncType"];
        formData: Submission["formData"];
        json: Submission["json"];
        text: Submission["text"];
    };
};
type Navigation = NavigationStates[keyof NavigationStates];
type RevalidationState = "idle" | "loading";
/**
 * Potential states for fetchers
 */
type FetcherStates<TData = any> = {
    Idle: {
        state: "idle";
        formMethod: undefined;
        formAction: undefined;
        formEncType: undefined;
        text: undefined;
        formData: undefined;
        json: undefined;
        data: TData | undefined;
        " _hasFetcherDoneAnything "?: boolean;
    };
    Loading: {
        state: "loading";
        formMethod: Submission["formMethod"] | undefined;
        formAction: Submission["formAction"] | undefined;
        formEncType: Submission["formEncType"] | undefined;
        text: Submission["text"] | undefined;
        formData: Submission["formData"] | undefined;
        json: Submission["json"] | undefined;
        data: TData | undefined;
        " _hasFetcherDoneAnything "?: boolean;
    };
    Submitting: {
        state: "submitting";
        formMethod: Submission["formMethod"];
        formAction: Submission["formAction"];
        formEncType: Submission["formEncType"];
        text: Submission["text"];
        formData: Submission["formData"];
        json: Submission["json"];
        data: TData | undefined;
        " _hasFetcherDoneAnything "?: boolean;
    };
};
type Fetcher<TData = any> = FetcherStates<TData>[keyof FetcherStates<TData>];
interface BlockerBlocked {
    state: "blocked";
    reset(): void;
    proceed(): void;
    location: Location;
}
interface BlockerUnblocked {
    state: "unblocked";
    reset: undefined;
    proceed: undefined;
    location: undefined;
}
interface BlockerProceeding {
    state: "proceeding";
    reset: undefined;
    proceed: undefined;
    location: Location;
}
type Blocker = BlockerUnblocked | BlockerBlocked | BlockerProceeding;

/**
 * NOTE: If you refactor this to split up the modules into separate files,
 * you'll need to update the rollup config for react-router-dom-v5-compat.
 */

declare global {
    var __staticRouterHydrationData: HydrationState | undefined;
}

/**
 * Canonical install/read surface for Storybook's shared addons channel.
 *
 * Each runtime (manager, preview, dev server) installs one channel instance here. The module slot
 * is the source of truth; {@link setChannel} also mirrors to `__STORYBOOK_ADDONS_CHANNEL__`
 * so legacy code and builder preamble that read the global slot stay in sync.
 */

/**
 * Returns the installed addons channel, or `null` before one exists.
 *
 * The global slot wins over the module cache so duplicate copies of this module (e.g. dev-server
 * preset code and `.storybook` service registration loading different bundles) still observe
 * `setChannel` from whichever copy installed the live websocket channel.
 */
declare function getChannel(): ChannelLike | null;
/** Installs (or replaces) the shared addons channel. Pass `null` to clear. */
declare function setChannel(next: ChannelLike | null): void;
/** Clears the shared channel slot. Alias for `setChannel(null)`. */
declare function clearChannel(): void;
/** Installs a noop in-process channel — used by server presets and unit tests. */
declare function installNoopChannel(): void;
/**
 * Installs a noop channel when none is present yet.
 *
 * Prefer explicit `setChannel` / `installNoopChannel` at runtime entry points. This helper remains for
 * tests and tooling that need an in-process channel without a mock transport.
 */
declare function ensureChannel(): void;

/** The Standard Typed interface. This is a base type extended by other specs. */
interface StandardTypedV1<Input = unknown, Output = Input> {
    /** The Standard properties. */
    readonly "~standard": StandardTypedV1.Props<Input, Output>;
}
declare namespace StandardTypedV1 {
    /** The Standard Typed properties interface. */
    interface Props<Input = unknown, Output = Input> {
        /** The version number of the standard. */
        readonly version: 1;
        /** The vendor name of the schema library. */
        readonly vendor: string;
        /** Inferred types associated with the schema. */
        readonly types?: Types<Input, Output> | undefined;
    }
    /** The Standard Typed types interface. */
    interface Types<Input = unknown, Output = Input> {
        /** The input type of the schema. */
        readonly input: Input;
        /** The output type of the schema. */
        readonly output: Output;
    }
    /** Infers the input type of a Standard Typed. */
    type InferInput<Schema extends StandardTypedV1> = NonNullable<Schema["~standard"]["types"]>["input"];
    /** Infers the output type of a Standard Typed. */
    type InferOutput<Schema extends StandardTypedV1> = NonNullable<Schema["~standard"]["types"]>["output"];
}
/** The Standard Schema interface. */
interface StandardSchemaV1<Input = unknown, Output = Input> {
    /** The Standard Schema properties. */
    readonly "~standard": StandardSchemaV1.Props<Input, Output>;
}
declare namespace StandardSchemaV1 {
    /** The Standard Schema properties interface. */
    interface Props<Input = unknown, Output = Input> extends StandardTypedV1.Props<Input, Output> {
        /** Validates unknown input values. */
        readonly validate: (value: unknown, options?: StandardSchemaV1.Options | undefined) => Result<Output> | Promise<Result<Output>>;
    }
    /** The result interface of the validate function. */
    type Result<Output> = SuccessResult<Output> | FailureResult;
    /** The result interface if validation succeeds. */
    interface SuccessResult<Output> {
        /** The typed output value. */
        readonly value: Output;
        /** A falsy value for `issues` indicates success. */
        readonly issues?: undefined;
    }
    interface Options {
        /** Explicit support for additional vendor-specific parameters, if needed. */
        readonly libraryOptions?: Record<string, unknown> | undefined;
    }
    /** The result interface if validation fails. */
    interface FailureResult {
        /** The issues of failed validation. */
        readonly issues: ReadonlyArray<Issue>;
    }
    /** The issue interface of the failure output. */
    interface Issue {
        /** The error message of the issue. */
        readonly message: string;
        /** The path of the issue, if any. */
        readonly path?: ReadonlyArray<PropertyKey | PathSegment> | undefined;
    }
    /** The path segment interface of the issue. */
    interface PathSegment {
        /** The key representing a path segment. */
        readonly key: PropertyKey;
    }
    /** The Standard types interface. */
    interface Types<Input = unknown, Output = Input> extends StandardTypedV1.Types<Input, Output> {
    }
    /** Infers the input type of a Standard. */
    type InferInput<Schema extends StandardTypedV1> = StandardTypedV1.InferInput<Schema>;
    /** Infers the output type of a Standard. */
    type InferOutput<Schema extends StandardTypedV1> = StandardTypedV1.InferOutput<Schema>;
}

/** Generic Standard Schema constraint used across open-service definitions. */
type AnySchema = StandardSchemaV1<unknown, unknown>;
/** Stable alias for service identifiers across definition, runtime, and registration APIs. */
type ServiceId = string;
/** Public schema shape exposed when describing a schema-backed service contract. */
type SchemaDescriptor = AnySchema;
/** Raw caller-facing value type accepted by a schema-backed operation. */
type InferSchemaInput<TSchema extends AnySchema> = StandardSchemaV1.InferInput<TSchema>;
/** Parsed value type produced by a schema after validation. */
type InferSchemaOutput<TSchema extends AnySchema> = StandardSchemaV1.InferOutput<TSchema>;
/**
 * Named schema maps are the core inference surface for inline open-service authoring.
 *
 * `defineService()` infers one input-schema map and one output-schema map per operation family
 * (queries and commands). Keeping those maps separate gives TypeScript a place to correlate the
 * `input` and `output` properties of each inline object before it contextually types sibling
 * callbacks like `handler`, `load`, `staticPath`, and `staticInputs`.
 */
type OperationInputSchemas = Record<string, AnySchema>;
/**
 * Output-schema maps must stay key-aligned with their input-schema map.
 *
 * The authoring helper uses this alias instead of a plain `Record<string, AnySchema>` so each
 * operation key retains its own input/output schema pair during inference.
 */
type MatchingOutputSchemas<TInputSchemas extends OperationInputSchemas> = {
    [TKey in keyof TInputSchemas]: AnySchema;
};
/**
 * Internal utility used to keep handler maps assignable without collapsing everything to `unknown`.
 */
type BivariantCallback<TArgs extends unknown[], TResult> = {
    bivarianceHack(...args: TArgs): TResult;
}['bivarianceHack'];
/**
 * Runtime command map derived directly from the inferred command schema maps.
 *
 * Queries only need command-call typing, not the full command definition objects, so this helper
 * keeps query contexts readable while still preserving exact input/output types per command.
 */
type CommandFunctions<TCommandInputSchemas extends OperationInputSchemas, TCommandOutputSchemas extends MatchingOutputSchemas<TCommandInputSchemas>> = {
    [TKey in keyof TCommandInputSchemas]: BivariantCallback<[
        input: InferSchemaInput<TCommandInputSchemas[TKey]>
    ], Promise<InferSchemaOutput<TCommandOutputSchemas[TKey]>>>;
};
/**
 * Coarse lifecycle of a query's `load`, modeled after TanStack Query's `status`.
 *
 * - `pending` — no successful load has completed yet (and none has failed). The query may still
 *   expose `data` (the synchronous "current best" handler result), but nothing has been loaded.
 * - `error` — the most recent attempt (load rejection, or a synchronous handler / validation throw)
 *   failed. `data` keeps the last successful value, if any.
 * - `success` — a load has completed (or the query has no `load`, so there is nothing to load).
 */
type QueryStatus = 'pending' | 'error' | 'success';
/**
 * Whether a `load` is currently running, modeled after TanStack Query's `fetchStatus` — but named
 * with our own `load` vocabulary because open-service "loads" are any slow async work (computation,
 * extraction, I/O), not specifically remote fetching.
 *
 * - `loading` — a `load` is in flight (the first load, or a reactive background re-load).
 * - `idle` — no `load` is currently running.
 */
type LoadStatus = 'loading' | 'idle';
/**
 * The reactive state of a subscribed query: its current `data` plus the lifecycle of its `load`.
 *
 * `data` and `status` are independent. `data` is the synchronous handler result ("current best
 * effort") and holds the last successful value (or `undefined` before the first success / when a
 * handler throws), while `status`/`loadStatus`/`error` describe the asynchronous `load` lifecycle
 * tracked per subscription. A query with no `load` is `success`/`idle` from its first emission.
 *
 * `isLoading` is intentionally "any load in flight" (TanStack's `isFetching`), and
 * `isInitialLoading` is "a load is in flight and there is nothing to show yet"; the names follow our
 * `load` vocabulary rather than TanStack's `fetch`/`load` split. Unlike TanStack Query, a
 * subscription here can attach to a query whose `data` is already cached in service state, so
 * `isInitialLoading` additionally requires `data === undefined` — it never flags over cached data.
 */
type QueryState<TData> = {
    /** Last successfully produced value; `undefined` before the first success. */
    data: TData | undefined;
    /** The failure that produced `status: 'error'`, otherwise `undefined`. */
    error: Error | undefined;
    status: QueryStatus;
    loadStatus: LoadStatus;
    /** `status === 'pending'`. */
    isPending: boolean;
    /** `status === 'success'`. */
    isSuccess: boolean;
    /** `status === 'error'`. */
    isError: boolean;
    /** `loadStatus === 'loading'` — any load in flight, foreground or background. */
    isLoading: boolean;
    /** `isPending && isLoading && data === undefined` — a first load with nothing to show yet. */
    isInitialLoading: boolean;
    /** `isLoading && !isPending` — a background re-load while data is already shown. */
    isRefreshing: boolean;
};
/**
 * Public runtime shape of a query.
 *
 * - `.get(input)` reads synchronously: it validates input, runs the handler against current state,
 *   and returns the validated result. It does **not** fire the query's `load` — it is a pure
 *   "current best effort" read. (Reads of *other* queries from inside a handler or `load` body still
 *   participate in dependency tracking, so `.loaded()` and subscriptions trigger those dependency
 *   loads; a bare consumer `.get()` does not.)
 * - `.loaded(input)` awaits the full load — this query's `load` plus every transitively read
 *   dependency — before resolving with the validated result.
 * - `.subscribe(input, callback)` invokes `callback` synchronously with the current {@link QueryState}
 *   and again whenever tracked state or the load lifecycle changes (deduped on the whole state).
 *   Subscribing is what fires the query's reactive `load`.
 *
 * There is intentionally no bare-call form: a previous `query(input)` that returned synchronously
 * *and* fired the `load` behind the scenes was removed because the implicit background load was
 * confusing. Read with `.get(input)`, await with `.loaded(input)`, observe with `.subscribe(...)`.
 *
 * Queries whose input schema resolves to `undefined` (for example `v.void()`) may be called with
 * zero arguments: `query.get()`, `query.loaded()`.
 */
type InputQuery<TInput, TOutput> = {
    get(input: TInput): TOutput;
    loaded(input: TInput): Promise<TOutput>;
    subscribe(input: TInput, callback: (state: QueryState<TOutput>) => void): () => void;
    subscribe<TSelected>(input: TInput, selector: (value: TOutput) => TSelected, callback: (state: QueryState<TSelected>) => void): () => void;
};
/** Zero-argument overloads merged into {@link Query} when the input schema is void. */
type VoidQuery<TOutput> = {
    get(): TOutput;
    loaded(): Promise<TOutput>;
    subscribe(callback: (state: QueryState<TOutput>) => void): () => void;
    subscribe<TSelected>(selector: (value: TOutput) => TSelected, callback: (state: QueryState<TSelected>) => void): () => void;
};
type Query<TInput, TOutput> = undefined extends TInput ? VoidQuery<TOutput> & InputQuery<TInput, TOutput> : InputQuery<TInput, TOutput>;
/**
 * Runtime query map derived directly from the inferred query schema maps.
 *
 * The query counterpart to {@link CommandFunctions}: it preserves each sibling query's exact
 * input/output types on the read-only `self.queries` handle, so a handler or `load` can call
 * `self.queries.someQuery.get(input)` without manual casts. `defineService` computes this map from
 * the inferred query schema maps and threads it into the handler/load contexts as their `TQueries`;
 * the erased {@link AnyQueryFunctions} bound is used everywhere the concrete map is not known.
 */
type QueryFunctions<TQueryInputSchemas extends OperationInputSchemas, TQueryOutputSchemas extends MatchingOutputSchemas<TQueryInputSchemas>> = {
    [TKey in keyof TQueryInputSchemas]: Query<InferSchemaInput<TQueryInputSchemas[TKey]>, InferSchemaOutput<TQueryOutputSchemas[TKey]>>;
};
/**
 * Permissive bound for a `self.queries` handle.
 *
 * Every {@link Query} — input or void — structurally satisfies {@link InputQuery} (the void
 * overloads are additive), so this is the supertype that any concrete {@link QueryFunctions} map is
 * assignable to. It is the bound (and erased default) for the `TQueries` parameter below, which lets
 * the precise per-service map flow into handler contexts while still erasing cleanly into the
 * structural `AnyQueryDefinition` storage constraint. Using `Query<unknown, unknown>` here instead
 * would wrongly demand the void zero-arg overloads from input queries.
 */
type AnyQueryFunctions = Record<string, InputQuery<unknown, unknown>>;
/**
 * Read-only service handle exposed to query handlers.
 *
 * Query handlers are strict readers: they can read state and call sibling queries, but they cannot
 * mutate state and cannot invoke commands. Mutations belong in commands; load-side preparation
 * belongs in `load`.
 */
type QuerySelf<TState = unknown, TQueries extends AnyQueryFunctions = AnyQueryFunctions> = {
    readonly state: TState;
    queries: TQueries;
};
/**
 * Load handle exposed to `load` functions.
 *
 * `load` may read state and queries, and may invoke declared commands to mutate state. It does
 * not receive `setState` directly — all writes must flow through commands so authors keep one
 * documented mutation surface per service.
 */
type LoadSelf<TState = unknown, TCommandInputSchemas extends OperationInputSchemas = OperationInputSchemas, TCommandOutputSchemas extends MatchingOutputSchemas<TCommandInputSchemas> = MatchingOutputSchemas<TCommandInputSchemas>, TQueries extends AnyQueryFunctions = AnyQueryFunctions> = QuerySelf<TState, TQueries> & {
    commands: CommandFunctions<TCommandInputSchemas, TCommandOutputSchemas>;
};
/**
 * Mutable service handle exposed to command handlers.
 *
 * Commands receive both `setState` for direct state mutation and `commands` so one command can
 * delegate to another within the same service.
 */
type CommandSelf<TState = unknown, TCommandInputSchemas extends OperationInputSchemas = OperationInputSchemas, TCommandOutputSchemas extends MatchingOutputSchemas<TCommandInputSchemas> = MatchingOutputSchemas<TCommandInputSchemas>, TQueries extends AnyQueryFunctions = AnyQueryFunctions> = LoadSelf<TState, TCommandInputSchemas, TCommandOutputSchemas, TQueries> & {
    setState(mutate: (state: TState) => void): void;
};
type ServiceSummary = {
    id: ServiceId;
    description?: string;
    queryNames: string[];
    commandNames: string[];
};
type OperationDescriptor = {
    name: string;
    description?: string;
    input: SchemaDescriptor;
    output: SchemaDescriptor;
    /** Present when the query declares `staticPath` at definition time. */
    staticPath?: true;
};
type ServiceDescriptor = {
    id: ServiceId;
    description?: string;
    queries: Record<string, OperationDescriptor>;
    commands: Record<string, OperationDescriptor>;
};
/** Context passed to query handlers. */
type QueryCtx<TState, TQueries extends AnyQueryFunctions = AnyQueryFunctions> = {
    self: QuerySelf<TState, TQueries>;
    getService: ServiceRegistryApi['getService'];
};
/** Context passed to `load` functions and static-input enumerators. */
type LoadCtx<TState, TCommandInputSchemas extends OperationInputSchemas = OperationInputSchemas, TCommandOutputSchemas extends MatchingOutputSchemas<TCommandInputSchemas> = MatchingOutputSchemas<TCommandInputSchemas>, TQueries extends AnyQueryFunctions = AnyQueryFunctions> = {
    self: LoadSelf<TState, TCommandInputSchemas, TCommandOutputSchemas, TQueries>;
    getService: ServiceRegistryApi['getService'];
};
/** Static input enumerator stored on registered definitions; always receives load context. */
type RegisteredStaticInputs<TState> = BivariantCallback<[
    ctx: LoadCtx<TState>
], unknown[] | Promise<unknown[]>>;
/** Context passed to command handlers. */
type CommandCtx<TState, TCommandInputSchemas extends OperationInputSchemas = OperationInputSchemas, TCommandOutputSchemas extends MatchingOutputSchemas<TCommandInputSchemas> = MatchingOutputSchemas<TCommandInputSchemas>, TQueries extends AnyQueryFunctions = AnyQueryFunctions> = {
    self: CommandSelf<TState, TCommandInputSchemas, TCommandOutputSchemas, TQueries>;
    getService: ServiceRegistryApi['getService'];
};
/**
 * Declarative definition for one query.
 *
 * Queries validate caller input synchronously, run a synchronous read-only handler, and validate
 * the resolved output. The optional `load` hook is fired by subscriptions (reactively) and by
 * `.loaded()` callers (drained to completion), deduped per `(service, query, input)` while one is
 * already in flight — a bare `.get()` read never fires it.
 *
 * Queries that participate in static JSON generation declare `staticPath` at definition time.
 * `staticInputs` may also be declared here when the input list has no runtime dependencies; inputs
 * that need registry or story-index context belong in server registration instead.
 */
type QueryDefinition<TState, TInputSchema extends AnySchema, TOutputSchema extends AnySchema, TCommandInputSchemas extends OperationInputSchemas = OperationInputSchemas, TCommandOutputSchemas extends MatchingOutputSchemas<TCommandInputSchemas> = MatchingOutputSchemas<TCommandInputSchemas>, TQueries extends AnyQueryFunctions = AnyQueryFunctions> = {
    description?: string;
    /**
     * When true, hides this query from `describeService()` output. Defaults to false. Does not disable
     * the query at runtime — callers with a service handle can still invoke it.
     */
    internal?: boolean;
    input: TInputSchema;
    output: TOutputSchema;
    /** Logical path for the serialized state snapshot, relative to this service's output folder. */
    staticPath?: BivariantCallback<[input: InferSchemaOutput<TInputSchema>], string>;
    /** Dependency-free static build inputs declared alongside the public contract. */
    staticInputs?: BivariantCallback<[
    ], InferSchemaInput<TInputSchema>[] | Promise<InferSchemaInput<TInputSchema>[]>>;
    handler?: BivariantCallback<[
        input: InferSchemaOutput<TInputSchema>,
        ctx: QueryCtx<TState, TQueries>
    ], InferSchemaInput<TOutputSchema>>;
    load?: BivariantCallback<[
        input: InferSchemaOutput<TInputSchema>,
        ctx: LoadCtx<TState, TCommandInputSchemas, TCommandOutputSchemas, TQueries>
    ], void | Promise<void>>;
};
/**
 * Declarative definition for one command.
 *
 * Commands validate caller input, run against a mutable context, and validate the resolved output.
 */
type CommandDefinition<TState, TInputSchema extends AnySchema, TOutputSchema extends AnySchema, TCommandInputSchemas extends OperationInputSchemas = OperationInputSchemas, TCommandOutputSchemas extends MatchingOutputSchemas<TCommandInputSchemas> = MatchingOutputSchemas<TCommandInputSchemas>, TQueries extends AnyQueryFunctions = AnyQueryFunctions> = {
    description?: string;
    /**
     * When true, hides this command from `describeService()` output. Defaults to false. Does not
     * disable the command at runtime — callers with a service handle can still invoke it.
     */
    internal?: boolean;
    input: TInputSchema;
    output: TOutputSchema;
    handler?: BivariantCallback<[
        input: InferSchemaOutput<TInputSchema>,
        ctx: CommandCtx<TState, TCommandInputSchemas, TCommandOutputSchemas, TQueries>
    ], InferSchemaInput<TOutputSchema> | Promise<InferSchemaInput<TOutputSchema>>>;
};
/** Internal structural constraint used to store any query definition in a record. */
type AnyQueryDefinition<TState> = {
    description?: string;
    internal?: boolean;
    input: AnySchema;
    output: AnySchema;
    staticPath?: BivariantCallback<[input: unknown], string>;
    staticInputs?: RegisteredStaticInputs<TState>;
    handler?: BivariantCallback<[input: unknown, ctx: QueryCtx<TState>], unknown>;
    load?: BivariantCallback<[input: unknown, ctx: LoadCtx<TState>], void | Promise<void>>;
};
/** Internal structural constraint used to store any command definition in a record. */
type AnyCommandDefinition<TState> = {
    description?: string;
    internal?: boolean;
    input: AnySchema;
    output: AnySchema;
    handler?: BivariantCallback<[
        input: unknown,
        ctx: CommandCtx<TState>
    ], unknown | Promise<unknown>>;
};
/** Named query map attached to a service definition. */
type Queries<TState> = Record<string, AnyQueryDefinition<TState>>;
/** Named command map attached to a service definition. */
type Commands<TState> = Record<string, AnyCommandDefinition<TState>>;
/** Top-level description of a service: identity, initial state, queries, and commands. */
type ServiceDefinition<TState, TQueries extends Queries<TState>, TCommands extends Commands<TState>, TId extends ServiceId = ServiceId> = {
    id: TId;
    description?: string;
    /**
     * When true, hides this service from `listServices()` output. Defaults to false. Does not disable
     * the service at runtime — callers can still resolve it through `getService()`.
     */
    internal?: boolean;
    /**
     * Initial state for the service. Must be a plain object (not a primitive, `null`, or array) — see
     * {@link ServiceState} for why. The authoring boundary (`defineService`) enforces this; the runtime
     * type stays `TState` so already-constructed definitions flow through the registry unchanged.
     */
    initialState: TState;
    queries: TQueries;
    commands: TCommands;
};
/** Structural constraint for any service definition stored in the registry. */
type AnyServiceDefinition = ServiceDefinition<unknown, Queries<unknown>, Commands<unknown>>;
/** Runtime service instance derived from a `ServiceDefinition`. */
type ServiceInstance<TState, TQueries extends Queries<TState>, TCommands extends Commands<TState>> = {
    queries: {
        [TKey in keyof TQueries]: TQueries[TKey] extends {
            input: infer TInputSchema extends AnySchema;
            output: infer TOutputSchema extends AnySchema;
        } ? Query<InferSchemaInput<TInputSchema>, InferSchemaOutput<TOutputSchema>> : never;
    };
    commands: {
        [TKey in keyof TCommands]: TCommands[TKey] extends {
            input: infer TInputSchema extends AnySchema;
            output: infer TOutputSchema extends AnySchema;
        } ? (input: InferSchemaInput<TInputSchema>) => Promise<InferSchemaOutput<TOutputSchema>> : never;
    };
};
/** Runtime instance type recovered from one authored service definition. */
type ServiceInstanceOf<TDefinition extends AnyServiceDefinition> = TDefinition extends ServiceDefinition<infer TState, infer TQueries, infer TCommands> ? ServiceInstance<TState, TQueries, TCommands> : never;
interface ServiceRegistryApi {
    listServices(): Promise<ServiceSummary[]>;
    describeService(serviceId: ServiceId): Promise<ServiceDescriptor>;
    getService<TInstance = RuntimeService>(serviceId: ServiceId): TInstance;
}
type RuntimeService = ServiceInstance<unknown, Queries<unknown>, Commands<unknown>> & ServiceRegistryApi;
type ServiceQueryRegistration<TState> = {
    /** Static build inputs that may depend on registry or other server context. */
    staticInputs?: RegisteredStaticInputs<TState>;
};
type ServiceCommandRegistration<TState, TCommand extends AnyCommandDefinition<TState>> = Pick<TCommand, 'handler'>;
type ServiceRegistrationOptions<TState, TQueries extends Queries<TState>, TCommands extends Commands<TState>> = {
    queries?: {
        [TKey in keyof TQueries]?: ServiceQueryRegistration<TState>;
    };
    commands?: {
        [TKey in keyof TCommands]?: ServiceCommandRegistration<TState, TCommands[TKey]>;
    };
};

//#endregion
//#region src/methods/fallback/fallback.d.ts
/**
* Fallback type.
*/
type Fallback<TSchema extends BaseSchema<unknown, unknown, BaseIssue<unknown>>> = MaybeDeepReadonly<InferOutput<TSchema>> | ((dataset?: OutputDataset<InferOutput<TSchema>, InferIssue<TSchema>>, config?: Config<InferIssue<TSchema>>) => MaybeDeepReadonly<InferOutput<TSchema>>);
/**
* Schema with fallback type.
*/
type SchemaWithFallback<TSchema extends BaseSchema<unknown, unknown, BaseIssue<unknown>>, TFallback$1 extends Fallback<TSchema>> = TSchema & {
  /**
  * The fallback value.
  */
  readonly fallback: TFallback$1;
};
//#endregion
//#region src/methods/fallback/fallbackAsync.d.ts
/**
* Fallback async type.
*/
type FallbackAsync<TSchema extends BaseSchema<unknown, unknown, BaseIssue<unknown>> | BaseSchemaAsync<unknown, unknown, BaseIssue<unknown>>> = MaybeDeepReadonly<InferOutput<TSchema>> | ((dataset?: OutputDataset<InferOutput<TSchema>, InferIssue<TSchema>>, config?: Config<InferIssue<TSchema>>) => MaybePromise<MaybeDeepReadonly<InferOutput<TSchema>>>);
/**
* Schema with fallback async type.
*/
type SchemaWithFallbackAsync<TSchema extends BaseSchema<unknown, unknown, BaseIssue<unknown>> | BaseSchemaAsync<unknown, unknown, BaseIssue<unknown>>, TFallback$1 extends FallbackAsync<TSchema>> = Omit<TSchema, "async" | "~standard" | "~run"> & {
  /**
  * The fallback value.
  */
  readonly fallback: TFallback$1;
  /**
  * Whether it's async.
  */
  readonly async: true;
  /**
  * The Standard Schema properties.
  *
  * @internal
  */
  readonly "~standard": StandardProps<InferInput<TSchema>, InferOutput<TSchema>>;
  /**
  * Parses unknown input values.
  *
  * @param dataset The input dataset.
  * @param config The configuration.
  *
  * @returns The output dataset.
  *
  * @internal
  */
  readonly "~run": (dataset: UnknownDataset, config: Config<BaseIssue<unknown>>) => Promise<OutputDataset<InferOutput<TSchema>, InferIssue<TSchema>>>;
};
//#endregion
//#region src/types/metadata.d.ts
/**
* Base metadata interface.
*/
interface BaseMetadata<TInput$1> {
  /**
  * The object kind.
  */
  readonly kind: "metadata";
  /**
  * The metadata type.
  */
  readonly type: string;
  /**
  * The metadata reference.
  */
  readonly reference: (...args: any[]) => BaseMetadata<any>;
  /**
  * The input, output and issue type.
  *
  * @internal
  */
  readonly "~types"?: {
    readonly input: TInput$1;
    readonly output: TInput$1;
    readonly issue: never;
  } | undefined;
}
//#endregion
//#region src/types/dataset.d.ts
/**
* Unknown dataset interface.
*/
interface UnknownDataset {
  /**
  * Whether is's typed.
  */
  typed?: false;
  /**
  * The dataset value.
  */
  value: unknown;
  /**
  * The dataset issues.
  */
  issues?: undefined;
}
/**
* Success dataset interface.
*/
interface SuccessDataset<TValue$1> {
  /**
  * Whether is's typed.
  */
  typed: true;
  /**
  * The dataset value.
  */
  value: TValue$1;
  /**
  * The dataset issues.
  */
  issues?: undefined;
}
/**
* Partial dataset interface.
*/
interface PartialDataset<TValue$1, TIssue extends BaseIssue<unknown>> {
  /**
  * Whether is's typed.
  */
  typed: true;
  /**
  * The dataset value.
  */
  value: TValue$1;
  /**
  * The dataset issues.
  */
  issues: [TIssue, ...TIssue[]];
}
/**
* Failure dataset interface.
*/
interface FailureDataset<TIssue extends BaseIssue<unknown>> {
  /**
  * Whether is's typed.
  */
  typed: false;
  /**
  * The dataset value.
  */
  value: unknown;
  /**
  * The dataset issues.
  */
  issues: [TIssue, ...TIssue[]];
}
/**
* Output dataset type.
*/
type OutputDataset<TValue$1, TIssue extends BaseIssue<unknown>> = SuccessDataset<TValue$1> | PartialDataset<TValue$1, TIssue> | FailureDataset<TIssue>;
//#endregion
//#region src/types/standard.d.ts
/**
* The Standard Schema properties interface.
*/
interface StandardProps<TInput$1, TOutput$1> {
  /**
  * The version number of the standard.
  */
  readonly version: 1;
  /**
  * The vendor name of the schema library.
  */
  readonly vendor: "valibot";
  /**
  * Validates unknown input values.
  */
  readonly validate: (value: unknown) => StandardResult<TOutput$1> | Promise<StandardResult<TOutput$1>>;
  /**
  * Inferred types associated with the schema.
  */
  readonly types?: StandardTypes<TInput$1, TOutput$1> | undefined;
}
/**
* The result interface of the validate function.
*/
type StandardResult<TOutput$1> = StandardSuccessResult<TOutput$1> | StandardFailureResult;
/**
* The result interface if validation succeeds.
*/
interface StandardSuccessResult<TOutput$1> {
  /**
  * The typed output value.
  */
  readonly value: TOutput$1;
  /**
  * The non-existent issues.
  */
  readonly issues?: undefined;
}
/**
* The result interface if validation fails.
*/
interface StandardFailureResult {
  /**
  * The issues of failed validation.
  */
  readonly issues: readonly StandardIssue[];
}
/**
* The issue interface of the failure output.
*/
interface StandardIssue {
  /**
  * The error message of the issue.
  */
  readonly message: string;
  /**
  * The path of the issue, if any.
  */
  readonly path?: readonly (PropertyKey | StandardPathItem)[] | undefined;
}
/**
* The path item interface of the issue.
*/
interface StandardPathItem {
  /**
  * The key of the path item.
  */
  readonly key: PropertyKey;
}
/**
* The Standard Schema types interface.
*/
interface StandardTypes<TInput$1, TOutput$1> {
  /**
  * The input type of the schema.
  */
  readonly input: TInput$1;
  /**
  * The output type of the schema.
  */
  readonly output: TOutput$1;
}
//#endregion
//#region src/types/schema.d.ts
/**
* Base schema interface.
*/
interface BaseSchema<TInput$1, TOutput$1, TIssue extends BaseIssue<unknown>> {
  /**
  * The object kind.
  */
  readonly kind: "schema";
  /**
  * The schema type.
  */
  readonly type: string;
  /**
  * The schema reference.
  */
  readonly reference: (...args: any[]) => BaseSchema<unknown, unknown, BaseIssue<unknown>>;
  /**
  * The expected property.
  */
  readonly expects: string;
  /**
  * Whether it's async.
  */
  readonly async: false;
  /**
  * The Standard Schema properties.
  *
  * @internal
  */
  readonly "~standard": StandardProps<TInput$1, TOutput$1>;
  /**
  * Parses unknown input values.
  *
  * @param dataset The input dataset.
  * @param config The configuration.
  *
  * @returns The output dataset.
  *
  * @internal
  */
  readonly "~run": (dataset: UnknownDataset, config: Config<BaseIssue<unknown>>) => OutputDataset<TOutput$1, TIssue>;
  /**
  * The input, output and issue type.
  *
  * @internal
  */
  readonly "~types"?: {
    readonly input: TInput$1;
    readonly output: TOutput$1;
    readonly issue: TIssue;
  } | undefined;
}
/**
* Base schema async interface.
*/
interface BaseSchemaAsync<TInput$1, TOutput$1, TIssue extends BaseIssue<unknown>> extends Omit<BaseSchema<TInput$1, TOutput$1, TIssue>, "reference" | "async" | "~run"> {
  /**
  * The schema reference.
  */
  readonly reference: (...args: any[]) => BaseSchema<unknown, unknown, BaseIssue<unknown>> | BaseSchemaAsync<unknown, unknown, BaseIssue<unknown>>;
  /**
  * Whether it's async.
  */
  readonly async: true;
  /**
  * Parses unknown input values.
  *
  * @param dataset The input dataset.
  * @param config The configuration.
  *
  * @returns The output dataset.
  *
  * @internal
  */
  readonly "~run": (dataset: UnknownDataset, config: Config<BaseIssue<unknown>>) => Promise<OutputDataset<TOutput$1, TIssue>>;
}
//#endregion
//#region src/types/transformation.d.ts
/**
* Base transformation interface.
*/
interface BaseTransformation<TInput$1, TOutput$1, TIssue extends BaseIssue<unknown>> {
  /**
  * The object kind.
  */
  readonly kind: "transformation";
  /**
  * The transformation type.
  */
  readonly type: string;
  /**
  * The transformation reference.
  */
  readonly reference: (...args: any[]) => BaseTransformation<any, any, BaseIssue<unknown>>;
  /**
  * Whether it's async.
  */
  readonly async: false;
  /**
  * Transforms known input values.
  *
  * @param dataset The input dataset.
  * @param config The configuration.
  *
  * @returns The output dataset.
  *
  * @internal
  */
  readonly "~run": (dataset: SuccessDataset<TInput$1>, config: Config<BaseIssue<unknown>>) => OutputDataset<TOutput$1, BaseIssue<unknown> | TIssue>;
  /**
  * The input, output and issue type.
  *
  * @internal
  */
  readonly "~types"?: {
    readonly input: TInput$1;
    readonly output: TOutput$1;
    readonly issue: TIssue;
  } | undefined;
}
/**
* Base transformation async interface.
*/
interface BaseTransformationAsync<TInput$1, TOutput$1, TIssue extends BaseIssue<unknown>> extends Omit<BaseTransformation<TInput$1, TOutput$1, TIssue>, "reference" | "async" | "~run"> {
  /**
  * The transformation reference.
  */
  readonly reference: (...args: any[]) => BaseTransformation<any, any, BaseIssue<unknown>> | BaseTransformationAsync<any, any, BaseIssue<unknown>>;
  /**
  * Whether it's async.
  */
  readonly async: true;
  /**
  * Transforms known input values.
  *
  * @param dataset The input dataset.
  * @param config The configuration.
  *
  * @returns The output dataset.
  *
  * @internal
  */
  readonly "~run": (dataset: SuccessDataset<TInput$1>, config: Config<BaseIssue<unknown>>) => Promise<OutputDataset<TOutput$1, BaseIssue<unknown> | TIssue>>;
}
//#endregion
//#region src/types/validation.d.ts
/**
* Base validation interface.
*/
interface BaseValidation<TInput$1, TOutput$1, TIssue extends BaseIssue<unknown>> {
  /**
  * The object kind.
  */
  readonly kind: "validation";
  /**
  * The validation type.
  */
  readonly type: string;
  /**
  * The validation reference.
  */
  readonly reference: (...args: any[]) => BaseValidation<any, any, BaseIssue<unknown>>;
  /**
  * The expected property.
  */
  readonly expects: string | null;
  /**
  * Whether it's async.
  */
  readonly async: false;
  /**
  * Validates known input values.
  *
  * @param dataset The input dataset.
  * @param config The configuration.
  *
  * @returns The output dataset.
  *
  * @internal
  */
  readonly "~run": (dataset: OutputDataset<TInput$1, BaseIssue<unknown>>, config: Config<BaseIssue<unknown>>) => OutputDataset<TOutput$1, BaseIssue<unknown> | TIssue>;
  /**
  * The input, output and issue type.
  *
  * @internal
  */
  readonly "~types"?: {
    readonly input: TInput$1;
    readonly output: TOutput$1;
    readonly issue: TIssue;
  } | undefined;
}
/**
* Base validation async interface.
*/
interface BaseValidationAsync<TInput$1, TOutput$1, TIssue extends BaseIssue<unknown>> extends Omit<BaseValidation<TInput$1, TOutput$1, TIssue>, "reference" | "async" | "~run"> {
  /**
  * The validation reference.
  */
  readonly reference: (...args: any[]) => BaseValidation<any, any, BaseIssue<unknown>> | BaseValidationAsync<any, any, BaseIssue<unknown>>;
  /**
  * Whether it's async.
  */
  readonly async: true;
  /**
  * Validates known input values.
  *
  * @param dataset The input dataset.
  * @param config The configuration.
  *
  * @returns The output dataset.
  *
  * @internal
  */
  readonly "~run": (dataset: OutputDataset<TInput$1, BaseIssue<unknown>>, config: Config<BaseIssue<unknown>>) => Promise<OutputDataset<TOutput$1, BaseIssue<unknown> | TIssue>>;
}
//#endregion
//#region src/types/infer.d.ts
/**
* Infer input type.
*/
type InferInput<TItem$1 extends BaseSchema<unknown, unknown, BaseIssue<unknown>> | BaseSchemaAsync<unknown, unknown, BaseIssue<unknown>> | BaseValidation<any, unknown, BaseIssue<unknown>> | BaseValidationAsync<any, unknown, BaseIssue<unknown>> | BaseTransformation<any, unknown, BaseIssue<unknown>> | BaseTransformationAsync<any, unknown, BaseIssue<unknown>> | BaseMetadata<any>> = NonNullable<TItem$1["~types"]>["input"];
/**
* Infer output type.
*/
type InferOutput<TItem$1 extends BaseSchema<unknown, unknown, BaseIssue<unknown>> | BaseSchemaAsync<unknown, unknown, BaseIssue<unknown>> | BaseValidation<any, unknown, BaseIssue<unknown>> | BaseValidationAsync<any, unknown, BaseIssue<unknown>> | BaseTransformation<any, unknown, BaseIssue<unknown>> | BaseTransformationAsync<any, unknown, BaseIssue<unknown>> | BaseMetadata<any>> = NonNullable<TItem$1["~types"]>["output"];
/**
* Infer issue type.
*/
type InferIssue<TItem$1 extends BaseSchema<unknown, unknown, BaseIssue<unknown>> | BaseSchemaAsync<unknown, unknown, BaseIssue<unknown>> | BaseValidation<any, unknown, BaseIssue<unknown>> | BaseValidationAsync<any, unknown, BaseIssue<unknown>> | BaseTransformation<any, unknown, BaseIssue<unknown>> | BaseTransformationAsync<any, unknown, BaseIssue<unknown>> | BaseMetadata<any>> = NonNullable<TItem$1["~types"]>["issue"];
/**
* Constructs a type that is maybe readonly.
*/
type MaybeReadonly<TValue$1> = TValue$1 | Readonly<TValue$1>;
/**
* Constructs a type that is deeply readonly.
*/
type DeepReadonly<TValue$1> = TValue$1 extends Record<string, unknown> | readonly unknown[] ? { readonly [TKey in keyof TValue$1]: DeepReadonly<TValue$1[TKey]> } : TValue$1;
/**
* Constructs a type that is maybe deeply readonly.
*/
type MaybeDeepReadonly<TValue$1> = TValue$1 | DeepReadonly<TValue$1>;
/**
* Constructs a type that is maybe a promise.
*/
type MaybePromise<TValue$1> = TValue$1 | Promise<TValue$1>;
/**
* Prettifies a type for better readability.
*
* Hint: This type has no effect and is only used so that TypeScript displays
* the final type in the preview instead of the utility types used.
*/
type Prettify<TObject> = { [TKey in keyof TObject]: TObject[TKey] } & {};
/**
* Marks specific keys as optional.
*/
type MarkOptional<TObject, TKeys extends keyof TObject> = { [TKey in keyof TObject]?: unknown } & Omit<TObject, TKeys> & Partial<Pick<TObject, TKeys>>;
//#endregion
//#region src/types/other.d.ts
/**
* Error message type.
*/
type ErrorMessage<TIssue extends BaseIssue<unknown>> = ((issue: TIssue) => string) | string;
/**
* Default type.
*/
type Default<TWrapped$1 extends BaseSchema<unknown, unknown, BaseIssue<unknown>>, TInput$1 extends null | undefined> = MaybeDeepReadonly<InferInput<TWrapped$1> | TInput$1> | ((dataset?: UnknownDataset, config?: Config<InferIssue<TWrapped$1>>) => MaybeDeepReadonly<InferInput<TWrapped$1> | TInput$1>) | undefined;
/**
* Default async type.
*/
type DefaultAsync<TWrapped$1 extends BaseSchema<unknown, unknown, BaseIssue<unknown>> | BaseSchemaAsync<unknown, unknown, BaseIssue<unknown>>, TInput$1 extends null | undefined> = MaybeDeepReadonly<InferInput<TWrapped$1> | TInput$1> | ((dataset?: UnknownDataset, config?: Config<InferIssue<TWrapped$1>>) => MaybePromise<MaybeDeepReadonly<InferInput<TWrapped$1> | TInput$1>>) | undefined;
/**
* Default value type.
*/
type DefaultValue<TDefault extends Default<BaseSchema<unknown, unknown, BaseIssue<unknown>>, null | undefined> | DefaultAsync<BaseSchema<unknown, unknown, BaseIssue<unknown>> | BaseSchemaAsync<unknown, unknown, BaseIssue<unknown>>, null | undefined>> = TDefault extends DefaultAsync<infer TWrapped extends BaseSchema<unknown, unknown, BaseIssue<unknown>> | BaseSchemaAsync<unknown, unknown, BaseIssue<unknown>>, infer TInput> ? TDefault extends ((dataset?: UnknownDataset, config?: Config<InferIssue<TWrapped>>) => MaybePromise<MaybeDeepReadonly<InferInput<TWrapped> | TInput>>) ? Awaited<ReturnType<TDefault>> : TDefault : never;
//#endregion
//#region src/types/object.d.ts
/**
* Optional entry schema type.
*/
type OptionalEntrySchema = ExactOptionalSchema<BaseSchema<unknown, unknown, BaseIssue<unknown>>, unknown> | NullishSchema<BaseSchema<unknown, unknown, BaseIssue<unknown>>, unknown> | OptionalSchema<BaseSchema<unknown, unknown, BaseIssue<unknown>>, unknown>;
/**
* Optional entry schema async type.
*/
type OptionalEntrySchemaAsync = ExactOptionalSchemaAsync<BaseSchema<unknown, unknown, BaseIssue<unknown>> | BaseSchemaAsync<unknown, unknown, BaseIssue<unknown>>, unknown> | NullishSchemaAsync<BaseSchema<unknown, unknown, BaseIssue<unknown>> | BaseSchemaAsync<unknown, unknown, BaseIssue<unknown>>, unknown> | OptionalSchemaAsync<BaseSchema<unknown, unknown, BaseIssue<unknown>> | BaseSchemaAsync<unknown, unknown, BaseIssue<unknown>>, unknown>;
/**
* Object entries interface.
*/
interface ObjectEntries {
  [key: string]: BaseSchema<unknown, unknown, BaseIssue<unknown>> | SchemaWithFallback<BaseSchema<unknown, unknown, BaseIssue<unknown>>, unknown> | OptionalEntrySchema;
}
/**
* Object entries async interface.
*/
interface ObjectEntriesAsync {
  [key: string]: BaseSchema<unknown, unknown, BaseIssue<unknown>> | BaseSchemaAsync<unknown, unknown, BaseIssue<unknown>> | SchemaWithFallback<BaseSchema<unknown, unknown, BaseIssue<unknown>>, unknown> | SchemaWithFallbackAsync<BaseSchema<unknown, unknown, BaseIssue<unknown>> | BaseSchemaAsync<unknown, unknown, BaseIssue<unknown>>, unknown> | OptionalEntrySchema | OptionalEntrySchemaAsync;
}
/**
* Infer entries input type.
*/
type InferEntriesInput<TEntries$1 extends ObjectEntries | ObjectEntriesAsync> = { -readonly [TKey in keyof TEntries$1]: InferInput<TEntries$1[TKey]> };
/**
* Infer entries output type.
*/
type InferEntriesOutput<TEntries$1 extends ObjectEntries | ObjectEntriesAsync> = { -readonly [TKey in keyof TEntries$1]: InferOutput<TEntries$1[TKey]> };
/**
* Optional input keys type.
*/
type OptionalInputKeys<TEntries$1 extends ObjectEntries | ObjectEntriesAsync> = { [TKey in keyof TEntries$1]: TEntries$1[TKey] extends OptionalEntrySchema | OptionalEntrySchemaAsync ? TKey : never }[keyof TEntries$1];
/**
* Optional output keys type.
*/
type OptionalOutputKeys<TEntries$1 extends ObjectEntries | ObjectEntriesAsync> = { [TKey in keyof TEntries$1]: TEntries$1[TKey] extends OptionalEntrySchema | OptionalEntrySchemaAsync ? undefined extends TEntries$1[TKey]["default"] ? TKey : never : never }[keyof TEntries$1];
/**
* Input with question marks type.
*/
type InputWithQuestionMarks<TEntries$1 extends ObjectEntries | ObjectEntriesAsync, TObject extends InferEntriesInput<TEntries$1>> = MarkOptional<TObject, OptionalInputKeys<TEntries$1>>;
/**
* Output with question marks type.
*/
type OutputWithQuestionMarks<TEntries$1 extends ObjectEntries | ObjectEntriesAsync, TObject extends InferEntriesOutput<TEntries$1>> = MarkOptional<TObject, OptionalOutputKeys<TEntries$1>>;
/**
* Readonly output keys type.
*/
type ReadonlyOutputKeys<TEntries$1 extends ObjectEntries | ObjectEntriesAsync> = { [TKey in keyof TEntries$1]: TEntries$1[TKey] extends {
  readonly pipe: readonly unknown[];
} ? ReadonlyAction<any> extends TEntries$1[TKey]["pipe"][number] ? TKey : never : never }[keyof TEntries$1];
/**
* Output with readonly type.
*/
type OutputWithReadonly<TEntries$1 extends ObjectEntries | ObjectEntriesAsync, TObject extends OutputWithQuestionMarks<TEntries$1, InferEntriesOutput<TEntries$1>>> = ReadonlyOutputKeys<TEntries$1> extends never ? TObject : Readonly<TObject> & Pick<TObject, Exclude<keyof TObject, ReadonlyOutputKeys<TEntries$1>>>;
/**
* Infer object input type.
*/
type InferObjectInput<TEntries$1 extends ObjectEntries | ObjectEntriesAsync> = Prettify<InputWithQuestionMarks<TEntries$1, InferEntriesInput<TEntries$1>>>;
/**
* Infer object output type.
*/
type InferObjectOutput<TEntries$1 extends ObjectEntries | ObjectEntriesAsync> = Prettify<OutputWithReadonly<TEntries$1, OutputWithQuestionMarks<TEntries$1, InferEntriesOutput<TEntries$1>>>>;
/**
* Infer object issue type.
*/
type InferObjectIssue<TEntries$1 extends ObjectEntries | ObjectEntriesAsync> = InferIssue<TEntries$1[keyof TEntries$1]>;
//#endregion
//#region src/types/issue.d.ts
/**
* Array path item interface.
*/
interface ArrayPathItem {
  /**
  * The path item type.
  */
  readonly type: "array";
  /**
  * The path item origin.
  */
  readonly origin: "value";
  /**
  * The path item input.
  */
  readonly input: MaybeReadonly<unknown[]>;
  /**
  * The path item key.
  */
  readonly key: number;
  /**
  * The path item value.
  */
  readonly value: unknown;
}
/**
* Map path item interface.
*/
interface MapPathItem {
  /**
  * The path item type.
  */
  readonly type: "map";
  /**
  * The path item origin.
  */
  readonly origin: "key" | "value";
  /**
  * The path item input.
  */
  readonly input: Map<unknown, unknown>;
  /**
  * The path item key.
  */
  readonly key: unknown;
  /**
  * The path item value.
  */
  readonly value: unknown;
}
/**
* Object path item interface.
*/
interface ObjectPathItem {
  /**
  * The path item type.
  */
  readonly type: "object";
  /**
  * The path item origin.
  */
  readonly origin: "key" | "value";
  /**
  * The path item input.
  */
  readonly input: Record<string, unknown>;
  /**
  * The path item key.
  */
  readonly key: string;
  /**
  * The path item value.
  */
  readonly value: unknown;
}
/**
* Set path item interface.
*/
interface SetPathItem {
  /**
  * The path item type.
  */
  readonly type: "set";
  /**
  * The path item origin.
  */
  readonly origin: "value";
  /**
  * The path item input.
  */
  readonly input: Set<unknown>;
  /**
  * The path item key.
  */
  readonly key: null;
  /**
  * The path item key.
  */
  readonly value: unknown;
}
/**
* Unknown path item interface.
*/
interface UnknownPathItem {
  /**
  * The path item type.
  */
  readonly type: "unknown";
  /**
  * The path item origin.
  */
  readonly origin: "key" | "value";
  /**
  * The path item input.
  */
  readonly input: unknown;
  /**
  * The path item key.
  */
  readonly key: unknown;
  /**
  * The path item value.
  */
  readonly value: unknown;
}
/**
* Issue path item type.
*/
type IssuePathItem = ArrayPathItem | MapPathItem | ObjectPathItem | SetPathItem | UnknownPathItem;
/**
* Base issue interface.
*/
interface BaseIssue<TInput$1> extends Config<BaseIssue<TInput$1>> {
  /**
  * The issue kind.
  */
  readonly kind: "schema" | "validation" | "transformation";
  /**
  * The issue type.
  */
  readonly type: string;
  /**
  * The raw input data.
  */
  readonly input: TInput$1;
  /**
  * The expected property.
  */
  readonly expected: string | null;
  /**
  * The received property.
  */
  readonly received: string;
  /**
  * The error message.
  */
  readonly message: string;
  /**
  * The input requirement.
  */
  readonly requirement?: unknown | undefined;
  /**
  * The issue path.
  */
  readonly path?: [IssuePathItem, ...IssuePathItem[]] | undefined;
  /**
  * The sub issues.
  */
  readonly issues?: [BaseIssue<TInput$1>, ...BaseIssue<TInput$1>[]] | undefined;
}
//#endregion
//#region src/types/config.d.ts
/**
* Config interface.
*/
interface Config<TIssue extends BaseIssue<unknown>> {
  /**
  * The selected language.
  */
  readonly lang?: string | undefined;
  /**
  * The error message.
  */
  readonly message?: ErrorMessage<TIssue> | undefined;
  /**
  * Whether it should be aborted early.
  */
  readonly abortEarly?: boolean | undefined;
  /**
  * Whether a pipe should be aborted early.
  */
  readonly abortPipeEarly?: boolean | undefined;
}
//#endregion
//#region src/schemas/array/types.d.ts
/**
* Array issue interface.
*/
interface ArrayIssue extends BaseIssue<unknown> {
  /**
  * The issue kind.
  */
  readonly kind: "schema";
  /**
  * The issue type.
  */
  readonly type: "array";
  /**
  * The expected property.
  */
  readonly expected: "Array";
}
//#endregion
//#region src/schemas/array/array.d.ts
/**
* Array schema interface.
*/
interface ArraySchema<TItem$1 extends BaseSchema<unknown, unknown, BaseIssue<unknown>>, TMessage extends ErrorMessage<ArrayIssue> | undefined> extends BaseSchema<InferInput<TItem$1>[], InferOutput<TItem$1>[], ArrayIssue | InferIssue<TItem$1>> {
  /**
  * The schema type.
  */
  readonly type: "array";
  /**
  * The schema reference.
  */
  readonly reference: typeof array;
  /**
  * The expected property.
  */
  readonly expects: "Array";
  /**
  * The array item schema.
  */
  readonly item: TItem$1;
  /**
  * The error message.
  */
  readonly message: TMessage;
}
/**
* Creates an array schema.
*
* @param item The item schema.
*
* @returns An array schema.
*/
declare function array<const TItem$1 extends BaseSchema<unknown, unknown, BaseIssue<unknown>>>(item: TItem$1): ArraySchema<TItem$1, undefined>;
/**
* Creates an array schema.
*
* @param item The item schema.
* @param message The error message.
*
* @returns An array schema.
*/
declare function array<const TItem$1 extends BaseSchema<unknown, unknown, BaseIssue<unknown>>, const TMessage extends ErrorMessage<ArrayIssue> | undefined>(item: TItem$1, message: TMessage): ArraySchema<TItem$1, TMessage>;
//#endregion
//#region src/schemas/custom/types.d.ts
/**
* Custom issue interface.
*/
interface CustomIssue extends BaseIssue<unknown> {
  /**
  * The issue kind.
  */
  readonly kind: "schema";
  /**
  * The issue type.
  */
  readonly type: "custom";
  /**
  * The expected property.
  */
  readonly expected: "unknown";
}
//#endregion
//#region src/schemas/custom/custom.d.ts
/**
* Check type.
*/
type Check = (input: unknown) => boolean;
/**
* Custom schema interface.
*/
interface CustomSchema<TInput$1, TMessage extends ErrorMessage<CustomIssue> | undefined> extends BaseSchema<TInput$1, TInput$1, CustomIssue> {
  /**
  * The schema type.
  */
  readonly type: "custom";
  /**
  * The schema reference.
  */
  readonly reference: typeof custom;
  /**
  * The expected property.
  */
  readonly expects: "unknown";
  /**
  * The type check function.
  */
  readonly check: Check;
  /**
  * The error message.
  */
  readonly message: TMessage;
}
/**
* Creates a custom schema.
*
* @param check The type check function.
*
* @returns A custom schema.
*/
declare function custom<TInput$1>(check: Check): CustomSchema<TInput$1, undefined>;
/**
* Creates a custom schema.
*
* @param check The type check function.
* @param message The error message.
*
* @returns A custom schema.
*/
declare function custom<TInput$1, const TMessage extends ErrorMessage<CustomIssue> | undefined = ErrorMessage<CustomIssue> | undefined>(check: Check, message: TMessage): CustomSchema<TInput$1, TMessage>;
//#endregion
//#region src/schemas/exactOptional/exactOptional.d.ts
/**
* Exact optional schema interface.
*/
interface ExactOptionalSchema<TWrapped$1 extends BaseSchema<unknown, unknown, BaseIssue<unknown>>, TDefault extends Default<TWrapped$1, never>> extends BaseSchema<InferInput<TWrapped$1>, InferOutput<TWrapped$1>, InferIssue<TWrapped$1>> {
  /**
  * The schema type.
  */
  readonly type: "exact_optional";
  /**
  * The schema reference.
  */
  readonly reference: typeof exactOptional;
  /**
  * The expected property.
  */
  readonly expects: TWrapped$1["expects"];
  /**
  * The wrapped schema.
  */
  readonly wrapped: TWrapped$1;
  /**
  * The default value.
  */
  readonly default: TDefault;
}
/**
* Creates an exact optional schema.
*
* @param wrapped The wrapped schema.
*
* @returns An exact optional schema.
*/
declare function exactOptional<const TWrapped$1 extends BaseSchema<unknown, unknown, BaseIssue<unknown>>>(wrapped: TWrapped$1): ExactOptionalSchema<TWrapped$1, undefined>;
/**
* Creates an exact optional schema.
*
* @param wrapped The wrapped schema.
* @param default_ The default value.
*
* @returns An exact optional schema.
*/
declare function exactOptional<const TWrapped$1 extends BaseSchema<unknown, unknown, BaseIssue<unknown>>, const TDefault extends Default<TWrapped$1, never>>(wrapped: TWrapped$1, default_: TDefault): ExactOptionalSchema<TWrapped$1, TDefault>;
//#endregion
//#region src/schemas/exactOptional/exactOptionalAsync.d.ts
/**
* Exact optional schema async interface.
*/
interface ExactOptionalSchemaAsync<TWrapped$1 extends BaseSchema<unknown, unknown, BaseIssue<unknown>> | BaseSchemaAsync<unknown, unknown, BaseIssue<unknown>>, TDefault extends DefaultAsync<TWrapped$1, never>> extends BaseSchemaAsync<InferInput<TWrapped$1>, InferOutput<TWrapped$1>, InferIssue<TWrapped$1>> {
  /**
  * The schema type.
  */
  readonly type: "exact_optional";
  /**
  * The schema reference.
  */
  readonly reference: typeof exactOptional | typeof exactOptionalAsync;
  /**
  * The expected property.
  */
  readonly expects: TWrapped$1["expects"];
  /**
  * The wrapped schema.
  */
  readonly wrapped: TWrapped$1;
  /**
  * The default value.
  */
  readonly default: TDefault;
}
/**
* Creates an exact optional schema.
*
* @param wrapped The wrapped schema.
*
* @returns An exact optional schema.
*/
declare function exactOptionalAsync<const TWrapped$1 extends BaseSchema<unknown, unknown, BaseIssue<unknown>> | BaseSchemaAsync<unknown, unknown, BaseIssue<unknown>>>(wrapped: TWrapped$1): ExactOptionalSchemaAsync<TWrapped$1, undefined>;
/**
* Creates an exact optional schema.
*
* @param wrapped The wrapped schema.
* @param default_ The default value.
*
* @returns An exact optional schema.
*/
declare function exactOptionalAsync<const TWrapped$1 extends BaseSchema<unknown, unknown, BaseIssue<unknown>> | BaseSchemaAsync<unknown, unknown, BaseIssue<unknown>>, const TDefault extends DefaultAsync<TWrapped$1, never>>(wrapped: TWrapped$1, default_: TDefault): ExactOptionalSchemaAsync<TWrapped$1, TDefault>;
//#endregion
//#region src/schemas/looseObject/types.d.ts
/**
* Loose object issue interface.
*/
interface LooseObjectIssue extends BaseIssue<unknown> {
  /**
  * The issue kind.
  */
  readonly kind: "schema";
  /**
  * The issue type.
  */
  readonly type: "loose_object";
  /**
  * The expected property.
  */
  readonly expected: "Object" | `"${string}"`;
}
//#endregion
//#region src/schemas/looseObject/looseObject.d.ts
/**
* Loose object schema interface.
*/
interface LooseObjectSchema<TEntries$1 extends ObjectEntries, TMessage extends ErrorMessage<LooseObjectIssue> | undefined> extends BaseSchema<InferObjectInput<TEntries$1> & {
  [key: string]: unknown;
}, InferObjectOutput<TEntries$1> & {
  [key: string]: unknown;
}, LooseObjectIssue | InferObjectIssue<TEntries$1>> {
  /**
  * The schema type.
  */
  readonly type: "loose_object";
  /**
  * The schema reference.
  */
  readonly reference: typeof looseObject;
  /**
  * The expected property.
  */
  readonly expects: "Object";
  /**
  * The entries schema.
  */
  readonly entries: TEntries$1;
  /**
  * The error message.
  */
  readonly message: TMessage;
}
/**
* Creates a loose object schema.
*
* @param entries The entries schema.
*
* @returns A loose object schema.
*/
declare function looseObject<const TEntries$1 extends ObjectEntries>(entries: TEntries$1): LooseObjectSchema<TEntries$1, undefined>;
/**
* Creates a loose object schema.
*
* @param entries The entries schema.
* @param message The error message.
*
* @returns A loose object schema.
*/
declare function looseObject<const TEntries$1 extends ObjectEntries, const TMessage extends ErrorMessage<LooseObjectIssue> | undefined>(entries: TEntries$1, message: TMessage): LooseObjectSchema<TEntries$1, TMessage>;
//#endregion
//#region src/schemas/nullish/types.d.ts
/**
* Infer nullish output type.
*/
type InferNullishOutput<TWrapped$1 extends BaseSchema<unknown, unknown, BaseIssue<unknown>> | BaseSchemaAsync<unknown, unknown, BaseIssue<unknown>>, TDefault extends DefaultAsync<TWrapped$1, null | undefined>> = undefined extends TDefault ? InferOutput<TWrapped$1> | null | undefined : InferOutput<TWrapped$1> | Extract<DefaultValue<TDefault>, null | undefined>;
//#endregion
//#region src/schemas/nullish/nullish.d.ts
/**
* Nullish schema interface.
*/
interface NullishSchema<TWrapped$1 extends BaseSchema<unknown, unknown, BaseIssue<unknown>>, TDefault extends Default<TWrapped$1, null | undefined>> extends BaseSchema<InferInput<TWrapped$1> | null | undefined, InferNullishOutput<TWrapped$1, TDefault>, InferIssue<TWrapped$1>> {
  /**
  * The schema type.
  */
  readonly type: "nullish";
  /**
  * The schema reference.
  */
  readonly reference: typeof nullish;
  /**
  * The expected property.
  */
  readonly expects: `(${TWrapped$1["expects"]} | null | undefined)`;
  /**
  * The wrapped schema.
  */
  readonly wrapped: TWrapped$1;
  /**
  * The default value.
  */
  readonly default: TDefault;
}
/**
* Creates a nullish schema.
*
* @param wrapped The wrapped schema.
*
* @returns A nullish schema.
*/
declare function nullish<const TWrapped$1 extends BaseSchema<unknown, unknown, BaseIssue<unknown>>>(wrapped: TWrapped$1): NullishSchema<TWrapped$1, undefined>;
/**
* Creates a nullish schema.
*
* @param wrapped The wrapped schema.
* @param default_ The default value.
*
* @returns A nullish schema.
*/
declare function nullish<const TWrapped$1 extends BaseSchema<unknown, unknown, BaseIssue<unknown>>, const TDefault extends Default<TWrapped$1, null | undefined>>(wrapped: TWrapped$1, default_: TDefault): NullishSchema<TWrapped$1, TDefault>;
//#endregion
//#region src/schemas/nullish/nullishAsync.d.ts
/**
* Nullish schema async interface.
*/
interface NullishSchemaAsync<TWrapped$1 extends BaseSchema<unknown, unknown, BaseIssue<unknown>> | BaseSchemaAsync<unknown, unknown, BaseIssue<unknown>>, TDefault extends DefaultAsync<TWrapped$1, null | undefined>> extends BaseSchemaAsync<InferInput<TWrapped$1> | null | undefined, InferNullishOutput<TWrapped$1, TDefault>, InferIssue<TWrapped$1>> {
  /**
  * The schema type.
  */
  readonly type: "nullish";
  /**
  * The schema reference.
  */
  readonly reference: typeof nullish | typeof nullishAsync;
  /**
  * The expected property.
  */
  readonly expects: `(${TWrapped$1["expects"]} | null | undefined)`;
  /**
  * The wrapped schema.
  */
  readonly wrapped: TWrapped$1;
  /**
  * The default value.
  */
  readonly default: TDefault;
}
/**
* Creates a nullish schema.
*
* @param wrapped The wrapped schema.
*
* @returns A nullish schema.
*/
declare function nullishAsync<const TWrapped$1 extends BaseSchema<unknown, unknown, BaseIssue<unknown>> | BaseSchemaAsync<unknown, unknown, BaseIssue<unknown>>>(wrapped: TWrapped$1): NullishSchemaAsync<TWrapped$1, undefined>;
/**
* Creates a nullish schema.
*
* @param wrapped The wrapped schema.
* @param default_ The default value.
*
* @returns A nullish schema.
*/
declare function nullishAsync<const TWrapped$1 extends BaseSchema<unknown, unknown, BaseIssue<unknown>> | BaseSchemaAsync<unknown, unknown, BaseIssue<unknown>>, const TDefault extends DefaultAsync<TWrapped$1, null | undefined>>(wrapped: TWrapped$1, default_: TDefault): NullishSchemaAsync<TWrapped$1, TDefault>;
//#endregion
//#region src/schemas/object/types.d.ts
/**
* Object issue interface.
*/
interface ObjectIssue extends BaseIssue<unknown> {
  /**
  * The issue kind.
  */
  readonly kind: "schema";
  /**
  * The issue type.
  */
  readonly type: "object";
  /**
  * The expected property.
  */
  readonly expected: "Object" | `"${string}"`;
}
//#endregion
//#region src/schemas/object/object.d.ts
/**
* Object schema interface.
*/
interface ObjectSchema<TEntries$1 extends ObjectEntries, TMessage extends ErrorMessage<ObjectIssue> | undefined> extends BaseSchema<InferObjectInput<TEntries$1>, InferObjectOutput<TEntries$1>, ObjectIssue | InferObjectIssue<TEntries$1>> {
  /**
  * The schema type.
  */
  readonly type: "object";
  /**
  * The schema reference.
  */
  readonly reference: typeof object;
  /**
  * The expected property.
  */
  readonly expects: "Object";
  /**
  * The entries schema.
  */
  readonly entries: TEntries$1;
  /**
  * The error message.
  */
  readonly message: TMessage;
}
/**
* Creates an object schema.
*
* Hint: This schema removes unknown entries. The output will only include the
* entries you specify. To include unknown entries, use `looseObject`. To
* return an issue for unknown entries, use `strictObject`. To include and
* validate unknown entries, use `objectWithRest`.
*
* @param entries The entries schema.
*
* @returns An object schema.
*/
declare function object<const TEntries$1 extends ObjectEntries>(entries: TEntries$1): ObjectSchema<TEntries$1, undefined>;
/**
* Creates an object schema.
*
* Hint: This schema removes unknown entries. The output will only include the
* entries you specify. To include unknown entries, use `looseObject`. To
* return an issue for unknown entries, use `strictObject`. To include and
* validate unknown entries, use `objectWithRest`.
*
* @param entries The entries schema.
* @param message The error message.
*
* @returns An object schema.
*/
declare function object<const TEntries$1 extends ObjectEntries, const TMessage extends ErrorMessage<ObjectIssue> | undefined>(entries: TEntries$1, message: TMessage): ObjectSchema<TEntries$1, TMessage>;
//#endregion
//#region src/schemas/optional/types.d.ts
/**
* Infer optional output type.
*/
type InferOptionalOutput<TWrapped$1 extends BaseSchema<unknown, unknown, BaseIssue<unknown>> | BaseSchemaAsync<unknown, unknown, BaseIssue<unknown>>, TDefault extends DefaultAsync<TWrapped$1, undefined>> = undefined extends TDefault ? InferOutput<TWrapped$1> | undefined : InferOutput<TWrapped$1> | Extract<DefaultValue<TDefault>, undefined>;
//#endregion
//#region src/schemas/optional/optional.d.ts
/**
* Optional schema interface.
*/
interface OptionalSchema<TWrapped$1 extends BaseSchema<unknown, unknown, BaseIssue<unknown>>, TDefault extends Default<TWrapped$1, undefined>> extends BaseSchema<InferInput<TWrapped$1> | undefined, InferOptionalOutput<TWrapped$1, TDefault>, InferIssue<TWrapped$1>> {
  /**
  * The schema type.
  */
  readonly type: "optional";
  /**
  * The schema reference.
  */
  readonly reference: typeof optional;
  /**
  * The expected property.
  */
  readonly expects: `(${TWrapped$1["expects"]} | undefined)`;
  /**
  * The wrapped schema.
  */
  readonly wrapped: TWrapped$1;
  /**
  * The default value.
  */
  readonly default: TDefault;
}
/**
* Creates an optional schema.
*
* @param wrapped The wrapped schema.
*
* @returns An optional schema.
*/
declare function optional<const TWrapped$1 extends BaseSchema<unknown, unknown, BaseIssue<unknown>>>(wrapped: TWrapped$1): OptionalSchema<TWrapped$1, undefined>;
/**
* Creates an optional schema.
*
* @param wrapped The wrapped schema.
* @param default_ The default value.
*
* @returns An optional schema.
*/
declare function optional<const TWrapped$1 extends BaseSchema<unknown, unknown, BaseIssue<unknown>>, const TDefault extends Default<TWrapped$1, undefined>>(wrapped: TWrapped$1, default_: TDefault): OptionalSchema<TWrapped$1, TDefault>;
//#endregion
//#region src/schemas/optional/optionalAsync.d.ts
/**
* Optional schema async interface.
*/
interface OptionalSchemaAsync<TWrapped$1 extends BaseSchema<unknown, unknown, BaseIssue<unknown>> | BaseSchemaAsync<unknown, unknown, BaseIssue<unknown>>, TDefault extends DefaultAsync<TWrapped$1, undefined>> extends BaseSchemaAsync<InferInput<TWrapped$1> | undefined, InferOptionalOutput<TWrapped$1, TDefault>, InferIssue<TWrapped$1>> {
  /**
  * The schema type.
  */
  readonly type: "optional";
  /**
  * The schema reference.
  */
  readonly reference: typeof optional | typeof optionalAsync;
  /**
  * The expected property.
  */
  readonly expects: `(${TWrapped$1["expects"]} | undefined)`;
  /**
  * The wrapped schema.
  */
  readonly wrapped: TWrapped$1;
  /**
  * The default value.
  */
  readonly default: TDefault;
}
/**
* Creates an optional schema.
*
* @param wrapped The wrapped schema.
*
* @returns An optional schema.
*/
declare function optionalAsync<const TWrapped$1 extends BaseSchema<unknown, unknown, BaseIssue<unknown>> | BaseSchemaAsync<unknown, unknown, BaseIssue<unknown>>>(wrapped: TWrapped$1): OptionalSchemaAsync<TWrapped$1, undefined>;
/**
* Creates an optional schema.
*
* @param wrapped The wrapped schema.
* @param default_ The default value.
*
* @returns An optional schema.
*/
declare function optionalAsync<const TWrapped$1 extends BaseSchema<unknown, unknown, BaseIssue<unknown>> | BaseSchemaAsync<unknown, unknown, BaseIssue<unknown>>, const TDefault extends DefaultAsync<TWrapped$1, undefined>>(wrapped: TWrapped$1, default_: TDefault): OptionalSchemaAsync<TWrapped$1, TDefault>;
//#endregion
//#region src/schemas/record/types.d.ts
/**
* Record issue interface.
*/
interface RecordIssue extends BaseIssue<unknown> {
  /**
  * The issue kind.
  */
  readonly kind: "schema";
  /**
  * The issue type.
  */
  readonly type: "record";
  /**
  * The expected property.
  */
  readonly expected: "Object";
}
/**
* Is literal type.
*/
type IsLiteral<TKey$1 extends string | number | symbol> = string extends TKey$1 ? false : number extends TKey$1 ? false : symbol extends TKey$1 ? false : TKey$1 extends Brand<string | number | symbol> ? false : true;
/**
* Optional keys type.
*/
type OptionalKeys<TObject extends Record<string | number | symbol, unknown>> = { [TKey in keyof TObject]: IsLiteral<TKey> extends true ? TKey : never }[keyof TObject];
/**
* With question marks type.
*
* Hint: We mark an entry as optional if we detect that its key is a literal
* type. The reason for this is that it is not technically possible to detect
* missing literal keys without restricting the key schema to `string`, `enum`
* and `picklist`. However, if `enum` and `picklist` are used, it is better to
* use `object` with `entriesFromList` because it already covers the needed
* functionality. This decision also reduces the bundle size of `record`,
* because it only needs to check the entries of the input and not any missing
* keys.
*/
type WithQuestionMarks<TObject extends Record<string | number | symbol, unknown>> = MarkOptional<TObject, OptionalKeys<TObject>>;
/**
* With readonly type.
*/
type WithReadonly<TValue$1 extends BaseSchema<unknown, unknown, BaseIssue<unknown>> | BaseSchemaAsync<unknown, unknown, BaseIssue<unknown>>, TObject extends WithQuestionMarks<Record<string | number | symbol, unknown>>> = TValue$1 extends {
  readonly pipe: readonly unknown[];
} ? ReadonlyAction<any> extends TValue$1["pipe"][number] ? Readonly<TObject> : TObject : TObject;
/**
* Infer record input type.
*/
type InferRecordInput<TKey$1 extends BaseSchema<string, string | number | symbol, BaseIssue<unknown>> | BaseSchemaAsync<string, string | number | symbol, BaseIssue<unknown>>, TValue$1 extends BaseSchema<unknown, unknown, BaseIssue<unknown>> | BaseSchemaAsync<unknown, unknown, BaseIssue<unknown>>> = Prettify<WithQuestionMarks<Record<InferInput<TKey$1>, InferInput<TValue$1>>>>;
/**
* Infer record output type.
*/
type InferRecordOutput<TKey$1 extends BaseSchema<string, string | number | symbol, BaseIssue<unknown>> | BaseSchemaAsync<string, string | number | symbol, BaseIssue<unknown>>, TValue$1 extends BaseSchema<unknown, unknown, BaseIssue<unknown>> | BaseSchemaAsync<unknown, unknown, BaseIssue<unknown>>> = Prettify<WithReadonly<TValue$1, WithQuestionMarks<Record<InferOutput<TKey$1>, InferOutput<TValue$1>>>>>;
//#endregion
//#region src/schemas/record/record.d.ts
/**
* Record schema interface.
*/
interface RecordSchema<TKey$1 extends BaseSchema<string, string | number | symbol, BaseIssue<unknown>>, TValue$1 extends BaseSchema<unknown, unknown, BaseIssue<unknown>>, TMessage extends ErrorMessage<RecordIssue> | undefined> extends BaseSchema<InferRecordInput<TKey$1, TValue$1>, InferRecordOutput<TKey$1, TValue$1>, RecordIssue | InferIssue<TKey$1> | InferIssue<TValue$1>> {
  /**
  * The schema type.
  */
  readonly type: "record";
  /**
  * The schema reference.
  */
  readonly reference: typeof record;
  /**
  * The expected property.
  */
  readonly expects: "Object";
  /**
  * The record key schema.
  */
  readonly key: TKey$1;
  /**
  * The record value schema.
  */
  readonly value: TValue$1;
  /**
  * The error message.
  */
  readonly message: TMessage;
}
/**
* Creates a record schema.
*
* @param key The key schema.
* @param value The value schema.
*
* @returns A record schema.
*/
declare function record<const TKey$1 extends BaseSchema<string, string | number | symbol, BaseIssue<unknown>>, const TValue$1 extends BaseSchema<unknown, unknown, BaseIssue<unknown>>>(key: TKey$1, value: TValue$1): RecordSchema<TKey$1, TValue$1, undefined>;
/**
* Creates a record schema.
*
* @param key The key schema.
* @param value The value schema.
* @param message The error message.
*
* @returns A record schema.
*/
declare function record<const TKey$1 extends BaseSchema<string, string | number | symbol, BaseIssue<unknown>>, const TValue$1 extends BaseSchema<unknown, unknown, BaseIssue<unknown>>, const TMessage extends ErrorMessage<RecordIssue> | undefined>(key: TKey$1, value: TValue$1, message: TMessage): RecordSchema<TKey$1, TValue$1, TMessage>;
//#endregion
//#region src/schemas/string/string.d.ts
/**
* String issue interface.
*/
interface StringIssue extends BaseIssue<unknown> {
  /**
  * The issue kind.
  */
  readonly kind: "schema";
  /**
  * The issue type.
  */
  readonly type: "string";
  /**
  * The expected property.
  */
  readonly expected: "string";
}
/**
* String schema interface.
*/
interface StringSchema<TMessage extends ErrorMessage<StringIssue> | undefined> extends BaseSchema<string, string, StringIssue> {
  /**
  * The schema type.
  */
  readonly type: "string";
  /**
  * The schema reference.
  */
  readonly reference: typeof string;
  /**
  * The expected property.
  */
  readonly expects: "string";
  /**
  * The error message.
  */
  readonly message: TMessage;
}
/**
* Creates a string schema.
*
* @returns A string schema.
*/
declare function string(): StringSchema<undefined>;
/**
* Creates a string schema.
*
* @param message The error message.
*
* @returns A string schema.
*/
declare function string<const TMessage extends ErrorMessage<StringIssue> | undefined>(message: TMessage): StringSchema<TMessage>;
//#endregion
//#region src/schemas/undefined/undefined.d.ts
/**
* Undefined issue interface.
*/
interface UndefinedIssue extends BaseIssue<unknown> {
  /**
  * The issue kind.
  */
  readonly kind: "schema";
  /**
  * The issue type.
  */
  readonly type: "undefined";
  /**
  * The expected property.
  */
  readonly expected: "undefined";
}
/**
* Undefined schema interface.
*/
interface UndefinedSchema<TMessage extends ErrorMessage<UndefinedIssue> | undefined> extends BaseSchema<undefined, undefined, UndefinedIssue> {
  /**
  * The schema type.
  */
  readonly type: "undefined";
  /**
  * The schema reference.
  */
  readonly reference: typeof undefined_;
  /**
  * The expected property.
  */
  readonly expects: "undefined";
  /**
  * The error message.
  */
  readonly message: TMessage;
}
/**
* Creates an undefined schema.
*
* @returns An undefined schema.
*/
declare function undefined_(): UndefinedSchema<undefined>;
/**
* Creates an undefined schema.
*
* @param message The error message.
*
* @returns An undefined schema.
*/
declare function undefined_<const TMessage extends ErrorMessage<UndefinedIssue> | undefined>(message: TMessage): UndefinedSchema<TMessage>;
//#endregion
//#region src/schemas/void/void.d.ts
/**
* Void issue interface.
*/
interface VoidIssue extends BaseIssue<unknown> {
  /**
  * The issue kind.
  */
  readonly kind: "schema";
  /**
  * The issue type.
  */
  readonly type: "void";
  /**
  * The expected property.
  */
  readonly expected: "void";
}
/**
* Void schema interface.
*/
interface VoidSchema<TMessage extends ErrorMessage<VoidIssue> | undefined> extends BaseSchema<void, void, VoidIssue> {
  /**
  * The schema type.
  */
  readonly type: "void";
  /**
  * The schema reference.
  */
  readonly reference: typeof void_;
  /**
  * The expected property.
  */
  readonly expects: "void";
  /**
  * The error message.
  */
  readonly message: TMessage;
}
/**
* Creates a void schema.
*
* @returns A void schema.
*/
declare function void_(): VoidSchema<undefined>;
/**
* Creates a void schema.
*
* @param message The error message.
*
* @returns A void schema.
*/
declare function void_<const TMessage extends ErrorMessage<VoidIssue> | undefined>(message: TMessage): VoidSchema<TMessage>;
//#endregion
//#region src/actions/brand/brand.d.ts
/**
* Brand symbol.
*/
declare const BrandSymbol: unique symbol;
/**
* Brand name type.
*/
type BrandName = string | number | symbol;
/**
* Brand interface.
*/
interface Brand<TName extends BrandName> {
  [BrandSymbol]: { [TValue in TName]: TValue };
}
//#endregion
//#region src/actions/readonly/readonly.d.ts
/**
* Readonly output type.
*/
type ReadonlyOutput<TInput$1> = TInput$1 extends Map<infer TKey, infer TValue> ? ReadonlyMap<TKey, TValue> : TInput$1 extends Set<infer TValue> ? ReadonlySet<TValue> : Readonly<TInput$1>;
/**
* Readonly action interface.
*/
interface ReadonlyAction<TInput$1> extends BaseTransformation<TInput$1, ReadonlyOutput<TInput$1>, never> {
  /**
  * The action type.
  */
  readonly type: "readonly";
  /**
  * The action reference.
  */
  readonly reference: typeof readonly;
}
/**
* Creates a readonly transformation action.
*
* @returns A readonly action.
*/
declare function readonly<TInput$1>(): ReadonlyAction<TInput$1>;

/** Free-form error attached to a payload or subcomponent. */
interface DocgenError {
    name: string;
    message: string;
}
/** Compact JSDoc tag map: tag name → list of tag values (e.g. `@example a` → `{ example: ['a'] }`). */
type DocgenJsDocTags = Record<string, string[]>;
/**
 * Docgen payload returned by `core/docgen`'s `docgen` query.
 *
 * Component-only fields (props, descriptions, subcomponents). Story snippets and file-level
 * imports live in `core/story-docs` when `experimentalDocgenServer` is enabled.
 */
interface DocgenPayload {
    id: string;
    name: string;
    /** CSF story file import path from the index entry (same as component manifest `path`). */
    path: string;
    description?: string;
    summary?: string;
    jsDocTags: DocgenJsDocTags;
    /** Renderer-converted argTypes derived from integration-specific docgen data at write time. */
    argTypes?: StrictArgTypes$2;
    subcomponents?: Record<string, DocgenSubcomponent>;
    error?: DocgenError;
    [key: string]: unknown;
}
/** Component-level summary + docgen for one subcomponent. */
interface DocgenSubcomponent {
    name: string;
    path: string;
    description?: string;
    summary?: string;
    import?: string;
    jsDocTags: DocgenJsDocTags;
    /** Renderer-converted argTypes derived from integration-specific docgen data at write time. */
    argTypes?: StrictArgTypes$2;
    error?: DocgenError;
    [key: string]: unknown;
}

/** Free-form error attached to a story snippet entry. */
interface StoryDocsError {
    name: string;
    message: string;
}
/** Snippet + metadata for one story under a component. */
interface StoryDoc {
    id: string;
    name: string;
    snippet?: string;
    description?: string;
    summary?: string;
    error?: StoryDocsError;
}
/** Story docs keyed by story id for O(1) lookup and fine-grained open-service subscriptions. */
type StoryDocsById = Record<string, StoryDoc>;
/**
 * Story-docs payload returned by `core/story-docs`'s `storyDocs` query.
 *
 * Carries per-story snippets and descriptions plus file-level import statements. Import snippets
 * do not currently honor the component `@import` JSDoc override tag — see the story-docs service
 * README for details.
 */
interface StoryDocsPayload {
    id: string;
    name: string;
    /** CSF story file import path from the index entry. */
    path: string;
    /** Suggested import statement(s) prepended to story snippets in docs. */
    import?: string;
    stories: StoryDocsById;
    error?: StoryDocsError;
}

type StoryDocsServiceState = {
    /** Extracted story docs keyed by component id. Populated by the `extractStoryDocs` command. */
    components: Record<string, StoryDocsPayload>;
};

interface SBBaseType {
    required?: boolean;
    raw?: string;
}
type SBScalarType = SBBaseType & {
    name: 'boolean' | 'string' | 'number' | 'function' | 'symbol' | 'date';
};
type SBArrayType = SBBaseType & {
    name: 'array';
    value: SBType;
};
type SBNodeType = SBBaseType & {
    name: 'node';
    renderer: string;
};
type SBObjectType = SBBaseType & {
    name: 'object';
    value: Record<string, SBType>;
};
type SBEnumType = SBBaseType & {
    name: 'enum';
    value: (string | number)[];
};
type SBIntersectionType = SBBaseType & {
    name: 'intersection';
    value: SBType[];
};
type SBUnionType = SBBaseType & {
    name: 'union';
    value: SBType[];
};
type SBLiteralType = SBBaseType & {
    name: 'literal';
    value: unknown;
};
type SBTupleType = SBBaseType & {
    name: 'tuple';
    value: SBType[];
};
type SBOtherType = SBBaseType & {
    name: 'other';
    value: string;
};
type SBType = SBScalarType | SBEnumType | SBArrayType | SBNodeType | SBObjectType | SBIntersectionType | SBUnionType | SBLiteralType | SBTupleType | SBOtherType;

type ControlType = 'object' | 'boolean' | 'check' | 'inline-check' | 'radio' | 'inline-radio' | 'select' | 'multi-select' | 'number' | 'range' | 'file' | 'color' | 'date' | 'text';
type ConditionalTest = {
    truthy?: boolean;
} | {
    exists: boolean;
} | {
    eq: any;
} | {
    neq: any;
};
type ConditionalValue = {
    arg: string;
} | {
    global: string;
};
type Conditional = ConditionalValue & ConditionalTest;
interface ControlBase {
    [key: string]: any;
    /** @see https://storybook.js.org/docs/api/arg-types#controltype */
    type?: ControlType;
    disable?: boolean;
}
type Control = ControlType | false | (ControlBase & (ControlBase | {
    type: 'color';
    /** @see https://storybook.js.org/docs/api/arg-types#controlpresetcolors */
    presetColors?: string[];
} | {
    type: 'file';
    /** @see https://storybook.js.org/docs/api/arg-types#controlaccept */
    accept?: string;
} | {
    type: 'inline-check' | 'radio' | 'inline-radio' | 'select' | 'multi-select';
    /** @see https://storybook.js.org/docs/api/arg-types#controllabels */
    labels?: {
        [options: string]: string;
    };
} | {
    type: 'number' | 'range';
    /** @see https://storybook.js.org/docs/api/arg-types#controlmax */
    max?: number;
    /** @see https://storybook.js.org/docs/api/arg-types#controlmin */
    min?: number;
    /** @see https://storybook.js.org/docs/api/arg-types#controlstep */
    step?: number;
}));
interface InputType {
    /** @see https://storybook.js.org/docs/api/arg-types#control */
    control?: Control;
    /** @see https://storybook.js.org/docs/api/arg-types#description */
    description?: string;
    /** @see https://storybook.js.org/docs/api/arg-types#if */
    if?: Conditional;
    /** @see https://storybook.js.org/docs/api/arg-types#mapping */
    mapping?: {
        [key: string]: any;
    };
    /** @see https://storybook.js.org/docs/api/arg-types#name */
    name?: string;
    /** @see https://storybook.js.org/docs/api/arg-types#options */
    options?: readonly any[];
    /** @see https://storybook.js.org/docs/api/arg-types#table */
    table?: {
        [key: string]: unknown;
        /** @see https://storybook.js.org/docs/api/arg-types#tablecategory */
        category?: string;
        /** @see https://storybook.js.org/docs/api/arg-types#tabledefaultvalue */
        defaultValue?: {
            summary?: string | undefined;
            detail?: string | undefined;
        };
        /** @see https://storybook.js.org/docs/api/arg-types#tabledisable */
        disable?: boolean;
        /** @see https://storybook.js.org/docs/api/arg-types#tablesubcategory */
        subcategory?: string;
        /** @see https://storybook.js.org/docs/api/arg-types#tabletype */
        type?: {
            summary?: string | undefined;
            detail?: string | undefined;
        };
    };
    /** @see https://storybook.js.org/docs/api/arg-types#type */
    type?: SBType | SBScalarType['name'];
    /**
     * @deprecated Use `table.defaultValue.summary` instead.
     * @see https://storybook.js.org/docs/api/arg-types#defaultvalue
     */
    defaultValue?: any;
    [key: string]: any;
}
interface StrictInputType extends InputType {
    name: string;
    type?: SBType;
}
interface Args {
    [name: string]: any;
}
type StrictArgTypes<TArgs = Args> = {
    [name in keyof TArgs]: StrictInputType;
};

declare const previewCoreServiceDefs: (ServiceDefinition<StoryDocsServiceState, {
    readonly storyDocs: QueryDefinition<StoryDocsServiceState, ObjectSchema<{
        readonly id: StringSchema<undefined>;
    }, undefined>, OptionalSchema<ObjectSchema<{
        readonly id: StringSchema<undefined>;
        readonly name: StringSchema<undefined>;
        readonly path: StringSchema<undefined>;
        readonly import: OptionalSchema<StringSchema<undefined>, undefined>;
        readonly stories: RecordSchema<StringSchema<undefined>, ObjectSchema<{
            readonly id: StringSchema<undefined>;
            readonly name: StringSchema<undefined>;
            readonly snippet: OptionalSchema<StringSchema<undefined>, undefined>;
            readonly description: OptionalSchema<StringSchema<undefined>, undefined>;
            readonly summary: OptionalSchema<StringSchema<undefined>, undefined>;
            readonly error: OptionalSchema<ObjectSchema<{
                readonly name: StringSchema<undefined>;
                readonly message: StringSchema<undefined>;
            }, undefined>, undefined>;
        }, undefined>, undefined>;
        readonly error: OptionalSchema<ObjectSchema<{
            readonly name: StringSchema<undefined>;
            readonly message: StringSchema<undefined>;
        }, undefined>, undefined>;
    }, undefined>, undefined>, {
        readonly extractStoryDocs: ObjectSchema<{
            readonly id: StringSchema<undefined>;
        }, undefined>;
        readonly extractAllStoryDocs: UndefinedSchema<undefined>;
    }, {
        readonly extractStoryDocs: OptionalSchema<ObjectSchema<{
            readonly id: StringSchema<undefined>;
            readonly name: StringSchema<undefined>;
            readonly path: StringSchema<undefined>;
            readonly import: OptionalSchema<StringSchema<undefined>, undefined>;
            readonly stories: RecordSchema<StringSchema<undefined>, ObjectSchema<{
                readonly id: StringSchema<undefined>;
                readonly name: StringSchema<undefined>;
                readonly snippet: OptionalSchema<StringSchema<undefined>, undefined>;
                readonly description: OptionalSchema<StringSchema<undefined>, undefined>;
                readonly summary: OptionalSchema<StringSchema<undefined>, undefined>;
                readonly error: OptionalSchema<ObjectSchema<{
                    readonly name: StringSchema<undefined>;
                    readonly message: StringSchema<undefined>;
                }, undefined>, undefined>;
            }, undefined>, undefined>;
            readonly error: OptionalSchema<ObjectSchema<{
                readonly name: StringSchema<undefined>;
                readonly message: StringSchema<undefined>;
            }, undefined>, undefined>;
        }, undefined>, undefined>;
        readonly extractAllStoryDocs: VoidSchema<undefined>;
    }, QueryFunctions<{
        readonly storyDocs: ObjectSchema<{
            readonly id: StringSchema<undefined>;
        }, undefined>;
        readonly storyDocsForAllComponents: VoidSchema<undefined>;
    }, {
        readonly storyDocs: OptionalSchema<ObjectSchema<{
            readonly id: StringSchema<undefined>;
            readonly name: StringSchema<undefined>;
            readonly path: StringSchema<undefined>;
            readonly import: OptionalSchema<StringSchema<undefined>, undefined>;
            readonly stories: RecordSchema<StringSchema<undefined>, ObjectSchema<{
                readonly id: StringSchema<undefined>;
                readonly name: StringSchema<undefined>;
                readonly snippet: OptionalSchema<StringSchema<undefined>, undefined>;
                readonly description: OptionalSchema<StringSchema<undefined>, undefined>;
                readonly summary: OptionalSchema<StringSchema<undefined>, undefined>;
                readonly error: OptionalSchema<ObjectSchema<{
                    readonly name: StringSchema<undefined>;
                    readonly message: StringSchema<undefined>;
                }, undefined>, undefined>;
            }, undefined>, undefined>;
            readonly error: OptionalSchema<ObjectSchema<{
                readonly name: StringSchema<undefined>;
                readonly message: StringSchema<undefined>;
            }, undefined>, undefined>;
        }, undefined>, undefined>;
        readonly storyDocsForAllComponents: RecordSchema<StringSchema<undefined>, ObjectSchema<{
            readonly id: StringSchema<undefined>;
            readonly name: StringSchema<undefined>;
            readonly path: StringSchema<undefined>;
            readonly import: OptionalSchema<StringSchema<undefined>, undefined>;
            readonly stories: RecordSchema<StringSchema<undefined>, ObjectSchema<{
                readonly id: StringSchema<undefined>;
                readonly name: StringSchema<undefined>;
                readonly snippet: OptionalSchema<StringSchema<undefined>, undefined>;
                readonly description: OptionalSchema<StringSchema<undefined>, undefined>;
                readonly summary: OptionalSchema<StringSchema<undefined>, undefined>;
                readonly error: OptionalSchema<ObjectSchema<{
                    readonly name: StringSchema<undefined>;
                    readonly message: StringSchema<undefined>;
                }, undefined>, undefined>;
            }, undefined>, undefined>;
            readonly error: OptionalSchema<ObjectSchema<{
                readonly name: StringSchema<undefined>;
                readonly message: StringSchema<undefined>;
            }, undefined>, undefined>;
        }, undefined>, undefined>;
    }>> & ({
        internal?: false;
    } | {
        __internal_naming_error: "Operation \"storyDocs\" has internal: true but must be prefixed with \"_\"";
    });
    readonly storyDocsForAllComponents: QueryDefinition<StoryDocsServiceState, VoidSchema<undefined>, RecordSchema<StringSchema<undefined>, ObjectSchema<{
        readonly id: StringSchema<undefined>;
        readonly name: StringSchema<undefined>;
        readonly path: StringSchema<undefined>;
        readonly import: OptionalSchema<StringSchema<undefined>, undefined>;
        readonly stories: RecordSchema<StringSchema<undefined>, ObjectSchema<{
            readonly id: StringSchema<undefined>;
            readonly name: StringSchema<undefined>;
            readonly snippet: OptionalSchema<StringSchema<undefined>, undefined>;
            readonly description: OptionalSchema<StringSchema<undefined>, undefined>;
            readonly summary: OptionalSchema<StringSchema<undefined>, undefined>;
            readonly error: OptionalSchema<ObjectSchema<{
                readonly name: StringSchema<undefined>;
                readonly message: StringSchema<undefined>;
            }, undefined>, undefined>;
        }, undefined>, undefined>;
        readonly error: OptionalSchema<ObjectSchema<{
            readonly name: StringSchema<undefined>;
            readonly message: StringSchema<undefined>;
        }, undefined>, undefined>;
    }, undefined>, undefined>, {
        readonly extractStoryDocs: ObjectSchema<{
            readonly id: StringSchema<undefined>;
        }, undefined>;
        readonly extractAllStoryDocs: UndefinedSchema<undefined>;
    }, {
        readonly extractStoryDocs: OptionalSchema<ObjectSchema<{
            readonly id: StringSchema<undefined>;
            readonly name: StringSchema<undefined>;
            readonly path: StringSchema<undefined>;
            readonly import: OptionalSchema<StringSchema<undefined>, undefined>;
            readonly stories: RecordSchema<StringSchema<undefined>, ObjectSchema<{
                readonly id: StringSchema<undefined>;
                readonly name: StringSchema<undefined>;
                readonly snippet: OptionalSchema<StringSchema<undefined>, undefined>;
                readonly description: OptionalSchema<StringSchema<undefined>, undefined>;
                readonly summary: OptionalSchema<StringSchema<undefined>, undefined>;
                readonly error: OptionalSchema<ObjectSchema<{
                    readonly name: StringSchema<undefined>;
                    readonly message: StringSchema<undefined>;
                }, undefined>, undefined>;
            }, undefined>, undefined>;
            readonly error: OptionalSchema<ObjectSchema<{
                readonly name: StringSchema<undefined>;
                readonly message: StringSchema<undefined>;
            }, undefined>, undefined>;
        }, undefined>, undefined>;
        readonly extractAllStoryDocs: VoidSchema<undefined>;
    }, QueryFunctions<{
        readonly storyDocs: ObjectSchema<{
            readonly id: StringSchema<undefined>;
        }, undefined>;
        readonly storyDocsForAllComponents: VoidSchema<undefined>;
    }, {
        readonly storyDocs: OptionalSchema<ObjectSchema<{
            readonly id: StringSchema<undefined>;
            readonly name: StringSchema<undefined>;
            readonly path: StringSchema<undefined>;
            readonly import: OptionalSchema<StringSchema<undefined>, undefined>;
            readonly stories: RecordSchema<StringSchema<undefined>, ObjectSchema<{
                readonly id: StringSchema<undefined>;
                readonly name: StringSchema<undefined>;
                readonly snippet: OptionalSchema<StringSchema<undefined>, undefined>;
                readonly description: OptionalSchema<StringSchema<undefined>, undefined>;
                readonly summary: OptionalSchema<StringSchema<undefined>, undefined>;
                readonly error: OptionalSchema<ObjectSchema<{
                    readonly name: StringSchema<undefined>;
                    readonly message: StringSchema<undefined>;
                }, undefined>, undefined>;
            }, undefined>, undefined>;
            readonly error: OptionalSchema<ObjectSchema<{
                readonly name: StringSchema<undefined>;
                readonly message: StringSchema<undefined>;
            }, undefined>, undefined>;
        }, undefined>, undefined>;
        readonly storyDocsForAllComponents: RecordSchema<StringSchema<undefined>, ObjectSchema<{
            readonly id: StringSchema<undefined>;
            readonly name: StringSchema<undefined>;
            readonly path: StringSchema<undefined>;
            readonly import: OptionalSchema<StringSchema<undefined>, undefined>;
            readonly stories: RecordSchema<StringSchema<undefined>, ObjectSchema<{
                readonly id: StringSchema<undefined>;
                readonly name: StringSchema<undefined>;
                readonly snippet: OptionalSchema<StringSchema<undefined>, undefined>;
                readonly description: OptionalSchema<StringSchema<undefined>, undefined>;
                readonly summary: OptionalSchema<StringSchema<undefined>, undefined>;
                readonly error: OptionalSchema<ObjectSchema<{
                    readonly name: StringSchema<undefined>;
                    readonly message: StringSchema<undefined>;
                }, undefined>, undefined>;
            }, undefined>, undefined>;
            readonly error: OptionalSchema<ObjectSchema<{
                readonly name: StringSchema<undefined>;
                readonly message: StringSchema<undefined>;
            }, undefined>, undefined>;
        }, undefined>, undefined>;
    }>> & ({
        internal?: false;
    } | {
        __internal_naming_error: "Operation \"storyDocsForAllComponents\" has internal: true but must be prefixed with \"_\"";
    });
} & {
    readonly storyDocs: {
        output: OptionalSchema<ObjectSchema<{
            readonly id: StringSchema<undefined>;
            readonly name: StringSchema<undefined>;
            readonly path: StringSchema<undefined>;
            readonly import: OptionalSchema<StringSchema<undefined>, undefined>;
            readonly stories: RecordSchema<StringSchema<undefined>, ObjectSchema<{
                readonly id: StringSchema<undefined>;
                readonly name: StringSchema<undefined>;
                readonly snippet: OptionalSchema<StringSchema<undefined>, undefined>;
                readonly description: OptionalSchema<StringSchema<undefined>, undefined>;
                readonly summary: OptionalSchema<StringSchema<undefined>, undefined>;
                readonly error: OptionalSchema<ObjectSchema<{
                    readonly name: StringSchema<undefined>;
                    readonly message: StringSchema<undefined>;
                }, undefined>, undefined>;
            }, undefined>, undefined>;
            readonly error: OptionalSchema<ObjectSchema<{
                readonly name: StringSchema<undefined>;
                readonly message: StringSchema<undefined>;
            }, undefined>, undefined>;
        }, undefined>, undefined>;
    };
    readonly storyDocsForAllComponents: {
        output: RecordSchema<StringSchema<undefined>, ObjectSchema<{
            readonly id: StringSchema<undefined>;
            readonly name: StringSchema<undefined>;
            readonly path: StringSchema<undefined>;
            readonly import: OptionalSchema<StringSchema<undefined>, undefined>;
            readonly stories: RecordSchema<StringSchema<undefined>, ObjectSchema<{
                readonly id: StringSchema<undefined>;
                readonly name: StringSchema<undefined>;
                readonly snippet: OptionalSchema<StringSchema<undefined>, undefined>;
                readonly description: OptionalSchema<StringSchema<undefined>, undefined>;
                readonly summary: OptionalSchema<StringSchema<undefined>, undefined>;
                readonly error: OptionalSchema<ObjectSchema<{
                    readonly name: StringSchema<undefined>;
                    readonly message: StringSchema<undefined>;
                }, undefined>, undefined>;
            }, undefined>, undefined>;
            readonly error: OptionalSchema<ObjectSchema<{
                readonly name: StringSchema<undefined>;
                readonly message: StringSchema<undefined>;
            }, undefined>, undefined>;
        }, undefined>, undefined>;
    };
}, {
    readonly extractStoryDocs: CommandDefinition<StoryDocsServiceState, ObjectSchema<{
        readonly id: StringSchema<undefined>;
    }, undefined>, OptionalSchema<ObjectSchema<{
        readonly id: StringSchema<undefined>;
        readonly name: StringSchema<undefined>;
        readonly path: StringSchema<undefined>;
        readonly import: OptionalSchema<StringSchema<undefined>, undefined>;
        readonly stories: RecordSchema<StringSchema<undefined>, ObjectSchema<{
            readonly id: StringSchema<undefined>;
            readonly name: StringSchema<undefined>;
            readonly snippet: OptionalSchema<StringSchema<undefined>, undefined>;
            readonly description: OptionalSchema<StringSchema<undefined>, undefined>;
            readonly summary: OptionalSchema<StringSchema<undefined>, undefined>;
            readonly error: OptionalSchema<ObjectSchema<{
                readonly name: StringSchema<undefined>;
                readonly message: StringSchema<undefined>;
            }, undefined>, undefined>;
        }, undefined>, undefined>;
        readonly error: OptionalSchema<ObjectSchema<{
            readonly name: StringSchema<undefined>;
            readonly message: StringSchema<undefined>;
        }, undefined>, undefined>;
    }, undefined>, undefined>, {
        readonly extractStoryDocs: ObjectSchema<{
            readonly id: StringSchema<undefined>;
        }, undefined>;
        readonly extractAllStoryDocs: UndefinedSchema<undefined>;
    }, {
        readonly extractStoryDocs: OptionalSchema<ObjectSchema<{
            readonly id: StringSchema<undefined>;
            readonly name: StringSchema<undefined>;
            readonly path: StringSchema<undefined>;
            readonly import: OptionalSchema<StringSchema<undefined>, undefined>;
            readonly stories: RecordSchema<StringSchema<undefined>, ObjectSchema<{
                readonly id: StringSchema<undefined>;
                readonly name: StringSchema<undefined>;
                readonly snippet: OptionalSchema<StringSchema<undefined>, undefined>;
                readonly description: OptionalSchema<StringSchema<undefined>, undefined>;
                readonly summary: OptionalSchema<StringSchema<undefined>, undefined>;
                readonly error: OptionalSchema<ObjectSchema<{
                    readonly name: StringSchema<undefined>;
                    readonly message: StringSchema<undefined>;
                }, undefined>, undefined>;
            }, undefined>, undefined>;
            readonly error: OptionalSchema<ObjectSchema<{
                readonly name: StringSchema<undefined>;
                readonly message: StringSchema<undefined>;
            }, undefined>, undefined>;
        }, undefined>, undefined>;
        readonly extractAllStoryDocs: VoidSchema<undefined>;
    }, QueryFunctions<{
        readonly storyDocs: ObjectSchema<{
            readonly id: StringSchema<undefined>;
        }, undefined>;
        readonly storyDocsForAllComponents: VoidSchema<undefined>;
    }, {
        readonly storyDocs: OptionalSchema<ObjectSchema<{
            readonly id: StringSchema<undefined>;
            readonly name: StringSchema<undefined>;
            readonly path: StringSchema<undefined>;
            readonly import: OptionalSchema<StringSchema<undefined>, undefined>;
            readonly stories: RecordSchema<StringSchema<undefined>, ObjectSchema<{
                readonly id: StringSchema<undefined>;
                readonly name: StringSchema<undefined>;
                readonly snippet: OptionalSchema<StringSchema<undefined>, undefined>;
                readonly description: OptionalSchema<StringSchema<undefined>, undefined>;
                readonly summary: OptionalSchema<StringSchema<undefined>, undefined>;
                readonly error: OptionalSchema<ObjectSchema<{
                    readonly name: StringSchema<undefined>;
                    readonly message: StringSchema<undefined>;
                }, undefined>, undefined>;
            }, undefined>, undefined>;
            readonly error: OptionalSchema<ObjectSchema<{
                readonly name: StringSchema<undefined>;
                readonly message: StringSchema<undefined>;
            }, undefined>, undefined>;
        }, undefined>, undefined>;
        readonly storyDocsForAllComponents: RecordSchema<StringSchema<undefined>, ObjectSchema<{
            readonly id: StringSchema<undefined>;
            readonly name: StringSchema<undefined>;
            readonly path: StringSchema<undefined>;
            readonly import: OptionalSchema<StringSchema<undefined>, undefined>;
            readonly stories: RecordSchema<StringSchema<undefined>, ObjectSchema<{
                readonly id: StringSchema<undefined>;
                readonly name: StringSchema<undefined>;
                readonly snippet: OptionalSchema<StringSchema<undefined>, undefined>;
                readonly description: OptionalSchema<StringSchema<undefined>, undefined>;
                readonly summary: OptionalSchema<StringSchema<undefined>, undefined>;
                readonly error: OptionalSchema<ObjectSchema<{
                    readonly name: StringSchema<undefined>;
                    readonly message: StringSchema<undefined>;
                }, undefined>, undefined>;
            }, undefined>, undefined>;
            readonly error: OptionalSchema<ObjectSchema<{
                readonly name: StringSchema<undefined>;
                readonly message: StringSchema<undefined>;
            }, undefined>, undefined>;
        }, undefined>, undefined>;
    }>> & ({
        internal?: false;
    } | {
        __internal_naming_error: "Operation \"extractStoryDocs\" has internal: true but must be prefixed with \"_\"";
    });
    readonly extractAllStoryDocs: CommandDefinition<StoryDocsServiceState, UndefinedSchema<undefined>, VoidSchema<undefined>, {
        readonly extractStoryDocs: ObjectSchema<{
            readonly id: StringSchema<undefined>;
        }, undefined>;
        readonly extractAllStoryDocs: UndefinedSchema<undefined>;
    }, {
        readonly extractStoryDocs: OptionalSchema<ObjectSchema<{
            readonly id: StringSchema<undefined>;
            readonly name: StringSchema<undefined>;
            readonly path: StringSchema<undefined>;
            readonly import: OptionalSchema<StringSchema<undefined>, undefined>;
            readonly stories: RecordSchema<StringSchema<undefined>, ObjectSchema<{
                readonly id: StringSchema<undefined>;
                readonly name: StringSchema<undefined>;
                readonly snippet: OptionalSchema<StringSchema<undefined>, undefined>;
                readonly description: OptionalSchema<StringSchema<undefined>, undefined>;
                readonly summary: OptionalSchema<StringSchema<undefined>, undefined>;
                readonly error: OptionalSchema<ObjectSchema<{
                    readonly name: StringSchema<undefined>;
                    readonly message: StringSchema<undefined>;
                }, undefined>, undefined>;
            }, undefined>, undefined>;
            readonly error: OptionalSchema<ObjectSchema<{
                readonly name: StringSchema<undefined>;
                readonly message: StringSchema<undefined>;
            }, undefined>, undefined>;
        }, undefined>, undefined>;
        readonly extractAllStoryDocs: VoidSchema<undefined>;
    }, QueryFunctions<{
        readonly storyDocs: ObjectSchema<{
            readonly id: StringSchema<undefined>;
        }, undefined>;
        readonly storyDocsForAllComponents: VoidSchema<undefined>;
    }, {
        readonly storyDocs: OptionalSchema<ObjectSchema<{
            readonly id: StringSchema<undefined>;
            readonly name: StringSchema<undefined>;
            readonly path: StringSchema<undefined>;
            readonly import: OptionalSchema<StringSchema<undefined>, undefined>;
            readonly stories: RecordSchema<StringSchema<undefined>, ObjectSchema<{
                readonly id: StringSchema<undefined>;
                readonly name: StringSchema<undefined>;
                readonly snippet: OptionalSchema<StringSchema<undefined>, undefined>;
                readonly description: OptionalSchema<StringSchema<undefined>, undefined>;
                readonly summary: OptionalSchema<StringSchema<undefined>, undefined>;
                readonly error: OptionalSchema<ObjectSchema<{
                    readonly name: StringSchema<undefined>;
                    readonly message: StringSchema<undefined>;
                }, undefined>, undefined>;
            }, undefined>, undefined>;
            readonly error: OptionalSchema<ObjectSchema<{
                readonly name: StringSchema<undefined>;
                readonly message: StringSchema<undefined>;
            }, undefined>, undefined>;
        }, undefined>, undefined>;
        readonly storyDocsForAllComponents: RecordSchema<StringSchema<undefined>, ObjectSchema<{
            readonly id: StringSchema<undefined>;
            readonly name: StringSchema<undefined>;
            readonly path: StringSchema<undefined>;
            readonly import: OptionalSchema<StringSchema<undefined>, undefined>;
            readonly stories: RecordSchema<StringSchema<undefined>, ObjectSchema<{
                readonly id: StringSchema<undefined>;
                readonly name: StringSchema<undefined>;
                readonly snippet: OptionalSchema<StringSchema<undefined>, undefined>;
                readonly description: OptionalSchema<StringSchema<undefined>, undefined>;
                readonly summary: OptionalSchema<StringSchema<undefined>, undefined>;
                readonly error: OptionalSchema<ObjectSchema<{
                    readonly name: StringSchema<undefined>;
                    readonly message: StringSchema<undefined>;
                }, undefined>, undefined>;
            }, undefined>, undefined>;
            readonly error: OptionalSchema<ObjectSchema<{
                readonly name: StringSchema<undefined>;
                readonly message: StringSchema<undefined>;
            }, undefined>, undefined>;
        }, undefined>, undefined>;
    }>> & ({
        internal?: false;
    } | {
        __internal_naming_error: "Operation \"extractAllStoryDocs\" has internal: true but must be prefixed with \"_\"";
    });
} & {
    readonly extractStoryDocs: {
        output: OptionalSchema<ObjectSchema<{
            readonly id: StringSchema<undefined>;
            readonly name: StringSchema<undefined>;
            readonly path: StringSchema<undefined>;
            readonly import: OptionalSchema<StringSchema<undefined>, undefined>;
            readonly stories: RecordSchema<StringSchema<undefined>, ObjectSchema<{
                readonly id: StringSchema<undefined>;
                readonly name: StringSchema<undefined>;
                readonly snippet: OptionalSchema<StringSchema<undefined>, undefined>;
                readonly description: OptionalSchema<StringSchema<undefined>, undefined>;
                readonly summary: OptionalSchema<StringSchema<undefined>, undefined>;
                readonly error: OptionalSchema<ObjectSchema<{
                    readonly name: StringSchema<undefined>;
                    readonly message: StringSchema<undefined>;
                }, undefined>, undefined>;
            }, undefined>, undefined>;
            readonly error: OptionalSchema<ObjectSchema<{
                readonly name: StringSchema<undefined>;
                readonly message: StringSchema<undefined>;
            }, undefined>, undefined>;
        }, undefined>, undefined>;
    };
    readonly extractAllStoryDocs: {
        output: VoidSchema<undefined>;
    };
}, "core/story-docs"> | ServiceDefinition<{
    components: Record<string, DocgenPayload>;
}, {
    readonly docgen: QueryDefinition<{
        components: Record<string, DocgenPayload>;
    }, ObjectSchema<{
        readonly id: StringSchema<undefined>;
    }, undefined>, OptionalSchema<LooseObjectSchema<{
        readonly subcomponents: OptionalSchema<RecordSchema<StringSchema<undefined>, LooseObjectSchema<{
            import: OptionalSchema<StringSchema<undefined>, undefined>;
            name: StringSchema<undefined>;
            path: StringSchema<undefined>;
            description: OptionalSchema<StringSchema<undefined>, undefined>;
            summary: OptionalSchema<StringSchema<undefined>, undefined>;
            jsDocTags: RecordSchema<StringSchema<undefined>, ArraySchema<StringSchema<undefined>, undefined>, undefined>;
            argTypes: OptionalSchema<CustomSchema<StrictArgTypes<Args>, undefined>, undefined>;
            error: OptionalSchema<ObjectSchema<{
                readonly name: StringSchema<undefined>;
                readonly message: StringSchema<undefined>;
            }, undefined>, undefined>;
        }, undefined>, undefined>, undefined>;
        readonly name: StringSchema<undefined>;
        readonly path: StringSchema<undefined>;
        readonly description: OptionalSchema<StringSchema<undefined>, undefined>;
        readonly summary: OptionalSchema<StringSchema<undefined>, undefined>;
        readonly jsDocTags: RecordSchema<StringSchema<undefined>, ArraySchema<StringSchema<undefined>, undefined>, undefined>;
        readonly argTypes: OptionalSchema<CustomSchema<StrictArgTypes<Args>, undefined>, undefined>;
        readonly error: OptionalSchema<ObjectSchema<{
            readonly name: StringSchema<undefined>;
            readonly message: StringSchema<undefined>;
        }, undefined>, undefined>;
        readonly id: StringSchema<undefined>;
    }, undefined>, undefined>, {
        readonly extractDocgen: ObjectSchema<{
            readonly id: StringSchema<undefined>;
        }, undefined>;
        readonly extractAllDocgen: UndefinedSchema<undefined>;
    }, {
        readonly extractDocgen: OptionalSchema<LooseObjectSchema<{
            readonly subcomponents: OptionalSchema<RecordSchema<StringSchema<undefined>, LooseObjectSchema<{
                import: OptionalSchema<StringSchema<undefined>, undefined>;
                name: StringSchema<undefined>;
                path: StringSchema<undefined>;
                description: OptionalSchema<StringSchema<undefined>, undefined>;
                summary: OptionalSchema<StringSchema<undefined>, undefined>;
                jsDocTags: RecordSchema<StringSchema<undefined>, ArraySchema<StringSchema<undefined>, undefined>, undefined>;
                argTypes: OptionalSchema<CustomSchema<StrictArgTypes<Args>, undefined>, undefined>;
                error: OptionalSchema<ObjectSchema<{
                    readonly name: StringSchema<undefined>;
                    readonly message: StringSchema<undefined>;
                }, undefined>, undefined>;
            }, undefined>, undefined>, undefined>;
            readonly name: StringSchema<undefined>;
            readonly path: StringSchema<undefined>;
            readonly description: OptionalSchema<StringSchema<undefined>, undefined>;
            readonly summary: OptionalSchema<StringSchema<undefined>, undefined>;
            readonly jsDocTags: RecordSchema<StringSchema<undefined>, ArraySchema<StringSchema<undefined>, undefined>, undefined>;
            readonly argTypes: OptionalSchema<CustomSchema<StrictArgTypes<Args>, undefined>, undefined>;
            readonly error: OptionalSchema<ObjectSchema<{
                readonly name: StringSchema<undefined>;
                readonly message: StringSchema<undefined>;
            }, undefined>, undefined>;
            readonly id: StringSchema<undefined>;
        }, undefined>, undefined>;
        readonly extractAllDocgen: VoidSchema<undefined>;
    }, QueryFunctions<{
        readonly docgen: ObjectSchema<{
            readonly id: StringSchema<undefined>;
        }, undefined>;
        readonly docgenForAllComponents: VoidSchema<undefined>;
    }, {
        readonly docgen: OptionalSchema<LooseObjectSchema<{
            readonly subcomponents: OptionalSchema<RecordSchema<StringSchema<undefined>, LooseObjectSchema<{
                import: OptionalSchema<StringSchema<undefined>, undefined>;
                name: StringSchema<undefined>;
                path: StringSchema<undefined>;
                description: OptionalSchema<StringSchema<undefined>, undefined>;
                summary: OptionalSchema<StringSchema<undefined>, undefined>;
                jsDocTags: RecordSchema<StringSchema<undefined>, ArraySchema<StringSchema<undefined>, undefined>, undefined>;
                argTypes: OptionalSchema<CustomSchema<StrictArgTypes<Args>, undefined>, undefined>;
                error: OptionalSchema<ObjectSchema<{
                    readonly name: StringSchema<undefined>;
                    readonly message: StringSchema<undefined>;
                }, undefined>, undefined>;
            }, undefined>, undefined>, undefined>;
            readonly name: StringSchema<undefined>;
            readonly path: StringSchema<undefined>;
            readonly description: OptionalSchema<StringSchema<undefined>, undefined>;
            readonly summary: OptionalSchema<StringSchema<undefined>, undefined>;
            readonly jsDocTags: RecordSchema<StringSchema<undefined>, ArraySchema<StringSchema<undefined>, undefined>, undefined>;
            readonly argTypes: OptionalSchema<CustomSchema<StrictArgTypes<Args>, undefined>, undefined>;
            readonly error: OptionalSchema<ObjectSchema<{
                readonly name: StringSchema<undefined>;
                readonly message: StringSchema<undefined>;
            }, undefined>, undefined>;
            readonly id: StringSchema<undefined>;
        }, undefined>, undefined>;
        readonly docgenForAllComponents: RecordSchema<StringSchema<undefined>, LooseObjectSchema<{
            readonly subcomponents: OptionalSchema<RecordSchema<StringSchema<undefined>, LooseObjectSchema<{
                import: OptionalSchema<StringSchema<undefined>, undefined>;
                name: StringSchema<undefined>;
                path: StringSchema<undefined>;
                description: OptionalSchema<StringSchema<undefined>, undefined>;
                summary: OptionalSchema<StringSchema<undefined>, undefined>;
                jsDocTags: RecordSchema<StringSchema<undefined>, ArraySchema<StringSchema<undefined>, undefined>, undefined>;
                argTypes: OptionalSchema<CustomSchema<StrictArgTypes<Args>, undefined>, undefined>;
                error: OptionalSchema<ObjectSchema<{
                    readonly name: StringSchema<undefined>;
                    readonly message: StringSchema<undefined>;
                }, undefined>, undefined>;
            }, undefined>, undefined>, undefined>;
            readonly name: StringSchema<undefined>;
            readonly path: StringSchema<undefined>;
            readonly description: OptionalSchema<StringSchema<undefined>, undefined>;
            readonly summary: OptionalSchema<StringSchema<undefined>, undefined>;
            readonly jsDocTags: RecordSchema<StringSchema<undefined>, ArraySchema<StringSchema<undefined>, undefined>, undefined>;
            readonly argTypes: OptionalSchema<CustomSchema<StrictArgTypes<Args>, undefined>, undefined>;
            readonly error: OptionalSchema<ObjectSchema<{
                readonly name: StringSchema<undefined>;
                readonly message: StringSchema<undefined>;
            }, undefined>, undefined>;
            readonly id: StringSchema<undefined>;
        }, undefined>, undefined>;
    }>> & ({
        internal?: false;
    } | {
        __internal_naming_error: "Operation \"docgen\" has internal: true but must be prefixed with \"_\"";
    });
    readonly docgenForAllComponents: QueryDefinition<{
        components: Record<string, DocgenPayload>;
    }, VoidSchema<undefined>, RecordSchema<StringSchema<undefined>, LooseObjectSchema<{
        readonly subcomponents: OptionalSchema<RecordSchema<StringSchema<undefined>, LooseObjectSchema<{
            import: OptionalSchema<StringSchema<undefined>, undefined>;
            name: StringSchema<undefined>;
            path: StringSchema<undefined>;
            description: OptionalSchema<StringSchema<undefined>, undefined>;
            summary: OptionalSchema<StringSchema<undefined>, undefined>;
            jsDocTags: RecordSchema<StringSchema<undefined>, ArraySchema<StringSchema<undefined>, undefined>, undefined>;
            argTypes: OptionalSchema<CustomSchema<StrictArgTypes<Args>, undefined>, undefined>;
            error: OptionalSchema<ObjectSchema<{
                readonly name: StringSchema<undefined>;
                readonly message: StringSchema<undefined>;
            }, undefined>, undefined>;
        }, undefined>, undefined>, undefined>;
        readonly name: StringSchema<undefined>;
        readonly path: StringSchema<undefined>;
        readonly description: OptionalSchema<StringSchema<undefined>, undefined>;
        readonly summary: OptionalSchema<StringSchema<undefined>, undefined>;
        readonly jsDocTags: RecordSchema<StringSchema<undefined>, ArraySchema<StringSchema<undefined>, undefined>, undefined>;
        readonly argTypes: OptionalSchema<CustomSchema<StrictArgTypes<Args>, undefined>, undefined>;
        readonly error: OptionalSchema<ObjectSchema<{
            readonly name: StringSchema<undefined>;
            readonly message: StringSchema<undefined>;
        }, undefined>, undefined>;
        readonly id: StringSchema<undefined>;
    }, undefined>, undefined>, {
        readonly extractDocgen: ObjectSchema<{
            readonly id: StringSchema<undefined>;
        }, undefined>;
        readonly extractAllDocgen: UndefinedSchema<undefined>;
    }, {
        readonly extractDocgen: OptionalSchema<LooseObjectSchema<{
            readonly subcomponents: OptionalSchema<RecordSchema<StringSchema<undefined>, LooseObjectSchema<{
                import: OptionalSchema<StringSchema<undefined>, undefined>;
                name: StringSchema<undefined>;
                path: StringSchema<undefined>;
                description: OptionalSchema<StringSchema<undefined>, undefined>;
                summary: OptionalSchema<StringSchema<undefined>, undefined>;
                jsDocTags: RecordSchema<StringSchema<undefined>, ArraySchema<StringSchema<undefined>, undefined>, undefined>;
                argTypes: OptionalSchema<CustomSchema<StrictArgTypes<Args>, undefined>, undefined>;
                error: OptionalSchema<ObjectSchema<{
                    readonly name: StringSchema<undefined>;
                    readonly message: StringSchema<undefined>;
                }, undefined>, undefined>;
            }, undefined>, undefined>, undefined>;
            readonly name: StringSchema<undefined>;
            readonly path: StringSchema<undefined>;
            readonly description: OptionalSchema<StringSchema<undefined>, undefined>;
            readonly summary: OptionalSchema<StringSchema<undefined>, undefined>;
            readonly jsDocTags: RecordSchema<StringSchema<undefined>, ArraySchema<StringSchema<undefined>, undefined>, undefined>;
            readonly argTypes: OptionalSchema<CustomSchema<StrictArgTypes<Args>, undefined>, undefined>;
            readonly error: OptionalSchema<ObjectSchema<{
                readonly name: StringSchema<undefined>;
                readonly message: StringSchema<undefined>;
            }, undefined>, undefined>;
            readonly id: StringSchema<undefined>;
        }, undefined>, undefined>;
        readonly extractAllDocgen: VoidSchema<undefined>;
    }, QueryFunctions<{
        readonly docgen: ObjectSchema<{
            readonly id: StringSchema<undefined>;
        }, undefined>;
        readonly docgenForAllComponents: VoidSchema<undefined>;
    }, {
        readonly docgen: OptionalSchema<LooseObjectSchema<{
            readonly subcomponents: OptionalSchema<RecordSchema<StringSchema<undefined>, LooseObjectSchema<{
                import: OptionalSchema<StringSchema<undefined>, undefined>;
                name: StringSchema<undefined>;
                path: StringSchema<undefined>;
                description: OptionalSchema<StringSchema<undefined>, undefined>;
                summary: OptionalSchema<StringSchema<undefined>, undefined>;
                jsDocTags: RecordSchema<StringSchema<undefined>, ArraySchema<StringSchema<undefined>, undefined>, undefined>;
                argTypes: OptionalSchema<CustomSchema<StrictArgTypes<Args>, undefined>, undefined>;
                error: OptionalSchema<ObjectSchema<{
                    readonly name: StringSchema<undefined>;
                    readonly message: StringSchema<undefined>;
                }, undefined>, undefined>;
            }, undefined>, undefined>, undefined>;
            readonly name: StringSchema<undefined>;
            readonly path: StringSchema<undefined>;
            readonly description: OptionalSchema<StringSchema<undefined>, undefined>;
            readonly summary: OptionalSchema<StringSchema<undefined>, undefined>;
            readonly jsDocTags: RecordSchema<StringSchema<undefined>, ArraySchema<StringSchema<undefined>, undefined>, undefined>;
            readonly argTypes: OptionalSchema<CustomSchema<StrictArgTypes<Args>, undefined>, undefined>;
            readonly error: OptionalSchema<ObjectSchema<{
                readonly name: StringSchema<undefined>;
                readonly message: StringSchema<undefined>;
            }, undefined>, undefined>;
            readonly id: StringSchema<undefined>;
        }, undefined>, undefined>;
        readonly docgenForAllComponents: RecordSchema<StringSchema<undefined>, LooseObjectSchema<{
            readonly subcomponents: OptionalSchema<RecordSchema<StringSchema<undefined>, LooseObjectSchema<{
                import: OptionalSchema<StringSchema<undefined>, undefined>;
                name: StringSchema<undefined>;
                path: StringSchema<undefined>;
                description: OptionalSchema<StringSchema<undefined>, undefined>;
                summary: OptionalSchema<StringSchema<undefined>, undefined>;
                jsDocTags: RecordSchema<StringSchema<undefined>, ArraySchema<StringSchema<undefined>, undefined>, undefined>;
                argTypes: OptionalSchema<CustomSchema<StrictArgTypes<Args>, undefined>, undefined>;
                error: OptionalSchema<ObjectSchema<{
                    readonly name: StringSchema<undefined>;
                    readonly message: StringSchema<undefined>;
                }, undefined>, undefined>;
            }, undefined>, undefined>, undefined>;
            readonly name: StringSchema<undefined>;
            readonly path: StringSchema<undefined>;
            readonly description: OptionalSchema<StringSchema<undefined>, undefined>;
            readonly summary: OptionalSchema<StringSchema<undefined>, undefined>;
            readonly jsDocTags: RecordSchema<StringSchema<undefined>, ArraySchema<StringSchema<undefined>, undefined>, undefined>;
            readonly argTypes: OptionalSchema<CustomSchema<StrictArgTypes<Args>, undefined>, undefined>;
            readonly error: OptionalSchema<ObjectSchema<{
                readonly name: StringSchema<undefined>;
                readonly message: StringSchema<undefined>;
            }, undefined>, undefined>;
            readonly id: StringSchema<undefined>;
        }, undefined>, undefined>;
    }>> & ({
        internal?: false;
    } | {
        __internal_naming_error: "Operation \"docgenForAllComponents\" has internal: true but must be prefixed with \"_\"";
    });
} & {
    readonly docgen: {
        output: OptionalSchema<LooseObjectSchema<{
            readonly subcomponents: OptionalSchema<RecordSchema<StringSchema<undefined>, LooseObjectSchema<{
                import: OptionalSchema<StringSchema<undefined>, undefined>;
                name: StringSchema<undefined>;
                path: StringSchema<undefined>;
                description: OptionalSchema<StringSchema<undefined>, undefined>;
                summary: OptionalSchema<StringSchema<undefined>, undefined>;
                jsDocTags: RecordSchema<StringSchema<undefined>, ArraySchema<StringSchema<undefined>, undefined>, undefined>;
                argTypes: OptionalSchema<CustomSchema<StrictArgTypes<Args>, undefined>, undefined>;
                error: OptionalSchema<ObjectSchema<{
                    readonly name: StringSchema<undefined>;
                    readonly message: StringSchema<undefined>;
                }, undefined>, undefined>;
            }, undefined>, undefined>, undefined>;
            readonly name: StringSchema<undefined>;
            readonly path: StringSchema<undefined>;
            readonly description: OptionalSchema<StringSchema<undefined>, undefined>;
            readonly summary: OptionalSchema<StringSchema<undefined>, undefined>;
            readonly jsDocTags: RecordSchema<StringSchema<undefined>, ArraySchema<StringSchema<undefined>, undefined>, undefined>;
            readonly argTypes: OptionalSchema<CustomSchema<StrictArgTypes<Args>, undefined>, undefined>;
            readonly error: OptionalSchema<ObjectSchema<{
                readonly name: StringSchema<undefined>;
                readonly message: StringSchema<undefined>;
            }, undefined>, undefined>;
            readonly id: StringSchema<undefined>;
        }, undefined>, undefined>;
    };
    readonly docgenForAllComponents: {
        output: RecordSchema<StringSchema<undefined>, LooseObjectSchema<{
            readonly subcomponents: OptionalSchema<RecordSchema<StringSchema<undefined>, LooseObjectSchema<{
                import: OptionalSchema<StringSchema<undefined>, undefined>;
                name: StringSchema<undefined>;
                path: StringSchema<undefined>;
                description: OptionalSchema<StringSchema<undefined>, undefined>;
                summary: OptionalSchema<StringSchema<undefined>, undefined>;
                jsDocTags: RecordSchema<StringSchema<undefined>, ArraySchema<StringSchema<undefined>, undefined>, undefined>;
                argTypes: OptionalSchema<CustomSchema<StrictArgTypes<Args>, undefined>, undefined>;
                error: OptionalSchema<ObjectSchema<{
                    readonly name: StringSchema<undefined>;
                    readonly message: StringSchema<undefined>;
                }, undefined>, undefined>;
            }, undefined>, undefined>, undefined>;
            readonly name: StringSchema<undefined>;
            readonly path: StringSchema<undefined>;
            readonly description: OptionalSchema<StringSchema<undefined>, undefined>;
            readonly summary: OptionalSchema<StringSchema<undefined>, undefined>;
            readonly jsDocTags: RecordSchema<StringSchema<undefined>, ArraySchema<StringSchema<undefined>, undefined>, undefined>;
            readonly argTypes: OptionalSchema<CustomSchema<StrictArgTypes<Args>, undefined>, undefined>;
            readonly error: OptionalSchema<ObjectSchema<{
                readonly name: StringSchema<undefined>;
                readonly message: StringSchema<undefined>;
            }, undefined>, undefined>;
            readonly id: StringSchema<undefined>;
        }, undefined>, undefined>;
    };
}, {
    readonly extractDocgen: CommandDefinition<{
        components: Record<string, DocgenPayload>;
    }, ObjectSchema<{
        readonly id: StringSchema<undefined>;
    }, undefined>, OptionalSchema<LooseObjectSchema<{
        readonly subcomponents: OptionalSchema<RecordSchema<StringSchema<undefined>, LooseObjectSchema<{
            import: OptionalSchema<StringSchema<undefined>, undefined>;
            name: StringSchema<undefined>;
            path: StringSchema<undefined>;
            description: OptionalSchema<StringSchema<undefined>, undefined>;
            summary: OptionalSchema<StringSchema<undefined>, undefined>;
            jsDocTags: RecordSchema<StringSchema<undefined>, ArraySchema<StringSchema<undefined>, undefined>, undefined>;
            argTypes: OptionalSchema<CustomSchema<StrictArgTypes<Args>, undefined>, undefined>;
            error: OptionalSchema<ObjectSchema<{
                readonly name: StringSchema<undefined>;
                readonly message: StringSchema<undefined>;
            }, undefined>, undefined>;
        }, undefined>, undefined>, undefined>;
        readonly name: StringSchema<undefined>;
        readonly path: StringSchema<undefined>;
        readonly description: OptionalSchema<StringSchema<undefined>, undefined>;
        readonly summary: OptionalSchema<StringSchema<undefined>, undefined>;
        readonly jsDocTags: RecordSchema<StringSchema<undefined>, ArraySchema<StringSchema<undefined>, undefined>, undefined>;
        readonly argTypes: OptionalSchema<CustomSchema<StrictArgTypes<Args>, undefined>, undefined>;
        readonly error: OptionalSchema<ObjectSchema<{
            readonly name: StringSchema<undefined>;
            readonly message: StringSchema<undefined>;
        }, undefined>, undefined>;
        readonly id: StringSchema<undefined>;
    }, undefined>, undefined>, {
        readonly extractDocgen: ObjectSchema<{
            readonly id: StringSchema<undefined>;
        }, undefined>;
        readonly extractAllDocgen: UndefinedSchema<undefined>;
    }, {
        readonly extractDocgen: OptionalSchema<LooseObjectSchema<{
            readonly subcomponents: OptionalSchema<RecordSchema<StringSchema<undefined>, LooseObjectSchema<{
                import: OptionalSchema<StringSchema<undefined>, undefined>;
                name: StringSchema<undefined>;
                path: StringSchema<undefined>;
                description: OptionalSchema<StringSchema<undefined>, undefined>;
                summary: OptionalSchema<StringSchema<undefined>, undefined>;
                jsDocTags: RecordSchema<StringSchema<undefined>, ArraySchema<StringSchema<undefined>, undefined>, undefined>;
                argTypes: OptionalSchema<CustomSchema<StrictArgTypes<Args>, undefined>, undefined>;
                error: OptionalSchema<ObjectSchema<{
                    readonly name: StringSchema<undefined>;
                    readonly message: StringSchema<undefined>;
                }, undefined>, undefined>;
            }, undefined>, undefined>, undefined>;
            readonly name: StringSchema<undefined>;
            readonly path: StringSchema<undefined>;
            readonly description: OptionalSchema<StringSchema<undefined>, undefined>;
            readonly summary: OptionalSchema<StringSchema<undefined>, undefined>;
            readonly jsDocTags: RecordSchema<StringSchema<undefined>, ArraySchema<StringSchema<undefined>, undefined>, undefined>;
            readonly argTypes: OptionalSchema<CustomSchema<StrictArgTypes<Args>, undefined>, undefined>;
            readonly error: OptionalSchema<ObjectSchema<{
                readonly name: StringSchema<undefined>;
                readonly message: StringSchema<undefined>;
            }, undefined>, undefined>;
            readonly id: StringSchema<undefined>;
        }, undefined>, undefined>;
        readonly extractAllDocgen: VoidSchema<undefined>;
    }, QueryFunctions<{
        readonly docgen: ObjectSchema<{
            readonly id: StringSchema<undefined>;
        }, undefined>;
        readonly docgenForAllComponents: VoidSchema<undefined>;
    }, {
        readonly docgen: OptionalSchema<LooseObjectSchema<{
            readonly subcomponents: OptionalSchema<RecordSchema<StringSchema<undefined>, LooseObjectSchema<{
                import: OptionalSchema<StringSchema<undefined>, undefined>;
                name: StringSchema<undefined>;
                path: StringSchema<undefined>;
                description: OptionalSchema<StringSchema<undefined>, undefined>;
                summary: OptionalSchema<StringSchema<undefined>, undefined>;
                jsDocTags: RecordSchema<StringSchema<undefined>, ArraySchema<StringSchema<undefined>, undefined>, undefined>;
                argTypes: OptionalSchema<CustomSchema<StrictArgTypes<Args>, undefined>, undefined>;
                error: OptionalSchema<ObjectSchema<{
                    readonly name: StringSchema<undefined>;
                    readonly message: StringSchema<undefined>;
                }, undefined>, undefined>;
            }, undefined>, undefined>, undefined>;
            readonly name: StringSchema<undefined>;
            readonly path: StringSchema<undefined>;
            readonly description: OptionalSchema<StringSchema<undefined>, undefined>;
            readonly summary: OptionalSchema<StringSchema<undefined>, undefined>;
            readonly jsDocTags: RecordSchema<StringSchema<undefined>, ArraySchema<StringSchema<undefined>, undefined>, undefined>;
            readonly argTypes: OptionalSchema<CustomSchema<StrictArgTypes<Args>, undefined>, undefined>;
            readonly error: OptionalSchema<ObjectSchema<{
                readonly name: StringSchema<undefined>;
                readonly message: StringSchema<undefined>;
            }, undefined>, undefined>;
            readonly id: StringSchema<undefined>;
        }, undefined>, undefined>;
        readonly docgenForAllComponents: RecordSchema<StringSchema<undefined>, LooseObjectSchema<{
            readonly subcomponents: OptionalSchema<RecordSchema<StringSchema<undefined>, LooseObjectSchema<{
                import: OptionalSchema<StringSchema<undefined>, undefined>;
                name: StringSchema<undefined>;
                path: StringSchema<undefined>;
                description: OptionalSchema<StringSchema<undefined>, undefined>;
                summary: OptionalSchema<StringSchema<undefined>, undefined>;
                jsDocTags: RecordSchema<StringSchema<undefined>, ArraySchema<StringSchema<undefined>, undefined>, undefined>;
                argTypes: OptionalSchema<CustomSchema<StrictArgTypes<Args>, undefined>, undefined>;
                error: OptionalSchema<ObjectSchema<{
                    readonly name: StringSchema<undefined>;
                    readonly message: StringSchema<undefined>;
                }, undefined>, undefined>;
            }, undefined>, undefined>, undefined>;
            readonly name: StringSchema<undefined>;
            readonly path: StringSchema<undefined>;
            readonly description: OptionalSchema<StringSchema<undefined>, undefined>;
            readonly summary: OptionalSchema<StringSchema<undefined>, undefined>;
            readonly jsDocTags: RecordSchema<StringSchema<undefined>, ArraySchema<StringSchema<undefined>, undefined>, undefined>;
            readonly argTypes: OptionalSchema<CustomSchema<StrictArgTypes<Args>, undefined>, undefined>;
            readonly error: OptionalSchema<ObjectSchema<{
                readonly name: StringSchema<undefined>;
                readonly message: StringSchema<undefined>;
            }, undefined>, undefined>;
            readonly id: StringSchema<undefined>;
        }, undefined>, undefined>;
    }>> & ({
        internal?: false;
    } | {
        __internal_naming_error: "Operation \"extractDocgen\" has internal: true but must be prefixed with \"_\"";
    });
    readonly extractAllDocgen: CommandDefinition<{
        components: Record<string, DocgenPayload>;
    }, UndefinedSchema<undefined>, VoidSchema<undefined>, {
        readonly extractDocgen: ObjectSchema<{
            readonly id: StringSchema<undefined>;
        }, undefined>;
        readonly extractAllDocgen: UndefinedSchema<undefined>;
    }, {
        readonly extractDocgen: OptionalSchema<LooseObjectSchema<{
            readonly subcomponents: OptionalSchema<RecordSchema<StringSchema<undefined>, LooseObjectSchema<{
                import: OptionalSchema<StringSchema<undefined>, undefined>;
                name: StringSchema<undefined>;
                path: StringSchema<undefined>;
                description: OptionalSchema<StringSchema<undefined>, undefined>;
                summary: OptionalSchema<StringSchema<undefined>, undefined>;
                jsDocTags: RecordSchema<StringSchema<undefined>, ArraySchema<StringSchema<undefined>, undefined>, undefined>;
                argTypes: OptionalSchema<CustomSchema<StrictArgTypes<Args>, undefined>, undefined>;
                error: OptionalSchema<ObjectSchema<{
                    readonly name: StringSchema<undefined>;
                    readonly message: StringSchema<undefined>;
                }, undefined>, undefined>;
            }, undefined>, undefined>, undefined>;
            readonly name: StringSchema<undefined>;
            readonly path: StringSchema<undefined>;
            readonly description: OptionalSchema<StringSchema<undefined>, undefined>;
            readonly summary: OptionalSchema<StringSchema<undefined>, undefined>;
            readonly jsDocTags: RecordSchema<StringSchema<undefined>, ArraySchema<StringSchema<undefined>, undefined>, undefined>;
            readonly argTypes: OptionalSchema<CustomSchema<StrictArgTypes<Args>, undefined>, undefined>;
            readonly error: OptionalSchema<ObjectSchema<{
                readonly name: StringSchema<undefined>;
                readonly message: StringSchema<undefined>;
            }, undefined>, undefined>;
            readonly id: StringSchema<undefined>;
        }, undefined>, undefined>;
        readonly extractAllDocgen: VoidSchema<undefined>;
    }, QueryFunctions<{
        readonly docgen: ObjectSchema<{
            readonly id: StringSchema<undefined>;
        }, undefined>;
        readonly docgenForAllComponents: VoidSchema<undefined>;
    }, {
        readonly docgen: OptionalSchema<LooseObjectSchema<{
            readonly subcomponents: OptionalSchema<RecordSchema<StringSchema<undefined>, LooseObjectSchema<{
                import: OptionalSchema<StringSchema<undefined>, undefined>;
                name: StringSchema<undefined>;
                path: StringSchema<undefined>;
                description: OptionalSchema<StringSchema<undefined>, undefined>;
                summary: OptionalSchema<StringSchema<undefined>, undefined>;
                jsDocTags: RecordSchema<StringSchema<undefined>, ArraySchema<StringSchema<undefined>, undefined>, undefined>;
                argTypes: OptionalSchema<CustomSchema<StrictArgTypes<Args>, undefined>, undefined>;
                error: OptionalSchema<ObjectSchema<{
                    readonly name: StringSchema<undefined>;
                    readonly message: StringSchema<undefined>;
                }, undefined>, undefined>;
            }, undefined>, undefined>, undefined>;
            readonly name: StringSchema<undefined>;
            readonly path: StringSchema<undefined>;
            readonly description: OptionalSchema<StringSchema<undefined>, undefined>;
            readonly summary: OptionalSchema<StringSchema<undefined>, undefined>;
            readonly jsDocTags: RecordSchema<StringSchema<undefined>, ArraySchema<StringSchema<undefined>, undefined>, undefined>;
            readonly argTypes: OptionalSchema<CustomSchema<StrictArgTypes<Args>, undefined>, undefined>;
            readonly error: OptionalSchema<ObjectSchema<{
                readonly name: StringSchema<undefined>;
                readonly message: StringSchema<undefined>;
            }, undefined>, undefined>;
            readonly id: StringSchema<undefined>;
        }, undefined>, undefined>;
        readonly docgenForAllComponents: RecordSchema<StringSchema<undefined>, LooseObjectSchema<{
            readonly subcomponents: OptionalSchema<RecordSchema<StringSchema<undefined>, LooseObjectSchema<{
                import: OptionalSchema<StringSchema<undefined>, undefined>;
                name: StringSchema<undefined>;
                path: StringSchema<undefined>;
                description: OptionalSchema<StringSchema<undefined>, undefined>;
                summary: OptionalSchema<StringSchema<undefined>, undefined>;
                jsDocTags: RecordSchema<StringSchema<undefined>, ArraySchema<StringSchema<undefined>, undefined>, undefined>;
                argTypes: OptionalSchema<CustomSchema<StrictArgTypes<Args>, undefined>, undefined>;
                error: OptionalSchema<ObjectSchema<{
                    readonly name: StringSchema<undefined>;
                    readonly message: StringSchema<undefined>;
                }, undefined>, undefined>;
            }, undefined>, undefined>, undefined>;
            readonly name: StringSchema<undefined>;
            readonly path: StringSchema<undefined>;
            readonly description: OptionalSchema<StringSchema<undefined>, undefined>;
            readonly summary: OptionalSchema<StringSchema<undefined>, undefined>;
            readonly jsDocTags: RecordSchema<StringSchema<undefined>, ArraySchema<StringSchema<undefined>, undefined>, undefined>;
            readonly argTypes: OptionalSchema<CustomSchema<StrictArgTypes<Args>, undefined>, undefined>;
            readonly error: OptionalSchema<ObjectSchema<{
                readonly name: StringSchema<undefined>;
                readonly message: StringSchema<undefined>;
            }, undefined>, undefined>;
            readonly id: StringSchema<undefined>;
        }, undefined>, undefined>;
    }>> & ({
        internal?: false;
    } | {
        __internal_naming_error: "Operation \"extractAllDocgen\" has internal: true but must be prefixed with \"_\"";
    });
} & {
    readonly extractDocgen: {
        output: OptionalSchema<LooseObjectSchema<{
            readonly subcomponents: OptionalSchema<RecordSchema<StringSchema<undefined>, LooseObjectSchema<{
                import: OptionalSchema<StringSchema<undefined>, undefined>;
                name: StringSchema<undefined>;
                path: StringSchema<undefined>;
                description: OptionalSchema<StringSchema<undefined>, undefined>;
                summary: OptionalSchema<StringSchema<undefined>, undefined>;
                jsDocTags: RecordSchema<StringSchema<undefined>, ArraySchema<StringSchema<undefined>, undefined>, undefined>;
                argTypes: OptionalSchema<CustomSchema<StrictArgTypes<Args>, undefined>, undefined>;
                error: OptionalSchema<ObjectSchema<{
                    readonly name: StringSchema<undefined>;
                    readonly message: StringSchema<undefined>;
                }, undefined>, undefined>;
            }, undefined>, undefined>, undefined>;
            readonly name: StringSchema<undefined>;
            readonly path: StringSchema<undefined>;
            readonly description: OptionalSchema<StringSchema<undefined>, undefined>;
            readonly summary: OptionalSchema<StringSchema<undefined>, undefined>;
            readonly jsDocTags: RecordSchema<StringSchema<undefined>, ArraySchema<StringSchema<undefined>, undefined>, undefined>;
            readonly argTypes: OptionalSchema<CustomSchema<StrictArgTypes<Args>, undefined>, undefined>;
            readonly error: OptionalSchema<ObjectSchema<{
                readonly name: StringSchema<undefined>;
                readonly message: StringSchema<undefined>;
            }, undefined>, undefined>;
            readonly id: StringSchema<undefined>;
        }, undefined>, undefined>;
    };
    readonly extractAllDocgen: {
        output: VoidSchema<undefined>;
    };
}, "core/docgen">)[];
/** Maps a list of service definitions to `{ [id]: instance }`, keyed by each definition's id. */
type CoreServices<TDefs extends readonly AnyServiceDefinition[]> = {
    [Def in TDefs[number] as Def['id']]: ServiceInstanceOf<Def>;
};
/** Core services registered in the preview. */
type PreviewCoreServices = CoreServices<typeof previewCoreServiceDefs>;
/** Module-level `getService` overloads keyed by a per-runtime core-service map. */
interface TypedGetService<TMap> {
    <K extends keyof TMap & ServiceId>(serviceId: K): TMap[K];
    <TInstance = RuntimeService>(serviceId: ServiceId): TInstance;
}

/** System tags used throughout Storybook for categorizing and filtering stories and docs entries. */
declare const Tag: {
    /** Indicates that autodocs should be generated for this component */
    readonly AUTODOCS: "autodocs";
    /** MDX documentation attached to a component's stories file */
    readonly ATTACHED_MDX: "attached-mdx";
    /** Standalone MDX documentation not attached to stories */
    readonly UNATTACHED_MDX: "unattached-mdx";
    /** Story has a play function */
    readonly PLAY_FN: "play-fn";
    /** Story has a test function */
    readonly TEST_FN: "test-fn";
    /** Development environment tag */
    readonly DEV: "dev";
    /** Test environment tag */
    readonly TEST: "test";
    /** Manifest generation tag */
    readonly MANIFEST: "manifest";
};
/**
 * Tags can be any string, including custom user-defined tags. The Tag constant above defines the
 * system tags used by Storybook.
 */
type Tag = string;

/**
 * Preview-side entrypoint for the open-service architecture.
 *
 * Import from here in preview (renderer) code. This entrypoint is intentionally renderer-agnostic —
 * it exposes only registration with no React dependencies. Use `.subscribe()` on queries to react
 * to state changes in your renderer.
 *
 * Define services with `storybook/open-service`. The manager entrypoint (`./manager.ts`) adds
 * `useServiceQuery` and `useServiceCommand` on top of relay registration.
 *
 * Quick start:
 *
 * ```ts
 * import { registerService } from 'storybook/preview-api';
 *
 * const service = registerService(myServiceDef);
 *
 * service.queries.color.subscribe(undefined, ({ data }) => {
 *   document.body.style.background = data ?? 'transparent';
 * });
 * ```
 */

declare const getService: TypedGetService<PreviewCoreServices>;
/**
 * Registers a service in the preview and returns its runtime surface.
 *
 * The preview is a leaf (`relay: false`). Builders install the addons channel before preview config
 * loads, so registration can assume the channel is already present.
 */
declare function registerService<TState, TQueries extends Queries<TState>, TCommands extends Commands<TState>>(definition: ServiceDefinition<TState, TQueries, TCommands>, registration?: ServiceRegistrationOptions<TState, TQueries, TCommands>): ServiceInstance<TState, TQueries, TCommands> & ServiceRegistryApi;

export { DocsContext, HooksContext, Preview, PreviewWeb, PreviewWithSelection, type PropDescriptor, type Report, ReporterAPI, type SelectionStore, StoryStore, Tag, UrlStore, type View, WebView, addons, applyHooks, clearChannel, combineArgs, combineParameters, composeConfigs, composeStepRunners, composeStories, composeStory, createPlaywrightTest, decorateStory, defaultDecorateStory, emitTransformCode, ensureChannel, filterArgTypes, getChannel, getCsfFactoryAnnotations, getService, inferControls, installNoopChannel, makeDecorator, mockChannel, normalizeArrays, normalizeProjectAnnotations, normalizeStory, pauseAnimations, prepareMeta, prepareStory, registerService, sanitizeStoryContextUpdate, setChannel, setDefaultProjectAnnotations, setProjectAnnotations, simulateDOMContentLoaded, simulatePageLoad, sortStoriesV7, useArgs, useCallback, useChannel, useEffect, useGlobals, useMemo, useParameter, useReducer, useRef, useState, useStoryContext, userOrAutoTitle, userOrAutoTitleFromSpecifier, waitForAnimations };