mirror of
https://github.com/Microsoft/vscode
synced 2024-08-27 13:00:58 +00:00
1354 lines
58 KiB
TypeScript
1354 lines
58 KiB
TypeScript
// Type definitions for Node.js v0.11.13
|
|
// Project: http://nodejs.org/
|
|
// Definitions by: Microsoft TypeScript <http://typescriptlang.org>, DefinitelyTyped <https://github.com/borisyankov/DefinitelyTyped>
|
|
// Definitions: https://github.com/borisyankov/DefinitelyTyped
|
|
|
|
/************************************************
|
|
* *
|
|
* Node.js v0.11.13 API *
|
|
* *
|
|
************************************************/
|
|
|
|
/************************************************
|
|
* *
|
|
* GLOBAL *
|
|
* *
|
|
************************************************/
|
|
declare var process: NodeJS.Process;
|
|
declare var global: any;
|
|
|
|
declare var __filename: string;
|
|
declare var __dirname: string;
|
|
|
|
// declare function setTimeout(callback: (...args: any[]) => void, ms: number, ...args: any[]): NodeJS.Timer;
|
|
// declare function clearTimeout(timeoutId: NodeJS.Timer): void;
|
|
// declare function setInterval(callback: (...args: any[]) => void, ms: number, ...args: any[]): NodeJS.Timer;
|
|
// declare function clearInterval(intervalId: NodeJS.Timer): 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 define: {
|
|
// (moduleName: string, dependencies: string[], callback: (...args: any[]) => any): any;
|
|
// (moduleName: string, dependencies: string[], definition: any): any;
|
|
// (moduleName: string, callback: (...args: any[]) => any): any;
|
|
// (moduleName: string, definition: any): any;
|
|
// (dependencies: string[], callback: (...args: any[]) => any): any;
|
|
// (dependencies: string[], definition: any): any;
|
|
// };
|
|
|
|
// declare var require: {
|
|
// toUrl(path: string): string;
|
|
// (moduleName: string): any;
|
|
// (dependencies: string[], callback: (...args: any[]) => any, errorback?: (err: any) => void): any;
|
|
// config(data: any): any;
|
|
// onError: Function;
|
|
// __$__nodeRequire<T>(moduleName: string): T;
|
|
// };
|
|
|
|
//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): Buffer;
|
|
new (size: number): Buffer;
|
|
// new (size: Uint8Array): Buffer;
|
|
new (array: any[]): Buffer;
|
|
prototype: Buffer;
|
|
isBuffer(obj: any): boolean;
|
|
byteLength(string: string, encoding?: string): number;
|
|
concat(list: Buffer[], totalLength?: number): Buffer;
|
|
};
|
|
|
|
|
|
// Buffer class
|
|
interface Buffer extends NodeBuffer {}
|
|
declare var Buffer: {
|
|
new (str: string, encoding?: string): Buffer;
|
|
new (size: number): Buffer;
|
|
// new (size: Uint8Array): Buffer;
|
|
new (array: any[]): Buffer;
|
|
prototype: Buffer;
|
|
isBuffer(obj: any): boolean;
|
|
byteLength(string: string, encoding?: string): number;
|
|
concat(list: Buffer[], totalLength?: number): Buffer;
|
|
};
|
|
|
|
/************************************************
|
|
* *
|
|
* GLOBAL INTERFACES *
|
|
* *
|
|
************************************************/
|
|
declare module NodeJS {
|
|
export interface ErrnoException extends Error {
|
|
errno?: any;
|
|
code?: string;
|
|
path?: string;
|
|
syscall?: string;
|
|
}
|
|
|
|
export 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;
|
|
}
|
|
|
|
export interface ReadableStream extends EventEmitter {
|
|
readable: boolean;
|
|
read(size?: number): any;
|
|
setEncoding(encoding: string): void;
|
|
pause(): void;
|
|
resume(): void;
|
|
pipe<T extends WritableStream>(destination: T, options?: { end?: boolean; }): T;
|
|
unpipe<T extends WritableStream>(destination?: T): void;
|
|
unshift(chunk: string): void;
|
|
unshift(chunk: Buffer): void;
|
|
wrap(oldStream: ReadableStream): ReadableStream;
|
|
}
|
|
|
|
export interface WritableStream extends EventEmitter {
|
|
writable: boolean;
|
|
write(buffer: Buffer, cb?: Function): boolean;
|
|
write(str: string, cb?: Function): boolean;
|
|
write(str: string, encoding?: string, cb?: Function): boolean;
|
|
end(): void;
|
|
end(buffer: Buffer, cb?: Function): void;
|
|
end(str: string, cb?: Function): void;
|
|
end(str: string, encoding?: string, cb?: Function): void;
|
|
}
|
|
|
|
export interface ReadWriteStream extends ReadableStream, WritableStream {}
|
|
|
|
export interface Process 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;
|
|
}
|
|
|
|
export interface Timer {
|
|
ref() : void;
|
|
unref() : void;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @deprecated
|
|
*/
|
|
interface NodeBuffer {
|
|
[index: number]: number;
|
|
write(string: string, offset?: number, length?: number, encoding?: string): number;
|
|
toString(encoding?: string, start?: number, end?: number): string;
|
|
toJSON(): any;
|
|
length: number;
|
|
copy(targetBuffer: Buffer, targetStart?: number, sourceStart?: number, sourceEnd?: number): number;
|
|
slice(start?: number, end?: number): Buffer;
|
|
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;
|
|
}
|
|
|
|
/************************************************
|
|
* *
|
|
* MODULES *
|
|
* *
|
|
************************************************/
|
|
declare module "buffer" {
|
|
export var INSPECT_MAX_BYTES: number;
|
|
}
|
|
|
|
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 class EventEmitter implements NodeJS.EventEmitter {
|
|
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.EventEmitter {
|
|
listen(port: number, hostname?: string, backlog?: number, callback?: Function): Server;
|
|
listen(path: string, callback?: Function): Server;
|
|
listen(handle: any, listeningListener?: Function): Server;
|
|
close(cb?: any): Server;
|
|
address(): { port: number; family: string; address: string; };
|
|
maxHeadersCount: number;
|
|
}
|
|
export interface ServerRequest extends events.EventEmitter, stream.Readable {
|
|
method: string;
|
|
url: string;
|
|
headers: any;
|
|
trailers: string;
|
|
httpVersion: string;
|
|
setEncoding(encoding?: string): void;
|
|
pause(): void;
|
|
resume(): void;
|
|
connection: net.Socket;
|
|
}
|
|
export interface ServerResponse extends events.EventEmitter, stream.Writable {
|
|
// Extended base methods
|
|
write(buffer: Buffer): boolean;
|
|
write(buffer: Buffer, cb?: Function): boolean;
|
|
write(str: string, cb?: Function): boolean;
|
|
write(str: string, encoding?: string, cb?: Function): boolean;
|
|
write(str: string, encoding?: string, fd?: string): 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;
|
|
|
|
// Extended base methods
|
|
end(): void;
|
|
end(buffer: Buffer, cb?: Function): void;
|
|
end(str: string, cb?: Function): void;
|
|
end(str: string, encoding?: string, cb?: Function): void;
|
|
end(data?: any, encoding?: string): void;
|
|
}
|
|
export interface ClientRequest extends events.EventEmitter, stream.Writable {
|
|
// Extended base methods
|
|
write(buffer: Buffer): boolean;
|
|
write(buffer: Buffer, cb?: Function): boolean;
|
|
write(str: string, cb?: Function): boolean;
|
|
write(str: string, encoding?: string, cb?: Function): boolean;
|
|
write(str: string, encoding?: string, fd?: string): boolean;
|
|
|
|
write(chunk: any, encoding?: string): void;
|
|
abort(): void;
|
|
setTimeout(timeout: number, callback?: Function): void;
|
|
setNoDelay(noDelay?: boolean): void;
|
|
setSocketKeepAlive(enable?: boolean, initialDelay?: number): void;
|
|
|
|
// Extended base methods
|
|
end(): void;
|
|
end(buffer: Buffer, cb?: Function): void;
|
|
end(str: string, cb?: Function): void;
|
|
end(str: string, encoding?: string, cb?: Function): void;
|
|
end(data?: any, encoding?: string): void;
|
|
}
|
|
export interface ClientResponse extends events.EventEmitter, stream.Readable {
|
|
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: {
|
|
[errorCode: number]: string;
|
|
[errorCode: string]: string;
|
|
};
|
|
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.Transform { }
|
|
export interface Gunzip extends stream.Transform { }
|
|
export interface Deflate extends stream.Transform { }
|
|
export interface Inflate extends stream.Transform { }
|
|
export interface DeflateRaw extends stream.Transform { }
|
|
export interface InflateRaw extends stream.Transform { }
|
|
export interface Unzip extends stream.Transform { }
|
|
|
|
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: Buffer, callback: (error: Error, result: any) =>void ): void;
|
|
export function deflateRaw(buf: Buffer, callback: (error: Error, result: any) =>void ): void;
|
|
export function gzip(buf: Buffer, callback: (error: Error, result: any) =>void ): void;
|
|
export function gunzip(buf: Buffer, callback: (error: Error, result: any) =>void ): void;
|
|
export function inflate(buf: Buffer, callback: (error: Error, result: any) =>void ): void;
|
|
export function inflateRaw(buf: Buffer, callback: (error: Error, result: any) =>void ): void;
|
|
export function unzip(buf: Buffer, 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 Agent {
|
|
maxSockets: number;
|
|
sockets: any;
|
|
requests: any;
|
|
}
|
|
export var Agent: {
|
|
new (options?: RequestOptions): Agent;
|
|
};
|
|
export interface Server extends tls.Server { }
|
|
export function createServer(options: ServerOptions, requestListener?: Function): Server;
|
|
export function request(options: RequestOptions, callback?: (res: events.EventEmitter) =>void ): http.ClientRequest;
|
|
export function get(options: RequestOptions, callback?: (res: events.EventEmitter) =>void ): http.ClientRequest;
|
|
export var globalAgent: Agent;
|
|
}
|
|
|
|
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?: NodeJS.ReadableStream;
|
|
output?: NodeJS.WritableStream;
|
|
terminal?: boolean;
|
|
eval?: Function;
|
|
useColors?: boolean;
|
|
useGlobal?: boolean;
|
|
ignoreUndefined?: boolean;
|
|
writer?: Function;
|
|
}
|
|
export function start(options: ReplOptions): events.EventEmitter;
|
|
}
|
|
|
|
declare module "readline" {
|
|
import events = require("events");
|
|
import stream = require("stream");
|
|
|
|
export interface ReadLine extends events.EventEmitter {
|
|
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: NodeJS.ReadableStream;
|
|
output: NodeJS.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.EventEmitter {
|
|
stdin: stream.Writable;
|
|
stdout: stream.Readable;
|
|
stderr: stream.Readable;
|
|
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: Buffer, stderr: Buffer) =>void ): ChildProcess;
|
|
export function exec(command: string, callback?: (error: Error, stdout: Buffer, stderr: Buffer) =>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: Buffer, stderr: Buffer) =>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: any; // string | Object
|
|
slashes: boolean;
|
|
hash?: string;
|
|
path?: string;
|
|
}
|
|
|
|
export interface UrlOptions {
|
|
protocol?: string;
|
|
auth?: string;
|
|
hostname?: string;
|
|
port?: string;
|
|
host?: string;
|
|
pathname?: string;
|
|
search?: string;
|
|
query?: any;
|
|
hash?: string;
|
|
path?: string;
|
|
}
|
|
|
|
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 Socket extends stream.Duplex {
|
|
// Extended base methods
|
|
write(buffer: Buffer): boolean;
|
|
write(buffer: Buffer, cb?: Function): boolean;
|
|
write(str: string, cb?: Function): boolean;
|
|
write(str: string, encoding?: string, cb?: Function): boolean;
|
|
write(str: string, encoding?: string, fd?: string): 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;
|
|
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;
|
|
|
|
// Extended base methods
|
|
end(): void;
|
|
end(buffer: Buffer, cb?: Function): void;
|
|
end(str: string, cb?: Function): void;
|
|
end(str: string, encoding?: string, cb?: Function): void;
|
|
end(data?: any, encoding?: string): void;
|
|
}
|
|
|
|
export var Socket: {
|
|
new (options?: { fd?: string; type?: string; allowHalfOpen?: boolean; }): Socket;
|
|
};
|
|
|
|
export interface Server extends Socket {
|
|
listen(port: number, host?: string, backlog?: number, listeningListener?: Function): Server;
|
|
listen(path: string, listeningListener?: Function): Server;
|
|
listen(handle: any, listeningListener?: Function): Server;
|
|
close(callback?: Function): Server;
|
|
address(): { port: number; family: string; address: string; };
|
|
maxConnections: number;
|
|
connections: number;
|
|
}
|
|
export function createServer(connectionListener?: (socket: Socket) =>void ): Server;
|
|
export function createServer(options?: { allowHalfOpen?: boolean; }, connectionListener?: (socket: Socket) =>void ): Server;
|
|
export function connect(options: { allowHalfOpen?: boolean; }, connectionListener?: Function): Socket;
|
|
export function connect(port: number, host?: string, connectionListener?: Function): Socket;
|
|
export function connect(path: string, connectionListener?: Function): Socket;
|
|
export function createConnection(options: { allowHalfOpen?: boolean; }, connectionListener?: Function): Socket;
|
|
export function createConnection(port: number, host?: string, connectionListener?: Function): Socket;
|
|
export function createConnection(path: string, connectionListener?: Function): Socket;
|
|
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");
|
|
|
|
interface RemoteInfo {
|
|
address: string;
|
|
port: number;
|
|
size: number;
|
|
}
|
|
|
|
interface AddressInfo {
|
|
address: string;
|
|
family: string;
|
|
port: number;
|
|
}
|
|
|
|
export function createSocket(type: string, callback?: (msg: Buffer, rinfo: RemoteInfo) => void): Socket;
|
|
|
|
interface Socket extends events.EventEmitter {
|
|
send(buf: Buffer, offset: number, length: number, port: number, address: string, callback?: (error: Error, bytes: number) => void): void;
|
|
bind(port: number, address?: string, callback?: () => void): void;
|
|
close(): void;
|
|
address(): AddressInfo;
|
|
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");
|
|
import events = require("events");
|
|
|
|
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;
|
|
birthtime: Date;
|
|
ctime: Date;
|
|
}
|
|
|
|
interface FSWatcher extends events.EventEmitter {
|
|
close(): void;
|
|
}
|
|
|
|
export interface ReadStream extends stream.Readable {}
|
|
export interface WriteStream extends stream.Writable {}
|
|
|
|
export function rename(oldPath: string, newPath: string, callback?: (err?: NodeJS.ErrnoException) => void): void;
|
|
export function renameSync(oldPath: string, newPath: string): void;
|
|
export function truncate(path: string, callback?: (err?: NodeJS.ErrnoException) => void): void;
|
|
export function truncate(path: string, len: number, callback?: (err?: NodeJS.ErrnoException) => void): void;
|
|
export function truncateSync(path: string, len?: number): void;
|
|
export function ftruncate(fd: number, callback?: (err?: NodeJS.ErrnoException) => void): void;
|
|
export function ftruncate(fd: number, len: number, callback?: (err?: NodeJS.ErrnoException) => void): void;
|
|
export function ftruncateSync(fd: number, len?: number): void;
|
|
export function chown(path: string, uid: number, gid: number, callback?: (err?: NodeJS.ErrnoException) => void): void;
|
|
export function chownSync(path: string, uid: number, gid: number): void;
|
|
export function fchown(fd: number, uid: number, gid: number, callback?: (err?: NodeJS.ErrnoException) => void): void;
|
|
export function fchownSync(fd: number, uid: number, gid: number): void;
|
|
export function lchown(path: string, uid: number, gid: number, callback?: (err?: NodeJS.ErrnoException) => void): void;
|
|
export function lchownSync(path: string, uid: number, gid: number): void;
|
|
export function chmod(path: string, mode: number, callback?: (err?: NodeJS.ErrnoException) => void): void;
|
|
export function chmod(path: string, mode: string, callback?: (err?: NodeJS.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?: NodeJS.ErrnoException) => void): void;
|
|
export function fchmod(fd: number, mode: string, callback?: (err?: NodeJS.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?: NodeJS.ErrnoException) => void): void;
|
|
export function lchmod(path: string, mode: string, callback?: (err?: NodeJS.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: NodeJS.ErrnoException, stats: Stats) => any): void;
|
|
export function lstat(path: string, callback?: (err: NodeJS.ErrnoException, stats: Stats) => any): void;
|
|
export function fstat(fd: number, callback?: (err: NodeJS.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?: NodeJS.ErrnoException) => void): void;
|
|
export function linkSync(srcpath: string, dstpath: string): void;
|
|
export function symlink(srcpath: string, dstpath: string, type?: string, callback?: (err?: NodeJS.ErrnoException) => void): void;
|
|
export function symlinkSync(srcpath: string, dstpath: string, type?: string): void;
|
|
export function readlink(path: string, callback?: (err: NodeJS.ErrnoException, linkString: string) => any): void;
|
|
export function readlinkSync(path: string): string;
|
|
export function realpath(path: string, callback?: (err: NodeJS.ErrnoException, resolvedPath: string) => any): void;
|
|
export function realpath(path: string, cache: {[path: string]: string}, callback: (err: NodeJS.ErrnoException, resolvedPath: string) =>any): void;
|
|
export function realpathSync(path: string, cache?: {[path: string]: string}): string;
|
|
export function unlink(path: string, callback?: (err?: NodeJS.ErrnoException) => void): void;
|
|
export function unlinkSync(path: string): void;
|
|
export function rmdir(path: string, callback?: (err?: NodeJS.ErrnoException) => void): void;
|
|
export function rmdirSync(path: string): void;
|
|
export function mkdir(path: string, callback?: (err?: NodeJS.ErrnoException) => void): void;
|
|
export function mkdir(path: string, mode: number, callback?: (err?: NodeJS.ErrnoException) => void): void;
|
|
export function mkdir(path: string, mode: string, callback?: (err?: NodeJS.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: NodeJS.ErrnoException, files: string[]) => void): void;
|
|
export function readdirSync(path: string): string[];
|
|
export function close(fd: number, callback?: (err?: NodeJS.ErrnoException) => void): void;
|
|
export function closeSync(fd: number): void;
|
|
export function open(path: string, flags: string, callback?: (err: NodeJS.ErrnoException, fd: number) => any): void;
|
|
export function open(path: string, flags: string, mode: number, callback?: (err: NodeJS.ErrnoException, fd: number) => any): void;
|
|
export function open(path: string, flags: string, mode: string, callback?: (err: NodeJS.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?: NodeJS.ErrnoException) => void): void;
|
|
export function utimes(path: string, atime: Date, mtime: Date, callback?: (err?: NodeJS.ErrnoException) => void): void;
|
|
export function utimesSync(path: string, atime: number, mtime: number): void;
|
|
export function utimesSync(path: string, atime: Date, mtime: Date): void;
|
|
export function futimes(fd: number, atime: number, mtime: number, callback?: (err?: NodeJS.ErrnoException) => void): void;
|
|
export function futimes(fd: number, atime: Date, mtime: Date, callback?: (err?: NodeJS.ErrnoException) => void): void;
|
|
export function futimesSync(fd: number, atime: number, mtime: number): void;
|
|
export function futimesSync(fd: number, atime: Date, mtime: Date): void;
|
|
export function fsync(fd: number, callback?: (err?: NodeJS.ErrnoException) => void): void;
|
|
export function fsyncSync(fd: number): void;
|
|
export function write(fd: number, buffer: Buffer, offset: number, length: number, position: number, callback?: (err: NodeJS.ErrnoException, written: number, buffer: Buffer) => void): void;
|
|
export function writeSync(fd: number, buffer: Buffer, offset: number, length: number, position: number): number;
|
|
export function read(fd: number, buffer: Buffer, offset: number, length: number, position: number, callback?: (err: NodeJS.ErrnoException, bytesRead: number, buffer: Buffer) => void): void;
|
|
export function readSync(fd: number, buffer: Buffer, offset: number, length: number, position: number): number;
|
|
export function readFile(filename: string, encoding: string, callback: (err: NodeJS.ErrnoException, data: string) => void): void;
|
|
export function readFile(filename: string, options: { encoding: string; flag?: string; }, callback: (err: NodeJS.ErrnoException, data: string) => void): void;
|
|
export function readFile(filename: string, options: { flag?: string; }, callback: (err: NodeJS.ErrnoException, data: Buffer) => void): void;
|
|
export function readFile(filename: string, callback: (err: NodeJS.ErrnoException, data: Buffer) => void ): void;
|
|
export function readFileSync(filename: string, encoding: string): string;
|
|
export function readFileSync(filename: string, options: { encoding: string; flag?: string; }): string;
|
|
export function readFileSync(filename: string, options?: { flag?: string; }): Buffer;
|
|
export function writeFile(filename: string, data: any, callback?: (err: NodeJS.ErrnoException) => void): void;
|
|
export function writeFile(filename: string, data: any, options: { encoding?: string; mode?: number; flag?: string; }, callback?: (err: NodeJS.ErrnoException) => void): void;
|
|
export function writeFile(filename: string, data: any, options: { encoding?: string; mode?: string; flag?: string; }, callback?: (err: NodeJS.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: NodeJS.ErrnoException) => void): void;
|
|
export function appendFile(filename: string, data: any, options: { encoding?: string; mode?: string; flag?: string; }, callback?: (err: NodeJS.ErrnoException) => void): void;
|
|
export function appendFile(filename: string, data: any, callback?: (err: NodeJS.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: Buffer): string;
|
|
detectIncompleteChar(buffer: Buffer): 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.Socket;
|
|
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): Server;
|
|
listen(path: string, listeningListener?: Function): Server;
|
|
listen(handle: any, listeningListener?: Function): Server;
|
|
|
|
listen(port: number, host?: string, callback?: Function): Server;
|
|
close(): Server;
|
|
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.Duplex {
|
|
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;
|
|
export function createHmac(algorithm: string, key: Buffer): Hmac;
|
|
interface Hash {
|
|
update(data: any, input_encoding?: string): Hash;
|
|
digest(encoding: 'buffer'): Buffer;
|
|
digest(encoding: string): any;
|
|
digest(): Buffer;
|
|
}
|
|
interface Hmac {
|
|
update(data: any, input_encoding?: string): Hmac;
|
|
digest(encoding: 'buffer'): Buffer;
|
|
digest(encoding: string): any;
|
|
digest(): Buffer;
|
|
}
|
|
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;
|
|
}
|
|
export function createDecipher(algorithm: string, password: any): Decipher;
|
|
export function 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: Buffer) => any): void;
|
|
export function pbkdf2Sync(password: string, salt: string, iterations: number, keylen: number) : Buffer;
|
|
export function randomBytes(size: number): Buffer;
|
|
export function randomBytes(size: number, callback: (err: Error, buf: Buffer) =>void ): void;
|
|
export function pseudoRandomBytes(size: number): Buffer;
|
|
export function pseudoRandomBytes(size: number, callback: (err: Error, buf: Buffer) =>void ): void;
|
|
}
|
|
|
|
declare module "stream" {
|
|
import events = require("events");
|
|
|
|
export interface Stream extends events.EventEmitter {
|
|
pipe<T extends NodeJS.WritableStream>(destination: T, options?: { end?: boolean; }): T;
|
|
}
|
|
|
|
export interface ReadableOptions {
|
|
highWaterMark?: number;
|
|
encoding?: string;
|
|
objectMode?: boolean;
|
|
}
|
|
|
|
export class Readable extends events.EventEmitter implements NodeJS.ReadableStream {
|
|
readable: boolean;
|
|
constructor(opts?: ReadableOptions);
|
|
_read(size: number): void;
|
|
read(size?: number): any;
|
|
setEncoding(encoding: string): void;
|
|
pause(): void;
|
|
resume(): void;
|
|
pipe<T extends NodeJS.WritableStream>(destination: T, options?: { end?: boolean; }): T;
|
|
unpipe<T extends NodeJS.WritableStream>(destination?: T): void;
|
|
unshift(chunk: string): void;
|
|
unshift(chunk: Buffer): void;
|
|
wrap(oldStream: NodeJS.ReadableStream): NodeJS.ReadableStream;
|
|
push(chunk: any, encoding?: string): boolean;
|
|
}
|
|
|
|
export interface WritableOptions {
|
|
highWaterMark?: number;
|
|
decodeStrings?: boolean;
|
|
}
|
|
|
|
export class Writable extends events.EventEmitter implements NodeJS.WritableStream {
|
|
writable: boolean;
|
|
constructor(opts?: WritableOptions);
|
|
_write(data: Buffer, encoding: string, callback: Function): void;
|
|
_write(data: string, encoding: string, callback: Function): void;
|
|
write(buffer: Buffer, cb?: Function): boolean;
|
|
write(str: string, cb?: Function): boolean;
|
|
write(str: string, encoding?: string, cb?: Function): boolean;
|
|
end(): void;
|
|
end(buffer: Buffer, cb?: Function): void;
|
|
end(str: string, cb?: Function): void;
|
|
end(str: string, encoding?: string, cb?: Function): void;
|
|
}
|
|
|
|
export interface DuplexOptions extends ReadableOptions, WritableOptions {
|
|
allowHalfOpen?: boolean;
|
|
}
|
|
|
|
// Note: Duplex extends both Readable and Writable.
|
|
export class Duplex extends Readable implements NodeJS.ReadWriteStream {
|
|
writable: boolean;
|
|
constructor(opts?: DuplexOptions);
|
|
_write(data: Buffer, encoding: string, callback: Function): void;
|
|
_write(data: string, encoding: string, callback: Function): void;
|
|
write(buffer: Buffer, cb?: Function): boolean;
|
|
write(str: string, cb?: Function): boolean;
|
|
write(str: string, encoding?: string, cb?: Function): boolean;
|
|
end(): void;
|
|
end(buffer: Buffer, cb?: Function): void;
|
|
end(str: string, cb?: Function): void;
|
|
end(str: string, encoding?: string, cb?: Function): void;
|
|
}
|
|
|
|
export interface TransformOptions extends ReadableOptions, WritableOptions {}
|
|
|
|
// Note: Transform lacks the _read and _write methods of Readable/Writable.
|
|
export class Transform extends events.EventEmitter implements NodeJS.ReadWriteStream {
|
|
readable: boolean;
|
|
writable: boolean;
|
|
constructor(opts?: TransformOptions);
|
|
_transform(chunk: Buffer, encoding: string, callback: Function): void;
|
|
_transform(chunk: string, encoding: string, callback: Function): void;
|
|
_flush(callback: Function): void;
|
|
read(size?: number): any;
|
|
setEncoding(encoding: string): void;
|
|
pause(): void;
|
|
resume(): void;
|
|
pipe<T extends NodeJS.WritableStream>(destination: T, options?: { end?: boolean; }): T;
|
|
unpipe<T extends NodeJS.WritableStream>(destination?: T): void;
|
|
unshift(chunk: string): void;
|
|
unshift(chunk: Buffer): void;
|
|
wrap(oldStream: NodeJS.ReadableStream): NodeJS.ReadableStream;
|
|
push(chunk: any, encoding?: string): boolean;
|
|
write(buffer: Buffer, cb?: Function): boolean;
|
|
write(str: string, cb?: Function): boolean;
|
|
write(str: string, encoding?: string, cb?: Function): boolean;
|
|
end(): void;
|
|
end(buffer: Buffer, cb?: Function): void;
|
|
end(str: string, cb?: Function): void;
|
|
end(str: string, encoding?: string, cb?: Function): void;
|
|
}
|
|
|
|
export class PassThrough extends Transform {}
|
|
}
|
|
|
|
declare module "util" {
|
|
export interface InspectOptions {
|
|
showHidden?: boolean;
|
|
depth?: number;
|
|
colors?: boolean;
|
|
customInspect?: boolean;
|
|
}
|
|
|
|
export function format(format: any, ...param: any[]): string;
|
|
export function deprecate(fn: Function, msg: string): Function;
|
|
export function debuglog(set: string): Function;
|
|
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 isBoolean(arg: any): boolean;
|
|
export function isNull(arg: any): boolean;
|
|
export function isNullOrUndefined(arg: any): boolean;
|
|
export function isNumber(arg: any): boolean;
|
|
export function isString(arg: any): boolean;
|
|
export function isSymbol(arg: any): boolean;
|
|
export function isUndefined(arg: any): boolean;
|
|
export function isRegExp(arg: any): boolean;
|
|
export function isObject(arg: any): boolean;
|
|
export function isDate(arg: any): boolean;
|
|
export function isError(arg: any): boolean;
|
|
export function isFunction(arg: any): boolean;
|
|
export function isPrimitive(arg: any): boolean;
|
|
export function isBuffer(arg: any): boolean;
|
|
export function log(...arg: any[]): void
|
|
export function inherits(constructor: any, superConstructor: any): void;
|
|
export function p(...arg: any[]): void;
|
|
export function exec(...arg: any[]): void;
|
|
export function print(...arg: any[]): void;
|
|
export function puts(...arg: any[]): void;
|
|
export function debug(string: string): void;
|
|
export function error(...arg: 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.Socket {
|
|
isRaw: boolean;
|
|
setRawMode(mode: boolean): void;
|
|
}
|
|
export interface WriteStream extends net.Socket {
|
|
columns: number;
|
|
rows: number;
|
|
}
|
|
}
|
|
|
|
declare module "domain" {
|
|
import events = require("events");
|
|
|
|
export class Domain extends events.EventEmitter {
|
|
run(fn: Function): void;
|
|
add(emitter: events.EventEmitter): void;
|
|
remove(emitter: events.EventEmitter): 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;
|
|
}
|