types

@types/q

// Project: https://github.com/kriskowal/q

// Definitions by: Barrie Nemetchek <https://github.com/bnemetchek>

// Andrew Gaspar <https://github.com/AndrewGaspar>

// John Reilly <https://github.com/johnnyreilly>

// Michel Boudreau <https://github.com/mboudreau>

// TeamworkGuy2 <https://github.com/TeamworkGuy2>

// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped

 * If value is a Q promise, returns the promise.

 * If value is a promise from another library it is coerced into a Q promise (where possible).

 * If value is not a promise, returns a promise that is fulfilled with value.

declare function Q<T>(promise: PromiseLike<T> | T): Q.Promise<T>;

 * Calling with nothing at all creates a void promise

export type IWhenable<T> = PromiseLike<T> | T;

export type IPromise<T> = PromiseLike<T>;

         * Calling resolve with a pending promise causes promise to wait on the passed promise, becoming fulfilled with its

         * fulfillment value or rejected with its rejection reason (or staying pending forever, if the passed promise does).

         * Calling resolve with a rejected promise causes promise to be rejected with the passed promise's rejection reason.

         * Calling resolve with a fulfilled promise causes promise to be fulfilled with the passed promise's fulfillment value.

         * Calling resolve with a non-promise value causes promise to be fulfilled with that value.

resolve(value?: IWhenable<T>): void;

         * Calling reject with a reason causes promise to be rejected with that reason.

         * Calling notify with a value causes promise to be notified of progress with that value. That is, any onProgress

         * handlers registered with promise or promises derived from promise will be called with the progress value.

         * Returns a function suitable for passing to a Node.js API. That is, it has a signature (err, result) and will

         * reject deferred.promise with err if err is given, or fulfill it with result if that is given.

        makeNodeResolver(): (reason: any, value: T) => void;

         * The then method from the Promises/A+ specification, with an additional progress handler.

then(onFulfill?: ((value: T) => IWhenable) | null, onReject?: ((error: any) => IWhenable) | null, onProgress?: ((progress: any) => any) | null): Promise;

then(onFulfill?: ((value: T) => IWhenable) | null, onReject?: ((error: any) => IWhenable<V>) | null, onProgress?: ((progress: any) => any) | null): Promise;

         * Like a finally clause, allows you to observe either the fulfillment or rejection of a promise, but to do so

         * without modifying the final value. This is useful for collecting resources regardless of whether a job succeeded,

         * like closing a database connection, shutting a server down, or deleting an unneeded key from an object.

         * finally returns a promise, which will become resolved with the same fulfillment value or rejection reason

         * as promise. However, if callback returns a promise, the resolution of the returned promise will be delayed

         * until the promise returned from callback is finished. Furthermore, if the returned promise rejects, that

         * rejection will be passed down the chain instead of the previous result.

finally(finallyCallback: () => any): Promise<T>;

         * Alias for finally() (for non-ES5 browsers)

fin(finallyCallback: () => any): Promise<T>;

         * Like then, but "spreads" the array into a variadic fulfillment handler. If any of the promises in the array are

         * rejected, instead calls onRejected with the first rejected promise's rejection reason.

         * This is especially useful in conjunction with all

spread(onFulfill: (...args: any[]) => IWhenable, onReject?: (reason: any) => IWhenable): Promise;

         * A sugar method, equivalent to promise.then(undefined, onRejected).

catch(onRejected: (reason: any) => IWhenable): Promise;

         * Alias for catch() (for non-ES5 browsers)

fail(onRejected: (reason: any) => IWhenable): Promise;

         * A sugar method, equivalent to promise.then(undefined, undefined, onProgress).

    // If a non-promise value is provided, it will not reject or progress

export function when<T, U>(value: IWhenable<T>, onFulfilled: (val: T) => IWhenable, onRejected?: ((reason: any) => IWhenable) | null, onProgress?: ((progress: any) => any) | null): Promise;

onFulfilled: (val: T) => IWhenable,

onRejected?: ((reason: any) => IWhenable) | null,

        onProgress?: ((progress: any) => any) | null

     * (Deprecated) Returns a new function that calls a function asynchronously with the given variadic arguments, and returns a promise.

     * Notably, any synchronous return values or thrown exceptions are transformed, respectively, into fulfillment values

     * or rejection reasons for the promise returned by this new function.

     * This method is especially useful in its static form for wrapping functions to ensure that they are always

     * asynchronous, and that any thrown exceptions (intentional or accidental) are appropriately transformed into a

     * returned rejected promise. For example:

     * var getUserData = Q.fbind(function (userName) {

     *         throw new Error("userName must be truthy!");

     *     if (localCache.has(userName)) {

     *         return localCache.get(userName);

     *     return getUserFromCloud(userName);

export function fbind<T>(method: (...args: any[]) => IWhenable<T>, ...args: any[]): (...args: any[]) => Promise<T>;

     * Returns a promise for the result of calling a function, with the given variadic arguments. Has the same return

     * value/thrown exception translation as explained above for fbind.

     * In its static form, it is aliased as Q.try, since it has semantics similar to a try block (but handling both synchronous

     * exceptions and asynchronous rejections). This allows code like

     *         throw new Error("The cloud is down!");

     *     console.error("Couldn't sync to the cloud", error);

export function fcall<T>(method: (...args: any[]) => T, ...args: any[]): Promise<T>;

    // but 'try' is a reserved word.  This is the only way to get around this

     * Returns a promise for the result of calling the named method of an object with the given variadic arguments.

     * The object itself is this in the function, just like a synchronous method call.

export function invoke<T>(obj: any, functionName: string, ...args: any[]): Promise<T>;

export function send<T>(obj: any, functionName: string, ...args: any[]): Promise<T>;

export function mcall<T>(obj: any, functionName: string, ...args: any[]): Promise<T>;

     * Creates a promise-returning function from a Node.js-style function, optionally binding it with the given

     * var readFile = Q.nfbind(FS.readFile);

     * readFile("foo.txt", "utf-8").done(function (text) {

     * Note that if you have a method that uses the Node.js callback pattern, as opposed to just a function, you will

     * need to bind its this value before passing it to nfbind, like so:

     * var Kitty = mongoose.model("Kitty");

     * var findKitties = Q.nfbind(Kitty.find.bind(Kitty));

     * The better strategy for methods would be to use Q.nbind, as shown below.

export function nfbind<T>(nodeFunction: (...args: any[]) => any, ...args: any[]): (...args: any[]) => Promise<T>;

export function denodeify<T>(nodeFunction: (...args: any[]) => any, ...args: any[]): (...args: any[]) => Promise<T>;

     * Creates a promise-returning function from a Node.js-style method, optionally binding it with the given

     * var findKitties = Q.nbind(Kitty.find, Kitty);

     * findKitties({ cute: true }).done(function (theKitties) {

export function nbind<T>(nodeFunction: (...args: any[]) => any, thisArg: any, ...args: any[]): (...args: any[]) => Promise<T>;

    "description": "TypeScript definitions for Q",

            "url": "https://github.com/bnemetchek",

            "githubUsername": "bnemetchek"

            "url": "https://github.com/AndrewGaspar",

            "githubUsername": "AndrewGaspar"

            "url": "https://github.com/johnnyreilly",

            "githubUsername": "johnnyreilly"

            "url": "https://github.com/mboudreau",

            "githubUsername": "mboudreau"

            "url": "https://github.com/TeamworkGuy2",

            "githubUsername": "TeamworkGuy2"

        "url": "https://github.com/DefinitelyTyped/DefinitelyTyped.git",

    "typesPublisherContentHash": "87a8fc5bb3b44cce66c05b0d26d6fe564f24b41c65949ea6727cb21eab63aeb6",

    "typesPublisherContentHash": "468c45fb0acfd51599db9fd0186f40568f238a731e9d591452de2c66ac244221",

This package contains type definitions for Q (https://github.com/kriskowal/q).

Files were exported from https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/q.

 * Last updated: Fri, 15 May 2020 11:32:02 GMT

 * Last updated: Fri, 15 May 2020 23:04:11 GMT

These definitions were written by [Barrie Nemetchek](https://github.com/bnemetchek), [Andrew Gaspar](https://github.com/AndrewGaspar), [John Reilly](https://github.com/johnnyreilly), [Michel Boudreau](https://github.com/mboudreau), and [TeamworkGuy2](https://github.com/TeamworkGuy2).

		@@ -288,3 +288,8 @@ // Type definitions for Q 1.5
		// If a non-promise value is provided, it will not reject or progress
		export function when<T, U>(value: IWhenable<T>, onFulfilled: (val: T) => IWhenable<U>, onRejected?: ((reason: any) => IWhenable<U>) \| null, onProgress?: ((progress: any) => any) \| null): Promise<U>;
		export function when<T, U>(
		value: IWhenable<T>,
		onFulfilled: (val: T) => IWhenable<U>,
		onRejected?: ((reason: any) => IWhenable<U>) \| null,
		onProgress?: ((progress: any) => any) \| null
		): Promise<U>;

		@@ -291,0 +296,0 @@ /**

		{
		"name": "@types/q",
		"version": "1.5.3",
		"version": "1.5.4",
		"description": "TypeScript definitions for Q",
		@@ -42,4 +42,4 @@ "license": "MIT",
		"dependencies": {},
		"typesPublisherContentHash": "87a8fc5bb3b44cce66c05b0d26d6fe564f24b41c65949ea6727cb21eab63aeb6",
		"typesPublisherContentHash": "468c45fb0acfd51599db9fd0186f40568f238a731e9d591452de2c66ac244221",
		"typeScriptVersion": "3.0"
		}

		@@ -11,3 +11,3 @@ # Installation
		### Additional Details
		* Last updated: Fri, 15 May 2020 11:32:02 GMT
		* Last updated: Fri, 15 May 2020 23:04:11 GMT
		* Dependencies: none
		@@ -14,0 +14,0 @@ * Global values: `Q`

Improved metrics