@discourse/types 0.0.2 → 2026.1.0-2709d36

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

@@ -1,51 +0,0 @@
-{
-    "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/index.d.ts

@@ -1,497 +0,0 @@
-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

@@ -1,35 +0,0 @@
-{
-    "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/declarations/-private/class-based/modifier-manager.d.ts

@@ -1,43 +0,0 @@
-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
-}