8000 flow/lib/node.js at v0.31 · dominictobias/flow · GitHub
[go: up one dir, main page]
Skip to content

node.js

Latest commit

 

History

History
1502 lines (1378 loc) · 50.4 KB

node.js

File metadata and controls

1502 lines (1378 loc) · 50.4 KB
Raw
/**
* Copyright (c) 2013-present, Facebook, Inc.
* All rights reserved.
*
* 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.
*
*/
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'
declare class Buffer {
constructor(
value: Array<number> | number | string | Buffer,
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(): Array<number>;
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, 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 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: Buffer, stderr: 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: ?Error, stdout: Buffer, stderr: Buffer) => void;
type child_process$forkOpts = {
cwd?: string;
env?: Object;
execPath?: string;
execArgv?: Array<string>;
silent?: boolean;
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 creatSign(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,
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;
}
// TODO: This is copypasta of the EventEmitter class signature exported from the
// `events` module. The only reason this exists is because other module
// interface definitions need to reference this type structure -- but
// referencing type structures defined in other modules isn't possible at
// the time of this writing.
declare class events$EventEmitter {
// deprecated
static listenerCount(emitter: events$EventEmitter, event: string): number;
addListener(event: string, listener: Function): events$EventEmitter;
emit(event: string, ...args:Array<any>): boolean;
listeners(event: string): Array<Function>;
listenerCount(event: string): number;
on(event: string, listener: Function): events$EventEmitter;
once(event: string, listener: Function): events$EventEmitter;
removeAllListeners(event?: string): events$EventEmitter;
removeListener(event: string, listener: Function): events$EventEmitter;
setMaxListeners(n: number): void;
getMaxListeners(): number;
}
declare module "events" {
// TODO: See the comment above the events$EventEmitter declaration
declare var EventEmitter: typeof events$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;
atime: Date;
mtime: Date;
ctime: Date;
isFile(): boolean;
isDirectory(): boolean;
isBlockDevice(): boolean;
isCharacterDevice(): boolean;
isSymbolicLink(): boolean;
isFIFO(): boolean;
isSocket(): boolean;
}
declare class FSWatcher extends events$EventEmitter {
close(): void
}
declare class ReadStream extends stream$Readable {
close(): void
}
declare class WriteStream extends stream$Writable {
close(): void
}
declare function rename(oldPath: string, newPath: string, callback?: (err: ?Error) => void): void;
declare function renameSync(oldPath: string, newPath: string): void;
declare function ftruncate(fd: number, len: number, callback?: (err: ?Error) => void): void;
declare function ftruncateSync(fd: number, len: number): void;
declare function truncate(path: string, len: number, callback?: (err: ?Error) => void): void;
declare function truncateSync(path: string, len: number): void;
declare function chown(path: string, uid: number, gid: number, callback?: (err: ?Error) => void): void;
declare function chownSync(path: string, uid: number, gid: number): void;
declare function fchown(fd: number, uid: number, gid: number, callback?: (err: ?Error) => void): void;
declare function fchownSync(fd: number, uid: number, gid: number): void;
declare function lchown(path: string, uid: number, gid: number, callback?: (err: ?Error) => void): void;
declare function lchownSync(path: string, uid: number, gid: number): void;
declare function chmod(path: string, mode: number | string, callback?: (err: ?Error) => void): void;
declare function chmodSync(path: string, mode: number | string): void;
declare function fchmod(fd: number, mode: number | string, callback?: (err: ?Error) => void): void;
declare function fchmodSync(fd: number, mode: number | string): void;
declare function lchmod(path: string, mode: number | string, callback?: (err: ?Error) => void): void;
declare function lchmodSync(path: string, mode: number | string): void;
declare function stat(path: string, callback?: (err: ?Error, stats: Stats) => any): void;
declare function statSync(path: string): Stats;
declare function fstat(fd: number, callback?: (err: ?Error, stats: Stats) => any): void;
declare function fstatSync(fd: number): Stats;
declare function lstat(path: string, callback?: (err: ?Error, stats: Stats) => any): void;
declare function lstatSync(path: string): Stats;
declare function link(srcpath: string, dstpath: string, callback?: (err: ?Error) => void): void;
declare function linkSync(srcpath: string, dstpath: string): void;
declare function symlink(srcpath: string, dtspath: string, type?: string, callback?: (err: ?Error) => void): void;
declare function symlinkSync(srcpath: string, dstpath: string, type: string): void;
declare function readlink(path: string, callback: (err: ?Error, linkString: string) => void): void;
declare function readlinkSync(path: string): string;
declare function realpath(path: string, cache?: Object, callback?: (err: ?Error, resolvedPath: string) => void): void;
declare function realpathSync(path: string, cache?: Object): string;
declare function unlink(path: string, callback?: (err: ?Error) => void): void;
declare function unlinkSync(path: string): void;
declare function rmdir(path: string, callback?: (err: ?Error) => void): void;
declare function rmdirSync(path: string): void;
declare function mkdir(path: string, mode?: number, callback?: (err: ?Error) => void): void;
declare function mkdirSync(path: string, mode?: number): void;
declare function readdir(path: string, callback?: (err: ?Error, files: Array<string>) => void): void;
declare function readdirSync(path: string): Array<string>;
declare function close(fd: number, callback?: (err: ?Error) => void): void;
declare function closeSync(fd: number): void;
declare function open(path: string, flags: string, mode?: number, callback?: (err: ?Error, fd: number) => void): void;
declare function openSync(path: string, flags: string, mode?: number): number;
declare function utimes(path: string, atime: number, mtime: number, callback?: (err: ?Error) => void): void;
declare function utimesSync(path: string, atime: number, mtime: number): void;
declare function futimes(fd: number, atime: number, mtime: number, callback?: (err: ?Error) => void): void;
declare function futimesSync(fd: number, atime: number, mtime: number): void;
declare function fsync(fd: number, callback?: (err: ?Error) => void): void;
declare function fsyncSync(fd: number): void;
declare var write: (fd: number, buffer: Buffer, offset: number, length: number, position?: mixed, callback?: (err: ?Error, write: number, str: string) => void) => void
| (fd: number, data: mixed, position?: mixed, encoding?: string, callback?: (err: ?Error, write: number, str: string) => void) => void;
declare var writeSync: (fd: number, buffer: Buffer, offset: number, length: number, position?: number) => number
| (fd: number, data: mixed, position?: mixed, encoding?: string) => number;
declare function read(
fd: number,
buffer: Buffer,
offset: number,
length: number,
position: ?number,
callback?: (err: ?Error, bytesRead: number, buffer: Buffer) => void
): void;
declare function readSync(
fd: number,
buffer: Buffer,
offset: number,
length: number,
position: number
): number;
declare function readFile(
filename: string,
callback: (err: ?Error, data: Buffer) => void
): void;
declare function readFile(
filename: string,
encoding: string,
callback: (err: ?Error, data: string) => void
): void;
declare function readFile(
filename: string,
options: { encoding: string; flag?: string },
callback: (err: ?Error, data: string) => void
): void;
declare function readFile(
filename: string,
options: { flag?: string },
callback: (err: ?Error, data: Buffer) => void
): void;
declare function readFileSync(filename: string, _: void): Buffer;
declare function readFileSync(filename: string, encoding: string): string;
declare function readFileSync(filename: string, options: { encoding: string, flag?: string }): string;
declare function readFileSync(filename: string, options: { encoding?: void, flag?: string }): Buffer;
declare function writeFile(
filename: string,
data: Buffer | string,
options?: Object | string,
callback?: (err: ?Error) => void
): void;
declare function writeFileSync(
filename: string,
data: Buffer | string,
options?: Object | string
): void;
declare function appendFile(filename: string, data: string | Buffer, options?: Object, callback?: (err: ?Error) => void): void;
declare function appendFileSync(filename: string, data: string | Buffer, options?: Object): void;
declare function watchFile(filename: string, options?: Object, listener?: (curr: Stats, prev: Stats) => void): void;
declare function unwatchFile(filename: string, listener?: (curr: Stats, prev: Stats) => void): void;
declare function watch(filename: string, options?: Object, listener?: (event: string, filename: string) => void): FSWatcher;
declare function exists(path: string, callback?: (exists: boolean) => void): void;
declare function existsSync(path: string): boolean;
declare function access(path: string, mode?: any, callback?: (err: ?Error) => void): void;
declare function accessSync(path: string, mode?: any): void;
declare function createReadStream(path: string, options?: Object): ReadStream;
declare function createWriteStream(path: string, options?: Object): WriteStream;
declare var F_OK: number;
declare var R_OK: number;
declare var W_OK: number;
declare var X_OK: number;
}
declare class http$IncomingMessage extends stream$Readable {
headers: Object;
httpVersion: string;
method: string;
trailers: Object;
setTimeout(msecs: number, callback: Function): void;
socket: net$Socket;
statusCode: number;
url: string;
}
declare class http$ClientRequest extends stream$Writable {
flushHeaders(): void;
abort(): void;
setTimeout(msecs: number, callback?: Function): void;
setNoDelay(noDelay?: boolean): void;
setSocketKeepAlive(enable?: boolean, initialDelay?: number): void;
}
declare module "http" {
declare class Server extends net$Server {
listen(port: number, hostname?: string, backlog?: number, callback?: Function): Server;
listen(path: string, callback?: Function): Server;
listen(handle: Object, callback?: Function): Server;
close(callback?: Function): Server;
maxHeadersCount: number;
setTimeout(msecs: number, callback: Function): Server;
timeout: number;
}
declare class ClientRequest extends http$ClientRequest {}
declare class IncomingMessage extends http$IncomingMessage {}
declare function createServer(listener?: Function): Server;
declare function request(
options: Object | string,
callback?: (response: IncomingMessage) => void
): ClientRequest;
declare function get(
options: Object | string,
callback?: (response: IncomingMessage) => void
): ClientRequest;
}
declare module "https" {
declare class Server extends tls$Server {
listen(port: number, hostname?: string, backlog?: number, callback?: Function): Server;
listen(path: string, callback?: Function): Server;
listen(handle: Object, callback?: Function): Server;
close(callback?: Function): Server;
setTimeout(msecs: number, callback: Function): Server;
timeout: number;
}
declare class ClientRequest extends http$ClientRequest {}
declare class IncomingMessage extends http$IncomingMessage {}
declare function createServer(options: Object, secureConnectionListener?: function): Server;
declare function request(
options: Object | string,
callback?: (response: IncomingMessage) => void
): ClientRequest;
declare function get(
options: Object | string,
callback?: (response: IncomingMessage) => void
): ClientRequest;
}
declare class net$Socket extends stream$Duplex {
constructor(options?: Object): void;
address(): net$Socket$address;
bufferSize: number;
bytesRead: number;
bytesWritten: number;
connect(options: Object, connectListener?: function): void;
destroy(): void;
end(
chunk?: string | Buffer,
encodingOrCallback?: string | (data: any) => void,
callback?: (data: any) => void
): void;
localAddress: string;
localPort: number;
pause(): stream$Readable;
ref(): net$Socket;
remoteAddress: string | void;
remoteFamily: string;
remotePort: number;
resume(): stream$Readable;
setEncoding(encoding?: string): stream$Readable;
setKeepAlive(enable?: boolean, initialDelay?: number): net$Socket;
setNoDelay(noDelay?: boolean): net$Socket;
setTimeout(timeout: number, callback?: function): net$Socket;
unref(): net$Socket;
write(
chunk?: string | Buffer,
encodingOrCallback?: string | (data: any) => void,
callback?: (data: any) => void
): boolean;
}
declare class net$Server extends events$EventEmitter {
listen(port: number, hostname?: string, backlog?: number, callback?: Function): net$Server;
listen(path: string, callback?: Function): net$Server;
listen(handle: Object, callback?: Function): net$Server;
close(callback?: Function): net$Server;
address(): net$Socket$address;
connections: number;
maxConnections: number;
getConnections(callback: Function): void;
ref(): net$Server;
unref(): net$Server;
}
type net$connectOptions = {
port?: number,
host?: string,
localAddress?: string,
localPort?: number,
family?: number,
lookup?: string,
path?: string,
};
declare module "net" {
declare class Server extends net$Server {}
declare class Socket extends net$Socket {}
declare function isIP(input: string): number;
declare function isIPv4(input: string): boolean;
declare function isIPv6(input: string): boolean;
declare type connectionListener = (socket: Socket) => any;
declare function createServer(
options?: {
allowHalfOpen?: boolean,
pauseOnConnect?: boolean,
} | connectionListener,
connectionListener?: connectionListener,
): Server;
declare type connectListener = () => any;
declare function connect(
pathOrPortOrOptions: string | number | net$connectOptions,
hostOrConnectListener?: string | connectListener,
connectListener?: connectListener,
): Socket;
declare function createConnection(
pathOrPortOrOptions: string | number | net$connectOptions,
hostOrConnectListener?: string | connectListener,
connectListener?: connectListener,
): Socket;
}
type os$CPU = {
model: string,
speed: number,
times: {
idle: number,
irq: number,
nice: number,
sys: number,
user: number,
}
};
type os$NetIFAddr = {
address: string,
family: string,
internal: boolean,
mac: string,
netmask: string
};
declare module "os" {
declare function arch(): "x64"|"arm"|"ia32";
declare function cpus(): Array<os$CPU>;
declare function endianness(): "BE"|"LE";
declare function freemem(): number;
declare function homedir(): string;
declare function hostname(): string;
declare function loadavg(): [number, number, number];
declare function networkInterfaces(): {[ifName: string]: Array<os$NetIFAddr>};
declare function platform(): string;
declare function release(): string;
declare function tmpdir(): string;
declare function totalmem(): number;
declare function type(): string;
declare function uptime(): number;
declare var EOL: string;
}
declare module "path" {
declare function normalize(path: string): string;
declare function join(...parts: Array<string>): string;
declare function resolve(...parts: Array<string>): string;
declare function isAbsolute(path: string): boolean;
declare function relative(from: string, to: string): string;
declare function dirname(path: string): string;
declare function basename(path: string, ext?: string): string;
declare function extname(path: string): string;
declare var sep: string;
declare var delimiter: string;
declare function parse(pathString: string): {
root: string;
dir: string;
base: string;
ext: string;
name: string;
};
declare function format(pathObject: {
root?: string;
dir?: string;
base?: string;
ext?: string;
name?: string;
}): string;
declare var posix: any;
declare var win32: any;
}
declare module "punycode" {
declare function decode(string: string): string;
declare function encode(string: string): string;
declare function toASCII(domain: string): string;
declare function toUnicode(domain: string): string;
declare var ucs2: {
View remainder of file in raw view
0