@angular/compiler-cli 21.2.1 → 21.2.3

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

@@ -6,11 +6,11 @@
  * found in the LICENSE file at https://angular.dev/license
  */
 import { DirectiveOwner } from '@angular/compiler';
-import ts from 'typescript';
 import { TcbOp } from './base';
+import { TcbExpr } from './codegen';
 import { Context } from './context';
 import type { Scope } from './scope';
-import { TypeCheckableDirectiveMeta } from '../../api';
+import { TcbDirectiveMetadata } from '../../api';
 import { CustomFormControlType } from './signal_forms';
 /**
  * A `TcbOp` which constructs an instance of a directive with types inferred from its inputs. The
@@ -30,9 +30,9 @@ export declare class TcbDirectiveCtorOp extends TcbOp {
     private node;
     private dir;
     private customFormControlType;
-    constructor(tcb: Context, scope: Scope, node: DirectiveOwner, dir: TypeCheckableDirectiveMeta, customFormControlType: CustomFormControlType | null);
+    constructor(tcb: Context, scope: Scope, node: DirectiveOwner, dir: TcbDirectiveMetadata, customFormControlType: CustomFormControlType | null);
     get optional(): boolean;
-    execute(): ts.Identifier;
+    execute(): TcbExpr;
     circularFallback(): TcbOp;
 }
 /**
@@ -53,7 +53,7 @@ export declare class TcbDirectiveCtorCircularFallbackOp extends TcbOp {
     private tcb;
     private scope;
     private dir;
-    constructor(tcb: Context, scope: Scope, dir: TypeCheckableDirectiveMeta);
+    constructor(tcb: Context, scope: Scope, dir: TcbDirectiveMetadata);
     get optional(): boolean;
-    execute(): ts.Identifier;
+    execute(): TcbExpr;
 }

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

@@ -6,11 +6,11 @@
  * found in the LICENSE file at https://angular.dev/license
  */
 import { DirectiveOwner } from '@angular/compiler';
-import ts from 'typescript';
 import type { Context } from './context';
 import type { Scope } from './scope';
 import { TcbOp } from './base';
-import { TypeCheckableDirectiveMeta } from '../../api';
+import { TcbExpr } from './codegen';
+import { TcbDirectiveMetadata } from '../../api';
 /**
  * A `TcbOp` which constructs an instance of a directive. For generic directives, generic
  * parameters are set to `any` type.
@@ -19,10 +19,10 @@ export declare abstract class TcbDirectiveTypeOpBase extends TcbOp {
     protected tcb: Context;
     protected scope: Scope;
     protected node: DirectiveOwner;
-    protected dir: TypeCheckableDirectiveMeta;
-    constructor(tcb: Context, scope: Scope, node: DirectiveOwner, dir: TypeCheckableDirectiveMeta);
+    protected dir: TcbDirectiveMetadata;
+    constructor(tcb: Context, scope: Scope, node: DirectiveOwner, dir: TcbDirectiveMetadata);
     get optional(): boolean;
-    execute(): ts.Identifier;
+    execute(): TcbExpr;
 }
 /**
  * A `TcbOp` which constructs an instance of a non-generic directive _without_ setting any of its
@@ -38,7 +38,7 @@ export declare class TcbNonGenericDirectiveTypeOp extends TcbDirectiveTypeOpBase
      * Creates a variable declaration for this op's directive of the argument type. Returns the id of
      * the newly created variable.
      */
-    execute(): ts.Identifier;
+    execute(): TcbExpr;
 }
 /**
  * A `TcbOp` which constructs an instance of a generic directive with its generic parameters set
@@ -49,5 +49,5 @@ export declare class TcbNonGenericDirectiveTypeOp extends TcbDirectiveTypeOpBase
  * type parameters set to `any`.
  */
 export declare class TcbGenericDirectiveTypeWithAnyParamsOp extends TcbDirectiveTypeOpBase {
-    execute(): ts.Identifier;
+    execute(): TcbExpr;
 }

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

@@ -6,8 +6,8 @@
  * found in the LICENSE file at https://angular.dev/license
  */
 import { TmplAstElement } from '@angular/compiler';
-import ts from 'typescript';
 import { TcbOp } from './base';
+import { TcbExpr } from './codegen';
 import type { Context } from './context';
 import type { Scope } from './scope';
 /**
@@ -22,5 +22,5 @@ export declare class TcbElementOp extends TcbOp {
     private element;
     constructor(tcb: Context, scope: Scope, element: TmplAstElement);
     get optional(): boolean;
-    execute(): ts.Identifier;
+    execute(): TcbExpr;
 }

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

@@ -6,18 +6,18 @@
  * found in the LICENSE file at https://angular.dev/license
  */
 import { AST, DirectiveOwner, TmplAstBoundAttribute, TmplAstBoundEvent } from '@angular/compiler';
-import ts from 'typescript';
 import { TcbOp } from './base';
+import { TcbExpr } from './codegen';
 import type { Context } from './context';
 import type { Scope } from './scope';
-import { TypeCheckableDirectiveMeta } from '../../api';
+import { TcbDirectiveMetadata } from '../../api';
 import { LocalSymbol } from './references';
 /**
  * Similar to `tcbExpression`, this function converts the provided `AST` expression into a
  * `ts.Expression`, with special handling of the `$event` variable that can be used within event
  * bindings.
  */
-export declare function tcbEventHandlerExpression(ast: AST, tcb: Context, scope: Scope): ts.Expression;
+export declare function tcbEventHandlerExpression(ast: AST, tcb: Context, scope: Scope): TcbExpr;
 /**
  * A `TcbOp` which generates code to check event bindings on an element that correspond with the
  * outputs of a directive.
@@ -31,7 +31,7 @@ export declare class TcbDirectiveOutputsOp extends TcbOp {
     private inputs;
     private outputs;
     private dir;
-    constructor(tcb: Context, scope: Scope, node: DirectiveOwner, inputs: TmplAstBoundAttribute[] | null, outputs: TmplAstBoundEvent[], dir: TypeCheckableDirectiveMeta);
+    constructor(tcb: Context, scope: Scope, node: DirectiveOwner, inputs: TmplAstBoundAttribute[] | null, outputs: TmplAstBoundEvent[], dir: TcbDirectiveMetadata);
     get optional(): boolean;
     execute(): null;
 }

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

@@ -6,19 +6,19 @@
  * found in the LICENSE file at https://angular.dev/license
  */
 import { AST, PropertyRead, TmplAstLetDeclaration } from '@angular/compiler';
-import ts from 'typescript';
 import { TcbOp } from './base';
+import { TcbExpr } from './codegen';
 import type { Context } from './context';
 import type { Scope } from './scope';
 /**
  * Process an `AST` expression and convert it into a `ts.Expression`, generating references to the
  * correct identifiers in the current scope.
  */
-export declare function tcbExpression(ast: AST, tcb: Context, scope: Scope): ts.Expression;
+export declare function tcbExpression(ast: AST, tcb: Context, scope: Scope): TcbExpr;
 /**
  * Wraps an expression in an `unwrapSignal` call which extracts the signal's value.
  */
-export declare function unwrapWritableSignal(expression: ts.Expression, tcb: Context): ts.CallExpression;
+export declare function unwrapWritableSignal(expression: TcbExpr, tcb: Context): TcbExpr;
 /**
  * A `TcbOp` which renders an Angular expression (e.g. `{{foo() && bar.baz}}`).
  *
@@ -51,14 +51,14 @@ export declare class TcbExpressionTranslator {
     protected tcb: Context;
     protected scope: Scope;
     constructor(tcb: Context, scope: Scope);
-    translate(ast: AST): ts.Expression;
+    translate(ast: AST): TcbExpr;
     /**
      * Resolve an `AST` expression within the given scope.
      *
      * Some `AST` expressions refer to top-level concepts (references, variables, the component
      * context). This method assists in resolving those.
      */
-    protected resolve(ast: AST): ts.Expression | null;
+    protected resolve(ast: AST): TcbExpr | null;
     private getTargetNodeExpression;
     protected isValidLetDeclarationAccess(target: TmplAstLetDeclaration, ast: PropertyRead): boolean;
 }

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

@@ -6,11 +6,11 @@
  * 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';
+import { TcbExpr } from './codegen';
 /**
  * A `TcbOp` which renders a `for` block as a TypeScript `for...of` loop.
  *
@@ -28,5 +28,5 @@ export declare class TcbForLoopTrackTranslator extends TcbExpressionTranslator {
     private block;
     private allowedVariables;
     constructor(tcb: Context, scope: Scope, block: TmplAstForLoopBlock);
-    protected resolve(ast: AST): ts.Expression | null;
+    protected resolve(ast: AST): TcbExpr | null;
 }

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

@@ -6,8 +6,8 @@
  * found in the LICENSE file at https://angular.dev/license
  */
 import { TmplAstHostElement } from '@angular/compiler';
-import ts from 'typescript';
 import { TcbOp } from './base';
+import { TcbExpr } from './codegen';
 import type { Context } from './context';
 import type { Scope } from './scope';
 /**
@@ -21,5 +21,5 @@ export declare class TcbHostElementOp extends TcbOp {
     private element;
     readonly optional = true;
     constructor(tcb: Context, scope: Scope, element: TmplAstHostElement);
-    execute(): ts.Identifier;
+    execute(): TcbExpr;
 }

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

@@ -6,17 +6,17 @@
  * 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 { TcbDirectiveMetadata } from '../../api';
 import { TcbOp } from './base';
+import { TcbExpr } from './codegen';
 import { CustomFormControlType } 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;
+export declare function translateInput(value: AST | string, tcb: Context, scope: Scope): TcbExpr;
 /**
  * A `TcbOp` which generates code to check input bindings on an element that correspond with the
  * members of a directive.
@@ -30,7 +30,7 @@ export declare class TcbDirectiveInputsOp extends TcbOp {
     private dir;
     private isFormControl;
     private customFormControlType;
-    constructor(tcb: Context, scope: Scope, node: TmplAstTemplate | TmplAstElement | TmplAstComponent | TmplAstDirective, dir: TypeCheckableDirectiveMeta, isFormControl: boolean | undefined, customFormControlType: CustomFormControlType | null);
+    constructor(tcb: Context, scope: Scope, node: TmplAstTemplate | TmplAstElement | TmplAstComponent | TmplAstDirective, dir: TcbDirectiveMetadata, isFormControl: boolean | undefined, customFormControlType: CustomFormControlType | null);
     get optional(): boolean;
     execute(): null;
     private checkRequiredInputs;

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

@@ -6,10 +6,10 @@
  * 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';
+import { TcbExpr } from './codegen';
 /**
  * A `TcbOp` which generates a constant for a `TmplAstLetDeclaration`.
  *
@@ -25,5 +25,5 @@ export declare class TcbLetDeclarationOp extends TcbOp {
      * should be checked even if they aren't referenced anywhere.
      */
     readonly optional = false;
-    execute(): ts.Identifier;
+    execute(): TcbExpr;
 }

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

@@ -6,11 +6,11 @@
  * 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 { TcbExpr } from './codegen';
 import type { Context } from './context';
 import type { Scope } from './scope';
-import { TypeCheckableDirectiveMeta } from '../../api';
+import { TcbDirectiveMetadata } from '../../api';
 /** Types that can referenced locally in a template. */
 export type LocalSymbol = TmplAstElement | TmplAstTemplate | TmplAstVariable | TmplAstLetDeclaration | TmplAstReference | TmplAstHostElement | TmplAstComponent | TmplAstDirective;
 /**
@@ -39,9 +39,9 @@ export declare class TcbReferenceOp extends TcbOp {
     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);
+    constructor(tcb: Context, scope: Scope, node: TmplAstReference, host: TmplAstElement | TmplAstTemplate | TmplAstComponent | TmplAstDirective, target: TcbDirectiveMetadata | TmplAstTemplate | TmplAstElement);
     readonly optional = true;
-    execute(): ts.Identifier;
+    execute(): TcbExpr;
 }
 /**
  * A `TcbOp` which is used when the target of a reference is missing. This operation generates a
@@ -53,5 +53,5 @@ export declare class TcbInvalidReferenceOp extends TcbOp {
     private readonly scope;
     constructor(tcb: Context, scope: Scope);
     readonly optional = true;
-    execute(): ts.Identifier;
+    execute(): TcbExpr;
 }

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

@@ -6,8 +6,8 @@
  * 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 { TcbExpr } from './codegen';
 import { Context } from './context';
 /**
  * A `TcbOp` which feeds elements and unclaimed properties to the `DomSchemaChecker`.
@@ -26,6 +26,6 @@ export declare class TcbDomSchemaCheckerOp extends TcbOp {
     private claimedInputs;
     constructor(tcb: Context, element: TmplAstElement | TmplAstComponent | TmplAstHostElement, checkElement: boolean, claimedInputs: Set<string> | null);
     get optional(): boolean;
-    execute(): ts.Expression | null;
+    execute(): TcbExpr | null;
     private getTagName;
 }

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

@@ -6,8 +6,8 @@
  * 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 { TcbExpr } from './codegen';
+import { TcbDirectiveMetadata } from '../../api';
 import { Context } from './context';
 import { LocalSymbol } from './references';
 /**
@@ -30,7 +30,7 @@ export declare class Scope {
     /**
      * 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`
+     * This array can contain either a `TcbOp` which has yet to be executed, or a `TcbExpr|null`
      * representing the memoized result of executing the operation. As operations are executed, their
      * results are written into the `opQueue`, overwriting the original operation.
      *
@@ -101,7 +101,7 @@ export declare class Scope {
      * @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;
+    static forNodes(tcb: Context, parentScope: Scope | null, scopedNode: TmplAstTemplate | TmplAstIfBlockBranch | TmplAstForLoopBlock | TmplAstHostElement | null, children: TmplAstNode[] | null, guard: TcbExpr | null): Scope;
     /** Registers a local variable with a scope. */
     private static registerVariable;
     /**
@@ -123,20 +123,20 @@ export declare class Scope {
      * @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;
+    resolve(node: LocalSymbol, directive?: TcbDirectiveMetadata): TcbExpr;
     /**
      * Add a statement to this scope.
      */
-    addStatement(stmt: ts.Statement): void;
+    addStatement(stmt: TcbExpr): void;
     /**
      * Get the statements.
      */
-    render(): ts.Statement[];
+    render(): TcbExpr[];
     /**
      * 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;
+    guards(): TcbExpr | null;
     /** Returns whether a template symbol is defined locally within the current scope. */
     isLocal(node: TmplAstVariable | TmplAstLetDeclaration | TmplAstReference): boolean;
     /**
@@ -150,10 +150,10 @@ export declare class Scope {
      * @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;
+    createChildScope(parentScope: Scope, scopedNode: TmplAstTemplate | TmplAstIfBlockBranch | TmplAstForLoopBlock | TmplAstHostElement | null, children: TmplAstNode[] | null, guard: TcbExpr | null): Scope;
     private resolveLocal;
     /**
-     * Like `executeOp`, but assert that the operation actually returned `ts.Expression`.
+     * Like `executeOp`, but assert that the operation actually returned `TcbExpr`.
      */
     private resolveOp;
     /**

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

@@ -6,8 +6,8 @@
  * found in the LICENSE file at https://angular.dev/license
  */
 import { TmplAstComponent } from '@angular/compiler';
-import ts from 'typescript';
 import { TcbOp } from './base';
+import { TcbExpr } from './codegen';
 import { Context } from './context';
 import type { Scope } from './scope';
 export declare function getComponentTagName(node: TmplAstComponent): string;
@@ -22,5 +22,5 @@ export declare class TcbComponentNodeOp extends TcbOp {
     private component;
     readonly optional = true;
     constructor(tcb: Context, scope: Scope, component: TmplAstComponent);
-    execute(): ts.Identifier;
+    execute(): TcbExpr;
 }

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

@@ -6,7 +6,7 @@
  * found in the LICENSE file at https://angular.dev/license
  */
 import { DirectiveOwner, TmplAstComponent, TmplAstDirective, TmplAstElement, TmplAstNode, TmplAstTemplate } from '@angular/compiler';
-import { TypeCheckableDirectiveMeta } from '../../api';
+import { TcbDirectiveMetadata } from '../../api';
 import { TcbOp } from './base';
 import { TcbBoundAttribute } from './bindings';
 import type { Context } from './context';
@@ -39,12 +39,12 @@ export declare class TcbNativeRadioButtonFieldOp extends TcbNativeFieldOp {
     execute(): null;
 }
 /** Expands the set of bound inputs with the ones from custom field directives. */
-export declare function expandBoundAttributesForField(directive: TypeCheckableDirectiveMeta, node: TmplAstTemplate | TmplAstElement | TmplAstComponent | TmplAstDirective, customFormControlType: CustomFormControlType | null): TcbBoundAttribute[] | null;
-export declare function isFieldDirective(meta: TypeCheckableDirectiveMeta): boolean;
+export declare function expandBoundAttributesForField(directive: TcbDirectiveMetadata, node: TmplAstTemplate | TmplAstElement | TmplAstComponent | TmplAstDirective, customFormControlType: CustomFormControlType | null): TcbBoundAttribute[] | null;
+export declare function isFieldDirective(meta: TcbDirectiveMetadata): boolean;
 /** Determines if a directive is a custom field and its type. */
-export declare function getCustomFieldDirectiveType(meta: TypeCheckableDirectiveMeta): CustomFormControlType | null;
+export declare function getCustomFieldDirectiveType(meta: TcbDirectiveMetadata): CustomFormControlType | null;
 /** Determines if a directive usage is on a native field. */
-export declare function isNativeField(dir: TypeCheckableDirectiveMeta, node: TmplAstNode, allDirectiveMatches: TypeCheckableDirectiveMeta[]): node is TmplAstElement & {
+export declare function isNativeField(dir: TcbDirectiveMetadata, node: TmplAstNode, allDirectiveMatches: TcbDirectiveMetadata[]): node is TmplAstElement & {
     name: 'input' | 'select' | 'textarea';
 };
 /** Checks whether a node has bindings that aren't supported on fields. */
@@ -55,4 +55,4 @@ export declare function checkUnsupportedFieldBindings(node: DirectiveOwner, unsu
  * A node is a form control if it has a matching `FormField` directive, and no other directives match
  * the `field` input.
  */
-export declare function isFormControl(allDirectiveMatches: TypeCheckableDirectiveMeta[]): boolean;
+export declare function isFormControl(allDirectiveMatches: TcbDirectiveMetadata[]): boolean;

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

@@ -6,8 +6,8 @@
  * found in the LICENSE file at https://angular.dev/license
  */
 import { TmplAstTemplate } from '@angular/compiler';
-import ts from 'typescript';
 import { TcbOp } from './base';
+import { TcbExpr } from './codegen';
 import type { Context } from './context';
 import type { Scope } from './scope';
 /**
@@ -20,7 +20,7 @@ export declare class TcbTemplateContextOp extends TcbOp {
     private scope;
     constructor(tcb: Context, scope: Scope);
     readonly optional = true;
-    execute(): ts.Identifier;
+    execute(): TcbExpr;
 }
 /**
  * A `TcbOp` which descends into a `TmplAstTemplate`'s children and generates type-checking code for

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

@@ -6,10 +6,10 @@
  * 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';
+import { TcbExpr } from './codegen';
 /**
  * A `TcbOp` which renders a variable that is implicitly available within a block (e.g. `$count`
  * in a `@for` block).
@@ -21,9 +21,9 @@ export declare class TcbBlockImplicitVariableOp extends TcbOp {
     private scope;
     private type;
     private variable;
-    constructor(tcb: Context, scope: Scope, type: ts.TypeNode, variable: TmplAstVariable);
+    constructor(tcb: Context, scope: Scope, type: TcbExpr, variable: TmplAstVariable);
     readonly optional = true;
-    execute(): ts.Identifier;
+    execute(): TcbExpr;
 }
 /**
  * A `TcbOp` which creates an expression for particular let- `TmplAstVariable` on a
@@ -38,7 +38,7 @@ export declare class TcbTemplateVariableOp extends TcbOp {
     private variable;
     constructor(tcb: Context, scope: Scope, template: TmplAstTemplate, variable: TmplAstVariable);
     get optional(): boolean;
-    execute(): ts.Identifier;
+    execute(): TcbExpr;
 }
 /**
  * A `TcbOp` which renders a variable defined inside of block syntax (e.g. `@if (expr; as var) {}`).
@@ -50,7 +50,7 @@ export declare class TcbBlockVariableOp extends TcbOp {
     private scope;
     private initializer;
     private variable;
-    constructor(tcb: Context, scope: Scope, initializer: ts.Expression, variable: TmplAstVariable);
+    constructor(tcb: Context, scope: Scope, initializer: TcbExpr, variable: TmplAstVariable);
     get optional(): boolean;
-    execute(): ts.Identifier;
+    execute(): TcbExpr;
 }

package/src/ngtsc/typecheck/src/reference_emit_environment.d.ts

@@ -10,6 +10,8 @@ import ts from 'typescript';
 import { ImportFlags, Reference, ReferenceEmitter } from '../../imports';
 import { ReflectionHost } from '../../reflection';
 import { ImportManager } from '../../translator';
+import { TcbReferenceMetadata } from '../api';
+import { TcbExpr } from './ops/codegen';
 /**
  * An environment for a given source file that can be used to emit references.
  *
@@ -18,7 +20,7 @@ import { ImportManager } from '../../translator';
  */
 export declare class ReferenceEmitEnvironment {
     readonly importManager: ImportManager;
-    protected refEmitter: ReferenceEmitter;
+    refEmitter: ReferenceEmitter;
     readonly reflector: ReflectionHost;
     contextFile: ts.SourceFile;
     constructor(importManager: ImportManager, refEmitter: ReferenceEmitter, reflector: ReflectionHost, contextFile: ts.SourceFile);
@@ -30,10 +32,22 @@ export declare class ReferenceEmitEnvironment {
      */
     referenceType(ref: Reference, flags?: ImportFlags): ts.TypeNode;
     /**
-     * Generate a `ts.Expression` that refers to the external symbol. This
-     * may result in new imports being generated.
+     * Generates a `ts.TypeNode` from a `TcbReferenceMetadata` object.
+     * This is used by the TCB operations which do not hold on to the original `ts.Declaration`.
+     *
+     * Note: It's important that we do not try to evaluate the `typeParameters` here and pad them
+     * out with `any` type arguments. If we supply `any` to a generic pipe (e.g. `var _pipe1: MyPipe<any>;`),
+     * it destroys the generic constraints and degrades the `transform` signature. When they are omitted
+     * entirely, TypeScript implicitly flags an error, which the Angular compiler filters out, and
+     * crucially recovers by falling back to constraint inference (e.g. `var _pipe1: MyPipe;` infers
+     * bounds safely).
+     */
+    referenceTcbType(ref: TcbReferenceMetadata): ts.TypeNode;
+    /**
+     * Generates a `TcbExpr` from a `TcbReferenceMetadata` object.
      */
-    referenceExternalSymbol(moduleName: string, name: string): ts.Expression;
+    referenceTcbValue(ref: TcbReferenceMetadata): TcbExpr;
+    referenceExternalSymbol(moduleName: string, name: string): TcbExpr;
     /**
      * Generate a `ts.TypeNode` that references a given type from the provided module.
      *

package/src/ngtsc/typecheck/src/tcb_adapter.d.ts

@@ -0,0 +1,20 @@
+/**
+ * @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 { TypeCheckBlockMetadata, TcbTypeCheckBlockMetadata, TcbComponentMetadata } from '../api';
+import { Environment } from './environment';
+import { Reference } from '../../imports';
+import { ClassDeclaration } from '../../reflection';
+import ts from 'typescript';
+/**
+ * Adapts the compiler's `TypeCheckBlockMetadata` (which includes full TS AST nodes)
+ * into a purely detached `TcbTypeCheckBlockMetadata` that can be mapped to JSON.
+ */
+export declare function adaptTypeCheckBlockMetadata(ref: Reference<ClassDeclaration<ts.ClassDeclaration>>, meta: TypeCheckBlockMetadata, env: Environment): {
+    tcbMeta: TcbTypeCheckBlockMetadata;
+    component: TcbComponentMetadata;
+};

package/src/ngtsc/typecheck/src/tcb_util.d.ts

@@ -9,7 +9,7 @@ import { AbsoluteSourceSpan, ParseSourceSpan } from '@angular/compiler';
 import ts from 'typescript';
 import { ClassDeclaration, ReflectionHost } from '../../../../src/ngtsc/reflection';
 import { Reference } from '../../imports';
-import { FullSourceMapping, SourceLocation, TypeCheckId, SourceMapping } from '../api';
+import { FullSourceMapping, SourceLocation, TypeCheckId, SourceMapping, TcbTypeParameter } from '../api';
 import { ReferenceEmitEnvironment } from './reference_emit_environment';
 /**
  * Adapter interface which allows the directive type-checking diagnostics code to interpret offsets
@@ -78,3 +78,4 @@ export declare function ensureTypeCheckFilePreparationImports(env: ReferenceEmit
 export declare function checkIfGenericTypeBoundsCanBeEmitted(node: ClassDeclaration<ts.ClassDeclaration>, reflector: ReflectionHost, env: ReferenceEmitEnvironment): boolean;
 export declare function findNodeInFile<T extends ts.Node>(file: ts.SourceFile, predicate: (node: ts.Node) => node is T): T | null;
 export declare function findNodeInFile(file: ts.SourceFile, predicate: (node: ts.Node) => boolean): ts.Node | null;
+export declare function generateTcbTypeParameters(typeParameters: ReadonlyArray<ts.TypeParameterDeclaration>, sourceFile: ts.SourceFile): TcbTypeParameter[];

package/src/ngtsc/typecheck/src/ts_util.d.ts

@@ -6,43 +6,6 @@
  * found in the LICENSE file at https://angular.dev/license
  */
 import ts from 'typescript';
-export declare function tsCastToAny(expr: ts.Expression): ts.Expression;
-/**
- * Create an expression which instantiates an element by its HTML tagName.
- *
- * Thanks to narrowing of `document.createElement()`, this expression will have its type inferred
- * based on the tag name, including for custom elements that have appropriate .d.ts definitions.
- */
-export declare function tsCreateElement(...tagNames: string[]): ts.Expression;
-/**
- * Create a `ts.VariableStatement` which declares a variable without explicit initialization.
- *
- * The initializer `null!` is used to bypass strict variable initialization checks.
- *
- * Unlike with `tsCreateVariable`, the type of the variable is explicitly specified.
- */
-export declare function tsDeclareVariable(id: ts.Identifier, type: ts.TypeNode): ts.VariableStatement;
-/**
- * Creates a `ts.TypeQueryNode` for a coerced input.
- *
- * For example: `typeof MatInput.ngAcceptInputType_value`, where MatInput is `typeName` and `value`
- * is the `coercedInputName`.
- *
- * @param typeName The `EntityName` of the Directive where the static coerced input is defined.
- * @param coercedInputName The field name of the coerced input.
- */
-export declare function tsCreateTypeQueryForCoercedInput(typeName: ts.EntityName, coercedInputName: string): ts.TypeQueryNode;
-/**
- * Create a `ts.VariableStatement` that initializes a variable with a given expression.
- *
- * Unlike with `tsDeclareVariable`, the type of the variable is inferred from the initializer
- * expression.
- */
-export declare function tsCreateVariable(id: ts.Identifier, initializer: ts.Expression, flags?: ts.NodeFlags | null): ts.VariableStatement;
-/**
- * Construct a `ts.CallExpression` that calls a method on a receiver.
- */
-export declare function tsCallMethod(receiver: ts.Expression, methodName: string, args?: ts.Expression[]): ts.CallExpression;
 export declare function isAccessExpression(node: ts.Node): node is ts.ElementAccessExpression | ts.PropertyAccessExpression;
 /**
  * Creates a TypeScript node representing a numeric value.

package/src/ngtsc/typecheck/src/type_check_block.d.ts

@@ -6,9 +6,7 @@
  * found in the LICENSE file at https://angular.dev/license
  */
 import ts from 'typescript';
-import { Reference } from '../../imports';
-import { ClassDeclaration } from '../../reflection';
-import { TypeCheckBlockMetadata } from '../api';
+import { TcbComponentMetadata, TcbTypeCheckBlockMetadata } from '../api';
 import { DomSchemaChecker } from './dom';
 import { Environment } from './environment';
 import { OutOfBandDiagnosticRecorder } from './oob';
@@ -37,4 +35,4 @@ import { TcbGenericContextBehavior } from './ops/context';
  * @param genericContextBehavior controls how generic parameters (especially parameters with generic
  * bounds) will be referenced from the generated TCB code.
  */
-export declare function generateTypeCheckBlock(env: Environment, ref: Reference<ClassDeclaration<ts.ClassDeclaration>>, name: ts.Identifier, meta: TypeCheckBlockMetadata, domSchemaChecker: DomSchemaChecker, oobRecorder: OutOfBandDiagnosticRecorder, genericContextBehavior: TcbGenericContextBehavior): ts.FunctionDeclaration;
+export declare function generateTypeCheckBlock(env: Environment, component: TcbComponentMetadata, name: ts.Identifier, meta: TcbTypeCheckBlockMetadata, domSchemaChecker: DomSchemaChecker, oobRecorder: OutOfBandDiagnosticRecorder, genericContextBehavior: TcbGenericContextBehavior): string;