@jest/test-result

addResult: (aggregatedResults: AggregatedResult, testResult: TestResult) => void;

buildFailureTestResult: (
    testPath: string,
    err: TestResult_2.SerializableError
) => TestResult;

createEmptyTestResult: () => TestResult;

formatTestResults: (
    results: AggregatedResult,
    codeCoverageFormatter?: CodeCoverageFormatter,
    reporter?: CodeCoverageReporter
) => FormattedTestResults;

makeEmptyAggregatedTestResult: () => AggregatedResult;

type AggregatedResult = AggregatedResultWithoutCoverage & {
    coverageMap?: CoverageMap | null;
};

type AssertionLocation = {
    fullName: string;
    path: string;
};

type AssertionResult = TestResult_2.AssertionResult;

type FailedAssertion = {
    matcherName?: string;
    message?: string;
    actual?: unknown;
    pass?: boolean;
    passed?: boolean;
    expected?: unknown;
    isNot?: boolean;
    stack?: string;
    error?: unknown;
};

type FormattedTestResults = {
    coverageMap?: CoverageMap | null | undefined;
    numFailedTests: number;
    numFailedTestSuites: number;
    numPassedTests: number;
    numPassedTestSuites: number;
    numPendingTests: number;
    numPendingTestSuites: number;
    numRuntimeErrorTestSuites: number;
    numTotalTests: number;
    numTotalTestSuites: number;
    snapshot: SnapshotSummary;
    startTime: number;
    success: boolean;
    testResults: Array<FormattedTestResult>;
    wasInterrupted: boolean;
};

type SerializableError = TestResult_2.SerializableError;

type SnapshotSummary = {
    added: number;
    didUpdate: boolean;
    failure: boolean;
    filesAdded: number;
    filesRemoved: number;
    filesRemovedList: Array<string>;
    filesUnmatched: number;
    filesUpdated: number;
    matched: number;
    total: number;
    unchecked: number;
    uncheckedKeysByFile: Array<UncheckedSnapshot>;
    unmatched: number;
    updated: number;
};

type Status = AssertionResult['status'];

type Suite = {
    title: string;
    suites: Array<Suite>;
    tests: Array<AssertionResult>;
};

type Test = {
    context: TestContext;
    duration?: number;
    path: string;
};

type TestCaseResult = AssertionResult;

type TestContext = {
    config: Config.ProjectConfig;
    hasteFS: IHasteFS;
    moduleMap: IModuleMap;
    resolver: Resolver;
};

type TestEvents = {
    'test-file-start': [Test];
    'test-file-success': [Test, TestResult];
    'test-file-failure': [Test, SerializableError];
    'test-case-start': [string, Circus.TestCaseStartInfo];
    'test-case-result': [string, AssertionResult];
};

type TestFileEvent<T extends keyof TestEvents = keyof TestEvents> = (
    eventName: T,
    args: TestEvents[T]
) => unknown;

type TestResult = {
    console?: ConsoleBuffer;
    coverage?: CoverageMapData;
    displayName?: Config.DisplayName;
    failureMessage?: string | null;
    leaks: boolean;
    memoryUsage?: number;
    numFailingTests: number;
    numPassingTests: number;
    numPendingTests: number;
    numTodoTests: number;
    openHandles: Array<Error>;
    perfStats: {
        end: number;
        runtime: number;
        slow: boolean;
        start: number;
    };
    skipped: boolean;
    snapshot: {
        added: number;
        fileDeleted: boolean;
        matched: number;
        unchecked: number;
        uncheckedKeys: Array<string>;
        unmatched: number;
        updated: number;
    };
    testExecError?: SerializableError;
    testFilePath: string;
    testResults: Array<AssertionResult>;
    v8Coverage?: V8CoverageResult;
};

type TestResultsProcessor = (
    results: AggregatedResult
) => AggregatedResult | Promise<AggregatedResult>;

type V8CoverageResult = Array<{
    codeTransformResult: RuntimeTransformResult | undefined;
    result: V8Coverage[number];
}>;