@discourse/types 0.0.0 → 0.0.2

package/external-types/@glint__ember-tsc/lib/transform/template/rewrite-module.d.ts

@@ -0,0 +1,24 @@
+declare module '@glint/ember-tsc/transform/template/rewrite-module' {
+import { GlintEnvironment } from '../../config/index.js';
+import { TSLib } from '../util.js';
+import TransformedModule, { SourceFile } from './transformed-module.js';
+/**
+ * Input to the process of rewriting a template, containing:
+ *   script: the backing JS/TS module for a component, which may contain
+ *           embedded templates depending on the environment
+ */
+export type RewriteInput = {
+    script: SourceFile;
+};
+/**
+ * Given the script and/or template that together comprise a component module,
+ * returns a `TransformedModule` representing the combined result, with the
+ * template(s), either alongside or inline, rewritten into equivalent TypeScript
+ * in terms of the active glint environment's exported types.
+ *
+ * May return `null` if an unrecoverable parse error occurs or if there is
+ * no transformation to be done.
+ */
+export declare function rewriteModule(ts: TSLib, { script }: RewriteInput, environment: GlintEnvironment, clientId?: string): TransformedModule | null;
+//# sourceMappingURL=rewrite-module.d.ts.map
+}

package/external-types/@glint__ember-tsc/lib/transform/template/scope-stack.d.ts

@@ -0,0 +1,15 @@
+declare module '@glint/ember-tsc/transform/template/scope-stack' {
+/**
+ * A `ScopeStack` is used while traversing a template
+ * to track what identifiers are currently in scope.
+ */
+export default class ScopeStack {
+    private stack;
+    constructor(identifiers: string[]);
+    push(identifiers: Array<string>): void;
+    pop(): void;
+    hasBinding(identifier: string): boolean;
+    private get top();
+}
+//# sourceMappingURL=scope-stack.d.ts.map
+}

package/external-types/@glint__ember-tsc/lib/transform/template/template-to-typescript.d.ts

@@ -0,0 +1,21 @@
+declare module '@glint/ember-tsc/transform/template/template-to-typescript' {
+import { GlintEmitMetadata, GlintSpecialForm } from '@glint/ember-tsc/config-types';
+import { EmbeddingSyntax, RewriteResult } from './map-template-contents.js';
+export type TemplateToTypescriptOptions = {
+    typesModule: string;
+    meta?: GlintEmitMetadata | undefined;
+    globals?: Array<string> | undefined;
+    backingValue?: string;
+    preamble?: Array<string>;
+    embeddingSyntax?: EmbeddingSyntax;
+    useJsDoc?: boolean;
+    specialForms?: Record<string, GlintSpecialForm>;
+};
+/**
+ * Given the text contents of a template, returns a  TypeScript representation
+ * of that template's contents, as well as a mapping of offsets and ranges between
+ * the original and transformed contents.
+ */
+export declare function templateToTypescript(originalTemplate: string, { typesModule, globals, meta, backingValue, preamble, embeddingSyntax, specialForms, useJsDoc, }: TemplateToTypescriptOptions): RewriteResult;
+//# sourceMappingURL=template-to-typescript.d.ts.map
+}

package/external-types/@glint__ember-tsc/lib/transform/template/transformed-module.d.ts

@@ -0,0 +1,113 @@
+declare module '@glint/ember-tsc/transform/template/transformed-module' {
+import type { AST } from '@glimmer/syntax';
+import { CodeMapping } from '@volar/language-core';
+import GlimmerASTMappingTree from './glimmer-ast-mapping-tree.js';
+export type Range = {
+    start: number;
+    end: number;
+};
+export type RangeWithMapping = Range & {
+    mapping?: GlimmerASTMappingTree;
+};
+export type RangeWithMappingAndSource = RangeWithMapping & {
+    source: SourceFile;
+};
+export type CorrelatedSpan = {
+    /** Where this span of content originated */
+    originalFile: SourceFile;
+    /** The offset where this content began in its original source */
+    originalStart: number;
+    /** The length of this span's content in its original source */
+    originalLength: number;
+    /** The location in the untransformed source where this span is spliced in */
+    insertionPoint: number;
+    /** The contents of this span in the transformed output */
+    transformedSource: string;
+    /** The offset in the transformed output of this span */
+    transformedStart: number;
+    /** The length of this span in the transformed output */
+    transformedLength: number;
+    /** (Glimmer/Handlebars spans only:) A mapping of offsets within this span between its original and transformed versions */
+    glimmerAstMapping?: GlimmerASTMappingTree;
+};
+export type DirectiveKind = 'ignore' | 'expect-error' | 'nocheck';
+export type Directive = {
+    kind: DirectiveKind;
+    commentNode: AST.CommentStatement | AST.MustacheCommentStatement;
+    source: SourceFile;
+    location: Range;
+    areaOfEffect: Range;
+    /** The number of errors that have been reported for this directive */
+    errorCount: number;
+};
+export type TransformError = {
+    isContentTagError?: boolean;
+    message: string;
+    location: Range;
+    source: SourceFile;
+};
+export type SourceFile = {
+    filename: string;
+    contents: string;
+};
+export type TemplateSymbol = {
+    start: number;
+    end: number;
+    startTagEnd: number;
+};
+/**
+ * This class represents the result of transforming a TypeScript
+ * module with one or more embedded HBS templates. It contains
+ * both the original and transformed source text of the module, as
+ * well any errors encountered during transformation.
+ *
+ * It is used heavily for bidirectional source mapping between the original TS/HBS code
+ * and the singular transformed TS output (aka the Intermediate Representation).
+ * It can be queried with an offset or range in either the
+ * original or transformed source to determine the corresponding
+ * offset or range in the other.
+ */
+export default class TransformedModule {
+    readonly transformedContents: string;
+    readonly errors: ReadonlyArray<TransformError>;
+    readonly directives: ReadonlyArray<Directive>;
+    readonly correlatedSpans: Array<CorrelatedSpan>;
+    readonly originalFileName: string;
+    constructor(transformedContents: string, errors: ReadonlyArray<TransformError>, directives: ReadonlyArray<Directive>, correlatedSpans: Array<CorrelatedSpan>, originalFileName: string);
+    toDebugString(): string;
+    getOriginalOffset(transformedOffset: number): {
+        source?: SourceFile;
+        offset: number;
+    };
+    getTransformedOffset(originalFileName: string, originalOffset: number): number;
+    getOriginalRange(transformedStart: number, transformedEnd: number): RangeWithMappingAndSource;
+    getTransformedRange(originalFileName: string, originalStart: number, originalEnd: number): RangeWithMapping;
+    getExactTransformedRanges(originalFileName: string, originalStart: number, originalEnd: number): GlimmerASTMappingTree[];
+    findTemplateAtOriginalOffset(originalFileName: string, originalOffset: number): {
+        originalContentStart: number;
+        originalContentEnd: number;
+        originalContent: string;
+    } | null;
+    private determineOriginalOffsetAndSpan;
+    private determineTransformedOffsetAndSpan;
+    /**
+     * Converts the mappings in this transformed module to the format expected by Volar.
+     *
+     * The main difference between the two formats is that while the classic Glint transformation
+     * mappings support mapping a differently sized source region to a differently sized target region
+     * (e.g. `{{expectsAtLeastOneArg}}` in an .hbs file to `__glintDSL__.emitContent(__glintDSL__.resolveOrReturn(expectsAtLeastOneArg)());`
+     * in a generated TS file, in Volar you can only map regions of the same size.
+     *
+     * In the case that you need to map regions of different sizes in Volar, you need to use
+     * zero-length mappings to delineate regions/boundaries that should map to each other, otherwise there will
+     * be cases where TS diagnostics will fail to transform/map back to the original source. Example:
+     *
+     * - `{{[[ZEROLEN-A]][[expectsAtLeastOneArg]][[ZEROLEN-B]]}}`
+     * - to
+     * - `[[ZEROLEN-A]]__glintDSL__.emitContent(__glintDSL__.resolveOrReturn([[expectsAtLeastOneArg]])());[[ZEROLEN-B]]`
+     */
+    toVolarMappings(filenameFilter?: string): CodeMapping[];
+    templateSymbols(): Array<TemplateSymbol>;
+}
+//# sourceMappingURL=transformed-module.d.ts.map
+}

package/external-types/@glint__ember-tsc/lib/transform/util.d.ts

@@ -0,0 +1,9 @@
+declare module '@glint/ember-tsc/transform/util' {
+import type ts from 'typescript';
+import { SourceFile } from './template/transformed-module.js';
+export type TSLib = typeof ts;
+export declare function unreachable(value: never, message?: string): never;
+export declare function assert(test: unknown, message?: string | (() => string)): asserts test;
+export declare function createSyntheticSourceFile(ts: TSLib, source: SourceFile): ts.SourceFile;
+//# sourceMappingURL=util.d.ts.map
+}

package/external-types/@glint__ember-tsc/lib/volar/ember-language-plugin.d.ts

@@ -0,0 +1,16 @@
+declare module '@glint/ember-tsc/volar/ember-language-plugin' {
+import { LanguagePlugin } from '@volar/language-core';
+import type ts from 'typescript';
+import { URI } from 'vscode-uri';
+import { GlintConfig } from '../index.js';
+export type TS = typeof ts;
+/**
+ * Create a [Volar](https://volarjs.dev) language plugin to support
+ *
+ * - .gts/.gjs files (the `ember-template-imports` environment)
+ */
+export declare function createEmberLanguagePlugin<T extends URI | string>(glintConfig: GlintConfig, { clientId }?: {
+    clientId?: string;
+}): LanguagePlugin<T>;
+//# sourceMappingURL=ember-language-plugin.d.ts.map
+}

package/external-types/@glint__ember-tsc/lib/volar/gts-virtual-code.d.ts

@@ -0,0 +1,85 @@
+declare module '@glint/ember-tsc/volar/gts-virtual-code' {
+import { CodeMapping, VirtualCode } from '@volar/language-core';
+import type ts from 'typescript';
+import { IScriptSnapshot } from 'typescript';
+import { GlintConfig } from '../index.js';
+import { Directive, rewriteModule } from '../transform/index.js';
+export type TS = typeof ts;
+interface EmbeddedCodeWithDirectives extends VirtualCode {
+    directives: readonly Directive[];
+}
+/**
+ * A Volar VirtualCode representing .gts/.gjs files, which includes 0+ embedded
+ * Handlebars templates within <template> tags.
+ *
+ * ## Virtual Code Overview (and how we use it)
+ *
+ * VirtualCodes are one of the most core/central primitives provided by Volar.
+ * They are:
+ *
+ * - Used both in (classic) Language Server mode and in newer TS Plugin mode
+ * - Responsible for parsing and transforming source code of a particular language (e.g. GTS)
+ *   into embedded codes (e.g. a valid type-checkable TS file wherein all `<template>` tags
+ *   have been replaced with valid TS code)
+ *
+ * ## Embedded Codes
+ *
+ * The VirtualCode interface has an `embeddedCodes` array that (typically) contains
+ * generated code based on the root virtual code file type (in our case, GTS). The generated
+ * embedded codes will typically have a different file type ID (e.g. `typescript`); Volar
+ * in turn can perform language processing on these specific files (e.g. generate diagnostics),
+ * and then propagate these diagnostics upwards to the root virtual code file. In order to do this,
+ * we need to provide source code mapping information so that Volar can correctly map the diagnostics
+ * back to the original source code.
+ *
+ * Note that "embedded code" can be somewhat of a confusing concept based on how familiar
+ * languages like HTML allow other languages (JS in script tags, CSS in style tags, etc.)
+ * to be embedded within a parent file (e.g. HTML). If you were building a VirtualCode for HTML,
+ * you would have an `embeddedCodes` array that contains VirtualCodes for the embedded languages,
+ * where each VirtualCode had the extracted HTML, CSS, JS, etc contents.
+ *
+ * But for GTS, the embedded code that we generate does not actually exist in the same form in
+ * the parent document (the .gts file); rather, the embedded code is a valid TS file that has
+ * been generated from the .gts by replacing all of the embedded `<template>`s with TS. Whereas
+ * for HTML, embedded codes are simple extracted strings of HTML, CSS, JS, etc, for GTS, the
+ * embedded code is a transformed file that's most likely much larger than the original .gts file.
+ *
+ * Additionally:
+ *
+ * - We always generate an embedded code of TypeScript even when the .gts file has no embedded templates
+ *   (meaning it is already valid TS). This keeps both our code and the structure of our VirtualCode
+ *   simple and consistent. In cases where there are no embedded templates, the embedded code contains
+ *   the same contents as the root virtual code file.
+ *
+ * - Even when there are multiple <template> tags, we only generate 1 embedded TS code representing
+ *   the TS code for all of the entire .gts file.
+ *
+ * - The Root VirtualCode we provide is simple the untransformed .gts file itself. This is a Volar
+ *   convention and also allows for the possible of writing language service plugins that operate
+ *   directly on .gts (i.e. `glimmer-ts`) files directly (rather than on an embedded code).
+ *
+ * In summary, `embeddedCodes` is a more general/abstract concept of ANY kind of language that
+ * is embedded or generated from the root virtual code file for the purposes of performing
+ * language service processing for the particular file type of the embedded code.
+ */
+export declare class VirtualGtsCode implements VirtualCode {
+    private glintConfig;
+    snapshot: IScriptSnapshot;
+    languageId: 'glimmer-ts' | 'glimmer-js' | 'typescript.glimmer' | 'javascript.glimmer';
+    clientId?: string | undefined;
+    /**
+     * The virtual files embedded in the GTS file. (such as <template>)
+     */
+    embeddedCodes: EmbeddedCodeWithDirectives[];
+    /**
+     * The id is a unique (within the VirtualCode and its embedded files) id for Volar to identify it. It could be any string.
+     */
+    id: string;
+    mappings: CodeMapping[];
+    transformedModule: ReturnType<typeof rewriteModule> | null;
+    constructor(glintConfig: GlintConfig, snapshot: IScriptSnapshot, languageId: 'glimmer-ts' | 'glimmer-js' | 'typescript.glimmer' | 'javascript.glimmer', clientId?: string | undefined);
+    update(snapshot: IScriptSnapshot): void;
+}
+export {};
+//# sourceMappingURL=gts-virtual-code.d.ts.map
+}

package/external-types/@glint__ember-tsc/lib/volar/language-server.d.ts

@@ -0,0 +1,4 @@
+declare module '@glint/ember-tsc/volar/language-server' {
+export {};
+//# sourceMappingURL=language-server.d.ts.map
+}

package/external-types/@glint__ember-tsc/lib/volar/script-snapshot.d.ts

@@ -0,0 +1,19 @@
+declare module '@glint/ember-tsc/volar/script-snapshot' {
+/**
+ * @typedef {import('typescript').IScriptSnapshot} IScriptSnapshot
+ */
+import { IScriptSnapshot, TextChangeRange } from 'typescript';
+/**
+ * A TypeScript compatible script snapshot that wraps a string of text.
+ *
+ * @implements {IScriptSnapshot}
+ */
+export declare class ScriptSnapshot implements IScriptSnapshot {
+    text: string;
+    constructor(text: string);
+    getChangeRange(_oldSnapshot: IScriptSnapshot): TextChangeRange | undefined;
+    getLength(): number;
+    getText(start: number, end: number): string;
+}
+//# sourceMappingURL=script-snapshot.d.ts.map
+}

package/external-types/@glint__ember-tsc/package.json

@@ -0,0 +1,104 @@
+{
+  "name": "@glint/ember-tsc",
+  "version": "1.0.8",
+  "repository": "typed-ember/glint",
+  "description": "A CLI for performing typechecking on Glimmer templates",
+  "license": "MIT",
+  "author": "Dan Freeman (https://github.com/dfreeman)",
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./lib/index.d.ts",
+      "default": "./lib/index.js"
+    },
+    "./config-types": {
+      "types": "./lib/config/types.d.cts",
+      "default": "./lib/config/types.cjs"
+    },
+    "./bin/*": "./bin/*.js",
+    "./globals": "./types/globals/index.d.ts",
+    "./-private/dsl": {
+      "types": "./types/-private/dsl/index.d.ts",
+      "default": "./types/-private/dsl/index.d.ts"
+    },
+    "./types": "./types/-private/dsl/integration-declarations.d.ts",
+    "./-private/dsl/globals": "./types/-private/dsl/globals.d.ts",
+    "./-private/intrinsics/action": "./types/-private/intrinsics/action.d.ts",
+    "./-private/intrinsics/concat": "./types/-private/intrinsics/concat.d.ts",
+    "./-private/intrinsics/each": "./types/-private/intrinsics/each.d.ts",
+    "./-private/intrinsics/each-in": "./types/-private/intrinsics/each-in.d.ts",
+    "./-private/intrinsics/fn": "./types/-private/intrinsics/fn.d.ts",
+    "./-private/intrinsics/get": "./types/-private/intrinsics/get.d.ts",
+    "./-private/intrinsics/log": "./types/-private/intrinsics/log.d.ts",
+    "./-private/intrinsics/mount": "./types/-private/intrinsics/mount.d.ts",
+    "./-private/intrinsics/mut": "./types/-private/intrinsics/mut.d.ts",
+    "./-private/intrinsics/on": "./types/-private/intrinsics/on.d.ts",
+    "./-private/intrinsics/outlet": "./types/-private/intrinsics/outlet.d.ts",
+    "./-private/intrinsics/unbound": "./types/-private/intrinsics/unbound.d.ts",
+    "./-private/intrinsics/unique-id": "./types/-private/intrinsics/unique-id.d.ts",
+    "./*": {
+      "types": "./lib/*.d.ts",
+      "default": "./lib/*.js"
+    }
+  },
+  "files": [
+    "README.md",
+    "lib",
+    "bin",
+    "src",
+    "types"
+  ],
+  "bin": {
+    "ember-tsc": "bin/ember-tsc.js",
+    "glint-language-server": "bin/glint-language-server.js"
+  },
+  "peerDependencies": {
+    "typescript": ">=5.6.0"
+  },
+  "dependencies": {
+    "@glimmer/syntax": ">= 0.95.0",
+    "@volar/kit": "2.4.23",
+    "@volar/language-core": "2.4.23",
+    "@volar/language-server": "2.4.23",
+    "@volar/language-service": "2.4.23",
+    "@volar/source-map": "2.4.23",
+    "@volar/test-utils": "2.4.23",
+    "@volar/typescript": "2.4.23",
+    "computeds": "^0.0.1",
+    "content-tag": "^3.1.2",
+    "escape-string-regexp": "^4.0.0",
+    "semver": "^7.5.2",
+    "silent-error": "^1.1.1",
+    "uuid": "^8.3.2",
+    "volar-service-typescript": "0.0.65",
+    "volar-service-html": "0.0.64",
+    "vscode-languageserver-protocol": "^3.17.5",
+    "vscode-languageserver-textdocument": "^1.0.5",
+    "vscode-uri": "^3.0.8",
+    "yargs": "^17.5.1",
+    "@glint/template": "1.7.3"
+  },
+  "devDependencies": {
+    "@glimmer/component": "^2.0.0",
+    "@types/common-tags": "^1.8.0",
+    "@types/node": "^18.11.5",
+    "@types/semver": "^7.3.13",
+    "@types/uuid": "^8.3.4",
+    "@types/yargs": "^17.0.10",
+    "@typescript/server-harness": "latest",
+    "@vitest/ui": "~1.0.0",
+    "common-tags": "^1.8.0",
+    "execa": "^4.0.1",
+    "strip-ansi": "^6.0.0",
+    "typescript": ">=5.6.0",
+    "@glint/type-test": "2.0.0",
+    "glint-monorepo-test-utils": "0.0.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "tsc --build",
+    "dev": "tsc --watch"
+  }
+}

package/external-types/@glint__ember-tsc/types/-private/dsl/globals.d.ts

@@ -0,0 +1,207 @@
+declare module '@glint/ember-tsc/-private/dsl/globals' {
+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;
+
+}