declare namespace dojo {
	namespace promise {

		/* dojo/promise/all */

		type PromiseObjectOrArray = { [name: string]: Promise<any> } | Promise<any>[];
		type PromiseTypedObjectOrArray<T> = { [name: string]: Promise<T> } | Promise<T>[];

		interface All {
			/**
			 * Takes multiple promises and returns a new promise that is fulfilled
			 * when all promises have been resolved or one has been rejected.
			 * @param objectOrArray The promise will be fulfilled with a list of results if invoked with an
			 * 						array, or an object of results when passed an object (using the same
			 * 						keys). If passed neither an object or array it is resolved with an
			 * 						undefined value.
			 */
			<T>(array: Thenable<T>[]): Promise<T[]>;
			<T>(object: { [name: string]: Thenable<T> }): Promise<{ [name: string]: T }>;
			(array: Thenable<any>[]): Promise<any[]>;
			(object: { [name: string]: Thenable<any> }): Promise<{ [name: string]: any }>;
		}

		/* dojo/promise/first */

		interface First {
			/**
			 * Takes multiple promises and returns a new promise that is fulfilled
			 * when the first of these promises is fulfilled.
			 * @param objectOrArray The promises are taken from the array or object values. If no value
			 * 						is passed, the returned promise is resolved with an undefined value.
			 */
			<T>(objectOrArray?: PromiseTypedObjectOrArray<T>): Promise<T>;
			(objectOrArray?: PromiseObjectOrArray): Promise<any>;
		}

		/* dojo/promise/instrumentation */

		interface Instrumentation {
			/**
			 * Initialize instrumentation for the Deferred class.
			 */
			(Deferred: DeferredConstructor): void;
		}

		/* dojo/promise/Promise */

		type Thenable<T> = PromiseLike<T>;

		interface PromiseCallback<T, U> {
			(result: T): U | Thenable<U>;
		}

		interface PromiseErrback<U> {
			(error: any): U | Thenable<U> | void;
		}

		interface PromiseProgback {
			(progress: any): void;
		}

		interface Promise<T> extends Thenable<T> {
			/**
			 * Inform the deferred it may cancel its asynchronous operation.
			 */
			cancel(reason?: any, strict?: boolean): any;

			/**
			 * Checks whether the promise has been resolved.
			 */
			isResolved(): boolean;

			/**
			 * Checks whether the promise has been rejected.
			 */
			isRejected(): boolean;

			/**
			 * Checks whether the promise has been resolved or rejected.
			 */
			isFulfilled(): boolean;

			/**
			 * Checks whether the promise has been canceled.
			 */
			isCanceled(): boolean;

			/**
			 * Add a callback to be invoked when the promise is resolved
			 * or rejected.
			 */
			always<U>(callbackOrErrback: PromiseCallback<T, U> | PromiseErrback<U>): Promise<U>;

			/**
			 * Add new errbacks to the promise. Follows ECMA specification naming.
			 */
			catch<U>(errback: PromiseErrback<U>): Promise<U>;

			/**
			 * Add new errbacks to the promise.
			 */
			otherwise<U>(errback: PromiseErrback<U>): Promise<U>;

			trace(): this;
			traceRejected(): this;
			toString(): string;
		}

		interface PromiseConstructor {
			/**
			 * The public interface to a deferred.
			 */
			new <T>(): Promise<T>;
		}

		/* dojo/promise/tracer */

		/* TODO: Uncomment for TS 1.8 */
		/* type TracerEvent = 'resolved' | 'rejected' | 'progress'; */

		interface Tracer {
			/**
			 * Subscribe to traces.
			 */
			on(type: string /* TracerEvent */, listener: EventListener): Handle;
		}
	}
}