@discourse/types 0.0.1 → 2026.1.0-61b723a

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

@@ -0,0 +1,9 @@
+declare module '@ember/test-helpers/dom/-is-select-element' {
+/**
+  @private
+  @param {Element} element the element to check
+  @returns {boolean} `true` when the element is a select element, `false` otherwise
+*/
+export default function isSelectElement(element: Element | Document): element is HTMLSelectElement;
+//# sourceMappingURL=-is-select-element.d.ts.map
+}

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

@@ -0,0 +1,21 @@
+declare module '@ember/test-helpers/dom/-logging' {
+import type { Target } from './-target';
+/**
+ * Logs a debug message to the console if the `testHelperLogging` query
+ * parameter is set.
+ *
+ * @private
+ * @param {string} helperName Name of the helper
+ * @param {string|Element} target The target element or selector
+ */
+export declare function log(helperName: string, target: Target, ...args: any[]): void;
+/**
+ * This generates a human-readable description to a DOM element.
+ *
+ * @private
+ * @param {*} el The element that should be described
+ * @returns {string} A human-readable description
+ */
+export declare function elementToString(el: unknown): string;
+//# sourceMappingURL=-logging.d.ts.map
+}

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

@@ -0,0 +1,12 @@
+declare module '@ember/test-helpers/dom/-target' {
+import type { IDOMElementDescriptor } from 'dom-element-descriptors';
+export type Target = string | Element | IDOMElementDescriptor | Document | Window;
+export interface HTMLElementContentEditable extends HTMLElement {
+    isContentEditable: true;
+}
+export declare function isElement(target: unknown): target is Element;
+export declare function isWindow(target: Target): target is Window;
+export declare function isDocument(target: unknown): target is Document;
+export declare function isContentEditable(element: Element): element is HTMLElementContentEditable;
+//# sourceMappingURL=-target.d.ts.map
+}

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

@@ -0,0 +1,9 @@
+declare module '@ember/test-helpers/dom/-to-array' {
+/**
+  @private
+  @param {NodeList} nodelist the nodelist to convert to an array
+  @returns {Array} an array
+*/
+export default function toArray<T extends Node>(nodelist: NodeListOf<T>): T[];
+//# sourceMappingURL=-to-array.d.ts.map
+}

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

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

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

@@ -0,0 +1,65 @@
+declare module '@ember/test-helpers/dom/click' {
+import { type Target } from './-target.ts';
+/**
+ * Represent a particular mouse button being clicked.
+ * See https://developer.mozilla.org/en-US/docs/Web/API/MouseEvent/buttons for available options.
+ */
+export declare const DEFAULT_CLICK_OPTIONS: {
+    buttons: number;
+    button: number;
+};
+/**
+  @private
+  @param {Element} element the element to click on
+  @param {MouseEventInit} options the options to be merged into the mouse events
+  @return {Promise<Event | void>} resolves when settled
+*/
+export declare function __click__(element: Element | Document | Window, options: MouseEventInit): Promise<Event | void>;
+/**
+  Clicks on the specified target.
+
+  Sends a number of events intending to simulate a "real" user clicking on an
+  element.
+
+  For non-focusable elements the following events are triggered (in order):
+
+  - `mousedown`
+  - `mouseup`
+  - `click`
+
+  For focusable (e.g. form control) elements the following events are triggered
+  (in order):
+
+  - `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 clicking a given element.
+
+  Use the `options` hash to change the parameters of the [MouseEvents](https://developer.mozilla.org/en-US/docs/Web/API/MouseEvent/MouseEvent).
+  You can use this to specify modifier keys as well.
+
+  @public
+  @param {string|Element|IDOMElementDescriptor} target the element, selector, or descriptor to click on
+  @param {MouseEventInit} _options the options to be merged into the mouse events.
+  @return {Promise<void>} resolves when settled
+
+  @example
+  <caption>
+    Emulating clicking a button using `click`
+  </caption>
+  click('button');
+
+  @example
+  <caption>
+    Emulating clicking a button and pressing the `shift` key simultaneously using `click` with `options`.
+  </caption>
+
+  click('button', { shiftKey: true });
+*/
+export default function click(target: Target, _options?: MouseEventInit): Promise<void>;
+//# sourceMappingURL=click.d.ts.map
+}

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

@@ -0,0 +1,65 @@
+declare module '@ember/test-helpers/dom/double-click' {
+import { type Target } from './-target.ts';
+/**
+  @private
+  @param {Element} element the element to double-click on
+  @param {MouseEventInit} options the options to be merged into the mouse events
+  @returns {Promise<Event | void>} resolves when settled
+*/
+export declare function __doubleClick__(element: Element | Document | Window, options: MouseEventInit): Promise<Event | void>;
+/**
+  Double-clicks on the specified target.
+
+  Sends a number of events intending to simulate a "real" user clicking on an
+  element.
+
+  For non-focusable elements the following events are triggered (in order):
+
+  - `mousedown`
+  - `mouseup`
+  - `click`
+  - `mousedown`
+  - `mouseup`
+  - `click`
+  - `dblclick`
+
+  For focusable (e.g. form control) elements the following events are triggered
+  (in order):
+
+  - `mousedown`
+  - `focus`
+  - `focusin`
+  - `mouseup`
+  - `click`
+  - `mousedown`
+  - `mouseup`
+  - `click`
+  - `dblclick`
+
+  The exact listing of events that are triggered may change over time as needed
+  to continue to emulate how actual browsers handle clicking a given element.
+
+  Use the `options` hash to change the parameters of the [MouseEvents](https://developer.mozilla.org/en-US/docs/Web/API/MouseEvent/MouseEvent).
+
+  @public
+  @param {string|Element|IDOMElementDescriptor} target the element, selector, or descriptor to double-click on
+  @param {MouseEventInit} _options the options to be merged into the mouse events
+  @return {Promise<void>} resolves when settled
+
+  @example
+  <caption>
+    Emulating double clicking a button using `doubleClick`
+  </caption>
+
+  doubleClick('button');
+
+  @example
+  <caption>
+    Emulating double clicking a button and pressing the `shift` key simultaneously using `click` with `options`.
+  </caption>
+
+  doubleClick('button', { shiftKey: true });
+*/
+export default function doubleClick(target: Target, _options?: MouseEventInit): Promise<void>;
+//# sourceMappingURL=double-click.d.ts.map
+}

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

@@ -0,0 +1,22 @@
+declare module '@ember/test-helpers/dom/fill-in' {
+import { type Target } from './-target.ts';
+/**
+  Fill the provided text into the `value` property (or set `.innerHTML` when
+  the target is a content editable element) then trigger `change` and `input`
+  events on the specified target.
+
+  @public
+  @param {string|Element|IDOMElementDescriptor} target the element, selector, or descriptor to enter text into
+  @param {string} text the text to fill into the target element
+  @return {Promise<void>} resolves when the application is settled
+
+  @example
+  <caption>
+    Emulating filling an input with text using `fillIn`
+  </caption>
+
+  fillIn('input', 'hello world');
+*/
+export default function fillIn(target: Target, text: string): Promise<void>;
+//# sourceMappingURL=fill-in.d.ts.map
+}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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