Aurora.3/tgui/packages/tgui-bench/lib/benchmark.d.ts

/* eslint-disable */
// Type definitions for Benchmark v2.1.4
// Project: https://benchmarkjs.com
// Definitions by: Asana <https://asana.com>
//                 Charlie Fish <https://github.com/fishcharlie>
//                 Blair Zajac <https://github.com/blair>
// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped

declare class Benchmark {
  static filter<T>(arr: T[], callback: (value: T) => any, thisArg?: any): T[];
  static filter<T>(arr: T[], filter: string, thisArg?: any): T[];
  static formatNumber(num: number): string;
  static join(obj: Object, separator1?: string, separator2?: string): string;
  static invoke(
    benches: Benchmark[],
    name: string | Object,
    ...args: any[]
  ): any[];
  static runInContext(context: Object): Function;

  static each(obj: Object | any[], callback: Function, thisArg?: any): void;
  static forEach<T>(arr: T[], callback: (value: T) => any, thisArg?: any): void;
  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 map<T, K>(arr: T[], callback: (value: T) => K, thisArg?: any): K[];
  static reduce<T, K>(
    arr: T[],
    callback: (accumulator: K, value: T) => K,
    thisArg?: any,
  ): K;

  static options: Benchmark.Options;
  static platform: Benchmark.Platform;
  static support: Benchmark.Support;
  static version: string;

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

  id: number;
  name: string;
  count: number;
  cycles: number;
  hz: number;
  compiled: Function | string;
  error: Error;
  fn: Function | string;
  aborted: boolean;
  running: boolean;
  setup: Function | string;
  teardown: Function | string;

  stats: Benchmark.Stats;
  times: Benchmark.Times;

  abort(): Benchmark;
  clone(options: Benchmark.Options): Benchmark;
  compare(benchmark: Benchmark): number;
  emit(type: string | Object): any;
  listeners(type: string): Function[];
  off(type?: string, listener?: Function): Benchmark;
  off(types: string[]): Benchmark;
  on(type?: string, listener?: Function): Benchmark;
  on(types: string[]): Benchmark;
  reset(): Benchmark;
  run(options?: Benchmark.Options): Benchmark;
  toString(): string;
}

declare namespace Benchmark {
  export interface Options {
    async?: boolean | undefined;
    defer?: boolean | undefined;
    delay?: number | 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;
    setup?: Function | string | undefined;
    teardown?: Function | string | undefined;
    fn?: Function | string | undefined;
    queued?: boolean | undefined;
  }

  export interface Platform {
    description: string;
    layout: string;
    product: string;
    name: string;
    manufacturer: string;
    os: string;
    prerelease: string;
    version: string;
    toString(): string;
  }

  export interface Support {
    browser: boolean;
    timeout: boolean;
    decompilation: boolean;
  }

  export interface Stats {
    moe: number;
    rme: number;
    sem: number;
    deviation: number;
    mean: number;
    sample: any[];
    variance: number;
  }

  export interface Times {
    cycle: number;
    elapsed: number;
    period: number;
    timeStamp: number;
  }

  export class Deferred {
    constructor(clone: Benchmark);

    benchmark: Benchmark;
    cycles: number;
    elapsed: number;
    timeStamp: number;

    resolve(): void;
  }

  export interface Target {
    options: Options;
    async?: boolean | undefined;
    defer?: boolean | undefined;
    delay?: number | undefined;
    initCount?: number | undefined;
    maxTime?: number | undefined;
    minSamples?: number | undefined;
    minTime?: number | undefined;
    name?: string | undefined;
    fn?: Function | undefined;
    id: number;
    stats?: Stats | undefined;
    times?: Times | undefined;
    running: boolean;
    count?: number | undefined;
    compiled?: Function | undefined;
    cycles?: number | undefined;
    hz?: number | undefined;
  }

  export class Event {
    constructor(type: string | Object);

    aborted: boolean;
    cancelled: boolean;
    currentTarget: Object;
    result: any;
    target: Target;
    timeStamp: number;
    type: string;
  }

  export class Suite {
    static options: { name: string };

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

    length: number;
    aborted: boolean;
    running: boolean;

    abort(): Suite;
    add(name: string, fn: Function | string, options?: Options): Suite;
    add(fn: Function | string, options?: Options): Suite;
    add(name: string, options?: Options): Suite;
    add(options: Options): Suite;
    clone(options: Options): Suite;
    emit(type: string | Object): any;
    filter(callback: Function | string): Suite;
    join(separator?: string): string;
    listeners(type: string): Function[];
    off(type?: string, callback?: Function): Suite;
    off(types: string[]): Suite;
    on(type?: string, callback?: Function): Suite;
    on(types: string[]): Suite;
    push(benchmark: Benchmark): number;
    reset(): Suite;
    run(options?: Options): Suite;
    reverse(): any[];
    sort(compareFn: (a: any, b: any) => number): any[];
    splice(start: number, deleteCount?: number): any[];
    unshift(benchmark: Benchmark): number;

    each(callback: Function): Suite;
    forEach(callback: Function): Suite;
    indexOf(value: any): number;
    map(callback: Function | string): any[];
    reduce<T>(callback: Function, accumulator: T): T;

    pop(): Function;
    shift(): Benchmark;
    slice(start: number, end: number): any[];
    slice(start: number, deleteCount: number, ...values: any[]): any[];
  }
}

export = Benchmark;