@discourse/types 0.0.1 → 0.0.2

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

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

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

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

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

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

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

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

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

@@ -0,0 +1,69 @@
+declare module '@ember/test-helpers/setup-application-context' {
+import { type BaseContext, type TestContext } from './setup-context.ts';
+export interface ApplicationTestContext extends TestContext {
+    element?: Element | null;
+}
+export declare function isApplicationTestContext(context: BaseContext): context is ApplicationTestContext;
+/**
+  Determines if we have any pending router transitions (used to determine `settled` state)
+
+  @public
+  @returns {(boolean|null)} if there are pending transitions
+*/
+export declare function hasPendingTransitions(): boolean | null;
+/**
+  Setup the current router instance with settledness tracking. Generally speaking this
+  is done automatically (during a `visit('/some-url')` invocation), but under some
+  circumstances (e.g. a non-application test where you manually call `this.owner.setupRouter()`)
+  you may want to call it yourself.
+
+  @public
+ */
+export declare function setupRouterSettlednessTracking(): void;
+/**
+  Navigate the application to the provided URL.
+
+  @public
+  @param {string} url The URL to visit (e.g. `/posts`)
+  @param {object} options app boot options
+  @returns {Promise<void>} resolves when settled
+
+  @example
+  <caption>
+    Visiting the route for post 1.
+  </caption>
+  await visit('/posts/1');
+
+  @example
+  <caption>
+    Visiting the route for post 1 while also providing the `rootElement` app boot option.
+  </caption>
+  await visit('/', { rootElement: '#container' });
+*/
+export declare function visit(url: string, options?: Record<string, unknown>): Promise<void>;
+/**
+  @public
+  @returns {string} the currently active route name
+*/
+export declare function currentRouteName(): string;
+/**
+  @public
+  @returns {string} the applications current url
+*/
+export declare function currentURL(): string;
+/**
+  Used by test framework addons to setup the provided context for working with
+  an application (e.g. routing).
+
+  `setupContext` must have been run on the provided context prior to calling
+  `setupApplicationContext`.
+
+  Sets up the basic framework used by application tests.
+
+  @public
+  @param {Object} context the context to setup
+  @returns {Promise<void>} resolves when the context is set up
+*/
+export default function setupApplicationContext(context: TestContext): Promise<void>;
+//# sourceMappingURL=setup-application-context.d.ts.map
+}

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

@@ -0,0 +1,209 @@
+declare module '@ember/test-helpers/setup-context' {
+import type { Resolver } from '@ember/owner';
+import { type Owner } from './build-owner.ts';
+import { type DeprecationFailure } from './-internal/deprecations.ts';
+import { type Warning } from './-internal/warnings.ts';
+export interface SetupContextOptions {
+    resolver?: Resolver | undefined;
+}
+export type BaseContext = object;
+/**
+ * The public API for the test context, which test authors can depend on being
+ * available.
+ *
+ * Note: this is *not* user-constructible; it becomes available by calling
+ * `setupContext()` with a base context object.
+ */
+export interface TestContext extends BaseContext {
+    owner: Owner;
+    set<T>(key: string, value: T): T;
+    setProperties<T extends Record<string, unknown>>(hash: T): T;
+    get(key: string): unknown;
+    getProperties(...args: string[]): Record<string, unknown>;
+    pauseTest(): Promise<void>;
+    resumeTest(): void;
+}
+export declare function isTestContext(context: BaseContext): context is TestContext;
+/**
+  Stores the provided context as the "global testing context".
+
+  Generally setup automatically by `setupContext`.
+
+  @public
+  @param {Object} context the context to use
+*/
+export declare function setContext(context: BaseContext): void;
+/**
+  Retrieve the "global testing context" as stored by `setContext`.
+
+  @public
+  @returns {Object} the previously stored testing context
+*/
+export declare function getContext(): BaseContext | undefined;
+/**
+  Clear the "global testing context".
+
+  Generally invoked from `teardownContext`.
+
+  @public
+*/
+export declare function unsetContext(): void;
+/**
+ * Returns a promise to be used to pauses the current test (due to being
+ * returned from the test itself).  This is useful for debugging while testing
+ * or for test-driving.  It allows you to inspect the state of your application
+ * at any point.
+ *
+ * The test framework wrapper (e.g. `ember-qunit` or `ember-mocha`) should
+ * ensure that when `pauseTest()` is used, any framework specific test timeouts
+ * are disabled.
+ *
+ * @public
+ * @returns {Promise<void>} resolves _only_ when `resumeTest()` is invoked
+ * @example <caption>Usage via ember-qunit</caption>
+ *
+ * import { setupRenderingTest } from 'ember-qunit';
+ * import { render, click, pauseTest } from '@ember/test-helpers';
+ *
+ *
+ * module('awesome-sauce', function(hooks) {
+ *   setupRenderingTest(hooks);
+ *
+ *   test('does something awesome', async function(assert) {
+ *     await render(hbs`{{awesome-sauce}}`);
+ *
+ *     // added here to visualize / interact with the DOM prior
+ *     // to the interaction below
+ *     await pauseTest();
+ *
+ *     click('.some-selector');
+ *
+ *     assert.equal(this.element.textContent, 'this sauce is awesome!');
+ *   });
+ * });
+ */
+export declare function pauseTest(): Promise<void>;
+/**
+  Resumes a test previously paused by `await pauseTest()`.
+
+  @public
+*/
+export declare function resumeTest(): void;
+/**
+ * Returns deprecations which have occurred so far for a the current test context
+ *
+ * @public
+ * @returns {Array<DeprecationFailure>} An array of deprecation messages
+ * @example <caption>Usage via ember-qunit</caption>
+ *
+ * import { getDeprecations } from '@ember/test-helpers';
+ *
+ * module('awesome-sauce', function(hooks) {
+ *   setupRenderingTest(hooks);
+ *
+ *   test('does something awesome', function(assert) {
+       const deprecations = getDeprecations() // => returns deprecations which have occurred so far in this test
+ *   });
+ * });
+ */
+export declare function getDeprecations(): Array<DeprecationFailure>;
+export type { DeprecationFailure };
+/**
+ * Returns deprecations which have occurred so far for a the current test context
+ *
+ * @public
+ * @param {Function} [callback] The callback that when executed will have its DeprecationFailure recorded
+ * @returns {Array<DeprecationFailure> | Promise<Array<DeprecationFailure>>} An array of deprecation messages
+ * @example <caption>Usage via ember-qunit</caption>
+ *
+ * import { getDeprecationsDuringCallback } from '@ember/test-helpers';
+ *
+ * module('awesome-sauce', function(hooks) {
+ *   setupRenderingTest(hooks);
+ *
+ *   test('does something awesome', function(assert) {
+ *     const deprecations = getDeprecationsDuringCallback(() => {
+ *       // code that might emit some deprecations
+ *
+ *     }); // => returns deprecations which occurred while the callback was invoked
+ *   });
+ *
+ *
+ *   test('does something awesome', async function(assert) {
+ *     const deprecations = await getDeprecationsDuringCallback(async () => {
+ *       // awaited code that might emit some deprecations
+ *     }); // => returns deprecations which occurred while the callback was invoked
+ *   });
+ * });
+ */
+export declare function getDeprecationsDuringCallback(callback: () => void): Array<DeprecationFailure> | Promise<Array<DeprecationFailure>>;
+/**
+ * Returns warnings which have occurred so far for a the current test context
+ *
+ * @public
+ * @returns {Array<Warning>} An array of warnings
+ * @example <caption>Usage via ember-qunit</caption>
+ *
+ * import { getWarnings } from '@ember/test-helpers';
+ *
+ * module('awesome-sauce', function(hooks) {
+ *   setupRenderingTest(hooks);
+ *
+ *   test('does something awesome', function(assert) {
+       const warnings = getWarnings() // => returns warnings which have occurred so far in this test
+ *   });
+ * });
+ */
+export declare function getWarnings(): Array<Warning>;
+export type { Warning };
+/**
+ * Returns warnings which have occurred so far for a the current test context
+ *
+ * @public
+ * @param {Function} [callback] The callback that when executed will have its warnings recorded
+ * @returns {Array<Warning> | Promise<Array<Warning>>} An array of warnings information
+ * @example <caption>Usage via ember-qunit</caption>
+ *
+ * import { getWarningsDuringCallback } from '@ember/test-helpers';
+ * import { warn } from '@ember/debug';
+ *
+ * module('awesome-sauce', function(hooks) {
+ *   setupRenderingTest(hooks);
+ *
+ *   test('does something awesome', function(assert) {
+ *     const warnings = getWarningsDuringCallback(() => {
+ *     warn('some warning');
+ *
+ *     }); // => returns warnings which occurred while the callback was invoked
+ *   });
+ *
+ *   test('does something awesome', async function(assert) {
+ *     warn('some warning');
+ *
+ *     const warnings = await getWarningsDuringCallback(async () => {
+ *       warn('some other warning');
+ *     }); // => returns warnings which occurred while the callback was invoked
+ *   });
+ * });
+ */
+export declare function getWarningsDuringCallback(callback: () => void): Array<Warning> | Promise<Array<Warning>>;
+/**
+  Used by test framework addons to setup the provided context for testing.
+
+  Responsible for:
+
+  - sets the "global testing context" to the provided context (`setContext`)
+  - create an owner object and set it on the provided context (e.g. `this.owner`)
+  - setup `this.set`, `this.setProperties`, `this.get`, and `this.getProperties` to the provided context
+  - setting up AJAX listeners
+  - setting up `pauseTest` (also available as `this.pauseTest()`) and `resumeTest` helpers
+
+  @public
+  @param {Object} base the context to setup
+  @param {Object} [options] options used to override defaults
+  @param {Resolver} [options.resolver] a resolver to use for customizing normal resolution
+  @returns {Promise<Object>} resolves with the context that was setup
+*/
+export default function setupContext<T extends object>(base: T, options?: SetupContextOptions): Promise<T & TestContext>;
+//# sourceMappingURL=setup-context.d.ts.map
+}

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

@@ -0,0 +1,53 @@
+declare module '@ember/test-helpers/setup-onerror' {
+import { type BaseContext } from './setup-context.ts';
+/**
+ * Sets the `Ember.onerror` function for tests. This value is intended to be reset after
+ * each test to ensure correct test isolation. To reset, you should simply call `setupOnerror`
+ * without an `onError` argument.
+ *
+ * @public
+ * @param {Function} onError the onError function to be set on Ember.onerror
+ *
+ * @example <caption>Example implementation for `ember-qunit` or `ember-mocha`</caption>
+ *
+ * import { setupOnerror } from '@ember/test-helpers';
+ *
+ * test('Ember.onerror is stubbed properly', function(assert) {
+ *   setupOnerror(function(err) {
+ *     assert.ok(err);
+ *   });
+ * });
+ */
+export default function setupOnerror(onError?: (error: Error) => void): void;
+/**
+ * Resets `Ember.onerror` to the value it originally was at the start of the test run.
+ * If there is no context or cached value this is a no-op.
+ *
+ * @public
+ *
+ * @example
+ *
+ * import { resetOnerror } from '@ember/test-helpers';
+ *
+ * QUnit.testDone(function() {
+ *   resetOnerror();
+ * })
+ */
+export declare function resetOnerror(): void;
+/**
+ * Caches the current value of Ember.onerror. When `setupOnerror` is called without a value
+ * or when `resetOnerror` is called the value will be set to what was cached here.
+ *
+ * @private
+ * @param {BaseContext} context the text context
+ */
+export declare function _prepareOnerror(context: BaseContext): void;
+/**
+ * Removes the cached value of Ember.onerror.
+ *
+ * @private
+ * @param {BaseContext} context the text context
+ */
+export declare function _cleanupOnerror(context: BaseContext): void;
+//# sourceMappingURL=setup-onerror.d.ts.map
+}

package/external-types/@ember__test-helpers/declarations/setup-rendering-context.d.ts

@@ -0,0 +1,75 @@
+declare module '@ember/test-helpers/setup-rendering-context' {
+import { type BaseContext, type TestContext } from './setup-context.ts';
+import type { Owner } from './build-owner.ts';
+declare const hasCalledSetupRenderingContext: unique symbol;
+export interface RenderingTestContext extends TestContext {
+    element: Element | Document;
+    [hasCalledSetupRenderingContext]?: true;
+}
+export declare function isRenderingTestContext(context: BaseContext): context is RenderingTestContext;
+export interface RenderOptions {
+    /**
+      The owner object to use as the basis for the template. In most cases you
+      will not need to specify this, however if you are using ember-engines
+      it is possible to specify the _engine's_ owner instead of the host
+      applications.
+    */
+    owner?: Owner;
+}
+/**
+  Renders the provided template and appends it to the DOM.
+
+  @public
+  @param {Template|Component} templateFactoryOrComponent the component (or template) to render
+  @param {RenderOptions} options options hash containing engine owner ({ owner: engineOwner })
+  @returns {Promise<void>} resolves when settled
+
+  @example
+  <caption>
+    Render a div element with the class 'container'.
+  </caption>
+  await render(hbs`<div class="container"></div>`);
+*/
+export declare function render(templateFactoryOrComponent: object, options?: RenderOptions): Promise<void>;
+/**
+  Clears any templates previously rendered. This is commonly used for
+  confirming behavior that is triggered by teardown (e.g.
+  `willDestroyElement`).
+
+  @public
+  @returns {Promise<void>} resolves when settled
+*/
+export declare function clearRender(): Promise<void>;
+/**
+  Used by test framework addons to setup the provided context for rendering.
+
+  `setupContext` must have been ran on the provided context
+  prior to calling `setupRenderingContext`.
+
+  Responsible for:
+
+  - Setup the basic framework used for rendering by the
+    `render` helper.
+  - Ensuring the event dispatcher is properly setup.
+  - Setting `this.element` to the root element of the testing
+    container (things rendered via `render` will go _into_ this
+    element).
+
+  @public
+  @param {TestContext} context the context to setup for rendering
+  @returns {Promise<RenderingTestContext>} resolves with the context that was setup
+
+  @example
+  <caption>
+    Rendering out a paragraph element containing the content 'hello', and then clearing that content via clearRender.
+  </caption>
+
+  await render(hbs`<p>Hello!</p>`);
+  assert.equal(this.element.textContent, 'Hello!', 'has rendered content');
+  await clearRender();
+  assert.equal(this.element.textContent, '', 'has rendered content');
+*/
+export default function setupRenderingContext(context: TestContext): Promise<RenderingTestContext>;
+export {};
+//# sourceMappingURL=setup-rendering-context.d.ts.map
+}

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

@@ -0,0 +1,23 @@
+declare module '@ember/test-helpers/teardown-context' {
+import type { TestContext } from './setup-context';
+export interface TeardownContextOptions {
+    waitForSettled?: boolean | undefined;
+}
+/**
+  Used by test framework addons to tear down the provided context after testing is completed.
+
+  Responsible for:
+
+  - un-setting the "global testing context" (`unsetContext`)
+  - destroy the contexts owner object
+  - remove AJAX listeners
+
+  @public
+  @param {Object} context the context to setup
+  @param {Object} [options] options used to override defaults
+  @param {boolean} [options.waitForSettled=true] should the teardown wait for `settled()`ness
+  @returns {Promise<void>} resolves when settled
+*/
+export default function teardownContext(context: TestContext, { waitForSettled }?: TeardownContextOptions): Promise<void>;
+//# sourceMappingURL=teardown-context.d.ts.map
+}