@discourse/types 0.0.2 → 2026.1.0-2709d36

package/external-types/@ember__test-helpers/declarations/dom/find-all.d.ts

@@ -1,7 +0,0 @@
-declare module '@ember/test-helpers/dom/find-all' {
-export default function findAll<K extends keyof (HTMLElementTagNameMap | SVGElementTagNameMap)>(selector: K): Array<HTMLElementTagNameMap[K] | SVGElementTagNameMap[K]>;
-export default function findAll<K extends keyof HTMLElementTagNameMap>(selector: K): Array<HTMLElementTagNameMap[K]>;
-export default function findAll<K extends keyof SVGElementTagNameMap>(selector: K): Array<SVGElementTagNameMap[K]>;
-export default function findAll(selector: string): Element[];
-//# sourceMappingURL=find-all.d.ts.map
-}

package/external-types/@ember__test-helpers/declarations/dom/find.d.ts

@@ -1,7 +0,0 @@
-declare module '@ember/test-helpers/dom/find' {
-export default function find<K extends keyof (HTMLElementTagNameMap | SVGElementTagNameMap)>(selector: K): HTMLElementTagNameMap[K] | SVGElementTagNameMap[K] | null;
-export default function find<K extends keyof HTMLElementTagNameMap>(selector: K): HTMLElementTagNameMap[K] | null;
-export default function find<K extends keyof SVGElementTagNameMap>(selector: K): SVGElementTagNameMap[K] | null;
-export default function find(selector: string): Element | null;
-//# sourceMappingURL=find.d.ts.map
-}

package/external-types/@ember__test-helpers/declarations/dom/fire-event.d.ts

@@ -1,18 +0,0 @@
-declare module '@ember/test-helpers/dom/fire-event' {
-export declare const KEYBOARD_EVENT_TYPES: ["keydown", "keypress", "keyup"];
-export type KeyboardEventType = (typeof KEYBOARD_EVENT_TYPES)[number];
-export declare function isKeyboardEventType(eventType: any): eventType is KeyboardEventType;
-declare const MOUSE_EVENT_TYPES: ["click", "mousedown", "mouseup", "dblclick", "mouseenter", "mouseleave", "mousemove", "mouseout", "mouseover"];
-export type MouseEventType = (typeof MOUSE_EVENT_TYPES)[number];
-export declare function isMouseEventType(eventType: any): eventType is MouseEventType;
-declare const FILE_SELECTION_EVENT_TYPES: ["change"];
-export type FileSelectionEventType = (typeof FILE_SELECTION_EVENT_TYPES)[number];
-export declare function isFileSelectionEventType(eventType: any): eventType is FileSelectionEventType;
-export declare function isFileSelectionInput(element: any): element is HTMLInputElement;
-declare function fireEvent(element: Element | Document | Window, eventType: KeyboardEventType, options?: any): Promise<Event>;
-declare function fireEvent(element: Element | Document | Window, eventType: MouseEventType, options?: any): Promise<Event | void>;
-declare function fireEvent(element: Element | Document | Window, eventType: string, options?: any): Promise<Event>;
-export default fireEvent;
-export declare function _buildKeyboardEvent(type: KeyboardEventType, options?: any): Event;
-//# sourceMappingURL=fire-event.d.ts.map
-}

package/external-types/@ember__test-helpers/declarations/dom/focus.d.ts

@@ -1,41 +0,0 @@
-declare module '@ember/test-helpers/dom/focus' {
-import { type Target } from './-target.ts';
-type FocusRecord = {
-    focusTarget: HTMLElement | SVGElement;
-    previousFocusedElement?: HTMLElement | SVGElement | null;
-};
-/**
-  @private
-  @param {Element} element the element to trigger events on
-  @return {Promise<FocusRecord | Event | void>} resolves when settled
-*/
-export declare function __focus__(element: HTMLElement | Element | Document | SVGElement): Promise<FocusRecord | Event | void>;
-/**
-  Focus the specified target.
-
-  Sends a number of events intending to simulate a "real" user focusing an
-  element.
-
-  The following events are triggered (in order):
-
-  - `focus`
-  - `focusin`
-
-  The exact listing of events that are triggered may change over time as needed
-  to continue to emulate how actual browsers handle focusing a given element.
-
-  @public
-  @param {string|Element|IDOMElementDescriptor} target the element, selector, or descriptor to focus
-  @return {Promise<void>} resolves when the application is settled
-
-  @example
-  <caption>
-    Emulating focusing an input using `focus`
-  </caption>
-
-  focus('input');
-*/
-export default function focus(target: Target): Promise<void>;
-export {};
-//# sourceMappingURL=focus.d.ts.map
-}

package/external-types/@ember__test-helpers/declarations/dom/get-root-element.d.ts

@@ -1,17 +0,0 @@
-declare module '@ember/test-helpers/dom/get-root-element' {
-/**
-  Get the root element of the application under test (usually `#ember-testing`)
-
-  @public
-  @returns {Element} the root element
-
-  @example
-  <caption>
-    Getting the root element of the application and checking that it is equal
-    to the element with id 'ember-testing'.
-  </caption>
-  assert.equal(getRootElement(), document.querySelector('#ember-testing'));
-*/
-export default function getRootElement(): Element | Document;
-//# sourceMappingURL=get-root-element.d.ts.map
-}

package/external-types/@ember__test-helpers/declarations/dom/scroll-to.d.ts

@@ -1,21 +0,0 @@
-declare module '@ember/test-helpers/dom/scroll-to' {
-import type { IDOMElementDescriptor } from 'dom-element-descriptors';
-/**
-  Scrolls DOM element, selector, or descriptor to the given coordinates.
-  @public
-  @param {string|HTMLElement|IDOMElementDescriptor} target the element, selector, or descriptor to trigger scroll on
-  @param {Number} x x-coordinate
-  @param {Number} y y-coordinate
-  @return {Promise<void>} resolves when settled
-
-  @example
-  <caption>
-    Scroll DOM element to specific coordinates
-  </caption>
-
-  scrollTo('#my-long-div', 0, 0); // scroll to top
-  scrollTo('#my-long-div', 0, 100); // scroll down
-*/
-export default function scrollTo(target: string | HTMLElement | IDOMElementDescriptor, x: number, y: number): Promise<void>;
-//# sourceMappingURL=scroll-to.d.ts.map
-}

package/external-types/@ember__test-helpers/declarations/dom/select.d.ts

@@ -1,28 +0,0 @@
-declare module '@ember/test-helpers/dom/select' {
-import type { Target } from './-target.ts';
-/**
-  Set the `selected` property true for the provided option the target is a
-  select element (or set the select property true for multiple options if the
-  multiple attribute is set true on the HTMLSelectElement) then trigger
-  `change` and `input` events on the specified target.
-
-  @public
-  @param {string|Element|IDOMElementDescriptor} target the element, selector, or descriptor for the select element
-  @param {string|string[]} options the value/values of the items to select
-  @param {boolean} keepPreviouslySelected a flag keep any existing selections
-  @return {Promise<void>} resolves when the application is settled
-
-  @example
-  <caption>
-    Emulating selecting an option or multiple options using `select`
-  </caption>
-
-  select('select', 'apple');
-
-  select('select', ['apple', 'orange']);
-
-  select('select', ['apple', 'orange'], true);
-*/
-export default function select(target: Target, options: string | string[], keepPreviouslySelected?: boolean): Promise<void>;
-//# sourceMappingURL=select.d.ts.map
-}

package/external-types/@ember__test-helpers/declarations/dom/tab.d.ts

@@ -1,31 +0,0 @@
-declare module '@ember/test-helpers/dom/tab' {
-/**
-  Emulates the user pressing the tab button.
-
-  Sends a number of events intending to simulate a "real" user pressing tab on their
-  keyboard.
-
-  @public
-  @param {Object} [options] optional tab behaviors
-  @param {boolean} [options.backwards=false] indicates if the the user navigates backwards
-  @param {boolean} [options.unRestrainTabIndex=false] indicates if tabbing should throw an error when tabindex is greater than 0
-  @return {Promise<void>} resolves when settled
-
-  @example
-  <caption>
-    Emulating pressing the `TAB` key
-  </caption>
-  tab();
-
-  @example
-  <caption>
-    Emulating pressing the `SHIFT`+`TAB` key combination
-  </caption>
-  tab({ backwards: true });
-*/
-export default function triggerTab({ backwards, unRestrainTabIndex, }?: {
-    backwards?: boolean | undefined;
-    unRestrainTabIndex?: boolean | undefined;
-}): Promise<void>;
-//# sourceMappingURL=tab.d.ts.map
-}

package/external-types/@ember__test-helpers/declarations/dom/tap.d.ts

@@ -1,47 +0,0 @@
-declare module '@ember/test-helpers/dom/tap' {
-import type { Target } from './-target.ts';
-/**
-  Taps on the specified target.
-
-  Sends a number of events intending to simulate a "real" user tapping on an
-  element.
-
-  For non-focusable elements the following events are triggered (in order):
-
-  - `touchstart`
-  - `touchend`
-  - `mousedown`
-  - `mouseup`
-  - `click`
-
-  For focusable (e.g. form control) elements the following events are triggered
-  (in order):
-
-  - `touchstart`
-  - `touchend`
-  - `mousedown`
-  - `focus`
-  - `focusin`
-  - `mouseup`
-  - `click`
-
-  The exact listing of events that are triggered may change over time as needed
-  to continue to emulate how actual browsers handle tapping on a given element.
-
-  Use the `options` hash to change the parameters of the tap events.
-
-  @public
-  @param {string|Element|IDOMElementDescriptor} target the element, selector, or descriptor to tap on
-  @param {Object} options the options to be merged into the touch events
-  @return {Promise<void>} resolves when settled
-
-  @example
-  <caption>
-    Emulating tapping a button using `tap`
-  </caption>
-
-  tap('button');
-*/
-export default function tap(target: Target, options?: TouchEventInit): Promise<void>;
-//# sourceMappingURL=tap.d.ts.map
-}

package/external-types/@ember__test-helpers/declarations/dom/trigger-event.d.ts

@@ -1,49 +0,0 @@
-declare module '@ember/test-helpers/dom/trigger-event' {
-import type { Target } from './-target.ts';
-/**
- * Triggers an event on the specified target.
- *
- * @public
- * @param {string|Element|IDOMElementDescriptor} target the element, selector, or descriptor to trigger the event on
- * @param {string} eventType the type of event to trigger
- * @param {Object} options additional properties to be set on the event
- * @param {boolean} force if true, will bypass availability checks (false by default)
- * @return {Promise<void>} resolves when the application is settled
- *
- * @example
- * <caption>
- * Using `triggerEvent` to upload a file
- *
- * When using `triggerEvent` to upload a file the `eventType` must be `change` and you must pass the
- * `options` param as an object with a key `files` containing an array of
- * [Blob](https://developer.mozilla.org/en-US/docs/Web/API/Blob).
- * </caption>
- *
- * triggerEvent(
- *   'input.fileUpload',
- *   'change',
- *   { files: [new Blob(['Ember Rules!'])] }
- * );
- *
- *
- * @example
- * <caption>
- * Using `triggerEvent` to upload a dropped file
- *
- * When using `triggerEvent` to handle a dropped (via drag-and-drop) file, the `eventType` must be `drop`. Assuming your `drop` event handler uses the [DataTransfer API](https://developer.mozilla.org/en-US/docs/Web/API/DataTransfer),
- * you must pass the `options` param as an object with a key of `dataTransfer`. The `options.dataTransfer`     object should have a `files` key, containing an array of [File](https://developer.mozilla.org/en-US/docs/Web/API/File).
- * </caption>
- *
- * triggerEvent(
- *   '[data-test-drop-zone]',
- *   'drop',
- *   {
- *     dataTransfer: {
- *       files: [new File(['Ember Rules!'], 'ember-rules.txt')]
- *     }
- *   }
- * )
- */
-export default function triggerEvent(target: Target, eventType: string, options?: Record<string, unknown>, force?: boolean): Promise<void>;
-//# sourceMappingURL=trigger-event.d.ts.map
-}

package/external-types/@ember__test-helpers/declarations/dom/trigger-key-event.d.ts

@@ -1,44 +0,0 @@
-declare module '@ember/test-helpers/dom/trigger-key-event' {
-import { type KeyboardEventType } from './fire-event.ts';
-import type { Target } from './-target.ts';
-export interface KeyModifiers {
-    ctrlKey?: boolean;
-    altKey?: boolean;
-    shiftKey?: boolean;
-    metaKey?: boolean;
-}
-/**
-  @private
-  @param {Element | Document} element the element to trigger the key event on
-  @param {'keydown' | 'keyup' | 'keypress'} eventType the type of event to trigger
-  @param {number|string} key the `keyCode`(number) or `key`(string) of the event being triggered
-  @param {Object} [modifiers] the state of various modifier keys
-  @return {Promise<Event>} resolves when settled
- */
-export declare function __triggerKeyEvent__(element: Element | Document, eventType: KeyboardEventType, key: number | string, modifiers?: KeyModifiers): Promise<Event>;
-/**
-  Triggers a keyboard event of given type in the target element.
-  It also requires the developer to provide either a string with the [`key`](https://developer.mozilla.org/en-US/docs/Web/API/KeyboardEvent/key/Key_Values)
-  or the numeric [`keyCode`](https://developer.mozilla.org/en-US/docs/Web/API/KeyboardEvent/keyCode) of the pressed key.
-  Optionally the user can also provide a POJO with extra modifiers for the event.
-
-  @public
-  @param {string|Element|IDOMElementDescriptor} target the element, selector, or descriptor to trigger the event on
-  @param {'keydown' | 'keyup' | 'keypress'} eventType the type of event to trigger
-  @param {number|string} key the `keyCode`(number) or `key`(string) of the event being triggered
-  @param {Object} [modifiers] the state of various modifier keys
-  @param {boolean} [modifiers.ctrlKey=false] if true the generated event will indicate the control key was pressed during the key event
-  @param {boolean} [modifiers.altKey=false] if true the generated event will indicate the alt key was pressed during the key event
-  @param {boolean} [modifiers.shiftKey=false] if true the generated event will indicate the shift key was pressed during the key event
-  @param {boolean} [modifiers.metaKey=false] if true the generated event will indicate the meta key was pressed during the key event
-  @return {Promise<void>} resolves when the application is settled unless awaitSettled is false
-
-  @example
-  <caption>
-    Emulating pressing the `ENTER` key on a button using `triggerKeyEvent`
-  </caption>
-  triggerKeyEvent('button', 'keydown', 'Enter');
-*/
-export default function triggerKeyEvent(target: Target, eventType: KeyboardEventType, key: number | string, modifiers?: KeyModifiers): Promise<void>;
-//# sourceMappingURL=trigger-key-event.d.ts.map
-}

package/external-types/@ember__test-helpers/declarations/dom/type-in.d.ts

@@ -1,32 +0,0 @@
-declare module '@ember/test-helpers/dom/type-in' {
-import { type Target } from './-target.ts';
-export interface Options {
-    delay?: number;
-}
-/**
- * Mimics character by character entry into the target `input` or `textarea` element.
- *
- * Allows for simulation of slow entry by passing an optional millisecond delay
- * between key events.
-
- * The major difference between `typeIn` and `fillIn` is that `typeIn` triggers
- * keyboard events as well as `input` and `change`.
- * Typically this looks like `focus` -> `focusin` -> `keydown` -> `keypress` -> `keyup` -> `input` -> `change`
- * per character of the passed text (this may vary on some browsers).
- *
- * @public
- * @param {string|Element|IDOMElementDescriptor} target the element, selector, or descriptor to enter text into
- * @param {string} text the test to fill the element with
- * @param {Object} options {delay: x} (default 50) number of milliseconds to wait per keypress
- * @return {Promise<void>} resolves when the application is settled
- *
- * @example
- * <caption>
- *   Emulating typing in an input using `typeIn`
- * </caption>
- *
- * typeIn('input', 'hello world');
- */
-export default function typeIn(target: Target, text: string, options?: Options): Promise<void>;
-//# sourceMappingURL=type-in.d.ts.map
-}

package/external-types/@ember__test-helpers/declarations/dom/wait-for-focus.d.ts

@@ -1,27 +0,0 @@
-declare module '@ember/test-helpers/dom/wait-for-focus' {
-import { type IDOMElementDescriptor } from 'dom-element-descriptors';
-export interface Options {
-    timeout?: number;
-    count?: number | null;
-    timeoutMessage?: string;
-}
-/**
-  Used to wait for a particular selector to receive focus. Useful for verifying
-  keyboard navigation handling and default focus behaviour, without having to
-  think about timing issues.
-
-  @param {string|IDOMElementDescriptor} target the selector or DOM element descriptor to wait receiving focus
-  @param {Object} [options] the options to be used
-  @param {number} [options.timeout=1000] the time to wait (in ms) for a match
-  @param {string} [options.timeoutMessage='waitForFocus timed out waiting for selector'] the message to use in the reject on timeout
-  @return {Promise<Element>} resolves when the element received focus
-
-  @example
-  <caption>
-    Waiting until a selector receive focus:
-  </caption>
-  await waitForFocus('.my-selector', { timeout: 2000 })
-*/
-export default function waitForFocus(target: string | IDOMElementDescriptor, options?: Options): Promise<Element>;
-//# sourceMappingURL=wait-for-focus.d.ts.map
-}

package/external-types/@ember__test-helpers/declarations/dom/wait-for.d.ts

@@ -1,27 +0,0 @@
-declare module '@ember/test-helpers/dom/wait-for' {
-import { type IDOMElementDescriptor } from 'dom-element-descriptors';
-export interface Options {
-    timeout?: number;
-    count?: number | null;
-    timeoutMessage?: string;
-}
-/**
-  Used to wait for a particular selector to appear in the DOM. Due to the fact
-  that it does not wait for general settledness, this is quite useful for testing
-  interim DOM states (e.g. loading states, pending promises, etc).
-
-  @param {string|IDOMElementDescriptor} target the selector or DOM element descriptor to wait for
-  @param {Object} [options] the options to be used
-  @param {number} [options.timeout=1000] the time to wait (in ms) for a match
-  @param {number} [options.count=null] the number of elements that should match the provided selector (null means one or more)
-  @return {Promise<Element|Element[]>} resolves when the element(s) appear on the page
-
-  @example
-  <caption>
-    Waiting until a selector is rendered:
-  </caption>
-  await waitFor('.my-selector', { timeout: 2000 })
-*/
-export default function waitFor(target: string | IDOMElementDescriptor, options?: Options): Promise<Element | Element[]>;
-//# sourceMappingURL=wait-for.d.ts.map
-}

package/external-types/@ember__test-helpers/declarations/global.d.ts

@@ -1,5 +0,0 @@
-declare module '@ember/test-helpers/global' {
-declare const _default: any;
-export default _default;
-//# sourceMappingURL=global.d.ts.map
-}

package/external-types/@ember__test-helpers/declarations/has-ember-version.d.ts

@@ -1,13 +0,0 @@
-declare module '@ember/test-helpers/has-ember-version' {
-/**
-  Checks if the currently running Ember version is greater than or equal to the
-  specified major and minor version numbers.
-
-  @private
-  @param {number} major the major version number to compare
-  @param {number} minor the minor version number to compare
-  @returns {boolean} true if the Ember version is >= MAJOR.MINOR specified, false otherwise
-*/
-export default function hasEmberVersion(major: number, minor: number): boolean;
-//# sourceMappingURL=has-ember-version.d.ts.map
-}

package/external-types/@ember__test-helpers/declarations/helper-hooks.d.ts

@@ -1,48 +0,0 @@
-declare module '@ember/test-helpers/helper-hooks' {
-export type Hook = (...args: any[]) => void | Promise<void>;
-export type HookLabel = 'start' | 'end' | 'targetFound';
-export type HookUnregister = {
-    unregister: () => void;
-};
-/**
- * Registers a function to be run during the invocation of a test helper.
- *
- * @param {string} helperName The name of the test helper in which to run the hook.
- *                            Test helper names include `blur`, `click`, `doubleClick`, `fillIn`,
- *                            `fireEvent`, `focus`, `render`, `scrollTo`, `select`, `tab`, `tap`, `triggerEvent`,
- *                            `triggerKeyEvent`, `typeIn`, and `visit`.
- * @param {string} label A label to help identify the hook. Built-in labels include `start`, `end`,
- *                       and `targetFound`, the former designating either the start or end of
- *                       the helper invocation.
- * @param {Function} hook The hook function to run when the test helper is invoked.
- * @returns {HookUnregister} An object containing an `unregister` function that unregisters
- *                           the specific hook initially registered to the helper.
- * @example
- * <caption>
- *   Registering a hook for the `end` point of the `click` test helper invocation
- * </caption>
- *
- * const hook = registerHook('click', 'end', () => {
- *   console.log('Running `click:end` test helper hook');
- * });
- *
- * // Unregister the hook at some later point in time
- * hook.unregister();
- */
-export declare function registerHook(helperName: string, label: HookLabel, hook: Hook): HookUnregister;
-/**
- * Runs all hooks registered for a specific test helper.
- *
- * @param {string} helperName The name of the test helper in which to run the hook.
- *                            Test helper names include `blur`, `click`, `doubleClick`, `fillIn`,
- *                            `fireEvent`, `focus`, `render`, `scrollTo`, `select`, `tab`, `tap`, `triggerEvent`,
- *                            `triggerKeyEvent`, `typeIn`, and `visit`.
- * @param {string} label A label to help identify the hook. Built-in labels include `start`, `end`,
- *                       and `targetFound`, the former designating either the start or end of
- *                       the helper invocation.
- * @param {unknown[]} args Any arguments originally passed to the test helper.
- * @returns {Promise<void>} A promise representing the serial invocation of the hooks.
- */
-export declare function runHooks(helperName: string, label: HookLabel, ...args: unknown[]): Promise<void>;
-//# sourceMappingURL=helper-hooks.d.ts.map
-}

package/external-types/@ember__test-helpers/declarations/index.d.ts

@@ -1,49 +0,0 @@
-declare module '@ember/test-helpers' {
-import type { Backburner, DeferredActionQueues } from '@ember/runloop/-private/backburner';
-export { setResolver, getResolver } from './resolver.ts';
-export { getApplication, setApplication } from './application.ts';
-export { default as hasEmberVersion } from './has-ember-version.ts';
-export type { BaseContext, DeprecationFailure, TestContext, Warning, SetupContextOptions, } from './setup-context.ts';
-export { default as setupContext, getContext, setContext, unsetContext, pauseTest, resumeTest, getDeprecations, getDeprecationsDuringCallback, getWarnings, getWarningsDuringCallback, } from './setup-context.ts';
-export { default as teardownContext } from './teardown-context.ts';
-export type { TeardownContextOptions } from './teardown-context.ts';
-export { default as setupRenderingContext, render, clearRender, } from './setup-rendering-context.ts';
-export type { RenderingTestContext } from './setup-rendering-context.ts';
-export { default as rerender } from './rerender.ts';
-export { default as setupApplicationContext, visit, currentRouteName, currentURL, } from './setup-application-context.ts';
-export { default as settled, isSettled, getSettledState } from './settled.ts';
-export { default as waitUntil } from './wait-until.ts';
-export { default as validateErrorHandler } from './validate-error-handler.ts';
-export { default as setupOnerror, resetOnerror } from './setup-onerror.ts';
-export type { default as DebugInfo } from './-internal/debug-info.ts';
-export { getDebugInfo } from './-internal/debug-info.ts';
-export { default as registerDebugInfoHelper } from './-internal/debug-info-helpers.ts';
-export type { TestMetadata } from './test-metadata.ts';
-export { default as getTestMetadata } from './test-metadata.ts';
-export { registerHook, runHooks, type Hook, type HookLabel, type HookUnregister, } from './helper-hooks.ts';
-export { default as click } from './dom/click.ts';
-export { default as doubleClick } from './dom/double-click.ts';
-export { default as tab } from './dom/tab.ts';
-export { default as tap } from './dom/tap.ts';
-export { default as focus } from './dom/focus.ts';
-export { default as blur } from './dom/blur.ts';
-export { default as triggerEvent } from './dom/trigger-event.ts';
-export { default as triggerKeyEvent } from './dom/trigger-key-event.ts';
-export { default as fillIn } from './dom/fill-in.ts';
-export { default as select } from './dom/select.ts';
-export { default as waitFor } from './dom/wait-for.ts';
-export { default as getRootElement } from './dom/get-root-element.ts';
-export { default as find } from './dom/find.ts';
-export { default as findAll } from './dom/find-all.ts';
-export { default as typeIn } from './dom/type-in.ts';
-export { default as scrollTo } from './dom/scroll-to.ts';
-export { default as waitForFocus } from './dom/wait-for-focus.ts';
-export type { Target } from './dom/-target.ts';
-declare module '@ember/runloop' {
-    interface PrivateBackburner extends Backburner {
-        hasTimers(): boolean;
-        currentInstance: DeferredActionQueues | null;
-    }
-}
-//# sourceMappingURL=index.d.ts.map
-}

package/external-types/@ember__test-helpers/declarations/rerender.d.ts

@@ -1,20 +0,0 @@
-declare module '@ember/test-helpers/rerender' {
-/**
-  Returns a promise which will resolve when rendering has completed. In
-  this context, rendering is completed when all auto-tracked state that is
-  consumed in the template (including any tracked state in models, services,
-  etc.  that are then used in a template) has been updated in the DOM.
-
-  For example, in a test you might want to update some tracked state and
-  then run some assertions after rendering has completed. You _could_ use
-  `await settled()` in that location, but in some contexts you don't want to
-  wait for full settledness (which includes test waiters, pending AJAX/fetch,
-  run loops, etc) but instead only want to know when that updated value has
-  been rendered in the DOM. **THAT** is what `await rerender()` is _perfect_
-  for.
-  @public
-  @returns {Promise<void>} a promise which fulfills when rendering has completed
-*/
-export default function rerender(): Promise<void>;
-//# sourceMappingURL=rerender.d.ts.map
-}

package/external-types/@ember__test-helpers/declarations/resolver.d.ts

@@ -1,21 +0,0 @@
-declare module '@ember/test-helpers/resolver' {
-import type { Resolver } from '@ember/owner';
-/**
-  Stores the provided resolver instance so that tests being ran can resolve
-  objects in the same way as a normal application.
-
-  Used by `setupContext` and `setupRenderingContext` as a fallback when `setApplication` was _not_ used.
-
-  @public
-  @param {Ember.Resolver} resolver the resolver to be used for testing
-*/
-export declare function setResolver(resolver: Resolver): void;
-/**
-  Retrieve the resolver instance stored by `setResolver`.
-
-  @public
-  @returns {Ember.Resolver} the previously stored resolver
-*/
-export declare function getResolver(): Resolver | undefined;
-//# sourceMappingURL=resolver.d.ts.map
-}

package/external-types/@ember__test-helpers/declarations/settled.d.ts

@@ -1,72 +0,0 @@
-declare module '@ember/test-helpers/settled' {
-import type DebugInfo from './-internal/debug-info.ts';
-/**
-  Clears listeners that were previously setup for `ajaxSend` and `ajaxComplete`.
-
-  @private
-*/
-export declare function _teardownAJAXHooks(): void;
-/**
-  Sets up listeners for `ajaxSend` and `ajaxComplete`.
-
-  @private
-*/
-export declare function _setupAJAXHooks(): void;
-export interface SettledState {
-    hasRunLoop: boolean;
-    hasPendingTimers: boolean;
-    hasPendingWaiters: boolean;
-    hasPendingRequests: boolean;
-    hasPendingTransitions: boolean | null;
-    isRenderPending: boolean;
-    pendingRequestCount: number;
-    debugInfo: DebugInfo;
-}
-/**
-  Check various settledness metrics, and return an object with the following properties:
-
-  - `hasRunLoop` - Checks if a run-loop has been started. If it has, this will
-    be `true` otherwise it will be `false`.
-  - `hasPendingTimers` - Checks if there are scheduled timers in the run-loop.
-    These pending timers are primarily registered by `Ember.run.schedule`. If
-    there are pending timers, this will be `true`, otherwise `false`.
-  - `hasPendingWaiters` - Checks if any registered test waiters are still
-    pending (e.g. the waiter returns `true`). If there are pending waiters,
-    this will be `true`, otherwise `false`.
-  - `hasPendingRequests` - Checks if there are pending AJAX requests (based on
-    `ajaxSend` / `ajaxComplete` events triggered by `jQuery.ajax`). If there
-    are pending requests, this will be `true`, otherwise `false`.
-  - `hasPendingTransitions` - Checks if there are pending route transitions. If the
-    router has not been instantiated / setup for the test yet this will return `null`,
-    if there are pending transitions, this will be `true`, otherwise `false`.
-  - `pendingRequestCount` - The count of pending AJAX requests.
-  - `debugInfo` - Debug information that's combined with info return from backburner's
-    getDebugInfo method.
-  - `isRenderPending` - Checks if there are any pending render operations. This will be true as long
-    as there are tracked values in the template that have not been rerendered yet.
-
-  @public
-  @returns {Object} object with properties for each of the metrics used to determine settledness
-*/
-export declare function getSettledState(): SettledState;
-/**
-  Checks various settledness metrics (via `getSettledState()`) to determine if things are settled or not.
-
-  Settled generally means that there are no pending timers, no pending waiters,
-  no pending AJAX requests, and no current run loop. However, new settledness
-  metrics may be added and used as they become available.
-
-  @public
-  @returns {boolean} `true` if settled, `false` otherwise
-*/
-export declare function isSettled(): boolean;
-/**
-  Returns a promise that resolves when in a settled state (see `isSettled` for
-  a definition of "settled state").
-
-  @public
-  @returns {Promise<void>} resolves when settled
-*/
-export default function settled(): Promise<void>;
-//# sourceMappingURL=settled.d.ts.map
-}