@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;

makeCollectedTestResult: (
    testResults: Array<AssertionResult>,
    {
        displayName,
        testFilePath,
    }: { displayName: Config.DisplayName; testFilePath: string }
) => TestResult;

makeEmptyAggregatedTestResult: () => AggregatedResult;

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

type AggregatedResultWithoutCoverage = {
    numFailedTests: number;
    numFailedTestSuites: number;
    numPassedTests: number;
    numPassedTestSuites: number;
    numPendingTests: number;
    numTodoTests: number;
    numPendingTestSuites: number;
    numRuntimeErrorTestSuites: number;
    numTotalTests: number;
    numTotalTestSuites: number;
    openHandles: Array<Error>;
    snapshot: SnapshotSummary;
    startTime: number;
    success: boolean;
    testResults: Array<TestResult>;
    wasInterrupted: boolean;
    runExecError?: SerializableError;
};

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

type AssertionResult = TestResult_2.AssertionResult;

type CodeCoverageFormatter = (
    coverage: CoverageMapData | null | undefined,
    reporter: CodeCoverageReporter
) => Record<string, unknown> | null | undefined;

type CodeCoverageReporter = unknown;

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

type FormattedAssertionResult = Pick<
    AssertionResult,
    'ancestorTitles' | 'fullName' | 'location' | 'status' | 'title' | 'duration'
> & {
    failureMessages: AssertionResult['failureMessages'] | null;
};

type FormattedTestResult = {
    message: string;
    name: string;
    summary: string;
    status: 'failed' | 'passed' | 'skipped' | 'focused';
    startTime: number;
    endTime: number;
    coverage: unknown;
    assertionResults: Array<FormattedAssertionResult>;
};

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 RuntimeTransformResult = TransformTypes.TransformResult;

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 & {
    startedAt?: number | null;
};

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, TestCaseResult];
};

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

type TestResult = {
    console?: ConsoleBuffer;
    coverage?: CoverageMapData;
    displayName?: Config.DisplayName;
    /**
     * Whether [`test.failing()`](https://jestjs.io/docs/api#testfailingname-fn-timeout)
     * was used.
     */
    failing?: boolean;
    failureMessage?: string | null;
    leaks: boolean;
    memoryUsage?: number;
    numFailingTests: number;
    numPassingTests: number;
    numPendingTests: number;
    numTodoTests: number;
    openHandles: Array<Error>;
    perfStats: {
        end: number;
        loadTestEnvironmentEnd: number;
        loadTestEnvironmentStart: number;
        runtime: number;
        setupAfterEnvEnd: number;
        setupAfterEnvStart: number;
        setupFilesEnd: number;
        setupFilesStart: 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 UncheckedSnapshot = {
    filePath: string;
    keys: Array<string>;
};

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