Brunobkr/llama.cpp_AlgMor24_github

1import { StoryId } from 'storybook/internal/csf';2import { NormalizedProjectAnnotations, ProjectAnnotations, ComposedStoryFn } from 'storybook/internal/types';3 4/**5 * Actions represent the type of change to a location value.6 */7declare enum Action {8    /**9     * A POP indicates a change to an arbitrary index in the history stack, such10     * as a back or forward navigation. It does not describe the direction of the11     * navigation, only that the current index changed.12     *13     * Note: This is the default action for newly created history objects.14     */15    Pop = "POP",16    /**17     * A PUSH indicates a new entry being added to the history stack, such as when18     * a link is clicked and a new page loads. When this happens, all subsequent19     * entries in the stack are lost.20     */21    Push = "PUSH",22    /**23     * A REPLACE indicates the entry at the current index in the history stack24     * being replaced by a new one.25     */26    Replace = "REPLACE"27}28/**29 * The pathname, search, and hash values of a URL.30 */31interface Path {32    /**33     * A URL pathname, beginning with a /.34     */35    pathname: string;36    /**37     * A URL search string, beginning with a ?.38     */39    search: string;40    /**41     * A URL fragment identifier, beginning with a #.42     */43    hash: string;44}45/**46 * An entry in a history stack. A location contains information about the47 * URL path, as well as possibly some arbitrary state and a key.48 */49interface Location extends Path {50    /**51     * A value of arbitrary data associated with this location.52     */53    state: any;54    /**55     * A unique string associated with this location. May be used to safely store56     * and retrieve data in some other storage API, like `localStorage`.57     *58     * Note: This value is always "default" on the initial location.59     */60    key: string;61}62 63/**64 * Map of routeId -> data returned from a loader/action/error65 */66interface RouteData {67    [routeId: string]: any;68}69declare enum ResultType {70    data = "data",71    deferred = "deferred",72    redirect = "redirect",73    error = "error"74}75/**76 * Successful result from a loader or action77 */78interface SuccessResult {79    type: ResultType.data;80    data: any;81    statusCode?: number;82    headers?: Headers;83}84/**85 * Successful defer() result from a loader or action86 */87interface DeferredResult {88    type: ResultType.deferred;89    deferredData: DeferredData;90    statusCode?: number;91    headers?: Headers;92}93/**94 * Redirect result from a loader or action95 */96interface RedirectResult {97    type: ResultType.redirect;98    status: number;99    location: string;100    revalidate: boolean;101    reloadDocument?: boolean;102}103/**104 * Unsuccessful result from a loader or action105 */106interface ErrorResult {107    type: ResultType.error;108    error: any;109    headers?: Headers;110}111/**112 * Result from a loader or action - potentially successful or unsuccessful113 */114type DataResult = SuccessResult | DeferredResult | RedirectResult | ErrorResult;115type LowerCaseFormMethod = "get" | "post" | "put" | "patch" | "delete";116type UpperCaseFormMethod = Uppercase<LowerCaseFormMethod>;117/**118 * Active navigation/fetcher form methods are exposed in lowercase on the119 * RouterState120 */121type FormMethod = LowerCaseFormMethod;122/**123 * In v7, active navigation/fetcher form methods are exposed in uppercase on the124 * RouterState.  This is to align with the normalization done via fetch().125 */126type V7_FormMethod = UpperCaseFormMethod;127type FormEncType = "application/x-www-form-urlencoded" | "multipart/form-data" | "application/json" | "text/plain";128type JsonObject = {129    [Key in string]: JsonValue;130} & {131    [Key in string]?: JsonValue | undefined;132};133type JsonArray = JsonValue[] | readonly JsonValue[];134type JsonPrimitive = string | number | boolean | null;135type JsonValue = JsonPrimitive | JsonObject | JsonArray;136/**137 * @private138 * Internal interface to pass around for action submissions, not intended for139 * external consumption140 */141type Submission = {142    formMethod: FormMethod | V7_FormMethod;143    formAction: string;144    formEncType: FormEncType;145    formData: FormData;146    json: undefined;147    text: undefined;148} | {149    formMethod: FormMethod | V7_FormMethod;150    formAction: string;151    formEncType: FormEncType;152    formData: undefined;153    json: JsonValue;154    text: undefined;155} | {156    formMethod: FormMethod | V7_FormMethod;157    formAction: string;158    formEncType: FormEncType;159    formData: undefined;160    json: undefined;161    text: string;162};163/**164 * @private165 * Arguments passed to route loader/action functions.  Same for now but we keep166 * this as a private implementation detail in case they diverge in the future.167 */168interface DataFunctionArgs {169    request: Request;170    params: Params;171    context?: any;172}173/**174 * Arguments passed to loader functions175 */176interface LoaderFunctionArgs extends DataFunctionArgs {177}178/**179 * Arguments passed to action functions180 */181interface ActionFunctionArgs extends DataFunctionArgs {182}183/**184 * Loaders and actions can return anything except `undefined` (`null` is a185 * valid return value if there is no data to return).  Responses are preferred186 * and will ease any future migration to Remix187 */188type DataFunctionValue = Response | NonNullable<unknown> | null;189/**190 * Route loader function signature191 */192interface LoaderFunction {193    (args: LoaderFunctionArgs): Promise<DataFunctionValue> | DataFunctionValue;194}195/**196 * Route action function signature197 */198interface ActionFunction {199    (args: ActionFunctionArgs): Promise<DataFunctionValue> | DataFunctionValue;200}201/**202 * Route shouldRevalidate function signature.  This runs after any submission203 * (navigation or fetcher), so we flatten the navigation/fetcher submission204 * onto the arguments.  It shouldn't matter whether it came from a navigation205 * or a fetcher, what really matters is the URLs and the formData since loaders206 * have to re-run based on the data models that were potentially mutated.207 */208interface ShouldRevalidateFunction {209    (args: {210        currentUrl: URL;211        currentParams: AgnosticDataRouteMatch["params"];212        nextUrl: URL;213        nextParams: AgnosticDataRouteMatch["params"];214        formMethod?: Submission["formMethod"];215        formAction?: Submission["formAction"];216        formEncType?: Submission["formEncType"];217        text?: Submission["text"];218        formData?: Submission["formData"];219        json?: Submission["json"];220        actionResult?: DataResult;221        defaultShouldRevalidate: boolean;222    }): boolean;223}224/**225 * Keys we cannot change from within a lazy() function. We spread all other keys226 * onto the route. Either they're meaningful to the router, or they'll get227 * ignored.228 */229type ImmutableRouteKey = "lazy" | "caseSensitive" | "path" | "id" | "index" | "children";230type RequireOne<T, Key = keyof T> = Exclude<{231    [K in keyof T]: K extends Key ? Omit<T, K> & Required<Pick<T, K>> : never;232}[keyof T], undefined>;233/**234 * lazy() function to load a route definition, which can add non-matching235 * related properties to a route236 */237interface LazyRouteFunction<R extends AgnosticRouteObject> {238    (): Promise<RequireOne<Omit<R, ImmutableRouteKey>>>;239}240/**241 * Base RouteObject with common props shared by all types of routes242 */243type AgnosticBaseRouteObject = {244    caseSensitive?: boolean;245    path?: string;246    id?: string;247    loader?: LoaderFunction;248    action?: ActionFunction;249    hasErrorBoundary?: boolean;250    shouldRevalidate?: ShouldRevalidateFunction;251    handle?: any;252    lazy?: LazyRouteFunction<AgnosticBaseRouteObject>;253};254/**255 * Index routes must not have children256 */257type AgnosticIndexRouteObject = AgnosticBaseRouteObject & {258    children?: undefined;259    index: true;260};261/**262 * Non-index routes may have children, but cannot have index263 */264type AgnosticNonIndexRouteObject = AgnosticBaseRouteObject & {265    children?: AgnosticRouteObject[];266    index?: false;267};268/**269 * A route object represents a logical route, with (optionally) its child270 * routes organized in a tree-like structure.271 */272type AgnosticRouteObject = AgnosticIndexRouteObject | AgnosticNonIndexRouteObject;273type AgnosticDataIndexRouteObject = AgnosticIndexRouteObject & {274    id: string;275};276type AgnosticDataNonIndexRouteObject = AgnosticNonIndexRouteObject & {277    children?: AgnosticDataRouteObject[];278    id: string;279};280/**281 * A data route object, which is just a RouteObject with a required unique ID282 */283type AgnosticDataRouteObject = AgnosticDataIndexRouteObject | AgnosticDataNonIndexRouteObject;284/**285 * The parameters that were parsed from the URL path.286 */287type Params<Key extends string = string> = {288    readonly [key in Key]: string | undefined;289};290/**291 * A RouteMatch contains info about how a route matched a URL.292 */293interface AgnosticRouteMatch<ParamKey extends string = string, RouteObjectType extends AgnosticRouteObject = AgnosticRouteObject> {294    /**295     * The names and values of dynamic parameters in the URL.296     */297    params: Params<ParamKey>;298    /**299     * The portion of the URL pathname that was matched.300     */301    pathname: string;302    /**303     * The portion of the URL pathname that was matched before child routes.304     */305    pathnameBase: string;306    /**307     * The route object that was used to match.308     */309    route: RouteObjectType;310}311interface AgnosticDataRouteMatch extends AgnosticRouteMatch<string, AgnosticDataRouteObject> {312}313declare class DeferredData {314    private pendingKeysSet;315    private controller;316    private abortPromise;317    private unlistenAbortSignal;318    private subscribers;319    data: Record<string, unknown>;320    init?: ResponseInit;321    deferredKeys: string[];322    constructor(data: Record<string, unknown>, responseInit?: ResponseInit);323    private trackPromise;324    private onSettle;325    private emit;326    subscribe(fn: (aborted: boolean, settledKey?: string) => void): () => boolean;327    cancel(): void;328    resolveData(signal: AbortSignal): Promise<boolean>;329    get done(): boolean;330    get unwrappedData(): {};331    get pendingKeys(): string[];332}333 334/**335 * State maintained internally by the router.  During a navigation, all states336 * reflect the the "old" location unless otherwise noted.337 */338interface RouterState {339    /**340     * The action of the most recent navigation341     */342    historyAction: Action;343    /**344     * The current location reflected by the router345     */346    location: Location;347    /**348     * The current set of route matches349     */350    matches: AgnosticDataRouteMatch[];351    /**352     * Tracks whether we've completed our initial data load353     */354    initialized: boolean;355    /**356     * Current scroll position we should start at for a new view357     *  - number -> scroll position to restore to358     *  - false -> do not restore scroll at all (used during submissions)359     *  - null -> don't have a saved position, scroll to hash or top of page360     */361    restoreScrollPosition: number | false | null;362    /**363     * Indicate whether this navigation should skip resetting the scroll position364     * if we are unable to restore the scroll position365     */366    preventScrollReset: boolean;367    /**368     * Tracks the state of the current navigation369     */370    navigation: Navigation;371    /**372     * Tracks any in-progress revalidations373     */374    revalidation: RevalidationState;375    /**376     * Data from the loaders for the current matches377     */378    loaderData: RouteData;379    /**380     * Data from the action for the current matches381     */382    actionData: RouteData | null;383    /**384     * Errors caught from loaders for the current matches385     */386    errors: RouteData | null;387    /**388     * Map of current fetchers389     */390    fetchers: Map<string, Fetcher>;391    /**392     * Map of current blockers393     */394    blockers: Map<string, Blocker>;395}396/**397 * Data that can be passed into hydrate a Router from SSR398 */399type HydrationState = Partial<Pick<RouterState, "loaderData" | "actionData" | "errors">>;400/**401 * Potential states for state.navigation402 */403type NavigationStates = {404    Idle: {405        state: "idle";406        location: undefined;407        formMethod: undefined;408        formAction: undefined;409        formEncType: undefined;410        formData: undefined;411        json: undefined;412        text: undefined;413    };414    Loading: {415        state: "loading";416        location: Location;417        formMethod: Submission["formMethod"] | undefined;418        formAction: Submission["formAction"] | undefined;419        formEncType: Submission["formEncType"] | undefined;420        formData: Submission["formData"] | undefined;421        json: Submission["json"] | undefined;422        text: Submission["text"] | undefined;423    };424    Submitting: {425        state: "submitting";426        location: Location;427        formMethod: Submission["formMethod"];428        formAction: Submission["formAction"];429        formEncType: Submission["formEncType"];430        formData: Submission["formData"];431        json: Submission["json"];432        text: Submission["text"];433    };434};435type Navigation = NavigationStates[keyof NavigationStates];436type RevalidationState = "idle" | "loading";437/**438 * Potential states for fetchers439 */440type FetcherStates<TData = any> = {441    Idle: {442        state: "idle";443        formMethod: undefined;444        formAction: undefined;445        formEncType: undefined;446        text: undefined;447        formData: undefined;448        json: undefined;449        data: TData | undefined;450        " _hasFetcherDoneAnything "?: boolean;451    };452    Loading: {453        state: "loading";454        formMethod: Submission["formMethod"] | undefined;455        formAction: Submission["formAction"] | undefined;456        formEncType: Submission["formEncType"] | undefined;457        text: Submission["text"] | undefined;458        formData: Submission["formData"] | undefined;459        json: Submission["json"] | undefined;460        data: TData | undefined;461        " _hasFetcherDoneAnything "?: boolean;462    };463    Submitting: {464        state: "submitting";465        formMethod: Submission["formMethod"];466        formAction: Submission["formAction"];467        formEncType: Submission["formEncType"];468        text: Submission["text"];469        formData: Submission["formData"];470        json: Submission["json"];471        data: TData | undefined;472        " _hasFetcherDoneAnything "?: boolean;473    };474};475type Fetcher<TData = any> = FetcherStates<TData>[keyof FetcherStates<TData>];476interface BlockerBlocked {477    state: "blocked";478    reset(): void;479    proceed(): void;480    location: Location;481}482interface BlockerUnblocked {483    state: "unblocked";484    reset: undefined;485    proceed: undefined;486    location: undefined;487}488interface BlockerProceeding {489    state: "proceeding";490    reset: undefined;491    proceed: undefined;492    location: Location;493}494type Blocker = BlockerUnblocked | BlockerBlocked | BlockerProceeding;495 496/**497 * NOTE: If you refactor this to split up the modules into separate files,498 * you'll need to update the rollup config for react-router-dom-v5-compat.499 */500 501declare global {502    var __staticRouterHydrationData: HydrationState | undefined;503}504 505/** The Standard Typed interface. This is a base type extended by other specs. */506interface StandardTypedV1<Input = unknown, Output = Input> {507    /** The Standard properties. */508    readonly "~standard": StandardTypedV1.Props<Input, Output>;509}510declare namespace StandardTypedV1 {511    /** The Standard Typed properties interface. */512    interface Props<Input = unknown, Output = Input> {513        /** The version number of the standard. */514        readonly version: 1;515        /** The vendor name of the schema library. */516        readonly vendor: string;517        /** Inferred types associated with the schema. */518        readonly types?: Types<Input, Output> | undefined;519    }520    /** The Standard Typed types interface. */521    interface Types<Input = unknown, Output = Input> {522        /** The input type of the schema. */523        readonly input: Input;524        /** The output type of the schema. */525        readonly output: Output;526    }527    /** Infers the input type of a Standard Typed. */528    type InferInput<Schema extends StandardTypedV1> = NonNullable<Schema["~standard"]["types"]>["input"];529    /** Infers the output type of a Standard Typed. */530    type InferOutput<Schema extends StandardTypedV1> = NonNullable<Schema["~standard"]["types"]>["output"];531}532/** The Standard Schema interface. */533interface StandardSchemaV1<Input = unknown, Output = Input> {534    /** The Standard Schema properties. */535    readonly "~standard": StandardSchemaV1.Props<Input, Output>;536}537declare namespace StandardSchemaV1 {538    /** The Standard Schema properties interface. */539    interface Props<Input = unknown, Output = Input> extends StandardTypedV1.Props<Input, Output> {540        /** Validates unknown input values. */541        readonly validate: (value: unknown, options?: StandardSchemaV1.Options | undefined) => Result<Output> | Promise<Result<Output>>;542    }543    /** The result interface of the validate function. */544    type Result<Output> = SuccessResult<Output> | FailureResult;545    /** The result interface if validation succeeds. */546    interface SuccessResult<Output> {547        /** The typed output value. */548        readonly value: Output;549        /** A falsy value for `issues` indicates success. */550        readonly issues?: undefined;551    }552    interface Options {553        /** Explicit support for additional vendor-specific parameters, if needed. */554        readonly libraryOptions?: Record<string, unknown> | undefined;555    }556    /** The result interface if validation fails. */557    interface FailureResult {558        /** The issues of failed validation. */559        readonly issues: ReadonlyArray<Issue>;560    }561    /** The issue interface of the failure output. */562    interface Issue {563        /** The error message of the issue. */564        readonly message: string;565        /** The path of the issue, if any. */566        readonly path?: ReadonlyArray<PropertyKey | PathSegment> | undefined;567    }568    /** The path segment interface of the issue. */569    interface PathSegment {570        /** The key representing a path segment. */571        readonly key: PropertyKey;572    }573    /** The Standard types interface. */574    interface Types<Input = unknown, Output = Input> extends StandardTypedV1.Types<Input, Output> {575    }576    /** Infers the input type of a Standard. */577    type InferInput<Schema extends StandardTypedV1> = StandardTypedV1.InferInput<Schema>;578    /** Infers the output type of a Standard. */579    type InferOutput<Schema extends StandardTypedV1> = StandardTypedV1.InferOutput<Schema>;580}581 582/** Stable alias for service identifiers across definition, runtime, and registration APIs. */583type ServiceId = string;584 585declare global {586    var globalProjectAnnotations: NormalizedProjectAnnotations<any>;587    var defaultProjectAnnotations: ProjectAnnotations<any>;588}589type WrappedStoryRef = {590    __pw_type: 'jsx';591    props: Record<string, any>;592} | {593    __pw_type: 'importRef';594};595type UnwrappedJSXStoryRef = {596    __pw_type: 'jsx';597    type: UnwrappedImportStoryRef;598};599type UnwrappedImportStoryRef = ComposedStoryFn;600declare global {601    function __pwUnwrapObject(storyRef: WrappedStoryRef): Promise<UnwrappedJSXStoryRef | UnwrappedImportStoryRef>;602}603 604type StatusValue = 'status-value:pending' | 'status-value:success' | 'status-value:new' | 'status-value:modified' | 'status-value:affected' | 'status-value:reviewing' | 'status-value:warning' | 'status-value:error' | 'status-value:unknown';605type StatusTypeId = string;606interface Status {607    value: StatusValue;608    typeId: StatusTypeId;609    storyId: StoryId;610    title: string;611    description: string;612    data?: any;613    sidebarContextMenu?: boolean;614}615 616/** Identifies which operation surface produced a validation failure. */617type OperationKind = 'query' | 'command';618/**619 * Describes the operation and validation phase associated with a schema failure.620 */621type ValidationMeta = {622    kind: OperationKind;623    serviceId: ServiceId;624    name: string;625    phase: 'input' | 'output';626    issues: ReadonlyArray<StandardSchemaV1.Issue>;627};628 629declare abstract class StorybookError extends Error {630    private _name;631    /** Category of the error. Used to classify the type of error, e.g., 'PREVIEW_API'. */632    readonly category: string;633    /** Code representing the error. Used to uniquely identify the error, e.g., 1. */634    readonly code: number;635    /**636     * Data associated with the error. Used to provide additional information in the error message or637     * to be passed to telemetry.638     */639    readonly data: {};640    /**641     * Specifies the documentation for the error.642     *643     * - If `true`, links to a documentation page on the Storybook website (make sure it exists before644     *   enabling) – This is not implemented yet.645     * - If a string, uses the provided URL for documentation (external or FAQ links).646     * - If `false` (default), no documentation link is added.647     */648    readonly documentation: boolean | string | string[];649    /** Flag used to easily determine if the error originates from Storybook. */650    readonly fromStorybook: true;651    /**652     * Flag used to determine if the error is handled by us and should therefore not be shown to the653     * user.654     */655    isHandledError: boolean;656    get fullErrorCode(): `SB_${string}_${string}`;657    /** Overrides the default `Error.name` property in the format: SB_<CATEGORY>_<CODE>. */658    get name(): string;659    set name(name: string);660    /**661     * A collection of sub errors which relate to a parent error.662     *663     * Sub-errors are used to represent multiple related errors that occurred together. When a664     * StorybookError with sub-errors is sent to telemetry, both the parent error and each sub-error665     * are sent as separate telemetry events. This allows for better error tracking and debugging.666     *667     * @example668     *669     * ```ts670     * const error1 = new SomeError();671     * const error2 = new AnotherError();672     * const parentError = new ParentError({673     *   // ... other props674     *   subErrors: [error1, error2],675     * });676     * ```677     */678    subErrors: StorybookError[];679    constructor(props: {680        category: string;681        code: number;682        message: string;683        cause?: unknown;684        documentation?: boolean | string | string[];685        isHandledError?: boolean;686        name: string;687        /**688         * Optional array of sub-errors that are related to this error. When this error is sent to689         * telemetry, each sub-error will be sent as a separate event.690         */691        subErrors?: StorybookError[];692    });693    /** Generates the error message along with additional documentation link (if applicable). */694    static getFullMessage({ documentation, code, category, message, }: ConstructorParameters<typeof StorybookError>[0]): string;695}696 697/**698 * If you can't find a suitable category for your error, create one based on the package name/file699 * path of which the error is thrown. For instance: If it's from `@storybook/node-logger`, then700 * NODE-LOGGER If it's from a package that is too broad, e.g. @storybook/cli in the init command,701 * then use a combination like CLI_INIT702 */703declare enum Category {704    CLI = "CLI",705    CLI_INIT = "CLI_INIT",706    CLI_AUTOMIGRATE = "CLI_AUTOMIGRATE",707    CLI_UPGRADE = "CLI_UPGRADE",708    CLI_ADD = "CLI_ADD",709    CODEMOD = "CODEMOD",710    CORE_SERVER = "CORE-SERVER",711    CSF_PLUGIN = "CSF-PLUGIN",712    CSF_TOOLS = "CSF-TOOLS",713    CORE_COMMON = "CORE-COMMON",714    NODE_LOGGER = "NODE-LOGGER",715    TELEMETRY = "TELEMETRY",716    BUILDER_MANAGER = "BUILDER-MANAGER",717    BUILDER_VITE = "BUILDER-VITE",718    BUILDER_WEBPACK5 = "BUILDER-WEBPACK5",719    SOURCE_LOADER = "SOURCE-LOADER",720    POSTINSTALL = "POSTINSTALL",721    DOCS_TOOLS = "DOCS-TOOLS",722    CORE_WEBPACK = "CORE-WEBPACK",723    FRAMEWORK_ANGULAR = "FRAMEWORK_ANGULAR",724    FRAMEWORK_EMBER = "FRAMEWORK_EMBER",725    FRAMEWORK_HTML_VITE = "FRAMEWORK_HTML-VITE",726    FRAMEWORK_HTML_WEBPACK5 = "FRAMEWORK_HTML-WEBPACK5",727    FRAMEWORK_NEXTJS = "FRAMEWORK_NEXTJS",728    FRAMEWORK_PREACT_VITE = "FRAMEWORK_PREACT-VITE",729    FRAMEWORK_PREACT_WEBPACK5 = "FRAMEWORK_PREACT-WEBPACK5",730    FRAMEWORK_REACT_VITE = "FRAMEWORK_REACT-VITE",731    FRAMEWORK_REACT_WEBPACK5 = "FRAMEWORK_REACT-WEBPACK5",732    FRAMEWORK_SERVER_WEBPACK5 = "FRAMEWORK_SERVER-WEBPACK5",733    FRAMEWORK_SVELTE_VITE = "FRAMEWORK_SVELTE-VITE",734    FRAMEWORK_SVELTEKIT = "FRAMEWORK_SVELTEKIT",735    FRAMEWORK_VUE_VITE = "FRAMEWORK_VUE-VITE",736    FRAMEWORK_VUE_WEBPACK5 = "FRAMEWORK_VUE-WEBPACK5",737    FRAMEWORK_VUE3_VITE = "FRAMEWORK_VUE3-VITE",738    FRAMEWORK_VUE3_WEBPACK5 = "FRAMEWORK_VUE3-WEBPACK5",739    FRAMEWORK_WEB_COMPONENTS_VITE = "FRAMEWORK_WEB-COMPONENTS-VITE",740    FRAMEWORK_WEB_COMPONENTS_WEBPACK5 = "FRAMEWORK_WEB-COMPONENTS-WEBPACK5"741}742declare class NxProjectDetectedError extends StorybookError {743    constructor();744}745declare class MissingFrameworkFieldError extends StorybookError {746    constructor();747}748declare class InvalidFrameworkNameError extends StorybookError {749    data: {750        frameworkName: string;751    };752    constructor(data: {753        frameworkName: string;754    });755}756declare class CouldNotEvaluateFrameworkError extends StorybookError {757    data: {758        frameworkName: string;759    };760    constructor(data: {761        frameworkName: string;762    });763}764declare class ConflictingStaticDirConfigError extends StorybookError {765    constructor();766}767declare class InvalidStoriesEntryError extends StorybookError {768    constructor();769}770declare class OpenServiceValidationError extends StorybookError {771    data: ValidationMeta;772    constructor(data: ValidationMeta);773}774declare class OpenServiceDuplicateRegistrationError extends StorybookError {775    data: {776        serviceId: ServiceId;777    };778    constructor(data: {779        serviceId: ServiceId;780    });781}782declare class OpenServiceMissingServiceError extends StorybookError {783    data: {784        serviceId: ServiceId;785    };786    constructor(data: {787        serviceId: ServiceId;788    });789}790declare class OpenServiceUnimplementedOperationError extends StorybookError {791    data: {792        serviceId: ServiceId;793        name: string;794        kind: 'query' | 'command';795    };796    constructor(data: {797        serviceId: ServiceId;798        name: string;799        kind: 'query' | 'command';800    });801}802declare class OpenServiceInvalidStaticPathError extends StorybookError {803    data: {804        serviceId: ServiceId;805        name: string;806        path: string;807    };808    constructor(data: {809        serviceId: ServiceId;810        name: string;811        path: string;812    });813}814declare class OpenServiceAsyncSchemaError extends StorybookError {815    data: {816        serviceId: ServiceId;817        name: string;818        kind: 'query' | 'command';819        phase: 'input' | 'output';820    };821    constructor(data: {822        serviceId: ServiceId;823        name: string;824        kind: 'query' | 'command';825        phase: 'input' | 'output';826    });827}828declare class OpenServiceLoadedDrainExceededError extends StorybookError {829    data: {830        serviceId: ServiceId;831        name: string;832        iterations: number;833    };834    constructor(data: {835        serviceId: ServiceId;836        name: string;837        iterations: number;838    });839}840declare class OpenServiceDocgenMissingComponentError extends StorybookError {841    data: {842        id: string;843    };844    constructor(data: {845        id: string;846    });847}848declare class OpenServiceMissingChannelError extends StorybookError {849    data: {850        serviceId?: ServiceId;851    };852    constructor(data?: {853        serviceId?: ServiceId;854    });855}856declare class OpenServiceRemoteCommandDisconnectedError extends StorybookError {857    data: {858        serviceId: ServiceId;859    };860    constructor(data: {861        serviceId: ServiceId;862    });863}864declare class OpenServiceRemoteCommandUnhandledError extends StorybookError {865    data: {866        serviceId: ServiceId;867        commandName: string;868    };869    constructor(data: {870        serviceId: ServiceId;871        commandName: string;872    });873}874declare class WebpackMissingStatsError extends StorybookError {875    constructor();876}877declare class WebpackInvocationError extends StorybookError {878    data: {879        error: Error;880    };881    constructor(data: {882        error: Error;883    });884}885declare class WebpackCompilationError extends StorybookError {886    data: {887        errors: {888            message: string;889            stack?: string;890            name?: string;891        }[];892    };893    constructor(data: {894        errors: {895            message: string;896            stack?: string;897            name?: string;898        }[];899    });900}901declare class MissingAngularJsonError extends StorybookError {902    data: {903        path: string;904    };905    constructor(data: {906        path: string;907    });908}909declare class AngularLegacyBuildOptionsError extends StorybookError {910    constructor();911}912declare class CriticalPresetLoadError extends StorybookError {913    data: {914        error: Error;915        presetName: string;916    };917    constructor(data: {918        error: Error;919        presetName: string;920    });921}922declare class MissingBuilderError extends StorybookError {923    constructor();924}925declare class GoogleFontsDownloadError extends StorybookError {926    data: {927        fontFamily: string;928        url: string;929    };930    constructor(data: {931        fontFamily: string;932        url: string;933    });934}935declare class GoogleFontsLoadingError extends StorybookError {936    data: {937        error: unknown | Error;938        url: string;939    };940    constructor(data: {941        error: unknown | Error;942        url: string;943    });944}945declare class SvelteViteWithSvelteKitError extends StorybookError {946    constructor();947}948declare class NoMatchingExportError extends StorybookError {949    data: {950        error: unknown | Error;951    };952    constructor(data: {953        error: unknown | Error;954    });955}956declare class MainFileMissingError extends StorybookError {957    data: {958        location: string;959        source?: 'storybook' | 'vitest';960    };961    constructor(data: {962        location: string;963        source?: 'storybook' | 'vitest';964    });965}966declare class MainFileEvaluationError extends StorybookError {967    data: {968        location: string;969        error: Error;970    };971    constructor(data: {972        location: string;973        error: Error;974    });975}976declare class StatusTypeIdMismatchError extends StorybookError {977    data: {978        status: Status;979        typeId: StatusTypeId;980    };981    constructor(data: {982        status: Status;983        typeId: StatusTypeId;984    });985}986declare class NoFreePortError extends StorybookError {987    data: {988        requestedPort?: number;989    };990    constructor(data: {991        requestedPort?: number;992    });993}994declare class GenerateNewProjectOnInitError extends StorybookError {995    data: {996        error: unknown | Error;997        packageManager: string;998        projectType: string;999    };1000    constructor(data: {1001        error: unknown | Error;1002        packageManager: string;1003        projectType: string;1004    });1005}1006type MinimumReleaseAgeHandledErrorData = {1007    message: string;1008    cause?: unknown;1009} | {1010    packageManagerName: string;1011    minimumReleaseAgeConfigName: string;1012    minimumReleaseAgeConfigDocs: string;1013    minimumReleaseAgeExclusionsConfigName?: string;1014    minimumReleaseAgeExclusionsConfigDocs?: string;1015    failedPackage?: string | null;1016    cause?: unknown;1017};1018declare class MinimumReleaseAgeHandledError extends StorybookError {1019    data: MinimumReleaseAgeHandledErrorData;1020    constructor(data: MinimumReleaseAgeHandledErrorData);1021}1022declare class AddonVitestPostinstallPrerequisiteCheckError extends StorybookError {1023    data: {1024        reasons: string[];1025    };1026    constructor(data: {1027        reasons: string[];1028    });1029}1030declare class AddonVitestPostinstallFailedAddonA11yError extends StorybookError {1031    data: {1032        error: unknown | Error;1033    };1034    constructor(data: {1035        error: unknown | Error;1036    });1037}1038declare class AddonVitestPostinstallWorkspaceUpdateError extends StorybookError {1039    data: {1040        filePath: string;1041    };1042    constructor(data: {1043        filePath: string;1044    });1045}1046declare class AddonVitestPostinstallConfigUpdateError extends StorybookError {1047    data: {1048        filePath: string;1049    };1050    constructor(data: {1051        filePath: string;1052    });1053}1054declare class AddonVitestPostinstallError extends StorybookError {1055    data: {1056        errors: StorybookError[];1057    };1058    constructor(data: {1059        errors: StorybookError[];1060    });1061}1062declare class UpgradeStorybookToLowerVersionError extends StorybookError {1063    data: {1064        beforeVersion: string;1065        currentVersion: string;1066    };1067    constructor(data: {1068        beforeVersion: string;1069        currentVersion: string;1070    });1071}1072declare class UpgradeStorybookUnknownCurrentVersionError extends StorybookError {1073    constructor();1074}1075declare class NoStatsForViteDevError extends StorybookError {1076    constructor();1077}1078declare class ViteModuleGraphSubscriptionError extends StorybookError {1079    constructor();1080}1081declare class FindPackageVersionsError extends StorybookError {1082    data: {1083        error: Error | unknown;1084        packageName: string;1085        packageManager: string;1086    };1087    constructor(data: {1088        error: Error | unknown;1089        packageName: string;1090        packageManager: string;1091    });1092}1093declare class IncompatiblePostCssConfigError extends StorybookError {1094    data: {1095        error: Error;1096    };1097    constructor(data: {1098        error: Error;1099    });1100}1101declare class SavingGlobalSettingsFileError extends StorybookError {1102    data: {1103        filePath: string;1104        error: Error | unknown;1105    };1106    constructor(data: {1107        filePath: string;1108        error: Error | unknown;1109    });1110}1111declare class CommonJsConfigNotSupportedError extends StorybookError {1112    constructor();1113}1114declare class AutomigrateError extends StorybookError {1115    data: {1116        errors: Array<Error | unknown>;1117    };1118    constructor(data: {1119        errors: Array<Error | unknown>;1120    });1121}1122 1123export { AddonVitestPostinstallConfigUpdateError, AddonVitestPostinstallError, AddonVitestPostinstallFailedAddonA11yError, AddonVitestPostinstallPrerequisiteCheckError, AddonVitestPostinstallWorkspaceUpdateError, AngularLegacyBuildOptionsError, AutomigrateError, Category, CommonJsConfigNotSupportedError, ConflictingStaticDirConfigError, CouldNotEvaluateFrameworkError, CriticalPresetLoadError, FindPackageVersionsError, GenerateNewProjectOnInitError, GoogleFontsDownloadError, GoogleFontsLoadingError, IncompatiblePostCssConfigError, InvalidFrameworkNameError, InvalidStoriesEntryError, MainFileEvaluationError, MainFileMissingError, MinimumReleaseAgeHandledError, MissingAngularJsonError, MissingBuilderError, MissingFrameworkFieldError, NoFreePortError, NoMatchingExportError, NoStatsForViteDevError, NxProjectDetectedError, OpenServiceAsyncSchemaError, OpenServiceDocgenMissingComponentError, OpenServiceDuplicateRegistrationError, OpenServiceInvalidStaticPathError, OpenServiceLoadedDrainExceededError, OpenServiceMissingChannelError, OpenServiceMissingServiceError, OpenServiceRemoteCommandDisconnectedError, OpenServiceRemoteCommandUnhandledError, OpenServiceUnimplementedOperationError, OpenServiceValidationError, SavingGlobalSettingsFileError, StatusTypeIdMismatchError, StorybookError, SvelteViteWithSvelteKitError, UpgradeStorybookToLowerVersionError, UpgradeStorybookUnknownCurrentVersionError, ViteModuleGraphSubscriptionError, WebpackCompilationError, WebpackInvocationError, WebpackMissingStatsError };1124