tstyche 2.0.0 → 2.1.1

package/README.md

@@ -59,6 +59,7 @@ test("handles numbers", () => {
 Here is the list of all matchers:
 
 - `.toBe()`, `.toBeAssignableTo()`, `.toBeAssignableWith()`, `.toMatch()` compare types or types of expression,
+- `.toAcceptProps()` checks types of JSX component's props,
 - `.toHaveProperty()` looks up keys on an object type,
 - `.toRaiseError()` captures the type error message or code,
 - `.toBeString()`, `.toBeNumber()`, `.toBeVoid()` and 9 more shorthand checks for primitive types.

package/build/index.d.cts

@@ -59,6 +59,31 @@ interface Test {
     todo: (name: string, callback?: () => void | Promise<void>) => void;
 }
 interface Matchers {
+    /**
+     * Checks if the JSX component accepts props of the given type.
+     *
+     * @remarks
+     *
+     * This is a work in progress feature. Generic components are not yet supported.
+     */
+    toAcceptProps: {
+        /**
+         * Checks if the JSX component accepts props of the given type.
+         *
+         * @remarks
+         *
+         * This is a work in progress feature. Generic components are not yet supported.
+         */
+        <Target>(): void;
+        /**
+         * Checks if the JSX component accepts the given props.
+         *
+         * @remarks
+         *
+         * This is a work in progress feature. Generic components are not yet supported.
+         */
+        (target: unknown): void;
+    };
     /**
      * Checks if the source type is identical to the target type.
      */

package/build/index.d.ts

@@ -59,6 +59,31 @@ interface Test {
     todo: (name: string, callback?: () => void | Promise<void>) => void;
 }
 interface Matchers {
+    /**
+     * Checks if the JSX component accepts props of the given type.
+     *
+     * @remarks
+     *
+     * This is a work in progress feature. Generic components are not yet supported.
+     */
+    toAcceptProps: {
+        /**
+         * Checks if the JSX component accepts props of the given type.
+         *
+         * @remarks
+         *
+         * This is a work in progress feature. Generic components are not yet supported.
+         */
+        <Target>(): void;
+        /**
+         * Checks if the JSX component accepts the given props.
+         *
+         * @remarks
+         *
+         * This is a work in progress feature. Generic components are not yet supported.
+         */
+        (target: unknown): void;
+    };
     /**
      * Checks if the source type is identical to the target type.
      */

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.
  */
@@ -221,12 +274,12 @@ declare enum Color {
     Gray = "90"
 }
 
-type ScribblerNode = Array<ScribblerNode> | ScribblerJsx.Element | string | undefined;
+type ScribblerNode = Array<ScribblerNode> | ScribblerJsx.Element | string | number | undefined;
 type FunctionComponent = (props: Record<string, unknown>) => ScribblerJsx.Element;
 declare namespace ScribblerJsx {
     interface Element {
         props: Record<string, unknown>;
-        type: FunctionComponent | string;
+        type: FunctionComponent | number | string;
     }
     interface ElementChildrenAttribute {
         children: ScribblerNode;
@@ -280,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;
@@ -436,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;
@@ -448,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, }: {
@@ -603,6 +601,8 @@ declare class EventEmitter {
     removeHandlers(): void;
 }
 
+type ArgumentNode = ts.Expression | ts.TypeNode;
+type DiagnosticsHandler = (diagnostics: Diagnostic | Array<Diagnostic>) => void;
 interface MatchResult {
     explain: () => Array<Diagnostic>;
     isMatch: boolean;
@@ -617,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(index: number, count: number, 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;
@@ -699,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 {
@@ -791,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;
 }
@@ -799,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, ConfigDiagnosticText, 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, OptionGroup, OutputService, type OutputServiceOptions, Path, ProjectResult, ProjectService, type ReadStream, type ResolvedConfig, Result, ResultCount, ResultHandler, ResultStatus, ResultTiming, type RunCallback, 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 };
+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 };