From 89f124421574994f16ec28f5ee5c3855686389ea Mon Sep 17 00:00:00 2001
From: Ilya Mochalov <chrootsu@gmail.com>
Date: Sun, 7 Feb 2016 15:48:39 +0500
Subject: [PATCH] consul: added definitions

---
 consul/consul.d.ts | 1034 ++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 1034 insertions(+)
 create mode 100644 consul/consul.d.ts

diff --git a/consul/consul.d.ts b/consul/consul.d.ts
new file mode 100644
index 000000000..23c39186e
--- /dev/null
+++ b/consul/consul.d.ts
@@ -0,0 +1,1034 @@
+// Type definitions for Consul v0.23.0
+// Project: https://github.com/silas/node-consul
+// Definitions by: Ilya Mochalov <https://github.com/chrootsu>
+// Definitions: https://github.com/borisyankov/DefinitelyTyped
+
+/// <reference path="../node/node.d.ts" />
+
+declare module "consul" {
+
+	import {IncomingMessage as HttpIncomingMessage} from "http";
+
+	namespace Consul {
+
+		interface Thenable<T> {
+			then<U>(onFulfilled?: (value: T) => U | Thenable<U>, onRejected?: (error: any) => U | Thenable<U>): Thenable<U>;
+			then<U>(onFulfilled?: (value: T) => U | Thenable<U>, onRejected?: (error: any) => void): Thenable<U>;
+			catch<U>(onRejected?: (error: any) => U | Thenable<U>): Thenable<U>;
+		}
+
+		interface CommonOptions {
+			consistent?: boolean;
+			dc?: string;
+			stale?: boolean;
+			token?: string;
+			wait?: string;
+			wan?: boolean;
+
+			ctx?: NodeJS.EventEmitter;
+			timeout?: number;
+		}
+
+		interface Response extends HttpIncomingMessage {
+			body?: Object|string|Buffer;
+		}
+
+		interface Callback<TData> {
+			(err?: Error, data?: TData, res?: Response): any;
+		}
+
+		namespace Acl {
+
+			interface CreateOptions extends CommonOptions {
+				name?: string;
+				type?: string;
+				rules?: string;
+			}
+
+			interface UpdateOptions extends CommonOptions {
+				id: string;
+				name?: string;
+				type?: string;
+				rules?: string;
+			}
+
+			interface DestroyOptions extends CommonOptions {
+				id: string;
+			}
+
+			interface InfoOptions extends CommonOptions {
+				id: string;
+			}
+
+			interface GetOptions extends InfoOptions {}
+
+			interface CloneOptions extends CommonOptions {
+				id: string;
+			}
+
+			interface ListOptions extends CommonOptions {}
+		}
+
+		interface Acl {
+			consul: Consul;
+
+			/**
+			 * Creates a new token with policy
+			 */
+			create: {
+				<TData>(opts: Acl.CreateOptions, callback: Callback<TData>): void;
+				<TData>(callback: Callback<TData>): void;
+				<TData>(opts?: Acl.CreateOptions): Thenable<TData>;
+			};
+
+			/**
+			 * Update the policy of a token
+			 */
+			update: {
+				<TData>(opts: Acl.UpdateOptions, callback: Callback<TData>): void;
+				<TData>(opts: Acl.UpdateOptions): Thenable<TData>;
+			}
+
+			/**
+			 * Destroys a given token
+			 */
+			destroy: {
+				<TData>(id: string, callback: Callback<TData>): void;
+				<TData>(opts: Acl.DestroyOptions, callback: Callback<TData>): void;
+				<TData>(id: string): Thenable<TData>;
+				<TData>(opts: Acl.DestroyOptions): Thenable<TData>;
+			};
+
+			/**
+			 * Queries the policy of a given token
+			 */
+			info: {
+				<TData>(id: string, callback: Callback<TData>): void;
+				<TData>(opts: Acl.InfoOptions, callback: Callback<TData>): void;
+				<TData>(id: string): Thenable<TData>;
+				<TData>(opts: Acl.InfoOptions): Thenable<TData>;
+			};
+			get: {
+				<TData>(id: string, callback: Callback<TData>): void;
+				<TData>(opts: Acl.GetOptions, callback: Callback<TData>): void;
+				<TData>(id: string): Thenable<TData>;
+				<TData>(opts: Acl.GetOptions): Thenable<TData>;
+			};
+
+			/**
+			 * Creates a new token by cloning an existing token
+			 */
+			clone: {
+				<TData>(id: string, callback: Callback<TData>): void;
+				<TData>(opts: Acl.CloneOptions, callback: Callback<TData>): void;
+				<TData>(id: string): Thenable<TData>;
+				<TData>(opts: Acl.CloneOptions): Thenable<TData>;
+			};
+
+			/**
+			 * Lists all the active tokens
+			 */
+			list: {
+				<TData>(opts: Acl.ListOptions, callback: Callback<TData>): void;
+				<TData>(callback: Callback<TData>): void;
+				<TData>(opts?: Acl.ListOptions): Thenable<TData>;
+			};
+		}
+
+		interface AclStatic {
+			new (consul: Consul): Acl;
+		}
+
+		namespace Agent {
+
+			namespace Check {
+
+				interface ListOptions extends CommonOptions {}
+
+				interface RegisterOptions extends CommonOptions {
+					name: string;
+					id?: string;
+					serviceid?: string;
+					http?: string;
+					script?: string;
+					interval?: string;
+					ttl?: string;
+					notes?: string;
+					status?: string;
+				}
+
+				interface DeregisterOptions extends CommonOptions {
+					id: string;
+				}
+
+				interface PassOptions extends CommonOptions {
+					id: string;
+					note?: string;
+				}
+
+				interface WarnOptions extends CommonOptions {
+					id: string;
+					note?: string;
+				}
+
+				interface FailOptions extends CommonOptions {
+					id: string;
+					note?: string;
+				}
+			}
+
+			interface Check {
+				consul: Consul;
+
+				/**
+				 * Returns the checks the local agent is managing
+				 */
+				list: {
+					<TData>(opts: Check.ListOptions, callback: Callback<TData>): void;
+					<TData>(callback: Callback<TData>): void;
+					<TData>(opts?: Check.ListOptions): Thenable<TData>;
+				};
+
+				/**
+				 * Registers a new local check
+				 */
+				register: {
+					<TData>(opts: Check.RegisterOptions, callback: Callback<TData>): void;
+					<TData>(opts: Check.RegisterOptions): Thenable<TData>;
+				};
+
+				/**
+				 * Deregister a local check
+				 */
+				deregister: {
+					<TData>(id: string, callback: Callback<TData>): void;
+					<TData>(opts: Check.DeregisterOptions, callback: Callback<TData>): void;
+					<TData>(id: string): Thenable<TData>;
+					<TData>(opts: Check.DeregisterOptions): Thenable<TData>;
+				};
+
+				/**
+				 * Mark a local test as passing
+				 */
+				pass: {
+					<TData>(id: string, callback: Callback<TData>): void;
+					<TData>(opts: Check.PassOptions, callback: Callback<TData>): void;
+					<TData>(id: string): Thenable<TData>;
+					<TData>(opts: Check.PassOptions): Thenable<TData>;
+				};
+
+				/**
+				 * Mark a local test as warning
+				 */
+				warn: {
+					<TData>(id: string, callback: Callback<TData>): void;
+					<TData>(opts: Check.WarnOptions, callback: Callback<TData>): void;
+					<TData>(id: string): Thenable<TData>;
+					<TData>(opts: Check.WarnOptions): Thenable<TData>;
+				};
+
+				/**
+				 * Mark a local test as critical
+				 */
+				fail: {
+					<TData>(id: string, callback: Callback<TData>): void;
+					<TData>(opts: Check.FailOptions, callback: Callback<TData>): void;
+					<TData>(id: string): Thenable<TData>;
+					<TData>(opts: Check.FailOptions): Thenable<TData>;
+				};
+			}
+
+			interface CheckStatic {
+				new (consul: Consul): Check;
+			}
+
+			namespace Service {
+
+				interface RegisterCheck {
+					http?: string;
+					script?: string;
+					interval?: string;
+					ttl?: string;
+					notes?: string;
+					status?: string;
+				}
+
+				interface ListOptions extends CommonOptions {}
+
+				interface RegisterOptions extends CommonOptions {
+					name: string;
+					id?: string;
+					tags?: string[];
+					address?: string;
+					port?: number;
+					check?: RegisterCheck;
+					checks?: RegisterCheck[];
+				}
+
+				interface DeregisterOptions extends CommonOptions {
+					id: string;
+				}
+
+				interface MaintenanceOptions extends CommonOptions {
+					id: string;
+					enable: boolean;
+					reason?: string;
+				}
+			}
+
+			interface Service {
+				consul: Consul;
+
+				/**
+				 * Returns the services local agent is managing
+				 */
+				list: {
+					<TData>(opts: Service.ListOptions, callback: Callback<TData>): void;
+					<TData>(callback: Callback<TData>): void;
+					<TData>(opts?: Service.ListOptions): Thenable<TData>;
+				};
+
+				/**
+				 * Registers a new local service
+				 */
+				register: {
+					<TData>(name: string, callback: Callback<TData>): void;
+					<TData>(opts: Service.RegisterOptions, callback: Callback<TData>): void;
+					<TData>(name: string): Thenable<TData>;
+					<TData>(opts: Service.RegisterOptions): Thenable<TData>;
+				};
+
+				/**
+				 * Deregister a local service
+				 */
+				deregister: {
+					<TData>(id: string, callback: Callback<TData>): void;
+					<TData>(opts: Service.DeregisterOptions, callback: Callback<TData>): void;
+					<TData>(id: string): Thenable<TData>;
+					<TData>(opts: Service.DeregisterOptions): Thenable<TData>;
+				};
+
+				/**
+				 * Manages node maintenance mode
+				 */
+				maintenance: {
+					<TData>(opts: Service.MaintenanceOptions, callback: Callback<TData>): void;
+					<TData>(opts: Service.MaintenanceOptions): Thenable<TData>;
+				};
+			}
+
+			interface ServiceStatic {
+				new (consul: Consul): Service;
+			}
+
+			interface ChecksOptions extends Check.ListOptions {}
+
+			interface ServicesOptions extends Service.ListOptions {}
+
+			interface MembersOptions extends CommonOptions {
+				wan?: boolean;
+			}
+
+			interface SelfOptions extends CommonOptions {}
+
+			interface MaintenanceOptions extends CommonOptions {
+				enable: boolean;
+				reason?: string;
+			}
+
+			interface JoinOptions extends CommonOptions {
+				address: string;
+				wan?: boolean;
+			}
+
+			interface ForceLeaveOptions extends CommonOptions {
+				node: string;
+			}
+		}
+
+		interface Agent {
+			consul: Consul;
+			check: Agent.Check;
+			service: Agent.Service;
+
+			/**
+			 * Returns the checks the local agent is managing
+			 */
+			checks: {
+				<TData>(opts: Agent.ChecksOptions, callback: Callback<TData>): void;
+				<TData>(callback: Callback<TData>): void;
+				<TData>(opts?: Agent.ChecksOptions): Thenable<TData>;
+			};
+
+			/**
+			 * Returns the services local agent is managing
+			 */
+			services: {
+				<TData>(opts: Agent.ServicesOptions, callback: Callback<TData>): void;
+				<TData>(callback: Callback<TData>): void;
+				<TData>(opts?: Agent.ServicesOptions): Thenable<TData>;
+			};
+
+			/**
+			 * Returns the members as seen by the local consul agent
+			 */
+			members: {
+				<TData>(opts: Agent.MembersOptions, callback: Callback<TData>): void;
+				<TData>(callback: Callback<TData>): void;
+				<TData>(opts?: Agent.MembersOptions): Thenable<TData>;
+			};
+
+			/**
+			 * Returns the local node configuration
+			 */
+			self: {
+				<TData>(opts: Agent.SelfOptions, callback: Callback<TData>): void;
+				<TData>(callback: Callback<TData>): void;
+				<TData>(opts?: Agent.SelfOptions): Thenable<TData>;
+			};
+
+			/**
+			 * Manages node maintenance mode
+			 */
+			maintenance: {
+				<TData>(enable: boolean, callback: Callback<TData>): void;
+				<TData>(opts: Agent.MaintenanceOptions, callback: Callback<TData>): void;
+				<TData>(enable: boolean): Thenable<TData>;
+				<TData>(opts: Agent.MaintenanceOptions): Thenable<TData>;
+			};
+
+			/**
+			 * Trigger local agent to join a node
+			 */
+			join: {
+				<TData>(address: string, callback: Callback<TData>): void;
+				<TData>(opts: Agent.JoinOptions, callback: Callback<TData>): void;
+				<TData>(address: string): Thenable<TData>;
+				<TData>(opts: Agent.JoinOptions): Thenable<TData>;
+			};
+
+			/**
+			 * Force remove node
+			 */
+			forceLeave: {
+				<TData>(node: string, callback: Callback<TData>): void;
+				<TData>(opts: Agent.ForceLeaveOptions, callback: Callback<TData>): void;
+				<TData>(node: string): Thenable<TData>;
+				<TData>(opts: Agent.ForceLeaveOptions): Thenable<TData>;
+			};
+		}
+
+		interface AgentStatic {
+			new (consul: Consul): Agent;
+
+			Check: Agent.CheckStatic;
+			Service: Agent.ServiceStatic;
+		}
+
+		namespace Catalog {
+
+			namespace Node {
+
+				interface ListOptions extends CommonOptions {
+					dc?: string;
+				}
+
+				interface ServicesOptions extends CommonOptions {
+					node: string;
+				}
+			}
+
+			interface Node {
+				consul: Consul;
+
+				/**
+				 * Lists nodes in a given DC
+				 */
+				list: {
+					<TData>(dc: string, callback: Callback<TData>): void;
+					<TData>(opts: Node.ListOptions, callback: Callback<TData>): void;
+					<TData>(callback: Callback<TData>): void;
+					<TData>(dc?: string): Thenable<TData>;
+					<TData>(opts?: Node.ListOptions): Thenable<TData>;
+				};
+
+				/**
+				 * Lists the services provided by a node
+				 */
+				services: {
+					<TData>(node: string, callback: Callback<TData>): void;
+					<TData>(opts: Node.ServicesOptions, callback: Callback<TData>): void;
+					<TData>(node: string): Thenable<TData>;
+					<TData>(opts: Node.ServicesOptions): Thenable<TData>;
+				};
+			}
+
+			interface NodeStatic {
+				new(consul: Consul): Node;
+			}
+
+			namespace Service {
+
+				interface ListOptions extends CommonOptions {
+					dc?: string;
+				}
+
+				interface NodesOptions extends CommonOptions {
+					service: string;
+					dc?: string;
+					tag?: string;
+				}
+			}
+
+
+
+			interface Service {
+				consul: Consul;
+
+				/**
+				 * Lists services in a given DC
+				 */
+				list: {
+					<TData>(dc: string, callback: Callback<TData>): void;
+					<TData>(opts: Service.ListOptions, callback: Callback<TData>): void;
+					<TData>(callback: Callback<TData>): void;
+					<TData>(dc?: string): Thenable<TData>;
+					<TData>(opts?: Service.ListOptions): Thenable<TData>;
+				};
+
+				/**
+				 * Lists the nodes in a given service
+				 */
+				nodes: {
+					<TData>(service: string, callback: Callback<TData>): void;
+					<TData>(opts: Service.NodesOptions, callback: Callback<TData>): void;
+					<TData>(service: string): Thenable<TData>;
+					<TData>(opts: Service.NodesOptions): Thenable<TData>;
+				};
+			}
+
+			interface ServiceStatic {
+				new(consul: Consul): Service;
+			}
+
+			interface DatacentersOptions extends CommonOptions {}
+
+			interface NodesOptions extends Node.ListOptions {}
+
+			interface ServicesOptions extends Service.ListOptions {}
+		}
+
+		interface Catalog {
+			consul: Consul;
+			node: Catalog.Node;
+			service: Catalog.Service;
+
+			/**
+			 * Lists known datacenters
+			 */
+			datacenters: {
+				<TData>(opts: Catalog.DatacentersOptions, callback: Callback<TData>): void;
+				<TData>(callback: Callback<TData>): void;
+				<TData>(opts?: Catalog.DatacentersOptions): Thenable<TData>;
+			};
+
+			/**
+			 * Lists nodes in a given DC
+			 */
+			nodes: {
+				<TData>(dc: string, callback: Callback<TData>): void;
+				<TData>(opts: Catalog.NodesOptions, callback: Callback<TData>): void;
+				<TData>(callback: Callback<TData>): void;
+				<TData>(dc?: string): Thenable<TData>;
+				<TData>(opts?: Catalog.NodesOptions): Thenable<TData>;
+			};
+
+			/**
+			 * Lists services in a given DC
+			 */
+			services: {
+				<TData>(dc: string, callback: Callback<TData>): void;
+				<TData>(opts: Catalog.ServicesOptions, callback: Callback<TData>): void;
+				<TData>(callback: Callback<TData>): void;
+				<TData>(dc?: string): Thenable<TData>;
+				<TData>(opts?: Catalog.ServicesOptions): Thenable<TData>;
+			};
+		}
+
+		interface CatalogStatic {
+			new(consul: Consul): Catalog;
+
+			Node: Catalog.NodeStatic;
+			Service: Catalog.ServiceStatic;
+		}
+
+		namespace Event {
+
+			interface FireOptions extends CommonOptions {
+				name: string;
+				payload: string|Buffer;
+				node?: string;
+				service?: string;
+				tag?: string;
+			}
+
+			interface ListOptions extends CommonOptions {
+				name?: string;
+			}
+		}
+
+		interface Event {
+			consul: Consul;
+
+			/**
+			 * Fires a new user event
+			 */
+			fire: {
+				<TData>(name: string, payload: string|Buffer, callback: Callback<TData>): void;
+				<TData>(name: string, callback: Callback<TData>): void;
+				<TData>(opts: Event.FireOptions, callback: Callback<TData>): void;
+				<TData>(name: string, payload: string|Buffer): Thenable<TData>;
+				<TData>(name: string): Thenable<TData>;
+				<TData>(opts: Event.FireOptions): Thenable<TData>;
+			};
+
+			/**
+			 * Lists the most recent events an agent has seen
+			 */
+			list: {
+				<TData>(name: string, callback: Callback<TData>): void;
+				<TData>(opts: Event.ListOptions, callback: Callback<TData>): void;
+				<TData>(callback: Callback<TData>): void;
+				<TData>(name?: string): Thenable<TData>;
+				<TData>(opts?: Event.ListOptions): Thenable<TData>;
+			};
+		}
+
+		interface EventStatic {
+			new(consul: Consul): Event;
+		}
+
+		namespace Health {
+
+			interface NodeOptions extends CommonOptions {
+				node: string;
+				dc?: string;
+			}
+
+			interface ChecksOptions extends CommonOptions {
+				service: string;
+				dc?: string;
+			}
+
+			interface ServiceOptions extends CommonOptions {
+				service: string;
+				dc?: string;
+				tag?: string;
+				passing?: boolean;
+			}
+
+			interface StateOptions extends CommonOptions {
+				state: string;
+				dc?: string;
+			}
+		}
+
+		interface Health {
+			consul: Consul;
+
+			/**
+			 * Returns the health info of a node
+			 */
+			node: {
+				<TData>(node: string, callback: Callback<TData>): void;
+				<TData>(opts: Health.NodeOptions, callback: Callback<TData>): void;
+				<TData>(node: string): Thenable<TData>;
+				<TData>(opts: Health.NodeOptions): Thenable<TData>;
+			};
+
+			/**
+			 * Returns the checks of a service
+			 */
+			checks: {
+				<TData>(service: string, callback: Callback<TData>): void;
+				<TData>(opts: Health.ChecksOptions, callback: Callback<TData>): void;
+				<TData>(service: string): Thenable<TData>;
+				<TData>(opts: Health.ChecksOptions): Thenable<TData>;
+			};
+
+			/**
+			 * Returns the nodes and health info of a service
+			 */
+			service: {
+				<TData>(service: string, callback: Callback<TData>): void;
+				<TData>(opts: Health.ServiceOptions, callback: Callback<TData>): void;
+				<TData>(service: string): Thenable<TData>;
+				<TData>(opts: Health.ServiceOptions): Thenable<TData>;
+			};
+
+			/**
+			 * Returns the checks in a given state
+			 */
+			state: {
+				<TData>(state: string, callback: Callback<TData>): void;
+				<TData>(opts: Health.StateOptions, callback: Callback<TData>): void;
+				<TData>(state: string): Thenable<TData>;
+				<TData>(opts: Health.StateOptions): Thenable<TData>;
+			};
+		}
+
+		interface HealthStatic {
+			new(consul: Consul): Health;
+		}
+
+		namespace Kv {
+
+			interface GetOptions extends CommonOptions {
+				key: string;
+				dc?: string;
+				recurse?: boolean;
+				index?: string;
+				wait?: string;
+				raw?: boolean;
+				buffer?: boolean;
+			}
+
+			interface KeysOptions extends CommonOptions {
+				key: string;
+				dc?: string;
+				separator?: string;
+			}
+
+			interface SetOptions extends CommonOptions {
+				key: string;
+				value: string|Buffer;
+				dc?: string;
+				flags?: number;
+				cas?: string;
+				acquire?: string;
+				release?: string;
+			}
+
+			interface DelOptions extends CommonOptions {
+				key: string;
+				dc?: string;
+				recurse?: boolean;
+				cas?: string;
+			}
+
+			interface DeleteOptions extends DelOptions {}
+		}
+
+		interface Kv {
+			consul: Consul;
+
+			/**
+			 * Get
+			 */
+			get: {
+				<TData>(key: string, callback: Callback<TData>): void;
+				<TData>(opts: Kv.GetOptions, callback: Callback<TData>): void;
+				<TData>(key: string): Thenable<TData>;
+				<TData>(opts: Kv.GetOptions): Thenable<TData>;
+			};
+
+			/**
+			 * Keys
+			 */
+			keys: {
+				<TData>(key: string, callback: Callback<TData>): void;
+				<TData>(opts: Kv.KeysOptions, callback: Callback<TData>): void;
+				<TData>(callback: Callback<TData>): void;
+				<TData>(key?: string): Thenable<TData>;
+				<TData>(opts?: Kv.KeysOptions): Thenable<TData>;
+			};
+
+			/**
+			 * Set
+			 */
+			set: {
+				<TData>(key: string, value: string|Buffer, opts: Kv.SetOptions, callback: Callback<TData>): void;
+				<TData>(key: string, value: string|Buffer, callback: Callback<TData>): void;
+				<TData>(opts: Kv.SetOptions, callback: Callback<TData>): void;
+				<TData>(key: string, value: string|Buffer, opts: Kv.SetOptions): Thenable<TData>;
+				<TData>(key: string, value: string|Buffer): Thenable<TData>;
+				<TData>(opts: Kv.SetOptions): Thenable<TData>;
+			};
+
+			/**
+			 * Delete
+			 */
+			del: {
+				<TData>(key: string, callback: Callback<TData>): void;
+				<TData>(opts: Kv.DelOptions, callback: Callback<TData>): void;
+				<TData>(key: string): Thenable<TData>;
+				<TData>(opts: Kv.DelOptions): Thenable<TData>;
+			};
+			delete: {
+				<TData>(key: string, callback: Callback<TData>): void;
+				<TData>(opts: Kv.DeleteOptions, callback: Callback<TData>): void;
+				<TData>(key: string): Thenable<TData>;
+				<TData>(opts: Kv.DeleteOptions): Thenable<TData>;
+			};
+		}
+
+		interface KvStatic {
+			new(consul: Consul): Kv;
+		}
+
+		namespace Lock {
+
+			interface Options {
+				key: string;
+				session?: Object|string;
+				value?: string|Buffer;
+				lockwaittime?: string;
+				lockretrytime?: string;
+			}
+		}
+
+		interface Lock extends NodeJS.EventEmitter {
+			consul: Consul;
+
+			/**
+			 * Acquire lock
+			 */
+			acquire(): void;
+
+			/**
+			 * Release lock
+			 */
+			release(): void;
+		}
+
+		interface LockStatic {
+			new(consul: Consul, opts: Lock.Options): Lock;
+		}
+
+		namespace Session {
+
+			interface CreateOptions extends CommonOptions {
+				dc?: string;
+				lockdelay?: string;
+				name?: string;
+				node?: string;
+				checks?: string[];
+				behavior?: string;
+				ttl?: string;
+			}
+
+			interface DestroyOptions extends CommonOptions {
+				id: string;
+				dc?: string;
+			}
+
+			interface InfoOptions extends CommonOptions {
+				id: string;
+				dc?: string;
+			}
+
+			interface GetOptions extends InfoOptions {}
+
+			interface NodeOptions extends CommonOptions {
+				node: string;
+				dc?: string;
+			}
+
+			interface ListOptions extends CommonOptions {
+				dc?: string;
+			}
+
+			interface RenewOptions extends CommonOptions {
+				id: string;
+				dc?: string;
+			}
+		}
+
+
+		interface Session {
+			consul: Consul;
+
+			/**
+			 * Creates a new session
+			 */
+			create: {
+				<TData>(opts: Session.CreateOptions, callback: Callback<TData>): void;
+				<TData>(callback: Callback<TData>): void;
+				<TData>(opts?: Session.CreateOptions): Thenable<TData>;
+			};
+
+			/**
+			 * Destroys a given session
+			 */
+			destroy: {
+				<TData>(id: string, callback: Callback<TData>): void;
+				<TData>(opts: Session.DestroyOptions, callback: Callback<TData>): void;
+				<TData>(id: string): Thenable<TData>;
+				<TData>(opts: Session.DestroyOptions): Thenable<TData>;
+			};
+
+			/**
+			 * Queries a given session
+			 */
+			info: {
+				<TData>(id: string, callback: Callback<TData>): void;
+				<TData>(opts: Session.InfoOptions, callback: Callback<TData>): void;
+				<TData>(id: string): Thenable<TData>;
+				<TData>(opts: Session.InfoOptions): Thenable<TData>;
+			};
+			get: {
+				<TData>(id: string, callback: Callback<TData>): void;
+				<TData>(opts: Session.GetOptions, callback: Callback<TData>): void;
+				<TData>(id: string): Thenable<TData>;
+				<TData>(opts: Session.GetOptions): Thenable<TData>;
+			};
+
+			/**
+			 * Lists sessions belonging to a node
+			 */
+			node: {
+				<TData>(node: string, callback: Callback<TData>): void;
+				<TData>(opts: Session.NodeOptions, callback: Callback<TData>): void;
+				<TData>(node: string): Thenable<TData>;
+				<TData>(opts: Session.NodeOptions): Thenable<TData>;
+			};
+
+			/**
+			 * Lists all the active sessions
+			 */
+			list: {
+				<TData>(opts: Session.ListOptions, callback: Callback<TData>): void;
+				<TData>(callback: Callback<TData>): void;
+				<TData>(opts?: Session.ListOptions): Thenable<TData>;
+			};
+
+			/**
+			 * Renews a TTL-based session
+			 */
+			renew: {
+				<TData>(id: string, callback: Callback<TData>): void;
+				<TData>(opts: Session.RenewOptions, callback: Callback<TData>): void;
+				<TData>(id: string): Thenable<TData>;
+				<TData>(opts: Session.RenewOptions): Thenable<TData>;
+			};
+		}
+
+		interface SessionStatic {
+			new(consul: Consul): Session;
+		}
+
+		namespace Status {
+
+			interface LeaderOptions extends CommonOptions {}
+
+			interface PeersOptions extends CommonOptions {}
+		}
+
+		interface Status {
+			consul: Consul;
+
+			/**
+			 * Returns the current Raft leader.
+			 */
+			leader: {
+				<TData>(opts: Status.LeaderOptions, callback: Callback<TData>): void;
+				<TData>(callback: Callback<TData>): void;
+				<TData>(opts?: Status.LeaderOptions): Thenable<TData>;
+			};
+
+			/**
+			 * Returns the current Raft peer set
+			 */
+			peers: {
+				<TData>(opts: Status.PeersOptions, callback: Callback<TData>): void;
+				<TData>(callback: Callback<TData>): void;
+				<TData>(opts?: Status.PeersOptions): Thenable<TData>;
+			};
+		}
+
+		interface StatusStatic {
+			new(consul: Consul): Status;
+		}
+
+		namespace Watch {
+
+			interface Options {
+				method: Function;
+				options?: CommonOptions;
+			}
+		}
+
+		interface Watch extends NodeJS.EventEmitter {
+			consul: Consul;
+
+			/**
+			 * Is running
+			 */
+			isRunning(): boolean;
+
+			/**
+			 * Update time
+			 */
+			updateTime(): number;
+
+			/**
+			 * End watch
+			 */
+			end(): void;
+		}
+
+		interface WatchStatic {
+			new(consul: Consul, opts: Watch.Options): Watch;
+		}
+
+		interface ConsulOptions {
+			host?: string;
+			port?: string;
+			secure?: boolean;
+			ca?: string[];
+			defaults?: CommonOptions;
+			promisify?: boolean|Function;
+		}
+
+		interface Consul {
+			acl: Acl;
+			agent: Agent;
+			catalog: Catalog;
+			event: Event;
+			health: Health;
+			kv: Kv;
+			session: Session;
+			status: Status;
+
+			/**
+			 * Lock helper.
+			 */
+			lock(opts: Lock.Options): Lock;
+
+			/**
+			 * Watch helper.
+			 */
+			watch(opts: Watch.Options): Watch;
+		}
+
+		interface ConsulStatic {
+			(opts?: ConsulOptions): Consul;
+			new (opts?: ConsulOptions): Consul;
+
+			Acl: AclStatic;
+			Agent: AgentStatic;
+			Catalog: CatalogStatic;
+			Event: EventStatic;
+			Health: HealthStatic;
+			Kv: KvStatic;
+			Lock: LockStatic;
+			Session: SessionStatic;
+			Status: StatusStatic;
+			Watch: WatchStatic;
+		}
+	}
+
+	let Consul: Consul.ConsulStatic;
+
+	export = Consul;
+}