angular2

angular2

Version 2.0.0-beta.21
Published 8 years ago
No dependencies
MIT license

Install

npm i angular2

yarn add angular2

pnpm add angular2

Overview

Angular 2 - a web framework for modern web apps

Index

Namespaces

assert
buffer
- INSPECT_MAX_BYTES
child_process
cluster
constants
crypto
dgram
dns
domain
- create()
- Domain
es6-collections
es6-promise
- Promise
events
- EventEmitter
fs
hammerjs
- Hammer
http
https
net
os
path
path.posix
path.win32
protractor
protractor.error
- Error
- ErrorCode
protractor.ExpectedConditions
protractor.logging
protractor.promise
protractor.stacktrace
protractor.until
punycode
querystring
readline
repl
- ReplOptions
- start()
selenium-webdriver
selenium-webdriver.By
selenium-webdriver.error
selenium-webdriver.logging
selenium-webdriver.promise
selenium-webdriver.stacktrace
selenium-webdriver.until
selenium-webdriver/chrome
selenium-webdriver/executors
- createExecutor()
selenium-webdriver/firefox
selenium-webdriver/testing
stream
string_decoder
- NodeStringDecoder
- StringDecoder
tls
tty
url
util
vm
zlib

Namespaces

namespace assert

module 'assert' {}

variable doesNotThrow

var doesNotThrow: {
    (block: Function, message?: string): void;
    (block: Function, error: Function, message?: string): void;
    (block: Function, error: RegExp, message?: string): void;
    (block: Function, error: (err: any) => boolean, message?: string): void;
};

variable throws

var throws: {
    (block: Function, message?: string): void;
    (block: Function, error: Function, message?: string): void;
    (block: Function, error: RegExp, message?: string): void;
    (block: Function, error: (err: any) => boolean, message?: string): void;
};

function deepEqual

deepEqual: (actual: any, expected: any, message?: string) => void;

function deepStrictEqual

deepStrictEqual: (actual: any, expected: any, message?: string) => void;

function equal

equal: (actual: any, expected: any, message?: string) => void;

function fail

fail: (
    actual?: any,
    expected?: any,
    message?: string,
    operator?: string
) => void;

function ifError

ifError: (value: any) => void;

function internal

internal: typeof internal;

function notDeepEqual

notDeepEqual: (acutal: any, expected: any, message?: string) => void;

function notDeepStrictEqual

notDeepStrictEqual: (actual: any, expected: any, message?: string) => void;

function notEqual

notEqual: (actual: any, expected: any, message?: string) => void;

function notStrictEqual

notStrictEqual: (actual: any, expected: any, message?: string) => void;

function ok

ok: (value: any, message?: string) => void;

function strictEqual

strictEqual: (actual: any, expected: any, message?: string) => void;

class AssertionError

class AssertionError implements Error {}

constructor

constructor(options?: {
    message?: string;
    actual?: any;
    expected?: any;
    operator?: string;
    stackStartFunction?: Function;
});

property actual

actual: any;

property expected

expected: any;

property generatedMessage

generatedMessage: boolean;

property message

message: string;

property name

name: string;

property operator

operator: string;

namespace buffer

module 'buffer' {}

********************************************** * MODULES * * **********************************************

variable INSPECT_MAX_BYTES

var INSPECT_MAX_BYTES: number;

namespace child_process

module 'child_process' {}

function exec

exec: {
    (
        command: string,
        options: {
            cwd?: string;
            stdio?: any;
            customFds?: any;
            env?: any;
            encoding?: string;
            timeout?: number;
            maxBuffer?: number;
            killSignal?: string;
        },
        callback?: (error: Error, stdout: Buffer, stderr: Buffer) => void
    ): ChildProcess;
    (
        command: string,
        callback?: (error: Error, stdout: Buffer, stderr: Buffer) => void
    ): ChildProcess;
};

function execFile

execFile: {
    (
        file: string,
        callback?: (error: Error, stdout: Buffer, stderr: Buffer) => void
    ): ChildProcess;
    (
        file: string,
        args?: string[],
        callback?: (error: Error, stdout: Buffer, stderr: Buffer) => void
    ): ChildProcess;
    (
        file: string,
        args?: string[],
        options?: {
            cwd?: string;
            stdio?: any;
            customFds?: any;
            env?: any;
            encoding?: string;
            timeout?: number;
            maxBuffer?: number;
            killSignal?: string;
        },
        callback?: (error: Error, stdout: Buffer, stderr: Buffer) => void
    ): ChildProcess;
};

function execFileSync

execFileSync: (
    command: string,
    args?: string[],
    options?: {
        cwd?: string;
        input?: string | Buffer;
        stdio?: any;
        env?: any;
        uid?: number;
        gid?: number;
        timeout?: number;
        maxBuffer?: number;
        killSignal?: string;
        encoding?: string;
    }
) => string | Buffer;

function execSync

execSync: (
    command: string,
    options?: {
        cwd?: string;
        input?: string | Buffer;
        stdio?: any;
        env?: any;
        uid?: number;
        gid?: number;
        timeout?: number;
        maxBuffer?: number;
        killSignal?: string;
        encoding?: string;
    }
) => string | Buffer;

function fork

fork: (
    modulePath: string,
    args?: string[],
    options?: {
        cwd?: string;
        env?: any;
        execPath?: string;
        execArgv?: string[];
        silent?: boolean;
        uid?: number;
        gid?: number;
    }
) => ChildProcess;

function spawn

spawn: (
    command: string,
    args?: string[],
    options?: {
        cwd?: string;
        stdio?: any;
        custom?: any;
        env?: any;
        detached?: boolean;
    }
) => ChildProcess;

function spawnSync

spawnSync: (
    command: string,
    args?: string[],
    options?: {
        cwd?: string;
        input?: string | Buffer;
        stdio?: any;
        env?: any;
        uid?: number;
        gid?: number;
        timeout?: number;
        maxBuffer?: number;
        killSignal?: string;
        encoding?: string;
    }
) => {
    pid: number;
    output: string[];
    stdout: string | Buffer;
    stderr: string | Buffer;
    status: number;
    signal: string;
    error: Error;
};

interface ChildProcess

interface ChildProcess extends events.EventEmitter {}

property pid

pid: number;

property stderr

stderr: stream.Readable;

property stdin

stdin: stream.Writable;

property stdout

stdout: stream.Readable;

method disconnect

disconnect: () => void;

method kill

kill: (signal?: string) => void;

method send

send: (message: any, sendHandle?: any) => void;

method unref

unref: () => void;

namespace cluster

module 'cluster' {}

variable isMaster

var isMaster: boolean;

variable isWorker

var isWorker: boolean;

variable settings

var settings: ClusterSettings;

variable worker

var worker: Worker;

variable workers

var workers: Worker[];

function addListener

addListener: (event: string, listener: Function) => void;

function disconnect

disconnect: (callback?: Function) => void;

function emit

emit: (event: string, ...args: any[]) => boolean;

function fork

fork: (env?: any) => Worker;

function listeners

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

function on

on: (event: string, listener: Function) => any;

function once

once: (event: string, listener: Function) => void;

function removeAllListeners

removeAllListeners: (event?: string) => void;

function removeListener

removeListener: (event: string, listener: Function) => void;

function setMaxListeners

setMaxListeners: (n: number) => void;

function setupMaster

setupMaster: (settings?: ClusterSettings) => void;

class Worker

class Worker extends events.EventEmitter {}

property id

id: string;

property process

process: child.ChildProcess;

property suicide

suicide: boolean;

method destroy

destroy: (signal?: string) => void;

method disconnect

disconnect: () => void;

method kill

kill: (signal?: string) => void;

method send

send: (message: any, sendHandle?: any) => void;

interface ClusterSettings

interface ClusterSettings {}

property args

args?: string[];

property exec

exec?: string;

property silent

silent?: boolean;

namespace constants

module 'constants' {}

variable DH_CHECK_P_NOT_PRIME

var DH_CHECK_P_NOT_PRIME: number;

variable DH_CHECK_P_NOT_SAFE_PRIME

var DH_CHECK_P_NOT_SAFE_PRIME: number;

variable DH_NOT_SUITABLE_GENERATOR

var DH_NOT_SUITABLE_GENERATOR: number;

variable DH_UNABLE_TO_CHECK_GENERATOR

var DH_UNABLE_TO_CHECK_GENERATOR: number;

variable E2BIG

var E2BIG: number;

variable EACCES

var EACCES: number;

variable EADDRINUSE

var EADDRINUSE: number;

variable EADDRNOTAVAIL

var EADDRNOTAVAIL: number;

variable EAFNOSUPPORT

var EAFNOSUPPORT: number;

variable EAGAIN

var EAGAIN: number;

variable EALREADY

var EALREADY: number;

variable EBADF

var EBADF: number;

variable EBADMSG

var EBADMSG: number;

variable EBUSY

var EBUSY: number;

variable ECANCELED

var ECANCELED: number;

variable ECHILD

var ECHILD: number;

variable ECONNABORTED

var ECONNABORTED: number;

variable ECONNREFUSED

var ECONNREFUSED: number;

variable ECONNRESET

var ECONNRESET: number;

variable EDEADLK

var EDEADLK: number;

variable EDESTADDRREQ

var EDESTADDRREQ: number;

variable EDOM

var EDOM: number;

variable EEXIST

var EEXIST: number;

variable EFAULT

var EFAULT: number;

variable EFBIG

var EFBIG: number;

variable EHOSTUNREACH

var EHOSTUNREACH: number;

variable EIDRM

var EIDRM: number;

variable EILSEQ

var EILSEQ: number;

variable EINPROGRESS

var EINPROGRESS: number;

variable EINTR

var EINTR: number;

variable EINVAL

var EINVAL: number;

variable EIO

var EIO: number;

variable EISCONN

var EISCONN: number;

variable EISDIR

var EISDIR: number;

variable ELOOP

var ELOOP: number;

variable EMFILE

var EMFILE: number;

variable EMLINK

var EMLINK: number;

variable EMSGSIZE

var EMSGSIZE: number;

variable ENAMETOOLONG

var ENAMETOOLONG: number;

variable ENETDOWN

var ENETDOWN: number;

variable ENETRESET

var ENETRESET: number;

variable ENETUNREACH

var ENETUNREACH: number;

variable ENFILE

var ENFILE: number;

variable ENGINE_METHOD_ALL

var ENGINE_METHOD_ALL: number;

variable ENGINE_METHOD_CIPHERS

var ENGINE_METHOD_CIPHERS: number;

variable ENGINE_METHOD_DH

var ENGINE_METHOD_DH: number;

variable ENGINE_METHOD_DIGESTS

var ENGINE_METHOD_DIGESTS: number;

variable ENGINE_METHOD_DSA

var ENGINE_METHOD_DSA: number;

variable ENGINE_METHOD_ECDH

var ENGINE_METHOD_ECDH: number;

variable ENGINE_METHOD_ECDSA

var ENGINE_METHOD_ECDSA: number;

variable ENGINE_METHOD_NONE

var ENGINE_METHOD_NONE: number;

variable ENGINE_METHOD_PKEY_ASN1_METHS

var ENGINE_METHOD_PKEY_ASN1_METHS: number;

variable ENGINE_METHOD_PKEY_METHS

var ENGINE_METHOD_PKEY_METHS: number;

variable ENGINE_METHOD_RAND

var ENGINE_METHOD_RAND: number;

variable ENGINE_METHOD_STORE

var ENGINE_METHOD_STORE: number;

variable ENOBUFS

var ENOBUFS: number;

variable ENODATA

var ENODATA: number;

variable ENODEV

var ENODEV: number;

variable ENOENT

var ENOENT: number;

variable ENOEXEC

var ENOEXEC: number;

variable ENOLCK

var ENOLCK: number;

variable ENOLINK

var ENOLINK: number;

variable ENOMEM

var ENOMEM: number;

variable ENOMSG

var ENOMSG: number;

variable ENOPROTOOPT

var ENOPROTOOPT: number;

variable ENOSPC

var ENOSPC: number;

variable ENOSR

var ENOSR: number;

variable ENOSTR

var ENOSTR: number;

variable ENOSYS

var ENOSYS: number;

variable ENOTCONN

var ENOTCONN: number;

variable ENOTDIR

var ENOTDIR: number;

variable ENOTEMPTY

var ENOTEMPTY: number;

variable ENOTSOCK

var ENOTSOCK: number;

variable ENOTSUP

var ENOTSUP: number;

variable ENOTTY

var ENOTTY: number;

variable ENXIO

var ENXIO: number;

variable EOPNOTSUPP

var EOPNOTSUPP: number;

variable EOVERFLOW

var EOVERFLOW: number;

variable EPERM

var EPERM: number;

variable EPIPE

var EPIPE: number;

variable EPROTO

var EPROTO: number;

variable EPROTONOSUPPORT

var EPROTONOSUPPORT: number;

variable EPROTOTYPE

var EPROTOTYPE: number;

variable ERANGE

var ERANGE: number;

variable EROFS

var EROFS: number;

variable ESPIPE

var ESPIPE: number;

variable ESRCH

var ESRCH: number;

variable ETIME

var ETIME: number;

variable ETIMEDOUT

var ETIMEDOUT: number;

variable ETXTBSY

var ETXTBSY: number;

variable EWOULDBLOCK

var EWOULDBLOCK: number;

variable EXDEV

var EXDEV: number;

variable F_OK

var F_OK: number;

variable NPN_ENABLED

var NPN_ENABLED: number;

variable O_APPEND

var O_APPEND: number;

variable O_CREAT

var O_CREAT: number;

variable O_EXCL

var O_EXCL: number;

variable O_RDONLY

var O_RDONLY: number;

variable O_RDWR

var O_RDWR: number;

variable O_TRUNC

var O_TRUNC: number;

variable O_WRONLY

var O_WRONLY: number;

variable POINT_CONVERSION_COMPRESSED

var POINT_CONVERSION_COMPRESSED: number;

variable POINT_CONVERSION_HYBRID

var POINT_CONVERSION_HYBRID: number;

variable POINT_CONVERSION_UNCOMPRESSED

var POINT_CONVERSION_UNCOMPRESSED: number;

variable R_OK

var R_OK: number;

variable RSA_NO_PADDING

var RSA_NO_PADDING: number;

variable RSA_PKCS1_OAEP_PADDING

var RSA_PKCS1_OAEP_PADDING: number;

variable RSA_PKCS1_PADDING

var RSA_PKCS1_PADDING: number;

variable RSA_PKCS1_PSS_PADDING

var RSA_PKCS1_PSS_PADDING: number;

variable RSA_SSLV23_PADDING

var RSA_SSLV23_PADDING: number;

variable RSA_X931_PADDING

var RSA_X931_PADDING: number;

variable S_IFCHR

var S_IFCHR: number;

variable S_IFDIR

var S_IFDIR: number;

variable S_IFLNK

var S_IFLNK: number;

variable S_IFMT

var S_IFMT: number;

variable S_IFREG

var S_IFREG: number;

variable SIGABRT

var SIGABRT: number;

variable SIGBREAK

var SIGBREAK: number;

variable SIGFPE

var SIGFPE: number;

variable SIGHUP

var SIGHUP: number;

variable SIGILL

var SIGILL: number;

variable SIGINT

var SIGINT: number;

variable SIGKILL

var SIGKILL: number;

variable SIGSEGV

var SIGSEGV: number;

variable SIGTERM

var SIGTERM: number;

variable SIGWINCH

var SIGWINCH: number;

variable SSL_OP_ALL

var SSL_OP_ALL: number;

variable SSL_OP_ALLOW_UNSAFE_LEGACY_RENEGOTIATION

var SSL_OP_ALLOW_UNSAFE_LEGACY_RENEGOTIATION: number;

variable SSL_OP_CIPHER_SERVER_PREFERENCE

var SSL_OP_CIPHER_SERVER_PREFERENCE: number;

variable SSL_OP_CISCO_ANYCONNECT

var SSL_OP_CISCO_ANYCONNECT: number;

variable SSL_OP_COOKIE_EXCHANGE

var SSL_OP_COOKIE_EXCHANGE: number;

variable SSL_OP_CRYPTOPRO_TLSEXT_BUG

var SSL_OP_CRYPTOPRO_TLSEXT_BUG: number;

variable SSL_OP_DONT_INSERT_EMPTY_FRAGMENTS

var SSL_OP_DONT_INSERT_EMPTY_FRAGMENTS: number;

variable SSL_OP_EPHEMERAL_RSA

var SSL_OP_EPHEMERAL_RSA: number;

variable SSL_OP_LEGACY_SERVER_CONNECT

var SSL_OP_LEGACY_SERVER_CONNECT: number;

variable SSL_OP_MICROSOFT_BIG_SSLV3_BUFFER

var SSL_OP_MICROSOFT_BIG_SSLV3_BUFFER: number;

variable SSL_OP_MICROSOFT_SESS_ID_BUG

var SSL_OP_MICROSOFT_SESS_ID_BUG: number;

variable SSL_OP_MSIE_SSLV2_RSA_PADDING

var SSL_OP_MSIE_SSLV2_RSA_PADDING: number;

variable SSL_OP_NETSCAPE_CA_DN_BUG

var SSL_OP_NETSCAPE_CA_DN_BUG: number;

variable SSL_OP_NETSCAPE_CHALLENGE_BUG

var SSL_OP_NETSCAPE_CHALLENGE_BUG: number;

variable SSL_OP_NETSCAPE_DEMO_CIPHER_CHANGE_BUG

var SSL_OP_NETSCAPE_DEMO_CIPHER_CHANGE_BUG: number;

variable SSL_OP_NETSCAPE_REUSE_CIPHER_CHANGE_BUG

var SSL_OP_NETSCAPE_REUSE_CIPHER_CHANGE_BUG: number;

variable SSL_OP_NO_COMPRESSION

var SSL_OP_NO_COMPRESSION: number;

variable SSL_OP_NO_QUERY_MTU

var SSL_OP_NO_QUERY_MTU: number;

variable SSL_OP_NO_SESSION_RESUMPTION_ON_RENEGOTIATION

var SSL_OP_NO_SESSION_RESUMPTION_ON_RENEGOTIATION: number;

variable SSL_OP_NO_SSLv2

var SSL_OP_NO_SSLv2: number;

variable SSL_OP_NO_SSLv3

var SSL_OP_NO_SSLv3: number;

variable SSL_OP_NO_TICKET

var SSL_OP_NO_TICKET: number;

variable SSL_OP_NO_TLSv1

var SSL_OP_NO_TLSv1: number;

variable SSL_OP_NO_TLSv1_1

var SSL_OP_NO_TLSv1_1: number;

variable SSL_OP_NO_TLSv1_2

var SSL_OP_NO_TLSv1_2: number;

variable SSL_OP_PKCS1_CHECK_1

var SSL_OP_PKCS1_CHECK_1: number;

variable SSL_OP_PKCS1_CHECK_2

var SSL_OP_PKCS1_CHECK_2: number;

variable SSL_OP_SINGLE_DH_USE

var SSL_OP_SINGLE_DH_USE: number;

variable SSL_OP_SINGLE_ECDH_USE

var SSL_OP_SINGLE_ECDH_USE: number;

variable SSL_OP_SSLEAY_080_CLIENT_DH_BUG

var SSL_OP_SSLEAY_080_CLIENT_DH_BUG: number;

variable SSL_OP_SSLREF2_REUSE_CERT_TYPE_BUG

var SSL_OP_SSLREF2_REUSE_CERT_TYPE_BUG: number;

variable SSL_OP_TLS_BLOCK_PADDING_BUG

var SSL_OP_TLS_BLOCK_PADDING_BUG: number;

variable SSL_OP_TLS_D5_BUG

var SSL_OP_TLS_D5_BUG: number;

variable SSL_OP_TLS_ROLLBACK_BUG

var SSL_OP_TLS_ROLLBACK_BUG: number;

variable UV_UDP_REUSEADDR

var UV_UDP_REUSEADDR: number;

variable W_OK

var W_OK: number;

variable WSA_E_CANCELLED

var WSA_E_CANCELLED: number;

variable WSA_E_NO_MORE

var WSA_E_NO_MORE: number;

variable WSAEACCES

var WSAEACCES: number;

variable WSAEADDRINUSE

var WSAEADDRINUSE: number;

variable WSAEADDRNOTAVAIL

var WSAEADDRNOTAVAIL: number;

variable WSAEAFNOSUPPORT

var WSAEAFNOSUPPORT: number;

variable WSAEALREADY

var WSAEALREADY: number;

variable WSAEBADF

var WSAEBADF: number;

variable WSAECANCELLED

var WSAECANCELLED: number;

variable WSAECONNABORTED

var WSAECONNABORTED: number;

variable WSAECONNREFUSED

var WSAECONNREFUSED: number;

variable WSAECONNRESET

var WSAECONNRESET: number;

variable WSAEDESTADDRREQ

var WSAEDESTADDRREQ: number;

variable WSAEDISCON

var WSAEDISCON: number;

variable WSAEDQUOT

var WSAEDQUOT: number;

variable WSAEFAULT

var WSAEFAULT: number;

variable WSAEHOSTDOWN

var WSAEHOSTDOWN: number;

variable WSAEHOSTUNREACH

var WSAEHOSTUNREACH: number;

variable WSAEINPROGRESS

var WSAEINPROGRESS: number;

variable WSAEINTR

var WSAEINTR: number;

variable WSAEINVAL

var WSAEINVAL: number;

variable WSAEINVALIDPROCTABLE

var WSAEINVALIDPROCTABLE: number;

variable WSAEINVALIDPROVIDER

var WSAEINVALIDPROVIDER: number;

variable WSAEISCONN

var WSAEISCONN: number;

variable WSAELOOP

var WSAELOOP: number;

variable WSAEMFILE

var WSAEMFILE: number;

variable WSAEMSGSIZE

var WSAEMSGSIZE: number;

variable WSAENAMETOOLONG

var WSAENAMETOOLONG: number;

variable WSAENETDOWN

var WSAENETDOWN: number;

variable WSAENETRESET

var WSAENETRESET: number;

variable WSAENETUNREACH

var WSAENETUNREACH: number;

variable WSAENOBUFS

var WSAENOBUFS: number;

variable WSAENOMORE

var WSAENOMORE: number;

variable WSAENOPROTOOPT

var WSAENOPROTOOPT: number;

variable WSAENOTCONN

var WSAENOTCONN: number;

variable WSAENOTEMPTY

var WSAENOTEMPTY: number;

variable WSAENOTSOCK

var WSAENOTSOCK: number;

variable WSAEOPNOTSUPP

var WSAEOPNOTSUPP: number;

variable WSAEPFNOSUPPORT

var WSAEPFNOSUPPORT: number;

variable WSAEPROCLIM

var WSAEPROCLIM: number;

variable WSAEPROTONOSUPPORT

var WSAEPROTONOSUPPORT: number;

variable WSAEPROTOTYPE

var WSAEPROTOTYPE: number;

variable WSAEPROVIDERFAILEDINIT

var WSAEPROVIDERFAILEDINIT: number;

variable WSAEREFUSED

var WSAEREFUSED: number;

variable WSAEREMOTE

var WSAEREMOTE: number;

variable WSAESHUTDOWN

var WSAESHUTDOWN: number;

variable WSAESOCKTNOSUPPORT

var WSAESOCKTNOSUPPORT: number;

variable WSAESTALE

var WSAESTALE: number;

variable WSAETIMEDOUT

var WSAETIMEDOUT: number;

variable WSAETOOMANYREFS

var WSAETOOMANYREFS: number;

variable WSAEUSERS

var WSAEUSERS: number;

variable WSAEWOULDBLOCK

var WSAEWOULDBLOCK: number;

variable WSANOTINITIALISED

var WSANOTINITIALISED: number;

variable WSASERVICE_NOT_FOUND

var WSASERVICE_NOT_FOUND: number;

variable WSASYSCALLFAILURE

var WSASYSCALLFAILURE: number;

variable WSASYSNOTREADY

var WSASYSNOTREADY: number;

variable WSATYPE_NOT_FOUND

var WSATYPE_NOT_FOUND: number;

variable WSAVERNOTSUPPORTED

var WSAVERNOTSUPPORTED: number;

variable X_OK

var X_OK: number;

namespace crypto

module 'crypto' {}

function createCipher

createCipher: (algorithm: string, password: any) => Cipher;

function createCipheriv

createCipheriv: (algorithm: string, key: any, iv: any) => Cipher;

function createCredentials

createCredentials: (details: CredentialDetails) => Credentials;

function createDecipher

createDecipher: (algorithm: string, password: any) => Decipher;

function createDecipheriv

createDecipheriv: (algorithm: string, key: any, iv: any) => Decipher;

function createDiffieHellman

createDiffieHellman: {
    (prime_length: number): DiffieHellman;
    (prime: number, encoding?: string): DiffieHellman;
};

function createHash

createHash: (algorithm: string) => Hash;

function createHmac

createHmac: {
    (algorithm: string, key: string): Hmac;
    (algorithm: string, key: Buffer): Hmac;
};

function createSign

createSign: (algorithm: string) => Signer;

function createVerify

createVerify: (algorith: string) => Verify;

function getDiffieHellman

getDiffieHellman: (group_name: string) => DiffieHellman;

function pbkdf2

pbkdf2: {
    (
        password: string | Buffer,
        salt: string | Buffer,
        iterations: number,
        keylen: number,
        callback: (err: Error, derivedKey: Buffer) => any
    ): void;
    (
        password: string | Buffer,
        salt: string | Buffer,
        iterations: number,
        keylen: number,
        digest: string,
        callback: (err: Error, derivedKey: Buffer) => any
    ): void;
};

function pbkdf2Sync

pbkdf2Sync: {
    (
        password: string | Buffer,
        salt: string | Buffer,
        iterations: number,
        keylen: number
    ): Buffer;
    (
        password: string | Buffer,
        salt: string | Buffer,
        iterations: number,
        keylen: number,
        digest: string
    ): Buffer;
};

function pseudoRandomBytes

pseudoRandomBytes: {
    (size: number): Buffer;
    (size: number, callback: (err: Error, buf: Buffer) => void): void;
};

function randomBytes

randomBytes: {
    (size: number): Buffer;
    (size: number, callback: (err: Error, buf: Buffer) => void): void;
};

interface Cipher

interface Cipher {}

method final

final: { (): Buffer; (output_encoding: string): string };

method setAutoPadding

setAutoPadding: (auto_padding: boolean) => void;

method update

update: {
    (data: Buffer): Buffer;
    (data: string, input_encoding?: string, output_encoding?: string): string;
};

interface CredentialDetails

interface CredentialDetails {}

property ca

ca: any;

property cert

cert: string;

property ciphers

ciphers: string;

property crl

crl: any;

property key

key: string;

property passphrase

passphrase: string;

property pfx

pfx: string;

interface Credentials

interface Credentials {}

property context

context?: any;

interface Decipher

interface Decipher {}

method final

final: { (): Buffer; (output_encoding: string): string };

method setAutoPadding

setAutoPadding: (auto_padding: boolean) => void;

method update

update: {
    (data: Buffer): Buffer;
    (data: string, input_encoding?: string, output_encoding?: string): string;
};

interface DiffieHellman

interface DiffieHellman {}

method computeSecret

computeSecret: (
    other_public_key: string,
    input_encoding?: string,
    output_encoding?: string
) => string;

method generateKeys

generateKeys: (encoding?: string) => string;

method getGenerator

getGenerator: (encoding: string) => string;

method getPrime

getPrime: (encoding?: string) => string;

method getPrivateKey

getPrivateKey: (encoding?: string) => string;

method getPublicKey

getPublicKey: (encoding?: string) => string;

method setPrivateKey

setPrivateKey: (public_key: string, encoding?: string) => void;

method setPublicKey

setPublicKey: (public_key: string, encoding?: string) => void;

interface Hash

interface Hash {}

method digest

digest: { (encoding: 'buffer'): Buffer; (encoding: string): any; (): Buffer };

method update

update: (data: any, input_encoding?: string) => Hash;

interface Hmac

interface Hmac {}

method digest

digest: { (encoding: 'buffer'): Buffer; (encoding: string): any; (): Buffer };

method update

update: (data: any, input_encoding?: string) => Hmac;

interface Signer

interface Signer extends NodeJS.WritableStream {}

method sign

sign: (private_key: string, output_format: string) => string;

method update

update: (data: any) => void;

interface Verify

interface Verify extends NodeJS.WritableStream {}

method update

update: (data: any) => void;

method verify

verify: (
    object: string,
    signature: string,
    signature_format?: string
) => boolean;

namespace dgram

module 'dgram' {}

function createSocket

createSocket: (
    type: string,
    callback?: (msg: Buffer, rinfo: RemoteInfo) => void
) => Socket;

interface AddressInfo

interface AddressInfo {}

property address

address: string;

property family

family: string;

property port

port: number;

interface RemoteInfo

interface RemoteInfo {}

property address

address: string;

property port

port: number;

property size

size: number;

interface Socket

interface Socket extends events.EventEmitter {}

method addMembership

addMembership: (multicastAddress: string, multicastInterface?: string) => void;

method address

address: () => AddressInfo;

method bind

bind: (port: number, address?: string, callback?: () => void) => void;

method close

close: () => void;

method dropMembership

dropMembership: (multicastAddress: string, multicastInterface?: string) => void;

method send

send: (
    buf: Buffer,
    offset: number,
    length: number,
    port: number,
    address: string,
    callback?: (error: Error, bytes: number) => void
) => void;

method setBroadcast

setBroadcast: (flag: boolean) => void;

method setMulticastLoopback

setMulticastLoopback: (flag: boolean) => void;

method setMulticastTTL

setMulticastTTL: (ttl: number) => void;

namespace dns

module 'dns' {}

function lookup

lookup: {
    (
        domain: string,
        family: number,
        callback: (err: Error, address: string, family: number) => void
    ): string;
    (
        domain: string,
        callback: (err: Error, address: string, family: number) => void
    ): string;
};

function resolve

resolve: {
    (
        domain: string,
        rrtype: string,
        callback: (err: Error, addresses: string[]) => void
    ): string[];
    (domain: string, callback: (err: Error, addresses: string[]) => void): string[];
};

function resolve4

resolve4: (
    domain: string,
    callback: (err: Error, addresses: string[]) => void
) => string[];

function resolve6

resolve6: (
    domain: string,
    callback: (err: Error, addresses: string[]) => void
) => string[];

function resolveCname

resolveCname: (
    domain: string,
    callback: (err: Error, addresses: string[]) => void
) => string[];

function resolveMx

resolveMx: (
    domain: string,
    callback: (err: Error, addresses: string[]) => void
) => string[];

function resolveNs

resolveNs: (
    domain: string,
    callback: (err: Error, addresses: string[]) => void
) => string[];

function resolveSrv

resolveSrv: (
    domain: string,
    callback: (err: Error, addresses: string[]) => void
) => string[];

function resolveTxt

resolveTxt: (
    domain: string,
    callback: (err: Error, addresses: string[]) => void
) => string[];

function reverse

reverse: (
    ip: string,
    callback: (err: Error, domains: string[]) => void
) => string[];

namespace domain

module 'domain' {}

function create

create: () => Domain;

class Domain

class Domain extends events.EventEmitter {}

method add

add: (emitter: events.EventEmitter) => void;

method addListener

addListener: (event: string, listener: Function) => Domain;

method bind

bind: (cb: (err: Error, data: any) => any) => any;

method dispose

dispose: () => void;

method intercept

intercept: (cb: (data: any) => any) => any;

method on

on: (event: string, listener: Function) => Domain;

method once

once: (event: string, listener: Function) => Domain;

method remove

remove: (emitter: events.EventEmitter) => void;

method removeAllListeners

removeAllListeners: (event?: string) => Domain;

method removeListener

removeListener: (event: string, listener: Function) => Domain;

method run

run: (fn: Function) => void;

namespace es6-collections

module 'es6-collections' {}

variable Map

var Map: MapConstructor;

variable Set

var Set: SetConstructor;

variable WeakMap

var WeakMap: WeakMapConstructor;

variable WeakSet

var WeakSet: WeakSetConstructor;

namespace es6-promise

module 'es6-promise' {}

variable Promise

var Promise: PromiseConstructor;

namespace events

module 'events' {}

class EventEmitter

class EventEmitter implements NodeJS.EventEmitter {}

property defaultMaxListeners

static defaultMaxListeners: number;

property EventEmitter

static EventEmitter: EventEmitter;

method addListener

addListener: (event: string, listener: Function) => EventEmitter;

method emit

emit: (event: string, ...args: any[]) => boolean;

method getMaxListeners

getMaxListeners: () => number;

method listenerCount

static listenerCount: (emitter: EventEmitter, event: string) => number;

method listeners

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

method on

on: (event: string, listener: Function) => EventEmitter;

method once

once: (event: string, listener: Function) => EventEmitter;

method removeAllListeners

removeAllListeners: (event?: string) => EventEmitter;

method removeListener

removeListener: (event: string, listener: Function) => EventEmitter;

method setMaxListeners

setMaxListeners: (n: number) => EventEmitter;

namespace fs

module 'fs' {}

variable F_OK

var F_OK: number;

Constant for fs.access(). File is visible to the calling process.

variable R_OK

var R_OK: number;

Constant for fs.access(). File can be read by the calling process.

variable W_OK

var W_OK: number;

Constant for fs.access(). File can be written by the calling process.

variable X_OK

var X_OK: number;

Constant for fs.access(). File can be executed by the calling process.

function access

access: {
    (path: string, callback: (err: NodeJS.ErrnoException) => void): void;
    (
        path: string,
        mode: number,
        callback: (err: NodeJS.ErrnoException) => void
    ): void;
};

Tests a user's permissions for the file specified by path.

function accessSync

accessSync: (path: string, mode?: number) => void;

Synchronous version of fs.access. This throws if any accessibility checks fail, and does nothing otherwise.

function appendFile

appendFile: {
    (
        filename: string,
        data: any,
        options: { encoding?: string; mode?: number; flag?: string },
        callback?: (err: NodeJS.ErrnoException) => void
    ): void;
    (
        filename: string,
        data: any,
        options: { encoding?: string; mode?: string; flag?: string },
        callback?: (err: NodeJS.ErrnoException) => void
    ): void;
    (
        filename: string,
        data: any,
        callback?: (err: NodeJS.ErrnoException) => void
    ): void;
};

function appendFileSync

appendFileSync: {
    (
        filename: string,
        data: any,
        options?: { encoding?: string; mode?: number; flag?: string }
    ): void;
    (
        filename: string,
        data: any,
        options?: { encoding?: string; mode?: string; flag?: string }
    ): void;
};

function chmod

chmod: {
    (
        path: string,
        mode: number,
        callback?: (err?: NodeJS.ErrnoException) => void
    ): void;
    (
        path: string,
        mode: string,
        callback?: (err?: NodeJS.ErrnoException) => void
    ): void;
};

function chmodSync

chmodSync: {
    (path: string, mode: number): void;
    (path: string, mode: string): void;
};

function chown

chown: (
    path: string,
    uid: number,
    gid: number,
    callback?: (err?: NodeJS.ErrnoException) => void
) => void;

function chownSync

chownSync: (path: string, uid: number, gid: number) => void;

function close

close: (fd: number, callback?: (err?: NodeJS.ErrnoException) => void) => void;

function closeSync

closeSync: (fd: number) => void;

function createReadStream

createReadStream: (
    path: string,
    options?: {
        flags?: string;
        encoding?: string;
        fd?: number;
        mode?: number;
        autoClose?: boolean;
    }
) => ReadStream;

function createWriteStream

createWriteStream: (
    path: string,
    options?: { flags?: string; encoding?: string; fd?: number; mode?: number }
) => WriteStream;

function exists

exists: (path: string, callback?: (exists: boolean) => void) => void;

function existsSync

existsSync: (path: string) => boolean;

function fchmod

fchmod: {
    (
        fd: number,
        mode: number,
        callback?: (err?: NodeJS.ErrnoException) => void
    ): void;
    (
        fd: number,
        mode: string,
        callback?: (err?: NodeJS.ErrnoException) => void
    ): void;
};

function fchmodSync

fchmodSync: {
    (fd: number, mode: number): void;
    (fd: number, mode: string): void;
};

function fchown

fchown: (
    fd: number,
    uid: number,
    gid: number,
    callback?: (err?: NodeJS.ErrnoException) => void
) => void;

function fchownSync

fchownSync: (fd: number, uid: number, gid: number) => void;

function fstat

fstat: (
    fd: number,
    callback?: (err: NodeJS.ErrnoException, stats: Stats) => any
) => void;

function fstatSync

fstatSync: (fd: number) => Stats;

function fsync

fsync: (fd: number, callback?: (err?: NodeJS.ErrnoException) => void) => void;

function fsyncSync

fsyncSync: (fd: number) => void;

function ftruncate

ftruncate: {
    (fd: number, callback?: (err?: NodeJS.ErrnoException) => void): void;
    (
        fd: number,
        len: number,
        callback?: (err?: NodeJS.ErrnoException) => void
    ): void;
};

function ftruncateSync

ftruncateSync: (fd: number, len?: number) => void;

function futimes

futimes: {
    (
        fd: number,
        atime: number,
        mtime: number,
        callback?: (err?: NodeJS.ErrnoException) => void
    ): void;
    (
        fd: number,
        atime: Date,
        mtime: Date,
        callback?: (err?: NodeJS.ErrnoException) => void
    ): void;
};

function futimesSync

futimesSync: {
    (fd: number, atime: number, mtime: number): void;
    (fd: number, atime: Date, mtime: Date): void;
};

function lchmod

lchmod: {
    (
        path: string,
        mode: number,
        callback?: (err?: NodeJS.ErrnoException) => void
    ): void;
    (
        path: string,
        mode: string,
        callback?: (err?: NodeJS.ErrnoException) => void
    ): void;
};

function lchmodSync

lchmodSync: {
    (path: string, mode: number): void;
    (path: string, mode: string): void;
};

function lchown

lchown: (
    path: string,
    uid: number,
    gid: number,
    callback?: (err?: NodeJS.ErrnoException) => void
) => void;

function lchownSync

lchownSync: (path: string, uid: number, gid: number) => void;

function link

link: (
    srcpath: string,
    dstpath: string,
    callback?: (err?: NodeJS.ErrnoException) => void
) => void;

function linkSync

linkSync: (srcpath: string, dstpath: string) => void;

function lstat

lstat: (
    path: string,
    callback?: (err: NodeJS.ErrnoException, stats: Stats) => any
) => void;

function lstatSync

lstatSync: (path: string) => Stats;

function mkdir

mkdir: {
    (path: string, callback?: (err?: NodeJS.ErrnoException) => void): void;
    (
        path: string,
        mode: number,
        callback?: (err?: NodeJS.ErrnoException) => void
    ): void;
    (
        path: string,
        mode: string,
        callback?: (err?: NodeJS.ErrnoException) => void
    ): void;
};

function mkdirSync

mkdirSync: {
    (path: string, mode?: number): void;
    (path: string, mode?: string): void;
};

function open

open: {
    (
        path: string,
        flags: string,
        callback?: (err: NodeJS.ErrnoException, fd: number) => any
    ): void;
    (
        path: string,
        flags: string,
        mode: number,
        callback?: (err: NodeJS.ErrnoException, fd: number) => any
    ): void;
    (
        path: string,
        flags: string,
        mode: string,
        callback?: (err: NodeJS.ErrnoException, fd: number) => any
    ): void;
};

function openSync

openSync: {
    (path: string, flags: string, mode?: number): number;
    (path: string, flags: string, mode?: string): number;
};

function read

read: (
    fd: number,
    buffer: Buffer,
    offset: number,
    length: number,
    position: number,
    callback?: (
        err: NodeJS.ErrnoException,
        bytesRead: number,
        buffer: Buffer
    ) => void
) => void;

function readdir

readdir: (
    path: string,
    callback?: (err: NodeJS.ErrnoException, files: string[]) => void
) => void;

function readdirSync

readdirSync: (path: string) => string[];

function readFile

readFile: {
    (
        filename: string,
        encoding: string,
        callback: (err: NodeJS.ErrnoException, data: string) => void
    ): void;
    (
        filename: string,
        options: { encoding: string; flag?: string },
        callback: (err: NodeJS.ErrnoException, data: string) => void
    ): void;
    (
        filename: string,
        options: { flag?: string },
        callback: (err: NodeJS.ErrnoException, data: Buffer) => void
    ): void;
    (
        filename: string,
        callback: (err: NodeJS.ErrnoException, data: Buffer) => void
    ): void;
};

function readFileSync

readFileSync: {
    (filename: string, encoding: string): string;
    (filename: string, options: { encoding: string; flag?: string }): string;
    (filename: string, options?: { flag?: string }): Buffer;
};

function readlink

readlink: (
    path: string,
    callback?: (err: NodeJS.ErrnoException, linkString: string) => any
) => void;

function readlinkSync

readlinkSync: (path: string) => string;

function readSync

readSync: (
    fd: number,
    buffer: Buffer,
    offset: number,
    length: number,
    position: number
) => number;

function realpath

realpath: {
    (
        path: string,
        callback?: (err: NodeJS.ErrnoException, resolvedPath: string) => any
    ): void;
    (
        path: string,
        cache: { [path: string]: string },
        callback: (err: NodeJS.ErrnoException, resolvedPath: string) => any
    ): void;
};

function realpathSync

realpathSync: (path: string, cache?: { [path: string]: string }) => string;

function rename

rename: (
    oldPath: string,
    newPath: string,
    callback?: (err?: NodeJS.ErrnoException) => void
) => void;

Asynchronous rename.
Parameter oldPath
Parameter newPath
Parameter callback
No arguments other than a possible exception are given to the completion callback.

function renameSync

renameSync: (oldPath: string, newPath: string) => void;

Synchronous rename
Parameter oldPath
Parameter newPath

function rmdir

rmdir: (path: string, callback?: (err?: NodeJS.ErrnoException) => void) => void;

function rmdirSync

rmdirSync: (path: string) => void;

function stat

stat: (
    path: string,
    callback?: (err: NodeJS.ErrnoException, stats: Stats) => any
) => void;

function statSync

statSync: (path: string) => Stats;

function symlink

symlink: (
    srcpath: string,
    dstpath: string,
    type?: string,
    callback?: (err?: NodeJS.ErrnoException) => void
) => void;

function symlinkSync

symlinkSync: (srcpath: string, dstpath: string, type?: string) => void;

function truncate

truncate: {
    (path: string, callback?: (err?: NodeJS.ErrnoException) => void): void;
    (
        path: string,
        len: number,
        callback?: (err?: NodeJS.ErrnoException) => void
    ): void;
};

function truncateSync

truncateSync: (path: string, len?: number) => void;

function unlink

unlink: (path: string, callback?: (err?: NodeJS.ErrnoException) => void) => void;

function unlinkSync

unlinkSync: (path: string) => void;

function unwatchFile

unwatchFile: (
    filename: string,
    listener?: (curr: Stats, prev: Stats) => void
) => void;

function utimes

utimes: {
    (
        path: string,
        atime: number,
        mtime: number,
        callback?: (err?: NodeJS.ErrnoException) => void
    ): void;
    (
        path: string,
        atime: Date,
        mtime: Date,
        callback?: (err?: NodeJS.ErrnoException) => void
    ): void;
};

function utimesSync

utimesSync: {
    (path: string, atime: number, mtime: number): void;
    (path: string, atime: Date, mtime: Date): void;
};

function watch

watch: {
    (
        filename: string,
        listener?: (event: string, filename: string) => any
    ): FSWatcher;
    (
        filename: string,
        options: { persistent?: boolean },
        listener?: (event: string, filename: string) => any
    ): FSWatcher;
};

function watchFile

watchFile: {
    (filename: string, listener: (curr: Stats, prev: Stats) => void): void;
    (
        filename: string,
        options: { persistent?: boolean; interval?: number },
        listener: (curr: Stats, prev: Stats) => void
    ): void;
};

function write

write: {
    (
        fd: number,
        buffer: Buffer,
        offset: number,
        length: number,
        position: number,
        callback?: (
            err: NodeJS.ErrnoException,
            written: number,
            buffer: Buffer
        ) => void
    ): void;
    (
        fd: number,
        buffer: Buffer,
        offset: number,
        length: number,
        callback?: (
            err: NodeJS.ErrnoException,
            written: number,
            buffer: Buffer
        ) => void
    ): void;
    (
        fd: number,
        data: any,
        callback?: (err: NodeJS.ErrnoException, written: number, str: string) => void
    ): void;
    (
        fd: number,
        data: any,
        offset: number,
        callback?: (err: NodeJS.ErrnoException, written: number, str: string) => void
    ): void;
    (
        fd: number,
        data: any,
        offset: number,
        encoding: string,
        callback?: (err: NodeJS.ErrnoException, written: number, str: string) => void
    ): void;
};

function writeFile

writeFile: {
    (
        filename: string,
        data: any,
        callback?: (err: NodeJS.ErrnoException) => void
    ): void;
    (
        filename: string,
        data: any,
        options: { encoding?: string; mode?: number; flag?: string },
        callback?: (err: NodeJS.ErrnoException) => void
    ): void;
    (
        filename: string,
        data: any,
        options: { encoding?: string; mode?: string; flag?: string },
        callback?: (err: NodeJS.ErrnoException) => void
    ): void;
};

function writeFileSync

writeFileSync: {
    (
        filename: string,
        data: any,
        options?: { encoding?: string; mode?: number; flag?: string }
    ): void;
    (
        filename: string,
        data: any,
        options?: { encoding?: string; mode?: string; flag?: string }
    ): void;
};

function writeSync

writeSync: (
    fd: number,
    buffer: Buffer,
    offset: number,
    length: number,
    position: number
) => number;

interface FSWatcher

interface FSWatcher extends events.EventEmitter {}

method close

close: () => void;

interface ReadStream

interface ReadStream extends stream.Readable {}

method close

close: () => void;

interface Stats

interface Stats {}

property atime

atime: Date;

property birthtime

birthtime: Date;

property blksize

blksize: number;

property blocks

blocks: number;

property ctime

ctime: Date;

property dev

dev: number;

property gid

gid: number;

property ino

ino: number;

property mode

mode: number;

property mtime

mtime: Date;

property nlink

nlink: number;

property rdev

rdev: number;

property size

size: number;

property uid

uid: number;

method isBlockDevice

isBlockDevice: () => boolean;

method isCharacterDevice

isCharacterDevice: () => boolean;

method isDirectory

isDirectory: () => boolean;

method isFIFO

isFIFO: () => boolean;

method isFile

isFile: () => boolean;

method isSocket

isSocket: () => boolean;

method isSymbolicLink

isSymbolicLink: () => boolean;

interface WriteStream

interface WriteStream extends stream.Writable {}

property bytesWritten

bytesWritten: number;

method close

close: () => void;

namespace hammerjs

module 'hammerjs' {}

variable Hammer

var Hammer: HammerStatic;

namespace http

module 'http' {}

variable globalAgent

var globalAgent: Agent;

variable METHODS

var METHODS: string[];

variable STATUS_CODES

var STATUS_CODES: { [errorCode: number]: string; [errorCode: string]: string };

function createClient

createClient: (port?: number, host?: string) => any;

function createServer

createServer: (
    requestListener?: (request: IncomingMessage, response: ServerResponse) => void
) => Server;

function get

get: (options: any, callback?: (res: IncomingMessage) => void) => ClientRequest;

function request

request: (
    options: RequestOptions,
    callback?: (res: IncomingMessage) => void
) => ClientRequest;

class Agent

class Agent {}

constructor

constructor(opts?: AgentOptions);

property maxSockets

maxSockets: number;

property requests

requests: any;

property sockets

sockets: any;

method destroy

destroy: () => void;

Destroy any sockets that are currently in use by the agent. It is usually not necessary to do this. However, if you are using an agent with KeepAlive enabled, then it is best to explicitly shut down the agent when you know that it will no longer be used. Otherwise, sockets may hang open for quite a long time before the server terminates them.

interface AgentOptions

interface AgentOptions {}

property keepAlive

keepAlive?: boolean;

Keep sockets around in a pool to be used by other requests in the future. Default = false

property keepAliveMsecs

keepAliveMsecs?: number;

When using HTTP KeepAlive, how often to send TCP KeepAlive packets over sockets being kept alive. Default = 1000. Only relevant if keepAlive is set to true.

property maxFreeSockets

maxFreeSockets?: number;

Maximum number of sockets to leave open in a free state. Only relevant if keepAlive is set to true. Default = 256.

property maxSockets

maxSockets?: number;

Maximum number of sockets to allow per host. Default for Node 0.10 is 5, default for Node 0.12 is Infinity

interface ClientRequest

interface ClientRequest extends events.EventEmitter, stream.Writable {}

method abort

abort: () => void;

method end

end: {
    (): void;
    (buffer: Buffer, cb?: Function): void;
    (str: string, cb?: Function): void;
    (str: string, encoding?: string, cb?: Function): void;
    (data?: any, encoding?: string): void;
};

method setNoDelay

setNoDelay: (noDelay?: boolean) => void;

method setSocketKeepAlive

setSocketKeepAlive: (enable?: boolean, initialDelay?: number) => void;

method setTimeout

setTimeout: (timeout: number, callback?: Function) => void;

method write

write: {
    (buffer: Buffer): boolean;
    (buffer: Buffer, cb?: Function): boolean;
    (str: string, cb?: Function): boolean;
    (str: string, encoding?: string, cb?: Function): boolean;
    (str: string, encoding?: string, fd?: string): boolean;
    (chunk: any, encoding?: string): void;
};

interface ClientResponse

interface ClientResponse extends IncomingMessage {}

Deprecated
Use IncomingMessage

interface IncomingMessage

interface IncomingMessage extends events.EventEmitter, stream.Readable {}

property headers

headers: any;

property httpVersion

httpVersion: string;

property method

method?: string;

Only valid for request obtained from http.Server.

property rawHeaders

rawHeaders: string[];

property rawTrailers

rawTrailers: any;

property socket

socket: net.Socket;

property statusCode

statusCode?: number;

Only valid for response obtained from http.ClientRequest.

property statusMessage

statusMessage?: string;

Only valid for response obtained from http.ClientRequest.

property trailers

trailers: any;

property url

url?: string;

Only valid for request obtained from http.Server.

method setTimeout

setTimeout: (msecs: number, callback: Function) => NodeJS.Timer;

interface RequestOptions

interface RequestOptions {}

property agent

agent?: Agent | boolean;

property auth

auth?: string;

property family

family?: number;

property headers

headers?: { [key: string]: any };

property host

host?: string;

property hostname

hostname?: string;

property localAddress

localAddress?: string;

property method

method?: string;

property path

path?: string;

property port

port?: number;

property protocol

protocol?: string;

property socketPath

socketPath?: string;

interface Server

interface Server extends events.EventEmitter {}

property maxHeadersCount

maxHeadersCount: number;

method address

address: () => { port: number; family: string; address: string };

method close

close: (cb?: any) => Server;

method listen

listen: {
    (
        port: number,
        hostname?: string,
        backlog?: number,
        callback?: Function
    ): Server;
    (port: number, hostname?: string, callback?: Function): Server;
    (path: string, callback?: Function): Server;
    (handle: any, listeningListener?: Function): Server;
};

interface ServerRequest

interface ServerRequest extends IncomingMessage {}

Deprecated
Use IncomingMessage

property connection

connection: net.Socket;

interface ServerResponse

interface ServerResponse extends events.EventEmitter, stream.Writable {}

property headersSent

headersSent: boolean;

property sendDate

sendDate: boolean;

property statusCode

statusCode: number;

property statusMessage

statusMessage: string;

method addTrailers

addTrailers: (headers: any) => void;

method end

end: {
    (): void;
    (buffer: Buffer, cb?: Function): void;
    (str: string, cb?: Function): void;
    (str: string, encoding?: string, cb?: Function): void;
    (data?: any, encoding?: string): void;
};

method getHeader

getHeader: (name: string) => string;

method removeHeader

removeHeader: (name: string) => void;

method setHeader

setHeader: (name: string, value: string) => void;

method write

write: {
    (buffer: Buffer): boolean;
    (buffer: Buffer, cb?: Function): boolean;
    (str: string, cb?: Function): boolean;
    (str: string, encoding?: string, cb?: Function): boolean;
    (str: string, encoding?: string, fd?: string): boolean;
    (chunk: any, encoding?: string): any;
};

method writeContinue

writeContinue: () => void;

method writeHead

writeHead: {
    (statusCode: number, reasonPhrase?: string, headers?: any): void;
    (statusCode: number, headers?: any): void;
};

namespace https

module 'https' {}

variable Agent

var Agent: new (options?: RequestOptions) => Agent;

variable globalAgent

var globalAgent: Agent;

function createServer

createServer: (options: ServerOptions, requestListener?: Function) => Server;

function get

get: (
    options: RequestOptions,
    callback?: (res: http.IncomingMessage) => void
) => http.ClientRequest;

function request

request: (
    options: RequestOptions,
    callback?: (res: http.IncomingMessage) => void
) => http.ClientRequest;

interface Agent

interface Agent {}

property maxSockets

maxSockets: number;

property requests

requests: any;

property sockets

sockets: any;

interface RequestOptions

interface RequestOptions extends http.RequestOptions {}

property ca

ca?: any;

property cert

cert?: any;

property ciphers

ciphers?: string;

property key

key?: any;

property passphrase

passphrase?: string;

property pfx

pfx?: any;

property rejectUnauthorized

rejectUnauthorized?: boolean;

property secureProtocol

secureProtocol?: string;

interface Server

interface Server extends tls.Server {}

interface ServerOptions

interface ServerOptions {}

property ca

ca?: any;

property cert

cert?: any;

property ciphers

ciphers?: string;

property crl

crl?: any;

property honorCipherOrder

honorCipherOrder?: boolean;

property key

key?: any;

property NPNProtocols

NPNProtocols?: any;

property passphrase

passphrase?: string;

property pfx

pfx?: any;

property rejectUnauthorized

rejectUnauthorized?: boolean;

property requestCert

requestCert?: boolean;

property SNICallback

SNICallback?: (servername: string) => any;

namespace net

module 'net' {}

variable Socket

var Socket: new (options?: {
    fd?: string;
    type?: string;
    allowHalfOpen?: boolean;
}) => Socket;

function connect

connect: {
    (
        options: {
            port: number;
            host?: string;
            localAddress?: string;
            localPort?: string;
            family?: number;
            allowHalfOpen?: boolean;
        },
        connectionListener?: Function
    ): Socket;
    (port: number, host?: string, connectionListener?: Function): Socket;
    (path: string, connectionListener?: Function): Socket;
};

function createConnection

createConnection: {
    (
        options: {
            port: number;
            host?: string;
            localAddress?: string;
            localPort?: string;
            family?: number;
            allowHalfOpen?: boolean;
        },
        connectionListener?: Function
    ): Socket;
    (port: number, host?: string, connectionListener?: Function): Socket;
    (path: string, connectionListener?: Function): Socket;
};

function createServer

createServer: {
    (connectionListener?: (socket: Socket) => void): Server;
    (
        options?: { allowHalfOpen?: boolean },
        connectionListener?: (socket: Socket) => void
    ): Server;
};

function isIP

isIP: (input: string) => number;

function isIPv4

isIPv4: (input: string) => boolean;

function isIPv6

isIPv6: (input: string) => boolean;

interface Server

interface Server extends Socket {}

property connections

connections: number;

property maxConnections

maxConnections: number;

method address

address: () => { port: number; family: string; address: string };

method close

close: (callback?: Function) => Server;

method listen

listen: {
    (
        port: number,
        host?: string,
        backlog?: number,
        listeningListener?: Function
    ): Server;
    (path: string, listeningListener?: Function): Server;
    (handle: any, listeningListener?: Function): Server;
};

interface Socket

interface Socket extends stream.Duplex {}

property bufferSize

bufferSize: number;

property bytesRead

bytesRead: number;

property bytesWritten

bytesWritten: number;

property localAddress

localAddress: string;

property localPort

localPort: number;

property remoteAddress

remoteAddress: string;

property remoteFamily

remoteFamily: string;

property remotePort

remotePort: number;

method address

address: () => { port: number; family: string; address: string };

method connect

connect: {
    (port: number, host?: string, connectionListener?: Function): void;
    (path: string, connectionListener?: Function): void;
};

method destroy

destroy: () => void;

method end

end: {
    (): void;
    (buffer: Buffer, cb?: Function): void;
    (str: string, cb?: Function): void;
    (str: string, encoding?: string, cb?: Function): void;
    (data?: any, encoding?: string): void;
};

method pause

pause: () => void;

method ref

ref: () => void;

method resume

resume: () => void;

method setEncoding

setEncoding: (encoding?: string) => void;

method setKeepAlive

setKeepAlive: (enable?: boolean, initialDelay?: number) => void;

method setNoDelay

setNoDelay: (noDelay?: boolean) => void;

method setTimeout

setTimeout: (timeout: number, callback?: Function) => void;

method unref

unref: () => void;

method write

write: {
    (buffer: Buffer): boolean;
    (buffer: Buffer, cb?: Function): boolean;
    (str: string, cb?: Function): boolean;
    (str: string, encoding?: string, cb?: Function): boolean;
    (str: string, encoding?: string, fd?: string): boolean;
    (data: any, encoding?: string, callback?: Function): void;
};

namespace os

module 'os' {}

variable EOL

var EOL: string;

function arch

arch: () => string;

function cpus

cpus: () => CpuInfo[];

function endianness

endianness: () => string;

function freemem

freemem: () => number;

function homedir

homedir: () => string;

function hostname

hostname: () => string;

function loadavg

loadavg: () => number[];

function networkInterfaces

networkInterfaces: () => { [index: string]: NetworkInterfaceInfo[] };

function platform

platform: () => string;

function release

release: () => string;

function tmpdir

tmpdir: () => string;

function totalmem

totalmem: () => number;

function type

type: () => string;

function uptime

uptime: () => number;

interface CpuInfo

interface CpuInfo {}

property model

model: string;

property speed

speed: number;

property times

times: {
    user: number;
    nice: number;
    sys: number;
    idle: number;
    irq: number;
};

interface NetworkInterfaceInfo

interface NetworkInterfaceInfo {}

property address

address: string;

property family

family: string;

property internal

internal: boolean;

property mac

mac: string;

property netmask

netmask: string;

namespace path

module 'path' {}

variable delimiter

var delimiter: string;

The platform-specific file delimiter. ';' or ':'.

variable sep

var sep: string;

The platform-specific file separator. '\' or '/'.

function basename

basename: (p: string, ext?: string) => string;

Return the last portion of a path. Similar to the Unix basename command. Often used to extract the file name from a fully qualified path.
Parameter p
the path to evaluate.
Parameter ext
optionally, an extension to remove from the result.

function dirname

dirname: (p: string) => string;

Return the directory name of a path. Similar to the Unix dirname command.
Parameter p
the path to evaluate.

function extname

extname: (p: string) => string;

Return the extension of the path, from the last '.' to end of string in the last portion of the path. If there is no '.' in the last portion of the path or the first character of it is '.', then it returns an empty string
Parameter p
the path to evaluate.

function format

format: (pathObject: ParsedPath) => string;

Returns a path string from an object - the opposite of parse().
Parameter pathString
path to evaluate.

function isAbsolute

isAbsolute: (path: string) => boolean;

Determines whether {path} is an absolute path. An absolute path will always resolve to the same location, regardless of the working directory.
Parameter path
path to test.

function join

join: { (...paths: any[]): string; (...paths: string[]): string };

Join all arguments together and normalize the resulting path. Arguments must be strings. In v0.8, non-string arguments were silently ignored. In v0.10 and up, an exception is thrown.
Parameter paths
string paths to join.

function normalize

normalize: (p: string) => string;

Normalize a string path, reducing '..' and '.' parts. When multiple slashes are found, they're replaced by a single one; when the path contains a trailing slash, it is preserved. On Windows backslashes are used.
Parameter p
string path to normalize.

function parse

parse: (pathString: string) => ParsedPath;

Returns an object from a path string - the opposite of format().
Parameter pathString
path to evaluate.

function relative

relative: (from: string, to: string) => string;

Solve the relative path from {from} to {to}. At times we have two absolute paths, and we need to derive the relative path from one to the other. This is actually the reverse transform of path.resolve.
Parameter from
Parameter to

function resolve

resolve: (...pathSegments: any[]) => string;

The right-most parameter is considered {to}. Other parameters are considered an array of {from}.
Starting from leftmost {from} paramter, resolves {to} to an absolute path.
If {to} isn't already absolute, {from} arguments are prepended in right to left order, until an absolute path is found. If after using all {from} paths still no absolute path is found, the current working directory is used as well. The resulting path is normalized, and trailing slashes are removed unless the path gets resolved to the root directory.
Parameter pathSegments
string paths to join. Non-string arguments are ignored.

interface ParsedPath

interface ParsedPath {}

A parsed path object generated by path.parse() or consumed by path.format().

property base

base: string;

The file name including extension (if any) such as 'index.html'

property dir

dir: string;

The full directory path such as '/home/user/dir' or 'c:\path\dir'

property ext

ext: string;

The file extension (if any) such as '.html'

property name

name: string;

The file name without extension (if any) such as 'index'

property root

root: string;

The root of the path such as '/' or 'c:'

namespace path.posix

namespace path.posix {}

variable delimiter

var delimiter: string;

variable sep

var sep: string;

function basename

basename: (p: string, ext?: string) => string;

function dirname

dirname: (p: string) => string;

function extname

extname: (p: string) => string;

function format

format: (pP: ParsedPath) => string;

function isAbsolute

isAbsolute: (p: string) => boolean;

function join

join: (...paths: any[]) => string;

function normalize

normalize: (p: string) => string;

function parse

parse: (p: string) => ParsedPath;

function relative

relative: (from: string, to: string) => string;

function resolve

resolve: (...pathSegments: any[]) => string;

namespace path.win32

namespace path.win32 {}

variable delimiter

var delimiter: string;

variable sep

var sep: string;

function basename

basename: (p: string, ext?: string) => string;

function dirname

dirname: (p: string) => string;

function extname

extname: (p: string) => string;

function format

format: (pP: ParsedPath) => string;

function isAbsolute

isAbsolute: (p: string) => boolean;

function join

join: (...paths: any[]) => string;

function normalize

normalize: (p: string) => string;

function parse

parse: (p: string) => ParsedPath;

function relative

relative: (from: string, to: string) => string;

function resolve

resolve: (...pathSegments: any[]) => string;

namespace protractor

module 'protractor' {}

variable Browser

var Browser: webdriver.IBrowser;

variable Button

var Button: webdriver.IButton;

variable By

var By: IProtractorLocatorStrategy;

variable Capability

var Capability: webdriver.ICapability;

variable CommandName

var CommandName: webdriver.ICommandName;

variable Key

var Key: webdriver.IKey;

function wrapDriver

wrapDriver: (
    webdriver: webdriver.WebDriver,
    opt_baseUrl?: string,
    opt_rootElement?: string
) => Protractor;

Create a new instance of Protractor by wrapping a webdriver instance.
Parameter webdriver
The configured webdriver instance.
Parameter opt_baseUrl
A URL to prepend to relative gets. {Protractor}

class ActionSequence

class ActionSequence extends webdriver.ActionSequence {}

class Builder

class Builder extends webdriver.Builder {}

class Capabilities

class Capabilities extends webdriver.Capabilities {}

class Command

class Command extends webdriver.Command {}

class EventEmitter

class EventEmitter extends webdriver.EventEmitter {}

class Session

class Session extends webdriver.Session {}

class WebDriver

class WebDriver extends webdriver.WebDriver {}

class WebElement

class WebElement extends webdriver.WebElement {}

class WebElementPromise

class WebElementPromise extends webdriver.WebElementPromise {}

interface Element

interface Element {}

Use as: element(locator)
The ElementFinder can be treated as a WebElement for most purposes, in particular, you may perform actions (i.e. click, getText) on them as you would a WebElement. ElementFinders extend Promise, and once an action is performed on an ElementFinder, the latest result from the chain can be accessed using then. Unlike a WebElement, an ElementFinder will wait for angular to settle before performing finds or actions.
ElementFinder can be used to build a chain of locators that is used to find an element. An ElementFinder does not actually attempt to find the element until an action is called, which means they can be set up in helper files before the page is available.
Parameter locator
An element locator. {ElementFinder}

method all

all: (locator: webdriver.Locator) => ElementArrayFinder;

ElementArrayFinder is used for operations on an array of elements (as opposed to a single element).
Parameter locator
An element locator. {ElementArrayFinder}

call signature

(locator: webdriver.Locator): ElementFinder;

interface ElementArrayFinder

interface ElementArrayFinder extends webdriver.promise.IThenable<ElementFinder[]> {}

method $$

$$: (selector: string) => ElementArrayFinder;

Shorthand function for finding arrays of elements by css.
{function(string): ElementArrayFinder}

method all

all: (locator: webdriver.Locator) => ElementArrayFinder;

Calls to ElementArrayFinder may be chained to find an array of elements using the current elements in this ElementArrayFinder as the starting point. This function returns a new ElementArrayFinder which would contain the children elements found (and could also be empty).
element.all(locator).all(locator) 1a 1b 2a 2b
Parameter subLocator
{ElementArrayFinder}
Example 1
var foo = element.all(by.css('.parent')).all(by.css('.foo')) expect(foo.getText()).toEqual(['1a', '2a']) var baz = element.all(by.css('.parent')).all(by.css('.baz')) expect(baz.getText()).toEqual(['1b']) var nonexistent = element.all(by.css('.parent')).all(by.css('.NONEXISTENT')) expect(nonexistent.getText()).toEqual([''])

method allowAnimations

allowAnimations: (value: boolean) => ElementArrayFinder;

Determine if animation is allowed on the current underlying elements.
Parameter value
Example 1
// Turns off ng-animate animations for all elements in the element(by.css('body')).allowAnimations(false);
{ElementArrayFinder} which resolves to whether animation is allowed.

method asElementFinders_

asElementFinders_: () => webdriver.promise.Promise<ElementFinder[]>;

Represents the ElementArrayFinder as an array of ElementFinders.
{Array.} Return a promise, which resolves to a list of ElementFinders specified by the locator.

method clear

clear: () => webdriver.promise.Promise<void>;

Schedules a command to clear the of this element. This command has no effect if the underlying DOM element is neither a text INPUT element nor a TEXTAREA element. {!webdriver.promise.Promise} A promise that will be resolved when the element has been cleared.

method click

click: () => webdriver.promise.Promise<void>;

Schedules a command to click on this element. {!webdriver.promise.Promise} A promise that will be resolved when the click command has completed.

method clone

clone: () => ElementArrayFinder;

Create a shallow copy of ElementArrayFinder.
{!ElementArrayFinder} A shallow copy of this.

method count

count: () => webdriver.promise.Promise<number>;

Count the number of elements represented by the ElementArrayFinder.
element.all(locator).count() First Second Third
Example 1
var list = element.all(by.css('.items li')); expect(list.count()).toBe(3);
{!webdriver.promise.Promise} A promise which resolves to the number of elements matching the locator.

method each

each: (fn: (element: ElementFinder, index: number) => void) => void;

Calls the input function on each ElementFinder represented by the ElementArrayFinder.
element.all(locator).each(eachFunction) First Second Third
Parameter fn
Input function
Example 1
element.all(by.css('.items li')).each(function(element) { // Will print First, Second, Third. element.getText().then(console.log); });

method evaluate

evaluate: (expression: string) => ElementArrayFinder;

Evaluates the input as if it were on the scope of the current underlying elements.
{{variableInScope}}
Parameter expression
{ElementArrayFinder} which resolves to the evaluated expression for each underlying element. The result will be resolved as in webdriver.WebDriver.executeScript. In summary - primitives will be resolved as is, functions will be converted to string, and elements will be returned as a WebElement.
Example 1
var value = element(by.id('foo')).evaluate('variableInScope');

method filter

filter: (
    filterFn: (element: ElementFinder, index: number) => any
) => ElementArrayFinder;

Apply a filter function to each element within the ElementArrayFinder. Returns a new ElementArrayFinder with all elements that pass the filter function. The filter function receives the ElementFinder as the first argument and the index as a second arg. This does not actually retrieve the underlying list of elements, so it can be used in page objects.
element.all(locator).filter(filterFn) First Second Third
Parameter filterFn
Filter function that will test if an element should be returned. filterFn can either return a boolean or a promise that resolves to a boolean. {!ElementArrayFinder} A ElementArrayFinder that represents an array of element that satisfy the filter function.
Example 1
element.all(by.css('.items li')).filter(function(elem, index) { return elem.getText().then(function(text) { return text === 'Third'; }); }).then(function(filteredElements) { filteredElements[0].click(); });

method first

first: () => ElementFinder;

Get the first matching element for the ElementArrayFinder. This does not actually retrieve the underlying element.
element.all(locator).first() First Second Third
Example 1
var first = element.all(by.css('.items li')).first(); expect(first.getText()).toBe('First');
{ElementFinder} finder representing the first matching element

method get

get: (index: number) => ElementFinder;

Get an element within the ElementArrayFinder by index. The index starts at 0. Negative indices are wrapped (i.e. -i means ith element from last) This does not actually retrieve the underlying element.
element.all(locator).get(index) First Second Third
Parameter index
Element index. {ElementFinder} finder representing element at the given index.
Example 1
var list = element.all(by.css('.items li')); expect(list.get(0).getText()).toBe('First'); expect(list.get(1).getText()).toBe('Second');

method getAttribute

getAttribute: (attributeName: string) => webdriver.promise.Promise<string[]>;

Schedules a command to query for the value of the given attribute of the element. Will return the current value even if it has been modified after the page has been loaded. More exactly, this method will return the value of the given attribute, unless that attribute is not present, in which case the value of the property with the same name is returned. If neither value is set, null is returned. The "style" attribute is converted as best can be to a text representation with a trailing semi-colon. The following are deemed to be "boolean" attributes and will be returned as thus:
async, autofocus, autoplay, checked, compact, complete, controls, declare, defaultchecked, defaultselected, defer, disabled, draggable, ended, formnovalidate, hidden, indeterminate, iscontenteditable, ismap, itemscope, loop, multiple, muted, nohref, noresize, noshade, novalidate, nowrap, open, paused, pubdate, readonly, required, reversed, scoped, seamless, seeking, selected, spellcheck, truespeed, willvalidate
Finally, the following commonly mis-capitalized attribute/property names are evaluated as expected: "class" "readonly"
Parameter attributeName
The name of the attribute to query. {!webdriver.promise.Promise} A promise that will be resolved with the attribute's value.

method getCssValue

getCssValue: (cssStyleProperty: string) => webdriver.promise.Promise<string[]>;

Schedules a command to query for the computed style of the element represented by this instance. If the element inherits the named style from its parent, the parent will be queried for its value. Where possible, color values will be converted to their hex representation (e.g. #00ff00 instead of rgb(0, 255, 0)). Warning: the value returned will be as the browser interprets it, so it may be tricky to form a proper assertion.
Parameter cssStyleProperty
The name of the CSS style property to look up. {!webdriver.promise.Promise} A promise that will be resolved with the requested CSS value.

method getId

getId: () => webdriver.promise.Promise<webdriver.IWebElementId[]>;

{!webdriver.promise.Promise.<webdriver.WebElement.Id>} A promise that resolves to this element's JSON representation as defined by the WebDriver wire protocol.
See Also
- http://code.google.com/p/selenium/wiki/JsonWireProtocol

method getInnerHtml

getInnerHtml: () => webdriver.promise.Promise<string[]>;

Schedules a command to retrieve the inner HTML of this element. {!webdriver.promise.Promise} A promise that will be resolved with the element's inner HTML.

method getLocation

getLocation: () => webdriver.promise.Promise<webdriver.ILocation[]>;

Schedules a command to compute the location of this element in page space. {!webdriver.promise.Promise} A promise that will be resolved to the element's location as a {@code {x:number, y:number}} object.

method getOuterHtml

getOuterHtml: () => webdriver.promise.Promise<string[]>;

Schedules a command to retrieve the outer HTML of this element. {!webdriver.promise.Promise} A promise that will be resolved with the element's outer HTML.

method getSize

getSize: () => webdriver.promise.Promise<webdriver.ISize[]>;

Schedules a command to compute the size of this element's bounding box, in pixels. {!webdriver.promise.Promise} A promise that will be resolved with the element's size as a {@code {width:number, height:number}} object.

method getTagName

getTagName: () => webdriver.promise.Promise<string[]>;

Schedules a command to query for the tag/node name of this element. {!webdriver.promise.Promise} A promise that will be resolved with the element's tag name.

method getText

getText: () => webdriver.promise.Promise<string[]>;

Get the visible (i.e. not hidden by CSS) innerText of this element, including sub-elements, without any leading or trailing whitespace. {!webdriver.promise.Promise} A promise that will be resolved with the element's visible text.

method getWebElements

getWebElements: () => webdriver.WebElement[];

Returns the elements as an array of WebElements.

method isDisplayed

isDisplayed: () => webdriver.promise.Promise<boolean[]>;

Schedules a command to test whether this element is currently displayed. {!webdriver.promise.Promise} A promise that will be resolved with whether this element is currently visible on the page.

method isEnabled

isEnabled: () => webdriver.promise.Promise<boolean[]>;

Schedules a command to query whether the DOM element represented by this instance is enabled, as dicted by the attribute. {!webdriver.promise.Promise} A promise that will be resolved with whether this element is currently enabled.

method isSelected

isSelected: () => webdriver.promise.Promise<boolean[]>;

Schedules a command to query whether this element is selected. {!webdriver.promise.Promise} A promise that will be resolved with whether this element is currently selected.

method last

last: () => ElementFinder;

Get the last matching element for the ElementArrayFinder. This does not actually retrieve the underlying element.
element.all(locator).last() First Second Third
Example 1
var last = element.all(by.css('.items li')).last(); expect(last.getText()).toBe('Third');
{ElementFinder} finder representing the last matching element

method locator

locator: () => webdriver.Locator;

Returns the most relevant locator.
Example 1
$('#ID1').locator() // returns by.css('#ID1') $('#ID1').$('#ID2').locator() // returns by.css('#ID2') $$('#ID1').filter(filterFn).get(0).click().locator() // returns by.css('#ID1')
{webdriver.Locator}

method map

map: <T>(
    mapFn: (element: ElementFinder, index: number) => T
) => webdriver.promise.Promise<T[]>;

Apply a map function to each element within the ElementArrayFinder. The callback receives the ElementFinder as the first argument and the index as a second arg.
element.all(locator).map(mapFunction) First Second Third
Parameter mapFn
Map function that will be applied to each element. {!webdriver.promise.Promise} A promise that resolves to an array of values returned by the map function.
Example 1
var items = element.all(by.css('.items li')).map(function(elm, index) { return { index: index, text: elm.getText(), class: elm.getAttribute('class') }; }); expect(items).toEqual([ {index: 0, text: 'First', class: 'one'}, {index: 1, text: 'Second', class: 'two'}, {index: 2, text: 'Third', class: 'three'} ]);

method reduce

reduce: {
    <T>(
        reduceFn: (
            acc: T,
            element: ElementFinder,
            index: number,
            arr: ElementFinder[]
        ) => webdriver.promise.Promise<T>,
        initialValue: T
    ): webdriver.promise.Promise<T>;
    <T>(
        reduceFn: (
            acc: T,
            element: ElementFinder,
            index: number,
            arr: ElementFinder[]
        ) => T,
        initialValue: T
    ): webdriver.promise.Promise<T>;
};

Apply a reduce function against an accumulator and every element found using the locator (from left-to-right). The reduce function has to reduce every element into a single value (the accumulator). Returns promise of the accumulator. The reduce function receives the accumulator, current ElementFinder, the index, and the entire array of ElementFinders, respectively.
element.all(locator).reduce(reduceFn) First Second Third
Parameter reduceFn
Reduce function that reduces every element into a single value.
Parameter initialValue
Initial value of the accumulator. {!webdriver.promise.Promise} A promise that resolves to the final value of the accumulator.
Example 1
var value = element.all(by.css('.items li')).reduce(function(acc, elem) { return elem.getText().then(function(text) { return acc + text + ' '; }); });
expect(value).toEqual('First Second Third ');

method sendKeys

sendKeys: (...var_args: string[]) => webdriver.promise.Promise<void>;

Schedules a command to type a sequence on the DOM element represented by this instance. Modifier keys (SHIFT, CONTROL, ALT, META) are stateful; once a modifier is processed in the keysequence, that key state is toggled until one of the following occurs: The modifier key is encountered again in the sequence. At this point the state of the key is toggled (along with the appropriate keyup/down events). The key is encountered in the sequence. When this key is encountered, all modifier keys current in the down state are released (with accompanying keyup events). The NULL key can be used to simulate common keyboard shortcuts: element.sendKeys("text was", webdriver.Key.CONTROL, "a", webdriver.Key.NULL, "now text is"); // Alternatively: element.sendKeys("text was", webdriver.Key.chord(webdriver.Key.CONTROL, "a"), "now text is"); The end of the keysequence is encountered. When there are no more keys to type, all depressed modifier keys are released (with accompanying keyup events). Note: On browsers where native keyboard events are not yet supported (e.g. Firefox on OS X), key events will be synthesized. Special punctionation keys will be synthesized according to a standard QWERTY en-us keyboard layout.
Parameter var_args
The sequence of keys to type. All arguments will be joined into a single sequence (var_args is permitted for convenience). {!webdriver.promise.Promise} A promise that will be resolved when all keys have been typed.

method submit

submit: () => webdriver.promise.Promise<void>;

Schedules a command to submit the form containing this element (or this element if it is a FORM element). This command is a no-op if the element is not contained in a form. {!webdriver.promise.Promise} A promise that will be resolved when the form has been submitted.

method toElementFinder_

toElementFinder_: () => ElementFinder;

Returns an ElementFinder representation of ElementArrayFinder. It ensures that the ElementArrayFinder resolves to one and only one underlying element.
{ElementFinder} An ElementFinder representation

interface ElementFinder

interface ElementFinder
    extends webdriver.IWebElement,
        webdriver.promise.IThenable<any> {}

method $

$: (selector: string) => ElementFinder;

Shortcut for querying the document directly with css.
$(cssSelector) First Second
Parameter selector
A css selector {ElementFinder} which identifies the located webdriver.WebElement
Example 1
var item = $('.count .two'); expect(item.getText()).toBe('Second');

method $$

$$: (selector: string) => ElementArrayFinder;

Shortcut for querying the document directly with css.
$$(cssSelector) First Second
Parameter selector
a css selector {ElementArrayFinder} which identifies the array of the located webdriver.WebElements.
Example 1
// The following protractor expressions are equivalent. var list = element.all(by.css('.count span')); expect(list.count()).toBe(2);
list = $$('.count span'); expect(list.count()).toBe(2); expect(list.get(0).getText()).toBe('First'); expect(list.get(1).getText()).toBe('Second');

method all

all: (subLocator: webdriver.Locator) => ElementArrayFinder;

Calls to element may be chained to find an array of elements within a parent.
element(locator).all(locator) First Second Third
Parameter subLocator
{ElementArrayFinder}
Example 1
var items = element(by.css('.parent')).all(by.tagName('li'))

method allowAnimations

allowAnimations: (value: string) => ElementFinder;

Parameter value
{ElementFinder} which resolves to whether animation is allowed.
See Also
- ElementArrayFinder.prototype.allowAnimations.

method clone

clone: () => ElementFinder;

Create a shallow copy of ElementFinder.
{!ElementFinder} A shallow copy of this.

method element

element: (subLocator: webdriver.Locator) => ElementFinder;

Calls to element may be chained to find elements within a parent.
element(locator).element(locator) Child text {{person.phone}}
Parameter subLocator
{ElementFinder}
Example 1
// Chain 2 element calls. var child = element(by.css('.parent')). element(by.css('.child')); expect(child.getText()).toBe('Child text\n555-123-4567');
// Chain 3 element calls. var triple = element(by.css('.parent')). element(by.css('.child')). element(by.binding('person.phone')); expect(triple.getText()).toBe('555-123-4567');

method evaluate

evaluate: (expression: string) => ElementFinder;

Evaluates the input as if it were on the scope of the current element.
Parameter expression
{ElementFinder} which resolves to the evaluated expression.
See Also
- ElementArrayFinder.evaluate

method getWebElement

getWebElement: () => webdriver.WebElement;

Returns the WebElement represented by this ElementFinder. Throws the WebDriver error if the element doesn't exist.
Example 1
The following three expressions are equivalent. element(by.css('.parent')).getWebElement(); browser.waitForAngular(); browser.driver.findElement(by.css('.parent')); browser.findElement(by.css('.parent'));
element(locator).getWebElement() {webdriver.WebElement}

method isElementPresent

isElementPresent: (
    subLocator: webdriver.Locator
) => webdriver.promise.Promise<boolean>;

Override for WebElement.prototype.isElementPresent so that protractor waits for Angular to settle before making the check.
Parameter subLocator
Locator for element to look for. {ElementFinder} which resolves to whether the element is present on the page.
See Also
- ElementFinder.isPresent

method isPresent

isPresent: () => webdriver.promise.Promise<boolean>;

Determine whether the element is present on the page.
{{person.name}}
Example 1
// Element exists. expect(element(by.binding('person.name')).isPresent()).toBe(true);
// Element not present. expect(element(by.binding('notPresent')).isPresent()).toBe(false);
{ElementFinder} which resolves to whether the element is present on the page.

method locator

locator: () => webdriver.Locator;

See Also
- ElementArrayFinder.prototype.locator
  {webdriver.Locator}

interface IBrowser

interface IBrowser extends Protractor {}

method forkNewDriverInstance

forkNewDriverInstance: (
    opt_useSameUrl?: boolean,
    opt_copyMockModules?: boolean
) => Protractor;

Fork another instance of protractor for use in interactive tests.
Parameter opt_useSameUrl
Whether to navigate to current url on creation
Parameter opt_copyMockModules
Whether to apply same mock modules on creation {Protractor} a protractor instance.

method getProcessedConfig

getProcessedConfig: () => webdriver.promise.Promise<any>;

Get the processed configuration object that is currently being run. This will contain the specs and capabilities properties of the current runner instance.
Set by the runner.
{webdriver.promise.Promise} A promise which resolves to the capabilities object.

interface IProtractorLocatorStrategy

interface IProtractorLocatorStrategy {}

property className

className: typeof webdriver.By.className;

webdriver's By is an enum of locator functions, so we must set it to a prototype before inheriting from it.

property css

css: typeof webdriver.By.css;

property id

id: typeof webdriver.By.id;

property js

js: typeof webdriver.By.js;

property linkText

linkText: typeof webdriver.By.linkText;

property name

name: typeof webdriver.By.name;

property partialLinkText

partialLinkText: typeof webdriver.By.partialLinkText;

property tagName

tagName: typeof webdriver.By.tagName;

property xpath

xpath: typeof webdriver.By.xpath;

method addLocator

addLocator: {
    (name: string, script: string): void;
    (name: string, script: Function): void;
};

Add a locator to this instance of ProtractorBy. This locator can then be used with element(by.locatorName(args)).
Go!
Parameter name
The name of the new locator.
Parameter script
A script to be run in the context of the browser. This script will be passed an array of arguments that contains any args passed into the locator followed by the element scoping the search and the css selector for the root angular element. It should return an array of elements.
Example 1
// Add the custom locator. by.addLocator('buttonTextSimple', function(buttonText, opt_parentElement, opt_rootSelector) { // This function will be serialized as a string and will execute in the // browser. The first argument is the text for the button. The second // argument is the parent element, if any. var using = opt_parentElement, buttons = using.querySelectorAll('button');
// Return an array of buttons with the text. return Array.prototype.filter.call(buttons, function(button) { return button.textContent === buttonText; }); });
// Use the custom locator. element(by.buttonTextSimple('Go!')).click();
by.addLocator(locatorName, functionOrScript)

method binding

binding: (bindingDescriptor: string) => webdriver.Locator;

Find an element by binding.
{{person.name}}
Parameter bindingDescriptor
{{findElementsOverride: findElementsOverride, toString: Function|string}}
Example 1
var span1 = element(by.binding('person.name')); expect(span1.getText()).toBe('Foo');
var span2 = element(by.binding('person.email')); expect(span2.getText()).toBe('foo@bar.com');

method buttonText

buttonText: (searchText: string) => webdriver.Locator;

Find a button by text.
Save
Parameter searchText
{{findElementsOverride: findElementsOverride, toString: Function|string}}
Example 1
element(by.buttonText('Save'));

method cssContainingText

cssContainingText: (
    cssSelector: string,
    searchText: string
) => webdriver.Locator;

Find elements by CSS which contain a certain string.
Dog Cat
Example 1
// Returns the DIV for the dog, but not cat. var dog = element(by.cssContainingText('.pet', 'Dog'));

method exactBinding

exactBinding: (bindingDescriptor: string) => webdriver.Locator;

Find an element by exact binding.
{{ person.name }} {{person_phone|uppercase}}
Parameter bindingDescriptor
{{findElementsOverride: findElementsOverride, toString: Function|string}}
Example 1
expect(element(by.exactBinding('person.name')).isPresent()).toBe(true); expect(element(by.exactBinding('person-email')).isPresent()).toBe(true); expect(element(by.exactBinding('person')).isPresent()).toBe(false); expect(element(by.exactBinding('person_phone')).isPresent()).toBe(true); expect(element(by.exactBinding('person_phone|uppercase')).isPresent()).toBe(true); expect(element(by.exactBinding('phone')).isPresent()).toBe(false);

method model

model: (model: string) => webdriver.Locator;

Find an element by ng-model expression.
by.model(modelName)
Parameter model
ng-model expression.
Example 1
var input = element(by.model('person.name')); input.sendKeys('123'); expect(input.getAttribute('value')).toBe('Foo123');

method options

options: (optionsDescriptor: string) => webdriver.Locator;

Find an element by ng-options expression.
by.options(optionsDescriptor) red green
Parameter optionsDescriptor
ng-options expression.
Example 1
var allOptions = element.all(by.options('c for c in colors')); expect(allOptions.count()).toEqual(2); var firstOption = allOptions.first(); expect(firstOption.getText()).toEqual('red');

method partialButtonText

partialButtonText: (searchText: string) => webdriver.Locator;

Find a button by partial text.
Save my file
Parameter searchText
{{findElementsOverride: findElementsOverride, toString: Function|string}}
Example 1
element(by.partialButtonText('Save'));

method repeater

repeater: (repeatDescriptor: string) => RepeaterLocator;

Find elements inside an ng-repeat.
{{cat.name}} {{cat.age}}
{{$index}} <div class="book-info" ng-repeat-end> {{book.name}} {{book.blurb}}
Example 1
// Returns the DIV for the second cat. var secondCat = element(by.repeater('cat in pets').row(1));
// Returns the SPAN for the first cat's name. var firstCatName = element(by.repeater('cat in pets'). row(0).column('{{cat.name}}'));
// Returns a promise that resolves to an array of WebElements from a column var ages = element.all( by.repeater('cat in pets').column('{{cat.age}}'));
// Returns a promise that resolves to an array of WebElements containing // all top level elements repeated by the repeater. For 2 pets rows resolves // to an array of 2 elements. var rows = element.all(by.repeater('cat in pets'));
// Returns a promise that resolves to an array of WebElements containing all // the elements with a binding to the book's name. var divs = element.all(by.repeater('book in library').column('book.name'));
// Returns a promise that resolves to an array of WebElements containing // the DIVs for the second book. var bookInfo = element.all(by.repeater('book in library').row(1));
// Returns the H4 for the first book's name. var firstBookName = element(by.repeater('book in library'). row(0).column('{{book.name}}'));
// Returns a promise that resolves to an array of WebElements containing // all top level elements repeated by the repeater. For 2 books divs // resolves to an array of 4 elements. var divs = element.all(by.repeater('book in library'));

interface LocatorWithColumn

interface LocatorWithColumn extends webdriver.Locator {}

method column

column: {
    (index: number): webdriver.Locator;
    (name: string): webdriver.Locator;
};

interface Protractor

interface Protractor extends webdriver.WebDriver {}

property baseUrl

baseUrl: string;

All get methods will be resolved against this base URL. Relative URLs are = resolved the way anchor tags resolve.
{string}

property driver

driver: webdriver.WebDriver;

The wrapped webdriver instance. Use this to interact with pages that do not contain Angular (such as a log-in screen).
{webdriver.WebDriver}

property getPageTimeout

getPageTimeout: number;

Timeout in milliseconds to wait for pages to load when calling get.
{number}

property ignoreSynchronization

ignoreSynchronization: boolean;

If true, Protractor will not attempt to synchronize with the page before performing actions. This can be harmful because Protractor will not wait until $timeouts and $http calls have been processed, which can cause tests to become flaky. This should be used only when necessary, such as when a page continuously polls an API using $timeout.
{boolean}

property params

params: any;

An object that holds custom test parameters.
{Object}

property resetUrl

resetUrl: string;

The reset URL to use between page loads.
{string}

property rootEl

rootEl: string;

The css selector for an element on which to find Angular. This is usually 'body' but if your ng-app is on a subsection of the page it may be a subelement.
{string}

method $

$: (selector: string) => ElementFinder;

Shorthand function for finding elements by css.
{function(string): ElementFinder}

method $$

$$: (selector: string) => ElementArrayFinder;

Shorthand function for finding arrays of elements by css.
{function(string): ElementArrayFinder}

method addMockModule

addMockModule: {
    (name: string, script: string, ...varArgs: any[]): void;
    (name: string, script: Function, ...varArgs: any[]): void;
};

Add a module to load before Angular whenever Protractor.get is called. Modules will be registered after existing modules already on the page, so any module registered here will override preexisting modules with the same name.
Parameter name
The name of the module to load or override.
Parameter script
The JavaScript to load the module.
Parameter varArgs
Any additional arguments will be provided to the script and may be referenced using the arguments object.
Example 1
browser.addMockModule('modName', function() { angular.module('modName', []).value('foo', 'bar'); });

method clearMockModules

clearMockModules: () => void;

Clear the list of registered mock modules.

method debugger

debugger: () => void;

Pauses the test and injects some helper functions into the browser, so that debugging may be done in the browser console.
This should be used under node in debug mode, i.e. with protractor debug <configuration.js>
Example 1
While in the debugger, commands can be scheduled through webdriver by entering the repl: debug> repl Press Ctrl + C to leave rdebug repl > ptor.findElement(protractor.By.input('user').sendKeys('Laura')); > ptor.debugger(); debug> c
This will run the sendKeys command as the next task, then re-enter the debugger.

method element

element: (locator: webdriver.Locator) => ElementFinder;

Helper function for finding elements.
{function(webdriver.Locator): ElementFinder}

method get

get: (
    destination: string,
    opt_timeout?: number
) => webdriver.promise.Promise<void>;

Parameter destination
Destination URL.
Parameter opt_timeout
Number of milliseconds to wait for Angular to start.
See Also
- webdriver.WebDriver.get
  Navigate to the given destination and loads mock modules before Angular. Assumes that the page being loaded uses Angular. If you need to access a page which does not have Angular on load, use the wrapped webdriver directly.

method getLocationAbsUrl

getLocationAbsUrl: () => webdriver.promise.Promise<string>;

Returns the current absolute url from AngularJS.

method pause

pause: (opt_debugPort?: number) => void;

Beta (unstable) pause function for debugging webdriver tests. Use browser.pause() in your test to enter the protractor debugger from that point in the control flow. Does not require changes to the command line (no need to add 'debug').
Parameter opt_debugPort
Optional port to use for the debugging process
Example 1
element(by.id('foo')).click(); browser.pause(); // Execution will stop before the next click action. element(by.id('bar')).click();

method refresh

refresh: (opt_timeout?: number) => webdriver.promise.Promise<void>;

See webdriver.WebDriver.refresh
Makes a full reload of the current page and loads mock modules before Angular. Assumes that the page being loaded uses Angular. If you need to access a page which does not have Angular on load, use the wrapped webdriver directly.
Parameter opt_timeout
Number of seconds to wait for Angular to start.

method removeMockModule

removeMockModule: (name: string) => void;

Remove a registered mock module.
Parameter name
The name of the module to remove.
Example 1
browser.removeMockModule('modName');

method setLocation

setLocation: (url: string) => webdriver.promise.Promise<void>;

Browse to another page using in-page navigation.
Parameter url
In page URL using the same syntax as $location.url()
Returns
{!webdriver.promise.Promise} A promise that will resolve once page has been changed.

method waitForAngular

waitForAngular: () => webdriver.promise.Promise<void>;

Instruct webdriver to wait until Angular has finished rendering and has no outstanding $http calls before continuing.
{!webdriver.promise.Promise} A promise that will resolve to the scripts return value.

interface RepeaterLocator

interface RepeaterLocator extends LocatorWithColumn {}

method row

row: (index: number) => LocatorWithColumn;

namespace protractor.error

namespace protractor.error {}

variable ErrorCode

var ErrorCode: webdriver.error.IErrorCode;

class Error

class Error extends webdriver.error.Error {}

namespace protractor.ExpectedConditions

namespace protractor.ExpectedConditions {}

function alertIsPresent

alertIsPresent: <T>() => webdriver.until.Condition<T>;

Expect an alert to be present.
{!webdriver.until.Condition} An expected condition that returns a promise representing whether an alert is present.

function and

and: <T>(...fns: webdriver.until.Condition<T>[]) => webdriver.until.Condition<T>;

Chain a number of expected conditions using logical_and, short circuiting at the first expected condition that evaluates to false.
Parameter fns
An array of expected conditions to 'and' together. {!webdriver.until.Condition} An expected condition that returns a promise which evaluates to the result of the logical and.

function elementToBeClickable

elementToBeClickable: <T>(
    element: ElementFinder
) => webdriver.until.Condition<T>;

An Expectation for checking an element is visible and enabled such that you can click it.
Parameter element
The element to check {!webdriver.until.Condition} An expected condition that returns a promise representing whether the element is clickable.

function elementToBeSelected

elementToBeSelected: <T>(element: ElementFinder) => webdriver.until.Condition<T>;

An expectation for checking the selection is selected.
Parameter elementFinder
The element to check {!webdriver.until.Condition} An expected condition that returns a promise representing whether the element is selected.

function invisibilityOf

invisibilityOf: <T>(element: ElementFinder) => webdriver.until.Condition<T>;

An expectation for checking that an element is present on the DOM of a page. This does not necessarily mean that the element is visible. This is the opposite of 'stalenessOf'.
Parameter elementFinder
The element to check {!webdriver.until.Condition} An expected condition that returns a promise representing whether the element is invisible.

function not

not: <T>(
    expectedCondition: webdriver.until.Condition<T>
) => webdriver.until.Condition<T>;

Negates the result of a promise.
Parameter expectedCondition
{!webdriver.until.Condition} An expected condition that returns the negated value.

function or

or: <T>(...fns: webdriver.until.Condition<T>[]) => webdriver.until.Condition<T>;

Chain a number of expected conditions using logical_or, short circuiting at the first expected condition that evaluates to true.
Parameter fns
An array of expected conditions to 'or' together. {!webdriver.until.Condition} An expected condition that returns a promise which evaluates to the result of the logical or.

function presenceOf

presenceOf: <T>(element: ElementFinder) => webdriver.until.Condition<T>;

An expectation for checking that an element is present on the DOM of a page. This does not necessarily mean that the element is visible. This is the opposite of 'stalenessOf'.
Parameter elementFinder
The element to check {!webdriver.until.Condition} An expected condition that returns a promise representing whether the element is present.

function stalenessOf

stalenessOf: <T>(element: ElementFinder) => webdriver.until.Condition<T>;

An expectation for checking that an element is not attached to the DOM of a page. This is the opposite of 'presenceOf'.
Parameter elementFinder
The element to check {!webdriver.until.Condition} An expected condition that returns a promise representing whether the element is stale.

function textToBePresentInElement

textToBePresentInElement: <T>(
    element: ElementFinder,
    text: string
) => webdriver.until.Condition<T>;

An expectation for checking if the given text is present in the element. Returns false if the elementFinder does not find an element.
Parameter element
The element to check
Parameter text
The text to verify against {!webdriver.until.Condition} An expected condition that returns a promise representing whether the text is present in the element.

function textToBePresentInElementValue

textToBePresentInElementValue: <T>(
    element: ElementFinder,
    text: string
) => webdriver.until.Condition<T>;

An expectation for checking if the given text is present in the element’s value. Returns false if the elementFinder does not find an element.
Parameter element
The element to check
Parameter text
The text to verify against {!webdriver.until.Condition} An expected condition that returns a promise representing whether the text is present in the element's value.

function titleContains

titleContains: <T>(title: string) => webdriver.until.Condition<T>;

An expectation for checking that the title contains a case-sensitive substring.
Parameter title
The fragment of title expected {!webdriver.until.Condition} An expected condition that returns a promise representing whether the title contains the string.

function titleIs

titleIs: <T>(title: string) => webdriver.until.Condition<T>;

An expectation for checking the title of a page.
Parameter title
The expected title, which must be an exact match. {!webdriver.until.Condition} An expected condition that returns a promise representing whether the title equals the string.

function visibilityOf

visibilityOf: <T>(element: ElementFinder) => webdriver.until.Condition<T>;

An expectation for checking that an element is present on the DOM of a page and visible. Visibility means that the element is not only displayed but also has a height and width that is greater than 0. This is the opposite of 'invisibilityOf'.
Parameter elementFinder
The element to check {!webdriver.until.Condition} An expected condition that returns a promise representing whether the element is visible.

namespace protractor.logging

namespace protractor.logging {}

variable Level

var Level: webdriver.logging.ILevelValues;

variable Type

var Type: webdriver.logging.IType;

function getLevel

getLevel: {
    (nameOrValue: string): webdriver.logging.ILevel;
    (nameOrValue: number): webdriver.logging.ILevel;
};

class Entry

class Entry extends webdriver.logging.Entry {}

class Preferences

class Preferences extends webdriver.logging.Preferences {}

namespace protractor.promise

namespace protractor.promise {}

function all

all: (arr: webdriver.promise.Promise<any>[]) => webdriver.promise.Promise<any[]>;

Given an array of promises, will return a promise that will be fulfilled with the fulfillment values of the input array's values. If any of the input array's promises are rejected, the returned promise will be rejected with the same reason.
Parameter arr
An array of promises to wait on. {!webdriver.promise.Promise.<!Array.>} A promise that is fulfilled with an array containing the fulfilled values of the input array, or rejected with the same reason as the first rejected value. T

function asap

asap: (value: any, callback: Function, opt_errback?: Function) => void;

Invokes the appropriate callback function as soon as a promised is resolved. This function is similar to webdriver.promise.when, except it does not return a new promise.
Parameter value
The value to observe.
Parameter callback
The function to call when the value is resolved successfully.
Parameter opt_errback
The function to call when the value is rejected.

function checkedNodeCall

checkedNodeCall: <T>(
    fn: Function,
    ...var_args: any[]
) => webdriver.promise.Promise<T>;

Wraps a function that is assumed to be a node-style callback as its final argument. This callback takes two arguments: an error value (which will be null if the call succeeded), and the success value as the second argument. If the call fails, the returned promise will be rejected, otherwise it will be resolved with the result.
Parameter fn
The function to wrap. {!webdriver.promise.Promise} A promise that will be resolved with the result of the provided function's callback.

function consume

consume: <T>(
    generatorFn: Function,
    opt_self?: any,
    ...var_args: any[]
) => webdriver.promise.Promise<T>;

Consumes a . Each time the generator yields a promise, this function will wait for it to be fulfilled before feeding the fulfilled value back into . Likewise, if a yielded promise is rejected, the rejection error will be passed to .
Example 1: the Fibonacci Sequence. webdriver.promise.consume(function* fibonacci() { var n1 = 1, n2 = 1; for (var i = 0; i < 4; ++i) { var tmp = yield n1 + n2; n1 = n2; n2 = tmp; } return n1 + n2; }).then(function(result) { console.log(result); // 13 });
Example 2: a generator that throws. webdriver.promise.consume(function* () { yield webdriver.promise.delayed(250).then(function() { throw Error('boom'); }); }).thenCatch(function(e) { console.log(e.toString()); // Error: boom });
Parameter generatorFn
The generator function to execute.
Parameter opt_self
The object to use as "this" when invoking the initial generator.
Parameter var_args
Any arguments to pass to the initial generator. {!webdriver.promise.Promise.<?>} A promise that will resolve to the generator's final result.
Throws
{TypeError} If the given function is not a generator.

function controlFlow

controlFlow: () => webdriver.promise.ControlFlow;

{!webdriver.promise.ControlFlow} The currently active control flow.

function createFlow

createFlow: <R>(
    callback: (flow: webdriver.promise.ControlFlow) => R
) => webdriver.promise.Promise<R>;

Creates a new control flow. The provided callback will be invoked as the first task within the new flow, with the flow as its sole argument. Returns a promise that resolves to the callback result.
Parameter callback
The entry point to the newly created flow. {!webdriver.promise.Promise} A promise that resolves to the callback result.

function defer

defer: <T>() => webdriver.promise.Deferred<T>;

Creates a new deferred object. {!webdriver.promise.Deferred} The new deferred object.

function delayed

delayed: (ms: number) => webdriver.promise.Promise<void>;

Creates a promise that will be resolved at a set time in the future.
Parameter ms
The amount of time, in milliseconds, to wait before resolving the promise. {!webdriver.promise.Promise} The promise.

function filter

filter: {
    <T>(
        arr: T[],
        fn: (element: T, index: number, array: T[]) => any,
        opt_self?: any
    ): webdriver.promise.Promise<T[]>;
    <T>(
        arr: webdriver.promise.Promise<T[]>,
        fn: (element: T, index: number, array: T[]) => any,
        opt_self?: any
    ): webdriver.promise.Promise<T[]>;
};

Calls a function for each element in an array, and if the function returns true adds the element to a new array.
If the return value of the filter function is a promise, this function will wait for it to be fulfilled before determining whether to insert the element into the new array.
If the filter function throws or returns a rejected promise, the promise returned by this function will be rejected with the same reason. Only the first failure will be reported; all subsequent errors will be silently ignored.
Parameter arr
The array to iterator over, or a promise that will resolve to said array.
Parameter fn
The function to call for each element in the array.
Parameter opt_self
The object to be used as the value of 'this' within . TYPE, SELF

function fulfilled

fulfilled: <T>(opt_value?: T) => webdriver.promise.Promise<T>;

Creates a promise that has been resolved with the given value.
Parameter opt_value
The resolved value. {!webdriver.promise.Promise} The resolved promise.

function fullyResolved

fullyResolved: <T>(value: any) => webdriver.promise.Promise<T>;

Returns a promise that will be resolved with the input value in a fully-resolved state. If the value is an array, each element will be fully resolved. Likewise, if the value is an object, all keys will be fully resolved. In both cases, all nested arrays and objects will also be fully resolved. All fields are resolved in place; the returned promise will resolve on and not a copy.
Warning: This function makes no checks against objects that contain cyclical references:
var value = {}; value['self'] = value; webdriver.promise.fullyResolved(value); // Stack overflow.
Parameter value
The value to fully resolve. {!webdriver.promise.Promise} A promise for a fully resolved version of the input value.

function isGenerator

isGenerator: (fn: Function) => boolean;

Tests is a function is a generator.
Parameter fn
The function to test. {boolean} Whether the function is a generator.

function isPromise

isPromise: (value: any) => boolean;

Determines whether a should be treated as a promise. Any object whose "then" property is a function will be considered a promise.
Parameter value
The value to test. {boolean} Whether the value is a promise.

function map

map: {
    <T>(
        arr: T[],
        fn: (element: T, index: number, array: T[]) => any,
        opt_self?: any
    ): webdriver.promise.Promise<T[]>;
    <T>(
        arr: webdriver.promise.Promise<T[]>,
        fn: (element: T, index: number, array: T[]) => any,
        opt_self?: any
    ): webdriver.promise.Promise<T[]>;
};

Calls a function for each element in an array and inserts the result into a new array, which is used as the fulfillment value of the promise returned by this function.
If the return value of the mapping function is a promise, this function will wait for it to be fulfilled before inserting it into the new array.
If the mapping function throws or returns a rejected promise, the promise returned by this function will be rejected with the same reason. Only the first failure will be reported; all subsequent errors will be silently ignored.
Parameter arr
The array to iterator over, or a promise that will resolve to said array.
Parameter fn
The function to call for each element in the array. This function should expect three arguments (the element, the index, and the array itself.
Parameter opt_self
The object to be used as the value of 'this' within . TYPE, SELF

function rejected

rejected: (opt_reason?: any) => webdriver.promise.Promise<void>;

Creates a promise that has been rejected with the given reason.
Parameter opt_reason
The rejection reason; may be any value, but is usually an Error or a string. {!webdriver.promise.Promise} The rejected promise.

function setDefaultFlow

setDefaultFlow: (flow: webdriver.promise.ControlFlow) => void;

Changes the default flow to use when no others are active.
Parameter flow
The new default flow.
Throws
{Error} If the default flow is not currently active.

function when

when: {
    <T, R>(
        value: T,
        opt_callback?: (value: T) => any,
        opt_errback?: (error: any) => any
    ): webdriver.promise.Promise<R>;
    <T, R>(
        value: webdriver.promise.Promise<T>,
        opt_callback?: (value: T) => any,
        opt_errback?: (error: any) => any
    ): webdriver.promise.Promise<R>;
};

Registers an observer on a promised , returning a new promise that will be resolved when the value is. If is not a promise, then the return promise will be immediately resolved.
Parameter value
The value to observe.
Parameter opt_callback
The function to call when the value is resolved successfully.
Parameter opt_errback
The function to call when the value is rejected. {!webdriver.promise.Promise} A new promise.

class CancellationError

class CancellationError extends webdriver.promise.CancellationError {}

class ControlFlow

class ControlFlow extends webdriver.promise.ControlFlow {}

class Deferred

class Deferred<T> extends webdriver.promise.Deferred<T> {}

class Promise

class Promise<T> extends webdriver.promise.Promise<T> {}

class Thenable

class Thenable<T> extends webdriver.promise.Thenable<T> {}

namespace protractor.stacktrace

namespace protractor.stacktrace {}

variable BROWSER_SUPPORTED

var BROWSER_SUPPORTED: boolean;

Whether the current browser supports stack traces.
{boolean}

function format

format: (error: any) => any;

Formats an error's stack trace.
Parameter error
The error to format. {!(Error|goog.testing.JsUnitException)} The formatted error.

function get

get: () => webdriver.stacktrace.Frame[];

Gets the native stack trace if available otherwise follows the call chain. The generated trace will exclude all frames up to and including the call to this function. {!Array.<!webdriver.stacktrace.Frame>} The frames of the stack trace.

class Frame

class Frame extends webdriver.stacktrace.Frame {}

class Snapshot

class Snapshot extends webdriver.stacktrace.Snapshot {}

namespace protractor.until

namespace protractor.until {}

function ableToSwitchToFrame

ableToSwitchToFrame: {
    (frame: number): webdriver.until.Condition<boolean>;
    (frame: webdriver.IWebElement): webdriver.until.Condition<boolean>;
    (frame: webdriver.Locator): webdriver.until.Condition<boolean>;
    (
        frame: (webdriver: webdriver.WebDriver) => webdriver.IWebElement
    ): webdriver.until.Condition<boolean>;
    (frame: any): webdriver.until.Condition<boolean>;
};

Creates a condition that will wait until the input driver is able to switch to the designated frame. The target frame may be specified as: A numeric index into for the currently selected frame. A webdriver.WebElement, which must reference a FRAME or IFRAME element on the current page. A locator which may be used to first locate a FRAME or IFRAME on the current page before attempting to switch to it.
Upon successful resolution of this condition, the driver will be left focused on the new frame.
Parameter frame
The frame identifier. {!until.Condition.} A new condition.

function alertIsPresent

alertIsPresent: () => webdriver.until.Condition<webdriver.Alert>;

Creates a condition that waits for an alert to be opened. Upon success, the returned promise will be fulfilled with the handle for the opened alert.
{!until.Condition.<!webdriver.Alert>} The new condition.

function elementIsDisabled

elementIsDisabled: (
    element: webdriver.IWebElement
) => webdriver.until.Condition<boolean>;

Creates a condition that will wait for the given element to be disabled.
Parameter element
The element to test. {!until.Condition.} The new condition.
See Also
- webdriver.WebDriver#isEnabled

function elementIsEnabled

elementIsEnabled: (
    element: webdriver.IWebElement
) => webdriver.until.Condition<boolean>;

Creates a condition that will wait for the given element to be enabled.
Parameter element
The element to test. {!until.Condition.} The new condition.
See Also
- webdriver.WebDriver#isEnabled

function elementIsNotSelected

elementIsNotSelected: (
    element: webdriver.IWebElement
) => webdriver.until.Condition<boolean>;

Creates a condition that will wait for the given element to be deselected.
Parameter element
The element to test. {!until.Condition.} The new condition.
See Also
- webdriver.WebDriver#isSelected

function elementIsNotVisible

elementIsNotVisible: (
    element: webdriver.IWebElement
) => webdriver.until.Condition<boolean>;

Creates a condition that will wait for the given element to be in the DOM, yet not visible to the user.
Parameter element
The element to test. {!until.Condition.} The new condition.
See Also
- webdriver.WebDriver#isDisplayed

function elementIsSelected

elementIsSelected: (
    element: webdriver.IWebElement
) => webdriver.until.Condition<boolean>;

Creates a condition that will wait for the given element to be selected.
Parameter element
The element to test. {!until.Condition.} The new condition.
See Also
- webdriver.WebDriver#isSelected

function elementIsVisible

elementIsVisible: (
    element: webdriver.IWebElement
) => webdriver.until.Condition<boolean>;

Creates a condition that will wait for the given element to become visible.
Parameter element
The element to test. {!until.Condition.} The new condition.
See Also
- webdriver.WebDriver#isDisplayed

function elementLocated

elementLocated: {
    (locator: webdriver.Locator): webdriver.until.Condition<webdriver.IWebElement>;
    (locator: any): webdriver.until.Condition<webdriver.IWebElement>;
};

Creates a condition that will loop until an element is with the given locator.
Parameter locator
The locator to use. {!until.Condition.<!webdriver.WebElement>} The new condition.

function elementsLocated

elementsLocated: {
    (locator: webdriver.Locator): webdriver.until.Condition<webdriver.IWebElement[]>;
    (locator: any): webdriver.until.Condition<webdriver.IWebElement[]>;
};

Creates a condition that will loop until at least one element is with the given locator.
Parameter locator
The locator to use. {!until.Condition.<!Array.<!webdriver.WebElement>>} The new condition.

function elementTextContains

elementTextContains: (
    element: webdriver.IWebElement,
    substr: string
) => webdriver.until.Condition<boolean>;

Creates a condition that will wait for the given element's to contain the given substring.
Parameter element
The element to test.
Parameter substr
The substring to search for. {!until.Condition.} The new condition.
See Also
- webdriver.WebDriver#getText

function elementTextIs

elementTextIs: (
    element: webdriver.IWebElement,
    text: string
) => webdriver.until.Condition<boolean>;

Creates a condition that will wait for the given element's to match the given exactly.
Parameter element
The element to test.
Parameter text
The expected text. {!until.Condition.} The new condition.
See Also
- webdriver.WebDriver#getText

function elementTextMatches

elementTextMatches: (
    element: webdriver.IWebElement,
    regex: RegExp
) => webdriver.until.Condition<boolean>;

Creates a condition that will wait for the given element's to match a regular expression.
Parameter element
The element to test.
Parameter regex
The regular expression to test against. {!until.Condition.} The new condition.
See Also
- webdriver.WebDriver#getText

function stalenessOf

stalenessOf: (
    element: webdriver.IWebElement
) => webdriver.until.Condition<boolean>;

Creates a condition that will wait for the given element to become stale. An element is considered stale once it is removed from the DOM, or a new page has loaded.
Parameter element
The element that should become stale. {!until.Condition.} The new condition.

function titleContains

titleContains: (substr: string) => webdriver.until.Condition<boolean>;

Creates a condition that will wait for the current page's title to contain the given substring.
Parameter substr
The substring that should be present in the page title. {!until.Condition.} The new condition.

function titleIs

titleIs: (title: string) => webdriver.until.Condition<boolean>;

Creates a condition that will wait for the current page's title to match the given value.
Parameter title
The expected page title. {!until.Condition.} The new condition.

function titleMatches

titleMatches: (regex: RegExp) => webdriver.until.Condition<boolean>;

Creates a condition that will wait for the current page's title to match the given regular expression.
Parameter regex
The regular expression to test against. {!until.Condition.} The new condition.

class Condition

class Condition<T> extends webdriver.until.Condition<T> {}

namespace punycode

module 'punycode' {}

variable ucs2

var ucs2: ucs2;

variable version

var version: any;

function decode

decode: (string: string) => string;

function encode

encode: (string: string) => string;

function toASCII

toASCII: (domain: string) => string;

function toUnicode

toUnicode: (domain: string) => string;

interface ucs2

interface ucs2 {}

method decode

decode: (string: string) => number[];

method encode

encode: (codePoints: number[]) => string;

namespace querystring

module 'querystring' {}

function escape

escape: (str: string) => string;

function parse

parse: {
    (str: string, sep?: string, eq?: string, options?: ParseOptions): any;
    <T extends {}>(
        str: string,
        sep?: string,
        eq?: string,
        options?: ParseOptions
    ): T;
};

function stringify

stringify: <T>(
    obj: T,
    sep?: string,
    eq?: string,
    options?: StringifyOptions
) => string;

function unescape

unescape: (str: string) => string;

interface ParseOptions

interface ParseOptions {}

property decodeURIComponent

decodeURIComponent?: Function;

property maxKeys

maxKeys?: number;

interface StringifyOptions

interface StringifyOptions {}

property encodeURIComponent

encodeURIComponent?: Function;

namespace readline

module 'readline' {}

function clearLine

clearLine: (stream: NodeJS.WritableStream, dir: number) => void;

function clearScreenDown

clearScreenDown: (stream: NodeJS.WritableStream) => void;

function createInterface

createInterface: {
    (
        input: NodeJS.ReadableStream,
        output?: NodeJS.WritableStream,
        completer?: Completer,
        terminal?: boolean
    ): ReadLine;
    (options: ReadLineOptions): ReadLine;
};

function cursorTo

cursorTo: (stream: NodeJS.WritableStream, x: number, y: number) => void;

function moveCursor

moveCursor: (
    stream: NodeJS.WritableStream,
    dx: number | string,
    dy: number | string
) => void;

interface Completer

interface Completer {}

call signature

(line: string): CompleterResult;

call signature

(line: string, callback: (err: any, result: CompleterResult) => void): any;

interface CompleterResult

interface CompleterResult {}

property completions

completions: string[];

property line

line: string;

interface Key

interface Key {}

property ctrl

ctrl?: boolean;

property meta

meta?: boolean;

property name

name?: string;

property sequence

sequence?: string;

property shift

shift?: boolean;

interface ReadLine

interface ReadLine extends events.EventEmitter {}

method close

close: () => void;

method pause

pause: () => ReadLine;

method prompt

prompt: (preserveCursor?: boolean) => void;

method question

question: (query: string, callback: (answer: string) => void) => void;

method resume

resume: () => ReadLine;

method setPrompt

setPrompt: (prompt: string) => void;

method write

write: (data: string | Buffer, key?: Key) => void;

interface ReadLineOptions

interface ReadLineOptions {}

property completer

completer?: Completer;

property historySize

historySize?: number;

property input

input: NodeJS.ReadableStream;

property output

output?: NodeJS.WritableStream;

property terminal

terminal?: boolean;

namespace repl

module 'repl' {}

function start

start: (options: ReplOptions) => events.EventEmitter;

interface ReplOptions

interface ReplOptions {}

property eval

eval?: Function;

property ignoreUndefined

ignoreUndefined?: boolean;

property input

input?: NodeJS.ReadableStream;

property output

output?: NodeJS.WritableStream;

property prompt

prompt?: string;

property terminal

terminal?: boolean;

property useColors

useColors?: boolean;

property useGlobal

useGlobal?: boolean;

property writer

writer?: Function;

namespace selenium-webdriver

module 'selenium-webdriver' {}

variable Browser

var Browser: IBrowser;

variable Button

var Button: IButton;

variable Capability

var Capability: ICapability;

variable CommandName

var CommandName: ICommandName;

variable Key

var Key: IKey;

class ActionSequence

class ActionSequence {}

Class for defining sequences of complex user interactions. Each sequence will not be executed until is called.
Example: new webdriver.ActionSequence(driver). keyDown(webdriver.Key.SHIFT). click(element1). click(element2). dragAndDrop(element3, element4). keyUp(webdriver.Key.SHIFT). perform();

constructor

constructor(driver: WebDriver);

Parameter driver
The driver instance to use.

method click

click: {
    (opt_elementOrButton?: WebElement, opt_button?: number): ActionSequence;
    (opt_elementOrButton?: number): ActionSequence;
};

Clicks a mouse button.
If an element is provided, the mouse will first be moved to the center of that element. This is equivalent to: sequence.mouseMove(element).click()
Parameter opt_elementOrButton
Either the element to interact with or the button to click with. Defaults to webdriver.Button.LEFT if neither an element nor button is specified.
Parameter opt_button
The button to use. Defaults to webdriver.Button.LEFT. Ignored if a button is provided as the first argument. {!webdriver.ActionSequence} A self reference.

method doubleClick

doubleClick: {
    (opt_elementOrButton?: WebElement, opt_button?: number): ActionSequence;
    (opt_elementOrButton?: number): ActionSequence;
};

Double-clicks a mouse button.
If an element is provided, the mouse will first be moved to the center of that element. This is equivalent to: sequence.mouseMove(element).doubleClick()
Warning: this method currently only supports the left mouse button. See http://code.google.com/p/selenium/issues/detail?id=4047
Parameter opt_elementOrButton
Either the element to interact with or the button to click with. Defaults to webdriver.Button.LEFT if neither an element nor button is specified.
Parameter opt_button
The button to use. Defaults to webdriver.Button.LEFT. Ignored if a button is provided as the first argument. {!webdriver.ActionSequence} A self reference.

method dragAndDrop

dragAndDrop: {
    (element: WebElement, location: WebElement): ActionSequence;
    (element: WebElement, location: ILocation): ActionSequence;
};

Convenience function for performing a "drag and drop" manuever. The target element may be moved to the location of another element, or by an offset (in pixels).
Parameter element
The element to drag.
Parameter location
The location to drag to, either as another WebElement or an offset in pixels. {!webdriver.ActionSequence} A self reference.

method keyDown

keyDown: (key: string) => ActionSequence;

Performs a modifier key press. The modifier key is not released until or is called. The key press will be targetted at the currently focused element.
Parameter key
The modifier key to push. Must be one of {ALT, CONTROL, SHIFT, COMMAND, META}. {!webdriver.ActionSequence} A self reference.
Throws
{Error} If the key is not a valid modifier key.

method keyUp

keyUp: (key: string) => ActionSequence;

Performs a modifier key release. The release is targetted at the currently focused element.
Parameter key
The modifier key to release. Must be one of {ALT, CONTROL, SHIFT, COMMAND, META}. {!webdriver.ActionSequence} A self reference.
Throws
{Error} If the key is not a valid modifier key.

method mouseDown

mouseDown: {
    (opt_elementOrButton?: WebElement, opt_button?: number): ActionSequence;
    (opt_elementOrButton?: number): ActionSequence;
};

Presses a mouse button. The mouse button will not be released until is called, regardless of whether that call is made in this sequence or another. The behavior for out-of-order events (e.g. mouseDown, click) is undefined.
If an element is provided, the mouse will first be moved to the center of that element. This is equivalent to: sequence.mouseMove(element).mouseDown()
Warning: this method currently only supports the left mouse button. See http://code.google.com/p/selenium/issues/detail?id=4047
Parameter opt_elementOrButton
Either the element to interact with or the button to click with. Defaults to webdriver.Button.LEFT if neither an element nor button is specified.
Parameter opt_button
The button to use. Defaults to webdriver.Button.LEFT. Ignored if a button is provided as the first argument. {!webdriver.ActionSequence} A self reference.

method mouseMove

mouseMove: {
    (location: WebElement, opt_offset?: ILocation): ActionSequence;
    (location: ILocation): ActionSequence;
};

Moves the mouse. The location to move to may be specified in terms of the mouse's current location, an offset relative to the top-left corner of an element, or an element (in which case the middle of the element is used).
Parameter location
The location to drag to, as either another WebElement or an offset in pixels.
Parameter opt_offset
An optional offset, in pixels. Defaults to (0, 0). {!webdriver.ActionSequence} A self reference.

method mouseUp

mouseUp: {
    (opt_elementOrButton?: WebElement, opt_button?: number): ActionSequence;
    (opt_elementOrButton?: number): ActionSequence;
};

Releases a mouse button. Behavior is undefined for calling this function without a previous call to .
If an element is provided, the mouse will first be moved to the center of that element. This is equivalent to: sequence.mouseMove(element).mouseUp()
Warning: this method currently only supports the left mouse button. See http://code.google.com/p/selenium/issues/detail?id=4047
Parameter opt_elementOrButton
Either the element to interact with or the button to click with. Defaults to webdriver.Button.LEFT if neither an element nor button is specified.
Parameter opt_button
The button to use. Defaults to webdriver.Button.LEFT. Ignored if a button is provided as the first argument. {!webdriver.ActionSequence} A self reference.

method perform

perform: () => webdriver.promise.Promise<void>;

Executes this action sequence. {!webdriver.promise.Promise} A promise that will be resolved once this sequence has completed.

method sendKeys

sendKeys: (...var_args: any[]) => ActionSequence;

Simulates typing multiple keys. Each modifier key encountered in the sequence will not be released until it is encountered again. All key events will be targetted at the currently focused element.
Parameter var_args
The keys to type. {!webdriver.ActionSequence} A self reference.
Throws
{Error} If the key is not a valid modifier key.

class Builder

class Builder {}

constructor

constructor();

method build

build: () => WebDriver;

Creates a new WebDriver client based on this builder's current configuration.
{!webdriver.WebDriver} A new WebDriver instance.
Throws
{Error} If the current configuration is invalid.

method forBrowser

forBrowser: (
    name: string,
    opt_version?: string,
    opt_platform?: string
) => Builder;

Configures the target browser for clients created by this instance. Any calls to after this function will overwrite these settings.
You may also define the target browser using the environment variable. If set, this environment variable should be of the form .
Parameter name
The name of the target browser; common defaults are available on the webdriver.Browser enum.
Parameter opt_version
A desired version; may be omitted if any version should be used.
Parameter opt_platform
The desired platform; may be omitted if any version may be used. {!Builder} A self reference.

method getCapabilities

getCapabilities: () => Capabilities;

Returns the base set of capabilities this instance is currently configured to use. {!webdriver.Capabilities} The current capabilities for this builder.

method getServerUrl

getServerUrl: () => string;

{string} The URL of the WebDriver server this instance is configured to use.

method setAlertBehavior

setAlertBehavior: (behavior: string) => Builder;

Sets the default action to take with an unexpected alert before returning an error.
Parameter beahvior
The desired behavior; should be "accept", "dismiss", or "ignore". Defaults to "dismiss". {!Builder} A self reference.

method setChromeOptions

setChromeOptions: (options: chrome.Options) => Builder;

Sets Chrome-specific options for drivers created by this builder. Any logging or proxy settings defined on the given options will take precedence over those set through and , respectively.
Parameter options
The ChromeDriver options to use. {!Builder} A self reference.

method setControlFlow

setControlFlow: (flow: webdriver.promise.ControlFlow) => Builder;

Sets the control flow that created drivers should execute actions in. If the flow is never set, or is set to , it will use the active flow at the time is called.
Parameter flow
The control flow to use, or to {!Builder} A self reference.

method setEnableNativeEvents

setEnableNativeEvents: (enabled: boolean) => Builder;

Sets whether native events should be used.
Parameter enabled
Whether to enable native events. {!Builder} A self reference.

method setFirefoxOptions

setFirefoxOptions: (options: firefox.Options) => Builder;

Sets Firefox-specific options for drivers created by this builder. Any logging or proxy settings defined on the given options will take precedence over those set through and , respectively.
Parameter options
The FirefoxDriver options to use. {!Builder} A self reference.

method setLoggingPrefs

setLoggingPrefs: {
    (prefs: webdriver.logging.Preferences): Builder;
    (prefs: { [key: string]: string }): Builder;
};

Sets the logging preferences for the created session. Preferences may be changed by repeated calls, or by calling .
Parameter prefs
The desired logging preferences. {!Builder} A self reference.

method setProxy

setProxy: (config: ProxyConfig) => Builder;

Sets the proxy configuration to use for WebDriver clients created by this builder. Any calls to after this function will overwrite these settings.
Parameter config
The configuration to use. {!Builder} A self reference.

method setScrollBehavior

setScrollBehavior: (behavior: number) => Builder;

Sets how elements should be scrolled into view for interaction.
Parameter behavior
The desired scroll behavior: either 0 to align with the top of the viewport or 1 to align with the bottom. {!Builder} A self reference.

method usingServer

usingServer: (url: string) => Builder;

Sets the URL of a remote WebDriver server to use. Once a remote URL has been specified, the builder direct all new clients to that server. If this method is never called, the Builder will attempt to create all clients locally.
As an alternative to this method, you may also set the environment variable.
Parameter url
The URL of a remote server to use. {!Builder} A self reference.

method withCapabilities

withCapabilities: {
    (capabilities: Capabilities): Builder;
    (capabilities: any): Builder;
};

Sets the desired capabilities when requesting a new session. This will overwrite any previously set capabilities.
Parameter capabilities
The desired capabilities for a new session. {!Builder} A self reference.

class Capabilities

class Capabilities {}

constructor

constructor(opt_other?: Capabilities);

Parameter opt_other
Another set of capabilities to merge into this instance.

constructor

constructor(opt_other?: any);

method android

static android: () => Capabilities;

{!webdriver.Capabilities} A basic set of capabilities for Android.

method chrome

static chrome: () => Capabilities;

{!webdriver.Capabilities} A basic set of capabilities for Chrome.

method firefox

static firefox: () => Capabilities;

{!webdriver.Capabilities} A basic set of capabilities for Firefox.

method get

get: (key: string) => any;

Parameter key
The capability to return. {*} The capability with the given key, or if it has not been set.

method has

has: (key: string) => boolean;

Parameter key
The capability to check. {boolean} Whether the specified capability is set.

method htmlunit

static htmlunit: () => Capabilities;

{!webdriver.Capabilities} A basic set of capabilities for HTMLUnit.

method htmlunitwithjs

static htmlunitwithjs: () => Capabilities;

{!webdriver.Capabilities} A basic set of capabilities for HTMLUnit with enabled Javascript.

method ie

static ie: () => Capabilities;

{!webdriver.Capabilities} A basic set of capabilities for Internet Explorer.

method ipad

static ipad: () => Capabilities;

{!webdriver.Capabilities} A basic set of capabilities for iPad.

method iphone

static iphone: () => Capabilities;

{!webdriver.Capabilities} A basic set of capabilities for iPhone.

method merge

merge: { (other: Capabilities): Capabilities; (other: any): Capabilities };

Merges another set of capabilities into this instance. Any duplicates in the provided set will override those already set on this instance.
Parameter other
The capabilities to merge into this instance. {!webdriver.Capabilities} A self reference.

method opera

static opera: () => Capabilities;

{!webdriver.Capabilities} A basic set of capabilities for Opera.

method phantomjs

static phantomjs: () => Capabilities;

{!webdriver.Capabilities} A basic set of capabilities for PhantomJS.

method safari

static safari: () => Capabilities;

{!webdriver.Capabilities} A basic set of capabilities for Safari.

method set

set: (key: string, value: any) => Capabilities;

Parameter key
The capability to set.
Parameter value
The capability value. Capability values must be JSON serializable. Pass to unset the capability. {!webdriver.Capabilities} A self reference.

method setAlertBehavior

setAlertBehavior: (behavior: string) => Capabilities;

Sets the default action to take with an unexpected alert before returning an error.
Parameter behavior
The desired behavior; should be "accept", "dismiss", or "ignore". Defaults to "dismiss". {!webdriver.Capabilities} A self reference.

method setEnableNativeEvents

setEnableNativeEvents: (enabled: boolean) => Capabilities;

Sets whether native events should be used.
Parameter enabled
Whether to enable native events. {!webdriver.Capabilities} A self reference.

method setLoggingPrefs

setLoggingPrefs: {
    (prefs: webdriver.logging.Preferences): Capabilities;
    (prefs: { [key: string]: string }): Capabilities;
};

Sets the logging preferences. Preferences may be specified as a webdriver.logging.Preferences instance, or a as a map of log-type to log-level.
Parameter prefs
The logging preferences. {!webdriver.Capabilities} A self reference.

method setProxy

setProxy: (proxy: ProxyConfig) => Capabilities;

Sets the proxy configuration for this instance.
Parameter proxy
The desired proxy configuration. {!webdriver.Capabilities} A self reference.

method setScrollBehavior

setScrollBehavior: (behavior: number) => Capabilities;

Sets how elements should be scrolled into view for interaction.
Parameter behavior
The desired scroll behavior: either 0 to align with the top of the viewport or 1 to align with the bottom. {!webdriver.Capabilities} A self reference.

method toJSON

toJSON: () => any;

{!Object} The JSON representation of this instance.

class Command

class Command {}

Describes a command to be executed by the WebDriverJS framework.
Parameter name
The name of this command.

constructor

constructor(name: string);

Parameter name
The name of this command.

method getName

getName: () => string;

{!webdriver.CommandName} This command's name.

method getParameter

getParameter: (key: string) => any;

Returns a named command parameter.
Parameter key
The parameter key to look up. {*} The parameter value, or undefined if it has not been set.

method getParameters

getParameters: () => any;

{!Object.<*>} The parameters to send with this command.

method setParameter

setParameter: (name: string, value: any) => Command;

Sets a parameter to send with this command.
Parameter name
The parameter name.
Parameter value
The parameter value. {!webdriver.Command} A self reference.

method setParameters

setParameters: (parameters: any) => Command;

Sets the parameters for this command.
Parameter parameters
The command parameters. {!webdriver.Command} A self reference.

class EventEmitter

class EventEmitter {}

Object that can emit events for others to listen for. This is used instead of Closure's event system because it is much more light weight. The API is based on Node's EventEmitters.

constructor

constructor();

method addListener

addListener: (
    type: string,
    listenerFn: Function,
    opt_scope?: any
) => EventEmitter;

Registers a listener.
Parameter type
The type of event to listen for.
Parameter listenerFn
The function to invoke when the event is fired.
Parameter opt_scope
The object in whose scope to invoke the listener. {!webdriver.EventEmitter} A self reference.

method emit

emit: (type: string, ...var_args: any[]) => void;

Fires an event and calls all listeners.
Parameter type
The type of event to emit.
Parameter var_args
Any arguments to pass to each listener.

method listeners

listeners: (
    type: string
) => Array<{ fn: Function; oneshot: boolean; scope: any }>;

Returns a mutable list of listeners for a specific type of event.
Parameter type
The type of event to retrieve the listeners for. {!Array.<{fn: !Function, oneshot: boolean, scope: (Object|undefined)}>} The registered listeners for the given event type.

method on

on: (type: string, listenerFn: Function, opt_scope?: any) => EventEmitter;

An alias for .
Parameter type
The type of event to listen for.
Parameter listenerFn
The function to invoke when the event is fired.
Parameter opt_scope
The object in whose scope to invoke the listener. {!webdriver.EventEmitter} A self reference.

method once

once: (type: string, listenerFn: any, opt_scope?: any) => EventEmitter;

Registers a one-time listener which will be called only the first time an event is emitted, after which it will be removed.
Parameter type
The type of event to listen for.
Parameter listenerFn
The function to invoke when the event is fired.
Parameter opt_scope
The object in whose scope to invoke the listener. {!webdriver.EventEmitter} A self reference.

method removeAllListeners

removeAllListeners: (opt_type?: string) => EventEmitter;

Removes all listeners for a specific type of event. If no event is specified, all listeners across all types will be removed.
Parameter opt_type
The type of event to remove listeners from. {!webdriver.EventEmitter} A self reference.

method removeListener

removeListener: (type: string, listenerFn: Function) => EventEmitter;

Removes a previously registered event listener.
Parameter type
The type of event to unregister.
Parameter listenerFn
The handler function to remove. {!webdriver.EventEmitter} A self reference.

class FileDetector

class FileDetector {}

Used with on file input elements () to detect when the entered key sequence defines the path to a file.
By default, will enter all key sequences exactly as entered. You may set a on the parent WebDriver instance to define custom behavior for handling file elements. Of particular note is the , which should be used when running against a remote [Selenium Server](http://docs.seleniumhq.org/download/).

constructor

constructor();

method handleFile

handleFile: (
    driver: webdriver.WebDriver,
    path: string
) => webdriver.promise.Promise<string>;

Handles the file specified by the given path, preparing it for use with the current browser. If the path does not refer to a valid file, it will be returned unchanged, otherwisee a path suitable for use with the current browser will be returned.
This default implementation is a no-op. Subtypes may override this function for custom tailored file handling.
Parameter driver
The driver for the current browser.
Parameter path
The path to process. {!webdriver.promise.Promise} A promise for the processed file path.

class Locator

class Locator {}

An element locator.

constructor

constructor(using: string, value: string);

An element locator.
Parameter using
The type of strategy to use for this locator.
Parameter value
The search target of this locator.

property Strategy

static Strategy: {
    className: typeof webdriver.By.className;
    css: typeof webdriver.By.css;
    id: typeof webdriver.By.id;
    js: typeof webdriver.By.js;
    linkText: typeof webdriver.By.linkText;
    name: typeof webdriver.By.name;
    partialLinkText: typeof webdriver.By.partialLinkText;
    tagName: typeof webdriver.By.tagName;
    xpath: typeof webdriver.By.xpath;
};

Maps webdriver.By.Hash keys to the appropriate factory function. {!Object.<string, function(string): !(Function|webdriver.Locator)>}

property using

using: string;

The search strategy to use when searching for an element. {string}

property value

value: string;

The search target for this locator. {string}

method checkLocator

static checkLocator: (value: any) => Locator | Function;

Verifies that a is a valid locator to use for searching for elements on the page.
Parameter value
The value to check is a valid locator. {!(webdriver.Locator|Function)} A valid locator object or function.
Throws
{TypeError} If the given value is an invalid locator.

method toString

toString: () => string;

{string} String representation of this locator.

class Session

class Session {}

Contains information about a WebDriver session.

constructor

constructor(id: string, capabilities: Capabilities);

Parameter id
The session ID.
Parameter capabilities
The session capabilities.

constructor

constructor(id: string, capabilities: any);

method getCapabilities

getCapabilities: () => Capabilities;

{!webdriver.Capabilities} This session's capabilities.

method getCapability

getCapability: (key: string) => any;

Retrieves the value of a specific capability.
Parameter key
The capability to retrieve. {*} The capability value.

method getId

getId: () => string;

{string} This session's ID.

method toJSON

toJSON: () => string;

Returns the JSON representation of this object, which is just the string session ID. {string} The JSON representation of this Session.

class TouchSequence

class TouchSequence {}

Class for defining sequences of user touch interactions. Each sequence will not be executed until is called.
Example:
new webdriver.TouchSequence(driver). tapAndHold({x: 0, y: 0}). move({x: 3, y: 4}). release({x: 10, y: 10}). perform();

constructor

constructor(driver: WebDriver);

method doubleTap

doubleTap: (elem: WebElement) => TouchSequence;

Double taps an element.
Parameter elem
The element to double tap. {!webdriver.TouchSequence} A self reference.

method flick

flick: (speed: ISpeed) => TouchSequence;

Flick, starting anywhere on the screen, at speed xspeed and yspeed.
Parameter speed
The speed to flick in each direction, in pixels per second. {!webdriver.TouchSequence} A self reference.

method flickElement

flickElement: (
    elem: WebElement,
    offset: IOffset,
    speed: number
) => TouchSequence;

Flick starting at elem and moving by x and y at specified speed.
Parameter elem
The element where flick starts.
Parameter offset
The offset to flick to.
Parameter speed
The speed to flick at in pixels per second. {!webdriver.TouchSequence} A self reference.

method longPress

longPress: (elem: WebElement) => TouchSequence;

Long press on an element.
Parameter elem
The element to long press. {!webdriver.TouchSequence} A self reference.

method move

move: (location: ILocation) => TouchSequence;

Move a held to the specified location.
Parameter location
The location to move to. {!webdriver.TouchSequence} A self reference.

method perform

perform: () => webdriver.promise.Promise<void>;

Executes this action sequence. {!webdriver.promise.Promise} A promise that will be resolved once this sequence has completed.

method release

release: (location: ILocation) => TouchSequence;

Release a held at the specified location.
Parameter location
The location to release at. {!webdriver.TouchSequence} A self reference.

method scroll

scroll: (offset: IOffset) => TouchSequence;

Scrolls the touch screen by the given offset.
Parameter offset
The offset to scroll to. {!webdriver.TouchSequence} A self reference.

method scrollFromElement

scrollFromElement: (elem: WebElement, offset: IOffset) => TouchSequence;

Scrolls the touch screen, starting on elem and moving by the specified offset.
Parameter elem
The element where scroll starts.
Parameter offset
The offset to scroll to. {!webdriver.TouchSequence} A self reference.

method tap

tap: (elem: WebElement) => TouchSequence;

Taps an element.
Parameter elem
The element to tap. {!webdriver.TouchSequence} A self reference.

method tapAndHold

tapAndHold: (location: ILocation) => TouchSequence;

Touch down at the given location.
Parameter location
The location to touch down at. {!webdriver.TouchSequence} A self reference.

class WebDriver

class WebDriver {}

Creates a new WebDriver client, which provides control over a browser.
Every WebDriver command returns a that represents the result of that command. Callbacks may be registered on this object to manipulate the command result or catch an expected error. Any commands scheduled with a callback are considered sub-commands and will execute before the next command in the current frame. For example:
var message = []; driver.call(message.push, message, 'a').then(function() { driver.call(message.push, message, 'b'); }); driver.call(message.push, message, 'c'); driver.call(function() { alert('message is abc? ' + (message.join('') == 'abc')); });

constructor

constructor(
    session: Session,
    executor: CommandExecutor,
    opt_flow?: promise.ControlFlow
);

Parameter session
Either a known session or a promise that will be resolved to a session.
Parameter executor
The executor to use when sending commands to the browser.
Parameter opt_flow
The flow to schedule commands through. Defaults to the active flow object.

constructor

constructor(
    session: promise.Promise<Session>,
    executor: CommandExecutor,
    opt_flow?: promise.ControlFlow
);

property Logs

static Logs: WebDriverLogs;

static Navigation: WebDriverNavigation;

property Options

static Options: WebDriverOptions;

property TargetLocator

static TargetLocator: WebDriverTargetLocator;

property Timeouts

static Timeouts: WebDriverTimeouts;

property Window

static Window: WebDriverWindow;

method actions

actions: () => ActionSequence;

Creates a new action sequence using this driver. The sequence will not be scheduled for execution until webdriver.ActionSequence#perform is called. Example: driver.actions(). mouseDown(element1). mouseMove(element2). mouseUp(). perform(); {!webdriver.ActionSequence} A new action sequence for this instance.

method attachToSession

static attachToSession: (
    executor: CommandExecutor,
    sessionId: string,
    opt_flow?: webdriver.promise.ControlFlow
) => WebDriver;

Creates a new WebDriver client for an existing session.
Parameter executor
Command executor to use when querying for session details.
Parameter sessionId
ID of the session to attach to.
Parameter opt_flow
The control flow all driver commands should execute under. Defaults to the control flow. {!webdriver.WebDriver} A new client for the specified session.

method call

call: <T>(
    fn: (...var_args: any[]) => T | webdriver.promise.Promise<T>,
    opt_scope?: any,
    ...var_args: any[]
) => webdriver.promise.Promise<T>;

Schedules a command to execute a custom function.
Parameter fn
The function to execute.
Parameter opt_scope
The object in whose scope to execute the function.
Parameter var_args
Any arguments to pass to the function. {!webdriver.promise.Promise.} A promise that will be resolved' with the function's result. T

method close

close: () => webdriver.promise.Promise<void>;

Schedules a command to close the current window. {!webdriver.promise.Promise.} A promise that will be resolved when this command has completed.

method controlFlow

controlFlow: () => webdriver.promise.ControlFlow;

{!webdriver.promise.ControlFlow} The control flow used by this instance.

method createSession

static createSession: (
    executor: CommandExecutor,
    desiredCapabilities: Capabilities,
    opt_flow?: webdriver.promise.ControlFlow
) => WebDriver;

Creates a new WebDriver session.
Parameter executor
The executor to create the new session with.
Parameter desiredCapabilities
The desired capabilities for the new session.
Parameter opt_flow
The control flow all driver commands should execute under, including the initial session creation. Defaults to the control flow. {!webdriver.WebDriver} The driver for the newly created session.

method executeAsyncScript

executeAsyncScript: <T>(
    script: string | Function,
    ...var_args: any[]
) => webdriver.promise.Promise<T>;

Schedules a command to execute asynchronous JavaScript in the context of the currently selected frame or window. The script fragment will be executed as the body of an anonymous function. If the script is provided as a function object, that function will be converted to a string for injection into the target window.
Any arguments provided in addition to the script will be included as script arguments and may be referenced using the object. Arguments may be a boolean, number, string, or . Arrays and objects may also be used as script arguments as long as each item adheres to the types previously mentioned.
Unlike executing synchronous JavaScript with , scripts executed with this function must explicitly signal they are finished by invoking the provided callback. This callback will always be injected into the executed function as the last argument, and thus may be referenced with . The following steps will be taken for resolving this functions return value against the first argument to the script's callback function:
- For a HTML element, the value will resolve to a webdriver.WebElement - Null and undefined return values will resolve to null - Booleans, numbers, and strings will resolve as is - Functions will resolve to their string representation - For arrays and objects, each member item will be converted according to the rules above
__Example #1:__ Performing a sleep that is synchronized with the currently selected window:
var start = new Date().getTime(); driver.executeAsyncScript( 'window.setTimeout(arguments[arguments.length - 1], 500);'). then(function() { console.log( 'Elapsed time: ' + (new Date().getTime() - start) + ' ms'); });
__Example #2:__ Synchronizing a test with an AJAX application:
var button = driver.findElement(By.id('compose-button')); button.click(); driver.executeAsyncScript( 'var callback = arguments[arguments.length - 1];' + 'mailClient.getComposeWindowWidget().onload(callback);'); driver.switchTo().frame('composeWidget'); driver.findElement(By.id('to')).sendKeys('dog@example.com');
__Example #3:__ Injecting a XMLHttpRequest and waiting for the result. In this example, the inject script is specified with a function literal. When using this format, the function is converted to a string for injection, so it should not reference any symbols not defined in the scope of the page under test.
driver.executeAsyncScript(function() { var callback = arguments[arguments.length - 1]; var xhr = new XMLHttpRequest(); xhr.open("GET", "/resource/data.json", true); xhr.onreadystatechange = function() { if (xhr.readyState == 4) { callback(xhr.responseText); } } xhr.send(''); }).then(function(str) { console.log(JSON.parse(str)['food']); });
Parameter script
The script to execute.
Parameter var_args
The arguments to pass to the script. {!webdriver.promise.Promise.} A promise that will resolve to the scripts return value. T

method executeScript

executeScript: {
    <T>(script: string, ...var_args: any[]): webdriver.promise.Promise<T>;
    <T>(script: Function, ...var_args: any[]): promise.Promise<T>;
};

Schedules a command to execute JavaScript in the context of the currently selected frame or window. The script fragment will be executed as the body of an anonymous function. If the script is provided as a function object, that function will be converted to a string for injection into the target window.
Any arguments provided in addition to the script will be included as script arguments and may be referenced using the object. Arguments may be a boolean, number, string, or . Arrays and objects may also be used as script arguments as long as each item adheres to the types previously mentioned.
The script may refer to any variables accessible from the current window. Furthermore, the script will execute in the window's context, thus may be used to refer to the current document. Any local variables will not be available once the script has finished executing, though global variables will persist.
If the script has a return value (i.e. if the script contains a return statement), then the following steps will be taken for resolving this functions return value:
- For a HTML element, the value will resolve to a webdriver.WebElement - Null and undefined return values will resolve to null - Booleans, numbers, and strings will resolve as is - Functions will resolve to their string representation - For arrays and objects, each member item will be converted according to the rules above
Parameter script
The script to execute.
Parameter var_args
The arguments to pass to the script. {!webdriver.promise.Promise.} A promise that will resolve to the scripts return value. T

method findElement

findElement: (
    locatorOrElement: Locator | By.Hash | WebElement | Function
) => WebElementPromise;

Schedule a command to find an element on the page. If the element cannot be found, a bot.ErrorCode.NO_SUCH_ELEMENT result will be returned by the driver. Unlike other commands, this error cannot be suppressed. In other words, scheduling a command to find an element doubles as an assert that the element is present on the page. To test whether an element is present on the page, use instead.
The search criteria for an element may be defined using one of the factories in the webdriver.By namespace, or as a short-hand webdriver.By.Hash object. For example, the following two statements are equivalent:
var e1 = driver.findElement(By.id('foo')); var e2 = driver.findElement({id:'foo'});
You may also provide a custom locator function, which takes as input this WebDriver instance and returns a webdriver.WebElement, or a promise that will resolve to a WebElement. For example, to find the first visible link on a page, you could write:
var link = driver.findElement(firstVisibleLink);
function firstVisibleLink(driver) { var links = driver.findElements(By.tagName('a')); return webdriver.promise.filter(links, function(link) { return links.isDisplayed(); }).then(function(visibleLinks) { return visibleLinks[0]; }); }
When running in the browser, a WebDriver cannot manipulate DOM elements directly; it may do so only through a webdriver.WebElement reference. This function may be used to generate a WebElement from a DOM element. A reference to the DOM element will be stored in a known location and this driver will attempt to retrieve it through . If the element cannot be found (eg, it belongs to a different document than the one this instance is currently focused on), a bot.ErrorCode.NO_SUCH_ELEMENT error will be returned.
Parameter locator
The locator to use. {!webdriver.WebElement} A WebElement that can be used to issue commands against the located element. If the element is not found, the element will be invalidated and all scheduled commands aborted.

method findElements

findElements: (
    locator: Locator | By.Hash | Function
) => webdriver.promise.Promise<WebElement[]>;

Schedule a command to search for multiple elements on the page.
Parameter locator
The locator strategy to use when searching for the element. {!webdriver.promise.Promise.<!Array.<!webdriver.WebElement>>} A promise that will resolve to an array of WebElements.

method get

get: (url: string) => webdriver.promise.Promise<void>;

Schedules a command to navigate to the given URL.
Parameter url
The fully qualified URL to open. {!webdriver.promise.Promise.} A promise that will be resolved when the document has finished loading.

method getAllWindowHandles

getAllWindowHandles: () => webdriver.promise.Promise<string[]>;

Schedules a command to retrieve the current list of available window handles. {!webdriver.promise.Promise.<!Array.>} A promise that will be resolved with an array of window handles.

method getCapabilities

getCapabilities: () => webdriver.promise.Promise<Capabilities>;

{!webdriver.promise.Promise.<!webdriver.Capabilities>} A promise that will resolve with the this instance's capabilities.

method getCurrentUrl

getCurrentUrl: () => webdriver.promise.Promise<string>;

Schedules a command to retrieve the URL of the current page. {!webdriver.promise.Promise.} A promise that will be resolved with the current URL.

method getPageSource

getPageSource: () => webdriver.promise.Promise<string>;

Schedules a command to retrieve the current page's source. The page source returned is a representation of the underlying DOM: do not expect it to be formatted or escaped in the same way as the response sent from the web server. {!webdriver.promise.Promise.} A promise that will be resolved with the current page source.

method getSession

getSession: () => webdriver.promise.Promise<Session>;

{!webdriver.promise.Promise.<!webdriver.Session>} A promise for this client's session.

method getTitle

getTitle: () => webdriver.promise.Promise<string>;

Schedules a command to retrieve the current page's title. {!webdriver.promise.Promise.} A promise that will be resolved with the current page's title.

method getWindowHandle

getWindowHandle: () => webdriver.promise.Promise<string>;

Schedules a command to retrieve they current window handle. {!webdriver.promise.Promise.} A promise that will be resolved with the current window handle.

method isElementPresent

isElementPresent: (
    locatorOrElement: Locator | By.Hash | WebElement | Function
) => webdriver.promise.Promise<boolean>;

Schedules a command to test if an element is present on the page.
If given a DOM element, this function will check if it belongs to the document the driver is currently focused on. Otherwise, the function will test if at least one element can be found with the given search criteria.
Parameter locatorOrElement
The locator to use, or the actual DOM element to be located by the server. {!webdriver.promise.Promise.} A promise that will resolve with whether the element is present on the page.

method manage

manage: () => WebDriverOptions;

{!webdriver.WebDriver.Options} The options interface for this instance.

method navigate

navigate: () => WebDriverNavigation;

{!webdriver.WebDriver.Navigation} The navigation interface for this instance.

method quit

quit: () => webdriver.promise.Promise<void>;

Schedules a command to quit the current session. After calling quit, this instance will be invalidated and may no longer be used to issue commands against the browser. {!webdriver.promise.Promise.} A promise that will be resolved when the command has completed.

method schedule

schedule: <T>(
    command: Command,
    description: string
) => webdriver.promise.Promise<T>;

Schedules a to be executed by this driver's .
Parameter command
The command to schedule.
Parameter description
A description of the command for debugging. {!webdriver.promise.Promise} A promise that will be resolved with the command result.

method setFileDetector

setFileDetector: (detector: FileDetector) => void;

Sets the that should be used with this instance.
Parameter detector
The detector to use or .

method sleep

sleep: (ms: number) => webdriver.promise.Promise<void>;

Schedules a command to make the driver sleep for the given amount of time.
Parameter ms
The amount of time, in milliseconds, to sleep. {!webdriver.promise.Promise.} A promise that will be resolved when the sleep has finished.

method switchTo

switchTo: () => WebDriverTargetLocator;

{!webdriver.WebDriver.TargetLocator} The target locator interface for this instance.

method takeScreenshot

takeScreenshot: () => webdriver.promise.Promise<string>;

Schedule a command to take a screenshot. The driver makes a best effort to return a screenshot of the following, in order of preference: Entire page Current window Visible portion of the current frame The screenshot of the entire display containing the browser
{!webdriver.promise.Promise.} A promise that will be resolved to the screenshot as a base-64 encoded PNG.

method touchActions

touchActions: () => TouchSequence;

Creates a new touch sequence using this driver. The sequence will not be scheduled for execution until webdriver.TouchSequence#perform is called. Example:
driver.touchActions(). tap(element1). doubleTap(element2). perform();
{!webdriver.TouchSequence} A new touch sequence for this instance.

method wait

wait: <T>(
    condition:
        | promise.Promise<T>
        | until.Condition<T>
        | ((driver: WebDriver) => T),
    timeout?: number,
    opt_message?: string
) => webdriver.promise.Promise<T>;

Schedules a command to wait for a condition to hold. The condition may be specified by a webdriver.until.Condition, as a custom function, or as a webdriver.promise.Promise.
For a webdriver.until.Condition or function, the wait will repeatedly evaluate the condition until it returns a truthy value. If any errors occur while evaluating the condition, they will be allowed to propagate. In the event a condition returns a , the polling loop will wait for it to be resolved and use the resolved value for whether the condition has been satisified. Note the resolution time for a promise is factored into whether a wait has timed out.
*Example:* waiting up to 10 seconds for an element to be present and visible on the page.
var button = driver.wait(until.elementLocated(By.id('foo'), 10000); button.click();
This function may also be used to block the command flow on the resolution of a . When given a promise, the command will simply wait for its resolution before completing. A timeout may be provided to fail the command if the promise does not resolve before the timeout expires.
*Example:* Suppose you have a function, startTestServer, that returns a promise for when a server is ready for requests. You can block a WebDriver client on this promise with:
var started = startTestServer(); driver.wait(started, 5 * 1000, 'Server should start within 5 seconds'); driver.get(getServerUrl());
Parameter condition
The condition to wait on, defined as a promise, condition object, or a function to evaluate as a condition.
Parameter opt_timeout
How long to wait for the condition to be true.
Parameter opt_message
An optional message to use if the wait times out. {!webdriver.promise.Promise} A promise that will be fulfilled with the first truthy value returned by the condition function, or rejected if the condition times out. T

class WebElement

class WebElement implements Serializable<IWebElementId> {}

Represents a DOM element. WebElements can be found by searching from the document root using a webdriver.WebDriver instance, or by searching under another WebElement:
driver.get('http://www.google.com'); var searchForm = driver.findElement(By.tagName('form')); var searchBox = searchForm.findElement(By.name('q')); searchBox.sendKeys('webdriver');
The WebElement is implemented as a promise for compatibility with the promise API. It will always resolve itself when its internal state has been fully resolved and commands may be issued against the element. This can be used to catch errors when an element cannot be located on the page:
driver.findElement(By.id('not-there')).then(function(element) { alert('Found an element that was not expected to be there!'); }, function(error) { alert('The element was not found, as expected'); });
{webdriver.Serializable.<webdriver.WebElement.Id>}

constructor

constructor(
    driver: WebDriver,
    id: IWebElementId | promise.Promise<IWebElementId>
);

Parameter driver
The parent WebDriver instance for this element.
Parameter id
The server-assigned opaque ID for the underlying DOM element.

property ELEMENT_KEY

static ELEMENT_KEY: string;

The property key used in the wire protocol to indicate that a JSON object contains the ID of a WebElement. {string}

property Id

static Id: IWebElementId;

Wire protocol definition of a WebElement ID. {{ELEMENT: string}}
See Also
- https://github.com/SeleniumHQ/selenium/wiki/JsonWireProtocol

method clear

clear: () => webdriver.promise.Promise<void>;

Schedules a command to clear the of this element. This command has no effect if the underlying DOM element is neither a text INPUT element nor a TEXTAREA element. {!webdriver.promise.Promise.} A promise that will be resolved when the element has been cleared.

method click

click: () => webdriver.promise.Promise<void>;

Schedules a command to click on this element. {!webdriver.promise.Promise.} A promise that will be resolved when the click command has completed.

method equals

static equals: (
    a: WebElement,
    b: WebElement
) => webdriver.promise.Promise<boolean>;

Compares to WebElements for equality.
Parameter a
A WebElement.
Parameter b
A WebElement. {!webdriver.promise.Promise} A promise that will be resolved to whether the two WebElements are equal.

method findElement

findElement: (locator: Locator | By.Hash | Function) => WebElementPromise;

Schedule a command to find a descendant of this element. If the element cannot be found, a bot.ErrorCode.NO_SUCH_ELEMENT result will be returned by the driver. Unlike other commands, this error cannot be suppressed. In other words, scheduling a command to find an element doubles as an assert that the element is present on the page. To test whether an element is present on the page, use instead.
The search criteria for an element may be defined using one of the factories in the webdriver.By namespace, or as a short-hand webdriver.By.Hash object. For example, the following two statements are equivalent:
var e1 = element.findElement(By.id('foo')); var e2 = element.findElement({id:'foo'});
You may also provide a custom locator function, which takes as input this WebDriver instance and returns a webdriver.WebElement, or a promise that will resolve to a WebElement. For example, to find the first visible link on a page, you could write:
var link = element.findElement(firstVisibleLink);
function firstVisibleLink(element) { var links = element.findElements(By.tagName('a')); return webdriver.promise.filter(links, function(link) { return links.isDisplayed(); }).then(function(visibleLinks) { return visibleLinks[0]; }); }
Parameter locator
The locator strategy to use when searching for the element. {!webdriver.WebElement} A WebElement that can be used to issue commands against the located element. If the element is not found, the element will be invalidated and all scheduled commands aborted.

method findElements

findElements: (
    locator: Locator | By.Hash | Function
) => webdriver.promise.Promise<WebElement[]>;

Schedules a command to find all of the descendants of this element that match the given search criteria.
Parameter locator
The locator strategy to use when searching for the elements. {!webdriver.promise.Promise.<!Array.<!webdriver.WebElement>>} A promise that will resolve to an array of WebElements.

method getAttribute

getAttribute: (attributeName: string) => webdriver.promise.Promise<string>;

Schedules a command to query for the value of the given attribute of the element. Will return the current value, even if it has been modified after the page has been loaded. More exactly, this method will return the value of the given attribute, unless that attribute is not present, in which case the value of the property with the same name is returned. If neither value is set, null is returned (for example, the "value" property of a textarea element). The "style" attribute is converted as best can be to a text representation with a trailing semi-colon. The following are deemed to be "boolean" attributes and will return either "true" or null:
async, autofocus, autoplay, checked, compact, complete, controls, declare, defaultchecked, defaultselected, defer, disabled, draggable, ended, formnovalidate, hidden, indeterminate, iscontenteditable, ismap, itemscope, loop, multiple, muted, nohref, noresize, noshade, novalidate, nowrap, open, paused, pubdate, readonly, required, reversed, scoped, seamless, seeking, selected, spellcheck, truespeed, willvalidate
Finally, the following commonly mis-capitalized attribute/property names are evaluated as expected:
- "class" - "readonly"
Parameter attributeName
The name of the attribute to query. {!webdriver.promise.Promise.<?string>} A promise that will be resolved with the attribute's value. The returned value will always be either a string or null.

method getCssValue

getCssValue: (cssStyleProperty: string) => webdriver.promise.Promise<string>;

Schedules a command to query for the computed style of the element represented by this instance. If the element inherits the named style from its parent, the parent will be queried for its value. Where possible, color values will be converted to their hex representation (e.g. #00ff00 instead of rgb(0, 255, 0)).
_Warning:_ the value returned will be as the browser interprets it, so it may be tricky to form a proper assertion.
Parameter cssStyleProperty
The name of the CSS style property to look up. {!webdriver.promise.Promise.} A promise that will be resolved with the requested CSS value.

method getDriver

getDriver: () => WebDriver;

{!webdriver.WebDriver} The parent driver for this instance.

method getId

getId: () => webdriver.promise.Promise<IWebElementId>;

{!webdriver.promise.Promise.<webdriver.WebElement.Id>} A promise that resolves to this element's JSON representation as defined by the WebDriver wire protocol.
See Also
- http://code.google.com/p/selenium/wiki/JsonWireProtocol

method getInnerHtml

getInnerHtml: () => webdriver.promise.Promise<string>;

Schedules a command to retrieve the inner HTML of this element. {!webdriver.promise.Promise} A promise that will be resolved with the element's inner HTML.

method getLocation

getLocation: () => webdriver.promise.Promise<ILocation>;

Schedules a command to compute the location of this element in page space. {!webdriver.promise.Promise.<{x: number, y: number}>} A promise that will be resolved to the element's location as a {@code {x:number, y:number}} object.

method getOuterHtml

getOuterHtml: () => webdriver.promise.Promise<string>;

Schedules a command to retrieve the outer HTML of this element. {!webdriver.promise.Promise.} A promise that will be resolved with the element's outer HTML.

method getRawId

getRawId: () => webdriver.promise.Promise<string>;

Returns the raw ID string ID for this element. {!webdriver.promise.Promise} A promise that resolves to this element's raw ID as a string value.

method getSize

getSize: () => webdriver.promise.Promise<ISize>;

Schedules a command to compute the size of this element's bounding box, in pixels. {!webdriver.promise.Promise.<{width: number, height: number}>} A promise that will be resolved with the element's size as a {@code {width:number, height:number}} object.

method getTagName

getTagName: () => webdriver.promise.Promise<string>;

Schedules a command to query for the tag/node name of this element. {!webdriver.promise.Promise.} A promise that will be resolved with the element's tag name.

method getText

getText: () => webdriver.promise.Promise<string>;

Get the visible (i.e. not hidden by CSS) innerText of this element, including sub-elements, without any leading or trailing whitespace. {!webdriver.promise.Promise.} A promise that will be resolved with the element's visible text.

method isDisplayed

isDisplayed: () => webdriver.promise.Promise<boolean>;

Schedules a command to test whether this element is currently displayed. {!webdriver.promise.Promise.} A promise that will be resolved with whether this element is currently visible on the page.

method isElementPresent

isElementPresent: (
    locator: Locator | By.Hash | Function
) => webdriver.promise.Promise<boolean>;

Schedules a command to test if there is at least one descendant of this element that matches the given search criteria.
Parameter locator
The locator strategy to use when searching for the element. {!webdriver.promise.Promise.} A promise that will be resolved with whether an element could be located on the page.

method isEnabled

isEnabled: () => webdriver.promise.Promise<boolean>;

Schedules a command to query whether the DOM element represented by this instance is enabled, as dicted by the attribute. {!webdriver.promise.Promise.} A promise that will be resolved with whether this element is currently enabled.

method isSelected

isSelected: () => webdriver.promise.Promise<boolean>;

Schedules a command to query whether this element is selected. {!webdriver.promise.Promise.} A promise that will be resolved with whether this element is currently selected.

method sendKeys

sendKeys: (
    ...var_args: Array<string | webdriver.promise.Promise<string>>
) => webdriver.promise.Promise<void>;

Schedules a command to type a sequence on the DOM element represented by this instance.
Modifier keys (SHIFT, CONTROL, ALT, META) are stateful; once a modifier is processed in the keysequence, that key state is toggled until one of the following occurs:
- The modifier key is encountered again in the sequence. At this point the state of the key is toggled (along with the appropriate keyup/down events). - The webdriver.Key.NULL key is encountered in the sequence. When this key is encountered, all modifier keys current in the down state are released (with accompanying keyup events). The NULL key can be used to simulate common keyboard shortcuts:
element.sendKeys("text was", webdriver.Key.CONTROL, "a", webdriver.Key.NULL, "now text is"); // Alternatively: element.sendKeys("text was", webdriver.Key.chord(webdriver.Key.CONTROL, "a"), "now text is");
- The end of the keysequence is encountered. When there are no more keys to type, all depressed modifier keys are released (with accompanying keyup events).
If this element is a file input (), the specified key sequence should specify the path to the file to attach to the element. This is analgous to the user clicking "Browse..." and entering the path into the file select dialog.
var form = driver.findElement(By.css('form')); var element = form.findElement(By.css('input[type=file]')); element.sendKeys('/path/to/file.txt'); form.submit();
For uploads to function correctly, the entered path must reference a file on the _browser's_ machine, not the local machine running this script. When running against a remote Selenium server, a webdriver.FileDetector may be used to transparently copy files to the remote machine before attempting to upload them in the browser.
__Note:__ On browsers where native keyboard events are not supported (e.g. Firefox on OS X), key events will be synthesized. Special punctionation keys will be synthesized according to a standard QWERTY en-us keyboard layout.
Parameter var_args
The sequence of keys to type. All arguments will be joined into a single sequence. {!webdriver.promise.Promise.} A promise that will be resolved when all keys have been typed.

method serialize

serialize: () => webdriver.promise.Promise<IWebElementId>;

Modifiers
- @override

method submit

submit: () => webdriver.promise.Promise<void>;

Schedules a command to submit the form containing this element (or this element if it is a FORM element). This command is a no-op if the element is not contained in a form. {!webdriver.promise.Promise.} A promise that will be resolved when the form has been submitted.

class WebElementPromise

class WebElementPromise
    extends WebElement
    implements webdriver.promise.IThenable<WebElement> {}

WebElementPromise is a promise that will be fulfilled with a WebElement. This serves as a forward proxy on WebElement, allowing calls to be scheduled without directly on this instance before the underlying WebElement has been fulfilled. In other words, the following two statements are equivalent: driver.findElement({id: 'my-button'}).click(); driver.findElement({id: 'my-button'}).then(function(el) { return el.click(); });
Parameter driver
The parent WebDriver instance for this element.
Parameter el
A promise that will resolve to the promised element. {webdriver.WebElement} {webdriver.promise.Thenable.<!webdriver.WebElement>}

method cancel

cancel: (opt_reason?: string) => void;

Cancels the computation of this promise's value, rejecting the promise in the process. This method is a no-op if the promise has alreayd been resolved.
Parameter opt_reason
The reason this promise is being cancelled.

method isPending

isPending: () => boolean;

{boolean} Whether this promise's value is still being computed.

method then

then: {
    <R>(
        opt_callback?: (value: WebElement) => webdriver.promise.Promise<R>,
        opt_errback?: (error: any) => any
    ): webdriver.promise.Promise<R>;
    <R>(
        opt_callback?: (value: WebElement) => R,
        opt_errback?: (error: any) => any
    ): promise.Promise<R>;
};

Registers listeners for when this instance is resolved.
Parameter opt_callback
The function to call if this promise is successfully resolved. The function should expect a single argument: the promise's resolved value.
Parameter opt_errback
The function to call if this promise is rejected. The function should expect a single argument: the rejection reason. A new promise which will be resolved with the result of the invoked callback.

method thenCatch

thenCatch: <R>(errback: (error: any) => any) => webdriver.promise.Promise<R>;

Registers a listener for when this promise is rejected. This is synonymous with the clause in a synchronous API: // Synchronous API: try { doSynchronousWork(); } catch (ex) { console.error(ex); }
// Asynchronous promise API: doAsynchronousWork().thenCatch(function(ex) { console.error(ex); });
Parameter errback
The function to call if this promise is rejected. The function should expect a single argument: the rejection reason. {!webdriver.promise.Promise.} A new promise which will be resolved with the result of the invoked callback. R

method thenFinally

thenFinally: <R>(callback: () => any) => webdriver.promise.Promise<R>;

Registers a listener to invoke when this promise is resolved, regardless of whether the promise's value was successfully computed. This function is synonymous with the clause in a synchronous API: // Synchronous API: try { doSynchronousWork(); } finally { cleanUp(); }
// Asynchronous promise API: doAsynchronousWork().thenFinally(cleanUp);
Note: similar to the clause, if the registered callback returns a rejected promise or throws an error, it will silently replace the rejection error (if any) from this promise: try { throw Error('one'); } finally { throw Error('two'); // Hides Error: one }
webdriver.promise.rejected(Error('one')) .thenFinally(function() { throw Error('two'); // Hides Error: one });
Parameter callback
The function to call when this promise is resolved. {!webdriver.promise.Promise.} A promise that will be fulfilled with the callback result. R

interface Alert

interface Alert {}

Represents a modal dialog such as , , or . Provides functions to retrieve the message displayed with the alert, accept or dismiss the alert, and set the response text (in the case of ).

method accept

accept: () => webdriver.promise.Promise<void>;

Accepts this alert. {!webdriver.promise.Promise} A promise that will be resolved when this command has completed.

method dismiss

dismiss: () => webdriver.promise.Promise<void>;

Dismisses this alert. {!webdriver.promise.Promise} A promise that will be resolved when this command has completed.

method getText

getText: () => webdriver.promise.Promise<string>;

Retrieves the message text displayed with this alert. For instance, if the alert were opened with alert("hello"), then this would return "hello". {!webdriver.promise.Promise} A promise that will be resolved to the text displayed with this alert.

method sendKeys

sendKeys: (text: string) => webdriver.promise.Promise<void>;

Sets the response text on this alert. This command will return an error if the underlying alert does not support response text (e.g. window.alert and window.confirm).
Parameter text
The text to set. {!webdriver.promise.Promise} A promise that will be resolved when this command has completed.

interface AlertPromise

interface AlertPromise extends Alert, webdriver.promise.IThenable<Alert> {}

AlertPromise is a promise that will be fulfilled with an Alert. This promise serves as a forward proxy on an Alert, allowing calls to be scheduled directly on this instance before the underlying Alert has been fulfilled. In other words, the following two statements are equivalent: driver.switchTo().alert().dismiss(); driver.switchTo().alert().then(function(alert) { return alert.dismiss(); });
Parameter driver
The driver controlling the browser this alert is attached to.
Parameter alert
A thenable that will be fulfilled with the promised alert. {webdriver.Alert} {webdriver.promise.Thenable.<!webdriver.Alert>}

interface CommandExecutor

interface CommandExecutor {}

Handles the execution of objects.

method execute

execute: (
    command: Command,
    callback: (error: Error, responseObject: any) => any
) => void;

Executes the given . If there is an error executing the command, the provided callback will be invoked with the offending error. Otherwise, the callback will be invoked with a null Error and non-null bot.response.ResponseObject object.
Parameter command
The command to execute.
Parameter callback
the function to invoke when the command response is ready.

interface IBrowser

interface IBrowser {}

Recognized browser names. {string}

property ANDROID

ANDROID: string;

property CHROME

CHROME: string;

property FIREFOX

FIREFOX: string;

property HTMLUNIT

HTMLUNIT: string;

property INTERNET_EXPLORER

INTERNET_EXPLORER: string;

property IPAD

IPAD: string;

property IPHONE

IPHONE: string;

property OPERA

OPERA: string;

property PHANTOM_JS

PHANTOM_JS: string;

property SAFARI

SAFARI: string;

interface IButton

interface IButton {}

Enumeration of the buttons used in the advanced interactions API. NOTE: A TypeScript enum was not used so that this class could be extended in Protractor. {number}

property LEFT

LEFT: number;

property MIDDLE

MIDDLE: number;

property RIGHT

RIGHT: number;

interface ICapability

interface ICapability {}

Common webdriver capability keys. {string}

property ACCEPT_SSL_CERTS

ACCEPT_SSL_CERTS: string;

Indicates whether a driver should accept all SSL certs by default. This capability only applies when requesting a new session. To query whether a driver can handle insecure SSL certs, see webdriver.Capability.SECURE_SSL.

property BROWSER_NAME

BROWSER_NAME: string;

The browser name. Common browser names are defined in the webdriver.Browser enum.

property ELEMENT_SCROLL_BEHAVIOR

ELEMENT_SCROLL_BEHAVIOR: string;

Defines how elements should be scrolled into the viewport for interaction. This capability will be set to zero (0) if elements are aligned with the top of the viewport, or one (1) if aligned with the bottom. The default behavior is to align with the top of the viewport.

property HANDLES_ALERTS

HANDLES_ALERTS: string;

Whether the driver is capable of handling modal alerts (e.g. alert, confirm, prompt). To define how a driver should handle alerts, use webdriver.Capability.UNEXPECTED_ALERT_BEHAVIOR.

property LOGGING_PREFS

LOGGING_PREFS: string;

Key for the logging driver logging preferences.

property NATIVE_EVENTS

NATIVE_EVENTS: string;

Whether this session generates native events when simulating user input.

property PLATFORM

PLATFORM: string;

Describes the platform the browser is running on. Will be one of ANDROID, IOS, LINUX, MAC, UNIX, or WINDOWS. When requesting a session, ANY may be used to indicate no platform preference (this is semantically equivalent to omitting the platform capability).

property PROXY

PROXY: string;

Describes the proxy configuration to use for a new WebDriver session.

property ROTATABLE

ROTATABLE: string;

Whether the driver supports changing the brower's orientation.

property SECURE_SSL

SECURE_SSL: string;

Whether a driver is only capable of handling secure SSL certs. To request that a driver accept insecure SSL certs by default, use webdriver.Capability.ACCEPT_SSL_CERTS.

property SUPPORTS_APPLICATION_CACHE

SUPPORTS_APPLICATION_CACHE: string;

Whether the driver supports manipulating the app cache.

property SUPPORTS_CSS_SELECTORS

SUPPORTS_CSS_SELECTORS: string;

Whether the driver supports locating elements with CSS selectors.

property SUPPORTS_JAVASCRIPT

SUPPORTS_JAVASCRIPT: string;

Whether the browser supports JavaScript.

property SUPPORTS_LOCATION_CONTEXT

SUPPORTS_LOCATION_CONTEXT: string;

Whether the driver supports controlling the browser's location info.

property TAKES_SCREENSHOT

TAKES_SCREENSHOT: string;

Whether the driver supports taking screenshots.

property UNEXPECTED_ALERT_BEHAVIOR

UNEXPECTED_ALERT_BEHAVIOR: string;

Defines how the driver should handle unexpected alerts. The value should be one of "accept", "dismiss", or "ignore.

property VERSION

VERSION: string;

Defines the browser version.

interface ICommandName

interface ICommandName {}

An enumeration of valid command string.

property ACCEPT_ALERT

ACCEPT_ALERT: string;

property ADD_COOKIE

ADD_COOKIE: string;

property CLEAR_APP_CACHE

CLEAR_APP_CACHE: string;

property CLEAR_ELEMENT

CLEAR_ELEMENT: string;

property CLEAR_LOCAL_STORAGE

CLEAR_LOCAL_STORAGE: string;

property CLEAR_SESSION_STORAGE

CLEAR_SESSION_STORAGE: string;

property CLICK

CLICK: string;

property CLICK_ELEMENT

CLICK_ELEMENT: string;

property CLOSE

CLOSE: string;

property DELETE_ALL_COOKIES

DELETE_ALL_COOKIES: string;

property DELETE_COOKIE

DELETE_COOKIE: string;

property DESCRIBE_SESSION

DESCRIBE_SESSION: string;

property DISMISS_ALERT

DISMISS_ALERT: string;

property DOUBLE_CLICK

DOUBLE_CLICK: string;

property ELEMENT_EQUALS

ELEMENT_EQUALS: string;

property EXECUTE_ASYNC_SCRIPT

EXECUTE_ASYNC_SCRIPT: string;

property EXECUTE_SCRIPT

EXECUTE_SCRIPT: string;

property EXECUTE_SQL

EXECUTE_SQL: string;

property FIND_CHILD_ELEMENT

FIND_CHILD_ELEMENT: string;

property FIND_CHILD_ELEMENTS

FIND_CHILD_ELEMENTS: string;

property FIND_ELEMENT

FIND_ELEMENT: string;

property FIND_ELEMENTS

FIND_ELEMENTS: string;

property GET

GET: string;

property GET_ACTIVE_ELEMENT

GET_ACTIVE_ELEMENT: string;

property GET_ALERT_TEXT

GET_ALERT_TEXT: string;

property GET_ALL_COOKIES

GET_ALL_COOKIES: string;

property GET_APP_CACHE

GET_APP_CACHE: string;

property GET_APP_CACHE_STATUS

GET_APP_CACHE_STATUS: string;

property GET_AVAILABLE_LOG_TYPES

GET_AVAILABLE_LOG_TYPES: string;

property GET_COOKIE

GET_COOKIE: string;

property GET_CURRENT_URL

GET_CURRENT_URL: string;

property GET_CURRENT_WINDOW_HANDLE

GET_CURRENT_WINDOW_HANDLE: string;

property GET_ELEMENT_ATTRIBUTE

GET_ELEMENT_ATTRIBUTE: string;

property GET_ELEMENT_LOCATION

GET_ELEMENT_LOCATION: string;

property GET_ELEMENT_LOCATION_IN_VIEW

GET_ELEMENT_LOCATION_IN_VIEW: string;

property GET_ELEMENT_SIZE

GET_ELEMENT_SIZE: string;

property GET_ELEMENT_TAG_NAME

GET_ELEMENT_TAG_NAME: string;

property GET_ELEMENT_TEXT

GET_ELEMENT_TEXT: string;

property GET_ELEMENT_VALUE_OF_CSS_PROPERTY

GET_ELEMENT_VALUE_OF_CSS_PROPERTY: string;

property GET_LOCAL_STORAGE_ITEM

GET_LOCAL_STORAGE_ITEM: string;

property GET_LOCAL_STORAGE_KEYS

GET_LOCAL_STORAGE_KEYS: string;

property GET_LOCAL_STORAGE_SIZE

GET_LOCAL_STORAGE_SIZE: string;

property GET_LOCATION

GET_LOCATION: string;

property GET_LOG

GET_LOG: string;

property GET_PAGE_SOURCE

GET_PAGE_SOURCE: string;

property GET_SCREEN_ORIENTATION

GET_SCREEN_ORIENTATION: string;

property GET_SERVER_STATUS

GET_SERVER_STATUS: string;

property GET_SESSION_LOGS

GET_SESSION_LOGS: string;

property GET_SESSION_STORAGE_ITEM

GET_SESSION_STORAGE_ITEM: string;

property GET_SESSION_STORAGE_KEYS

GET_SESSION_STORAGE_KEYS: string;

property GET_SESSION_STORAGE_SIZE

GET_SESSION_STORAGE_SIZE: string;

property GET_SESSIONS

GET_SESSIONS: string;

property GET_TITLE

GET_TITLE: string;

property GET_WINDOW_HANDLES

GET_WINDOW_HANDLES: string;

property GET_WINDOW_POSITION

GET_WINDOW_POSITION: string;

property GET_WINDOW_SIZE

GET_WINDOW_SIZE: string;

property GO_BACK

GO_BACK: string;

property GO_FORWARD

GO_FORWARD: string;

property IMPLICITLY_WAIT

IMPLICITLY_WAIT: string;

property IS_BROWSER_ONLINE

IS_BROWSER_ONLINE: string;

property IS_ELEMENT_DISPLAYED

IS_ELEMENT_DISPLAYED: string;

property IS_ELEMENT_ENABLED

IS_ELEMENT_ENABLED: string;

property IS_ELEMENT_SELECTED

IS_ELEMENT_SELECTED: string;

property MAXIMIZE_WINDOW

MAXIMIZE_WINDOW: string;

property MOUSE_DOWN

MOUSE_DOWN: string;

property MOUSE_UP

MOUSE_UP: string;

property MOVE_TO

MOVE_TO: string;

property NEW_SESSION

NEW_SESSION: string;

property QUIT

QUIT: string;

property REFRESH

REFRESH: string;

property REMOVE_LOCAL_STORAGE_ITEM

REMOVE_LOCAL_STORAGE_ITEM: string;

property REMOVE_SESSION_STORAGE_ITEM

REMOVE_SESSION_STORAGE_ITEM: string;

property SCREENSHOT

SCREENSHOT: string;

property SEND_KEYS_TO_ACTIVE_ELEMENT

SEND_KEYS_TO_ACTIVE_ELEMENT: string;

property SEND_KEYS_TO_ELEMENT

SEND_KEYS_TO_ELEMENT: string;

property SET_ALERT_TEXT

SET_ALERT_TEXT: string;

property SET_BROWSER_ONLINE

SET_BROWSER_ONLINE: string;

property SET_LOCAL_STORAGE_ITEM

SET_LOCAL_STORAGE_ITEM: string;

property SET_LOCATION

SET_LOCATION: string;

property SET_SCREEN_ORIENTATION

SET_SCREEN_ORIENTATION: string;

property SET_SCRIPT_TIMEOUT

SET_SCRIPT_TIMEOUT: string;

property SET_SESSION_STORAGE_ITEM

SET_SESSION_STORAGE_ITEM: string;

property SET_TIMEOUT

SET_TIMEOUT: string;

property SET_WINDOW_POSITION

SET_WINDOW_POSITION: string;

property SET_WINDOW_SIZE

SET_WINDOW_SIZE: string;

property SUBMIT_ELEMENT

SUBMIT_ELEMENT: string;

property SWITCH_TO_FRAME

SWITCH_TO_FRAME: string;

property SWITCH_TO_WINDOW

SWITCH_TO_WINDOW: string;

property TOUCH_DOUBLE_TAP

TOUCH_DOUBLE_TAP: string;

property TOUCH_DOWN

TOUCH_DOWN: string;

property TOUCH_FLICK

TOUCH_FLICK: string;

property TOUCH_LONG_PRESS

TOUCH_LONG_PRESS: string;

property TOUCH_MOVE

TOUCH_MOVE: string;

property TOUCH_SCROLL

TOUCH_SCROLL: string;

property TOUCH_SINGLE_TAP

TOUCH_SINGLE_TAP: string;

property TOUCH_UP

TOUCH_UP: string;

interface IKey

interface IKey {}

Representations of pressable keys that aren't text. These are stored in the Unicode PUA (Private Use Area) code points, 0xE000-0xF8FF. Refer to http://www.google.com.au/search?&q=unicode+pua&btnG=Search
{string}

property ADD

ADD: string;

property ALT

ALT: string;

property ARROW_DOWN

ARROW_DOWN: string;

property ARROW_LEFT

ARROW_LEFT: string;

property ARROW_RIGHT

ARROW_RIGHT: string;

property ARROW_UP

ARROW_UP: string;

property BACK_SPACE

BACK_SPACE: string;

property CANCEL

CANCEL: string;

property chord

chord: (...var_args: string[]) => string;

Simulate pressing many keys at once in a "chord". Takes a sequence of webdriver.Keys or strings, appends each of the values to a string, and adds the chord termination key (webdriver.Key.NULL) and returns the resultant string.
Note: when the low-level webdriver key handlers see Keys.NULL, active modifier keys (CTRL/ALT/SHIFT/etc) release via a keyup event.
Parameter var_args
The key sequence to concatenate. {string} The null-terminated key sequence.
See Also
- http://code.google.com/p/webdriver/issues/detail?id=79

property CLEAR

CLEAR: string;

property COMMAND

COMMAND: string;

property CONTROL

CONTROL: string;

property DECIMAL

DECIMAL: string;

property DELETE

DELETE: string;

property DIVIDE

DIVIDE: string;

property DOWN

DOWN: string;

property END

END: string;

property ENTER

ENTER: string;

property EQUALS

EQUALS: string;

property ESCAPE

ESCAPE: string;

property F1

F1: string;

property F10

F10: string;

property F11

F11: string;

property F12

F12: string;

property F2

F2: string;

property F3

F3: string;

property F4

F4: string;

property F5

F5: string;

property F6

F6: string;

property F7

F7: string;

property F8

F8: string;

property F9

F9: string;

property HELP

HELP: string;

property HOME

HOME: string;

property INSERT

INSERT: string;

property LEFT

LEFT: string;

property META

META: string;

property MULTIPLY

MULTIPLY: string;

property NULL

NULL: string;

property NUMPAD0

NUMPAD0: string;

property NUMPAD1

NUMPAD1: string;

property NUMPAD2

NUMPAD2: string;

property NUMPAD3

NUMPAD3: string;

property NUMPAD4

NUMPAD4: string;

property NUMPAD5

NUMPAD5: string;

property NUMPAD6

NUMPAD6: string;

property NUMPAD7

NUMPAD7: string;

property NUMPAD8

NUMPAD8: string;

property NUMPAD9

NUMPAD9: string;

property PAGE_DOWN

PAGE_DOWN: string;

property PAGE_UP

PAGE_UP: string;

property PAUSE

PAUSE: string;

property RETURN

RETURN: string;

property RIGHT

RIGHT: string;

property SEMICOLON

SEMICOLON: string;

property SEPARATOR

SEPARATOR: string;

property SHIFT

SHIFT: string;

property SPACE

SPACE: string;

property SUBTRACT

SUBTRACT: string;

property TAB

TAB: string;

property UP

UP: string;

interface ILocation

interface ILocation {}

property x

x: number;

property y

y: number;

interface IOffset

interface IOffset {}

property x

x: number;

property y

y: number;

interface ISize

interface ISize {}

property height

height: number;

property width

width: number;

interface ISpeed

interface ISpeed {}

property xspeed

xspeed: number;

property yspeed

yspeed: number;

interface IWebDriverOptionsCookie

interface IWebDriverOptionsCookie {}

property domain

domain?: string;

property expiry

expiry?: number;

property name

name: string;

property path

path?: string;

property secure

secure?: boolean;

property value

value: string;

interface IWebElement

interface IWebElement {}

Represents a DOM element. WebElements can be found by searching from the document root using a instance, or by searching under another : driver.get('http://www.google.com'); var searchForm = driver.findElement(By.tagName('form')); var searchBox = searchForm.findElement(By.name('q')); searchBox.sendKeys('webdriver');
The WebElement is implemented as a promise for compatibility with the promise API. It will always resolve itself when its internal state has been fully resolved and commands may be issued against the element. This can be used to catch errors when an element cannot be located on the page: driver.findElement(By.id('not-there')).then(function(element) { alert('Found an element that was not expected to be there!'); }, function(error) { alert('The element was not found, as expected'); });

method clear

clear: () => webdriver.promise.Promise<void>;

Schedules a command to clear the of this element. This command has no effect if the underlying DOM element is neither a text INPUT element nor a TEXTAREA element. {!webdriver.promise.Promise} A promise that will be resolved when the element has been cleared.

method click

click: () => webdriver.promise.Promise<void>;

Schedules a command to click on this element. {!webdriver.promise.Promise} A promise that will be resolved when the click command has completed.

method getAttribute

getAttribute: (attributeName: string) => webdriver.promise.Promise<string>;

Schedules a command to query for the value of the given attribute of the element. Will return the current value even if it has been modified after the page has been loaded. More exactly, this method will return the value of the given attribute, unless that attribute is not present, in which case the value of the property with the same name is returned. If neither value is set, null is returned. The "style" attribute is converted as best can be to a text representation with a trailing semi-colon. The following are deemed to be "boolean" attributes and will be returned as thus:
async, autofocus, autoplay, checked, compact, complete, controls, declare, defaultchecked, defaultselected, defer, disabled, draggable, ended, formnovalidate, hidden, indeterminate, iscontenteditable, ismap, itemscope, loop, multiple, muted, nohref, noresize, noshade, novalidate, nowrap, open, paused, pubdate, readonly, required, reversed, scoped, seamless, seeking, selected, spellcheck, truespeed, willvalidate
Finally, the following commonly mis-capitalized attribute/property names are evaluated as expected: "class" "readonly"
Parameter attributeName
The name of the attribute to query. {!webdriver.promise.Promise} A promise that will be resolved with the attribute's value.

method getCssValue

getCssValue: (cssStyleProperty: string) => webdriver.promise.Promise<string>;

Schedules a command to query for the computed style of the element represented by this instance. If the element inherits the named style from its parent, the parent will be queried for its value. Where possible, color values will be converted to their hex representation (e.g. #00ff00 instead of rgb(0, 255, 0)). Warning: the value returned will be as the browser interprets it, so it may be tricky to form a proper assertion.
Parameter cssStyleProperty
The name of the CSS style property to look up. {!webdriver.promise.Promise} A promise that will be resolved with the requested CSS value.

method getId

getId: () => webdriver.promise.Promise<IWebElementId>;

{!webdriver.promise.Promise.<webdriver.WebElement.Id>} A promise that resolves to this element's JSON representation as defined by the WebDriver wire protocol.
See Also
- http://code.google.com/p/selenium/wiki/JsonWireProtocol

method getInnerHtml

getInnerHtml: () => webdriver.promise.Promise<string>;

Schedules a command to retrieve the inner HTML of this element. {!webdriver.promise.Promise} A promise that will be resolved with the element's inner HTML.

method getLocation

getLocation: () => webdriver.promise.Promise<ILocation>;

Schedules a command to compute the location of this element in page space. {!webdriver.promise.Promise} A promise that will be resolved to the element's location as a {@code {x:number, y:number}} object.

method getOuterHtml

getOuterHtml: () => webdriver.promise.Promise<string>;

Schedules a command to retrieve the outer HTML of this element. {!webdriver.promise.Promise} A promise that will be resolved with the element's outer HTML.

method getSize

getSize: () => webdriver.promise.Promise<ISize>;

Schedules a command to compute the size of this element's bounding box, in pixels. {!webdriver.promise.Promise} A promise that will be resolved with the element's size as a {@code {width:number, height:number}} object.

method getTagName

getTagName: () => webdriver.promise.Promise<string>;

Schedules a command to query for the tag/node name of this element. {!webdriver.promise.Promise} A promise that will be resolved with the element's tag name.

method getText

getText: () => webdriver.promise.Promise<string>;

Get the visible (i.e. not hidden by CSS) innerText of this element, including sub-elements, without any leading or trailing whitespace. {!webdriver.promise.Promise} A promise that will be resolved with the element's visible text.

method isDisplayed

isDisplayed: () => webdriver.promise.Promise<boolean>;

Schedules a command to test whether this element is currently displayed. {!webdriver.promise.Promise} A promise that will be resolved with whether this element is currently visible on the page.

method isEnabled

isEnabled: () => webdriver.promise.Promise<boolean>;

Schedules a command to query whether the DOM element represented by this instance is enabled, as dicted by the attribute. {!webdriver.promise.Promise} A promise that will be resolved with whether this element is currently enabled.

method isSelected

isSelected: () => webdriver.promise.Promise<boolean>;

Schedules a command to query whether this element is selected. {!webdriver.promise.Promise} A promise that will be resolved with whether this element is currently selected.

method sendKeys

sendKeys: (...var_args: string[]) => webdriver.promise.Promise<void>;

Schedules a command to type a sequence on the DOM element represented by this instance. Modifier keys (SHIFT, CONTROL, ALT, META) are stateful; once a modifier is processed in the keysequence, that key state is toggled until one of the following occurs: The modifier key is encountered again in the sequence. At this point the state of the key is toggled (along with the appropriate keyup/down events). The key is encountered in the sequence. When this key is encountered, all modifier keys current in the down state are released (with accompanying keyup events). The NULL key can be used to simulate common keyboard shortcuts: element.sendKeys("text was", webdriver.Key.CONTROL, "a", webdriver.Key.NULL, "now text is"); // Alternatively: element.sendKeys("text was", webdriver.Key.chord(webdriver.Key.CONTROL, "a"), "now text is"); The end of the keysequence is encountered. When there are no more keys to type, all depressed modifier keys are released (with accompanying keyup events). Note: On browsers where native keyboard events are not yet supported (e.g. Firefox on OS X), key events will be synthesized. Special punctionation keys will be synthesized according to a standard QWERTY en-us keyboard layout.
Parameter var_args
The sequence of keys to type. All arguments will be joined into a single sequence (var_args is permitted for convenience). {!webdriver.promise.Promise} A promise that will be resolved when all keys have been typed.

method submit

submit: () => webdriver.promise.Promise<void>;

Schedules a command to submit the form containing this element (or this element if it is a FORM element). This command is a no-op if the element is not contained in a form. {!webdriver.promise.Promise} A promise that will be resolved when the form has been submitted.

interface IWebElementFinders

interface IWebElementFinders {}

method findElement

findElement: (locator: Locator | By.Hash | Function) => WebElementPromise;

Schedule a command to find a descendant of this element. If the element cannot be found, a result will be returned by the driver. Unlike other commands, this error cannot be suppressed. In other words, scheduling a command to find an element doubles as an assert that the element is present on the page. To test whether an element is present on the page, use instead.
The search criteria for an element may be defined using one of the factories in the webdriver.By namespace, or as a short-hand webdriver.By.Hash object. For example, the following two statements are equivalent: var e1 = element.findElement(By.id('foo')); var e2 = element.findElement({id:'foo'});
You may also provide a custom locator function, which takes as input this WebDriver instance and returns a webdriver.WebElement, or a promise that will resolve to a WebElement. For example, to find the first visible link on a page, you could write: var link = element.findElement(firstVisibleLink);
function firstVisibleLink(element) { var links = element.findElements(By.tagName('a')); return webdriver.promise.filter(links, function(link) { return links.isDisplayed(); }).then(function(visibleLinks) { return visibleLinks[0]; }); }
Parameter locator
The locator strategy to use when searching for the element. {!webdriver.WebElement} A WebElement that can be used to issue commands against the located element. If the element is not found, the element will be invalidated and all scheduled commands aborted.

method findElements

findElements: (
    locator: Locator | By.Hash | Function
) => webdriver.promise.Promise<WebElement[]>;

Schedules a command to find all of the descendants of this element that match the given search criteria.
Parameter locator
The locator strategy to use when searching for the elements. {!webdriver.promise.Promise.<!Array.<!webdriver.WebElement>>} A promise that will resolve to an array of WebElements.

method isElementPresent

isElementPresent: (
    locator: Locator | By.Hash | Function
) => webdriver.promise.Promise<boolean>;

Schedules a command to test if there is at least one descendant of this element that matches the given search criteria.
Parameter locator
The locator strategy to use when searching for the element. {!webdriver.promise.Promise.} A promise that will be resolved with whether an element could be located on the page.

interface IWebElementId

interface IWebElementId {}

property ELEMENT

ELEMENT: string;

interface ProxyConfig

interface ProxyConfig {}

property ftpProxy

ftpProxy?: string;

property httpProxy

httpProxy?: string;

property noProxy

noProxy?: string;

property proxyAutoconfigUrl

proxyAutoconfigUrl?: string;

property proxyType

proxyType: string;

property sslProxy

sslProxy?: string;

interface Serializable

interface Serializable<T> {}

Defines an object that can be asynchronously serialized to its WebDriver wire representation.
T

method serialize

serialize: {
    (): T | webdriver.promise.IThenable<T>;
    (): T | promise.IThenable<T>;
};

Returns either this instance's serialized represention, if immediately available, or a promise for its serialized representation. This function is conceptually equivalent to objects that have a property, except the serialize() result may be a promise or an object containing a promise (which are not directly JSON friendly).
{!(T|IThenable.<!T>)} This instance's serialized wire format.

interface Serializable

interface Serializable<T> {}

Defines an object that can be asynchronously serialized to its WebDriver wire representation.
T

method serialize

serialize: {
    (): T | promise.IThenable<T>;
    (): T | webdriver.promise.IThenable<T>;
};

Returns either this instance's serialized represention, if immediately available, or a promise for its serialized representation. This function is conceptually equivalent to objects that have a property, except the serialize() result may be a promise or an object containing a promise (which are not directly JSON friendly).
{!(T|IThenable.<!T>)} This instance's serialized wire format.

interface UnhandledAlertError

interface UnhandledAlertError extends webdriver.error.Error {}

An error returned to indicate that there is an unhandled modal dialog on the current page. {bot.Error}

method getAlert

getAlert: () => Alert;

{!webdriver.Alert} The open alert.
Deprecated
Use . This method will be removed in 2.45.0.

method getAlertText

getAlertText: () => string;

{string} The text displayed with the unhandled alert.

interface WebDriverLogs

interface WebDriverLogs {}

Interface for managing WebDriver log records.

method get

get: (type: string) => webdriver.promise.Promise<webdriver.logging.Entry[]>;

Fetches available log entries for the given type.
Note that log buffers are reset after each call, meaning that available log entries correspond to those entries not yet returned for a given log type. In practice, this means that this call will return the available log entries since the last call, or from the start of the session.
Parameter type
The desired log type. {!webdriver.promise.Promise.<!Array.<!webdriver.logging.Entry>>} A promise that will resolve to a list of log entries for the specified type.

method getAvailableLogTypes

getAvailableLogTypes: () => webdriver.promise.Promise<string[]>;

Retrieves the log types available to this driver. {!webdriver.promise.Promise.<!Array.<!webdriver.logging.Type>>} A promise that will resolve to a list of available log types.

construct signature

new (driver: WebDriver): WebDriverLogs;

Parameter driver
The parent driver.

interface WebDriverNavigation

interface WebDriverNavigation {}

Interface for navigating back and forth in the browser history.

method back

back: () => webdriver.promise.Promise<void>;

Schedules a command to move backwards in the browser history. {!webdriver.promise.Promise.} A promise that will be resolved when the navigation event has completed.

method forward

forward: () => webdriver.promise.Promise<void>;

Schedules a command to move forwards in the browser history. {!webdriver.promise.Promise.} A promise that will be resolved when the navigation event has completed.

method refresh

refresh: () => webdriver.promise.Promise<void>;

Schedules a command to refresh the current page. {!webdriver.promise.Promise.} A promise that will be resolved when the navigation event has completed.

method to

to: (url: string) => webdriver.promise.Promise<void>;

Schedules a command to navigate to a new URL.
Parameter url
The URL to navigate to. {!webdriver.promise.Promise.} A promise that will be resolved when the URL has been loaded.

construct signature

new (driver: WebDriver): WebDriverNavigation;

Parameter driver
The parent driver.

interface WebDriverOptions

interface WebDriverOptions {}

Provides methods for managing browser and driver state.

method addCookie

addCookie: {
    (
        name: string,
        value: string,
        opt_path?: string,
        opt_domain?: string,
        opt_isSecure?: boolean,
        opt_expiry?: number
    ): webdriver.promise.Promise<void>;
    (
        name: string,
        value: string,
        opt_path?: string,
        opt_domain?: string,
        opt_isSecure?: boolean,
        opt_expiry?: Date
    ): promise.Promise<void>;
};

Schedules a command to add a cookie.
Parameter name
The cookie name.
Parameter value
The cookie value.
Parameter opt_path
The cookie path.
Parameter opt_domain
The cookie domain.
Parameter opt_isSecure
Whether the cookie is secure.
Parameter opt_expiry
When the cookie expires. If specified as a number, should be in milliseconds since midnight, January 1, 1970 UTC. {!webdriver.promise.Promise} A promise that will be resolved when the cookie has been added to the page.

method deleteAllCookies

deleteAllCookies: () => webdriver.promise.Promise<void>;

Schedules a command to delete all cookies visible to the current page. {!webdriver.promise.Promise} A promise that will be resolved when all cookies have been deleted.

method deleteCookie

deleteCookie: (name: string) => webdriver.promise.Promise<void>;

Schedules a command to delete the cookie with the given name. This command is a no-op if there is no cookie with the given name visible to the current page.
Parameter name
The name of the cookie to delete. {!webdriver.promise.Promise} A promise that will be resolved when the cookie has been deleted.

method getCookie

getCookie: (name: string) => webdriver.promise.Promise<IWebDriverOptionsCookie>;

Schedules a command to retrieve the cookie with the given name. Returns null if there is no such cookie. The cookie will be returned as a JSON object as described by the WebDriver wire protocol.
Parameter name
The name of the cookie to retrieve. {!webdriver.promise.Promise} A promise that will be resolved with the named cookie, or if there is no such cookie.
See Also
- http://code.google.com/p/selenium/wiki/JsonWireProtocol#Cookie_JSON_Object

method getCookies

getCookies: () => webdriver.promise.Promise<IWebDriverOptionsCookie[]>;

Schedules a command to retrieve all cookies visible to the current page. Each cookie will be returned as a JSON object as described by the WebDriver wire protocol. {!webdriver.promise.Promise} A promise that will be resolved with the cookies visible to the current page.
See Also
- http://code.google.com/p/selenium/wiki/JsonWireProtocol#Cookie_JSON_Object

method logs

logs: () => WebDriverLogs;

{!webdriver.WebDriver.Logs} The interface for managing driver logs.

method timeouts

timeouts: () => WebDriverTimeouts;

{!webdriver.WebDriver.Timeouts} The interface for managing driver timeouts.

method window

window: () => WebDriverWindow;

{!webdriver.WebDriver.Window} The interface for managing the current window.

construct signature

new (driver: webdriver.WebDriver): WebDriverOptions;

Parameter driver
The parent driver.

interface WebDriverTargetLocator

interface WebDriverTargetLocator {}

An interface for changing the focus of the driver to another frame or window.

method activeElement

activeElement: () => WebElementPromise;

Schedules a command retrieve the element on the current document, or if activeElement is not available. {!webdriver.WebElement} The active element.

method alert

alert: () => AlertPromise;

Schedules a command to change focus to the active alert dialog. This command will return a bot.ErrorCode.NO_MODAL_DIALOG_OPEN error if a modal dialog is not currently open. {!webdriver.Alert} The open alert.

method defaultContent

defaultContent: () => webdriver.promise.Promise<void>;

Schedules a command to switch focus of all future commands to the first frame on the page. {!webdriver.promise.Promise} A promise that will be resolved when the driver has changed focus to the default content.

method frame

frame: {
    (nameOrIndex: string): webdriver.promise.Promise<void>;
    (nameOrIndex: number): promise.Promise<void>;
};

Schedules a command to switch the focus of all future commands to another frame on the page. If the frame is specified by a number, the command will switch to the frame by its (zero-based) index into the collection. If the frame is specified by a string, the command will select the frame by its name or ID. To select sub-frames, simply separate the frame names/IDs by dots. As an example, "main.child" will select the frame with the name "main" and then its child "child". If the specified frame can not be found, the deferred result will errback with a error.
Parameter nameOrIndex
The frame locator. {!webdriver.promise.Promise} A promise that will be resolved when the driver has changed focus to the specified frame.

method window

window: (nameOrHandle: string) => webdriver.promise.Promise<void>;

Schedules a command to switch the focus of all future commands to another window. Windows may be specified by their attribute or by its handle (as returned by ). If the specificed window can not be found, the deferred result will errback with a error.
Parameter nameOrHandle
The name or window handle of the window to switch focus to. {!webdriver.promise.Promise} A promise that will be resolved when the driver has changed focus to the specified window.

construct signature

new (driver: WebDriver): WebDriverTargetLocator;

Parameter driver
The parent driver.

interface WebDriverTimeouts

interface WebDriverTimeouts {}

An interface for managing timeout behavior for WebDriver instances.

method implicitlyWait

implicitlyWait: (ms: number) => webdriver.promise.Promise<void>;

Specifies the amount of time the driver should wait when searching for an element if it is not immediately present. When searching for a single element, the driver should poll the page until the element has been found, or this timeout expires before failing with a error. When searching for multiple elements, the driver should poll the page until at least one element has been found or this timeout has expired. Setting the wait timeout to 0 (its default value), disables implicit waiting. Increasing the implicit wait timeout should be used judiciously as it will have an adverse effect on test run time, especially when used with slower location strategies like XPath.
Parameter ms
The amount of time to wait, in milliseconds. {!webdriver.promise.Promise} A promise that will be resolved when the implicit wait timeout has been set.

method pageLoadTimeout

pageLoadTimeout: (ms: number) => webdriver.promise.Promise<void>;

Sets the amount of time to wait for a page load to complete before returning an error. If the timeout is negative, page loads may be indefinite.
Parameter ms
The amount of time to wait, in milliseconds. {!webdriver.promise.Promise} A promise that will be resolved when the timeout has been set.

method setScriptTimeout

setScriptTimeout: (ms: number) => webdriver.promise.Promise<void>;

Sets the amount of time to wait, in milliseconds, for an asynchronous script to finish execution before returning an error. If the timeout is less than or equal to 0, the script will be allowed to run indefinitely.
Parameter ms
The amount of time to wait, in milliseconds. {!webdriver.promise.Promise} A promise that will be resolved when the script timeout has been set.

construct signature

new (driver: WebDriver): WebDriverTimeouts;

Parameter driver
The parent driver.

interface WebDriverWindow

interface WebDriverWindow {}

An interface for managing the current window.

method getPosition

getPosition: () => webdriver.promise.Promise<ILocation>;

Retrieves the window's current position, relative to the top left corner of the screen. {!webdriver.promise.Promise} A promise that will be resolved with the window's position in the form of a {x:number, y:number} object literal.

method getSize

getSize: () => webdriver.promise.Promise<ISize>;

Retrieves the window's current size. {!webdriver.promise.Promise} A promise that will be resolved with the window's size in the form of a {width:number, height:number} object literal.

method maximize

maximize: () => webdriver.promise.Promise<void>;

Maximizes the current window. {!webdriver.promise.Promise} A promise that will be resolved when the command has completed.

method setPosition

setPosition: (x: number, y: number) => webdriver.promise.Promise<void>;

Repositions the current window.
Parameter x
The desired horizontal position, relative to the left side of the screen.
Parameter y
The desired vertical position, relative to the top of the of the screen. {!webdriver.promise.Promise} A promise that will be resolved when the command has completed.

method setSize

setSize: (width: number, height: number) => webdriver.promise.Promise<void>;

Resizes the current window.
Parameter width
The desired window width.
Parameter height
The desired window height. {!webdriver.promise.Promise} A promise that will be resolved when the command has completed.

construct signature

new (driver: WebDriver): WebDriverWindow;

Parameter driver
The parent driver.

namespace selenium-webdriver.By

namespace selenium-webdriver.By {}

function className

className: (value: string) => Locator;

Locates elements that have a specific class name. The returned locator is equivalent to searching for elements with the CSS selector ".clazz".
Parameter className
The class name to search for. {!webdriver.Locator} The new locator.
See Also
- http://www.w3.org/TR/2011/WD-html5-20110525/elements.html#classes
- http://www.w3.org/TR/CSS2/selector.html#class-html

function css

css: (value: string) => Locator;

Locates elements using a CSS selector. For browsers that do not support CSS selectors, WebDriver implementations may return an error. An implementation may, however, emulate the CSS selector API.
Parameter selector
The CSS selector to use. {!webdriver.Locator} The new locator.
See Also
- http://www.w3.org/TR/CSS2/selector.html

function id

id: (value: string) => Locator;

Locates an element by its ID.
Parameter id
The ID to search for. {!webdriver.Locator} The new locator.

function js

js: (
    script: any,
    ...var_args: any[]
) => (WebDriver: WebDriver) => webdriver.promise.Promise<any>;

Locates an elements by evaluating a . The result of this expression must be an element or list of elements.
Parameter script
The script to execute.
Parameter var_args
The arguments to pass to the script. {function(!webdriver.WebDriver): !webdriver.promise.Promise} A new, JavaScript-based locator function.

function linkText

linkText: (value: string) => Locator;

Locates link elements whose matches the given string.
Parameter text
The link text to search for. {!webdriver.Locator} The new locator.

function name

name: (value: string) => Locator;

Locates elements whose attribute has the given value.
Parameter name
The name attribute to search for. {!webdriver.Locator} The new locator.

function partialLinkText

partialLinkText: (value: string) => Locator;

Locates link elements whose contains the given substring.
Parameter text
The substring to check for in a link's visible text. {!webdriver.Locator} The new locator.

function tagName

tagName: (value: string) => Locator;

Locates elements with a given tag name. The returned locator is equivalent to using the [getElementsByTagName](https://developer.mozilla.org/en-US/docs/Web/API/Element.getElementsByTagName) DOM function.
Parameter text
The substring to check for in a link's visible text. {!webdriver.Locator} The new locator.
See Also
- http://www.w3.org/TR/REC-DOM-Level-1/level-one-core.html

function xpath

xpath: (value: string) => Locator;

Locates elements matching a XPath selector. Care should be taken when using an XPath selector with a webdriver.WebElement as WebDriver will respect the context in the specified in the selector. For example, given the selector , WebDriver will search from the document root regardless of whether the locator was used with a WebElement.
Parameter xpath
The XPath selector to use. {!webdriver.Locator} The new locator.
See Also
- http://www.w3.org/TR/xpath/

type Hash

type Hash =
    | { className: string }
    | { css: string }
    | { id: string }
    | { js: string }
    | { linkText: string }
    | { name: string }
    | { partialLinkText: string }
    | { tagName: string }
    | { xpath: string };

Short-hand expressions for the primary element locator strategies. For example the following two statements are equivalent:
var e1 = driver.findElement(webdriver.By.id('foo')); var e2 = driver.findElement({id: 'foo'});
Care should be taken when using JavaScript minifiers (such as the Closure compiler), as locator hashes will always be parsed using the un-obfuscated properties listed.
{( {className: string}| {css: string}| {id: string}| {js: string}| {linkText: string}| {name: string}| {partialLinkText: string}| {tagName: string}| {xpath: string})}

namespace selenium-webdriver.error

namespace selenium-webdriver.error {}

variable ErrorCode

var ErrorCode: IErrorCode;

class Error

class Error {}

Error extension that includes error status codes from the WebDriver wire protocol: http://code.google.com/p/selenium/wiki/JsonWireProtocol#Response_Status_Codes
{Error}

constructor

constructor(code: number, opt_message?: string);

Parameter code
The error's status code.
Parameter opt_message
Optional error message.

property code

code: number;

This error's status code. {!bot.ErrorCode}

property isAutomationError

isAutomationError: boolean;

Flag used for duck-typing when this code is embedded in a Firefox extension. This is required since an Error thrown in one component and then reported to another will fail instanceof checks in the second component. {boolean}

property message

message: string;

Modifiers
- @override

property name

name: string;

Modifiers
- @override

property stack

stack: string;

Modifiers
- @override

property state

state: string;

{string}

property State

static State: {
    ELEMENT_NOT_SELECTABLE: string;
    ELEMENT_NOT_VISIBLE: string;
    IME_ENGINE_ACTIVATION_FAILED: string;
    IME_NOT_AVAILABLE: string;
    INVALID_COOKIE_DOMAIN: string;
    INVALID_ELEMENT_COORDINATES: string;
    INVALID_ELEMENT_STATE: string;
    INVALID_SELECTOR: string;
    JAVASCRIPT_ERROR: string;
    MOVE_TARGET_OUT_OF_BOUNDS: string;
    NO_SUCH_ALERT: string;
    NO_SUCH_DOM: string;
    NO_SUCH_ELEMENT: string;
    NO_SUCH_FRAME: string;
    NO_SUCH_WINDOW: string;
    SCRIPT_TIMEOUT: string;
    SESSION_NOT_CREATED: string;
    STALE_ELEMENT_REFERENCE: string;
    SUCCESS: string;
    TIMEOUT: string;
    UNABLE_TO_SET_COOKIE: string;
    UNEXPECTED_ALERT_OPEN: string;
    UNKNOWN_COMMAND: string;
    UNKNOWN_ERROR: string;
    UNSUPPORTED_OPERATION: string;
};

Status strings enumerated in the W3C WebDriver working draft. {string}
See Also
- http://www.w3.org/TR/webdriver/#status-codes

method toString

toString: () => string;

{string} The string representation of this error.

interface IErrorCode

interface IErrorCode {}

property ELEMENT_NOT_SELECTABLE

ELEMENT_NOT_SELECTABLE: number;

property ELEMENT_NOT_VISIBLE

ELEMENT_NOT_VISIBLE: number;

property IME_ENGINE_ACTIVATION_FAILED

IME_ENGINE_ACTIVATION_FAILED: number;

property IME_NOT_AVAILABLE

IME_NOT_AVAILABLE: number;

property INVALID_COOKIE_DOMAIN

INVALID_COOKIE_DOMAIN: number;

property INVALID_ELEMENT_COORDINATES

INVALID_ELEMENT_COORDINATES: number;

property INVALID_ELEMENT_STATE

INVALID_ELEMENT_STATE: number;

property INVALID_SELECTOR_ERROR

INVALID_SELECTOR_ERROR: number;

property INVALID_XPATH_SELECTOR

INVALID_XPATH_SELECTOR: number;

property INVALID_XPATH_SELECTOR_RETURN_TYPE

INVALID_XPATH_SELECTOR_RETURN_TYPE: number;

property JAVASCRIPT_ERROR

JAVASCRIPT_ERROR: number;

property METHOD_NOT_ALLOWED

METHOD_NOT_ALLOWED: number;

property MODAL_DIALOG_OPENED

MODAL_DIALOG_OPENED: number;

property MOVE_TARGET_OUT_OF_BOUNDS

MOVE_TARGET_OUT_OF_BOUNDS: number;

property NO_MODAL_DIALOG_OPEN

NO_MODAL_DIALOG_OPEN: number;

property NO_SUCH_ALERT

NO_SUCH_ALERT: number;

property NO_SUCH_ELEMENT

NO_SUCH_ELEMENT: number;

property NO_SUCH_FRAME

NO_SUCH_FRAME: number;

property NO_SUCH_WINDOW

NO_SUCH_WINDOW: number;

property SCRIPT_TIMEOUT

SCRIPT_TIMEOUT: number;

property SESSION_NOT_CREATED

SESSION_NOT_CREATED: number;

property SQL_DATABASE_ERROR

SQL_DATABASE_ERROR: number;

property STALE_ELEMENT_REFERENCE

STALE_ELEMENT_REFERENCE: number;

property SUCCESS

SUCCESS: number;

property TIMEOUT

TIMEOUT: number;

property UNABLE_TO_SET_COOKIE

UNABLE_TO_SET_COOKIE: number;

property UNEXPECTED_ALERT_OPEN

UNEXPECTED_ALERT_OPEN: number;

property UNKNOWN_COMMAND

UNKNOWN_COMMAND: number;

property UNKNOWN_ERROR

UNKNOWN_ERROR: number;

property UNSUPPORTED_OPERATION

UNSUPPORTED_OPERATION: number;

property XPATH_LOOKUP_ERROR

XPATH_LOOKUP_ERROR: number;

namespace selenium-webdriver.logging

namespace selenium-webdriver.logging {}

variable Level

var Level: ILevelValues;

variable Type

var Type: IType;

Common log types. {string}

function getLevel

getLevel: { (nameOrValue: string): ILevel; (nameOrValue: number): ILevel };

Converts a level name or value to a webdriver.logging.Level value. If the name/value is not recognized, webdriver.logging.Level.ALL will be returned.
Parameter nameOrValue
The log level name, or value, to convert . {!webdriver.logging.Level} The converted level.

class Entry

class Entry {}

A single log entry.

constructor

constructor(
    level: ILevel,
    message: string,
    opt_timestamp?: number,
    opt_type?: string
);

Parameter level
The entry level.
Parameter message
The log message.
Parameter opt_timestamp
The time this entry was generated, in milliseconds since 0:00:00, January 1, 1970 UTC. If omitted, the current time will be used.
Parameter opt_type
The log type, if known.

constructor

constructor(
    level: string,
    message: string,
    opt_timestamp?: number,
    opt_type?: string
);

property level

level: ILevel;

{!webdriver.logging.Level}

property message

message: string;

{string}

property timestamp

timestamp: number;

{number}

property type

type: string;

{string}

method fromClosureLogRecord

static fromClosureLogRecord: (logRecord: any, opt_type?: string) => Entry;

Converts a goog.debug.LogRecord into a webdriver.logging.Entry.
Parameter logRecord
The record to convert.
Parameter opt_type
The log type. {!webdriver.logging.Entry} The converted entry.

method toJSON

toJSON: () => IEntryJSON;

{{level: string, message: string, timestamp: number, type: string}} The JSON representation of this entry.

class Preferences

class Preferences {}

A hash describing log preferences. {Object.<webdriver.logging.Type, webdriver.logging.LevelName>}

method setLevel

setLevel: (type: string, level: ILevel) => void;

method toJSON

toJSON: () => { [key: string]: string };

interface IEntryJSON

interface IEntryJSON {}

property level

level: string;

property message

message: string;

property timestamp

timestamp: number;

property type

type: string;

interface ILevel

interface ILevel {}

Logging levels. {{value: number, name: webdriver.logging.LevelName}}

property name

name: string;

property value

value: number;

interface ILevelValues

interface ILevelValues {}

property ALL

ALL: ILevel;

property DEBUG

DEBUG: ILevel;

property INFO

INFO: ILevel;

property OFF

OFF: ILevel;

property SEVERE

SEVERE: ILevel;

property WARNING

WARNING: ILevel;

interface IType

interface IType {}

property BROWSER

BROWSER: string;

Logs originating from the browser.

property CLIENT

CLIENT: string;

Logs from a WebDriver client.

property DRIVER

DRIVER: string;

Logs from a WebDriver implementation.

property PERFORMANCE

PERFORMANCE: string;

Logs related to performance.

property SERVER

SERVER: string;

Logs from the remote server.

namespace selenium-webdriver.promise

namespace selenium-webdriver.promise {}

function all

all: (arr: Promise<any>[]) => Promise<any[]>;

Given an array of promises, will return a promise that will be fulfilled with the fulfillment values of the input array's values. If any of the input array's promises are rejected, the returned promise will be rejected with the same reason.
Parameter arr
An array of promises to wait on. {!webdriver.promise.Promise.<!Array.>} A promise that is fulfilled with an array containing the fulfilled values of the input array, or rejected with the same reason as the first rejected value. T

function asap

asap: (value: any, callback: Function, opt_errback?: Function) => void;

Invokes the appropriate callback function as soon as a promised is resolved. This function is similar to webdriver.promise.when, except it does not return a new promise.
Parameter value
The value to observe.
Parameter callback
The function to call when the value is resolved successfully.
Parameter opt_errback
The function to call when the value is rejected.

function checkedNodeCall

checkedNodeCall: <T>(fn: Function, ...var_args: any[]) => Promise<T>;

Wraps a function that is assumed to be a node-style callback as its final argument. This callback takes two arguments: an error value (which will be null if the call succeeded), and the success value as the second argument. If the call fails, the returned promise will be rejected, otherwise it will be resolved with the result.
Parameter fn
The function to wrap. {!webdriver.promise.Promise} A promise that will be resolved with the result of the provided function's callback.

function consume

consume: <T>(
    generatorFn: Function,
    opt_self?: any,
    ...var_args: any[]
) => Promise<T>;

Consumes a . Each time the generator yields a promise, this function will wait for it to be fulfilled before feeding the fulfilled value back into . Likewise, if a yielded promise is rejected, the rejection error will be passed to .
Example 1: the Fibonacci Sequence. webdriver.promise.consume(function* fibonacci() { var n1 = 1, n2 = 1; for (var i = 0; i < 4; ++i) { var tmp = yield n1 + n2; n1 = n2; n2 = tmp; } return n1 + n2; }).then(function(result) { console.log(result); // 13 });
Example 2: a generator that throws. webdriver.promise.consume(function* () { yield webdriver.promise.delayed(250).then(function() { throw Error('boom'); }); }).thenCatch(function(e) { console.log(e.toString()); // Error: boom });
Parameter generatorFn
The generator function to execute.
Parameter opt_self
The object to use as "this" when invoking the initial generator.
Parameter var_args
Any arguments to pass to the initial generator. {!webdriver.promise.Promise.<?>} A promise that will resolve to the generator's final result.
Throws
{TypeError} If the given function is not a generator.

function controlFlow

controlFlow: () => ControlFlow;

{!webdriver.promise.ControlFlow} The currently active control flow.

function createFlow

createFlow: <R>(callback: (flow: ControlFlow) => R) => Promise<R>;

Creates a new control flow. The provided callback will be invoked as the first task within the new flow, with the flow as its sole argument. Returns a promise that resolves to the callback result.
Parameter callback
The entry point to the newly created flow. {!webdriver.promise.Promise} A promise that resolves to the callback result.

function defer

defer: <T>() => Deferred<T>;

Creates a new deferred object. {!webdriver.promise.Deferred} The new deferred object.

function delayed

delayed: (ms: number) => Promise<void>;

Creates a promise that will be resolved at a set time in the future.
Parameter ms
The amount of time, in milliseconds, to wait before resolving the promise. {!webdriver.promise.Promise} The promise.

function filter

filter: {
    <T>(
        arr: T[],
        fn: (element: T, index: number, array: T[]) => any,
        opt_self?: any
    ): Promise<T[]>;
    <T>(
        arr: Promise<T[]>,
        fn: (element: T, index: number, array: T[]) => any,
        opt_self?: any
    ): Promise<T[]>;
};

Calls a function for each element in an array, and if the function returns true adds the element to a new array.
If the return value of the filter function is a promise, this function will wait for it to be fulfilled before determining whether to insert the element into the new array.
If the filter function throws or returns a rejected promise, the promise returned by this function will be rejected with the same reason. Only the first failure will be reported; all subsequent errors will be silently ignored.
Parameter arr
The array to iterator over, or a promise that will resolve to said array.
Parameter fn
The function to call for each element in the array.
Parameter opt_self
The object to be used as the value of 'this' within . TYPE, SELF

function fulfilled

fulfilled: <T>(opt_value?: T) => Promise<T>;

Creates a promise that has been resolved with the given value.
Parameter opt_value
The resolved value. {!webdriver.promise.Promise} The resolved promise.

function fullyResolved

fullyResolved: <T>(value: any) => Promise<T>;

Returns a promise that will be resolved with the input value in a fully-resolved state. If the value is an array, each element will be fully resolved. Likewise, if the value is an object, all keys will be fully resolved. In both cases, all nested arrays and objects will also be fully resolved. All fields are resolved in place; the returned promise will resolve on and not a copy.
Warning: This function makes no checks against objects that contain cyclical references:
var value = {}; value['self'] = value; webdriver.promise.fullyResolved(value); // Stack overflow.
Parameter value
The value to fully resolve. {!webdriver.promise.Promise} A promise for a fully resolved version of the input value.

function isGenerator

isGenerator: (fn: Function) => boolean;

Tests is a function is a generator.
Parameter fn
The function to test. {boolean} Whether the function is a generator.

function isPromise

isPromise: (value: any) => boolean;

Determines whether a should be treated as a promise. Any object whose "then" property is a function will be considered a promise.
Parameter value
The value to test. {boolean} Whether the value is a promise.

function map

map: {
    <T>(
        arr: T[],
        fn: (element: T, index: number, array: T[]) => any,
        opt_self?: any
    ): Promise<T[]>;
    <T>(
        arr: Promise<T[]>,
        fn: (element: T, index: number, array: T[]) => any,
        opt_self?: any
    ): Promise<T[]>;
};

Calls a function for each element in an array and inserts the result into a new array, which is used as the fulfillment value of the promise returned by this function.
If the return value of the mapping function is a promise, this function will wait for it to be fulfilled before inserting it into the new array.
If the mapping function throws or returns a rejected promise, the promise returned by this function will be rejected with the same reason. Only the first failure will be reported; all subsequent errors will be silently ignored.
Parameter arr
The array to iterator over, or a promise that will resolve to said array.
Parameter fn
The function to call for each element in the array. This function should expect three arguments (the element, the index, and the array itself.
Parameter opt_self
The object to be used as the value of 'this' within . TYPE, SELF

function rejected

rejected: (opt_reason?: any) => Promise<void>;

Creates a promise that has been rejected with the given reason.
Parameter opt_reason
The rejection reason; may be any value, but is usually an Error or a string. {!webdriver.promise.Promise} The rejected promise.

function setDefaultFlow

setDefaultFlow: (flow: ControlFlow) => void;

Changes the default flow to use when no others are active.
Parameter flow
The new default flow.
Throws
{Error} If the default flow is not currently active.

function when

when: {
    <T, R>(
        value: T,
        opt_callback?: (value: T) => any,
        opt_errback?: (error: any) => any
    ): Promise<R>;
    <T, R>(
        value: Promise<T>,
        opt_callback?: (value: T) => any,
        opt_errback?: (error: any) => any
    ): Promise<R>;
};

Registers an observer on a promised , returning a new promise that will be resolved when the value is. If is not a promise, then the return promise will be immediately resolved.
Parameter value
The value to observe.
Parameter opt_callback
The function to call when the value is resolved successfully.
Parameter opt_errback
The function to call when the value is rejected. {!webdriver.promise.Promise} A new promise.

class CancellationError

class CancellationError {}

Error used when the computation of a promise is cancelled.
{goog.debug.Error}

constructor

constructor(opt_msg?: string);

Parameter opt_msg
The cancellation message.

property message

message: string;

property name

name: string;

class ControlFlow

class ControlFlow extends EventEmitter {}

Handles the execution of scheduled tasks, each of which may be an asynchronous operation. The control flow will ensure tasks are executed in the ordered scheduled, starting each task only once those before it have completed.
Each task scheduled within this flow may return a webdriver.promise.Promise to indicate it is an asynchronous operation. The ControlFlow will wait for such promises to be resolved before marking the task as completed.
Tasks and each callback registered on a webdriver.promise.Promise will be run in their own ControlFlow frame. Any tasks scheduled within a frame will take priority over previously scheduled tasks. Furthermore, if any of the tasks in the frame fail, the remainder of the tasks in that frame will be discarded and the failure will be propagated to the user through the callback/task's promised result.
Each time a ControlFlow empties its task queue, it will fire an event. Conversely, whenever the flow terminates due to an unhandled error, it will remove all remaining tasks in its queue and fire an event. If there are no listeners registered with the flow, the error will be rethrown to the global error handler.
{EventEmitter}

constructor

constructor();

property EventType

static EventType: {
    IDLE: string;
    RESET: string;
    SCHEDULE_TASK: string;
    UNCAUGHT_EXCEPTION: string;
};

Events that may be emitted by an webdriver.promise.ControlFlow. {string}

method execute

execute: <T>(fn: () => T | Promise<T>, opt_description?: string) => Promise<T>;

Schedules a task for execution. If there is nothing currently in the queue, the task will be executed in the next turn of the event loop. If the task function is a generator, the task will be executed using webdriver.promise.consume.
Parameter fn
The function to call to start the task. If the function returns a webdriver.promise.Promise, this instance will wait for it to be resolved before starting the next task.
Parameter opt_description
A description of the task. {!promise.Promise} A promise that will be resolved with the result of the action. T

method getSchedule

getSchedule: (opt_includeStackTraces?: boolean) => string;

Generates an annotated string describing the internal state of this control flow, including the currently executing as well as pending tasks. If , the string will include the stack trace from when each task was scheduled.
Parameter opt_includeStackTraces
Whether to include the stack traces from when each task was scheduled. Defaults to false. {string} String representation of this flow's internal state.

method reset

reset: () => void;

Resets this instance, clearing its queue and removing all event listeners.

method timeout

timeout: (ms: number, opt_description?: string) => Promise<void>;

Inserts a into the command queue. This is equivalent to a thread sleep in a synchronous programming language.
Parameter ms
The timeout delay, in milliseconds.
Parameter opt_description
A description to accompany the timeout. {!webdriver.promise.Promise} A promise that will be resolved with the result of the action.

method toString

toString: () => string;

Returns a string representation of this control flow, which is its current , sans task stack traces. {string} The string representation of this contorl flow.
Modifiers
- @override

method wait

wait: <T>(
    condition: Promise<T> | Function,
    opt_timeout?: number,
    opt_message?: string
) => Promise<T>;

Schedules a task that shall wait for a condition to hold. Each condition function may return any value, but it will always be evaluated as a boolean.
Condition functions may schedule sub-tasks with this instance, however, their execution time will be factored into whether a wait has timed out.
In the event a condition returns a Promise, the polling loop will wait for it to be resolved before evaluating whether the condition has been satisfied. The resolution time for a promise is factored into whether a wait has timed out.
If the condition function throws, or returns a rejected promise, the wait task will fail.
If the condition is defined as a promise, the flow will wait for it to settle. If the timeout expires before the promise settles, the promise returned by this function will be rejected.
If this function is invoked with timeout === 0, or the timeout is omitted, the flow will wait indefinitely for the condition to be satisfied.
Parameter condition
The condition to poll, or a promise to wait on.
Parameter opt_timeout
How long to wait, in milliseconds, for the condition to hold before timing out. If omitted, the flow will wait indefinitely.
Parameter opt_message
An optional error message to include if the wait times out; defaults to the empty string. {!promise.Promise} A promise that will be fulfilled when the condition has been satisified. The promise shall be rejected if the wait times out waiting for the condition.
Throws
{TypeError} If condition is not a function or promise or if timeout is not a number >= 0. T

class Deferred

class Deferred<T> extends Promise<T> {}

Represents a value that will be resolved at some point in the future. This class represents the protected "producer" half of a Promise - each Deferred has a property that may be returned to consumers for registering callbacks, reserving the ability to resolve the deferred to the producer.
If this Deferred is rejected and there are no listeners registered before the next turn of the event loop, the rejection will be passed to the webdriver.promise.ControlFlow as an unhandled failure.
If this Deferred is cancelled, the cancellation reason will be forward to the Deferred's canceller function (if provided). The canceller may return a truth-y value to override the reason provided for rejection.
{webdriver.promise.Promise}

constructor

constructor(opt_flow?: ControlFlow);

Parameter opt_flow
The control flow this instance was created under. This should only be provided during unit tests.

property promise

promise: Promise<T>;

The consumer promise for this instance. Provides protected access to the callback registering functions. {!webdriver.promise.Promise}

property State_

static State_: {
    BLOCKED: number;
    PENDING: number;
    REJECTED: number;
    RESOLVED: number;
};

method errback

errback: (opt_error?: any) => void;

method fulfill

fulfill: (opt_value?: T) => void;

Resolves this promise with the given value. If the value is itself a promise and not a reference to this deferred, this instance will wait for it before resolving.
Parameter opt_value
The resolved value.

method reject

reject: (opt_error?: any) => void;

Rejects this promise. If the error is itself a promise, this instance will be chained to it and be rejected with the error's resolved value.
Parameter opt_error
The rejection reason, typically either a or a .

method removeAll

removeAll: () => void;

Removes all of the listeners previously registered on this deferred.
Throws
{Error} If this deferred has already been resolved.

class Promise

class Promise<T> implements IThenable<T> {}

Represents the eventual value of a completed operation. Each promise may be in one of three states: pending, fulfilled, or rejected. Each promise starts in the pending state and may make a single transition to either a fulfilled or rejected state, at which point the promise is considered resolved.
{promise.Thenable} T
See Also
- http://promises-aplus.github.io/promises-spec/

constructor

constructor(
    resolver: (
        onFulfilled: IFulfilledCallback<T>,
        onRejected: IRejectedCallback
    ) => void,
    opt_flow?: ControlFlow
);

Parameter resolver
Function that is invoked immediately to begin computation of this promise's value. The function should accept a pair of callback functions, one for fulfilling the promise and another for rejecting it.
Parameter opt_flow
The control flow this instance was created under. Defaults to the currently active flow.

constructor

constructor();

method cancel

cancel: (reason: any) => void;

Cancels the computation of this promise's value, rejecting the promise in the process.
Parameter reason
The reason this promise is being cancelled. If not an , one will be created using the value's string representation.

method isPending

isPending: () => boolean;

{boolean} Whether this promise's value is still being computed.

method then

then: {
    <R>(
        opt_callback?: (value: T) => Promise<R>,
        opt_errback?: (error: any) => any
    ): Promise<R>;
    <R>(
        opt_callback?: (value: T) => R,
        opt_errback?: (error: any) => any
    ): Promise<R>;
};

Registers listeners for when this instance is resolved. This function most overridden by subtypes.
Parameter opt_callback
The function to call if this promise is successfully resolved. The function should expect a single argument: the promise's resolved value.
Parameter opt_errback
The function to call if this promise is rejected. The function should expect a single argument: the rejection reason. A new promise which will be resolved with the result of the invoked callback.

method thenCatch

thenCatch: <R>(errback: (error: any) => any) => Promise<R>;

Registers a listener for when this promise is rejected. This is synonymous with the clause in a synchronous API: // Synchronous API: try { doSynchronousWork(); } catch (ex) { console.error(ex); }
// Asynchronous promise API: doAsynchronousWork().thenCatch(function(ex) { console.error(ex); });
Parameter errback
The function to call if this promise is rejected. The function should expect a single argument: the rejection reason. {!webdriver.promise.Promise.} A new promise which will be resolved with the result of the invoked callback. R

method thenFinally

thenFinally: <R>(callback: () => any) => Promise<R>;

Registers a listener to invoke when this promise is resolved, regardless of whether the promise's value was successfully computed. This function is synonymous with the clause in a synchronous API: // Synchronous API: try { doSynchronousWork(); } finally { cleanUp(); }
// Asynchronous promise API: doAsynchronousWork().thenFinally(cleanUp);
Note: similar to the clause, if the registered callback returns a rejected promise or throws an error, it will silently replace the rejection error (if any) from this promise: try { throw Error('one'); } finally { throw Error('two'); // Hides Error: one }
webdriver.promise.rejected(Error('one')) .thenFinally(function() { throw Error('two'); // Hides Error: one });
Parameter callback
The function to call when this promise is resolved. {!webdriver.promise.Promise.} A promise that will be fulfilled with the callback result. R

class Thenable

class Thenable<T> implements IThenable<T> {}

Thenable is a promise-like object with a method which may be used to schedule callbacks on a promised value.
T

method addImplementation

static addImplementation: (ctor: Function) => void;

Adds a property to a class prototype to allow runtime checks of whether instances of that class implement the Thenable interface. This function will also ensure the prototype's function is exported from compiled code.
Parameter ctor
The constructor whose prototype to modify.

method cancel

cancel: (opt_reason?: string) => void;

Cancels the computation of this promise's value, rejecting the promise in the process. This method is a no-op if the promise has alreayd been resolved.
Parameter opt_reason
The reason this promise is being cancelled.

method isImplementation

static isImplementation: (object: any) => boolean;

Checks if an object has been tagged for implementing the Thenable interface as defined by webdriver.promise.Thenable.addImplementation.
Parameter object
The object to test. {boolean} Whether the object is an implementation of the Thenable interface.

method isPending

isPending: () => boolean;

{boolean} Whether this promise's value is still being computed.

method then

then: {
    <R>(
        opt_callback?: (value: T) => Promise<R>,
        opt_errback?: (error: any) => any
    ): Promise<R>;
    <R>(
        opt_callback?: (value: T) => R,
        opt_errback?: (error: any) => any
    ): Promise<R>;
};

Registers listeners for when this instance is resolved.
Parameter opt_callback
The function to call if this promise is successfully resolved. The function should expect a single argument: the promise's resolved value.
Parameter opt_errback
The function to call if this promise is rejected. The function should expect a single argument: the rejection reason. A new promise which will be resolved with the result of the invoked callback.

method thenCatch

thenCatch: <R>(errback: (error: any) => any) => Promise<R>;

Registers a listener for when this promise is rejected. This is synonymous with the clause in a synchronous API: // Synchronous API: try { doSynchronousWork(); } catch (ex) { console.error(ex); }
// Asynchronous promise API: doAsynchronousWork().thenCatch(function(ex) { console.error(ex); });
Parameter errback
The function to call if this promise is rejected. The function should expect a single argument: the rejection reason. {!webdriver.promise.Promise.} A new promise which will be resolved with the result of the invoked callback. R

method thenFinally

thenFinally: <R>(callback: () => any) => Promise<R>;

Registers a listener to invoke when this promise is resolved, regardless of whether the promise's value was successfully computed. This function is synonymous with the clause in a synchronous API: // Synchronous API: try { doSynchronousWork(); } finally { cleanUp(); }
// Asynchronous promise API: doAsynchronousWork().thenFinally(cleanUp);
Note: similar to the clause, if the registered callback returns a rejected promise or throws an error, it will silently replace the rejection error (if any) from this promise: try { throw Error('one'); } finally { throw Error('two'); // Hides Error: one }
webdriver.promise.rejected(Error('one')) .thenFinally(function() { throw Error('two'); // Hides Error: one });
Parameter callback
The function to call when this promise is resolved. {!webdriver.promise.Promise.} A promise that will be fulfilled with the callback result. R

interface IControlFlowTimer

interface IControlFlowTimer {}

property clearInterval

clearInterval: (ms: number) => void;

property clearTimeout

clearTimeout: (ms: number) => void;

property setInterval

setInterval: (fn: Function, ms: number) => number;

property setTimeout

setTimeout: (fn: Function, ms: number) => number;

interface IFulfilledCallback

interface IFulfilledCallback<T> {}

call signature

(value: T | IThenable<T> | Thenable<T> | void): void;

interface IRejectedCallback

interface IRejectedCallback {}

call signature

(reason: any): void;

interface IThenable

interface IThenable<T> {}

method cancel

cancel: (opt_reason?: string) => void;

Cancels the computation of this promise's value, rejecting the promise in the process. This method is a no-op if the promise has alreayd been resolved.
Parameter opt_reason
The reason this promise is being cancelled.

method isPending

isPending: () => boolean;

{boolean} Whether this promise's value is still being computed.

method then

then: {
    <R>(
        opt_callback?: (value: T) => Promise<R>,
        opt_errback?: (error: any) => any
    ): Promise<R>;
    <R>(
        opt_callback?: (value: T) => R,
        opt_errback?: (error: any) => any
    ): Promise<R>;
};

Registers listeners for when this instance is resolved.
Parameter opt_callback
The function to call if this promise is successfully resolved. The function should expect a single argument: the promise's resolved value.
Parameter opt_errback
The function to call if this promise is rejected. The function should expect a single argument: the rejection reason. A new promise which will be resolved with the result of the invoked callback.

method thenCatch

thenCatch: <R>(errback: (error: any) => any) => Promise<R>;

Registers a listener for when this promise is rejected. This is synonymous with the clause in a synchronous API: // Synchronous API: try { doSynchronousWork(); } catch (ex) { console.error(ex); }
// Asynchronous promise API: doAsynchronousWork().thenCatch(function(ex) { console.error(ex); });
Parameter errback
The function to call if this promise is rejected. The function should expect a single argument: the rejection reason. {!webdriver.promise.Promise.} A new promise which will be resolved with the result of the invoked callback. R

method thenFinally

thenFinally: <R>(callback: () => any) => Promise<R>;

Registers a listener to invoke when this promise is resolved, regardless of whether the promise's value was successfully computed. This function is synonymous with the clause in a synchronous API: // Synchronous API: try { doSynchronousWork(); } finally { cleanUp(); }
// Asynchronous promise API: doAsynchronousWork().thenFinally(cleanUp);
Note: similar to the clause, if the registered callback returns a rejected promise or throws an error, it will silently replace the rejection error (if any) from this promise: try { throw Error('one'); } finally { throw Error('two'); // Hides Error: one }
webdriver.promise.rejected(Error('one')) .thenFinally(function() { throw Error('two'); // Hides Error: one });
Parameter callback
The function to call when this promise is resolved. {!webdriver.promise.Promise.} A promise that will be fulfilled with the callback result. R

namespace selenium-webdriver.stacktrace

namespace selenium-webdriver.stacktrace {}

variable BROWSER_SUPPORTED

var BROWSER_SUPPORTED: boolean;

Whether the current browser supports stack traces.
{boolean}

function format

format: (error: any) => any;

Formats an error's stack trace.
Parameter error
The error to format. {!(Error|goog.testing.JsUnitException)} The formatted error.

function get

get: () => Frame[];

Gets the native stack trace if available otherwise follows the call chain. The generated trace will exclude all frames up to and including the call to this function. {!Array.<!webdriver.stacktrace.Frame>} The frames of the stack trace.

class Frame

class Frame {}

Class representing one stack frame.

constructor

constructor(context?: string, name?: string, alias?: string, path?: string);

Parameter context
Context object, empty in case of global functions or if the browser doesn't provide this information.
Parameter name
Function name, empty in case of anonymous functions.
Parameter alias
Alias of the function if available. For example the function name will be 'c' and the alias will be 'b' if the function is defined as a.b = function c() {};.
Parameter path
File path or URL including line number and optionally column number separated by colons.

method getColumn

getColumn: () => number;

{number} The column number if known and -1 if it is unknown.

method getLine

getLine: () => number;

{number} The line number if known or -1 if it is unknown.

method getName

getName: () => string;

{string} The function name or empty string if the function is anonymous and the object field which it's assigned to is unknown.

method getUrl

getUrl: () => string;

{string} The url or empty string if it is unknown.

method isAnonymous

isAnonymous: () => boolean;

{boolean} Whether the stack frame contains an anonymous function.

method toString

toString: () => string;

Converts this frame to its string representation using V8's stack trace format: http://code.google.com/p/v8/wiki/JavaScriptStackTraceApi {string} The string representation of this frame.
Modifiers
- @override

class Snapshot

class Snapshot {}

Stores a snapshot of the stack trace at the time this instance was created. The stack trace will always be adjusted to exclude this function call.

constructor

constructor(opt_slice?: number);

Parameter opt_slice
The number of frames to remove from the top of the generated stack trace.

method getStacktrace

getStacktrace: () => Frame[];

{!Array.<!webdriver.stacktrace.Frame>} The parsed stack trace.

namespace selenium-webdriver.until

namespace selenium-webdriver.until {}

function ableToSwitchToFrame

ableToSwitchToFrame: (
    frame:
        | number
        | WebElement
        | Locator
        | By.Hash
        | ((webdriver: WebDriver) => WebElement)
) => Condition<boolean>;

Creates a condition that will wait until the input driver is able to switch to the designated frame. The target frame may be specified as: A numeric index into for the currently selected frame. A webdriver.WebElement, which must reference a FRAME or IFRAME element on the current page. A locator which may be used to first locate a FRAME or IFRAME on the current page before attempting to switch to it.
Upon successful resolution of this condition, the driver will be left focused on the new frame.
Parameter frame
The frame identifier. {!until.Condition.} A new condition.

function alertIsPresent

alertIsPresent: () => Condition<Alert>;

Creates a condition that waits for an alert to be opened. Upon success, the returned promise will be fulfilled with the handle for the opened alert.
{!until.Condition.<!webdriver.Alert>} The new condition.

function elementIsDisabled

elementIsDisabled: (element: WebElement) => Condition<boolean>;

Creates a condition that will wait for the given element to be disabled.
Parameter element
The element to test. {!until.Condition.} The new condition.
See Also
- webdriver.WebDriver#isEnabled

function elementIsEnabled

elementIsEnabled: (element: WebElement) => Condition<boolean>;

Creates a condition that will wait for the given element to be enabled.
Parameter element
The element to test. {!until.Condition.} The new condition.
See Also
- webdriver.WebDriver#isEnabled

function elementIsNotSelected

elementIsNotSelected: (element: WebElement) => Condition<boolean>;

Creates a condition that will wait for the given element to be deselected.
Parameter element
The element to test. {!until.Condition.} The new condition.
See Also
- webdriver.WebDriver#isSelected

function elementIsNotVisible

elementIsNotVisible: (element: WebElement) => Condition<boolean>;

Creates a condition that will wait for the given element to be in the DOM, yet not visible to the user.
Parameter element
The element to test. {!until.Condition.} The new condition.
See Also
- webdriver.WebDriver#isDisplayed

function elementIsSelected

elementIsSelected: (element: WebElement) => Condition<boolean>;

Creates a condition that will wait for the given element to be selected.
Parameter element
The element to test. {!until.Condition.} The new condition.
See Also
- webdriver.WebDriver#isSelected

function elementIsVisible

elementIsVisible: (element: WebElement) => Condition<boolean>;

Creates a condition that will wait for the given element to become visible.
Parameter element
The element to test. {!until.Condition.} The new condition.
See Also
- webdriver.WebDriver#isDisplayed

function elementLocated

elementLocated: (locator: Locator | By.Hash | Function) => Condition<WebElement>;

Creates a condition that will loop until an element is with the given locator.
Parameter locator
The locator to use. {!until.Condition.<!webdriver.WebElement>} The new condition.

function elementsLocated

elementsLocated: (
    locator: Locator | By.Hash | Function
) => Condition<WebElement[]>;

Creates a condition that will loop until at least one element is with the given locator.
Parameter locator
The locator to use. {!until.Condition.<!Array.<!webdriver.WebElement>>} The new condition.

function elementTextContains

elementTextContains: (element: WebElement, substr: string) => Condition<boolean>;

Creates a condition that will wait for the given element's to contain the given substring.
Parameter element
The element to test.
Parameter substr
The substring to search for. {!until.Condition.} The new condition.
See Also
- webdriver.WebDriver#getText

function elementTextIs

elementTextIs: (element: WebElement, text: string) => Condition<boolean>;

Creates a condition that will wait for the given element's to match the given exactly.
Parameter element
The element to test.
Parameter text
The expected text. {!until.Condition.} The new condition.
See Also
- webdriver.WebDriver#getText

function elementTextMatches

elementTextMatches: (element: WebElement, regex: RegExp) => Condition<boolean>;

Creates a condition that will wait for the given element's to match a regular expression.
Parameter element
The element to test.
Parameter regex
The regular expression to test against. {!until.Condition.} The new condition.
See Also
- webdriver.WebDriver#getText

function stalenessOf

stalenessOf: (element: WebElement) => Condition<boolean>;

Creates a condition that will wait for the given element to become stale. An element is considered stale once it is removed from the DOM, or a new page has loaded.
Parameter element
The element that should become stale. {!until.Condition.} The new condition.

function titleContains

titleContains: (substr: string) => Condition<boolean>;

Creates a condition that will wait for the current page's title to contain the given substring.
Parameter substr
The substring that should be present in the page title. {!until.Condition.} The new condition.

function titleIs

titleIs: (title: string) => Condition<boolean>;

Creates a condition that will wait for the current page's title to match the given value.
Parameter title
The expected page title. {!until.Condition.} The new condition.

function titleMatches

titleMatches: (regex: RegExp) => Condition<boolean>;

Creates a condition that will wait for the current page's title to match the given regular expression.
Parameter regex
The regular expression to test against. {!until.Condition.} The new condition.

class Condition

class Condition<T> {}

Defines a condition to

constructor

constructor(message: string, fn: (webdriver: WebDriver) => any);

Parameter message
A descriptive error message. Should complete the sentence "Waiting [...]"
Parameter fn
The condition function to evaluate on each iteration of the wait loop.

method description

description: () => string;

{string} A description of this condition.

method fn

fn: (webdriver: WebDriver) => any;

{function(!webdriver.WebDriver): OUT}

namespace selenium-webdriver/chrome

module 'selenium-webdriver/chrome' {}

function getDefaultService

getDefaultService: () => any;

Returns the default ChromeDriver service. If such a service has not been configured, one will be constructed using the default configuration for a ChromeDriver executable found on the system PATH. {!remote.DriverService} The default ChromeDriver service.

function setDefaultService

setDefaultService: (service: any) => void;

Sets the default service to use for new ChromeDriver instances.
Parameter service
The service to use.
Throws
{Error} If the default service is currently running.

class Driver

class Driver extends webdriver.WebDriver {}

Creates a new WebDriver client for Chrome.
{webdriver.WebDriver}

constructor

constructor(
    opt_config?: webdriver.Capabilities,
    opt_service?: any,
    opt_flow?: webdriver.promise.ControlFlow
);

Parameter opt_config
The configuration options.
Parameter opt_service
The session to use; will use the by default.
Parameter opt_flow
The control flow to use, or to use the currently active flow.

constructor

constructor(
    opt_config?: Options,
    opt_service?: any,
    opt_flow?: webdriver.promise.ControlFlow
);

class Options

class Options {}

Class for managing ChromeDriver specific options.

constructor

constructor();

method addArguments

addArguments: (...var_args: string[]) => Options;

Add additional command line arguments to use when launching the Chrome browser. Each argument may be specified with or without the "--" prefix (e.g. "--foo" and "foo"). Arguments with an associated value should be delimited by an "=": "foo=bar".
Parameter var_args
The arguments to add. {!Options} A self reference.

method addExtensions

addExtensions: (...var_args: any[]) => Options;

Add additional extensions to install when launching Chrome. Each extension should be specified as the path to the packed CRX file, or a Buffer for an extension.
Parameter var_args
The extensions to add. {!Options} A self reference.

method androidActivity

androidActivity: (name: string) => Options;

Sets the name of the activity hosting a Chrome-based Android WebView. This option must be set to connect to an [Android WebView]( https://sites.google.com/a/chromium.org/chromedriver/getting-started/getting-started---android)
Parameter name
The activity name. {!Options} A self reference.

method androidChrome

androidChrome: () => Options;

Configures the ChromeDriver to launch Chrome on Android via adb. This function is shorthand for . {!Options} A self reference.

method androidDeviceSerial

androidDeviceSerial: (serial: string) => Options;

Sets the device serial number to connect to via ADB. If not specified, the ChromeDriver will select an unused device at random. An error will be returned if all devices already have active sessions.
Parameter serial
The device serial number to connect to. {!Options} A self reference.

method androidPackage

androidPackage: (pkg: string) => Options;

Sets the package name of the Chrome or WebView app.
Parameter pkg
The package to connect to, or null to disable Android and switch back to using desktop Chrome. {!Options} A self reference.

method androidProcess

androidProcess: (processName: string) => Options;

Sets the process name of the Activity hosting the WebView (as given by ps). If not specified, the process name is assumed to be the same as .
Parameter processName
The main activity name. {!Options} A self reference.

method androidUseRunningApp

androidUseRunningApp: (useRunning: boolean) => Options;

Sets whether to connect to an already-running instead of the specified instead of launching the app with a clean data directory.
Parameter useRunning
Whether to connect to a running instance. {!Options} A self reference.

method detachDriver

detachDriver: (detach: boolean) => Options;

Sets whether to leave the started Chrome browser running if the controlling ChromeDriver service is killed before is called.
Parameter detach
Whether to leave the browser running if the chromedriver service is killed before the session. {!Options} A self reference.

method excludeSwitches

excludeSwitches: (...var_args: string[]) => Options;

List of Chrome command line switches to exclude that ChromeDriver by default passes when starting Chrome. Do not prefix switches with "--".
Parameter var_args
The switches to exclude. {!Options} A self reference.

method fromCapabilities

static fromCapabilities: (capabilities: webdriver.Capabilities) => Options;

Extracts the ChromeDriver specific options from the given capabilities object.
Parameter capabilities
The capabilities object. {!Options} The ChromeDriver options.

method setChromeBinaryPath

setChromeBinaryPath: (path: string) => Options;

Sets the path to the Chrome binary to use. On Mac OS X, this path should reference the actual Chrome executable, not just the application binary (e.g. "/Applications/Google Chrome.app/Contents/MacOS/Google Chrome").
The binary path be absolute or relative to the chromedriver server executable, but it must exist on the machine that will launch Chrome.
Parameter path
The path to the Chrome binary to use. {!Options} A self reference.

method setChromeLogFile

setChromeLogFile: (path: string) => Options;

Sets the path to Chrome's log file. This path should exist on the machine that will launch Chrome.
Parameter path
Path to the log file to use. {!Options} A self reference.

method setLocalState

setLocalState: (state: any) => Options;

Sets preferences for the "Local State" file in Chrome's user data directory.
Parameter state
Dictionary of local state preferences. {!Options} A self reference.

method setLoggingPrefs

setLoggingPrefs: (prefs: webdriver.logging.Preferences) => Options;

Sets the logging preferences for the new session.
Parameter prefs
The logging preferences. {!Options} A self reference.

method setPerfLoggingPrefs

setPerfLoggingPrefs: (prefs: IPerfLoggingPrefs) => Options;

Sets the performance logging preferences. Options include:
- enableNetwork: Whether or not to collect events from Network domain. - enablePage: Whether or not to collect events from Page domain. - enableTimeline: Whether or not to collect events from Timeline domain. Note: when tracing is enabled, Timeline domain is implicitly disabled, unless enableTimeline is explicitly set to true. - tracingCategories: A comma-separated string of Chrome tracing categories for which trace events should be collected. An unspecified or empty string disables tracing. - bufferUsageReportingInterval: The requested number of milliseconds between DevTools trace buffer usage events. For example, if 1000, then once per second, DevTools will report how full the trace buffer is. If a report indicates the buffer usage is 100%, a warning will be issued.
Parameter prefs
The performance logging preferences. {!Options} A self reference.

method setProxy

setProxy: (proxy: webdriver.ProxyConfig) => Options;

Sets the proxy settings for the new session.
Parameter proxy
The proxy configuration to use. {!Options} A self reference.

method setUserPreferences

setUserPreferences: (prefs: any) => Options;

Sets the user preferences for Chrome's user profile. See the "Preferences" file in Chrome's user data directory for examples.
Parameter prefs
Dictionary of user preferences to use. {!Options} A self reference.

method toCapabilities

toCapabilities: (
    opt_capabilities?: webdriver.Capabilities
) => webdriver.Capabilities;

Converts this options instance to a webdriver.Capabilities object.
Parameter opt_capabilities
The capabilities to merge these options into, if any. {!webdriver.Capabilities} The capabilities.

method toJSON

toJSON: () => IOptionsValues;

Converts this instance to its JSON wire protocol representation. Note this function is an implementation not intended for general use. {{args: !Array., binary: (string|undefined), detach: boolean, extensions: !Array., localState: (Object|undefined), logFile: (string|undefined), prefs: (Object|undefined)}} The JSON wire protocol representation of this instance.

class ServiceBuilder

class ServiceBuilder {}

Creates remote.DriverService instances that manage a ChromeDriver server.

constructor

constructor(opt_exe?: string);

Parameter opt_exe
Path to the server executable to use. If omitted, the builder will attempt to locate the chromedriver on the current PATH.
Throws
{Error} If provided executable does not exist, or the chromedriver cannot be found on the PATH.

method build

build: () => any;

Creates a new DriverService using this instance's current configuration. {remote.DriverService} A new driver service using this instance's current configuration.
Throws
{Error} If the driver exectuable was not specified and a default could not be found on the current PATH.

method enableVerboseLogging

enableVerboseLogging: () => ServiceBuilder;

Enables verbose logging. {!ServiceBuilder} A self reference.

method loggingTo

loggingTo: (path: string) => ServiceBuilder;

Sets the path of the log file the driver should log to. If a log file is not specified, the driver will log to stderr.
Parameter path
Path of the log file to use. {!ServiceBuilder} A self reference.

method setAdbPort

setAdbPort: (port: number) => ServiceBuilder;

Sets which port adb is listening to. _The ChromeDriver will connect to adb if an is requested, but adb **must** be started beforehand._
Parameter port
Which port adb is running on. {!ServiceBuilder} A self reference.

method setNumHttpThreads

setNumHttpThreads: (n: number) => ServiceBuilder;

Sets the number of threads the driver should use to manage HTTP requests. By default, the driver will use 4 threads.
Parameter n
The number of threads to use. {!ServiceBuilder} A self reference.

method setStdio

setStdio: { (config: string): ServiceBuilder; (config: any[]): ServiceBuilder };

Defines the stdio configuration for the driver service. See for more information.
Parameter config
The configuration to use. {!ServiceBuilder} A self reference.

method setUrlBasePath

setUrlBasePath: (path: string) => ServiceBuilder;

Sets the base path for WebDriver REST commands (e.g. "/wd/hub"). By default, the driver will accept commands relative to "/".
Parameter path
The base path to use. {!ServiceBuilder} A self reference.

method usingPort

usingPort: (port: number) => ServiceBuilder;

Sets the port to start the ChromeDriver on.
Parameter port
The port to use, or 0 for any free port. {!ServiceBuilder} A self reference.
Throws
{Error} If the port is invalid.

method withEnvironment

withEnvironment: (env: { [key: string]: string }) => ServiceBuilder;

Defines the environment to start the server under. This settings will be inherited by every browser session started by the server.
Parameter env
The environment to use. {!ServiceBuilder} A self reference.

interface IOptionsValues

interface IOptionsValues {}

property args

args: string[];

property binary

binary?: string;

property detach

detach: boolean;

property extensions

extensions: string[];

property localState

localState?: any;

property logFile

logFile?: string;

property prefs

prefs?: any;

interface IPerfLoggingPrefs

interface IPerfLoggingPrefs {}

property bufferUsageReportingInterval

bufferUsageReportingInterval: number;

property enableNetwork

enableNetwork: boolean;

property enablePage

enablePage: boolean;

property enableTimeline

enableTimeline: boolean;

property tracingCategories

tracingCategories: string;

namespace selenium-webdriver/executors

module 'selenium-webdriver/executors' {}

function createExecutor

createExecutor: {
    (url: string): webdriver.CommandExecutor;
    (url: webdriver.promise.Promise<string>): webdriver.CommandExecutor;
};

Creates a command executor that uses WebDriver's JSON wire protocol.
Parameter url
The server's URL, or a promise that will resolve to that URL.
Returns
{!webdriver.CommandExecutor} The new command executor.

namespace selenium-webdriver/firefox

module 'selenium-webdriver/firefox' {}

class Binary

class Binary {}

Manages a Firefox subprocess configured for use with WebDriver.

constructor

constructor(opt_exe?: string);

Parameter opt_exe
Path to the Firefox binary to use. If not specified, will attempt to locate Firefox on the current system.

method addArguments

addArguments: (...var_args: string[]) => void;

Add arguments to the command line used to start Firefox.
Parameter var_args
Either the arguments to add as varargs, or the arguments as an array.

method kill

kill: () => webdriver.promise.Promise<void>;

Kills the managed Firefox process. {!promise.Promise} A promise for when the process has terminated.

method launch

launch: (profile: string) => webdriver.promise.Promise<any>;

Launches Firefox and eturns a promise that will be fulfilled when the process terminates.
Parameter profile
Path to the profile directory to use. {!promise.Promise.<!exec.Result>} A promise for the process result.
Throws
{Error} If this instance has already been started.

class Driver

class Driver extends webdriver.WebDriver {}

A WebDriver client for Firefox.
{webdriver.WebDriver}

constructor

constructor(
    opt_config?: webdriver.Capabilities,
    opt_flow?: webdriver.promise.ControlFlow
);

Parameter opt_config
The configuration options for this driver, specified as either an Options or webdriver.Capabilities, or as a raw hash object.
Parameter opt_flow
The flow to schedule commands through. Defaults to the active flow object.

constructor

constructor(opt_config?: any, opt_flow?: webdriver.promise.ControlFlow);

class Options

class Options {}

Configuration options for the FirefoxDriver.

constructor

constructor();

method setBinary

setBinary: { (binary: string): Options; (binary: Binary): Options };

Sets the binary to use. The binary may be specified as the path to a Firefox executable, or as a Binary object.
Parameter binary
The binary to use. {!Options} A self reference.

method setLoggingPreferences

setLoggingPreferences: (prefs: webdriver.logging.Preferences) => Options;

Sets the logging preferences for the new session.
Parameter prefs
The logging preferences. {!Options} A self reference.

method setProfile

setProfile: { (profile: string): Options; (profile: Profile): Options };

Sets the profile to use. The profile may be specified as a Profile object or as the path to an existing Firefox profile to use as a template.
Parameter profile
The profile to use. {!Options} A self reference.

method setProxy

setProxy: (proxy: webdriver.ProxyConfig) => Options;

Sets the proxy to use.
Parameter proxy
The proxy configuration to use. {!Options} A self reference.

method toCapabilities

toCapabilities: (opt_remote?: any) => webdriver.Capabilities;

Converts these options to a webdriver.Capabilities instance.
{!webdriver.Capabilities} A new capabilities object.

class Profile

class Profile {}

Models a Firefox proifle directory for use with the FirefoxDriver. The directory uses an in-memory model until is called.

constructor

constructor(opt_dir?: string);

Parameter opt_dir
Path to an existing Firefox profile directory to use a template for this profile. If not specified, a blank profile will be used.

method acceptUntrustedCerts

acceptUntrustedCerts: () => boolean;

{boolean} Whether the FirefoxDriver is configured to automatically accept untrusted SSL certificates.

method addExtension

addExtension: (extension: string) => void;

Registers an extension to be included with this profile.
Parameter extension
Path to the extension to include, as either an unpacked extension directory or the path to a xpi file.

method assumeUntrustedCertIssuer

assumeUntrustedCertIssuer: () => boolean;

{boolean} Whether to assume untrusted certs come from untrusted issuers.

method encode

encode: () => webdriver.promise.Promise<string>;

Encodes this profile as a zipped, base64 encoded directory. {!promise.Promise.} A promise for the encoded profile.

method getPort

getPort: () => number;

{number} The port this profile is currently configured to use, or 0 if the port will be selected at random when the profile is written to disk.

method getPreference

getPreference: (key: string) => any;

Returns the currently configured value of a profile preference. This does not include any defaults defined in the profile's template directory user.js file (if a template were specified on construction).
Parameter key
The desired preference. {(string|number|boolean|undefined)} The current value of the requested preference.

method nativeEventsEnabled

nativeEventsEnabled: () => boolean;

Returns whether native events are enabled in this profile. {boolean} .

method setAcceptUntrustedCerts

setAcceptUntrustedCerts: (value: boolean) => void;

Sets whether the FirefoxDriver should automatically accept untrusted SSL certificates.
Parameter value
.

method setAssumeUntrustedCertIssuer

setAssumeUntrustedCertIssuer: (value: boolean) => void;

Sets whether to assume untrusted certificates come from untrusted issuers.
Parameter value
.

method setNativeEventsEnabled

setNativeEventsEnabled: (enabled: boolean) => void;

Sets whether to use native events with this profile.
Parameter enabled
.

method setPort

setPort: (port: number) => void;

Sets the port to use for the WebDriver extension loaded by this profile.
Parameter port
The desired port, or 0 to use any free port.

method setPreference

setPreference: {
    (key: string, value: string): void;
    (key: string, value: number): void;
    (key: string, value: boolean): void;
};

Sets a desired preference for this profile.
Parameter key
The preference key.
Parameter value
The preference value.
Throws
{Error} If attempting to set a frozen preference.

method writeToDisk

writeToDisk: (
    opt_excludeWebDriverExt?: boolean
) => webdriver.promise.Promise<string>;

Writes this profile to disk.
Parameter opt_excludeWebDriverExt
Whether to exclude the WebDriver extension from the generated profile. Used to reduce the size of an since the server will always install the extension itself. {!promise.Promise.} A promise for the path to the new profile directory.

namespace selenium-webdriver/testing

module 'selenium-webdriver/testing' {}

function after

after: (fn: Function) => void;

function afterEach

afterEach: (fn: Function) => void;

function before

before: (fn: Function) => void;

function beforeEach

beforeEach: (fn: Function) => void;

function describe

describe: (name: string, fn: Function) => void;

Registers a new test suite.
Parameter name
The suite name.
Parameter fn
The suite function, or to define a pending test suite.

function iit

iit: (name: string, fn: Function) => void;

An alias for that flags the test as the only one that should be run within the current suite.
Parameter name
The test name.
Parameter fn
The test function, or to define a pending test case.

function it

it: (name: string, fn: Function) => void;

Add a test to the current suite.
Parameter name
The test name.
Parameter fn
The test function, or to define a pending test case.

function xdescribe

xdescribe: (name: string, fn: Function) => void;

Defines a suppressed test suite.
Parameter name
The suite name.
Parameter fn
The suite function, or to define a pending test suite.

function xit

xit: (name: string, fn: Function) => void;

Adds a test to the current suite while suppressing it so it is not run.
Parameter name
The test name.
Parameter fn
The test function, or to define a pending test case.

namespace stream

module 'stream' {}

class Duplex

class Duplex extends Readable implements NodeJS.ReadWriteStream {}

constructor

constructor(opts?: DuplexOptions);

property writable

writable: boolean;

method end

end: {
    (): void;
    (chunk: any, cb?: Function): void;
    (chunk: any, encoding?: string, cb?: Function): void;
};

method write

write: {
    (chunk: any, cb?: Function): boolean;
    (chunk: any, encoding?: string, cb?: Function): boolean;
};

class PassThrough

class PassThrough extends Transform {}

class Readable

class Readable extends events.EventEmitter implements NodeJS.ReadableStream {}

constructor

constructor(opts?: ReadableOptions);

property readable

readable: boolean;

method pause

pause: () => void;

method pipe

pipe: <T extends NodeJS.WritableStream>(
    destination: T,
    options?: { end?: boolean }
) => T;

method push

push: (chunk: any, encoding?: string) => boolean;

method read

read: (size?: number) => any;

method resume

resume: () => void;

method setEncoding

setEncoding: (encoding: string) => void;

method unpipe

unpipe: <T extends NodeJS.WritableStream>(destination?: T) => void;

method unshift

unshift: (chunk: any) => void;

method wrap

wrap: (oldStream: NodeJS.ReadableStream) => NodeJS.ReadableStream;

class Stream

class Stream extends events.EventEmitter {}

method pipe

pipe: <T extends NodeJS.WritableStream>(
    destination: T,
    options?: { end?: boolean }
) => T;

class Transform

class Transform extends events.EventEmitter implements NodeJS.ReadWriteStream {}

constructor

constructor(opts?: TransformOptions);

property readable

readable: boolean;

property writable

writable: boolean;

method end

end: {
    (): void;
    (chunk: any, cb?: Function): void;
    (chunk: any, encoding?: string, cb?: Function): void;
};

method pause

pause: () => void;

method pipe

pipe: <T extends NodeJS.WritableStream>(
    destination: T,
    options?: { end?: boolean }
) => T;

method push

push: (chunk: any, encoding?: string) => boolean;

method read

read: (size?: number) => any;

method resume

resume: () => void;

method setEncoding

setEncoding: (encoding: string) => void;

method unpipe

unpipe: <T extends NodeJS.WritableStream>(destination?: T) => void;

method unshift

unshift: (chunk: any) => void;

method wrap

wrap: (oldStream: NodeJS.ReadableStream) => NodeJS.ReadableStream;

method write

write: {
    (chunk: any, cb?: Function): boolean;
    (chunk: any, encoding?: string, cb?: Function): boolean;
};

class Writable

class Writable extends events.EventEmitter implements NodeJS.WritableStream {}

constructor

constructor(opts?: WritableOptions);

property writable

writable: boolean;

method end

end: {
    (): void;
    (chunk: any, cb?: Function): void;
    (chunk: any, encoding?: string, cb?: Function): void;
};

method write

write: {
    (chunk: any, cb?: Function): boolean;
    (chunk: any, encoding?: string, cb?: Function): boolean;
};

interface DuplexOptions

interface DuplexOptions extends ReadableOptions, WritableOptions {}

property allowHalfOpen

allowHalfOpen?: boolean;

interface ReadableOptions

interface ReadableOptions {}

property encoding

encoding?: string;

property highWaterMark

highWaterMark?: number;

property objectMode

objectMode?: boolean;

interface TransformOptions

interface TransformOptions extends ReadableOptions, WritableOptions {}

interface WritableOptions

interface WritableOptions {}

property decodeStrings

decodeStrings?: boolean;

property highWaterMark

highWaterMark?: number;

property objectMode

objectMode?: boolean;

namespace string_decoder

module 'string_decoder' {}

variable StringDecoder

var StringDecoder: new (encoding: string) => NodeStringDecoder;

interface NodeStringDecoder

interface NodeStringDecoder {}

method detectIncompleteChar

detectIncompleteChar: (buffer: Buffer) => number;

method write

write: (buffer: Buffer) => string;

namespace tls

module 'tls' {}

variable CLIENT_RENEG_LIMIT

var CLIENT_RENEG_LIMIT: number;

variable CLIENT_RENEG_WINDOW

var CLIENT_RENEG_WINDOW: number;

function connect

connect: {
    (options: TlsOptions, secureConnectionListener?: () => void): ClearTextStream;
    (
        port: number,
        host?: string,
        options?: ConnectionOptions,
        secureConnectListener?: () => void
    ): ClearTextStream;
    (
        port: number,
        options?: ConnectionOptions,
        secureConnectListener?: () => void
    ): ClearTextStream;
};

function createSecureContext

createSecureContext: (details: SecureContextOptions) => SecureContext;

function createSecurePair

createSecurePair: (
    credentials?: crypto.Credentials,
    isServer?: boolean,
    requestCert?: boolean,
    rejectUnauthorized?: boolean
) => SecurePair;

function createServer

createServer: (
    options: TlsOptions,
    secureConnectionListener?: (cleartextStream: ClearTextStream) => void
) => Server;

interface ClearTextStream

interface ClearTextStream extends stream.Duplex {}

property address

address: {
    port: number;
    family: string;
    address: string;
};

property authorizationError

authorizationError: Error;

property authorized

authorized: boolean;

property getCipher

getCipher: {
    name: string;
    version: string;
};

property remoteAddress

remoteAddress: string;

property remotePort

remotePort: number;

method getPeerCertificate

getPeerCertificate: () => any;

interface ConnectionOptions

interface ConnectionOptions {}

property ca

ca?: any;

property cert

cert?: any;

property host

host?: string;

property key

key?: any;

property NPNProtocols

NPNProtocols?: any;

property passphrase

passphrase?: string;

property pfx

pfx?: any;

property port

port?: number;

property rejectUnauthorized

rejectUnauthorized?: boolean;

property servername

servername?: string;

property socket

socket?: net.Socket;

interface SecureContext

interface SecureContext {}

property context

context: any;

interface SecureContextOptions

interface SecureContextOptions {}

property ca

ca?: any;

property cert

cert?: any;

property ciphers

ciphers?: string;

property crl

crl?: any;

property honorCipherOrder

honorCipherOrder?: boolean;

property key

key?: any;

property passphrase

passphrase?: string;

property pfx

pfx?: any;

interface SecurePair

interface SecurePair {}

property cleartext

cleartext: any;

property encrypted

encrypted: any;

interface Server

interface Server extends net.Server {}

property connections

connections: number;

property maxConnections

maxConnections: number;

method addContext

addContext: (
    hostName: string,
    credentials: { key: string; cert: string; ca: string }
) => void;

method address

address: () => { port: number; family: string; address: string };

method close

close: () => Server;

method listen

listen: {
    (
        port: number,
        host?: string,
        backlog?: number,
        listeningListener?: Function
    ): Server;
    (path: string, listeningListener?: Function): Server;
    (handle: any, listeningListener?: Function): Server;
    (port: number, host?: string, callback?: Function): Server;
};

interface TlsOptions

interface TlsOptions {}

property ca

ca?: any;

property cert

cert?: any;

property ciphers

ciphers?: string;

property crl

crl?: any;

property honorCipherOrder

honorCipherOrder?: any;

property host

host?: string;

property key

key?: any;

property NPNProtocols

NPNProtocols?: any;

property passphrase

passphrase?: string;

property pfx

pfx?: any;

property port

port?: number;

property rejectUnauthorized

rejectUnauthorized?: boolean;

property requestCert

requestCert?: boolean;

property SNICallback

SNICallback?: (servername: string) => any;

namespace tty

module 'tty' {}

function isatty

isatty: (fd: number) => boolean;

interface ReadStream

interface ReadStream extends net.Socket {}

property isRaw

isRaw: boolean;

method setRawMode

setRawMode: (mode: boolean) => void;

interface WriteStream

interface WriteStream extends net.Socket {}

property columns

columns: number;

property rows

rows: number;

namespace url

module 'url' {}

function format

format: (url: Url) => string;

function parse

parse: (
    urlStr: string,
    parseQueryString?: boolean,
    slashesDenoteHost?: boolean
) => Url;

function resolve

resolve: (from: string, to: string) => string;

interface Url

interface Url {}

property auth

auth?: string;

property hash

hash?: string;

property host

host?: string;

property hostname

hostname?: string;

property href

href?: string;

property path

path?: string;

property pathname

pathname?: string;

property port

port?: string;

property protocol

protocol?: string;

property query

query?: any;

property search

search?: string;

property slashes

slashes?: boolean;

namespace util

module 'util' {}

function debug

debug: (string: string) => void;

function debuglog

debuglog: (key: string) => (msg: string, ...param: any[]) => void;

function error

error: (...param: any[]) => void;

function format

format: (format: any, ...param: any[]) => string;

function inherits

inherits: (constructor: any, superConstructor: any) => void;

function inspect

inspect: {
    (object: any, showHidden?: boolean, depth?: number, color?: boolean): string;
    (object: any, options: InspectOptions): string;
};

function isArray

isArray: (object: any) => boolean;

function isDate

isDate: (object: any) => boolean;

function isError

isError: (object: any) => boolean;

function isRegExp

isRegExp: (object: any) => boolean;

function log

log: (string: string) => void;

function print

print: (...param: any[]) => void;

function puts

puts: (...param: any[]) => void;

interface InspectOptions

interface InspectOptions {}

property colors

colors?: boolean;

property customInspect

customInspect?: boolean;

property depth

depth?: number;

property showHidden

showHidden?: boolean;

namespace vm

module 'vm' {}

function createContext

createContext: (initSandbox?: Context) => Context;

function createScript

createScript: (code: string, filename?: string) => Script;

function runInContext

runInContext: (code: string, context: Context, filename?: string) => void;

function runInNewContext

runInNewContext: (code: string, sandbox?: Context, filename?: string) => void;

function runInThisContext

runInThisContext: (code: string, filename?: string) => void;

interface Context

interface Context {}

interface Script

interface Script {}

method runInNewContext

runInNewContext: (sandbox?: Context) => void;

method runInThisContext

runInThisContext: () => void;

namespace zlib

module 'zlib' {}

variable Z_ASCII

var Z_ASCII: number;

variable Z_BEST_COMPRESSION

var Z_BEST_COMPRESSION: number;

variable Z_BEST_SPEED

var Z_BEST_SPEED: number;

variable Z_BINARY

var Z_BINARY: number;

variable Z_BLOCK

var Z_BLOCK: number;

variable Z_BUF_ERROR

var Z_BUF_ERROR: number;

variable Z_DATA_ERROR

var Z_DATA_ERROR: number;

variable Z_DEFAULT_COMPRESSION

var Z_DEFAULT_COMPRESSION: number;

variable Z_DEFAULT_STRATEGY

var Z_DEFAULT_STRATEGY: number;

variable Z_DEFLATED

var Z_DEFLATED: number;

variable Z_ERRNO

var Z_ERRNO: number;

variable Z_FILTERED

var Z_FILTERED: number;

variable Z_FINISH

var Z_FINISH: number;

variable Z_FIXED

var Z_FIXED: number;

variable Z_FULL_FLUSH

var Z_FULL_FLUSH: number;

variable Z_HUFFMAN_ONLY

var Z_HUFFMAN_ONLY: number;

variable Z_MEM_ERROR

var Z_MEM_ERROR: number;

variable Z_NEED_DICT

var Z_NEED_DICT: number;

variable Z_NO_COMPRESSION

var Z_NO_COMPRESSION: number;

variable Z_NO_FLUSH

var Z_NO_FLUSH: number;

variable Z_NULL

var Z_NULL: number;

variable Z_OK

var Z_OK: number;

variable Z_PARTIAL_FLUSH

var Z_PARTIAL_FLUSH: number;

variable Z_RLE

var Z_RLE: number;

variable Z_STREAM_END

var Z_STREAM_END: number;

variable Z_STREAM_ERROR

var Z_STREAM_ERROR: number;

variable Z_SYNC_FLUSH

var Z_SYNC_FLUSH: number;

variable Z_TEXT

var Z_TEXT: number;

variable Z_TREES

var Z_TREES: number;

variable Z_UNKNOWN

var Z_UNKNOWN: number;

variable Z_VERSION_ERROR

var Z_VERSION_ERROR: number;

function createDeflate

createDeflate: (options?: ZlibOptions) => Deflate;

function createDeflateRaw

createDeflateRaw: (options?: ZlibOptions) => DeflateRaw;

function createGunzip

createGunzip: (options?: ZlibOptions) => Gunzip;

function createGzip

createGzip: (options?: ZlibOptions) => Gzip;

function createInflate

createInflate: (options?: ZlibOptions) => Inflate;

function createInflateRaw

createInflateRaw: (options?: ZlibOptions) => InflateRaw;

function createUnzip

createUnzip: (options?: ZlibOptions) => Unzip;

function deflate

deflate: (buf: Buffer, callback: (error: Error, result: any) => void) => void;

function deflateRaw

deflateRaw: (buf: Buffer, callback: (error: Error, result: any) => void) => void;

function deflateRawSync

deflateRawSync: (buf: Buffer, options?: ZlibOptions) => any;

function deflateSync

deflateSync: (buf: Buffer, options?: ZlibOptions) => any;

function gunzip

gunzip: (buf: Buffer, callback: (error: Error, result: any) => void) => void;

function gunzipSync

gunzipSync: (buf: Buffer, options?: ZlibOptions) => any;

function gzip

gzip: (buf: Buffer, callback: (error: Error, result: any) => void) => void;

function gzipSync

gzipSync: (buf: Buffer, options?: ZlibOptions) => any;

function inflate

inflate: (buf: Buffer, callback: (error: Error, result: any) => void) => void;

function inflateRaw

inflateRaw: (buf: Buffer, callback: (error: Error, result: any) => void) => void;

function inflateRawSync

inflateRawSync: (buf: Buffer, options?: ZlibOptions) => any;

function inflateSync

inflateSync: (buf: Buffer, options?: ZlibOptions) => any;

function unzip

unzip: (buf: Buffer, callback: (error: Error, result: any) => void) => void;

function unzipSync

unzipSync: (buf: Buffer, options?: ZlibOptions) => any;

interface Deflate

interface Deflate extends stream.Transform {}

interface DeflateRaw

interface DeflateRaw extends stream.Transform {}

interface Gunzip

interface Gunzip extends stream.Transform {}

interface Gzip

interface Gzip extends stream.Transform {}

interface Inflate

interface Inflate extends stream.Transform {}

interface InflateRaw

interface InflateRaw extends stream.Transform {}

interface Unzip

interface Unzip extends stream.Transform {}

interface ZlibOptions

interface ZlibOptions {}

property chunkSize

chunkSize?: number;

property dictionary

dictionary?: any;

property level

level?: number;

property memLevel

memLevel?: number;

property strategy

strategy?: number;

property windowBits

windowBits?: number;

Package Files (7)

Dependencies (0)

No dependencies.

Dev Dependencies (0)

No dev dependencies.

Peer Dependencies (4)

Badge

To add a badge like this oneto your package's README, use the codes available below.

You may also use Shields.io to create a custom badge linking to https://www.jsdocs.io/package/angular2.

Markdown

[![jsDocs.io](https://img.shields.io/badge/jsDocs.io-reference-blue)](https://www.jsdocs.io/package/angular2)

HTML

<a href="https://www.jsdocs.io/package/angular2"><img src="https://img.shields.io/badge/jsDocs.io-reference-blue" alt="jsDocs.io"></a>

Updated 2 years ago.
Package analyzed in 30897 ms.
Missing or incorrect documentation? Open an issue for this package.