tstyche 2.0.0-beta.0 → 2.0.0-rc.0

package/build/tstyche.d.ts

@@ -1,23 +1,27 @@
 import type ts from 'typescript';
 
+declare class DiagnosticOrigin {
+    breadcrumbs: Array<string> | undefined;
+    end: number;
+    sourceFile: ts.SourceFile;
+    start: number;
+    constructor(start: number, end: number, sourceFile: ts.SourceFile, breadcrumbs?: Array<string>);
+    static fromJsonNode(node: ts.Node, sourceFile: ts.SourceFile, skipTrivia: (position: number, sourceFile: ts.SourceFile) => number): DiagnosticOrigin;
+    static fromNode(node: ts.Node, breadcrumbs?: Array<string>): DiagnosticOrigin;
+}
+
 declare enum DiagnosticCategory {
     Error = "error",
     Warning = "warning"
 }
 
-interface DiagnosticOrigin {
-    breadcrumbs?: Array<string>;
-    end: number;
-    file: ts.SourceFile;
-    start: number;
-}
 declare class Diagnostic {
-    text: string | Array<string>;
     category: DiagnosticCategory;
-    origin?: DiagnosticOrigin | undefined;
-    code?: string;
-    related?: Array<Diagnostic>;
-    constructor(text: string | Array<string>, category: DiagnosticCategory, origin?: DiagnosticOrigin | undefined);
+    code: string | undefined;
+    related: Array<Diagnostic> | undefined;
+    origin: DiagnosticOrigin | undefined;
+    text: string | Array<string>;
+    constructor(text: string | Array<string>, category: DiagnosticCategory, origin?: DiagnosticOrigin);
     add(options: {
         code?: string;
         origin?: DiagnosticOrigin;
@@ -30,10 +34,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 +66,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 +87,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 +151,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 +178,133 @@ 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 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 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 {
+    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 {
+    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 | undefined;
+    constructor(identifier: string | URL, position?: number);
+}
+
+declare class TestTree {
+    diagnostics: Set<ts.Diagnostic>;
+    members: Array<TestMember | Assertion>;
+    sourceFile: ts.SourceFile;
+    constructor(diagnostics: Set<ts.Diagnostic>, sourceFile: ts.SourceFile);
+    get hasOnly(): boolean;
 }
 
 declare enum TestMemberBrand {
@@ -218,25 +320,15 @@ 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;
-    parent: TestTree | TestMember;
-    flags: TestMemberFlags;
-    compiler: typeof ts;
     diagnostics: Set<ts.Diagnostic>;
+    flags: TestMemberFlags;
     members: Array<TestMember | Assertion>;
     name: string;
-    constructor(brand: TestMemberBrand, node: ts.CallExpression, parent: TestTree | TestMember, flags: TestMemberFlags);
+    node: ts.CallExpression;
+    parent: TestTree | TestMember;
+    constructor(compiler: typeof ts, brand: TestMemberBrand, node: ts.CallExpression, parent: TestTree | TestMember, flags: TestMemberFlags);
     get ancestorNames(): Array<string>;
     validate(): Array<Diagnostic>;
 }
@@ -245,11 +337,11 @@ interface MatcherNode extends ts.CallExpression {
     expression: ts.PropertyAccessExpression;
 }
 declare class Assertion extends TestMember {
+    isNot: boolean;
     matcherNode: MatcherNode;
     modifierNode: ts.PropertyAccessExpression;
     notNode: ts.PropertyAccessExpression | undefined;
-    isNot: boolean;
-    constructor(brand: TestMemberBrand, node: ts.CallExpression, parent: TestTree | TestMember, flags: TestMemberFlags, matcherNode: MatcherNode, modifierNode: ts.PropertyAccessExpression, notNode: ts.PropertyAccessExpression | undefined);
+    constructor(compiler: typeof ts, brand: TestMemberBrand, node: ts.CallExpression, parent: TestTree | TestMember, flags: TestMemberFlags, matcherNode: MatcherNode, modifierNode: ts.PropertyAccessExpression, notNode?: ts.PropertyAccessExpression);
     get ancestorNames(): Array<string>;
     get matcherName(): ts.MemberName;
     get source(): ts.NodeArray<ts.Expression> | ts.NodeArray<ts.TypeNode>;
@@ -258,42 +350,10 @@ declare class Assertion extends TestMember {
 
 declare class CollectService {
     #private;
-    compiler: typeof ts;
-    readonly matcherIdentifiers: string[];
-    readonly modifierIdentifiers: string[];
-    readonly notIdentifier = "not";
     constructor(compiler: typeof ts);
     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;
@@ -310,11 +370,11 @@ declare enum ResultStatus {
 
 declare class ExpectResult {
     assertion: Assertion;
-    parent: TestResult | undefined;
     diagnostics: Array<Diagnostic>;
+    parent: TestResult | undefined;
     status: ResultStatus;
     timing: ResultTiming;
-    constructor(assertion: Assertion, parent: TestResult | undefined);
+    constructor(assertion: Assertion, parent?: TestResult);
 }
 
 declare class ResultCount {
@@ -326,14 +386,14 @@ declare class ResultCount {
 }
 
 declare class TestResult {
-    test: TestMember;
-    parent: DescribeResult | undefined;
     diagnostics: Array<Diagnostic>;
     expectCount: ResultCount;
+    parent: DescribeResult | undefined;
     results: Array<ExpectResult>;
     status: ResultStatus;
+    test: TestMember;
     timing: ResultTiming;
-    constructor(test: TestMember, parent: DescribeResult | undefined);
+    constructor(test: TestMember, parent?: DescribeResult);
 }
 
 declare class DescribeResult {
@@ -341,62 +401,55 @@ declare class DescribeResult {
     parent: DescribeResult | undefined;
     results: Array<DescribeResult | TestResult>;
     timing: ResultTiming;
-    constructor(describe: TestMember, parent: DescribeResult | undefined);
+    constructor(describe: TestMember, parent?: DescribeResult);
 }
 
 type FileResultStatus = ResultStatus.Runs | ResultStatus.Passed | ResultStatus.Failed;
 declare class FileResult {
-    testFile: URL;
     diagnostics: Array<Diagnostic>;
     expectCount: ResultCount;
     results: Array<DescribeResult | TestResult | ExpectResult>;
     status: FileResultStatus;
     testCount: ResultCount;
+    testFile: TestFile;
     timing: ResultTiming;
-    constructor(testFile: URL);
+    constructor(testFile: TestFile);
 }
 
 declare class ProjectResult {
     compilerVersion: string;
-    projectConfigFilePath: string | undefined;
     diagnostics: Array<Diagnostic>;
+    projectConfigFilePath: string | undefined;
     results: Array<FileResult>;
     constructor(compilerVersion: string, projectConfigFilePath: string | undefined);
 }
 
 type TargetResultStatus = ResultStatus.Runs | ResultStatus.Passed | ResultStatus.Failed;
 declare class TargetResult {
-    versionTag: string;
-    testFiles: Array<URL>;
     results: Map<string | undefined, ProjectResult>;
     status: TargetResultStatus;
+    testFiles: Array<TestFile>;
     timing: ResultTiming;
-    constructor(versionTag: string, testFiles: Array<URL>);
+    versionTag: string;
+    constructor(versionTag: string, testFiles: Array<TestFile>);
 }
 
 declare class Result {
-    resolvedConfig: ResolvedConfig;
-    testFiles: Array<URL>;
     expectCount: ResultCount;
     fileCount: ResultCount;
+    resolvedConfig: ResolvedConfig;
     results: Array<TargetResult>;
     targetCount: ResultCount;
     testCount: ResultCount;
+    testFiles: Array<TestFile>;
     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 +506,118 @@ 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;
+    constructor(resolvedConfig: ResolvedConfig);
+    isTestFile(filePath: string): boolean;
+    selectFiles(): Promise<Array<string>>;
+}
+
+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>;
+}
+
+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 {
@@ -484,10 +642,10 @@ declare class PrimitiveTypeMatcher {
 }
 
 declare abstract class RelationMatcherBase {
-    typeChecker: TypeChecker;
     abstract relation: Relation;
     abstract relationExplanationText: string;
     relationExplanationVerb: string;
+    typeChecker: TypeChecker;
     constructor(typeChecker: TypeChecker);
     protected explain(sourceType: ts.Type, targetType: ts.Type, isNot: boolean): Array<Diagnostic>;
     match(sourceType: ts.Type, targetType: ts.Type, isNot: boolean): MatchResult;
@@ -536,8 +694,6 @@ declare class ToRaiseError {
 
 declare class Expect {
     #private;
-    compiler: typeof ts;
-    typeChecker: TypeChecker;
     toBe: ToBe;
     toBeAny: PrimitiveTypeMatcher;
     toBeAssignable: ToBeAssignableWith;
@@ -563,83 +719,68 @@ 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;
+    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 normalizeSlashes: (filePath: string) => string;
     static dirname(filePath: string): string;
     static join(...filePaths: Array<string>): string;
-    static normalizeSlashes(filePath: string): string;
     static relative(from: string, to: string): string;
     static resolve(...filePaths: Array<string>): string;
 }
 
 declare class ProjectService {
     #private;
-    compiler: typeof ts;
     constructor(compiler: typeof ts);
     closeFile(filePath: string): void;
     getDefaultProject(filePath: string): ts.server.Project | undefined;
@@ -647,109 +788,11 @@ 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 +802,28 @@ declare class Version {
     static isVersionTag(target: string): boolean;
 }
 
-type RunCallback = (testFiles: Array<string>) => Promise<void>;
+type WatchHandler = (filePath: string) => void | Promise<void>;
+interface WatcherOptions {
+    recursive?: boolean;
+}
 declare class Watcher {
     #private;
-    readonly resolvedConfig: ResolvedConfig;
-    constructor(resolvedConfig: ResolvedConfig, runCallback: RunCallback, selectService: SelectService, testFiles: Array<string>);
+    constructor(targetPath: string, onChanged: WatchHandler, onRemoved?: WatchHandler, options?: WatcherOptions);
+    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;
+    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, 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 WatcherOptions, type WriteStream, addsPackageStepText, defaultOptions, describeNameText, diagnosticText, fileStatusText, fileViewText, formattedText, helpText, summaryText, testNameText, usesCompilerStepText, waitingForFileChangesText, watchUsageText };