@discourse/types 0.0.1 → 2026.1.0-a5a0839

package/external-types/@glimmer__syntax/package.json

@@ -0,0 +1,54 @@
+{
+  "name": "@glimmer/syntax",
+  "version": "0.93.1",
+  "license": "MIT",
+  "repository": "https://github.com/glimmerjs/glimmer-vm/tree/main/packages/@glimmer/syntax",
+  "type": "module",
+  "exports": {
+    ".": {
+      "require": {
+        "types": "./dist/dev/index.d.cts",
+        "default": "./dist/dev/index.cjs"
+      },
+      "default": {
+        "development": {
+          "types": "./dist/dev/index.d.ts",
+          "default": "./dist/dev/index.js"
+        },
+        "default": {
+          "types": "./dist/prod/index.d.ts",
+          "default": "./dist/prod/index.js"
+        }
+      }
+    }
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "files": [
+    "dist"
+  ],
+  "dependencies": {
+    "@handlebars/parser": "~2.0.0",
+    "simple-html-tokenizer": "^0.5.11",
+    "@glimmer/interfaces": "0.93.0",
+    "@glimmer/util": "0.93.1",
+    "@glimmer/wire-format": "0.93.1"
+  },
+  "devDependencies": {
+    "@types/qunit": "^2.19.9",
+    "eslint": "^8.52.0",
+    "publint": "^0.2.5",
+    "rollup": "^4.5.1",
+    "typescript": "*",
+    "@glimmer-workspace/build-support": "1.0.0",
+    "@glimmer/debug-util": "0.92.3",
+    "@glimmer/local-debug-flags": "0.92.0"
+  },
+  "scripts": {
+    "build": "rollup -c rollup.config.mjs",
+    "test:lint": "eslint .",
+    "test:publint": "publint",
+    "test:types": "tsc --noEmit -p ../tsconfig.json"
+  }
+}

package/external-types/@glint__ember-tsc/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023 The Ember TypeScript team and contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/external-types/@glint__ember-tsc/lib/cli/run-volar-tsc.d.ts

@@ -0,0 +1,4 @@
+declare module '@glint/ember-tsc/cli/run-volar-tsc' {
+export declare function run(): void;
+//# sourceMappingURL=run-volar-tsc.d.ts.map
+}

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

@@ -0,0 +1,17 @@
+declare module '@glint/ember-tsc/config/config' {
+import { GlintConfigInput } from '@glint/ember-tsc/config-types';
+import { GlintEnvironment } from './environment.js';
+/**
+ * This class represents parsed Glint configuration from a `tsconfig` or `jsconfig` file,
+ * with methods for interrogating project configuration based on its contents.
+ */
+export declare class GlintConfig {
+    readonly ts: typeof import('typescript');
+    readonly rootDir: string;
+    readonly configPath: string;
+    readonly environment: GlintEnvironment;
+    constructor(ts: typeof import('typescript'), configPath: string, config: GlintConfigInput);
+}
+export declare function normalizePath(fileName: string): string;
+//# sourceMappingURL=config.d.ts.map
+}

package/external-types/@glint__ember-tsc/lib/config/environment.d.ts

@@ -0,0 +1,28 @@
+declare module '@glint/ember-tsc/config/environment' {
+import { GlintEnvironmentConfig, GlintExtensionConfig, GlintExtensionsConfig, GlintTagsConfig, SourceKind } from '@glint/ember-tsc/config-types';
+export declare const DEFAULT_EXTENSIONS: GlintExtensionsConfig;
+/**
+ * A GlintEnvironment represents the _merged_ configurations of one or more
+ * glint environments (e.g. ember-template-imports).
+ */
+export declare class GlintEnvironment {
+    readonly names: Array<string>;
+    private tagConfig;
+    private extensionsConfig;
+    constructor(names: Array<string>, config: GlintEnvironmentConfig);
+    static load(topLevelGlintConfigObject: any): GlintEnvironment;
+    getSourceKind(fileName: string): SourceKind | 'unknown';
+    isUntypedScript(path: string): boolean;
+    /**
+     * Returns any custom configuration for the given file extension.
+     */
+    getConfigForExtension(extension: string): GlintExtensionConfig | undefined;
+    /**
+     * Returns an array of template tags that should be rewritten according to this
+     * config object, along with an import specifier indicating where the template types
+     * for each tag can be found.
+     */
+    getConfiguredTemplateTags(): GlintTagsConfig;
+}
+//# sourceMappingURL=environment.d.ts.map
+}

package/external-types/@glint__ember-tsc/lib/config/index.d.ts

@@ -0,0 +1,19 @@
+declare module '@glint/ember-tsc/config/' {
+import { GlintConfig } from './config.js';
+export { GlintConfig } from './config.js';
+export { GlintEnvironment } from './environment.js';
+export { ConfigLoader, findTypeScript } from './loader.js';
+/**
+ * Loads glint configuration, starting from the given directory
+ * and searching upwards and raising an error if no configuration
+ * is found.
+ */
+export declare function loadConfig(from: string): GlintConfig;
+/**
+ * Loads glint configuration, starting from the given directory
+ * and searching upwards. Returns `null` if no configuration is
+ * found.
+ */
+export declare function findConfig(from: string): GlintConfig | null;
+//# sourceMappingURL=index.d.ts.map
+}

package/external-types/@glint__ember-tsc/lib/config/loader.d.ts

@@ -0,0 +1,27 @@
+declare module '@glint/ember-tsc/config/loader' {
+import { GlintConfigInput } from '@glint/ember-tsc/config-types';
+import type TS from 'typescript';
+import { GlintConfig } from './config.js';
+/**
+ * @private
+ *
+ * Only exported for testing purposes. Do not import.
+ */
+export declare const require: NodeJS.Require;
+type TypeScript = typeof TS;
+/**
+ * `ConfigLoader` provides an interface for finding the Glint config that
+ * applies to a given file or directory, ensuring that only a single instance
+ * of `GlintConfig` is ever created for a given `tsconfig.json` or
+ * `jsconfig.json` source file.
+ */
+export declare class ConfigLoader {
+    private configs;
+    configForFile(filePath: string): GlintConfig | null;
+    configForDirectory(directory: string): GlintConfig | null;
+}
+export declare function findTypeScript(fromDir: string): TypeScript | null;
+export declare function loadConfigInput(ts: TypeScript, entryPath: string): GlintConfigInput | null;
+export {};
+//# sourceMappingURL=loader.d.ts.map
+}

package/external-types/@glint__ember-tsc/lib/config/types.d.cts

@@ -0,0 +1,62 @@
+declare module '@glint/ember-tsc/config-types' {
+import type ts from 'typescript';
+type TSLib = typeof ts;
+export type GlintConfigInput = {
+    environment: string | Array<string> | Record<string, unknown>;
+};
+export type GlintEnvironmentConfig = {
+    tags?: GlintTagsConfig;
+    extensions?: GlintExtensionsConfig;
+};
+export type GlintExtensionPreprocess<T> = (source: string, filePath: string) => {
+    contents: string;
+    data?: T;
+};
+export type GlintEmitMetadata = {
+    prepend?: string;
+    append?: string;
+    templateLocation?: {
+        start: number;
+        end: number;
+        contentStart: number;
+        contentEnd: number;
+    };
+};
+export type GlintExtensionTransform<T> = (data: T, state: {
+    ts: TSLib;
+    context: ts.TransformationContext;
+    setEmitMetadata: (node: ts.TaggedTemplateExpression, meta: GlintEmitMetadata) => void;
+}) => ts.Transformer<ts.Node>;
+export type GlintSpecialForm = 'if' | 'if-not' | 'yield' | 'object-literal' | 'array-literal' | 'bind-invokable' | '===' | '!==' | '&&' | '||' | '!';
+export type GlintSpecialFormConfig = {
+    globals?: {
+        [global: string]: GlintSpecialForm;
+    };
+    imports?: {
+        [path: string]: {
+            [identifier: string]: GlintSpecialForm;
+        };
+    };
+};
+export type SourceKind = 'typed-script' | 'untyped-script';
+export type GlintExtensionConfig<PreprocessData = any> = {
+    kind: SourceKind;
+    preprocess?: GlintExtensionPreprocess<PreprocessData>;
+    transform?: GlintExtensionTransform<PreprocessData>;
+};
+export type GlintExtensionsConfig = {
+    [extension: string]: GlintExtensionConfig;
+};
+export type GlintTagConfig = {
+    typesModule: string;
+    globals?: Array<string>;
+    specialForms?: GlintSpecialFormConfig;
+};
+export type GlintTagsConfig = {
+    [importSource: string]: {
+        [importSpecifier: string]: GlintTagConfig;
+    };
+};
+export {};
+//# sourceMappingURL=types.d.cts.map
+}

package/external-types/@glint__ember-tsc/lib/environment-ember-template-imports/-private/environment/common.d.ts

@@ -0,0 +1,15 @@
+declare module '@glint/ember-tsc/environment-ember-template-imports/-private/environment/common' {
+export type PreprocessData = {
+    templateLocations: Array<TemplateLocation>;
+};
+export type TemplateLocation = {
+    startTagOffset: number;
+    startTagLength: number;
+    endTagOffset: number;
+    endTagLength: number;
+    transformedStart: number;
+    transformedEnd: number;
+};
+export declare const GLOBAL_TAG = "___T";
+//# sourceMappingURL=common.d.ts.map
+}

package/external-types/@glint__ember-tsc/lib/environment-ember-template-imports/-private/environment/index.d.ts

@@ -0,0 +1,5 @@
+declare module '@glint/ember-tsc/environment-ember-template-imports/-private/environment/' {
+import { GlintEnvironmentConfig } from '@glint/ember-tsc/config-types';
+export default function emberTemplateImportsEnvironment(options: Record<string, unknown>): GlintEnvironmentConfig;
+//# sourceMappingURL=index.d.ts.map
+}

package/external-types/@glint__ember-tsc/lib/environment-ember-template-imports/-private/environment/preprocess.d.ts

@@ -0,0 +1,6 @@
+declare module '@glint/ember-tsc/environment-ember-template-imports/-private/environment/preprocess' {
+import { GlintExtensionPreprocess } from '@glint/ember-tsc/config-types';
+import { PreprocessData } from './common.js';
+export declare const preprocess: GlintExtensionPreprocess<PreprocessData>;
+//# sourceMappingURL=preprocess.d.ts.map
+}

package/external-types/@glint__ember-tsc/lib/environment-ember-template-imports/-private/environment/transform.d.ts

@@ -0,0 +1,6 @@
+declare module '@glint/ember-tsc/environment-ember-template-imports/-private/environment/transform' {
+import { GlintExtensionTransform } from '@glint/ember-tsc/config-types';
+import { PreprocessData } from './common.js';
+export declare const transform: GlintExtensionTransform<PreprocessData>;
+//# sourceMappingURL=transform.d.ts.map
+}

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

@@ -0,0 +1,9 @@
+declare module '@glint/ember-tsc' {
+import { GlintConfig, loadConfig, findConfig } from './config/index.js';
+import { createEmberLanguagePlugin } from './volar/ember-language-plugin.js';
+import { VirtualGtsCode } from './volar/gts-virtual-code.js';
+import { augmentDiagnostics } from './transform/diagnostics/augmentation.js';
+export { loadConfig, findConfig, createEmberLanguagePlugin, VirtualGtsCode, augmentDiagnostics };
+export type { GlintConfig };
+//# sourceMappingURL=index.d.ts.map
+}

package/external-types/@glint__ember-tsc/lib/plugins/g-compiler-errors.d.ts

@@ -0,0 +1,14 @@
+declare module '@glint/ember-tsc/plugins/g-compiler-errors' {
+import type { LanguageServicePlugin } from '@volar/language-service';
+/**
+ * This LanguageServicePlugin surfaces compiler/syntax errors as diagnostics
+ * within .gts/.gjs files, e.g. if there is an unclosed html tag or `{{` curly brace,
+ * the entire `<template>` tag region will be highlighted as an error.
+ *
+ * @GLINT_FEATURE_DIAGNOSTICS
+ * @GLINT_FEATURE_DIAGNOSTICS_LANGUAGE_SERVER
+ * @GLINT_FEATURE_DIAGNOSTICS_LANGUAGE_SERVER_GTS_COMPILER_ERRORS
+ */
+export declare function create(): LanguageServicePlugin;
+//# sourceMappingURL=g-compiler-errors.d.ts.map
+}

package/external-types/@glint__ember-tsc/lib/plugins/g-template-tag-symbols.d.ts

@@ -0,0 +1,13 @@
+declare module '@glint/ember-tsc/plugins/g-template-tag-symbols' {
+import type { LanguageServicePlugin } from '@volar/language-service';
+/**
+ * Provides symbols for `<template>` tags within .gts/.gjs files.
+ * This among other things faciliates code folding of the `<template>` region.
+ *
+ * Note that this ONLY provides symbols for the `<template>` tag and none of the
+ * contents of the template tag. Symbols inside or outside the template tag are actually
+ * generated by the syntactic TS LanguageServicePlugin (search `createTypeScriptSyntacticPlugin`).
+ */
+export declare function create(): LanguageServicePlugin;
+//# sourceMappingURL=g-template-tag-symbols.d.ts.map
+}

package/external-types/@glint__ember-tsc/lib/plugins/utils.d.ts

@@ -0,0 +1,27 @@
+declare module '@glint/ember-tsc/plugins/utils' {
+import { type LanguageServiceContext, type SourceScript, type TextDocument, type VirtualCode } from '@volar/language-service';
+import { URI } from 'vscode-uri';
+import { VirtualGtsCode } from '../volar/gts-virtual-code.js';
+type EmbeddedInfo = {
+    sourceScript: Required<SourceScript<URI>>;
+    virtualCode: VirtualCode;
+    root: VirtualGtsCode;
+};
+/**
+ * Helper function that accepts a document URI and, if it matches the format
+ * of Volar's special URI format for representing embedded codes within a virtual code,
+ * will look up and return the embedded code and its root VirtualGtsCode.
+ *
+ * A example Volar embedded document URI would be something like:
+ *
+ *    volar-embedded-content://gts/file%253A%252F%252F%252FUsers%252Fmachty%252Fcode%252Fglint%252Ftest-packages%252Fts-template-imports-app%252Fsrc%252Fempty-fixture.gts
+ *
+ * Note that the hostname/authority part of the URI is the embedded code ID, e.g. `gts`. These correspond
+ * to the IDs we assign to parsed embedded virtual codes contained within the root virtual code,
+ * e.g. `ts` corresponds to the TypeScript representation of .gts files where all `<template>` tags
+ * have been converted to type-checkable TS.
+ */
+export declare function getEmbeddedInfo(context: LanguageServiceContext, document: TextDocument, desiredEmbeddedCodeId?: string | ((id: string) => boolean), desiredDocumentLanguageId?: string | ((id: string) => boolean)): EmbeddedInfo | undefined;
+export {};
+//# sourceMappingURL=utils.d.ts.map
+}

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

@@ -0,0 +1,6 @@
+declare module '@glint/ember-tsc/transform/diagnostics/augmentation' {
+import TransformedModule from '../template/transformed-module.js';
+import { Diagnostic } from './index.js';
+export declare function augmentDiagnostics<T extends Diagnostic>(transformedModule: TransformedModule, diagnostics: T[]): T[];
+//# sourceMappingURL=augmentation.d.ts.map
+}

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

@@ -0,0 +1,7 @@
+declare module '@glint/ember-tsc/transform/diagnostics/' {
+import type * as ts from 'typescript';
+export type Diagnostic = ts.Diagnostic & {
+    isContentTagError?: boolean;
+};
+//# sourceMappingURL=index.d.ts.map
+}

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

@@ -0,0 +1,6 @@
+declare module '@glint/ember-tsc/transform/' {
+export type { Directive, default as TransformedModule } from './template/transformed-module.js';
+export type { Diagnostic } from './diagnostics/index.js';
+export { rewriteModule } from './template/rewrite-module.js';
+//# sourceMappingURL=index.d.ts.map
+}

package/external-types/@glint__ember-tsc/lib/transform/template/code-features.d.ts

@@ -0,0 +1,32 @@
+declare module '@glint/ember-tsc/transform/template/code-features' {
+import { CodeInformation } from '@volar/language-server/node.js';
+/**
+ * Based on https://github.com/machty/vue-language-tools/blob/deff856aa8c15f691544e646519215a15aacbef1/packages/language-core/lib/codegen/codeFeatures.ts
+ *
+ * This file exports a "code features" object which provides a useful shorthand/shortcut
+ * for specifying a nubmer of Volar CodeInformation configuration options in the code
+ * we use for mapping between source code (e.g. .gts files) and transformed (i.e. type-checkable TS) code.
+ *
+ * Volar uses the CodeInformation we pass along with each mapping to determine what sort of language
+ * features should be activated/processed for a given span of code.
+ */
+declare const raw: {
+    all: {
+        verification: true;
+        completion: true;
+        semantic: true;
+        navigation: true;
+    };
+    withoutHighlight: {
+        semantic: {
+            shouldHighlight: () => false;
+        };
+        verification: true;
+        navigation: true;
+        completion: true;
+    };
+};
+export declare const codeFeatures: { [K in keyof typeof raw]: CodeInformation; };
+export {};
+//# sourceMappingURL=code-features.d.ts.map
+}

package/external-types/@glint__ember-tsc/lib/transform/template/glimmer-ast-mapping-tree.d.ts

@@ -0,0 +1,82 @@
+declare module '@glint/ember-tsc/transform/template/glimmer-ast-mapping-tree' {
+import { AST } from '@glimmer/syntax';
+import { Range } from './transformed-module.js';
+import { Identifier } from './map-template-contents.js';
+import { CodeInformation } from '@volar/language-server/node.js';
+export type MappingSource = AST.Node | TemplateEmbedding | TextContent | Identifier | ParseError;
+/**
+ * In cases where we're unable to parse a template, we still want to
+ * be able to hold a placeholder mapping so that we can respond sensibly
+ * to offset transformation queries. This class acts as a standin for
+ * the proper AST node we were unable to obtain in such cases.
+ */
+export declare class ParseError {
+    readonly type = "ParseError";
+}
+/**
+ * The Glimmer AST uses `TextNode` for both string arg values on elements
+ * and for top-level text content floating in the DOM itself. Since we
+ * want to treat the two differently (namely, string args may have useful
+ * completion suggestions but plain text doesn't), we use a stand-in
+ * node for the latter.
+ */
+export declare class TextContent {
+    readonly type = "TextContent";
+}
+/**
+ * This node represents the root of an embedded template, including
+ * the surrounding `<template>...</template>` boilerplate that designates
+ * the surrounded contents as a template.
+ */
+export declare class TemplateEmbedding {
+    readonly type = "TemplateEmbedding";
+}
+/**
+ * A `MappingTree` maintains a hierarchy of mappings between ranges of
+ * locations in original and transformed source strings. These mappings
+ * are naturally hierarchical due to the tree structure of the underlying
+ * code.
+ *
+ * For instance, given an expression like `{{foo.bar}}` in a template, a
+ * corresponding expression in TypeScript might be `foo?.bar`. The individual
+ * identifiers `foo` and `bar` map directly to one another, but the full
+ * expressions do as well. By maintaining a full hierarchy of these mappings,
+ * we can always report diagnostics in the template at roughly the same
+ * level of granularity as TS itself uses when reporting on the transformed
+ * output.
+ */
+export default class GlimmerASTMappingTree {
+    transformedRange: Range;
+    originalRange: Range;
+    children: Array<GlimmerASTMappingTree>;
+    sourceNode: MappingSource;
+    codeInformation?: CodeInformation | undefined;
+    parent: GlimmerASTMappingTree | null;
+    constructor(transformedRange: Range, originalRange: Range, children: Array<GlimmerASTMappingTree> | undefined, sourceNode: MappingSource, codeInformation?: CodeInformation | undefined);
+    /**
+     * Returns the mapping corresponding to the smallest span in the transformed source
+     * that contains the given range, or `null` if that range doesn't fall within
+     * this mapping tree.
+     */
+    narrowestMappingForTransformedRange(range: Range): GlimmerASTMappingTree | null;
+    /**
+     * Returns the mapping corresponding to the smallest span in the original source
+     * that contains the given range, or `null` if that range doesn't fall within
+     * this mapping tree.
+     */
+    narrowestMappingForOriginalRange(range: Range): GlimmerASTMappingTree | null;
+    /**
+     * Returns all mappings that exactly match the provided range.
+     */
+    exactMappingsForOriginalRange(range: Range): GlimmerASTMappingTree[];
+    toDebugString(options: {
+        originalStart: number;
+        originalSource: string;
+        transformedStart: number;
+        transformedSource: string;
+        indent?: string;
+    }): string;
+    private getSourceRange;
+}
+//# sourceMappingURL=glimmer-ast-mapping-tree.d.ts.map
+}

package/external-types/@glint__ember-tsc/lib/transform/template/inlining/index.d.ts

@@ -0,0 +1,18 @@
+declare module '@glint/ember-tsc/transform/template/inlining/' {
+import type ts from 'typescript';
+import { CorrelatedSpan, Directive, TransformError } from '../transformed-module.js';
+import { TSLib } from '../../util.js';
+export type PartialCorrelatedSpan = Omit<CorrelatedSpan, 'transformedStart' | 'transformedLength'>;
+export type CorrelatedSpansResult = {
+    errors: Array<TransformError>;
+    directives: Array<Directive>;
+    partialSpans: Array<PartialCorrelatedSpan>;
+};
+/**
+ * Given an AST node for an embedded template, determines whether it's embedded
+ * within a class in such a way that that class should be treated as its backing
+ * value.
+ */
+export declare function isEmbeddedInClass(ts: TSLib, node: ts.Node): boolean;
+//# sourceMappingURL=index.d.ts.map
+}

package/external-types/@glint__ember-tsc/lib/transform/template/inlining/tagged-strings.d.ts

@@ -0,0 +1,10 @@
+declare module '@glint/ember-tsc/transform/template/inlining/tagged-strings' {
+import { GlintEmitMetadata } from '@glint/ember-tsc/config-types';
+import type ts from 'typescript';
+import { GlintEnvironment } from '../../../config/index.js';
+import { TSLib } from '../../util.js';
+import { SourceFile } from '../transformed-module.js';
+import { CorrelatedSpansResult } from './index.js';
+export declare function calculateTaggedTemplateSpans(ts: TSLib, node: ts.TaggedTemplateExpression, meta: GlintEmitMetadata | undefined, script: SourceFile, environment: GlintEnvironment): CorrelatedSpansResult;
+//# sourceMappingURL=tagged-strings.d.ts.map
+}

package/external-types/@glint__ember-tsc/lib/transform/template/map-template-contents.d.ts

@@ -0,0 +1,123 @@
+declare module '@glint/ember-tsc/transform/template/map-template-contents' {
+import { AST } from '@glimmer/syntax';
+import { CodeInformation } from '@volar/language-server/node.js';
+import GlimmerASTMappingTree, { MappingSource } from './glimmer-ast-mapping-tree.js';
+import { Directive, DirectiveKind, Range } from './transformed-module.js';
+/**
+ * @glimmer/syntax parses identifiers as strings. Aside from meaning
+ * we often have to reverse engineer location information for them
+ * by hand, it also means we can't treat mappings from identifiers
+ * consistently with how we treat mappings from other AST nodes.
+ *
+ * This class just gives us a uniform way to store identifiers
+ * or other nodes as the `source` for a mapping.
+ */
+export declare class Identifier {
+    readonly name: string;
+    readonly type = "Identifier";
+    constructor(name: string);
+}
+export type Mapper = {
+    /**
+     * Given a @glimmer/syntax AST node, returns the corresponding start
+     * and end offsets of that node in the original source.
+     */
+    rangeForNode: (node: AST.Node, span?: AST.Node['loc']) => Range;
+    /**
+     * Given a 0-based line number, returns the corresponding start and
+     * end offsets for that line.
+     */
+    rangeForLine: (line: number) => Range;
+    /**
+     * Captures the existence of a directive specified by the given source
+     * node and affecting the given range of text.
+     */
+    directive: (type: DirectiveKind, commentNode: AST.CommentStatement | AST.MustacheCommentStatement, location: Range, areaOfEffect: Range) => void;
+    /**
+     * Emits placeholder `ts-expect-error`s for corresponding `@glint-expect-error` directives.
+     * This is called at the end of the template transformation to ensure that we're at a
+     * top-level / statement-level point in the transformed code, which is a requirement for
+     * the `ts-expect-error` placeholder diagnostics to be emitted.
+     */
+    emitDirectivePlaceholders: () => void;
+    /**
+     * Records an error at the given location.
+     */
+    error: (message: string, location: Range) => void;
+    /** Emit a newline in the transformed source */
+    newline(): void;
+    /** Increase the indent level for future emitted content */
+    indent(): void;
+    /** Decrease the indent level for future emitted content */
+    dedent(): void;
+    /** Append the given raw text to the transformed source */
+    text(value: string): void;
+    /**
+     * Append the given raw text to the transformed source, creating
+     * a 0-length mapping for it in the output.
+     */
+    synthetic(value: string): void;
+    /**
+     * Essentially the inverse of `emit.synthetic`, this notes the
+     * presence of a template AST node at a given location while not
+     * emitting anything in the resulting TS translation.
+     */
+    nothing(node: AST.Node, source?: MappingSource): void;
+    /**
+     * Append the given value to the transformed source, mapping
+     * that span back to the given offset in the original source.
+     */
+    identifier(value: string, hbsOffset: number, hbsLength?: number): void;
+    /**
+     * Map all content emitted in the given callback to the span
+     * corresponding to the given AST node in the original source.
+     */
+    forNode(node: AST.Node, callback: () => void, codeFeaturesForNode?: CodeInformation): void;
+    forNodeWithSpan(node: AST.Node, span: AST.Node['loc'], callback: () => void, codeFeaturesForNode?: CodeInformation): void;
+};
+type LocalDirective = Omit<Directive, 'source'>;
+/** The result of rewriting a template */
+export type RewriteResult = {
+    /**
+     * Any errors discovered during rewriting, along with their location
+     * in terms of the original source.
+     */
+    errors: Array<{
+        message: string;
+        location: Range | undefined;
+    }>;
+    /**
+     * The source code and a `MappingTree` resulting from rewriting a
+     * template. If the template contains unrecoverable syntax errors,
+     * this may be undefined.
+     */
+    result?: {
+        code: string;
+        directives: Array<LocalDirective>;
+        mapping: GlimmerASTMappingTree;
+    };
+};
+/**
+ * Syntax surrounding the contents of a template that marks it as
+ * embedded within the surrounding context, like the `hbs` tag and
+ * backticks on a tagged string or the `<template>` markers in a
+ * `.gts`/`.gjs` file.
+ */
+export type EmbeddingSyntax = {
+    prefix: string;
+    suffix: string;
+};
+export type MapTemplateContentsOptions = {
+    embeddingSyntax: EmbeddingSyntax;
+};
+/**
+ * Given the text of a handlebars template (either standalone .hbs file, or the contents
+ * of an embedded `<template>...</template>` within a .gts file), invokes the given callback
+ * with a set of tools to emit mapped contents corresponding to
+ * that template, tracking the text emitted in order to provide
+ * a mapping of ranges in the input to ranges in the output.
+ */
+export declare function mapTemplateContents(template: string, { embeddingSyntax }: MapTemplateContentsOptions, callback: (ast: AST.Template | null, mapper: Mapper) => void): RewriteResult;
+export {};
+//# sourceMappingURL=map-template-contents.d.ts.map
+}