+
@@ -59,6 +59,10 @@
+
+
+
+
diff --git a/src/citasalud/apps/api/serializers.py b/src/citasalud/apps/api/serializers.py
index 5e24c13..7f4e2c8 100644
--- a/src/citasalud/apps/api/serializers.py
+++ b/src/citasalud/apps/api/serializers.py
@@ -1,35 +1,35 @@
# coding=utf-8
from rest_framework import serializers
-from citasalud.apps.main.models import PerfilMedico, Especialidad
+from citasalud.apps.main.models import PerfilUsuario, Medico, Especialidad
+from django.contrib.auth.models import User
-class DynamicFieldsModelSerializer(serializers.ModelSerializer):
- """
- A ModelSerializer that takes an additional `fields` argument that
- controls which fields should be displayed.
- """
+class PerfilUsuarioSerializer(serializers.ModelSerializer):
+ """ Serializador para Perfil de Usuario """
+
+ class Meta:
+ model = PerfilUsuario
- def __init__(self, *args, **kwargs):
- # Don't pass the 'fields' arg up to the superclass
- fields = kwargs.pop('fields', None)
- # Instantiate the superclass normally
- super(DynamicFieldsModelSerializer, self).__init__(*args, **kwargs)
+class UsuarioSerializer(serializers.ModelSerializer):
+ profile = PerfilUsuarioSerializer()
- if fields is not None:
- # Drop any fields that are not specified in the `fields` argument.
- allowed = set(fields)
- existing = set(self.fields.keys())
- for field_name in existing - allowed:
- self.fields.pop(field_name)
+ class Meta:
+ model = User
+ fields = ('username', 'email', 'profile', 'is_active')
+ def create(self, validated_data):
+ profile_data = validated_data.pop('profile')
+ user = User.objects.create(**validated_data)
+ Profile.objects.create(user=user, **profile_data)
+ return user
-class MedicoSerializer(DynamicFieldsModelSerializer):
+class MedicoSerializer(serializers.ModelSerializer):
""" Serializador para Médico """
class Meta:
- model = PerfilMedico
+ model = Medico
# extra_kwargs = {'password': {'write_only': True}}
diff --git a/src/citasalud/apps/api/views.py b/src/citasalud/apps/api/views.py
new file mode 100644
index 0000000..6bf127f
--- /dev/null
+++ b/src/citasalud/apps/api/views.py
@@ -0,0 +1,13 @@
+# coding=utf-8
+from rest_framework.views import APIView
+from rest_framework.response import Response
+from rest_framework import authentication, permissions
+from .serializers import UsuarioSerializer
+
+class CurrentUserView(APIView):
+ authentication_classes = (authentication.TokenAuthentication,)
+ permission_classes = (permissions.IsAuthenticated,)
+
+ def get(self, request):
+ serializer = UsuarioSerializer(request.user)
+ return Response(serializer.data)
\ No newline at end of file
diff --git a/src/citasalud/apps/api/viewsets.py b/src/citasalud/apps/api/viewsets.py
index 2755c81..9e796d5 100644
--- a/src/citasalud/apps/api/viewsets.py
+++ b/src/citasalud/apps/api/viewsets.py
@@ -1,11 +1,16 @@
-from ..main.models import PerfilMedico, Especialidad
-from .serializers import MedicoSerializer, EspecialidadSerializer
+from ..main.models import Medico, Especialidad, User
+from .serializers import UsuarioSerializer, MedicoSerializer, EspecialidadSerializer
from rest_framework import viewsets
+class UsuarioViewSet(viewsets.ModelViewSet):
+ serializer_class = UsuarioSerializer
+ queryset = User.objects.all()
+
+
class MedicoViewSet(viewsets.ModelViewSet):
serializer_class = MedicoSerializer
- queryset = PerfilMedico.objects.all()
+ queryset = Medico.objects.all()
class EspecialidadViewSet(viewsets.ModelViewSet):
diff --git a/src/citasalud/apps/main/admin.py b/src/citasalud/apps/main/admin.py
index be4f8a5..ee2b553 100644
--- a/src/citasalud/apps/main/admin.py
+++ b/src/citasalud/apps/main/admin.py
@@ -1,7 +1,7 @@
# coding=utf-8
from django.contrib import admin
-from .models import PerfilUsuario, Especialidad, CitaMedica, PerfilMedico, PerfilPaciente, PerfilPersonal
+from .models import PerfilUsuario, Especialidad, CitaMedica, Medico, Paciente, Personal
# from django.contrib.auth.admin import UserAdmin
@@ -13,9 +13,9 @@
# )
# ordering = []
admin.site.register(PerfilUsuario)
-admin.site.register(PerfilPaciente)
-admin.site.register(PerfilPersonal)
-admin.site.register(PerfilMedico)
+admin.site.register(Paciente)
+admin.site.register(Personal)
+admin.site.register(Medico)
admin.site.register(CitaMedica)
admin.site.register(Especialidad)
# admin.site.register(Usuario, UsuarioAdmin)
diff --git a/src/citasalud/apps/main/models.py b/src/citasalud/apps/main/models.py
index 3dd9f64..438e356 100644
--- a/src/citasalud/apps/main/models.py
+++ b/src/citasalud/apps/main/models.py
@@ -6,7 +6,7 @@
class PerfilUsuario(models.Model):
- usuario = models.OneToOneField(User)
+ usuario = models.OneToOneField(User, related_name="profile", null=True, blank=True)
activado = models.BooleanField("Usuario activado")
dni = DNIField("DNI", unique=True)
@@ -41,25 +41,25 @@ def __unicode__(self):
# return True
-class PerfilPaciente(models.Model):
+class Paciente(models.Model):
usuario = models.OneToOneField('PerfilUsuario')
nss = PrimaryNumberField("NSS", digits=9)
def __unicode__(self):
- return "%s, %s (%s)" % (self.apellidos, self.nombre, self.nss)
+ return "%s (%s)" % (self.usuario.get_short_name(), self.nss)
class Meta:
verbose_name = "Paciente"
verbose_name_plural = "Pacientes"
-class PerfilPersonal(models.Model):
+class Personal(models.Model):
usuario = models.OneToOneField('PerfilUsuario')
nregistropersonal = PrimaryNumberField("N° Registro personal")
departamento = models.CharField("Departamento", max_length=32)
-class PerfilMedico(PerfilPersonal):
+class Medico(Personal):
ncolegiado = PrimaryNumberField("N° Colegiado")
especialidades = models.ManyToManyField("Especialidad", blank=True, related_name='especialidades')
@@ -68,7 +68,7 @@ def tipo(self):
return TIPO_MEDICO.ESPECIALISTA if self.especialidades else TIPO_MEDICO.GENERAL
def __unicode__(self):
- return "%s, %s (%s)" % (self.apellidos, self.nombre, self.ncolegiado)
+ return "%s (%s)" % (self.usuario.get_short_name(), self.ncolegiado)
class Meta:
verbose_name = "Médico"
@@ -78,7 +78,7 @@ class Meta:
class Especialidad(models.Model):
id = models.CharField("ID Especialidad", max_length=5, primary_key=True)
- nombre = models.CharField("Nombre", max_length=32)
+ nombre = models.CharField("Nombre", max_length=64)
def __unicode__(self):
return "%s - %s" % (self.id, self.nombre)
@@ -91,7 +91,7 @@ class Meta:
class CitaMedica(models.Model):
historia = models.ForeignKey("HistoriaClinica")
- medico = models.ForeignKey("PerfilMedico")
+ medico = models.ForeignKey("Medico")
horario = models.DateTimeField("Hora de cita")
asistio = models.BooleanField()
@@ -99,6 +99,6 @@ class Meta:
verbose_name = u"Cita médica"
verbose_name_plural = "Citas médicas"
-
+
class HistoriaClinica(models.Model):
- paciente = models.OneToOneField("PerfilPaciente")
\ No newline at end of file
+ paciente = models.OneToOneField("Paciente")
\ No newline at end of file
diff --git a/src/citasalud/apps/main/tests.py b/src/citasalud/apps/main/tests.py
deleted file mode 100644
index 7ce503c..0000000
--- a/src/citasalud/apps/main/tests.py
+++ /dev/null
@@ -1,3 +0,0 @@
-from django.test import TestCase
-
-# Create your tests here.
diff --git a/src/citasalud/apps/main/views.py b/src/citasalud/apps/main/views.py
deleted file mode 100644
index 91ea44a..0000000
--- a/src/citasalud/apps/main/views.py
+++ /dev/null
@@ -1,3 +0,0 @@
-from django.shortcuts import render
-
-# Create your views here.
diff --git a/src/citasalud/db.sqlite3 b/src/citasalud/db.sqlite3
index e336001..a32eee6 100644
Binary files a/src/citasalud/db.sqlite3 and b/src/citasalud/db.sqlite3 differ
diff --git a/src/citasalud/settings/__init__.py b/src/citasalud/settings/__init__.py
index 3174739..66b9c25 100644
--- a/src/citasalud/settings/__init__.py
+++ b/src/citasalud/settings/__init__.py
@@ -39,6 +39,7 @@
'django.contrib.staticfiles',
'localflavor',
'rest_framework',
+ 'rest_framework.authtoken',
'citasalud.apps.main',
)
@@ -86,6 +87,17 @@
}
}
+#DATABASES = {
+# 'default': {
+# 'ENGINE': 'django.db.backends.mysql',
+# 'NAME': 'citasalud',
+# 'USER': 'root',
+# 'PASSWORD': 'LU7412369',
+# 'HOST': 'dev',
+# 'PORT': '',
+# }
+#}
+
# Internationalization
# https://docs.djangoproject.com/en/1.7/topics/i18n/
diff --git a/src/citasalud/settings/djrf.py b/src/citasalud/settings/djrf.py
index 9b048c6..686549a 100644
--- a/src/citasalud/settings/djrf.py
+++ b/src/citasalud/settings/djrf.py
@@ -3,5 +3,8 @@
# or allow read-only access for unauthenticated users.
'DEFAULT_PERMISSION_CLASSES': [
'rest_framework.permissions.DjangoModelPermissionsOrAnonReadOnly'
- ]
+ ],
+ 'DEFAULT_AUTHENTICATION_CLASSES': (
+ 'rest_framework.authentication.TokenAuthentication',
+ )
}
diff --git a/src/citasalud/urls.py b/src/citasalud/urls.py
index fb5f374..1ccc1bb 100644
--- a/src/citasalud/urls.py
+++ b/src/citasalud/urls.py
@@ -1,22 +1,26 @@
from django.conf.urls import include, url
from django.contrib import admin
-from citasalud.apps.api.viewsets import MedicoViewSet, EspecialidadViewSet
+from citasalud.apps.api.viewsets import MedicoViewSet, EspecialidadViewSet, UsuarioViewSet
from rest_framework.routers import DefaultRouter
-
+from rest_framework.authtoken import views
+from citasalud.apps.api.views import CurrentUserView
admin.autodiscover()
router = DefaultRouter()
router.register(r'medicos', MedicoViewSet)
router.register(r'especialidades', EspecialidadViewSet)
+router.register(r'usuarios', UsuarioViewSet)
urlpatterns = [
# Examples:
# url(r'^$', 'citasalud.views.home', name='home'),
# url(r'^blog/', include('blog.urls')),
- url(r'^', include(router.urls)),
+ url(r'^api/currentuser', CurrentUserView.as_view() ),
+ url(r'^api/', include(router.urls)),
url(r'^api-auth/', include('rest_framework.urls', namespace='rest_framework')),
+ url(r'^api-auth-token/', views.obtain_auth_token),
url(r'^admin/', include(admin.site.urls)),
]
diff --git a/typings/node/node.d.ts b/typings/node/node.d.ts
new file mode 100644
index 0000000..2543cca
--- /dev/null
+++ b/typings/node/node.d.ts
@@ -0,0 +1,1520 @@
+// Type definitions for Node.js v0.12.0
+// Project: http://nodejs.org/
+// Definitions by: Microsoft TypeScript , DefinitelyTyped
+// Definitions: https://github.com/borisyankov/DefinitelyTyped
+
+/************************************************
+* *
+* Node.js v0.12.0 API *
+* *
+************************************************/
+
+/************************************************
+* *
+* GLOBAL *
+* *
+************************************************/
+declare var process: NodeJS.Process;
+declare var global: NodeJS.Global;
+
+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 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?: number;
+ 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): string|Buffer;
+ setEncoding(encoding: string): void;
+ pause(): void;
+ resume(): void;
+ pipe(destination: T, options?: { end?: boolean; }): T;
+ unpipe(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 Global {
+ Array: typeof Array;
+ ArrayBuffer: typeof ArrayBuffer;
+ Boolean: typeof Boolean;
+ Buffer: typeof Buffer;
+ DataView: typeof DataView;
+ Date: typeof Date;
+ Error: typeof Error;
+ EvalError: typeof EvalError;
+ Float32Array: typeof Float32Array;
+ Float64Array: typeof Float64Array;
+ Function: typeof Function;
+ GLOBAL: Global;
+ Infinity: typeof Infinity;
+ Int16Array: typeof Int16Array;
+ Int32Array: typeof Int32Array;
+ Int8Array: typeof Int8Array;
+ Intl: typeof Intl;
+ JSON: typeof JSON;
+ Map: typeof Map;
+ Math: typeof Math;
+ NaN: typeof NaN;
+ Number: typeof Number;
+ Object: typeof Object;
+ Promise: Function;
+ RangeError: typeof RangeError;
+ ReferenceError: typeof ReferenceError;
+ RegExp: typeof RegExp;
+ Set: typeof Set;
+ String: typeof String;
+ Symbol: Function;
+ SyntaxError: typeof SyntaxError;
+ TypeError: typeof TypeError;
+ URIError: typeof URIError;
+ Uint16Array: typeof Uint16Array;
+ Uint32Array: typeof Uint32Array;
+ Uint8Array: typeof Uint8Array;
+ Uint8ClampedArray: Function;
+ WeakMap: typeof WeakMap;
+ WeakSet: Function;
+ clearImmediate: (immediateId: any) => void;
+ clearInterval: (intervalId: NodeJS.Timer) => void;
+ clearTimeout: (timeoutId: NodeJS.Timer) => void;
+ console: typeof console;
+ decodeURI: typeof decodeURI;
+ decodeURIComponent: typeof decodeURIComponent;
+ encodeURI: typeof encodeURI;
+ encodeURIComponent: typeof encodeURIComponent;
+ escape: (str: string) => string;
+ eval: typeof eval;
+ global: Global;
+ isFinite: typeof isFinite;
+ isNaN: typeof isNaN;
+ parseFloat: typeof parseFloat;
+ parseInt: typeof parseInt;
+ process: Process;
+ root: Global;
+ setImmediate: (callback: (...args: any[]) => void, ...args: any[]) => any;
+ setInterval: (callback: (...args: any[]) => void, ms: number, ...args: any[]) => NodeJS.Timer;
+ setTimeout: (callback: (...args: any[]) => void, ms: number, ...args: any[]) => NodeJS.Timer;
+ undefined: typeof undefined;
+ unescape: (str: string) => string;
+ gc: () => 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(str: string): string;
+ export function unescape(str: string): string;
+}
+
+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(port: number, hostname?: string, 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;
+ }
+ /**
+ * @deprecated Use IncomingMessage
+ */
+ export interface ServerRequest extends IncomingMessage {
+ 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 IncomingMessage extends events.EventEmitter, stream.Readable {
+ httpVersion: string;
+ headers: any;
+ rawHeaders: string[];
+ trailers: any;
+ rawTrailers: any;
+ setTimeout(msecs: number, callback: Function): NodeJS.Timer;
+ /**
+ * Only valid for request obtained from http.Server.
+ */
+ method?: string;
+ /**
+ * Only valid for request obtained from http.Server.
+ */
+ url?: string;
+ /**
+ * Only valid for response obtained from http.ClientRequest.
+ */
+ statusCode?: number;
+ /**
+ * Only valid for response obtained from http.ClientRequest.
+ */
+ statusMessage?: string;
+ socket: net.Socket;
+ }
+ /**
+ * @deprecated Use IncomingMessage
+ */
+ export interface ClientResponse extends IncomingMessage { }
+
+ export interface AgentOptions {
+ /**
+ * Keep sockets around in a pool to be used by other requests in the future. Default = false
+ */
+ keepAlive?: boolean;
+ /**
+ * When using HTTP KeepAlive, how often to send TCP KeepAlive packets over sockets being kept alive. Default = 1000.
+ * Only relevant if keepAlive is set to true.
+ */
+ keepAliveMsecs?: number;
+ /**
+ * Maximum number of sockets to allow per host. Default for Node 0.10 is 5, default for Node 0.12 is Infinity
+ */
+ maxSockets?: number;
+ /**
+ * Maximum number of sockets to leave open in a free state. Only relevant if keepAlive is set to true. Default = 256.
+ */
+ maxFreeSockets?: number;
+ }
+
+ export class Agent {
+ maxSockets: number;
+ sockets: any;
+ requests: any;
+
+ constructor(opts?: AgentOptions);
+
+ /**
+ * Destroy any sockets that are currently in use by the agent.
+ * It is usually not necessary to do this. However, if you are using an agent with KeepAlive enabled,
+ * then it is best to explicitly shut down the agent when you know that it will no longer be used. Otherwise,
+ * sockets may hang open for quite a long time before the server terminates them.
+ */
+ destroy(): void;
+ }
+
+ export var STATUS_CODES: {
+ [errorCode: number]: string;
+ [errorCode: string]: string;
+ };
+ export function createServer(requestListener?: (request: IncomingMessage, response: ServerResponse) =>void ): Server;
+ export function createClient(port?: number, host?: string): any;
+ export function request(options: any, callback?: (res: IncomingMessage) => void): ClientRequest;
+ export function get(options: any, callback?: (res: IncomingMessage) => void): 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: http.IncomingMessage) =>void ): http.ClientRequest;
+ export function get(options: RequestOptions, callback?: (res: http.IncomingMessage) =>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,
+ callback?: (error: Error, stdout: Buffer, stderr: Buffer) =>void ): ChildProcess;
+ export function execFile(file: string, args?: 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;
+ export function execSync(command: string, options?: {
+ cwd?: string;
+ input?: string|Buffer;
+ stdio?: any;
+ env?: any;
+ uid?: number;
+ gid?: number;
+ timeout?: number;
+ maxBuffer?: number;
+ killSignal?: string;
+ encoding?: string;
+ }): ChildProcess;
+ export function execFileSync(command: string, args?: string[], options?: {
+ cwd?: string;
+ input?: string|Buffer;
+ stdio?: any;
+ env?: any;
+ uid?: number;
+ gid?: number;
+ timeout?: number;
+ maxBuffer?: number;
+ killSignal?: string;
+ 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; };
+ unref(): void;
+ ref(): void;
+
+ remoteAddress: string;
+ remoteFamily: string;
+ remotePort: number;
+ localAddress: string;
+ localPort: 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;
+ ctime: Date;
+ }
+
+ interface FSWatcher extends events.EventEmitter {
+ close(): void;
+ }
+
+ export interface ReadStream extends stream.Readable {
+ close(): void;
+ }
+ export interface WriteStream extends stream.Writable {
+ close(): void;
+ }
+
+ 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 interface ParsedPath {
+ root: string;
+ dir: string;
+ base: string;
+ ext: string;
+ name: string;
+ }
+
+ export function normalize(p: string): string;
+ export function join(...paths: any[]): string;
+ export function resolve(...pathSegments: any[]): string;
+ export function isAbsolute(p: string): boolean;
+ 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;
+ export var delimiter: string;
+ export function parse(p: string): ParsedPath;
+ export function format(pP: ParsedPath): string;
+
+ export module posix {
+ export function normalize(p: string): string;
+ export function join(...paths: any[]): string;
+ export function resolve(...pathSegments: any[]): string;
+ export function isAbsolute(p: string): boolean;
+ 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;
+ export var delimiter: string;
+ export function parse(p: string): ParsedPath;
+ export function format(pP: ParsedPath): string;
+ }
+
+ export module win32 {
+ export function normalize(p: string): string;
+ export function join(...paths: any[]): string;
+ export function resolve(...pathSegments: any[]): string;
+ export function isAbsolute(p: string): boolean;
+ 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;
+ export var delimiter: string;
+ export function parse(p: string): ParsedPath;
+ export function format(pP: ParsedPath): 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: Buffer): Buffer;
+ update(data: string, input_encoding?: string, output_encoding?: string): string;
+ final(): Buffer;
+ 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: Buffer): Buffer;
+ update(data: string, input_encoding?: string, output_encoding?: string): string;
+ final(): Buffer;
+ 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(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): string|Buffer;
+ setEncoding(encoding: string): void;
+ pause(): void;
+ resume(): void;
+ pipe(destination: T, options?: { end?: boolean; }): T;
+ unpipe(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(destination: T, options?: { end?: boolean; }): T;
+ unpipe(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 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.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;
+}