@angular/compiler-cli 21.0.0-rc.2 → 21.0.0

package/src/ngtsc/typecheck/src/ops/for_block.d.ts

@@ -0,0 +1,32 @@
+/*!
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.dev/license
+ */
+import { AST, TmplAstForLoopBlock } from '@angular/compiler';
+import ts from 'typescript';
+import { TcbExpressionTranslator } from './expression';
+import type { Context } from './context';
+import type { Scope } from './scope';
+import { TcbOp } from './base';
+/**
+ * A `TcbOp` which renders a `for` block as a TypeScript `for...of` loop.
+ *
+ * Executing this operation returns nothing.
+ */
+export declare class TcbForOfOp extends TcbOp {
+    private tcb;
+    private scope;
+    private block;
+    constructor(tcb: Context, scope: Scope, block: TmplAstForLoopBlock);
+    get optional(): boolean;
+    execute(): null;
+}
+export declare class TcbForLoopTrackTranslator extends TcbExpressionTranslator {
+    private block;
+    private allowedVariables;
+    constructor(tcb: Context, scope: Scope, block: TmplAstForLoopBlock);
+    protected resolve(ast: AST): ts.Expression | null;
+}

package/src/ngtsc/typecheck/src/ops/host.d.ts

@@ -0,0 +1,25 @@
+/*!
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.dev/license
+ */
+import { TmplAstHostElement } from '@angular/compiler';
+import ts from 'typescript';
+import { TcbOp } from './base';
+import type { Context } from './context';
+import type { Scope } from './scope';
+/**
+ * A `TcbOp` which creates an expression for a the host element of a directive.
+ *
+ * Executing this operation returns a reference to the element variable.
+ */
+export declare class TcbHostElementOp extends TcbOp {
+    private tcb;
+    private scope;
+    private element;
+    readonly optional = true;
+    constructor(tcb: Context, scope: Scope, element: TmplAstHostElement);
+    execute(): ts.Identifier;
+}

package/src/ngtsc/typecheck/src/ops/if_block.d.ts

@@ -0,0 +1,28 @@
+/*!
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.dev/license
+ */
+import { TmplAstIfBlock } from '@angular/compiler';
+import { TcbOp } from './base';
+import type { Scope } from './scope';
+import type { Context } from './context';
+/**
+ * A `TcbOp` which renders an `if` template block as a TypeScript `if` statement.
+ *
+ * Executing this operation returns nothing.
+ */
+export declare class TcbIfOp extends TcbOp {
+    private tcb;
+    private scope;
+    private block;
+    private expressionScopes;
+    constructor(tcb: Context, scope: Scope, block: TmplAstIfBlock);
+    get optional(): boolean;
+    execute(): null;
+    private generateBranch;
+    private getBranchScope;
+    private generateBranchGuard;
+}

package/src/ngtsc/typecheck/src/ops/inputs.d.ts

@@ -0,0 +1,56 @@
+/*!
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.dev/license
+ */
+import { AST, TmplAstBoundAttribute, TmplAstComponent, TmplAstDirective, TmplAstElement, TmplAstTemplate } from '@angular/compiler';
+import ts from 'typescript';
+import type { Context } from './context';
+import type { Scope } from './scope';
+import { TypeCheckableDirectiveMeta } from '../../api';
+import { TcbOp } from './base';
+import { CustomFieldType } from './signal_forms';
+import { LocalSymbol } from './references';
+/**
+ * Translates the given attribute binding to a `ts.Expression`.
+ */
+export declare function translateInput(value: AST | string, tcb: Context, scope: Scope): ts.Expression;
+/**
+ * A `TcbOp` which generates code to check input bindings on an element that correspond with the
+ * members of a directive.
+ *
+ * Executing this operation returns nothing.
+ */
+export declare class TcbDirectiveInputsOp extends TcbOp {
+    private tcb;
+    private scope;
+    private node;
+    private dir;
+    private customControlType;
+    constructor(tcb: Context, scope: Scope, node: TmplAstTemplate | TmplAstElement | TmplAstComponent | TmplAstDirective, dir: TypeCheckableDirectiveMeta, customControlType: CustomFieldType | null);
+    get optional(): boolean;
+    execute(): null;
+    private checkRequiredInputs;
+}
+/**
+ * A `TcbOp` which generates code to check "unclaimed inputs" - bindings on an element which were
+ * not attributed to any directive or component, and are instead processed against the HTML element
+ * itself.
+ *
+ * Currently, only the expressions of these bindings are checked. The targets of the bindings are
+ * checked against the DOM schema via a `TcbDomSchemaCheckerOp`.
+ *
+ * Executing this operation returns nothing.
+ */
+export declare class TcbUnclaimedInputsOp extends TcbOp {
+    private tcb;
+    private scope;
+    private inputs;
+    private target;
+    private claimedInputs;
+    constructor(tcb: Context, scope: Scope, inputs: TmplAstBoundAttribute[], target: LocalSymbol, claimedInputs: Set<string> | null);
+    get optional(): boolean;
+    execute(): null;
+}

package/src/ngtsc/typecheck/src/ops/intersection_observer.d.ts

@@ -0,0 +1,22 @@
+/*!
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.dev/license
+ */
+import { AST } from '@angular/compiler';
+import { TcbOp } from './base';
+import { Context } from './context';
+import type { Scope } from './scope';
+/**
+ * A `TcbOp` which can be used to type check the options of an `IntersectionObserver`.
+ */
+export declare class TcbIntersectionObserverOp extends TcbOp {
+    private tcb;
+    private scope;
+    private options;
+    constructor(tcb: Context, scope: Scope, options: AST);
+    readonly optional = false;
+    execute(): null;
+}

package/src/ngtsc/typecheck/src/ops/let.d.ts

@@ -0,0 +1,29 @@
+/*!
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.dev/license
+ */
+import { TmplAstLetDeclaration } from '@angular/compiler';
+import ts from 'typescript';
+import { Context } from './context';
+import type { Scope } from './scope';
+import { TcbOp } from './base';
+/**
+ * A `TcbOp` which generates a constant for a `TmplAstLetDeclaration`.
+ *
+ * Executing this operation returns a reference to the `@let` declaration.
+ */
+export declare class TcbLetDeclarationOp extends TcbOp {
+    private tcb;
+    private scope;
+    private node;
+    constructor(tcb: Context, scope: Scope, node: TmplAstLetDeclaration);
+    /**
+     * `@let` declarations are mandatory, because their expressions
+     * should be checked even if they aren't referenced anywhere.
+     */
+    readonly optional = false;
+    execute(): ts.Identifier;
+}

package/src/ngtsc/typecheck/src/ops/references.d.ts

@@ -0,0 +1,57 @@
+/*!
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.dev/license
+ */
+import { TmplAstComponent, TmplAstDirective, TmplAstElement, TmplAstHostElement, TmplAstLetDeclaration, TmplAstReference, TmplAstTemplate, TmplAstVariable } from '@angular/compiler';
+import ts from 'typescript';
+import { TcbOp } from './base';
+import type { Context } from './context';
+import type { Scope } from './scope';
+import { TypeCheckableDirectiveMeta } from '../../api';
+/** Types that can referenced locally in a template. */
+export type LocalSymbol = TmplAstElement | TmplAstTemplate | TmplAstVariable | TmplAstLetDeclaration | TmplAstReference | TmplAstHostElement | TmplAstComponent | TmplAstDirective;
+/**
+ * A `TcbOp` which creates a variable for a local ref in a template.
+ * The initializer for the variable is the variable expression for the directive, template, or
+ * element the ref refers to. When the reference is used in the template, those TCB statements will
+ * access this variable as well. For example:
+ * ```ts
+ * var _t1 = document.createElement('div');
+ * var _t2 = _t1;
+ * _t2.value
+ * ```
+ * This operation supports more fluent lookups for the `TemplateTypeChecker` when getting a symbol
+ * for a reference. In most cases, this isn't essential; that is, the information for the symbol
+ * could be gathered without this operation using the `BoundTarget`. However, for the case of
+ * ng-template references, we will need this reference variable to not only provide a location in
+ * the shim file, but also to narrow the variable to the correct `TemplateRef<T>` type rather than
+ * `TemplateRef<any>` (this work is still TODO).
+ *
+ * Executing this operation returns a reference to the directive instance variable with its inferred
+ * type.
+ */
+export declare class TcbReferenceOp extends TcbOp {
+    private readonly tcb;
+    private readonly scope;
+    private readonly node;
+    private readonly host;
+    private readonly target;
+    constructor(tcb: Context, scope: Scope, node: TmplAstReference, host: TmplAstElement | TmplAstTemplate | TmplAstComponent | TmplAstDirective, target: TypeCheckableDirectiveMeta | TmplAstTemplate | TmplAstElement);
+    readonly optional = true;
+    execute(): ts.Identifier;
+}
+/**
+ * A `TcbOp` which is used when the target of a reference is missing. This operation generates a
+ * variable of type any for usages of the invalid reference to resolve to. The invalid reference
+ * itself is recorded out-of-band.
+ */
+export declare class TcbInvalidReferenceOp extends TcbOp {
+    private readonly tcb;
+    private readonly scope;
+    constructor(tcb: Context, scope: Scope);
+    readonly optional = true;
+    execute(): ts.Identifier;
+}

package/src/ngtsc/typecheck/src/ops/schema.d.ts

@@ -0,0 +1,31 @@
+/*!
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.dev/license
+ */
+import { TmplAstComponent, TmplAstElement, TmplAstHostElement } from '@angular/compiler';
+import ts from 'typescript';
+import { TcbOp } from './base';
+import { Context } from './context';
+/**
+ * A `TcbOp` which feeds elements and unclaimed properties to the `DomSchemaChecker`.
+ *
+ * The DOM schema is not checked via TCB code generation. Instead, the `DomSchemaChecker` ingests
+ * elements and property bindings and accumulates synthetic `ts.Diagnostic`s out-of-band. These are
+ * later merged with the diagnostics generated from the TCB.
+ *
+ * For convenience, the TCB iteration of the template is used to drive the `DomSchemaChecker` via
+ * the `TcbDomSchemaCheckerOp`.
+ */
+export declare class TcbDomSchemaCheckerOp extends TcbOp {
+    private tcb;
+    private element;
+    private checkElement;
+    private claimedInputs;
+    constructor(tcb: Context, element: TmplAstElement | TmplAstComponent | TmplAstHostElement, checkElement: boolean, claimedInputs: Set<string> | null);
+    get optional(): boolean;
+    execute(): ts.Expression | null;
+    private getTagName;
+}

package/src/ngtsc/typecheck/src/ops/scope.d.ts

@@ -0,0 +1,187 @@
+/*!
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.dev/license
+ */
+import { TmplAstForLoopBlock, TmplAstHostElement, TmplAstIfBlockBranch, TmplAstLetDeclaration, TmplAstNode, TmplAstReference, TmplAstTemplate, TmplAstVariable } from '@angular/compiler';
+import ts from 'typescript';
+import { TypeCheckableDirectiveMeta } from '../../api';
+import { Context } from './context';
+import { LocalSymbol } from './references';
+/**
+ * Local scope within the type check block for a particular template.
+ *
+ * The top-level template and each nested `<ng-template>` have their own `Scope`, which exist in a
+ * hierarchy. The structure of this hierarchy mirrors the syntactic scopes in the generated type
+ * check block, where each nested template is encased in an `if` structure.
+ *
+ * As a template's `TcbOp`s are executed in a given `Scope`, statements are added via
+ * `addStatement()`. When this processing is complete, the `Scope` can be turned into a `ts.Block`
+ * via `renderToBlock()`.
+ *
+ * If a `TcbOp` requires the output of another, it can call `resolve()`.
+ */
+export declare class Scope {
+    private tcb;
+    private parent;
+    private guard;
+    /**
+     * A queue of operations which need to be performed to generate the TCB code for this scope.
+     *
+     * This array can contain either a `TcbOp` which has yet to be executed, or a `ts.Expression|null`
+     * representing the memoized result of executing the operation. As operations are executed, their
+     * results are written into the `opQueue`, overwriting the original operation.
+     *
+     * If an operation is in the process of being executed, it is temporarily overwritten here with
+     * `INFER_TYPE_FOR_CIRCULAR_OP_EXPR`. This way, if a cycle is encountered where an operation
+     * depends transitively on its own result, the inner operation will infer the least narrow type
+     * that fits instead. This has the same semantics as TypeScript itself when types are referenced
+     * circularly.
+     */
+    private opQueue;
+    /**
+     * A map of `TmplAstElement`s to the index of their `TcbElementOp` in the `opQueue`
+     */
+    private elementOpMap;
+    /**
+     * A map of `TmplAstHostElement`s to the index of their `TcbHostElementOp` in the `opQueue`
+     */
+    private hostElementOpMap;
+    /**
+     * A map of `TmplAstComponent`s to the index of their `TcbComponentNodeOp` in the `opQueue`
+     */
+    private componentNodeOpMap;
+    /**
+     * A map of maps which tracks the index of `TcbDirectiveCtorOp`s in the `opQueue` for each
+     * directive on a `TmplAstElement` or `TmplAstTemplate` node.
+     */
+    private directiveOpMap;
+    /**
+     * A map of `TmplAstReference`s to the index of their `TcbReferenceOp` in the `opQueue`
+     */
+    private referenceOpMap;
+    /**
+     * Map of immediately nested <ng-template>s (within this `Scope`) represented by `TmplAstTemplate`
+     * nodes to the index of their `TcbTemplateContextOp`s in the `opQueue`.
+     */
+    private templateCtxOpMap;
+    /**
+     * Map of variables declared on the template that created this `Scope` (represented by
+     * `TmplAstVariable` nodes) to the index of their `TcbVariableOp`s in the `opQueue`, or to
+     * pre-resolved variable identifiers.
+     */
+    private varMap;
+    /**
+     * A map of the names of `TmplAstLetDeclaration`s to the index of their op in the `opQueue`.
+     *
+     * Assumes that there won't be duplicated `@let` declarations within the same scope.
+     */
+    private letDeclOpMap;
+    /**
+     * Statements for this template.
+     *
+     * Executing the `TcbOp`s in the `opQueue` populates this array.
+     */
+    private statements;
+    /**
+     * Gets names of the for loop context variables and their types.
+     */
+    private static getForLoopContextVariableTypes;
+    private constructor();
+    /**
+     * Constructs a `Scope` given either a `TmplAstTemplate` or a list of `TmplAstNode`s.
+     *
+     * @param tcb the overall context of TCB generation.
+     * @param parentScope the `Scope` of the parent template (if any) or `null` if this is the root
+     * `Scope`.
+     * @param scopedNode Node that provides the scope around the child nodes (e.g. a
+     * `TmplAstTemplate` node exposing variables to its children).
+     * @param children Child nodes that should be appended to the TCB.
+     * @param guard an expression that is applied to this scope for type narrowing purposes.
+     */
+    static forNodes(tcb: Context, parentScope: Scope | null, scopedNode: TmplAstTemplate | TmplAstIfBlockBranch | TmplAstForLoopBlock | TmplAstHostElement | null, children: TmplAstNode[] | null, guard: ts.Expression | null): Scope;
+    /** Registers a local variable with a scope. */
+    private static registerVariable;
+    /**
+     * Look up a `ts.Expression` representing the value of some operation in the current `Scope`,
+     * including any parent scope(s). This method always returns a mutable clone of the
+     * `ts.Expression` with the comments cleared.
+     *
+     * @param node a `TmplAstNode` of the operation in question. The lookup performed will depend on
+     * the type of this node:
+     *
+     * Assuming `directive` is not present, then `resolve` will return:
+     *
+     * * `TmplAstElement` - retrieve the expression for the element DOM node
+     * * `TmplAstTemplate` - retrieve the template context variable
+     * * `TmplAstVariable` - retrieve a template let- variable
+     * * `TmplAstLetDeclaration` - retrieve a template `@let` declaration
+     * * `TmplAstReference` - retrieve variable created for the local ref
+     *
+     * @param directive if present, a directive type on a `TmplAstElement` or `TmplAstTemplate` to
+     * look up instead of the default for an element or template node.
+     */
+    resolve(node: LocalSymbol, directive?: TypeCheckableDirectiveMeta): ts.Identifier | ts.NonNullExpression;
+    /**
+     * Add a statement to this scope.
+     */
+    addStatement(stmt: ts.Statement): void;
+    /**
+     * Get the statements.
+     */
+    render(): ts.Statement[];
+    /**
+     * Returns an expression of all template guards that apply to this scope, including those of
+     * parent scopes. If no guards have been applied, null is returned.
+     */
+    guards(): ts.Expression | null;
+    /** Returns whether a template symbol is defined locally within the current scope. */
+    isLocal(node: TmplAstVariable | TmplAstLetDeclaration | TmplAstReference): boolean;
+    /**
+     * Constructs a `Scope` given either a `TmplAstTemplate` or a list of `TmplAstNode`s.
+     * This is identical to `Scope.forNodes` which we can't reference in some ops due to
+     * circular dependencies.
+     *.
+     * @param parentScope the `Scope` of the parent template.
+     * @param scopedNode Node that provides the scope around the child nodes (e.g. a
+     * `TmplAstTemplate` node exposing variables to its children).
+     * @param children Child nodes that should be appended to the TCB.
+     * @param guard an expression that is applied to this scope for type narrowing purposes.
+     */
+    createChildScope(parentScope: Scope, scopedNode: TmplAstTemplate | TmplAstIfBlockBranch | TmplAstForLoopBlock | TmplAstHostElement | null, children: TmplAstNode[] | null, guard: ts.Expression | null): Scope;
+    private resolveLocal;
+    /**
+     * Like `executeOp`, but assert that the operation actually returned `ts.Expression`.
+     */
+    private resolveOp;
+    /**
+     * Execute a particular `TcbOp` in the `opQueue`.
+     *
+     * This method replaces the operation in the `opQueue` with the result of execution (once done)
+     * and also protects against a circular dependency from the operation to itself by temporarily
+     * setting the operation's result to a special expression.
+     */
+    private executeOp;
+    private appendNode;
+    private appendChildren;
+    private checkAndAppendReferencesOfNode;
+    private appendDirectivesAndInputsOfElementLikeNode;
+    private appendOutputsOfElementLikeNode;
+    private appendInputsOfSelectorlessNode;
+    private appendOutputsOfSelectorlessNode;
+    private appendDirectiveInputs;
+    private getDirectiveOp;
+    private appendSelectorlessDirectives;
+    private appendDeepSchemaChecks;
+    private appendIcuExpressions;
+    private appendContentProjectionCheckOp;
+    private appendComponentNode;
+    private appendDeferredBlock;
+    private appendDeferredTriggers;
+    private appendHostElement;
+    private validateReferenceBasedDeferredTrigger;
+    /** Reports a diagnostic if there are any `@let` declarations that conflict with a node. */
+    private static checkConflictingLet;
+}

package/src/ngtsc/typecheck/src/ops/selectorless.d.ts

@@ -0,0 +1,26 @@
+/*!
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.dev/license
+ */
+import { TmplAstComponent } from '@angular/compiler';
+import ts from 'typescript';
+import { TcbOp } from './base';
+import { Context } from './context';
+import type { Scope } from './scope';
+export declare function getComponentTagName(node: TmplAstComponent): string;
+/**
+ * A `TcbOp` which creates an expression for a native DOM element from a `TmplAstComponent`.
+ *
+ * Executing this operation returns a reference to the element variable.
+ */
+export declare class TcbComponentNodeOp extends TcbOp {
+    private tcb;
+    private scope;
+    private component;
+    readonly optional = true;
+    constructor(tcb: Context, scope: Scope, component: TmplAstComponent);
+    execute(): ts.Identifier;
+}

package/src/ngtsc/typecheck/src/ops/signal_forms.d.ts

@@ -0,0 +1,40 @@
+/*!
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.dev/license
+ */
+import { DirectiveOwner, TmplAstComponent, TmplAstDirective, TmplAstElement, TmplAstTemplate } from '@angular/compiler';
+import { TcbOp } from './base';
+import type { Context } from './context';
+import type { Scope } from './scope';
+import { TypeCheckableDirectiveMeta } from '../../api';
+import { TcbBoundAttribute } from './bindings';
+/** Possible types of custom field directives. */
+export type CustomFieldType = 'value' | 'checkbox';
+/** Names of input fields to which users aren't allowed to bind when using a `field` directive. */
+export declare const customFormControlBannedInputFields: Set<string>;
+/**
+ * A `TcbOp` which constructs an instance of the signal forms `Field` directive on a native element.
+ */
+export declare class TcbNativeFieldDirectiveTypeOp extends TcbOp {
+    private tcb;
+    private scope;
+    private node;
+    /** Bindings that aren't supported on signal form fields. */
+    protected readonly unsupportedBindingFields: Set<string>;
+    private readonly inputType;
+    get optional(): boolean;
+    constructor(tcb: Context, scope: Scope, node: TmplAstElement);
+    execute(): null;
+    private getExpectedTypeFromDomNode;
+    private getUnsupportedType;
+}
+/** Expands the set of bound inputs with the ones from custom field directives. */
+export declare function expandBoundAttributesForField(directive: TypeCheckableDirectiveMeta, node: TmplAstTemplate | TmplAstElement | TmplAstComponent | TmplAstDirective, customFieldType: CustomFieldType): TcbBoundAttribute[] | null;
+export declare function isFieldDirective(meta: TypeCheckableDirectiveMeta): boolean;
+/** Determines if a directive is a custom field and its type. */
+export declare function getCustomFieldDirectiveType(meta: TypeCheckableDirectiveMeta): CustomFieldType | null;
+/** Checks whether a node has bindings that aren't supported on fields. */
+export declare function checkUnsupportedFieldBindings(node: DirectiveOwner, unsupportedBindingFields: Set<string>, tcb: Context): void;

package/src/ngtsc/typecheck/src/ops/switch_block.d.ts

@@ -0,0 +1,25 @@
+/*!
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.dev/license
+ */
+import { TmplAstSwitchBlock } from '@angular/compiler';
+import { TcbOp } from './base';
+import type { Scope } from './scope';
+import type { Context } from './context';
+/**
+ * A `TcbOp` which renders a `switch` block as a TypeScript `switch` statement.
+ *
+ * Executing this operation returns nothing.
+ */
+export declare class TcbSwitchOp extends TcbOp {
+    private tcb;
+    private scope;
+    private block;
+    constructor(tcb: Context, scope: Scope, block: TmplAstSwitchBlock);
+    get optional(): boolean;
+    execute(): null;
+    private generateGuard;
+}

package/src/ngtsc/typecheck/src/ops/template.d.ts

@@ -0,0 +1,40 @@
+/*!
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.dev/license
+ */
+import { TmplAstTemplate } from '@angular/compiler';
+import ts from 'typescript';
+import { TcbOp } from './base';
+import type { Context } from './context';
+import type { Scope } from './scope';
+/**
+ * A `TcbOp` which generates a variable for a `TmplAstTemplate`'s context.
+ *
+ * Executing this operation returns a reference to the template's context variable.
+ */
+export declare class TcbTemplateContextOp extends TcbOp {
+    private tcb;
+    private scope;
+    constructor(tcb: Context, scope: Scope);
+    readonly optional = true;
+    execute(): ts.Identifier;
+}
+/**
+ * A `TcbOp` which descends into a `TmplAstTemplate`'s children and generates type-checking code for
+ * them.
+ *
+ * This operation wraps the children's type-checking code in an `if` block, which may include one
+ * or more type guard conditions that narrow types within the template body.
+ */
+export declare class TcbTemplateBodyOp extends TcbOp {
+    private tcb;
+    private scope;
+    private template;
+    constructor(tcb: Context, scope: Scope, template: TmplAstTemplate);
+    get optional(): boolean;
+    execute(): null;
+    private addDirectiveGuards;
+}

package/src/ngtsc/typecheck/src/ops/variables.d.ts

@@ -0,0 +1,56 @@
+/*!
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.dev/license
+ */
+import { TmplAstTemplate, TmplAstVariable } from '@angular/compiler';
+import ts from 'typescript';
+import { TcbOp } from './base';
+import type { Context } from './context';
+import type { Scope } from './scope';
+/**
+ * A `TcbOp` which renders a variable that is implicitly available within a block (e.g. `$count`
+ * in a `@for` block).
+ *
+ * Executing this operation returns the identifier which can be used to refer to the variable.
+ */
+export declare class TcbBlockImplicitVariableOp extends TcbOp {
+    private tcb;
+    private scope;
+    private type;
+    private variable;
+    constructor(tcb: Context, scope: Scope, type: ts.TypeNode, variable: TmplAstVariable);
+    readonly optional = true;
+    execute(): ts.Identifier;
+}
+/**
+ * A `TcbOp` which creates an expression for particular let- `TmplAstVariable` on a
+ * `TmplAstTemplate`'s context.
+ *
+ * Executing this operation returns a reference to the variable variable (lol).
+ */
+export declare class TcbTemplateVariableOp extends TcbOp {
+    private tcb;
+    private scope;
+    private template;
+    private variable;
+    constructor(tcb: Context, scope: Scope, template: TmplAstTemplate, variable: TmplAstVariable);
+    get optional(): boolean;
+    execute(): ts.Identifier;
+}
+/**
+ * A `TcbOp` which renders a variable defined inside of block syntax (e.g. `@if (expr; as var) {}`).
+ *
+ * Executing this operation returns the identifier which can be used to refer to the variable.
+ */
+export declare class TcbBlockVariableOp extends TcbOp {
+    private tcb;
+    private scope;
+    private initializer;
+    private variable;
+    constructor(tcb: Context, scope: Scope, initializer: ts.Expression, variable: TmplAstVariable);
+    get optional(): boolean;
+    execute(): ts.Identifier;
+}