flow/lib/node.js at v0.36 · dominictobias/flow

Repository navigation

8000

/**

* This source code is licensed under the BSD-style license found in the

* LICENSE file in the "flow" directory of this source tree. An additional grant

* of patent rights can be found in the PATENTS file in the same directory.

interface ErrnoError extends Error {

errno?: number;

code?: string;

path?: string;

syscall?: string;

}

type buffer$NonBufferEncoding =

'hex' | 'HEX' |

'utf8' | 'UTF8' | 'utf-8' | 'UTF-8' |

'ascii' | 'ASCII' |

'binary' | 'BINARY' |

'base64' | 'BASE64' |

'ucs2' | 'UCS2' | 'ucs-2' | 'UCS-2' |

'utf16le' | 'UTF16LE' | 'utf-16le' | 'UTF-16LE';

type buffer$Encoding = buffer$NonBufferEncoding | 'buffer'

type buffer$ToJSONRet = { type: string, data: Array<number> }

declare class Buffer {

constructor(

value: Array<number> | number | string | Buffer | ArrayBuffer,

encoding?: buffer$Encoding

): void;

[i: number]: number;

length: number;

compare(otherBuffer: Buffer): number;

copy(targetBuffer: Buffer, targetStart?: number, sourceStart?: number, sourceEnd?: number): number;

entries(): Iterator<[number, number]>;

equals(otherBuffer: Buffer): boolean;

fill(value: string | number, offset?: number, end?: number): void;

includes(

value: string | Buffer | number,

offsetOrEncoding?: number | buffer$Encoding,

encoding?: buffer$Encoding

): boolean;

indexOf(

value: string | Buffer | number,

offsetOrEncoding?: number | buffer$Encoding,

encoding?: buffer$Encoding

): number;

inspect(): string;

keys(): Iterator<number>,

lastIndexOf(

value: string | Buffer | number,

offsetOrEncoding?: number | buffer$Encoding,

encoding?: buffer$Encoding

): number;

readDoubleBE(offset: number, noAssert?: boolean): number;

readDoubleLE(offset: number, noAssert?: boolean): number;

readFloatBE(offset: number, noAssert?: boolean): number;

readFloatLE(offset: number, noAssert?: boolean): number;

readInt16BE(offset: number, noAssert?: boolean): number;

readInt16LE(offset: number, noAssert?: boolean): number;

readInt32BE(offset: number, noAssert?: boolean): number;

readInt32LE(offset: number, noAssert?: boolean): number;

readInt8(offset: number, noAssert?: boolean): number;

readIntBE(offset: number, byteLength: number, noAssert?: boolean): number;

readIntLE(offset: number, byteLength: number, noAssert?: boolean): number;

readUInt16BE(offset: number, noAssert?: boolean): number;

readUInt16LE(offset: number, noAssert?: boolean): number;

readUInt32BE(offset: number, noAssert?: boolean): number;

readUInt32LE(offset: number, noAssert?: boolean): number;

readUInt8(offset: number, noAssert?: boolean): number;

readUIntBE(offset: number, byteLength: number, noAssert?: boolean): number;

readUIntLE(offset: number, byteLength: number, noAssert?: boolean): number;

slice(start?: number, end?: number): Buffer;

swap16(): Buffer;

swap32(): Buffer;

toJSON(): buffer$ToJSONRet;

toString(encoding?: buffer$Encoding, start?: number, end?: number): string;

values(): Iterator<number>;

write(string: string, offset?: number, length?: number, encoding?: buffer$Encoding): void;

writeDoubleBE(value: number, offset: number, noAssert?: boolean): number;

writeDoubleLE(value: number, offset: number, noAssert?: boolean): number;

writeFloatBE(value: number, offset: number, noAssert?: boolean): number;

writeFloatLE(value: number, offset: number, noAssert?: boolean): number;

writeInt16BE(value: number, offset: number, noAssert?: boolean): number;

writeInt16LE(value: number, offset: number, noAssert?: boolean): number;

writeInt32BE(value: number, offset: number, noAssert?: boolean): number;

writeInt32LE(value: number, offset: number, noAssert?: boolean): number;

writeInt8(value: number, offset: number, noAssert?: boolean): number;

writeIntBE(value: number, offset: number, byteLength: number, noAssert?: boolean): number;

writeIntLE(value: number, offset: number, byteLength: number, noAssert?: boolean): number;

writeUInt16BE(value: number, offset: number, noAssert?: boolean): number;

writeUInt16LE(value: number, offset: number, noAssert?: boolean): number;

writeUInt32BE(value: number, offset: number, noAssert?: boolean): number;

writeUInt32LE(value: number, offset: number, noAssert?: boolean): number;

writeUInt8(value: number, offset: number, noAssert?: boolean): number;

writeUIntBE(value: number, offset: number, byteLength: number, noAssert?: boolean): number;

writeUIntLE(value: number, offset: number, byteLength: number, noAssert?: boolean): number;

static alloc(size: number, fill?: string | number, encoding?: buffer$Encoding): Buffer;

static allocUnsafe(size: number): Buffer;

static allocUnsafeSlow(size: number): Buffer;

static byteLength(string: string | Buffer | $TypedArray | DataView | ArrayBuffer, encoding?: buffer$Encoding): number;

static compare(buf1: Buffer, buf2: Buffer): number;

static concat(list: Array<Buffer>, totalLength?: number): Buffer;

// `UNUSED` argument strictly enforces arity to enable overloading this

// function with 1-arg and 2-arg variants.

static from(value: Array<number>, UNUSED: void): Buffer;

static from(value: Buffer, UNUSED: void): Buffer;

static from(value: string, encoding?: buffer$Encoding): Buffer;

static from(value: ArrayBuffer, byteOffset?: number, length?: number): Buffer;

static isBuffer(obj: any): boolean;

static isEncoding(encoding: string): boolean;

}

declare module "buffer" {

declare var INSPECT_MAX_BYTES: number;

}

type child_process$execOpts = {

cwd?: string;

env?: Object;

encoding?: string;

shell?: string;

timeout?: number;

maxBuffer?: number;

killSignal?: string;

uid?: number;

gid?: number;

};

declare class child_process$Error extends Error {

code: number,

signal: ?string,

}

type child_process$execCallback = (error: ?child_process$Error, stdout: string | Buffer, stderr: string | Buffer) => void;

type child_process$execSyncOpts = {

cwd?: string;

input?: string | Buffer;

stdio?: Array<any>;

env?: Object;

uid?: number;

gid?: number;

timeout?: number;

killSignal?: string;

maxBuffer?: number;

encoding?: string;

};

type child_process$execFileOpts = {

cwd?: string;

env?: Object;

encoding?: string;

timeout?: number;

maxBuffer?: number;

killSignal?: string;

uid?: number;

gid?: number;

};

type child_process$execFileCallback = (error: ?child_process$Error, stdout: Buffer, stderr: Buffer) => void;

type child_process$forkOpts = {

cwd?: string;

env?: Object;

execPath?: string;

execArgv?: Array<string>;

silent?: boolean;

stdio?: Array<any>;

uid?: number;

gid?: number;

};

type child_process$Handle = any; // TODO

type child_process$spawnOpts = {

cwd?: string;

env?: Object;

stdio?: string | Array<any>;

detached?: boolean;

uid?: number;

gid?: number;

};

type child_process$spawnRet = {

pid: number;

output: Array<any>;

stdout: Buffer | string;

stderr: Buffer | string;

status: number;

signal: string;

error: Error;

};

declare class child_process$ChildProcess extends events$EventEmitter {

stdin: stream$Writable;

stdout: stream$Readable;

stderr: stream$Readable;

pid: number;

connected: boolean;

disconnect(): void;

kill(signal?: string): void;

send(message: Object, sendHandle?: child_process$Handle): boolean;

}

declare module "child_process" {

declare var ChildProcess: typeof child_process$ChildProcess;

declare function exec(

command: string,

optionsOrCallback?: child_process$execOpts | child_process$execCallback,

callback?: child_process$execCallback

): child_process$ChildProcess;

declare function execSync(

command: string,

options: {encoding: buffer$NonBufferEncoding} & child_process$execSyncOpts

): string;

declare function execSync(

command: string,

options?: child_process$execSyncOpts

): Buffer;

declare function execFile(

file: string,

argsOrOptionsOrCallback?:

Array<string> | child_process$execFileOpts | child_process$execFileCallback,

optionsOrCallback?: child_process$execFileOpts | child_process$execFileCallback,

callback?: child_process$execFileCallback

): child_process$ChildProcess;

declare function execFileSync(

command: string,

argsOrOptions?: Array<string> | child_process$execFileOpts,

options?: child_process$execFileOpts

): Buffer | string;

declare function fork(

modulePath: string,

argsOrOptions?: Array<string> | child_process$forkOpts,

options?: child_process$forkOpts

): child_process$ChildProcess;

declare function spawn(

command: string,

argsOrOptions?: Array<string> | child_process$spawnOpts,

options?: child_process$spawnOpts

): child_process$ChildProcess;

declare function spawnSync(

command: string,

argsOrOptions?: Array<string> | child_process$spawnOpts,

options?: child_process$spawnOpts

): child_process$spawnRet;

}

type cluster$Worker = {

id: string;

process: child_process$ChildProcess;

suicide: boolean;

disconnect(): void;

kill(signal?: string): void;

send(message: Object, sendHandle?: child_process$Handle): boolean;

}

declare module "cluster" {

declare var isMaster: boolean;

declare var isWorker: boolean;

declare var settings: {

args: Array<string>;

exec: string;

execArgv: Array<string>;

silent: boolean;

};

declare var worker: cluster$Worker;

declare var workers: Object;

declare function disconnect(callback?: () => void): void;

declare function fork(env?: Object): cluster$Worker;

declare function setupMaster(settings?: Object): void;

}

type crypto$createCredentialsDetails = any; // TODO

declare class crypto$Cipher extends stream$Duplex {

final(output_encoding: 'binary' | 'base64' | 'hex'): string;

final(output_encoding: void): Buffer;

getAuthTag(): Buffer;

setAAD(buffer: Buffer): void;

setAuthTag(buffer: Buffer): void;

setAutoPadding(auto_padding?: boolean): crypto$Cipher;

update(

data: string,

input_encoding: 'utf8'| 'ascii' | 'binary',

output_encoding: 'binary' | 'base64' | 'hex'

): string;

update(

data: string,

input_encoding: 'utf8'| 'ascii' | 'binary',

output_encoding: void

): Buffer;

update(

data: Buffer,

input_encoding: void,

output_encoding: 'binary' | 'base64' | 'hex'

): string;

update(

data: Buffer,

input_encoding: void,

output_encoding: void

): Buffer;

}

type crypto$Credentials = {

// TODO

}

type crypto$DiffieHellman = {

computeSecret(

other_public_key: string,

input_encoding?: string,

output_encoding?: string

): any;

generateKeys(encoding?: string): any;

getGenerator(encoding?: string): any;

getPrime(encoding?: string): any;

getPrivateKey(encoding?: string): any;

getPublicKey(encoding?: string): any;

setPrivateKey(private_key: any, encoding?: string): void;

setPublicKey(public_key: any, encoding?: string): void;

}

declare class crypto$Decipher extends stream$Duplex {

final(output_encoding: 'binary' | 'base64' | 'hex'): string;

final(output_encoding: void): Buffer;

getAuthTag(): Buffer;

setAAD(buffer: Buffer): void;

setAuthTag(buffer: Buffer): void;

setAutoPadding(auto_padding?: boolean): crypto$Cipher;

update(

data: string,

input_encoding: 'utf8'| 'ascii' | 'binary',

output_encoding: 'binary' | 'base64' | 'hex'

): string;

update(

data: string,

input_encoding: 'utf8'| 'ascii' | 'binary',

output_encoding: void

): Buffer;

update(

data: Buffer,

input_encoding: void,

output_encoding: 'binary' | 'base64' | 'hex'

): string;

update(

data: Buffer,

input_encoding: void,

output_encoding: void

): Buffer;

}

declare class crypto$Hash extends stream$Duplex {

digest(encoding: 'hex' | 'binary' | 'base64'): string;

digest(encoding: void): Buffer;

update(data: Buffer, input_encoding?: void): crypto$Hash;

update(data: string, input_encoding?: 'utf8' | 'ascii' | 'binary'): crypto$Hash;

}

declare class crypto$Hmac extends stream$Duplex {

digest(encoding: 'hex' | 'binary' | 'base64'): string;

digest(encoding: void): Buffer;

update(data: Buffer, input_encoding?: void): crypto$Hmac;

update(data: string, input_encoding?: 'utf8' | 'ascii' | 'binary'): crypto$Hmac;

}

type crypto$Sign$private_key = string | {

key: string,

passphrase: string,

}

declare class crypto$Sign extends stream$Writable {

sign(

private_key: crypto$Sign$private_key,

output_format: 'binary' | 'hex' | 'base64'

): string;

sign(

private_key: crypto$Sign$private_key,

output_format: void

): Buffer;

update(data: Buffer, input_encoding?: void): crypto$Sign;

update(data: string, input_encoding?: 'utf8' | 'ascii' | 'binary'): crypto$Sign;

}

declare class crypto$Verify extends stream$Writable {

update(data: Buffer, input_encoding?: void): crypto$Verify;

update(data: string, input_encoding?: 'utf8' | 'ascii' | 'binary'): crypto$Verify;

verify(

object: string,

signature: string,

signature_format: 'binary' | 'hex' | 'base64'

): boolean;

verify(object: string, signature: Buffer, signature_format: void): boolean;

}

declare module "crypto" {

declare var DEFAULT_ENCODING: string;

declare function createCipher(algorithm: string, password: string | Buffer): crypto$Cipher;

declare function createCipheriv(

algorithm: string,

key: string | Buffer,

iv: string | Buffer

): crypto$Cipher;

declare function createCredentials(

details?: crypto$createCredentialsDetails

): crypto$Credentials

declare function createDecipher(algorithm: string, password: string | Buffer): crypto$Decipher;

declare function createDecipheriv(

algorithm: string,

key: string | Buffer,

iv: string | Buffer

): crypto$Decipher;

declare function createDiffieHellman(prime_length: number): crypto$DiffieHellman;

declare function createDiffieHellman(prime: number, encoding?: string): crypto$DiffieHellman;

declare function createHash(algorithm: string): crypto$Hash;

declare function createHmac(algorithm: string, key: string | Buffer): crypto$Hmac;

declare function createSign(algorithm: string): crypto$Sign;

declare function createVerify(algorithm: string): crypto$Verify;

declare function getCiphers(): Array<string>;

declare function getDiffieHellman(group_name: string): crypto$DiffieHellman;

declare function getHashes(): Array<string>;

declare function pbkdf2(

password: string | Buffer,

salt: string | Buffer,

iterations: number,

keylen: number,

digestOrCallback: string | ((err: ?Error, derivedKey: Buffer) => void),

callback?: (err: ?Error, derivedKey: Buffer) => void

): void;

declare function pbkdf2Sync(

password: string | Buffer,

salt: string | Buffer,

iterations: number,

keylen: number,

digest?: string

): Buffer;

// `UNUSED` argument strictly enforces arity to enable overloading this

// function with 1-arg and 2-arg variants.

declare function pseudoRandomBytes(size: number, UNUSED: void): Buffer;

declare function pseudoRandomBytes(

size: number,

callback: (err: ?Error, buffer: Buffer) => void

): void;

// `UNUSED` argument strictly enforces arity to enable overloading this

// function with 1-arg and 2-arg variants.

declare function randomBytes(size: number, UNUSED: void): Buffer;

declare function randomBytes(

size: number,

callback: (err: ?Error, buffer: Buffer) => void

): void;

}

type net$Socket$address = {address: string; family: string; port: number};

type dgram$Socket = {

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

address(): net$Socket$address;

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

close(): void;

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

ref(): void;

send(

buf: Buffer,

offset: number,

length: number,

port: number,

address: string,

callback?: (err: ?Error, bytes: any) => void

): void;

setBroadcast(flag: boolean): void;

setMulticastLoopback(flag: boolean): void;

setMulticastTTL(ttl: number): void;

setTTL(ttl: number): void;

unref(): void;

};

declare module "dgram" {

declare function createSocket(type: string, callback?: () => void): dgram$Socket;

}

declare module "dns" {

declare var ADDRGETNETWORKPARAMS: string;

declare var BADFAMILY: string;

declare var BADFLAGS: string;

declare var BADHINTS: string;

declare var BADQUERY: string;

declare var BADNAME: string;

declare var BADRESP: string;

declare var BADSTR: string;

declare var CANCELLED: string;

declare var CONNREFUSED: string;

declare var DESTRUCTION: string;

declare var EOF: string;

declare var FILE: string;

declare var FORMER: string;

declare var LOADIPHLPAPI: string;

declare var NODATA: string;

declare var NOMEM: string;

declare var NONAME: string;

declare var NOTFOUND: string;

declare var NOTIMP: string;

declare var NOTINITIALIZED: string;

declare var REFUSED: string;

declare var SERVFAIL: string;

declare var TIMEOUT: string;

declare function lookup(

domain: string,

family?: ?number,

callback?: (err: ?Error, address: string, family: number) => void

): void;

declare function resolve(

domain: string,

rrtype?: string,

callback?: (err: ?Error, addresses: Array<any>) => void

): void;

declare function resolve4(

domain: string,