tape

const skip: any;

const test: Harness;

createHarness: (conf_?: HarnessConfig) => Harness;

createStream: (opts?: StreamOptions) => ThroughStream;

getHarness: (opts?: HarnessConfig) => Harness;

harnessFunction: {
    (this: Test, name: string, opts: tape.TestOptions, cb: Test.TestCase): Test;
    (this: Test, name: string, opts: tape.TestOptions): Test;
    (this: Test, name: string, cb: Test.TestCase): Test;
    (this: Test, name: string): Test;
    (this: Test, opts: tape.TestOptions, cb: Test.TestCase): Test;
    (this: Test, opts: tape.TestOptions): Test;
    (this: Test, cb: Test.TestCase): Test;
    (this: void, name: string, opts: tape.TestOptions, cb: Test.TestCase): Test;
    (this: void, name: string, opts: tape.TestOptions): Test;
    (this: void, name: string, cb: Test.TestCase): Test;
    (this: void, name: string): Test;
    (this: void, opts: tape.TestOptions, cb: Test.TestCase): Test;
    (this: void, opts: tape.TestOptions): Test;
    (this: void, cb: Test.TestCase): Test;
};

onFailure: (cb: Test.SyncCallback, ...rest: unknown[]) => void;

onFinish: (cb: Test.SyncCallback, ...rest: unknown[]) => void;

only: {
    (name: string, cb: Test.TestCase): void;
    (name: string, opts: TestOptions, cb: Test.TestCase): void;
    (cb: Test.TestCase): void;
    (opts: TestOptions, cb?: Test.TestCase): void;
};

run: () => void;

tape: typeof tape;

wait: () => void;

type Callback = Test.Callback;

type CreateStream = typeof createStream;

type Harness = typeof harnessFunction & {
    run?: () => void;
    only: typeof only;
    _exitCode: number;
    _results: Results;
    _tests: Test[];
    close: () => void;
    createStream: CreateStream;
    onFailure: HarnessEventHandler;
    onFinish: HarnessEventHandler;
};

type HarnessConfig = {
    autoclose?: boolean;
    noOnly?: boolean;
    stream?: NodeJS.WritableStream | ThroughStream;
    exit?: boolean;
} & StreamOptions;

type HarnessEventHandler = (cb: Test.SyncCallback, ...rest: unknown[]) => void;

type InterceptResults = Test.InterceptResults;

type RestoreFunction = Test.RestoreFunction;

type SyncCallback = Test.SyncCallback;

type SyncOrAsyncCallback = Test.Callback;

type TestCase = Test.TestCase;

type TestOptions = {
    objectPrintDepth?: number | undefined;
    skip?: boolean | string | undefined;
    timeout?: number | undefined;
    ignoreSyncTimeout?: boolean;
    todo?: boolean | string | undefined;
};

type WrapObject<T extends Test.Callback> = Test.WrapObject<T>;

type WrappedCall = Test.WrappedCall;

type WrappedFn<T extends Test.Callback> = Test.WrappedFn<T>;

type WrapResults = Test.WrapResults;