@discourse/types 2026.1.0-c7e9cdd → 2026.3.0-d02b2966

package/external-types/glimmer__syntax/index.d.ts

@@ -0,0 +1,1595 @@
+declare module '@glimmer/syntax' {
+	import { Nullable, Maybe, PresentArray, GetContextualFreeOpcode, Dict, Core } from '@glimmer/interfaces';
+
+	/**
+	 * @module
+	 *
+	 * This file contains types for the raw AST returned from the Handlebars parser.
+	 * These types were originally imported from
+	 * https://github.com/DefinitelyTyped/DefinitelyTyped/blob/master/types/handlebars/index.d.ts.
+	 */
+
+	interface CommonNode {
+	    loc: SourceLocation$1;
+	}
+	interface SourceLocation$1 {
+	    source: string;
+	    start: Position;
+	    end: Position;
+	}
+	interface Position {
+	    line: number;
+	    column: number;
+	}
+	interface Program$1 extends CommonNode {
+	    type: 'Program';
+	    body: Statement$1[];
+	    blockParams?: string[];
+	    chained?: boolean;
+	}
+	type Statement$1 = MustacheStatement$1 | BlockStatement$1 | DecoratorBlock | PartialStatement | PartialBlockStatement | ContentStatement | CommentStatement$1;
+	interface CommonMustache extends CommonNode {
+	    path: Expression$1;
+	    params: Expression$1[];
+	    hash: Hash$1;
+	    escaped: boolean;
+	    strip: StripFlags$1;
+	}
+	interface MustacheStatement$1 extends CommonMustache {
+	    type: 'MustacheStatement';
+	}
+	interface CommonBlock extends CommonNode {
+	    chained: boolean;
+	    path: PathExpression$2 | SubExpression$1;
+	    params: Expression$1[];
+	    hash: Hash$1;
+	    program: Program$1;
+	    inverse?: Program$1;
+	    openStrip?: StripFlags$1;
+	    inverseStrip?: StripFlags$1;
+	    closeStrip?: StripFlags$1;
+	}
+	interface BlockStatement$1 extends CommonBlock {
+	    type: 'BlockStatement';
+	}
+	interface DecoratorBlock extends CommonBlock {
+	    type: 'DecoratorBlock';
+	}
+	interface PartialStatement extends CommonNode {
+	    type: 'PartialStatement';
+	    name: PathExpression$2 | SubExpression$1;
+	    params: Expression$1[];
+	    hash: Hash$1;
+	    indent: string;
+	    strip: StripFlags$1;
+	}
+	interface PartialBlockStatement extends CommonNode {
+	    type: 'PartialBlockStatement';
+	    name: PathExpression$2 | SubExpression$1;
+	    params: Expression$1[];
+	    hash: Hash$1;
+	    program: Program$1;
+	    openStrip: StripFlags$1;
+	    closeStrip: StripFlags$1;
+	}
+	interface ContentStatement extends CommonNode {
+	    type: 'ContentStatement';
+	    value: string;
+	    original: StripFlags$1;
+	}
+	interface CommentStatement$1 extends CommonNode {
+	    type: 'CommentStatement';
+	    value: string;
+	    strip: StripFlags$1;
+	}
+	type Expression$1 = SubExpression$1 | PathExpression$2 | Literal$1;
+	interface SubExpression$1 extends CommonNode {
+	    type: 'SubExpression';
+	    path: PathExpression$2 | SubExpression$1;
+	    params: Expression$1[];
+	    hash: Hash$1;
+	}
+	interface PathExpression$2 extends CommonNode {
+	    type: 'PathExpression';
+	    data: boolean;
+	    depth: number;
+	    parts: string[];
+	    original: string;
+	}
+	type Literal$1 = StringLiteral$2 | BooleanLiteral$1 | NumberLiteral$1 | UndefinedLiteral$1 | NullLiteral$1;
+	interface StringLiteral$2 extends CommonNode {
+	    type: 'StringLiteral';
+	    value: string;
+	    original: string;
+	}
+	interface BooleanLiteral$1 extends CommonNode {
+	    type: 'BooleanLiteral';
+	    value: boolean;
+	    original: boolean;
+	}
+	interface NumberLiteral$1 extends CommonNode {
+	    type: 'NumberLiteral';
+	    value: number;
+	    original: number;
+	}
+	interface UndefinedLiteral$1 extends CommonNode {
+	    type: 'UndefinedLiteral';
+	}
+	interface NullLiteral$1 extends CommonNode {
+	    type: 'NullLiteral';
+	}
+	interface Hash$1 extends CommonNode {
+	    pairs: HashPair$1[];
+	}
+	interface HashPair$1 extends CommonNode {
+	    key: string;
+	    value: Expression$1;
+	}
+	interface StripFlags$1 {
+	    open: boolean;
+	    close: boolean;
+	} const visitorKeys: {
+	    readonly Template: readonly ["body"];
+	    readonly Block: readonly ["body"];
+	    readonly MustacheStatement: readonly ["path", "params", "hash"];
+	    readonly BlockStatement: readonly ["path", "params", "hash", "program", "inverse"];
+	    readonly ElementModifierStatement: readonly ["path", "params", "hash"];
+	    readonly CommentStatement: readonly [];
+	    readonly MustacheCommentStatement: readonly [];
+	    readonly ElementNode: readonly ["attributes", "modifiers", "children", "comments"];
+	    readonly AttrNode: readonly ["value"];
+	    readonly TextNode: readonly [];
+	    readonly ConcatStatement: readonly ["parts"];
+	    readonly SubExpression: readonly ["path", "params", "hash"];
+	    readonly PathExpression: readonly [];
+	    readonly StringLiteral: readonly [];
+	    readonly BooleanLiteral: readonly [];
+	    readonly NumberLiteral: readonly [];
+	    readonly NullLiteral: readonly [];
+	    readonly UndefinedLiteral: readonly [];
+	    readonly Hash: readonly ["pairs"];
+	    readonly HashPair: readonly ["value"];
+	};
+	type VisitorKeysMap = typeof visitorKeys;
+	type VisitorKeys = {
+	    [P in keyof VisitorKeysMap]: VisitorKeysMap[P][number];
+	};
+	type VisitorKey<N extends Node> = VisitorKeys[N['type']] & keyof N; class WalkerPath<N extends Node> {
+	    node: N;
+	    parent: WalkerPath<Node> | null;
+	    parentKey: string | null;
+	    constructor(node: N, parent?: WalkerPath<Node> | null, parentKey?: string | null);
+	    get parentNode(): Node | null;
+	    parents(): Iterable<WalkerPath<Node> | null>;
+	}
+
+	interface FullNodeTraversal<N extends Node> {
+	    enter?(node: N, path: WalkerPath<N>): void;
+	    exit?(node: N, path: WalkerPath<N>): void;
+	    keys?: KeysVisitor<N>;
+	}
+	type NodeHandler<N extends Node> = (node: N, path: WalkerPath<N>) => Node | Node[] | undefined | void;
+	type NodeTraversal<N extends Node> = FullNodeTraversal<N> | NodeHandler<N>;
+	type NodeVisitor = {
+	    [P in keyof Nodes]?: NodeTraversal<Nodes[P]>;
+	} & {
+	    All?: NodeTraversal<Node>;
+	    /**
+	     * @deprecated use Template or Block instead
+	     */
+	    Program?: NodeTraversal<Template$1 | Block$1>;
+	};
+	interface FullKeyTraversal<N extends Node, K extends string> {
+	    enter?(node: N, key: K): void;
+	    exit?(node: N, key: K): void;
+	}
+	type KeyHandler<N extends Node, K extends VisitorKey<N>> = (node: N, key: K) => void;
+	type KeyTraversal<N extends Node, K extends VisitorKey<N>> = FullKeyTraversal<N, K> | KeyHandler<N, K>;
+	type KeysVisitor<N extends Node> = {
+	    [P in VisitorKey<N>]?: KeyTraversal<N, P>;
+	} & {
+	    All?: KeyTraversal<N, VisitorKey<N>>;
+	    /**
+	     * @deprecated use Template or Block instead
+	     */
+	    Program?: KeyTraversal<Template$1 | Block$1, 'body'>;
+	}; function traverse(node: Node, visitor: NodeVisitor): void;
+
+	type NodeCallback<N extends Node> = (node: N, walker: Walker) => void; class Walker {
+	    order?: unknown | undefined;
+	    stack: unknown[];
+	    constructor(order?: unknown | undefined);
+	    visit<N extends Node>(node: Nullable<N>, visitor: NodeCallback<N>): void;
+	    children<N extends Node>(node: N & Node, callback: NodeCallback<N & Node>): void;
+	}
+
+	type BuilderHead = string | CallableExpression;
+	type TagDescriptor = string | PathExpression$1 | {
+	    path: PathExpression$1;
+	    selfClosing?: boolean;
+	} | {
+	    name: string;
+	    selfClosing?: boolean;
+	}; function buildMustache(path: BuilderHead | Literal, params?: Expression[], hash?: Hash, trusting?: boolean, loc?: SourceLocation, strip?: StripFlags): MustacheStatement;
+	type PossiblyDeprecatedBlock = Block$1 | Template$1; function buildBlock(path: BuilderHead, params: Nullable<Expression[]>, hash: Nullable<Hash>, _defaultBlock: PossiblyDeprecatedBlock, _elseBlock?: Nullable<PossiblyDeprecatedBlock>, loc?: SourceLocation, openStrip?: StripFlags, inverseStrip?: StripFlags, closeStrip?: StripFlags): BlockStatement; function buildElementModifier(path: BuilderHead, params?: Expression[], hash?: Hash, loc?: Nullable<SourceLocation>): ElementModifierStatement; function buildComment(value: string, loc?: SourceLocation): CommentStatement; function buildMustacheComment(value: string, loc?: SourceLocation): MustacheCommentStatement; function buildConcat(parts: (TextNode | MustacheStatement)[], loc?: SourceLocation): ConcatStatement;
+	interface BuildElementOptions {
+	    attrs?: AttrNode$1[];
+	    modifiers?: ElementModifierStatement[];
+	    children?: Statement[];
+	    comments?: MustacheCommentStatement[];
+	    blockParams?: VarHead[] | string[];
+	    openTag?: SourceLocation;
+	    closeTag?: Maybe<SourceLocation>;
+	    loc?: SourceLocation;
+	} function buildElement(tag: TagDescriptor, options?: BuildElementOptions): ElementNode$1; function buildAttr(name: string, value: AttrValue, loc?: SourceLocation): AttrNode$1; function buildText(chars?: string, loc?: SourceLocation): TextNode; function buildSexpr(path: BuilderHead, params?: Expression[], hash?: Hash, loc?: SourceLocation): SubExpression; function buildThis(loc?: SourceLocation): ThisHead; function buildAtName(name: string, loc?: SourceLocation): AtHead; function buildVar(name: string, loc?: SourceLocation): VarHead; function buildHeadFromString(original: string, loc?: SourceLocation): PathHead; function buildCleanPath(head: PathHead, tail?: string[], loc?: SourceLocation): PathExpression$1; function buildPath(path: PathExpression$1 | string | {
+	    head: string;
+	    tail: string[];
+	}, loc?: SourceLocation): PathExpression$1; function buildPath(path: BuilderHead, loc?: SourceLocation): CallableExpression; function buildPath(path: BuilderHead | Literal | Expression, loc?: SourceLocation): Expression; function buildLiteral<T extends Literal>(type: T['type'], value: T['value'], loc?: SourceLocation): T; function buildHash(pairs?: HashPair[], loc?: SourceLocation): Hash; function buildPair(key: string, value: Expression, loc?: SourceLocation): HashPair; function buildProgram(body?: Statement[], blockParams?: string[], loc?: SourceLocation): Template$1 | Block$1; function buildBlockItself(body?: Statement[], params?: Array<VarHead | string>, chained?: boolean, loc?: SourceLocation): Block$1; function buildTemplate(body?: Statement[], blockParams?: string[], loc?: SourceLocation): Template$1; function buildPosition(line: number, column: number): SourcePosition; function buildLoc(loc: Nullable<SourceLocation>): SourceSpan; function buildLoc(startLine: number, startColumn: number, endLine?: number, endColumn?: number, source?: string): SourceSpan; const _default: {
+	    mustache: typeof buildMustache;
+	    block: typeof buildBlock;
+	    comment: typeof buildComment;
+	    mustacheComment: typeof buildMustacheComment;
+	    element: typeof buildElement;
+	    elementModifier: typeof buildElementModifier;
+	    attr: typeof buildAttr;
+	    text: typeof buildText;
+	    sexpr: typeof buildSexpr;
+	    concat: typeof buildConcat;
+	    hash: typeof buildHash;
+	    pair: typeof buildPair;
+	    literal: typeof buildLiteral;
+	    program: typeof buildProgram;
+	    blockItself: typeof buildBlockItself;
+	    template: typeof buildTemplate;
+	    loc: typeof buildLoc;
+	    pos: typeof buildPosition;
+	    path: typeof buildPath;
+	    fullPath: typeof buildCleanPath;
+	    head: typeof buildHeadFromString;
+	    at: typeof buildAtName;
+	    var: typeof buildVar;
+	    this: typeof buildThis;
+	    string: (value: string) => StringLiteral$1;
+	    boolean: (value: boolean) => BooleanLiteral;
+	    number: (value: number) => NumberLiteral;
+	    undefined(): UndefinedLiteral;
+	    null(): NullLiteral;
+	};
+
+	/**
+	  ASTPlugins can make changes to the Glimmer template AST before
+	  compilation begins.
+	*/
+	interface ASTPluginBuilder<TEnv extends ASTPluginEnvironment = ASTPluginEnvironment> {
+	    (env: TEnv): ASTPlugin;
+	}
+	interface ASTPlugin {
+	    name: string;
+	    visitor: NodeVisitor;
+	}
+	interface ASTPluginEnvironment {
+	    meta?: object | undefined;
+	    syntax: Syntax;
+	}
+	interface HandlebarsParseOptions {
+	    srcName?: string;
+	    ignoreStandalone?: boolean;
+	}
+	interface TemplateIdFn {
+	    (src: string): Nullable<string>;
+	}
+	interface PrecompileOptions extends PreprocessOptions {
+	    id?: TemplateIdFn;
+	    /**
+	     * Additional non-native keywords.
+	     *
+	     * Local variables (block params or lexical scope) always takes precedence,
+	     * but otherwise, suitable free variable candidates (e.g. those are not part
+	     * of a path) are matched against this list and turned into keywords.
+	     *
+	     * In strict mode compilation, keywords suppresses the undefined reference
+	     * error and will be resolved by the runtime environment.
+	     *
+	     * In loose mode, keywords are currently ignored and since all free variables
+	     * are already resolved by the runtime environment.
+	     */
+	    keywords?: readonly string[];
+	    /**
+	     * In loose mode, this hook allows embedding environments to customize the name of an
+	     * angle-bracket component. In practice, this means that `<HelloWorld />` in Ember is
+	     * compiled by Glimmer as an invocation of a component named `hello-world`.
+	     *
+	     * It's a little weird that this is needed in addition to the resolver, but it's a
+	     * classic-only feature and it seems fine to leave it alone for classic consumers.
+	     */
+	    customizeComponentName?: ((input: string) => string) | undefined;
+	}
+	interface PrecompileOptionsWithLexicalScope extends PrecompileOptions {
+	    lexicalScope: (variable: string) => boolean;
+	    /**
+	     * If `emit.debugSymbols` is set to `true`, the name of lexical local variables
+	     * will be included in the wire format.
+	     */
+	    emit?: {
+	        debugSymbols?: boolean;
+	    } | undefined;
+	}
+	interface PreprocessOptions {
+	    strictMode?: boolean | undefined;
+	    locals?: string[] | undefined;
+	    meta?: {
+	        moduleName?: string | undefined;
+	    } | undefined;
+	    plugins?: {
+	        ast?: ASTPluginBuilder[] | undefined;
+	    } | undefined;
+	    parseOptions?: HandlebarsParseOptions | undefined;
+	    customizeComponentName?: ((input: string) => string) | undefined;
+	    /**
+	      Useful for specifying a group of options together.
+	  
+	      When `'codemod'` we disable all whitespace control in handlebars
+	      (to preserve as much as possible) and we also avoid any
+	      escaping/unescaping of HTML entity codes.
+	     */
+	    mode?: 'codemod' | 'precompile' | undefined;
+	}
+	interface Syntax {
+	    parse: typeof preprocess;
+	    builders: typeof _default;
+	    print: typeof build;
+	    traverse: typeof traverse;
+	    Walker: typeof Walker;
+	} function preprocess(input: string | Source | Program$1, options?: PreprocessOptions): Template$1; class Source {
+	    readonly source: string;
+	    readonly module: string;
+	    static from(source: string, options?: PrecompileOptions): Source;
+	    constructor(source: string, module?: string);
+	    /**
+	     * Validate that the character offset represents a position in the source string.
+	     */
+	    validate(offset: number): boolean;
+	    slice(start: number, end: number): string;
+	    offsetFor(line: number, column: number): SourceOffset;
+	    spanFor({ start, end }: Readonly<SourceLocation>): SourceSpan;
+	    hbsPosFor(offset: number): Nullable<SourcePosition>;
+	    charPosFor(position: SourcePosition): number | null;
+	}
+
+	/**
+	 * We have already computed the character position of this offset or span.
+	 */
+	type CharOffsetKind = 'CharPosition';
+	/**
+	 * This offset or span was instantiated with a Handlebars SourcePosition or SourceLocation. Its
+	 * character position will be computed on demand.
+	 */
+	type HbsPositionKind = 'HbsPosition';
+	/**
+	 * for (rare) situations where a node is created but there was no source location (e.g. the name
+	 * "default" in default blocks when the word "default" never appeared in source). This is used
+	 * by the internals when there is a legitimate reason for the internals to synthesize a node
+	 * with no location.
+	 */
+	type InternalSyntheticKind = 'InternalsSynthetic';
+	/**
+	 * For situations where a node represents zero parts of the source (for example, empty arguments).
+	 * In general, we attempt to assign these nodes *some* position (empty arguments can be
+	 * positioned immediately after the callee), but it's not always possible
+	 */
+	type NonExistentKind = 'NonExistent';
+	/**
+	 * For situations where a source location was expected, but it didn't correspond to the node in
+	 * the source. This happens if a plugin creates broken locations.
+	 */
+	type BrokenKind = 'Broken';
+	type OffsetKind = CharOffsetKind | HbsPositionKind | InvisibleKind;
+	/**
+	 * These kinds  describe spans that don't have a concrete location in the original source.
+	 */
+	type InvisibleKind = BrokenKind | InternalSyntheticKind | NonExistentKind;
+
+	type SerializedSourceSlice<Chars extends string = string> = [
+	    chars: Chars,
+	    span: SerializedSourceSpan
+	]; class SourceSlice<Chars extends string = string> {
+	    static synthetic<S extends string>(chars: S): SourceSlice<S>;
+	    static load(source: Source, slice: SerializedSourceSlice): SourceSlice;
+	    readonly chars: Chars;
+	    readonly loc: SourceSpan;
+	    constructor(options: {
+	        loc: SourceSpan;
+	        chars: Chars;
+	    });
+	    getString(): string;
+	    serialize(): SerializedSourceSlice<Chars>;
+	}
+
+	/**
+	 * All spans have these details in common.
+	 */
+	interface SpanData {
+	    readonly kind: OffsetKind;
+	    /**
+	     * Convert this span into a string. If the span is broken, return `''`.
+	     */
+	    asString(): string;
+	    /**
+	     * Gets the module the span was located in.
+	     */
+	    getModule(): string;
+	    /**
+	     * Get the starting position for this span. Try to avoid creating new position objects, as they
+	     * cache computations.
+	     */
+	    getStart(): AnyPosition;
+	    /**
+	     * Get the ending position for this span. Try to avoid creating new position objects, as they
+	     * cache computations.
+	     */
+	    getEnd(): AnyPosition;
+	    /**
+	     * Compute the `SourceLocation` for this span, returned as an instance of `HbsSpan`.
+	     */
+	    toHbsSpan(): HbsSpan | null;
+	    /**
+	     * For compatibility, whenever the `start` or `end` of a {@see SourceOffset} changes, spans are
+	     * notified of the change so they can update themselves. This shouldn't happen outside of AST
+	     * plugins.
+	     */
+	    locDidUpdate(changes: {
+	        start?: SourcePosition;
+	        end?: SourcePosition;
+	    }): void;
+	    /**
+	     * Serialize into a {@see SerializedSourceSpan}, which is compact and designed for readability in
+	     * context like AST Explorer. If you need a {@see SourceLocation}, use {@see toJSON}.
+	     */
+	    serialize(): SerializedSourceSpan;
+	} class SourceSpan implements SourceLocation {
+	    private data;
+	    static get NON_EXISTENT(): SourceSpan;
+	    static load(source: Source, serialized: SerializedSourceSpan): SourceSpan;
+	    static forHbsLoc(source: Source, loc: SourceLocation): SourceSpan;
+	    static forCharPositions(source: Source, startPos: number, endPos: number): SourceSpan;
+	    static synthetic(chars: string): SourceSpan;
+	    static broken(pos?: SourceLocation): SourceSpan;
+	    readonly isInvisible: boolean;
+	    constructor(data: SpanData & AnySpan);
+	    getStart(): SourceOffset;
+	    getEnd(): SourceOffset;
+	    get loc(): SourceLocation;
+	    get module(): string;
+	    /**
+	     * Get the starting `SourcePosition` for this `SourceSpan`, lazily computing it if needed.
+	     */
+	    get startPosition(): SourcePosition;
+	    /**
+	     * Get the ending `SourcePosition` for this `SourceSpan`, lazily computing it if needed.
+	     */
+	    get endPosition(): SourcePosition;
+	    /**
+	     * Support converting ASTv1 nodes into a serialized format using JSON.stringify.
+	     */
+	    toJSON(): SourceLocation;
+	    /**
+	     * Create a new span with the current span's end and a new beginning.
+	     */
+	    withStart(other: SourceOffset): SourceSpan;
+	    /**
+	     * Create a new span with the current span's beginning and a new ending.
+	     */
+	    withEnd(other: SourceOffset): SourceSpan;
+	    asString(): string;
+	    /**
+	     * Convert this `SourceSpan` into a `SourceSlice`.
+	     */
+	    toSlice(expected?: string): SourceSlice;
+	    /**
+	     * For compatibility with SourceLocation in AST plugins
+	     *
+	     * @deprecated use startPosition instead
+	     */
+	    get start(): SourcePosition;
+	    /**
+	     * For compatibility with SourceLocation in AST plugins
+	     *
+	     * @deprecated use withStart instead
+	     */
+	    set start(position: SourcePosition);
+	    /**
+	     * For compatibility with SourceLocation in AST plugins
+	     *
+	     * @deprecated use endPosition instead
+	     */
+	    get end(): SourcePosition;
+	    /**
+	     * For compatibility with SourceLocation in AST plugins
+	     *
+	     * @deprecated use withEnd instead
+	     */
+	    set end(position: SourcePosition);
+	    /**
+	     * For compatibility with SourceLocation in AST plugins
+	     *
+	     * @deprecated use module instead
+	     */
+	    get source(): string;
+	    collapse(where: 'start' | 'end'): SourceSpan;
+	    extend(other: SourceSpan): SourceSpan;
+	    serialize(): SerializedSourceSpan;
+	    slice({ skipStart, skipEnd }: {
+	        skipStart?: number;
+	        skipEnd?: number;
+	    }): SourceSpan;
+	    sliceStartChars({ skipStart, chars }: {
+	        skipStart?: number;
+	        chars: number;
+	    }): SourceSpan;
+	    sliceEndChars({ skipEnd, chars }: {
+	        skipEnd?: number;
+	        chars: number;
+	    }): SourceSpan;
+	}
+	type AnySpan = HbsSpan | CharPositionSpan | InvisibleSpan; class CharPositionSpan implements SpanData {
+	    #private;
+	    readonly source: Source;
+	    readonly charPositions: {
+	        start: CharPosition;
+	        end: CharPosition;
+	    };
+	    readonly kind: "CharPosition";
+	    constructor(source: Source, charPositions: {
+	        start: CharPosition;
+	        end: CharPosition;
+	    });
+	    wrap(): SourceSpan;
+	    asString(): string;
+	    getModule(): string;
+	    getStart(): AnyPosition;
+	    getEnd(): AnyPosition;
+	    locDidUpdate(): void;
+	    toHbsSpan(): HbsSpan | null;
+	    serialize(): SerializedSourceSpan;
+	    toCharPosSpan(): this;
+	} class HbsSpan implements SpanData {
+	    #private;
+	    readonly source: Source;
+	    readonly hbsPositions: {
+	        start: HbsPosition;
+	        end: HbsPosition;
+	    };
+	    readonly kind: "HbsPosition";
+	    constructor(source: Source, hbsPositions: {
+	        start: HbsPosition;
+	        end: HbsPosition;
+	    }, providedHbsLoc?: SourceLocation | null);
+	    serialize(): SerializedConcreteSourceSpan;
+	    wrap(): SourceSpan;
+	    private updateProvided;
+	    locDidUpdate({ start, end }: {
+	        start?: SourcePosition;
+	        end?: SourcePosition;
+	    }): void;
+	    asString(): string;
+	    getModule(): string;
+	    getStart(): AnyPosition;
+	    getEnd(): AnyPosition;
+	    toHbsLoc(): SourceLocation;
+	    toHbsSpan(): this;
+	    toCharPosSpan(): CharPositionSpan | null;
+	} class InvisibleSpan implements SpanData {
+	    readonly kind: InvisibleKind;
+	    readonly loc: SourceLocation;
+	    readonly string: string | null;
+	    constructor(kind: InvisibleKind, loc: SourceLocation, string?: string | null);
+	    serialize(): SerializedConcreteSourceSpan;
+	    wrap(): SourceSpan;
+	    asString(): string;
+	    locDidUpdate({ start, end }: {
+	        start?: SourcePosition;
+	        end?: SourcePosition;
+	    }): void;
+	    getModule(): string;
+	    getStart(): AnyPosition;
+	    getEnd(): AnyPosition;
+	    toCharPosSpan(): this;
+	    toHbsSpan(): null;
+	    toHbsLoc(): SourceLocation;
+	}
+	type SerializedConcreteSourceSpan = /** collapsed */ number | /** normal */ [start: number, size: number] | /** synthetic */ string;
+	type SerializedSourceSpan = SerializedConcreteSourceSpan;
+
+	interface SourceLocation {
+	    start: SourcePosition;
+	    end: SourcePosition;
+	}
+	interface SourcePosition {
+	    /** >= 1 */
+	    line: number;
+	    /** >= 0 */
+	    column: number;
+	} const UNKNOWN_POSITION: Readonly<{
+	    readonly line: 1;
+	    readonly column: 0;
+	}>; const SYNTHETIC_LOCATION: Readonly<{
+	    readonly source: "(synthetic)";
+	    readonly start: Readonly<{
+	        readonly line: 1;
+	        readonly column: 0;
+	    }>;
+	    readonly end: Readonly<{
+	        readonly line: 1;
+	        readonly column: 0;
+	    }>;
+	}>; const NON_EXISTENT_LOCATION: Readonly<{
+	    readonly source: "(nonexistent)";
+	    readonly start: Readonly<{
+	        readonly line: 1;
+	        readonly column: 0;
+	    }>;
+	    readonly end: Readonly<{
+	        readonly line: 1;
+	        readonly column: 0;
+	    }>;
+	}>;
+
+	/**
+	 * All positions have these details in common. Most notably, all three kinds of positions can
+	 * must be able to attempt to convert themselves into {@see CharPosition}.
+	 */
+	interface PositionData {
+	    readonly kind: OffsetKind;
+	    toCharPos(): CharPosition | null;
+	    toJSON(): SourcePosition;
+	} const BROKEN = "BROKEN";
+	type BROKEN = 'BROKEN';
+	type AnyPosition = HbsPosition | CharPosition | InvisiblePosition; class SourceOffset {
+	    readonly data: PositionData & AnyPosition;
+	    /**
+	     * Create a `SourceOffset` from a Handlebars `SourcePosition`. It's stored as-is, and converted
+	     * into a character offset on demand, which avoids unnecessarily computing the offset of every
+	     * `SourceLocation`, but also means that broken `SourcePosition`s are not always detected.
+	     */
+	    static forHbsPos(source: Source, pos: SourcePosition): SourceOffset;
+	    /**
+	     * Create a `SourceOffset` that corresponds to a broken `SourcePosition`. This means that the
+	     * calling code determined (or knows) that the `SourceLocation` doesn't correspond correctly to
+	     * any part of the source.
+	     */
+	    static broken(pos?: SourcePosition): SourceOffset;
+	    constructor(data: PositionData & AnyPosition);
+	    /**
+	     * Get the character offset for this `SourceOffset`, if possible.
+	     */
+	    get offset(): number | null;
+	    /**
+	     * Compare this offset with another one.
+	     *
+	     * If both offsets are `HbsPosition`s, they're equivalent as long as their lines and columns are
+	     * the same. This avoids computing offsets unnecessarily.
+	     *
+	     * Otherwise, two `SourceOffset`s are equivalent if their successfully computed character offsets
+	     * are the same.
+	     */
+	    eql(right: SourceOffset): boolean;
+	    /**
+	     * Create a span that starts from this source offset and ends with another source offset. Avoid
+	     * computing character offsets if both `SourceOffset`s are still lazy.
+	     */
+	    until(other: SourceOffset): SourceSpan;
+	    /**
+	     * Create a `SourceOffset` by moving the character position represented by this source offset
+	     * forward or backward (if `by` is negative), if possible.
+	     *
+	     * If this `SourceOffset` can't compute a valid character offset, `move` returns a broken offset.
+	     *
+	     * If the resulting character offset is less than 0 or greater than the size of the source, `move`
+	     * returns a broken offset.
+	     */
+	    move(by: number): SourceOffset;
+	    /**
+	     * Create a new `SourceSpan` that represents a collapsed range at this source offset. Avoid
+	     * computing the character offset if it has not already been computed.
+	     */
+	    collapsed(): SourceSpan;
+	    /**
+	     * Convert this `SourceOffset` into a Handlebars {@see SourcePosition} for compatibility with
+	     * existing plugins.
+	     */
+	    toJSON(): SourcePosition;
+	} class CharPosition implements PositionData {
+	    readonly source: Source;
+	    readonly charPos: number;
+	    readonly kind: "CharPosition";
+	    /** Computed from char offset */
+	    _locPos: HbsPosition | BROKEN | null;
+	    constructor(source: Source, charPos: number);
+	    /**
+	     * This is already a `CharPosition`.
+	     *
+	     * {@see HbsPosition} for the alternative.
+	     */
+	    toCharPos(): this;
+	    /**
+	     * Produce a Handlebars {@see SourcePosition} for this `CharPosition`. If this `CharPosition` was
+	     * computed using {@see SourceOffset#move}, this will compute the `SourcePosition` for the offset.
+	     */
+	    toJSON(): SourcePosition;
+	    wrap(): SourceOffset;
+	    /**
+	     * A `CharPosition` always has an offset it can produce without any additional computation.
+	     */
+	    get offset(): number;
+	    /**
+	     * Convert the current character offset to an `HbsPosition`, if it was not already computed. Once
+	     * a `CharPosition` has computed its `HbsPosition`, it will not need to do compute it again, and
+	     * the same `CharPosition` is retained when used as one of the ends of a `SourceSpan`, so
+	     * computing the `HbsPosition` should be a one-time operation.
+	     */
+	    toHbsPos(): HbsPosition | null;
+	} class HbsPosition implements PositionData {
+	    readonly source: Source;
+	    readonly hbsPos: SourcePosition;
+	    readonly kind: "HbsPosition";
+	    _charPos: CharPosition | BROKEN | null;
+	    constructor(source: Source, hbsPos: SourcePosition, charPos?: number | null);
+	    /**
+	     * Lazily compute the character offset from the {@see SourcePosition}. Once an `HbsPosition` has
+	     * computed its `CharPosition`, it will not need to do compute it again, and the same
+	     * `HbsPosition` is retained when used as one of the ends of a `SourceSpan`, so computing the
+	     * `CharPosition` should be a one-time operation.
+	     */
+	    toCharPos(): CharPosition | null;
+	    /**
+	     * Return the {@see SourcePosition} that this `HbsPosition` was instantiated with. This operation
+	     * does not need to compute anything.
+	     */
+	    toJSON(): SourcePosition;
+	    wrap(): SourceOffset;
+	    /**
+	     * This is already an `HbsPosition`.
+	     *
+	     * {@see CharPosition} for the alternative.
+	     */
+	    toHbsPos(): this;
+	} class InvisiblePosition implements PositionData {
+	    readonly kind: BrokenKind | InternalSyntheticKind | NonExistentKind;
+	    readonly pos: SourcePosition;
+	    constructor(kind: BrokenKind | InternalSyntheticKind | NonExistentKind, pos: SourcePosition);
+	    /**
+	     * A broken position cannot be turned into a {@see CharacterPosition}.
+	     */
+	    toCharPos(): null;
+	    /**
+	     * The serialization of an `InvisiblePosition is whatever Handlebars {@see SourcePosition} was
+	     * originally identified as broken, non-existent or synthetic.
+	     *
+	     * If an `InvisiblePosition` never had an source offset at all, this method returns
+	     * {@see UNKNOWN_POSITION} for compatibility.
+	     */
+	    toJSON(): SourcePosition;
+	    wrap(): SourceOffset;
+	    get offset(): null;
+	} class SpanList {
+	    static range(span: PresentArray<HasSourceSpan>): SourceSpan;
+	    static range(span: HasSourceSpan[], fallback: SourceSpan): SourceSpan;
+	    _span: SourceSpan[];
+	    constructor(span?: SourceSpan[]);
+	    add(offset: SourceSpan): void;
+	    getRangeOffset(fallback: SourceSpan): SourceSpan;
+	}
+	type HasSourceSpan = {
+	    loc: SourceSpan;
+	} | SourceSpan | [HasSourceSpan, ...HasSourceSpan[]]; function loc(span: HasSourceSpan): SourceSpan;
+	type MaybeHasSourceSpan = {
+	    loc: SourceSpan;
+	} | SourceSpan | MaybeHasSourceSpan[]; function hasSpan(span: MaybeHasSourceSpan): span is HasSourceSpan; function maybeLoc(location: MaybeHasSourceSpan, fallback: SourceSpan): SourceSpan;
+
+	type api$2_HasSourceSpan = HasSourceSpan;
+	type api$2_MaybeHasSourceSpan = MaybeHasSourceSpan; const api$2_NON_EXISTENT_LOCATION: typeof NON_EXISTENT_LOCATION; const api$2_SYNTHETIC_LOCATION: typeof SYNTHETIC_LOCATION;
+	type api$2_SerializedSourceSpan = SerializedSourceSpan;
+	type api$2_Source = Source; const api$2_Source: typeof Source;
+	type api$2_SourceLocation = SourceLocation;
+	type api$2_SourceOffset = SourceOffset; const api$2_SourceOffset: typeof SourceOffset;
+	type api$2_SourcePosition = SourcePosition;
+	type api$2_SourceSlice<Chars extends string = string> = SourceSlice<Chars>; const api$2_SourceSlice: typeof SourceSlice;
+	type api$2_SourceSpan = SourceSpan; const api$2_SourceSpan: typeof SourceSpan;
+	type api$2_SpanList = SpanList; const api$2_SpanList: typeof SpanList; const api$2_UNKNOWN_POSITION: typeof UNKNOWN_POSITION; const api$2_hasSpan: typeof hasSpan; const api$2_loc: typeof loc; const api$2_maybeLoc: typeof maybeLoc; namespace api$2 {
+	  export { type api$2_HasSourceSpan as HasSourceSpan, type api$2_MaybeHasSourceSpan as MaybeHasSourceSpan, api$2_NON_EXISTENT_LOCATION as NON_EXISTENT_LOCATION, api$2_SYNTHETIC_LOCATION as SYNTHETIC_LOCATION, type api$2_SerializedSourceSpan as SerializedSourceSpan, api$2_Source as Source, type api$2_SourceLocation as SourceLocation, api$2_SourceOffset as SourceOffset, type api$2_SourcePosition as SourcePosition, api$2_SourceSlice as SourceSlice, api$2_SourceSpan as SourceSpan, api$2_SpanList as SpanList, api$2_UNKNOWN_POSITION as UNKNOWN_POSITION, api$2_hasSpan as hasSpan, api$2_loc as loc, api$2_maybeLoc as maybeLoc };
+	}
+
+	interface BaseNode {
+	    type: NodeType;
+	    loc: SourceSpan;
+	}
+	interface CommonProgram extends BaseNode {
+	    body: Statement[];
+	}
+	interface Block$1 extends CommonProgram {
+	    type: 'Block';
+	    params: VarHead[];
+	    chained?: boolean;
+	    /**
+	     * string accessor for params.name
+	     */
+	    blockParams: string[];
+	}
+	type EntityEncodingState = 'transformed' | 'raw';
+	interface Template$1 extends CommonProgram {
+	    type: 'Template';
+	    blockParams: string[];
+	}
+	/**
+	 * @deprecated use Template or Block instead
+	 */
+	type Program = Template$1 | Block$1;
+	type CallableExpression = SubExpression | PathExpression$1;
+	interface CallParts {
+	    path: CallableExpression;
+	    params: Expression[];
+	    hash: Hash;
+	    loc: SourceSpan;
+	}
+	type CallNode$1 = MustacheStatement | BlockStatement | ElementModifierStatement | SubExpression;
+	interface MustacheStatement extends BaseNode {
+	    type: 'MustacheStatement';
+	    path: Expression;
+	    params: Expression[];
+	    hash: Hash;
+	    trusting: boolean;
+	    strip: StripFlags;
+	    /**
+	     * @deprecated use trusting instead
+	     */
+	    escaped: boolean;
+	}
+	interface BlockStatement extends BaseNode {
+	    type: 'BlockStatement';
+	    path: CallableExpression;
+	    params: Expression[];
+	    hash: Hash;
+	    program: Block$1;
+	    inverse?: Nullable<Block$1>;
+	    openStrip: StripFlags;
+	    inverseStrip: StripFlags;
+	    closeStrip: StripFlags;
+	    chained?: boolean;
+	}
+	interface ElementModifierStatement extends BaseNode {
+	    type: 'ElementModifierStatement';
+	    path: CallableExpression;
+	    params: Expression[];
+	    hash: Hash;
+	}
+	interface CommentStatement extends BaseNode {
+	    type: 'CommentStatement';
+	    value: string;
+	}
+	interface MustacheCommentStatement extends BaseNode {
+	    type: 'MustacheCommentStatement';
+	    value: string;
+	}
+	interface ElementNode$1 extends BaseNode {
+	    type: 'ElementNode';
+	    path: PathExpression$1;
+	    selfClosing: boolean;
+	    attributes: AttrNode$1[];
+	    params: VarHead[];
+	    modifiers: ElementModifierStatement[];
+	    comments: MustacheCommentStatement[];
+	    children: Statement[];
+	    /**
+	     * span for the open tag
+	     */
+	    openTag: SourceSpan;
+	    /**
+	     * span for the close tag, null for void or self-closing tags
+	     */
+	    closeTag: Nullable<SourceSpan>;
+	    /**
+	     * string accessor for path.original
+	     */
+	    tag: string;
+	    /**
+	     * string accessor for params.name
+	     */
+	    blockParams: string[];
+	}
+	type StatementName = 'MustacheStatement' | 'CommentStatement' | 'BlockStatement' | 'MustacheCommentStatement' | 'TextNode' | 'ElementNode';
+	interface AttrNode$1 extends BaseNode {
+	    type: 'AttrNode';
+	    name: string;
+	    value: AttrValue;
+	}
+	type AttrValue = TextNode | MustacheStatement | ConcatStatement;
+	type AttrPart = TextNode | MustacheStatement;
+	interface TextNode extends BaseNode {
+	    type: 'TextNode';
+	    chars: string;
+	}
+	interface ConcatStatement extends BaseNode {
+	    type: 'ConcatStatement';
+	    parts: PresentArray<TextNode | MustacheStatement>;
+	}
+	type ExpressionName = 'SubExpression' | 'PathExpression' | LiteralName;
+	interface SubExpression extends BaseNode {
+	    type: 'SubExpression';
+	    path: CallableExpression;
+	    params: Expression[];
+	    hash: Hash;
+	}
+	interface ThisHead {
+	    type: 'ThisHead';
+	    original: 'this';
+	    loc: SourceSpan;
+	}
+	interface AtHead {
+	    type: 'AtHead';
+	    name: string;
+	    loc: SourceSpan;
+	    /**
+	     * alias for name
+	     */
+	    original: string;
+	}
+	interface VarHead {
+	    type: 'VarHead';
+	    name: string;
+	    loc: SourceSpan;
+	    /**
+	     * alias for name
+	     */
+	    original: string;
+	}
+	type PathHead = ThisHead | AtHead | VarHead;
+	interface MinimalPathExpression extends BaseNode {
+	    type: 'PathExpression';
+	    head: PathHead;
+	    tail: string[];
+	}
+	interface PathExpression$1 extends MinimalPathExpression {
+	    type: 'PathExpression';
+	    original: string;
+	    head: PathHead;
+	    tail: string[];
+	    /**
+	     * @deprecated use `head` and `tail` instead
+	     */
+	    parts: readonly string[];
+	    /**
+	     * @deprecated use `head.type` instead
+	     */
+	    readonly this: boolean;
+	    /**
+	     * @deprecated use `head.type' instead
+	     */
+	    readonly data: boolean;
+	}
+	type LiteralName = 'StringLiteral' | 'BooleanLiteral' | 'NumberLiteral' | 'UndefinedLiteral' | 'NullLiteral';
+	interface StringLiteral$1 extends BaseNode {
+	    type: 'StringLiteral';
+	    value: string;
+	    /**
+	     * @deprecated use value instead
+	     */
+	    original: string;
+	}
+	interface BooleanLiteral extends BaseNode {
+	    type: 'BooleanLiteral';
+	    value: boolean;
+	    /**
+	     * @deprecated use value instead
+	     */
+	    original: boolean;
+	}
+	interface NumberLiteral extends BaseNode {
+	    type: 'NumberLiteral';
+	    value: number;
+	    /**
+	     * @deprecated use value instead
+	     */
+	    original: number;
+	}
+	interface UndefinedLiteral extends BaseNode {
+	    type: 'UndefinedLiteral';
+	    value: undefined;
+	    /**
+	     * @deprecated use value instead
+	     */
+	    original: undefined;
+	}
+	interface NullLiteral extends BaseNode {
+	    type: 'NullLiteral';
+	    value: null;
+	    /**
+	     * @deprecated use value instead
+	     */
+	    original: null;
+	}
+	interface Hash extends BaseNode {
+	    type: 'Hash';
+	    pairs: HashPair[];
+	}
+	interface HashPair extends BaseNode {
+	    type: 'HashPair';
+	    key: string;
+	    value: Expression;
+	}
+	interface StripFlags {
+	    open: boolean;
+	    close: boolean;
+	}
+	type Nodes = {
+	    Template: Template$1;
+	    Block: Block$1;
+	    MustacheStatement: MustacheStatement;
+	    BlockStatement: BlockStatement;
+	    ElementModifierStatement: ElementModifierStatement;
+	    CommentStatement: CommentStatement;
+	    MustacheCommentStatement: MustacheCommentStatement;
+	    ElementNode: ElementNode$1;
+	    AttrNode: AttrNode$1;
+	    TextNode: TextNode;
+	    ConcatStatement: ConcatStatement;
+	    SubExpression: SubExpression;
+	    PathExpression: PathExpression$1;
+	    StringLiteral: StringLiteral$1;
+	    BooleanLiteral: BooleanLiteral;
+	    NumberLiteral: NumberLiteral;
+	    NullLiteral: NullLiteral;
+	    UndefinedLiteral: UndefinedLiteral;
+	    Hash: Hash;
+	    HashPair: HashPair;
+	};
+	type NodeType = keyof Nodes;
+	type Node = Nodes[NodeType];
+	type SubNodes = {
+	    ThisHead: ThisHead;
+	    AtHead: AtHead;
+	    VarHead: VarHead;
+	};
+	type SubNodeType = keyof SubNodes;
+	type SubNode = SubNodes[SubNodeType];
+	type Statement = Nodes[StatementName];
+	type Statements = Pick<Nodes, StatementName>;
+	type Literal = Nodes[LiteralName];
+	type Expression = Nodes[ExpressionName];
+	type Expressions = Pick<Nodes, ExpressionName>;
+	type TopLevelStatement = Statement | Nodes['Block'];
+	type ParentNode = Template$1 | Block$1 | ElementNode$1;
+
+	type api$1_AtHead = AtHead;
+	type api$1_AttrPart = AttrPart;
+	type api$1_AttrValue = AttrValue;
+	type api$1_BaseNode = BaseNode;
+	type api$1_BlockStatement = BlockStatement;
+	type api$1_BooleanLiteral = BooleanLiteral;
+	type api$1_CallParts = CallParts;
+	type api$1_CallableExpression = CallableExpression;
+	type api$1_CommentStatement = CommentStatement;
+	type api$1_CommonProgram = CommonProgram;
+	type api$1_ConcatStatement = ConcatStatement;
+	type api$1_ElementModifierStatement = ElementModifierStatement;
+	type api$1_EntityEncodingState = EntityEncodingState;
+	type api$1_Expression = Expression;
+	type api$1_ExpressionName = ExpressionName;
+	type api$1_Expressions = Expressions;
+	type api$1_Hash = Hash;
+	type api$1_HashPair = HashPair;
+	type api$1_Literal = Literal;
+	type api$1_LiteralName = LiteralName;
+	type api$1_MinimalPathExpression = MinimalPathExpression;
+	type api$1_MustacheCommentStatement = MustacheCommentStatement;
+	type api$1_MustacheStatement = MustacheStatement;
+	type api$1_Node = Node;
+	type api$1_NodeType = NodeType;
+	type api$1_Nodes = Nodes;
+	type api$1_NullLiteral = NullLiteral;
+	type api$1_NumberLiteral = NumberLiteral;
+	type api$1_ParentNode = ParentNode;
+	type api$1_PathHead = PathHead;
+	type api$1_Program = Program;
+	type api$1_SourceLocation = SourceLocation;
+	type api$1_SourcePosition = SourcePosition;
+	type api$1_Statement = Statement;
+	type api$1_StatementName = StatementName;
+	type api$1_Statements = Statements;
+	type api$1_StripFlags = StripFlags;
+	type api$1_SubExpression = SubExpression;
+	type api$1_SubNode = SubNode;
+	type api$1_SubNodeType = SubNodeType;
+	type api$1_SubNodes = SubNodes;
+	type api$1_TextNode = TextNode;
+	type api$1_ThisHead = ThisHead;
+	type api$1_TopLevelStatement = TopLevelStatement;
+	type api$1_UndefinedLiteral = UndefinedLiteral;
+	type api$1_VarHead = VarHead; namespace api$1 {
+	  export type { api$1_AtHead as AtHead, AttrNode$1 as AttrNode, api$1_AttrPart as AttrPart, api$1_AttrValue as AttrValue, api$1_BaseNode as BaseNode, Block$1 as Block, api$1_BlockStatement as BlockStatement, api$1_BooleanLiteral as BooleanLiteral, CallNode$1 as CallNode, api$1_CallParts as CallParts, api$1_CallableExpression as CallableExpression, api$1_CommentStatement as CommentStatement, api$1_CommonProgram as CommonProgram, api$1_ConcatStatement as ConcatStatement, api$1_ElementModifierStatement as ElementModifierStatement, ElementNode$1 as ElementNode, api$1_EntityEncodingState as EntityEncodingState, api$1_Expression as Expression, api$1_ExpressionName as ExpressionName, api$1_Expressions as Expressions, api$1_Hash as Hash, api$1_HashPair as HashPair, api$1_Literal as Literal, api$1_LiteralName as LiteralName, api$1_MinimalPathExpression as MinimalPathExpression, api$1_MustacheCommentStatement as MustacheCommentStatement, api$1_MustacheStatement as MustacheStatement, api$1_Node as Node, api$1_NodeType as NodeType, api$1_Nodes as Nodes, api$1_NullLiteral as NullLiteral, api$1_NumberLiteral as NumberLiteral, api$1_ParentNode as ParentNode, PathExpression$1 as PathExpression, api$1_PathHead as PathHead, SourcePosition as Position, api$1_Program as Program, api$1_SourceLocation as SourceLocation, api$1_SourcePosition as SourcePosition, api$1_Statement as Statement, api$1_StatementName as StatementName, api$1_Statements as Statements, StringLiteral$1 as StringLiteral, api$1_StripFlags as StripFlags, api$1_SubExpression as SubExpression, api$1_SubNode as SubNode, api$1_SubNodeType as SubNodeType, api$1_SubNodes as SubNodes, Template$1 as Template, api$1_TextNode as TextNode, api$1_ThisHead as ThisHead, api$1_TopLevelStatement as TopLevelStatement, api$1_UndefinedLiteral as UndefinedLiteral, api$1_VarHead as VarHead };
+	} function getVoidTags(): string[];
+	interface PrinterOptions {
+	    entityEncoding: EntityEncodingState;
+	    /**
+	     * Used to override the mechanism of printing a given AST.Node.
+	     *
+	     * This will generally only be useful to source -> source codemods
+	     * where you would like to specialize/override the way a given node is
+	     * printed (e.g. you would like to preserve as much of the original
+	     * formatting as possible).
+	     *
+	     * When the provided override returns undefined, the default built in printing
+	     * will be done for the AST.Node.
+	     *
+	     * @param ast the ast node to be printed
+	     * @param options the options specified during the print() invocation
+	     */
+	    override?(ast: Node, options: PrinterOptions): void | string;
+	} function isVoidTag(tag: string): boolean; function build(ast: Node, options?: PrinterOptions): string; function sortByLoc(a: Node, b: Node): -1 | 0 | 1;
+
+	interface GetTemplateLocalsOptions {
+	    includeKeywords?: boolean;
+	    includeHtmlElements?: boolean;
+	} function getTemplateLocals(html: string, options?: GetTemplateLocalsOptions): string[];
+
+	type Keywords = keyof typeof KEYWORDS_TYPES;
+	type KeywordType = 'Call' | 'Modifier' | 'Append' | 'Block'; function isKeyword(word: string): word is Keywords; function isKeyword(word: string, type: KeywordType): boolean; const KEYWORDS_TYPES: {
+	    action: ("Call" | "Modifier")[];
+	    component: ("Block" | "Call" | "Append")[];
+	    debugger: "Append"[];
+	    'each-in': "Block"[];
+	    each: "Block"[];
+	    'has-block-params': ("Call" | "Append")[];
+	    'has-block': ("Call" | "Append")[];
+	    helper: ("Call" | "Append")[];
+	    if: ("Block" | "Call" | "Append")[];
+	    'in-element': "Block"[];
+	    let: "Block"[];
+	    log: ("Call" | "Append")[];
+	    modifier: ("Call" | "Modifier")[];
+	    mount: "Append"[];
+	    mut: ("Call" | "Append")[];
+	    outlet: "Append"[];
+	    readonly: ("Call" | "Append")[];
+	    unbound: ("Call" | "Append")[];
+	    unless: ("Block" | "Call" | "Append")[];
+	    yield: "Append"[];
+	};
+
+	interface BaseNodeFields {
+	    loc: SourceSpan;
+	} function node(): {
+	    fields<Fields extends object>(): NodeConstructor<Fields & BaseNodeFields>;
+	}; function node<T extends string>(name: T): {
+	    fields<Fields extends object>(): TypedNodeConstructor<T, Fields & BaseNodeFields>;
+	};
+	interface NodeConstructor<Fields> {
+	    new (fields: Fields): Readonly<Fields>;
+	}
+	type TypedNode<T extends string, Fields> = {
+	    type: T;
+	} & Readonly<Fields>;
+	interface TypedNodeConstructor<T extends string, Fields> {
+	    new (options: Fields): TypedNode<T, Fields>;
+	}
+
+	/**
+	 * Attr nodes look like HTML attributes, but are classified as:
+	 *
+	 * 1. `HtmlAttr`, which means a regular HTML attribute in Glimmer
+	 * 2. `SplatAttr`, which means `...attributes`
+	 * 3. `ComponentArg`, which means an attribute whose name begins with `@`, and it is therefore a
+	 *    component argument.
+	 */
+	type AttrNode = HtmlAttr | SplatAttr | ComponentArg;
+	/**
+	 * `HtmlAttr` and `SplatAttr` are grouped together because the order of the `SplatAttr` node,
+	 * relative to other attributes, matters.
+	 */
+	type HtmlOrSplatAttr = HtmlAttr | SplatAttr;
+	/**
+	 * "Attr Block" nodes are allowed inside an open element tag in templates. They interact with the
+	 * element (or component).
+	 */
+	type AttrBlockNode = AttrNode | ElementModifier; const HtmlAttr_base: TypedNodeConstructor<"HtmlAttr", AttrNodeOptions & BaseNodeFields>; class HtmlAttr extends HtmlAttr_base {
+	} const SplatAttr_base: TypedNodeConstructor<"SplatAttr", {
+	    symbol: number;
+	} & BaseNodeFields>; class SplatAttr extends SplatAttr_base {
+	} const ComponentArg_base: NodeConstructor<AttrNodeOptions & BaseNodeFields>; class ComponentArg extends ComponentArg_base {
+	    /**
+	     * Convert the component argument into a named argument node
+	     */
+	    toNamedArgument(): NamedArgument;
+	} const ElementModifier_base: TypedNodeConstructor<"ElementModifier", CallFields & BaseNodeFields>; class ElementModifier extends ElementModifier_base {
+	}
+	interface AttrNodeOptions {
+	    name: SourceSlice;
+	    value: ExpressionNode;
+	    trusting: boolean;
+	} const Template_base: NodeConstructor<{
+	    table: ProgramSymbolTable;
+	} & GlimmerParentNodeOptions & BaseNodeFields>; class Template extends Template_base {
+	} const Block_base: NodeConstructor<{
+	    scope: BlockSymbolTable;
+	} & GlimmerParentNodeOptions & BaseNodeFields>; class Block extends Block_base {
+	} const NamedBlocks_base: NodeConstructor<{
+	    blocks: readonly NamedBlock[];
+	} & BaseNodeFields>; class NamedBlocks extends NamedBlocks_base {
+	    /**
+	     * Get the `NamedBlock` for a given name.
+	     */
+	    get(name: 'default'): NamedBlock;
+	    get(name: string): NamedBlock | null;
+	}
+	interface NamedBlockFields extends BaseNodeFields {
+	    name: SourceSlice;
+	    block: Block;
+	    attrs: readonly HtmlOrSplatAttr[];
+	    componentArgs: readonly ComponentArg[];
+	    modifiers: readonly ElementModifier[];
+	} const NamedBlock_base: NodeConstructor<NamedBlockFields & BaseNodeFields>; class NamedBlock extends NamedBlock_base {
+	    get args(): Args;
+	}
+
+	/**
+	 * Content Nodes are allowed in content positions in templates. They correspond to behavior in the
+	 * [Data][data] tokenization state in HTML.
+	 *
+	 * [data]: https://html.spec.whatwg.org/multipage/parsing.html#data-state
+	 */
+	type ContentNode = HtmlText | HtmlComment | AppendContent | InvokeBlock | InvokeComponent | SimpleElement | GlimmerComment; const GlimmerComment_base: TypedNodeConstructor<"GlimmerComment", {
+	    text: SourceSlice;
+	} & BaseNodeFields>; class GlimmerComment extends GlimmerComment_base {
+	} const HtmlText_base: TypedNodeConstructor<"HtmlText", {
+	    chars: string;
+	} & BaseNodeFields>; class HtmlText extends HtmlText_base {
+	} const HtmlComment_base: TypedNodeConstructor<"HtmlComment", {
+	    text: SourceSlice;
+	} & BaseNodeFields>; class HtmlComment extends HtmlComment_base {
+	} const AppendContent_base: TypedNodeConstructor<"AppendContent", {
+	    value: ExpressionNode;
+	    trusting: boolean;
+	    table: SymbolTable;
+	} & BaseNodeFields>; class AppendContent extends AppendContent_base {
+	    get callee(): ExpressionNode;
+	    get args(): Args;
+	} const InvokeBlock_base: TypedNodeConstructor<"InvokeBlock", CallFields & {
+	    blocks: NamedBlocks;
+	} & BaseNodeFields>; class InvokeBlock extends InvokeBlock_base {
+	}
+	interface InvokeComponentFields {
+	    callee: ExpressionNode;
+	    blocks: NamedBlocks;
+	    attrs: readonly HtmlOrSplatAttr[];
+	    componentArgs: readonly ComponentArg[];
+	    modifiers: readonly ElementModifier[];
+	} const InvokeComponent_base: TypedNodeConstructor<"InvokeComponent", InvokeComponentFields & BaseNodeFields>; class InvokeComponent extends InvokeComponent_base {
+	    get args(): Args;
+	}
+	interface SimpleElementOptions extends BaseNodeFields {
+	    tag: SourceSlice;
+	    body: readonly ContentNode[];
+	    attrs: readonly HtmlOrSplatAttr[];
+	    componentArgs: readonly ComponentArg[];
+	    modifiers: readonly ElementModifier[];
+	} const SimpleElement_base: TypedNodeConstructor<"SimpleElement", SimpleElementOptions & BaseNodeFields>; class SimpleElement extends SimpleElement_base {
+	    get args(): Args;
+	}
+	type ElementNode = NamedBlock | InvokeComponent | SimpleElement;
+
+	interface SerializedBaseNode {
+	    loc: SerializedSourceSpan;
+	}
+	interface GlimmerParentNodeOptions extends BaseNodeFields {
+	    body: readonly ContentNode[];
+	}
+	interface CallFields extends BaseNodeFields {
+	    callee: CalleeNode;
+	    args: Args;
+	}
+	type CalleeNode = KeywordExpression | PathExpression | CallExpression;
+	type CallNode = CallExpression | InvokeBlock | AppendContent | InvokeComponent | ElementModifier;
+
+	type HELPER_VAR_NS = 'Helper'; const HELPER_VAR_NS: HELPER_VAR_NS;
+	type MODIFIER_VAR_NS = 'Modifier'; const MODIFIER_VAR_NS: MODIFIER_VAR_NS;
+	type COMPONENT_VAR_NS = 'Component'; const COMPONENT_VAR_NS: COMPONENT_VAR_NS;
+	type FreeVarNamespace = HELPER_VAR_NS | MODIFIER_VAR_NS | COMPONENT_VAR_NS; const STRICT_RESOLUTION: {
+	    resolution: () => GetContextualFreeOpcode;
+	    serialize: () => SerializedResolution;
+	    isAngleBracket: false;
+	};
+	type StrictResolution = typeof STRICT_RESOLUTION; const HTML_RESOLUTION: {
+	    isAngleBracket: true;
+	    resolution: () => GetContextualFreeOpcode;
+	    serialize: () => SerializedResolution;
+	};
+	type HtmlResolution = typeof HTML_RESOLUTION; function isStrictResolution(value: unknown): value is StrictResolution; class LooseModeResolution {
+	    readonly namespaces: Namespaces;
+	    readonly isAngleBracket: boolean;
+	    /**
+	     * Namespaced resolution is used in an unambiguous syntax position:
+	     *
+	     * 1. `(sexp)` (namespace: `Helper`)
+	     * 2. `{{#block}}` (namespace: `Component`)
+	     * 3. `<a {{modifier}}>` (namespace: `Modifier`)
+	     * 4. `<Component />` (namespace: `Component`)
+	     */
+	    static namespaced(namespace: FreeVarNamespace, isAngleBracket?: boolean): LooseModeResolution;
+	    /**
+	     * Append resolution is used when the variable should be resolved in both the `component` and
+	     * `helper` namespaces.
+	     *
+	     * ```hbs
+	     * {{x}}
+	     * ```
+	     *
+	     * ```hbs
+	     * {{x y}}
+	     * ```
+	     *
+	     * ^ In either case, `x` should be resolved in the `component` and `helper` namespaces.
+	     */
+	    static append(): LooseModeResolution;
+	    /**
+	     * Trusting append resolution is used when the variable should be resolved only in the
+	     * `helper` namespaces.
+	     *
+	     * ```hbs
+	     * {{{x}}}
+	     * ```
+	     *
+	     * ```hbs
+	     * {{{x y}}}
+	     * ```
+	     *
+	     * ^ In either case, `x` should be resolved in the `helper` namespace.
+	     */
+	    static trustingAppend(): LooseModeResolution;
+	    constructor(namespaces: Namespaces, isAngleBracket?: boolean);
+	    resolution(): GetContextualFreeOpcode;
+	    serialize(): SerializedResolution;
+	} const HELPER_NAMESPACE: "Helper"; const MODIFIER_NAMESPACE: "Modifier"; const COMPONENT_NAMESPACE: "Component";
+	/**
+	 * A `Namespaced` must be resolved in one or more namespaces.
+	 *
+	 * ```hbs
+	 * <X />
+	 * ```
+	 *
+	 * ^ `X` is resolved in the `component` namespace
+	 *
+	 * ```hbs
+	 * (x)
+	 * ```
+	 *
+	 * ^ `x` is resolved in the `helper` namespace
+	 *
+	 * ```hbs
+	 * <a {{x}} />
+	 * ```
+	 *
+	 * ^ `x` is resolved in the `modifier` namespace
+	 */
+	type Namespaces = [HELPER_VAR_NS] | [MODIFIER_VAR_NS] | [COMPONENT_VAR_NS] | [COMPONENT_VAR_NS, HELPER_VAR_NS];
+	type FreeVarResolution = StrictResolution | HtmlResolution | LooseModeResolution;
+	type SerializedResolution = 'Strict' | 'Helper' | 'Modifier' | 'Component' | 'ComponentOrHelper'; function loadResolution(resolution: SerializedResolution): FreeVarResolution; const ThisReference_base: TypedNodeConstructor<"This", object & BaseNodeFields>; class ThisReference extends ThisReference_base {
+	} const ArgReference_base: TypedNodeConstructor<"Arg", {
+	    name: SourceSlice;
+	    symbol: number;
+	} & BaseNodeFields>; class ArgReference extends ArgReference_base {
+	} const LocalVarReference_base: TypedNodeConstructor<"Local", {
+	    name: string;
+	    isTemplateLocal: boolean;
+	    symbol: number;
+	} & BaseNodeFields>; class LocalVarReference extends LocalVarReference_base {
+	} const FreeVarReference_base: TypedNodeConstructor<"Free", {
+	    name: string;
+	    resolution: FreeVarResolution;
+	    symbol: number;
+	} & BaseNodeFields>; class FreeVarReference extends FreeVarReference_base {
+	}
+	type VariableReference = ThisReference | ArgReference | LocalVarReference | FreeVarReference;
+
+	/**
+	 * A Handlebars literal.
+	 *
+	 * {@link https://handlebarsjs.com/guide/expressions.html#literal-segments}
+	 */
+	type LiteralValue = string | boolean | number | undefined | null;
+	interface LiteralTypes {
+	    string: string;
+	    boolean: boolean;
+	    number: number;
+	    null: null;
+	    undefined: undefined;
+	} const LiteralExpression_base: TypedNodeConstructor<"Literal", {
+	    value: LiteralValue;
+	} & BaseNodeFields>; class LiteralExpression extends LiteralExpression_base {
+	    toSlice(this: StringLiteral): SourceSlice;
+	}
+	type StringLiteral = LiteralExpression & {
+	    value: string;
+	}; function isLiteral<K extends keyof LiteralTypes = keyof LiteralTypes>(node: ExpressionNode, kind?: K): node is StringLiteral; const PathExpression_base: TypedNodeConstructor<"Path", {
+	    ref: VariableReference;
+	    tail: readonly SourceSlice[];
+	} & BaseNodeFields>; class PathExpression extends PathExpression_base {
+	} const KeywordExpression_base: TypedNodeConstructor<"Keyword", {
+	    name: string;
+	    symbol: number;
+	} & BaseNodeFields>; class KeywordExpression extends KeywordExpression_base {
+	} const CallExpression_base: TypedNodeConstructor<"Call", CallFields & BaseNodeFields>; class CallExpression extends CallExpression_base {
+	} const InterpolateExpression_base: TypedNodeConstructor<"Interpolate", {
+	    parts: PresentArray<ExpressionNode>;
+	} & BaseNodeFields>; class InterpolateExpression extends InterpolateExpression_base {
+	}
+	type ExpressionNode = LiteralExpression | PathExpression | KeywordExpression | CallExpression | InterpolateExpression; const Args_base: NodeConstructor<{
+	    positional: PositionalArguments;
+	    named: NamedArguments;
+	} & BaseNodeFields>; class Args extends Args_base {
+	    static empty(loc: SourceSpan): Args;
+	    static named(named: NamedArguments): Args;
+	    nth(offset: number): ExpressionNode | null;
+	    get(name: string): ExpressionNode | null;
+	    isEmpty(): boolean;
+	} const PositionalArguments_base: NodeConstructor<{
+	    exprs: readonly ExpressionNode[];
+	} & BaseNodeFields>; class PositionalArguments extends PositionalArguments_base {
+	    static empty(loc: SourceSpan): PositionalArguments;
+	    get size(): number;
+	    nth(offset: number): ExpressionNode | null;
+	    isEmpty(): boolean;
+	} const NamedArguments_base: NodeConstructor<{
+	    entries: readonly NamedArgument[];
+	} & BaseNodeFields>; class NamedArguments extends NamedArguments_base {
+	    static empty(loc: SourceSpan): NamedArguments;
+	    get size(): number;
+	    get(name: string): ExpressionNode | null;
+	    isEmpty(): boolean;
+	} class NamedArgument {
+	    readonly loc: SourceSpan;
+	    readonly name: SourceSlice;
+	    readonly value: ExpressionNode;
+	    constructor(options: {
+	        name: SourceSlice;
+	        value: ExpressionNode;
+	    });
+	}
+
+	type api_AppendContent = AppendContent; const api_AppendContent: typeof AppendContent;
+	type api_ArgReference = ArgReference; const api_ArgReference: typeof ArgReference;
+	type api_Args = Args; const api_Args: typeof Args;
+	type api_AttrBlockNode = AttrBlockNode;
+	type api_AttrNode = AttrNode;
+	type api_AttrNodeOptions = AttrNodeOptions;
+	type api_BaseNodeFields = BaseNodeFields;
+	type api_Block = Block; const api_Block: typeof Block; const api_COMPONENT_NAMESPACE: typeof COMPONENT_NAMESPACE;
+	type api_CallExpression = CallExpression; const api_CallExpression: typeof CallExpression;
+	type api_CallFields = CallFields;
+	type api_CallNode = CallNode;
+	type api_CalleeNode = CalleeNode;
+	type api_ComponentArg = ComponentArg; const api_ComponentArg: typeof ComponentArg;
+	type api_ContentNode = ContentNode;
+	type api_ElementModifier = ElementModifier; const api_ElementModifier: typeof ElementModifier;
+	type api_ElementNode = ElementNode;
+	type api_ExpressionNode = ExpressionNode;
+	type api_FreeVarReference = FreeVarReference; const api_FreeVarReference: typeof FreeVarReference;
+	type api_FreeVarResolution = FreeVarResolution;
+	type api_GlimmerComment = GlimmerComment; const api_GlimmerComment: typeof GlimmerComment;
+	type api_GlimmerParentNodeOptions = GlimmerParentNodeOptions; const api_HELPER_NAMESPACE: typeof HELPER_NAMESPACE; const api_HTML_RESOLUTION: typeof HTML_RESOLUTION;
+	type api_HtmlAttr = HtmlAttr; const api_HtmlAttr: typeof HtmlAttr;
+	type api_HtmlComment = HtmlComment; const api_HtmlComment: typeof HtmlComment;
+	type api_HtmlOrSplatAttr = HtmlOrSplatAttr;
+	type api_HtmlResolution = HtmlResolution;
+	type api_HtmlText = HtmlText; const api_HtmlText: typeof HtmlText;
+	type api_InterpolateExpression = InterpolateExpression; const api_InterpolateExpression: typeof InterpolateExpression;
+	type api_InvokeBlock = InvokeBlock; const api_InvokeBlock: typeof InvokeBlock;
+	type api_InvokeComponent = InvokeComponent; const api_InvokeComponent: typeof InvokeComponent;
+	type api_KeywordExpression = KeywordExpression; const api_KeywordExpression: typeof KeywordExpression;
+	type api_LiteralExpression = LiteralExpression; const api_LiteralExpression: typeof LiteralExpression;
+	type api_LiteralTypes = LiteralTypes;
+	type api_LiteralValue = LiteralValue;
+	type api_LocalVarReference = LocalVarReference; const api_LocalVarReference: typeof LocalVarReference;
+	type api_LooseModeResolution = LooseModeResolution; const api_LooseModeResolution: typeof LooseModeResolution; const api_MODIFIER_NAMESPACE: typeof MODIFIER_NAMESPACE;
+	type api_NamedArgument = NamedArgument; const api_NamedArgument: typeof NamedArgument;
+	type api_NamedArguments = NamedArguments; const api_NamedArguments: typeof NamedArguments;
+	type api_NamedBlock = NamedBlock; const api_NamedBlock: typeof NamedBlock;
+	type api_NamedBlockFields = NamedBlockFields;
+	type api_NamedBlocks = NamedBlocks; const api_NamedBlocks: typeof NamedBlocks;
+	type api_NodeConstructor<Fields> = NodeConstructor<Fields>;
+	type api_PathExpression = PathExpression; const api_PathExpression: typeof PathExpression;
+	type api_PositionalArguments = PositionalArguments; const api_PositionalArguments: typeof PositionalArguments; const api_STRICT_RESOLUTION: typeof STRICT_RESOLUTION;
+	type api_SerializedBaseNode = SerializedBaseNode;
+	type api_SerializedResolution = SerializedResolution;
+	type api_SimpleElement = SimpleElement; const api_SimpleElement: typeof SimpleElement;
+	type api_SplatAttr = SplatAttr; const api_SplatAttr: typeof SplatAttr;
+	type api_StrictResolution = StrictResolution;
+	type api_StringLiteral = StringLiteral;
+	type api_Template = Template; const api_Template: typeof Template;
+	type api_ThisReference = ThisReference; const api_ThisReference: typeof ThisReference;
+	type api_TypedNodeConstructor<T extends string, Fields> = TypedNodeConstructor<T, Fields>;
+	type api_VariableReference = VariableReference; const api_isLiteral: typeof isLiteral; const api_isStrictResolution: typeof isStrictResolution; const api_loadResolution: typeof loadResolution; const api_node: typeof node; namespace api {
+	  export { api_AppendContent as AppendContent, api_ArgReference as ArgReference, api_Args as Args, type api_AttrBlockNode as AttrBlockNode, type api_AttrNode as AttrNode, type api_AttrNodeOptions as AttrNodeOptions, type api_BaseNodeFields as BaseNodeFields, api_Block as Block, api_COMPONENT_NAMESPACE as COMPONENT_NAMESPACE, api_CallExpression as CallExpression, type api_CallFields as CallFields, type api_CallNode as CallNode, type api_CalleeNode as CalleeNode, api_ComponentArg as ComponentArg, type api_ContentNode as ContentNode, api_ElementModifier as ElementModifier, type api_ElementNode as ElementNode, type api_ExpressionNode as ExpressionNode, api_FreeVarReference as FreeVarReference, type api_FreeVarResolution as FreeVarResolution, api_GlimmerComment as GlimmerComment, type api_GlimmerParentNodeOptions as GlimmerParentNodeOptions, api_HELPER_NAMESPACE as HELPER_NAMESPACE, api_HTML_RESOLUTION as HTML_RESOLUTION, api_HtmlAttr as HtmlAttr, api_HtmlComment as HtmlComment, type api_HtmlOrSplatAttr as HtmlOrSplatAttr, type api_HtmlResolution as HtmlResolution, api_HtmlText as HtmlText, api_InterpolateExpression as InterpolateExpression, api_InvokeBlock as InvokeBlock, api_InvokeComponent as InvokeComponent, api_KeywordExpression as KeywordExpression, api_LiteralExpression as LiteralExpression, type api_LiteralTypes as LiteralTypes, type api_LiteralValue as LiteralValue, api_LocalVarReference as LocalVarReference, api_LooseModeResolution as LooseModeResolution, api_MODIFIER_NAMESPACE as MODIFIER_NAMESPACE, api_NamedArgument as NamedArgument, api_NamedArguments as NamedArguments, api_NamedBlock as NamedBlock, type api_NamedBlockFields as NamedBlockFields, api_NamedBlocks as NamedBlocks, type api_NodeConstructor as NodeConstructor, api_PathExpression as PathExpression, api_PositionalArguments as PositionalArguments, api_STRICT_RESOLUTION as STRICT_RESOLUTION, type api_SerializedBaseNode as SerializedBaseNode, type api_SerializedResolution as SerializedResolution, api_SimpleElement as SimpleElement, api_SplatAttr as SplatAttr, type api_StrictResolution as StrictResolution, type api_StringLiteral as StringLiteral, api_Template as Template, api_ThisReference as ThisReference, type api_TypedNodeConstructor as TypedNodeConstructor, type api_VariableReference as VariableReference, api_isLiteral as isLiteral, api_isStrictResolution as isStrictResolution, api_loadResolution as loadResolution, api_node as node };
+	}
+
+	interface SymbolTableOptions {
+	    customizeComponentName: (input: string) => string;
+	    lexicalScope: (variable: string) => boolean;
+	} abstract class SymbolTable {
+	    static top(locals: readonly string[], keywords: readonly string[], options: SymbolTableOptions): ProgramSymbolTable;
+	    abstract root(): ProgramSymbolTable;
+	    abstract has(name: string): boolean;
+	    abstract get(name: string): [symbol: number, isRoot: boolean];
+	    abstract hasKeyword(name: string): boolean;
+	    abstract getKeyword(name: string): number;
+	    abstract hasLexical(name: string): boolean;
+	    abstract getLocalsMap(): Dict<number>;
+	    abstract getDebugInfo(): Core.DebugSymbols;
+	    abstract allocateFree(name: string, resolution: FreeVarResolution): number;
+	    abstract allocateNamed(name: string): number;
+	    abstract allocateBlock(name: string): number;
+	    abstract allocate(identifier: string): number;
+	    child(locals: string[]): BlockSymbolTable;
+	} class ProgramSymbolTable extends SymbolTable {
+	    private templateLocals;
+	    private keywords;
+	    private options;
+	    constructor(templateLocals: readonly string[], keywords: readonly string[], options: SymbolTableOptions);
+	    readonly symbols: string[];
+	    readonly upvars: string[];
+	    private size;
+	    readonly named: Dict<number>;
+	    readonly blocks: Dict<number>;
+	    readonly usedTemplateLocals: string[];
+	    root(): this;
+	    hasLexical(name: string): boolean;
+	    hasKeyword(name: string): boolean;
+	    getKeyword(name: string): number;
+	    getUsedTemplateLocals(): string[];
+	    has(name: string): boolean;
+	    get(name: string): [number, boolean];
+	    getLocalsMap(): Dict<number>;
+	    getDebugInfo(): Core.DebugSymbols;
+	    allocateFree(name: string, resolution: FreeVarResolution): number;
+	    allocateNamed(name: string): number;
+	    allocateBlock(name: string): number;
+	    allocate(identifier: string): number;
+	} class BlockSymbolTable extends SymbolTable {
+	    #private;
+	    private parent;
+	    symbols: string[];
+	    slots: number[];
+	    constructor(parent: SymbolTable, symbols: string[], slots: number[]);
+	    root(): ProgramSymbolTable;
+	    get locals(): string[];
+	    hasLexical(name: string): boolean;
+	    getKeyword(name: string): number;
+	    hasKeyword(name: string): boolean;
+	    has(name: string): boolean;
+	    get(name: string): [number, boolean];
+	    getLocalsMap(): Dict<number>;
+	    getDebugInfo(): [locals: Record<string, number>, upvars: Record<string, number>];
+	    allocateFree(name: string, resolution: FreeVarResolution): number;
+	    allocateNamed(name: string): number;
+	    allocateBlock(name: string): number;
+	    allocate(identifier: string): number;
+	}
+
+	interface GlimmerSyntaxError extends Error {
+	    location: SourceSpan | null;
+	    code: string | null;
+	} function generateSyntaxError(message: string, location: SourceSpan): GlimmerSyntaxError;
+
+	interface TraversalErrorConstructor {
+	    new (message: string, node: Node, parent: Nullable<Node>, key: string): TraversalError;
+	    readonly prototype: TraversalError;
+	}
+	interface TraversalError extends Error {
+	    constructor: TraversalErrorConstructor;
+	    key: string;
+	    node: Node;
+	    parent: Nullable<Node>;
+	    stack?: string;
+	} const TraversalError: TraversalErrorConstructor; function cannotRemoveNode(node: Node, parent: Node, key: string): TraversalError; function cannotReplaceNode(node: Node, parent: Node, key: string): TraversalError; function normalize(source: Source, options?: PrecompileOptionsWithLexicalScope): [ast: Template, locals: string[]];
+
+	export { api$1 as AST, type ASTPlugin, type ASTPluginBuilder, type ASTPluginEnvironment, api$1 as ASTv1, api as ASTv2, BlockSymbolTable, type GlimmerSyntaxError, type HasSourceSpan, KEYWORDS_TYPES, type KeywordType, type MaybeHasSourceSpan, type NodeVisitor, Walker as Path, type PrecompileOptions, type PrecompileOptionsWithLexicalScope, type PreprocessOptions, ProgramSymbolTable, SourceSlice, SpanList, SymbolTable, type Syntax, type TemplateIdFn, Walker, WalkerPath, _default as builders, cannotRemoveNode, cannotReplaceNode, generateSyntaxError, getTemplateLocals, getVoidTags, hasSpan, isKeyword, isVoidTag, loc, maybeLoc, node, normalize, preprocess, build as print, sortByLoc, api$2 as src, traverse, visitorKeys };
+
+}