@discourse/types 2026.1.0-c7e9cdd → 2026.3.0-d02b2966

package/external-types/ember-source/types/stable/@ember/-internals/glimmer/lib/helpers/mut.d.ts

@@ -20,11 +20,11 @@ declare module '@ember/-internals/glimmer/lib/helpers/mut' {
 
       ```javascript
       // my-child.js
-      export default Component.extend({
+      export default class MyChild extends Component {
         click() {
           this.incrementProperty('childClickCount');
         }
-      });
+      }
       ```
 
       Note that for curly components (`{{my-component}}`) the bindings are already mutable,
@@ -47,11 +47,11 @@ declare module '@ember/-internals/glimmer/lib/helpers/mut' {
 
       ```javascript
       // my-child.js
-      export default Component.extend({
+      export default class MyChild extends Component {
         click() {
           this.get('click-count-change')(this.get('childClickCount') + 1);
         }
-      });
+      }
       ```
 
       The `mut` helper changes the `totalClicks` value to what was provided as the `fn` argument.

package/external-types/ember-source/types/stable/@ember/-internals/glimmer/lib/helpers/readonly.d.ts

@@ -9,9 +9,9 @@ declare module '@ember/-internals/glimmer/lib/helpers/readonly' {
       To specify that a binding is read-only, when invoking the child `Component`:
 
       ```app/components/my-parent.js
-      export default Component.extend({
-        totalClicks: 3
-      });
+      export default class MyParent extends Component {
+        totalClicks = 3;
+      }
       ```
 
       ```app/templates/components/my-parent.hbs
@@ -25,11 +25,11 @@ declare module '@ember/-internals/glimmer/lib/helpers/readonly' {
       Now, when you update `childClickCount`:
 
       ```app/components/my-child.js
-      export default Component.extend({
+      export default class MyChild extends Component {
         click() {
           this.incrementProperty('childClickCount');
         }
-      });
+      }
       ```
 
       The value updates in the child component, but not the parent component:
@@ -62,14 +62,14 @@ declare module '@ember/-internals/glimmer/lib/helpers/readonly' {
       ```app/components/my-parent.js
       import Component from '@ember/component';
 
-      export default Component.extend({
+      export default class MyParent extends Component {
         clicks: null,
 
         init() {
           this._super(...arguments);
           this.set('clicks', { total: 3 });
         }
-      });
+      }
       ```
 
       ```app/templates/components/my-parent.hbs
@@ -86,11 +86,11 @@ declare module '@ember/-internals/glimmer/lib/helpers/readonly' {
       ```app/components/my-child.js
       import Component from '@ember/component';
 
-      export default Component.extend({
+      export default class MyChild extends Component {
         click() {
           this.get('clicks').incrementProperty('total');
         }
-      });
+      }
       ```
 
       You will see the following happen:

package/external-types/ember-source/types/stable/@ember/-internals/glimmer/lib/renderer.d.ts

@@ -1,6 +1,6 @@
 declare module '@ember/-internals/glimmer/lib/renderer' {
     import type { InternalOwner } from "@ember/-internals/owner";
-    import type { Bounds, Cursor, DebugRenderTree, DynamicScope as GlimmerDynamicScope, Environment, RenderResult, Template, TemplateFactory, EvaluationContext, TreeBuilder } from "@glimmer/interfaces";
+    import type { Bounds, Cursor, DebugRenderTree, Environment, DynamicScope as GlimmerDynamicScope, RenderResult as GlimmerRenderResult, Template, TemplateFactory, EvaluationContext, TreeBuilder, ClassicResolver } from "@glimmer/interfaces";
     import type { Nullable } from "@ember/-internals/utility-types";
     import type { Reference } from "@glimmer/reference";
     import type { CurriedValue } from "@glimmer/runtime";
@@ -8,6 +8,7 @@ declare module '@ember/-internals/glimmer/lib/renderer' {
     import type { SimpleDocument, SimpleElement, SimpleNode } from "@simple-dom/interface";
     import RSVP from "rsvp";
     import type Component from "@ember/-internals/glimmer/lib/component";
+    import type ClassicComponent from "@ember/-internals/glimmer/lib/component";
     import { BOUNDS } from "@ember/-internals/glimmer/lib/component-managers/curly";
     import ResolverImpl from "@ember/-internals/glimmer/lib/resolver";
     import type { OutletState } from "@ember/-internals/glimmer/lib/utils/outlet";
@@ -30,14 +31,29 @@ declare module '@ember/-internals/glimmer/lib/renderer' {
         get(key: "outletState"): Reference<OutletState | undefined>;
         set(key: "outletState", value: Reference<OutletState | undefined>): Reference<OutletState | undefined>;
     }
-    class RootState {
+    type RootState = ClassicRootState | ComponentRootState;
+    class ComponentRootState {
+        #private;
+        readonly type = "component";
+        constructor(state: RendererState, definition: object, options: {
+            into: Cursor;
+            args?: Record<string, unknown>;
+        });
+        isFor(_component: ClassicComponent): boolean;
+        render(): void;
+        destroy(): void;
+        get destroyed(): boolean;
+        get result(): GlimmerRenderResult | undefined;
+    }
+    class ClassicRootState {
         root: Component | OutletView;
+        readonly type = "classic";
         id: string;
-        result: RenderResult | undefined;
+        result: GlimmerRenderResult | undefined;
         destroyed: boolean;
         render: () => void;
         readonly env: Environment;
-        constructor(root: Component | OutletView, context: EvaluationContext, owner: InternalOwner, template: Template, self: Reference<unknown>, parentElement: SimpleElement, dynamicScope: DynamicScope, builder: IBuilder);
+        constructor(root: Component | OutletView, context: EvaluationContext, owner: object, template: Template, self: Reference<unknown>, parentElement: SimpleElement, dynamicScope: DynamicScope, builder: IBuilder);
         isFor(possibleRoot: unknown): boolean;
         destroy(): void;
     }
@@ -46,52 +62,152 @@ declare module '@ember/-internals/glimmer/lib/renderer' {
     interface ViewRegistry {
         [viewId: string]: unknown;
     }
-    export class Renderer {
+    type Resolver = ClassicResolver;
+    interface RendererData {
+        owner: object;
+        context: EvaluationContext;
+        builder: IBuilder;
+    }
+    export class RendererState {
+        #private;
+        static create(data: RendererData, renderer: BaseRenderer): RendererState;
+        private constructor();
+        get debug(): {
+            roots: RootState[];
+            inRenderTransaction: boolean;
+            isInteractive: boolean;
+        };
+        get roots(): RootState[];
+        get owner(): object;
+        get builder(): IBuilder;
+        get context(): EvaluationContext;
+        get env(): Environment;
+        get isInteractive(): boolean;
+        renderRoot(root: RootState, renderer: BaseRenderer): RootState;
+        renderRoots(renderer: BaseRenderer): void;
+        scheduleRevalidate(renderer: BaseRenderer): void;
+        isValid(): boolean;
+        revalidate(renderer: BaseRenderer): void;
+        clearAllRoots(renderer: BaseRenderer): void;
+    }
+    type IntoTarget = Cursor | Element | SimpleElement;
+    /**
+     * The returned object from `renderComponent`
+     * @public
+     * @module @ember/renderer
+     */
+    export interface RenderResult {
+        /**
+         * Destroys the render tree and removes all rendered content from the element rendered into
+         */
+        destroy(): void;
+    }
+    /**
+     * Render a component into a DOM element.
+     *
+     * @method renderComponent
+     * @static
+     * @for @ember/renderer
+     * @param {Object} component The component to render.
+     * @param {Object} options
+     * @param {Element} options.into Where to render the component in to.
+     * @param {Object} [options.owner] Optionally specify the owner to use. This will be used for injections, and overall cleanup.
+     * @param {Object} [options.env] Optional renderer configuration
+     * @param {Object} [options.args] Optionally pass args in to the component. These may be reactive as long as it is an object or object-like
+     * @public
+     */
+    export function renderComponent(
+        /**
+         * The component definition to render.
+         *
+         * Any component that has had its manager registered is valid.
+         * For the component-types that ship with ember, manager registration
+         * does not need to be worried about.
+         */
+        component: object,
+        { owner, env, into, args, }: {
+            /**
+             * The element to render the component in to.
+             */
+            into: IntoTarget;
+            /**
+             * Optional owner. Defaults to `{}`, can be any object, but will need to implement the [Owner](https://api.emberjs.com/ember/release/classes/Owner) API for components within this render tree to access services.
+             */
+            owner?: object;
+            /**
+             * Optionally configure the rendering environment
+             */
+            env?: {
+                /**
+                 * When false, modifiers will not run.
+                 */
+                isInteractive?: boolean;
+                /**
+                 * All other options are forwarded to the underlying renderer.
+                 * (its API is currently private and out of scope for this RFC,
+                 *  so passing additional things here is also considered private API)
+                 */
+                [rendererOption: string]: unknown;
+            };
+            /**
+             * These args get passed to the rendered component
+             *
+             * If your args are reactive, re-rendering will happen automatically.
+             *
+             */
+            args?: Record<string, unknown>;
+        }
+    ): RenderResult;
+    export class BaseRenderer {
+        static strict(owner: object, document: SimpleDocument | Document, options: {
+            isInteractive: boolean;
+            hasDOM?: boolean;
+        }): BaseRenderer;
+        readonly state: RendererState;
+        constructor(owner: object, envOptions: {
+            isInteractive: boolean;
+            hasDOM: boolean;
+        }, document: SimpleDocument, resolver: Resolver, builder: IBuilder);
+        get debugRenderTree(): DebugRenderTree;
+        isValid(): boolean;
+        destroy(): void;
+        render(component: object, options: {
+            into: IntoTarget;
+            args?: Record<string, unknown>;
+        }): RootState;
+        rerender(): void;
+    }
+    export class Renderer extends BaseRenderer {
+        static strict(owner: object, document: SimpleDocument | Document, options: {
+            isInteractive: boolean;
+            hasDOM?: boolean;
+        }): BaseRenderer;
         private _rootTemplate;
         private _viewRegistry;
-        private _roots;
-        private _removedRoots;
-        private _builder;
-        private _inRenderTransaction;
-        private _owner;
-        private _context;
-        private _lastRevision;
-        private _destroyed;
-        /** @internal */
-        _isInteractive: boolean;
-        readonly _runtimeResolver: ResolverImpl;
-        readonly env: Environment;
         static create(props: {
             _viewRegistry: any;
         }): Renderer;
-        constructor(owner: InternalOwner, document: SimpleDocument, envOptions: {
+        constructor(owner: InternalOwner, document: SimpleDocument, env: {
             isInteractive: boolean;
             hasDOM: boolean;
-        }, rootTemplate: TemplateFactory, viewRegistry: ViewRegistry, builder?: typeof clientBuilder);
-        get debugRenderTree(): DebugRenderTree;
+        }, rootTemplate: TemplateFactory, viewRegistry: ViewRegistry, builder?: typeof clientBuilder, resolver?: ResolverImpl);
         appendOutletView(view: OutletView, target: SimpleElement): void;
-        appendTo(view: Component, target: SimpleElement): void;
-        _appendDefinition(root: OutletView | Component, definition: CurriedValue, target: SimpleElement): void;
-        rerender(): void;
+        appendTo(view: ClassicComponent, target: SimpleElement): void;
+        _appendDefinition(root: OutletView | ClassicComponent, definition: CurriedValue, target: SimpleElement): void;
+        cleanupRootFor(component: ClassicComponent): void;
+        remove(view: ClassicComponent): void;
+        get _roots(): RootState[];
+        get _inRenderTransaction(): boolean;
+        get _isInteractive(): boolean;
+        get _context(): EvaluationContext;
         register(view: any): void;
         unregister(view: any): void;
-        remove(view: Component): void;
-        cleanupRootFor(view: unknown): void;
-        destroy(): void;
-        getElement(view: View): Nullable<Element>;
-        getBounds(view: View): {
+        getElement(component: View): Nullable<Element>;
+        getBounds(component: View): {
             parentElement: SimpleElement;
             firstNode: SimpleNode;
             lastNode: SimpleNode;
         };
-        createElement(tagName: string): SimpleElement;
-        _renderRoot(root: RootState): void;
-        _renderRoots(): void;
-        _renderRootsTransaction(): void;
-        _clearAllRoots(): void;
-        _scheduleRevalidate(): void;
-        _isValid(): boolean;
-        _revalidate(): void;
     }
     export {};
 }

package/external-types/ember-source/types/stable/@ember/-internals/glimmer/lib/resolver.d.ts

@@ -2,6 +2,8 @@ declare module '@ember/-internals/glimmer/lib/resolver' {
     import type { InternalOwner } from "@ember/-internals/owner";
     import type { ClassicResolver, HelperDefinitionState, ModifierDefinitionState, ResolvedComponentDefinition } from "@glimmer/interfaces";
     import type { Nullable } from "@ember/-internals/utility-types";
+    export const BUILTIN_KEYWORD_HELPERS: Record<string, object>;
+    export const BUILTIN_HELPERS: Record<string, object>;
     const BUILTIN_KEYWORD_MODIFIERS: Record<string, ModifierDefinitionState>;
     export default class ResolverImpl implements ClassicResolver<InternalOwner> {
         private componentDefinitionCache;

package/external-types/ember-source/types/stable/@ember/-internals/glimmer/lib/utils/string.d.ts

@@ -4,19 +4,19 @@ declare module '@ember/-internals/glimmer/lib/utils/string' {
     */
     import type { SafeString as GlimmerSafeString } from "@glimmer/runtime";
     /**
-      A wrapper around a string that has been marked as safe ("trusted"). **When
+      A wrapper around a string that has been marked as "trusted". **When
       rendered in HTML, Ember will not perform any escaping.**
 
       Note:
 
       1. This does not *make* the string safe; it means that some code in your
-         application has *marked* it as safe using the `htmlSafe()` function.
+         application has *marked* it as trusted using the `trustHTML()` function.
 
-      2. The only public API for getting a `SafeString` is calling `htmlSafe()`. It
+      2. The only public API for getting a `TrustedHTML` is calling `trustHTML()`. It
          is *not* user-constructible.
 
       If a string contains user inputs or other untrusted data, you must sanitize
-      the string before using the `htmlSafe` method. Otherwise your code is
+      the string before using the `trustHTML` method. Otherwise your code is
       vulnerable to [Cross-Site Scripting][xss]. There are many open source
       sanitization libraries to choose from, both for front end and server-side
       sanitization.
@@ -24,19 +24,19 @@ declare module '@ember/-internals/glimmer/lib/utils/string' {
       [xss]: https://owasp.org/www-community/attacks/DOM_Based_XSS
 
       ```javascript
-      import { htmlSafe } from '@ember/template';
+      import { trustHTML } from '@ember/template';
 
       let someTrustedOrSanitizedString = "<div>Hello!</div>"
 
-      htmlSafe(someTrustedorSanitizedString);
+      trustHTML(someTrustedorSanitizedString);
       ```
 
       @for @ember/template
-      @class SafeString
-      @since 4.12.0
+      @class TrustedHTML
+      @since 6.7.0
       @public
      */
-    export class SafeString implements GlimmerSafeString {
+    export class TrustedHTML implements GlimmerSafeString {
         private readonly __string;
         constructor(string: string);
         /**
@@ -56,6 +56,41 @@ declare module '@ember/-internals/glimmer/lib/utils/string' {
          */
         toHTML(): string;
     }
+    /**
+      A wrapper around a string that has been marked as safe ("trusted"). **When
+      rendered in HTML, Ember will not perform any escaping.**
+
+      Note:
+
+      1. This does not *make* the string safe; it means that some code in your
+         application has *marked* it as safe using the `htmlSafe()` function.
+
+      2. The only public API for getting a `SafeString` is calling `htmlSafe()`. It
+         is *not* user-constructible.
+
+      If a string contains user inputs or other untrusted data, you must sanitize
+      the string before using the `htmlSafe` method. Otherwise your code is
+      vulnerable to [Cross-Site Scripting][xss]. There are many open source
+      sanitization libraries to choose from, both for front end and server-side
+      sanitization.
+
+      [xss]: https://owasp.org/www-community/attacks/DOM_Based_XSS
+
+      ```javascript
+      import { htmlSafe } from '@ember/template';
+
+      let someTrustedOrSanitizedString = "<div>Hello!</div>"
+
+      htmlSafe(someTrustedorSanitizedString);
+      ```
+
+      @for @ember/template
+      @class SafeString
+      @since 4.12.0
+      @public
+     */
+    export const SafeString: typeof TrustedHTML;
+    export type SafeString = TrustedHTML;
     /**
       Use this method to indicate that a string should be rendered as HTML
       when the string is used in a template. To say this another way,
@@ -85,7 +120,39 @@ declare module '@ember/-internals/glimmer/lib/utils/string' {
       @return {SafeString} A string that will not be HTML escaped by Handlebars.
       @public
     */
-    export function htmlSafe(str: string): SafeString;
+    export const htmlSafe: typeof trustHTML;
+    /**
+      Use this method to indicate that a string should be rendered as HTML
+      without escaping when the string is used in a template. To say this another way,
+      strings marked with `trustHTML` will not be HTML escaped.
+
+      A word of warning -   The `trustHTML` method does not make the string safe;
+      it only tells the framework to treat the string as if it is safe to render
+      as HTML - that we trust its contents to be safe. If a string contains user inputs or other untrusted
+      data, you must sanitize the string before using the `trustHTML` method.
+      Otherwise your code is vulnerable to
+      [Cross-Site Scripting](https://owasp.org/www-community/attacks/DOM_Based_XSS).
+      There are many open source sanitization libraries to choose from,
+      both for front end and server-side sanitization.
+
+      ```glimmer-js
+      import { trustHTML } from '@ember/template';
+
+      const someTrustedOrSanitizedString = "<div>Hello!</div>"
+
+      <template>
+        {{trustHTML someTrustedOrSanitizedString}}
+      </template>
+      ```
+
+      @method trustHTML
+      @for @ember/template
+      @param str {String} The string to treat as trusted.
+      @static
+      @return {TrustedHTML} A string that will not be HTML escaped by Handlebars.
+      @public
+     */
+    export function trustHTML(str: string): TrustedHTML;
     /**
       Detects if a string was decorated using `htmlSafe`.
 
@@ -105,5 +172,25 @@ declare module '@ember/-internals/glimmer/lib/utils/string' {
       @return {Boolean} `true` if the string was decorated with `htmlSafe`, `false` otherwise.
       @public
     */
-    export function isHTMLSafe(str: unknown): str is SafeString;
+    export const isHTMLSafe: typeof isTrustedHTML;
+    /**
+      Detects if a string was decorated using `trustHTML`.
+
+      ```javascript
+      import { trustHTML, isTrustedHTML } from '@ember/template';
+
+      let plainString = 'plain string';
+      let safeString = trustHTML('<div>someValue</div>');
+
+      isTrustedHTML(plainString); // false
+      isTrustedHTML(safeString);  // true
+      ```
+
+      @method isTrustedHTML
+      @for @ember/template
+      @static
+      @return {Boolean} `true` if the string was decorated with `htmlSafe`, `false` otherwise.
+      @public
+    */
+    export function isTrustedHTML(str: unknown): str is TrustedHTML;
 }

package/external-types/ember-source/types/stable/@ember/-internals/metal/index.d.ts

@@ -1,7 +1,7 @@
 declare module '@ember/-internals/metal' {
     export { default as computed, autoComputed, isComputed, ComputedProperty, type ComputedDecorator, type ComputedPropertyGetter, type ComputedPropertyObj, type ComputedPropertySetter, type ComputedPropertyCallback, } from "@ember/-internals/metal/lib/computed";
     export { getCachedValueFor } from "@ember/-internals/metal/lib/computed_cache";
-    export { default as alias } from "@ember/-internals/metal/lib/alias";
+    export { default as alias, type AliasDecorator } from "@ember/-internals/metal/lib/alias";
     export { deprecateProperty } from "@ember/-internals/metal/lib/deprecate_property";
     export { PROXY_CONTENT, _getPath, get, _getProp, type HasUnknownProperty, hasUnknownProperty, } from "@ember/-internals/metal/lib/property_get";
     export { set, _setProp, trySet } from "@ember/-internals/metal/lib/property_set";
@@ -22,5 +22,5 @@ declare module '@ember/-internals/metal' {
     export { tracked, TrackedDescriptor } from "@ember/-internals/metal/lib/tracked";
     export { cached } from "@ember/-internals/metal/lib/cached";
     export { createCache, getValue, isConst } from "@ember/-internals/metal/lib/cache";
-    export { NAMESPACES, NAMESPACES_BY_ID, addNamespace, findNamespace, findNamespaces, processNamespace, processAllNamespaces, removeNamespace, isSearchDisabled as isNamespaceSearchDisabled, setSearchDisabled as setNamespaceSearchDisabled, setUnprocessedMixins, } from "@ember/-internals/metal/lib/namespace_search";
+    export { NAMESPACES, NAMESPACES_BY_ID, addNamespace, findNamespace, findNamespaces, processNamespace, processAllNamespaces, removeNamespace, isSearchDisabled as isNamespaceSearchDisabled, setSearchDisabled as setNamespaceSearchDisabled, setUnprocessedMixins, type Namespace, } from "@ember/-internals/metal/lib/namespace_search";
 }

package/external-types/ember-source/types/stable/@ember/-internals/runtime/lib/mixins/container_proxy.d.ts

@@ -2,7 +2,7 @@ declare module '@ember/-internals/runtime/lib/mixins/container_proxy' {
     /**
     @module ember
     */
-    import type Container from "@ember/-internals/container/lib/container";
+    import type { Container } from "@ember/-internals/container";
     import Mixin from "@ember/object/mixin";
     import type { ContainerProxy } from "@ember/-internals/owner";
     /**

package/external-types/ember-source/types/stable/@ember/-internals/utils/lib/is_proxy.d.ts

@@ -1,5 +1,5 @@
 declare module '@ember/-internals/utils/lib/is_proxy' {
-    import type ProxyMixin from "@ember/-internals/runtime/lib/mixins/-proxy";
+    import type { _ProxyMixin as ProxyMixin } from "@ember/-internals/runtime";
     export function isProxy(value: unknown): value is ProxyMixin<unknown>;
     export function setProxy(object: ProxyMixin<unknown>): void;
 }

package/external-types/ember-source/types/stable/@ember/-internals/views/index.d.ts

@@ -3,11 +3,7 @@ declare module '@ember/-internals/views' {
     export { default as EventDispatcher } from "@ember/-internals/views/lib/system/event_dispatcher";
     export { default as ComponentLookup } from "@ember/-internals/views/lib/component_lookup";
     export { default as CoreView } from "@ember/-internals/views/lib/views/core_view";
-    export { default as ClassNamesSupport } from "@ember/-internals/views/lib/mixins/class_names_support";
-    export { default as ChildViewsSupport } from "@ember/-internals/views/lib/mixins/child_views_support";
-    export { default as ViewStateSupport } from "@ember/-internals/views/lib/mixins/view_state_support";
-    export { default as ViewMixin } from "@ember/-internals/views/lib/mixins/view_support";
     export { default as ActionSupport } from "@ember/-internals/views/lib/mixins/action_support";
     export { MUTABLE_CELL } from "@ember/-internals/views/lib/compat/attrs";
-    export { default as ActionManager } from "@ember/-internals/views/lib/system/action_manager";
+    export { default as ViewStates } from "@ember/-internals/views/lib/views/states";
 }

package/external-types/ember-source/types/stable/@ember/-internals/views/lib/component_lookup.d.ts

@@ -1,9 +1,8 @@
 declare module '@ember/-internals/views/lib/component_lookup' {
     import type { InternalOwner, RegisterOptions } from "@ember/-internals/owner";
     import EmberObject from "@ember/object";
-    const _default: Readonly<typeof EmberObject> & (new (owner?: import("@ember/-internals/owner").default | undefined) => EmberObject) & {
+    export default class ComponentLookup extends EmberObject {
         componentFor(name: string, owner: InternalOwner): import("@ember/-internals/owner").FactoryManager<object> | undefined;
         layoutFor(name: string, owner: InternalOwner, options: RegisterOptions): unknown;
-    };
-    export default _default;
+    }
 }

package/external-types/ember-source/types/stable/@ember/-internals/views/lib/system/utils.d.ts

@@ -1,5 +1,5 @@
 declare module '@ember/-internals/views/lib/system/utils' {
-    import type { View } from "@ember/-internals/glimmer/lib/renderer";
+    import type { View } from "@ember/-internals/glimmer";
     import type { InternalOwner } from "@ember/-internals/owner";
     import type { Dict } from "@glimmer/interfaces";
     import type { Nullable } from "@ember/-internals/utility-types";
@@ -80,15 +80,5 @@ declare module '@ember/-internals/views/lib/system/utils' {
       @param {Ember.View} view
     */
     export function getViewBoundingClientRect(view: View): ClientRect | DOMRect;
-    /**
-      Determines if the element matches the specified selector.
-
-      @private
-      @method matches
-      @param {DOMElement} el
-      @param {String} selector
-    */
-    export const elMatches: typeof Element.prototype.matches | undefined;
-    export function matches(el: Element, selector: string): boolean;
     export function contains(a: Node, b: Node): boolean;
 }

package/external-types/ember-source/types/stable/@ember/-internals/views/lib/views/core_view.d.ts

@@ -1,5 +1,5 @@
 declare module '@ember/-internals/views/lib/views/core_view' {
-    import type { Renderer, View } from "@ember/-internals/glimmer/lib/renderer";
+    import type { Renderer, View } from "@ember/-internals/glimmer";
     import { ActionHandler } from "@ember/-internals/runtime";
     import Evented from "@ember/object/evented";
     import type { ViewState } from "@ember/-internals/views/lib/views/states";

package/external-types/ember-source/types/stable/@ember/application/instance.d.ts

@@ -5,9 +5,8 @@ declare module '@ember/application/instance' {
     import EngineInstance from "@ember/engine/instance";
     import type { BootOptions } from "@ember/engine/instance";
     import type Application from "@ember/application";
-    import type { BootEnvironment } from "@ember/-internals/glimmer";
+    import type { BootEnvironment, Component } from "@ember/-internals/glimmer";
     import Router from "@ember/routing/router";
-    import type { ViewMixin } from "@ember/-internals/views";
     import { EventDispatcher } from "@ember/-internals/views";
     import type { Registry } from "@ember/-internals/container";
     import type { SimpleElement } from "@simple-dom/interface";
@@ -84,7 +83,7 @@ declare module '@ember/application/instance' {
           @deprecated
           @private
         */
-        didCreateRootView(view: ViewMixin): void;
+        didCreateRootView(view: Component): void;
         /**
           Tells the router to start routing. The router will ask the location for the
           current URL of the page to determine the initial URL to start routing to.

package/external-types/ember-source/types/stable/@ember/application/namespace.d.ts

@@ -2,14 +2,14 @@ declare module '@ember/application/namespace' {
     /**
     @module @ember/application/namespace
     */
-    import { findNamespace, processAllNamespaces } from "@ember/-internals/metal";
+    import { findNamespace, processAllNamespaces, type Namespace as MetalNamespace } from "@ember/-internals/metal";
     import EmberObject from "@ember/object";
     /**
       A Namespace is an object usually used to contain other objects or methods
       such as an application or framework. Create a namespace anytime you want
       to define one of these new containers.
 
-      # Example Usage
+      ## Example Usage
 
       ```javascript
       MyFramework = Ember.Namespace.create({
@@ -22,9 +22,9 @@ declare module '@ember/application/namespace' {
       @public
     */
     class Namespace extends EmberObject {
-        static NAMESPACES: import("@ember/-internals/metal/lib/namespace_search").Namespace[];
+        static NAMESPACES: MetalNamespace[];
         static NAMESPACES_BY_ID: {
-            [name: string]: import("@ember/-internals/metal/lib/namespace_search").Namespace;
+            [name: string]: MetalNamespace;
         };
         static processAll: typeof processAllNamespaces;
         static byName: typeof findNamespace;

package/external-types/ember-source/types/stable/@ember/object/evented.d.ts

@@ -11,12 +11,12 @@ declare module '@ember/object/evented' {
       import EmberObject from '@ember/object';
       import Evented from '@ember/object/evented';
 
-      export default EmberObject.extend(Evented, {
+      export default class Person extends EmberObject.extend(Evented) {
         greet() {
           // ...
           this.trigger('greet');
         }
-      });
+      }
       ```
 
       ```javascript