jest-jasmine2

buildCollectedTestResult: ({
    config,
    suite,
    testNamePattern,
    testPath,
}: {
    config: Config.ProjectConfig;
    suite: SuiteLike;
    testNamePattern: string | undefined;
    testPath: string;
}) => TestResult;

collectSpecs: (
    suite: SuiteLike,
    ancestors: Array<string>,
    testNamePatternRE: RegExp | null
) => Array<AssertionResult>;

createSpy: (name: string, originalFn: Fn) => Spy;

expectationResultFactory: (
    options: Options,
    initError?: Error
) => FailedAssertion;

jasmine2: (
    globalConfig: Config.GlobalConfig,
    config: Config.ProjectConfig,
    environment: JestEnvironment,
    runtime: Runtime,
    testPath: string
) => Promise<TestResult>;

jasmineEnv: (
    j$: Jasmine
) => new () => {
    specFilter: (spec: Spec) => boolean;
    catchExceptions: (value: unknown) => boolean;
    throwOnExpectationFailure: (value: unknown) => void;
    catchingExceptions: () => boolean;
    topSuite: () => Suite;
    fail: (error: Error | AssertionErrorWithStack) => void;
    pending: (message: string) => void;
    afterAll: (afterAllFunction: QueueableFn['fn'], timeout?: number) => void;
    fit: (
        description: Circus.TestNameLike,
        fn: QueueableFn['fn'],
        timeout?: number
    ) => Spec;
    throwingExpectationFailures: () => boolean;
    randomizeTests: (value: unknown) => void;
    randomTests: () => boolean;
    seed: (value: unknown) => unknown;
    execute: (runnablesToRun?: Array<string>, suiteTree?: Suite) => Promise<void>;
    fdescribe: (
        description: Circus.TestNameLike,
        specDefinitions: SpecDefinitionsFn
    ) => Suite;
    spyOn: (
        obj: Record<string, Spy>,
        methodName: string,
        accessType?: keyof PropertyDescriptor
    ) => Spy;
    beforeEach: (beforeEachFunction: QueueableFn['fn'], timeout?: number) => void;
    afterEach: (afterEachFunction: QueueableFn['fn'], timeout?: number) => void;
    clearReporters: () => void;
    addReporter: (reporterToAdd: Reporter) => void;
    it: (
        description: Circus.TestNameLike,
        fn: QueueableFn['fn'],
        timeout?: number
    ) => Spec;
    xdescribe: (
        description: Circus.TestNameLike,
        specDefinitions: SpecDefinitionsFn
    ) => Suite;
    xit: (
        description: Circus.TestNameLike,
        fn: QueueableFn['fn'],
        timeout?: number
    ) => Spec;
    beforeAll: (beforeAllFunction: QueueableFn['fn'], timeout?: number) => void;
    todo: () => Spec;
    provideFallbackReporter: (reporterToAdd: Reporter) => void;
    allowRespy: (allow: boolean) => void;
    describe: (
        description: Circus.TestNameLike,
        specDefinitions: SpecDefinitionsFn
    ) => Suite;
};

queueRunner: (
    options: Options_2
) => PromiseLike<void> & {
    cancel: () => void;
    catch: (onRejected?: PromiseCallback) => Promise<void>;
};

type Jasmine = {
    _DEFAULT_TIMEOUT_INTERVAL: number;
    DEFAULT_TIMEOUT_INTERVAL: number;
    currentEnv_: ReturnType<typeof jasmineEnv>['prototype'];
    getEnv: () => ReturnType<typeof jasmineEnv>['prototype'];
    createSpy: typeof createSpy;
    Env: ReturnType<typeof jasmineEnv>;
    JsApiReporter: typeof JsApiReporter;
    ReportDispatcher: typeof ReportDispatcher;
    Spec: typeof Spec;
    SpyRegistry: typeof SpyRegistry;
    Suite: typeof Suite;
    Timer: typeof Timer;
    version: string;
    testPath: string;
    addMatchers: (matchers: JasmineMatchersObject) => void;
} & AsymmetricMatchers & {
        process: typeof Process;
    };

type SpecLike = {
    description: string;
    getFullName: () => string;
};

type SuiteLike = {
    children: Array<SuiteLike | SpecLike>;
    description: string;
};