tstyche 5.0.0-beta.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;
@@ -53,6 +166,7 @@ interface ConfigFileOptions {
     testFileMatch?: Array<string>;
     tsconfig?: string;
 }
+
 interface InlineConfig {
     fixme?: boolean;
     if?: {
@@ -139,64 +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 SourceService {
-    #private;
-    static get(source: SourceFile | ts.SourceFile): SourceFile | ts.SourceFile;
-    static set(source: SourceFile | ts.SourceFile): void;
-}
-
-declare class DiagnosticOrigin {
-    assertionNode: ExpectNode | undefined;
-    end: number;
-    sourceFile: SourceFile | ts.SourceFile;
-    start: number;
-    constructor(start: number, end: number, sourceFile: SourceFile | ts.SourceFile, 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;
-
 interface BaseOptionDefinition {
     brand: OptionBrand;
     description: string;
@@ -222,88 +278,6 @@ declare class Options {
     static validate(optionName: string, optionValue: string, onDiagnostics: DiagnosticsHandler, origin?: DiagnosticOrigin): Promise<void>;
 }
 
-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;
-}
-
-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);
-}
-
-interface SuppressedError {
-    directive: TextRange;
-    ignore: boolean;
-    argument?: TextRange;
-    diagnostics: Array<ts.Diagnostic>;
-}
-
-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 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;
@@ -344,42 +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",
-    Skipped = "skipped",
     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 {
     expect: ExpectNode;
-    diagnostics: Array<Diagnostic>;
     parent: TestResult | undefined;
-    status: ResultStatus;
+    status: AssertionResultStatus;
     timing: ResultTiming;
     constructor(expect: ExpectNode, parent?: TestResult);
 }
 
-declare class ResultCount {
-    failed: number;
-    passed: number;
-    skipped: number;
-    fixme: number;
-    todo: number;
-    get total(): number;
-}
-
 declare class TestResult {
-    diagnostics: Array<Diagnostic>;
-    expectCount: ResultCount;
+    assertionCounts: AssertionCounts;
     parent: DescribeResult | undefined;
     results: Array<ExpectResult>;
     status: ResultStatus;
@@ -403,27 +388,24 @@ declare class FileLocation {
     constructor(file: string | URL, position?: number);
 }
 
-type FileResultStatus = ResultStatus.Runs | ResultStatus.Passed | ResultStatus.Failed;
 declare class FileResult {
-    diagnostics: Array<Diagnostic>;
-    expectCount: ResultCount;
+    assertionCounts: AssertionCounts;
     file: FileLocation;
     results: Array<DescribeResult | TestResult | ExpectResult>;
+    suppressedCounts: SuppressedCounts;
     status: FileResultStatus;
-    testCount: ResultCount;
+    testCounts: TestCounts;
     timing: ResultTiming;
     constructor(file: FileLocation);
 }
 
 declare class ProjectResult {
     compilerVersion: string;
-    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 {
     files: Array<FileLocation>;
     results: Map<string | undefined, ProjectResult>;
@@ -434,16 +416,22 @@ declare class TargetResult {
 }
 
 declare class Result {
-    expectCount: ResultCount;
-    fileCount: ResultCount;
+    assertionCounts: AssertionCounts;
+    fileCounts: FileCounts;
     files: Array<FileLocation>;
     results: Array<TargetResult>;
-    targetCount: ResultCount;
-    testCount: ResultCount;
+    suppressedCounts: SuppressedCounts;
+    targetCounts: TargetCounts;
+    testCounts: TestCounts;
     timing: ResultTiming;
     constructor(files: Array<FileLocation>);
 }
 
+declare class SuppressedResult {
+    suppressed: SuppressedError;
+    constructor(suppressed: SuppressedError);
+}
+
 interface EventHandler {
     on: (event: Event) => void;
 }
@@ -519,6 +507,13 @@ type Event = ["config:error", {
     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>;
 }];
@@ -536,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(assertionNode: ExpectNode, 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",
@@ -678,15 +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;
+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" | "fixme" | "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;
@@ -785,11 +723,6 @@ declare class Store {
     static validateTag(tag: string): Promise<boolean | undefined>;
 }
 
-declare class SuppressedService {
-    #private;
-    match(testTree: TestTree, onDiagnostics: DiagnosticsHandler<Array<Diagnostic>>): void;
-}
-
 declare class Version {
     #private;
     static isGreaterThan(source: string, target: string): boolean;
@@ -797,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, files: Array<FileLocation>);
-    watch(cancellationToken: CancellationToken): AsyncIterable<Array<FileLocation>>;
-}
-
-declare class WhenService {
-    #private;
-    constructor(reject: Reject, onDiagnostics: DiagnosticsHandler<Array<Diagnostic>>);
-    action(when: WhenNode): void;
-}
-
-export { BaseReporter, CancellationHandler, CancellationReason, CancellationToken, Cli, CollectService, Color, Config, ConfigDiagnosticText, DescribeResult, Diagnostic, DiagnosticCategory, DiagnosticOrigin, Directive, EventEmitter, ExitCodeHandler, ExpectNode, ExpectResult, ExpectService, FileLocation, FileResult, 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, SourceService, Store, SummaryReporter, SuppressedService, TargetResult, TestResult, TestTree, TestTreeNode, TestTreeNodeBrand, TestTreeNodeFlags, Text, Version, WatchReporter, WatchService, Watcher, WhenNode, WhenService, addsPackageText, argumentIsProvided, argumentOrTypeArgumentIsProvided, defaultOptions, describeNameText, diagnosticBelongsToNode, diagnosticText, environmentOptions, fileStatusText, fileViewText, formattedText, getDiagnosticMessageText, getTextSpanEnd, helpText, isDiagnosticWithLocation, nodeBelongsToArgumentList, summaryText, testNameText, usesCompilerText, waitingForFileChangesText, watchUsageText };
-export type { CodeFrameOptions, CommandLineOptions, ConfigFileOptions, DiagnosticsHandler, DirectiveRange, EnvironmentOptions, Event, EventHandler, FileResultStatus, FileWatchHandler, InlineConfig, InputHandler, ItemDefinition, MatchResult, OptionDefinition, Plugin, Reporter, ReporterEvent, ResolvedConfig, ScribblerOptions, SelectHookContext, SuppressedError, TargetResultStatus, 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 };