tstyche 4.3.0 → 5.0.0-beta.1

package/build/tstyche.d.ts

@@ -20,6 +20,119 @@ declare class Cli {
     run(commandLine: Array<string>, cancellationToken?: CancellationToken): Promise<void>;
 }
 
+declare enum DiagnosticCategory {
+    Error = "error",
+    Warning = "warning"
+}
+
+interface SuppressedError {
+    directive: TextRange;
+    ignore: boolean;
+    argument?: TextRange;
+    diagnostics: Array<ts.Diagnostic>;
+}
+
+declare enum TestTreeNodeBrand {
+    Describe = "describe",
+    Test = "test",
+    Expect = "expect",
+    When = "when"
+}
+
+declare enum TestTreeNodeFlags {
+    None = 0,
+    Only = 1,
+    Skip = 2,
+    Todo = 4
+}
+
+declare class WhenNode extends TestTreeNode {
+    actionNode: ts.CallExpression;
+    actionNameNode: ts.PropertyAccessExpression;
+    abilityDiagnostics: Set<ts.Diagnostic>;
+    target: ts.NodeArray<ts.Expression> | ts.NodeArray<ts.TypeNode>;
+    constructor(compiler: typeof ts, brand: TestTreeNodeBrand, node: ts.CallExpression, parent: TestTree | TestTreeNode, flags: TestTreeNodeFlags, actionNode: ts.CallExpression, actionNameNode: ts.PropertyAccessExpression);
+}
+
+declare class TestTreeNode {
+    brand: TestTreeNodeBrand;
+    children: Array<TestTreeNode | ExpectNode | WhenNode>;
+    diagnostics: Set<ts.Diagnostic>;
+    flags: TestTreeNodeFlags;
+    name: string;
+    node: ts.CallExpression;
+    parent: TestTree | TestTreeNode;
+    constructor(compiler: typeof ts, brand: TestTreeNodeBrand, node: ts.CallExpression, parent: TestTree | TestTreeNode, flags: TestTreeNodeFlags);
+}
+
+declare class ExpectNode extends TestTreeNode {
+    abilityDiagnostics: Set<ts.Diagnostic>;
+    isNot: boolean;
+    matcherNode: ts.CallExpression | ts.Decorator;
+    matcherNameNode: ts.PropertyAccessExpression;
+    modifierNode: ts.PropertyAccessExpression;
+    notNode: ts.PropertyAccessExpression | undefined;
+    source: ts.NodeArray<ts.Expression> | ts.NodeArray<ts.TypeNode>;
+    target: ts.NodeArray<ts.Expression> | ts.NodeArray<ts.TypeNode> | undefined;
+    constructor(compiler: typeof ts, brand: TestTreeNodeBrand, node: ts.CallExpression, parent: TestTree | TestTreeNode, flags: TestTreeNodeFlags, matcherNode: ts.CallExpression | ts.Decorator, matcherNameNode: ts.PropertyAccessExpression, modifierNode: ts.PropertyAccessExpression, notNode: ts.PropertyAccessExpression | undefined);
+}
+
+declare class TestTree {
+    children: Array<TestTreeNode | ExpectNode | WhenNode>;
+    diagnostics: Set<ts.Diagnostic>;
+    hasOnly: boolean;
+    sourceFile: ts.SourceFile;
+    suppressedErrors: Array<SuppressedError> | undefined;
+    constructor(diagnostics: Set<ts.Diagnostic>, sourceFile: ts.SourceFile);
+}
+
+declare class DiagnosticOrigin {
+    assertionNode: ExpectNode | undefined;
+    end: number;
+    sourceFile: ts.SourceFile | JsonSourceFile;
+    start: number;
+    constructor(start: number, end: number, sourceFile: ts.SourceFile | JsonSourceFile, assertionNode?: ExpectNode);
+    static fromAssertion(assertionNode: ExpectNode): DiagnosticOrigin;
+    static fromNode(node: ts.Node, assertionNode?: ExpectNode): DiagnosticOrigin;
+    static fromNodes(nodes: ts.NodeArray<ts.Node>, assertionNode?: ExpectNode): DiagnosticOrigin;
+}
+
+declare class Diagnostic {
+    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>): Array<Diagnostic>;
+    static warning(text: string | Array<string>, origin?: DiagnosticOrigin): Diagnostic;
+}
+
+declare function diagnosticBelongsToNode(diagnostic: ts.Diagnostic, node: ts.NodeArray<ts.Node> | ts.Node): boolean;
+declare function getDiagnosticMessageText(diagnostic: ts.Diagnostic): string | Array<string>;
+declare function getTextSpanEnd(span: ts.TextSpan): number;
+declare function isDiagnosticWithLocation(diagnostic: ts.Diagnostic): diagnostic is ts.DiagnosticWithLocation;
+
+type DiagnosticsHandler<T extends Diagnostic | Array<Diagnostic> = Diagnostic> = (this: void, diagnostics: T) => void;
+
+declare class JsonSourceFile {
+    #private;
+    fileName: string;
+    text: string;
+    constructor(fileName: string, text: string);
+    getLineStarts(): Array<number>;
+    getLineAndCharacterOfPosition(position: number): {
+        line: number;
+        character: number;
+    };
+}
+
 interface CommandLineOptions {
     config?: string;
     failFast?: boolean;
@@ -40,7 +153,7 @@ interface CommandLineOptions {
     watch?: boolean;
 }
 interface ConfigFileOptions {
-    checkSourceFiles?: boolean;
+    checkDeclarationFiles?: boolean;
     checkSuppressedErrors?: boolean;
     failFast?: boolean;
     fixtureFileMatch?: Array<string>;
@@ -53,7 +166,9 @@ interface ConfigFileOptions {
     testFileMatch?: Array<string>;
     tsconfig?: string;
 }
+
 interface InlineConfig {
+    fixme?: boolean;
     if?: {
         target?: Array<string>;
     };
@@ -63,6 +178,17 @@ interface ResolvedConfig extends Omit<CommandLineOptions, "config" | keyof Confi
     configFilePath: string;
     pathMatch: Array<string>;
 }
+interface TextRange {
+    start: number;
+    end: number;
+    text: string;
+}
+interface DirectiveRange {
+    sourceFile: ts.SourceFile;
+    namespace: TextRange;
+    directive?: TextRange;
+    argument?: TextRange;
+}
 
 declare class Config {
     #private;
@@ -85,9 +211,10 @@ declare class Config {
 
 declare enum OptionBrand {
     String = "string",
+    SemverRange = "range",
     Number = "number",
     Boolean = "boolean",
-    BareTrue = "bareTrue",
+    True = "true",
     List = "list"
 }
 
@@ -99,34 +226,22 @@ declare class ConfigDiagnosticText {
     static fileMatchPatternCannotStartWith(optionName: string, segment: string): Array<string>;
     static inspectSupportedVersions(): string;
     static moduleWasNotFound(specifier: string): string;
+    static optionValueMustBe(optionName: string, optionBrand: OptionBrand): string;
     static rangeIsNotValid(value: string): string;
+    static rangeDoesNotMatchSupported(value: string): string;
     static rangeUsage(): Array<string>;
-    static requiresValueType(optionName: string, optionBrand: OptionBrand): string;
     static seen(element: string): string;
     static unexpected(element: string): string;
     static unknownOption(optionName: string): string;
-    static usage(optionName: string, optionBrand: OptionBrand): Array<string>;
     static versionIsNotSupported(value: string): string;
     static watchCannotBeEnabled(): string;
 }
 
-interface TextRange {
-    start: number;
-    end: number;
-    text: string;
-}
-interface DirectiveRange {
-    namespace: TextRange;
-    directive?: TextRange;
-    argument?: TextRange;
-}
-type DirectiveRanges = Array<DirectiveRange> & {
-    sourceFile: ts.SourceFile;
-};
 declare class Directive {
     #private;
-    static getDirectiveRanges(compiler: typeof ts, sourceFile: ts.SourceFile, position?: number): DirectiveRanges | undefined;
-    static getInlineConfig(ranges: DirectiveRanges | undefined): Promise<InlineConfig | undefined>;
+    static getDirectiveRange(compiler: typeof ts, owner: TestTreeNode, directiveText: string): DirectiveRange | undefined;
+    static getDirectiveRanges(compiler: typeof ts, node: ts.Node): Array<DirectiveRange> | undefined;
+    static getInlineConfig(ranges: Array<DirectiveRange> | DirectiveRange | undefined): Promise<InlineConfig | undefined>;
 }
 
 declare const defaultOptions: Required<ConfigFileOptions>;
@@ -138,58 +253,6 @@ declare enum OptionGroup {
     ResolvedConfig = 6
 }
 
-declare enum DiagnosticCategory {
-    Error = "error",
-    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: AssertionNode | undefined;
-    end: number;
-    sourceFile: SourceFile | ts.SourceFile;
-    start: number;
-    constructor(start: number, end: number, sourceFile: SourceFile | ts.SourceFile, assertion?: AssertionNode);
-    static fromAssertion(assertion: AssertionNode): DiagnosticOrigin;
-    static fromNode(node: ts.Node, assertion?: AssertionNode): DiagnosticOrigin;
-    static fromNodes(nodes: ts.NodeArray<ts.Node>, assertion?: AssertionNode): DiagnosticOrigin;
-}
-
-declare class Diagnostic {
-    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>, sourceFile?: ts.SourceFile): Array<Diagnostic>;
-    static warning(text: string | Array<string>, origin?: DiagnosticOrigin): Diagnostic;
-}
-
-declare function diagnosticBelongsToNode(diagnostic: ts.Diagnostic, node: ts.NodeArray<ts.Node> | ts.Node): boolean;
-declare function getDiagnosticMessageText(diagnostic: ts.Diagnostic): string | Array<string>;
-declare function getTextSpanEnd(span: ts.TextSpan): number;
-declare function isDiagnosticWithLocation(diagnostic: ts.Diagnostic): diagnostic is ts.DiagnosticWithLocation;
-
-type DiagnosticsHandler<T extends Diagnostic | Array<Diagnostic> = Diagnostic> = (this: void, diagnostics: T) => void;
-
 interface BaseOptionDefinition {
     brand: OptionBrand;
     description: string;
@@ -197,7 +260,7 @@ interface BaseOptionDefinition {
     name: string;
 }
 interface PrimitiveTypeOptionDefinition extends BaseOptionDefinition {
-    brand: OptionBrand.String | OptionBrand.Number | OptionBrand.Boolean | OptionBrand.BareTrue;
+    brand: OptionBrand.String | OptionBrand.SemverRange | OptionBrand.Number | OptionBrand.Boolean | OptionBrand.True;
 }
 interface ItemDefinition {
     brand: OptionBrand.String;
@@ -212,97 +275,9 @@ declare class Options {
     #private;
     static for(optionGroup: OptionGroup): Map<string, OptionDefinition>;
     static resolve(optionName: string, optionValue: string, rootPath?: string): string;
-    static validate(optionName: string, optionValue: string, optionBrand: OptionBrand, onDiagnostics: DiagnosticsHandler, origin?: DiagnosticOrigin): Promise<void>;
-}
-
-declare enum TestTreeNodeBrand {
-    Describe = "describe",
-    Test = "test",
-    Expect = "expect",
-    When = "when"
-}
-
-declare enum TestTreeNodeFlags {
-    None = 0,
-    Fail = 1,
-    Only = 2,
-    Skip = 4,
-    Todo = 8
-}
-
-declare class WhenNode extends TestTreeNode {
-    actionNode: ts.CallExpression;
-    actionNameNode: ts.PropertyAccessExpression;
-    abilityDiagnostics: Set<ts.Diagnostic>;
-    target: ts.NodeArray<ts.Expression> | ts.NodeArray<ts.TypeNode>;
-    constructor(compiler: typeof ts, brand: TestTreeNodeBrand, node: ts.CallExpression, parent: TestTree | TestTreeNode, flags: TestTreeNodeFlags, actionNode: ts.CallExpression, actionNameNode: ts.PropertyAccessExpression);
-}
-
-declare class TestTreeNode {
-    brand: TestTreeNodeBrand;
-    children: Array<TestTreeNode | AssertionNode | WhenNode>;
-    diagnostics: Set<ts.Diagnostic>;
-    flags: TestTreeNodeFlags;
-    name: string;
-    node: ts.CallExpression;
-    parent: TestTree | TestTreeNode;
-    constructor(compiler: typeof ts, brand: TestTreeNodeBrand, node: ts.CallExpression, parent: TestTree | TestTreeNode, flags: TestTreeNodeFlags);
-    getDirectiveRanges(compiler: typeof ts): DirectiveRanges | undefined;
-}
-
-interface SuppressedError {
-    directive: TextRange;
-    ignore: boolean;
-    argument?: TextRange;
-    diagnostics: Array<ts.Diagnostic>;
-}
-type SuppressedErrors = Array<SuppressedError> & {
-    sourceFile: ts.SourceFile;
-};
-
-declare class TestTree {
-    children: Array<TestTreeNode | AssertionNode | WhenNode>;
-    diagnostics: Set<ts.Diagnostic>;
-    hasOnly: boolean;
-    sourceFile: ts.SourceFile;
-    suppressedErrors: SuppressedErrors | undefined;
-    constructor(diagnostics: Set<ts.Diagnostic>, sourceFile: ts.SourceFile);
-    getDirectiveRanges(compiler: typeof ts): DirectiveRanges | undefined;
-}
-
-declare class AssertionNode extends TestTreeNode {
-    abilityDiagnostics: Set<ts.Diagnostic>;
-    isNot: boolean;
-    matcherNode: ts.CallExpression | ts.Decorator;
-    matcherNameNode: ts.PropertyAccessExpression;
-    modifierNode: ts.PropertyAccessExpression;
-    notNode: ts.PropertyAccessExpression | undefined;
-    source: ts.NodeArray<ts.Expression> | ts.NodeArray<ts.TypeNode>;
-    target: ts.NodeArray<ts.Expression> | ts.NodeArray<ts.TypeNode> | undefined;
-    constructor(compiler: typeof ts, brand: TestTreeNodeBrand, node: ts.CallExpression, parent: TestTree | TestTreeNode, flags: TestTreeNodeFlags, matcherNode: ts.CallExpression | ts.Decorator, matcherNameNode: ts.PropertyAccessExpression, modifierNode: ts.PropertyAccessExpression, notNode: ts.PropertyAccessExpression | undefined);
-}
-
-declare class ProjectService {
-    #private;
-    constructor(compiler: typeof ts, resolvedConfig: ResolvedConfig);
-    closeFile(filePath: string): void;
-    getDefaultProject(filePath: string): ts.server.Project | undefined;
-    getLanguageService(filePath: string): ts.LanguageService | undefined;
-    openFile(filePath: string, sourceText?: string | undefined, projectRootPath?: string | undefined): void;
+    static validate(optionName: string, optionValue: string, onDiagnostics: DiagnosticsHandler, origin?: DiagnosticOrigin): Promise<void>;
 }
 
-declare class CollectService {
-    #private;
-    constructor(compiler: typeof ts, projectService: ProjectService, resolvedConfig: ResolvedConfig);
-    createTestTree(sourceFile: ts.SourceFile, semanticDiagnostics?: Array<ts.Diagnostic>): TestTree;
-}
-
-declare function nodeBelongsToArgumentList(compiler: typeof ts, node: ts.Node): boolean;
-
-declare function argumentIsProvided<T>(argumentNameText: string, node: T, enclosingNode: ts.Node, onDiagnostics: DiagnosticsHandler<Array<Diagnostic>>): node is NonNullable<T>;
-
-declare function argumentOrTypeArgumentIsProvided<T>(argumentNameText: string, typeArgumentNameText: string, node: T, enclosingNode: ts.Node, onDiagnostics: DiagnosticsHandler<Array<Diagnostic>>): node is NonNullable<T>;
-
 interface EnvironmentOptions {
     isCi: boolean;
     noColor: boolean;
@@ -343,40 +318,53 @@ declare class WatchReporter extends BaseReporter {
     on([event, payload]: ReporterEvent): void;
 }
 
-declare class ResultTiming {
-    end: number;
-    start: number;
-    get duration(): number;
-}
-
 declare enum ResultStatus {
     Runs = "runs",
     Passed = "passed",
+    Matched = "matched",
     Failed = "failed",
+    Fixme = "fixme",
     Skipped = "skipped",
+    Ignored = "ignored",
     Todo = "todo"
 }
 
+type TargetResultStatus = ResultStatus.Runs | ResultStatus.Passed | ResultStatus.Failed;
+type TargetCounts = {
+    [K in Exclude<TargetResultStatus, ResultStatus.Runs>]: number;
+};
+type FileResultStatus = ResultStatus.Runs | ResultStatus.Passed | ResultStatus.Failed;
+type FileCounts = {
+    [K in Exclude<FileResultStatus, ResultStatus.Runs>]: number;
+};
+type TestResultStatus = ResultStatus.Runs | ResultStatus.Passed | ResultStatus.Failed | ResultStatus.Skipped | ResultStatus.Fixme | ResultStatus.Todo;
+type TestCounts = {
+    [K in Exclude<TestResultStatus, ResultStatus.Runs>]: number;
+};
+type AssertionResultStatus = ResultStatus.Runs | ResultStatus.Passed | ResultStatus.Failed | ResultStatus.Skipped | ResultStatus.Fixme | ResultStatus.Todo;
+type AssertionCounts = {
+    [K in Exclude<AssertionResultStatus, ResultStatus.Runs>]: number;
+};
+type SuppressedResultStatus = ResultStatus.Matched | ResultStatus.Failed | ResultStatus.Ignored;
+type SuppressedCounts = {
+    [K in SuppressedResultStatus]: number;
+};
+type ResultCounts = TargetCounts | FileCounts | TestCounts | AssertionCounts | SuppressedCounts;
+interface ResultTiming {
+    start: number;
+    end: number;
+}
+
 declare class ExpectResult {
-    assertion: AssertionNode;
-    diagnostics: Array<Diagnostic>;
+    expect: ExpectNode;
     parent: TestResult | undefined;
-    status: ResultStatus;
+    status: AssertionResultStatus;
     timing: ResultTiming;
-    constructor(assertion: AssertionNode, parent?: TestResult);
-}
-
-declare class ResultCount {
-    failed: number;
-    passed: number;
-    skipped: number;
-    todo: number;
-    get total(): number;
+    constructor(expect: ExpectNode, parent?: TestResult);
 }
 
 declare class TestResult {
-    diagnostics: Array<Diagnostic>;
-    expectCount: ResultCount;
+    assertionCounts: AssertionCounts;
     parent: DescribeResult | undefined;
     results: Array<ExpectResult>;
     status: ResultStatus;
@@ -393,52 +381,55 @@ declare class DescribeResult {
     constructor(describe: TestTreeNode, parent?: DescribeResult);
 }
 
-declare class Task {
+declare class FileLocation {
     #private;
-    filePath: string;
+    path: string;
     position: number | undefined;
-    constructor(filePath: string | URL, position?: number);
+    constructor(file: string | URL, position?: number);
 }
 
-type TaskResultStatus = ResultStatus.Runs | ResultStatus.Passed | ResultStatus.Failed;
-declare class TaskResult {
-    diagnostics: Array<Diagnostic>;
-    expectCount: ResultCount;
+declare class FileResult {
+    assertionCounts: AssertionCounts;
+    file: FileLocation;
     results: Array<DescribeResult | TestResult | ExpectResult>;
-    status: TaskResultStatus;
-    task: Task;
-    testCount: ResultCount;
+    suppressedCounts: SuppressedCounts;
+    status: FileResultStatus;
+    testCounts: TestCounts;
     timing: ResultTiming;
-    constructor(task: Task);
+    constructor(file: FileLocation);
 }
 
 declare class ProjectResult {
     compilerVersion: string;
-    diagnostics: Array<Diagnostic>;
     projectConfigFilePath: string | undefined;
-    results: Array<TaskResult>;
+    results: Array<FileResult>;
     constructor(compilerVersion: string, projectConfigFilePath: string | undefined);
 }
 
-type TargetResultStatus = ResultStatus.Runs | ResultStatus.Passed | ResultStatus.Failed;
 declare class TargetResult {
+    files: Array<FileLocation>;
     results: Map<string | undefined, ProjectResult>;
     status: TargetResultStatus;
     target: string;
-    tasks: Array<Task>;
     timing: ResultTiming;
-    constructor(target: string, tasks: Array<Task>);
+    constructor(target: string, files: Array<FileLocation>);
 }
 
 declare class Result {
-    expectCount: ResultCount;
-    fileCount: ResultCount;
+    assertionCounts: AssertionCounts;
+    fileCounts: FileCounts;
+    files: Array<FileLocation>;
     results: Array<TargetResult>;
-    targetCount: ResultCount;
-    tasks: Array<Task>;
-    testCount: ResultCount;
+    suppressedCounts: SuppressedCounts;
+    targetCounts: TargetCounts;
+    testCounts: TestCounts;
     timing: ResultTiming;
-    constructor(tasks: Array<Task>);
+    constructor(files: Array<FileLocation>);
+}
+
+declare class SuppressedResult {
+    suppressed: SuppressedError;
+    constructor(suppressed: SuppressedError);
 }
 
 interface EventHandler {
@@ -466,13 +457,13 @@ type Event = ["config:error", {
     projectConfigFilePath: string | undefined;
 }] | ["project:error", {
     diagnostics: Array<Diagnostic>;
-}] | ["task:start", {
-    result: TaskResult;
-}] | ["task:error", {
+}] | ["file:start", {
+    result: FileResult;
+}] | ["file:error", {
     diagnostics: Array<Diagnostic>;
-    result: TaskResult;
-}] | ["task:end", {
-    result: TaskResult;
+    result: FileResult;
+}] | ["file:end", {
+    result: FileResult;
 }] | ["directive:error", {
     diagnostics: Array<Diagnostic>;
 }] | ["collect:start", {
@@ -480,7 +471,7 @@ type Event = ["config:error", {
 }] | ["collect:error", {
     diagnostics: Array<Diagnostic>;
 }] | ["collect:node", {
-    node: TestTreeNode | AssertionNode | WhenNode;
+    node: TestTreeNode | ExpectNode | WhenNode;
 }] | ["collect:end", {
     tree: TestTree;
 }] | ["describe:start", {
@@ -498,6 +489,8 @@ type Event = ["config:error", {
     result: TestResult;
 }] | ["test:skip", {
     result: TestResult;
+}] | ["test:fixme", {
+    result: TestResult;
 }] | ["test:todo", {
     result: TestResult;
 }] | ["expect:start", {
@@ -512,6 +505,15 @@ type Event = ["config:error", {
     result: ExpectResult;
 }] | ["expect:skip", {
     result: ExpectResult;
+}] | ["expect:fixme", {
+    result: ExpectResult;
+}] | ["suppressed:error", {
+    diagnostics: Array<Diagnostic>;
+    result: SuppressedResult;
+}] | ["suppressed:match", {
+    result: SuppressedResult;
+}] | ["suppressed:ignore", {
+    result: SuppressedResult;
 }] | ["watch:error", {
     diagnostics: Array<Diagnostic>;
 }];
@@ -529,65 +531,6 @@ declare class EventEmitter {
     removeReporters(): void;
 }
 
-declare class Reject {
-    #private;
-    constructor(compiler: typeof ts, typeChecker: ts.TypeChecker, resolvedConfig: ResolvedConfig);
-    argumentType(target: Array<[name: string, node: ts.Expression | ts.TypeNode | undefined]>, onDiagnostics: DiagnosticsHandler<Array<Diagnostic>>): boolean;
-}
-
-interface MatchResult {
-    explain: () => Array<Diagnostic>;
-    isMatch: boolean;
-}
-interface TypeChecker extends ts.TypeChecker {
-    isApplicableIndexType: (source: ts.Type, target: ts.Type) => boolean;
-    isTypeIdenticalTo: (source: ts.Type, target: ts.Type) => boolean;
-}
-
-declare class ExpectService {
-    #private;
-    private toAcceptProps;
-    private toBe;
-    private toBeApplicable;
-    private toBeAssignableTo;
-    private toBeAssignableWith;
-    private toBeCallableWith;
-    private toBeConstructableWith;
-    private toHaveProperty;
-    private toRaiseError;
-    constructor(compiler: typeof ts, typeChecker: TypeChecker, reject: Reject);
-    match(assertion: AssertionNode, onDiagnostics: DiagnosticsHandler<Diagnostic | Array<Diagnostic>>): MatchResult | undefined;
-}
-
-declare class Glob {
-    #private;
-    static toRegex(patterns: Array<string>, target: "directories" | "files"): RegExp;
-}
-
-declare class CancellationHandler implements EventHandler {
-    #private;
-    constructor(cancellationToken: CancellationToken, cancellationReason: CancellationReason);
-    on([, payload]: Event): void;
-}
-
-declare class ExitCodeHandler implements EventHandler {
-    #private;
-    on([event, payload]: Event): void;
-    resetCode(): void;
-}
-
-declare class ResultHandler implements EventHandler {
-    #private;
-    on([event, payload]: Event): void;
-}
-
-type InputHandler = (chunk: string) => void;
-declare class InputService {
-    #private;
-    constructor(onInput: InputHandler);
-    close(): void;
-}
-
 declare enum Color {
     Reset = "0",
     Red = "31",
@@ -654,6 +597,8 @@ interface CodeFrameOptions {
 
 declare function diagnosticText(diagnostic: Diagnostic, codeFrameOptions?: CodeFrameOptions): ScribblerJsx.Element;
 
+declare function fileStatusText(status: FileResultStatus, file: FileLocation): 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;
@@ -669,17 +614,17 @@ declare class OutputService {
     static writeWarning(element: ScribblerJsx.Element | Array<ScribblerJsx.Element>): void;
 }
 
-declare function summaryText({ duration, expectCount, fileCount, targetCount, testCount, }: {
-    duration: number;
-    expectCount: ResultCount;
-    fileCount: ResultCount;
-    targetCount: ResultCount;
-    testCount: ResultCount;
-}): ScribblerJsx.Element;
-
-declare function taskStatusText(status: TaskResultStatus, task: Task): ScribblerJsx.Element;
+interface SummaryTextOptions {
+    targetCounts: ResultCounts;
+    fileCounts: ResultCounts;
+    testCounts: ResultCounts;
+    assertionCounts: ResultCounts;
+    suppressedCounts: SuppressedCounts;
+    timing: ResultTiming;
+}
+declare function summaryText({ targetCounts, fileCounts, testCounts, assertionCounts, suppressedCounts, timing, }: SummaryTextOptions): ScribblerJsx.Element;
 
-declare function testNameText(status: "fail" | "pass" | "skip" | "todo", name: string, indent?: number): ScribblerJsx.Element;
+declare function testNameText(status: Exclude<TestResultStatus, ResultStatus.Runs>, name: string, indent?: number): ScribblerJsx.Element;
 
 declare function usesCompilerText(compilerVersion: string, projectConfigFilePath: string | undefined, options?: {
     prependEmptyLine: boolean;
@@ -718,7 +663,7 @@ declare class Runner {
     #private;
     static version: string;
     constructor(resolvedConfig: ResolvedConfig);
-    run(testFiles: Array<string | URL | Task>, cancellationToken?: CancellationToken): Promise<void>;
+    run(files: Array<string | URL | FileLocation>, cancellationToken?: CancellationToken): Promise<void>;
 }
 
 declare class Select {
@@ -778,10 +723,6 @@ declare class Store {
     static validateTag(tag: string): Promise<boolean | undefined>;
 }
 
-declare class SuppressedService {
-    match(suppressedErrors: SuppressedErrors, onDiagnostics: DiagnosticsHandler<Array<Diagnostic>>): void;
-}
-
 declare class Version {
     #private;
     static isGreaterThan(source: string, target: string): boolean;
@@ -789,33 +730,5 @@ declare class Version {
     static isSatisfiedWith(source: string, target: string): boolean;
 }
 
-type WatchHandler = (filePath: string) => void;
-interface WatcherOptions {
-    recursive?: boolean;
-}
-declare class Watcher {
-    #private;
-    constructor(targetPath: string, onChanged: WatchHandler, onRemoved?: WatchHandler, options?: WatcherOptions);
-    close(): void;
-    watch(): void;
-}
-
-type FileWatchHandler = () => void;
-declare class FileWatcher extends Watcher {
-    constructor(targetPath: string, onChanged: FileWatchHandler);
-}
-
-declare class WatchService {
-    #private;
-    constructor(resolvedConfig: ResolvedConfig, tasks: Array<Task>);
-    watch(cancellationToken: CancellationToken): AsyncIterable<Array<Task>>;
-}
-
-declare class WhenService {
-    #private;
-    constructor(reject: Reject, onDiagnostics: DiagnosticsHandler<Array<Diagnostic>>);
-    action(when: WhenNode): void;
-}
-
-export { AssertionNode, BaseReporter, CancellationHandler, CancellationReason, CancellationToken, Cli, CollectService, Color, Config, ConfigDiagnosticText, DescribeResult, Diagnostic, DiagnosticCategory, DiagnosticOrigin, Directive, EventEmitter, ExitCodeHandler, ExpectResult, ExpectService, FileWatcher, Glob, InputService, Line, ListReporter, OptionBrand, OptionGroup, Options, OutputService, Path, PluginService, ProjectResult, ProjectService, Reject, Result, ResultCount, ResultHandler, ResultStatus, ResultTiming, Runner, Scribbler, ScribblerJsx, Select, SelectDiagnosticText, SetupReporter, SourceFile, Store, SummaryReporter, SuppressedService, TargetResult, Task, TaskResult, TestResult, TestTree, TestTreeNode, TestTreeNodeBrand, TestTreeNodeFlags, Text, Version, WatchReporter, WatchService, Watcher, WhenNode, WhenService, addsPackageText, argumentIsProvided, argumentOrTypeArgumentIsProvided, defaultOptions, describeNameText, diagnosticBelongsToNode, diagnosticText, environmentOptions, fileViewText, formattedText, getDiagnosticMessageText, getTextSpanEnd, helpText, isDiagnosticWithLocation, nodeBelongsToArgumentList, summaryText, taskStatusText, testNameText, usesCompilerText, waitingForFileChangesText, watchUsageText };
-export type { CodeFrameOptions, CommandLineOptions, ConfigFileOptions, DiagnosticsHandler, DirectiveRange, DirectiveRanges, EnvironmentOptions, Event, EventHandler, FileWatchHandler, InlineConfig, InputHandler, ItemDefinition, MatchResult, OptionDefinition, Plugin, Reporter, ReporterEvent, ResolvedConfig, ScribblerOptions, SelectHookContext, SuppressedError, SuppressedErrors, TargetResultStatus, TaskResultStatus, TextRange, TypeChecker, WatchHandler, WatcherOptions };
+export { BaseReporter, CancellationReason, CancellationToken, Cli, Color, Config, ConfigDiagnosticText, DescribeResult, Diagnostic, DiagnosticCategory, DiagnosticOrigin, Directive, EventEmitter, ExpectResult, FileLocation, FileResult, Line, ListReporter, OptionBrand, OptionGroup, Options, OutputService, Path, PluginService, ProjectResult, Result, ResultStatus, Runner, Scribbler, ScribblerJsx, Select, SelectDiagnosticText, SetupReporter, Store, SummaryReporter, SuppressedResult, TargetResult, TestResult, Text, Version, WatchReporter, addsPackageText, defaultOptions, describeNameText, diagnosticBelongsToNode, diagnosticText, environmentOptions, fileStatusText, fileViewText, formattedText, getDiagnosticMessageText, getTextSpanEnd, helpText, isDiagnosticWithLocation, summaryText, testNameText, usesCompilerText, waitingForFileChangesText, watchUsageText };
+export type { AssertionCounts, AssertionResultStatus, CodeFrameOptions, CommandLineOptions, ConfigFileOptions, DiagnosticsHandler, DirectiveRange, EnvironmentOptions, Event, EventHandler, FileCounts, FileResultStatus, InlineConfig, ItemDefinition, OptionDefinition, Plugin, Reporter, ReporterEvent, ResolvedConfig, ResultCounts, ResultTiming, ScribblerOptions, SelectHookContext, SuppressedCounts, SuppressedResultStatus, TargetCounts, TargetResultStatus, TestCounts, TestResultStatus, TextRange };