tstyche 3.0.0-beta.3 → 3.0.0-beta.4

package/build/tstyche.d.ts

@@ -1,42 +1,23 @@
 import type ts from 'typescript';
 
-declare enum OptionBrand {
-    String = "string",
-    Number = "number",
-    Boolean = "boolean",
-    BareTrue = "bareTrue",// a boolean option that does not take a value and when specified is interpreted as 'true'
-    List = "list"
-}
-
-declare enum OptionGroup {
-    CommandLine = 2,
-    ConfigFile = 4
+declare enum CancellationReason {
+    ConfigChange = "configChange",
+    ConfigError = "configError",
+    FailFast = "failFast",
+    WatchClose = "watchClose"
 }
 
-declare class ConfigDiagnosticText {
+declare class CancellationToken {
     #private;
-    static expected(element: string): string;
-    static expectsListItemType(optionName: string, optionBrand: OptionBrand): string;
-    static expectsValue(optionName: string, optionGroup: OptionGroup): string;
-    static fileDoesNotExist(filePath: string): string;
-    static seen(element: string): string;
-    static testFileMatchCannotStartWith(segment: string): Array<string>;
-    static requiresValueType(optionName: string, optionBrand: OptionBrand, optionGroup: OptionGroup): string;
-    static unknownOption(optionName: string): string;
-    static versionIsNotSupported(value: string): string;
-    static watchCannotBeEnabled(): string;
+    get isCancellationRequested(): boolean;
+    get reason(): CancellationReason | undefined;
+    cancel(reason: CancellationReason): void;
+    reset(): void;
 }
 
-declare class StoreService {
+declare class Cli {
     #private;
-    constructor();
-    getSupportedTags(): Promise<Array<string> | undefined>;
-    install(tag: string): Promise<void>;
-    load(tag: string): Promise<typeof ts | undefined>;
-    open(): Promise<void>;
-    prune(): Promise<void>;
-    update(): Promise<void>;
-    validateTag(tag: string): Promise<boolean | undefined>;
+    run(commandLine: Array<string>, cancellationToken?: CancellationToken): Promise<void>;
 }
 
 declare enum DiagnosticCategory {
@@ -44,6 +25,48 @@ declare enum DiagnosticCategory {
     Warning = "warning"
 }
 
+declare class SourceFile {
+    #private;
+    fileName: string;
+    text: string;
+    constructor(fileName: string, text: string);
+    getLineStarts(): Array<number>;
+    getLineAndCharacterOfPosition(position: number): {
+        line: number;
+        character: number;
+    };
+}
+
+declare class DiagnosticOrigin {
+    assertion: Assertion | undefined;
+    end: number;
+    sourceFile: SourceFile | ts.SourceFile;
+    start: number;
+    constructor(start: number, end: number, sourceFile: SourceFile | ts.SourceFile, assertion?: Assertion);
+    static fromAssertion(assertion: Assertion): DiagnosticOrigin;
+    static fromNode(node: ts.Node, assertion?: Assertion): DiagnosticOrigin;
+}
+
+declare class Diagnostic {
+    #private;
+    category: DiagnosticCategory;
+    code: string | undefined;
+    origin: DiagnosticOrigin | undefined;
+    related: Array<Diagnostic> | undefined;
+    text: string | Array<string>;
+    constructor(text: string | Array<string>, category: DiagnosticCategory, origin?: DiagnosticOrigin);
+    add(options: {
+        code?: string | undefined;
+        related?: Array<Diagnostic> | undefined;
+    }): this;
+    static error(text: string | Array<string>, origin?: DiagnosticOrigin): Diagnostic;
+    extendWith(text: string | Array<string>, origin?: DiagnosticOrigin): Diagnostic;
+    static fromDiagnostics(diagnostics: Array<ts.Diagnostic>, compiler: typeof ts): Array<Diagnostic>;
+    static warning(text: string | Array<string>, origin?: DiagnosticOrigin): Diagnostic;
+}
+
+type DiagnosticsHandler$1 = (this: void, diagnostic: Diagnostic) => void;
+
 declare enum TestMemberBrand {
     Describe = "describe",
     Test = "test",
@@ -99,44 +122,32 @@ declare class CollectService {
     createTestTree(sourceFile: ts.SourceFile, semanticDiagnostics?: Array<ts.Diagnostic>): TestTree;
 }
 
-declare class SourceFile {
-    #private;
-    fileName: string;
-    text: string;
-    constructor(fileName: string, text: string);
-    getLineStarts(): Array<number>;
-    getLineAndCharacterOfPosition(position: number): {
-        line: number;
-        character: number;
-    };
+declare enum OptionBrand {
+    String = "string",
+    Number = "number",
+    Boolean = "boolean",
+    BareTrue = "bareTrue",// a boolean option that does not take a value and when specified is interpreted as 'true'
+    List = "list"
 }
 
-declare class DiagnosticOrigin {
-    assertion: Assertion | undefined;
-    end: number;
-    sourceFile: SourceFile | ts.SourceFile;
-    start: number;
-    constructor(start: number, end: number, sourceFile: SourceFile | ts.SourceFile, assertion?: Assertion);
-    static fromAssertion(assertion: Assertion): DiagnosticOrigin;
-    static fromNode(node: ts.Node, assertion?: Assertion): DiagnosticOrigin;
+declare enum OptionGroup {
+    CommandLine = 2,
+    ConfigFile = 4
 }
 
-declare class Diagnostic {
+declare class ConfigDiagnosticText {
     #private;
-    category: DiagnosticCategory;
-    code: string | undefined;
-    origin: DiagnosticOrigin | undefined;
-    related: Array<Diagnostic> | undefined;
-    text: string | Array<string>;
-    constructor(text: string | Array<string>, category: DiagnosticCategory, origin?: DiagnosticOrigin);
-    add(options: {
-        code?: string | undefined;
-        related?: Array<Diagnostic> | undefined;
-    }): this;
-    static error(text: string | Array<string>, origin?: DiagnosticOrigin): Diagnostic;
-    extendWith(text: string | Array<string>, origin?: DiagnosticOrigin): Diagnostic;
-    static fromDiagnostics(diagnostics: Array<ts.Diagnostic>, compiler: typeof ts): Array<Diagnostic>;
-    static warning(text: string | Array<string>, origin?: DiagnosticOrigin): Diagnostic;
+    static expected(element: string): string;
+    static expectsListItemType(optionName: string, optionBrand: OptionBrand): string;
+    static expectsValue(optionName: string, optionGroup: OptionGroup): string;
+    static fileDoesNotExist(filePath: string): string;
+    static moduleWasNotFound(specifier: string): string;
+    static seen(element: string): string;
+    static testFileMatchCannotStartWith(segment: string): Array<string>;
+    static requiresValueType(optionName: string, optionBrand: OptionBrand, optionGroup: OptionGroup): string;
+    static unknownOption(optionName: string): string;
+    static versionIsNotSupported(value: string): string;
+    static watchCannotBeEnabled(): string;
 }
 
 /**
@@ -147,6 +158,14 @@ interface ConfigFileOptions {
      * Stop running tests after the first failed assertion.
      */
     failFast?: boolean;
+    /**
+     * The list of plugins to use.
+     */
+    plugins?: Array<string>;
+    /**
+     * The list of reporters to use.
+     */
+    reporters?: Array<string>;
     /**
      * The path to a directory containing files of a test project.
      */
@@ -189,10 +208,18 @@ interface CommandLineOptions {
      * Only run tests with matching name.
      */
     only?: string;
+    /**
+     * The list of plugins to use.
+     */
+    plugins?: Array<string>;
     /**
      * Remove all installed versions of the 'typescript' package and exit.
      */
     prune?: boolean;
+    /**
+     * The list of reporters to use.
+     */
+    reporters?: Array<string>;
     /**
      * Print the resolved configuration and exit.
      */
@@ -219,38 +246,7 @@ interface CommandLineOptions {
     watch?: boolean;
 }
 
-interface EnvironmentOptions {
-    /**
-     * Is `true` if the process is running in a continuous integration environment.
-     */
-    isCi: boolean;
-    /**
-     * Specifies whether color should be disabled in the output.
-     */
-    noColor: boolean;
-    /**
-     * Specifies whether interactive elements should be disabled in the output.
-     */
-    noInteractive: boolean;
-    /**
-     * The base URL of the 'npm' registry to use.
-     */
-    npmRegistry: string;
-    /**
-     * The directory where to store the 'typescript' packages.
-     */
-    storePath: string;
-    /**
-     * The number of seconds to wait before giving up stale operations.
-     */
-    timeout: number;
-    /**
-     * The path to the currently installed TypeScript module.
-     */
-    typescriptPath: string | undefined;
-}
-
-interface ResolvedConfig extends EnvironmentOptions, Omit<CommandLineOptions, keyof ConfigFileOptions | "config">, Required<ConfigFileOptions> {
+interface ResolvedConfig extends Omit<CommandLineOptions, "config" | keyof ConfigFileOptions>, Required<ConfigFileOptions> {
     /**
      * The path to a TSTyche configuration file.
      */
@@ -260,11 +256,23 @@ interface ResolvedConfig extends EnvironmentOptions, Omit<CommandLineOptions, ke
      */
     pathMatch: Array<string>;
 }
-declare class ConfigService {
-    #private;
-    parseCommandLine(commandLineArgs: Array<string>, storeService: StoreService): Promise<void>;
-    readConfigFile(storeService: StoreService): Promise<void>;
-    resolveConfig(): ResolvedConfig;
+declare class Config {
+    #private;
+    static parseCommandLine(commandLine: Array<string>): Promise<{
+        commandLineOptions: CommandLineOptions;
+        pathMatch: Array<string>;
+    }>;
+    static parseConfigFile(filePath?: string): Promise<{
+        configFileOptions: ConfigFileOptions;
+        configFilePath: string;
+    }>;
+    static resolve(options?: {
+        configFileOptions?: ConfigFileOptions;
+        configFilePath?: string;
+        commandLineOptions?: Omit<CommandLineOptions, "config">;
+        pathMatch?: Array<string>;
+    }): ResolvedConfig;
+    static resolveConfigFilePath(filePath?: string): string;
 }
 
 interface ItemDefinition {
@@ -286,77 +294,73 @@ interface ListTypeOptionDefinition extends BaseOptionDefinition {
     brand: OptionBrand.List;
     items: ItemDefinition;
 }
-declare class OptionDefinitionsMap {
+declare class Options {
     #private;
     static for(optionGroup: OptionGroup): Map<string, OptionDefinition>;
 }
 
 declare const defaultOptions: Required<ConfigFileOptions>;
 
-declare const environmentOptions: EnvironmentOptions;
-
-declare enum Color {
-    Reset = "0",
-    Red = "31",
-    Green = "32",
-    Yellow = "33",
-    Blue = "34",
-    Magenta = "35",
-    Cyan = "36",
-    Gray = "90"
+interface EnvironmentOptions {
+    /**
+     * Is `true` if the process is running in continuous integration environment.
+     */
+    isCi: boolean;
+    /**
+     * Specifies whether color should be disabled in the output.
+     */
+    noColor: boolean;
+    /**
+     * Specifies whether interactive elements should be disabled in the output.
+     */
+    noInteractive: boolean;
+    /**
+     * The base URL of the 'npm' registry to use.
+     */
+    npmRegistry: string;
+    /**
+     * The directory where to store the 'typescript' packages.
+     */
+    storePath: string;
+    /**
+     * The number of seconds to wait before giving up stale operations.
+     */
+    timeout: number;
+    /**
+     * The path to the currently installed TypeScript module.
+     */
+    typescriptPath: string | undefined;
 }
 
-type ScribblerNode = Array<ScribblerNode> | ScribblerJsx.Element | string | number | undefined;
-type FunctionComponent = (props: Record<string, unknown>) => ScribblerJsx.Element;
-declare namespace ScribblerJsx {
-    interface Element {
-        props: Record<string, unknown>;
-        type: FunctionComponent | number | string;
-    }
-    interface ElementChildrenAttribute {
-        children: ScribblerNode;
-    }
-    interface IntrinsicElements {
-        ansi: {
-            escapes: Color | Array<Color>;
-        };
-        newLine: {};
-        text: {
-            children: Array<ScribblerNode>;
-            indent: number;
-        };
-    }
-}
+declare const environmentOptions: EnvironmentOptions;
 
-interface LineProps {
-    children?: ScribblerNode;
-    color?: Color;
-    indent?: number;
+interface Reporter {
+    on: (event: ReporterEvent) => void;
 }
-declare function Line({ children, color, indent }: LineProps): ScribblerJsx.Element;
+type ReporterEvent = Exclude<Event, ["config:error" | "select:error", {}]>;
 
-interface ScribblerOptions {
-    newLine?: string;
-    noColor?: boolean;
+declare abstract class BaseReporter implements Reporter {
+    protected resolvedConfig: ResolvedConfig;
+    constructor(resolvedConfig: ResolvedConfig);
+    abstract on([event, payload]: ReporterEvent): void;
 }
-declare class Scribbler {
+
+declare class ListReporter extends BaseReporter {
     #private;
-    constructor(options?: ScribblerOptions);
-    render(element: ScribblerJsx.Element): string;
+    on([event, payload]: ReporterEvent): void;
 }
 
-interface TextProps {
-    children?: ScribblerNode;
-    color?: Color | undefined;
-    indent?: number | undefined;
+declare class SetupReporter {
+    on([event, payload]: ReporterEvent): void;
 }
-declare function Text({ children, color, indent }: TextProps): ScribblerJsx.Element;
 
-declare function addsPackageText(packageVersion: string, packagePath: string): ScribblerJsx.Element;
-
-declare function describeNameText(name: string, indent?: number): ScribblerJsx.Element;
+declare class SummaryReporter extends BaseReporter {
+    on([event, payload]: ReporterEvent): void;
+}
 
-declare function diagnosticText(diagnostic: Diagnostic): ScribblerJsx.Element;
+declare class WatchReporter extends BaseReporter {
+    on([event, payload]: ReporterEvent): void;
+}
 
 declare class ResultTiming {
     end: number;
@@ -457,92 +461,15 @@ declare class Result {
     constructor(resolvedConfig: ResolvedConfig, tasks: Array<Task>);
 }
 
-declare function taskStatusText(status: TaskResultStatus, task: Task): ScribblerJsx.Element;
-
-declare function fileViewText(lines: Array<ScribblerJsx.Element>, addEmptyFinalLine: boolean): ScribblerJsx.Element;
-
-declare function formattedText(input: string | Array<string> | Record<string, unknown>): ScribblerJsx.Element;
-
-declare function helpText(optionDefinitions: Map<string, OptionDefinition>, tstycheVersion: string): ScribblerJsx.Element;
-
-declare class OutputService {
-    #private;
-    constructor();
-    clearTerminal(): void;
-    eraseLastLine(): void;
-    writeError(element: ScribblerJsx.Element | Array<ScribblerJsx.Element>): void;
-    writeMessage(element: ScribblerJsx.Element | Array<ScribblerJsx.Element>): void;
-    writeWarning(element: ScribblerJsx.Element | Array<ScribblerJsx.Element>): void;
-}
-
-declare function summaryText({ duration, expectCount, fileCount, onlyMatch, pathMatch, skipMatch, targetCount, testCount, }: {
-    duration: number;
-    expectCount: ResultCount;
-    fileCount: ResultCount;
-    onlyMatch: string | undefined;
-    pathMatch: Array<string>;
-    skipMatch: string | undefined;
-    targetCount: ResultCount;
-    testCount: ResultCount;
-}): ScribblerJsx.Element;
-
-declare function testNameText(status: "fail" | "pass" | "skip" | "todo", name: string, indent?: number): ScribblerJsx.Element;
-
-declare function usesCompilerText(compilerVersion: string, projectConfigFilePath: string | undefined, options?: {
-    prependEmptyLine: boolean;
-}): ScribblerJsx.Element;
-
-declare function waitingForFileChangesText(): ScribblerJsx.Element;
-
-declare function watchUsageText(): ScribblerJsx.Element;
-
-declare class SelectDiagnosticText {
-    #private;
-    static noTestFilesWereLeft(resolvedConfig: ResolvedConfig): Array<string>;
-    static noTestFilesWereSelected(resolvedConfig: ResolvedConfig): Array<string>;
-}
-
-declare class SelectService {
-    #private;
-    constructor(resolvedConfig: ResolvedConfig);
-    isTestFile(filePath: string): boolean;
-    selectFiles(): Promise<Array<string>>;
-}
-
-declare enum CancellationReason {
-    ConfigChange = "configChange",
-    ConfigError = "configError",
-    FailFast = "failFast",
-    WatchClose = "watchClose"
-}
-
-declare class CancellationToken {
-    #private;
-    get isCancellationRequested(): boolean;
-    get reason(): CancellationReason | undefined;
-    cancel(reason: CancellationReason): void;
-    reset(): void;
-}
-
-declare class TSTyche {
-    #private;
-    static version: string;
-    constructor(resolvedConfig: ResolvedConfig, outputService: OutputService, selectService: SelectService, storeService: StoreService);
-    close(): void;
-    run(testFiles: Array<string | URL>, cancellationToken?: CancellationToken): Promise<void>;
-}
-
-declare class Cli {
-    #private;
-    run(commandLineArguments: Array<string>, cancellationToken?: CancellationToken): Promise<void>;
+interface EventHandler {
+    on: (event: Event) => void;
 }
-
 type Event = ["config:error", {
     diagnostics: Array<Diagnostic>;
-}] | ["deprecation:info", {
-    diagnostics: Array<Diagnostic>;
 }] | ["select:error", {
     diagnostics: Array<Diagnostic>;
+}] | ["deprecation:info", {
+    diagnostics: Array<Diagnostic>;
 }] | ["run:start", {
     result: Result;
 }] | ["run:end", {
@@ -601,15 +528,17 @@ type Event = ["config:error", {
     diagnostics: Array<Diagnostic>;
 }];
 
-interface EventHandler {
-    handleEvent: (event: Event) => void;
-}
 declare class EventEmitter {
     #private;
+    static instanceCount: number;
+    constructor();
     addHandler(handler: EventHandler): void;
+    addReporter(reporter: Reporter): void;
     static dispatch(event: Event): void;
     removeHandler(handler: EventHandler): void;
+    removeReporter(reporter: Reporter): void;
     removeHandlers(): void;
+    removeReporters(): void;
 }
 
 type ArgumentNode = ts.Expression | ts.TypeNode;
@@ -763,50 +692,146 @@ declare class ExpectService {
 declare class CancellationHandler implements EventHandler {
     #private;
     constructor(cancellationToken: CancellationToken, cancellationReason: CancellationReason);
-    handleEvent([, payload]: Event): void;
+    on([, payload]: Event): void;
 }
 
 declare class ExitCodeHandler implements EventHandler {
     #private;
-    handleEvent([eventName, payload]: Event): void;
+    on([event, payload]: Event): void;
     resetCode(): void;
 }
 
 declare class ResultHandler implements EventHandler {
     #private;
-    handleEvent([eventName, payload]: Event): void;
+    on([event, payload]: Event): void;
 }
 
-declare abstract class Reporter implements EventHandler {
-    protected outputService: OutputService;
-    constructor(outputService: OutputService);
-    abstract handleEvent([eventName, payload]: Event): void;
+interface Hooks {
+    /**
+     * Is called after configuration is resolved and allows to modify it.
+     */
+    config?: (resolvedConfig: ResolvedConfig) => ResolvedConfig | Promise<ResolvedConfig>;
+    /**
+     * Is called after test files are selected and allows to modify the list.
+     */
+    select?: (testFiles: Array<string>) => Array<string | URL> | Promise<Array<string | URL>>;
 }
 
-declare class RunReporter extends Reporter implements EventHandler {
+declare class HooksService {
     #private;
-    constructor(resolvedConfig: ResolvedConfig, outputService: OutputService);
-    handleEvent([eventName, payload]: Event): void;
+    static addHandler(hooks: Hooks): void;
+    static call(hook: "config", resolvedConfig: ResolvedConfig): Promise<ResolvedConfig>;
+    static call(hook: "select", testFiles: Array<string>): Promise<Array<string | URL>>;
+    static removeHandlers(): void;
 }
 
-declare class SetupReporter extends Reporter implements EventHandler {
-    handleEvent([eventName, payload]: Event): void;
+type InputHandler = (chunk: string) => void;
+declare class InputService {
+    #private;
+    constructor(onInput: InputHandler);
+    close(): void;
 }
 
-declare class SummaryReporter extends Reporter implements EventHandler {
-    handleEvent([eventName, payload]: Event): void;
+declare enum Color {
+    Reset = "0",
+    Red = "31",
+    Green = "32",
+    Yellow = "33",
+    Blue = "34",
+    Magenta = "35",
+    Cyan = "36",
+    Gray = "90"
 }
 
-declare class WatchReporter extends Reporter implements EventHandler {
-    handleEvent([eventName, payload]: Event): void;
+type ScribblerNode = Array<ScribblerNode> | ScribblerJsx.Element | string | number | undefined;
+type FunctionComponent = (props: Record<string, unknown>) => ScribblerJsx.Element;
+declare namespace ScribblerJsx {
+    interface Element {
+        props: Record<string, unknown>;
+        type: FunctionComponent | number | string;
+    }
+    interface ElementChildrenAttribute {
+        children: ScribblerNode;
+    }
+    interface IntrinsicElements {
+        ansi: {
+            escapes: Color | Array<Color>;
+        };
+        newLine: {};
+        text: {
+            children: Array<ScribblerNode>;
+            indent: number;
+        };
+    }
 }
 
-type InputHandler = (chunk: string) => void;
-declare class InputService {
+interface LineProps {
+    children?: ScribblerNode;
+    color?: Color;
+    indent?: number;
+}
+declare function Line({ children, color, indent }: LineProps): ScribblerJsx.Element;
+
+interface ScribblerOptions {
+    newLine?: string;
+    noColor?: boolean;
+}
+declare class Scribbler {
     #private;
-    constructor(onInput: InputHandler);
-    close(): void;
+    constructor(options?: ScribblerOptions);
+    render(element: ScribblerJsx.Element): string;
+}
+
+interface TextProps {
+    children?: ScribblerNode;
+    color?: Color | undefined;
+    indent?: number | undefined;
 }
+declare function Text({ children, color, indent }: TextProps): ScribblerJsx.Element;
+
+declare function addsPackageText(packageVersion: string, packagePath: string): ScribblerJsx.Element;
+
+declare function describeNameText(name: string, indent?: number): ScribblerJsx.Element;
+
+declare function diagnosticText(diagnostic: Diagnostic): ScribblerJsx.Element;
+
+declare function taskStatusText(status: TaskResultStatus, task: Task): ScribblerJsx.Element;
+
+declare function fileViewText(lines: Array<ScribblerJsx.Element>, addEmptyFinalLine: boolean): ScribblerJsx.Element;
+
+declare function formattedText(input: string | Array<string> | Record<string, unknown>): ScribblerJsx.Element;
+
+declare function helpText(options: Map<string, OptionDefinition>, version: string): ScribblerJsx.Element;
+
+declare class OutputService {
+    #private;
+    static clearTerminal(): void;
+    static eraseLastLine(): void;
+    static writeError(element: ScribblerJsx.Element | Array<ScribblerJsx.Element>): void;
+    static writeMessage(element: ScribblerJsx.Element | Array<ScribblerJsx.Element>): void;
+    static writeWarning(element: ScribblerJsx.Element | Array<ScribblerJsx.Element>): void;
+}
+
+declare function summaryText({ duration, expectCount, fileCount, onlyMatch, pathMatch, skipMatch, targetCount, testCount, }: {
+    duration: number;
+    expectCount: ResultCount;
+    fileCount: ResultCount;
+    onlyMatch: string | undefined;
+    pathMatch: Array<string>;
+    skipMatch: string | undefined;
+    targetCount: ResultCount;
+    testCount: ResultCount;
+}): ScribblerJsx.Element;
+
+declare function testNameText(status: "fail" | "pass" | "skip" | "todo", name: string, indent?: number): ScribblerJsx.Element;
+
+declare function usesCompilerText(compilerVersion: string, projectConfigFilePath: string | undefined, options?: {
+    prependEmptyLine: boolean;
+}): ScribblerJsx.Element;
+
+declare function waitingForFileChangesText(): ScribblerJsx.Element;
+
+declare function watchUsageText(): ScribblerJsx.Element;
 
 declare class Path {
     static normalizeSlashes: (filePath: string) => string;
@@ -827,9 +852,32 @@ declare class ProjectService {
 
 declare class Runner {
     #private;
-    constructor(resolvedConfig: ResolvedConfig, selectService: SelectService, storeService: StoreService);
-    close(): void;
-    run(tasks: Array<Task>, cancellationToken?: CancellationToken): Promise<void>;
+    static version: string;
+    constructor(resolvedConfig: ResolvedConfig);
+    run(testFiles: Array<string | URL | Task>, cancellationToken?: CancellationToken): Promise<void>;
+}
+
+declare class Select {
+    #private;
+    static isTestFile(filePath: string, resolvedConfig: ResolvedConfig): boolean;
+    static selectFiles(resolvedConfig: ResolvedConfig): Promise<Array<string>>;
+}
+
+declare class SelectDiagnosticText {
+    #private;
+    static noTestFilesWereLeft(resolvedConfig: ResolvedConfig): Array<string>;
+    static noTestFilesWereSelected(resolvedConfig: ResolvedConfig): Array<string>;
+}
+
+declare class Store {
+    #private;
+    static getSupportedTags(): Promise<Array<string> | undefined>;
+    static install(tag: string): Promise<void>;
+    static load(tag: string): Promise<typeof ts | undefined>;
+    static open(): Promise<void>;
+    static prune(): Promise<void>;
+    static update(): Promise<void>;
+    static validateTag(tag: string): Promise<boolean | undefined>;
 }
 
 declare class Version {
@@ -857,8 +905,8 @@ declare class FileWatcher extends Watcher {
 
 declare class WatchService {
     #private;
-    constructor(resolvedConfig: ResolvedConfig, selectService: SelectService, tasks: Array<Task>);
+    constructor(resolvedConfig: ResolvedConfig, tasks: Array<Task>);
     watch(cancellationToken: CancellationToken): AsyncIterable<Array<Task>>;
 }
 
-export { Assertion, CancellationHandler, CancellationReason, CancellationToken, Cli, CollectService, Color, type CommandLineOptions, ConfigDiagnosticText, type ConfigFileOptions, ConfigService, DescribeResult, Diagnostic, DiagnosticCategory, DiagnosticOrigin, type Event, EventEmitter, type EventHandler, ExitCodeHandler, ExpectResult, ExpectService, type FileWatchHandler, FileWatcher, type InputHandler, InputService, type ItemDefinition, Line, type MatchResult, OptionBrand, type OptionDefinition, OptionDefinitionsMap, OptionGroup, OutputService, Path, ProjectResult, ProjectService, type ResolvedConfig, Result, ResultCount, ResultHandler, ResultStatus, ResultTiming, RunReporter, Runner, Scribbler, ScribblerJsx, type ScribblerOptions, SelectDiagnosticText, SelectService, SetupReporter, SourceFile, StoreService, SummaryReporter, TSTyche, TargetResult, type TargetResultStatus, Task, TaskResult, type TaskResultStatus, TestMember, TestMemberBrand, TestMemberFlags, TestResult, TestTree, Text, type TypeChecker, Version, type WatchHandler, WatchReporter, WatchService, Watcher, type WatcherOptions, addsPackageText, defaultOptions, describeNameText, diagnosticText, environmentOptions, fileViewText, formattedText, helpText, summaryText, taskStatusText, testNameText, usesCompilerText, waitingForFileChangesText, watchUsageText };
+export { Assertion, BaseReporter, CancellationHandler, CancellationReason, CancellationToken, Cli, CollectService, Color, type CommandLineOptions, Config, ConfigDiagnosticText, type ConfigFileOptions, DescribeResult, Diagnostic, DiagnosticCategory, DiagnosticOrigin, type DiagnosticsHandler$1 as DiagnosticsHandler, type EnvironmentOptions, type Event, EventEmitter, type EventHandler, ExitCodeHandler, ExpectResult, ExpectService, type FileWatchHandler, FileWatcher, type Hooks, HooksService, type InputHandler, InputService, type ItemDefinition, Line, ListReporter, type MatchResult, OptionBrand, type OptionDefinition, OptionGroup, Options, OutputService, Path, ProjectResult, ProjectService, type Reporter, type ReporterEvent, type ResolvedConfig, Result, ResultCount, ResultHandler, ResultStatus, ResultTiming, Runner, Scribbler, ScribblerJsx, type ScribblerOptions, Select, SelectDiagnosticText, SetupReporter, SourceFile, Store, SummaryReporter, TargetResult, type TargetResultStatus, Task, TaskResult, type TaskResultStatus, TestMember, TestMemberBrand, TestMemberFlags, TestResult, TestTree, Text, type TypeChecker, Version, type WatchHandler, WatchReporter, WatchService, Watcher, type WatcherOptions, addsPackageText, defaultOptions, describeNameText, diagnosticText, environmentOptions, fileViewText, formattedText, helpText, summaryText, taskStatusText, testNameText, usesCompilerText, waitingForFileChangesText, watchUsageText };