@discourse/types 0.0.2 → 2026.1.0-2709d36

package/external-types/qunit/package.json

@@ -0,0 +1,52 @@
+{
+  "name": "@types/qunit",
+  "version": "2.19.13",
+  "description": "TypeScript definitions for qunit",
+  "homepage": "https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/qunit",
+  "license": "MIT",
+  "contributors": [
+    {
+      "name": "James Bracy",
+      "githubUsername": "waratuman",
+      "url": "https://github.com/waratuman"
+    },
+    {
+      "name": "Stefan Sechelmann",
+      "githubUsername": "sechel",
+      "url": "https://github.com/sechel"
+    },
+    {
+      "name": "Krystan HuffMenne",
+      "githubUsername": "gitKrystan",
+      "url": "https://github.com/gitKrystan"
+    },
+    {
+      "name": "James C. Davis",
+      "githubUsername": "jamescdavis",
+      "url": "https://github.com/jamescdavis"
+    },
+    {
+      "name": "Peter Wagenet",
+      "githubUsername": "wagenet",
+      "url": "https://github.com/wagenet"
+    },
+    {
+      "name": "Timo Tijhof",
+      "githubUsername": "Krinkle",
+      "url": "https://github.com/Krinkle"
+    }
+  ],
+  "main": "",
+  "types": "index.d.ts",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/DefinitelyTyped/DefinitelyTyped.git",
+    "directory": "types/qunit"
+  },
+  "scripts": {},
+  "dependencies": {},
+  "peerDependencies": {},
+  "typesPublisherContentHash": "6efc5498e0df23deb29b9c5c74054b5373adca817b2ae1ce60472998a4e02229",
+  "typeScriptVersion": "5.2",
+  "__types": "index.d.ts"
+}

package/external-types/rsvp/LICENSE

@@ -0,0 +1,21 @@
+    MIT License
+
+    Copyright (c) Microsoft Corporation.
+
+    Permission is hereby granted, free of charge, to any person obtaining a copy
+    of this software and associated documentation files (the "Software"), to deal
+    in the Software without restriction, including without limitation the rights
+    to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+    copies of the Software, and to permit persons to whom the Software is
+    furnished to do so, subject to the following conditions:
+
+    The above copyright notice and this permission notice shall be included in all
+    copies or substantial portions of the Software.
+
+    THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+    IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+    FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+    AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+    LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+    OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+    SOFTWARE

package/external-types/rsvp/index.d.ts

@@ -0,0 +1,493 @@
+declare module 'rsvp' {
+	 namespace RSVP {
+	    // All the Promise methods essentially flatten existing promises, so that
+	    // you don't end up with `Promise<Promise<Promise<string>>>` if you happen
+	    // to return another `Promise` from a `.then()` invocation, etc. So all of
+	    // them can take a type or a promise-like/then-able type.
+	    type Arg<T> = T | PromiseLike<T>;
+
+	    // RSVP supplies status for promises in certain places.
+	    enum State {
+	        fulfilled = "fulfilled",
+	        rejected = "rejected",
+	        pending = "pending",
+	    }
+
+	    type Resolved<T> = {
+	        state: State.fulfilled;
+	        value: T;
+	    };
+
+	    type Rejected<T = any> = {
+	        state: State.rejected;
+	        reason: T;
+	    };
+
+	    type Pending = {
+	        state: State.pending;
+	    };
+
+	    type PromiseState<T> = Resolved<T> | Rejected | Pending;
+
+	    type Deferred<T> = {
+	        promise: Promise<T>;
+	        resolve: (value?: RSVP.Arg<T>) => void;
+	        reject: (reason?: any) => void;
+	    };
+
+	    interface InstrumentEvent {
+	        guid: string; // guid of promise. Must be globally unique, not just within the implementation
+	        childGuid: string; // child of child promise (for chained via `then`)
+	        eventName: string; // one of ['created', 'chained', 'fulfilled', 'rejected']
+	        detail: any; // fulfillment value or rejection reason, if applicable
+	        label: string; // label passed to promise's constructor
+	        timeStamp: number; // milliseconds elapsed since 1 January 1970 00:00:00 UTC up until now
+	    }
+
+	    interface ObjectWithEventMixins {
+	        on(
+	            eventName: "created" | "chained" | "fulfilled" | "rejected",
+	            listener: (event: InstrumentEvent) => void,
+	        ): void;
+	        on(eventName: "error", errorHandler: (reason: any) => void): void;
+	        on(eventName: string, callback: (value: any) => void): void;
+	        off(eventName: string, callback?: (value: any) => void): void;
+	        trigger(eventName: string, options?: any, label?: string): void;
+	    }
+
+	    class EventTarget {
+	        /** `RSVP.EventTarget.mixin` extends an object with EventTarget methods. */
+	        static mixin(object: object): ObjectWithEventMixins;
+
+	        /** Registers a callback to be executed when `eventName` is triggered */
+	        static on(
+	            eventName: "created" | "chained" | "fulfilled" | "rejected",
+	            listener: (event: InstrumentEvent) => void,
+	        ): void;
+	        static on(eventName: "error", errorHandler: (reason: any) => void): void;
+	        static on(eventName: string, callback: (value: any) => void): void;
+
+	        /**
+	         * You can use `off` to stop firing a particular callback for an event.
+	         *
+	         * If you don't pass a `callback` argument to `off`, ALL callbacks for the
+	         * event will not be executed when the event fires.
+	         */
+	        static off(eventName: string, callback?: (value: any) => void): void;
+
+	        /**
+	         * Use `trigger` to fire custom events.
+	         *
+	         * You can also pass a value as a second argument to `trigger` that will be
+	         * passed as an argument to all event listeners for the event
+	         */
+	        static trigger(eventName: string, options?: any, label?: string): void;
+	    }
+
+	    class Promise<T> implements PromiseLike<T> {
+	        constructor(
+	            executor: (resolve: (value?: RSVP.Arg<T>) => void, reject: (reason?: any) => void) => void,
+	            label?: string,
+	        );
+
+	        new<T>(
+	            executor: (resolve: (value?: RSVP.Arg<T>) => void, reject: (reason?: any) => void) => void,
+	        ): RSVP.Promise<T>;
+
+	        then<TResult1 = T, TResult2 = never>(
+	            onFulfilled?: ((value: T) => TResult1 | PromiseLike<TResult1>) | null,
+	            onRejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null,
+	            label?: string,
+	        ): RSVP.Promise<TResult1 | TResult2>;
+
+	        catch<TResult = never>(
+	            onRejected?: ((reason: any) => TResult | PromiseLike<TResult>) | null,
+	            label?: string,
+	        ): RSVP.Promise<T | TResult>;
+
+	        finally<U>(onFinally?: U | PromiseLike<U>): RSVP.Promise<T>;
+
+	        readonly [Symbol.toStringTag]: "Promise";
+
+	        static all<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>(
+	            values: [Arg<T1>, Arg<T2>, Arg<T3>, Arg<T4>, Arg<T5>, Arg<T6>, Arg<T7>, Arg<T8>, Arg<T9>, Arg<T10>],
+	            label?: string,
+	        ): RSVP.Promise<[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]>;
+	        static all<T1, T2, T3, T4, T5, T6, T7, T8, T9>(
+	            values: [Arg<T1>, Arg<T2>, Arg<T3>, Arg<T4>, Arg<T5>, Arg<T6>, Arg<T7>, Arg<T8>, Arg<T9>],
+	            label?: string,
+	        ): RSVP.Promise<[T1, T2, T3, T4, T5, T6, T7, T8, T9]>;
+	        static all<T1, T2, T3, T4, T5, T6, T7, T8>(
+	            values: [Arg<T1>, Arg<T2>, Arg<T3>, Arg<T4>, Arg<T5>, Arg<T6>, Arg<T7>, Arg<T8>],
+	            label?: string,
+	        ): RSVP.Promise<[T1, T2, T3, T4, T5, T6, T7, T8]>;
+	        static all<T1, T2, T3, T4, T5, T6, T7>(
+	            values: [Arg<T1>, Arg<T2>, Arg<T3>, Arg<T4>, Arg<T5>, Arg<T6>, Arg<T7>],
+	            label?: string,
+	        ): RSVP.Promise<[T1, T2, T3, T4, T5, T6, T7]>;
+	        static all<T1, T2, T3, T4, T5, T6>(
+	            values: [Arg<T1>, Arg<T2>, Arg<T3>, Arg<T4>, Arg<T5>, Arg<T6>],
+	            label?: string,
+	        ): RSVP.Promise<[T1, T2, T3, T4, T5, T6]>;
+	        static all<T1, T2, T3, T4, T5>(
+	            values: [Arg<T1>, Arg<T2>, Arg<T3>, Arg<T4>, Arg<T5>],
+	            label?: string,
+	        ): RSVP.Promise<[T1, T2, T3, T4, T5]>;
+	        static all<T1, T2, T3, T4>(
+	            values: [Arg<T1>, Arg<T2>, Arg<T3>, Arg<T4>],
+	            label?: string,
+	        ): RSVP.Promise<[T1, T2, T3, T4]>;
+	        static all<T1, T2, T3>(values: [Arg<T1>, Arg<T2>, Arg<T3>], label?: string): RSVP.Promise<[T1, T2, T3]>;
+	        static all<T1, T2>(values: [Arg<T1>, Arg<T2>], label?: string): Promise<[T1, T2]>;
+	        static all<T>(values: Array<Arg<T>>, label?: string): RSVP.Promise<T[]>;
+
+	        static race<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>(
+	            values: [
+	                Arg<T1>,
+	                Arg<T2>,
+	                Arg<T3>,
+	                Arg<T4>,
+	                Arg<T5>,
+	                Arg<T6>,
+	                Arg<T7>,
+	                Arg<T8>,
+	                Arg<T9>,
+	                T10 | PromiseLike<T10>,
+	            ],
+	            label?: string,
+	        ): RSVP.Promise<T1 | T2 | T3 | T4 | T5 | T6 | T7 | T8 | T9 | T10>;
+	        static race<T1, T2, T3, T4, T5, T6, T7, T8, T9>(
+	            values: [Arg<T1>, Arg<T2>, Arg<T3>, Arg<T4>, Arg<T5>, Arg<T6>, Arg<T7>, Arg<T8>, Arg<T9>],
+	            label?: string,
+	        ): RSVP.Promise<T1 | T2 | T3 | T4 | T5 | T6 | T7 | T8 | T9>;
+	        static race<T1, T2, T3, T4, T5, T6, T7, T8>(
+	            values: [Arg<T1>, Arg<T2>, Arg<T3>, Arg<T4>, Arg<T5>, Arg<T6>, Arg<T7>, Arg<T8>],
+	            label?: string,
+	        ): RSVP.Promise<T1 | T2 | T3 | T4 | T5 | T6 | T7 | T8>;
+	        static race<T1, T2, T3, T4, T5, T6, T7>(
+	            values: [Arg<T1>, Arg<T2>, Arg<T3>, Arg<T4>, Arg<T5>, Arg<T6>, Arg<T7>],
+	            label?: string,
+	        ): RSVP.Promise<T1 | T2 | T3 | T4 | T5 | T6 | T7>;
+	        static race<T1, T2, T3, T4, T5, T6>(
+	            values: [Arg<T1>, Arg<T2>, Arg<T3>, Arg<T4>, Arg<T5>, Arg<T6>],
+	            label?: string,
+	        ): RSVP.Promise<T1 | T2 | T3 | T4 | T5 | T6>;
+	        static race<T1, T2, T3, T4, T5>(
+	            values: [Arg<T1>, Arg<T2>, Arg<T3>, Arg<T4>, Arg<T5>],
+	            label?: string,
+	        ): RSVP.Promise<T1 | T2 | T3 | T4 | T5>;
+	        static race<T1, T2, T3, T4>(
+	            values: [Arg<T1>, Arg<T2>, Arg<T3>, Arg<T4>],
+	            label?: string,
+	        ): RSVP.Promise<T1 | T2 | T3 | T4>;
+	        static race<T1, T2, T3>(values: [Arg<T1>, Arg<T2>, Arg<T3>], label?: string): RSVP.Promise<T1 | T2 | T3>;
+	        static race<T1, T2>(values: [Arg<T1>, Arg<T2>], label?: string): RSVP.Promise<T1 | T2>;
+	        static race<T>(values: Array<Arg<T>>, label?: string): RSVP.Promise<T>;
+
+	        static reject(reason?: any, label?: string): RSVP.Promise<never>;
+
+	        static resolve<T>(value?: Arg<T>, label?: string): RSVP.Promise<T>;
+	        static resolve(): RSVP.Promise<void>;
+
+	        /**
+	         * @deprecated
+	         */
+	        static cast: typeof RSVP.Promise.resolve;
+	    }
+
+	    const all: typeof Promise.all;
+	    const race: typeof Promise.race;
+	    const reject: typeof Promise.reject;
+	    const resolve: typeof Promise.resolve;
+	    function rethrow(reason: any): void;
+
+	    const cast: typeof Promise.cast;
+
+	    const on: typeof EventTarget.on;
+	    const off: typeof EventTarget.off;
+
+	    // ----- denodeify ----- //
+	    // Here be absurd things because we don't have variadic types. All of
+	    // this will go away if we can ever write this:
+	    //
+	    //     denodeify<...T, ...A>(
+	    //         nodeFunc: (...args: ...A, callback: (err: any, ...cbArgs: ...T) => any) => void,
+	    //         options?: false
+	    //     ): (...args: ...A) => RSVP.Promise<...T>
+	    //
+	    // That day, however, may never come. So, in the meantime, we do this.
+
+	    function denodeify<T1, T2, T3, A>(
+	        nodeFunc: (arg1: A, callback: (err: any, data1: T1, data2: T2, data3: T3) => void) => void,
+	        options?: false,
+	    ): (arg1: A) => RSVP.Promise<T1>;
+
+	    function denodeify<T1, T2, A>(
+	        nodeFunc: (arg1: A, callback: (err: any, data1: T1, data2: T2) => void) => void,
+	        options?: false,
+	    ): (arg1: A) => RSVP.Promise<T1>;
+
+	    function denodeify<T, A>(
+	        nodeFunc: (arg1: A, callback: (err: any, data: T) => void) => void,
+	        options?: false,
+	    ): (arg1: A) => RSVP.Promise<T>;
+
+	    function denodeify<T1, T2, T3, A>(
+	        nodeFunc: (arg1: A, callback: (err: any, data1: T1, data2: T2, data3: T3) => void) => void,
+	        options: true,
+	    ): (arg1: A) => RSVP.Promise<[T1, T2, T3]>;
+
+	    function denodeify<T1, T2, A>(
+	        nodeFunc: (arg1: A, callback: (err: any, data1: T1, data2: T2) => void) => void,
+	        options: true,
+	    ): (arg1: A) => RSVP.Promise<[T1, T2]>;
+
+	    function denodeify<T, A>(
+	        nodeFunc: (arg1: A, callback: (err: any, data: T) => void) => void,
+	        options: true,
+	    ): (arg1: A) => RSVP.Promise<[T]>;
+
+	    function denodeify<T1, T2, T3, A, K1 extends string, K2 extends string, K3 extends string>(
+	        nodeFunc: (arg1: A, callback: (err: any, data1: T1, data2: T2, data3: T3) => void) => void,
+	        options: [K1, K2, K3],
+	    ): (arg1: A) => RSVP.Promise<{ [K in K1]: T1 } & { [K in K2]: T2 } & { [K in K3]: T3 }>;
+
+	    function denodeify<T1, T2, A, K1 extends string, K2 extends string>(
+	        nodeFunc: (arg1: A, callback: (err: any, data1: T1, data2: T2) => void) => void,
+	        options: [K1, K2],
+	    ): (arg1: A) => RSVP.Promise<{ [K in K1]: T1 } & { [K in K2]: T2 }>;
+
+	    function denodeify<T, A, K1 extends string>(
+	        nodeFunc: (arg1: A, callback: (err: any, data: T) => void) => void,
+	        options: [K1],
+	    ): (arg1: A) => RSVP.Promise<{ [K in K1]: T }>;
+
+	    // ----- hash and hashSettled ----- //
+	    function hash<T>(object: { [P in keyof T]: Arg<T[P]> }, label?: string): RSVP.Promise<T>;
+	    function hashSettled<T>(
+	        object: { [P in keyof T]: Arg<T[P]> },
+	        label?: string,
+	    ): RSVP.Promise<{ [P in keyof T]: PromiseState<T[P]> }>;
+
+	    function allSettled<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>(
+	        entries: [Arg<T1>, Arg<T2>, Arg<T3>, Arg<T4>, Arg<T5>, Arg<T6>, Arg<T7>, Arg<T8>, Arg<T9>, Arg<T10>],
+	        label?: string,
+	    ): RSVP.Promise<
+	        [
+	            PromiseState<T1>,
+	            PromiseState<T2>,
+	            PromiseState<T3>,
+	            PromiseState<T4>,
+	            PromiseState<T5>,
+	            PromiseState<T6>,
+	            PromiseState<T7>,
+	            PromiseState<T8>,
+	            PromiseState<T9>,
+	        ]
+	    >;
+	    function allSettled<T1, T2, T3, T4, T5, T6, T7, T8, T9>(
+	        entries: [Arg<T1>, Arg<T2>, Arg<T3>, Arg<T4>, Arg<T5>, Arg<T6>, Arg<T7>, Arg<T8>, Arg<T9>],
+	        label?: string,
+	    ): RSVP.Promise<
+	        [
+	            PromiseState<T1>,
+	            PromiseState<T2>,
+	            PromiseState<T3>,
+	            PromiseState<T4>,
+	            PromiseState<T5>,
+	            PromiseState<T6>,
+	            PromiseState<T7>,
+	            PromiseState<T8>,
+	            PromiseState<T9>,
+	        ]
+	    >;
+	    function allSettled<T1, T2, T3, T4, T5, T6, T7, T8>(
+	        entries: [Arg<T1>, Arg<T2>, Arg<T3>, Arg<T4>, Arg<T5>, Arg<T6>, Arg<T7>, Arg<T8>],
+	        label?: string,
+	    ): RSVP.Promise<
+	        [
+	            PromiseState<T1>,
+	            PromiseState<T2>,
+	            PromiseState<T3>,
+	            PromiseState<T4>,
+	            PromiseState<T5>,
+	            PromiseState<T6>,
+	            PromiseState<T7>,
+	            PromiseState<T8>,
+	        ]
+	    >;
+	    function allSettled<T1, T2, T3, T4, T5, T6, T7>(
+	        entries: [Arg<T1>, Arg<T2>, Arg<T3>, Arg<T4>, Arg<T5>, Arg<T6>, Arg<T7>],
+	        label?: string,
+	    ): RSVP.Promise<
+	        [
+	            PromiseState<T1>,
+	            PromiseState<T2>,
+	            PromiseState<T3>,
+	            PromiseState<T4>,
+	            PromiseState<T5>,
+	            PromiseState<T6>,
+	            PromiseState<T7>,
+	        ]
+	    >;
+	    function allSettled<T1, T2, T3, T4, T5, T6>(
+	        entries: [Arg<T1>, Arg<T2>, Arg<T3>, Arg<T4>, Arg<T5>, Arg<T6>],
+	        label?: string,
+	    ): RSVP.Promise<
+	        [PromiseState<T1>, PromiseState<T2>, PromiseState<T3>, PromiseState<T4>, PromiseState<T5>, PromiseState<T6>]
+	    >;
+	    function allSettled<T1, T2, T3, T4, T5>(
+	        entries: [Arg<T1>, Arg<T2>, Arg<T3>, Arg<T4>, Arg<T5>],
+	        label?: string,
+	    ): RSVP.Promise<[PromiseState<T1>, PromiseState<T2>, PromiseState<T3>, PromiseState<T4>, PromiseState<T5>]>;
+	    function allSettled<T1, T2, T3, T4>(
+	        entries: [Arg<T1>, Arg<T2>, Arg<T3>, Arg<T4>],
+	        label?: string,
+	    ): RSVP.Promise<[PromiseState<T1>, PromiseState<T2>, PromiseState<T3>, PromiseState<T4>]>;
+	    function allSettled<T1, T2, T3>(
+	        entries: [Arg<T1>, Arg<T2>, Arg<T3>],
+	        label?: string,
+	    ): RSVP.Promise<[PromiseState<T1>, PromiseState<T2>, PromiseState<T3>]>;
+	    function allSettled<T1, T2>(
+	        entries: [Arg<T1>, Arg<T2>],
+	        label?: string,
+	    ): RSVP.Promise<[PromiseState<T1>, PromiseState<T2>]>;
+	    function allSettled<T>(entries: Array<Arg<T>>, label?: string): RSVP.Promise<[PromiseState<T>]>;
+
+	    function map<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, U>(
+	        entries: [Arg<T1>, Arg<T2>, Arg<T3>, Arg<T4>, Arg<T5>, Arg<T6>, Arg<T7>, Arg<T8>, Arg<T9>, Arg<T10>],
+	        mapFn: (item: T1 | T2 | T3 | T4 | T5 | T6 | T7 | T8 | T9 | T10) => U,
+	        label?: string,
+	    ): RSVP.Promise<U[] & { length: 10 }>;
+
+	    function map<T1, T2, T3, T4, T5, T6, T7, T8, T9, U>(
+	        entries: [Arg<T1>, Arg<T2>, Arg<T3>, Arg<T4>, Arg<T5>, Arg<T6>, Arg<T7>, Arg<T8>, Arg<T9>],
+	        mapFn: (item: T1 | T2 | T3 | T4 | T5 | T6 | T7 | T8 | T9) => U,
+	        label?: string,
+	    ): RSVP.Promise<U[] & { length: 9 }>;
+	    function map<T1, T2, T3, T4, T5, T6, T7, T8, U>(
+	        entries: [Arg<T1>, Arg<T2>, Arg<T3>, Arg<T4>, Arg<T5>, Arg<T6>, Arg<T7>, Arg<T8>],
+	        mapFn: (item: T1 | T2 | T3 | T4 | T5 | T6 | T7 | T8) => U,
+	        label?: string,
+	    ): RSVP.Promise<U[] & { length: 8 }>;
+	    function map<T1, T2, T3, T4, T5, T6, T7, U>(
+	        entries: [Arg<T1>, Arg<T2>, Arg<T3>, Arg<T4>, Arg<T5>, Arg<T6>, Arg<T7>],
+	        mapFn: (item: T1 | T2 | T3 | T4 | T5 | T6 | T7) => U,
+	        label?: string,
+	    ): RSVP.Promise<U[] & { length: 7 }>;
+	    function map<T1, T2, T3, T4, T5, T6, U>(
+	        entries: [Arg<T1>, Arg<T2>, Arg<T3>, Arg<T4>, Arg<T5>, Arg<T6>],
+	        mapFn: (item: T1 | T2 | T3 | T4 | T5 | T6) => U,
+	        label?: string,
+	    ): RSVP.Promise<U[] & { length: 6 }>;
+	    function map<T1, T2, T3, T4, T5, U>(
+	        entries: [Arg<T1>, Arg<T2>, Arg<T3>, Arg<T4>, Arg<T5>],
+	        mapFn: (item: T1 | T2 | T3 | T4 | T5) => U,
+	        label?: string,
+	    ): RSVP.Promise<U[] & { length: 5 }>;
+	    function map<T1, T2, T3, T4, U>(
+	        entries: [Arg<T1>, Arg<T2>, Arg<T3>, Arg<T4>],
+	        mapFn: (item: T1 | T2 | T3 | T4) => U,
+	        label?: string,
+	    ): RSVP.Promise<U[] & { length: 4 }>;
+	    function map<T1, T2, T3, U>(
+	        entries: [Arg<T1>, Arg<T2>, Arg<T3>],
+	        mapFn: (item: T1 | T2 | T3) => U,
+	        label?: string,
+	    ): RSVP.Promise<U[] & { length: 3 }>;
+	    function map<T1, T2, U>(
+	        entries: [Arg<T1>, Arg<T2>],
+	        mapFn: (item: T1 | T2) => U,
+	        label?: string,
+	    ): RSVP.Promise<U[] & { length: 2 }>;
+	    function map<T, U>(
+	        entries: Array<Arg<T>>,
+	        mapFn: (item: T) => U,
+	        label?: string,
+	    ): RSVP.Promise<U[] & { length: 1 }>;
+
+	    function filter<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>(
+	        entries: [Arg<T1>, Arg<T2>, Arg<T3>, Arg<T4>, Arg<T5>, Arg<T6>, Arg<T7>, Arg<T8>, Arg<T9>, Arg<T10>],
+	        filterFn: (item: T1 | T2 | T3 | T4 | T5 | T6 | T7 | T8 | T9 | T10) => boolean,
+	        label?: string,
+	    ): RSVP.Promise<Array<T1 | T2 | T3 | T4 | T5 | T6 | T7 | T8 | T9 | T10>>;
+	    function filter<T1, T2, T3, T4, T5, T6, T7, T8, T9>(
+	        entries: [Arg<T1>, Arg<T2>, Arg<T3>, Arg<T4>, Arg<T5>, Arg<T6>, Arg<T7>, Arg<T8>, Arg<T9>],
+	        filterFn: (item: T1 | T2 | T3 | T4 | T5 | T6 | T7 | T8 | T9) => boolean,
+	        label?: string,
+	    ): RSVP.Promise<Array<T1 | T2 | T3 | T4 | T5 | T6 | T7 | T8 | T9>>;
+	    function filter<T1, T2, T3, T4, T5, T6, T7, T8>(
+	        entries: [Arg<T1>, Arg<T2>, Arg<T3>, Arg<T4>, Arg<T5>, Arg<T6>, Arg<T7>, Arg<T8>],
+	        filterFn: (item: T1 | T2 | T3 | T4 | T5 | T6 | T7 | T8) => boolean,
+	        label?: string,
+	    ): RSVP.Promise<Array<T1 | T2 | T3 | T4 | T5 | T6 | T7 | T8>>;
+	    function filter<T1, T2, T3, T4, T5, T6, T7>(
+	        entries: [Arg<T1>, Arg<T2>, Arg<T3>, Arg<T4>, Arg<T5>, Arg<T6>, Arg<T7>],
+	        filterFn: (item: T1 | T2 | T3 | T4 | T5 | T6 | T7) => boolean,
+	        label?: string,
+	    ): RSVP.Promise<Array<T1 | T2 | T3 | T4 | T5 | T6 | T7>>;
+	    function filter<T1, T2, T3, T4, T5, T6>(
+	        entries: [Arg<T1>, Arg<T2>, Arg<T3>, Arg<T4>, Arg<T5>, Arg<T6>],
+	        filterFn: (item: T1 | T2 | T3 | T4 | T5 | T6) => boolean,
+	        label?: string,
+	    ): RSVP.Promise<Array<T1 | T2 | T3 | T4 | T5 | T6> & { length: 6 }>;
+	    function filter<T1, T2, T3, T4, T5>(
+	        entries: [Arg<T1>, Arg<T2>, Arg<T3>, Arg<T4>, Arg<T5>],
+	        filterFn: (item: T1 | T2 | T3 | T4 | T5) => boolean,
+	        label?: string,
+	    ): RSVP.Promise<Array<T1 | T2 | T3 | T4 | T5>>;
+	    function filter<T1, T2, T3, T4>(
+	        entries: [Arg<T1>, Arg<T2>, Arg<T3>, Arg<T4>],
+	        filterFn: (item: T1 | T2 | T3 | T4) => boolean,
+	        label?: string,
+	    ): RSVP.Promise<Array<T1 | T2 | T3 | T4>>;
+	    function filter<T1, T2, T3>(
+	        entries: [Arg<T1>, Arg<T2>, Arg<T3>],
+	        filterFn: (item: T1 | T2 | T3) => boolean,
+	        label?: string,
+	    ): RSVP.Promise<Array<T1 | T2 | T3>>;
+	    function filter<T1, T2>(
+	        entries: [Arg<T1>, Arg<T2>],
+	        filterFn: (item: T1 | T2) => boolean,
+	        label?: string,
+	    ): RSVP.Promise<Array<T1 | T2>>;
+	    function filter<T>(entries: Array<Arg<T>>, filterFn: (item: T) => boolean, label?: string): RSVP.Promise<T[]>;
+
+	    function defer<T>(label?: string): Deferred<T>;
+
+	    function configure<T>(name: string): T;
+	    function configure<T>(name: string, value: T): void;
+
+	    function asap<T, U>(callback: (callbackArg: T) => U, arg: T): void;
+
+	    const async: typeof asap;
+	}
+
+	export default RSVP;
+
+	export interface Promise<T> extends RSVP.Promise<T> {}
+	export const Promise: typeof RSVP.Promise;
+
+	export interface EventTarget extends RSVP.EventTarget {}
+	export const EventTarget: typeof RSVP.EventTarget;
+
+	export const asap: typeof RSVP.asap;
+	export const cast: typeof RSVP.cast;
+	export const all: typeof RSVP.all;
+	export const allSettled: typeof RSVP.allSettled;
+	export const race: typeof RSVP.race;
+	export const hash: typeof RSVP.hash;
+	export const hashSettled: typeof RSVP.hashSettled;
+	export const rethrow: typeof RSVP.rethrow;
+	export const defer: typeof RSVP.defer;
+	export const denodeify: typeof RSVP.denodeify;
+	export const configure: typeof RSVP.configure;
+	export const on: typeof RSVP.on;
+	export const off: typeof RSVP.off;
+	export const resolve: typeof RSVP.resolve;
+	export const reject: typeof RSVP.reject;
+	export const map: typeof RSVP.map;
+	export const async: typeof RSVP.async;
+	export const filter: typeof RSVP.filter;
+
+}

package/external-types/rsvp/package.json

@@ -0,0 +1,36 @@
+{
+  "name": "@types/rsvp",
+  "version": "4.0.9",
+  "description": "TypeScript definitions for rsvp",
+  "homepage": "https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/rsvp",
+  "license": "MIT",
+  "contributors": [
+    {
+      "name": "Krystan HuffMenne",
+      "githubUsername": "gitKrystan",
+      "url": "https://github.com/gitKrystan"
+    },
+    {
+      "name": "James C. Davis",
+      "githubUsername": "jamescdavis",
+      "url": "https://github.com/jamescdavis"
+    },
+    {
+      "name": "Peter Wagenet",
+      "githubUsername": "wagenet",
+      "url": "https://github.com/wagenet"
+    }
+  ],
+  "main": "",
+  "types": "index.d.ts",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/DefinitelyTyped/DefinitelyTyped.git",
+    "directory": "types/rsvp"
+  },
+  "scripts": {},
+  "dependencies": {},
+  "typesPublisherContentHash": "d5bedb67b0c16cb9f848204d65877287c339a8569914d51746879d85233e5a25",
+  "typeScriptVersion": "4.6",
+  "__types": "index.d.ts"
+}

package/external-types/sinon/LICENSE

@@ -0,0 +1,21 @@
+    MIT License
+
+    Copyright (c) Microsoft Corporation.
+
+    Permission is hereby granted, free of charge, to any person obtaining a copy
+    of this software and associated documentation files (the "Software"), to deal
+    in the Software without restriction, including without limitation the rights
+    to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+    copies of the Software, and to permit persons to whom the Software is
+    furnished to do so, subject to the following conditions:
+
+    The above copyright notice and this permission notice shall be included in all
+    copies or substantial portions of the Software.
+
+    THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+    IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+    FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+    AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+    LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+    OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+    SOFTWARE