@wix/zero-config-implementation 1.33.0 → 1.34.0

package/dist/index.d.ts

@@ -1,45 +1,2742 @@
-import { EditorReactComponent } from '@wix/zero-config-schema';
-import { ResultAsync } from 'neverthrow';
-import { NotFoundError, ParseError } from './errors';
-import { ExtractionError } from './extraction-types';
-import { RunExtractorsOptions } from './information-extractors/react';
-export interface ManifestResult {
-    component: EditorReactComponent;
-    errors: ExtractionError[];
-}
-/**
- * Extract component manifest from a TypeScript source file.
- *
- * @param componentPath - Path to the TypeScript source file
- * @param compiledEntryPath - Path to the built JS entry file of the component's package (e.g. dist/index.js)
- * @param options.onError - Called for each non-fatal extraction error as it occurs
- * @errors
- * - {@link NotFoundError} — Source file does not exist (phase: `compile`)
- * - {@link ParseError} — TypeScript config or component types could not be parsed (phase: `compile` | `extract`)
- */
-export interface ExtractComponentManifestOptions extends RunExtractorsOptions {
-    onError?: (error: ExtractionError) => void;
-}
-export declare function extractComponentManifest(componentPath: string, compiledEntryPath: string, options?: ExtractComponentManifestOptions): ResultAsync<ManifestResult, InstanceType<typeof NotFoundError> | InstanceType<typeof ParseError>>;
-export type { ExtractionError } from './extraction-types';
-export type { EditorReactComponent } from '@wix/zero-config-schema';
-export type { ComponentInfoWithCss, ExtractedCssInfo, ProcessComponentResult } from './manifest-pipeline';
-/** TypeScript compilation & static analysis */
-export { compileTsFile } from './ts-compiler';
-export { extractAllComponentInfo, extractDefaultComponentInfo } from './information-extractors/ts/components';
-export { extractCssImports } from './information-extractors/ts/css-imports';
-export type { ComponentInfo, PropInfo, ResolvedType, ResolvedKind, DefaultValue, } from './information-extractors/ts/types';
-/** React render-time extraction */
-export type { RunExtractorsOptions } from './information-extractors/react';
-export { runExtractors, ExtractorStore, buildElementTree, createPropTrackerExtractor, createCssPropertiesExtractor, } from './information-extractors/react';
-export type { ExtractionResult, ReactExtractor, RenderContext, CreateElementEvent, RenderCompleteEvent, ExtractedElement, PropTrackerData, PropTrackerExtractorState, CssPropertiesData, CoupledComponentInfo, CoupledProp, DOMBinding, TrackingStores, PropWriteInfo, PropSpyMeta, } from './information-extractors/react';
-/** CSS parsing & selector matching */
-export { parseCss } from './information-extractors/css';
-export type { CSSParserAPI } from './information-extractors/css';
-/** Error classes */
-export { BaseError, NotFoundError, ParseError, ValidationError, IoError, DefectError, withDefectBoundary, } from './errors';
-/** Module loader primitives */
-export { loadModule, findComponent } from './module-loader';
-export type { LoadModuleFailure } from './module-loader';
-export { renderWithExtractors } from './component-renderer';
-export type { CreateElementListener } from './component-renderer';
+import { ComponentType } from 'react';
+import { default as default_2 } from 'typescript';
+import { EditorReactComponent } from '@wix/zero-config-schema';
+import { Program } from 'typescript';
+
+/**
+ * Unbound added properties of a plugin
+ */
+declare interface AddedProperties {
+    [PropName: string]: unknown
+}
+
+/**
+ * Single aggregate error
+ */
+declare type AggregateErrorOption = unknown
+
+/**
+ * Optional aggregate `errors` array
+ */
+declare type AggregateErrors = DefinedAggregateErrors | undefined
+
+/**
+ * Object with an `errors` property to set as `error.errors`
+ */
+declare type AggregateErrorsProperty<
+AggregateErrorsArg extends AggregateErrors,
+CauseArg extends Cause,
+> =
+ConcatAggregateErrors<AggregateErrorsArg, CauseArg> extends never
+? { errors?: Error[] }
+: {
+    errors: NormalizeAggregateErrors<
+    ConcatAggregateErrors<AggregateErrorsArg, CauseArg>
+    >
+}
+
+/**
+ * Root error class for the entire project. All domain errors extend this.
+ *
+ * Plugins attached here cascade to every subclass automatically.
+ * The `phase` prop defaults to `"unknown"` and is overridden at the call
+ * site or via `mapErr` as the error propagates through pipeline stages.
+ */
+export declare const BaseError: SpecificErrorClass<    {
+name: "cli";
+isOptions: (options: unknown) => boolean;
+getOptions: (options?: Options) => {
+custom: string;
+stack?: boolean;
+cause?: boolean;
+props?: boolean;
+colors?: boolean;
+icon?: ("infinity" | "tick" | "info" | "warning" | "cross" | "square" | "squareSmall" | "squareSmallFilled" | "squareDarkShade" | "squareMediumShade" | "squareLightShade" | "squareTop" | "squareBottom" | "squareLeft" | "squareRight" | "squareCenter" | "circle" | "circleFilled" | "circleDotted" | "circleDouble" | "circleCircle" | "circleCross" | "circlePipe" | "circleQuestionMark" | "radioOn" | "radioOff" | "checkboxOn" | "checkboxOff" | "checkboxCircleOn" | "checkboxCircleOff" | "questionMarkPrefix" | "bullet" | "dot" | "ellipsis" | "pointer" | "pointerSmall" | "triangleUp" | "triangleUpSmall" | "triangleUpOutline" | "triangleDown" | "triangleDownSmall" | "triangleLeft" | "triangleLeftSmall" | "triangleRight" | "triangleRightSmall" | "lozenge" | "lozengeOutline" | "home" | "hamburger" | "smiley" | "mustache" | "heart" | "star" | "play" | "musicNote" | "musicNoteBeamed" | "nodejs" | "arrowUp" | "arrowDown" | "arrowLeft" | "arrowRight" | "arrowLeftRight" | "arrowUpDown" | "almostEqual" | "notEqual" | "lessOrEqual" | "greaterOrEqual" | "identical" | "subscriptZero" | "subscriptOne" | "subscriptTwo" | "subscriptThree" | "subscriptFour" | "subscriptFive" | "subscriptSix" | "subscriptSeven" | "subscriptEight" | "subscriptNine" | "oneHalf" | "oneThird" | "oneQuarter" | "oneFifth" | "oneSixth" | "oneSeventh" | "oneEighth" | "oneNinth" | "oneTenth" | "twoThirds" | "twoFifths" | "threeQuarters" | "threeFifths" | "threeEighths" | "fourFifths" | "fiveSixths" | "fiveEighths" | "sevenEighth" | "line" | "lineBold" | "lineDouble" | "lineDashed0" | "lineDashed1" | "lineDashed2" | "lineDashed3" | "lineDashed4" | "lineDashed5" | "lineDashed6" | "lineDashed7" | "lineDashed8" | "lineDashed9" | "lineDashed10" | "lineDashed11" | "lineDashed12" | "lineDashed13" | "lineDashed14" | "lineDashed15" | "lineVertical" | "lineVerticalBold" | "lineVerticalDouble" | "lineVerticalDashed0" | "lineVerticalDashed1" | "lineVerticalDashed2" | "lineVerticalDashed3" | "lineVerticalDashed4" | "lineVerticalDashed5" | "lineVerticalDashed6" | "lineVerticalDashed7" | "lineVerticalDashed8" | "lineVerticalDashed9" | "lineVerticalDashed10" | "lineVerticalDashed11" | "lineDownLeft" | "lineDownLeftArc" | "lineDownBoldLeftBold" | "lineDownBoldLeft" | "lineDownLeftBold" | "lineDownDoubleLeftDouble" | "lineDownDoubleLeft" | "lineDownLeftDouble" | "lineDownRight" | "lineDownRightArc" | "lineDownBoldRightBold" | "lineDownBoldRight" | "lineDownRightBold" | "lineDownDoubleRightDouble" | "lineDownDoubleRight" | "lineDownRightDouble" | "lineUpLeft" | "lineUpLeftArc" | "lineUpBoldLeftBold" | "lineUpBoldLeft" | "lineUpLeftBold" | "lineUpDoubleLeftDouble" | "lineUpDoubleLeft" | "lineUpLeftDouble" | "lineUpRight" | "lineUpRightArc" | "lineUpBoldRightBold" | "lineUpBoldRight" | "lineUpRightBold" | "lineUpDoubleRightDouble" | "lineUpDoubleRight" | "lineUpRightDouble" | "lineUpDownLeft" | "lineUpBoldDownBoldLeftBold" | "lineUpBoldDownBoldLeft" | "lineUpDownLeftBold" | "lineUpBoldDownLeftBold" | "lineUpDownBoldLeftBold" | "lineUpDownBoldLeft" | "lineUpBoldDownLeft" | "lineUpDoubleDownDoubleLeftDouble" | "lineUpDoubleDownDoubleLeft" | "lineUpDownLeftDouble" | "lineUpDownRight" | "lineUpBoldDownBoldRightBold" | "lineUpBoldDownBoldRight" | "lineUpDownRightBold" | "lineUpBoldDownRightBold" | "lineUpDownBoldRightBold" | "lineUpDownBoldRight" | "lineUpBoldDownRight" | "lineUpDoubleDownDoubleRightDouble" | "lineUpDoubleDownDoubleRight" | "lineUpDownRightDouble" | "lineDownLeftRight" | "lineDownBoldLeftBoldRightBold" | "lineDownLeftBoldRightBold" | "lineDownBoldLeftRight" | "lineDownBoldLeftBoldRight" | "lineDownBoldLeftRightBold" | "lineDownLeftRightBold" | "lineDownLeftBoldRight" | "lineDownDoubleLeftDoubleRightDouble" | "lineDownDoubleLeftRight" | "lineDownLeftDoubleRightDouble" | "lineUpLeftRight" | "lineUpBoldLeftBoldRightBold" | "lineUpLeftBoldRightBold" | "lineUpBoldLeftRight" | "lineUpBoldLeftBoldRight" | "lineUpBoldLeftRightBold" | "lineUpLeftRightBold" | "lineUpLeftBoldRight" | "lineUpDoubleLeftDoubleRightDouble" | "lineUpDoubleLeftRight" | "lineUpLeftDoubleRightDouble" | "lineUpDownLeftRight" | "lineUpBoldDownBoldLeftBoldRightBold" | "lineUpDownBoldLeftBoldRightBold" | "lineUpBoldDownLeftBoldRightBold" | "lineUpBoldDownBoldLeftRightBold" | "lineUpBoldDownBoldLeftBoldRight" | "lineUpBoldDownLeftRight" | "lineUpDownBoldLeftRight" | "lineUpDownLeftBoldRight" | "lineUpDownLeftRightBold" | "lineUpBoldDownBoldLeftRight" | "lineUpDownLeftBoldRightBold" | "lineUpBoldDownLeftBoldRight" | "lineUpBoldDownLeftRightBold" | "lineUpDownBoldLeftBoldRight" | "lineUpDownBoldLeftRightBold" | "lineUpDoubleDownDoubleLeftDoubleRightDouble" | "lineUpDoubleDownDoubleLeftRight" | "lineUpDownLeftDoubleRightDouble" | "lineCross" | "lineBackslash" | "lineSlash") | "";
+header?: Styles | "";
+classes?: {
+readonly [errorName: string]: Omit<Options_3, "classes">;
+} & {
+readonly [errorName: string]: Omit<Options_2, "classes">;
+};
+exitCode?: number;
+silent?: boolean;
+timeout?: number;
+log?: (message: string) => void;
+};
+instanceMethods: {
+exit: ({ error, options }: Info<Options>["instanceMethods"]) => void;
+pretty: ({ error, options: { exitCode, silent, timeout, log, ...beautifulErrorOptions }, }: Info<Options>["instanceMethods"]) => string;
+};
+}[], {
+/** Pipeline stage where the error originated (composed at runtime). */
+phase: string;
+/** True if this error represents a violated invariant, not a user error. */
+isDefect: boolean;
+/** Process exit code used by BaseError.exit(). */
+exitCode: number;
+}, CustomClass>;
+
+declare type BasicColors =
+| 'black'
+| 'red'
+| 'green'
+| 'yellow'
+| 'blue'
+| 'magenta'
+| 'cyan'
+| 'white'
+| 'gray'
+
+declare type BasicStyle =
+| 'bold'
+| 'underline'
+| 'inverse'
+| 'reset'
+| 'dim'
+| 'italic'
+| 'hidden'
+| 'strikethrough'
+| 'visible'
+
+/**
+ * Builds an element tree from HTML, merging with store data.
+ * Each element gets a semantic name from concatenated ancestor names.
+ */
+export declare function buildElementTree(html: string, store: ExtractorStore): ExtractedElement[];
+
+/**
+ * Optional `cause` option
+ */
+declare type Cause = unknown
+
+declare type CollectResults<T, Collected extends unknown[] = [], Depth extends number = 50> = [
+Depth
+] extends [never] ? [] : T extends [infer H, ...infer Rest] ? H extends Result<infer L, infer R> ? CollectResults<Rest, [
+...Collected,
+[L, R]
+], Prev[Depth]> : never : Collected;
+
+declare type Combine<T, Depth extends number = 5> = Transpose<CollectResults<T>, [], Depth> extends [
+infer L,
+infer R
+] ? [UnknownMembersToNever<L>, UnknownMembersToNever<R>] : Transpose<CollectResults<T>, [], Depth> extends [] ? [[], []] : never;
+
+declare type CombineResultAsyncs<T extends readonly ResultAsync<unknown, unknown>[]> = IsLiteralArray<T> extends 1 ? TraverseAsync<UnwrapAsync<T>> : ResultAsync<ExtractOkAsyncTypes<T>, ExtractErrAsyncTypes<T>[number]>;
+
+declare type CombineResults<T extends readonly Result<unknown, unknown>[]> = IsLiteralArray<T> extends 1 ? Traverse<T> : Result<ExtractOkTypes<T>, ExtractErrTypes<T>[number]>;
+
+declare type CombineResultsWithAllErrorsArray<T extends readonly Result<unknown, unknown>[]> = IsLiteralArray<T> extends 1 ? TraverseWithAllErrors<T> : Result<ExtractOkTypes<T>, ExtractErrTypes<T>[number][]>;
+
+declare type CombineResultsWithAllErrorsArrayAsync<T extends readonly ResultAsync<unknown, unknown>[]> = IsLiteralArray<T> extends 1 ? TraverseWithAllErrorsAsync<UnwrapAsync<T>> : ResultAsync<ExtractOkAsyncTypes<T>, ExtractErrAsyncTypes<T>[number][]>;
+
+/**
+ * Properties shared by all `info` objects.
+ *
+ * @private This type is private and only exported as a temporary workaround
+ * for an open issue with TypeScript. It will be removed in a future release.
+ * See:
+ *
+ * - [modern-errors issue #18](https://github.com/ehmicky/modern-errors/issues/18)
+ * - [TypeScript issue #47663](https://github.com/microsoft/TypeScript/issues/47663)
+ */
+declare interface CommonInfo<Options = never> {
+    /**
+     * Normalized error instance.
+     *
+     * @example
+     * ```js
+     * export default {
+     *   name: 'example',
+     *   properties({ error }) {
+     *     return { isInputError: error.name === 'InputError' }
+     *   },
+     * }
+     * ```
+     */
+    error: ErrorInstance
+
+    /**
+     * Plugin's options, as returned by `getOptions()`.
+     *
+     * @example
+     * ```js
+     * export default {
+     *   name: 'example',
+     *   getOptions(options) {
+     *     return options
+     *   },
+     *   // `new ErrorClass('message', { example: value })` sets
+     *   // `error.example: value`
+     *   properties({ options }) {
+     *     return { example: options }
+     *   },
+     * }
+     * ```
+     */
+    readonly options: Options
+
+    /**
+     * Current error class.
+     *
+     * @example
+     * ```js
+     * export default {
+     *   name: 'example',
+     *   instanceMethods: {
+     *     addErrors({ error, ErrorClass }, errors = []) {
+     *       error.errors = errors.map(ErrorClass.normalize)
+     *     },
+     *   },
+     * }
+     * ```
+     */
+    readonly ErrorClass: ErrorClass
+
+    /**
+     * Array containing both the current error class and all its subclasses
+     * (including deep ones).
+     *
+     * @example
+     * ```js
+     * export default {
+     *   name: 'example',
+     *   staticMethods: {
+     *     isKnownErrorClass({ ErrorClasses }, value) {
+     *       return ErrorClasses.includes(value)
+     *     },
+     *   },
+     * }
+     * ```
+     */
+    readonly ErrorClasses: readonly ErrorClass[]
+
+    /**
+     * Returns the `info` object from a specific `Error`.
+     * All members are present except for `info.errorInfo` itself.
+     *
+     * @example
+     * ```js
+     * export default {
+     *   name: 'example',
+     *   staticMethods: {
+     *     getLogErrors:
+     *       ({ errorInfo }) =>
+     *       (errors) => {
+     *         errors.forEach((error) => {
+     *           const { options } = errorInfo(error)
+     *           console.error(options.example?.stack ? error.stack : error.message)
+     *         })
+     *     },
+     *   },
+     * }
+     * ```
+     */
+    readonly errorInfo: (error: unknown) => Info['errorInfo']
+}
+
+/**
+ * Compile a TypeScript file into a ts.Program.
+ *
+ * @param filePath - Path to the TypeScript source file
+ * @returns The compiled TypeScript program on success
+ * @errors
+ * - {@link NotFoundError} — Source file does not exist (phase: `compile`)
+ * - {@link ParseError} — TypeScript config could not be parsed (phase: `compile`)
+ */
+export declare function compileTsFile(filePath: string): ResultAsync<default_2.Program, InstanceType<typeof NotFoundError> | InstanceType<typeof ParseError>>;
+
+export declare interface ComponentInfo {
+    componentName: string;
+    props: Record<string, PropInfo>;
+}
+
+export declare interface ComponentInfoWithCss extends CoupledComponentInfo {
+    css: ExtractedCssInfo[];
+    varUsedByTraceId: Map<string, Set<string>>;
+}
+
+/**
+ * Concatenate the `errors` option with `cause.errors`, if either is defined
+ */
+declare type ConcatAggregateErrors<
+AggregateErrorsArg extends AggregateErrors,
+CauseArg extends Cause,
+> = [AggregateErrorsArg] extends [DefinedAggregateErrors]
+? 'errors' extends keyof CauseArg
+? CauseArg['errors'] extends DefinedAggregateErrors
+? [...CauseArg['errors'], ...AggregateErrorsArg]
+: AggregateErrorsArg
+: AggregateErrorsArg
+: 'errors' extends keyof CauseArg
+? CauseArg['errors'] extends DefinedAggregateErrors
+? CauseArg['errors']
+: never
+: never
+
+/**
+ * Options of all core plugins
+ */
+declare interface CorePluginsOptions<ChildProps extends ErrorProps> {
+    /**
+     * Error properties.
+     *
+     * @example
+     * ```js
+     * const error = new InputError('...', { props: { isUserError: true } })
+     * console.log(error.isUserError) // true
+     * ```
+     *
+     * @example
+     * ```js
+     * const InputError = BaseError.subclass('InputError', {
+     *   props: { isUserError: true },
+     * })
+     * const error = new InputError('...')
+     * console.log(error.isUserError) // true
+     * ```
+     */
+    readonly props?: ChildProps
+}
+
+export declare interface CoupledComponentInfo {
+    componentName: string;
+    props: Record<string, CoupledProp>;
+    elements: ExtractedElement[];
+    innerElementProps?: Map<string, Record<string, CoupledProp>>;
+    propUsages: TrackingStores['propUsages'];
+}
+
+export declare interface CoupledProp extends PropInfo {
+    /** Full stores.propUsages key for this prop, e.g. "props.linkUrl". */
+    propPath: string;
+    logicOnly: boolean;
+}
+
+/**
+ * Creates a CSS properties extractor that determines relevant CSS properties
+ * for each element based on its tag and role.
+ */
+export declare function createCssPropertiesExtractor(): ReactExtractor;
+
+/**
+ * Event emitted for each DOM element created during render.
+ */
+export declare interface CreateElementEvent {
+    tag: string;
+    props: Record<string, unknown>;
+    traceId: string;
+    children: unknown[];
+    store: ExtractorStore;
+}
+
+export declare interface CreateElementListener {
+    onCreateElement: (event: CreateElementEvent) => void;
+}
+
+/**
+ * Creates a prop tracker extractor that:
+ * 1. Generates spy-instrumented mock props during beforeRender
+ * 2. Detects spy markers in element props during onCreateElement
+ * 3. propUsages tracking data to the store namespaced by 'prop-tracker'
+ */
+export declare function createPropTrackerExtractor(): {
+    extractor: ReactExtractor;
+    state: PropTrackerExtractorState;
+};
+
+/**
+ * `ErrorClass.subclass()`
+ *
+ * @private This type is private and only exported as a temporary workaround
+ * for an open issue with TypeScript. It will be removed in a future release.
+ * See:
+ *
+ * - [modern-errors issue #18](https://github.com/ehmicky/modern-errors/issues/18)
+ * - [TypeScript issue #47663](https://github.com/microsoft/TypeScript/issues/47663)
+ */
+declare type CreateSubclass<
+PluginsArg extends Plugins,
+ErrorPropsArg extends ErrorProps,
+CustomClassArg extends CustomClass,
+> = <
+ChildPlugins extends Plugins = [],
+ChildCustomClass extends CustomClassArg = CustomClassArg,
+ChildProps extends ErrorProps = object,
+>(
+errorName: ErrorName,
+options?: SpecificClassOptions<
+PluginsArg,
+ChildPlugins,
+ChildProps,
+ChildCustomClass
+>,
+) => SpecificErrorClass<
+[...PluginsArg, ...ChildPlugins],
+MergeErrorProps<ErrorPropsArg, ChildProps>,
+ChildCustomClass
+>
+
+/**
+ * API returned by parseCss function for querying parsed CSS
+ */
+export declare interface CSSParserAPI {
+    /**
+     * Gets CSS properties for a specific selector
+     * @param selector - The selector to extract properties for
+     * @returns Array of CSS properties for the specified selector
+     */
+    getPropertiesForSelector: (selector: string) => CSSProperty[];
+    /**
+     * Gets all selectors and their properties from the CSS
+     * @returns Map from selector to its CSS properties
+     */
+    getAllProperties: () => Map<string, CSSProperty[]>;
+    /**
+     * Gets all CSS property names that use a specific CSS variable
+     * @param varName - The CSS variable name (with or without --)
+     * @returns Array of CSS property names that use this variable
+     */
+    getVarUsages: (varName: string) => string[];
+    /**
+     * Gets unique properties from multiple selectors with CSS cascade rules:
+     * - First selector wins (properties from earlier selectors take precedence)
+     * - Within a selector, last value wins (if property appears multiple times)
+     * @param selectors - Array of selectors to extract properties from
+     * @returns Map of property names to their values
+     */
+    getUniqueProperties: (selectors: string[]) => Map<string, string>;
+    /**
+     * Gets a DOM-matchable selector by stripping pseudo-classes.
+     * Returns null if the selector contains pseudo-elements (unmatchable against real DOM).
+     * @param selector - The original CSS selector string
+     * @returns DOM-matchable selector string or null
+     */
+    getDomSelector: (selector: string) => string | null;
+    /**
+     * Determines the CSS property type for a custom property based on how it is used.
+     * If all usages of varName are within the same CSS property, returns that property name.
+     * If usages differ, returns the CSS data type inferred from the initial value
+     * ('color', 'length', 'number', or 'string').
+     * Returns undefined if the variable is never used via var().
+     * @param varName - The CSS variable name (with or without --)
+     * @param defaultValue - The initial value string of the custom property
+     */
+    getVarPropertyType: (varName: string, defaultValue: string) => string | undefined;
+}
+
+export declare interface CssPropertiesData {
+    relevant: string[];
+}
+
+declare interface CSSProperty {
+    name: string;
+    value: string;
+    /** CSS variable names referenced via var() in this property's value */
+    varRefs?: string[];
+}
+
+/**
+ * `custom` option
+ *
+ * @private This type is private and only exported as a temporary workaround
+ * for an open issue with TypeScript. It will be removed in a future release.
+ * See:
+ *
+ * - [modern-errors issue #18](https://github.com/ehmicky/modern-errors/issues/18)
+ * - [TypeScript issue #47663](https://github.com/microsoft/TypeScript/issues/47663)
+ */
+declare interface CustomClass {
+    new (message: string, options?: InstanceOptions): Error
+    subclass: unknown
+}
+
+declare type Dedup<T> = T extends Result<infer RL, infer RR> ? [unknown] extends [RL] ? Err<RL, RR> : Ok<RL, RR> : T;
+
+/**
+ * Resolved default value with its type.
+ * For literals (string, number, boolean, null), the value is the actual JavaScript value.
+ * For structured literals (object, array), the value is the parsed JavaScript value.
+ * For unresolvable values (references, expressions), we store the raw source text.
+ */
+export declare type DefaultValue = {
+    kind: 'string';
+    value: string;
+} | {
+    kind: 'number';
+    value: number;
+} | {
+    kind: 'boolean';
+    value: boolean;
+} | {
+    kind: 'null';
+    value: null;
+} | {
+    kind: 'object';
+    value: Record<string, unknown>;
+} | {
+    kind: 'array';
+    value: unknown[];
+} | {
+    kind: 'unresolved';
+    value: string;
+};
+
+/**
+ * Represents an unexpected internal failure — a violated invariant or
+ * impossible state that should never occur during normal operation.
+ *
+ * Exit code 70 (EX_SOFTWARE) signals an internal software error.
+ */
+export declare const DefectError: SpecificErrorClass<    {
+name: "cli";
+isOptions: (options: unknown) => boolean;
+getOptions: (options?: Options) => {
+custom: string;
+stack?: boolean;
+cause?: boolean;
+props?: boolean;
+colors?: boolean;
+icon?: ("infinity" | "tick" | "info" | "warning" | "cross" | "square" | "squareSmall" | "squareSmallFilled" | "squareDarkShade" | "squareMediumShade" | "squareLightShade" | "squareTop" | "squareBottom" | "squareLeft" | "squareRight" | "squareCenter" | "circle" | "circleFilled" | "circleDotted" | "circleDouble" | "circleCircle" | "circleCross" | "circlePipe" | "circleQuestionMark" | "radioOn" | "radioOff" | "checkboxOn" | "checkboxOff" | "checkboxCircleOn" | "checkboxCircleOff" | "questionMarkPrefix" | "bullet" | "dot" | "ellipsis" | "pointer" | "pointerSmall" | "triangleUp" | "triangleUpSmall" | "triangleUpOutline" | "triangleDown" | "triangleDownSmall" | "triangleLeft" | "triangleLeftSmall" | "triangleRight" | "triangleRightSmall" | "lozenge" | "lozengeOutline" | "home" | "hamburger" | "smiley" | "mustache" | "heart" | "star" | "play" | "musicNote" | "musicNoteBeamed" | "nodejs" | "arrowUp" | "arrowDown" | "arrowLeft" | "arrowRight" | "arrowLeftRight" | "arrowUpDown" | "almostEqual" | "notEqual" | "lessOrEqual" | "greaterOrEqual" | "identical" | "subscriptZero" | "subscriptOne" | "subscriptTwo" | "subscriptThree" | "subscriptFour" | "subscriptFive" | "subscriptSix" | "subscriptSeven" | "subscriptEight" | "subscriptNine" | "oneHalf" | "oneThird" | "oneQuarter" | "oneFifth" | "oneSixth" | "oneSeventh" | "oneEighth" | "oneNinth" | "oneTenth" | "twoThirds" | "twoFifths" | "threeQuarters" | "threeFifths" | "threeEighths" | "fourFifths" | "fiveSixths" | "fiveEighths" | "sevenEighth" | "line" | "lineBold" | "lineDouble" | "lineDashed0" | "lineDashed1" | "lineDashed2" | "lineDashed3" | "lineDashed4" | "lineDashed5" | "lineDashed6" | "lineDashed7" | "lineDashed8" | "lineDashed9" | "lineDashed10" | "lineDashed11" | "lineDashed12" | "lineDashed13" | "lineDashed14" | "lineDashed15" | "lineVertical" | "lineVerticalBold" | "lineVerticalDouble" | "lineVerticalDashed0" | "lineVerticalDashed1" | "lineVerticalDashed2" | "lineVerticalDashed3" | "lineVerticalDashed4" | "lineVerticalDashed5" | "lineVerticalDashed6" | "lineVerticalDashed7" | "lineVerticalDashed8" | "lineVerticalDashed9" | "lineVerticalDashed10" | "lineVerticalDashed11" | "lineDownLeft" | "lineDownLeftArc" | "lineDownBoldLeftBold" | "lineDownBoldLeft" | "lineDownLeftBold" | "lineDownDoubleLeftDouble" | "lineDownDoubleLeft" | "lineDownLeftDouble" | "lineDownRight" | "lineDownRightArc" | "lineDownBoldRightBold" | "lineDownBoldRight" | "lineDownRightBold" | "lineDownDoubleRightDouble" | "lineDownDoubleRight" | "lineDownRightDouble" | "lineUpLeft" | "lineUpLeftArc" | "lineUpBoldLeftBold" | "lineUpBoldLeft" | "lineUpLeftBold" | "lineUpDoubleLeftDouble" | "lineUpDoubleLeft" | "lineUpLeftDouble" | "lineUpRight" | "lineUpRightArc" | "lineUpBoldRightBold" | "lineUpBoldRight" | "lineUpRightBold" | "lineUpDoubleRightDouble" | "lineUpDoubleRight" | "lineUpRightDouble" | "lineUpDownLeft" | "lineUpBoldDownBoldLeftBold" | "lineUpBoldDownBoldLeft" | "lineUpDownLeftBold" | "lineUpBoldDownLeftBold" | "lineUpDownBoldLeftBold" | "lineUpDownBoldLeft" | "lineUpBoldDownLeft" | "lineUpDoubleDownDoubleLeftDouble" | "lineUpDoubleDownDoubleLeft" | "lineUpDownLeftDouble" | "lineUpDownRight" | "lineUpBoldDownBoldRightBold" | "lineUpBoldDownBoldRight" | "lineUpDownRightBold" | "lineUpBoldDownRightBold" | "lineUpDownBoldRightBold" | "lineUpDownBoldRight" | "lineUpBoldDownRight" | "lineUpDoubleDownDoubleRightDouble" | "lineUpDoubleDownDoubleRight" | "lineUpDownRightDouble" | "lineDownLeftRight" | "lineDownBoldLeftBoldRightBold" | "lineDownLeftBoldRightBold" | "lineDownBoldLeftRight" | "lineDownBoldLeftBoldRight" | "lineDownBoldLeftRightBold" | "lineDownLeftRightBold" | "lineDownLeftBoldRight" | "lineDownDoubleLeftDoubleRightDouble" | "lineDownDoubleLeftRight" | "lineDownLeftDoubleRightDouble" | "lineUpLeftRight" | "lineUpBoldLeftBoldRightBold" | "lineUpLeftBoldRightBold" | "lineUpBoldLeftRight" | "lineUpBoldLeftBoldRight" | "lineUpBoldLeftRightBold" | "lineUpLeftRightBold" | "lineUpLeftBoldRight" | "lineUpDoubleLeftDoubleRightDouble" | "lineUpDoubleLeftRight" | "lineUpLeftDoubleRightDouble" | "lineUpDownLeftRight" | "lineUpBoldDownBoldLeftBoldRightBold" | "lineUpDownBoldLeftBoldRightBold" | "lineUpBoldDownLeftBoldRightBold" | "lineUpBoldDownBoldLeftRightBold" | "lineUpBoldDownBoldLeftBoldRight" | "lineUpBoldDownLeftRight" | "lineUpDownBoldLeftRight" | "lineUpDownLeftBoldRight" | "lineUpDownLeftRightBold" | "lineUpBoldDownBoldLeftRight" | "lineUpDownLeftBoldRightBold" | "lineUpBoldDownLeftBoldRight" | "lineUpBoldDownLeftRightBold" | "lineUpDownBoldLeftBoldRight" | "lineUpDownBoldLeftRightBold" | "lineUpDoubleDownDoubleLeftDoubleRightDouble" | "lineUpDoubleDownDoubleLeftRight" | "lineUpDownLeftDoubleRightDouble" | "lineCross" | "lineBackslash" | "lineSlash") | "";
+header?: Styles | "";
+classes?: {
+readonly [errorName: string]: Omit<Options_3, "classes">;
+} & {
+readonly [errorName: string]: Omit<Options_2, "classes">;
+};
+exitCode?: number;
+silent?: boolean;
+timeout?: number;
+log?: (message: string) => void;
+};
+instanceMethods: {
+exit: ({ error, options }: Info<Options>["instanceMethods"]) => void;
+pretty: ({ error, options: { exitCode, silent, timeout, log, ...beautifulErrorOptions }, }: Info<Options>["instanceMethods"]) => string;
+};
+}[], {
+phase: string;
+isDefect: boolean;
+exitCode: number;
+}, CustomClass>;
+
+/**
+ * Aggregate `errors` array
+ */
+declare type DefinedAggregateErrors = readonly AggregateErrorOption[]
+
+export declare interface DOMBinding {
+    element: string;
+    attribute: string;
+    concatenated: boolean;
+    elementId: string;
+}
+
+export { EditorReactComponent }
+
+declare type EmptyArrayToNever<T, NeverArrayToNever extends number = 0> = T extends [] ? never : NeverArrayToNever extends 1 ? T extends [never, ...infer Rest] ? [EmptyArrayToNever<Rest>] extends [never] ? never : T : T : T;
+
+export declare class Err<T, E> implements IResult<T, E> {
+    readonly error: E;
+    constructor(error: E);
+    isOk(): this is Ok<T, E>;
+    isErr(): this is Err<T, E>;
+    map<A>(_f: (t: T) => A): Result<A, E>;
+    mapErr<U>(f: (e: E) => U): Result<T, U>;
+    andThrough<F>(_f: (t: T) => Result<unknown, F>): Result<T, E | F>;
+    andTee(_f: (t: T) => unknown): Result<T, E>;
+    orTee(f: (t: E) => unknown): Result<T, E>;
+    andThen<R extends Result<unknown, unknown>>(_f: (t: T) => R): Result<InferOkTypes<R>, InferErrTypes<R> | E>;
+    andThen<U, F>(_f: (t: T) => Result<U, F>): Result<U, E | F>;
+    orElse<R extends Result<unknown, unknown>>(f: (e: E) => R): Result<InferOkTypes<R> | T, InferErrTypes<R>>;
+    orElse<U, A>(f: (e: E) => Result<U, A>): Result<U | T, A>;
+    asyncAndThen<U, F>(_f: (t: T) => ResultAsync<U, F>): ResultAsync<U, E | F>;
+    asyncAndThrough<F>(_f: (t: T) => ResultAsync<unknown, F>): ResultAsync<T, E | F>;
+    asyncMap<U>(_f: (t: T) => Promise<U>): ResultAsync<U, E>;
+    unwrapOr<A>(v: A): T | A;
+    match<A, B = A>(_ok: (t: T) => A, err: (e: E) => B): A | B;
+    safeUnwrap(): Generator<Err<never, E>, T>;
+    _unsafeUnwrap(config?: ErrorConfig): T;
+    _unsafeUnwrapErr(_?: ErrorConfig): E;
+    [Symbol.iterator](): Generator<Err<never, E>, T>;
+}
+
+export declare function err<T = never, E extends string = string>(err: E): Err<T, E>;
+
+export declare function err<T = never, E = unknown>(err: E): Err<T, E>;
+
+export declare function err<T = never, E extends void = void>(err: void): Err<T, void>;
+
+export declare function errAsync<T = never, E = unknown>(err: E): ResultAsync<T, E>;
+
+export declare function errAsync<T = never, E extends void = void>(err: void): ResultAsync<T, void>;
+
+/**
+ * Error class
+ */
+declare type ErrorClass<PluginsArg extends Plugins = Plugins> =
+SpecificErrorClass<PluginsArg, ErrorProps, CustomClass>
+
+declare interface ErrorConfig {
+    withStackTrace: boolean;
+}
+
+/**
+ * Error instance object
+ */
+declare type ErrorInstance<PluginsArg extends Plugins = Plugins> =
+SpecificErrorInstance<
+PluginsArg,
+ErrorProps,
+CustomClass,
+AggregateErrors,
+Cause
+>
+
+/**
+ * Bound instance method of a plugin
+ */
+declare type ErrorInstanceMethod<
+InstanceMethodArg extends InstanceMethod,
+MethodOptionsArg extends MethodOptions<Plugin>,
+> = (
+...args: ErrorInstanceMethodParams<InstanceMethodArg, MethodOptionsArg>
+) => ReturnType<InstanceMethodArg>
+
+/**
+ * Bound instance method parameters
+ */
+declare type ErrorInstanceMethodParams<
+InstanceMethodArg extends InstanceMethod,
+MethodOptionsArg extends MethodOptions<Plugin>,
+> =
+| SliceFirst<Parameters<InstanceMethodArg>>
+| ([MethodOptionsArg] extends [never]
+? never
+: readonly [
+...SliceFirst<Parameters<InstanceMethodArg>>,
+MethodOptionsArg,
+])
+
+/**
+ * Bound instance methods of a plugin, always defined
+ */
+declare type ErrorInstanceMethods<
+InstanceMethodsArg extends InstanceMethods,
+MethodOptionsArg extends MethodOptions<Plugin>,
+> = {
+    readonly [MethodName in keyof InstanceMethodsArg]: ErrorInstanceMethod<
+    InstanceMethodsArg[MethodName],
+    MethodOptionsArg
+    >
+}
+
+/**
+ * Bound mixed method of a plugin
+ */
+declare type ErrorMixedMethod<
+InstanceMethodArg extends InstanceMethod,
+MethodOptionsArg extends MethodOptions<Plugin>,
+> = (
+...args: ErrorMixedMethodParams<InstanceMethodArg, MethodOptionsArg>
+) => ReturnType<InstanceMethodArg>
+
+/**
+ * Bound mixed method parameters
+ */
+declare type ErrorMixedMethodParams<
+InstanceMethodArg extends InstanceMethod,
+MethodOptionsArg extends MethodOptions<Plugin>,
+> =
+| readonly [unknown, ...SliceFirst<Parameters<InstanceMethodArg>>]
+| ([MethodOptionsArg] extends [never]
+? never
+: readonly [
+unknown,
+...SliceFirst<Parameters<InstanceMethodArg>>,
+MethodOptionsArg,
+])
+
+/**
+ * Bound mixed methods of a plugin, always defined
+ */
+declare type ErrorMixedMethods<
+InstanceMethodsArg extends InstanceMethods,
+MethodOptionsArg extends MethodOptions<Plugin>,
+> = {
+    readonly [MethodName in keyof InstanceMethodsArg]: ErrorMixedMethod<
+    InstanceMethodsArg[MethodName],
+    MethodOptionsArg
+    >
+}
+
+/**
+ * Error class name
+ */
+declare type ErrorName = `${string}Error`
+
+/**
+ * Error properties
+ */
+declare type ErrorProps = object
+
+/**
+ * Bound static method of a plugin
+ */
+declare type ErrorStaticMethod<
+StaticMethodArg extends StaticMethod,
+MethodOptionsArg extends MethodOptions<Plugin>,
+> = (
+...args: ErrorStaticMethodParams<StaticMethodArg, MethodOptionsArg>
+) => ReturnType<StaticMethodArg>
+
+/**
+ * Bound static method parameters
+ */
+declare type ErrorStaticMethodParams<
+StaticMethodArg extends StaticMethod,
+MethodOptionsArg extends MethodOptions<Plugin>,
+> =
+| SliceFirst<Parameters<StaticMethodArg>>
+| ([MethodOptionsArg] extends [never]
+? never
+: readonly [...SliceFirst<Parameters<StaticMethodArg>>, MethodOptionsArg])
+
+/**
+ * Bound static methods of a plugin, always defined
+ */
+declare type ErrorStaticMethods<
+StaticMethodsArg extends StaticMethods,
+MethodOptionsArg extends MethodOptions<Plugin>,
+> = {
+    readonly [MethodName in keyof StaticMethodsArg]: ErrorStaticMethod<
+    StaticMethodsArg[MethodName],
+    MethodOptionsArg
+    >
+}
+
+/**
+ * Non-dynamic members of error classes
+ *
+ * @private This type is private and only exported as a temporary workaround
+ * for an open issue with TypeScript. It will be removed in a future release.
+ * See:
+ *
+ * - [modern-errors issue #18](https://github.com/ehmicky/modern-errors/issues/18)
+ * - [TypeScript issue #47663](https://github.com/microsoft/TypeScript/issues/47663)
+ */
+declare interface ErrorSubclassCore<
+PluginsArg extends Plugins,
+ErrorPropsArg extends ErrorProps,
+CustomClassArg extends CustomClass,
+> {
+    /**
+     * Error subclass
+     *
+     * @example
+     * ```js
+     * throw new InputError('Missing file path.')
+     * ```
+     */
+    new <
+    ChildProps extends ErrorProps = ErrorProps,
+    AggregateErrorsArg extends AggregateErrors = AggregateErrors,
+    CauseArg extends Cause = Cause,
+    >(
+    message: string,
+    options?: ParentInstanceOptions<
+    PluginsArg,
+    ChildProps,
+    CustomClassArg,
+    AggregateErrorsArg,
+    CauseArg
+    >,
+    ...extra: ParentExtra<CustomClassArg>
+    ): SpecificErrorInstance<
+    PluginsArg,
+    MergeErrorProps<ErrorPropsArg, ChildProps>,
+    CustomClassArg,
+    AggregateErrorsArg,
+    CauseArg
+    >
+
+    readonly prototype: InstanceType<
+    ErrorSubclassCore<PluginsArg, ErrorPropsArg, CustomClassArg>
+    >
+
+    /**
+     * Creates and returns a child `ErrorClass`.
+     *
+     * @example
+     * ```js
+     * export const InputError = ErrorClass.subclass('InputError', options)
+     * ```
+     */
+    subclass: CreateSubclass<PluginsArg, ErrorPropsArg, CustomClassArg>
+
+    /**
+     * Normalizes invalid errors.
+     *
+     * If `error` is an instance of `ErrorClass` (or one of its subclasses), it is
+     * left as is. Otherwise, it is converted to `NewErrorClass`, which defaults
+     * to `ErrorClass` itself.
+     *
+     * @example
+     * ```js
+     * try {
+     *   throw 'Missing file path.'
+     * } catch (invalidError) {
+     *   const normalizedError = BaseError.normalize(invalidError)
+     *   // This works: 'Missing file path.'
+     *   // `normalizedError` is a `BaseError` instance.
+     *   console.log(normalizedError.message.trim())
+     * }
+     * ```
+     */
+    normalize: NormalizeError<PluginsArg, ErrorPropsArg, CustomClassArg>
+}
+
+/**
+ * Options of a plugin
+ */
+declare type ExternalPluginOptions<PluginArg extends Plugin> =
+PluginArg extends Plugin
+? PluginArg['getOptions'] extends NonNullable<Plugin['getOptions']>
+? Parameters<PluginArg['getOptions']>[0]
+: never
+: never
+
+/**
+ * Options of all non-core plugins
+ */
+declare type ExternalPluginsOptions<PluginsArg extends Plugins> = {
+    readonly [PluginArg in PluginsArg[number] as PluginOptionName<PluginArg>]?: ExternalPluginOptions<PluginArg>
+}
+
+export declare function extractAllComponentInfo(program: default_2.Program, filePath: string): ComponentInfo[];
+
+export declare function extractComponentManifest(componentPath: string, compiledEntryPath: string, options?: ExtractComponentManifestOptions): ResultAsync<ManifestResult, InstanceType<typeof NotFoundError> | InstanceType<typeof ParseError>>;
+
+/**
+ * Extract component manifest from a TypeScript source file.
+ *
+ * @param componentPath - Path to the TypeScript source file
+ * @param compiledEntryPath - Path to the built JS entry file of the component's package (e.g. dist/index.js)
+ * @param options.onError - Called for each non-fatal extraction error as it occurs
+ * @errors
+ * - {@link NotFoundError} — Source file does not exist (phase: `compile`)
+ * - {@link ParseError} — TypeScript config or component types could not be parsed (phase: `compile` | `extract`)
+ */
+export declare interface ExtractComponentManifestOptions extends RunExtractorsOptions {
+    onError?: (error: ExtractionError) => void;
+}
+
+export declare function extractCssImports(program: Program): string[];
+
+/**
+ * Extracts component info for only the default-exported component in a file.
+ * Returns `undefined` if the file has no default export or if the default export
+ * is not a recognized React component.
+ *
+ * Handles the re-export case where the entry file only re-exports the component
+ * from another file (e.g. `export { Foo as default } from './Foo'`). In that
+ * situation react-docgen-typescript finds no component in the entry file, so we
+ * follow the re-export to the defining file and extract from there instead.
+ */
+export declare function extractDefaultComponentInfo(program: default_2.Program, filePath: string): ComponentInfo | undefined;
+
+export declare interface ExtractedCssInfo {
+    filePath: string;
+    api: CSSParserAPI;
+    properties: Map<string, string>;
+    customProperties: Map<string, string>;
+    isCssModule: boolean;
+}
+
+export declare interface ExtractedElement {
+    traceId: string;
+    name: string;
+    tag: string;
+    attributes: Record<string, string>;
+    extractorData: Map<string, unknown>;
+    children: ExtractedElement[];
+    hasTextContent?: boolean;
+}
+
+declare type ExtractErrAsyncTypes<T extends readonly ResultAsync<unknown, unknown>[]> = {
+    [idx in keyof T]: T[idx] extends ResultAsync<unknown, infer E> ? E : never;
+};
+
+declare type ExtractErrTypes<T extends readonly Result<unknown, unknown>[]> = {
+    [idx in keyof T]: T[idx] extends Result<unknown, infer E> ? E : never;
+};
+
+/** A non-fatal issue encountered during component extraction. */
+export declare interface ExtractionError {
+    componentName: string;
+    phase: 'render' | 'coupling' | 'css' | 'loader' | 'conversion';
+    error: InstanceType<typeof BaseError>;
+}
+
+export declare interface ExtractionResult {
+    html: string;
+    store: ExtractorStore;
+    elements: ExtractedElement[];
+}
+
+declare type ExtractOkAsyncTypes<T extends readonly ResultAsync<unknown, unknown>[]> = {
+    [idx in keyof T]: T[idx] extends ResultAsync<infer U, unknown> ? U : never;
+};
+
+declare type ExtractOkTypes<T extends readonly Result<unknown, unknown>[]> = {
+    [idx in keyof T]: T[idx] extends Result<infer U, unknown> ? U : never;
+};
+
+/**
+ * ExtractorStore - Shared store for extractors with namespace support
+ *
+ * Extractors write to this store during render, namespaced by their name:
+ *   store.set(traceId, 'prop-tracker', { boundProps: ['label', 'onClick'] })
+ *   store.set(traceId, 'css-properties', { relevant: ['color', 'background'] })
+ *
+ * Store structure: Map<traceId, Map<extractorName, data>>
+ */
+export declare class ExtractorStore {
+    private data;
+    set<T>(traceId: string, extractorName: string, value: T): void;
+    get<T>(traceId: string, extractorName: string): T | undefined;
+    getAll(traceId: string): Map<string, unknown> | undefined;
+    entries(): IterableIterator<[string, Map<string, unknown>]>;
+    clear(): void;
+}
+
+declare const figureSet: {
+    	readonly tick: string;
+    	readonly info: string;
+    	readonly warning: string;
+    	readonly cross: string;
+    	readonly square: string;
+    	readonly squareSmall: string;
+    	readonly squareSmallFilled: string;
+    	readonly squareDarkShade: string;
+    	readonly squareMediumShade: string;
+    	readonly squareLightShade: string;
+    	readonly squareTop: string;
+    	readonly squareBottom: string;
+    	readonly squareLeft: string;
+    	readonly squareRight: string;
+    	readonly squareCenter: string;
+    	readonly circle: string;
+    	readonly circleFilled: string;
+    	readonly circleDotted: string;
+    	readonly circleDouble: string;
+    	readonly circleCircle: string;
+    	readonly circleCross: string;
+    	readonly circlePipe: string;
+    	readonly circleQuestionMark: string;
+    	readonly radioOn: string;
+    	readonly radioOff: string;
+    	readonly checkboxOn: string;
+    	readonly checkboxOff: string;
+    	readonly checkboxCircleOn: string;
+    	readonly checkboxCircleOff: string;
+    	readonly questionMarkPrefix: string;
+    	readonly bullet: string;
+    	readonly dot: string;
+    	readonly ellipsis: string;
+    	readonly pointer: string;
+    	readonly pointerSmall: string;
+    	readonly triangleUp: string;
+    	readonly triangleUpSmall: string;
+    	readonly triangleUpOutline: string;
+    	readonly triangleDown: string;
+    	readonly triangleDownSmall: string;
+    	readonly triangleLeft: string;
+    	readonly triangleLeftSmall: string;
+    	readonly triangleRight: string;
+    	readonly triangleRightSmall: string;
+    	readonly lozenge: string;
+    	readonly lozengeOutline: string;
+    	readonly home: string;
+    	readonly hamburger: string;
+    	readonly smiley: string;
+    	readonly mustache: string;
+    	readonly heart: string;
+    	readonly star: string;
+    	readonly play: string;
+    	readonly musicNote: string;
+    	readonly musicNoteBeamed: string;
+    	readonly nodejs: string;
+    	readonly arrowUp: string;
+    	readonly arrowDown: string;
+    	readonly arrowLeft: string;
+    	readonly arrowRight: string;
+    	readonly arrowLeftRight: string;
+    	readonly arrowUpDown: string;
+    	readonly almostEqual: string;
+    	readonly notEqual: string;
+    	readonly lessOrEqual: string;
+    	readonly greaterOrEqual: string;
+    	readonly identical: string;
+    	readonly infinity: string;
+    	readonly subscriptZero: string;
+    	readonly subscriptOne: string;
+    	readonly subscriptTwo: string;
+    	readonly subscriptThree: string;
+    	readonly subscriptFour: string;
+    	readonly subscriptFive: string;
+    	readonly subscriptSix: string;
+    	readonly subscriptSeven: string;
+    	readonly subscriptEight: string;
+    	readonly subscriptNine: string;
+    	readonly oneHalf: string;
+    	readonly oneThird: string;
+    	readonly oneQuarter: string;
+    	readonly oneFifth: string;
+    	readonly oneSixth: string;
+    	readonly oneSeventh: string;
+    	readonly oneEighth: string;
+    	readonly oneNinth: string;
+    	readonly oneTenth: string;
+    	readonly twoThirds: string;
+    	readonly twoFifths: string;
+    	readonly threeQuarters: string;
+    	readonly threeFifths: string;
+    	readonly threeEighths: string;
+    	readonly fourFifths: string;
+    	readonly fiveSixths: string;
+    	readonly fiveEighths: string;
+    	readonly sevenEighth: string;
+    	readonly line: string;
+    	readonly lineBold: string;
+    	readonly lineDouble: string;
+    	readonly lineDashed0: string;
+    	readonly lineDashed1: string;
+    	readonly lineDashed2: string;
+    	readonly lineDashed3: string;
+    	readonly lineDashed4: string;
+    	readonly lineDashed5: string;
+    	readonly lineDashed6: string;
+    	readonly lineDashed7: string;
+    	readonly lineDashed8: string;
+    	readonly lineDashed9: string;
+    	readonly lineDashed10: string;
+    	readonly lineDashed11: string;
+    	readonly lineDashed12: string;
+    	readonly lineDashed13: string;
+    	readonly lineDashed14: string;
+    	readonly lineDashed15: string;
+    	readonly lineVertical: string;
+    	readonly lineVerticalBold: string;
+    	readonly lineVerticalDouble: string;
+    	readonly lineVerticalDashed0: string;
+    	readonly lineVerticalDashed1: string;
+    	readonly lineVerticalDashed2: string;
+    	readonly lineVerticalDashed3: string;
+    	readonly lineVerticalDashed4: string;
+    	readonly lineVerticalDashed5: string;
+    	readonly lineVerticalDashed6: string;
+    	readonly lineVerticalDashed7: string;
+    	readonly lineVerticalDashed8: string;
+    	readonly lineVerticalDashed9: string;
+    	readonly lineVerticalDashed10: string;
+    	readonly lineVerticalDashed11: string;
+    	readonly lineDownLeft: string;
+    	readonly lineDownLeftArc: string;
+    	readonly lineDownBoldLeftBold: string;
+    	readonly lineDownBoldLeft: string;
+    	readonly lineDownLeftBold: string;
+    	readonly lineDownDoubleLeftDouble: string;
+    	readonly lineDownDoubleLeft: string;
+    	readonly lineDownLeftDouble: string;
+    	readonly lineDownRight: string;
+    	readonly lineDownRightArc: string;
+    	readonly lineDownBoldRightBold: string;
+    	readonly lineDownBoldRight: string;
+    	readonly lineDownRightBold: string;
+    	readonly lineDownDoubleRightDouble: string;
+    	readonly lineDownDoubleRight: string;
+    	readonly lineDownRightDouble: string;
+    	readonly lineUpLeft: string;
+    	readonly lineUpLeftArc: string;
+    	readonly lineUpBoldLeftBold: string;
+    	readonly lineUpBoldLeft: string;
+    	readonly lineUpLeftBold: string;
+    	readonly lineUpDoubleLeftDouble: string;
+    	readonly lineUpDoubleLeft: string;
+    	readonly lineUpLeftDouble: string;
+    	readonly lineUpRight: string;
+    	readonly lineUpRightArc: string;
+    	readonly lineUpBoldRightBold: string;
+    	readonly lineUpBoldRight: string;
+    	readonly lineUpRightBold: string;
+    	readonly lineUpDoubleRightDouble: string;
+    	readonly lineUpDoubleRight: string;
+    	readonly lineUpRightDouble: string;
+    	readonly lineUpDownLeft: string;
+    	readonly lineUpBoldDownBoldLeftBold: string;
+    	readonly lineUpBoldDownBoldLeft: string;
+    	readonly lineUpDownLeftBold: string;
+    	readonly lineUpBoldDownLeftBold: string;
+    	readonly lineUpDownBoldLeftBold: string;
+    	readonly lineUpDownBoldLeft: string;
+    	readonly lineUpBoldDownLeft: string;
+    	readonly lineUpDoubleDownDoubleLeftDouble: string;
+    	readonly lineUpDoubleDownDoubleLeft: string;
+    	readonly lineUpDownLeftDouble: string;
+    	readonly lineUpDownRight: string;
+    	readonly lineUpBoldDownBoldRightBold: string;
+    	readonly lineUpBoldDownBoldRight: string;
+    	readonly lineUpDownRightBold: string;
+    	readonly lineUpBoldDownRightBold: string;
+    	readonly lineUpDownBoldRightBold: string;
+    	readonly lineUpDownBoldRight: string;
+    	readonly lineUpBoldDownRight: string;
+    	readonly lineUpDoubleDownDoubleRightDouble: string;
+    	readonly lineUpDoubleDownDoubleRight: string;
+    	readonly lineUpDownRightDouble: string;
+    	readonly lineDownLeftRight: string;
+    	readonly lineDownBoldLeftBoldRightBold: string;
+    	readonly lineDownLeftBoldRightBold: string;
+    	readonly lineDownBoldLeftRight: string;
+    	readonly lineDownBoldLeftBoldRight: string;
+    	readonly lineDownBoldLeftRightBold: string;
+    	readonly lineDownLeftRightBold: string;
+    	readonly lineDownLeftBoldRight: string;
+    	readonly lineDownDoubleLeftDoubleRightDouble: string;
+    	readonly lineDownDoubleLeftRight: string;
+    	readonly lineDownLeftDoubleRightDouble: string;
+    	readonly lineUpLeftRight: string;
+    	readonly lineUpBoldLeftBoldRightBold: string;
+    	readonly lineUpLeftBoldRightBold: string;
+    	readonly lineUpBoldLeftRight: string;
+    	readonly lineUpBoldLeftBoldRight: string;
+    	readonly lineUpBoldLeftRightBold: string;
+    	readonly lineUpLeftRightBold: string;
+    	readonly lineUpLeftBoldRight: string;
+    	readonly lineUpDoubleLeftDoubleRightDouble: string;
+    	readonly lineUpDoubleLeftRight: string;
+    	readonly lineUpLeftDoubleRightDouble: string;
+    	readonly lineUpDownLeftRight: string;
+    	readonly lineUpBoldDownBoldLeftBoldRightBold: string;
+    	readonly lineUpDownBoldLeftBoldRightBold: string;
+    	readonly lineUpBoldDownLeftBoldRightBold: string;
+    	readonly lineUpBoldDownBoldLeftRightBold: string;
+    	readonly lineUpBoldDownBoldLeftBoldRight: string;
+    	readonly lineUpBoldDownLeftRight: string;
+    	readonly lineUpDownBoldLeftRight: string;
+    	readonly lineUpDownLeftBoldRight: string;
+    	readonly lineUpDownLeftRightBold: string;
+    	readonly lineUpBoldDownBoldLeftRight: string;
+    	readonly lineUpDownLeftBoldRightBold: string;
+    	readonly lineUpBoldDownLeftBoldRight: string;
+    	readonly lineUpBoldDownLeftRightBold: string;
+    	readonly lineUpDownBoldLeftBoldRight: string;
+    	readonly lineUpDownBoldLeftRightBold: string;
+    	readonly lineUpDoubleDownDoubleLeftDoubleRightDouble: string;
+    	readonly lineUpDoubleDownDoubleLeftRight: string;
+    	readonly lineUpDownLeftDoubleRightDouble: string;
+    	readonly lineCross: string;
+    	readonly lineBackslash: string;
+    	readonly lineSlash: string;
+};
+
+export declare function findComponent(moduleExports: Record<string, unknown>, name: string): ComponentType<unknown> | null;
+
+/**
+ * `plugin.getOptions()` method
+ */
+declare type GetOptions = (input: never, full: boolean) => unknown
+
+/**
+ * Bound added properties of a plugin, always defined
+ */
+declare type GetProperties = (info: InfoParameter['properties']) => AddedProperties
+
+declare type InferAsyncErrTypes<R> = R extends ResultAsync<unknown, infer E> ? E : never;
+
+declare type InferAsyncOkTypes<R> = R extends ResultAsync<infer T, unknown> ? T : never;
+
+declare type InferErrTypes<R> = R extends Result<unknown, infer E> ? E : never;
+
+declare type InferOkTypes<R> = R extends Result<infer T, unknown> ? T : never;
+
+/**
+ * `info` is a plain object passed as the first argument to `properties()`,
+ * instance methods and static methods.
+ *
+ * Its members are readonly and should not be mutated, except for `info.error`
+ * inside instance methods (not inside `properties()`).
+ */
+declare interface Info<Options = never> {
+    /**
+     * `info` object passed to `plugin.properties()`
+     */
+    readonly properties: CommonInfo<Options>
+
+    /**
+     * `info` object passed to `plugin.instanceMethods.*()`
+     */
+    readonly instanceMethods: CommonInfo<Options>
+
+    /**
+     * `info` object passed to `plugin.staticMethods.*()`
+     */
+    readonly staticMethods: Omit<CommonInfo<Options>, 'error'>
+
+    /**
+     * `info` object returned by `errorInfo()`
+     */
+    readonly errorInfo: Omit<CommonInfo<Options>, 'errorInfo'>
+}
+
+/**
+ * `info` parameter. Unlike `Info`, this is not meant for plugin declarations,
+ * but for plugin consumption.
+ */
+declare type InfoParameter = {
+    readonly [InfoName in keyof Info]: UntypedInfo<Info[InfoName]>
+}
+
+/**
+ * Unbound instance method of a plugin
+ */
+declare type InstanceMethod = (
+info: InfoParameter['instanceMethods'],
+...args: readonly never[]
+) => unknown
+
+/**
+ * Unbound instance methods of a plugin
+ */
+declare interface InstanceMethods {
+    readonly [MethodName: string]: InstanceMethod
+}
+
+/**
+ * Options passed to error constructors: `new ErrorClass('message', options)`
+ */
+declare type InstanceOptions<PluginsArg extends Plugins = Plugins> =
+SpecificInstanceOptions<PluginsArg, ErrorProps, AggregateErrors, Cause>
+
+/** File system or network I/O failed (permissions, disk full, timeout). */
+export declare const IoError: SpecificErrorClass<    {
+name: "cli";
+isOptions: (options: unknown) => boolean;
+getOptions: (options?: Options) => {
+custom: string;
+stack?: boolean;
+cause?: boolean;
+props?: boolean;
+colors?: boolean;
+icon?: ("infinity" | "tick" | "info" | "warning" | "cross" | "square" | "squareSmall" | "squareSmallFilled" | "squareDarkShade" | "squareMediumShade" | "squareLightShade" | "squareTop" | "squareBottom" | "squareLeft" | "squareRight" | "squareCenter" | "circle" | "circleFilled" | "circleDotted" | "circleDouble" | "circleCircle" | "circleCross" | "circlePipe" | "circleQuestionMark" | "radioOn" | "radioOff" | "checkboxOn" | "checkboxOff" | "checkboxCircleOn" | "checkboxCircleOff" | "questionMarkPrefix" | "bullet" | "dot" | "ellipsis" | "pointer" | "pointerSmall" | "triangleUp" | "triangleUpSmall" | "triangleUpOutline" | "triangleDown" | "triangleDownSmall" | "triangleLeft" | "triangleLeftSmall" | "triangleRight" | "triangleRightSmall" | "lozenge" | "lozengeOutline" | "home" | "hamburger" | "smiley" | "mustache" | "heart" | "star" | "play" | "musicNote" | "musicNoteBeamed" | "nodejs" | "arrowUp" | "arrowDown" | "arrowLeft" | "arrowRight" | "arrowLeftRight" | "arrowUpDown" | "almostEqual" | "notEqual" | "lessOrEqual" | "greaterOrEqual" | "identical" | "subscriptZero" | "subscriptOne" | "subscriptTwo" | "subscriptThree" | "subscriptFour" | "subscriptFive" | "subscriptSix" | "subscriptSeven" | "subscriptEight" | "subscriptNine" | "oneHalf" | "oneThird" | "oneQuarter" | "oneFifth" | "oneSixth" | "oneSeventh" | "oneEighth" | "oneNinth" | "oneTenth" | "twoThirds" | "twoFifths" | "threeQuarters" | "threeFifths" | "threeEighths" | "fourFifths" | "fiveSixths" | "fiveEighths" | "sevenEighth" | "line" | "lineBold" | "lineDouble" | "lineDashed0" | "lineDashed1" | "lineDashed2" | "lineDashed3" | "lineDashed4" | "lineDashed5" | "lineDashed6" | "lineDashed7" | "lineDashed8" | "lineDashed9" | "lineDashed10" | "lineDashed11" | "lineDashed12" | "lineDashed13" | "lineDashed14" | "lineDashed15" | "lineVertical" | "lineVerticalBold" | "lineVerticalDouble" | "lineVerticalDashed0" | "lineVerticalDashed1" | "lineVerticalDashed2" | "lineVerticalDashed3" | "lineVerticalDashed4" | "lineVerticalDashed5" | "lineVerticalDashed6" | "lineVerticalDashed7" | "lineVerticalDashed8" | "lineVerticalDashed9" | "lineVerticalDashed10" | "lineVerticalDashed11" | "lineDownLeft" | "lineDownLeftArc" | "lineDownBoldLeftBold" | "lineDownBoldLeft" | "lineDownLeftBold" | "lineDownDoubleLeftDouble" | "lineDownDoubleLeft" | "lineDownLeftDouble" | "lineDownRight" | "lineDownRightArc" | "lineDownBoldRightBold" | "lineDownBoldRight" | "lineDownRightBold" | "lineDownDoubleRightDouble" | "lineDownDoubleRight" | "lineDownRightDouble" | "lineUpLeft" | "lineUpLeftArc" | "lineUpBoldLeftBold" | "lineUpBoldLeft" | "lineUpLeftBold" | "lineUpDoubleLeftDouble" | "lineUpDoubleLeft" | "lineUpLeftDouble" | "lineUpRight" | "lineUpRightArc" | "lineUpBoldRightBold" | "lineUpBoldRight" | "lineUpRightBold" | "lineUpDoubleRightDouble" | "lineUpDoubleRight" | "lineUpRightDouble" | "lineUpDownLeft" | "lineUpBoldDownBoldLeftBold" | "lineUpBoldDownBoldLeft" | "lineUpDownLeftBold" | "lineUpBoldDownLeftBold" | "lineUpDownBoldLeftBold" | "lineUpDownBoldLeft" | "lineUpBoldDownLeft" | "lineUpDoubleDownDoubleLeftDouble" | "lineUpDoubleDownDoubleLeft" | "lineUpDownLeftDouble" | "lineUpDownRight" | "lineUpBoldDownBoldRightBold" | "lineUpBoldDownBoldRight" | "lineUpDownRightBold" | "lineUpBoldDownRightBold" | "lineUpDownBoldRightBold" | "lineUpDownBoldRight" | "lineUpBoldDownRight" | "lineUpDoubleDownDoubleRightDouble" | "lineUpDoubleDownDoubleRight" | "lineUpDownRightDouble" | "lineDownLeftRight" | "lineDownBoldLeftBoldRightBold" | "lineDownLeftBoldRightBold" | "lineDownBoldLeftRight" | "lineDownBoldLeftBoldRight" | "lineDownBoldLeftRightBold" | "lineDownLeftRightBold" | "lineDownLeftBoldRight" | "lineDownDoubleLeftDoubleRightDouble" | "lineDownDoubleLeftRight" | "lineDownLeftDoubleRightDouble" | "lineUpLeftRight" | "lineUpBoldLeftBoldRightBold" | "lineUpLeftBoldRightBold" | "lineUpBoldLeftRight" | "lineUpBoldLeftBoldRight" | "lineUpBoldLeftRightBold" | "lineUpLeftRightBold" | "lineUpLeftBoldRight" | "lineUpDoubleLeftDoubleRightDouble" | "lineUpDoubleLeftRight" | "lineUpLeftDoubleRightDouble" | "lineUpDownLeftRight" | "lineUpBoldDownBoldLeftBoldRightBold" | "lineUpDownBoldLeftBoldRightBold" | "lineUpBoldDownLeftBoldRightBold" | "lineUpBoldDownBoldLeftRightBold" | "lineUpBoldDownBoldLeftBoldRight" | "lineUpBoldDownLeftRight" | "lineUpDownBoldLeftRight" | "lineUpDownLeftBoldRight" | "lineUpDownLeftRightBold" | "lineUpBoldDownBoldLeftRight" | "lineUpDownLeftBoldRightBold" | "lineUpBoldDownLeftBoldRight" | "lineUpBoldDownLeftRightBold" | "lineUpDownBoldLeftBoldRight" | "lineUpDownBoldLeftRightBold" | "lineUpDoubleDownDoubleLeftDoubleRightDouble" | "lineUpDoubleDownDoubleLeftRight" | "lineUpDownLeftDoubleRightDouble" | "lineCross" | "lineBackslash" | "lineSlash") | "";
+header?: Styles | "";
+classes?: {
+readonly [errorName: string]: Omit<Options_3, "classes">;
+} & {
+readonly [errorName: string]: Omit<Options_2, "classes">;
+};
+exitCode?: number;
+silent?: boolean;
+timeout?: number;
+log?: (message: string) => void;
+};
+instanceMethods: {
+exit: ({ error, options }: Info<Options>["instanceMethods"]) => void;
+pretty: ({ error, options: { exitCode, silent, timeout, log, ...beautifulErrorOptions }, }: Info<Options>["instanceMethods"]) => string;
+};
+}[], {
+/** Pipeline stage where the error originated (composed at runtime). */
+phase: string;
+/** True if this error represents a violated invariant, not a user error. */
+isDefect: boolean;
+/** Process exit code used by BaseError.exit(). */
+exitCode: number;
+} & object, CustomClass>;
+
+declare interface IResult<T, E> {
+    /**
+     * Used to check if a `Result` is an `OK`
+     *
+     * @returns `true` if the result is an `OK` variant of Result
+     */
+    isOk(): this is Ok<T, E>;
+    /**
+     * Used to check if a `Result` is an `Err`
+     *
+     * @returns `true` if the result is an `Err` variant of Result
+     */
+    isErr(): this is Err<T, E>;
+    /**
+     * Maps a `Result<T, E>` to `Result<U, E>`
+     * by applying a function to a contained `Ok` value, leaving an `Err` value
+     * untouched.
+     *
+     * @param f The function to apply an `OK` value
+     * @returns the result of applying `f` or an `Err` untouched
+     */
+    map<A>(f: (t: T) => A): Result<A, E>;
+    /**
+     * Maps a `Result<T, E>` to `Result<T, F>` by applying a function to a
+     * contained `Err` value, leaving an `Ok` value untouched.
+     *
+     * This function can be used to pass through a successful result while
+     * handling an error.
+     *
+     * @param f a function to apply to the error `Err` value
+     */
+    mapErr<U>(f: (e: E) => U): Result<T, U>;
+    /**
+     * Similar to `map` Except you must return a new `Result`.
+     *
+     * This is useful for when you need to do a subsequent computation using the
+     * inner `T` value, but that computation might fail.
+     * Additionally, `andThen` is really useful as a tool to flatten a
+     * `Result<Result<A, E2>, E1>` into a `Result<A, E2>` (see example below).
+     *
+     * @param f The function to apply to the current value
+     */
+    andThen<R extends Result<unknown, unknown>>(f: (t: T) => R): Result<InferOkTypes<R>, InferErrTypes<R> | E>;
+    andThen<U, F>(f: (t: T) => Result<U, F>): Result<U, E | F>;
+    /**
+     * This "tee"s the current value to an passed-in computation such as side
+     * effect functions but still returns the same current value as the result.
+     *
+     * This is useful when you want to pass the current result to your side-track
+     * work such as logging but want to continue main-track work after that.
+     * This method does not care about the result of the passed in computation.
+     *
+     * @param f The function to apply to the current value
+     */
+    andTee(f: (t: T) => unknown): Result<T, E>;
+    /**
+     * This "tee"s the current `Err` value to an passed-in computation such as side
+     * effect functions but still returns the same `Err` value as the result.
+     *
+     * This is useful when you want to pass the current `Err` value to your side-track
+     * work such as logging but want to continue error-track work after that.
+     * This method does not care about the result of the passed in computation.
+     *
+     * @param f The function to apply to the current `Err` value
+     */
+    orTee(f: (t: E) => unknown): Result<T, E>;
+    /**
+     * Similar to `andTee` except error result of the computation will be passed
+     * to the downstream in case of an error.
+     *
+     * This version is useful when you want to make side-effects but in case of an
+     * error, you want to pass the error to the downstream.
+     *
+     * @param f The function to apply to the current value
+     */
+    andThrough<R extends Result<unknown, unknown>>(f: (t: T) => R): Result<T, InferErrTypes<R> | E>;
+    andThrough<F>(f: (t: T) => Result<unknown, F>): Result<T, E | F>;
+    /**
+     * Takes an `Err` value and maps it to a `Result<T, SomeNewType>`.
+     *
+     * This is useful for error recovery.
+     *
+     *
+     * @param f  A function to apply to an `Err` value, leaving `Ok` values
+     * untouched.
+     */
+    orElse<R extends Result<unknown, unknown>>(f: (e: E) => R): Result<InferOkTypes<R> | T, InferErrTypes<R>>;
+    orElse<U, A>(f: (e: E) => Result<U, A>): Result<U | T, A>;
+    /**
+     * Similar to `map` Except you must return a new `Result`.
+     *
+     * This is useful for when you need to do a subsequent async computation using
+     * the inner `T` value, but that computation might fail. Must return a ResultAsync
+     *
+     * @param f The function that returns a `ResultAsync` to apply to the current
+     * value
+     */
+    asyncAndThen<U, F>(f: (t: T) => ResultAsync<U, F>): ResultAsync<U, E | F>;
+    /**
+     * Maps a `Result<T, E>` to `ResultAsync<U, E>`
+     * by applying an async function to a contained `Ok` value, leaving an `Err`
+     * value untouched.
+     *
+     * @param f An async function to apply an `OK` value
+     */
+    asyncMap<U>(f: (t: T) => Promise<U>): ResultAsync<U, E>;
+    /**
+     * Unwrap the `Ok` value, or return the default if there is an `Err`
+     *
+     * @param v the default value to return if there is an `Err`
+     */
+    unwrapOr<A>(v: A): T | A;
+    /**
+     *
+     * Given 2 functions (one for the `Ok` variant and one for the `Err` variant)
+     * execute the function that matches the `Result` variant.
+     *
+     * Match callbacks do not necessitate to return a `Result`, however you can
+     * return a `Result` if you want to.
+     *
+     * `match` is like chaining `map` and `mapErr`, with the distinction that
+     * with `match` both functions must have the same return type.
+     *
+     * @param ok
+     * @param err
+     */
+    match<A, B = A>(ok: (t: T) => A, err: (e: E) => B): A | B;
+    /**
+     * @deprecated will be removed in 9.0.0.
+     *
+     * You can use `safeTry` without this method.
+     * @example
+     * ```typescript
+     * safeTry(function* () {
+     *   const okValue = yield* yourResult
+     * })
+     * ```
+     * Emulates Rust's `?` operator in `safeTry`'s body. See also `safeTry`.
+     */
+    safeUnwrap(): Generator<Err<never, E>, T>;
+    /**
+     * **This method is unsafe, and should only be used in a test environments**
+     *
+     * Takes a `Result<T, E>` and returns a `T` when the result is an `Ok`, otherwise it throws a custom object.
+     *
+     * @param config
+     */
+    _unsafeUnwrap(config?: ErrorConfig): T;
+    /**
+     * **This method is unsafe, and should only be used in a test environments**
+     *
+     * takes a `Result<T, E>` and returns a `E` when the result is an `Err`,
+     * otherwise it throws a custom object.
+     *
+     * @param config
+     */
+    _unsafeUnwrapErr(config?: ErrorConfig): E;
+}
+
+declare type IsLiteralArray<T> = T extends {
+    length: infer L;
+} ? L extends number ? number extends L ? 0 : 1 : 0 : 0;
+
+/**
+ * `plugin.isOptions()` method
+ */
+declare type IsOptions = (input: unknown) => boolean
+
+/**
+ * Class-specific options, excluding plugin options
+ */
+declare interface KnownClassOptions<
+ChildPlugins extends Plugins,
+ChildCustomClass extends CustomClass,
+> {
+    /**
+     * Plugins to add.
+     *
+     * @example
+     * ```js
+     * import modernErrorsBugs from 'modern-errors-bugs'
+     * import modernErrorsSerialize from 'modern-errors-serialize'
+     *
+     * export const BaseError = ModernError.subclass('BaseError', {
+     *   plugins: [modernErrorsBugs, modernErrorsSerialize],
+     * })
+     * ```
+     */
+    readonly plugins?: ChildPlugins
+
+    /**
+     * Custom class to add any methods, `constructor` or properties.
+     *
+     * @example
+     * ```js
+     * export const InputError = BaseError.subclass('InputError', {
+     *   // The `class` must extend from the parent error class
+     *   custom: class extends BaseError {
+     *     // If a `constructor` is defined, its parameters must be (message, options)
+     *     constructor(message, options) {
+     *       message += message.endsWith('.') ? '' : '.'
+     *       super(message, options)
+     *     }
+     *
+     *     isUserInput() {
+     *       // ...
+     *     }
+     *   },
+     * })
+     *
+     * const error = new InputError('Wrong user name')
+     * console.log(error.message) // 'Wrong user name.'
+     * console.log(error.isUserInput())
+     * ```
+     */
+    readonly custom?: ChildCustomClass
+}
+
+/**
+ * Attempts to load a module, first via ESM `import()`, then via CJS `require`.
+ *
+ * ESM `import()` is preferred because it participates in the ESM loader hook
+ * pipeline (registered via `module.register()` in the CLI). This is required
+ * for JSX interception to work — the loader hook redirects `react/jsx-runtime`
+ * to the interceptable version. CJS `require()` bypasses ESM hooks even when
+ * loading ESM modules (Node 22+), so it's only used as a fallback.
+ *
+ * @param entryPath - Absolute path to the module entry point.
+ * @returns A `ResultAsync` containing the module exports on success.
+ * @errors {LoadModuleFailure} When both ESM import and CJS require fail.
+ */
+export declare function loadModule(entryPath: string): ResultAsync<Record<string, unknown>, LoadModuleFailure>;
+
+/**
+ * Structured failure from `loadModule` when both ESM import and CJS require fail.
+ * Carries each error separately so callers can report them independently.
+ */
+export declare interface LoadModuleFailure {
+    /** The ESM import error, or null when no ESM was attempted (e.g. empty path). */
+    esmError: Error | null;
+    /** The CJS require error, or a generic error for the empty-path case. */
+    cjsError: Error;
+}
+
+/**
+ * Options passed to error constructors, excluding any plugin options
+ */
+declare interface MainInstanceOptions<
+AggregateErrorsArg extends AggregateErrors,
+CauseArg extends Cause,
+> {
+    /**
+     * The `errors` option aggregates multiple errors into one. This is like
+     * [`new AggregateError(errors)`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/AggregateError/AggregateError)
+     * except that it works with any error class.
+     *
+     * @example
+     * ```js
+     * const databaseError = new DatabaseError('...')
+     * const authError = new AuthError('...')
+     * throw new InputError('...', { errors: [databaseError, authError] })
+     * // InputError: ... {
+     * //   [errors]: [
+     * //     DatabaseError: ...
+     * //     AuthError: ...
+     * //   ]
+     * // }
+     * ```
+     */
+    readonly errors?: AggregateErrorsArg
+
+    /**
+     * Any error's message, class and options can be wrapped using the
+     * [standard `cause` option](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Error/cause).
+     *
+     * Instead of being set as a `cause` property, the inner error is directly
+     * [merged](https://github.com/ehmicky/merge-error-cause) to the outer error,
+     * including its
+     * [`message`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Error/message),
+     * [`stack`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Error/stack),
+     * [`name`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Error/name),
+     * [`AggregateError.errors`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/AggregateError)
+     * and any [additional property](#%EF%B8%8F-error-properties).
+     *
+     * @example
+     * ```js
+     * try {
+     *   // ...
+     * } catch (cause) {
+     *   throw new InputError('Could not read the file.', { cause })
+     * }
+     * ```
+     */
+    readonly cause?: CauseArg
+}
+
+export declare interface ManifestResult {
+    component: EditorReactComponent;
+    errors: ExtractionError[];
+}
+
+declare type MemberListOf<T> = ((T extends unknown ? (t: T) => T : never) extends infer U ? (U extends unknown ? (u: U) => unknown : never) extends (v: infer V) => unknown ? V : never : never) extends (_: unknown) => infer W ? [...MemberListOf<Exclude<T, W>>, W] : [];
+
+declare type MembersToUnion<T> = T extends unknown[] ? T[number] : never;
+
+/**
+ * Merge error `props` from the class options and instance options
+ */
+declare type MergeErrorProps<
+PropsOne extends ErrorProps,
+PropsTwo extends ErrorProps,
+> = SimpleSetProps<PropsOne, PropsTwo>
+
+/**
+ * Options passed to plugin methods:
+ * `ErrorClass.{staticMethod}(..., options)`,
+ * `ErrorClass.{instanceMethod}(error, ..., options)` or
+ * `error.{instanceMethod}(..., options)`
+ */
+declare type MethodOptions<PluginArg extends Plugin> =
+ExternalPluginOptions<PluginArg>
+
+/**
+ * Normalize each error in the `errors` option to `Error` instances
+ */
+declare type NormalizeAggregateError<ErrorArg extends AggregateErrorOption> =
+ErrorArg extends Error ? ErrorArg : Error
+
+/**
+ * Normalize all errors in the `errors` option to `Error` instances
+ */
+declare type NormalizeAggregateErrors<
+AggregateErrorsArg extends DefinedAggregateErrors,
+> = AggregateErrorsArg extends never[]
+? []
+: AggregateErrorsArg extends readonly [
+infer AggregateErrorArg extends AggregateErrorOption,
+...infer Rest extends DefinedAggregateErrors,
+]
+? [
+NormalizeAggregateError<AggregateErrorArg>,
+...NormalizeAggregateErrors<Rest>,
+]
+: NormalizeAggregateError<AggregateErrorsArg[number]>[]
+
+/**
+ * The `cause` option, as used when merged to the error instance
+ */
+declare type NormalizedCause<CauseArg extends Cause> = CauseArg extends Error
+? CauseArg
+: object
+
+/**
+ * Apply `ErrorClass.normalize()` on both `error` and `error.errors`
+ */
+declare type NormalizeDeepError<
+ErrorArg,
+ParentError extends ErrorInstance,
+NewError extends ErrorInstance,
+> = ErrorArg extends {
+    errors: infer AggregateErrorsArg extends DefinedAggregateErrors
+}
+? Omit<NormalizeOneError<ErrorArg, ParentError, NewError>, 'errors'> & {
+    errors: NormalizeManyErrors<AggregateErrorsArg, ParentError, NewError>
+}
+: NormalizeOneError<ErrorArg, ParentError, NewError>
+
+/**
+ * `ErrorClass.normalize()`.
+ *
+ * @private This type is private and only exported as a temporary workaround
+ * for an open issue with TypeScript. It will be removed in a future release.
+ * See:
+ *
+ * - [modern-errors issue #18](https://github.com/ehmicky/modern-errors/issues/18)
+ * - [TypeScript issue #47663](https://github.com/microsoft/TypeScript/issues/47663)
+ */
+declare type NormalizeError<
+PluginsArg extends Plugins,
+ErrorPropsArg extends ErrorProps,
+CustomClassArg extends CustomClass,
+> = <
+ErrorArg,
+NewErrorClass extends SpecificErrorClass<
+PluginsArg,
+ErrorPropsArg,
+CustomClassArg
+> = SpecificErrorClass<PluginsArg, ErrorPropsArg, CustomClassArg>,
+>(
+error: ErrorArg,
+NewErrorClass?: NewErrorClass,
+) => NormalizeDeepError<
+ErrorArg,
+InstanceType<SpecificErrorClass<PluginsArg, ErrorPropsArg, CustomClassArg>> &
+ErrorInstance,
+InstanceType<NewErrorClass> & ErrorInstance
+>
+
+/**
+ * Apply `ErrorClass.normalize()` on `error.errors`
+ */
+declare type NormalizeManyErrors<
+AggregateErrorsArg extends DefinedAggregateErrors,
+ParentError extends ErrorInstance,
+NewError extends ErrorInstance,
+> = AggregateErrorsArg extends never[]
+? []
+: AggregateErrorsArg extends readonly [
+infer AggregateErrorArg extends AggregateErrorOption,
+...infer Rest extends DefinedAggregateErrors,
+]
+? [
+NormalizeDeepError<AggregateErrorArg, ParentError, NewError>,
+...NormalizeManyErrors<Rest, ParentError, NewError>,
+]
+: NormalizeDeepError<AggregateErrorsArg[number], ParentError, NewError>[]
+
+/**
+ * Apply `ErrorClass.normalize()` on `error`, but not `error.errors`
+ */
+declare type NormalizeOneError<
+ErrorArg,
+ParentError extends ErrorInstance,
+NewError extends ErrorInstance,
+> = ErrorArg extends ParentError
+? ErrorArg
+: ErrorArg extends Error
+? SetProps<ErrorArg, NewError>
+: NewError
+
+/** A required resource (file, module, component) could not be found. */
+export declare const NotFoundError: SpecificErrorClass<    {
+name: "cli";
+isOptions: (options: unknown) => boolean;
+getOptions: (options?: Options) => {
+custom: string;
+stack?: boolean;
+cause?: boolean;
+props?: boolean;
+colors?: boolean;
+icon?: ("infinity" | "tick" | "info" | "warning" | "cross" | "square" | "squareSmall" | "squareSmallFilled" | "squareDarkShade" | "squareMediumShade" | "squareLightShade" | "squareTop" | "squareBottom" | "squareLeft" | "squareRight" | "squareCenter" | "circle" | "circleFilled" | "circleDotted" | "circleDouble" | "circleCircle" | "circleCross" | "circlePipe" | "circleQuestionMark" | "radioOn" | "radioOff" | "checkboxOn" | "checkboxOff" | "checkboxCircleOn" | "checkboxCircleOff" | "questionMarkPrefix" | "bullet" | "dot" | "ellipsis" | "pointer" | "pointerSmall" | "triangleUp" | "triangleUpSmall" | "triangleUpOutline" | "triangleDown" | "triangleDownSmall" | "triangleLeft" | "triangleLeftSmall" | "triangleRight" | "triangleRightSmall" | "lozenge" | "lozengeOutline" | "home" | "hamburger" | "smiley" | "mustache" | "heart" | "star" | "play" | "musicNote" | "musicNoteBeamed" | "nodejs" | "arrowUp" | "arrowDown" | "arrowLeft" | "arrowRight" | "arrowLeftRight" | "arrowUpDown" | "almostEqual" | "notEqual" | "lessOrEqual" | "greaterOrEqual" | "identical" | "subscriptZero" | "subscriptOne" | "subscriptTwo" | "subscriptThree" | "subscriptFour" | "subscriptFive" | "subscriptSix" | "subscriptSeven" | "subscriptEight" | "subscriptNine" | "oneHalf" | "oneThird" | "oneQuarter" | "oneFifth" | "oneSixth" | "oneSeventh" | "oneEighth" | "oneNinth" | "oneTenth" | "twoThirds" | "twoFifths" | "threeQuarters" | "threeFifths" | "threeEighths" | "fourFifths" | "fiveSixths" | "fiveEighths" | "sevenEighth" | "line" | "lineBold" | "lineDouble" | "lineDashed0" | "lineDashed1" | "lineDashed2" | "lineDashed3" | "lineDashed4" | "lineDashed5" | "lineDashed6" | "lineDashed7" | "lineDashed8" | "lineDashed9" | "lineDashed10" | "lineDashed11" | "lineDashed12" | "lineDashed13" | "lineDashed14" | "lineDashed15" | "lineVertical" | "lineVerticalBold" | "lineVerticalDouble" | "lineVerticalDashed0" | "lineVerticalDashed1" | "lineVerticalDashed2" | "lineVerticalDashed3" | "lineVerticalDashed4" | "lineVerticalDashed5" | "lineVerticalDashed6" | "lineVerticalDashed7" | "lineVerticalDashed8" | "lineVerticalDashed9" | "lineVerticalDashed10" | "lineVerticalDashed11" | "lineDownLeft" | "lineDownLeftArc" | "lineDownBoldLeftBold" | "lineDownBoldLeft" | "lineDownLeftBold" | "lineDownDoubleLeftDouble" | "lineDownDoubleLeft" | "lineDownLeftDouble" | "lineDownRight" | "lineDownRightArc" | "lineDownBoldRightBold" | "lineDownBoldRight" | "lineDownRightBold" | "lineDownDoubleRightDouble" | "lineDownDoubleRight" | "lineDownRightDouble" | "lineUpLeft" | "lineUpLeftArc" | "lineUpBoldLeftBold" | "lineUpBoldLeft" | "lineUpLeftBold" | "lineUpDoubleLeftDouble" | "lineUpDoubleLeft" | "lineUpLeftDouble" | "lineUpRight" | "lineUpRightArc" | "lineUpBoldRightBold" | "lineUpBoldRight" | "lineUpRightBold" | "lineUpDoubleRightDouble" | "lineUpDoubleRight" | "lineUpRightDouble" | "lineUpDownLeft" | "lineUpBoldDownBoldLeftBold" | "lineUpBoldDownBoldLeft" | "lineUpDownLeftBold" | "lineUpBoldDownLeftBold" | "lineUpDownBoldLeftBold" | "lineUpDownBoldLeft" | "lineUpBoldDownLeft" | "lineUpDoubleDownDoubleLeftDouble" | "lineUpDoubleDownDoubleLeft" | "lineUpDownLeftDouble" | "lineUpDownRight" | "lineUpBoldDownBoldRightBold" | "lineUpBoldDownBoldRight" | "lineUpDownRightBold" | "lineUpBoldDownRightBold" | "lineUpDownBoldRightBold" | "lineUpDownBoldRight" | "lineUpBoldDownRight" | "lineUpDoubleDownDoubleRightDouble" | "lineUpDoubleDownDoubleRight" | "lineUpDownRightDouble" | "lineDownLeftRight" | "lineDownBoldLeftBoldRightBold" | "lineDownLeftBoldRightBold" | "lineDownBoldLeftRight" | "lineDownBoldLeftBoldRight" | "lineDownBoldLeftRightBold" | "lineDownLeftRightBold" | "lineDownLeftBoldRight" | "lineDownDoubleLeftDoubleRightDouble" | "lineDownDoubleLeftRight" | "lineDownLeftDoubleRightDouble" | "lineUpLeftRight" | "lineUpBoldLeftBoldRightBold" | "lineUpLeftBoldRightBold" | "lineUpBoldLeftRight" | "lineUpBoldLeftBoldRight" | "lineUpBoldLeftRightBold" | "lineUpLeftRightBold" | "lineUpLeftBoldRight" | "lineUpDoubleLeftDoubleRightDouble" | "lineUpDoubleLeftRight" | "lineUpLeftDoubleRightDouble" | "lineUpDownLeftRight" | "lineUpBoldDownBoldLeftBoldRightBold" | "lineUpDownBoldLeftBoldRightBold" | "lineUpBoldDownLeftBoldRightBold" | "lineUpBoldDownBoldLeftRightBold" | "lineUpBoldDownBoldLeftBoldRight" | "lineUpBoldDownLeftRight" | "lineUpDownBoldLeftRight" | "lineUpDownLeftBoldRight" | "lineUpDownLeftRightBold" | "lineUpBoldDownBoldLeftRight" | "lineUpDownLeftBoldRightBold" | "lineUpBoldDownLeftBoldRight" | "lineUpBoldDownLeftRightBold" | "lineUpDownBoldLeftBoldRight" | "lineUpDownBoldLeftRightBold" | "lineUpDoubleDownDoubleLeftDoubleRightDouble" | "lineUpDoubleDownDoubleLeftRight" | "lineUpDownLeftDoubleRightDouble" | "lineCross" | "lineBackslash" | "lineSlash") | "";
+header?: Styles | "";
+classes?: {
+readonly [errorName: string]: Omit<Options_3, "classes">;
+} & {
+readonly [errorName: string]: Omit<Options_2, "classes">;
+};
+exitCode?: number;
+silent?: boolean;
+timeout?: number;
+log?: (message: string) => void;
+};
+instanceMethods: {
+exit: ({ error, options }: Info<Options>["instanceMethods"]) => void;
+pretty: ({ error, options: { exitCode, silent, timeout, log, ...beautifulErrorOptions }, }: Info<Options>["instanceMethods"]) => string;
+};
+}[], {
+/** Pipeline stage where the error originated (composed at runtime). */
+phase: string;
+/** True if this error represents a violated invariant, not a user error. */
+isDefect: boolean;
+/** Process exit code used by BaseError.exit(). */
+exitCode: number;
+} & object, CustomClass>;
+
+export declare class Ok<T, E> implements IResult<T, E> {
+    readonly value: T;
+    constructor(value: T);
+    isOk(): this is Ok<T, E>;
+    isErr(): this is Err<T, E>;
+    map<A>(f: (t: T) => A): Result<A, E>;
+    mapErr<U>(_f: (e: E) => U): Result<T, U>;
+    andThen<R extends Result<unknown, unknown>>(f: (t: T) => R): Result<InferOkTypes<R>, InferErrTypes<R> | E>;
+    andThen<U, F>(f: (t: T) => Result<U, F>): Result<U, E | F>;
+    andThrough<R extends Result<unknown, unknown>>(f: (t: T) => R): Result<T, InferErrTypes<R> | E>;
+    andThrough<F>(f: (t: T) => Result<unknown, F>): Result<T, E | F>;
+    andTee(f: (t: T) => unknown): Result<T, E>;
+    orTee(_f: (t: E) => unknown): Result<T, E>;
+    orElse<R extends Result<unknown, unknown>>(_f: (e: E) => R): Result<InferOkTypes<R> | T, InferErrTypes<R>>;
+    orElse<U, A>(_f: (e: E) => Result<U, A>): Result<U | T, A>;
+    asyncAndThen<U, F>(f: (t: T) => ResultAsync<U, F>): ResultAsync<U, E | F>;
+    asyncAndThrough<R extends ResultAsync<unknown, unknown>>(f: (t: T) => R): ResultAsync<T, InferAsyncErrTypes<R> | E>;
+    asyncAndThrough<F>(f: (t: T) => ResultAsync<unknown, F>): ResultAsync<T, E | F>;
+    asyncMap<U>(f: (t: T) => Promise<U>): ResultAsync<U, E>;
+    unwrapOr<A>(_v: A): T | A;
+    match<A, B = A>(ok: (t: T) => A, _err: (e: E) => B): A | B;
+    safeUnwrap(): Generator<Err<never, E>, T>;
+    _unsafeUnwrap(_?: ErrorConfig): T;
+    _unsafeUnwrapErr(config?: ErrorConfig): E;
+    [Symbol.iterator](): Generator<Err<never, E>, T>;
+}
+
+export declare function ok<T, E = never>(value: T): Ok<T, E>;
+
+export declare function ok<T extends void = void, E = never>(value: void): Ok<void, E>;
+
+export declare function okAsync<T, E = never>(value: T): ResultAsync<T, E>;
+
+export declare function okAsync<T extends void = void, E = never>(value: void): ResultAsync<void, E>;
+
+/**
+ * Like `Omit<Source, OmittedKeys>` except it reduces empty `{}` for simpler
+ * debugging.
+ */
+declare type OmitKeys<
+Source,
+OmittedKeys extends PropertyKey,
+> = keyof Source extends OmittedKeys ? object : Omit<Source, OmittedKeys>
+
+/**
+ * Options of `modern-errors-cli`
+ */
+declare type Options = Omit<Options_2, 'classes' | 'custom'>;
+
+/**
+ * `handle-cli-error` options
+ */
+declare type Options_2 = Options_3 & {
+    /**
+     * Process [exit code](https://en.wikipedia.org/wiki/Exit_status).
+     *
+     * We recommend values between 1 and 124 because the following exit codes have
+     * some special meaning:
+     *
+     * - 0: success
+     * - 125: invalid [`options`](#options)
+     * - 126 to 255: used by shells like Bash
+     *
+     * @default 1
+     */
+    readonly exitCode?: number
+
+    /**
+     * Exits the process without logging anything on the console.
+     *
+     * @default false
+     */
+    readonly silent?: boolean
+
+    /**
+     * The process exits gracefully: it waits for any ongoing tasks (callbacks,
+     * promises, etc.) to complete, up to a specific `timeout`.
+     *
+     * Special values:
+     *  - `0`: Exits right away, without waiting for ongoing tasks
+     *  - `Number.POSITIVE_INFINITY`: Waits for ongoing tasks forever, without
+     *    timing out
+     *
+     * @default 5000
+     */
+    readonly timeout?: number
+
+    /**
+     * Function used to print the error message.
+     *
+     * @default console.error
+     */
+    readonly log?: (message: string) => void
+
+    /**
+     * Specify different options per error class. The object:
+     *  - Keys are either the
+     *    [`error.name`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Error/name),
+     *    or `"default"` (used if no `error.name` matches)
+     *  - Values are options objects
+     *
+     * @default {}
+     *
+     * @example
+     * ```js
+     * handleCliError(error, {
+     *   InputError: { exitCode: 1, stack: false },
+     *   DatabaseError: { exitCode: 2, stack: false },
+     *   default: { exitCode: 3 },
+     * })
+     * ```
+     */
+    readonly classes?: {
+        readonly [errorName: string]: Omit<Options_2, 'classes'>
+    }
+}
+
+/**
+ * `beautiful-error` options
+ */
+declare interface Options_3 {
+    /**
+     * Whether to show the `error` stack trace.
+     *
+     * @default true
+     */
+    readonly stack?: boolean
+
+    /**
+     * Whether to show nested errors, i.e.
+     * [`error.cause`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Error/cause)
+     * and
+     * [`error.errors`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/AggregateError/errors).
+     *
+     * @default true
+     */
+    readonly cause?: boolean
+
+    /**
+     * Whether to show the error's additional properties.
+     *
+     * @default true
+     */
+    readonly props?: boolean
+
+    /**
+     * Whether to colorize the error's message, stack trace and additional properties.
+     *
+     * Quoted strings in the error's message are printed in bold (for `"..."` and
+     * `'...'`) and in italic (for `` `...` ``).
+     *
+     * @default `true` in terminals, `false` otherwise
+     */
+    readonly colors?: boolean
+
+    /**
+     * Icon prepended to the error's name. The available values are listed
+     * [here](https://github.com/sindresorhus/figures/blob/main/readme.md#figures-1).
+     * Can be disabled by passing an empty string.
+     *
+     * @default 'cross'
+     */
+    readonly icon?: keyof typeof figureSet | ''
+
+    /**
+     * Color/style of the error's icon and name. The available values are listed
+     * [here](https://github.com/ehmicky/chalk-string#available-styles).
+     * Several styles can be specified by using spaces.
+     * Can be disabled by passing an empty string.
+     *
+     * @default 'red bold'
+     */
+    readonly header?: Styles | ''
+
+    /**
+     * Name of a method to map the output. That method must take the output as a
+     * string argument, transform it then return it.
+     *
+     * @example
+     * ```js
+     * class ExampleError extends Error {
+     *   beautiful(output) {
+     *     return output.replaceAll('secret', '***')
+     *   }
+     * }
+     *
+     * const error = new ExampleError('Unknown value: secret')
+     * const message = beautifulError(error) // 'Unknown value: ***'
+     * ```
+     *
+     * @default 'beautiful'
+     */
+    readonly custom?: string | symbol
+
+    /**
+     * Specify different options per error class. The object:
+     *  - Keys are either the
+     *    [`error.name`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Error/name),
+     *    or `"default"` (used if no `error.name` matches)
+     *  - Values are options objects
+     *
+     * @default {}
+     *
+     * @example
+     * ```js
+     * const message = beautifulError(error, {
+     *   InputError: { icon: 'warning', stack: false },
+     *   DatabaseError: { icon: 'info', stack: false },
+     *   default: { icon: 'cross' },
+     * })
+     * ```
+     */
+    readonly classes?: {
+        readonly [errorName: string]: Omit<Options_3, 'classes'>
+    }
+}
+
+/**
+ * Last variadic arguments of the `constructor` of the parent error class
+ */
+declare type ParentExtra<CustomClassArg extends CustomClass> =
+ConstructorParameters<CustomClassArg> extends readonly [
+unknown,
+unknown?,
+...infer Extra extends readonly unknown[],
+]
+? Extra
+: readonly never[]
+
+/**
+ * Second argument of the `constructor` of the parent error class
+ */
+declare type ParentInstanceOptions<
+PluginsArg extends Plugins,
+ChildProps extends ErrorProps,
+CustomClassArg extends CustomClass,
+AggregateErrorsArg extends AggregateErrors,
+CauseArg extends Cause,
+> = ConstructorParameters<CustomClassArg>[1] &
+SpecificInstanceOptions<PluginsArg, ChildProps, AggregateErrorsArg, CauseArg>
+
+/**
+ * Factory function that parses CSS and returns an API to query the parsed result
+ * @param cssString - The CSS file content as a string
+ * @returns API object with methods to query the parsed CSS
+ */
+export declare function parseCss(cssString: string): CSSParserAPI;
+
+/** Data could not be parsed or decoded (JSON, source code, config, CSS). */
+export declare const ParseError: SpecificErrorClass<    {
+name: "cli";
+isOptions: (options: unknown) => boolean;
+getOptions: (options?: Options) => {
+custom: string;
+stack?: boolean;
+cause?: boolean;
+props?: boolean;
+colors?: boolean;
+icon?: ("infinity" | "tick" | "info" | "warning" | "cross" | "square" | "squareSmall" | "squareSmallFilled" | "squareDarkShade" | "squareMediumShade" | "squareLightShade" | "squareTop" | "squareBottom" | "squareLeft" | "squareRight" | "squareCenter" | "circle" | "circleFilled" | "circleDotted" | "circleDouble" | "circleCircle" | "circleCross" | "circlePipe" | "circleQuestionMark" | "radioOn" | "radioOff" | "checkboxOn" | "checkboxOff" | "checkboxCircleOn" | "checkboxCircleOff" | "questionMarkPrefix" | "bullet" | "dot" | "ellipsis" | "pointer" | "pointerSmall" | "triangleUp" | "triangleUpSmall" | "triangleUpOutline" | "triangleDown" | "triangleDownSmall" | "triangleLeft" | "triangleLeftSmall" | "triangleRight" | "triangleRightSmall" | "lozenge" | "lozengeOutline" | "home" | "hamburger" | "smiley" | "mustache" | "heart" | "star" | "play" | "musicNote" | "musicNoteBeamed" | "nodejs" | "arrowUp" | "arrowDown" | "arrowLeft" | "arrowRight" | "arrowLeftRight" | "arrowUpDown" | "almostEqual" | "notEqual" | "lessOrEqual" | "greaterOrEqual" | "identical" | "subscriptZero" | "subscriptOne" | "subscriptTwo" | "subscriptThree" | "subscriptFour" | "subscriptFive" | "subscriptSix" | "subscriptSeven" | "subscriptEight" | "subscriptNine" | "oneHalf" | "oneThird" | "oneQuarter" | "oneFifth" | "oneSixth" | "oneSeventh" | "oneEighth" | "oneNinth" | "oneTenth" | "twoThirds" | "twoFifths" | "threeQuarters" | "threeFifths" | "threeEighths" | "fourFifths" | "fiveSixths" | "fiveEighths" | "sevenEighth" | "line" | "lineBold" | "lineDouble" | "lineDashed0" | "lineDashed1" | "lineDashed2" | "lineDashed3" | "lineDashed4" | "lineDashed5" | "lineDashed6" | "lineDashed7" | "lineDashed8" | "lineDashed9" | "lineDashed10" | "lineDashed11" | "lineDashed12" | "lineDashed13" | "lineDashed14" | "lineDashed15" | "lineVertical" | "lineVerticalBold" | "lineVerticalDouble" | "lineVerticalDashed0" | "lineVerticalDashed1" | "lineVerticalDashed2" | "lineVerticalDashed3" | "lineVerticalDashed4" | "lineVerticalDashed5" | "lineVerticalDashed6" | "lineVerticalDashed7" | "lineVerticalDashed8" | "lineVerticalDashed9" | "lineVerticalDashed10" | "lineVerticalDashed11" | "lineDownLeft" | "lineDownLeftArc" | "lineDownBoldLeftBold" | "lineDownBoldLeft" | "lineDownLeftBold" | "lineDownDoubleLeftDouble" | "lineDownDoubleLeft" | "lineDownLeftDouble" | "lineDownRight" | "lineDownRightArc" | "lineDownBoldRightBold" | "lineDownBoldRight" | "lineDownRightBold" | "lineDownDoubleRightDouble" | "lineDownDoubleRight" | "lineDownRightDouble" | "lineUpLeft" | "lineUpLeftArc" | "lineUpBoldLeftBold" | "lineUpBoldLeft" | "lineUpLeftBold" | "lineUpDoubleLeftDouble" | "lineUpDoubleLeft" | "lineUpLeftDouble" | "lineUpRight" | "lineUpRightArc" | "lineUpBoldRightBold" | "lineUpBoldRight" | "lineUpRightBold" | "lineUpDoubleRightDouble" | "lineUpDoubleRight" | "lineUpRightDouble" | "lineUpDownLeft" | "lineUpBoldDownBoldLeftBold" | "lineUpBoldDownBoldLeft" | "lineUpDownLeftBold" | "lineUpBoldDownLeftBold" | "lineUpDownBoldLeftBold" | "lineUpDownBoldLeft" | "lineUpBoldDownLeft" | "lineUpDoubleDownDoubleLeftDouble" | "lineUpDoubleDownDoubleLeft" | "lineUpDownLeftDouble" | "lineUpDownRight" | "lineUpBoldDownBoldRightBold" | "lineUpBoldDownBoldRight" | "lineUpDownRightBold" | "lineUpBoldDownRightBold" | "lineUpDownBoldRightBold" | "lineUpDownBoldRight" | "lineUpBoldDownRight" | "lineUpDoubleDownDoubleRightDouble" | "lineUpDoubleDownDoubleRight" | "lineUpDownRightDouble" | "lineDownLeftRight" | "lineDownBoldLeftBoldRightBold" | "lineDownLeftBoldRightBold" | "lineDownBoldLeftRight" | "lineDownBoldLeftBoldRight" | "lineDownBoldLeftRightBold" | "lineDownLeftRightBold" | "lineDownLeftBoldRight" | "lineDownDoubleLeftDoubleRightDouble" | "lineDownDoubleLeftRight" | "lineDownLeftDoubleRightDouble" | "lineUpLeftRight" | "lineUpBoldLeftBoldRightBold" | "lineUpLeftBoldRightBold" | "lineUpBoldLeftRight" | "lineUpBoldLeftBoldRight" | "lineUpBoldLeftRightBold" | "lineUpLeftRightBold" | "lineUpLeftBoldRight" | "lineUpDoubleLeftDoubleRightDouble" | "lineUpDoubleLeftRight" | "lineUpLeftDoubleRightDouble" | "lineUpDownLeftRight" | "lineUpBoldDownBoldLeftBoldRightBold" | "lineUpDownBoldLeftBoldRightBold" | "lineUpBoldDownLeftBoldRightBold" | "lineUpBoldDownBoldLeftRightBold" | "lineUpBoldDownBoldLeftBoldRight" | "lineUpBoldDownLeftRight" | "lineUpDownBoldLeftRight" | "lineUpDownLeftBoldRight" | "lineUpDownLeftRightBold" | "lineUpBoldDownBoldLeftRight" | "lineUpDownLeftBoldRightBold" | "lineUpBoldDownLeftBoldRight" | "lineUpBoldDownLeftRightBold" | "lineUpDownBoldLeftBoldRight" | "lineUpDownBoldLeftRightBold" | "lineUpDoubleDownDoubleLeftDoubleRightDouble" | "lineUpDoubleDownDoubleLeftRight" | "lineUpDownLeftDoubleRightDouble" | "lineCross" | "lineBackslash" | "lineSlash") | "";
+header?: Styles | "";
+classes?: {
+readonly [errorName: string]: Omit<Options_3, "classes">;
+} & {
+readonly [errorName: string]: Omit<Options_2, "classes">;
+};
+exitCode?: number;
+silent?: boolean;
+timeout?: number;
+log?: (message: string) => void;
+};
+instanceMethods: {
+exit: ({ error, options }: Info<Options>["instanceMethods"]) => void;
+pretty: ({ error, options: { exitCode, silent, timeout, log, ...beautifulErrorOptions }, }: Info<Options>["instanceMethods"]) => string;
+};
+}[], {
+/** Pipeline stage where the error originated (composed at runtime). */
+phase: string;
+/** True if this error represents a violated invariant, not a user error. */
+isDefect: boolean;
+/** Process exit code used by BaseError.exit(). */
+exitCode: number;
+} & object, CustomClass>;
+
+/**
+ * Plugins extend `modern-errors` features.
+ *
+ * @example
+ * ```js
+ * export default {
+ *   // Name used to configure the plugin
+ *   name: 'example',
+ *
+ *   // Set error properties
+ *   properties(info) {
+ *     return {}
+ *   },
+ *
+ *   // Add instance methods like `ErrorClass.exampleMethod(error, ...args)` or
+ *   // `error.exampleMethod(...args)`
+ *   instanceMethods: {
+ *     exampleMethod(info, ...args) {
+ *       // ...
+ *     },
+ *   },
+ *
+ *   // Add static methods like `ErrorClass.staticMethod(...args)`
+ *   staticMethods: {
+ *     staticMethod(info, ...args) {
+ *       // ...
+ *     },
+ *   },
+ *
+ *   // Validate and normalize options
+ *   getOptions(options, full) {
+ *     return options
+ *   },
+ *
+ *   // Determine if a value is plugin's options
+ *   isOptions(options) {
+ *     return typeof options === 'boolean'
+ *   },
+ * }
+ * ```
+ */
+declare interface Plugin {
+    /**
+     * Plugin's name. It is used to configure the plugin's options.
+     *
+     * Only lowercase letters must be used (as opposed to `_` `-` `.` or uppercase
+     * letters).
+     *
+     * @example
+     * ```js
+     * // Users configure this plugin using
+     * // `ErrorClass.subclass('ErrorName', { example: ... })`
+     * // or `new ErrorClass('...', { example: ... })
+     * export default {
+     *   name: 'example',
+     * }
+     * ```
+     */
+    readonly name: string
+
+    /**
+     * Normalize and return the plugin's `options`.
+     * Required to use plugin `options`.
+     *
+     * If `options` are invalid, an `Error` should be thrown. The error message is
+     * automatically prepended with `Invalid "${plugin.name}" options:`. Regular
+     * [`Error`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Error)s
+     * should be thrown, as opposed to using `modern-errors` itself.
+     *
+     * The plugin's `options` can have any type.
+     *
+     * @example
+     * ```js
+     * export default {
+     *   name: 'example',
+     *   getOptions(options = true) {
+     *     if (typeof options !== 'boolean') {
+     *       throw new Error('It must be true or false.')
+     *     }
+     *
+     *     return options
+     *   },
+     * }
+     * ```
+     */
+    readonly getOptions?: GetOptions
+
+    /**
+     * Plugin users can pass the plugin's `options` as the last argument of any
+     * plugin method (instance or static). `isOptions()` determines whether the
+     * last argument of a plugin method are `options` or not.
+     * This should be defined if the plugin has any method with arguments.
+     *
+     * If `options` are invalid but can be determined not to be the last argument
+     * of any plugin's method, `isOptions()` should still return `true`. This
+     * allows `getOptions()` to validate them and throw proper error messages.
+     *
+     * @example
+     * ```js
+     * // `ErrorClass.exampleMethod(error, 'one', true)` results in:
+     * //   options: true
+     * //   args: ['one']
+     * // `ErrorClass.exampleMethod(error, 'one', 'two')` results in:
+     * //   options: undefined
+     * //   args: ['one', 'two']
+     * export default {
+     *   name: 'example',
+     *   isOptions(options) {
+     *     return typeof options === 'boolean'
+     *   },
+     *   getOptions(options) {
+     *     return options
+     *   },
+     *   instanceMethod: {
+     *     exampleMethod({ options }, ...args) {
+     *       // ...
+     *     },
+     *   },
+     * }
+     * ```
+     */
+    readonly isOptions?: IsOptions
+
+    /**
+     * Add error instance methods like `ErrorClass.methodName(error, ...args)` or
+     * `error.methodName(...args)`. Unlike static methods, this should be used
+     * when the method's main argument is an `error` instance.
+     *
+     * The first argument `info` is provided by `modern-errors`. The `error`
+     * argument is passed as `info.error`. The other `...args` are forwarded from
+     * the method's call.
+     *
+     * @example
+     * ```js
+     * export default {
+     *   name: 'example',
+     *   // `ErrorClass.concatMessage(error, "one")` or
+     *   // `error.concatMessage("one")`
+     *   // return `${error.message} - one`
+     *   instanceMethods: {
+     *     concatMessage(info, string) {
+     *       return `${info.error.message} - ${string}`
+     *     },
+     *   },
+     * }
+     * ```
+     */
+    readonly instanceMethods?: InstanceMethods
+
+    /**
+     * Add error static methods like `ErrorClass.methodName(...args)`. Unlike
+     * instance methods, this should be used when the method's main argument is
+     * _not_ an `error` instance.
+     *
+     * The first argument `info` is provided by `modern-errors`. `info.error` is
+     * not defined. The other `...args` are forwarded from the method's call.
+     *
+     * @example
+     * ```js
+     * export default {
+     *   name: 'example',
+     *   // `ErrorClass.multiply(2, 3)` returns `6`
+     *   staticMethods: {
+     *     multiply(info, first, second) {
+     *       return first * second
+     *     },
+     *   },
+     * }
+     * ```
+     */
+    readonly staticMethods?: StaticMethods
+
+    /**
+     * Set properties on `error.*` (including `message` or `stack`).
+     * The properties to set must be returned as an object.
+     *
+     * Error properties that are internal or secret can be prefixed with `_`.
+     * This makes them
+     * [non-enumerable](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Enumerability_and_ownership_of_properties),
+     * which prevents iterating or logging them.
+     *
+     * @example
+     * ```js
+     * export default {
+     *   name: 'example',
+     *   // Sets `error.example: true`
+     *   properties() {
+     *     return { example: true }
+     *   },
+     * }
+     * ```
+     */
+    readonly properties?: GetProperties
+}
+
+/**
+ * Bound instance methods of a plugin, if defined
+ */
+declare type PluginInstanceMethods<PluginArg extends Plugin> = PluginArg extends {
+    instanceMethods: InstanceMethods
+}
+? ErrorInstanceMethods<PluginArg['instanceMethods'], MethodOptions<PluginArg>>
+: object
+
+/**
+ * Bound mixed methods of a plugin, if defined
+ */
+declare type PluginMixedMethods<PluginArg extends Plugin> = PluginArg extends {
+    instanceMethods: InstanceMethods
+}
+? ErrorMixedMethods<PluginArg['instanceMethods'], MethodOptions<PluginArg>>
+: object
+
+/**
+ * Exclude plugins with a `name` that is not typed `as const`
+ */
+declare type PluginOptionName<PluginArg extends Plugin> =
+string extends PluginArg['name']
+? never
+: ExternalPluginOptions<PluginArg> extends never
+? never
+: PluginArg['name']
+
+/**
+ * Bound added properties of a plugin, if defined
+ */
+declare type PluginProperties<PluginArg extends Plugin> = PluginArg extends Plugin
+? PluginArg extends { properties: GetProperties }
+? ReturnType<PluginArg['properties']>
+: object
+: object
+
+/**
+ * List of plugins
+ */
+declare type Plugins = readonly Plugin[]
+
+/**
+ * Bound instance methods of all plugins
+ */
+declare type PluginsInstanceMethods<PluginsArg extends Plugins> =
+UnionToIntersection<PluginInstanceMethods<PluginsArg[number]>> & {}
+
+/**
+ * Bound mixed methods of all plugins
+ */
+declare type PluginsMixedMethods<PluginsArg extends Plugins> =
+UnionToIntersection<PluginMixedMethods<PluginsArg[number]>> & {}
+
+/**
+ * Options of all plugins, including core plugins
+ */
+declare type PluginsOptions<
+PluginsArg extends Plugins,
+ChildProps extends ErrorProps,
+> = keyof ExternalPluginsOptions<PluginsArg> extends never
+? CorePluginsOptions<ChildProps>
+: CorePluginsOptions<ChildProps> & ExternalPluginsOptions<PluginsArg>
+
+/**
+ * Bound added properties of all plugins
+ */
+declare type PluginsProperties<PluginsArg extends Plugins> = UnionToIntersection<
+PluginProperties<PluginsArg[number]>
+> & {}
+
+/**
+ * Bound static methods of all plugins
+ */
+declare type PluginsStaticMethods<PluginsArg extends Plugins> =
+UnionToIntersection<PluginStaticMethods<PluginsArg[number]>> & {}
+
+/**
+ * Bound static methods of a plugin, if defined
+ */
+declare type PluginStaticMethods<PluginArg extends Plugin> = PluginArg extends {
+    staticMethods: StaticMethods
+}
+? ErrorStaticMethods<PluginArg['staticMethods'], MethodOptions<PluginArg>>
+: object
+
+declare type Prev = [
+never,
+0,
+1,
+2,
+3,
+4,
+5,
+6,
+7,
+8,
+9,
+10,
+11,
+12,
+13,
+14,
+15,
+16,
+17,
+18,
+19,
+20,
+21,
+22,
+23,
+24,
+25,
+26,
+27,
+28,
+29,
+30,
+31,
+32,
+33,
+34,
+35,
+36,
+37,
+38,
+39,
+40,
+41,
+42,
+43,
+44,
+45,
+46,
+47,
+48,
+49,
+...0[]
+];
+
+/** The result of processing a single component through the manifest pipeline. */
+export declare interface ProcessComponentResult {
+    component: ComponentInfoWithCss;
+}
+
+export declare interface PropInfo {
+    name: string;
+    type: string;
+    required: boolean;
+    defaultValue?: DefaultValue;
+    resolvedType: ResolvedType;
+    description?: string;
+    deprecated?: boolean;
+}
+
+export declare interface PropSpyMeta {
+    path: string;
+    propName: string;
+    originalValue: unknown;
+}
+
+export declare interface PropTrackerData {
+    tag: string;
+    role?: string;
+    boundProps: string[];
+    concatenatedAttrs: Map<string, string>;
+}
+
+export declare interface PropTrackerExtractorState {
+    stores: TrackingStores;
+}
+
+export declare interface PropWriteInfo {
+    elements: Map<string, {
+        tag: string;
+        elementId: string;
+    }>;
+    attributes: Map<string, {
+        attr: string;
+        concatenated: boolean;
+    }>;
+}
+
+/**
+ * Interface for pluggable extractors.
+ * Extractors can hook into any combination of lifecycle events.
+ */
+export declare interface ReactExtractor {
+    name: string;
+    onBeforeRender?(context: RenderContext): void;
+    onCreateElement?(event: CreateElementEvent): void;
+    onRenderComplete?(event: RenderCompleteEvent): void;
+}
+
+/**
+ * Event emitted after render completes.
+ */
+export declare interface RenderCompleteEvent {
+    html: string;
+    context: RenderContext;
+}
+
+/**
+ * Context available to extractors during the beforeRender phase.
+ * Props are mutable - extractors can modify them before render.
+ */
+export declare interface RenderContext {
+    componentInfo: ComponentInfo;
+    component: ComponentType<unknown>;
+    props: Record<string, unknown>;
+    store: ExtractorStore;
+}
+
+/**
+ * Renders a React component to static HTML while intercepting element creation.
+ *
+ * Uses monkey-patching of React.createElement and jsx/jsxs to notify listeners
+ * when DOM elements are created. Each DOM element gets a unique `data-trace-id`
+ * attribute for tracking.
+ *
+ * @param Component - The React component to render
+ * @param componentProps - Props to pass to the component
+ * @param listeners - Listeners to notify on each DOM element creation
+ * @param store - Shared ExtractorStore, included in each CreateElementEvent
+ * @returns Static HTML string with trace IDs on DOM elements
+ *
+ * @example
+ * ```ts
+ * const store = new ExtractorStore()
+ * const tracker = createPropTracker(getSpyMetadata)
+ * const html = renderWithExtractors(MyComponent, { title: 'Hello' }, [tracker], store)
+ * // html contains: <div data-trace-id="t1">...</div>
+ * // tracker.stores now has prop→DOM bindings
+ * ```
+ */
+export declare function renderWithExtractors(Component: ComponentType<unknown>, componentProps: unknown, listeners: CreateElementListener[], store: ExtractorStore): string;
+
+/**
+ * API to extract component props with full TypeScript type resolution
+ */
+export declare type ResolvedKind = 'primitive' | 'semantic' | 'array' | 'object' | 'union' | 'intersection' | 'enum' | 'literal' | 'function';
+
+export declare interface ResolvedType {
+    kind: ResolvedKind;
+    value?: unknown;
+    /** For semantic types, the package the symbol came from */
+    source?: string;
+    properties?: Record<string, PropInfo>;
+    elementType?: ResolvedType;
+    types?: ResolvedType[];
+}
+
+export declare namespace Result {
+    /**
+     * Wraps a function with a try catch, creating a new function with the same
+     * arguments but returning `Ok` if successful, `Err` if the function throws
+     *
+     * @param fn function to wrap with ok on success or err on failure
+     * @param errorFn when an error is thrown, this will wrap the error result if provided
+     */
+    export function fromThrowable<Fn extends (...args: readonly any[]) => any, E>(fn: Fn, errorFn?: (e: unknown) => E): (...args: Parameters<Fn>) => Result<ReturnType<Fn>, E>;
+    export function combine<T extends readonly [Result<unknown, unknown>, ...Result<unknown, unknown>[]]>(resultList: T): CombineResults<T>;
+    export function combine<T extends readonly Result<unknown, unknown>[]>(resultList: T): CombineResults<T>;
+    export function combineWithAllErrors<T extends readonly [Result<unknown, unknown>, ...Result<unknown, unknown>[]]>(resultList: T): CombineResultsWithAllErrorsArray<T>;
+    export function combineWithAllErrors<T extends readonly Result<unknown, unknown>[]>(resultList: T): CombineResultsWithAllErrorsArray<T>;
+}
+
+export declare type Result<T, E> = Ok<T, E> | Err<T, E>;
+
+export declare class ResultAsync<T, E> implements PromiseLike<Result<T, E>> {
+    private _promise;
+    constructor(res: Promise<Result<T, E>>);
+    static fromSafePromise<T, E = never>(promise: PromiseLike<T>): ResultAsync<T, E>;
+    static fromPromise<T, E>(promise: PromiseLike<T>, errorFn: (e: unknown) => E): ResultAsync<T, E>;
+    static fromThrowable<A extends readonly any[], R, E>(fn: (...args: A) => Promise<R>, errorFn?: (err: unknown) => E): (...args: A) => ResultAsync<R, E>;
+    static combine<T extends readonly [ResultAsync<unknown, unknown>, ...ResultAsync<unknown, unknown>[]]>(asyncResultList: T): CombineResultAsyncs<T>;
+    static combine<T extends readonly ResultAsync<unknown, unknown>[]>(asyncResultList: T): CombineResultAsyncs<T>;
+    static combineWithAllErrors<T extends readonly [ResultAsync<unknown, unknown>, ...ResultAsync<unknown, unknown>[]]>(asyncResultList: T): CombineResultsWithAllErrorsArrayAsync<T>;
+    static combineWithAllErrors<T extends readonly ResultAsync<unknown, unknown>[]>(asyncResultList: T): CombineResultsWithAllErrorsArrayAsync<T>;
+    map<A>(f: (t: T) => A | Promise<A>): ResultAsync<A, E>;
+    andThrough<F>(f: (t: T) => Result<unknown, F> | ResultAsync<unknown, F>): ResultAsync<T, E | F>;
+    andTee(f: (t: T) => unknown): ResultAsync<T, E>;
+    orTee(f: (t: E) => unknown): ResultAsync<T, E>;
+    mapErr<U>(f: (e: E) => U | Promise<U>): ResultAsync<T, U>;
+    andThen<R extends Result<unknown, unknown>>(f: (t: T) => R): ResultAsync<InferOkTypes<R>, InferErrTypes<R> | E>;
+    andThen<R extends ResultAsync<unknown, unknown>>(f: (t: T) => R): ResultAsync<InferAsyncOkTypes<R>, InferAsyncErrTypes<R> | E>;
+    andThen<U, F>(f: (t: T) => Result<U, F> | ResultAsync<U, F>): ResultAsync<U, E | F>;
+    orElse<R extends Result<unknown, unknown>>(f: (e: E) => R): ResultAsync<InferOkTypes<R> | T, InferErrTypes<R>>;
+    orElse<R extends ResultAsync<unknown, unknown>>(f: (e: E) => R): ResultAsync<InferAsyncOkTypes<R> | T, InferAsyncErrTypes<R>>;
+    orElse<U, A>(f: (e: E) => Result<U, A> | ResultAsync<U, A>): ResultAsync<U | T, A>;
+    match<A, B = A>(ok: (t: T) => A, _err: (e: E) => B): Promise<A | B>;
+    unwrapOr<A>(t: A): Promise<T | A>;
+    /**
+     * @deprecated will be removed in 9.0.0.
+     *
+     * You can use `safeTry` without this method.
+     * @example
+     * ```typescript
+     * safeTry(async function* () {
+     *   const okValue = yield* yourResult
+     * })
+     * ```
+     * Emulates Rust's `?` operator in `safeTry`'s body. See also `safeTry`.
+     */
+    safeUnwrap(): AsyncGenerator<Err<never, E>, T>;
+    then<A, B>(successCallback?: (res: Result<T, E>) => A | PromiseLike<A>, failureCallback?: (reason: unknown) => B | PromiseLike<B>): PromiseLike<A | B>;
+    [Symbol.asyncIterator](): AsyncGenerator<Err<never, E>, T>;
+}
+
+/**
+ * Runs extractors through the full lifecycle and returns extraction results.
+ *
+ * @param componentInfo - TypeScript-extracted component information
+ * @param component - The React component to render
+ * @param extractors - Array of extractors to run
+ * @returns Extraction results including HTML, store, and element tree
+ */
+export declare function runExtractors(componentInfo: ComponentInfo, component: ComponentType<unknown>, extractors: ReactExtractor[], options?: RunExtractorsOptions): ExtractionResult;
+
+export declare interface RunExtractorsOptions {
+    /** Optional HOC to wrap the component before rendering (e.g. a context provider). */
+    wrapper?: (component: ComponentType<unknown>) => ComponentType<unknown>;
+}
+
+/**
+ * Like `LowObject & HighObject` except that if both keys are defined,
+ * `HighObject` overrides `LowObject` instead of intersecting to it
+ */
+declare type SetProps<
+LowObject extends object,
+HighObject extends object,
+> = Omit<LowObject, keyof HighObject> & HighObject
+
+/**
+ * Like `SetProps<LowObject, HighObject>` except it reduces empty `{}` for
+ * simpler debugging.
+ */
+declare type SimpleSetProps<
+LowObject extends object,
+HighObject extends object,
+> = keyof LowObject extends keyof HighObject
+? HighObject
+: keyof LowObject & keyof HighObject extends never
+? LowObject & HighObject
+: SetProps<LowObject, HighObject>
+
+/**
+ * Omit the first item of a tuple
+ */
+declare type SliceFirst<Tuple extends readonly unknown[]> =
+Tuple extends readonly [unknown, ...infer Rest extends readonly unknown[]]
+? Rest
+: readonly never[]
+
+/**
+ * Class-specific options, used internally only with additional generics
+ */
+declare type SpecificClassOptions<
+PluginsArg extends Plugins,
+ChildPlugins extends Plugins,
+ChildProps extends ErrorProps,
+ChildCustomClass extends CustomClass,
+> = KnownClassOptions<ChildPlugins, ChildCustomClass> &
+PluginsOptions<[...PluginsArg, ...ChildPlugins], ChildProps>
+
+/**
+ * Error class, with specific `props`, `custom`, etc.
+ *
+ * @private This type is private and only exported as a temporary workaround
+ * for an open issue with TypeScript. It will be removed in a future release.
+ * See:
+ *
+ * - [modern-errors issue #35](https://github.com/ehmicky/modern-errors/issues/35)
+ * - [modern-errors issue #18](https://github.com/ehmicky/modern-errors/issues/18)
+ * - [TypeScript issue #47663](https://github.com/microsoft/TypeScript/issues/47663)
+ */
+declare type SpecificErrorClass<
+PluginsArg extends Plugins,
+ErrorPropsArg extends ErrorProps,
+CustomClassArg extends CustomClass,
+> = ErrorSubclassCore<PluginsArg, ErrorPropsArg, CustomClassArg> &
+OmitKeys<
+CustomClassArg,
+keyof ErrorSubclassCore<PluginsArg, ErrorPropsArg, CustomClassArg>
+> &
+PluginsStaticMethods<PluginsArg> &
+PluginsMixedMethods<PluginsArg>
+
+/**
+ * Error instance object, used internally with additional generics.
+ * This mixes: `Error`, aggregate errors, plugin instance methods,
+ * `plugin.properties()` and `props`, while ensuring those do not overlap each
+ * other.
+ */
+declare type SpecificErrorInstance<
+PluginsArg extends Plugins,
+ErrorPropsArg extends ErrorProps,
+CustomClassArg extends CustomClass,
+AggregateErrorsArg extends AggregateErrors,
+CauseArg extends Cause,
+> = SetProps<
+NormalizedCause<CauseArg>,
+SetProps<
+ErrorPropsArg,
+SetProps<
+PluginsProperties<PluginsArg>,
+SetProps<
+PluginsInstanceMethods<PluginsArg>,
+SetProps<
+InstanceType<CustomClassArg>,
+AggregateErrorsProperty<AggregateErrorsArg, CauseArg>
+>
+>
+>
+>
+>
+
+/**
+ * Options passed to error constructors, used internally only with additional
+ * generics
+ */
+declare type SpecificInstanceOptions<
+PluginsArg extends Plugins,
+ChildProps extends ErrorProps,
+AggregateErrorsArg extends AggregateErrors,
+CauseArg extends Cause,
+> = MainInstanceOptions<AggregateErrorsArg, CauseArg> &
+PluginsOptions<PluginsArg, ChildProps>
+
+/**
+ * Unbound static method of a plugin
+ */
+declare type StaticMethod = (
+info: InfoParameter['staticMethods'],
+...args: readonly never[]
+) => unknown
+
+/**
+ * Unbound static methods of a plugin
+ */
+declare interface StaticMethods {
+    readonly [MethodName: string]: StaticMethod
+}
+
+declare type Style =
+| BasicStyle
+| BasicColors
+| `${BasicColors}Bright`
+| `hex-${string}`
+| `rgb-${number}-${number}-${number}`
+| `bg${Capitalize<BasicColors>}`
+| `bg${Capitalize<BasicColors>}Bright`
+| `bgHex-${string}`
+| `bgRgb-${number}-${number}-${number}`
+
+/**
+ * Space-separated list of styles. Some styles require dash-separated arguments.
+ */
+declare type Styles = Style | `${Style} ${Style}`
+
+export declare interface TrackingStores {
+    propUsages: Map<string, PropWriteInfo>;
+}
+
+declare type Transpose<A, Transposed extends unknown[][] = [], Depth extends number = 10> = A extends [infer T, ...infer Rest] ? T extends [infer L, infer R] ? Transposed extends [infer PL, infer PR] ? PL extends unknown[] ? PR extends unknown[] ? Transpose<Rest, [[...PL, L], [...PR, R]], Prev[Depth]> : never : never : Transpose<Rest, [[L], [R]], Prev[Depth]> : Transposed : Transposed;
+
+declare type Traverse<T, Depth extends number = 5> = Combine<T, Depth> extends [infer Oks, infer Errs] ? Result<EmptyArrayToNever<Oks, 1>, MembersToUnion<Errs>> : never;
+
+declare type TraverseAsync<T, Depth extends number = 5> = IsLiteralArray<T> extends 1 ? Combine<T, Depth> extends [infer Oks, infer Errs] ? ResultAsync<EmptyArrayToNever<Oks>, MembersToUnion<Errs>> : never : T extends Array<infer I> ? Combine<MemberListOf<I>, Depth> extends [infer Oks, infer Errs] ? Oks extends unknown[] ? Errs extends unknown[] ? ResultAsync<EmptyArrayToNever<Oks[number][]>, MembersToUnion<Errs[number][]>> : ResultAsync<EmptyArrayToNever<Oks[number][]>, Errs> : Errs extends unknown[] ? ResultAsync<Oks, MembersToUnion<Errs[number][]>> : ResultAsync<Oks, Errs> : never : never;
+
+declare type TraverseWithAllErrors<T, Depth extends number = 5> = Traverse<T, Depth> extends Result<infer Oks, infer Errs> ? Result<Oks, Errs[]> : never;
+
+declare type TraverseWithAllErrorsAsync<T, Depth extends number = 5> = TraverseAsync<T, Depth> extends ResultAsync<infer Oks, infer Errs> ? ResultAsync<Oks, Errs[]> : never;
+
+/**
+ * Turn `T | T2 | ...` into `T & T2 & ...`
+ */
+declare type UnionToIntersection<T> = (
+T extends unknown ? (arg: T) => unknown : never
+) extends (arg: infer U) => unknown
+? U
+: never
+
+declare type UnknownMembersToNever<T> = T extends [infer H, ...infer R] ? [[unknown] extends [H] ? never : H, ...UnknownMembersToNever<R>] : T;
+
+/**
+ * Remove the types of all `info.*` members to fix some type conflict issues
+ */
+declare type UntypedInfo<SpecificInfo> = {
+    readonly [InfoPropName in keyof SpecificInfo]: never
+}
+
+declare type UnwrapAsync<T> = IsLiteralArray<T> extends 1 ? Writable<T> extends [infer H, ...infer Rest] ? H extends PromiseLike<infer HI> ? HI extends Result<unknown, unknown> ? [Dedup<HI>, ...UnwrapAsync<Rest>] : never : never : [] : T extends Array<infer A> ? A extends PromiseLike<infer HI> ? HI extends Result<infer L, infer R> ? Ok<L, R>[] : never : never : never;
+
+/** Input or data does not satisfy validation rules. */
+export declare const ValidationError: SpecificErrorClass<    {
+name: "cli";
+isOptions: (options: unknown) => boolean;
+getOptions: (options?: Options) => {
+custom: string;
+stack?: boolean;
+cause?: boolean;
+props?: boolean;
+colors?: boolean;
+icon?: ("infinity" | "tick" | "info" | "warning" | "cross" | "square" | "squareSmall" | "squareSmallFilled" | "squareDarkShade" | "squareMediumShade" | "squareLightShade" | "squareTop" | "squareBottom" | "squareLeft" | "squareRight" | "squareCenter" | "circle" | "circleFilled" | "circleDotted" | "circleDouble" | "circleCircle" | "circleCross" | "circlePipe" | "circleQuestionMark" | "radioOn" | "radioOff" | "checkboxOn" | "checkboxOff" | "checkboxCircleOn" | "checkboxCircleOff" | "questionMarkPrefix" | "bullet" | "dot" | "ellipsis" | "pointer" | "pointerSmall" | "triangleUp" | "triangleUpSmall" | "triangleUpOutline" | "triangleDown" | "triangleDownSmall" | "triangleLeft" | "triangleLeftSmall" | "triangleRight" | "triangleRightSmall" | "lozenge" | "lozengeOutline" | "home" | "hamburger" | "smiley" | "mustache" | "heart" | "star" | "play" | "musicNote" | "musicNoteBeamed" | "nodejs" | "arrowUp" | "arrowDown" | "arrowLeft" | "arrowRight" | "arrowLeftRight" | "arrowUpDown" | "almostEqual" | "notEqual" | "lessOrEqual" | "greaterOrEqual" | "identical" | "subscriptZero" | "subscriptOne" | "subscriptTwo" | "subscriptThree" | "subscriptFour" | "subscriptFive" | "subscriptSix" | "subscriptSeven" | "subscriptEight" | "subscriptNine" | "oneHalf" | "oneThird" | "oneQuarter" | "oneFifth" | "oneSixth" | "oneSeventh" | "oneEighth" | "oneNinth" | "oneTenth" | "twoThirds" | "twoFifths" | "threeQuarters" | "threeFifths" | "threeEighths" | "fourFifths" | "fiveSixths" | "fiveEighths" | "sevenEighth" | "line" | "lineBold" | "lineDouble" | "lineDashed0" | "lineDashed1" | "lineDashed2" | "lineDashed3" | "lineDashed4" | "lineDashed5" | "lineDashed6" | "lineDashed7" | "lineDashed8" | "lineDashed9" | "lineDashed10" | "lineDashed11" | "lineDashed12" | "lineDashed13" | "lineDashed14" | "lineDashed15" | "lineVertical" | "lineVerticalBold" | "lineVerticalDouble" | "lineVerticalDashed0" | "lineVerticalDashed1" | "lineVerticalDashed2" | "lineVerticalDashed3" | "lineVerticalDashed4" | "lineVerticalDashed5" | "lineVerticalDashed6" | "lineVerticalDashed7" | "lineVerticalDashed8" | "lineVerticalDashed9" | "lineVerticalDashed10" | "lineVerticalDashed11" | "lineDownLeft" | "lineDownLeftArc" | "lineDownBoldLeftBold" | "lineDownBoldLeft" | "lineDownLeftBold" | "lineDownDoubleLeftDouble" | "lineDownDoubleLeft" | "lineDownLeftDouble" | "lineDownRight" | "lineDownRightArc" | "lineDownBoldRightBold" | "lineDownBoldRight" | "lineDownRightBold" | "lineDownDoubleRightDouble" | "lineDownDoubleRight" | "lineDownRightDouble" | "lineUpLeft" | "lineUpLeftArc" | "lineUpBoldLeftBold" | "lineUpBoldLeft" | "lineUpLeftBold" | "lineUpDoubleLeftDouble" | "lineUpDoubleLeft" | "lineUpLeftDouble" | "lineUpRight" | "lineUpRightArc" | "lineUpBoldRightBold" | "lineUpBoldRight" | "lineUpRightBold" | "lineUpDoubleRightDouble" | "lineUpDoubleRight" | "lineUpRightDouble" | "lineUpDownLeft" | "lineUpBoldDownBoldLeftBold" | "lineUpBoldDownBoldLeft" | "lineUpDownLeftBold" | "lineUpBoldDownLeftBold" | "lineUpDownBoldLeftBold" | "lineUpDownBoldLeft" | "lineUpBoldDownLeft" | "lineUpDoubleDownDoubleLeftDouble" | "lineUpDoubleDownDoubleLeft" | "lineUpDownLeftDouble" | "lineUpDownRight" | "lineUpBoldDownBoldRightBold" | "lineUpBoldDownBoldRight" | "lineUpDownRightBold" | "lineUpBoldDownRightBold" | "lineUpDownBoldRightBold" | "lineUpDownBoldRight" | "lineUpBoldDownRight" | "lineUpDoubleDownDoubleRightDouble" | "lineUpDoubleDownDoubleRight" | "lineUpDownRightDouble" | "lineDownLeftRight" | "lineDownBoldLeftBoldRightBold" | "lineDownLeftBoldRightBold" | "lineDownBoldLeftRight" | "lineDownBoldLeftBoldRight" | "lineDownBoldLeftRightBold" | "lineDownLeftRightBold" | "lineDownLeftBoldRight" | "lineDownDoubleLeftDoubleRightDouble" | "lineDownDoubleLeftRight" | "lineDownLeftDoubleRightDouble" | "lineUpLeftRight" | "lineUpBoldLeftBoldRightBold" | "lineUpLeftBoldRightBold" | "lineUpBoldLeftRight" | "lineUpBoldLeftBoldRight" | "lineUpBoldLeftRightBold" | "lineUpLeftRightBold" | "lineUpLeftBoldRight" | "lineUpDoubleLeftDoubleRightDouble" | "lineUpDoubleLeftRight" | "lineUpLeftDoubleRightDouble" | "lineUpDownLeftRight" | "lineUpBoldDownBoldLeftBoldRightBold" | "lineUpDownBoldLeftBoldRightBold" | "lineUpBoldDownLeftBoldRightBold" | "lineUpBoldDownBoldLeftRightBold" | "lineUpBoldDownBoldLeftBoldRight" | "lineUpBoldDownLeftRight" | "lineUpDownBoldLeftRight" | "lineUpDownLeftBoldRight" | "lineUpDownLeftRightBold" | "lineUpBoldDownBoldLeftRight" | "lineUpDownLeftBoldRightBold" | "lineUpBoldDownLeftBoldRight" | "lineUpBoldDownLeftRightBold" | "lineUpDownBoldLeftBoldRight" | "lineUpDownBoldLeftRightBold" | "lineUpDoubleDownDoubleLeftDoubleRightDouble" | "lineUpDoubleDownDoubleLeftRight" | "lineUpDownLeftDoubleRightDouble" | "lineCross" | "lineBackslash" | "lineSlash") | "";
+header?: Styles | "";
+classes?: {
+readonly [errorName: string]: Omit<Options_3, "classes">;
+} & {
+readonly [errorName: string]: Omit<Options_2, "classes">;
+};
+exitCode?: number;
+silent?: boolean;
+timeout?: number;
+log?: (message: string) => void;
+};
+instanceMethods: {
+exit: ({ error, options }: Info<Options>["instanceMethods"]) => void;
+pretty: ({ error, options: { exitCode, silent, timeout, log, ...beautifulErrorOptions }, }: Info<Options>["instanceMethods"]) => string;
+};
+}[], {
+/** Pipeline stage where the error originated (composed at runtime). */
+phase: string;
+/** True if this error represents a violated invariant, not a user error. */
+isDefect: boolean;
+/** Process exit code used by BaseError.exit(). */
+exitCode: number;
+} & object, CustomClass>;
+
+/**
+ * Wrap an async entry point with a defect boundary.
+ *
+ * If the wrapped function throws an exception (i.e. a defect that was not
+ * captured as a Result), it is caught, wrapped in a DefectError, and printed
+ * via BaseError.exit().
+ *
+ * @param fn - The entry point function to wrap
+ * @throws {DefectError} If an unexpected exception occurs during execution
+ */
+export declare function withDefectBoundary(fn: () => Promise<void>): Promise<void>;
+
+declare type Writable<T> = T extends ReadonlyArray<unknown> ? [...T] : T;
+
+export { }