sv 0.11.2 → 0.11.3

package/dist/{index-7xp7FWpU.d.mts → core-CnPhgWST.d.mts}

@@ -1,10 +1,13 @@
 import { log } from "@clack/prompts";
-import colors from "picocolors";
 import dedent from "dedent";
 import * as Walker from "zimmerframe";
+import { AgentName } from "package-manager-detector";
+import { resolveCommand } from "package-manager-detector/commands";
 import * as estree from "estree";
 import { BaseNode as BaseNode$1 } from "estree";
 import { AST as SvelteAst } from "svelte/compiler";
+import * as yaml from "yaml";
+import { TomlTable } from "smol-toml";
 
 //#region lib/core/addon/options.d.ts
 type BooleanQuestion = {
@@ -68,7 +71,8 @@ type Workspace = {
   * @returns the dependency version with any leading characters such as ^ or ~ removed
   */
   dependencyVersion: (pkg: string) => string | undefined;
-  typescript: boolean;
+  /** to know if the workspace is using typescript or javascript */
+  language: "ts" | "js";
   files: {
     viteConfig: "vite.config.js" | "vite.config.ts";
     svelteConfig: "svelte.config.js" | "svelte.config.ts";
@@ -89,14 +93,34 @@ type Workspace = {
       to: string;
     }) => string;
   };
+  /** If we are in a kit project, this object will contain the lib and routes directories */
   kit: {
     libDirectory: string;
     routesDirectory: string;
   } | undefined;
+  /** The package manager used to install dependencies */
   packageManager: PackageManager;
 };
 type PackageManager = "npm" | "yarn" | "pnpm" | "bun" | "deno";
 //#endregion
+//#region lib/addons/_config/official.d.ts
+type OfficialAddons = {
+  prettier: Addon<any>;
+  eslint: Addon<any>;
+  vitest: Addon<any>;
+  playwright: Addon<any>;
+  tailwindcss: Addon<any>;
+  sveltekitAdapter: Addon<any>;
+  devtoolsJson: Addon<any>;
+  drizzle: Addon<any>;
+  lucia: Addon<any>;
+  mdsvex: Addon<any>;
+  paraglide: Addon<any>;
+  storybook: Addon<any>;
+  mcp: Addon<any>;
+};
+declare const officialAddons: OfficialAddons;
+//#endregion
 //#region lib/core/addon/config.d.ts
 type ConditionDefinition = (Workspace: Workspace) => boolean;
 type PackageDefinition = {
@@ -112,10 +136,15 @@ type Scripts = {
   condition?: ConditionDefinition;
 };
 type SvApi = {
+  /** Add a package to the pnpm build dependencies. */
   pnpmBuildDependency: (pkg: string) => void;
+  /** Add a package to the dependencies. */
   dependency: (pkg: string, version: string) => void;
+  /** Add a package to the dev dependencies. */
   devDependency: (pkg: string, version: string) => void;
+  /** Execute a command in the workspace. */
   execute: (args: string[], stdio: "inherit" | "pipe") => Promise<void>;
+  /** Edit a file in the workspace. (will create it if it doesn't exist) */
   file: (path: string, edit: (content: string) => string) => void;
 };
 type Addon<Args extends OptionDefinition> = {
@@ -124,38 +153,107 @@ type Addon<Args extends OptionDefinition> = {
   shortDescription?: string;
   homepage?: string;
   options: Args;
+  /** Setup the addon. Will be called before the addon is run. */
   setup?: (workspace: Workspace & {
-    dependsOn: (name: string) => void;
+    /** On what official addons does this addon depend on? */
+    dependsOn: (name: keyof typeof officialAddons) => void;
+    /** Why is this addon not supported?
+    *
+    * @example
+    * if (!kit) unsupported('Requires SvelteKit');
+    */
     unsupported: (reason: string) => void;
-    runsAfter: (addonName: string) => void;
+    /** On what official addons does this addon run after? */
+    runsAfter: (name: keyof typeof officialAddons) => void;
   }) => MaybePromise<void>;
+  /** Run the addon. The actual execution of the addon... Add files, edit files, etc. */
   run: (workspace: Workspace & {
+    /** Add-on options */
     options: WorkspaceOptions<Args>;
+    /** Api to interact with the workspace. */
     sv: SvApi;
+    /** Cancel the addon at any time!
+    * @example
+    * return cancel('There is a problem with...');
+    */
     cancel: (reason: string) => void;
   }) => MaybePromise<void>;
-  nextSteps?: (data: {
-    highlighter: Highlighter;
-  } & Workspace & {
+  /** Next steps to display after the addon is run. */
+  nextSteps?: (data: Workspace & {
     options: WorkspaceOptions<Args>;
   }) => string[];
 };
-type Highlighter = {
-  addon: (str: string) => string;
-  path: (str: string) => string;
-  command: (str: string) => string;
-  website: (str: string) => string;
-  route: (str: string) => string;
-  env: (str: string) => string;
-  optional: (str: string) => string;
-};
+/**
+* The entry point for your addon, It will hold every thing! (options, setup, run, nextSteps, ...)
+*/
 declare function defineAddon<Args extends OptionDefinition>(config: Addon<Args>): Addon<Args>;
-type AddonSetupResult = {
+/**
+* Stage 1: Raw CLI input - what the user typed
+*/
+type AddonInput = {
+  readonly specifier: string;
+  readonly options: string[];
+};
+/**
+* Stage 2: Classified source - knows where addon comes from
+*/
+type AddonSource = {
+  readonly kind: "official";
+  readonly id: string;
+} | {
+  readonly kind: "file";
+  readonly path: string;
+} | {
+  readonly kind: "npm";
+  readonly packageName: string;
+  readonly npmUrl: string;
+  readonly registryUrl: string;
+  readonly tag: string;
+};
+type AddonReference = {
+  readonly specifier: string;
+  readonly options: string[];
+  readonly source: AddonSource;
+};
+/**
+* Stage 3: Code loaded - addon definition is always present
+*/
+type LoadedAddon = {
+  readonly reference: AddonReference;
+  readonly addon: AddonDefinition;
+};
+/**
+* Stage 4: Setup done - has dependency info
+*/
+type PreparedAddon = LoadedAddon & {
+  readonly setupResult: SetupResult;
+};
+/**
+* Stage 5: User configured - has answers to questions
+*/
+type ConfiguredAddon = PreparedAddon & {
+  readonly answers: OptionValues<any>;
+};
+/**
+* Stage 6: Execution result
+*/
+type AddonResult = {
+  readonly id: string;
+  readonly status: "success" | {
+    canceled: string[];
+  };
+  readonly files: string[];
+};
+/**
+* Generates an inline error hint based on the addon source
+*/
+declare function getErrorHint(source: AddonSource): string;
+type SetupResult = {
   dependsOn: string[];
   unsupported: string[];
   runsAfter: string[];
 };
-type AddonWithoutExplicitArgs = Addon<Record<string, Question<any>>>;
+type AddonDefinition = Addon<Record<string, Question<any>>>;
 type Tests = {
   expectProperty: (selector: string, property: string, expectedValue: string) => Promise<void>;
   elementExists: (selector: string) => Promise<void>;
@@ -177,34 +275,75 @@ type Verification = {
 };
 type Prettify<T> = { [K in keyof T]: T[K] } & unknown;
 type OptionBuilder<T extends OptionDefinition> = {
+  /**
+  * This type is a bit complex, but in usage, it's quite simple!
+  *
+  * The idea is to `add()` options one by one, with the key and the question.
+  *
+  * ```ts
+  *   .add('demo', {
+  *     question: 'Do you want to add a demo?',
+  *     type: 'boolean',  // string, number, select, multiselect
+  *     default: true,
+  *     // condition: (o) => o.previousOption === 'ok',
+  *   })
+  * ```
+  */
   add<K$1 extends string, const Q extends Question<T & Record<K$1, Q>>>(key: K$1, question: Q): OptionBuilder<T & Record<K$1, Q>>;
+  /** Finalize all options of your `add-on`. */
   build(): Prettify<T>;
 };
+/**
+* Options for an addon.
+*
+* Will be prompted to the user if there are not answered by args when calling the cli.
+*
+* ```ts
+* const options = defineAddonOptions()
+*   .add('demo', {
+*     question: `demo? ${color.optional('(a cool one!)')}`
+*     type: string | boolean | number | select | multiselect,
+*     default: true,
+*   })
+*   .build();
+* ```
+*
+* To define by args, you can do
+* ```sh
+* npx sv add <addon>=<option1>:<value1>+<option2>:<value2>
+* ```
+*/
 declare function defineAddonOptions(): OptionBuilder<{}>;
-declare namespace utils_d_exports {
-  export { createPrinter };
-}
-type Printer = (content: string, alt?: string) => string;
-declare function createPrinter(...conditions: boolean[]): Printer[];
 //#endregion
-//#region lib/core/common.d.ts
-type Version = {
-  major?: number;
-  minor?: number;
-  patch?: number;
+//#region lib/cli/add/utils.d.ts
+declare function fileExists(cwd: string, filePath: string): boolean;
+declare const color: {
+  addon: (str: string) => string;
+  command: (str: string) => string;
+  env: (str: string) => string;
+  path: (str: string) => string;
+  route: (str: string) => string;
+  website: (str: string) => string;
+  optional: (str: string) => string;
+  warning: (str: string) => string;
 };
-declare function splitVersion(str: string): Version;
+//#endregion
+//#region lib/core/common.d.ts
 declare function isVersionUnsupportedBelow(versionStr: string, belowStr: string): boolean | undefined;
 //#endregion
-//#region lib/core/addon/processors.d.ts
-type FileEditor = Workspace & {
-  content: string;
-};
-type FileType = {
-  name: (options: Workspace) => string;
-  condition?: ConditionDefinition;
-  content: (editor: FileEditor) => string;
-};
+//#region lib/addons/common.d.ts
+declare function addToDemoPage(existingContent: string, path: string, language: "ts" | "js"): string;
+/**
+* Returns the corresponding `@types/node` version for the version of Node.js running in the current process.
+*
+* If the installed version of Node.js is from a `Current` release, then the major is decremented to
+* the nearest `LTS` release version.
+*/
+declare function getNodeTypesVersion(): string;
+//#endregion
+//#region lib/core/utils.d.ts
+type Printer = (content: string, alt?: string) => string;
+declare function createPrinter(...conditions: boolean[]): Printer[];
 //#endregion
 //#region lib/core/tooling/js/ts-estree.d.ts
 declare module "estree" {
@@ -304,6 +443,7 @@ declare module "estree" {
 }
 //#endregion
 //#region lib/core/tooling/index.d.ts
+declare function parseYaml$1(content: string): ReturnType<typeof yaml.parseDocument>;
 type CommentType = {
   type: "Line" | "Block";
   value: string;
@@ -318,6 +458,24 @@ declare class Comments {
   }): void;
   remove(predicate: (comment: estree.Comment) => boolean | undefined | null): void;
 }
+declare namespace index_d_exports$3 {
+  export { addAtRule, addDeclaration, addImports, addRule };
+}
+declare function addRule(node: SvelteAst.CSS.StyleSheet, options: {
+  selector: string;
+}): SvelteAst.CSS.Rule;
+declare function addDeclaration(node: SvelteAst.CSS.Rule, options: {
+  property: string;
+  value: string;
+}): void;
+declare function addImports(node: SvelteAst.CSS.StyleSheet, options: {
+  imports: string[];
+}): void;
+declare function addAtRule(node: SvelteAst.CSS.StyleSheet, options: {
+  name: string;
+  params: string;
+  append: boolean;
+}): SvelteAst.CSS.Atrule;
 declare namespace array_d_exports {
   export { append, create$1 as create, prepend };
 }
@@ -466,7 +624,7 @@ declare function addGlobalAppInterface(node: estree.TSProgram, options: {
   name: "Error" | "Locals" | "PageData" | "PageState" | "Platform";
 }): estree.TSInterfaceDeclaration;
 declare function addHooksHandle(node: estree.Program, options: {
-  typescript: boolean;
+  language: "ts" | "js";
   newHandleName: string;
   handleContent: string;
 }): void;
@@ -479,28 +637,118 @@ declare const addPlugin: (ast: estree.Program, options: {
   mode?: "append" | "prepend";
 }) => void;
 declare const getConfig: (ast: estree.Program) => estree.ObjectExpression;
-declare namespace index_d_exports {
+declare namespace index_d_exports$2 {
   export { estree as AstTypes, Comments, array_d_exports as array, common_d_exports as common, exports_d_exports as exports, function_d_exports as functions, imports_d_exports as imports, kit_d_exports as kit, object_d_exports as object, variables_d_exports as variables, vite_d_exports as vite };
 }
 declare namespace index_d_exports$1 {
-  export { SvelteAst, addSlot, ensureScript, toFragment };
+  export { addAttribute, addFromRawHtml, appendElement, createElement, insertElement };
+}
+declare function createElement(tagName: string, attributes?: Record<string, string>): SvelteAst.RegularElement;
+declare function addAttribute(element: SvelteAst.RegularElement, name: string, value: string): void;
+declare function insertElement(fragment: SvelteAst.Fragment, elementToInsert: SvelteAst.Fragment["nodes"][0]): void;
+declare function appendElement(fragment: SvelteAst.Fragment, elementToAppend: SvelteAst.Fragment["nodes"][0]): void;
+declare function addFromRawHtml(fragment: SvelteAst.Fragment, html: string): void;
+declare namespace json_d_exports {
+  export { arrayUpsert, packageScriptsUpsert };
 }
+declare function arrayUpsert(data: any, key: string, value: any, options?: {
+  /** default: `append` */
+  mode?: "append" | "prepend";
+}): void;
+declare function packageScriptsUpsert(data: any, key: string, value: any): void;
+declare namespace index_d_exports {
+  export { addFragment, addSlot, ensureScript };
+}
+type RootWithInstance = SvelteAst.Root & {
+  instance: SvelteAst.Script;
+};
 declare function ensureScript(ast: SvelteAst.Root, options?: {
-  langTs?: boolean;
-}): estree.Program;
+  language?: "ts" | "js";
+}): asserts ast is RootWithInstance;
 declare function addSlot(ast: SvelteAst.Root, options: {
   svelteVersion: string;
-  langTs?: boolean;
+  language?: "ts" | "js";
+}): void;
+declare function addFragment(ast: SvelteAst.Root, content: string, options?: {
+  mode?: "append" | "prepend";
 }): void;
-declare function toFragment(content: string): SvelteAst.Fragment["nodes"];
 //#endregion
 //#region lib/core/tooling/parsers.d.ts
 type ParseBase = {
   source: string;
+  /**
+  * Generate the code after manipulating the `ast`.
+  *
+  * ```ts
+  * import { svelte } from 'sv/core';
+  * const { ast, generateCode } = parse.svelte(content);
+  *
+  * svelte.addFragment(ast, '<p>Hello World</p>');
+  *
+  * const code = generateCode();
+  * ```
+  */
   generateCode(): string;
 };
+declare function parseScript(source: string): {
+  ast: estree.Program;
+  comments: Comments;
+} & ParseBase;
+declare function parseCss(source: string): {
+  ast: SvelteAst.CSS.StyleSheet;
+} & ParseBase;
+declare function parseHtml(source: string): {
+  ast: SvelteAst.Fragment;
+} & ParseBase;
+declare function parseJson(source: string): {
+  data: any;
+} & ParseBase;
+declare function parseYaml(source: string): {
+  data: ReturnType<typeof parseYaml$1>;
+} & ParseBase;
 declare function parseSvelte(source: string): {
   ast: SvelteAst.Root;
 } & ParseBase;
+declare function parseToml(source: string): {
+  data: TomlTable;
+} & ParseBase;
+//#endregion
+//#region lib/core/addon/processors.d.ts
+type FileEditor = Workspace & {
+  content: string;
+};
+type FileType = {
+  name: (options: Workspace) => string;
+  condition?: ConditionDefinition;
+  content: (editor: FileEditor) => string;
+};
+//#endregion
+//#region lib/core.d.ts
+/**
+* Will help you `parse` code into an `ast` from all supported languages.
+* Then manipulate the `ast` as you want,
+* and finally `generateCode()` to write it back to the file.
+*
+* ```ts
+* import { parse } from 'sv/core';
+*
+* const { ast, generateCode } = parse.css('body { color: red; }');
+* const { ast, generateCode } = parse.html('<div>Hello, world!</div>');
+* const { ast, generateCode } = parse.json('{ "name": "John", "age": 30 }');
+* const { ast, generateCode } = parse.script('function add(a, b) { return a + b; }');
+* const { ast, generateCode } = parse.svelte('<div>Hello, world!</div>');
+* const { ast, generateCode } = parse.toml('name = "John"');
+* const { ast, generateCode } = parse.yaml('name: John');
+* ```
+*/
+declare const parse: {
+  css: typeof parseCss;
+  html: typeof parseHtml;
+  json: typeof parseJson;
+  script: typeof parseScript;
+  svelte: typeof parseSvelte;
+  toml: typeof parseToml;
+  yaml: typeof parseYaml;
+};
 //#endregion
-export { BaseQuestion as A, Tests as C, PackageManager as D, defineAddonOptions as E, OptionValues as F, Question as I, SelectQuestion as L, MultiSelectQuestion as M, NumberQuestion as N, Workspace as O, OptionDefinition as P, StringQuestion as R, TestDefinition as S, defineAddon as T, Highlighter as _, index_d_exports$1 as a, Scripts as b, FileEditor as c, splitVersion as d, utils_d_exports as f, ConditionDefinition as g, AddonWithoutExplicitArgs as h, parseSvelte as i, BooleanQuestion as j, WorkspaceOptions as k, FileType as l, AddonSetupResult as m, dedent as n, index_d_exports as o, Addon as p, log as r, Walker as s, colors as t, isVersionUnsupportedBelow as u, OptionBuilder as v, Verification as w, SvApi as x, PackageDefinition as y };
+export { Question as $, LoadedAddon as A, defineAddon as B, AddonDefinition as C, AddonSource as D, AddonResult as E, SetupResult as F, Workspace as G, getErrorHint as H, SvApi as I, BooleanQuestion as J, WorkspaceOptions as K, TestDefinition as L, PackageDefinition as M, PreparedAddon as N, ConditionDefinition as O, Scripts as P, OptionValues as Q, Tests as R, Addon as S, AddonReference as T, officialAddons as U, defineAddonOptions as V, PackageManager as W, NumberQuestion as X, MultiSelectQuestion as Y, OptionDefinition as Z, addToDemoPage as _, resolveCommand as a, color as b, index_d_exports as c, index_d_exports$2 as d, SelectQuestion as et, index_d_exports$3 as f, createPrinter as g, estree as h, parse as i, OptionBuilder as j, ConfiguredAddon as k, json_d_exports as l, SvelteAst as m, dedent as n, FileEditor as o, Comments as p, BaseQuestion as q, log as r, FileType as s, Walker as t, StringQuestion as tt, index_d_exports$1 as u, getNodeTypesVersion as v, AddonInput as w, fileExists as x, isVersionUnsupportedBelow as y, Verification as z };

package/dist/lib/core.d.mts

@@ -0,0 +1,2 @@
+import { $ as Question, A as LoadedAddon, B as defineAddon, C as AddonDefinition, D as AddonSource, E as AddonResult, F as SetupResult, G as Workspace, H as getErrorHint, I as SvApi, J as BooleanQuestion, K as WorkspaceOptions, L as TestDefinition, M as PackageDefinition, N as PreparedAddon, O as ConditionDefinition, P as Scripts, Q as OptionValues, R as Tests, S as Addon, T as AddonReference, V as defineAddonOptions, W as PackageManager, X as NumberQuestion, Y as MultiSelectQuestion, Z as OptionDefinition, _ as addToDemoPage, a as resolveCommand, b as color, c as index_d_exports$3, d as index_d_exports$2, et as SelectQuestion, f as index_d_exports, g as createPrinter, h as estree, i as parse, j as OptionBuilder, k as ConfiguredAddon, l as json_d_exports, m as SvelteAst, n as dedent, o as FileEditor, p as Comments, q as BaseQuestion, r as log, s as FileType, t as Walker, tt as StringQuestion, u as index_d_exports$1, v as getNodeTypesVersion, w as AddonInput, x as fileExists, y as isVersionUnsupportedBelow, z as Verification } from "../core-CnPhgWST.mjs";
+export { Addon, AddonDefinition, AddonInput, AddonReference, AddonResult, AddonSource, estree as AstTypes, BaseQuestion, BooleanQuestion, Comments, ConditionDefinition, ConfiguredAddon, FileEditor, FileType, LoadedAddon, MultiSelectQuestion, NumberQuestion, OptionBuilder, OptionDefinition, OptionValues, PackageDefinition, PackageManager, PreparedAddon, Question, Scripts, SelectQuestion, SetupResult, StringQuestion, SvApi, SvelteAst, TestDefinition, Tests, Verification, Walker, Workspace, WorkspaceOptions, addToDemoPage, color, createPrinter, index_d_exports as css, dedent, defineAddon, defineAddonOptions, fileExists, getErrorHint, getNodeTypesVersion, index_d_exports$1 as html, isVersionUnsupportedBelow, index_d_exports$2 as js, json_d_exports as json, log, parse, resolveCommand, index_d_exports$3 as svelte };

package/dist/lib/core.mjs

@@ -0,0 +1,3 @@
+import { $ as getNodeTypesVersion, K as svelte_exports, Q as addToDemoPage, X as createPrinter, Y as css_exports, d as json_exports, et as isVersionUnsupportedBelow, ft as resolveCommand, h as js_exports, l as parse, m as html_exports, nt as defineAddon, ot as walk_exports, r as fileExists, rt as defineAddonOptions, st as dedent_default, t as color, vt as T } from "../utils-DjBRIDJG.mjs";
+
+export { walk_exports as Walker, addToDemoPage, color, createPrinter, css_exports as css, dedent_default as dedent, defineAddon, defineAddonOptions, fileExists, getNodeTypesVersion, html_exports as html, isVersionUnsupportedBelow, js_exports as js, json_exports as json, T as log, parse, resolveCommand, svelte_exports as svelte };

package/dist/lib/index.d.mts

@@ -0,0 +1,16 @@
+import { U as officialAddons } from "../core-CnPhgWST.mjs";
+import { i as add, n as InstallOptions, r as OptionMap, t as AddonMap } from "../add-nRRWTjzp.mjs";
+
+//#region lib/create/index.d.ts
+type TemplateType = (typeof templateTypes)[number];
+type LanguageType = (typeof languageTypes)[number];
+declare const templateTypes: readonly ["minimal", "demo", "library", "addon"];
+declare const languageTypes: readonly ["typescript", "checkjs", "none"];
+type Options = {
+  name: string;
+  template: TemplateType;
+  types: LanguageType;
+};
+declare function create(cwd: string, options: Options): void;
+//#endregion
+export { type AddonMap, type InstallOptions, type LanguageType, type OptionMap, type TemplateType, add, create, officialAddons };

package/dist/lib/index.mjs

@@ -1,5 +1,5 @@
-import { p as create } from "../package-manager-CySZrSUa.mjs";
-import "../core-D715tamU.mjs";
-import { i as installAddon, n as officialAddons } from "../official-P5OKi7QM.mjs";
+import { p as create } from "../package-manager-DkCPtZM1.mjs";
+import "../utils-DjBRIDJG.mjs";
+import { c as officialAddons, t as add } from "../add-BWQarWDB.mjs";
 
-export { create, installAddon, officialAddons };
+export { add, create, officialAddons };

package/dist/lib/testing.d.mts

@@ -0,0 +1,108 @@
+import "../core-CnPhgWST.mjs";
+import { r as OptionMap, t as AddonMap } from "../add-nRRWTjzp.mjs";
+import { AgentName } from "package-manager-detector";
+import { TestProject } from "vitest/node";
+import { Page } from "@playwright/test";
+
+//#region lib/cli/utils/package-manager.d.ts
+declare function addPnpmBuildDependencies(cwd: string, packageManager: AgentName | null | undefined, allowedPackages: string[]): Promise<void>;
+//#endregion
+//#region lib/testing.d.ts
+type ProjectVariant = "kit-js" | "kit-ts" | "vite-js" | "vite-ts";
+declare const variants: ProjectVariant[];
+type CreateProject = (options: {
+  testId: string;
+  variant: ProjectVariant;
+  /** @default true */
+  clean?: boolean;
+}) => string;
+type SetupOptions = {
+  cwd: string;
+  variants: readonly ProjectVariant[];
+  /** @default false */
+  clean?: boolean;
+};
+declare function setup({
+  cwd,
+  clean,
+  variants
+}: SetupOptions): Promise<{
+  templatesDir: string;
+}>;
+type CreateOptions = {
+  cwd: string;
+  testName: string;
+  templatesDir: string;
+};
+declare function createProject({
+  cwd,
+  testName,
+  templatesDir
+}: CreateOptions): CreateProject;
+type PreviewOptions = {
+  cwd: string;
+  command?: string;
+};
+declare function startPreview({
+  cwd,
+  command
+}: PreviewOptions): Promise<{
+  url: string;
+  close: () => Promise<void>;
+}>;
+declare module "vitest" {
+  interface ProvidedContext {
+    testDir: string;
+    templatesDir: string;
+    variants: ProjectVariant[];
+  }
+}
+declare function setupGlobal({
+  TEST_DIR,
+  pre,
+  post
+}: {
+  TEST_DIR: string;
+  pre?: () => Promise<void>;
+  post?: () => Promise<void>;
+}): ({
+  provide
+}: TestProject) => Promise<() => Promise<void>>;
+type Fixtures = {
+  page: Page;
+  cwd(addonTestCase: AddonTestCase<any>): string;
+};
+type AddonTestCase<Addons extends AddonMap> = {
+  variant: ProjectVariant;
+  kind: {
+    type: string;
+    options: OptionMap<Addons>;
+  };
+};
+type SetupTestOptions<Addons extends AddonMap> = {
+  kinds: Array<AddonTestCase<Addons>["kind"]>;
+  filter?: (addonTestCase: AddonTestCase<Addons>) => boolean;
+  browser?: boolean;
+  preAdd?: (o: {
+    addonTestCase: AddonTestCase<Addons>;
+    cwd: string;
+  }) => Promise<void> | void;
+};
+type PrepareServerOptions = {
+  cwd: string;
+  page: Page;
+  buildCommand?: string;
+  previewCommand?: string;
+};
+type PrepareServerReturn = {
+  url: string;
+  close: () => Promise<void>;
+};
+declare function prepareServer({
+  cwd,
+  page,
+  buildCommand,
+  previewCommand
+}: PrepareServerOptions): Promise<PrepareServerReturn>;
+//#endregion
+export { AddonTestCase, CreateProject, Fixtures, PrepareServerOptions, PrepareServerReturn, ProjectVariant, SetupTestOptions, addPnpmBuildDependencies, createProject, prepareServer, setup, setupGlobal, startPreview, variants };