ember-source 6.12.0 → 7.0.0-beta.1

package/types/stable/ember/index.d.ts

@@ -1,358 +0,0 @@
-declare module 'ember' {
-    /**
-    @module ember
-    */
-    import * as utils from "@ember/-internals/utils";
-    import { Registry as InternalRegistry, Container as InternalContainer } from "@ember/-internals/container";
-    import * as instrumentation from "@ember/instrumentation";
-    import * as metal from "@ember/-internals/metal";
-    import { isEnabled } from "@ember/canary-features";
-    import * as EmberDebug from "@ember/debug";
-    import Backburner from "backburner.js";
-    import EmberController, { inject as injectController, ControllerMixin as EmberControllerMixin } from "@ember/controller";
-    import EmberService from "@ember/service";
-    import EmberObject, { action, observer as emberObserver } from "@ember/object";
-    import { dependentKeyCompat } from "@ember/object/compat";
-    import EmberComputedProperty from "@ember/object/computed";
-    import { RSVP as _RSVP, Comparable as InternalComparable, ActionHandler as InternalActionHandler } from "@ember/-internals/runtime";
-    import { componentCapabilities, modifierCapabilities, setComponentManager, template, isSerializationFirstNode, type TemplatesRegistry } from "@ember/-internals/glimmer";
-    import * as views from "@ember/-internals/views";
-    import EmberContainerDebugAdapter from "@ember/debug/container-debug-adapter";
-    import EmberDataAdapter from "@ember/debug/data-adapter";
-    import { run as emberRun } from "@ember/runloop";
-    import EmberArray, { NativeArray as EmberNativeArray, isArray as emberIsArray, makeArray as emberMakeArray } from "@ember/array";
-    import EmberMutableArray from "@ember/array/mutable";
-    import EmberArrayProxy from "@ember/array/proxy";
-    import EmberApplication, { onLoad as applicationOnLoad, runLoadHooks as applicationRunLoadHooks } from "@ember/application";
-    import EmberApplicationInstance from "@ember/application/instance";
-    import EmberNamespace from "@ember/application/namespace";
-    import EmberComponent, { Input as EmberInput } from "@ember/component";
-    import EmberHelper from "@ember/component/helper";
-    import EmberEngine from "@ember/engine";
-    import EmberEngineInstance from "@ember/engine/instance";
-    import EmberEnumerable from "@ember/enumerable";
-    import EmberMutableEnumerable from "@ember/enumerable/mutable";
-    import EmberCoreObject from "@ember/object/core";
-    import EmberEvented from "@ember/object/evented";
-    import EmberMixin, { mixin as emberMixin } from "@ember/object/mixin";
-    import EmberObservable from "@ember/object/observable";
-    import EmberObjectProxy from "@ember/object/proxy";
-    import EmberPromiseProxyMixin from "@ember/object/promise-proxy-mixin";
-    import EmberHashLocation from "@ember/routing/hash-location";
-    import EmberHistoryLocation from "@ember/routing/history-location";
-    import EmberNoneLocation from "@ember/routing/none-location";
-    import EmberRoute from "@ember/routing/route";
-    import EmberRouter from "@ember/routing/router";
-    import { controllerFor as emberControllerFor, generateController as emberGenerateController, generateControllerFactory as emberGenerateControllerFactory, DSL as EmberRouterDSL } from "@ember/routing/-internals";
-    import { isNone as emberIsNone, isBlank as emberIsBlank, isEmpty as emberIsEmpty, isPresent as emberIsPresent, isEqual as emberIsEqual, typeOf as emberTypeOf, compare as emberCompare } from "@ember/utils";
-    import * as glimmerRuntime from "@glimmer/runtime";
-    import { helperCapabilities, setModifierManager, setComponentTemplate, getComponentTemplate, setHelperManager } from "@glimmer/manager";
-    import { associateDestroyableChild, registerDestructor, unregisterDestructor } from "@ember/destroyable";
-    import type { precompile, compile } from "ember-template-compiler";
-    import { _impl as EmberTestingImpl } from "@ember/test";
-    namespace Ember {
-        const isNamespace = true;
-        function toString(): string;
-        const Container: typeof InternalContainer;
-        type Container = InternalContainer;
-        const Registry: typeof InternalRegistry;
-        type Registry = InternalRegistry;
-        const _setComponentManager: typeof setComponentManager;
-        const _componentManagerCapabilities: typeof componentCapabilities;
-        const _modifierManagerCapabilities: typeof modifierCapabilities;
-        const meta: {
-            (obj: object): import("@ember/-internals/meta").Meta;
-            _counters?: import("@ember/-internals/meta").MetaCounters;
-        };
-        const _createCache: typeof metal.createCache;
-        const _cacheGetValue: typeof metal.getValue;
-        const _cacheIsConst: typeof metal.isConst;
-        const _descriptor: typeof metal.nativeDescDecorator;
-        const _getPath: typeof metal._getPath;
-        const _setClassicDecorator: typeof metal.setClassicDecorator;
-        const _tracked: typeof metal.tracked;
-        const beginPropertyChanges: typeof metal.beginPropertyChanges;
-        const changeProperties: typeof metal.changeProperties;
-        const endPropertyChanges: typeof metal.endPropertyChanges;
-        const hasListeners: typeof metal.hasListeners;
-        const libraries: metal.Libraries;
-        const _ContainerProxyMixin: EmberMixin;
-        const _ProxyMixin: EmberMixin;
-        const _RegistryProxyMixin: EmberMixin;
-        const ActionHandler: EmberMixin;
-        type ActionHandler = InternalActionHandler;
-        const Comparable: EmberMixin;
-        type Comparable = InternalComparable;
-        const ComponentLookup: typeof views.ComponentLookup;
-        const EventDispatcher: typeof views.EventDispatcher;
-        const _Cache: typeof utils.Cache;
-        const GUID_KEY: `__ember${number}`;
-        const canInvoke: typeof utils.canInvoke;
-        const generateGuid: typeof utils.generateGuid;
-        const guidFor: typeof utils.guidFor;
-        const uuid: typeof utils.uuid;
-        const wrap: typeof utils.wrap;
-        const getOwner: (object: object) => import("@ember/owner").default | undefined;
-        const onLoad: typeof applicationOnLoad;
-        const runLoadHooks: typeof applicationRunLoadHooks;
-        const setOwner: typeof import("@ember/owner").setOwner;
-        const Application: typeof EmberApplication;
-        type Application = EmberApplication;
-        const ApplicationInstance: typeof EmberApplicationInstance;
-        type ApplicationInstance = EmberApplicationInstance;
-        const Namespace: typeof EmberNamespace;
-        type Namespace = EmberNamespace;
-        const A: <T>(arr?: globalThis.Array<T>) => EmberNativeArray<T>;
-        const Array: EmberMixin;
-        type Array<T> = EmberArray<T>;
-        const NativeArray: EmberMixin;
-        type NativeArray<T> = EmberNativeArray<T>;
-        const isArray: typeof emberIsArray;
-        const makeArray: typeof emberMakeArray;
-        const MutableArray: EmberMixin;
-        type MutableArray<T> = EmberMutableArray<T>;
-        const ArrayProxy: typeof EmberArrayProxy;
-        type ArrayProxy<T> = EmberArrayProxy<T>;
-        const FEATURES: {
-            isEnabled: typeof isEnabled;
-        };
-        const _Input: EmberInput;
-        const Component: typeof EmberComponent;
-        type Component<S = unknown> = EmberComponent<S>;
-        const Helper: typeof EmberHelper;
-        type Helper<S = unknown> = EmberHelper<S>;
-        const Controller: typeof EmberController;
-        type Controller<T = unknown> = EmberController<T>;
-        const ControllerMixin: EmberMixin;
-        type ControllerMixin<T> = EmberControllerMixin<T>;
-        const _captureRenderTree: typeof EmberDebug.captureRenderTree;
-        const assert: typeof EmberDebug.assert;
-        const warn: typeof EmberDebug.warn;
-        const debug: EmberDebug.DebugFunc;
-        const deprecate: typeof EmberDebug.deprecate;
-        const deprecateFunc: EmberDebug.DeprecateFuncFunc;
-        const runInDebug: EmberDebug.RunInDebugFunc;
-        const inspect: typeof EmberDebug.inspect;
-        const Debug: {
-            registerDeprecationHandler: typeof EmberDebug.registerDeprecationHandler;
-            registerWarnHandler: typeof EmberDebug.registerWarnHandler;
-            isComputed: typeof metal.isComputed;
-        };
-        const ContainerDebugAdapter: typeof EmberContainerDebugAdapter;
-        type ContainerDebugAdapter = EmberContainerDebugAdapter;
-        const DataAdapter: typeof EmberDataAdapter;
-        type DataAdapter<T> = EmberDataAdapter<T>;
-        const _assertDestroyablesDestroyed: (() => void) | undefined;
-        const _associateDestroyableChild: typeof associateDestroyableChild;
-        const _enableDestroyableTracking: (() => void) | undefined;
-        const _isDestroying: typeof glimmerRuntime.isDestroying;
-        const _isDestroyed: typeof glimmerRuntime.isDestroyed;
-        const _registerDestructor: typeof registerDestructor;
-        const _unregisterDestructor: typeof unregisterDestructor;
-        const destroy: typeof glimmerRuntime.destroy;
-        const Engine: typeof EmberEngine;
-        type Engine = EmberEngine;
-        const EngineInstance: typeof EmberEngineInstance;
-        type EngineInstance = EmberEngineInstance;
-        const Enumerable: EmberMixin;
-        type Enumerable = EmberEnumerable;
-        const MutableEnumerable: EmberMixin;
-        type MutableEnumerable = EmberMutableEnumerable;
-        /** @private */
-        const instrument: typeof instrumentation.instrument;
-        /** @private */
-        const subscribe: typeof instrumentation.subscribe;
-        /** @private */
-        const Instrumentation: {
-            instrument: typeof instrumentation.instrument;
-            subscribe: typeof instrumentation.subscribe;
-            unsubscribe: typeof instrumentation.unsubscribe;
-            reset: typeof instrumentation.reset;
-        };
-        const Object: typeof EmberObject;
-        type Object = EmberObject;
-        const _action: typeof action;
-        const computed: typeof metal.computed;
-        const defineProperty: typeof metal.defineProperty;
-        const get: typeof metal.get;
-        const getProperties: typeof metal.getProperties;
-        const notifyPropertyChange: typeof metal.notifyPropertyChange;
-        const observer: typeof emberObserver;
-        const set: typeof metal.set;
-        const trySet: typeof metal.trySet;
-        const setProperties: typeof metal.setProperties;
-        const cacheFor: typeof metal.getCachedValueFor;
-        const _dependentKeyCompat: typeof dependentKeyCompat;
-        const ComputedProperty: typeof metal.ComputedProperty;
-        type ComputedProperty = EmberComputedProperty;
-        const expandProperties: typeof metal.expandProperties;
-        const CoreObject: typeof EmberCoreObject;
-        type CoreObject = EmberCoreObject;
-        const Evented: EmberMixin;
-        type Evented = EmberEvented;
-        const on: typeof metal.on;
-        const addListener: typeof metal.addListener;
-        const removeListener: typeof metal.removeListener;
-        const sendEvent: typeof metal.sendEvent;
-        const Mixin: typeof EmberMixin;
-        type Mixin = EmberMixin;
-        const mixin: typeof emberMixin;
-        const Observable: EmberMixin;
-        type Observable = EmberObservable;
-        const addObserver: typeof metal.addObserver;
-        const removeObserver: typeof metal.removeObserver;
-        const PromiseProxyMixin: EmberMixin;
-        type PromiseProxyMixin<T> = EmberPromiseProxyMixin<T>;
-        const ObjectProxy: typeof EmberObjectProxy;
-        type ObjectProxy = EmberObjectProxy;
-        const RouterDSL: typeof EmberRouterDSL;
-        type RouterDSL = EmberRouterDSL;
-        const controllerFor: typeof emberControllerFor;
-        const generateController: typeof emberGenerateController;
-        const generateControllerFactory: typeof emberGenerateControllerFactory;
-        const HashLocation: typeof EmberHashLocation;
-        type HashLocation = EmberHashLocation;
-        const HistoryLocation: typeof EmberHistoryLocation;
-        type HistoryLocation = EmberHistoryLocation;
-        const NoneLocation: typeof EmberNoneLocation;
-        type NoneLocation = EmberNoneLocation;
-        const Route: typeof EmberRoute;
-        type Route = EmberRoute;
-        const Router: typeof EmberRouter;
-        type Router = EmberRouter;
-        const run: typeof emberRun;
-        const Service: typeof EmberService;
-        type Service = EmberService;
-        const compare: typeof emberCompare;
-        const isBlank: typeof emberIsBlank;
-        const isEmpty: typeof emberIsEmpty;
-        const isEqual: typeof emberIsEqual;
-        const isNone: typeof emberIsNone;
-        const isPresent: typeof emberIsPresent;
-        const typeOf: typeof emberTypeOf;
-        /**
-          The semantic version
-      
-          @property VERSION
-          @type String
-          @public
-        */
-        const VERSION: string;
-        const ViewUtils: {
-            getChildViews: typeof views.getChildViews;
-            getElementView: typeof views.getElementView;
-            getRootViews: typeof views.getRootViews;
-            getViewBounds: typeof views.getViewBounds;
-            getViewBoundingClientRect: typeof views.getViewBoundingClientRect;
-            getViewClientRects: typeof views.getViewClientRects;
-            getViewElement: typeof views.getViewElement;
-            isSimpleClick: typeof views.isSimpleClick;
-            isSerializationFirstNode: typeof isSerializationFirstNode;
-        };
-        const _getComponentTemplate: typeof getComponentTemplate;
-        const _helperManagerCapabilities: typeof helperCapabilities;
-        const _setComponentTemplate: typeof setComponentTemplate;
-        const _setHelperManager: typeof setHelperManager;
-        const _setModifierManager: typeof setModifierManager;
-        const _templateOnlyComponent: typeof glimmerRuntime.templateOnlyComponent;
-        const _invokeHelper: typeof glimmerRuntime.invokeHelper;
-        const _hash: object;
-        const _array: object;
-        const _concat: object;
-        const _get: object;
-        const _on: {};
-        const _fn: object;
-        const _Backburner: typeof Backburner;
-        type _Backburner = Backburner;
-        /**
-          Namespace for injection helper methods.
-      
-          @class inject
-          @namespace Ember
-          @static
-          @public
-        */
-        function inject(): void;
-        namespace inject {
-            var controller: typeof injectController;
-            var service: typeof import("@ember/service").service;
-        }
-        const __loader: {
-            readonly require: any;
-            readonly define: any;
-            readonly registry: any;
-        };
-        const ENV: Readonly<object>;
-        let lookup: Record<string, unknown>;
-        /**
-         This should not be needed.
-         You may be able to use an event listener for the error event on window.
-      
-         `window.addEventListener('error', eventHandler);`
-      
-         For promise rejections, you'll want to use the unhandledrejection event.
-         `window.addEventListener('unhandledrejection', eventHandler);`
-      
-         If you really need the original behavior:
-      
-         `import { getOnerror, setOnerror } from '@ember/-internals/error-handling';`
-      
-          @event onerror
-          @for Ember
-          @param {Error} error the error object
-          @public
-        */
-        let onerror: ((error: Error) => unknown) | undefined;
-        let testing: boolean;
-        /**
-          Whether searching on the global for new Namespace instances is enabled.
-      
-          This is only exported here as to not break any addons.  Given the new
-          visit API, you will have issues if you treat this as a indicator of
-          booted.
-      
-          Internally this is only exposing a flag in Namespace.
-      
-          @property BOOTED
-          @for Ember
-          @type Boolean
-          @private
-        */
-        let BOOTED: boolean;
-        /**
-          Global hash of shared templates. This will automatically be populated
-          by the build tools so that you can store your Handlebars templates in
-          separate files that get loaded into JavaScript at buildtime.
-      
-          @property TEMPLATES
-          @for Ember
-          @type Object
-          @private
-        */
-        let TEMPLATES: TemplatesRegistry;
-        let HTMLBars: EmberHTMLBars;
-        let Handlebars: EmberHandlebars;
-        let Test: (NonNullable<typeof EmberTestingImpl>["Test"] & {
-            Adapter: NonNullable<typeof EmberTestingImpl>["Adapter"];
-            QUnitAdapter: NonNullable<typeof EmberTestingImpl>["QUnitAdapter"];
-        }) | undefined;
-        let setupForTesting: NonNullable<typeof EmberTestingImpl>["setupForTesting"] | undefined;
-    }
-    namespace Ember {
-        export import RSVP = _RSVP;
-    }
-    interface EmberHandlebars {
-        template: typeof template;
-        Utils: {};
-        compile?: typeof compile;
-        precompile?: typeof precompile;
-    }
-    interface EmberHTMLBars {
-        template: typeof template;
-        compile?: typeof compile;
-        precompile?: typeof precompile;
-    }
-    let EmberHandlebars: EmberHandlebars;
-    let EmberHTMLBars: EmberHTMLBars;
-    export default Ember;
-}

package/types/stable/ember-template-compiler/lib/system/bootstrap.d.ts

@@ -1,26 +0,0 @@
-declare module 'ember-template-compiler/lib/system/bootstrap' {
-    /**
-    @module ember
-    */
-    import type { TemplateFactory } from "@glimmer/interfaces";
-    export interface BootstrapOptions {
-        context?: Document | HTMLElement;
-        hasTemplate(templateName: string): boolean;
-        setTemplate(templateName: string, template: TemplateFactory): void;
-    }
-    /**
-      Find templates stored in the head tag as script tags and make them available
-      to `Ember.CoreView` in the global `Ember.TEMPLATES` object.
-
-      Script tags with `text/x-handlebars` will be compiled
-      with Ember's template compiler and are suitable for use as a view's template.
-
-      @private
-      @method bootstrap
-      @for Ember.HTMLBars
-      @static
-      @param ctx
-    */
-    function bootstrap({ context, hasTemplate, setTemplate }: BootstrapOptions): void
-    export default bootstrap;
-}

package/types/stable/ember-template-compiler/lib/system/initializer.d.ts

@@ -1,3 +0,0 @@
-declare module 'ember-template-compiler/lib/system/initializer' {
-    export {};
-}

package/types/stable/ember-testing/lib/adapters/qunit.d.ts

@@ -1,22 +0,0 @@
-declare module 'ember-testing/lib/adapters/qunit' {
-    import Adapter from "ember-testing/lib/adapters/adapter";
-    /**
-       @module ember
-    */
-    /**
-      This class implements the methods defined by TestAdapter for the
-      QUnit testing framework.
-
-      @class QUnitAdapter
-      @namespace Ember.Test
-      @extends TestAdapter
-      @public
-    */
-    class QUnitAdapter extends Adapter {
-        doneCallbacks: Array<Function>;
-        asyncStart(): void;
-        asyncEnd(): void;
-        exception(error: unknown): never;
-    }
-    export default QUnitAdapter;
-}

package/types/stable/ember-testing/lib/ext/application.d.ts

@@ -1,12 +0,0 @@
-declare module 'ember-testing/lib/ext/application' {
-    import type Application from "@ember/application";
-    export interface TestableApp extends Application {
-        testing?: boolean;
-        testHelpers: Record<string, (...args: unknown[]) => unknown>;
-        originalMethods: Record<string, (...args: unknown[]) => unknown>;
-        setupForTesting(): void;
-        helperContainer: object | null;
-        injectTestHelpers(helperContainer: unknown): void;
-        removeTestHelpers(): void;
-    }
-}

package/types/stable/ember-testing/lib/ext/rsvp.d.ts

@@ -1,4 +0,0 @@
-declare module 'ember-testing/lib/ext/rsvp' {
-    import { RSVP } from "@ember/-internals/runtime";
-    export default RSVP;
-}

package/types/stable/ember-testing/lib/helpers/and_then.d.ts

@@ -1,4 +0,0 @@
-declare module 'ember-testing/lib/helpers/and_then' {
-    import type { TestableApp } from "ember-testing/lib/ext/application";
-    export default function andThen(app: TestableApp, callback: (app: TestableApp) => unknown): unknown;
-}

package/types/stable/ember-testing/lib/helpers/current_path.d.ts

@@ -1,22 +0,0 @@
-declare module 'ember-testing/lib/helpers/current_path' {
-    import type Application from "@ember/application";
-    /**
-      Returns the current path.
-
-    Example:
-
-    ```javascript
-    function validateURL() {
-      equal(currentPath(), 'some.path.index', "correct path was transitioned into.");
-    }
-
-    click('#some-link-id').then(validateURL);
-    ```
-
-    @method currentPath
-    @return {Object} The currently active path.
-    @since 1.5.0
-    @public
-    */
-    export default function currentPath(app: Application): string | null;
-}

package/types/stable/ember-testing/lib/helpers/current_route_name.d.ts

@@ -1,21 +0,0 @@
-declare module 'ember-testing/lib/helpers/current_route_name' {
-    import type Application from "@ember/application";
-    /**
-      Returns the currently active route name.
-
-    Example:
-
-    ```javascript
-    function validateRouteName() {
-      equal(currentRouteName(), 'some.path', "correct route was transitioned into.");
-    }
-    visit('/some/path').then(validateRouteName)
-    ```
-
-    @method currentRouteName
-    @return {Object} The name of the currently active route.
-    @since 1.5.0
-    @public
-    */
-    export default function currentRouteName(app: Application): string | null;
-}

package/types/stable/ember-testing/lib/helpers/current_url.d.ts

@@ -1,22 +0,0 @@
-declare module 'ember-testing/lib/helpers/current_url' {
-    import type Application from "@ember/application";
-    /**
-      Returns the current URL.
-
-    Example:
-
-    ```javascript
-    function validateURL() {
-      equal(currentURL(), '/some/path', "correct URL was transitioned into.");
-    }
-
-    click('#some-link-id').then(validateURL);
-    ```
-
-    @method currentURL
-    @return {Object} The currently active URL.
-    @since 1.5.0
-    @public
-    */
-    export default function currentURL(app: Application): string;
-}

package/types/stable/ember-testing/lib/helpers/pause_test.d.ts

@@ -1,52 +0,0 @@
-declare module 'ember-testing/lib/helpers/pause_test' {
-    /**
-    @module ember
-    */
-    import { RSVP } from "@ember/-internals/runtime";
-    /**
-     Resumes a test paused by `pauseTest`.
-
-     @method resumeTest
-     @return {void}
-     @public
-    */
-    export function resumeTest(): void;
-    /**
-     Pauses the current test - this is useful for debugging while testing or for test-driving.
-     It allows you to inspect the state of your application at any point.
-     Example (The test will pause before clicking the button):
-
-     ```javascript
-     visit('/')
-     return pauseTest();
-     click('.btn');
-     ```
-
-     You may want to turn off the timeout before pausing.
-
-     qunit (timeout available to use as of 2.4.0):
-
-     ```
-     visit('/');
-     assert.timeout(0);
-     return pauseTest();
-     click('.btn');
-     ```
-
-     mocha (timeout happens automatically as of ember-mocha v0.14.0):
-
-     ```
-     visit('/');
-     this.timeout(0);
-     return pauseTest();
-     click('.btn');
-     ```
-
-
-     @since 1.9.0
-     @method pauseTest
-     @return {Object} A promise that will never resolve
-     @public
-    */
-    export function pauseTest(): RSVP.default.Promise<unknown>;
-}

package/types/stable/ember-testing/lib/helpers/visit.d.ts

@@ -1,22 +0,0 @@
-declare module 'ember-testing/lib/helpers/visit' {
-    import type { TestableApp } from "ember-testing/lib/ext/application";
-    /**
-      Loads a route, sets up any controllers, and renders any templates associated
-      with the route as though a real user had triggered the route change while
-      using your app.
-
-      Example:
-
-      ```javascript
-      visit('posts/index').then(function() {
-        // assert something
-      });
-      ```
-
-      @method visit
-      @param {String} url the name of the route
-      @return {RSVP.Promise<undefined>}
-      @public
-    */
-    export default function visit(app: TestableApp, url: string): unknown;
-}

package/types/stable/ember-testing/lib/helpers/wait.d.ts

@@ -1,34 +0,0 @@
-declare module 'ember-testing/lib/helpers/wait' {
-    import type Application from "@ember/application";
-    /**
-      Causes the run loop to process any pending events. This is used to ensure that
-      any async operations from other helpers (or your assertions) have been processed.
-
-      This is most often used as the return value for the helper functions (see 'click',
-      'fillIn','visit',etc). However, there is a method to register a test helper which
-      utilizes this method without the need to actually call `wait()` in your helpers.
-
-      The `wait` helper is built into `registerAsyncHelper` by default. You will not need
-      to `return app.testHelpers.wait();` - the wait behavior is provided for you.
-
-      Example:
-
-      ```javascript
-      import { registerAsyncHelper } from '@ember/test';
-
-      registerAsyncHelper('loginUser', function(app, username, password) {
-        visit('secured/path/here')
-          .fillIn('#username', username)
-          .fillIn('#password', password)
-          .click('.submit');
-      });
-      ```
-
-      @method wait
-      @param {Object} value The value to be returned.
-      @return {RSVP.Promise<any>} Promise that resolves to the passed value.
-      @public
-      @since 1.0.0
-    */
-    export default function wait<T>(app: Application, value: T): Promise<T>;
-}

package/types/stable/ember-testing/lib/helpers.d.ts

@@ -1,3 +0,0 @@
-declare module 'ember-testing/lib/helpers' {
-    export {};
-}

package/types/stable/ember-testing/lib/initializers.d.ts

@@ -1,3 +0,0 @@
-declare module 'ember-testing/lib/initializers' {
-    export {};
-}

package/types/stable/ember-testing/lib/setup_for_testing.d.ts

@@ -1,15 +0,0 @@
-declare module 'ember-testing/lib/setup_for_testing' {
-    /**
-      Sets Ember up for testing. This is useful to perform
-      basic setup steps in order to unit test.
-
-      Use `App.setupForTesting` to perform integration tests (full
-      application testing).
-
-      @method setupForTesting
-      @namespace Ember
-      @since 1.5.0
-      @private
-    */
-    export default function setupForTesting(): void;
-}