@discourse/types 0.0.1 → 2026.1.0-61b723a

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

@@ -0,0 +1,97 @@
+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 { Nullable } from "@ember/-internals/utility-types";
+    import type { Reference } from "@glimmer/reference";
+    import type { CurriedValue } from "@glimmer/runtime";
+    import { clientBuilder } from "@glimmer/runtime";
+    import type { SimpleDocument, SimpleElement, SimpleNode } from "@simple-dom/interface";
+    import RSVP from "rsvp";
+    import type Component 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";
+    import OutletView from "@ember/-internals/glimmer/lib/views/outlet";
+    export type IBuilder = (env: Environment, cursor: Cursor) => TreeBuilder;
+    export interface View {
+        parentView: Nullable<View>;
+        renderer: Renderer;
+        tagName: string | null;
+        elementId: string | null;
+        isDestroying: boolean;
+        isDestroyed: boolean;
+        [BOUNDS]: Bounds | null;
+    }
+    export class DynamicScope implements GlimmerDynamicScope {
+        view: View | null;
+        outletState: Reference<OutletState | undefined>;
+        constructor(view: View | null, outletState: Reference<OutletState | undefined>);
+        child(): DynamicScope;
+        get(key: "outletState"): Reference<OutletState | undefined>;
+        set(key: "outletState", value: Reference<OutletState | undefined>): Reference<OutletState | undefined>;
+    }
+    class RootState {
+        root: Component | OutletView;
+        id: string;
+        result: RenderResult | 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);
+        isFor(possibleRoot: unknown): boolean;
+        destroy(): void;
+    }
+    export function _resetRenderers(): void;
+    export function renderSettled(): RSVP.Promise<void>;
+    interface ViewRegistry {
+        [viewId: string]: unknown;
+    }
+    export class Renderer {
+        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: {
+            isInteractive: boolean;
+            hasDOM: boolean;
+        }, rootTemplate: TemplateFactory, viewRegistry: ViewRegistry, builder?: typeof clientBuilder);
+        get debugRenderTree(): DebugRenderTree;
+        appendOutletView(view: OutletView, target: SimpleElement): void;
+        appendTo(view: Component, target: SimpleElement): void;
+        _appendDefinition(root: OutletView | Component, definition: CurriedValue, target: SimpleElement): void;
+        rerender(): void;
+        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): {
+            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

@@ -0,0 +1,17 @@
+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";
+    const BUILTIN_KEYWORD_MODIFIERS: Record<string, ModifierDefinitionState>;
+    export default class ResolverImpl implements ClassicResolver<InternalOwner> {
+        private componentDefinitionCache;
+        lookupPartial(): null;
+        lookupHelper(name: string, owner: InternalOwner): Nullable<HelperDefinitionState>;
+        lookupBuiltInHelper(name: string): HelperDefinitionState | null;
+        lookupModifier(name: string, owner: InternalOwner): Nullable<ModifierDefinitionState>;
+        lookupBuiltInModifier<K extends keyof typeof BUILTIN_KEYWORD_MODIFIERS>(name: K): (typeof BUILTIN_KEYWORD_MODIFIERS)[K];
+        lookupBuiltInModifier(name: string): null;
+        lookupComponent(name: string, owner: InternalOwner): ResolvedComponentDefinition | null;
+    }
+    export {};
+}

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

@@ -0,0 +1,5 @@
+declare module '@ember/-internals/glimmer/lib/setup-registry' {
+    import type { Registry } from "@ember/-internals/container";
+    export function setupApplicationRegistry(registry: Registry): void;
+    export function setupEngineRegistry(registry: Registry): void;
+}

package/external-types/ember-source/types/stable/@ember/-internals/glimmer/lib/syntax/in-element.d.ts

@@ -0,0 +1,47 @@
+declare module '@ember/-internals/glimmer/lib/syntax/in-element' {
+    /**
+     @module ember
+     */
+    /**
+     The `in-element` helper renders its block content outside of the regular flow,
+     into a DOM element given by its `destinationElement` positional argument.
+
+     Common use cases - often referred to as "portals" or "wormholes" - are rendering
+     dropdowns, modals or tooltips close to the root of the page to bypass CSS overflow
+     rules, or to render content to parts of the page that are outside of the control
+     of the Ember app itself (e.g. embedded into a static or server rendered HTML page).
+
+     ```handlebars
+     {{#in-element this.destinationElement}}
+       <div>Some content</div>
+     {{/in-element}}
+     ```
+
+     ### Arguments
+
+     `{{in-element}}` requires a single positional argument:
+
+     - `destinationElement` -- the DOM element to render into. It must exist at the time
+     of rendering.
+
+     It also supports an optional named argument:
+
+     - `insertBefore` -- by default the DOM element's content is replaced when used as
+     `destinationElement`. Passing `null` to `insertBefore` changes the behaviour to
+     append the block content to the end of any existing content. Any other value than
+     `null` is currently not supported.
+
+         For example:
+
+         ```handlebars
+         {{#in-element this.destinationElement insertBefore=null}}
+           <div>Some content</div>
+         {{/in-element}}
+         ```
+
+     @method in-element
+     @for Ember.Templates.helpers
+     @public
+     */
+    export {};
+}

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

@@ -0,0 +1,55 @@
+declare module '@ember/-internals/glimmer/lib/syntax/let' {
+    /**
+    @module ember
+    */
+    /**
+        The `let` helper receives one or more positional arguments and yields
+        them out as block params.
+
+        This allows the developer to introduce shorter names for certain computations
+        in the template.
+
+        This is especially useful if you are passing properties to a component
+        that receives a lot of options and you want to clean up the invocation.
+
+        For the following example, the template receives a `post` object with
+        `content` and `title` properties.
+
+        We are going to call the `my-post` component, passing a title which is
+        the title of the post suffixed with the name of the blog, the content
+        of the post, and a series of options defined in-place.
+
+        ```handlebars
+        {{#let
+            (concat post.title ' | The Ember.js Blog')
+            post.content
+            (hash
+              theme="high-contrast"
+              enableComments=true
+            )
+            as |title content options|
+        }}
+          <MyPost @title={{title}} @content={{content}} @options={{options}} />
+        {{/let}}
+      ```
+     or
+      ```handlebars
+        {{#let
+            (concat post.title ' | The Ember.js Blog')
+            post.content
+            (hash
+              theme="high-contrast"
+              enableComments=true
+            )
+            as |title content options|
+        }}
+          {{my-post title=title content=content options=options}}
+        {{/let}}
+      ```
+
+      @method let
+      @for Ember.Templates.helpers
+      @public
+    */
+    export {};
+}

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

@@ -0,0 +1,43 @@
+declare module '@ember/-internals/glimmer/lib/syntax/mount' {
+    /**
+      The `{{mount}}` helper lets you embed a routeless engine in a template.
+      Mounting an engine will cause an instance to be booted and its `application`
+      template to be rendered.
+
+      For example, the following template mounts the `ember-chat` engine:
+
+      ```handlebars
+      {{! application.hbs }}
+      {{mount "ember-chat"}}
+      ```
+
+      Additionally, you can also pass in a `model` argument that will be
+      set as the engines model. This can be an existing object:
+
+      ```
+      <div>
+        {{mount 'admin' model=userSettings}}
+      </div>
+      ```
+
+      Or an inline `hash`, and you can even pass components:
+
+      ```
+      <div>
+        <h1>Application template!</h1>
+        {{mount 'admin' model=(hash
+            title='Secret Admin'
+            signInButton=(component 'sign-in-button')
+        )}}
+      </div>
+      ```
+
+      @method mount
+      @param {String} name Name of the engine to mount.
+      @param {Object} [model] Object that will be set as
+                              the model of the engine.
+      @for Ember.Templates.helpers
+      @public
+    */
+    export const mountHelper: object;
+}

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

@@ -0,0 +1,27 @@
+declare module '@ember/-internals/glimmer/lib/syntax/outlet' {
+    /**
+      The `{{outlet}}` helper lets you specify where a child route will render in
+      your template. An important use of the `{{outlet}}` helper is in your
+      application's `application.hbs` file:
+
+      ```app/templates/application.hbs
+      <MyHeader />
+
+      <div class="my-dynamic-content">
+        <!-- this content will change based on the current route, which depends on the current URL -->
+        {{outlet}}
+      </div>
+
+      <MyFooter />
+      ```
+
+      See the [routing guide](https://guides.emberjs.com/release/routing/rendering-a-template/) for more
+      information on how your `route` interacts with the `{{outlet}}` helper.
+      Note: Your content __will not render__ if there isn't an `{{outlet}}` for it.
+
+      @method outlet
+      @for Ember.Templates.helpers
+      @public
+    */
+    export const outletHelper: object;
+}

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

@@ -0,0 +1,5 @@
+declare module '@ember/-internals/glimmer/lib/syntax/utils' {
+    import type { Core } from "@glimmer/interfaces";
+    import type { Nullable } from "@ember/-internals/utility-types";
+    export function hashToArgs(hash: Nullable<Core.Hash>): Nullable<Core.Hash>;
+}

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

@@ -0,0 +1,6 @@
+declare module '@ember/-internals/glimmer/lib/template' {
+    import type { SerializedTemplateWithLazyBlock, Template, TemplateFactory } from "@glimmer/interfaces";
+    export type StaticTemplate = SerializedTemplateWithLazyBlock;
+    export type OwnedTemplate = Template;
+    export function isTemplateFactory(template: Template | TemplateFactory): template is TemplateFactory;
+}

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

@@ -0,0 +1,11 @@
+declare module '@ember/-internals/glimmer/lib/template_registry' {
+    import type { TemplateFactory } from "@glimmer/interfaces";
+    export interface TemplatesRegistry {
+        [name: string]: TemplateFactory;
+    }
+    export function setTemplates(templates: TemplatesRegistry): void;
+    export function getTemplates(): TemplatesRegistry;
+    export function getTemplate(name: string): TemplateFactory | void;
+    export function hasTemplate(name: string): boolean;
+    export function setTemplate(name: string, template: TemplateFactory): TemplateFactory;
+}

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

@@ -0,0 +1,4 @@
+declare module '@ember/-internals/glimmer/lib/templates/empty' {
+    const _default: import("@glimmer/interfaces").TemplateFactory;
+    export default _default;
+}

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

@@ -0,0 +1,4 @@
+declare module '@ember/-internals/glimmer/lib/templates/input' {
+    const _default: import("@glimmer/interfaces").TemplateFactory;
+    export default _default;
+}

package/external-types/ember-source/types/stable/@ember/-internals/glimmer/lib/templates/link-to.d.ts

@@ -0,0 +1,4 @@
+declare module '@ember/-internals/glimmer/lib/templates/link-to' {
+    const _default: import("@glimmer/interfaces").TemplateFactory;
+    export default _default;
+}

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

@@ -0,0 +1,4 @@
+declare module '@ember/-internals/glimmer/lib/templates/outlet' {
+    const _default: import("@glimmer/interfaces").TemplateFactory;
+    export default _default;
+}

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

@@ -0,0 +1,4 @@
+declare module '@ember/-internals/glimmer/lib/templates/root' {
+    const _default: import("@glimmer/interfaces").TemplateFactory;
+    export default _default;
+}

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

@@ -0,0 +1,4 @@
+declare module '@ember/-internals/glimmer/lib/templates/textarea' {
+    const _default: import("@glimmer/interfaces").TemplateFactory;
+    export default _default;
+}

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

@@ -0,0 +1,19 @@
+declare module '@ember/-internals/glimmer/lib/utils/bindings' {
+    import type { ElementOperations } from "@glimmer/interfaces";
+    import type { Reference } from "@glimmer/reference";
+    import type Component from "@ember/-internals/glimmer/lib/component";
+    export function parseAttributeBinding(microsyntax: string): [string, string, boolean];
+    export function installAttributeBinding(
+      component: Component,
+      rootRef: Reference<Component>,
+      parsed: [string, string, boolean],
+      operations: ElementOperations
+    ): void;
+    export function createClassNameBindingRef(
+      rootRef: Reference<Component>,
+      microsyntax: string,
+      operations: ElementOperations
+    ): void;
+    export function createSimpleClassNameBindingRef(inner: Reference, path?: string): Reference<string | null>;
+    export function createColonClassNameBindingRef(inner: Reference, truthy: string, falsy: string | undefined): Reference<string | undefined>;
+}

package/external-types/ember-source/types/stable/@ember/-internals/glimmer/lib/utils/curly-component-state-bucket.d.ts

@@ -0,0 +1,31 @@
+declare module '@ember/-internals/glimmer/lib/utils/curly-component-state-bucket' {
+    import type { CapturedNamedArguments } from "@glimmer/interfaces";
+    import type { Reference } from "@glimmer/reference";
+    import type { Revision, Tag } from "@glimmer/validator";
+    import type Component from "@ember/-internals/glimmer/lib/component";
+    type Finalizer = () => void;
+    /**
+      @module ember
+    */
+    /**
+      Represents the internal state of the component.
+
+      @class ComponentStateBucket
+      @private
+    */
+    export default class ComponentStateBucket {
+        component: Component;
+        args: CapturedNamedArguments | null;
+        argsTag: Tag;
+        finalizer: Finalizer;
+        hasWrappedElement: boolean;
+        isInteractive: boolean;
+        classRef: Reference | null;
+        rootRef: Reference<Component>;
+        argsRevision: Revision;
+        constructor(component: Component, args: CapturedNamedArguments | null, argsTag: Tag, finalizer: Finalizer, hasWrappedElement: boolean, isInteractive: boolean);
+        willDestroy(): void;
+        finalize(): void;
+    }
+    export {};
+}

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

@@ -0,0 +1,4 @@
+declare module '@ember/-internals/glimmer/lib/utils/debug-render-message' {
+    let debugRenderMessage: undefined | ((renderingStack: string) => string);
+    export default debugRenderMessage;
+}

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

@@ -0,0 +1,5 @@
+declare module '@ember/-internals/glimmer/lib/utils/iterator' {
+    import type { Nullable } from "@ember/-internals/utility-types";
+    import type { IteratorDelegate } from "@glimmer/reference";
+    export default function toIterator(iterable: unknown): Nullable<IteratorDelegate>;
+}

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

@@ -0,0 +1,17 @@
+declare module '@ember/-internals/glimmer/lib/utils/managers' {
+    import type { InternalOwner } from "@ember/-internals/owner";
+    import type { ComponentManager } from "@glimmer/interfaces";
+    export { modifierCapabilities, componentCapabilities } from "@glimmer/manager";
+    /**
+       Associate a class with a component manager (an object that is responsible for
+       coordinating the lifecycle events that occurs when invoking, rendering and
+       re-rendering a component).
+
+       @method setComponentManager
+       @param {Function} factory a function to create the owner for an object
+       @param {Object} obj the object to associate with the componetn manager
+       @return {Object} the same object passed in
+       @public
+      */
+    export function setComponentManager<T extends object>(manager: (owner: InternalOwner) => ComponentManager<unknown>, obj: T): T;
+}

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

@@ -0,0 +1,46 @@
+declare module '@ember/-internals/glimmer/lib/utils/outlet' {
+    import type { InternalOwner } from "@ember/-internals/owner";
+    import type { Template } from "@glimmer/interfaces";
+    export interface RenderState {
+        /**
+         * This is usually inherited from the parent (all the way up to the app
+         * instance). However, engines uses this to swap out the owner when crossing
+         * a mount point.
+         */
+        owner: InternalOwner;
+        /**
+         * The name of the route/template
+         */
+        name: string;
+        /**
+         * The controller (the self of the outlet component)
+         */
+        controller: unknown;
+        /**
+         * The model (the resolved value of the model hook)
+         */
+        model: unknown;
+        /**
+         * The route's template – this is either a Template or a component, and it
+         * gets normalized during the render process.
+         */
+        template: Template | object | undefined;
+    }
+    export interface OutletState {
+        /**
+         * Represents what was rendered into this outlet.
+         */
+        render: RenderState | undefined;
+        /**
+         * Represents what, if any, should be rendered into the next {{outlet}} found
+         * at this level.
+         *
+         * This used to be a dictionary of children outlets, including the {{outlet}}
+         * "main" outlet any {{outlet "named"}} named outlets. Since named outlets
+         * are not a thing anymore, this can now just be a single`child`.
+         */
+        outlets: {
+            main: OutletState | undefined;
+        };
+    }
+}

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

@@ -0,0 +1,4 @@
+declare module '@ember/-internals/glimmer/lib/utils/process-args' {
+    import type { CapturedNamedArguments } from "@glimmer/interfaces";
+    export function processComponentArgs(namedArgs: CapturedNamedArguments): any;
+}

package/external-types/ember-source/types/stable/@ember/-internals/glimmer/lib/utils/serialization-first-node-helpers.d.ts

@@ -0,0 +1,3 @@
+declare module '@ember/-internals/glimmer/lib/utils/serialization-first-node-helpers' {
+    export { isSerializationFirstNode } from "@glimmer/runtime";
+}

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

@@ -0,0 +1,109 @@
+declare module '@ember/-internals/glimmer/lib/utils/string' {
+    /**
+    @module @ember/template
+    */
+    import type { SafeString as GlimmerSafeString } from "@glimmer/runtime";
+    /**
+      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 class SafeString implements GlimmerSafeString {
+        private readonly __string;
+        constructor(string: string);
+        /**
+          Get the string back to use as a string.
+      
+          @public
+          @method toString
+          @returns {String} The string marked as trusted
+         */
+        toString(): string;
+        /**
+          Get the wrapped string as HTML to use without escaping.
+      
+          @public
+          @method toHTML
+          @returns {String} the trusted string, without any escaping applied
+         */
+        toHTML(): string;
+    }
+    /**
+      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,
+      strings marked with `htmlSafe` will not be HTML escaped.
+
+      A word of warning -   The `htmlSafe` 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. 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](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.
+
+      ```javascript
+      import { htmlSafe } from '@ember/template';
+
+      const someTrustedOrSanitizedString = "<div>Hello!</div>"
+
+      htmlSafe(someTrustedorSanitizedString)
+      ```
+
+      @method htmlSafe
+      @for @ember/template
+      @param str {String} The string to treat as trusted.
+      @static
+      @return {SafeString} A string that will not be HTML escaped by Handlebars.
+      @public
+    */
+    export function htmlSafe(str: string): SafeString;
+    /**
+      Detects if a string was decorated using `htmlSafe`.
+
+      ```javascript
+      import { htmlSafe, isHTMLSafe } from '@ember/template';
+
+      let plainString = 'plain string';
+      let safeString = htmlSafe('<div>someValue</div>');
+
+      isHTMLSafe(plainString); // false
+      isHTMLSafe(safeString);  // true
+      ```
+
+      @method isHTMLSafe
+      @for @ember/template
+      @static
+      @return {Boolean} `true` if the string was decorated with `htmlSafe`, `false` otherwise.
+      @public
+    */
+    export function isHTMLSafe(str: unknown): str is SafeString;
+}

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

@@ -0,0 +1,3 @@
+declare module '@ember/-internals/glimmer/lib/utils/to-bool' {
+    export default function toBool(predicate: unknown): boolean;
+}

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

@@ -0,0 +1,34 @@
+declare module '@ember/-internals/glimmer/lib/views/outlet' {
+    import { type InternalOwner } from "@ember/-internals/owner";
+    import type { BootOptions } from "@ember/engine/instance";
+    import type { Template, TemplateFactory } from "@glimmer/interfaces";
+    import type { SimpleElement } from "@simple-dom/interface";
+    import type { OutletDefinitionState } from "@ember/-internals/glimmer/lib/component-managers/outlet";
+    import type { OutletState } from "@ember/-internals/glimmer/lib/utils/outlet";
+    export interface BootEnvironment {
+        hasDOM: boolean;
+        isInteractive: boolean;
+        _renderMode?: string;
+        options: BootOptions;
+    }
+    export default class OutletView {
+        private _environment;
+        owner: InternalOwner;
+        template: Template;
+        namespace: any;
+        static extend(injections: any): typeof OutletView;
+        static reopenClass(injections: any): void;
+        static create(options: {
+            environment: BootEnvironment;
+            application: InternalOwner;
+            template: TemplateFactory;
+        }): OutletView;
+        private ref;
+        state: OutletDefinitionState;
+        constructor(_environment: BootEnvironment, owner: InternalOwner, template: Template, namespace: any);
+        appendTo(selector: string | SimpleElement): void;
+        rerender(): void;
+        setOutletState(state: OutletState): void;
+        destroy(): void;
+    }
+}

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

@@ -0,0 +1,3 @@
+declare module '@ember/-internals/meta' {
+    export { counters, Meta, meta, type MetaCounters, peekMeta, setMeta, UNDEFINED } from "@ember/-internals/meta/lib/meta";
+}