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

package/types/stable/@glimmer/tracking/index.d.ts

@@ -0,0 +1,203 @@
+declare module '@glimmer/tracking' {
+  export { tracked, cached } from '@ember/-internals/metal';
+  /**
+    In order to tell Ember a value might change, we need to mark it as trackable.
+    Trackable values are values that:
+
+    - Can change over their component’s lifetime and
+    - Should cause Ember to rerender if and when they change
+
+    We can do this by marking the field with the `@tracked` decorator.
+
+    @module @glimmer/tracking
+    @public
+  */
+  /**
+    Marks a property as tracked. By default, values that are rendered in Ember app
+    templates are _static_, meaning that updates to them won't cause the
+    application to rerender. Marking a property as tracked means that when that
+    property changes, any templates that used that property, directly or
+    indirectly, will rerender. For instance, consider this component:
+
+    ```handlebars
+    <div>Count: {{this.count}}</div>
+    <div>Times Ten: {{this.timesTen}}</div>
+    <div>
+      <button {{on "click" this.plusOne}}>
+        Plus One
+      </button>
+    </div>
+    ```
+
+    ```javascript
+    import Component from '@glimmer/component';
+    import { tracked } from '@glimmer/tracking';
+    import { action } from '@ember/object';
+
+    export default class CounterComponent extends Component {
+      @tracked count = 0;
+
+      get timesTen() {
+        return this.count * 10;
+      }
+
+      @action
+      plusOne() {
+        this.count += 1;
+      }
+    }
+    ```
+
+    Both the `{{this.count}}` and the `{{this.timesTen}}` properties in the
+    template will update whenever the button is clicked. Any tracked properties
+    that are used in any way to calculate a value that is used in the template
+    will cause a rerender when updated - this includes through method calls and
+    other means:
+
+    ```javascript
+    import Component from '@glimmer/component';
+    import { tracked } from '@glimmer/tracking';
+
+    class Entry {
+      @tracked name;
+      @tracked phoneNumber;
+
+      constructor(name, phoneNumber) {
+        this.name = name;
+        this.phoneNumber = phoneNumber;
+      }
+    }
+
+    export default class PhoneBookComponent extends Component {
+      entries = [
+        new Entry('Pizza Palace', 5551234),
+        new Entry('1st Street Cleaners', 5554321),
+        new Entry('Plants R Us', 5552468),
+      ];
+
+      // Any usage of this property will update whenever any of the names in the
+      // entries arrays are updated
+      get names() {
+        return this.entries.map(e => e.name);
+      }
+
+      // Any usage of this property will update whenever any of the numbers in the
+      // entries arrays are updated
+      get numbers() {
+        return this.getFormattedNumbers();
+      }
+
+      getFormattedNumbers() {
+        return this.entries
+          .map(e => e.phoneNumber)
+          .map(number => {
+            let numberString = '' + number;
+
+            return numberString.slice(0, 3) + '-' + numberString.slice(3);
+          });
+      }
+    }
+    ```
+
+    It's important to note that setting tracked properties will always trigger an
+    update, even if the property is set to the same value as it was before.
+
+    ```js
+    let entry = new Entry('Pizza Palace', 5551234);
+    // if entry was used when rendering, this would cause a rerender, even though
+    // the name is being set to the same value as it was before
+    entry.name = entry.name;
+    ```
+
+    `tracked` can also be used with the classic Ember object model in a similar
+    manner to classic computed properties:
+
+    ```javascript
+    import EmberObject from '@ember/object';
+    import { tracked } from '@glimmer/tracking';
+
+    const Entry = EmberObject.extend({
+      name: tracked(),
+      phoneNumber: tracked()
+    });
+    ```
+
+    Often this is unnecessary, but to ensure robust auto-tracking behavior it is
+    advisable to mark tracked state appropriately wherever possible.
+    This form of `tracked` also accepts an optional configuration object
+    containing either an initial `value` or an `initializer` function (but not
+    both).
+
+    ```javascript
+    import EmberObject from '@ember/object';
+    import { tracked } from '@glimmer/tracking';
+
+    const Entry = EmberObject.extend({
+      name: tracked({ value: 'Zoey' }),
+      favoriteSongs: tracked({
+        initializer: () => ['Raspberry Beret', 'Time After Time']
+      })
+    });
+    ```
+
+    @method tracked
+    @static
+    @for @glimmer/tracking
+    @public
+  */
+  /**
+    The `@cached` decorator can be used on getters in order to cache the return
+    value of the getter. This is useful when a getter is expensive and used very
+    often. For instance, in this guest list class, we have the `sortedGuests`
+    getter that sorts the guests alphabetically:
+
+    ```js
+    import { tracked } from '@glimmer/tracking';
+
+    class GuestList {
+      @tracked guests = ['Zoey', 'Tomster'];
+
+      get sortedGuests() {
+        return this.guests.slice().sort()
+      }
+    }
+    ```
+
+    Every time `sortedGuests` is accessed, a new array will be created and sorted,
+    because JavaScript getters do not cache by default. When the guest list is
+    small, like the one in the example, this is not a problem. However, if the guest
+    list were to grow very large, it would mean that we would be doing a large
+    amount of work each time we accessed `sortedGetters`. With `@cached`, we can
+    cache the value instead:
+
+    ```js
+    import { tracked, cached } from '@glimmer/tracking';
+
+    class GuestList {
+      @tracked guests = ['Zoey', 'Tomster'];
+
+      @cached
+      get sortedGuests() {
+        return this.guests.slice().sort()
+      }
+    }
+    ```
+
+    Now the `sortedGuests` getter will be cached based on _autotracking_. It will
+    only rerun and create a new sorted array when the `guests` tracked property is
+    updated.
+
+    In general, you should avoid using `@cached` unless you have confirmed that the
+    getter you are decorating is computationally expensive. `@cached` adds a small
+    amount of overhead to the getter, making it more expensive. While this overhead
+    is small, if `@cached` is overused it can add up to a large impact overall in
+    your app. Many getters and tracked properties are only accessed once, rendered,
+    and then never rerendered, so adding `@cached` when it is unnecessary can
+    negatively impact performance.
+
+    @method cached
+    @static
+    @for @glimmer/tracking
+    @public
+   */
+}

package/types/stable/@glimmer/tracking/primitives/cache.d.ts

@@ -0,0 +1,3 @@
+declare module '@glimmer/tracking/primitives/cache.d.ts' {
+  export { createCache, getValue, isConst } from '@ember/-internals/metal';
+}

package/types/stable/ember/index.d.ts

@@ -0,0 +1,376 @@
+declare module 'ember' {
+  /**
+  @module ember
+  */
+  import require from 'require';
+  import * as utils from '@ember/-internals/utils';
+  import { Registry, Container } from '@ember/-internals/container';
+  import * as instrumentation from '@ember/instrumentation';
+  import * as metal from '@ember/-internals/metal';
+  import { isEnabled } from '@ember/canary-features';
+  import * as EmberDebug from '@ember/debug';
+  import Backburner from 'backburner';
+  import Controller, { inject as injectController } from '@ember/controller';
+  import { dasherize, camelize, capitalize, classify, decamelize, underscore, w } from '@ember/string';
+  import Service from '@ember/service';
+  import EmberObject, { action, observer } from '@ember/object';
+  import { dependentKeyCompat } from '@ember/object/compat';
+  import { RSVP } from '@ember/-internals/runtime';
+  import { setComponentManager, escapeExpression, template, isSerializationFirstNode, type TemplatesRegistry } from '@ember/-internals/glimmer';
+  import * as views from '@ember/-internals/views';
+  import ContainerDebugAdapter from '@ember/debug/container-debug-adapter';
+  import DataAdapter from '@ember/debug/data-adapter';
+  import { run } from '@ember/runloop';
+  import { NativeArray, isArray, makeArray } from '@ember/array';
+  import ArrayProxy from '@ember/array/proxy';
+  import Application, { onLoad, runLoadHooks } from '@ember/application';
+  import ApplicationInstance from '@ember/application/instance';
+  import Namespace from '@ember/application/namespace';
+  import Component from '@ember/component';
+  import Helper from '@ember/component/helper';
+  import Engine from '@ember/engine';
+  import EngineInstance from '@ember/engine/instance';
+  import CoreObject from '@ember/object/core';
+  import Mixin, { mixin } from '@ember/object/mixin';
+  import ObjectProxy from '@ember/object/proxy';
+  import { assign } from '@ember/polyfills';
+  import AutoLocation from '@ember/routing/auto-location';
+  import HashLocation from '@ember/routing/hash-location';
+  import HistoryLocation from '@ember/routing/history-location';
+  import NoneLocation from '@ember/routing/none-location';
+  import Route from '@ember/routing/route';
+  import Router from '@ember/routing/router';
+  import { controllerFor, generateController, generateControllerFactory, DSL as RouterDSL } from '@ember/routing/-internals';
+  import { isNone, isBlank, isEmpty, isPresent, isEqual, typeOf, compare } from '@ember/utils';
+  import * as glimmerRuntime from '@glimmer/runtime';
+  import { helperCapabilities, setModifierManager, setComponentTemplate, getComponentTemplate, setHelperManager } from '@glimmer/manager';
+  import { associateDestroyableChild, registerDestructor, unregisterDestructor } from '@ember/destroyable';
+  import type { precompile, compile } from 'ember-template-compiler';
+  import type * as EmberTesting from 'ember-testing';
+  /**
+    Namespace for injection helper methods.
+
+    @class inject
+    @namespace Ember
+    @static
+    @public
+  */
+  function inject(): void;
+  namespace inject {
+      var controller: typeof injectController;
+      var service: typeof import("@ember/service").service;
+  }
+  const PartialEmber: {
+      readonly isNamespace: true;
+      readonly toString: () => string;
+      readonly Container: typeof Container;
+      readonly Registry: typeof Registry;
+      readonly _setComponentManager: typeof setComponentManager;
+      readonly _componentManagerCapabilities: typeof import("@glimmer/manager").componentCapabilities;
+      readonly _modifierManagerCapabilities: typeof import("@glimmer/manager").modifierCapabilities;
+      readonly meta: {
+          (obj: object): import("@ember/-internals/meta").Meta;
+          _counters?: import("@ember/-internals/meta").MetaCounters | undefined;
+      };
+      readonly _createCache: typeof metal.createCache;
+      readonly _cacheGetValue: typeof metal.getValue;
+      readonly _cacheIsConst: typeof metal.isConst;
+      readonly _descriptor: typeof metal.nativeDescDecorator;
+      readonly _getPath: typeof metal._getPath;
+      readonly _setClassicDecorator: typeof metal.setClassicDecorator;
+      readonly _tracked: typeof metal.tracked;
+      readonly beginPropertyChanges: typeof metal.beginPropertyChanges;
+      readonly changeProperties: typeof metal.changeProperties;
+      readonly endPropertyChanges: typeof metal.endPropertyChanges;
+      readonly hasListeners: typeof metal.hasListeners;
+      readonly libraries: metal.Libraries;
+      readonly _ContainerProxyMixin: Mixin;
+      readonly _ProxyMixin: Mixin;
+      readonly _RegistryProxyMixin: Mixin;
+      readonly ActionHandler: Mixin;
+      readonly Comparable: Mixin;
+      readonly RSVP: typeof RSVP;
+      readonly ComponentLookup: Readonly<typeof EmberObject> & (new (owner?: import("../@ember/owner").default | undefined) => EmberObject);
+      readonly EventDispatcher: typeof views.EventDispatcher;
+      readonly _Cache: typeof utils.Cache;
+      readonly GUID_KEY: `__ember${number}`;
+      readonly canInvoke: typeof utils.canInvoke;
+      readonly generateGuid: typeof utils.generateGuid;
+      readonly guidFor: typeof utils.guidFor;
+      readonly uuid: typeof utils.uuid;
+      readonly wrap: typeof utils.wrap;
+      readonly getOwner: (object: object) => import("../@ember/owner").default | undefined;
+      readonly onLoad: typeof onLoad;
+      readonly runLoadHooks: typeof runLoadHooks;
+      readonly setOwner: typeof import("../@ember/owner").setOwner;
+      readonly Application: typeof Application;
+      readonly ApplicationInstance: typeof ApplicationInstance;
+      readonly Namespace: typeof Namespace;
+      readonly A: <T>(arr?: T[] | undefined) => NativeArray<T>;
+      readonly Array: Mixin;
+      readonly NativeArray: Mixin;
+      readonly isArray: typeof isArray;
+      readonly makeArray: typeof makeArray;
+      readonly MutableArray: Mixin;
+      readonly ArrayProxy: typeof ArrayProxy;
+      readonly FEATURES: {
+          readonly EMBER_UNIQUE_ID_HELPER: boolean;
+          readonly EMBER_DEFAULT_HELPER_MANAGER: boolean;
+          readonly isEnabled: typeof isEnabled;
+      };
+      readonly _Input: import("../@ember/-internals/glimmer/lib/components/internal").OpaqueInternalComponentConstructor;
+      readonly Component: typeof Component;
+      readonly Helper: typeof Helper;
+      readonly Controller: typeof Controller;
+      readonly ControllerMixin: Mixin;
+      readonly _captureRenderTree: typeof EmberDebug.captureRenderTree;
+      readonly assert: EmberDebug.AssertFunc;
+      readonly warn: import("../@ember/debug/lib/warn").WarnFunc;
+      readonly debug: EmberDebug.DebugFunc;
+      readonly deprecate: import("../@ember/debug/lib/deprecate").DeprecateFunc;
+      readonly deprecateFunc: EmberDebug.DeprecateFuncFunc;
+      readonly runInDebug: EmberDebug.RunInDebugFunc;
+      readonly inspect: typeof EmberDebug.inspect;
+      readonly Debug: {
+          readonly registerDeprecationHandler: (handler: import("../@ember/debug/lib/handlers").HandlerCallback<EmberDebug.DeprecationOptions>) => void;
+          readonly registerWarnHandler: import("../@ember/debug/lib/warn").RegisterHandlerFunc;
+          readonly isComputed: typeof metal.isComputed;
+      };
+      readonly ContainerDebugAdapter: typeof ContainerDebugAdapter;
+      readonly DataAdapter: typeof DataAdapter;
+      readonly _assertDestroyablesDestroyed: (() => void) | undefined;
+      readonly _associateDestroyableChild: typeof associateDestroyableChild;
+      readonly _enableDestroyableTracking: (() => void) | undefined;
+      readonly _isDestroying: typeof glimmerRuntime.isDestroying;
+      readonly _isDestroyed: typeof glimmerRuntime.isDestroyed;
+      readonly _registerDestructor: typeof registerDestructor;
+      readonly _unregisterDestructor: typeof unregisterDestructor;
+      readonly destroy: typeof glimmerRuntime.destroy;
+      readonly Engine: typeof Engine;
+      readonly EngineInstance: typeof EngineInstance;
+      readonly Enumerable: Mixin;
+      readonly MutableEnumerable: Mixin;
+      readonly Error: ErrorConstructor;
+      readonly instrument: typeof instrumentation.instrument;
+      readonly subscribe: typeof instrumentation.subscribe;
+      readonly Instrumentation: {
+          readonly instrument: typeof instrumentation.instrument;
+          readonly subscribe: typeof instrumentation.subscribe;
+          readonly unsubscribe: typeof instrumentation.unsubscribe;
+          readonly reset: typeof instrumentation.reset;
+      };
+      readonly Object: typeof EmberObject;
+      readonly _action: typeof action;
+      readonly computed: typeof metal.computed;
+      readonly defineProperty: typeof metal.defineProperty;
+      readonly get: typeof metal.get;
+      readonly getProperties: typeof metal.getProperties;
+      readonly notifyPropertyChange: typeof metal.notifyPropertyChange;
+      readonly observer: typeof observer;
+      readonly set: typeof metal.set;
+      readonly trySet: typeof metal.trySet;
+      readonly setProperties: typeof metal.setProperties;
+      readonly cacheFor: typeof metal.getCachedValueFor;
+      readonly _dependentKeyCompat: typeof dependentKeyCompat;
+      readonly ComputedProperty: typeof metal.ComputedProperty;
+      readonly expandProperties: typeof metal.expandProperties;
+      readonly CoreObject: typeof CoreObject;
+      readonly Evented: Mixin;
+      readonly on: typeof metal.on;
+      readonly addListener: typeof metal.addListener;
+      readonly removeListener: typeof metal.removeListener;
+      readonly sendEvent: typeof metal.sendEvent;
+      readonly Mixin: typeof Mixin;
+      readonly mixin: typeof mixin;
+      readonly Observable: Mixin;
+      readonly addObserver: typeof metal.addObserver;
+      readonly removeObserver: typeof metal.removeObserver;
+      readonly PromiseProxyMixin: Mixin;
+      readonly ObjectProxy: typeof ObjectProxy;
+      readonly assign: typeof assign;
+      readonly RouterDSL: typeof RouterDSL;
+      readonly controllerFor: typeof controllerFor;
+      readonly generateController: typeof generateController;
+      readonly generateControllerFactory: typeof generateControllerFactory;
+      readonly AutoLocation: typeof AutoLocation;
+      readonly HashLocation: typeof HashLocation;
+      readonly HistoryLocation: typeof HistoryLocation;
+      readonly Location: {
+          create(options?: {
+              implementation: string;
+          } | undefined): import("@ember/routing/location").ILocation;
+          implementations: Record<string, {
+              create: (...args: any[]) => import("@ember/routing/location").ILocation;
+          }>;
+      };
+      readonly NoneLocation: typeof NoneLocation;
+      readonly Route: typeof Route;
+      readonly Router: typeof Router;
+      readonly run: typeof run;
+      readonly Service: typeof Service;
+      readonly String: {
+          readonly camelize: typeof camelize;
+          readonly capitalize: typeof capitalize;
+          readonly classify: typeof classify;
+          readonly decamelize: typeof decamelize;
+          readonly dasherize: typeof dasherize;
+          readonly underscore: typeof underscore;
+          readonly w: typeof w;
+      };
+      readonly compare: typeof compare;
+      readonly isBlank: typeof isBlank;
+      readonly isEmpty: typeof isEmpty;
+      readonly isEqual: typeof isEqual;
+      readonly isNone: typeof isNone;
+      readonly isPresent: typeof isPresent;
+      readonly typeOf: typeof typeOf;
+      /**
+        The semantic version
+    
+        @property VERSION
+        @type String
+        @public
+      */
+      readonly VERSION: string;
+      readonly ViewUtils: {
+          readonly getChildViews: typeof views.getChildViews;
+          readonly getElementView: typeof views.getElementView;
+          readonly getRootViews: typeof views.getRootViews;
+          readonly getViewBounds: typeof views.getViewBounds;
+          readonly getViewBoundingClientRect: typeof views.getViewBoundingClientRect;
+          readonly getViewClientRects: typeof views.getViewClientRects;
+          readonly getViewElement: typeof views.getViewElement;
+          readonly isSimpleClick: typeof views.isSimpleClick;
+          readonly isSerializationFirstNode: typeof isSerializationFirstNode;
+      };
+      readonly _getComponentTemplate: typeof getComponentTemplate;
+      readonly _helperManagerCapabilities: typeof helperCapabilities;
+      readonly _setComponentTemplate: typeof setComponentTemplate;
+      readonly _setHelperManager: typeof setHelperManager;
+      readonly _setModifierManager: typeof setModifierManager;
+      readonly _templateOnlyComponent: typeof glimmerRuntime.templateOnlyComponent;
+      readonly _invokeHelper: typeof glimmerRuntime.invokeHelper;
+      readonly _hash: object;
+      readonly _array: object;
+      readonly _concat: object;
+      readonly _get: object;
+      readonly _on: {};
+      readonly _fn: object;
+      readonly _Backburner: typeof Backburner;
+      readonly inject: typeof inject;
+      readonly platform: {
+          readonly defineProperty: true;
+          readonly hasPropertyAccessors: true;
+      };
+      readonly __loader: {
+          readonly require: typeof require;
+          readonly define: typeof define;
+          readonly registry: any;
+      };
+  };
+  interface EmberHandlebars {
+      template: typeof template;
+      Utils: {
+          escapeExpression: typeof escapeExpression;
+      };
+      compile?: typeof compile;
+      precompile?: typeof precompile;
+  }
+  interface EmberHTMLBars {
+      template: typeof template;
+      compile?: typeof compile;
+      precompile?: typeof precompile;
+  }
+  type PartialEmber = typeof PartialEmber;
+  interface Ember extends PartialEmber {
+      get ENV(): object;
+      get lookup(): Record<string, unknown>;
+      set lookup(value: Record<string, unknown>);
+      /**
+        A function may be assigned to `Ember.onerror` to be called when Ember
+        internals encounter an error. This is useful for specialized error handling
+        and reporting code.
+    
+        ```javascript
+    
+        Ember.onerror = function(error) {
+          const payload = {
+            stack: error.stack,
+            otherInformation: 'whatever app state you want to provide'
+          };
+    
+          fetch('/report-error', {
+            method: 'POST',
+            body: JSON.stringify(payload)
+          });
+        };
+        ```
+    
+        Internally, `Ember.onerror` is used as Backburner's error handler.
+    
+        @event onerror
+        @for Ember
+        @param {Exception} error the error object
+        @public
+      */
+      get onerror(): Function | undefined;
+      set onerror(handler: Function | undefined);
+      get testing(): boolean;
+      set testing(value: boolean);
+      /**
+        Defines the hash of localized strings for the current language. Used by
+        the `String.loc` helper. To localize, add string values to this
+        hash.
+    
+        @property STRINGS
+        @for Ember
+        @type Object
+        @private
+      */
+      get STRINGS(): {
+          [key: string]: string;
+      };
+      set STRINGS(value: {
+          [key: string]: string;
+      });
+      /**
+        Whether searching on the global for new Namespace instances is enabled.
+    
+        This is only exported here as to not break any addons.  Given the new
+        visit API, you will have issues if you treat this as a indicator of
+        booted.
+    
+        Internally this is only exposing a flag in Namespace.
+    
+        @property BOOTED
+        @for Ember
+        @type Boolean
+        @private
+      */
+      get BOOTED(): boolean;
+      set BOOTED(flag: boolean);
+      /**
+        Global hash of shared templates. This will automatically be populated
+        by the build tools so that you can store your Handlebars templates in
+        separate files that get loaded into JavaScript at buildtime.
+    
+        @property TEMPLATES
+        @for Ember
+        @type Object
+        @private
+      */
+      get TEMPLATES(): TemplatesRegistry;
+      set TEMPLATES(registry: TemplatesRegistry);
+      HTMLBars: EmberHTMLBars;
+      Handlebars: EmberHandlebars;
+      Test?: typeof EmberTesting['Test'] & {
+          Adapter: typeof EmberTesting['Adapter'];
+          QUnitAdapter: typeof EmberTesting['QUnitAdapter'];
+      };
+      setupForTesting?: typeof EmberTesting['setupForTesting'];
+  }
+  const Ember: Ember;
+  let EmberHandlebars: EmberHandlebars;
+  let EmberHTMLBars: EmberHTMLBars;
+  export default Ember;
+}

package/types/stable/ember-template-compiler/index.d.ts

@@ -0,0 +1,21 @@
+declare module 'ember-template-compiler' {
+  import * as _GlimmerSyntax from '@glimmer/syntax';
+  import VERSION from 'ember/version';
+  global {
+      interface NodeRequire {
+          has(name: string): boolean;
+      }
+      function define(path: string, deps: string[], module: () => void): void;
+  }
+  export let _Ember: unknown;
+  export { default as precompile } from './lib/system/precompile';
+  export { default as compile } from './lib/system/compile';
+  export { default as compileOptions, buildCompileOptions as _buildCompileOptions, transformsFor as _transformsFor, } from './lib/system/compile-options';
+  export { RESOLUTION_MODE_TRANSFORMS, STRICT_MODE_TRANSFORMS } from './lib/plugins/index';
+  export { EmberPrecompileOptions } from './lib/types';
+  export { preprocess as _preprocess, print as _print } from '@glimmer/syntax';
+  export { precompile as _precompile } from '@glimmer/compiler';
+  export { _GlimmerSyntax, VERSION };
+  import './lib/system/bootstrap';
+  import './lib/system/initializer';
+}

package/types/stable/ember-template-compiler/lib/plugins/assert-against-attrs.d.ts

@@ -0,0 +1,20 @@
+declare module 'ember-template-compiler/lib/plugins/assert-against-attrs.d.ts' {
+  import type { ASTPlugin } from '@glimmer/syntax';
+  import type { EmberASTPluginEnvironment } from '../types';
+  /**
+   @module ember
+  */
+  /**
+    A Glimmer2 AST transformation that asserts against
+
+    ```handlebars
+    {{attrs.foo.bar}}
+    ```
+
+    ...as well as `{{#if attrs.foo}}`, `{{deeply (nested attrs.foobar.baz)}}`.
+
+    @private
+    @class AssertAgainstAttrs
+  */
+  export default function assertAgainstAttrs(env: EmberASTPluginEnvironment): ASTPlugin;
+}

package/types/stable/ember-template-compiler/lib/plugins/assert-against-named-outlets.d.ts

@@ -0,0 +1,14 @@
+declare module 'ember-template-compiler/lib/plugins/assert-against-named-outlets.d.ts' {
+  import type { ASTPlugin } from '@glimmer/syntax';
+  import type { EmberASTPluginEnvironment } from '../types';
+  /**
+   @module ember
+  */
+  /**
+    Prevents usage of named outlets, a legacy concept in Ember removed in 4.0.
+
+    @private
+    @class AssertAgainstNamedOutlets
+  */
+  export default function assertAgainstNamedOutlets(env: EmberASTPluginEnvironment): ASTPlugin;
+}

package/types/stable/ember-template-compiler/lib/plugins/assert-input-helper-without-block.d.ts

@@ -0,0 +1,5 @@
+declare module 'ember-template-compiler/lib/plugins/assert-input-helper-without-block.d.ts' {
+  import type { ASTPlugin } from '@glimmer/syntax';
+  import type { EmberASTPluginEnvironment } from '../types';
+  export default function errorOnInputWithContent(env: EmberASTPluginEnvironment): ASTPlugin;
+}

package/types/stable/ember-template-compiler/lib/plugins/assert-reserved-named-arguments.d.ts

@@ -0,0 +1,5 @@
+declare module 'ember-template-compiler/lib/plugins/assert-reserved-named-arguments.d.ts' {
+  import type { ASTPlugin } from '@glimmer/syntax';
+  import type { EmberASTPluginEnvironment } from '../types';
+  export default function assertReservedNamedArguments(env: EmberASTPluginEnvironment): ASTPlugin;
+}

package/types/stable/ember-template-compiler/lib/plugins/assert-splattribute-expression.d.ts

@@ -0,0 +1,5 @@
+declare module 'ember-template-compiler/lib/plugins/assert-splattribute-expression.d.ts' {
+  import type { ASTPlugin } from '@glimmer/syntax';
+  import type { EmberASTPluginEnvironment } from '../types';
+  export default function assertSplattributeExpressions(env: EmberASTPluginEnvironment): ASTPlugin;
+}

package/types/stable/ember-template-compiler/lib/plugins/index.d.ts

@@ -0,0 +1,5 @@
+declare module 'ember-template-compiler/lib/plugins' {
+  import AssertReservedNamedArguments from './assert-reserved-named-arguments';
+  export const RESOLUTION_MODE_TRANSFORMS: readonly (typeof AssertReservedNamedArguments)[];
+  export const STRICT_MODE_TRANSFORMS: readonly (typeof AssertReservedNamedArguments)[];
+}