@glint/ember-tsc 1.0.0

package/types/-private/dsl/globals.d.ts

@@ -0,0 +1,204 @@
+import Globals from '../../globals';
+
+import * as VM from '@glint/template/-private/keywords';
+
+import { ActionKeyword } from '../intrinsics/action';
+import { EachKeyword } from '../intrinsics/each';
+import { EachInKeyword } from '../intrinsics/each-in';
+import { LogHelper } from '../intrinsics/log';
+import { MountKeyword } from '../intrinsics/mount';
+import { MutKeyword } from '../intrinsics/mut';
+import { OutletKeyword } from '../intrinsics/outlet';
+import { UnboundKeyword } from '../intrinsics/unbound';
+import { UniqueIdHelper } from '../intrinsics/unique-id';
+
+// The keyword vs global breakdown here is loosely matched with
+// the listing in http://emberjs.github.io/rfcs/0496-handlebars-strict-mode.html
+
+interface Keywords {
+  /**
+    The {{action}} helper provides a way to pass triggers for behavior (usually just a function)
+    between components, and into components from controllers.
+
+    See [the API documentation] for further details.
+
+    [the API documentation]: https://api.emberjs.com/ember/release/classes/Ember.Templates.helpers/methods/action?anchor=action
+   */
+  action: ActionKeyword;
+
+  /**
+    The `{{component}}` helper lets you add instances of `Component` to a template.
+    `{{component}}`'s primary use is for cases where you want to dynamically change
+    which type of component is rendered as the state of your application changes.
+
+    See [the API documentation] for further details.
+
+    [the API documentation]: https://api.emberjs.com/ember/release/classes/Ember.Templates.helpers/methods/component?anchor=component
+   */
+  component: VM.ComponentKeyword;
+
+  /**
+    Execute the `debugger` statement in the current template's context.
+
+    See [the API documentation] for further details.
+
+    [the API documentation]: https://api.emberjs.com/ember/release/classes/Ember.Templates.helpers/methods/debugger?anchor=debugger
+  */
+  debugger: VM.DebuggerKeyword;
+
+  /**
+    The `{{#each}}` helper loops over elements in a collection.
+
+    See [the API documentation] for further details.
+
+    [the API documentation]: https://api.emberjs.com/ember/release/classes/Ember.Templates.helpers/methods/each?anchor=each
+  */
+  each: EachKeyword;
+
+  /**
+    The `{{each-in}}` helper loops over properties on an object.
+
+    See [the API documentation] for further details.
+
+    [the API documentation]: https://api.emberjs.com/ember/release/classes/Ember.Templates.helpers/methods/each-in?anchor=each-in
+  */
+  'each-in': EachInKeyword;
+
+  /**
+    `{{has-block}}` indicates if the component was invoked with a block.
+
+    See [the API documentation] for further details.
+
+    [the API documentation]: https://api.emberjs.com/ember/release/classes/Ember.Templates.helpers/methods/hasBlock?anchor=hasBlock
+  */
+  'has-block': VM.HasBlockKeyword;
+
+  /**
+    `{{has-block-params}}` indicates if the component was invoked with block params.
+
+    See [the API documentation] for further details.
+
+    [the API documentation]: https://api.emberjs.com/ember/release/classes/Ember.Templates.helpers/methods/hasBlockParams?anchor=hasBlockParams
+  */
+  'has-block-params': VM.HasBlockParamsKeyword;
+
+  /**
+    Use the `{{helper}}` helper to create a contextual helper so that it can be passed
+    around as first-class values in templates.
+
+    See [the API documentation] for further details.
+
+    [the API documentation]: https://api.emberjs.com/ember/release/classes/Ember.Templates.helpers/methods/helper?anchor=helper
+  */
+  helper: VM.HelperKeyword;
+
+  // `{{if}}` is implemented directly in `ember-tsc`
+  if: void;
+
+  /**
+    The `{{in-element}}` helper renders its block content outside of the regular flow,
+    into a DOM element given by its `destinationElement` positional argument.
+
+    See [the API documentation] for further details.
+
+    [the API documentation]: https://api.emberjs.com/ember/release/classes/Ember.Templates.helpers/methods/in-element?anchor=in-element
+  */
+  'in-element': VM.InElementKeyword;
+
+  /**
+    The `{{let}}` helper receives one or more positional arguments and yields
+    them out as block params.
+
+    See [the API documentation] for further details.
+
+    [the API documentation]: https://api.emberjs.com/ember/release/classes/Ember.Templates.helpers/methods/let?anchor=let
+   */
+  let: VM.LetKeyword;
+
+  /**
+    `log` allows you to output the value of variables in the current rendering
+    context.
+
+    See [the API documentation] for further details.
+
+    [the API documentation]: https://api.emberjs.com/ember/release/classes/Ember.Templates.helpers/methods/log?anchor=log
+   */
+  log: LogHelper;
+
+  /**
+    Use the `{{modifier}}` helper to create a contextual modifier so that it can be passed
+    around as first-class values in templates.
+
+    See [the API documentation] for further details.
+
+    [the API documentation]: https://api.emberjs.com/ember/release/classes/Ember.Templates.helpers/methods/modifier?anchor=modifier
+  */
+  modifier: VM.ModifierKeyword;
+
+  /**
+    The `{{mount}}` helper lets you embed a routeless engine in a template.
+
+    See [the API documentation] for further details.
+
+    [the API documentation]: https://api.emberjs.com/ember/release/classes/Ember.Templates.helpers/methods/mount?anchor=mount
+    ```
+  */
+  mount: MountKeyword;
+
+  /**
+    The `mut` helper, when used with `fn`, will return a function that
+    sets the value passed to `mut` to its first argument.
+
+    See [the API documentation] for further details.
+
+    [the API documentation]: https://api.emberjs.com/ember/release/classes/Ember.Templates.helpers/methods/mut?anchor=mut
+   */
+  mut: MutKeyword;
+
+  /**
+    The `{{outlet}}` helper lets you specify where a child route will render in
+    your template.
+
+    See [the API documentation] for further details.
+
+    [the API documentation]: https://api.emberjs.com/ember/release/classes/Ember.Templates.helpers/methods/outlet?anchor=outlet
+  */
+  outlet: OutletKeyword;
+
+  /**
+    The `{{unbound}}` helper disconnects the one-way binding of a property,
+    essentially freezing its value at the moment of rendering.
+
+    See [the API documentation] for further details.
+
+    [the API documentation]: https://api.emberjs.com/ember/release/classes/Ember.Templates.helpers/methods/unbound?anchor=unbound
+   */
+  unbound: UnboundKeyword;
+
+  /**
+  Use the `{{unique-id}}` helper to generate a unique ID string suitable for use as an ID
+  attribute in the DOM.
+ 
+  See [the API documentation] for further details.
+
+  [the API documentation]: https://api.emberjs.com/ember/release/classes/Ember.Templates.helpers/methods/unique-id?anchor=unique-id
+   */
+  'unique-id': UniqueIdHelper;
+
+  // `{{unless}}` is implemented directly in `ember-tsc`
+  unless: void;
+
+  /**
+    Use the `{{with}}` helper when you want to alias a property to a new name.
+
+    See [the API documentation] for further details.
+
+    [the API documentation]: https://api.emberjs.com/ember/release/classes/Ember.Templates.helpers/methods/with?anchor=with
+   */
+  with: VM.WithKeyword;
+
+  // `{{yield}}` is implemented directly in `ember-tsc`
+  yield: void;
+}
+
+export const Globals: Keywords & Globals;

package/types/-private/dsl/index.d.ts

@@ -0,0 +1,50 @@
+// Reference the scaffolding for our merged declarations for third party modules so
+// that vanilla TS will see those as long as authors have
+// `import '@glint/ember-tsc/environment-ember-template-imports'` somewhere in their project.
+
+/// <reference path="../../globals/index.d.ts" preserve="true" />
+/// <reference path="./integration-declarations.d.ts" preserve="true" />
+
+export * from '@glint/template/-private/dsl';
+export { Globals } from './globals';
+
+import { ResolveOrReturn } from '@glint/template/-private/dsl';
+import {
+  AnyContext,
+  AnyFunction,
+  ComponentReturn,
+  DirectInvokable,
+  HasContext,
+  InvokableInstance,
+  Invoke,
+  InvokeDirect,
+  TemplateContext,
+} from '@glint/template/-private/integration';
+
+// Items that can be directly invoked by value
+export declare function resolve<T extends DirectInvokable>(item: T): T[typeof InvokeDirect];
+// Items whose instance type can be invoked
+export declare function resolve<Args extends unknown[], Instance extends InvokableInstance>(
+  item: (abstract new (...args: Args) => Instance) | null | undefined,
+): (...args: Parameters<Instance[typeof Invoke]>) => ReturnType<Instance[typeof Invoke]>;
+// Plain functions
+export declare function resolve<T extends ((...params: any) => any) | null | undefined>(
+  item: T,
+): NonNullable<T>;
+
+export declare const resolveOrReturn: ResolveOrReturn<typeof resolve>;
+
+// We customize the top-level `templateExpression` wrapper function for this environment to
+// return a type that's assignable to `TemplateOnlyComponent` from '@ember/component/template-only'.
+// Longer term we should rationalize this to a type that doesn't carry extra baggage
+// and likely comes from a more sensible path.
+
+import { TemplateOnlyComponent } from '@ember/component/template-only';
+
+export declare function templateExpression<
+  Signature extends AnyFunction = () => ComponentReturn<{}>,
+  Context extends AnyContext = TemplateContext<void, {}, {}, void>,
+>(
+  f: (__glintRef__: Context, __glintDSL__: never) => void,
+): TemplateOnlyComponent<never> &
+  (abstract new () => InvokableInstance<Signature> & HasContext<Context>);

package/types/-private/dsl/integration-declarations.d.ts

@@ -0,0 +1,143 @@
+// This module is responsible for augmenting the upstream definitions of entities that interact
+// with templates to include the information necessary for Glint to typecheck them.
+
+import { ComponentLike, HelperLike, ModifierLike } from '@glint/template';
+import {
+  Context,
+  FlattenBlockParams,
+  HasContext,
+  TemplateContext,
+} from '@glint/template/-private/integration';
+import {
+  ComponentSignatureArgs,
+  ComponentSignatureBlocks,
+  ComponentSignatureElement,
+} from '@glint/template/-private/signature';
+
+//////////////////////////////////////////////////////////////////////
+// Components
+
+import '@ember/component';
+import '@ember/component/template-only';
+import '@glimmer/component';
+
+type ComponentContext<This, S> = TemplateContext<
+  This,
+  ComponentSignatureArgs<S>['Named'],
+  FlattenBlockParams<ComponentSignatureBlocks<S>>,
+  ComponentSignatureElement<S>
+>;
+
+declare module '@glimmer/component' {
+  export default interface Component<S> extends InstanceType<ComponentLike<S>> {
+    [Context]: ComponentContext<this, S>;
+  }
+}
+
+import { InputComponent as ImportedInputComponent } from '../intrinsics/input';
+import { TextareaComponent as ImportedTextareaComponent } from '../intrinsics/textarea';
+declare module '@ember/component' {
+  export default interface Component<S> extends InstanceType<ComponentLike<S>> {
+    [Context]: ComponentContext<this, S>;
+  }
+  export interface Textarea extends ImportedTextareaComponent {}
+  export interface Input extends ImportedInputComponent {}
+}
+
+interface TemplateOnlyComponentInstance<S> extends InstanceType<ComponentLike<S>> {
+  [Context]: ComponentContext<null, S>;
+}
+
+// As with other abstract constructor types, this allows us to provide a class
+// and therefore have InstanceType work as needed, while forbidding construction
+// by end users.
+type TemplateOnlyConstructor<S> = abstract new () => TemplateOnlyComponentInstance<S>;
+
+declare module '@ember/component/template-only' {
+  export interface TemplateOnlyComponent<S> extends TemplateOnlyConstructor<S> {}
+}
+
+//////////////////////////////////////////////////////////////////////
+// Helpers
+
+import '@ember/component/helper';
+
+declare module '@ember/component/helper' {
+  export default interface Helper<S> extends InstanceType<HelperLike<S>> {}
+}
+
+//////////////////////////////////////////////////////////////////////
+// Modifiers
+
+import 'ember-modifier';
+
+declare module 'ember-modifier' {
+  export default interface ClassBasedModifier<S> extends InstanceType<ModifierLike<S>> {}
+}
+
+//////////////////////////////////////////////////////////////////////
+// Routes and Controllers
+
+import Controller from '@ember/controller';
+import Route from '@ember/routing/route';
+
+type ModelForRoute<T extends Route> = Awaited<ReturnType<T['model']>>;
+type ModelField<T> = { model: T };
+
+declare module '@ember/routing/route' {
+  export default interface Route {
+    [Context]: TemplateContext<
+      Controller & ModelField<ModelForRoute<this>>,
+      ModelField<ModelForRoute<this>>,
+      {},
+      null
+    >;
+  }
+}
+
+declare module '@ember/controller' {
+  export default interface Controller {
+    [Context]: TemplateContext<this, ModelField<this['model']>, {}, null>;
+  }
+}
+
+import { LinkToComponent } from '../intrinsics/link-to';
+declare module '@ember/routing' {
+  export interface LinkTo extends LinkToComponent {}
+}
+
+//////////////////////////////////////////////////////////////////////
+// Rendering Tests
+
+import '@ember/test-helpers';
+import 'ember-cli-htmlbars';
+
+type TestTemplate<T> = abstract new () => HasContext<TemplateContext<T, {}, {}, void>>;
+
+declare module '@ember/test-helpers' {
+  export function render<T>(template: TestTemplate<T>): Promise<void>;
+}
+
+// Declaring that `TemplateFactory` is a valid `TestTemplate` prevents vanilla `tsc` from freaking out
+// about `hbs` not returning a valid type for `render`. Glint itself will never see `hbs` get used, as
+// it's transformed to the template DSL before typechecking.
+declare module 'ember-cli-htmlbars' {
+  interface TemplateFactory extends TestTemplate<any> {}
+}
+
+import '@ember/modifier';
+import { OnModifier as ImportedOnModifier } from '../intrinsics/on';
+declare module '@ember/modifier' {
+  export interface OnModifier extends ImportedOnModifier {}
+}
+
+import '@ember/helper';
+import { ConcatHelper as ImportedConcatHelper } from '../intrinsics/concat';
+import { FnHelper as ImportedFnHelper } from '../intrinsics/fn';
+import { GetHelper as ImportedGetHelper } from '../intrinsics/get';
+
+declare module '@ember/helper' {
+  export interface ConcatHelper extends ImportedConcatHelper {}
+  export interface FnHelper extends ImportedFnHelper {}
+  export interface GetHelper extends ImportedGetHelper {}
+}

package/types/-private/intrinsics/action.d.ts

@@ -0,0 +1,45 @@
+import { DirectInvokable, NamedArgs } from '@glint/template/-private/integration';
+
+export type ActionNamedArgs<T> = NamedArgs<{
+  value?: keyof T;
+}>;
+
+export type ActionResult<T, Args extends ActionNamedArgs<T>> = undefined extends Args['value']
+  ? T
+  : Args['value'] extends keyof T
+    ? T[Args['value']]
+    : T;
+
+export type ActionKeyword = DirectInvokable<{
+  <Ret, Args extends ActionNamedArgs<Ret>, Params extends unknown[]>(
+    f: (...rest: Params) => Ret,
+    args?: Args,
+  ): (...rest: Params) => ActionResult<Ret, Args>;
+  <A, Ret, Args extends ActionNamedArgs<Ret>, Params extends unknown[]>(
+    f: (a: A, ...rest: Params) => Ret,
+    a: A,
+    args?: Args,
+  ): (...rest: Params) => ActionResult<Ret, Args>;
+  <A, B, Ret, Args extends ActionNamedArgs<Ret>, Params extends unknown[]>(
+    f: (a: A, b: B, ...rest: Params) => Ret,
+    a: A,
+    b: B,
+    args?: Args,
+  ): (...rest: Params) => ActionResult<Ret, Args>;
+  <A, B, C, Ret, Args extends ActionNamedArgs<Ret>, Params extends unknown[]>(
+    f: (a: A, b: B, c: C, ...rest: Params) => Ret,
+    a: A,
+    b: B,
+    c: C,
+    args?: Args,
+  ): (...rest: Params) => ActionResult<Ret, Args>;
+  <A, B, C, D, Ret, Args extends ActionNamedArgs<Ret>, Params extends unknown[]>(
+    f: (a: A, b: B, c: C, d: D, ...rest: Params) => Ret,
+    a: A,
+    b: B,
+    c: C,
+    d: D,
+    args?: Args,
+  ): (...rest: Params) => ActionResult<Ret, Args>;
+  (action: string, ...rest: unknown[]): (...rest: unknown[]) => unknown;
+}>;

package/types/-private/intrinsics/concat.d.ts

@@ -0,0 +1,6 @@
+import { HelperLike } from '@glint/template';
+
+export type ConcatHelper = HelperLike<{
+  Args: { Positional: unknown[] };
+  Return: string;
+}>;

package/types/-private/intrinsics/each-in.d.ts

@@ -0,0 +1,24 @@
+import { ComponentLike } from '@glint/template';
+
+export type EachInKeyword = abstract new <T>() => InstanceType<
+  ComponentLike<{
+    Args: {
+      Positional: [object: T];
+      Named: { key?: string };
+    };
+    Blocks: {
+      default: EachInIteratorPair<T>;
+      else?: [];
+    };
+  }>
+>;
+
+type EachInIteratorPair<T> =
+  T extends Iterable<[infer K, infer V]>
+    ? [key: K, value: V]
+    : [key: EachInKey<T>, value: Exclude<T, null | undefined>[EachInKey<T>]];
+
+// `{{each-in}}` internally uses `Object.keys`, so only string keys are included
+// TS, on the other hand, gives a wider result for `keyof` than many users expect
+// for record types: https://github.com/microsoft/TypeScript/issues/29249
+type EachInKey<T> = Extract<keyof Exclude<T, null | undefined>, string>;

package/types/-private/intrinsics/each.d.ts

@@ -0,0 +1,17 @@
+import EmberArray from '@ember/array';
+import { ComponentLike } from '@glint/template';
+
+type ArrayLike<T> = ReadonlyArray<T> | Iterable<T> | EmberArray<T>;
+
+export type EachKeyword = abstract new <T = any>() => InstanceType<
+  ComponentLike<{
+    Args: {
+      Positional: [items: ArrayLike<T> | null | undefined];
+      Named: { key?: string };
+    };
+    Blocks: {
+      default: [T, number];
+      else: [];
+    };
+  }>
+>;

package/types/-private/intrinsics/fn.d.ts

@@ -0,0 +1,44 @@
+import { DirectInvokable } from '@glint/template/-private/integration';
+import { Mut } from './mut';
+
+export type FnHelper = DirectInvokable<{
+  <T>(update: Mut<T>): (value: T) => void;
+  <T>(update: Mut<T>, value: T): () => void;
+  <Ret, Args extends unknown[]>(f: (...rest: Args) => Ret): (...rest: Args) => Ret;
+  <A, Ret, Args extends unknown[]>(f: (a: A, ...rest: Args) => Ret, a: A): (...rest: Args) => Ret;
+  <A, B, Ret, Args extends unknown[]>(
+    f: (a: A, b: B, ...rest: Args) => Ret,
+    a: A,
+    b: B,
+  ): (...rest: Args) => Ret;
+  <A, B, C, Ret, Args extends unknown[]>(
+    f: (a: A, b: B, c: C, ...rest: Args) => Ret,
+    a: A,
+    b: B,
+    c: C,
+  ): (...rest: Args) => Ret;
+  <A, B, C, D, Ret, Args extends unknown[]>(
+    f: (a: A, b: B, c: C, d: D, ...rest: Args) => Ret,
+    a: A,
+    b: B,
+    c: C,
+    d: D,
+  ): (...rest: Args) => Ret;
+  <A, B, C, D, E, Ret, Args extends unknown[]>(
+    f: (a: A, b: B, c: C, d: D, e: E, ...rest: Args) => Ret,
+    a: A,
+    b: B,
+    c: C,
+    d: D,
+    e: E,
+  ): (...rest: Args) => Ret;
+  <A, B, C, D, E, G, Ret, Args extends unknown[]>(
+    f: (a: A, b: B, c: C, d: D, e: E, g: G, ...rest: Args) => Ret,
+    a: A,
+    b: B,
+    c: C,
+    d: D,
+    e: E,
+    g: G,
+  ): (...rest: Args) => Ret;
+}>;

package/types/-private/intrinsics/get.d.ts

@@ -0,0 +1,31 @@
+import { DirectInvokable } from '@glint/template/-private/integration';
+import ObjectProxy from '@ember/object/proxy';
+import '@ember/object/-private/types';
+
+// This hack lets us support both the stable/preview types from `ember-source`
+// and the classic types still live on DefinitelyTyped. If using the DT types,
+// this acts as a declaration merge for a module which is then integrated via
+// the rest of the DT types. If using the stable/preview types, this ends up
+// being a no-op.
+declare const GetSetMarker: unique symbol;
+declare module '@ember/object/-private/types' {
+  interface ComputedPropertyMarker<Get, Set = Get> {
+    [GetSetMarker]: [Get, Set];
+  }
+}
+
+type UnwrapComputedPropertyGetter<T> = T extends { [GetSetMarker]: [infer U, any] } ? U : T;
+
+export type GetHelper = DirectInvokable<{
+  <T, K extends keyof T>(obj: T, key: K): UnwrapComputedPropertyGetter<T[K]>;
+  <T, K extends keyof T>(
+    obj: T | null | undefined,
+    key: K,
+  ): UnwrapComputedPropertyGetter<T[K]> | undefined;
+  <T extends object, K extends keyof T>(
+    obj: ObjectProxy<T> | null | undefined,
+    key: K,
+  ): UnwrapComputedPropertyGetter<T[K]> | undefined;
+  (obj: null | undefined, key: string): undefined;
+  (obj: unknown, key: string): unknown;
+}>;

package/types/-private/intrinsics/input.d.ts

@@ -0,0 +1,24 @@
+import { ComponentLike } from '@glint/template';
+
+export interface CheckboxInputArgs {
+  type: 'checkbox';
+  checked?: boolean | undefined;
+}
+
+export interface TextInputArgs {
+  type?: string | undefined;
+  value?: string | null | undefined;
+  enter?: ((value: string, event: KeyboardEvent) => void) | undefined;
+  'insert-newline'?: ((value: string, event: KeyboardEvent) => void) | undefined;
+  'escape-press'?: ((value: string, event: KeyboardEvent) => void) | undefined;
+  'focus-in'?: ((value: string, event: FocusEvent) => void) | undefined;
+  'focus-out'?: ((value: string, event: FocusEvent) => void) | undefined;
+  'key-down'?: ((value: string, event: KeyboardEvent) => void) | undefined;
+  'key-press'?: ((value: string, event: KeyboardEvent) => void) | undefined;
+  'key-up'?: ((value: string, event: KeyboardEvent) => void) | undefined;
+}
+
+export type InputComponent = ComponentLike<{
+  Args: { Named: CheckboxInputArgs | TextInputArgs };
+  Element: HTMLInputElement;
+}>;

package/types/-private/intrinsics/link-to.d.ts

@@ -0,0 +1,31 @@
+import { ComponentLike } from '@glint/template';
+import { ComponentReturn, DirectInvokable, NamedArgs } from '@glint/template/-private/integration';
+
+type RequireAtLeastOne<T, Keys extends keyof T = keyof T> = Pick<T, Exclude<keyof T, Keys>> &
+  {
+    [K in Keys]-?: Required<Pick<T, K>> & Partial<Pick<T, Exclude<Keys, K>>>;
+  }[Keys];
+
+type LinkToArgs = RequireAtLeastOne<
+  {
+    route?: string;
+    model?: unknown;
+    models?: unknown[];
+    query?: Record<string, unknown>;
+    disabled?: boolean;
+    activeClass?: string;
+    'current-when'?: string | boolean;
+    preventDefault?: boolean;
+    replace?: boolean;
+    tagName?: string;
+  },
+  'route' | 'model' | 'models' | 'query'
+>;
+
+type LinkToReturn = ComponentReturn<{ default: [] }, HTMLAnchorElement>;
+
+export type LinkToComponent = ComponentLike<{
+  Args: LinkToArgs;
+  Blocks: { default: [] };
+  Element: HTMLAnchorElement;
+}>;

package/types/-private/intrinsics/log.d.ts

@@ -0,0 +1,6 @@
+import { HelperLike } from '@glint/template';
+
+export type LogHelper = HelperLike<{
+  Args: { Positional: unknown[] };
+  Return: void;
+}>;

package/types/-private/intrinsics/mount.d.ts

@@ -0,0 +1,9 @@
+import { HelperLike } from '@glint/template';
+
+export type MountKeyword = HelperLike<{
+  Args: {
+    Positional: [engine: string];
+    Named: { model?: unknown };
+  };
+  Return: void;
+}>;

package/types/-private/intrinsics/mut.d.ts

@@ -0,0 +1,14 @@
+import { HelperLike } from '@glint/template';
+
+declare const Mut: unique symbol;
+
+export type Mut<T> = { [Mut]: (value: T) => void };
+
+export type MutKeyword = abstract new <T>() => InstanceType<
+  HelperLike<{
+    Args: {
+      Positional: [value: T];
+    };
+    Return: Mut<T>;
+  }>
+>;