@types/benchmark

constructor(fn: string | Function, options?: Benchmark.Options);

constructor(name: string, fn: string | Function, options?: Benchmark.Options);

constructor(name: string, options?: Benchmark.Options);

constructor(options: Benchmark.Options);

aborted: boolean;

compiled: string | Function;

count: number;

cycles: number;

error: Error;

fn: string | Function;

hz: number;

id: number;

name?: string;

static options: Benchmark.Options;

static platform: Benchmark.Platform;

running: boolean;

setup: string | Function;

stats: Benchmark.Stats;

static support: Benchmark.Support;

teardown: string | Function;

times: Benchmark.Times;

static version: string;

abort: () => Benchmark;

clone: (options: Benchmark.Options) => Benchmark;

compare: (benchmark: Benchmark) => number;

static each: (obj: Object | any[], callback: Function, thisArg?: any) => void;

emit: (type: string | Object) => any;

static filter: {
    <T>(arr: T[], callback: (value: T) => any, thisArg?: any): T[];
    <T>(arr: T[], filter: string, thisArg?: any): T[];
};

static forEach: <T>(
    arr: T[],
    callback: (value: T) => any,
    thisArg?: any
) => void;

static formatNumber: (num: number) => string;

static forOwn: (obj: Object, callback: Function, thisArg?: any) => void;

static has: (obj: Object, path: any[] | string) => boolean;

static indexOf: <T>(arr: T[], value: T, fromIndex?: number) => number;

static invoke: (
    benches: Benchmark[],
    name: string | Object,
    ...args: any[]
) => any[];

static join: (obj: Object, separator1?: string, separator2?: string) => string;

listeners: (type: string) => Function[];

static map: <T, K>(arr: T[], callback: (value: T) => K, thisArg?: any) => K[];

off: {
    (type?: string, listener?: Function): Benchmark;
    (types: string[]): Benchmark;
};

on: {
    (type?: string, listener?: Function): Benchmark;
    (types: string[]): Benchmark;
};

static reduce: <T, K>(
    arr: T[],
    callback: (accumulator: K, value: T) => K,
    thisArg?: any
) => K;

reset: () => Benchmark;

run: (options?: Benchmark.Options) => Benchmark;

static runInContext: (context: Object) => Function;

toString: () => string;

constructor(clone: Benchmark);

benchmark: Benchmark;

cycles: number;

elapsed: number;

timeStamp: number;

resolve: () => void;

constructor(type: string | Object);

aborted: boolean;

cancelled: boolean;

currentTarget: Object;

result: any;

target: Target;

timeStamp: number;

type: string;

constructor(name?: string, options?: Options);

constructor(options?: Options);

aborted: boolean;

length: number;

name?: string;

static options: { name: string };

running: boolean;

abort: () => Suite;

add: {
    (name: string, fn: Function | string, options?: Options): Suite;
    (fn: string | Function, options?: Options): Suite;
    (name: string, options?: Options): Suite;
    (options: Options): Suite;
};

clone: (options: Options) => Suite;

each: (callback: Function) => Suite;

emit: (type: string | Object) => any;

filter: (callback: Function | string) => Suite;

forEach: (callback: Function) => Suite;

indexOf: (value: any) => number;

join: (separator?: string) => string;

listeners: (type: string) => Function[];

map: (callback: Function | string) => any[];

off: { (type?: string, callback?: Function): Suite; (types: string[]): Suite };

on: { (type?: string, callback?: Function): Suite; (types: string[]): Suite };

pop: () => Function;

push: (benchmark: Benchmark) => number;

reduce: <T>(callback: Function, accumulator: T) => T;

reset: () => Suite;

reverse: () => any[];

run: (options?: Options) => Suite;

shift: () => Benchmark;

slice: {
    (start: number, end: number): any[];
    (start: number, deleteCount: number, ...values: any[]): any[];
};

sort: (compareFn: (a: any, b: any) => number) => any[];

splice: (start: number, deleteCount?: number) => any[];

unshift: (benchmark: Benchmark) => number;

async?: boolean | undefined;

defer?: boolean | undefined;

delay?: number | undefined;

fn?: Function | string | undefined;

id?: string | undefined;

initCount?: number | undefined;

maxTime?: number | undefined;

minSamples?: number | undefined;

minTime?: number | undefined;

name?: string | undefined;

onAbort?: Function | undefined;

onComplete?: Function | undefined;

onCycle?: Function | undefined;

onError?: Function | undefined;

onReset?: Function | undefined;

onStart?: Function | undefined;

queued?: boolean | undefined;

setup?: Function | string | undefined;

teardown?: Function | string | undefined;

description: string;

layout: string;

manufacturer: string;

name: string;

os: string;

prerelease: string;

product: string;

version: string;

toString: () => string;

deviation: number;

mean: number;

moe: number;

rme: number;

sample: any[];

sem: number;

variance: number;

browser: boolean;

decompilation: boolean;

timeout: boolean;

async?: boolean | undefined;

compiled?: Function | undefined;

count?: number | undefined;

cycles?: number | undefined;

defer?: boolean | undefined;

delay?: number | undefined;

fn?: Function | undefined;

hz?: number | undefined;

id: number;

initCount?: number | undefined;

maxTime?: number | undefined;

minSamples?: number | undefined;

minTime?: number | undefined;

name?: string | undefined;

options: Options;

running: boolean;

stats?: Stats | undefined;

times?: Times | undefined;

cycle: number;

elapsed: number;

period: number;

timeStamp: number;