@angular/compiler-cli 18.0.0-next.1 → 18.0.0-next.3

package/index.d.ts

@@ -13,4 +13,5 @@ export { OptimizeFor } from './src/ngtsc/typecheck/api';
 export { ConsoleLogger, Logger, LogLevel } from './src/ngtsc/logging';
 export { NodeJSFileSystem, absoluteFrom } from './src/ngtsc/file_system';
 export * from './src/ngtsc/docs/src/entities';
+export * from './src/ngtsc/docs';
 export { isLocalCompilationDiagnostics } from './src/ngtsc/diagnostics';

package/linker/babel/src/ast/babel_ast_host.d.ts

@@ -24,8 +24,9 @@ export declare class BabelAstHost implements AstHost<t.Expression> {
     parseArrayLiteral(array: t.Expression): t.Expression[];
     isObjectLiteral: typeof t.isObjectExpression;
     parseObjectLiteral(obj: t.Expression): Map<string, t.Expression>;
-    isFunctionExpression(node: t.Expression): node is Extract<t.Function, t.Expression>;
+    isFunctionExpression(node: t.Expression): node is Extract<t.Function | t.ArrowFunctionExpression, t.Expression>;
     parseReturnValue(fn: t.Expression): t.Expression;
+    parseParameters(fn: t.Expression): t.Expression[];
     isCallExpression: typeof t.isCallExpression;
     parseCallee(call: t.Expression): t.Expression;
     parseArguments(call: t.Expression): t.Expression[];

package/linker/src/ast/ast_host.d.ts

@@ -76,6 +76,10 @@ export interface AstHost<TExpression> {
      * statement, extracting the returned expression, or throw if it is not possible.
      */
     parseReturnValue(fn: TExpression): TExpression;
+    /**
+     * Returns the parameter expressions for the function, or throw if it is not a function.
+     */
+    parseParameters(fn: TExpression): TExpression[];
     /**
      * Return true if the given expression is a call expression, or false otherwise.
      */

package/linker/src/ast/ast_value.d.ts

@@ -188,6 +188,11 @@ export declare class AstValue<T, TExpression> {
      * it is not a function expression.
      */
     getFunctionReturnValue<R>(this: ConformsTo<this, T, Function>): AstValue<R, TExpression>;
+    /**
+     * Extract the parameters from this value as a function expression, or error if it is not a
+     * function expression.
+     */
+    getFunctionParameters<R>(this: ConformsTo<this, T, Function>): AstValue<R, TExpression>[];
     isCallExpression(): boolean;
     getCallee(): AstValue<unknown, TExpression>;
     getArguments(): AstValue<unknown, TExpression>[];

package/linker/src/ast/typescript/typescript_ast_host.d.ts

@@ -31,6 +31,7 @@ export declare class TypeScriptAstHost implements AstHost<ts.Expression> {
     parseObjectLiteral(obj: ts.Expression): Map<string, ts.Expression>;
     isFunctionExpression(node: ts.Expression): node is ts.FunctionExpression | ts.ArrowFunction;
     parseReturnValue(fn: ts.Expression): ts.Expression;
+    parseParameters(fn: ts.Expression): ts.Expression[];
     isCallExpression: typeof ts.isCallExpression;
     parseCallee(call: ts.Expression): ts.Expression;
     parseArguments(call: ts.Expression): ts.Expression[];

package/linker/src/file_linker/partial_linkers/partial_class_metadata_async_linker_1.d.ts

@@ -0,0 +1,16 @@
+/**
+ * @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.io/license
+ */
+import { ConstantPool, R3DeclareClassMetadataAsync } from '@angular/compiler';
+import { AstObject } from '../../ast/ast_value';
+import { LinkedDefinition, PartialLinker } from './partial_linker';
+/**
+ * A `PartialLinker` that is designed to process `ɵɵngDeclareClassMetadataAsync()` call expressions.
+ */
+export declare class PartialClassMetadataAsyncLinkerVersion1<TExpression> implements PartialLinker<TExpression> {
+    linkPartialDeclaration(constantPool: ConstantPool, metaObj: AstObject<R3DeclareClassMetadataAsync, TExpression>): LinkedDefinition;
+}

package/linker/src/file_linker/partial_linkers/partial_linker_selector.d.ts

@@ -18,6 +18,7 @@ export declare const ɵɵngDeclareInjectable = "\u0275\u0275ngDeclareInjectable"
 export declare const ɵɵngDeclareInjector = "\u0275\u0275ngDeclareInjector";
 export declare const ɵɵngDeclareNgModule = "\u0275\u0275ngDeclareNgModule";
 export declare const ɵɵngDeclarePipe = "\u0275\u0275ngDeclarePipe";
+export declare const ɵɵngDeclareClassMetadataAsync = "\u0275\u0275ngDeclareClassMetadataAsync";
 export declare const declarationFunctions: string[];
 export interface LinkerRange<TExpression> {
     range: semver.Range;

package/linker/src/file_linker/partial_linkers/util.d.ts

@@ -7,7 +7,7 @@
  */
 import { MaybeForwardRefExpression, outputAst as o, R3DeclareDependencyMetadata, R3DependencyMetadata, R3Reference } from '@angular/compiler';
 import { AstObject, AstValue } from '../../ast/ast_value';
-export declare const PLACEHOLDER_VERSION = "18.0.0-next.1";
+export declare const PLACEHOLDER_VERSION = "18.0.0-next.3";
 export declare function wrapReference<TExpression>(wrapped: o.WrappedNodeExpr<TExpression>): R3Reference;
 /**
  * Parses the value of an enum from the AST value's symbol name.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@angular/compiler-cli",
-  "version": "18.0.0-next.1",
+  "version": "18.0.0-next.3",
   "description": "Angular - the compiler CLI for Node.js",
   "typings": "index.d.ts",
   "bin": {
@@ -43,7 +43,7 @@
     }
   },
   "dependencies": {
-    "@babel/core": "7.24.1",
+    "@babel/core": "7.24.3",
     "@jridgewell/sourcemap-codec": "^1.4.14",
     "reflect-metadata": "^0.2.0",
     "chokidar": "^3.0.0",
@@ -53,8 +53,8 @@
     "yargs": "^17.2.1"
   },
   "peerDependencies": {
-    "@angular/compiler": "18.0.0-next.1",
-    "typescript": ">=5.2 <5.5"
+    "@angular/compiler": "18.0.0-next.3",
+    "typescript": ">=5.4 <5.5"
   },
   "repository": {
     "type": "git",

package/src/ngtsc/annotations/component/src/handler.d.ts

@@ -102,7 +102,7 @@ export declare class ComponentDecoratorHandler implements DecoratorHandler<Decor
      * Computes a list of deferrable symbols based on dependencies from
      * the `@Component.imports` field and their usage in `@defer` blocks.
      */
-    private collectDeferredSymbols;
+    private resolveAllDeferredDependencies;
     /**
      * Collects deferrable symbols from the `@Component.deferredImports` field.
      */

package/src/ngtsc/annotations/directive/index.d.ts

@@ -12,3 +12,4 @@ export * from './src/input_function';
 export * from './src/output_function';
 export * from './src/query_functions';
 export * from './src/model_function';
+export * from './src/initializer_functions';

package/src/ngtsc/annotations/directive/src/initializer_function_access.d.ts

@@ -0,0 +1,17 @@
+/**
+ * @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.io/license
+ */
+import { ClassMember } from '../../../reflection';
+import { InitializerFunctionMetadata } from './initializer_functions';
+/**
+ * Validates that the initializer member is compatible with the given class
+ * member in terms of field access and visibility.
+ *
+ * @throws {FatalDiagnosticError} If the recognized initializer API is
+ *   incompatible.
+ */
+export declare function validateAccessOfInitializerApiMember({ api, call }: InitializerFunctionMetadata, member: Pick<ClassMember, 'accessLevel'>): void;

package/src/ngtsc/annotations/directive/src/initializer_functions.d.ts

@@ -7,7 +7,7 @@
  */
 import ts from 'typescript';
 import { ImportedSymbolsTracker } from '../../../imports';
-import { ClassMember, ReflectionHost } from '../../../reflection';
+import { ClassMemberAccessLevel, ReflectionHost } from '../../../reflection';
 /**
  * @fileoverview
  *
@@ -20,14 +20,18 @@ import { ClassMember, ReflectionHost } from '../../../reflection';
  * declared through initializer APIs.
  */
 export interface InitializerApiFunction {
+    /** Module name where the initializer function is imported from. */
     owningModule: '@angular/core' | '@angular/core/rxjs-interop';
+    /** Export name of the initializer function. */
     functionName: ('input' | 'model' | 'output' | 'outputFromObservable' | 'viewChild' | 'viewChildren' | 'contentChild' | 'contentChildren');
+    /** Class member access levels compatible with the API. */
+    allowedAccessLevels: ClassMemberAccessLevel[];
 }
 /**
  * Metadata describing an Angular class member that was recognized through
  * a function initializer. Like `input`, `input.required` or `viewChild`.
  */
-interface InitializerFunctionMetadata {
+export interface InitializerFunctionMetadata {
     /** Initializer API function that was recognized. */
     api: InitializerApiFunction;
     /** Node referring to the call expression. */
@@ -36,13 +40,13 @@ interface InitializerFunctionMetadata {
     isRequired: boolean;
 }
 /**
- * Attempts to identify an Angular class member that is declared via
- * its initializer referring to a given initializer API function.
+ * Attempts to identify an Angular initializer function call.
  *
  * Note that multiple possible initializer API function names can be specified,
  * allowing for checking multiple types in one pass.
+ *
+ * @returns The parsed initializer API, or null if none was found.
  */
-export declare function tryParseInitializerApiMember<Functions extends InitializerApiFunction[]>(functions: Functions, member: Pick<ClassMember, 'value'>, reflector: ReflectionHost, importTracker: ImportedSymbolsTracker): (InitializerFunctionMetadata & {
+export declare function tryParseInitializerApi<Functions extends InitializerApiFunction[]>(functions: Functions, expression: ts.Expression, reflector: ReflectionHost, importTracker: ImportedSymbolsTracker): (InitializerFunctionMetadata & {
     api: Functions[number];
 } | null);
-export {};

package/src/ngtsc/annotations/directive/src/input_function.d.ts

@@ -8,8 +8,11 @@
 import { ImportedSymbolsTracker } from '../../../imports';
 import { InputMapping } from '../../../metadata';
 import { ClassMember, ReflectionHost } from '../../../reflection';
+import { InitializerApiFunction } from './initializer_functions';
+/** Represents a function that can declare an input. */
+export declare const INPUT_INITIALIZER_FN: InitializerApiFunction;
 /**
  * Attempts to parse a signal input class member. Returns the parsed
  * input mapping if possible.
  */
-export declare function tryParseSignalInputMapping(member: Pick<ClassMember, 'name' | 'value'>, reflector: ReflectionHost, importTracker: ImportedSymbolsTracker): InputMapping | null;
+export declare function tryParseSignalInputMapping(member: Pick<ClassMember, 'name' | 'value' | 'accessLevel'>, reflector: ReflectionHost, importTracker: ImportedSymbolsTracker): InputMapping | null;

package/src/ngtsc/annotations/directive/src/model_function.d.ts

@@ -8,7 +8,10 @@
 import { ImportedSymbolsTracker } from '../../../imports';
 import { ModelMapping } from '../../../metadata';
 import { ClassMember, ReflectionHost } from '../../../reflection';
+import { InitializerApiFunction } from './initializer_functions';
+/** Represents a function that can declare a model. */
+export declare const MODEL_INITIALIZER_FN: InitializerApiFunction;
 /**
  * Attempts to parse a model class member. Returns the parsed model mapping if possible.
  */
-export declare function tryParseSignalModelMapping(member: Pick<ClassMember, 'name' | 'value'>, reflector: ReflectionHost, importTracker: ImportedSymbolsTracker): ModelMapping | null;
+export declare function tryParseSignalModelMapping(member: Pick<ClassMember, 'name' | 'value' | 'accessLevel'>, reflector: ReflectionHost, importTracker: ImportedSymbolsTracker): ModelMapping | null;

package/src/ngtsc/annotations/directive/src/output_function.d.ts

@@ -9,11 +9,14 @@ import ts from 'typescript';
 import { ImportedSymbolsTracker } from '../../../imports';
 import { InputOrOutput } from '../../../metadata';
 import { ClassMember, ReflectionHost } from '../../../reflection';
+import { InitializerApiFunction } from './initializer_functions';
+/** Possible functions that can declare an output. */
+export declare const OUTPUT_INITIALIZER_FNS: InitializerApiFunction[];
 /**
  * Attempts to parse a signal output class member. Returns the parsed
  * input mapping if possible.
  */
-export declare function tryParseInitializerBasedOutput(member: Pick<ClassMember, 'name' | 'value'>, reflector: ReflectionHost, importTracker: ImportedSymbolsTracker): {
+export declare function tryParseInitializerBasedOutput(member: Pick<ClassMember, 'name' | 'value' | 'accessLevel'>, reflector: ReflectionHost, importTracker: ImportedSymbolsTracker): {
     call: ts.CallExpression;
     metadata: InputOrOutput;
 } | null;

package/src/ngtsc/annotations/directive/src/query_functions.d.ts

@@ -8,9 +8,15 @@
 import { R3QueryMetadata } from '@angular/compiler';
 import ts from 'typescript';
 import { ImportedSymbolsTracker } from '../../../imports';
-import { ClassMember, ReflectionHost } from '../../../reflection';
+import { ClassMember, ClassMemberAccessLevel, ReflectionHost } from '../../../reflection';
 /** Possible query initializer API functions. */
 export type QueryFunctionName = 'viewChild' | 'contentChild' | 'viewChildren' | 'contentChildren';
+/** Possible query initializer API functions. */
+export declare const QUERY_INITIALIZER_FNS: {
+    functionName: QueryFunctionName;
+    owningModule: "@angular/core";
+    allowedAccessLevels: ClassMemberAccessLevel[];
+}[];
 /**
  * Attempts to detect a possible query definition for the given class member.
  *
@@ -19,7 +25,7 @@ export type QueryFunctionName = 'viewChild' | 'contentChild' | 'viewChildren' |
  *
  * @returns Resolved query metadata, or null if no query is declared.
  */
-export declare function tryParseSignalQueryFromInitializer(member: Pick<ClassMember, 'name' | 'value'>, reflector: ReflectionHost, importTracker: ImportedSymbolsTracker): {
+export declare function tryParseSignalQueryFromInitializer(member: Pick<ClassMember, 'name' | 'value' | 'accessLevel'>, reflector: ReflectionHost, importTracker: ImportedSymbolsTracker): {
     name: QueryFunctionName;
     metadata: R3QueryMetadata;
     call: ts.CallExpression;

package/src/ngtsc/annotations/index.d.ts

@@ -7,7 +7,7 @@
  */
 export { forwardRefResolver, getAngularDecorators, isAngularDecorator, NoopReferencesRegistry, ReferencesRegistry, ResourceLoader, ResourceLoaderContext } from './common';
 export { ComponentDecoratorHandler } from './component';
-export { DirectiveDecoratorHandler, queryDecoratorNames, QueryFunctionName, tryParseInitializerBasedOutput, tryParseSignalInputMapping, tryParseSignalModelMapping, tryParseSignalQueryFromInitializer } from './directive';
+export { DirectiveDecoratorHandler, InitializerApiFunction, INPUT_INITIALIZER_FN, MODEL_INITIALIZER_FN, OUTPUT_INITIALIZER_FNS, QUERY_INITIALIZER_FNS, queryDecoratorNames, QueryFunctionName, tryParseInitializerApi, tryParseInitializerBasedOutput, tryParseSignalInputMapping, tryParseSignalModelMapping, tryParseSignalQueryFromInitializer } from './directive';
 export { NgModuleDecoratorHandler } from './ng_module';
 export { InjectableDecoratorHandler } from './src/injectable';
 export { PipeDecoratorHandler } from './src/pipe';

package/src/ngtsc/diagnostics/src/error_code.d.ts

@@ -37,6 +37,11 @@ export declare enum ErrorCode {
      * function, but is still detected unexpectedly.
      */
     INITIALIZER_API_NO_REQUIRED_FUNCTION = 1052,
+    /**
+     * Raised whenever an initializer API is used on a class member
+     * and the given access modifiers (e.g. `private`) are not allowed.
+     */
+    INITIALIZER_API_DISALLOWED_MEMBER_VISIBILITY = 1053,
     /**
      * An Angular feature, like inputs, outputs or queries is incorrectly
      * declared on a static member.
@@ -387,6 +392,20 @@ export declare enum ErrorCode {
      * ```
      */
     INTERPOLATED_SIGNAL_NOT_INVOKED = 8109,
+    /**
+     * Initializer-based APIs can only be invoked from inside of an initializer.
+     *
+     * ```
+     * // Allowed
+     * myInput = input();
+     *
+     * // Not allowed
+     * function myInput() {
+     *   return input();
+     * }
+     * ```
+     */
+    UNSUPPORTED_INITIALIZER_API_USAGE = 8110,
     /**
      * The template type-checking engine would need to generate an inline type check block for a
      * component, but the current type-checking environment doesn't support it.

package/src/ngtsc/docs/src/entities.d.ts

@@ -19,7 +19,8 @@ export declare enum EntryType {
     NgModule = "ng_module",
     Pipe = "pipe",
     TypeAlias = "type_alias",
-    UndecoratedClass = "undecorated_class"
+    UndecoratedClass = "undecorated_class",
+    InitializerApiFunction = "initializer_api_function"
 }
 /** Types of class members */
 export declare enum MemberType {
@@ -133,3 +134,37 @@ export interface ParameterEntry {
     isOptional: boolean;
     isRestParam: boolean;
 }
+/** Interface describing a function with overload signatures. */
+export interface FunctionWithOverloads {
+    name: string;
+    signatures: FunctionEntry[];
+    implementation: FunctionEntry | null;
+}
+/**
+ * Docs entry describing an initializer API function.
+ *
+ * An initializer API function is a function that is invoked as
+ * initializer of class members. The function may hold additional
+ * sub functions, like `.required`.
+ *
+ * Known popular initializer APIs are `input()`, `output()`, `model()`.
+ *
+ * Initializer APIs are often constructed typed in complex ways so this
+ * entry type allows for readable "parsing" and interpretation of such
+ * constructs. Initializer APIs are explicitly denoted via a JSDoc tag.
+ */
+export interface InitializerApiFunctionEntry extends DocEntry {
+    callFunction: FunctionWithOverloads;
+    subFunctions: FunctionWithOverloads[];
+    __docsMetadata__?: {
+        /**
+         * Whether types should be shown in the signature
+         * preview of docs.
+         *
+         * By default, for readability purposes, types are omitted, but
+         * shorter initializer API functions like `output` may decide to
+         * render these types.
+         */
+        showTypesInSignaturePreview?: boolean;
+    };
+}

package/src/ngtsc/docs/src/function_extractor.d.ts

@@ -6,7 +6,7 @@
  * found in the LICENSE file at https://angular.io/license
  */
 import ts from 'typescript';
-import { FunctionEntry } from './entities';
+import { FunctionEntry, ParameterEntry } from './entities';
 export type FunctionLike = ts.FunctionDeclaration | ts.MethodDeclaration | ts.MethodSignature | ts.CallSignatureDeclaration | ts.ConstructSignatureDeclaration;
 export declare class FunctionExtractor {
     private name;
@@ -14,8 +14,9 @@ export declare class FunctionExtractor {
     private typeChecker;
     constructor(name: string, declaration: FunctionLike, typeChecker: ts.TypeChecker);
     extract(): FunctionEntry;
-    private extractAllParams;
     /** Gets all overloads for the function (excluding this extractor's FunctionDeclaration). */
     getOverloads(): ts.FunctionDeclaration[];
     private getSymbol;
 }
+/** Extracts parameters of the given parameter declaration AST nodes. */
+export declare function extractAllParams(params: ts.NodeArray<ts.ParameterDeclaration>, typeChecker: ts.TypeChecker): ParameterEntry[];

package/src/ngtsc/docs/src/initializer_api_function_extractor.d.ts

@@ -0,0 +1,24 @@
+/**
+ * @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.io/license
+ */
+import ts from 'typescript';
+import { InitializerApiFunctionEntry } from './entities';
+/**
+ * Checks whether the given node corresponds to an initializer API function.
+ *
+ * An initializer API function is a function declaration or variable declaration
+ * that is explicitly annotated with `@initializerApiFunction`.
+ *
+ * Note: The node may be a function overload signature that is automatically
+ * resolved to its implementation to detect the JSDoc tag.
+ */
+export declare function isInitializerApiFunction(node: ts.Node, typeChecker: ts.TypeChecker): node is ts.VariableDeclaration | ts.FunctionDeclaration;
+/**
+ * Extracts the given node as initializer API function and returns
+ * a docs entry that can be rendered to represent the API function.
+ */
+export declare function extractInitializerApiFunction(node: ts.VariableDeclaration | ts.FunctionDeclaration, typeChecker: ts.TypeChecker): InitializerApiFunctionEntry;

package/src/ngtsc/docs/src/internal.d.ts

@@ -0,0 +1,8 @@
+/**
+ * @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.io/license
+ */
+export {};

package/src/ngtsc/imports/src/imported_symbols_tracker.d.ts

@@ -32,6 +32,19 @@ export declare class ImportedSymbolsTracker {
      * @param moduleName Module from which the namespace is imported.
      */
     isPotentialReferenceToNamespaceImport(node: ts.Identifier, moduleName: string): boolean;
+    /**
+     * Checks if a file has a named imported of a certain symbol.
+     * @param sourceFile File to be checked.
+     * @param exportedName Name of the exported symbol that is being checked.
+     * @param moduleName Module that exports the symbol.
+     */
+    hasNamedImport(sourceFile: ts.SourceFile, exportedName: string, moduleName: string): boolean;
+    /**
+     * Checks if a file has namespace imports of a certain symbol.
+     * @param sourceFile File to be checked.
+     * @param moduleName Module whose namespace import is being searched for.
+     */
+    hasNamespaceImport(sourceFile: ts.SourceFile, moduleName: string): boolean;
     /** Scans a `SourceFile` for import statements and caches them for later use. */
     private scanImports;
 }

package/src/ngtsc/reflection/src/host.d.ts

@@ -77,6 +77,14 @@ export declare enum ClassMemberKind {
     Property = 3,
     Method = 4
 }
+/** Possible access levels of a class member. */
+export declare enum ClassMemberAccessLevel {
+    PublicWritable = 0,
+    PublicReadonly = 1,
+    Protected = 2,
+    Private = 3,
+    EcmaScriptPrivate = 4
+}
 /**
  * A member of a class, such as a property, method, or constructor.
  */
@@ -89,6 +97,8 @@ export interface ClassMember {
      * Indication of which type of member this is (property, method, etc).
      */
     kind: ClassMemberKind;
+    /** Access level describing the class member modifiers. */
+    accessLevel: ClassMemberAccessLevel;
     /**
      * TypeScript `ts.TypeNode` representing the type of the member, or `null` if not present or
      * applicable.
@@ -99,13 +109,13 @@ export interface ClassMember {
      */
     name: string;
     /**
-     * TypeScript `ts.Identifier` or `ts.StringLiteral` representing the name of the member, or `null`
-     * if no such node is present.
+     * TypeScript `ts.Identifier`, `ts.PrivateIdentifier`, or `ts.StringLiteral` representing the
+     * name of the member, or `null` if no such node is present.
      *
      * The `nameNode` is useful in writing references to this member that will be correctly source-
      * mapped back to the original file.
      */
-    nameNode: ts.Identifier | ts.StringLiteral | null;
+    nameNode: ts.Identifier | ts.PrivateIdentifier | ts.StringLiteral | null;
     /**
      * TypeScript `ts.Expression` which represents the value of the member.
      *

package/src/ngtsc/reflection/src/typescript.d.ts

@@ -52,7 +52,6 @@ export declare class TypeScriptReflectionHost implements ReflectionHost {
      */
     protected getDeclarationOfSymbol(symbol: ts.Symbol, originalId: ts.Identifier | null): Declaration | null;
     private _reflectDecorator;
-    private _reflectMember;
     /**
      * Get the set of declarations declared in `file` which are exported.
      */
@@ -69,6 +68,14 @@ export declare function filterToMembersWithDecorator(members: ClassMember[], nam
     member: ClassMember;
     decorators: Decorator[];
 }[];
+/**
+ * Reflects a class element and returns static information about the
+ * class member.
+ *
+ * Note: Decorator information is not included in this helper as it relies
+ * on type checking to resolve originating import.
+ */
+export declare function reflectClassMember(node: ts.ClassElement): Omit<ClassMember, 'decorators'> | null;
 export declare function findMember(members: ClassMember[], name: string, isStatic?: boolean): ClassMember | null;
 export declare function reflectObjectLiteral(node: ts.ObjectLiteralExpression): Map<string, ts.Expression>;
 /**

package/src/ngtsc/reflection/src/util.d.ts

@@ -6,7 +6,12 @@
  * found in the LICENSE file at https://angular.io/license
  */
 import ts from 'typescript';
-import { ClassDeclaration } from './host';
+import { ClassDeclaration, ClassMemberAccessLevel } from './host';
 export declare function isNamedClassDeclaration(node: ts.Node): node is ClassDeclaration<ts.ClassDeclaration>;
 export declare function isNamedFunctionDeclaration(node: ts.Node): node is ClassDeclaration<ts.FunctionDeclaration>;
 export declare function isNamedVariableDeclaration(node: ts.Node): node is ClassDeclaration<ts.VariableDeclaration>;
+/**
+ * Converts the given class member access level to a string.
+ * Useful fo error messages.
+ */
+export declare function classMemberAccessLevelToString(level: ClassMemberAccessLevel): string;

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

@@ -5,7 +5,7 @@
  * Use of this source code is governed by an MIT-style license that can be
  * found in the LICENSE file at https://angular.io/license
  */
-import { BindingPipe, PropertyRead, TmplAstBoundAttribute, TmplAstBoundEvent, TmplAstElement, TmplAstForLoopBlock, TmplAstForLoopBlockEmpty, TmplAstHoverDeferredTrigger, TmplAstIfBlockBranch, TmplAstInteractionDeferredTrigger, TmplAstReference, TmplAstTemplate, TmplAstVariable, TmplAstViewportDeferredTrigger } from '@angular/compiler';
+import { BindingPipe, PropertyRead, TmplAstBoundAttribute, TmplAstBoundEvent, TmplAstElement, TmplAstForLoopBlock, TmplAstForLoopBlockEmpty, TmplAstHoverDeferredTrigger, TmplAstIfBlockBranch, TmplAstInteractionDeferredTrigger, TmplAstReference, TmplAstSwitchBlockCase, TmplAstTemplate, TmplAstVariable, TmplAstViewportDeferredTrigger } from '@angular/compiler';
 import ts from 'typescript';
 import { ClassDeclaration } from '../../reflection';
 import { TemplateDiagnostic, TemplateId } from '../api';
@@ -90,7 +90,7 @@ export interface OutOfBandDiagnosticRecorder {
     /**
      * Reports cases where control flow nodes prevent content projection.
      */
-    controlFlowPreventingContentProjection(templateId: TemplateId, category: ts.DiagnosticCategory, projectionNode: TmplAstElement | TmplAstTemplate, componentName: string, slotSelector: string, controlFlowNode: TmplAstIfBlockBranch | TmplAstForLoopBlock | TmplAstForLoopBlockEmpty, preservesWhitespaces: boolean): void;
+    controlFlowPreventingContentProjection(templateId: TemplateId, category: ts.DiagnosticCategory, projectionNode: TmplAstElement | TmplAstTemplate, componentName: string, slotSelector: string, controlFlowNode: TmplAstIfBlockBranch | TmplAstSwitchBlockCase | TmplAstForLoopBlock | TmplAstForLoopBlockEmpty, preservesWhitespaces: boolean): void;
 }
 export declare class OutOfBandDiagnosticRecorderImpl implements OutOfBandDiagnosticRecorder {
     private resolver;
@@ -114,5 +114,5 @@ export declare class OutOfBandDiagnosticRecorderImpl implements OutOfBandDiagnos
     missingRequiredInputs(templateId: TemplateId, element: TmplAstElement | TmplAstTemplate, directiveName: string, isComponent: boolean, inputAliases: string[]): void;
     illegalForLoopTrackAccess(templateId: TemplateId, block: TmplAstForLoopBlock, access: PropertyRead): void;
     inaccessibleDeferredTriggerElement(templateId: TemplateId, trigger: TmplAstHoverDeferredTrigger | TmplAstInteractionDeferredTrigger | TmplAstViewportDeferredTrigger): void;
-    controlFlowPreventingContentProjection(templateId: TemplateId, category: ts.DiagnosticCategory, projectionNode: TmplAstElement | TmplAstTemplate, componentName: string, slotSelector: string, controlFlowNode: TmplAstIfBlockBranch | TmplAstForLoopBlock | TmplAstForLoopBlockEmpty, preservesWhitespaces: boolean): void;
+    controlFlowPreventingContentProjection(templateId: TemplateId, category: ts.DiagnosticCategory, projectionNode: TmplAstElement | TmplAstTemplate, componentName: string, slotSelector: string, controlFlowNode: TmplAstIfBlockBranch | TmplAstSwitchBlockCase | TmplAstForLoopBlock | TmplAstForLoopBlockEmpty, preservesWhitespaces: boolean): void;
 }

package/src/ngtsc/validation/index.d.ts

@@ -0,0 +1,8 @@
+/**
+ * @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.io/license
+ */
+export { SourceFileValidator } from './src/source_file_validator';

package/src/ngtsc/validation/src/rules/api.d.ts

@@ -0,0 +1,24 @@
+/*!
+ * @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.io/license
+ */
+import ts from 'typescript';
+/**
+ * Rule that checks a source file a specific issue.
+ */
+export interface SourceFileValidatorRule {
+    /**
+     * Whether the file should be checked. Used to stop the traversal of the file early.
+     * @param sourceFile File to be checked.
+     */
+    shouldCheck(sourceFile: ts.SourceFile): boolean;
+    /**
+     * Produces diagnostics for a specific node that may
+     * contain the issue that the rule is enforcing.
+     * @param node Node to be checked.
+     */
+    checkNode(node: ts.Node): ts.Diagnostic | ts.Diagnostic[] | null;
+}

package/src/ngtsc/validation/src/rules/initializer_api_usage_rule.d.ts

@@ -0,0 +1,21 @@
+/*!
+ * @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.io/license
+ */
+import ts from 'typescript';
+import { ImportedSymbolsTracker } from '../../../imports';
+import { ReflectionHost } from '../../../reflection';
+import { SourceFileValidatorRule } from './api';
+/**
+ * Rule that flags any initializer APIs that are used outside of an initializer.
+ */
+export declare class InitializerApiUsageRule implements SourceFileValidatorRule {
+    private reflector;
+    private importedSymbolsTracker;
+    constructor(reflector: ReflectionHost, importedSymbolsTracker: ImportedSymbolsTracker);
+    shouldCheck(sourceFile: ts.SourceFile): boolean;
+    checkNode(node: ts.Node): ts.Diagnostic | null;
+}

package/src/ngtsc/validation/src/source_file_validator.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.io/license
+ */
+import ts from 'typescript';
+import { ImportedSymbolsTracker } from '../../imports';
+import { ReflectionHost } from '../../reflection';
+/**
+ * Validates that TypeScript files match a specific set of rules set by the Angular compiler.
+ */
+export declare class SourceFileValidator {
+    private rules;
+    constructor(reflector: ReflectionHost, importedSymbolsTracker: ImportedSymbolsTracker);
+    /**
+     * Gets the diagnostics for a specific file, or null if the file is valid.
+     * @param sourceFile File to be checked.
+     */
+    getDiagnosticsForFile(sourceFile: ts.SourceFile): ts.Diagnostic[] | null;
+}