angular2

angular2

Version 2.0.0-beta.21
Published 7 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 {}