tstyche 2.0.0-rc.2 → 2.1.0

package/build/tstyche.d.ts

@@ -1,52 +1,17 @@
 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"
-}
-
-declare class Diagnostic {
-    category: DiagnosticCategory;
-    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;
-        related?: Array<Diagnostic>;
-    }): this;
-    static error(text: string | Array<string>, origin?: DiagnosticOrigin): Diagnostic;
-    static fromDiagnostics(diagnostics: ReadonlyArray<ts.Diagnostic>, compiler: typeof ts): Array<Diagnostic>;
-    static fromError(text: string | Array<string>, error: unknown): Diagnostic;
-    static isTsDiagnosticWithLocation(diagnostic: ts.Diagnostic): diagnostic is ts.DiagnosticWithLocation;
-    static warning(text: string | Array<string>, origin?: DiagnosticOrigin): Diagnostic;
-}
-
 declare enum CancellationReason {
     ConfigChange = "configChange",
     ConfigError = "configError",
-    FailFast = "failFast"
+    FailFast = "failFast",
+    WatchClose = "watchClose"
 }
 
-type CancellationRequestedHandler = (reason: CancellationReason) => void;
 declare class CancellationToken {
     #private;
     get isCancellationRequested(): boolean;
     get reason(): CancellationReason | undefined;
     cancel(reason: CancellationReason): void;
-    onCancellationRequested(handler: CancellationRequestedHandler): void;
     reset(): void;
 }
 
@@ -57,7 +22,6 @@ declare class StoreService {
     install(tag: string, cancellationToken?: CancellationToken): Promise<string | undefined>;
     load(tag: string, cancellationToken?: CancellationToken): Promise<typeof ts | undefined>;
     open(): Promise<void>;
-    resolveTag(tag: string): Promise<string | undefined>;
     update(): Promise<void>;
     validateTag(tag: string): Promise<boolean | undefined>;
 }
@@ -98,6 +62,95 @@ declare class OptionDefinitionsMap {
     static for(optionGroup: OptionGroup): Map<string, OptionDefinition>;
 }
 
+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 {
+    Describe = "describe",
+    Test = "test",
+    Expect = "expect"
+}
+declare enum TestMemberFlags {
+    None = 0,
+    Fail = 1,
+    Only = 2,
+    Skip = 4,
+    Todo = 8
+}
+
+declare class TestMember {
+    #private;
+    brand: TestMemberBrand;
+    diagnostics: Set<ts.Diagnostic>;
+    flags: TestMemberFlags;
+    members: Array<TestMember | Assertion>;
+    name: string;
+    node: ts.CallExpression;
+    parent: TestTree | TestMember;
+    constructor(compiler: typeof ts, brand: TestMemberBrand, node: ts.CallExpression, parent: TestTree | TestMember, flags: TestMemberFlags);
+    validate(): Array<Diagnostic>;
+}
+
+interface MatcherNode extends ts.CallExpression {
+    expression: ts.PropertyAccessExpression;
+}
+declare class Assertion extends TestMember {
+    isNot: boolean;
+    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 matcherName(): ts.MemberName;
+    get source(): ts.NodeArray<ts.Expression> | ts.NodeArray<ts.TypeNode>;
+    get target(): ts.NodeArray<ts.Expression> | ts.NodeArray<ts.TypeNode>;
+}
+
+declare class CollectService {
+    #private;
+    constructor(compiler: typeof ts);
+    createTestTree(sourceFile: ts.SourceFile, semanticDiagnostics?: Array<ts.Diagnostic>): TestTree;
+}
+
+declare class DiagnosticOrigin {
+    assertion: Assertion | undefined;
+    end: number;
+    sourceFile: ts.SourceFile;
+    start: number;
+    constructor(start: number, end: number, sourceFile: ts.SourceFile, assertion?: Assertion);
+    static fromAssertion(assertion: Assertion): DiagnosticOrigin;
+    static fromJsonNode(node: ts.Node, sourceFile: ts.SourceFile, skipTrivia: (position: number, sourceFile: ts.SourceFile) => number): DiagnosticOrigin;
+    static fromNode(node: ts.Node, assertion?: Assertion): DiagnosticOrigin;
+}
+
+declare enum DiagnosticCategory {
+    Error = "error",
+    Warning = "warning"
+}
+
+declare class Diagnostic {
+    #private;
+    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>, compiler: typeof ts): Array<Diagnostic>;
+    static fromError(text: string | Array<string>, error: unknown): Diagnostic;
+    static warning(text: string | Array<string>, origin?: DiagnosticOrigin): Diagnostic;
+}
+
 /**
  * Options passed through the command line.
  */
@@ -156,6 +209,19 @@ interface CommandLineOptions {
     watch?: boolean;
 }
 
+declare class ConfigDiagnosticText {
+    #private;
+    static doubleQuotesExpected(): string;
+    static expectsListItemType(optionName: string, optionBrand: OptionBrand): string;
+    static expectsValue(optionName: string, optionGroup: OptionGroup): string;
+    static fileDoesNotExist(filePath: string): 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 watchCannotBeEnabled(): string;
+}
+
 /**
  * Options loaded from the configuration file.
  */
@@ -197,22 +263,6 @@ declare class ConfigService {
     resolveConfig(): ResolvedConfig;
 }
 
-declare class OptionDiagnosticText {
-    #private;
-    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 enum Color {
     Reset = "0",
     Red = "31",
@@ -283,61 +333,6 @@ declare class TestFile {
     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 {
-    Describe = "describe",
-    Test = "test",
-    Expect = "expect"
-}
-declare enum TestMemberFlags {
-    None = 0,
-    Fail = 1,
-    Only = 2,
-    Skip = 4,
-    Todo = 8
-}
-
-declare class TestMember {
-    brand: TestMemberBrand;
-    diagnostics: Set<ts.Diagnostic>;
-    flags: TestMemberFlags;
-    members: Array<TestMember | Assertion>;
-    name: string;
-    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>;
-}
-
-interface MatcherNode extends ts.CallExpression {
-    expression: ts.PropertyAccessExpression;
-}
-declare class Assertion extends TestMember {
-    isNot: boolean;
-    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>;
-    get target(): ts.NodeArray<ts.Expression> | ts.NodeArray<ts.TypeNode>;
-}
-
-declare class CollectService {
-    #private;
-    constructor(compiler: typeof ts);
-    createTestTree(sourceFile: ts.SourceFile, semanticDiagnostics?: Array<ts.Diagnostic>): TestTree;
-}
-
 declare class ResultTiming {
     end: number;
     start: number;
@@ -430,85 +425,6 @@ declare class Result {
     constructor(resolvedConfig: ResolvedConfig, testFiles: Array<TestFile>);
 }
 
-type Event = ["config:error", {
-    diagnostics: Array<Diagnostic>;
-}] | ["deprecation:info", {
-    diagnostics: Array<Diagnostic>;
-}] | ["select:error", {
-    diagnostics: Array<Diagnostic>;
-}] | ["run:start", {
-    result: Result;
-}] | ["run:end", {
-    result: Result;
-}] | ["store:info", {
-    compilerVersion: string;
-    installationPath: string;
-}] | ["store:error", {
-    diagnostics: Array<Diagnostic>;
-}] | ["target:start", {
-    result: TargetResult;
-}] | ["target:end", {
-    result: TargetResult;
-}] | ["project:info", {
-    compilerVersion: string;
-    projectConfigFilePath: string | undefined;
-}] | ["project:error", {
-    diagnostics: Array<Diagnostic>;
-}] | ["file:start", {
-    result: FileResult;
-}] | ["file:error", {
-    diagnostics: Array<Diagnostic>;
-    result: FileResult;
-}] | ["file:end", {
-    result: FileResult;
-}] | ["describe:start", {
-    result: DescribeResult;
-}] | ["describe:end", {
-    result: DescribeResult;
-}] | ["test:start", {
-    result: TestResult;
-}] | ["test:error", {
-    diagnostics: Array<Diagnostic>;
-    result: TestResult;
-}] | ["test:fail", {
-    result: TestResult;
-}] | ["test:pass", {
-    result: TestResult;
-}] | ["test:skip", {
-    result: TestResult;
-}] | ["test:todo", {
-    result: TestResult;
-}] | ["expect:start", {
-    result: ExpectResult;
-}] | ["expect:error", {
-    diagnostics: Array<Diagnostic>;
-    result: ExpectResult;
-}] | ["expect:fail", {
-    diagnostics: Array<Diagnostic>;
-    result: ExpectResult;
-}] | ["expect:pass", {
-    result: ExpectResult;
-}] | ["expect:skip", {
-    result: ExpectResult;
-}] | ["watch:error", {
-    diagnostics: Array<Diagnostic>;
-}];
-interface EventHandler {
-    handleEvent: (event: Event) => void;
-}
-declare class EventEmitter {
-    #private;
-    addHandler(handler: EventHandler): void;
-    static dispatch(event: Event): 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;
@@ -518,7 +434,7 @@ declare function formattedText(input: string | Array<string> | Record<string, un
 declare function helpText(optionDefinitions: Map<string, OptionDefinition>, tstycheVersion: string): ScribblerJsx.Element;
 
 interface WriteStream {
-    write: (log: string) => void;
+    write: (chunk: string) => void;
 }
 interface OutputServiceOptions {
     noColor?: boolean;
@@ -530,9 +446,9 @@ declare class OutputService {
     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;
+    writeError(element: ScribblerJsx.Element | Array<ScribblerJsx.Element>): void;
+    writeMessage(element: ScribblerJsx.Element | Array<ScribblerJsx.Element>): void;
+    writeWarning(element: ScribblerJsx.Element | Array<ScribblerJsx.Element>): void;
 }
 
 declare function summaryText({ duration, expectCount, fileCount, onlyMatch, pathMatch, skipMatch, targetCount, testCount, }: {
@@ -556,6 +472,12 @@ declare function waitingForFileChangesText(): ScribblerJsx.Element;
 
 declare function watchUsageText(): ScribblerJsx.Element;
 
+declare class SelectDiagnosticText {
+    #private;
+    static noTestFilesWereLeft(resolvedConfig: ResolvedConfig): Array<string>;
+    static noTestFilesWereSelected(resolvedConfig: ResolvedConfig): Array<string>;
+}
+
 declare class SelectService {
     #private;
     constructor(resolvedConfig: ResolvedConfig);
@@ -604,6 +526,83 @@ declare class Environment {
     static get typescriptPath(): string | undefined;
 }
 
+type Event = ["config:error", {
+    diagnostics: Array<Diagnostic>;
+}] | ["deprecation:info", {
+    diagnostics: Array<Diagnostic>;
+}] | ["select:error", {
+    diagnostics: Array<Diagnostic>;
+}] | ["run:start", {
+    result: Result;
+}] | ["run:end", {
+    result: Result;
+}] | ["store:info", {
+    compilerVersion: string;
+    installationPath: string;
+}] | ["store:error", {
+    diagnostics: Array<Diagnostic>;
+}] | ["target:start", {
+    result: TargetResult;
+}] | ["target:end", {
+    result: TargetResult;
+}] | ["project:info", {
+    compilerVersion: string;
+    projectConfigFilePath: string | undefined;
+}] | ["project:error", {
+    diagnostics: Array<Diagnostic>;
+}] | ["file:start", {
+    result: FileResult;
+}] | ["file:error", {
+    diagnostics: Array<Diagnostic>;
+    result: FileResult;
+}] | ["file:end", {
+    result: FileResult;
+}] | ["describe:start", {
+    result: DescribeResult;
+}] | ["describe:end", {
+    result: DescribeResult;
+}] | ["test:start", {
+    result: TestResult;
+}] | ["test:error", {
+    diagnostics: Array<Diagnostic>;
+    result: TestResult;
+}] | ["test:fail", {
+    result: TestResult;
+}] | ["test:pass", {
+    result: TestResult;
+}] | ["test:skip", {
+    result: TestResult;
+}] | ["test:todo", {
+    result: TestResult;
+}] | ["expect:start", {
+    result: ExpectResult;
+}] | ["expect:error", {
+    diagnostics: Array<Diagnostic>;
+    result: ExpectResult;
+}] | ["expect:fail", {
+    diagnostics: Array<Diagnostic>;
+    result: ExpectResult;
+}] | ["expect:pass", {
+    result: ExpectResult;
+}] | ["expect:skip", {
+    result: ExpectResult;
+}] | ["watch:error", {
+    diagnostics: Array<Diagnostic>;
+}];
+
+interface EventHandler {
+    handleEvent: (event: Event) => void;
+}
+declare class EventEmitter {
+    #private;
+    addHandler(handler: EventHandler): void;
+    static dispatch(event: Event): void;
+    removeHandler(handler: EventHandler): void;
+    removeHandlers(): void;
+}
+
+type ArgumentNode = ts.Expression | ts.TypeNode;
+type DiagnosticsHandler = (diagnostics: Diagnostic | Array<Diagnostic>) => void;
 interface MatchResult {
     explain: () => Array<Diagnostic>;
     isMatch: boolean;
@@ -618,66 +617,116 @@ interface TypeChecker extends ts.TypeChecker {
     };
 }
 
+declare class MatchWorker {
+    #private;
+    assertion: Assertion;
+    constructor(compiler: typeof ts, typeChecker: TypeChecker, assertion: Assertion);
+    checkIsAssignableTo(sourceNode: ArgumentNode, targetNode: ArgumentNode): boolean;
+    checkIsAssignableWith(sourceNode: ArgumentNode, targetNode: ArgumentNode): boolean;
+    checkIsIdenticalTo(sourceNode: ArgumentNode, targetNode: ArgumentNode): boolean;
+    checkIsSubtype(sourceNode: ArgumentNode, targetNode: ArgumentNode): boolean;
+    extendsObjectType(type: ts.Type): boolean;
+    getParameterType(signature: ts.Signature, index: number): ts.Type | undefined;
+    getSignatures(node: ArgumentNode): Array<ts.Signature>;
+    getTypeText(node: ArgumentNode): string;
+    getType(node: ArgumentNode): ts.Type;
+    isAnyOrNeverType(type: ts.Type): type is ts.StringLiteralType | ts.NumberLiteralType;
+    isStringOrNumberLiteralType(type: ts.Type): type is ts.StringLiteralType | ts.NumberLiteralType;
+    isObjectType(type: ts.Type): type is ts.ObjectType;
+    isUnionType(type: ts.Type): type is ts.UnionType;
+    isUniqueSymbolType(type: ts.Type): type is ts.UniqueESSymbolType;
+    resolveDiagnosticOrigin(symbol: ts.Symbol, enclosingNode: ts.Node): DiagnosticOrigin;
+}
+
 declare class PrimitiveTypeMatcher {
     #private;
-    typeChecker: TypeChecker;
-    constructor(typeChecker: TypeChecker, targetTypeFlag: ts.TypeFlags);
-    match(sourceType: ts.Type): MatchResult;
+    constructor(targetTypeFlag: ts.TypeFlags);
+    match(matchWorker: MatchWorker, sourceNode: ArgumentNode): MatchResult;
+}
+
+declare class ToAcceptProps {
+    #private;
+    constructor(compiler: typeof ts, typeChecker: TypeChecker);
+    match(matchWorker: MatchWorker, sourceNode: ArgumentNode, targetNode: ArgumentNode, onDiagnostics: DiagnosticsHandler): MatchResult | undefined;
+}
+
+declare class ExpectDiagnosticText {
+    static argumentOrTypeArgumentMustBeProvided(argumentNameText: string, typeArgumentNameText: string): string;
+    static argumentMustBe(argumentNameText: string, expectedText: string): string;
+    static argumentMustBeProvided(argumentNameText: string): string;
+    static componentAcceptsProps(isTypeNode: boolean): string;
+    static componentDoesNotAcceptProps(isTypeNode: boolean): string;
+    static matcherIsDeprecated(matcherNameText: string): Array<string>;
+    static matcherIsNotSupported(matcherNameText: string): string;
+    static overloadGaveTheFollowingError(indexText: string, countText: string, signatureText: string): string;
+    static raisedTypeError(count?: number): string;
+    static typeArgumentMustBe(argumentNameText: string, expectedText: string): string;
+    static typeDidNotRaiseError(isTypeNode: boolean): string;
+    static typeDidNotRaiseMatchingError(isTypeNode: boolean): string;
+    static typeDoesNotHaveProperty(typeText: string, propertyNameText: string): string;
+    static typeDoesMatch(sourceTypeText: string, targetTypeText: string): string;
+    static typeDoesNotMatch(sourceTypeText: string, targetTypeText: string): string;
+    static typeHasProperty(typeText: string, propertyNameText: string): string;
+    static typeIs(typeText: string): string;
+    static typeIsAssignableTo(sourceTypeText: string, targetTypeText: string): string;
+    static typeIsAssignableWith(sourceTypeText: string, targetTypeText: string): string;
+    static typeIsIdenticalTo(sourceTypeText: string, targetTypeText: string): string;
+    static typeIsNotAssignableTo(sourceTypeText: string, targetTypeText: string): string;
+    static typeIsNotAssignableWith(sourceTypeText: string, targetTypeText: string): string;
+    static typeIsNotCompatibleWith(sourceTypeText: string, targetTypeText: string): string;
+    static typeIsNotIdenticalTo(sourceTypeText: string, targetTypeText: string): string;
+    static typeRaisedError(isTypeNode: boolean, count: number, targetCount: number): string;
+    static typeRaisedMatchingError(isTypeNode: boolean): string;
+    static typeRequiresProperty(typeText: string, propertyNameText: string): string;
+    static typesOfPropertyAreNotCompatible(propertyNameText: string): string;
 }
 
 declare abstract class RelationMatcherBase {
-    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;
+    abstract explainText(sourceTypeText: string, targetTypeText: string): string;
+    abstract explainNotText(sourceTypeText: string, targetTypeText: string): string;
+    protected explain(matchWorker: MatchWorker, sourceNode: ArgumentNode, targetNode: ArgumentNode): Diagnostic[];
+    abstract match(matchWorker: MatchWorker, sourceNode: ArgumentNode, targetNode: ArgumentNode): MatchResult;
 }
 
 declare class ToBe extends RelationMatcherBase {
-    relation: Relation;
-    relationExplanationText: string;
+    explainText: typeof ExpectDiagnosticText.typeIsIdenticalTo;
+    explainNotText: typeof ExpectDiagnosticText.typeIsNotIdenticalTo;
+    match(matchWorker: MatchWorker, sourceNode: ArgumentNode, targetNode: ArgumentNode): MatchResult;
 }
 
 declare class ToBeAssignableTo extends RelationMatcherBase {
-    relation: Relation;
-    relationExplanationText: string;
+    explainText: typeof ExpectDiagnosticText.typeIsAssignableTo;
+    explainNotText: typeof ExpectDiagnosticText.typeIsNotAssignableTo;
+    match(matchWorker: MatchWorker, sourceNode: ArgumentNode, targetNode: ArgumentNode): MatchResult;
 }
 
 declare class ToBeAssignableWith extends RelationMatcherBase {
-    relation: Relation;
-    relationExplanationText: string;
-    match(sourceType: ts.Type, targetType: ts.Type, isNot: boolean): MatchResult;
+    explainText: typeof ExpectDiagnosticText.typeIsAssignableWith;
+    explainNotText: typeof ExpectDiagnosticText.typeIsNotAssignableWith;
+    match(matchWorker: MatchWorker, sourceNode: ArgumentNode, targetNode: ArgumentNode): MatchResult;
 }
 
 declare class ToHaveProperty {
     #private;
-    compiler: typeof ts;
-    typeChecker: TypeChecker;
-    constructor(compiler: typeof ts, typeChecker: TypeChecker);
-    match(sourceType: ts.Type, targetType: ts.StringLiteralType | ts.NumberLiteralType | ts.UniqueESSymbolType, isNot: boolean): MatchResult;
+    constructor(compiler: typeof ts);
+    match(matchWorker: MatchWorker, sourceNode: ArgumentNode, targetNode: ArgumentNode, onDiagnostics: DiagnosticsHandler): MatchResult | undefined;
 }
 
 declare class ToMatch extends RelationMatcherBase {
-    relation: Relation;
-    relationExplanationText: string;
-    relationExplanationVerb: string;
+    explainText: typeof ExpectDiagnosticText.typeDoesMatch;
+    explainNotText: typeof ExpectDiagnosticText.typeDoesNotMatch;
+    match(matchWorker: MatchWorker, sourceNode: ArgumentNode, targetNode: ArgumentNode): MatchResult;
 }
 
 declare class ToRaiseError {
     #private;
-    compiler: typeof ts;
-    typeChecker: TypeChecker;
-    constructor(compiler: typeof ts, typeChecker: TypeChecker);
-    match(source: {
-        diagnostics: Array<ts.Diagnostic>;
-        node: ts.Expression | ts.TypeNode;
-    }, targetTypes: Array<ts.StringLiteralType | ts.NumberLiteralType>, isNot: boolean): MatchResult;
+    constructor(compiler: typeof ts);
+    match(matchWorker: MatchWorker, sourceNode: ArgumentNode, targetNodes: Array<ArgumentNode>, onDiagnostics: DiagnosticsHandler): MatchResult | undefined;
 }
 
-declare class Expect {
+declare class ExpectService {
     #private;
+    toAcceptProps: ToAcceptProps;
     toBe: ToBe;
     toBeAny: PrimitiveTypeMatcher;
     toBeAssignable: ToBeAssignableWith;
@@ -700,7 +749,7 @@ declare class Expect {
     toRaiseError: ToRaiseError;
     constructor(compiler: typeof ts, typeChecker: TypeChecker);
     static assertTypeChecker(typeChecker: ts.TypeChecker): typeChecker is TypeChecker;
-    match(assertion: Assertion, expectResult: ExpectResult): MatchResult | undefined;
+    match(assertion: Assertion, onDiagnostics: DiagnosticsHandler): MatchResult | undefined;
 }
 
 declare class CancellationHandler implements EventHandler {
@@ -715,34 +764,40 @@ declare class ExitCodeHandler implements EventHandler {
     resetCode(): void;
 }
 
-declare class RuntimeReporter implements EventHandler {
+declare class ResultHandler implements EventHandler {
     #private;
-    constructor(resolvedConfig: ResolvedConfig, outputService: OutputService);
     handleEvent([eventName, payload]: Event): void;
 }
 
-declare class SetupReporter implements EventHandler {
-    #private;
+declare abstract class Reporter implements EventHandler {
+    protected outputService: OutputService;
     constructor(outputService: OutputService);
-    handleEvent([eventName, payload]: Event): void;
+    abstract handleEvent([eventName, payload]: Event): void;
 }
 
-declare class SummaryReporter implements EventHandler {
+declare class RunReporter extends Reporter implements EventHandler {
     #private;
-    constructor(outputService: OutputService);
+    constructor(resolvedConfig: ResolvedConfig, outputService: OutputService);
     handleEvent([eventName, payload]: Event): void;
 }
 
-declare class WatchReporter implements EventHandler {
-    #private;
-    constructor(outputService: OutputService);
+declare class SetupReporter extends Reporter implements EventHandler {
     handleEvent([eventName, payload]: Event): void;
 }
 
-type InputHandler = (chunk: Buffer) => void;
+declare class SummaryReporter extends Reporter implements EventHandler {
+    handleEvent([eventName, payload]: Event): void;
+}
+
+declare class WatchReporter extends Reporter implements EventHandler {
+    handleEvent([eventName, payload]: Event): void;
+}
+
+type InputHandler = (chunk: string) => void;
 interface ReadStream {
     addListener: (event: "data", handler: InputHandler) => this;
     removeListener: (event: "data", handler: InputHandler) => this;
+    setEncoding: (encoding: "utf8") => this;
     setRawMode?: (mode: boolean) => this;
     unref: () => this;
 }
@@ -786,7 +841,7 @@ declare class Version {
     static isVersionTag(target: string): boolean;
 }
 
-type WatchHandler = (filePath: string) => void | Promise<void>;
+type WatchHandler = (filePath: string) => void;
 interface WatcherOptions {
     recursive?: boolean;
 }
@@ -794,20 +849,18 @@ declare class Watcher {
     #private;
     constructor(targetPath: string, onChanged: WatchHandler, onRemoved?: WatchHandler, options?: WatcherOptions);
     close(): void;
-    watch(): Promise<void>;
+    watch(): void;
 }
 
-type FileWatchHandler = () => void | Promise<void>;
+type FileWatchHandler = () => 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>>;
+    constructor(resolvedConfig: ResolvedConfig, selectService: SelectService, testFiles: Array<TestFile>);
+    watch(cancellationToken: CancellationToken): AsyncIterable<Array<TestFile>>;
 }
 
-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 };
+export { Assertion, CancellationHandler, CancellationReason, CancellationToken, Cli, CollectService, Color, type CommandLineOptions, ConfigDiagnosticText, type ConfigFileOptions, ConfigService, DescribeResult, Diagnostic, DiagnosticCategory, DiagnosticOrigin, Environment, type Event, EventEmitter, type EventHandler, ExitCodeHandler, ExpectResult, ExpectService, FileResult, type FileResultStatus, type FileWatchHandler, FileWatcher, type InputHandler, InputService, type InputServiceOptions, type ItemDefinition, Line, type MatchResult, OptionBrand, type OptionDefinition, OptionDefinitionsMap, OptionGroup, OutputService, type OutputServiceOptions, Path, ProjectResult, ProjectService, type ReadStream, type ResolvedConfig, Result, ResultCount, ResultHandler, ResultStatus, ResultTiming, RunReporter, Scribbler, ScribblerJsx, type ScribblerOptions, SelectDiagnosticText, 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 };