wct-local

arch: string;

baseURL: string;

version: string;

basePath?: string;

baseURL?: string;

drivers?: {
    [browserName: string]: DriverConfig;
    // chrome?: DriverConfig;
    // ie?: DriverConfig;
    // ... complete list?
};

logger?: (message: any) => void;

progressCb?: (
    totalLength: number,
    progressLength: number,
    chunkLength: number
) => void;

version: string;

basePath?: string;

cb?: (err: any, child: child_process.ChildProcess) => void;

drivers?: {
    [browserName: string]: DriverConfig;
    // chrome?: DriverConfig;
    // ie?: DriverConfig;
    // ... complete list?
};

javaArgs?: string[];

javaPath?: string;

seleniumArgs?: string[];

spawnCb?: Function;

spawnOptions?: child_process.SpawnOptions;

constructor(options: Config);

static Context: typeof Context;

options: Config;

emitHook: {
    (
        name: 'prepare:webserver',
        app: express.Application,
        done: (err?: any) => void
    ): Context;
    (name: 'configure', done: (err?: any) => void): Context;
    (name: 'prepare', done: (err?: any) => void): Context;
    (name: 'cleanup', done: (err?: any) => void): Context;
    (name: string, done: (err?: any) => void): Context;
    (name: string, ...args: any[]): Context;
};

enabledPlugins: () => string[];

hook: (name: string, handler: Handler) => void;

hookLate: (name: string, handler: Handler) => void;

pluginOptions: (name: string) => any;

plugins: (done: (err: any, plugins?: Plugin[]) => void) => void;

constructor(packageName: string, metadata: Metadata);

cliConfig: Config;

metadata: Metadata;

name: string;

packageName: string;

static Plugin: typeof Plugin;

execute: (context: Context, done: (message?: string) => void) => void;

static get: (name: string, done: (err: any, plugin?: Plugin) => void) => void;

static shortName: (name: string) => string;

deviceName?: string;

id: number;

sessionId: string;

url: wd.ValidHost;

activeBrowsers: BrowserDef[];

browserOptions: {
    [name: string]: wd.Capabilities;
};

clientOptions: {
    root: string;
    verbose?: boolean;
};

enforceJsonConf: boolean;

expanded: boolean;

extraScripts: string[];

origSuites?: string[];

output: NodeJS.WritableStream;

persistent: boolean;

plugins:
    | (string | boolean)[]
    | {
          [key: string]:
              | {
                    disabled: boolean;
                }
              | boolean;
      };

quiet?: boolean;

registerHooks: (wct: Context) => void;

remote?: {};

root: string;

sauce?: {};

simpleOutput?: boolean;

skipCleanup?: boolean;

skipPlugins?: boolean;

skipUpdateCheck?: boolean;

suites: string[];

testTimeout: number;

ttyOutput: boolean;

verbose: boolean;

webserver: {
    port: number;
    hostname: string;
    pathMappings: {
        [urlPath: string]: string;
    }[];
    urlPrefix: string;
    webRunnerPath?: string;
    webRunnerContent?: string;
    staticContent?: {
        [file: string]: string;
    };
};

'cli-options': Config;

(context: Context, pluginOptions: any, pluginMeta: Plugin): void;

failing?: number;

passing?: number;

pending?: number;

status: string;

attach: (sessionId: string, callback: NodeCB<Capabilities>) => void;

configureHttp: (options: { retries: number }) => void;

get: (url: string, callback: NodeCB<void>) => void;

init: (capabilities: Capabilities, callback: NodeCB<string>) => void;

on: (eventName: string, handler: Function) => void;

quit: (callback: NodeCB<void>) => void;

'moz:firefoxOptions'?: {
    args?: string[];
};

'phantomjs.binary.path'?: string;

'safari.options'?: {
    skipExtensionInstallation?: boolean;
};

browserName:
    | 'android'
    | 'chrome'
    | 'firefox'
    | 'htmlunit'
    | 'internet explorer'
    | 'iPhone'
    | 'iPad'
    | 'opera'
    | 'safari'
    | 'phantomjs';

chromeOptions?: {
    binary?: string;
    args?: string[];
};

cssSelectorsEnabled?: boolean;

firefox_binary?: string;

handlesAlerts?: boolean;

marionette?: boolean;

platform?:
    | 'WINDOWS'
    | 'XP'
    | 'VISTA'
    | 'MAC'
    | 'LINUX'
    | 'UNIX'
    | 'ANDROID'
    | 'ANY';

selenium?: {
    server: {
        url: string;
    };
};

version: string;

webdriver?: {
    remote: {
        quietExceptions: boolean;
    };
};

(err: any, value: T): void;