tstyche 1.1.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 {
@@ -43,7 +53,6 @@ declare class StoreService {
     install(tag: string, cancellationToken?: CancellationToken): Promise<string | undefined>;
     load(tag: string, cancellationToken?: CancellationToken): Promise<typeof ts | undefined>;
     open(): Promise<void>;
-    prune: () => Promise<void>;
     resolveTag(tag: string): Promise<string | undefined>;
     update(): Promise<void>;
     validateTag(tag: string): Promise<boolean | undefined>;
@@ -53,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 {
@@ -74,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,6 +146,10 @@ interface CommandLineOptions {
      * Print the version number and exit.
      */
     version?: boolean;
+    /**
+     * Watch for changes and rerun related test files.
+     */
+    watch?: boolean;
 }
 
 /**
@@ -161,37 +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;
-    selectTestFiles(): Array<string>;
 }
 
-declare class TSTyche {
+declare class OptionDiagnosticText {
     #private;
-    readonly resolvedConfig: ResolvedConfig;
-    static readonly version = "1.1.0";
-    constructor(resolvedConfig: ResolvedConfig, storeService: StoreService);
-    run(testFiles: Array<string | URL>): Promise<void>;
+    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 Cli {
+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;
-    constructor();
-    run(commandLineArguments: Array<string>): Promise<void>;
+    constructor(options?: ScribblerOptions);
+    render(element: ScribblerJsx.Element): string;
+}
+
+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;
+    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 {
@@ -207,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;
@@ -255,30 +359,6 @@ declare class CollectService {
     createTestTree(sourceFile: ts.SourceFile, semanticDiagnostics?: Array<ts.Diagnostic>): TestTree;
 }
 
-declare class Environment {
-    #private;
-    /**
-     * 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;
@@ -331,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 {
@@ -352,36 +432,35 @@ 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 = ["start", {
+type Event = ["config:error", {
+    diagnostics: Array<Diagnostic>;
+}] | ["deprecation:info", {
+    diagnostics: Array<Diagnostic>;
+}] | ["select:error", {
+    diagnostics: Array<Diagnostic>;
+}] | ["run:start", {
     result: Result;
-}] | ["end", {
+}] | ["run:end", {
     result: Result;
-}] | ["config:error", {
-    diagnostics: Array<Diagnostic>;
 }] | ["store:info", {
     compilerVersion: string;
     installationPath: string;
@@ -432,13 +511,120 @@ type Event = ["start", {
     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 {
@@ -466,20 +652,26 @@ declare abstract class RelationMatcherBase {
     typeChecker: TypeChecker;
     abstract relation: Relation;
     abstract relationExplanationText: string;
+    relationExplanationVerb: string;
     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;
 }
 
-declare class ToBeAssignable extends RelationMatcherBase {
+declare class ToBe extends RelationMatcherBase {
+    relation: Relation;
+    relationExplanationText: string;
+}
+
+declare class ToBeAssignableTo extends RelationMatcherBase {
     relation: Relation;
     relationExplanationText: string;
-    match(sourceType: ts.Type, targetType: ts.Type, isNot: boolean): MatchResult;
 }
 
-declare class ToEqual extends RelationMatcherBase {
+declare class ToBeAssignableWith extends RelationMatcherBase {
     relation: Relation;
     relationExplanationText: string;
+    match(sourceType: ts.Type, targetType: ts.Type, isNot: boolean): MatchResult;
 }
 
 declare class ToHaveProperty {
@@ -493,6 +685,7 @@ declare class ToHaveProperty {
 declare class ToMatch extends RelationMatcherBase {
     relation: Relation;
     relationExplanationText: string;
+    relationExplanationVerb: string;
 }
 
 declare class ToRaiseError {
@@ -510,8 +703,11 @@ declare class Expect {
     #private;
     compiler: typeof ts;
     typeChecker: TypeChecker;
+    toBe: ToBe;
     toBeAny: PrimitiveTypeMatcher;
-    toBeAssignable: ToBeAssignable;
+    toBeAssignable: ToBeAssignableWith;
+    toBeAssignableTo: ToBeAssignableTo;
+    toBeAssignableWith: ToBeAssignableWith;
     toBeBigInt: PrimitiveTypeMatcher;
     toBeBoolean: PrimitiveTypeMatcher;
     toBeNever: PrimitiveTypeMatcher;
@@ -523,7 +719,7 @@ declare class Expect {
     toBeUniqueSymbol: PrimitiveTypeMatcher;
     toBeUnknown: PrimitiveTypeMatcher;
     toBeVoid: PrimitiveTypeMatcher;
-    toEqual: ToEqual;
+    toEqual: ToBe;
     toHaveProperty: ToHaveProperty;
     toMatch: ToMatch;
     toRaiseError: ToRaiseError;
@@ -532,80 +728,58 @@ declare class Expect {
     match(assertion: Assertion, expectResult: ExpectResult): MatchResult | undefined;
 }
 
-/**
- * A stream to output messages.
- */
-interface WriteStream {
-    /**
-     * @param log - Message to write to the stream.
-     */
-    write: (log: string) => void;
-}
-/**
- * Options to configure an instance of the {@link Logger}.
- */
-interface LoggerOptions {
-    /**
-     * Specifies whether color should be disabled in the output. Default: `Environment.noColor`.
-     */
-    noColor?: boolean;
-    /**
-     * A stream to write warnings and errors. Default: `process.stderr`.
-     */
-    stderr?: WriteStream;
-    /**
-     * A stream to write informational messages. Default: `process.stdout`.
-     */
-    stdout?: WriteStream;
-}
-/**
- * Wraps the provided streams with a set of convenience methods.
- */
-declare class Logger {
+declare class CancellationHandler implements EventHandler {
     #private;
-    /**
-     * @param options - {@link LoggerOptions | Options} to configure an instance of the Logger.
-     */
-    constructor(options?: LoggerOptions);
-    /**
-     * Moves the cursor one line up in the `stdout` stream and erases that line.
-     */
-    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(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 function fileStatusText(status: FileResultStatus, testFile: URL): JSX.Element;
-
-declare function fileViewText(lines: Array<JSX.Element>, addEmptyFinalLine: boolean): JSX.Element;
+declare class ExitCodeHandler implements EventHandler {
+    #private;
+    handleEvent([eventName, payload]: Event): void;
+    resetCode(): void;
+}
 
-declare function formattedText(input: string | Array<string> | Record<string, unknown>): JSX.Element;
+declare class RuntimeReporter implements EventHandler {
+    #private;
+    readonly resolvedConfig: ResolvedConfig;
+    constructor(resolvedConfig: ResolvedConfig, outputService: OutputService);
+    handleEvent([eventName, payload]: Event): void;
+}
 
-declare function helpText(optionDefinitions: Map<string, OptionDefinition>, tstycheVersion: string): JSX.Element;
+declare class SetupReporter implements EventHandler {
+    #private;
+    constructor(outputService: OutputService);
+    handleEvent([eventName, payload]: Event): 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 class SummaryReporter implements EventHandler {
+    #private;
+    constructor(outputService: OutputService);
+    handleEvent([eventName, payload]: Event): void;
+}
 
-declare function testNameText(status: "fail" | "pass" | "skip" | "todo", name: string, indent?: number): JSX.Element;
+declare class WatchReporter implements EventHandler {
+    #private;
+    constructor(outputService: OutputService);
+    handleEvent([eventName, payload]: Event): void;
+}
 
-declare function usesCompilerStepText(compilerVersion: string, tsconfigFilePath: string | undefined, options?: {
-    prependEmptyLine: boolean;
-}): JSX.Element;
+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 InputServiceOptions {
+    stdin?: ReadStream;
+}
+declare class InputService {
+    #private;
+    constructor(onInput: InputHandler, options?: InputServiceOptions);
+    close(): void;
+}
 
 declare class Path {
     static dirname(filePath: string): string;
@@ -625,133 +799,42 @@ declare class ProjectService {
     openFile(filePath: string, sourceText?: string | undefined, projectRootPath?: string | undefined): void;
 }
 
-declare abstract class Reporter {
-    readonly resolvedConfig: ResolvedConfig;
-    protected logger: Logger;
-    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 TaskRunner {
     #private;
     readonly resolvedConfig: ResolvedConfig;
-    constructor(resolvedConfig: ResolvedConfig, storeService: StoreService);
-    run(testFiles: Array<URL>, target: Array<string>, cancellationToken?: CancellationToken): Promise<Result>;
+    constructor(resolvedConfig: ResolvedConfig, selectService: SelectService, storeService: StoreService);
+    close(): void;
+    run(testFiles: Array<TestFile>, cancellationToken?: CancellationToken): Promise<void>;
 }
 
-declare enum Color {
-    Reset = "0",
-    Red = "31",
-    Green = "32",
-    Yellow = "33",
-    Blue = "34",
-    Magenta = "35",
-    Cyan = "36",
-    Gray = "90"
+declare class Version {
+    #private;
+    static isGreaterThan(source: string, target: string): boolean;
+    static isSatisfiedWith(source: string, target: string): boolean;
+    static isVersionTag(target: string): boolean;
 }
 
-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;
-            };
-        }
-    }
-}
-/**
- * Options to configure an instance of the {@link Scribbler}.
- */
-interface ScribblerOptions {
-    /**
-     * The end of line sequence to be used in the output. Default: `"\n"`.
-     */
-    newLine?: string;
-    /**
-     * Do not include ANSI color escape codes in the output. Default: `false`.
-     */
-    noColor?: boolean;
-}
-/**
- * Provides the JSX factory function and renderer.
- */
-declare class Scribbler {
+type WatchHandler = (filePath: string) => void | Promise<void>;
+declare class Watcher {
     #private;
-    /**
-     * @param options - {@link ScribblerOptions | Options} to configure an instance of the Scribbler.
-     */
-    constructor(options?: ScribblerOptions);
-    /**
-     * Creates a new text element of the given `type`.
-     */
-    static createElement(type: ComponentConstructor | string, props: Record<string, unknown> | null, ...children: Array<ElementChildren>): JSX.Element;
-    /**
-     * Renders the provided JSX `element` and returns the resulting string.
-     */
-    render(element: JSX.Element | null): string;
+    readonly targetPath: string;
+    constructor(targetPath: string, onChanged: WatchHandler, onRemoved?: WatchHandler, recursive?: boolean);
+    close(): void;
+    watch(): Promise<void>;
 }
 
-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;
+type FileWatchHandler = () => void | Promise<void>;
+declare class FileWatcher extends Watcher {
+    constructor(targetPath: string, onChanged: FileWatchHandler);
 }
 
-declare class Version {
+type RunCallback = (testFiles: Array<TestFile>) => Promise<void>;
+declare class WatchService {
     #private;
-    static isGreaterThan(source: string, target: string): boolean;
-    static isSatisfiedWith(source: string, target: string): boolean;
-    static isVersionTag(target: string): boolean;
+    readonly resolvedConfig: ResolvedConfig;
+    constructor(resolvedConfig: ResolvedConfig, runCallback: RunCallback, selectService: SelectService, testFiles: Array<TestFile>);
+    close(): void;
+    watch(cancellationToken?: CancellationToken): Promise<Array<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, type ItemDefinition, Line, Logger, type LoggerOptions, type MatchResult, OptionBrand, type OptionDefinition, OptionDefinitionsMap, OptionGroup, Path, ProjectResult, ProjectService, Reporter, type ResolvedConfig, Result, ResultCount, ResultManager, ResultStatus, ResultTiming, Scribbler, type ScribblerOptions, StoreService, SummaryReporter, TSTyche, TargetResult, type TargetResultStatus, TaskRunner, TestMember, TestMemberBrand, TestMemberFlags, TestResult, TestTree, Text, ThoroughReporter, type TypeChecker, Version, type WriteStream, addsPackageStepText, describeNameText, diagnosticText, fileStatusText, fileViewText, formattedText, helpText, summaryText, testNameText, usesCompilerStepText };
+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 };