@discourse/types 0.0.1 → 0.0.2

package/external-types/@types__qunit/package.json

@@ -0,0 +1,51 @@
+{
+    "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"
+}

package/external-types/@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/@types__rsvp/index.d.ts

@@ -0,0 +1,497 @@
+declare module 'rsvp' {
+// These types are derived in large part from the Microsoft-supplied types for
+// ES2015 Promises. They have been tweaked to support RSVP's extensions to the
+// Promises A+ spec and the additional helper functions it supplies.
+
+declare 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/@types__rsvp/package.json

@@ -0,0 +1,35 @@
+{
+    "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"
+}

package/external-types/ember-modifier/LICENSE.md

@@ -0,0 +1,9 @@
+The MIT License (MIT)
+
+Copyright (c) 2019
+
+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/ember-modifier/declarations/-private/class-based/modifier-manager.d.ts

@@ -0,0 +1,43 @@
+declare module 'ember-modifier/-private/class-based/modifier-manager' {
+import type Owner from '@ember/owner';
+import type ClassBasedModifier from './modifier';
+import type { ArgsFor, ElementFor } from '../signature';
+/**
+ * The state bucket used throughout the life-cycle of the modifier. Basically a
+ * state *machine*, where the framework calls us with the version we hand back
+ * to it at each phase. The two states are the two `extends` versions of this
+ * below.
+ *
+ * @internal
+ */
+interface State<S> {
+    instance: ClassBasedModifier<S>;
+}
+/**
+ * The `State` after calling `createModifier`, and therefore the state available
+ * at the start of `InstallModifier`.
+ * @internal
+ */
+interface CreatedState<S> extends State<S> {
+    element: null;
+}
+/**
+ * The `State` after calling `installModifier`, and therefore the state
+ * available in all `updateModifier` calls and in `destroyModifier`.
+ * @internal
+ */
+interface InstalledState<S> extends State<S> {
+    element: ElementFor<S>;
+}
+export default class ClassBasedModifierManager<S> {
+    private owner;
+    capabilities: unknown;
+    constructor(owner: Owner);
+    createModifier(modifierClass: typeof ClassBasedModifier, args: ArgsFor<S>): CreatedState<S>;
+    installModifier(createdState: CreatedState<S>, element: ElementFor<S>, args: ArgsFor<S>): void;
+    updateModifier(state: InstalledState<S>, args: ArgsFor<S>): void;
+    destroyModifier({ instance }: InstalledState<S>): void;
+}
+export {};
+//# sourceMappingURL=modifier-manager.d.ts.map
+}