@aussieljk/forkbook 0.0.0-stage → 0.0.1-2

package/dist/common/index.d.ts

@@ -0,0 +1,1103 @@
+import { Is as DocgenProviderInput, Ms as DocgenMiddleware, Ns as DocgenPayload$1, Ws as IndexEntry$1 } from "../chunk-C2p5r3Vt.js";
+import { g as ChannelLike } from "../chunk-BXLImeLy.js";
+import { n as registerService } from "../chunk-CwQKNaYL.js";
+import { a as getPrettyPackageManagerName, c as PackageJson, d as ExecuteCommandOptions, f as executeCommand, i as getPackageDetails, l as PackageJsonWithDepsAndDevDeps, m as executeNodeCommand, n as PackageJsonInfo, o as InstallationMetadata, p as executeCommandSync, r as PackageManagerName, s as PackageMetadata, t as JsPackageManager, u as PackageJsonWithMaybeDeps } from "../chunk-B2t1tGRh.js";
+import { BuilderOptions, CLIOptions, CoreCommon_AddonInfo, CoreCommon_ResolvedAddonPreset, CoreCommon_ResolvedAddonVirtual, CoreCommon_StorybookInfo, IndexEntry, LoadOptions, LoadedPreset, NormalizedStoriesSpecifier, Options, PackageJson as PackageJson$1, PresetConfig, Presets, Ref, StoriesEntry, StorybookConfig, StorybookConfigRaw, SupportedBuilder, SupportedFramework, SupportedRenderer } from "@aussieljk/forkbook/internal/types";
+import { ConfigFile, CsfFile } from "@aussieljk/forkbook/internal/csf-tools";
+import { WriteStream } from "node:fs";
+import { types } from "@aussieljk/forkbook/internal/babel";
+import { isWebContainer } from "@webcontainer/env";
+import { FormatConfig } from "oxfmt";
+
+//#region ../../node_modules/type-fest/source/merge-exclusive.d.ts
+// Helper type. Not useful on its own.
+type Without<FirstType, SecondType> = { [KeyType in Exclude<keyof FirstType, keyof SecondType>]?: never };
+/**
+Create a type that has mutually exclusive keys.
+
+This type was inspired by [this comment](https://github.com/Microsoft/TypeScript/issues/14094#issuecomment-373782604).
+
+This type works with a helper type, called `Without`. `Without<FirstType, SecondType>` produces a type that has only keys from `FirstType` which are not present on `SecondType` and sets the value type for these keys to `never`. This helper type is then used in `MergeExclusive` to remove keys from either `FirstType` or `SecondType`.
+
+@example
+```
+import type {MergeExclusive} from 'type-fest';
+
+type ExclusiveVariation1 = {
+	exclusive1: boolean;
+};
+
+type ExclusiveVariation2 = {
+	exclusive2: string;
+};
+
+type ExclusiveOptions = MergeExclusive<ExclusiveVariation1, ExclusiveVariation2>;
+
+let exclusiveOptions: ExclusiveOptions;
+
+exclusiveOptions = {exclusive1: true};
+// Works
+
+exclusiveOptions = {exclusive2: 'hi'};
+// Works
+
+// @ts-expect-error
+exclusiveOptions = {exclusive1: true, exclusive2: 'hi'};
+// Error
+```
+
+@category Object
+*/
+type MergeExclusive<FirstType, SecondType> = (FirstType | SecondType) extends object ? (Without<FirstType, SecondType> & SecondType) | (Without<SecondType, FirstType> & FirstType) : FirstType | SecondType;
+//#endregion
+//#region .dts-emit/code/core/src/common/versions.d.ts
+declare const _default: {
+  '@aussieljk/forkbook': string;
+};
+//#endregion
+//#region .dts-emit/code/core/src/shared/constants/extensions.d.ts
+/**
+ * JS/TS source file extensions (incl. JSX/TSX). Used by parsers, bundlers, and other tooling that
+ * understands both languages but not framework single-file-component formats.
+ */
+declare const jsTsSourceExtensions: readonly ['.ts', '.tsx', '.js', '.jsx', '.mjs', '.cjs'];
+//#endregion
+//#region .dts-emit/code/core/src/common/presets.d.ts
+type InterPresetOptions = Omit<CLIOptions & LoadOptions & BuilderOptions & {
+  isCritical?: boolean;
+  build?: StorybookConfigRaw['build'];
+}, 'frameworkPresets'>;
+/**
+ * Parse an addon into either a managerEntries or a preset. Throw on invalid input.
+ *
+ * Valid inputs:
+ *
+ * - `'@aussieljk/forkbook/addon-docs/preset' => { type: 'presets', item }`
+ * - `'@aussieljk/forkbook/addon-docs' => { type: 'presets', item: '@aussieljk/forkbook/addon-docs/preset' }`
+ * - `{ name: '@aussieljk/forkbook/addon-docs(/preset)?', options: { } } => { type: 'presets', item: { name:
+ *   '@aussieljk/forkbook/addon-docs/preset', options } }`
+ */
+declare const resolveAddonName: (configDir: string, name: string, options: any) => CoreCommon_ResolvedAddonPreset | CoreCommon_ResolvedAddonVirtual | undefined;
+declare function loadPreset(input: PresetConfig, level: number, storybookOptions: InterPresetOptions): Promise<LoadedPreset[]>;
+declare function getPresets(presets: PresetConfig[], storybookOptions: InterPresetOptions): Promise<Presets>;
+declare function loadAllPresets(options: CLIOptions & LoadOptions & BuilderOptions & {
+  corePresets: PresetConfig[];
+  overridePresets: PresetConfig[]; /** Whether preset failures should be critical or not */
+  isCritical?: boolean;
+  build?: StorybookConfigRaw['build'];
+  channel: ChannelLike;
+}): Promise<Presets>;
+//#endregion
+//#region .dts-emit/code/core/src/common/utils/file-cache.d.ts
+interface FileSystemCacheOptions {
+  ns?: string;
+  prefix?: string;
+  hash_alg?: string;
+  basePath?: string;
+  ttl?: number;
+}
+interface CacheItem {
+  key: string;
+  content?: any;
+  value?: any;
+}
+interface CacheSetOptions {
+  ttl?: number;
+  encoding?: BufferEncoding;
+}
+declare class FileSystemCache {
+  private prefix;
+  private hash_alg;
+  private cache_dir;
+  private ttl;
+  constructor(options?: FileSystemCacheOptions);
+  private generateHash;
+  private isExpired;
+  private parseCacheData;
+  private parseSetData;
+  get<T = any>(name: string, fallback?: T): Promise<T>;
+  getSync<T>(name: string, fallback?: T): T;
+  set<T>(name: string, data: T, orgOpts?: CacheSetOptions | number): Promise<void>;
+  setSync<T>(name: string, data: T, orgOpts?: CacheSetOptions | number): void;
+  setMany(items: CacheItem[], options?: CacheSetOptions): Promise<void>;
+  setManySync(items: CacheItem[], options?: CacheSetOptions): void;
+  remove(name: string): Promise<void>;
+  removeSync(name: string): void;
+  clear(): Promise<void>;
+  clearSync(): void;
+  getAll(): Promise<CacheItem[]>;
+  load(): Promise<{
+    files: CacheItem[];
+  }>;
+}
+declare function createFileSystemCache(options: FileSystemCacheOptions): FileSystemCache;
+//#endregion
+//#region .dts-emit/code/core/src/common/utils/cache.d.ts
+declare const cache: FileSystemCache;
+//#endregion
+//#region .dts-emit/code/core/src/common/utils/cli.d.ts
+declare function temporaryDirectory({
+  prefix
+}?: {
+  prefix?: string | undefined;
+}): Promise<string>;
+type FileOptions = MergeExclusive<{
+  /**
+   * File extension.
+   *
+   * Mutually exclusive with the `name` option.
+   *
+   * _You usually won't need this option. Specify it only when actually needed._
+   */
+  readonly extension?: string;
+}, {
+  /**
+   * Filename.
+   *
+   * Mutually exclusive with the `extension` option.
+   *
+   * _You usually won't need this option. Specify it only when actually needed._
+   */
+  readonly name?: string;
+}>;
+declare function temporaryFile({
+  name,
+  extension
+}?: FileOptions): Promise<string>;
+declare function parseList(str: string): string[];
+declare function getEnvConfig(program: Record<string, any>, configEnv: Record<string, any>): void;
+/**
+ * Given a file name, creates an object with utilities to manage a log file. It creates a temporary
+ * log file which you can manage with the returned functions. You can then decide whether to move
+ * the log file to the users project, or remove it.
+ *
+ * @example
+ *
+ * ```ts
+ * const { logStream, moveLogFile, removeLogFile, clearLogFile, readLogFile } =
+ *   await createLogStream('my-log-file.log');
+ *
+ * // SCENARIO 1:
+ * // you can write custom messages to generate a log file
+ * logStream.write('my log message');
+ * await moveLogFile();
+ *
+ * // SCENARIO 2:
+ * // or you can pass it to stdio and capture the output of that command
+ * try {
+ *   await executeCommand({
+ *     command: 'pnpm',
+ *     args: ['info', packageName, ...args],
+ *     // do not output to the user, and send stdio and stderr to log file
+ *     stdio: ['ignore', logStream, logStream],
+ *   });
+ * } catch (err) {
+ *   // do something with the log file content
+ *   const output = await readLogFile();
+ *   // move the log file to the users project
+ *   await moveLogFile();
+ * }
+ * // success, no need to keep the log file
+ * await removeLogFile();
+ * ```
+ */
+declare const createLogStream: (logFileName?: string) => Promise<{
+  moveLogFile: () => Promise<void>;
+  removeLogFile: () => Promise<void>;
+  clearLogFile: () => Promise<void>;
+  readLogFile: () => Promise<string>;
+  logStream: WriteStream;
+}>;
+/** The package itself, or a framework, renderer or addon that ships inside it (`@aussieljk/forkbook/<area>`). */
+declare const isCorePackage: (pkg: string) => boolean;
+declare const isSatelliteAddon: (pkg: string) => boolean;
+//#endregion
+//#region .dts-emit/code/core/src/common/utils/check-addon-order.d.ts
+interface Options$1 {
+  before: CoreCommon_AddonInfo;
+  after: CoreCommon_AddonInfo;
+  configFile: string;
+  getConfig: (path: string) => any;
+}
+declare const checkAddonOrder: ({
+  before,
+  after,
+  configFile,
+  getConfig
+}: Options$1) => Promise<void>;
+//#endregion
+//#region .dts-emit/code/core/src/common/utils/envs.d.ts
+declare function loadEnvs(options?: {
+  production?: boolean;
+}): Promise<{
+  stringified: Record<string, string>;
+  raw: Record<string, string>;
+}>;
+declare const stringifyEnvs: (raw: Record<string, string>) => Record<string, string>;
+declare const stringifyProcessEnvs: (raw: Record<string, string>) => Record<string, string>;
+declare const optionalEnvToBoolean: (input: string | undefined) => boolean | undefined;
+/**
+ * Consistently determine if we are in a CI environment
+ *
+ * Doing Boolean(process.env.CI) or !process.env.CI is not enough, because users might set CI=false
+ * or CI=0, which would be truthy, and thus return true in those cases.
+ */
+declare function isCI(): boolean | undefined;
+//#endregion
+//#region .dts-emit/code/core/src/common/utils/find-storybook-package-root.d.ts
+/**
+ * Find the root directory of the `storybook` package this module runs from, as a realpathed
+ * normalized path.
+ *
+ * Walks up from this module's own directory to the first `package.json` whose `name` is
+ * `storybook`; manifests with other names, such as ESM/CJS type markers in dist subfolders, are
+ * skipped. Returns `undefined` when no such manifest exists.
+ */
+declare function findStorybookPackageRoot(): string | undefined;
+//#endregion
+//#region .dts-emit/code/core/src/common/utils/common-glob-options.d.ts
+declare const commonGlobOptions: (glob: string) => {
+  ignore?: undefined;
+} | {
+  ignore: string[];
+};
+//#endregion
+//#region .dts-emit/code/core/src/common/utils/deep-merge.d.ts
+type MergeableObject = Record<string, unknown>;
+/**
+ * Recursively merges plain objects from `source` into `target`. Nested plain objects are merged
+ * key by key; arrays and primitive values in `source` replace the target's values instead of being
+ * concatenated; `null` and `undefined` values in `source` are skipped, keeping the target's value.
+ */
+declare function deepMerge<T extends MergeableObject>(target: T, source: MergeableObject): T;
+//#endregion
+//#region .dts-emit/code/core/src/common/utils/default-config-dir.d.ts
+/**
+ * The config folder of a project when no `--config-dir` is given: `.forkbook`, or `.storybook`
+ * when the project has only that one (a project that moved from Storybook).
+ */
+declare function defaultConfigDir(cwd?: string): string;
+//#endregion
+//#region .dts-emit/code/core/src/common/utils/framework.d.ts
+declare const frameworkToRenderer: Record<SupportedFramework | SupportedRenderer, SupportedRenderer>;
+declare const frameworkToBuilder: Record<SupportedFramework, SupportedBuilder>;
+//#endregion
+//#region .dts-emit/code/core/src/common/utils/get-builder-options.d.ts
+/**
+ * Builder options can be specified in `core.builder.options` or `framework.options.builder`.
+ * Preference is given here to `framework.options.builder` if both are specified.
+ */
+declare function getBuilderOptions<T extends Record<string, any>>(options: Options): Promise<T | Record<string, never>>;
+//#endregion
+//#region .dts-emit/code/core/src/common/utils/get-pkg-pr-new-package-specifier.d.ts
+declare const isPkgPrNewVersionSpecifier: (storybookVersionSpecifier?: string) => boolean;
+declare const getPkgPrNewPackageSpecifier: (packageName: string, storybookVersionSpecifier?: string) => string | undefined;
+//#endregion
+//#region .dts-emit/code/core/src/common/utils/get-storybook-version-specifier-from-ancestry.d.ts
+type ProcessAncestryEntry = {
+  command?: string | null;
+};
+/**
+ * Read a Forkbook version specifier from process ancestry.
+ *
+ * Prefers a pkg.pr.new CLI URL in the command so `npx --yes https://pkg.pr.new/.../storybook@sha`
+ * and `npx storybook@https://pkg.pr.new/...` resolve to the same source. Falls back to
+ * `create-storybook@<spec>` / `storybook@<spec>` for npm tags and semver.
+ */
+declare const getStorybookVersionSpecifierFromAncestry: (ancestry: readonly ProcessAncestryEntry[]) => string | undefined;
+//#endregion
+//#region .dts-emit/code/core/src/common/utils/resolve-storybook-version-specifier.d.ts
+/** Set by the `storybook` dispatcher before it respawns `@aussieljk/forkbook/internal/cli-commands` or `@aussieljk/forkbook/internal/create`. */
+declare const FORKBOOK_VERSION_SPECIFIER_ENV = "FORKBOOK_VERSION_SPECIFIER";
+declare const resolveStorybookVersionSpecifier: (ancestry?: readonly ProcessAncestryEntry[], env?: NodeJS.ProcessEnv) => string | undefined;
+//#endregion
+//#region .dts-emit/code/core/src/common/utils/get-framework-name.d.ts
+/** Framework can be a string or an object. This utility always returns the string name. */
+declare function getFrameworkName(options: Options): Promise<string>;
+type FrameworkField = string | {
+  name: string;
+  options?: any;
+} | undefined;
+/** The `framework` field of a main config, with a Storybook name changed to its Forkbook name. */
+declare function forkbookFramework<T extends FrameworkField>(framework: T): T;
+/** A main config (or preset) with a Storybook framework name changed to its Forkbook name. */
+declare function withForkbookFramework<T extends {
+  framework?: FrameworkField;
+}>(config: T): T;
+/**
+ * Extracts the proper framework name from the given framework field. The framework field can be the
+ * framework package name or a path to the framework package.
+ *
+ * @example
+ *
+ * ```ts
+ * extractFrameworkPackageName('/path/to/@storybook/react-vite'); // => '@aussieljk/forkbook/react-vite'
+ * extractFrameworkPackageName('@third-party/framework'); // => '@third-party/framework'
+ * ```
+ */
+declare const extractFrameworkPackageName: (framework: string) => string;
+//#endregion
+//#region .dts-emit/code/core/src/common/utils/get-renderer-name.d.ts
+/**
+ * Render is set as a string on core. It must be set by the framework It falls back to the framework
+ * name if not set
+ */
+declare function getRendererName(options: Options): Promise<string>;
+/**
+ * Extracts the proper renderer name from the given framework name.
+ *
+ * @example
+ *
+ * ```ts
+ * extractRenderer('@aussieljk/forkbook/react'); // => 'react'
+ * extractRenderer('@third-party/framework'); // => null
+ * ```
+ *
+ * @param frameworkName The name of the framework.
+ * @returns The name of the renderer.
+ */
+declare function extractRenderer(frameworkName: string): Promise<import("@aussieljk/forkbook/internal/types").SupportedRenderer | null>;
+//#endregion
+//#region .dts-emit/code/core/src/common/utils/get-storybook-configuration.d.ts
+declare function getStorybookConfiguration(storybookScript: string, shortName: string, longName: string): string | null;
+//#endregion
+//#region .dts-emit/code/core/src/common/utils/get-storybook-info.d.ts
+declare const rendererPackages: Record<string, SupportedRenderer>;
+declare const frameworkPackages: Record<string, SupportedFramework>;
+declare const builderPackages: Record<string, SupportedBuilder>;
+declare const findConfigFile: (prefix: string, configDir: string) => string | null;
+declare const getConfigInfo: (configDir?: string) => {
+  configDir: string;
+  mainConfigPath: string | null;
+  previewConfigPath: string | null;
+  managerConfigPath: string | null;
+};
+declare const getStorybookInfo: (configDir?: string, cwd?: string, {
+  skipCache
+}?: {
+  skipCache?: boolean;
+}) => Promise<CoreCommon_StorybookInfo>;
+//#endregion
+//#region .dts-emit/code/core/src/common/utils/get-storybook-refs.d.ts
+declare const getAutoRefs: (options: Options) => Promise<Record<string, Ref>>;
+declare const checkRef: (url: string) => Promise<boolean>;
+declare const toTitle: (input: string) => string;
+declare function getRefs(options: Options): Promise<Record<string, Ref>>;
+//#endregion
+//#region .dts-emit/code/core/src/common/utils/glob-to-regexp.d.ts
+declare function globToRegexp(glob: string): RegExp;
+//#endregion
+//#region .dts-emit/code/core/src/common/utils/HandledError.d.ts
+declare class HandledError extends Error {
+  handled: boolean;
+  constructor(error: unknown);
+}
+//#endregion
+//#region .dts-emit/code/core/src/common/utils/interpolate.d.ts
+/**
+ * Return a string corresponding to template filled with bindings using following pattern: For each
+ * (key, value) of `bindings` replace, in template, `{{key}}` by escaped version of `value`
+ *
+ * @param template {String} Template with `{{binding}}`
+ * @param bindings {Object} key-value object use to fill the template, `{{key}}` will be replaced by
+ *   `escaped(value)`
+ * @returns {String} Filled template
+ */
+declare const interpolate: (template: string, bindings: Record<string, string>) => string;
+//#endregion
+//#region .dts-emit/code/core/src/common/utils/interpret-files.d.ts
+declare const supportedExtensions: readonly [".js", ".ts", ".jsx", ".tsx", ".mjs", ".mts", ".mtsx", ".cjs", ".cts", ".ctsx"];
+declare function getInterpretedFile(pathToFile: string): string | undefined;
+interface ResolveImportOptions {
+  basedir: string;
+}
+declare function resolveImport(id: string, options: ResolveImportOptions): string;
+//#endregion
+//#region .dts-emit/code/core/src/common/utils/load-main-config.d.ts
+declare function loadMainConfig({
+  configDir,
+  cwd,
+  skipCache
+}: {
+  configDir: string;
+  cwd?: string;
+  skipCache?: boolean;
+}): Promise<StorybookConfig>;
+//#endregion
+//#region .dts-emit/code/core/src/common/utils/load-manager-or-addons-file.d.ts
+declare function loadManagerOrAddonsFile({
+  configDir
+}: {
+  configDir: string;
+}): string | undefined;
+//#endregion
+//#region .dts-emit/code/core/src/common/utils/load-preview-or-config-file.d.ts
+declare function loadPreviewOrConfigFile({
+  configDir
+}: {
+  configDir: string;
+}): string | undefined;
+//#endregion
+//#region .dts-emit/code/core/src/common/utils/log-config.d.ts
+declare function logConfig(caption: unknown, config: unknown): void;
+//#endregion
+//#region .dts-emit/code/core/src/common/utils/module-resolver.d.ts
+/**
+ * Module resolution options, declared locally so consumers don't depend on the underlying resolver
+ * package.
+ */
+interface ModuleResolverOptions {
+  extensions?: string[];
+  mainFields?: string[];
+  conditionNames?: string[];
+  /** Honor `paths`/`baseUrl` from a tsconfig. `'auto'` walks up from the resolution origin. */
+  tsconfig?: 'auto' | {
+    configFile: string;
+  };
+}
+interface ModuleResolver {
+  /** Resolves `specifier` as if imported from `fromFile`. Throws when unresolvable. */
+  resolveFileSync(fromFile: string, specifier: string): string;
+  /** Resolves `specifier` as if imported from a file in `fromDirectory`. Throws when unresolvable. */
+  resolveSync(fromDirectory: string, specifier: string): string;
+}
+/**
+ * Resolve the same files the preview bundles: the browser build's resolve conditions, trimmed to
+ * what oxc-resolver understands.
+ *
+ * oxc-resolver defaults to no conditions at all, which would make exports maps without an
+ * unconditional entry unresolvable.
+ */
+declare const defaultResolveConditionNames: string[];
+declare function createModuleResolver(options?: ModuleResolverOptions): ModuleResolver;
+//#endregion
+//#region .dts-emit/code/core/src/common/utils/normalize-stories.d.ts
+declare const DEFAULT_FILES_PATTERN = "**/*.@(mdx|stories.@(js|jsx|mjs|ts|tsx))";
+declare const getDirectoryFromWorkingDir: ({
+  configDir,
+  workingDir,
+  directory
+}: NormalizeOptions & {
+  directory: string;
+}) => string;
+declare const normalizeStoriesEntry: (entry: StoriesEntry, {
+  configDir,
+  workingDir,
+  defaultFilesPattern
+}: NormalizeOptions) => NormalizedStoriesSpecifier;
+interface NormalizeOptions {
+  configDir: string;
+  workingDir: string;
+  defaultFilesPattern?: string;
+}
+declare const normalizeStories: (entries: StoriesEntry[], options: NormalizeOptions) => NormalizedStoriesSpecifier[];
+//#endregion
+//#region .dts-emit/code/core/src/common/utils/paths.d.ts
+declare const getProjectRoot: () => string;
+declare const invalidateProjectRootCache: () => void;
+/** Finds files in the directory tree up to the project root */
+declare const findFilesUp: (matchers: string[], baseDir?: string) => string[];
+declare const nodePathsToArray: (nodePath: string) => string[];
+/** Ensures that a path starts with `./` or `../`, or is entirely `.` or `..` */
+declare function normalizeStoryPath(filename: string): string;
+//#endregion
+//#region .dts-emit/code/core/src/common/utils/read-dependency-manifest.d.ts
+/**
+ * Reads a dependency's own `package.json`, resolved relative to `directory`.
+ *
+ * `<dep>/package.json` cannot reliably be resolved as a subpath: subpath
+ * resolution runs through the package's `exports` field, and a `"./*"` wildcard
+ * (e.g. refractor's `"./*": "./lang/*.js"`) remaps `package.json` to a file
+ * that does not exist.
+ *
+ * Strategy:
+ *
+ * 1. Try the subpath anyway — correct for packages with no `exports` field, or
+ *    that explicitly expose `"./package.json"`.
+ * 2. On failure, resolve the package's main entry (the `"."` export, which a
+ *    `"./*"` wildcard never affects) and walk up to the package root.
+ *
+ * `empathic/resolve` wraps Node's `createRequire().resolve()`, so both passes
+ * stay correct under hoisted monorepos.
+ *
+ * @param directory Directory to resolve `dependency` from (Node module resolution).
+ * @param dependency Bare package name, e.g. `react` or `@scope/pkg`.
+ * @returns The parsed `package.json`, or `undefined` if it cannot be resolved.
+ *   Never throws.
+ */
+declare const readDependencyManifest: (directory: string, dependency: string) => Promise<PackageJson$1 | undefined>;
+//#endregion
+//#region .dts-emit/code/core/src/common/utils/readTemplate.d.ts
+declare function readTemplate(filename: string): Promise<string>;
+//#endregion
+//#region .dts-emit/code/core/src/common/utils/resolve-meta-component.d.ts
+/** The component a story file documents, as far as static analysis can determine. */
+interface ResolvedMetaComponent {
+  /** Local identifier the component is bound to, in the module that names it. */
+  localName: string;
+  /** Specifier the component is imported from, or `undefined` when it is declared in the file. */
+  importId?: string;
+  /** Declaring module, or the naming module itself; `undefined` when the import does not resolve. */
+  path?: string;
+  /** Export name in the declaring module, so an import alias resolves to the real export. */
+  exportName: string;
+}
+type MetaComponentResolution = {
+  component: ResolvedMetaComponent;
+} | {
+  reason: 'no-meta-component' | 'no-component-import';
+} | {
+  reason: 'unreadable-component-expression'; /** Source text of the expression, so a caller can name what it could not follow. */
+  expression: string;
+};
+interface MetaComponentResolverOptions {
+  /** Extensions tried ahead of the JS/TS set, for single-file-component formats like `.vue`. */
+  extensions?: string[];
+}
+/**
+ * Builds a resolver that locates the component behind `meta.component` in a parsed CSF file.
+ *
+ * Server-side docgen never loads the story module, so the exported name and declaring file have to
+ * be recovered from source; the resolver caches, so create one per host rather than per call.
+ */
+declare function createMetaComponentResolver(options?: MetaComponentResolverOptions): (csf: CsfFile, storyPath: string) => MetaComponentResolution;
+//#endregion
+//#region .dts-emit/code/core/src/common/utils/subcomponents.d.ts
+type DeclaredSubcomponent = {
+  componentName: string;
+  name: string;
+};
+declare function extractDeclaredSubcomponents(csf: CsfFile): DeclaredSubcomponent[];
+//#endregion
+//#region .dts-emit/code/core/src/common/js-package-manager/JsPackageManagerFactory.d.ts
+declare class JsPackageManagerFactory {
+  /** Cache for package manager instances */
+  private static cache;
+  /** Generate a cache key based on the parameters */
+  private static getCacheKey;
+  /** Clear the package manager cache */
+  static clearCache(): void;
+  /**
+   * Determine which package manager type to use based on lockfiles, commands, and environment
+   *
+   * @param cwd - Current working directory
+   * @returns Package manager type as string: 'npm', 'pnpm', 'bun', 'yarn1', or 'yarn2'
+   * @throws Error if no usable package manager is found
+   */
+  static getPackageManagerType(cwd?: string): PackageManagerName;
+  static getPackageManager({
+    force,
+    configDir,
+    storiesPaths,
+    ignoreCache
+  }?: {
+    force?: PackageManagerName;
+    configDir?: string;
+    storiesPaths?: string[];
+    ignoreCache?: boolean;
+  }, cwd?: string): JsPackageManager;
+  /** Look up map of package manager proxies by name */
+  private static PROXY_MAP;
+  /**
+   * Infer the package manager based on the command the user is running. Each package manager sets
+   * the `npm_config_user_agent` environment variable with its name and version e.g. "npm/7.24.0"
+   * Which is really useful when invoking commands via npx/pnpx/yarn create/etc.
+   */
+  private static inferPackageManagerFromUserAgent;
+}
+//#endregion
+//#region .dts-emit/code/core/src/common/js-package-manager/util.d.ts
+declare const FORKBOOK_PACKAGE_PATTERNS: readonly ['@aussieljk/forkbook', '@storybook/*', 'eslint-plugin-storybook'];
+declare const hasStorybookMinimumAgeExclusions: (configuredPatterns: string[]) => boolean;
+declare const parsePackageData: (packageName?: string) => {
+  name: string;
+  value: {
+    version: string;
+    location: string;
+  };
+};
+declare const parsePositiveIntegerConfigValue: (value: string | null | undefined) => number | null;
+declare const parseReleaseTime: (value: unknown) => Date | null;
+declare const parsePackageTimeMap: (value: unknown) => Record<string, string> | null;
+declare const getAgeInMinutes: (publishedAt: Date, now?: Date) => number;
+declare const getLatestStableVersionAdheringToMinimumAgeGate: (timeMap: Record<string, string>, minimumAgeGateMinutes: number, now?: Date) => string | null;
+declare function getVitestStorybookRunCommand(packageManager: JsPackageManager, file?: string): string;
+declare function getMswInitCommand(packageManager: JsPackageManager): string;
+declare const FORKBOOK_RERUN_INSTRUCTION = "Please rerun Forkbook creation with:";
+declare const getStorybookRerunCommand: (compatibleVersion: string | null) => string;
+declare const getErrorLogs: (error: unknown) => string;
+/** Number of trailing output lines surfaced when a package install fails. */
+declare const INSTALL_ERROR_TAIL_LINES = 15;
+/**
+ * The tail of a failed package install's captured output (see `getErrorLogs`). Output longer than
+ * `lines` lines is truncated to the last `lines` — package managers print their own error summary
+ * (e.g. an npm ERESOLVE explanation) at the end. Returns '' only when there is no captured output
+ * at all; short outputs are returned in full so they are still logged and folded into the error.
+ */
+declare const getInstallErrorTail: (error: unknown, lines?: number) => string;
+//#endregion
+//#region .dts-emit/code/core/src/common/js-package-manager/vite-plus-versions.d.ts
+/**
+ * Attempts to load vendored package versions from `vite-plus/versions`.
+ *
+ * When a project uses vite-plus (typically via `"vite": "npm:vite-plus@..."`), vitest and vite are
+ * vendored rather than installed as separate packages. This function retrieves their actual versions
+ * from the `vite-plus/versions` subpath export.
+ *
+ * Returns null when vite-plus is not installed or lacks the `/versions` export (older versions).
+ */
+declare function getVitePlusVersions(): Promise<Record<string, string> | null>;
+declare function clearVitePlusCache(): void;
+//#endregion
+//#region .dts-emit/code/core/src/common/js-package-manager/warnOnYarn1.d.ts
+/**
+ * Warns (once per process) when a project uses Yarn 1 (Classic), which Forkbook only supports on
+ * a best-effort basis. Never throws and never blocks the calling flow.
+ */
+declare function warnOnYarn1(packageManagerType: PackageManagerName): void;
+//#endregion
+//#region .dts-emit/code/core/src/common/utils/remove.d.ts
+type RemoveAddonOptions = {
+  packageManager: JsPackageManager;
+  configDir?: string;
+  skipInstall?: boolean;
+};
+/**
+ * Remove the given addon package and remove it from main.js
+ *
+ * @example
+ *
+ * ```sh
+ * sb remove @aussieljk/forkbook/addon-links
+ * ```
+ */
+declare function removeAddon(addon: string, options: RemoveAddonOptions): Promise<void>;
+//#endregion
+//#region .dts-emit/code/core/src/common/utils/resolve-path-in-sb-cache.d.ts
+/**
+ * Get the path of the file or directory with input name inside the Forkbook cache directory:
+ *
+ * - `node_modules/.cache/storybook/{version}/{directoryName}` in a Node.js project or npm package
+ * - `.cache/storybook/{version}/{directoryName}` otherwise
+ *
+ * The cache directory includes the Forkbook version to ensure that upgrading Forkbook
+ * automatically invalidates the cache, preventing stale cache issues.
+ *
+ * @param fileOrDirectoryName {string} Name of the file or directory
+ * @param sub {string} Optional subdirectory name (defaults to 'default')
+ * @returns {string} Absolute path to the file or directory
+ */
+declare function resolvePathInStorybookCache(fileOrDirectoryName: string, sub?: string): string;
+//#endregion
+//#region .dts-emit/code/core/src/common/utils/symlinks.d.ts
+declare function isPreservingSymlinks(): boolean | undefined;
+//#endregion
+//#region .dts-emit/code/core/src/common/utils/template.d.ts
+declare function getPreviewBodyTemplate(configDirPath: string, interpolations?: Record<string, string>): string;
+declare function getPreviewHeadTemplate(configDirPath: string, interpolations?: Record<string, string>): string;
+//#endregion
+//#region .dts-emit/code/core/src/common/utils/tsconfig.d.ts
+declare const findTsconfigPath: (cwd: string) => string | undefined;
+/**
+ * Pick the tsconfig that actually applies to a given file, following project references when the
+ * nearest root config is just a references shell (for example Vite's `files: []` root tsconfig).
+ *
+ * Prefer the config that really owns the file instead of stopping at the first config filename we
+ * discover. Ownership also resolves `extends` so inherited `include` / `exclude` / `files` participate
+ * (patterns from a base config stay relative to that base, matching `tsc`).
+ */
+declare const findTsconfigPathForFile: (cwd: string, filePath: string) => string | undefined;
+/**
+ * Resolve a tsconfig for either a source file or a directory.
+ * Prefer file paths when available; directories must not be passed through
+ * `findTsconfigPathForFile` (that would `dirname` them and search from the parent).
+ */
+declare const findTsconfigPathForPath: (path: string) => string | undefined;
+declare const getTsconfigPathsBaseDir: (configPath: string) => string;
+//#endregion
+//#region .dts-emit/code/core/src/common/utils/validate-config.d.ts
+declare function validateFrameworkName(frameworkName: string | undefined): asserts frameworkName is string;
+//#endregion
+//#region .dts-emit/code/core/src/common/utils/validate-configuration-files.d.ts
+declare function validateConfigurationFiles(configDir: string, cwd?: string): Promise<void>;
+//#endregion
+//#region .dts-emit/code/core/src/common/utils/babel.d.ts
+/**
+ * Reads the major version of the `@babel/preset-env` that is actually installed in the consumer's
+ * project, at runtime.
+ *
+ * We can't rely on `@babel/core`'s exported `version`: it is a different package whose version can
+ * diverge from `@babel/preset-env`, and it gets resolved when Forkbook is bundled rather than from
+ * the user's project. We instead resolve and read preset-env's own `package.json`. This must stay
+ * synchronous because some call sites (e.g. the Next.js babel preset factory and the swc loader
+ * transform) are synchronous.
+ *
+ * This is primarily used to gate the `bugfixes` option, which is valid in preset-env v7 but was
+ * removed in v8 (where it throws when set, as the bugfix plugins are always enabled).
+ *
+ * @returns The major version (e.g. `7` or `8`), or `0` when preset-env cannot be resolved.
+ */
+declare const getBabelPresetEnvMajor: () => number | undefined;
+//#endregion
+//#region .dts-emit/code/core/src/common/utils/formatter.d.ts
+/** Format code with oxfmt. If oxfmt cannot format it, the code is returned as is. */
+declare function formatCode(filePath: string, content: string, options?: FormatConfig): Promise<string>;
+/**
+ * Format a file of the project with oxfmt and the nearest oxfmt config. Without a config, the
+ * content is returned as is, because the defaults would change the style of the whole file.
+ */
+declare function formatFileContent(filePath: string, content: string): Promise<string>;
+//#endregion
+//#region .dts-emit/code/core/src/common/utils/get-story-id.d.ts
+interface StoryIdData {
+  storyFilePath: string;
+  exportedStoryName: string;
+}
+type GetStoryIdOptions = StoryIdData & {
+  configDir: string;
+  stories: StoriesEntry[];
+  workingDir?: string;
+  userTitle?: string;
+  storyFilePath: string;
+};
+declare function getStoryId(data: StoryIdData, options: Options): Promise<{
+  storyId: string;
+  kind: string;
+}>;
+declare function getStoryTitle({
+  storyFilePath,
+  configDir,
+  stories,
+  workingDir,
+  userTitle
+}: Omit<GetStoryIdOptions, 'exportedStoryName'>): string | undefined;
+//#endregion
+//#region .dts-emit/code/core/src/common/utils/component-id.d.ts
+/**
+ * Derives the componentId portion of a story index entry id.
+ *
+ * Forkbook story ids have the shape `<componentId>--<storyName>`; the prefix before the first
+ * `--` is the stable component identifier shared by every story (and attached docs entry) that
+ * targets the same component. Centralising the split keeps the docgen service, manifest generator,
+ * and any future consumers on one definition.
+ */
+declare function getComponentIdFromEntry(entry: Pick<IndexEntry, 'id'>): string;
+//#endregion
+//#region .dts-emit/code/core/src/common/utils/select-component-entry.d.ts
+/**
+ * Filename test for CSF story files (e.g. `Button.stories.tsx`, `stories.ts`). Single source of
+ * truth shared by the CSF indexer and the React docgen provider so both agree on which files count
+ * as story files. Has no `g` flag, so the shared instance is safe to reuse across `.test()` calls.
+ */
+declare const STORY_FILE_TEST_REGEXP: RegExp;
+/** Whether an index entry is a story of a component, as opposed to a test or a docs entry. */
+declare function isEligibleStoryEntry(entry: IndexEntry$1): boolean;
+/**
+ * CSF story file path used for component resolution — the story entry's `importPath`, or the first
+ * `storiesImports` entry for attached MDX docs (same rule as the React component manifest generator).
+ */
+declare function getStoryImportPathFromEntry(entry: IndexEntry$1): string | undefined;
+/**
+ * Picks one index entry per componentId: story entries win; attached docs fill gaps only where no
+ * story exists for that componentId.
+ *
+ * Several story files can collapse onto one componentId by sharing a title. The selection cannot
+ * represent that, so it warns (deduplicated per distinct collision) that the component's own docs
+ * cover only the winning file.
+ */
+declare function selectComponentEntriesByComponentId(indexEntries: IndexEntry$1[]): Map<string, IndexEntry$1>;
+//#endregion
+//#region .dts-emit/code/core/src/common/utils/lazy-docgen-middleware.d.ts
+interface LazyDocgenMiddlewareOptions<TManager> {
+  /**
+   * Story file paths this middleware extracts from; any other path passes through.
+   * Defaults to CSF story files, so a renderer with its own story format (e.g. `.stories.svelte`)
+   * must widen it.
+   */
+  storyFileTest?: RegExp;
+  /**
+   * Builds the renderer's extraction manager.
+   * Called once, lazily, on the first eligible request and memoized for the worker's lifetime.
+   * Return `undefined` to permanently pass through to the rest of the chain.
+   */
+  createManager: () => Promise<TManager | undefined>;
+  /**
+   * Extracts one payload
+   * Returns `undefined` to delegate the request downstream
+   */
+  extract: (manager: TManager, input: DocgenProviderInput) => Promise<DocgenPayload$1 | undefined>;
+}
+declare function createLazyDocgenMiddleware<TManager>({
+  storyFileTest,
+  createManager,
+  extract
+}: LazyDocgenMiddlewareOptions<TManager>): DocgenMiddleware;
+//#endregion
+//#region .dts-emit/code/core/src/common/utils/posix.d.ts
+/** Replaces the path separator with forward slashes */
+declare const posix: (localPath: string, seperator?: string) => string;
+//#endregion
+//#region .dts-emit/code/core/src/common/utils/sync-main-preview-addons.d.ts
+declare function syncStorybookAddons(mainConfig: StorybookConfig, previewConfigPath: string, configDir: string): Promise<void>;
+declare function syncPreviewAddonsWithMainConfig(mainConfig: StorybookConfig, previewConfig: ConfigFile, configDir: string): Promise<ConfigFile>;
+//#endregion
+//#region .dts-emit/code/core/src/common/utils/setup-addon-in-config.d.ts
+interface SetupAddonInConfigOptions {
+  addonName: string;
+  mainConfigCSFFile: ConfigFile;
+  previewConfigPath: string | undefined;
+  configDir: string;
+}
+/**
+ * Setup an addon in the Forkbook configuration by adding it to the addons array in main config and
+ * syncing it with preview config.
+ *
+ * @param options Configuration options for setting up the addon
+ */
+declare function setupAddonInConfig({
+  addonName,
+  previewConfigPath,
+  configDir,
+  mainConfigCSFFile
+}: SetupAddonInConfigOptions): Promise<void>;
+//#endregion
+//#region .dts-emit/code/core/src/common/utils/wrap-getAbsolutePath-utils.d.ts
+/**
+ * Checks if the following node declarations exists in the main config file.
+ *
+ * @example
+ *
+ * ```ts
+ * const <name> = () => {};
+ * function <name>() {}
+ * ```
+ */
+declare function doesVariableOrFunctionDeclarationExist(node: types.Node, name: string): boolean;
+/**
+ * Returns the name of the getAbsolutePath wrapper function if it exists in the main config file.
+ *
+ * @returns Name of the getAbsolutePath wrapper function (e.g. `getAbsolutePath`).
+ */
+declare function getAbsolutePathWrapperName(config: ConfigFile): string | null;
+/** Check if the node needs to be wrapped with getAbsolutePath wrapper. */
+declare function isGetAbsolutePathWrapperNecessary(node: types.Node, cb?: (node: types.StringLiteral | types.ObjectProperty | types.ArrayExpression) => void): boolean;
+/**
+ * Get all fields that need to be wrapped with getAbsolutePath wrapper.
+ *
+ * @returns Array of fields that need to be wrapped with getAbsolutePath wrapper.
+ */
+declare function getFieldsForGetAbsolutePathWrapper(config: ConfigFile): types.Node[];
+/**
+ * Returns AST for the following function
+ *
+ * @example
+ *
+ * ```ts
+ * function getAbsolutePath(value) {
+ *   return dirname(fileURLToPath(import.meta.resolve(`${value}/package.json`)));
+ * }
+ * ```
+ */
+declare function getAbsolutePathWrapperAsCallExpression(isConfigTypescript: boolean, names?: {
+  dirname: string;
+  fileURLToPath: string;
+}): types.FunctionDeclaration;
+declare function wrapValueWithGetAbsolutePathWrapper(config: ConfigFile, node: types.Node): void;
+/**
+ * Import the named export `imported` from `source` into a main config, and return the local name to
+ * call it by. Reuses an existing import, and renames the import when the config already declares a
+ * binding with that name, such as its own `const dirname`.
+ */
+declare function ensureNamedImport(config: ConfigFile, imported: string, source: string): string;
+//#endregion
+//#region .dts-emit/code/core/src/common/utils/scan-and-transform-files.d.ts
+/**
+ * Helper function to scan for files matching a glob pattern and transform them
+ *
+ * @param options Configuration options
+ * @param transform Function to transform the found files
+ * @returns Array of errors encountered during transformation
+ */
+declare function scanAndTransformFiles<T extends Record<string, unknown>>({
+  promptMessage,
+  defaultGlob,
+  dryRun,
+  force,
+  transformFn,
+  transformOptions
+}: {
+  promptMessage?: string;
+  defaultGlob?: string;
+  dryRun: boolean;
+  force?: boolean;
+  transformFn: (files: string[], options: T, dryRun: boolean) => Promise<Array<{
+    file: string;
+    error: Error;
+  }>>;
+  transformOptions: T;
+}): Promise<Array<{
+  file: string;
+  error: Error;
+}>>;
+//#endregion
+//#region .dts-emit/code/core/src/common/utils/transform-imports.d.ts
+/**
+ * Rename imported and required packages, including their sub-paths. Returns `null` when no package
+ * matched.
+ */
+declare function transformImports(source: string, renamedImports: Record<string, string>): string | null;
+//#endregion
+//#region .dts-emit/code/core/src/shared/utils/module.d.ts
+/**
+ * This is just an alias for import.meta.resolve. It makes it possible to mock it in Vitest with
+ * module-mocking, as Vitest currently does not support import.meta.resolve in tests.
+ *
+ * @see https://github.com/vitest-dev/vitest/issues/6953
+ */
+declare const importMetaResolve: (...args: Parameters<ImportMeta['resolve']>) => string;
+/** Resolves the directory of a given package, by resolving its package.json file. */
+declare const resolvePackageDir: (pkg: Parameters<ImportMeta['resolve']>[0], parent?: Parameters<ImportMeta['resolve']>[0]) => string;
+/**
+ * Dynamically imports a module with TypeScript support, falling back to require if necessary.
+ *
+ * @example Import a TypeScript preset
+ *
+ * ```ts
+ * const preset = await importModule('./my-preset.ts');
+ * // Returns the default export or the entire module
+ * ```
+ *
+ * @example Import a JavaScript addon
+ *
+ * ```ts
+ * const addon = await importModule('@storybook/addon-essentials');
+ * // Returns the default export or the entire module
+ * ```
+ */
+declare function importModule(path: string, {
+  skipCache
+}?: {
+  skipCache?: boolean;
+}): Promise<any>;
+/**
+ * Safely resolves a module specifier to its absolute file path.
+ *
+ * Attempts to resolve the given module specifier by trying different file extensions until a valid
+ * file is found. Returns undefined if the module cannot be resolved.
+ *
+ * Optionally pass in a list of file extensions to try, defaulting to `.mjs`, `.js`, and `.cjs`.
+ *
+ * @example
+ *
+ * ```typescript
+ * // Resolve a relative module
+ * const path = safeResolveModule({
+ *   specifier: './utils',
+ *   parent: import.meta.url,
+ * });
+ *
+ * // Resolve with custom extensions
+ * const path = safeResolveModule({
+ *   specifier: './config',
+ *   extensions: ['.json', '.js'],
+ * });
+ * ```
+ */
+declare const safeResolveModule: ({
+  specifier,
+  parent,
+  extensions
+}: {
+  specifier: string;
+  parent?: string;
+  extensions?: string[];
+}) => string | undefined;
+//#endregion
+//#region .dts-emit/code/core/src/shared/utils/paths.d.ts
+/**
+ * Replaces Windows path separators with forward slashes, so paths compare and key consistently
+ * across platforms.
+ */
+declare function slash(path: string): string;
+/** Whether the path traverses a `node_modules` directory, on either path separator. */
+declare function isInNodeModules(path: string): boolean;
+//#endregion
+//#region .dts-emit/code/core/src/common/utils/get-addon-names.d.ts
+type AddonEntry = NonNullable<StorybookConfig['addons']>[number];
+/**
+ * Resolve an addon config entry (string, object, or absolute path) to its bare package name.
+ * Returns `undefined` for relative-path local addons.
+ */
+declare const normalizeAddonName: (addon: AddonEntry) => string | undefined;
+declare const getAddonNames: (mainConfig: StorybookConfig) => string[];
+//#endregion
+//#region .dts-emit/code/core/src/common/utils/utils.d.ts
+declare const groupBy: <K extends PropertyKey, T>(items: T[], keySelector: (item: T, index: number) => K) => Record<K, T[]>;
+declare function invariant(condition: unknown, message?: string | (() => string)): asserts condition;
+//#endregion
+//#region .dts-emit/code/core/src/common/utils/file-lock.d.ts
+interface FileLockOptions {
+  /** How long to wait for the current holder before giving up. */
+  waitBudgetMs?: number;
+  /** How long a lock may go without a heartbeat before it is treated as abandoned. */
+  staleAfterMs?: number;
+}
+/**
+ * Runs `run` under the lock at `lockPath`, at most once across every process that shares it.
+ *
+ * Returns `'busy'` when someone else held the lock for longer than the wait budget allowed, which
+ * callers are expected to carry on from rather than treat as a failure. `run` decides for itself
+ * whether there is still anything to do, since the winner may already have done it.
+ */
+declare const withFileLock: (lockPath: string, run: () => Promise<void>, {
+  waitBudgetMs,
+  staleAfterMs
+}?: FileLockOptions) => Promise<'ran' | 'busy'>;
+//#endregion
+//#region .dts-emit/code/core/src/common/utils/process-ancestry.d.ts
+interface ProcessInfo {
+  /** Process ID */
+  pid: number;
+  /** Parent Process ID */
+  ppid: number;
+  /** Command line or executable name */
+  command?: string;
+}
+/**
+ * Returns the ancestry of the given process (defaults to the current process),
+ * walking parent by parent until the process tree ends. On Windows, PID 0
+ * (System Idle Process) and PID 4 (System) terminate the walk; on other
+ * platforms, PID 0 and PID 1 (init) do.
+ */
+declare function getProcessAncestry(pid?: number): ProcessInfo[];
+//#endregion
+//#region .dts-emit/code/core/src/common/node-version.d.ts
+interface MinNodeVersion {
+  major: number;
+  minor: number;
+  patch: number;
+}
+/**
+ * Minimum Node.js versions supported by Forkbook.
+ * This is the single source of truth — all version checks should reference this.
+ */
+declare const MIN_SUPPORTED_NODE_VERSIONS: readonly MinNodeVersion[];
+/**
+ * Format a MinNodeVersion for human display:
+ * - { major: 20, minor: 0, patch: 0 } → "20+"
+ * - { major: 20, minor: 19, patch: 0 } → "20.19+"
+ * - { major: 22, minor: 22, patch: 1 } → "22.22.1+"
+ */
+declare function formatMinVersion(v: MinNodeVersion): string;
+/** Human-readable description like "20.19+ or 22.12+" */
+declare const MIN_SUPPORTED_NODE_DESCRIPTION: string;
+/**
+ * Check whether a Node.js version meets the minimum requirement.
+ *
+ * Expects the raw `process.versions.node` value (e.g. "22.12.0", "26.1.0-rc.0").
+ * Prerelease builds are evaluated with semver's prerelease rules, so a prerelease
+ * below the floor (e.g. "22.12.0-rc.0") still fails. Unparseable input fails closed.
+ */
+declare function isNodeVersionSupported(version: string): boolean;
+//#endregion
+export { DEFAULT_FILES_PATTERN, DeclaredSubcomponent, ExecuteCommandOptions, FORKBOOK_PACKAGE_PATTERNS, FORKBOOK_RERUN_INSTRUCTION, FORKBOOK_VERSION_SPECIFIER_ENV, FileLockOptions, FileOptions, FileSystemCache, HandledError, INSTALL_ERROR_TAIL_LINES, InstallationMetadata, InterPresetOptions, JsPackageManager, JsPackageManagerFactory, LazyDocgenMiddlewareOptions, MIN_SUPPORTED_NODE_DESCRIPTION, MIN_SUPPORTED_NODE_VERSIONS, MetaComponentResolution, MetaComponentResolverOptions, MinNodeVersion, ModuleResolver, ModuleResolverOptions, type PackageJson, PackageJsonInfo, PackageJsonWithDepsAndDevDeps, PackageJsonWithMaybeDeps, PackageManagerName, PackageMetadata, ProcessAncestryEntry, ProcessInfo, RemoveAddonOptions, ResolveImportOptions, ResolvedMetaComponent, STORY_FILE_TEST_REGEXP, SetupAddonInConfigOptions, builderPackages, cache, checkAddonOrder, checkRef, clearVitePlusCache, commonGlobOptions, createFileSystemCache, createLazyDocgenMiddleware, createLogStream, createMetaComponentResolver, createModuleResolver, deepMerge, defaultConfigDir, defaultResolveConditionNames, doesVariableOrFunctionDeclarationExist, ensureNamedImport, executeCommand, executeCommandSync, executeNodeCommand, extractDeclaredSubcomponents, extractFrameworkPackageName, extractRenderer, findConfigFile, findFilesUp, findStorybookPackageRoot, findTsconfigPath, findTsconfigPathForFile, findTsconfigPathForPath, forkbookFramework, formatCode, formatFileContent, formatMinVersion, frameworkPackages, frameworkToBuilder, frameworkToRenderer, getAbsolutePathWrapperAsCallExpression, getAbsolutePathWrapperName, getAddonNames, getAgeInMinutes, getAutoRefs, getBabelPresetEnvMajor, getBuilderOptions, getComponentIdFromEntry, getConfigInfo, getDirectoryFromWorkingDir, getEnvConfig, getErrorLogs, getFieldsForGetAbsolutePathWrapper, getFrameworkName, getInstallErrorTail, getInterpretedFile, getLatestStableVersionAdheringToMinimumAgeGate, getMswInitCommand, getPackageDetails, getPkgPrNewPackageSpecifier, getPresets, getPrettyPackageManagerName, getPreviewBodyTemplate, getPreviewHeadTemplate, getProcessAncestry, getProjectRoot, getRefs, getRendererName, getStoryId, getStoryImportPathFromEntry, getStoryTitle, getStorybookConfiguration, getStorybookInfo, getStorybookRerunCommand, getStorybookVersionSpecifierFromAncestry, getTsconfigPathsBaseDir, getVitePlusVersions, getVitestStorybookRunCommand, globToRegexp, groupBy, hasStorybookMinimumAgeExclusions, importMetaResolve, importModule, interpolate, invalidateProjectRootCache, invariant, isCI, isCorePackage, isEligibleStoryEntry, isGetAbsolutePathWrapperNecessary, isInNodeModules, isNodeVersionSupported, isPkgPrNewVersionSpecifier, isPreservingSymlinks, isSatelliteAddon, isWebContainer, jsTsSourceExtensions, loadAllPresets, loadEnvs, loadMainConfig, loadManagerOrAddonsFile, loadPreset, loadPreviewOrConfigFile, logConfig, nodePathsToArray, normalizeAddonName, normalizeStories, normalizeStoriesEntry, normalizeStoryPath, optionalEnvToBoolean, parseList, parsePackageData, parsePackageTimeMap, parsePositiveIntegerConfigValue, parseReleaseTime, posix, readDependencyManifest, readTemplate, registerService, removeAddon, rendererPackages, resolveAddonName, resolveImport, resolvePackageDir, resolvePathInStorybookCache, resolveStorybookVersionSpecifier, safeResolveModule, scanAndTransformFiles, selectComponentEntriesByComponentId, setupAddonInConfig, slash, stringifyEnvs, stringifyProcessEnvs, supportedExtensions, syncPreviewAddonsWithMainConfig, syncStorybookAddons, temporaryDirectory, temporaryFile, toTitle, transformImports, validateConfigurationFiles, validateFrameworkName, _default as versions, warnOnYarn1, withFileLock, withForkbookFramework, wrapValueWithGetAbsolutePathWrapper };