ember-source 4.10.0-beta.2 → 4.11.0-alpha.2

package/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.d.ts' {
+  import type { CapturedNamedArguments } from '@glimmer/interfaces';
+  import type { Reference } from '@glimmer/reference';
+  import type { Revision, Tag } from '@glimmer/validator';
+  import type Component from '../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/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.d.ts' {
+  let debugRenderMessage: undefined | ((renderingStack: string) => string);
+  export default debugRenderMessage;
+}

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

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

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

@@ -0,0 +1,19 @@
+declare module '@ember/-internals/glimmer/lib/utils/managers.d.ts' {
+  import type { InternalOwner } from '@ember/-internals/owner';
+  import type { ComponentManager } from '@glimmer/interfaces';
+  import { componentCapabilities as glimmerComponentCapabilities, modifierCapabilities as glimmerModifierCapabilities } 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;
+  export let componentCapabilities: typeof glimmerComponentCapabilities;
+  export let modifierCapabilities: typeof glimmerModifierCapabilities;
+}

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

@@ -0,0 +1,51 @@
+declare module '@ember/-internals/glimmer/lib/utils/outlet.d.ts' {
+  import type { InternalOwner } from '@ember/-internals/owner';
+  import type { Template, TemplateFactory } from '@glimmer/interfaces';
+  export interface RenderState {
+      /**
+       * Not sure why this is here, we use the owner of the template for lookups.
+       *
+       * Maybe this is for the render helper?
+       */
+      owner: InternalOwner;
+      /**
+       * The name of the parent outlet state.
+       */
+      into: string | undefined;
+      outlet: string;
+      /**
+       * 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;
+      /**
+       * template (the layout of the outlet component)
+       */
+      template: Template | TemplateFactory | undefined;
+  }
+  export interface Outlets {
+      [name: string]: OutletState | undefined;
+  }
+  export interface OutletState {
+      /**
+       * Nested outlet connections.
+       */
+      outlets: Outlets;
+      /**
+       * Represents what was rendered into this outlet.
+       */
+      render: RenderState | undefined;
+      /**
+       * Has to do with render helper and orphan outlets.
+       * Whether outlet state was rendered.
+       */
+      wasUsed?: boolean;
+  }
+}

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

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

package/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.d.ts' {
+  export { isSerializationFirstNode } from '@glimmer/runtime';
+}

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

@@ -0,0 +1,61 @@
+declare module '@ember/-internals/glimmer/lib/utils/string.d.ts' {
+  /**
+  @module @ember/template
+  */
+  export class SafeString {
+      string: string;
+      constructor(string: string);
+      toString(): string;
+      toHTML(): string;
+  }
+  export function escapeExpression(string: any): 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
+    @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';
+
+    var plainString = 'plain string',
+        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: any | null | undefined): str is SafeString;
+}

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

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

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

@@ -0,0 +1,34 @@
+declare module '@ember/-internals/glimmer/lib/views/outlet.d.ts' {
+  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 '../component-managers/outlet';
+  import type { OutletState } from '../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/types/stable/@ember/-internals/meta/index.d.ts

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

package/types/stable/@ember/-internals/meta/lib/meta.d.ts

@@ -0,0 +1,174 @@
+declare module '@ember/-internals/meta/lib/meta.d.ts' {
+  import type { ComputedProperty } from '@ember/-internals/metal';
+  import type { Revision, UpdatableTag } from '@glimmer/validator';
+  type ObjMap<T> = {
+      [key: string]: T;
+  };
+  export interface MetaCounters {
+      peekCalls: number;
+      peekPrototypeWalks: number;
+      setCalls: number;
+      deleteCalls: number;
+      metaCalls: number;
+      metaInstantiated: number;
+      matchingListenersCalls: number;
+      observerEventsCalls: number;
+      addToListenersCalls: number;
+      removeFromListenersCalls: number;
+      removeAllListenersCalls: number;
+      listenersInherited: number;
+      listenersFlattened: number;
+      parentListenersUsed: number;
+      flattenedListenersCalls: number;
+      reopensAfterFlatten: number;
+      readableLazyChainsCalls: number;
+      writableLazyChainsCalls: number;
+  }
+  let counters: MetaCounters | undefined;
+  /**
+  @module ember
+  */
+  export const UNDEFINED: symbol;
+  const enum ListenerKind {
+      ADD = 0,
+      ONCE = 1,
+      REMOVE = 2
+  }
+  interface StringListener {
+      event: string;
+      target: null;
+      method: string;
+      kind: ListenerKind.ADD | ListenerKind.ONCE | ListenerKind.REMOVE;
+      sync: boolean;
+  }
+  interface FunctionListener {
+      event: string;
+      target: object | null;
+      method: Function;
+      kind: ListenerKind.ADD | ListenerKind.ONCE | ListenerKind.REMOVE;
+      sync: boolean;
+  }
+  type Listener = StringListener | FunctionListener;
+  export class Meta {
+      /** @internal */
+      _descriptors: Map<string, any> | undefined;
+      /** @internal */
+      _mixins: any | undefined;
+      /** @internal */
+      _isInit: boolean;
+      /** @internal */
+      _lazyChains: ObjMap<[UpdatableTag, unknown][]> | undefined;
+      /** @internal */
+      _values: ObjMap<unknown> | undefined;
+      /** @internal */
+      _revisions: ObjMap<Revision> | undefined;
+      /** @internal */
+      source: object;
+      /** @internal */
+      proto: object | undefined;
+      /** @internal */
+      _parent: Meta | undefined | null;
+      /** @internal */
+      _listeners: Listener[] | undefined;
+      /** @internal */
+      _listenersVersion: number;
+      /** @internal */
+      _inheritedEnd: number;
+      /** @internal */
+      _flattenedVersion: number;
+      /** @internal */
+      constructor(obj: object);
+      /** @internal */
+      get parent(): Meta | null;
+      setInitializing(): void;
+      /** @internal */
+      unsetInitializing(): void;
+      /** @internal */
+      isInitializing(): boolean;
+      /** @internal */
+      isPrototypeMeta(obj: object): boolean;
+      /** @internal */
+      _getOrCreateOwnMap(key: '_values' | '_revisions' | '_lazyChains'): any;
+      /** @internal */
+      _getOrCreateOwnSet(key: '_mixins'): any;
+      /** @internal */
+      _findInheritedMap(key: keyof Meta, subkey: string): any | undefined;
+      /** @internal */
+      _hasInInheritedSet(key: keyof Meta, value: any): boolean;
+      /** @internal */
+      valueFor(key: string): unknown;
+      /** @internal */
+      setValueFor(key: string, value: unknown): void;
+      /** @internal */
+      revisionFor(key: string): Revision | undefined;
+      /** @internal */
+      setRevisionFor(key: string, revision: Revision | undefined): void;
+      /** @internal */
+      writableLazyChainsFor(key: string): [UpdatableTag, unknown][];
+      /** @internal */
+      readableLazyChainsFor(key: string): [UpdatableTag, unknown][] | undefined;
+      /** @internal */
+      addMixin(mixin: any): void;
+      /** @internal */
+      hasMixin(mixin: any): boolean;
+      /** @internal */
+      forEachMixins(fn: Function): void;
+      /** @internal */
+      writeDescriptors(subkey: string, value: any): void;
+      /** @internal */
+      peekDescriptors(subkey: string): any;
+      /** @internal */
+      removeDescriptors(subkey: string): void;
+      /** @internal */
+      forEachDescriptors(fn: (key: string, value: ComputedProperty) => void): void;
+      /** @internal */
+      addToListeners(eventName: string, target: object | null, method: Function | PropertyKey, once: boolean, sync: boolean): void;
+      /** @internal */
+      removeFromListeners(eventName: string, target: object | null, method: Function | string): void;
+      private pushListener;
+      private writableListeners;
+      /**
+        Flattening is based on a global revision counter. If the revision has
+        bumped it means that somewhere in a class inheritance chain something has
+        changed, so we need to reflatten everything. This can only happen if:
+    
+        1. A meta has been flattened (listener has been called)
+        2. The meta is a prototype meta with children who have inherited its
+           listeners
+        3. A new listener is subsequently added to the meta (e.g. via `.reopen()`)
+    
+        This is a very rare occurrence, so while the counter is global it shouldn't
+        be updated very often in practice.
+      */
+      private flattenedListeners;
+      /** @internal */
+      matchingListeners(eventName: string): (string | boolean | object | null)[] | undefined;
+      /** @internal */
+      observerEvents(): any[] | undefined;
+  }
+  export function setMeta(obj: object, meta: Meta): void;
+  export function peekMeta(obj: object): Meta | null;
+  /**
+    Retrieves the meta hash for an object. If `writable` is true ensures the
+    hash is writable for this object as well.
+
+    The meta object contains information about computed property descriptors as
+    well as any watched properties and other information. You generally will
+    not access this information directly but instead work with higher level
+    methods that manipulate this hash indirectly.
+
+    @method meta
+    @for Ember
+    @private
+
+    @param {Object} obj The object to retrieve meta for
+    @param {Boolean} [writable=true] Pass `false` if you do not intend to modify
+      the meta hash, allowing the method to avoid making an unnecessary copy.
+    @return {Object} the meta hash for an object
+  */
+  export const meta: {
+      (obj: object): Meta;
+      _counters?: MetaCounters;
+  };
+  export { counters };
+}

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

@@ -0,0 +1,26 @@
+declare module '@ember/-internals/metal' {
+  export { default as computed, autoComputed, isComputed, ComputedProperty, ComputedDecorator, ComputedPropertyGetter, ComputedPropertyObj, ComputedPropertySetter, ComputedPropertyCallback, } from './lib/computed';
+  export { getCachedValueFor } from './lib/computed_cache';
+  export { default as alias } from './lib/alias';
+  export { deprecateProperty } from './lib/deprecate_property';
+  export { PROXY_CONTENT, _getPath, get, _getProp, HasUnknownProperty, hasUnknownProperty, } from './lib/property_get';
+  export { set, _setProp, trySet } from './lib/property_set';
+  export { objectAt, replace, replaceInNativeArray, addArrayObserver, removeArrayObserver, } from './lib/array';
+  export { arrayContentWillChange, arrayContentDidChange } from './lib/array_events';
+  export { eachProxyArrayWillChange, eachProxyArrayDidChange } from './lib/each_proxy_events';
+  export { addListener, hasListeners, on, removeListener, sendEvent } from './lib/events';
+  export { beginPropertyChanges, changeProperties, endPropertyChanges, notifyPropertyChange, PropertyDidChange, PROPERTY_DID_CHANGE, } from './lib/property_events';
+  export { defineProperty, defineDecorator, defineValue } from './lib/properties';
+  export { ExtendedMethodDecorator, DecoratorPropertyDescriptor, ComputedDescriptor, ElementDescriptor, isElementDescriptor, nativeDescDecorator, descriptorForDecorator, descriptorForProperty, isClassicDecorator, setClassicDecorator, makeComputedDecorator, } from './lib/decorator';
+  export { default as libraries, Libraries } from './lib/libraries';
+  export { default as getProperties } from './lib/get_properties';
+  export { default as setProperties } from './lib/set_properties';
+  export { default as expandProperties } from './lib/expand_properties';
+  export { ASYNC_OBSERVERS, SYNC_OBSERVERS, addObserver, activateObserver, removeObserver, flushAsyncObservers, revalidateObservers, } from './lib/observer';
+  export { default as inject, DEBUG_INJECTION_FUNCTIONS } from './lib/injected_property';
+  export { tagForProperty, tagForObject, markObjectAsDirty } from './lib/tags';
+  export { tracked, TrackedDescriptor } from './lib/tracked';
+  export { cached } from './lib/cached';
+  export { createCache, getValue, isConst } from './lib/cache';
+  export { NAMESPACES, NAMESPACES_BY_ID, addNamespace, findNamespace, findNamespaces, processNamespace, processAllNamespaces, removeNamespace, isSearchDisabled as isNamespaceSearchDisabled, setSearchDisabled as setNamespaceSearchDisabled, setUnprocessedMixins, } from './lib/namespace_search';
+}

package/types/stable/@ember/-internals/metal/lib/alias.d.ts

@@ -0,0 +1,22 @@
+declare module '@ember/-internals/metal/lib/alias.d.ts' {
+  import type { Meta } from '@ember/-internals/meta';
+  import type { ExtendedMethodDecorator } from './decorator';
+  import { ComputedDescriptor } from './decorator';
+  export type AliasDecorator = ExtendedMethodDecorator & PropertyDecorator & AliasDecoratorImpl;
+  export default function alias(altKey: string): AliasDecorator;
+  class AliasDecoratorImpl extends Function {
+      readOnly(this: ExtendedMethodDecorator): ExtendedMethodDecorator;
+      oneWay(this: ExtendedMethodDecorator): ExtendedMethodDecorator;
+      meta(this: ExtendedMethodDecorator, meta?: any): any;
+  }
+  export class AliasedProperty extends ComputedDescriptor {
+      readonly altKey: string;
+      constructor(altKey: string);
+      setup(obj: object, keyName: string, propertyDesc: PropertyDescriptor, meta: Meta): void;
+      get(obj: object, keyName: string): any;
+      set(obj: object, _keyName: string, value: any): any;
+      readOnly(): void;
+      oneWay(): void;
+  }
+  export {};
+}

package/types/stable/@ember/-internals/metal/lib/array.d.ts

@@ -0,0 +1,18 @@
+declare module '@ember/-internals/metal/lib/array.d.ts' {
+  import type EmberArray from '@ember/array';
+  import type MutableArray from '@ember/array/mutable';
+  type ObservedArray<T> = (T[] | EmberArray<T>) & ObservedObject;
+  interface ObservedObject {
+      _revalidate?: () => void;
+  }
+  export function objectAt<T>(array: T[] | EmberArray<T>, index: number): T | undefined;
+  export function replace<T>(array: T[] | MutableArray<T>, start: number, deleteCount: number, items?: readonly T[]): void;
+  export function replaceInNativeArray<T>(array: T[], start: number, deleteCount: number, items: ReadonlyArray<T>): void;
+  interface ArrayObserverOptions {
+      willChange: string;
+      didChange: string;
+  }
+  export function addArrayObserver<T>(array: EmberArray<T>, target: object | Function | null, opts: ArrayObserverOptions): ObservedArray<T>;
+  export function removeArrayObserver<T>(array: T[] | EmberArray<T>, target: object | Function | null, opts: ArrayObserverOptions): ObservedArray<T>;
+  export {};
+}

package/types/stable/@ember/-internals/metal/lib/array_events.d.ts

@@ -0,0 +1,6 @@
+declare module '@ember/-internals/metal/lib/array_events.d.ts' {
+  export function arrayContentWillChange<T extends object>(array: T, startIdx: number, removeAmt: number, addAmt: number): T;
+  export function arrayContentDidChange<T extends {
+      length: number;
+  }>(array: T, startIdx: number, removeAmt: number, addAmt: number, notify?: boolean): T;
+}

package/types/stable/@ember/-internals/metal/lib/cache.d.ts

@@ -0,0 +1,121 @@
+declare module '@ember/-internals/metal/lib/cache.d.ts' {
+  export { createCache, getValue, isConst } from '@glimmer/validator';
+  /**
+    Ember uses caching based on trackable values to avoid updating large portions
+    of the application. This caching is exposed via a cache primitive that can be
+    used to cache a specific computation, so that it will not update and will
+    return the cached value until a tracked value used in its computation has
+    updated.
+
+    @module @glimmer/tracking/primitives/cache
+    @public
+  */
+  /**
+    Receives a function, and returns a wrapped version of it that memoizes based on
+    _autotracking_. The function will only rerun whenever any tracked values used
+    within it have changed. Otherwise, it will return the previous value.
+
+    ```js
+    import { tracked } from '@glimmer/tracking';
+    import { createCache, getValue } from '@glimmer/tracking/primitives/cache';
+
+    class State {
+      @tracked value;
+    }
+
+    let state = new State();
+    let computeCount = 0;
+
+    let counter = createCache(() => {
+      // consume the state. Now, `counter` will
+      // only rerun if `state.value` changes.
+      state.value;
+
+      return ++computeCount;
+    });
+
+    getValue(counter); // 1
+
+    // returns the same value because no tracked state has changed
+    getValue(counter); // 1
+
+    state.value = 'foo';
+
+    // reruns because a tracked value used in the function has changed,
+    // incermenting the counter
+    getValue(counter); // 2
+    ```
+
+    @method createCache
+    @static
+    @for @glimmer/tracking/primitives/cache
+    @public
+  */
+  /**
+    Gets the value of a cache created with `createCache`.
+
+    ```js
+    import { tracked } from '@glimmer/tracking';
+    import { createCache, getValue } from '@glimmer/tracking/primitives/cache';
+
+    let computeCount = 0;
+
+    let counter = createCache(() => {
+      return ++computeCount;
+    });
+
+    getValue(counter); // 1
+    ```
+
+    @method getValue
+    @static
+    @for @glimmer/tracking/primitives/cache
+    @public
+  */
+  /**
+    Can be used to check if a memoized function is _constant_. If no tracked state
+    was used while running a memoized function, it will never rerun, because nothing
+    can invalidate its result. `isConst` can be used to determine if a memoized
+    function is constant or not, in order to optimize code surrounding that
+    function.
+
+    ```js
+    import { tracked } from '@glimmer/tracking';
+    import { createCache, getValue, isConst } from '@glimmer/tracking/primitives/cache';
+
+    class State {
+      @tracked value;
+    }
+
+    let state = new State();
+    let computeCount = 0;
+
+    let counter = createCache(() => {
+      // consume the state
+      state.value;
+
+      return computeCount++;
+    });
+
+    let constCounter = createCache(() => {
+      return computeCount++;
+    });
+
+    getValue(counter);
+    getValue(constCounter);
+
+    isConst(counter); // false
+    isConst(constCounter); // true
+    ```
+
+    If called on a cache that hasn't been accessed yet, it will throw an
+    error. This is because there's no way to know if the function will be constant
+    or not yet, and so this helps prevent missing an optimization opportunity on
+    accident.
+
+    @method isConst
+    @static
+    @for @glimmer/tracking/primitives/cache
+    @public
+  */
+}

package/types/stable/@ember/-internals/metal/lib/cached.d.ts

@@ -0,0 +1,3 @@
+declare module '@ember/-internals/metal/lib/cached.d.ts' {
+  export const cached: PropertyDecorator;
+}

package/types/stable/@ember/-internals/metal/lib/chain-tags.d.ts

@@ -0,0 +1,8 @@
+declare module '@ember/-internals/metal/lib/chain-tags.d.ts' {
+  import type { Meta } from '@ember/-internals/meta';
+  import type { Tag, TagMeta } from '@glimmer/validator';
+  export const CHAIN_PASS_THROUGH: WeakSet<object>;
+  export function finishLazyChains(meta: Meta, key: string, value: any): void;
+  export function getChainTagsForKeys(obj: object, keys: string[], tagMeta: TagMeta, meta: Meta | null): Tag;
+  export function getChainTagsForKey(obj: object, key: string, tagMeta: TagMeta, meta: Meta | null): Tag;
+}

package/types/stable/@ember/-internals/metal/lib/change_event.d.ts

@@ -0,0 +1,3 @@
+declare module '@ember/-internals/metal/lib/change_event.d.ts' {
+  export default function changeEvent(keyName: string): string;
+}