/**

* Copyright (c) Meta Platforms, Inc. and affiliates.

* Portions copyright Node.js contributors. All rights reserved.

*

* This source code is licensed under the MIT license found in the

* LICENSE file in the root directory of this source tree.

*

* @lint-ignore-every LICENSELINT

* @flow

*/

interface ErrnoError extends Error {

address?: string;

code?: string;

dest?: string;

errno?: string | number;

info?: Object;

path?: string;

port?: number;

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' | 'latin1';

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

type buffer$ToJSONRet = {

type: string,

data: Array<number>,

...

}

declare class Buffer extends Uint8Array {

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 | Buffer | number, offset?: number, end?: number, encoding?: string): this;

fill(value: string, encoding?: string): this;

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): this;

swap16(): Buffer;

swap32(): Buffer;

swap64(): 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): number;

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;

static from(value: Buffer): Buffer;

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

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

static from(value: Iterable<number>): this;

static isBuffer(obj: any): boolean;

static isEncoding(encoding: string): boolean;

}

declare type Node$Buffer = typeof Buffer;

declare module "buffer" {

declare var kMaxLength: number;

declare var INSPECT_MAX_BYTES: number;

declare function transcode(source: Node$Buffer, fromEnc: buffer$Encoding, toEnc: buffer$Encoding): Node$Buffer;

declare var Buffer: Node$Buffer;

}

type child_process$execOpts = {

cwd?: string,

env?: Object,

encoding?: string,

shell?: string,

timeout?: number,

maxBuffer?: number,

killSignal?: string | number,

uid?: number,

gid?: number,

windowsHide?: boolean,

...

};

declare class child_process$Error extends Error {

code: number | string | null,

errno?: string,

syscall?: string,

path?: string,

spawnargs?: Array<string>,

killed?: boolean,

signal?: string | null,

cmd: 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 | $TypedArray | DataView,

stdio?: string | Array<any>,

env?: Object,

shell?: string,

uid?: number,

gid?: number,

timeout?: number,

killSignal?: string | number,

maxBuffer?: number,

encoding?: string,

windowsHide?: boolean,

...

};

type child_process$execFileOpts = {

cwd?: string,

env?: Object,

encoding?: string,

timeout?: number,

maxBuffer?: number,

killSignal?: string | number,

uid?: number,

gid?: number,

windowsHide?: boolean,

windowsVerbatimArguments?: boolean,

shell?: boolean | string,

...

};

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

type child_process$execFileSyncOpts = {

cwd?: string,

input?: string | Buffer | $TypedArray | DataView,

stdio?: string | Array<any>,

env?: Object,

uid?: number,

gid?: number,

timeout?: number,

killSignal?: string | number,

maxBuffer?: number,

encoding?: string,

windowsHide?: boolean,

shell?: boolean | string,

...

};

type child_process$forkOpts = {

cwd?: string,

env?: Object,

execPath?: string,

execArgv?: Array<string>,

silent?: boolean,

stdio?: Array<any> | string,

windowsVerbatimArguments?: boolean,

uid?: number,

gid?: number,

...

};

type child_process$Handle = any; // TODO

type child_process$spawnOpts = {

cwd?: string,

env?: Object,

argv0?: string,

stdio?: string | Array<any>,

detached?: boolean,

uid?: number,

gid?: number,

shell?: boolean | string,

windowsVerbatimArguments?: boolean,

windowsHide?: boolean,

...

};

type child_process$spawnRet = {

pid: number,

output: Array<any>,

stdout: Buffer | string,

stderr: Buffer | string,

status: number,

signal: string,

error: Error,

...

};

type child_process$spawnSyncOpts = {

cwd?: string,

input?: string | Buffer,

stdio?: string | Array<any>,

env?: Object,

uid?: number,

gid?: number,

timeout?: number,

killSignal?: string,

maxBuffer?: number,

encoding?: string,

shell?: boolean | string,

...

};

type child_process$spawnSyncRet = child_process$spawnRet;

declare class child_process$ChildProcess extends events$EventEmitter {

channel: Object;

connected: boolean;

killed: boolean;

pid: number;

exitCode: number | null;

stderr: stream$Readable;

stdin: stream$Writable;

stdio: Array<any>;

stdout: stream$Readable;

disconnect(): void;

kill(signal?: string): void;

send(

message: Object,

sendHandleOrCallback?: child_process$Handle,

optionsOrCallback?: Object | Function,

callback?: Function

): boolean;

unref(): void;

ref(): void;

}

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$execFileSyncOpts,

options?: child_process$execFileSyncOpts

): 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$spawnSyncOpts,

options?: child_process$spawnSyncOpts

): child_process$spawnSyncRet;

}

declare module "cluster" {

declare type ClusterSettings = {

execArgv: Array<string>,

exec: string,

args: Array<string>,

cwd: string,

serialization: 'json' | 'advanced',

silent: boolean,

stdio: Array<any>,

uid: number,

gid: number,

inspectPort: number | () => number,

windowsHide: boolean,

...

}

declare type ClusterSettingsOpt = {

execArgv?: Array<string>,

exec?: string,

args?: Array<string>,

cwd?: string,

serialization?: 'json' | 'advanced',

silent?: boolean,

stdio?: Array<any>,

uid?: number,

gid?: number,

inspectPort?: number | () => number,

windowsHide?: boolean,

...

}

declare class Worker extends events$EventEmitter {

id: number;

process: child_process$ChildProcess;

suicide: boolean;

disconnect(): void;

isConnected(): boolean;

isDead(): boolean;

kill(signal?: string): void;

send(

message: Object,

sendHandleOrCallback?: child_process$Handle | Function,

callback?: Function,

): boolean;

}

declare class Cluster extends events$EventEmitter {

isMaster: boolean;

isWorker: boolean;

settings: ClusterSettings;

worker: Worker;

workers: { [id: number]: Worker };

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

fork(env?: Object): Worker;

setupMaster(settings?: ClusterSettingsOpt): void;

}

declare module.exports: Cluster;

}

type crypto$createCredentialsDetails = any; // TODO

declare class crypto$Cipher extends stream$Duplex {

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

final(output_encoding: void): Buffer;

getAuthTag(): Buffer;

setAAD(buffer: Buffer): crypto$Cipher;

setAuthTag(buffer: Buffer): void;

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

update(

data: string,

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

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

): string;

update(

data: string,

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

output_encoding: void

): Buffer;

update(

data: Buffer,

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

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

): string;

update(

data: Buffer,

input_encoding: void,

output_encoding: void

): Buffer;

}

type crypto$Credentials = {...}

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,

...

}

type crypto$ECDH$Encoding = 'latin1' | 'hex' | 'base64';

type crypto$ECDH$Format = 'compressed' | 'uncompressed';

declare class crypto$ECDH {

computeSecret(

other_public_key: Buffer | $TypedArray | DataView

): Buffer,

computeSecret(

other_public_key: string,

input_encoding: crypto$ECDH$Encoding

): Buffer,

computeSecret(

other_public_key: Buffer | $TypedArray | DataView,

output_encoding: crypto$ECDH$Encoding

): string,

computeSecret(

other_public_key: string,

input_encoding: crypto$ECDH$Encoding,

output_encoding: crypto$ECDH$Encoding

): string,

generateKeys(format?: crypto$ECDH$Format): Buffer,

generateKeys(encoding: crypto$ECDH$Encoding, format?: crypto$ECDH$Format): string,

getPrivateKey(): Buffer,

getPrivateKey(encoding: crypto$ECDH$Encoding): string,

getPublicKey(format?: crypto$ECDH$Format): Buffer,

getPublicKey(encoding: crypto$ECDH$Encoding, format?: crypto$ECDH$Format): string,

setPrivateKey(private_key: Buffer | $TypedArray | DataView): void,

setPrivateKey(private_key: string, encoding: crypto$ECDH$Encoding): void

}

declare class crypto$Decipher extends stream$Duplex {

final(output_encoding: 'latin1' | 'binary' | 'ascii' | 'utf8'): 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: 'latin1' | 'binary' | 'base64' | 'hex',

output_encoding: 'latin1' | 'binary' | 'ascii' | 'utf8',

): string;

update(

data: string,

input_encoding: 'latin1' | 'binary' | 'base64' | 'hex',

output_encoding: void

): Buffer;

update(

data: Buffer,

input_encoding: void,

output_encoding: 'latin1' | 'binary' | 'ascii' | 'utf8',

): string;

update(

data: Buffer,

input_encoding: void,

output_encoding: void

): Buffer;

}

declare class crypto$Hash extends stream$Duplex {

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

digest(encoding: 'buffer'): Buffer;

digest(encoding: void): Buffer;

update(data: string | Buffer, input_encoding?: 'utf8' | 'ascii' | 'latin1' |

'binary'): crypto$Hash;

}

declare class crypto$Hmac extends stream$Duplex {

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

digest(encoding: 'buffer'): Buffer;

digest(encoding: void): Buffer;

update(data: string | Buffer, input_encoding?: 'utf8' | 'ascii' | 'latin1' |

'binary'): crypto$Hmac;

}

type crypto$Sign$private_key = string | {

key: string,

passphrase: string,

...

}

declare class crypto$Sign extends stream$Writable {

static(algorithm: string, options?: writableStreamOptions): crypto$Sign,

constructor(algorithm: string, options?: writableStreamOptions): void;

sign(

private_key: crypto$Sign$private_key,

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

): string;

sign(

private_key: crypto$Sign$private_key,

output_format: void

): Buffer;

update(data: string | Buffer, input_encoding?: 'utf8' | 'ascii' | 'latin1' |

'binary'): crypto$Sign;

}

declare class crypto$Verify extends stream$Writable {

static(algorithm: string, options?: writableStreamOptions): crypto$Verify,

constructor(algorithm: string, options?: writableStreamOptions): void;

update(data: string | Buffer, input_encoding?: 'utf8' | 'ascii' | 'latin1' |

'binary' ): crypto$Verify;

verify(

object: string,

signature: string | Buffer | $TypedArray | DataView,

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

): boolean;

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

}

type crypto$key = string | {

key: string,

passphrase?: string,

// TODO: enum type in crypto.constants

padding?: string,

...

};

declare module "crypto" {

declare var DEFAULT_ENCODING: string;

declare class Sign extends crypto$Sign {}

declare class Verify extends crypto$Verify {}

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 createECDH(curveName: string): crypto$ECDH;

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 getCurves(): 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,

digest: string,

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

): void;

declare function pbkdf2(

password: string | Buffer,

salt: string | Buffer,

iterations: number,

keylen: number,

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

): void;

declare function pbkdf2Sync(

password: string | Buffer,

salt: string | Buffer,

iterations: number,

keylen: number,

digest?: string

): Buffer;

declare function scrypt(

password: string | Buffer,

salt: string | Buffer,

keylen: number,

options: {|N?: number, r?: number, p?: number, maxmem?: number|}

| {|cost?: number, blockSize?: number, parallelization?: number, maxmem?: number|},

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

): void;

declare function scrypt(

password: string | Buffer,

salt: string | Buffer,

keylen: number,

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

): void;

declare function scryptSync(

password: string | Buffer,

salt: string | Buffer,

keylen: number,

options?: {|N?: number, r?: number, p?: number, maxmem?: number|}

| {|cost?: number, blockSize?: number, parallelization?: number, maxmem?: number|},

): Buffer;

declare function privateDecrypt(

private_key: crypto$key,

buffer: Buffer

): Buffer;

declare function privateEncrypt(

private_key: crypto$key,

buffer: Buffer

): Buffer;

declare function publicDecrypt(

key: crypto$key,

buffer: Buffer

): Buffer;

declare function publicEncrypt(

key: crypto$key,

buffer: Buffer

): 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;

declare function randomFillSync(buffer: Buffer | $TypedArray | DataView): void

declare function randomFillSync(buffer: Buffer | $TypedArray | DataView, offset: number): void

declare function randomFillSync(

buffer: Buffer | $TypedArray | DataView,

offset: number,

size: number

): void

declare function randomFill(

buffer: Buffer | $TypedArray | DataView,

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

): void

declare function randomFill(

buffer: Buffer | $TypedArray | DataView,

offset: number,

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

): void

declare function randomFill(

buffer: Buffer | $TypedArray | DataView,

offset: number,

size: number,

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

): void

declare function timingSafeEqual(

a: Buffer | $TypedArray | DataView,

b: Buffer | $TypedArray | DataView

): boolean;

}

type net$Socket$address = {

address: string,

family: string,

port: number,

...

};

type dgram$Socket$rinfo = {

address: string,

family: 'IPv4' | 'IPv6',

port: number,

size: number,

...

};

declare class dgram$Socket extends events$EventEmitter {

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

address(): net$Socket$address;

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

close(callback?: () => void): void;

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

ref(): void;

send(

msg: Buffer,

port: number,

address: string,

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

): void;

send(

msg: Buffer,

offset: number,

length: number,

port: number,

address: string,

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

): 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(

options: string | { 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 var ADDRCONFIG: number;

declare var V4MAPPED: number;

declare type LookupOptions = {

family?: number,

hints?: number,

verbatim?: boolean,

all?: boolean,

...

};

declare function lookup(

domain: string,

options: number | LookupOptions,

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

): void;

declare function lookup(

domain: string,

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,

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

): void;

declare function resolve6(

domain: string,

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

): void;

declare function resolveCname(

domain: string,

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

): void;

declare function resolveMx(

domain: string,

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

): void;

declare function resolveNs(

domain: string,

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

): void;

declare function resolveSrv(

domain: string,

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

): void;

declare function resolveTxt(

domain: string,

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

): void;

declare function reverse(

ip: string,

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

): void;

declare function timingSafeEqual(

a: Buffer | $TypedArray | DataView,

b: Buffer | $TypedArray | DataView

): boolean;

}

declare class events$EventEmitter {

// deprecated

static listenerCount(emitter: events$EventEmitter, event: string): number;

static defaultMaxListeners: number;

addListener(event: string, listener: Function): this;

emit(event: string, ...args:Array<any>): boolean;

eventNames(): Array<string>;

listeners(event: string): Array<Function>;

listenerCount(event: string): number;

on(event: string, listener: Function): this;

once(event: string, listener: Function): this;

prependListener(event: string, listener: Function): this;

prependOnceListener(event: string, listener: Function): this;

removeAllListeners(event?: string): this;

removeListener(event: string, listener: Function): this;

off(event: string, listener: Function): this;

setMaxListeners(n: number): this;

getMaxListeners(): number;

rawListeners(event: string): Array<Function>;

}

declare module "events" {

// TODO: See the comment above the events$EventEmitter declaration

declare class EventEmitter extends events$EventEmitter {

static EventEmitter: typeof EventEmitter;

}

declare module.exports: typeof EventEmitter;

}

declare class domain$Domain extends events$EventEmitter {

members: Array<any>;

add(emitter: events$EventEmitter): void;

bind(callback: Function): Function;

dispose(): void;

enter(): void;

exit(): void;

intercept(callback: Function): Function;

remove(emitter: events$EventEmitter): void;

run(fn: Function): void;

}

declare module "domain" {

declare function create(): domain$Domain;

}

declare module "fs" {

declare class Stats {

dev: number;

ino: number;

mode: number;

nlink: number;

uid: number;

gid: number;

rdev: number;

size: number;

blksize: number;

blocks: number;

atimeMs: number;

mtimeMs: number;

ctimeMs: number;

birthtimeMs: number;

atime: Date;

mtime: Date;

ctime: Date;

birthtime: Date;

isFile(): boolean;

isDirectory(): boolean;

isBlockDevice(): boolean;

isCharacterDevice(): boolean;

isSymbolicLink(): boolean;

isFIFO(): boolean;

isSocket(): boolean;

}

declare type PathLike = string | Buffer | URL;

declare class FSWatcher extends events$EventEmitter {

close(): void;

}

declare class ReadStream extends stream$Readable {

close(): void;

}

declare class WriteStream extends stream$Writable {

close(): void;

bytesWritten: number;

}

declare class Dirent {

name: string | Buffer;

isBlockDevice(): boolean;

isCharacterDevice(): boolean;

isDirectory(): boolean;

isFIFO(): boolean;

isFile(): boolean;

isSocket(): boolean;

isSymbolicLink(): boolean;

}

declare function rename(oldPath: string, newPath: string, callback?: (err: ?ErrnoError) => void): void;

declare function renameSync(oldPath: string, newPath: string): void;

declare function ftruncate(fd: number, len: number, callback?: (err: ?ErrnoError) => void): void;

declare function ftruncateSync(fd: number, len: number): void;

declare function truncate(path: string, len: number, callback?: (err: ?ErrnoError) => void): void;

declare function truncateSync(path: string, len: number): void;

declare function chown(path: string, uid: number, gid: number, callback?: (err: ?ErrnoError) => void): void;

declare function chownSync(path: string, uid: number, gid: number): void;

declare function fchown(fd: number, uid: number, gid: number, callback?: (err: ?ErrnoError) => void): void;

declare function fchownSync(fd: number, uid: number, gid: number): void;

declare function lchown(path: string, uid: number, gid: number, callback?: (err: ?ErrnoError) => void): void;

declare function lchownSync(path: string, uid: number, gid: number): void;

declare function chmod(path: string, mode: number | string, callback?: (err: ?ErrnoError) => void): void;

declare function chmodSync(path: string, mode: number | string): void;

declare function fchmod(fd: number, mode: number | string, callback?: (err: ?ErrnoError) => void): void;

declare function fchmodSync(fd: number, mode: number | string): void;

declare function lchmod(path: string, mode: number | string, callback?: (err: ?ErrnoError) => void): void;

declare function lchmodSync(path: string, mode: number | string): void;

declare function stat(path: string, callback?: (err: ?ErrnoError, stats: Stats) => any): void;

declare function statSync(path: string): Stats;

declare function fstat(fd: number, callback?: (err: ?ErrnoError, stats: Stats) => any): void;

declare function fstatSync(fd: number): Stats;

declare function lstat(path: string, callback?: (err: ?ErrnoError, stats: Stats) => any): void;

declare function lstatSync(path: string): Stats;

declare function link(srcpath: string, dstpath: string, callback?: (err: ?ErrnoError) => void): void;

declare function linkSync(srcpath: string, dstpath: string): void;

declare function symlink(srcpath: string, dtspath: string, type?: string, callback?: (err: ?ErrnoError) => void): void;

declare function symlinkSync(srcpath: string, dstpath: string, type?: string): void;

declare function readlink(path: string, callback: (err: ?ErrnoError, linkString: string) => void): void;

declare function readlinkSync(path: string): string;

declare function realpath(path: string, cache?: Object, callback?: (err: ?ErrnoError, resolvedPath: string) => void): void;

declare function realpathSync(path: string, cache?: Object): string;

declare function unlink(path: string, callback?: (err: ?ErrnoError) => void): void;

declare function unlinkSync(path: string): void;

declare type RmDirOptions = {|

/**

* If an `EBUSY`, `EMFILE`, `ENFILE`, `ENOTEMPTY`, or

* `EPERM` error is encountered, Node.js will retry the operation with a linear

* backoff wait of `retryDelay` ms longer on each try. This option represents the

* number of retries. This option is ignored if the `recursive` option is not

* `true`.