mirror of
https://github.com/gosticks/DefinitelyTyped.git
synced 2025-10-16 12:05:41 +00:00
cddd0b7aab
This is valuable information for Node applications that need to figure out why a particular system call failed. Note that errno can either be a string or a number, which is why I have typed it as 'any'. While this is undocumented, it is tested: Code property: https://github.com/joyent/node/blob/v0.10.23-release/test/simple/test-fs-open.js#L34 Errno property [string]: https://github.com/joyent/node/blob/v0.10.23-release/test/internet/test-dns.js#L148 Errno property [number]: https://github.com/joyent/node/blob/v0.10.23-release/test/simple/test-domain-implicit-fs.js#L43 Syscall property: https://github.com/joyent/node/blob/v0.10.23-release/test/simple/test-stdout-close-catch.js#L38 Path property (I can’t find a test, but many examples have this line): https://github.com/joyent/node/blob/v0.10.23-release/deps/npm/node_modules/fstream-npm/example/bundle.js#L6 ..and well supported in the code for all platforms (this is where I got the name 'ErrnoException' from): *nix: https://github.com/joyent/node/blob/v0.10.23-release/src/node.cc#L719 Windows: https://github.com/joyent/node/blob/v0.10.23-release/src/node.cc#L856 Unfortunately, while every errno exception is guaranteed to have the ‘errno’ and ‘code’ properties (see the logic in the source code in node.cc), there is no hard guarantee that particular library functions will always pass an ErrnoException to the callback. I cannot find a counterexample at this moment, though. Since we can’t have union types in TypeScript, I simply made all of the properties on ErrnoException optional as a compromise. I am only adding modifications to the fs module, which definitely throws ErrnoExceptions. But according to the examples above, other modules (e.g. dns) also pass errno information back to applications. People familiar with those other modules can update their typings to reference this interface when applicable; I lack the experience with those modules to update their typings. Further proof: ```javascript $ node > var fs = require('fs'); undefined > fs.open('doesntexistlol', 'r', function(e) { console.log(Object.keys(e)); console.log(e.code); console.log(e.errno); console.log(e.path); }); undefined > [ 'errno', 'code', 'path' ] ENOENT 34 doesntexistlol ```
1182 lines
51 KiB
TypeScript
1182 lines
51 KiB
TypeScript
/************************************************
|
|
* *
|
|
* Node.js v0.10.1 API *
|
|
* *
|
|
************************************************/
|
|
|
|
/************************************************
|
|
* *
|
|
* GLOBAL *
|
|
* *
|
|
************************************************/
|
|
declare var process: NodeProcess;
|
|
declare var global: any;
|
|
|
|
declare var __filename: string;
|
|
declare var __dirname: string;
|
|
|
|
declare function setTimeout(callback: (...args: any[]) => void , ms: number , ...args: any[]): NodeTimer;
|
|
declare function clearTimeout(timeoutId: NodeTimer): void;
|
|
declare function setInterval(callback: (...args: any[]) => void , ms: number , ...args: any[]): NodeTimer;
|
|
declare function clearInterval(intervalId: NodeTimer): void;
|
|
declare function setImmediate(callback: (...args: any[]) => void , ...args: any[]): any;
|
|
declare function clearImmediate(immediateId: any): void;
|
|
|
|
declare var require: {
|
|
(id: string): any;
|
|
resolve(id:string): string;
|
|
cache: any;
|
|
extensions: any;
|
|
main: any;
|
|
}
|
|
|
|
declare var module: {
|
|
exports: any;
|
|
require(id: string): any;
|
|
id: string;
|
|
filename: string;
|
|
loaded: boolean;
|
|
parent: any;
|
|
children: any[];
|
|
}
|
|
|
|
// Same as module.exports
|
|
declare var exports: any;
|
|
declare var SlowBuffer: {
|
|
new (str: string, encoding?: string): NodeBuffer;
|
|
new (size: number): NodeBuffer;
|
|
new (array: any[]): NodeBuffer;
|
|
prototype: NodeBuffer;
|
|
isBuffer(obj: any): boolean;
|
|
byteLength(string: string, encoding?: string): number;
|
|
concat(list: NodeBuffer[], totalLength?: number): NodeBuffer;
|
|
};
|
|
declare var Buffer: {
|
|
new (str: string, encoding?: string): NodeBuffer;
|
|
new (size: number): NodeBuffer;
|
|
new (array: any[]): NodeBuffer;
|
|
prototype: NodeBuffer;
|
|
isBuffer(obj: any): boolean;
|
|
byteLength(string: string, encoding?: string): number;
|
|
concat(list: NodeBuffer[], totalLength?: number): NodeBuffer;
|
|
}
|
|
|
|
/************************************************
|
|
* *
|
|
* INTERFACES *
|
|
* *
|
|
************************************************/
|
|
|
|
interface ErrnoException extends Error {
|
|
errno?: any;
|
|
code?: string;
|
|
path?: string;
|
|
syscall?: string;
|
|
}
|
|
|
|
interface EventEmitter {
|
|
addListener(event: string, listener: Function): EventEmitter;
|
|
on(event: string, listener: Function): EventEmitter;
|
|
once(event: string, listener: Function): EventEmitter;
|
|
removeListener(event: string, listener: Function): EventEmitter;
|
|
removeAllListeners(event?: string): EventEmitter;
|
|
setMaxListeners(n: number): void;
|
|
listeners(event: string): Function[];
|
|
emit(event: string, ...args: any[]): boolean;
|
|
}
|
|
|
|
interface WritableStream extends EventEmitter {
|
|
writable: boolean;
|
|
write(str: string, encoding?: string, fd?: string): boolean;
|
|
write(buffer: NodeBuffer): boolean;
|
|
end(): void;
|
|
end(str: string, enconding: string): void;
|
|
end(buffer: NodeBuffer): void;
|
|
destroy(): void;
|
|
destroySoon(): void;
|
|
}
|
|
|
|
interface ReadableStream extends EventEmitter {
|
|
readable: boolean;
|
|
setEncoding(encoding: string): void;
|
|
pause(): void;
|
|
resume(): void;
|
|
destroy(): void;
|
|
pipe<T extends WritableStream>(destination: T, options?: { end?: boolean; }): T;
|
|
}
|
|
|
|
interface NodeProcess extends EventEmitter {
|
|
stdout: WritableStream;
|
|
stderr: WritableStream;
|
|
stdin: ReadableStream;
|
|
argv: string[];
|
|
execPath: string;
|
|
abort(): void;
|
|
chdir(directory: string): void;
|
|
cwd(): string;
|
|
env: any;
|
|
exit(code?: number): void;
|
|
getgid(): number;
|
|
setgid(id: number): void;
|
|
setgid(id: string): void;
|
|
getuid(): number;
|
|
setuid(id: number): void;
|
|
setuid(id: string): void;
|
|
version: string;
|
|
versions: { http_parser: string; node: string; v8: string; ares: string; uv: string; zlib: string; openssl: string; };
|
|
config: {
|
|
target_defaults: {
|
|
cflags: any[];
|
|
default_configuration: string;
|
|
defines: string[];
|
|
include_dirs: string[];
|
|
libraries: string[];
|
|
};
|
|
variables: {
|
|
clang: number;
|
|
host_arch: string;
|
|
node_install_npm: boolean;
|
|
node_install_waf: boolean;
|
|
node_prefix: string;
|
|
node_shared_openssl: boolean;
|
|
node_shared_v8: boolean;
|
|
node_shared_zlib: boolean;
|
|
node_use_dtrace: boolean;
|
|
node_use_etw: boolean;
|
|
node_use_openssl: boolean;
|
|
target_arch: string;
|
|
v8_no_strict_aliasing: number;
|
|
v8_use_snapshot: boolean;
|
|
visibility: string;
|
|
};
|
|
};
|
|
kill(pid: number, signal?: string): void;
|
|
pid: number;
|
|
title: string;
|
|
arch: string;
|
|
platform: string;
|
|
memoryUsage(): { rss: number; heapTotal: number; heapUsed: number; };
|
|
nextTick(callback: Function): void;
|
|
umask(mask?: number): number;
|
|
uptime(): number;
|
|
hrtime(time?:number[]): number[];
|
|
|
|
// Worker
|
|
send?(message: any, sendHandle?: any): void;
|
|
}
|
|
|
|
// Buffer class
|
|
interface NodeBuffer {
|
|
[index: number]: number;
|
|
write(string: string, offset?: number, length?: number, encoding?: string): number;
|
|
toString(encoding?: string, start?: number, end?: number): string;
|
|
length: number;
|
|
copy(targetBuffer: NodeBuffer, targetStart?: number, sourceStart?: number, sourceEnd?: number): number;
|
|
slice(start?: number, end?: number): NodeBuffer;
|
|
readUInt8(offset: number, noAsset?: boolean): number;
|
|
readUInt16LE(offset: number, noAssert?: boolean): number;
|
|
readUInt16BE(offset: number, noAssert?: boolean): number;
|
|
readUInt32LE(offset: number, noAssert?: boolean): number;
|
|
readUInt32BE(offset: number, noAssert?: boolean): number;
|
|
readInt8(offset: number, noAssert?: boolean): number;
|
|
readInt16LE(offset: number, noAssert?: boolean): number;
|
|
readInt16BE(offset: number, noAssert?: boolean): number;
|
|
readInt32LE(offset: number, noAssert?: boolean): number;
|
|
readInt32BE(offset: number, noAssert?: boolean): number;
|
|
readFloatLE(offset: number, noAssert?: boolean): number;
|
|
readFloatBE(offset: number, noAssert?: boolean): number;
|
|
readDoubleLE(offset: number, noAssert?: boolean): number;
|
|
readDoubleBE(offset: number, noAssert?: boolean): number;
|
|
writeUInt8(value: number, offset: number, noAssert?: boolean): void;
|
|
writeUInt16LE(value: number, offset: number, noAssert?: boolean): void;
|
|
writeUInt16BE(value: number, offset: number, noAssert?: boolean): void;
|
|
writeUInt32LE(value: number, offset: number, noAssert?: boolean): void;
|
|
writeUInt32BE(value: number, offset: number, noAssert?: boolean): void;
|
|
writeInt8(value: number, offset: number, noAssert?: boolean): void;
|
|
writeInt16LE(value: number, offset: number, noAssert?: boolean): void;
|
|
writeInt16BE(value: number, offset: number, noAssert?: boolean): void;
|
|
writeInt32LE(value: number, offset: number, noAssert?: boolean): void;
|
|
writeInt32BE(value: number, offset: number, noAssert?: boolean): void;
|
|
writeFloatLE(value: number, offset: number, noAssert?: boolean): void;
|
|
writeFloatBE(value: number, offset: number, noAssert?: boolean): void;
|
|
writeDoubleLE(value: number, offset: number, noAssert?: boolean): void;
|
|
writeDoubleBE(value: number, offset: number, noAssert?: boolean): void;
|
|
fill(value: any, offset?: number, end?: number): void;
|
|
}
|
|
|
|
interface NodeTimer {
|
|
ref() : void;
|
|
unref() : void;
|
|
}
|
|
|
|
/************************************************
|
|
* *
|
|
* MODULES *
|
|
* *
|
|
************************************************/
|
|
declare module "querystring" {
|
|
export function stringify(obj: any, sep?: string, eq?: string): string;
|
|
export function parse(str: string, sep?: string, eq?: string, options?: { maxKeys?: number; }): any;
|
|
export function escape(): any;
|
|
export function unescape(): any;
|
|
}
|
|
|
|
declare module "events" {
|
|
export interface NodeEventEmitter {
|
|
addListener(event: string, listener: Function): NodeEventEmitter;
|
|
on(event: string, listener: Function): NodeEventEmitter;
|
|
once(event: string, listener: Function): NodeEventEmitter;
|
|
removeListener(event: string, listener: Function): NodeEventEmitter;
|
|
removeAllListeners(event?: string): NodeEventEmitter;
|
|
setMaxListeners(n: number): void;
|
|
listeners(event: string): Function[];
|
|
emit(event: string, ...args: any[]): boolean;
|
|
}
|
|
|
|
export class EventEmitter implements NodeEventEmitter {
|
|
static listenerCount(emitter: EventEmitter, event: string): number;
|
|
|
|
addListener(event: string, listener: Function): EventEmitter;
|
|
on(event: string, listener: Function): EventEmitter;
|
|
once(event: string, listener: Function): EventEmitter;
|
|
removeListener(event: string, listener: Function): EventEmitter;
|
|
removeAllListeners(event?: string): EventEmitter;
|
|
setMaxListeners(n: number): void;
|
|
listeners(event: string): Function[];
|
|
emit(event: string, ...args: any[]): boolean;
|
|
}
|
|
}
|
|
|
|
declare module "http" {
|
|
import events = require("events");
|
|
import net = require("net");
|
|
import stream = require("stream");
|
|
|
|
export interface Server extends events.NodeEventEmitter {
|
|
listen(port: number, hostname?: string, backlog?: number, callback?: Function): void;
|
|
listen(path: string, callback?: Function): void;
|
|
listen(handle: any, listeningListener?: Function): void;
|
|
close(cb?: any): void;
|
|
maxHeadersCount: number;
|
|
}
|
|
export interface ServerRequest extends events.NodeEventEmitter, stream.ReadableStream {
|
|
method: string;
|
|
url: string;
|
|
headers: any;
|
|
trailers: string;
|
|
httpVersion: string;
|
|
setEncoding(encoding?: string): void;
|
|
pause(): void;
|
|
resume(): void;
|
|
connection: net.NodeSocket;
|
|
}
|
|
export interface ServerResponse extends events.NodeEventEmitter, stream.WritableStream {
|
|
// Extended base methods
|
|
write(str: string, encoding?: string, fd?: string): boolean;
|
|
write(buffer: NodeBuffer): boolean;
|
|
|
|
writeContinue(): void;
|
|
writeHead(statusCode: number, reasonPhrase?: string, headers?: any): void;
|
|
writeHead(statusCode: number, headers?: any): void;
|
|
statusCode: number;
|
|
setHeader(name: string, value: string): void;
|
|
sendDate: boolean;
|
|
getHeader(name: string): string;
|
|
removeHeader(name: string): void;
|
|
write(chunk: any, encoding?: string): any;
|
|
addTrailers(headers: any): void;
|
|
end(data?: any, encoding?: string): void;
|
|
}
|
|
export interface ClientRequest extends events.NodeEventEmitter, stream.WritableStream {
|
|
// Extended base methods
|
|
write(str: string, encoding?: string, fd?: string): boolean;
|
|
write(buffer: NodeBuffer): boolean;
|
|
|
|
write(chunk: any, encoding?: string): void;
|
|
end(data?: any, encoding?: string): void;
|
|
abort(): void;
|
|
setTimeout(timeout: number, callback?: Function): void;
|
|
setNoDelay(noDelay?: Function): void;
|
|
setSocketKeepAlive(enable?: boolean, initialDelay?: number): void;
|
|
}
|
|
export interface ClientResponse extends events.NodeEventEmitter, stream.ReadableStream {
|
|
statusCode: number;
|
|
httpVersion: string;
|
|
headers: any;
|
|
trailers: any;
|
|
setEncoding(encoding?: string): void;
|
|
pause(): void;
|
|
resume(): void;
|
|
}
|
|
export interface Agent { maxSockets: number; sockets: any; requests: any; }
|
|
|
|
export var STATUS_CODES: any;
|
|
export function createServer(requestListener?: (request: ServerRequest, response: ServerResponse) =>void ): Server;
|
|
export function createClient(port?: number, host?: string): any;
|
|
export function request(options: any, callback?: Function): ClientRequest;
|
|
export function get(options: any, callback?: Function): ClientRequest;
|
|
export var globalAgent: Agent;
|
|
}
|
|
|
|
declare module "cluster" {
|
|
import child = require("child_process");
|
|
import events = require("events");
|
|
|
|
export interface ClusterSettings {
|
|
exec?: string;
|
|
args?: string[];
|
|
silent?: boolean;
|
|
}
|
|
|
|
export class Worker extends events.EventEmitter {
|
|
id: string;
|
|
process: child.ChildProcess;
|
|
suicide: boolean;
|
|
send(message: any, sendHandle?: any): void;
|
|
kill(signal?: string): void;
|
|
destroy(signal?: string): void;
|
|
disconnect(): void;
|
|
}
|
|
|
|
export var settings: ClusterSettings;
|
|
export var isMaster: boolean;
|
|
export var isWorker: boolean;
|
|
export function setupMaster(settings?: ClusterSettings): void;
|
|
export function fork(env?: any): Worker;
|
|
export function disconnect(callback?: Function): void;
|
|
export var worker: Worker;
|
|
export var workers: Worker[];
|
|
|
|
// Event emitter
|
|
export function addListener(event: string, listener: Function): void;
|
|
export function on(event: string, listener: Function): any;
|
|
export function once(event: string, listener: Function): void;
|
|
export function removeListener(event: string, listener: Function): void;
|
|
export function removeAllListeners(event?: string): void;
|
|
export function setMaxListeners(n: number): void;
|
|
export function listeners(event: string): Function[];
|
|
export function emit(event: string, ...args: any[]): boolean;
|
|
}
|
|
|
|
declare module "zlib" {
|
|
import stream = require("stream");
|
|
export interface ZlibOptions { chunkSize?: number; windowBits?: number; level?: number; memLevel?: number; strategy?: number; dictionary?: any; }
|
|
|
|
export interface Gzip extends stream.ReadWriteStream { }
|
|
export interface Gunzip extends stream.ReadWriteStream { }
|
|
export interface Deflate extends stream.ReadWriteStream { }
|
|
export interface Inflate extends stream.ReadWriteStream { }
|
|
export interface DeflateRaw extends stream.ReadWriteStream { }
|
|
export interface InflateRaw extends stream.ReadWriteStream { }
|
|
export interface Unzip extends stream.ReadWriteStream { }
|
|
|
|
export function createGzip(options?: ZlibOptions): Gzip;
|
|
export function createGunzip(options?: ZlibOptions): Gunzip;
|
|
export function createDeflate(options?: ZlibOptions): Deflate;
|
|
export function createInflate(options?: ZlibOptions): Inflate;
|
|
export function createDeflateRaw(options?: ZlibOptions): DeflateRaw;
|
|
export function createInflateRaw(options?: ZlibOptions): InflateRaw;
|
|
export function createUnzip(options?: ZlibOptions): Unzip;
|
|
|
|
export function deflate(buf: NodeBuffer, callback: (error: Error, result: any) =>void ): void;
|
|
export function deflateRaw(buf: NodeBuffer, callback: (error: Error, result: any) =>void ): void;
|
|
export function gzip(buf: NodeBuffer, callback: (error: Error, result: any) =>void ): void;
|
|
export function gunzip(buf: NodeBuffer, callback: (error: Error, result: any) =>void ): void;
|
|
export function inflate(buf: NodeBuffer, callback: (error: Error, result: any) =>void ): void;
|
|
export function inflateRaw(buf: NodeBuffer, callback: (error: Error, result: any) =>void ): void;
|
|
export function unzip(buf: NodeBuffer, callback: (error: Error, result: any) =>void ): void;
|
|
|
|
// Constants
|
|
export var Z_NO_FLUSH: number;
|
|
export var Z_PARTIAL_FLUSH: number;
|
|
export var Z_SYNC_FLUSH: number;
|
|
export var Z_FULL_FLUSH: number;
|
|
export var Z_FINISH: number;
|
|
export var Z_BLOCK: number;
|
|
export var Z_TREES: number;
|
|
export var Z_OK: number;
|
|
export var Z_STREAM_END: number;
|
|
export var Z_NEED_DICT: number;
|
|
export var Z_ERRNO: number;
|
|
export var Z_STREAM_ERROR: number;
|
|
export var Z_DATA_ERROR: number;
|
|
export var Z_MEM_ERROR: number;
|
|
export var Z_BUF_ERROR: number;
|
|
export var Z_VERSION_ERROR: number;
|
|
export var Z_NO_COMPRESSION: number;
|
|
export var Z_BEST_SPEED: number;
|
|
export var Z_BEST_COMPRESSION: number;
|
|
export var Z_DEFAULT_COMPRESSION: number;
|
|
export var Z_FILTERED: number;
|
|
export var Z_HUFFMAN_ONLY: number;
|
|
export var Z_RLE: number;
|
|
export var Z_FIXED: number;
|
|
export var Z_DEFAULT_STRATEGY: number;
|
|
export var Z_BINARY: number;
|
|
export var Z_TEXT: number;
|
|
export var Z_ASCII: number;
|
|
export var Z_UNKNOWN: number;
|
|
export var Z_DEFLATED: number;
|
|
export var Z_NULL: number;
|
|
}
|
|
|
|
declare module "os" {
|
|
export function tmpDir(): string;
|
|
export function hostname(): string;
|
|
export function type(): string;
|
|
export function platform(): string;
|
|
export function arch(): string;
|
|
export function release(): string;
|
|
export function uptime(): number;
|
|
export function loadavg(): number[];
|
|
export function totalmem(): number;
|
|
export function freemem(): number;
|
|
export function cpus(): { model: string; speed: number; times: { user: number; nice: number; sys: number; idle: number; irq: number; }; }[];
|
|
export function networkInterfaces(): any;
|
|
export var EOL: string;
|
|
}
|
|
|
|
declare module "https" {
|
|
import tls = require("tls");
|
|
import events = require("events");
|
|
import http = require("http");
|
|
|
|
export interface ServerOptions {
|
|
pfx?: any;
|
|
key?: any;
|
|
passphrase?: string;
|
|
cert?: any;
|
|
ca?: any;
|
|
crl?: any;
|
|
ciphers?: string;
|
|
honorCipherOrder?: boolean;
|
|
requestCert?: boolean;
|
|
rejectUnauthorized?: boolean;
|
|
NPNProtocols?: any;
|
|
SNICallback?: (servername: string) => any;
|
|
}
|
|
|
|
export interface RequestOptions {
|
|
host?: string;
|
|
hostname?: string;
|
|
port?: number;
|
|
path?: string;
|
|
method?: string;
|
|
headers?: any;
|
|
auth?: string;
|
|
agent?: any;
|
|
pfx?: any;
|
|
key?: any;
|
|
passphrase?: string;
|
|
cert?: any;
|
|
ca?: any;
|
|
ciphers?: string;
|
|
rejectUnauthorized?: boolean;
|
|
}
|
|
|
|
export interface NodeAgent {
|
|
maxSockets: number;
|
|
sockets: any;
|
|
requests: any;
|
|
}
|
|
export var Agent: {
|
|
new (options?: RequestOptions): NodeAgent;
|
|
};
|
|
export interface Server extends tls.Server { }
|
|
export function createServer(options: ServerOptions, requestListener?: Function): Server;
|
|
export function request(options: RequestOptions, callback?: (res: events.NodeEventEmitter) =>void ): http.ClientRequest;
|
|
export function get(options: RequestOptions, callback?: (res: events.NodeEventEmitter) =>void ): http.ClientRequest;
|
|
export var globalAgent: NodeAgent;
|
|
}
|
|
|
|
declare module "punycode" {
|
|
export function decode(string: string): string;
|
|
export function encode(string: string): string;
|
|
export function toUnicode(domain: string): string;
|
|
export function toASCII(domain: string): string;
|
|
export var ucs2: ucs2;
|
|
interface ucs2 {
|
|
decode(string: string): string;
|
|
encode(codePoints: number[]): string;
|
|
}
|
|
export var version: any;
|
|
}
|
|
|
|
declare module "repl" {
|
|
import stream = require("stream");
|
|
import events = require("events");
|
|
|
|
export interface ReplOptions {
|
|
prompt?: string;
|
|
input?: stream.ReadableStream;
|
|
output?: stream.WritableStream;
|
|
terminal?: boolean;
|
|
eval?: Function;
|
|
useColors?: boolean;
|
|
useGlobal?: boolean;
|
|
ignoreUndefined?: boolean;
|
|
writer?: Function;
|
|
}
|
|
export function start(options: ReplOptions): events.NodeEventEmitter;
|
|
}
|
|
|
|
declare module "readline" {
|
|
import events = require("events");
|
|
import stream = require("stream");
|
|
|
|
export interface ReadLine extends events.NodeEventEmitter {
|
|
setPrompt(prompt: string, length: number): void;
|
|
prompt(preserveCursor?: boolean): void;
|
|
question(query: string, callback: Function): void;
|
|
pause(): void;
|
|
resume(): void;
|
|
close(): void;
|
|
write(data: any, key?: any): void;
|
|
}
|
|
export interface ReadLineOptions {
|
|
input: stream.ReadableStream;
|
|
output: stream.WritableStream;
|
|
completer?: Function;
|
|
terminal?: boolean;
|
|
}
|
|
export function createInterface(options: ReadLineOptions): ReadLine;
|
|
}
|
|
|
|
declare module "vm" {
|
|
export interface Context { }
|
|
export interface Script {
|
|
runInThisContext(): void;
|
|
runInNewContext(sandbox?: Context): void;
|
|
}
|
|
export function runInThisContext(code: string, filename?: string): void;
|
|
export function runInNewContext(code: string, sandbox?: Context, filename?: string): void;
|
|
export function runInContext(code: string, context: Context, filename?: string): void;
|
|
export function createContext(initSandbox?: Context): Context;
|
|
export function createScript(code: string, filename?: string): Script;
|
|
}
|
|
|
|
declare module "child_process" {
|
|
import events = require("events");
|
|
import stream = require("stream");
|
|
|
|
export interface ChildProcess extends events.NodeEventEmitter {
|
|
stdin: stream.WritableStream;
|
|
stdout: stream.ReadableStream;
|
|
stderr: stream.ReadableStream;
|
|
pid: number;
|
|
kill(signal?: string): void;
|
|
send(message: any, sendHandle: any): void;
|
|
disconnect(): void;
|
|
}
|
|
|
|
export function spawn(command: string, args?: string[], options?: {
|
|
cwd?: string;
|
|
stdio?: any;
|
|
custom?: any;
|
|
env?: any;
|
|
detached?: boolean;
|
|
}): ChildProcess;
|
|
export function exec(command: string, options: {
|
|
cwd?: string;
|
|
stdio?: any;
|
|
customFds?: any;
|
|
env?: any;
|
|
encoding?: string;
|
|
timeout?: number;
|
|
maxBuffer?: number;
|
|
killSignal?: string;
|
|
}, callback: (error: Error, stdout: NodeBuffer, stderr: NodeBuffer) =>void ): ChildProcess;
|
|
export function exec(command: string, callback: (error: Error, stdout: NodeBuffer, stderr: NodeBuffer) =>void ): ChildProcess;
|
|
export function execFile(file: string, args: string[], options: {
|
|
cwd?: string;
|
|
stdio?: any;
|
|
customFds?: any;
|
|
env?: any;
|
|
encoding?: string;
|
|
timeout?: number;
|
|
maxBuffer?: string;
|
|
killSignal?: string;
|
|
}, callback: (error: Error, stdout: NodeBuffer, stderr: NodeBuffer) =>void ): ChildProcess;
|
|
export function fork(modulePath: string, args?: string[], options?: {
|
|
cwd?: string;
|
|
env?: any;
|
|
encoding?: string;
|
|
}): ChildProcess;
|
|
}
|
|
|
|
declare module "url" {
|
|
export interface Url {
|
|
href: string;
|
|
protocol: string;
|
|
auth: string;
|
|
hostname: string;
|
|
port: string;
|
|
host: string;
|
|
pathname: string;
|
|
search: string;
|
|
query: string;
|
|
slashes: boolean;
|
|
}
|
|
|
|
export interface UrlOptions {
|
|
protocol?: string;
|
|
auth?: string;
|
|
hostname?: string;
|
|
port?: string;
|
|
host?: string;
|
|
pathname?: string;
|
|
search?: string;
|
|
query?: any;
|
|
}
|
|
|
|
export function parse(urlStr: string, parseQueryString?: boolean , slashesDenoteHost?: boolean ): Url;
|
|
export function format(url: UrlOptions): string;
|
|
export function resolve(from: string, to: string): string;
|
|
}
|
|
|
|
declare module "dns" {
|
|
export function lookup(domain: string, family: number, callback: (err: Error, address: string, family: number) =>void ): string;
|
|
export function lookup(domain: string, callback: (err: Error, address: string, family: number) =>void ): string;
|
|
export function resolve(domain: string, rrtype: string, callback: (err: Error, addresses: string[]) =>void ): string[];
|
|
export function resolve(domain: string, callback: (err: Error, addresses: string[]) =>void ): string[];
|
|
export function resolve4(domain: string, callback: (err: Error, addresses: string[]) =>void ): string[];
|
|
export function resolve6(domain: string, callback: (err: Error, addresses: string[]) =>void ): string[];
|
|
export function resolveMx(domain: string, callback: (err: Error, addresses: string[]) =>void ): string[];
|
|
export function resolveTxt(domain: string, callback: (err: Error, addresses: string[]) =>void ): string[];
|
|
export function resolveSrv(domain: string, callback: (err: Error, addresses: string[]) =>void ): string[];
|
|
export function resolveNs(domain: string, callback: (err: Error, addresses: string[]) =>void ): string[];
|
|
export function resolveCname(domain: string, callback: (err: Error, addresses: string[]) =>void ): string[];
|
|
export function reverse(ip: string, callback: (err: Error, domains: string[]) =>void ): string[];
|
|
}
|
|
|
|
declare module "net" {
|
|
import stream = require("stream");
|
|
|
|
export interface NodeSocket extends stream.ReadWriteStream {
|
|
// Extended base methods
|
|
write(str: string, encoding?: string, fd?: string): boolean;
|
|
write(buffer: NodeBuffer): boolean;
|
|
|
|
connect(port: number, host?: string, connectionListener?: Function): void;
|
|
connect(path: string, connectionListener?: Function): void;
|
|
bufferSize: number;
|
|
setEncoding(encoding?: string): void;
|
|
write(data: any, encoding?: string, callback?: Function): void;
|
|
end(data?: any, encoding?: string): void;
|
|
destroy(): void;
|
|
pause(): void;
|
|
resume(): void;
|
|
setTimeout(timeout: number, callback?: Function): void;
|
|
setNoDelay(noDelay?: boolean): void;
|
|
setKeepAlive(enable?: boolean, initialDelay?: number): void;
|
|
address(): { port: number; family: string; address: string; };
|
|
remoteAddress: string;
|
|
remotePort: number;
|
|
bytesRead: number;
|
|
bytesWritten: number;
|
|
}
|
|
|
|
export var Socket: {
|
|
new (options?: { fd?: string; type?: string; allowHalfOpen?: boolean; }): NodeSocket;
|
|
};
|
|
|
|
export interface Server extends NodeSocket {
|
|
listen(port: number, host?: string, backlog?: number, listeningListener?: Function): void;
|
|
listen(path: string, listeningListener?: Function): void;
|
|
listen(handle: any, listeningListener?: Function): void;
|
|
close(callback?: Function): void;
|
|
address(): { port: number; family: string; address: string; };
|
|
maxConnections: number;
|
|
connections: number;
|
|
}
|
|
export function createServer(connectionListener?: (socket: NodeSocket) =>void ): Server;
|
|
export function createServer(options?: { allowHalfOpen?: boolean; }, connectionListener?: (socket: NodeSocket) =>void ): Server;
|
|
export function connect(options: { allowHalfOpen?: boolean; }, connectionListener?: Function): NodeSocket;
|
|
export function connect(port: number, host?: string, connectionListener?: Function): NodeSocket;
|
|
export function connect(path: string, connectionListener?: Function): NodeSocket;
|
|
export function createConnection(options: { allowHalfOpen?: boolean; }, connectionListener?: Function): NodeSocket;
|
|
export function createConnection(port: number, host?: string, connectionListener?: Function): NodeSocket;
|
|
export function createConnection(path: string, connectionListener?: Function): NodeSocket;
|
|
export function isIP(input: string): number;
|
|
export function isIPv4(input: string): boolean;
|
|
export function isIPv6(input: string): boolean;
|
|
}
|
|
|
|
declare module "dgram" {
|
|
import events = require("events");
|
|
|
|
export function createSocket(type: string, callback?: Function): Socket;
|
|
|
|
interface Socket extends events.NodeEventEmitter {
|
|
send(buf: NodeBuffer, offset: number, length: number, port: number, address: string, callback?: Function): void;
|
|
bind(port: number, address?: string): void;
|
|
close(): void;
|
|
address: { address: string; family: string; port: number; };
|
|
setBroadcast(flag: boolean): void;
|
|
setMulticastTTL(ttl: number): void;
|
|
setMulticastLoopback(flag: boolean): void;
|
|
addMembership(multicastAddress: string, multicastInterface?: string): void;
|
|
dropMembership(multicastAddress: string, multicastInterface?: string): void;
|
|
}
|
|
}
|
|
|
|
declare module "fs" {
|
|
import stream = require("stream");
|
|
|
|
interface Stats {
|
|
isFile(): boolean;
|
|
isDirectory(): boolean;
|
|
isBlockDevice(): boolean;
|
|
isCharacterDevice(): boolean;
|
|
isSymbolicLink(): boolean;
|
|
isFIFO(): boolean;
|
|
isSocket(): boolean;
|
|
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;
|
|
}
|
|
|
|
interface FSWatcher extends EventEmitter {
|
|
close(): void;
|
|
}
|
|
|
|
export interface ReadStream extends stream.ReadableStream { }
|
|
export interface WriteStream extends stream.WritableStream { }
|
|
|
|
export function rename(oldPath: string, newPath: string, callback?: (err?: ErrnoException) => void): void;
|
|
export function renameSync(oldPath: string, newPath: string): void;
|
|
export function truncate(path: string, callback?: (err?: ErrnoException) => void): void;
|
|
export function truncate(path: string, len: number, callback?: (err?: ErrnoException) => void): void;
|
|
export function truncateSync(path: string, len?: number): void;
|
|
export function ftruncate(fd: number, callback?: (err?: ErrnoException) => void): void;
|
|
export function ftruncate(fd: number, len: number, callback?: (err?: ErrnoException) => void): void;
|
|
export function ftruncateSync(fd: number, len?: number): void;
|
|
export function chown(path: string, uid: number, gid: number, callback?: (err?: ErrnoException) => void): void;
|
|
export function chownSync(path: string, uid: number, gid: number): void;
|
|
export function fchown(fd: number, uid: number, gid: number, callback?: (err?: ErrnoException) => void): void;
|
|
export function fchownSync(fd: number, uid: number, gid: number): void;
|
|
export function lchown(path: string, uid: number, gid: number, callback?: (err?: ErrnoException) => void): void;
|
|
export function lchownSync(path: string, uid: number, gid: number): void;
|
|
export function chmod(path: string, mode: number, callback?: (err?: ErrnoException) => void): void;
|
|
export function chmod(path: string, mode: string, callback?: (err?: ErrnoException) => void): void;
|
|
export function chmodSync(path: string, mode: number): void;
|
|
export function chmodSync(path: string, mode: string): void;
|
|
export function fchmod(fd: number, mode: number, callback?: (err?: ErrnoException) => void): void;
|
|
export function fchmod(fd: number, mode: string, callback?: (err?: ErrnoException) => void): void;
|
|
export function fchmodSync(fd: number, mode: number): void;
|
|
export function fchmodSync(fd: number, mode: string): void;
|
|
export function lchmod(path: string, mode: number, callback?: (err?: ErrnoException) => void): void;
|
|
export function lchmod(path: string, mode: string, callback?: (err?: ErrnoException) => void): void;
|
|
export function lchmodSync(path: string, mode: number): void;
|
|
export function lchmodSync(path: string, mode: string): void;
|
|
export function stat(path: string, callback?: (err: ErrnoException, stats: Stats) => any): void;
|
|
export function lstat(path: string, callback?: (err: ErrnoException, stats: Stats) => any): void;
|
|
export function fstat(fd: number, callback?: (err: ErrnoException, stats: Stats) => any): void;
|
|
export function statSync(path: string): Stats;
|
|
export function lstatSync(path: string): Stats;
|
|
export function fstatSync(fd: number): Stats;
|
|
export function link(srcpath: string, dstpath: string, callback?: (err?: ErrnoException) => void): void;
|
|
export function linkSync(srcpath: string, dstpath: string): void;
|
|
export function symlink(srcpath: string, dstpath: string, type?: string, callback?: (err?: ErrnoException) => void): void;
|
|
export function symlinkSync(srcpath: string, dstpath: string, type?: string): void;
|
|
export function readlink(path: string, callback?: (err: ErrnoException, linkString: string) => any): void;
|
|
export function readlinkSync(path: string): string;
|
|
export function realpath(path: string, callback?: (err: ErrnoException, resolvedPath: string) => any): void;
|
|
export function realpath(path: string, cache: {[path: string]: string}, callback: (err: ErrnoException, resolvedPath: string) =>any): void;
|
|
export function realpathSync(path: string, cache?: {[path: string]: string}): void;
|
|
export function unlink(path: string, callback?: (err?: ErrnoException) => void): void;
|
|
export function unlinkSync(path: string): void;
|
|
export function rmdir(path: string, callback?: (err?: ErrnoException) => void): void;
|
|
export function rmdirSync(path: string): void;
|
|
export function mkdir(path: string, callback?: (err?: ErrnoException) => void): void;
|
|
export function mkdir(path: string, mode: number, callback?: (err?: ErrnoException) => void): void;
|
|
export function mkdir(path: string, mode: string, callback?: (err?: ErrnoException) => void): void;
|
|
export function mkdirSync(path: string, mode?: number): void;
|
|
export function mkdirSync(path: string, mode?: string): void;
|
|
export function readdir(path: string, callback?: (err: ErrnoException, files: string[]) => void): void;
|
|
export function readdirSync(path: string): string[];
|
|
export function close(fd: number, callback?: (err?: ErrnoException) => void): void;
|
|
export function closeSync(fd: number): void;
|
|
export function open(path: string, flags: string, callback?: (err: ErrnoException, fd: number) => any): void;
|
|
export function open(path: string, flags: string, mode: number, callback?: (err: ErrnoException, fd: number) => any): void;
|
|
export function open(path: string, flags: string, mode: string, callback?: (err: ErrnoException, fd: number) => any): void;
|
|
export function openSync(path: string, flags: string, mode?: number): number;
|
|
export function openSync(path: string, flags: string, mode?: string): number;
|
|
export function utimes(path: string, atime: number, mtime: number, callback?: (err?: ErrnoException) => void): void;
|
|
export function utimesSync(path: string, atime: number, mtime: number): void;
|
|
export function futimes(fd: number, atime: number, mtime: number, callback?: (err?: ErrnoException) => void): void;
|
|
export function futimesSync(fd: number, atime: number, mtime: number): void;
|
|
export function fsync(fd: number, callback?: (err?: ErrnoException) => void): void;
|
|
export function fsyncSync(fd: number): void;
|
|
export function write(fd: number, buffer: NodeBuffer, offset: number, length: number, position: number, callback?: (err: ErrnoException, written: number, buffer: NodeBuffer) => void): void;
|
|
export function writeSync(fd: number, buffer: NodeBuffer, offset: number, length: number, position: number): number;
|
|
export function read(fd: number, buffer: NodeBuffer, offset: number, length: number, position: number, callback?: (err: ErrnoException, bytesRead: number, buffer: NodeBuffer) => void): void;
|
|
export function readSync(fd: number, buffer: NodeBuffer, offset: number, length: number, position: number): number;
|
|
export function readFile(filename: string, options: { encoding?: string; flag?: string; }, callback: (err: ErrnoException, data: any) => void): void;
|
|
export function readFile(filename: string, callback: (err: ErrnoException, data: NodeBuffer) => void ): void;
|
|
export function readFileSync(filename: string, options?: { flag?: string; }): NodeBuffer;
|
|
export function readFileSync(filename: string, options: { encoding: string; flag?: string; }): string;
|
|
export function writeFile(filename: string, data: any, callback?: (err: ErrnoException) => void): void;
|
|
export function writeFile(filename: string, data: any, options: { encoding?: string; mode?: number; flag?: string; }, callback?: (err: ErrnoException) => void): void;
|
|
export function writeFile(filename: string, data: any, options: { encoding?: string; mode?: string; flag?: string; }, callback?: (err: ErrnoException) => void): void;
|
|
export function writeFileSync(filename: string, data: any, options?: { encoding?: string; mode?: number; flag?: string; }): void;
|
|
export function writeFileSync(filename: string, data: any, options?: { encoding?: string; mode?: string; flag?: string; }): void;
|
|
export function appendFile(filename: string, data: any, options: { encoding?: string; mode?: number; flag?: string; }, callback?: (err: ErrnoException) => void): void;
|
|
export function appendFile(filename: string, data: any, options: { encoding?: string; mode?: string; flag?: string; }, callback?: (err: ErrnoException) => void): void;
|
|
export function appendFile(filename: string, data: any, callback?: (err: ErrnoException) => void): void;
|
|
export function appendFileSync(filename: string, data: any, options?: { encoding?: string; mode?: number; flag?: string; }): void;
|
|
export function appendFileSync(filename: string, data: any, options?: { encoding?: string; mode?: string; flag?: string; }): void;
|
|
export function watchFile(filename: string, listener: (curr: Stats, prev: Stats) => void): void;
|
|
export function watchFile(filename: string, options: { persistent?: boolean; interval?: number; }, listener: (curr: Stats, prev: Stats) => void): void;
|
|
export function unwatchFile(filename: string, listener?: (curr: Stats, prev: Stats) => void): void;
|
|
export function watch(filename: string, listener?: (event: string, filename: string) => any): FSWatcher;
|
|
export function watch(filename: string, options: { persistent?: boolean; }, listener?: (event: string, filename: string) => any): FSWatcher;
|
|
export function exists(path: string, callback?: (exists: boolean) => void): void;
|
|
export function existsSync(path: string): boolean;
|
|
export function createReadStream(path: string, options?: {
|
|
flags?: string;
|
|
encoding?: string;
|
|
fd?: string;
|
|
mode?: number;
|
|
bufferSize?: number;
|
|
}): ReadStream;
|
|
export function createReadStream(path: string, options?: {
|
|
flags?: string;
|
|
encoding?: string;
|
|
fd?: string;
|
|
mode?: string;
|
|
bufferSize?: number;
|
|
}): ReadStream;
|
|
export function createWriteStream(path: string, options?: {
|
|
flags?: string;
|
|
encoding?: string;
|
|
string?: string;
|
|
}): WriteStream;
|
|
}
|
|
|
|
declare module "path" {
|
|
export function normalize(p: string): string;
|
|
export function join(...paths: any[]): string;
|
|
export function resolve(...pathSegments: any[]): string;
|
|
export function relative(from: string, to: string): string;
|
|
export function dirname(p: string): string;
|
|
export function basename(p: string, ext?: string): string;
|
|
export function extname(p: string): string;
|
|
export var sep: string;
|
|
}
|
|
|
|
declare module "string_decoder" {
|
|
export interface NodeStringDecoder {
|
|
write(buffer: NodeBuffer): string;
|
|
detectIncompleteChar(buffer: NodeBuffer): number;
|
|
}
|
|
export var StringDecoder: {
|
|
new (encoding: string): NodeStringDecoder;
|
|
};
|
|
}
|
|
|
|
declare module "tls" {
|
|
import crypto = require("crypto");
|
|
import net = require("net");
|
|
import stream = require("stream");
|
|
|
|
var CLIENT_RENEG_LIMIT: number;
|
|
var CLIENT_RENEG_WINDOW: number;
|
|
|
|
export interface TlsOptions {
|
|
pfx?: any; //string or buffer
|
|
key?: any; //string or buffer
|
|
passphrase?: string;
|
|
cert?: any;
|
|
ca?: any; //string or buffer
|
|
crl?: any; //string or string array
|
|
ciphers?: string;
|
|
honorCipherOrder?: any;
|
|
requestCert?: boolean;
|
|
rejectUnauthorized?: boolean;
|
|
NPNProtocols?: any; //array or Buffer;
|
|
SNICallback?: (servername: string) => any;
|
|
}
|
|
|
|
export interface ConnectionOptions {
|
|
host?: string;
|
|
port?: number;
|
|
socket?: net.NodeSocket;
|
|
pfx?: any; //string | Buffer
|
|
key?: any; //string | Buffer
|
|
passphrase?: string;
|
|
cert?: any; //string | Buffer
|
|
ca?: any; //Array of string | Buffer
|
|
rejectUnauthorized?: boolean;
|
|
NPNProtocols?: any; //Array of string | Buffer
|
|
servername?: string;
|
|
}
|
|
|
|
export interface Server extends net.Server {
|
|
// Extended base methods
|
|
listen(port: number, host?: string, backlog?: number, listeningListener?: Function): void;
|
|
listen(path: string, listeningListener?: Function): void;
|
|
listen(handle: any, listeningListener?: Function): void;
|
|
|
|
listen(port: number, host?: string, callback?: Function): void;
|
|
close(): void;
|
|
address(): { port: number; family: string; address: string; };
|
|
addContext(hostName: string, credentials: {
|
|
key: string;
|
|
cert: string;
|
|
ca: string;
|
|
}): void;
|
|
maxConnections: number;
|
|
connections: number;
|
|
}
|
|
|
|
export interface ClearTextStream extends stream.ReadWriteStream {
|
|
authorized: boolean;
|
|
authorizationError: Error;
|
|
getPeerCertificate(): any;
|
|
getCipher: {
|
|
name: string;
|
|
version: string;
|
|
};
|
|
address: {
|
|
port: number;
|
|
family: string;
|
|
address: string;
|
|
};
|
|
remoteAddress: string;
|
|
remotePort: number;
|
|
}
|
|
|
|
export interface SecurePair {
|
|
encrypted: any;
|
|
cleartext: any;
|
|
}
|
|
|
|
export function createServer(options: TlsOptions, secureConnectionListener?: (cleartextStream: ClearTextStream) =>void ): Server;
|
|
export function connect(options: TlsOptions, secureConnectionListener?: () =>void ): ClearTextStream;
|
|
export function connect(port: number, host?: string, options?: ConnectionOptions, secureConnectListener?: () =>void ): ClearTextStream;
|
|
export function connect(port: number, options?: ConnectionOptions, secureConnectListener?: () =>void ): ClearTextStream;
|
|
export function createSecurePair(credentials?: crypto.Credentials, isServer?: boolean, requestCert?: boolean, rejectUnauthorized?: boolean): SecurePair;
|
|
}
|
|
|
|
declare module "crypto" {
|
|
export interface CredentialDetails {
|
|
pfx: string;
|
|
key: string;
|
|
passphrase: string;
|
|
cert: string;
|
|
ca: any; //string | string array
|
|
crl: any; //string | string array
|
|
ciphers: string;
|
|
}
|
|
export interface Credentials { context?: any; }
|
|
export function createCredentials(details: CredentialDetails): Credentials;
|
|
export function createHash(algorithm: string): Hash;
|
|
export function createHmac(algorithm: string, key: string): Hmac;
|
|
interface Hash {
|
|
update(data: any, input_encoding?: string): Hash;
|
|
digest(encoding?: string): string;
|
|
}
|
|
interface Hmac {
|
|
update(data: any): void;
|
|
digest(encoding?: string): void;
|
|
}
|
|
export function createCipher(algorithm: string, password: any): Cipher;
|
|
export function createCipheriv(algorithm: string, key: any, iv: any): Cipher;
|
|
interface Cipher {
|
|
update(data: any, input_encoding?: string, output_encoding?: string): string;
|
|
final(output_encoding?: string): string;
|
|
setAutoPadding(auto_padding: boolean): void;
|
|
createDecipher(algorithm: string, password: any): Decipher;
|
|
createDecipheriv(algorithm: string, key: any, iv: any): Decipher;
|
|
}
|
|
interface Decipher {
|
|
update(data: any, input_encoding?: string, output_encoding?: string): void;
|
|
final(output_encoding?: string): string;
|
|
setAutoPadding(auto_padding: boolean): void;
|
|
}
|
|
export function createSign(algorithm: string): Signer;
|
|
interface Signer {
|
|
update(data: any): void;
|
|
sign(private_key: string, output_format: string): string;
|
|
}
|
|
export function createVerify(algorith: string): Verify;
|
|
interface Verify {
|
|
update(data: any): void;
|
|
verify(object: string, signature: string, signature_format?: string): boolean;
|
|
}
|
|
export function createDiffieHellman(prime_length: number): DiffieHellman;
|
|
export function createDiffieHellman(prime: number, encoding?: string): DiffieHellman;
|
|
interface DiffieHellman {
|
|
generateKeys(encoding?: string): string;
|
|
computeSecret(other_public_key: string, input_encoding?: string, output_encoding?: string): string;
|
|
getPrime(encoding?: string): string;
|
|
getGenerator(encoding: string): string;
|
|
getPublicKey(encoding?: string): string;
|
|
getPrivateKey(encoding?: string): string;
|
|
setPublicKey(public_key: string, encoding?: string): void;
|
|
setPrivateKey(public_key: string, encoding?: string): void;
|
|
}
|
|
export function getDiffieHellman(group_name: string): DiffieHellman;
|
|
export function pbkdf2(password: string, salt: string, iterations: number, keylen: number, callback: (err: Error, derivedKey: string) => any): void;
|
|
export function randomBytes(size: number): NodeBuffer;
|
|
export function randomBytes(size: number, callback: (err: Error, buf: NodeBuffer) =>void ): void;
|
|
export function pseudoRandomBytes(size: number): NodeBuffer;
|
|
export function pseudoRandomBytes(size: number, callback: (err: Error, buf: NodeBuffer) =>void ): void;
|
|
}
|
|
|
|
declare module "stream" {
|
|
import events = require("events");
|
|
|
|
export interface WritableStream extends events.NodeEventEmitter {
|
|
writable: boolean;
|
|
write(str: string, encoding?: string, fd?: string): boolean;
|
|
write(buffer: NodeBuffer): boolean;
|
|
end(): void;
|
|
end(str: string, enconding: string): void;
|
|
end(buffer: NodeBuffer): void;
|
|
destroy(): void;
|
|
destroySoon(): void;
|
|
}
|
|
|
|
export interface ReadableStream extends events.NodeEventEmitter {
|
|
readable: boolean;
|
|
setEncoding(encoding: string): void;
|
|
pause(): void;
|
|
resume(): void;
|
|
destroy(): void;
|
|
pipe<T extends WritableStream>(destination: T, options?: { end?: boolean; }): T;
|
|
}
|
|
|
|
export interface ReadableOptions {
|
|
highWaterMark?: number;
|
|
encoding?: string;
|
|
objectMode?: boolean;
|
|
}
|
|
|
|
export class Readable extends events.EventEmitter implements ReadableStream {
|
|
readable: boolean;
|
|
constructor(opts?: ReadableOptions);
|
|
setEncoding(encoding: string): void;
|
|
pause(): void;
|
|
resume(): void;
|
|
destroy(): void;
|
|
pipe<T extends WritableStream>(destination: T, options?: { end?: boolean; }): T;
|
|
_read(): void;
|
|
push(chunk: any, encoding?: string): boolean;
|
|
}
|
|
|
|
export interface ReadWriteStream extends ReadableStream, WritableStream { }
|
|
}
|
|
|
|
declare module "util" {
|
|
export interface InspectOptions {
|
|
showHidden?: boolean;
|
|
depth?: number;
|
|
colors?: boolean;
|
|
customInspect?: boolean;
|
|
}
|
|
|
|
export function format(format: any, ...param: any[]): string;
|
|
export function debug(string: string): void;
|
|
export function error(...param: any[]): void;
|
|
export function puts(...param: any[]): void;
|
|
export function print(...param: any[]): void;
|
|
export function log(string: string): void;
|
|
export function inspect(object: any, showHidden?: boolean, depth?: number, color?: boolean): string;
|
|
export function inspect(object: any, options: InspectOptions): string;
|
|
export function isArray(object: any): boolean;
|
|
export function isRegExp(object: any): boolean;
|
|
export function isDate(object: any): boolean;
|
|
export function isError(object: any): boolean;
|
|
export function inherits(constructor: any, superConstructor: any): void;
|
|
}
|
|
|
|
declare module "assert" {
|
|
function internal (value: any, message?: string): void;
|
|
module internal {
|
|
export class AssertionError implements Error {
|
|
name: string;
|
|
message: string;
|
|
actual: any;
|
|
expected: any;
|
|
operator: string;
|
|
generatedMessage: boolean;
|
|
|
|
constructor(options?: {message?: string; actual?: any; expected?: any;
|
|
operator?: string; stackStartFunction?: Function});
|
|
}
|
|
|
|
export function fail(actual?: any, expected?: any, message?: string, operator?: string): void;
|
|
export function ok(value: any, message?: string): void;
|
|
export function equal(actual: any, expected: any, message?: string): void;
|
|
export function notEqual(actual: any, expected: any, message?: string): void;
|
|
export function deepEqual(actual: any, expected: any, message?: string): void;
|
|
export function notDeepEqual(acutal: any, expected: any, message?: string): void;
|
|
export function strictEqual(actual: any, expected: any, message?: string): void;
|
|
export function notStrictEqual(actual: any, expected: any, message?: string): void;
|
|
export 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;
|
|
}
|
|
|
|
export 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;
|
|
}
|
|
|
|
export function ifError(value: any): void;
|
|
}
|
|
|
|
export = internal;
|
|
}
|
|
|
|
declare module "tty" {
|
|
import net = require("net");
|
|
|
|
export function isatty(fd: number): boolean;
|
|
export interface ReadStream extends net.NodeSocket {
|
|
isRaw: boolean;
|
|
setRawMode(mode: boolean): void;
|
|
}
|
|
export interface WriteStream extends net.NodeSocket {
|
|
columns: number;
|
|
rows: number;
|
|
}
|
|
}
|
|
|
|
declare module "domain" {
|
|
import events = require("events");
|
|
|
|
export class Domain extends events.EventEmitter {
|
|
run(fn: Function): void;
|
|
add(emitter: events.NodeEventEmitter): void;
|
|
remove(emitter: events.NodeEventEmitter): void;
|
|
bind(cb: (err: Error, data: any) => any): any;
|
|
intercept(cb: (data: any) => any): any;
|
|
dispose(): void;
|
|
|
|
addListener(event: string, listener: Function): Domain;
|
|
on(event: string, listener: Function): Domain;
|
|
once(event: string, listener: Function): Domain;
|
|
removeListener(event: string, listener: Function): Domain;
|
|
removeAllListeners(event?: string): Domain;
|
|
}
|
|
|
|
export function create(): Domain;
|
|
}
|