@discourse/types 0.0.1 → 0.0.2

package/external-types/@ember__string/declarations/index.d.ts

@@ -0,0 +1,159 @@
+declare module '@ember/string' {
+/**
+ Returns the lowerCamelCase form of a string.
+
+ ```javascript
+ import { camelize } from '@ember/string';
+
+ camelize('innerHTML');                   // 'innerHTML'
+ camelize('action_name');                 // 'actionName'
+ camelize('css-class-name');              // 'cssClassName'
+ camelize('my favorite items');           // 'myFavoriteItems'
+ camelize('My Favorite Items');           // 'myFavoriteItems'
+ camelize('private-docs/owner-invoice');  // 'privateDocs/ownerInvoice'
+ ```
+
+ @method camelize
+ @param {String} str The string to camelize.
+ @return {String} the camelized string.
+ @public
+ */
+export declare function camelize(str: string): string;
+
+/**
+ Returns the Capitalized form of a string
+
+ ```javascript
+ import { capitalize } from '@ember/string';
+
+ capitalize('innerHTML')                 // 'InnerHTML'
+ capitalize('action_name')               // 'Action_name'
+ capitalize('css-class-name')            // 'Css-class-name'
+ capitalize('my favorite items')         // 'My favorite items'
+ capitalize('privateDocs/ownerInvoice'); // 'PrivateDocs/ownerInvoice'
+ ```
+
+ @method capitalize
+ @param {String} str The string to capitalize.
+ @return {String} The capitalized string.
+ @public
+ */
+export declare function capitalize(str: string): string;
+
+/**
+ Returns the UpperCamelCase form of a string.
+
+ ```javascript
+ import { classify } from '@ember/string';
+
+ classify('innerHTML');                   // 'InnerHTML'
+ classify('action_name');                 // 'ActionName'
+ classify('css-class-name');              // 'CssClassName'
+ classify('my favorite items');           // 'MyFavoriteItems'
+ classify('private-docs/owner-invoice');  // 'PrivateDocs/OwnerInvoice'
+ ```
+
+ @method classify
+ @param {String} str the string to classify
+ @return {String} the classified string
+ @public
+ */
+export declare function classify(str: string): string;
+
+/**
+ Replaces underscores, spaces, or camelCase with dashes.
+
+ ```javascript
+ import { dasherize } from '@ember/string';
+
+ dasherize('innerHTML');                // 'inner-html'
+ dasherize('action_name');              // 'action-name'
+ dasherize('css-class-name');           // 'css-class-name'
+ dasherize('my favorite items');        // 'my-favorite-items'
+ dasherize('privateDocs/ownerInvoice';  // 'private-docs/owner-invoice'
+ ```
+
+ @method dasherize
+ @param {String} str The string to dasherize.
+ @return {String} the dasherized string.
+ @public
+ */
+export declare function dasherize(str: string): string;
+
+/**
+ Converts a camelized string into all lower case separated by underscores.
+
+ ```javascript
+ import { decamelize } from '@ember/string';
+
+ decamelize('innerHTML');          // 'inner_html'
+ decamelize('action_name');        // 'action_name'
+ decamelize('css-class-name');     // 'css-class-name'
+ decamelize('my favorite items');  // 'my favorite items'
+ ```
+
+ @method decamelize
+ @param {String} str The string to decamelize.
+ @return {String} the decamelized string.
+ @public
+ */
+export declare function decamelize(str: string): string;
+
+export declare function getString(name: string): string | undefined;
+
+export declare function getStrings(): {
+    [key: string]: string;
+};
+
+export declare function setStrings(strings: {
+    [key: string]: string;
+}): void;
+
+/**
+ More general than decamelize. Returns the lower\_case\_and\_underscored
+ form of a string.
+
+ ```javascript
+ import { underscore } from '@ember/string';
+
+ underscore('innerHTML');                 // 'inner_html'
+ underscore('action_name');               // 'action_name'
+ underscore('css-class-name');            // 'css_class_name'
+ underscore('my favorite items');         // 'my_favorite_items'
+ underscore('privateDocs/ownerInvoice');  // 'private_docs/owner_invoice'
+ ```
+
+ @method underscore
+ @param {String} str The string to underscore.
+ @return {String} the underscored string.
+ @public
+ */
+export declare function underscore(str: string): string;
+
+/**
+ Splits a string into separate units separated by spaces, eliminating any
+ empty strings in the process. This is a convenience method for split that
+ is mostly useful when applied to the `String.prototype`.
+
+ ```javascript
+ import { w } from '@ember/string';
+
+ w("alpha beta gamma").forEach(function(key) {
+ console.log(key);
+ });
+
+ // > alpha
+ // > beta
+ // > gamma
+ ```
+
+ @method w
+ @param {String} str The string to split
+ @return {Array} array containing the split strings
+ @public
+ */
+export declare function w(str: string): string[];
+
+export { }
+
+}

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

@@ -0,0 +1,67 @@
+{
+  "name": "@ember/string",
+  "version": "4.0.1",
+  "description": "A set of utilities to transform strings",
+  "repository": "https://github.com/emberjs/ember-string",
+  "license": "MIT",
+  "author": "",
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./declarations/index.d.ts",
+      "default": "./dist/index.js"
+    }
+  },
+  "typesVersions": {
+    "*": {
+      "*": [
+        "declarations/*"
+      ]
+    }
+  },
+  "files": [
+    "dist",
+    "declarations",
+    "addon-main.cjs"
+  ],
+  "devDependencies": {
+    "@arethetypeswrong/cli": "^0.15.0",
+    "@embroider/addon-dev": "^4.1.0",
+    "@tsconfig/ember": "^3.0.2",
+    "@types/ember__debug": "^4.0.7",
+    "@typescript-eslint/eslint-plugin": "^6.14.0",
+    "@typescript-eslint/parser": "^6.14.0",
+    "concurrently": "^8.2.2",
+    "eslint": "^8.56.0",
+    "eslint-config-prettier": "^9.1.0",
+    "eslint-plugin-ember": "^11.12.0",
+    "eslint-plugin-n": "^16.4.0",
+    "eslint-plugin-prettier": "^5.0.1",
+    "expect-type": "^0.18.0",
+    "prettier": "^3.1.1",
+    "publint": "^0.2.7",
+    "release-plan": "^0.9.0",
+    "typescript": "^5.3.3",
+    "vite": "^5.3.2",
+    "vite-plugin-dts": "^3.9.1"
+  },
+  "volta": {
+    "node": "20.11.1",
+    "pnpm": "9.4.0"
+  },
+  "publishConfig": {
+    "registry": "https://registry.npmjs.org"
+  },
+  "scripts": {
+    "build": "vite build",
+    "lint": "pnpm build; concurrently 'npm:lint:*(!fix)' --names 'lint:'",
+    "lint:fix": "concurrently 'npm:lint:*:fix' --names 'fix:'",
+    "lint:js": "eslint . --cache",
+    "lint:js:fix": "eslint . --fix",
+    "lint:package": "publint",
+    "lint:published-types": "pnpm pack; attw; rm *.tgz",
+    "start": "vite build --watch",
+    "test": "cd tests && pnpm test",
+    "test:types": "tsc --noEmit --emitDeclarationOnly false"
+  }
+}

package/external-types/@ember__test-helpers/declarations/-internal/build-registry.d.ts

@@ -0,0 +1,36 @@
+declare module '@ember/test-helpers/-internal/build-registry' {
+import type { Resolver } from '@ember/owner';
+import EmberObject from '@ember/object';
+import { Registry } from '@ember/-internals/container';
+import type { FullName } from '@ember/owner';
+import { ContainerProxyMixin, RegistryProxyMixin } from '@ember/-internals/runtime';
+interface Owner extends RegistryProxyMixin, ContainerProxyMixin {
+}
+declare const Owner: Readonly<typeof EmberObject> & (new (owner?: import("@ember/owner").default) => EmberObject) & import("@ember/object/mixin").default & {
+    _emberTestHelpersMockOwner: boolean;
+    /**
+     * Unregister a factory and its instance.
+     *
+     * Overrides `RegistryProxy#unregister` in order to clear any cached instances
+     * of the unregistered factory.
+     *
+     * @param {string} fullName Name of the factory to unregister.
+     *
+     * @see {@link https://github.com/emberjs/ember.js/pull/12680}
+     * @see {@link https://github.com/emberjs/ember.js/blob/v4.5.0-alpha.5/packages/%40ember/engine/instance.ts#L152-L167}
+     */
+    unregister(this: Owner, fullName: FullName): void;
+};
+/**
+ * @private
+ * @param {Object} resolver the resolver to use with the registry
+ * @returns {Object} owner, container, registry
+ */
+export default function buildRegistry(resolver: Resolver): {
+    registry: Registry;
+    container: import("@ember/-internals/container").Container;
+    owner: Owner;
+};
+export {};
+//# sourceMappingURL=build-registry.d.ts.map
+}

package/external-types/@ember__test-helpers/declarations/-internal/debug-info-helpers.d.ts

@@ -0,0 +1,28 @@
+declare module '@ember/test-helpers/-internal/debug-info-helpers' {
+export interface DebugInfoHelper {
+    name: string;
+    log: () => void;
+}
+export declare const debugInfoHelpers: Set<DebugInfoHelper>;
+/**
+ * Registers a custom debug info helper to augment the output for test isolation validation.
+ *
+ * @public
+ * @param {DebugInfoHelper} debugHelper a custom debug info helper
+ * @example
+ *
+ * import { registerDebugInfoHelper } from '@ember/test-helpers';
+ *
+ * registerDebugInfoHelper({
+ *   name: 'Date override detection',
+ *   log() {
+ *     if (dateIsOverridden()) {
+ *       console.log(this.name);
+ *       console.log('The date object has been overridden');
+ *     }
+ *   }
+ * })
+ */
+export default function registerDebugInfoHelper(debugHelper: DebugInfoHelper): void;
+//# sourceMappingURL=debug-info-helpers.d.ts.map
+}

package/external-types/@ember__test-helpers/declarations/-internal/debug-info.d.ts

@@ -0,0 +1,71 @@
+declare module '@ember/test-helpers/-internal/debug-info' {
+import type { DebugInfo as BackburnerDebugInfo } from '@ember/runloop/-private/backburner';
+import { type PendingWaiterState } from '@ember/test-waiters';
+type MaybeDebugInfo = BackburnerDebugInfo | null;
+interface SettledState {
+    hasPendingTimers: boolean;
+    hasRunLoop: boolean;
+    hasPendingLegacyWaiters: boolean;
+    hasPendingTestWaiters: boolean;
+    hasPendingRequests: boolean;
+    isRenderPending: boolean;
+}
+interface SummaryInfo {
+    hasPendingRequests: boolean;
+    hasPendingLegacyWaiters: boolean;
+    hasPendingTestWaiters: boolean;
+    pendingTestWaiterInfo: PendingWaiterState;
+    autorunStackTrace: string | undefined | null;
+    pendingTimersCount: number;
+    hasPendingTimers: boolean;
+    pendingTimersStackTraces: (string | undefined)[];
+    pendingScheduledQueueItemCount: number;
+    pendingScheduledQueueItemStackTraces: (string | undefined)[];
+    hasRunLoop: boolean;
+    isRenderPending: boolean;
+}
+/**
+ * The base functionality which may be present on the `SettledState` interface
+ * in the `settled` module (**not** the one in this module).
+ */
+export default interface DebugInfo {
+    toConsole: () => void;
+}
+/**
+ * Determines if the `getDebugInfo` method is available in the
+ * running verison of backburner.
+ *
+ * @returns {boolean} True if `getDebugInfo` is present in backburner, otherwise false.
+ */
+export declare function backburnerDebugInfoAvailable(): boolean;
+/**
+ * Retrieves debug information from backburner's current deferred actions queue (runloop instance).
+ * If the `getDebugInfo` method isn't available, it returns `null`.
+ *
+ * @public
+ * @returns {MaybeDebugInfo | null} Backburner debugInfo or, if the getDebugInfo method is not present, null
+ */
+export declare function getDebugInfo(): MaybeDebugInfo;
+/**
+ * Encapsulates debug information for an individual test. Aggregates information
+ * from:
+ * - info provided by getSettledState
+ *    - hasPendingTimers
+ *    - hasRunLoop
+ *    - hasPendingWaiters
+ *    - hasPendingRequests
+ * - info provided by backburner's getDebugInfo method (timers, schedules, and stack trace info)
+ *
+ */
+export declare class TestDebugInfo implements DebugInfo {
+    private _settledState;
+    private _debugInfo;
+    private _summaryInfo;
+    constructor(settledState: SettledState, debugInfo?: MaybeDebugInfo);
+    get summary(): SummaryInfo;
+    toConsole(_console?: Console): void;
+    _formatCount(title: string, count: number): string;
+}
+export {};
+//# sourceMappingURL=debug-info.d.ts.map
+}

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

@@ -0,0 +1,37 @@
+declare module '@ember/test-helpers/-internal/deprecations' {
+import type { BaseContext } from '../setup-context';
+export interface DeprecationOptions {
+    id: string;
+    until: string;
+    for?: string;
+    since?: {
+        available: string;
+    };
+}
+export interface DeprecationFailure {
+    message: string;
+    options?: DeprecationOptions;
+}
+/**
+ *
+ * Provides the list of deprecation failures associated with a given base context;
+ *
+ * @private
+ * @param {BaseContext} [context] the test context
+ * @return {Array<DeprecationFailure>} the Deprecation Failures associated with the corresponding BaseContext;
+ */
+export declare function getDeprecationsForContext(context: BaseContext): Array<DeprecationFailure>;
+/**
+ *
+ * Provides the list of deprecation failures associated with a given base
+ * context which occur while a callback is executed. This callback can be
+ * synchronous, or it can be an async function.
+ *
+ * @private
+ * @param {BaseContext} [context] the test context
+ * @param {Function} [callback] The callback that when executed will have its DeprecationFailure recorded
+ * @return {Array<DeprecationFailure>} The Deprecation Failures associated with the corresponding baseContext which occurred while the CallbackFunction was executed
+ */
+export declare function getDeprecationsDuringCallbackForContext(context: BaseContext, callback: () => void): Array<DeprecationFailure> | Promise<Array<DeprecationFailure>>;
+//# sourceMappingURL=deprecations.d.ts.map
+}

package/external-types/@ember__test-helpers/declarations/-internal/is-component.d.ts

@@ -0,0 +1,13 @@
+declare module '@ember/test-helpers/-internal/is-component' {
+import type { ComponentLike } from '@glint/template';
+/**
+ * We should ultimately get a new API from @glimmer/runtime that provides this functionality
+ * (see https://github.com/emberjs/rfcs/pull/785 for more info).
+ * @private
+ * @param {Object} maybeComponent The thing you think might be a component
+ * @returns {boolean} True if it's a component, false if not
+ */
+declare function isComponent(maybeComponent: object): maybeComponent is ComponentLike;
+export default isComponent;
+//# sourceMappingURL=is-component.d.ts.map
+}

package/external-types/@ember__test-helpers/declarations/-internal/is-promise.d.ts

@@ -0,0 +1,12 @@
+declare module '@ember/test-helpers/-internal/is-promise' {
+/**
+ *
+ * detect if a value appears to be a promise
+ *
+ * @private
+ * @param {any} [maybePromise] the value being considered to be a promise
+ * @return {boolean} true if the value appears to be a promise, or false otherwise
+ */
+export default function (maybePromise: any): boolean;
+//# sourceMappingURL=is-promise.d.ts.map
+}

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

@@ -0,0 +1,5 @@
+declare module '@ember/test-helpers/-internal/render-settled' {
+declare let renderSettled: () => Promise<void>;
+export default renderSettled;
+//# sourceMappingURL=render-settled.d.ts.map
+}

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

@@ -0,0 +1,32 @@
+declare module '@ember/test-helpers/-internal/warnings' {
+import type { BaseContext } from '../setup-context';
+export interface WarningOptions {
+    id?: string;
+}
+export interface Warning {
+    message: string;
+    options?: WarningOptions;
+}
+/**
+ *
+ * Provides the list of warnings associated with a given base context;
+ *
+ * @private
+ * @param {BaseContext} [context] the test context
+ * @return {Array<Warning>} the warnings associated with the corresponding BaseContext;
+ */
+export declare function getWarningsForContext(context: BaseContext): Array<Warning>;
+/**
+ *
+ * Provides the list of warnings associated with a given test context which
+ * occurred only while a the provided callback is executed. This callback can be
+ * synchronous, or it can be an async function.
+ *
+ * @private
+ * @param {BaseContext} [context] the test context
+ * @param {Function} [callback] The callback that when executed will have its warnings recorded
+ * @return {Array<Warning>} The warnings associated with the corresponding baseContext which occurred while the CallbackFunction was executed
+ */
+export declare function getWarningsDuringCallbackForContext(context: BaseContext, callback: () => void): Array<Warning> | Promise<Array<Warning>>;
+//# sourceMappingURL=warnings.d.ts.map
+}

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

@@ -0,0 +1,5 @@
+declare module '@ember/test-helpers/-tuple' {
+export type Lit = string | number | boolean | undefined | null | void | {};
+export default function tuple<T extends Lit[]>(...args: T): T;
+//# sourceMappingURL=-tuple.d.ts.map
+}

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

@@ -0,0 +1,39 @@
+declare module '@ember/test-helpers/-utils' {
+export declare const nextTick: (cb: () => void) => Promise<void>;
+export declare const futureTick: typeof setTimeout;
+/**
+ Retrieves an array of destroyables from the specified property on the object
+ provided, iterates that array invoking each function, then deleting the
+ property (clearing the array).
+
+ @private
+ @param {Object} object an object to search for the destroyable array within
+ @param {string} property the property on the object that contains the destroyable array
+*/
+export declare function runDestroyablesFor(object: any, property: string): void;
+/**
+ Returns whether the passed in string consists only of numeric characters.
+
+ @private
+ @param {string} n input string
+ @returns {boolean} whether the input string consists only of numeric characters
+ */
+export declare function isNumeric(n: string): boolean;
+/**
+  Checks if an element is considered visible by the focus area spec.
+
+  @private
+  @param {Element} element the element to check
+  @returns {boolean} `true` when the element is visible, `false` otherwise
+*/
+export declare function isVisible(element: Element): boolean;
+/**
+  Checks if an element is disabled.
+
+  @private
+  @param {Element} element the element to check
+  @returns {boolean} `true` when the element is disabled, `false` otherwise
+*/
+export declare function isDisabled(element: HTMLElement): boolean;
+//# sourceMappingURL=-utils.d.ts.map
+}

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

@@ -0,0 +1,21 @@
+declare module '@ember/test-helpers/application' {
+import Application from '@ember/application';
+/**
+  Stores the provided application instance so that tests being ran will be aware of the application under test.
+
+  - Required by `setupApplicationContext` method.
+  - Used by `setupContext` and `setupRenderingContext` when present.
+
+  @public
+  @param {Ember.Application} application the application that will be tested
+*/
+export declare function setApplication(application: Application): void;
+/**
+  Retrieve the application instance stored by `setApplication`.
+
+  @public
+  @returns {Ember.Application} the previously stored application instance under test
+*/
+export declare function getApplication(): Application | undefined;
+//# sourceMappingURL=application.d.ts.map
+}

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

@@ -0,0 +1,35 @@
+declare module '@ember/test-helpers/build-owner' {
+import Application from '@ember/application';
+import type { Resolver } from '@ember/owner';
+import type EmberOwner from '@ember/owner';
+import type { SimpleElement } from '@simple-dom/interface';
+export interface Owner extends EmberOwner {
+    _emberTestHelpersMockOwner?: boolean;
+    rootElement?: string | Element | SimpleElement | null;
+    _lookupFactory?(key: string): any;
+    visit(url: string, options?: {
+        [key: string]: any;
+    }): Promise<any>;
+}
+/**
+  Creates an "owner" (an object that either _is_ or duck-types like an
+  `Ember.ApplicationInstance`) from the provided options.
+
+  If `options.application` is present (e.g. setup by an earlier call to
+  `setApplication`) an `Ember.ApplicationInstance` is built via
+  `application.buildInstance()`.
+
+  If `options.application` is not present, we fall back to using
+  `options.resolver` instead (setup via `setResolver`). This creates a mock
+  "owner" by using a custom created combination of `Ember.Registry`,
+  `Ember.Container`, `Ember._ContainerProxyMixin`, and
+  `Ember._RegistryProxyMixin`.
+
+  @private
+  @param {Ember.Application} [application] the Ember.Application to build an instance from
+  @param {Ember.Resolver} [resolver] the resolver to use to back a "mock owner"
+  @returns {Promise<Ember.ApplicationInstance>} a promise resolving to the generated "owner"
+*/
+export default function buildOwner(application: Application | undefined | null, resolver: Resolver | undefined | null): Promise<Owner>;
+//# sourceMappingURL=build-owner.d.ts.map
+}

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

@@ -0,0 +1,13 @@
+declare module '@ember/test-helpers/dom/-get-description' {
+import type { Target } from './-target';
+/**
+  Used internally by the DOM interaction helpers to get a description of a
+  target for debug/error messaging.
+
+  @private
+  @param {Target} target the target
+  @returns {string} a description of the target
+*/
+export default function getDescription(target: Target): string;
+//# sourceMappingURL=-get-description.d.ts.map
+}

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

@@ -0,0 +1,16 @@
+declare module '@ember/test-helpers/dom/-get-element' {
+import { type Target } from './-target.ts';
+import { type IDOMElementDescriptor } from 'dom-element-descriptors';
+declare function getElement<K extends keyof (HTMLElementTagNameMap | SVGElementTagNameMap)>(target: K): (HTMLElementTagNameMap[K] | SVGElementTagNameMap[K]) | null;
+declare function getElement<K extends keyof HTMLElementTagNameMap>(target: K): HTMLElementTagNameMap[K] | null;
+declare function getElement<K extends keyof SVGElementTagNameMap>(target: K): SVGElementTagNameMap[K] | null;
+declare function getElement(target: string): Element | null;
+declare function getElement(target: Element): Element;
+declare function getElement(target: IDOMElementDescriptor): Element | null;
+declare function getElement(target: Document): Document;
+declare function getElement(target: Window): Document;
+declare function getElement(target: string | IDOMElementDescriptor): Element | null;
+declare function getElement(target: Target): Element | Document | null;
+export default getElement;
+//# sourceMappingURL=-get-element.d.ts.map
+}

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

@@ -0,0 +1,8 @@
+declare module '@ember/test-helpers/dom/-get-elements' {
+import { type IDOMElementDescriptor } from 'dom-element-descriptors';
+declare function getElements(target: string): NodeListOf<Element>;
+declare function getElements(target: IDOMElementDescriptor): Iterable<Element>;
+declare function getElements(target: string | IDOMElementDescriptor): Iterable<Element>;
+export default getElements;
+//# sourceMappingURL=-get-elements.d.ts.map
+}

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

@@ -0,0 +1,12 @@
+declare module '@ember/test-helpers/dom/-get-window-or-element' {
+import { type Target } from './-target.ts';
+/**
+  Used internally by the DOM interaction helpers to find either window or an element.
+
+  @private
+  @param {string|Element} target the window, an element or selector to retrieve
+  @returns {Element|Window} the target or selector
+*/
+export declare function getWindowOrElement(target: Target): Element | Document | Window | null;
+//# sourceMappingURL=-get-window-or-element.d.ts.map
+}

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

@@ -0,0 +1,12 @@
+declare module '@ember/test-helpers/dom/-guard-for-maxlength' {
+import type { FormControl } from './-is-form-control';
+/**
+ * @private
+ * @param {Element} element - the element to check
+ * @param {string} text - the text being added to element
+ * @param {string} testHelper - the test helper context the guard is called from (for Error message)
+ * @throws if `element` has `maxlength` & `value` exceeds `maxlength`
+ */
+export default function guardForMaxlength(element: FormControl, text: string, testHelper: string): void;
+//# sourceMappingURL=-guard-for-maxlength.d.ts.map
+}

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

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

package/external-types/@ember__test-helpers/declarations/dom/-is-form-control.d.ts

@@ -0,0 +1,10 @@
+declare module '@ember/test-helpers/dom/-is-form-control' {
+export type FormControl = HTMLInputElement | HTMLButtonElement | HTMLSelectElement | HTMLTextAreaElement;
+/**
+  @private
+  @param {Element} element the element to check
+  @returns {boolean} `true` when the element is a form control, `false` otherwise
+*/
+export default function isFormControl(element: Element | Document | Window): element is FormControl;
+//# sourceMappingURL=-is-form-control.d.ts.map
+}