tstyche 2.0.0-beta.0 → 2.0.0-beta.1

package/build/tstyche.d.ts

@@ -30,10 +30,20 @@ declare class Diagnostic {
     static warning(text: string | Array<string>, origin?: DiagnosticOrigin): Diagnostic;
 }
 
+declare enum CancellationReason {
+    ConfigChange = "configChange",
+    ConfigError = "configError",
+    FailFast = "failFast"
+}
+
+type CancellationRequestedHandler = (reason: CancellationReason) => void;
 declare class CancellationToken {
     #private;
     get isCancellationRequested(): boolean;
-    cancel(): void;
+    get reason(): CancellationReason | undefined;
+    cancel(reason: CancellationReason): void;
+    onCancellationRequested(handler: CancellationRequestedHandler): void;
+    reset(): void;
 }
 
 declare class StoreService {
@@ -52,7 +62,7 @@ declare enum OptionBrand {
     String = "string",
     Number = "number",
     Boolean = "boolean",
-    True = "true",// an option which does not take a value
+    BareTrue = "bareTrue",// a boolean option that does not take a value and when specified is interpreted as 'true'
     List = "list"
 }
 declare enum OptionGroup {
@@ -73,7 +83,7 @@ interface BaseOptionDefinition {
     name: string;
 }
 interface PrimitiveTypeOptionDefinition extends BaseOptionDefinition {
-    brand: OptionBrand.String | OptionBrand.Number | OptionBrand.Boolean | OptionBrand.True;
+    brand: OptionBrand.String | OptionBrand.Number | OptionBrand.Boolean | OptionBrand.BareTrue;
 }
 interface ListTypeOptionDefinition extends BaseOptionDefinition {
     brand: OptionBrand.List;
@@ -137,7 +147,7 @@ interface CommandLineOptions {
      */
     version?: boolean;
     /**
-     * Watch for changes and rerun related tests files.
+     * Watch for changes and rerun related test files.
      */
     watch?: boolean;
 }
@@ -164,45 +174,137 @@ interface ConfigFileOptions {
     testFileMatch?: Array<string>;
 }
 
-interface ResolvedConfig extends Omit<CommandLineOptions, keyof ConfigFileOptions>, Required<ConfigFileOptions> {
+interface ResolvedConfig extends Omit<CommandLineOptions, keyof ConfigFileOptions | "config">, Required<ConfigFileOptions> {
+    /**
+     * The path to a TSTyche configuration file.
+     */
+    configFilePath: string;
     /**
      * Only run test files with matching path.
      */
     pathMatch: Array<string>;
 }
+declare const defaultOptions: Required<ConfigFileOptions>;
 declare class ConfigService {
     #private;
     compiler: typeof ts;
     constructor(compiler: typeof ts, storeService: StoreService);
-    get commandLineOptions(): CommandLineOptions;
-    get configFileOptions(): ConfigFileOptions;
-    static get defaultOptions(): Required<ConfigFileOptions>;
     parseCommandLine(commandLineArgs: Array<string>): Promise<void>;
     readConfigFile(): Promise<void>;
     resolveConfig(): ResolvedConfig;
 }
 
-declare class SelectService {
+declare class OptionDiagnosticText {
     #private;
-    readonly resolvedConfig: ResolvedConfig;
-    constructor(resolvedConfig: ResolvedConfig);
-    isTestFile(filePath: string): boolean;
-    selectFiles(): Promise<Array<string>>;
+    static doubleQuotesExpected(): string;
+    static expectsListItemType(optionName: string, optionBrand: OptionBrand): string;
+    static expectsValue(optionName: string, optionGroup: OptionGroup): string;
+    static fileDoesNotExist(filePath: string): string;
+    static noTestFilesWereLeft(resolvedConfig: ResolvedConfig): Array<string>;
+    static noTestFilesWereSelected(resolvedConfig: ResolvedConfig): Array<string>;
+    static requiresValueType(optionName: string, optionBrand: OptionBrand, optionGroup: OptionGroup): string;
+    static unknownOption(optionName: string): string;
+    static versionIsNotSupported(value: string): string;
+    static watchCannotBeEnabledInCiEnvironment(): string;
+    static watchIsNotAvailable(): string;
 }
 
-declare class TSTyche {
+declare enum Color {
+    Reset = "0",
+    Red = "31",
+    Green = "32",
+    Yellow = "33",
+    Blue = "34",
+    Magenta = "35",
+    Cyan = "36",
+    Gray = "90"
+}
+
+type ElementChildren = Array<ElementChildren> | ScribblerJsx.Element | string | undefined;
+type ComponentConstructor = new (props: Record<string, unknown>) => ScribblerJsx.ElementClass;
+declare namespace ScribblerJsx {
+    interface Element {
+        props: Record<string, unknown>;
+        type: ComponentConstructor | string;
+    }
+    interface ElementAttributesProperty {
+        props: Record<string, unknown>;
+    }
+    interface ElementClass {
+        render: () => ScribblerJsx.Element;
+    }
+    interface ElementChildrenAttribute {
+        children: ElementChildren;
+    }
+    interface IntrinsicElements {
+        ansi: {
+            escapes: Color | Array<Color>;
+        };
+        newLine: {
+            [key: string]: never;
+        };
+        text: {
+            children: Array<ElementChildren>;
+            indent: number;
+        };
+    }
+}
+
+interface LineProps {
+    children?: ScribblerJsx.ElementChildrenAttribute["children"];
+    color?: Color;
+    indent?: number;
+}
+declare class Line implements ScribblerJsx.ElementClass {
+    readonly props: LineProps;
+    constructor(props: LineProps);
+    render(): ScribblerJsx.Element;
+}
+
+interface ScribblerOptions {
+    newLine?: string;
+    noColor?: boolean;
+}
+declare class Scribbler {
     #private;
-    readonly resolvedConfig: ResolvedConfig;
-    static readonly version = "2.0.0-beta.0";
-    constructor(resolvedConfig: ResolvedConfig, storeService: StoreService);
-    run(testFiles: Array<string | URL>): Promise<void>;
-    watch(testFiles: Array<string>, selectService: SelectService): Promise<void>;
+    constructor(options?: ScribblerOptions);
+    render(element: ScribblerJsx.Element): string;
 }
 
-declare class Cli {
+interface TextProps {
+    children?: ScribblerJsx.ElementChildrenAttribute["children"];
+    color?: Color | undefined;
+    indent?: number | undefined;
+}
+declare class Text implements ScribblerJsx.ElementClass {
+    readonly props: TextProps;
+    constructor(props: TextProps);
+    render(): ScribblerJsx.Element;
+}
+
+declare function addsPackageStepText(compilerVersion: string, installationPath: string): ScribblerJsx.Element;
+
+declare function describeNameText(name: string, indent?: number): ScribblerJsx.Element;
+
+declare function diagnosticText(diagnostic: Diagnostic): ScribblerJsx.Element;
+
+declare class TestFile {
     #private;
-    constructor();
-    run(commandLineArguments: Array<string>): Promise<void>;
+    path: string;
+    position?: number;
+    constructor(identifier: string | URL);
+    add(options: {
+        position?: number;
+    }): this;
+}
+
+declare class TestTree {
+    compiler: typeof ts;
+    diagnostics: Set<ts.Diagnostic>;
+    sourceFile: ts.SourceFile;
+    members: Array<TestMember | Assertion>;
+    constructor(compiler: typeof ts, diagnostics: Set<ts.Diagnostic>, sourceFile: ts.SourceFile);
+    get hasOnly(): boolean;
 }
 
 declare enum TestMemberBrand {
@@ -218,15 +320,6 @@ declare enum TestMemberFlags {
     Todo = 8
 }
 
-declare class TestTree {
-    compiler: typeof ts;
-    diagnostics: Set<ts.Diagnostic>;
-    sourceFile: ts.SourceFile;
-    members: Array<TestMember | Assertion>;
-    constructor(compiler: typeof ts, diagnostics: Set<ts.Diagnostic>, sourceFile: ts.SourceFile);
-    get hasOnly(): boolean;
-}
-
 declare class TestMember {
     brand: TestMemberBrand;
     node: ts.CallExpression;
@@ -266,34 +359,6 @@ declare class CollectService {
     createTestTree(sourceFile: ts.SourceFile, semanticDiagnostics?: Array<ts.Diagnostic>): TestTree;
 }
 
-declare class Environment {
-    #private;
-    /**
-     * Is `true` if the process is running in a continuous integration environment.
-     */
-    static get isCi(): boolean;
-    /**
-     * Specifies whether color should be disabled in the output.
-     */
-    static get noColor(): boolean;
-    /**
-     * Specifies whether interactive elements should be disabled in the output.
-     */
-    static get noInteractive(): boolean;
-    /**
-     * The directory where to store the 'typescript' packages.
-     */
-    static get storePath(): string;
-    /**
-     * The number of seconds to wait before giving up stale operations.
-     */
-    static get timeout(): number;
-    /**
-     * The path to the currently installed TypeScript module.
-     */
-    static get typescriptPath(): string | undefined;
-}
-
 declare class ResultTiming {
     end: number;
     start: number;
@@ -346,14 +411,14 @@ declare class DescribeResult {
 
 type FileResultStatus = ResultStatus.Runs | ResultStatus.Passed | ResultStatus.Failed;
 declare class FileResult {
-    testFile: URL;
+    testFile: TestFile;
     diagnostics: Array<Diagnostic>;
     expectCount: ResultCount;
     results: Array<DescribeResult | TestResult | ExpectResult>;
     status: FileResultStatus;
     testCount: ResultCount;
     timing: ResultTiming;
-    constructor(testFile: URL);
+    constructor(testFile: TestFile);
 }
 
 declare class ProjectResult {
@@ -367,36 +432,29 @@ declare class ProjectResult {
 type TargetResultStatus = ResultStatus.Runs | ResultStatus.Passed | ResultStatus.Failed;
 declare class TargetResult {
     versionTag: string;
-    testFiles: Array<URL>;
+    testFiles: Array<TestFile>;
     results: Map<string | undefined, ProjectResult>;
     status: TargetResultStatus;
     timing: ResultTiming;
-    constructor(versionTag: string, testFiles: Array<URL>);
+    constructor(versionTag: string, testFiles: Array<TestFile>);
 }
 
 declare class Result {
     resolvedConfig: ResolvedConfig;
-    testFiles: Array<URL>;
+    testFiles: Array<TestFile>;
     expectCount: ResultCount;
     fileCount: ResultCount;
     results: Array<TargetResult>;
     targetCount: ResultCount;
     testCount: ResultCount;
     timing: ResultTiming;
-    constructor(resolvedConfig: ResolvedConfig, testFiles: Array<URL>);
-}
-
-declare class ResultManager {
-    #private;
-    handleEvent([eventName, payload]: Event): void;
+    constructor(resolvedConfig: ResolvedConfig, testFiles: Array<TestFile>);
 }
 
 type Event = ["config:error", {
     diagnostics: Array<Diagnostic>;
 }] | ["deprecation:info", {
     diagnostics: Array<Diagnostic>;
-}] | ["input:info", {
-    key: string;
 }] | ["select:error", {
     diagnostics: Array<Diagnostic>;
 }] | ["run:start", {
@@ -453,13 +511,120 @@ type Event = ["config:error", {
     result: ExpectResult;
 }] | ["expect:skip", {
     result: ExpectResult;
+}] | ["watch:error", {
+    diagnostics: Array<Diagnostic>;
 }];
-type EventHandler = (event: Event) => void;
+interface EventHandler {
+    handleEvent: (event: Event) => void;
+}
 declare class EventEmitter {
     #private;
-    static addHandler(handler: EventHandler): void;
+    addHandler(handler: EventHandler): void;
     static dispatch(event: Event): void;
-    static removeHandler(handler: EventHandler): void;
+    removeHandler(handler: EventHandler): void;
+    removeHandlers(): void;
+}
+
+declare class ResultHandler {
+    #private;
+    handleEvent([eventName, payload]: Event): void;
+}
+
+declare function fileStatusText(status: FileResultStatus, testFile: TestFile): 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;
+
+interface WriteStream {
+    write: (log: string) => void;
+}
+interface OutputServiceOptions {
+    noColor?: boolean;
+    stderr?: WriteStream;
+    stdout?: WriteStream;
+}
+declare class OutputService {
+    #private;
+    constructor(options?: OutputServiceOptions);
+    clearTerminal(): void;
+    eraseLastLine(): void;
+    writeError(body: ScribblerJsx.Element | Array<ScribblerJsx.Element>): void;
+    writeMessage(body: ScribblerJsx.Element | Array<ScribblerJsx.Element>): void;
+    writeWarning(body: 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 usesCompilerStepText(compilerVersion: string, tsconfigFilePath: string | undefined, options?: {
+    prependEmptyLine: boolean;
+}): ScribblerJsx.Element;
+
+declare function waitingForFileChangesText(): ScribblerJsx.Element;
+
+declare function watchUsageText(): ScribblerJsx.Element;
+
+declare class SelectService {
+    #private;
+    readonly resolvedConfig: ResolvedConfig;
+    constructor(resolvedConfig: ResolvedConfig);
+    isTestFile(filePath: string): boolean;
+    selectFiles(): Promise<Array<string>>;
+}
+
+declare class TSTyche {
+    #private;
+    readonly resolvedConfig: ResolvedConfig;
+    static readonly version = "2.0.0-beta.1";
+    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>;
+}
+
+declare class Environment {
+    #private;
+    /**
+     * Is `true` if the process is running in a continuous integration environment.
+     */
+    static get isCi(): boolean;
+    /**
+     * Specifies whether color should be disabled in the output.
+     */
+    static get noColor(): boolean;
+    /**
+     * Specifies whether interactive elements should be disabled in the output.
+     */
+    static get noInteractive(): boolean;
+    /**
+     * The directory where to store the 'typescript' packages.
+     */
+    static get storePath(): string;
+    /**
+     * The number of seconds to wait before giving up stale operations.
+     */
+    static get timeout(): number;
+    /**
+     * The path to the currently installed TypeScript module.
+     */
+    static get typescriptPath(): string | undefined;
 }
 
 interface MatchResult {
@@ -563,72 +728,59 @@ declare class Expect {
     match(assertion: Assertion, expectResult: ExpectResult): MatchResult | undefined;
 }
 
-interface ReadStream {
-    on: (event: "data", listener: (chunk: string) => void) => this;
-    setEncoding: (encoding: "utf8") => this;
-    setRawMode?: (mode: boolean) => this;
-    unref: () => this;
-}
-interface InputServiceOptions {
-    stdin?: ReadStream;
-}
-declare class InputService {
+declare class CancellationHandler implements EventHandler {
     #private;
-    constructor(options?: InputServiceOptions);
-    dispose(): void;
+    constructor(cancellationToken: CancellationToken, cancellationReason: CancellationReason);
+    handleEvent([, payload]: Event): void;
 }
 
-declare function addsPackageStepText(compilerVersion: string, installationPath: string): JSX.Element;
-
-declare function describeNameText(name: string, indent?: number): JSX.Element;
-
-declare function diagnosticText(diagnostic: Diagnostic): JSX.Element;
+declare class ExitCodeHandler implements EventHandler {
+    #private;
+    handleEvent([eventName, payload]: Event): void;
+    resetCode(): void;
+}
 
-declare function fileStatusText(status: FileResultStatus, testFile: URL): JSX.Element;
+declare class RuntimeReporter implements EventHandler {
+    #private;
+    readonly resolvedConfig: ResolvedConfig;
+    constructor(resolvedConfig: ResolvedConfig, outputService: OutputService);
+    handleEvent([eventName, payload]: Event): void;
+}
 
-declare function fileViewText(lines: Array<JSX.Element>, addEmptyFinalLine: boolean): JSX.Element;
+declare class SetupReporter implements EventHandler {
+    #private;
+    constructor(outputService: OutputService);
+    handleEvent([eventName, payload]: Event): void;
+}
 
-declare function formattedText(input: string | Array<string> | Record<string, unknown>): JSX.Element;
+declare class SummaryReporter implements EventHandler {
+    #private;
+    constructor(outputService: OutputService);
+    handleEvent([eventName, payload]: Event): void;
+}
 
-declare function helpText(optionDefinitions: Map<string, OptionDefinition>, tstycheVersion: string): JSX.Element;
+declare class WatchReporter implements EventHandler {
+    #private;
+    constructor(outputService: OutputService);
+    handleEvent([eventName, payload]: Event): void;
+}
 
-interface WriteStream {
-    write: (log: string) => void;
+type InputHandler = (chunk: Buffer) => void;
+interface ReadStream {
+    addListener: (event: "data", handler: InputHandler) => this;
+    removeListener: (event: "data", handler: InputHandler) => this;
+    setRawMode?: (mode: boolean) => this;
+    unref: () => this;
 }
-interface OutputServiceOptions {
-    noColor?: boolean;
-    stderr?: WriteStream;
-    stdout?: WriteStream;
+interface InputServiceOptions {
+    stdin?: ReadStream;
 }
-declare class OutputService {
+declare class InputService {
     #private;
-    constructor(options?: OutputServiceOptions);
-    clearTerminal(): void;
-    eraseLastLine(): void;
-    writeError(body: JSX.Element | Array<JSX.Element>): void;
-    writeMessage(body: JSX.Element | Array<JSX.Element>): void;
-    writeWarning(body: JSX.Element | Array<JSX.Element>): void;
+    constructor(onInput: InputHandler, options?: InputServiceOptions);
+    close(): 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;
-}): JSX.Element;
-
-declare function testNameText(status: "fail" | "pass" | "skip" | "todo", name: string, indent?: number): JSX.Element;
-
-declare function usesCompilerStepText(compilerVersion: string, tsconfigFilePath: string | undefined, options?: {
-    prependEmptyLine: boolean;
-}): JSX.Element;
-
-declare function watchModeUsageText(): JSX.Element;
-
 declare class Path {
     static dirname(filePath: string): string;
     static join(...filePaths: Array<string>): string;
@@ -647,109 +799,12 @@ declare class ProjectService {
     openFile(filePath: string, sourceText?: string | undefined, projectRootPath?: string | undefined): void;
 }
 
-declare abstract class Reporter {
-    readonly resolvedConfig: ResolvedConfig;
-    protected outputService: OutputService;
-    constructor(resolvedConfig: ResolvedConfig);
-    abstract handleEvent([eventName, payload]: Event): void;
-}
-
-declare class SummaryReporter extends Reporter {
-    handleEvent([eventName, payload]: Event): void;
-}
-
-declare class ThoroughReporter extends Reporter {
-    #private;
-    handleEvent([eventName, payload]: Event): void;
-}
-
-declare class WatchModeReporter extends Reporter {
-    handleEvent([eventName]: Event): void;
-}
-
 declare class TaskRunner {
     #private;
     readonly resolvedConfig: ResolvedConfig;
-    constructor(resolvedConfig: ResolvedConfig, storeService: StoreService);
-    run(testFiles: Array<URL>, target: Array<string>, cancellationToken?: CancellationToken): Promise<Result>;
-}
-
-declare enum Color {
-    Reset = "0",
-    Red = "31",
-    Green = "32",
-    Yellow = "33",
-    Blue = "34",
-    Magenta = "35",
-    Cyan = "36",
-    Gray = "90"
-}
-
-interface LineProps {
-    children?: JSX.ElementChildrenAttribute["children"];
-    color?: Color;
-    indent?: number;
-}
-declare class Line implements JSX.ElementClass {
-    readonly props: LineProps;
-    constructor(props: LineProps);
-    render(): JSX.Element;
-}
-
-type ElementChildren = Array<ElementChildren> | JSX.Element | string | undefined;
-type ComponentConstructor = new (props: Record<string, unknown>) => JSX.ElementClass;
-declare global {
-    namespace JSX {
-        interface Element {
-            $$typeof: symbol;
-            children: ElementChildren;
-            props: Record<string, unknown> | null;
-            type: ComponentConstructor | string;
-        }
-        interface ElementAttributesProperty {
-            props: Record<string, unknown> | null;
-        }
-        interface ElementClass {
-            render: () => JSX.Element | null;
-        }
-        interface ElementChildrenAttribute {
-            children: ElementChildren;
-        }
-        interface IntrinsicElements {
-            ansi: {
-                children?: never;
-                escapes: Color | Array<Color>;
-            };
-            newLine: {
-                children?: never;
-            };
-            text: {
-                children: ElementChildren;
-                indent?: number | undefined;
-            };
-        }
-    }
-}
-interface ScribblerOptions {
-    newLine?: string;
-    noColor?: boolean;
-}
-declare class Scribbler {
-    #private;
-    constructor(options?: ScribblerOptions);
-    static createElement(type: ComponentConstructor | string, props: Record<string, unknown> | null, ...children: Array<ElementChildren>): JSX.Element;
-    render(element: JSX.Element | null): string;
-}
-
-interface TextProps {
-    children?: JSX.ElementChildrenAttribute["children"];
-    color?: Color | undefined;
-    indent?: number | undefined;
-}
-declare class Text implements JSX.ElementClass {
-    readonly props: TextProps;
-    constructor(props: TextProps);
-    render(): JSX.Element;
+    constructor(resolvedConfig: ResolvedConfig, selectService: SelectService, storeService: StoreService);
+    close(): void;
+    run(testFiles: Array<TestFile>, cancellationToken?: CancellationToken): Promise<void>;
 }
 
 declare class Version {
@@ -759,12 +814,27 @@ declare class Version {
     static isVersionTag(target: string): boolean;
 }
 
-type RunCallback = (testFiles: Array<string>) => Promise<void>;
+type WatchHandler = (filePath: string) => void | Promise<void>;
 declare class Watcher {
     #private;
-    readonly resolvedConfig: ResolvedConfig;
-    constructor(resolvedConfig: ResolvedConfig, runCallback: RunCallback, selectService: SelectService, testFiles: Array<string>);
+    readonly targetPath: string;
+    constructor(targetPath: string, onChanged: WatchHandler, onRemoved?: WatchHandler, recursive?: boolean);
+    close(): void;
     watch(): Promise<void>;
 }
 
-export { Assertion, CancellationToken, Cli, CollectService, Color, type CommandLineOptions, type ConfigFileOptions, ConfigService, DescribeResult, Diagnostic, DiagnosticCategory, type DiagnosticOrigin, Environment, type Event, EventEmitter, type EventHandler, Expect, ExpectResult, FileResult, type FileResultStatus, InputService, type InputServiceOptions, type ItemDefinition, Line, type MatchResult, OptionBrand, type OptionDefinition, OptionDefinitionsMap, OptionGroup, OutputService, type OutputServiceOptions, Path, ProjectResult, ProjectService, type ReadStream, Reporter, type ResolvedConfig, Result, ResultCount, ResultManager, ResultStatus, ResultTiming, Scribbler, type ScribblerOptions, SelectService, StoreService, SummaryReporter, TSTyche, TargetResult, type TargetResultStatus, TaskRunner, TestMember, TestMemberBrand, TestMemberFlags, TestResult, TestTree, Text, ThoroughReporter, type TypeChecker, Version, WatchModeReporter, Watcher, type WriteStream, addsPackageStepText, describeNameText, diagnosticText, fileStatusText, fileViewText, formattedText, helpText, summaryText, testNameText, usesCompilerStepText, watchModeUsageText };
+type FileWatchHandler = () => void | Promise<void>;
+declare class FileWatcher extends Watcher {
+    constructor(targetPath: string, onChanged: FileWatchHandler);
+}
+
+type RunCallback = (testFiles: Array<TestFile>) => Promise<void>;
+declare class WatchService {
+    #private;
+    readonly resolvedConfig: ResolvedConfig;
+    constructor(resolvedConfig: ResolvedConfig, runCallback: RunCallback, selectService: SelectService, testFiles: Array<TestFile>);
+    close(): void;
+    watch(cancellationToken?: CancellationToken): Promise<Array<void>>;
+}
+
+export { Assertion, CancellationHandler, CancellationReason, CancellationToken, Cli, CollectService, Color, type CommandLineOptions, type ConfigFileOptions, ConfigService, DescribeResult, Diagnostic, DiagnosticCategory, type DiagnosticOrigin, Environment, type Event, EventEmitter, type EventHandler, ExitCodeHandler, Expect, ExpectResult, FileResult, type FileResultStatus, type FileWatchHandler, FileWatcher, type InputHandler, InputService, type InputServiceOptions, type ItemDefinition, Line, type MatchResult, OptionBrand, type OptionDefinition, OptionDefinitionsMap, OptionDiagnosticText, OptionGroup, OutputService, type OutputServiceOptions, Path, ProjectResult, ProjectService, type ReadStream, type ResolvedConfig, Result, ResultCount, ResultHandler, ResultStatus, ResultTiming, type RunCallback, RuntimeReporter, Scribbler, ScribblerJsx, type ScribblerOptions, SelectService, SetupReporter, StoreService, SummaryReporter, TSTyche, TargetResult, type TargetResultStatus, TaskRunner, TestFile, TestMember, TestMemberBrand, TestMemberFlags, TestResult, TestTree, Text, type TypeChecker, Version, type WatchHandler, WatchReporter, WatchService, Watcher, type WriteStream, addsPackageStepText, defaultOptions, describeNameText, diagnosticText, fileStatusText, fileViewText, formattedText, helpText, summaryText, testNameText, usesCompilerStepText, waitingForFileChangesText, watchUsageText };