@angular/core 18.0.0-next.1 → 18.0.0-next.3

package/index.d.ts

@@ -1,5 +1,5 @@
 /**
- * @license Angular v18.0.0-next.1
+ * @license Angular v18.0.0-next.3
  * (c) 2010-2022 Google LLC. https://angular.io/
  * License: MIT
  */
@@ -339,7 +339,7 @@ export declare interface AfterViewInit {
 export declare const ANIMATION_MODULE_TYPE: InjectionToken<"NoopAnimations" | "BrowserAnimations">;
 
 /**
- * A [DI token](guide/glossary#di-token "DI token definition") that provides a set of callbacks to
+ * A DI token that provides a set of callbacks to
  * be called for every component that is bootstrapped.
  *
  * Each callback must take a `ComponentRef` instance and return nothing.
@@ -351,7 +351,7 @@ export declare const ANIMATION_MODULE_TYPE: InjectionToken<"NoopAnimations" | "B
 export declare const APP_BOOTSTRAP_LISTENER: InjectionToken<readonly ((compRef: ComponentRef<any>) => void)[]>;
 
 /**
- * A [DI token](guide/glossary#di-token "DI token definition") representing a string ID, used
+ * A DI token representing a string ID, used
  * primarily for prefixing application attributes and CSS styles when
  * {@link ViewEncapsulation#Emulated} is being used.
  *
@@ -383,7 +383,7 @@ export declare const APP_BOOTSTRAP_LISTENER: InjectionToken<readonly ((compRef:
 export declare const APP_ID: InjectionToken<string>;
 
 /**
- * A [DI token](guide/glossary#di-token "DI token definition") that you can use to provide
+ * A DI token that you can use to provide
  * one or more initialization functions.
  *
  * The provided functions are injected at application startup and executed during
@@ -644,6 +644,7 @@ export declare class ApplicationRef {
     private _destroyListeners;
     private readonly internalErrorHandler;
     private readonly afterRenderEffectManager;
+    private readonly zonelessEnabled;
     private externalTestViews;
     private beforeRender;
     private afterTick;
@@ -1767,11 +1768,11 @@ export declare abstract class ComponentRef<C> {
      */
     abstract setInput(name: string, value: unknown): void;
     /**
-     * The host or anchor [element](guide/glossary#element) for this component instance.
+     * The host or anchor element for this component instance.
      */
     abstract get location(): ElementRef;
     /**
-     * The [dependency injector](guide/glossary#injector) for this component instance.
+     * The dependency injector for this component instance.
      */
     abstract get injector(): Injector;
     /**
@@ -1779,7 +1780,7 @@ export declare abstract class ComponentRef<C> {
      */
     abstract get instance(): C;
     /**
-     * The [host view](guide/glossary#view-hierarchy) defined by the template
+     * The host view defined by the template
      * for this component instance.
      */
     abstract get hostView(): ViewRef;
@@ -1900,6 +1901,9 @@ export declare const ContentChild: ContentChildDecorator;
  *   headerRequired = contentChild.required(MyHeader);            // Signal<MyHeader>
  * }
  * ```
+ *
+ * @initializerApiFunction
+ * @developerPreview
  */
 export declare const contentChild: ContentChildFunction;
 
@@ -1987,6 +1991,7 @@ export declare interface ContentChildDecorator {
  * provides access to required query results via the `.required` property.
  *
  * @developerPreview
+ * @docsPrivate Ignored because `contentChild` is the canonical API entry.
  */
 export declare interface ContentChildFunction {
     /**
@@ -2005,8 +2010,6 @@ export declare interface ContentChildFunction {
     }): Signal<ReadT | undefined>;
     /**
      * Initializes a content child query that is always expected to match.
-     *
-     * @developerPreview
      */
     required: {
         <LocatorT>(locator: ProviderToken<LocatorT> | string, opts?: {
@@ -2668,6 +2671,23 @@ declare interface DehydratedContainerView extends DehydratedView {
     data: Readonly<SerializedContainerView>;
 }
 
+/**
+ * An object that contains information about a dehydrated ICU case,
+ * to facilitate cleaning up ICU cases that were active during
+ * server-side rendering, but not during hydration.
+ */
+declare interface DehydratedIcuData {
+    /**
+     * The case index that this data represents.
+     */
+    case: number;
+    /**
+     * A reference back to the AST for the ICU node. This allows the
+     * AST to be used to clean up dehydrated nodes.
+     */
+    node: I18nICUNode;
+}
+
 /**
  * An object that contains hydration-related information serialized
  * on the server, as well as the necessary references to segments of
@@ -2712,11 +2732,19 @@ declare interface DehydratedView {
      * A mapping from a view to the first child to begin claiming nodes.
      *
      * This mapping is generated by an i18n block, and is the source of
-     * truth for the nodes inside of it. Once a view has been hydrated,
-     * the node is removed from the map. The remaining entries indicate
-     * dehydrated nodes that need to be cleaned up.
+     * truth for the nodes inside of it.
+     */
+    i18nNodes?: Map<number, RNode | null>;
+    /**
+     * A mapping from the index of an ICU node to dehydrated data for it.
+     *
+     * This information is used during the hydration process on the client.
+     * ICU cases that were active during server-side rendering will be added
+     * to the map. The hydration logic will "claim" matching cases, removing
+     * them from the map. The remaining entries are "unclaimed", and will be
+     * removed from the DOM during hydration cleanup.
      */
-    i18nNodes?: Map<number, RNode>;
+    dehydratedIcuData?: Map<number, DehydratedIcuData>;
 }
 
 /**
@@ -3002,9 +3030,9 @@ export declare interface Directive {
      */
     outputs?: string[];
     /**
-     * Configures the [injector](guide/glossary#injector) of this
-     * directive or component with a [token](guide/glossary#di-token)
-     * that maps to a [provider](guide/glossary#provider) of a dependency.
+     * Configures the injector of this
+     * directive or component with a token
+     * that maps to a provider of a dependency.
      */
     providers?: Provider[];
     /**
@@ -3572,8 +3600,8 @@ export declare class ElementRef<T = any> {
 declare const EMBEDDED_VIEW_INJECTOR = 20;
 
 /**
- * Represents an Angular [view](guide/glossary#view) in a view container.
- * An [embedded view](guide/glossary#view-hierarchy) can be referenced from a component
+ * Represents an Angular view in a view container.
+ * An embedded view can be referenced from a component
  * other than the hosting component whose template defines it, or it can be defined
  * independently by a `TemplateRef`.
  *
@@ -4684,6 +4712,8 @@ declare namespace i0 {
     }
 }
 
+declare const I18N_DATA = "l";
+
 /**
  * Array storing OpCode for dynamically creating `i18n` translation DOM elements.
  *
@@ -5060,7 +5090,7 @@ declare type InitialInputs = (string | ɵɵInputFlags)[];
  */
 export declare interface Inject {
     /**
-     * A [DI token](guide/glossary#di-token) that maps to the dependency to be injected.
+     * A DI token that maps to the dependency to be injected.
      */
     token: any;
 }
@@ -5575,29 +5605,52 @@ export declare interface Input {
 export declare const Input: InputDecorator;
 
 /**
- * The `input` function allows declaration of inputs in directives and
- * components.
+ * The `input` function allows declaration of Angular inputs in directives
+ * and components.
+ *
+ * There are two variants of inputs that can be declared:
  *
- * Initializes an input with an initial value. If no explicit value
- * is specified, Angular will use `undefined`.
+ *   1. **Optional inputs** with an initial value.
+ *   2. **Required inputs** that consumers need to set.
  *
- * Consider using `input.required` for inputs that don't need an
- * initial value.
+ * By default, the `input` function will declare optional inputs that
+ * always have an initial value. Required inputs can be declared
+ * using the `input.required()` function.
+ *
+ * Inputs are signals. The values of an input are exposed as a `Signal`.
+ * The signal always holds the latest value of the input that is bound
+ * from the parent.
  *
  * @usageNotes
- * Initialize an input in your directive or component by declaring a
- * class field and initializing it with the `input()` function.
+ * To use signal-based inputs, import `input` from `@angular/core`.
+ *
+ * ```
+ * import {input} from '@angular/core`;
+ * ```
+ *
+ * Inside your component, introduce a new class member and initialize
+ * it with a call to `input` or `input.required`.
  *
  * ```ts
- * @Directive({..})
- * export class MyDir {
- *   firstName = input<string>();            // string|undefined
- *   lastName = input.required<string>();    // string
- *   age = input(0);                         // number
+ * @Component({
+ *   ...
+ * })
+ * export class UserProfileComponent {
+ *   firstName = input<string>();             // Signal<string|undefined>
+ *   lastName  = input.required<string>();    // Signal<string>
+ *   age       = input(0)                     // Signal<number>
  * }
  * ```
  *
+ * Inside your component template, you can display values of the inputs
+ * by calling the signal.
+ *
+ * ```html
+ * <span>{{firstName()}}</span>
+ * ```
+ *
  * @developerPreview
+ * @initializerApiFunction
  */
 export declare const input: InputFunction;
 
@@ -5667,46 +5720,43 @@ export declare interface InputDecorator {
  * The function exposes an API for also declaring required inputs via the
  * `input.required` function.
  *
- * @usageNotes
- * Initialize an input in your directive or component by declaring a
- * class field and initializing it with the `input()` or `input.required()`
- * function.
- *
- * ```ts
- * @Directive({..})
- * export class MyDir {
- *   firstName = input<string>();            // string|undefined
- *   lastName = input.required<string>();    // string
- *   age = input(0);                         // number
- * }
- * ```
- *
  * @developerPreview
+ * @docsPrivate Ignored because `input` is the canonical API entry.
  */
 export declare interface InputFunction {
     /**
-     * Initializes an input with an initial value. If no explicit value
-     * is specified, Angular will use `undefined`.
-     *
-     * Consider using `input.required` for inputs that don't need an
-     * initial value.
+     * Initializes an input of type `T` with an initial value of `undefined`.
+     * Angular will implicitly use `undefined` as initial value.
+     */
+    <T>(): InputSignal<T | undefined>;
+    /** Declares an input of type `T` with an explicit initial value. */
+    <T>(initialValue: T, opts?: InputOptionsWithoutTransform<T>): InputSignal<T>;
+    /**
+     * Declares an input of type `T` with an initial value and a transform
+     * function.
      *
-     * @developerPreview
+     * The input accepts values of type `TransformT` and the given
+     * transform function will transform the value to type `T`.
      */
-    <ReadT>(): InputSignal<ReadT | undefined>;
-    <ReadT>(initialValue: ReadT, opts?: InputOptionsWithoutTransform<ReadT>): InputSignal<ReadT>;
-    <ReadT, WriteT>(initialValue: ReadT, opts: InputOptionsWithTransform<ReadT, WriteT>): InputSignalWithTransform<ReadT, WriteT>;
+    <T, TransformT>(initialValue: T, opts: InputOptionsWithTransform<T, TransformT>): InputSignalWithTransform<T, TransformT>;
     /**
      * Initializes a required input.
      *
-     * Users of your directive/component need to bind to this
+     * Consumers of your directive/component need to bind to this
      * input. If unset, a compile time error will be reported.
      *
      * @developerPreview
      */
     required: {
-        <ReadT>(opts?: InputOptionsWithoutTransform<ReadT>): InputSignal<ReadT>;
-        <ReadT, WriteT>(opts: InputOptionsWithTransform<ReadT, WriteT>): InputSignalWithTransform<ReadT, WriteT>;
+        /** Declares a required input of type `T`. */
+        <T>(opts?: InputOptionsWithoutTransform<T>): InputSignal<T>;
+        /**
+         * Declares a required input of type `T` with a transform function.
+         *
+         * The input accepts values of type `TransformT` and the given
+         * transform function will transform the value to type `T`.
+         */
+        <T, TransformT>(opts: InputOptionsWithTransform<T, TransformT>): InputSignalWithTransform<T, TransformT>;
     };
 }
 
@@ -5715,7 +5765,7 @@ export declare interface InputFunction {
  *
  * Options for signal inputs.
  */
-export declare interface InputOptions<ReadT, WriteT> {
+export declare interface InputOptions<T, TransformT> {
     /** Optional public name for the input. By default, the class field name is used. */
     alias?: string;
     /**
@@ -5728,7 +5778,7 @@ export declare interface InputOptions<ReadT, WriteT> {
      * attribute form to bind to the input via `<my-dir input>`. A transform can then
      * handle such string values and convert them to `boolean`. See: {@link booleanAttribute}.
      */
-    transform?: (v: WriteT) => ReadT;
+    transform?: (v: TransformT) => T;
 }
 
 /**
@@ -5736,7 +5786,7 @@ export declare interface InputOptions<ReadT, WriteT> {
  *
  * @developerPreview
  */
-export declare type InputOptionsWithoutTransform<ReadT> = Omit<InputOptions<ReadT, ReadT>, 'transform'> & {
+export declare type InputOptionsWithoutTransform<T> = Omit<InputOptions<T, T>, 'transform'> & {
     transform?: undefined;
 };
 
@@ -5745,7 +5795,7 @@ export declare type InputOptionsWithoutTransform<ReadT> = Omit<InputOptions<Read
  *
  * @developerPreview
  */
-export declare type InputOptionsWithTransform<ReadT, WriteT> = Required<Pick<InputOptions<ReadT, WriteT>, 'transform'>> & InputOptions<ReadT, WriteT>;
+export declare type InputOptionsWithTransform<T, TransformT> = Required<Pick<InputOptions<T, TransformT>, 'transform'>> & InputOptions<T, TransformT>;
 
 /**
  * `InputSignal` represents a special `Signal` for a directive/component input.
@@ -5758,28 +5808,28 @@ export declare type InputOptionsWithTransform<ReadT, WriteT> = Required<Pick<Inp
  *
  * @developerPreview
  */
-export declare interface InputSignal<ReadT> extends InputSignalWithTransform<ReadT, ReadT> {
+export declare interface InputSignal<T> extends InputSignalWithTransform<T, T> {
 }
 
 /**
  * Reactive node type for an input signal. An input signal extends a signal.
  * There are special properties to enable transforms and required inputs.
  */
-declare interface InputSignalNode<ReadT, WriteT> extends SignalNode<ReadT> {
+declare interface InputSignalNode<T, TransformT> extends SignalNode<T> {
     /**
      * User-configured transform that will run whenever a new value is applied
      * to the input signal node.
      */
-    transformFn: ((value: WriteT) => ReadT) | undefined;
+    transformFn: ((value: TransformT) => T) | undefined;
     /**
      * Applies a new value to the input signal. Expects transforms to be run
      * manually before.
      *
      * This function is called by the framework runtime code whenever a binding
      * changes. The value can in practice be anything at runtime, but for typing
-     * purposes we assume it's a valid `ReadT` value. Type-checking will enforce that.
+     * purposes we assume it's a valid `T` value. Type-checking will enforce that.
      */
-    applyValueToInputSignal<ReadT, WriteT>(node: InputSignalNode<ReadT, WriteT>, value: ReadT): void;
+    applyValueToInputSignal<T, TransformT>(node: InputSignalNode<T, TransformT>, value: T): void;
 }
 
 /**
@@ -5806,10 +5856,10 @@ declare interface InputSignalNode<ReadT, WriteT> extends SignalNode<ReadT> {
  *
  * @developerPreview
  */
-export declare interface InputSignalWithTransform<ReadT, WriteT> extends Signal<ReadT> {
-    [SIGNAL]: InputSignalNode<ReadT, WriteT>;
-    [ɵINPUT_SIGNAL_BRAND_READ_TYPE]: ReadT;
-    [ɵINPUT_SIGNAL_BRAND_WRITE_TYPE]: WriteT;
+export declare interface InputSignalWithTransform<T, TransformT> extends Signal<T> {
+    [SIGNAL]: InputSignalNode<T, TransformT>;
+    [ɵINPUT_SIGNAL_BRAND_READ_TYPE]: T;
+    [ɵINPUT_SIGNAL_BRAND_WRITE_TYPE]: TransformT;
 }
 
 /** Function that can be used to transform incoming input values. */
@@ -6776,31 +6826,51 @@ export declare enum MissingTranslationStrategy {
 }
 
 /**
- * `model` declares a writeable signal that is exposed as an input/output pair on the containing
- * directive. The input name is taken either from the class member or from the `alias` option.
+ * `model` declares a writeable signal that is exposed as an input/output
+ * pair on the containing directive.
+ *
+ * The input name is taken either from the class member or from the `alias` option.
  * The output name is generated by taking the input name and appending `Change`.
  *
- * Initializes a model with an initial value. If no explicit value
- * is specified, Angular will use `undefined`.
+ * @usageNotes
  *
- * Consider using `model.required` for models that don't need an
- * initial value.
+ * To use `model()`, import the function from `@angular/core`.
  *
- * @usageNotes
- * Initialize a model in your directive or component by declaring a
- * class field and initializing it with the `model()` or `model.required()`
- * function.
+ * ```
+ * import {model} from '@angular/core`;
+ * ```
+ *
+ * Inside your component, introduce a new class member and initialize
+ * it with a call to `model` or `model.required`.
  *
  * ```ts
- * @Directive({..})
+ * @Directive({
+ *   ...
+ * })
  * export class MyDir {
- *   firstName = model<string>();            // string|undefined
- *   lastName = model.required<string>();    // string
- *   age = model(0);                         // number
+ *   firstName = model<string>();            // ModelSignal<string|undefined>
+ *   lastName  = model.required<string>();   // ModelSignal<string>
+ *   age       = model(0);                   // ModelSignal<number>
+ * }
+ * ```
+ *
+ * Inside your component template, you can display the value of a `model`
+ * by calling the signal.
+ *
+ * ```html
+ * <span>{{firstName()}}</span>
+ * ```
+ *
+ * Updating the `model` is equivalent to updating a writable signal.
+ *
+ * ```ts
+ * updateName(newFirstName: string): void {
+ *   this.firstName.set(newFirstName);
  * }
  * ```
  *
  * @developerPreview
+ * @initializerApiFunction
  */
 export declare const model: ModelFunction;
 
@@ -6812,43 +6882,26 @@ export declare const model: ModelFunction;
  * The function exposes an API for also declaring required models via the
  * `model.required` function.
  *
- * @usageNotes
- * Initialize a model in your directive or component by declaring a
- * class field and initializing it with the `model()` or `model.required()`
- * function.
- *
- * ```ts
- * @Directive({..})
- * export class MyDir {
- *   firstName = model<string>();            // string|undefined
- *   lastName = model.required<string>();    // string
- *   age = model(0);                         // number
- * }
- * ```
- *
  * @developerPreview
+ * @docsPrivate Ignored because `model` is the canonical API entry.
  */
 export declare interface ModelFunction {
     /**
-     * Initializes a model with an initial value. If no explicit value
-     * is specified, Angular will use `undefined`.
-     *
-     * Consider using `model.required` for models that don't need an
-     * initial value.
-     *
-     * @developerPreview
+     * Initializes a model of type `T` with an initial value of `undefined`.
+     * Angular will implicitly use `undefined` as initial value.
      */
     <T>(): ModelSignal<T | undefined>;
+    /** Initializes a model of type `T` with the given initial value. */
     <T>(initialValue: T, opts?: ModelOptions): ModelSignal<T>;
-    /**
-     * Initializes a required model.
-     *
-     * Users of your directive/component need to bind to the input side of the model.
-     * If unset, a compile time error will be reported.
-     *
-     * @developerPreview
-     */
-    required<T>(opts?: ModelOptions): ModelSignal<T>;
+    required: {
+        /**
+         * Initializes a required model.
+         *
+         * Users of your directive/component need to bind to the input side of the model.
+         * If unset, a compile time error will be reported.
+         */
+        <T>(opts?: ModelOptions): ModelSignal<T>;
+    };
 }
 
 /**
@@ -6895,8 +6948,8 @@ export declare class ModuleWithComponentFactories<T> {
 }
 
 /**
- * A wrapper around an NgModule that associates it with [providers](guide/glossary#provider
- * "Definition"). Usage without a generic type is deprecated.
+ * A wrapper around an NgModule that associates it with providers
+ * Usage without a generic type is deprecated.
  *
  * @see [Deprecations](guide/deprecations#modulewithproviders-type-without-a-generic)
  *
@@ -6983,7 +7036,7 @@ export declare interface NgModule {
      */
     providers?: Array<Provider | EnvironmentProviders>;
     /**
-     * The set of components, directives, and pipes ([declarables](guide/glossary#declarable))
+     * The set of components, directives, and pipes (declarables
      * that belong to this module.
      *
      * @usageNotes
@@ -7010,7 +7063,7 @@ export declare interface NgModule {
      */
     declarations?: Array<Type<any> | any[]>;
     /**
-     * The set of NgModules whose exported [declarables](guide/glossary#declarable)
+     * The set of NgModules whose exported declarables
      * are available to templates in this module.
      *
      * @usageNotes
@@ -7476,7 +7529,6 @@ declare type NodeOutputBindings = Record<string, (number | string)[]>;
 
 declare const NODES = "n";
 
-
 declare const enum NotificationType {
     RefreshViews = 0,
     AfterRenderHooks = 1
@@ -7647,25 +7699,47 @@ export declare interface Output {
 export declare const Output: OutputDecorator;
 
 /**
- * The `output` function allows declaration of outputs in directives and
- * components.
+ * The `output` function allows declaration of Angular outputs in
+ * directives and components.
  *
- * Initializes an output that can emit values to consumers of your
- * directive/component.
+ * You can use outputs to emit values to parent directives and component.
+ * Parents can subscribe to changes via:
+ *
+ * - template event bindings. For example, `(myOutput)="doSomething($event)"`
+ * - programmatic subscription by using `OutputRef#subscribe`.
  *
  * @usageNotes
- * Initialize an output in your directive by declaring a
- * class field and initializing it with the `output()` function.
+ *
+ * To use `output()`, import the function from `@angular/core`.
+ *
+ * ```
+ * import {output} from '@angular/core`;
+ * ```
+ *
+ * Inside your component, introduce a new class member and initialize
+ * it with a call to `output`.
  *
  * ```ts
- * @Directive({..})
+ * @Directive({
+ *   ...
+ * })
  * export class MyDir {
- *   nameChange = output<string>();     // OutputEmitterRef<string>
- *   onClick = output();                // OutputEmitterRef<void>
+ *   nameChange = output<string>();    // OutputEmitterRef<string>
+ *   onClick    = output();            // OutputEmitterRef<void>
+ * }
+ * ```
+ *
+ * You can emit values to consumers of your directive, by using
+ * the `emit` method from `OutputEmitterRef`.
+ *
+ * ```ts
+ * updateName(newName: string): void {
+ *   this.nameChange.emit(newName);
  * }
  * ```
  *
  * @developerPreview
+ * @initializerApiFunction {"showTypesInSignaturePreview": true}
  */
 export declare function output<T = void>(opts?: OutputOptions): OutputEmitterRef<T>;
 
@@ -7758,7 +7832,7 @@ export declare interface OutputRefSubscription {
 }
 
 /**
- * A [DI token](guide/glossary#di-token "DI token definition") that indicates the root directory of
+ * A DI token that indicates the root directory of
  * the application
  * @publicApi
  * @deprecated
@@ -7775,7 +7849,7 @@ declare const PARENT = 3;
 export declare interface Pipe {
     /**
      * The pipe name to use in template bindings.
-     * Typically uses [lowerCamelCase](guide/glossary#case-types)
+     * Typically uses lowerCamelCase
      * because the name cannot contain hyphens.
      */
     name: string;
@@ -8258,6 +8332,7 @@ declare interface R3DeclareComponentFacade extends R3DeclareDirectiveFacade {
     pipes?: {
         [pipeName: string]: OpaqueValue | (() => OpaqueValue);
     };
+    deferBlockDependencies?: (() => Promise<Type_2> | null)[];
     viewProviders?: OpaqueValue;
     animations?: OpaqueValue;
     changeDetection?: ChangeDetectionStrategy_2;
@@ -9108,6 +9183,13 @@ declare interface SerializedView {
      * logic for such nodes and instead use a regular "creation mode".
      */
     [DISCONNECTED_NODES]?: number[];
+    /**
+     * Serialized information about i18n blocks in a template.
+     * Key-value pairs where a key is an index of the corresponding
+     * i18n entry within an LView, and the value is a list of
+     * active ICU cases.
+     */
+    [I18N_DATA]?: Record<number, number[]>;
 }
 
 /**
@@ -11103,6 +11185,7 @@ export declare const ViewChild: ViewChildDecorator;
  * ```
  *
  * @developerPreview
+ * @initializerApiFunction
  */
 export declare const viewChild: ViewChildFunction;
 
@@ -11184,6 +11267,7 @@ export declare interface ViewChildDecorator {
  * property.
  *
  * @developerPreview
+ * @docsPrivate Ignored because `viewChild` is the canonical API entry.
  */
 export declare interface ViewChildFunction {
     /**
@@ -11307,7 +11391,7 @@ export declare interface ViewChildrenDecorator {
  * (created by instantiating a `TemplateRef` with the `createEmbeddedView()` method).
  *
  * A view container instance can contain other view containers,
- * creating a [view hierarchy](guide/glossary#view-hierarchy).
+ * creating a view hierarchy.
  *
  * @usageNotes
  *
@@ -11364,7 +11448,7 @@ export declare abstract class ViewContainerRef {
      */
     abstract get element(): ElementRef;
     /**
-     * The [dependency injector](guide/glossary#injector) for this view container.
+     * The dependency injector for this view container.
      */
     abstract get injector(): Injector;
     /** @deprecated No replacement */
@@ -11546,7 +11630,7 @@ declare enum ViewEncapsulation_2 {
 declare type ViewQueriesFunction<T> = <U extends T>(rf: ɵRenderFlags, ctx: U) => void;
 
 /**
- * Represents an Angular [view](guide/glossary#view "Definition").
+ * Represents an Angular view.
  *
  * @see {@link ChangeDetectorRef#usage-notes Change detection usage}
  *
@@ -11863,6 +11947,7 @@ export declare const enum ɵBypassType {
  */
 export declare abstract class ɵChangeDetectionScheduler {
     abstract notify(source?: NotificationType): void;
+    abstract tick(shouldRefreshViews: boolean): void;
 }
 
 export declare function ɵclearResolutionOfComponentResourcesQueue(): Map<Type<any>, Component>;
@@ -12181,7 +12266,7 @@ export declare enum ɵDeferBlockState {
 /** The deps tracker to be used in the current Angular app in dev mode. */
 export declare const ɵdepsTracker: DepsTracker;
 
-export declare function ɵdetectChangesInViewIfRequired(lView: LView, isFirstPass: boolean, notifyErrorHandler: boolean): void;
+export declare function ɵdetectChangesInViewIfRequired(lView: LView, notifyErrorHandler: boolean, isFirstPass: boolean, zonelessEnabled: boolean): void;
 
 
 export declare function ɵdevModeEqual(a: any, b: any): boolean;
@@ -12440,9 +12525,6 @@ export declare function ɵgetDeferBlocks(lView: LView, deferBlocks: ɵDeferBlock
  */
 export declare function ɵgetDirectives(node: Node): {}[];
 
-
-export declare function ɵgetEnsureDirtyViewsAreAlwaysReachable(): boolean;
-
 /**
  * Retrieves the host element of a component or directive instance.
  * The host element is the DOM element that matched the selector of the directive.
@@ -13410,6 +13492,23 @@ export declare interface ɵSafeUrl extends ɵSafeValue {
 export declare interface ɵSafeValue {
 }
 
+/**
+ * Configures change detection scheduling when using ZoneJS.
+ */
+export declare enum ɵSchedulingMode {
+    /**
+     * Change detection will run when the `NgZone.onMicrotaskEmpty` observable emits.
+     * Change detection will also be scheduled to run whenever Angular is notified
+     * of a change. This includes calling `ChangeDetectorRef.markForCheck`,
+     * setting a `signal` value, and attaching a view.
+     */
+    Hybrid = 0,
+    /**
+     * Change detection will only run when the `NgZone.onMicrotaskEmpty` observable emits.
+     */
+    NgZoneOnly = 1
+}
+
 /**
  * Control whether the NgModule registration system enforces that each NgModule type registered has
  * a unique id.
@@ -13464,8 +13563,6 @@ export declare function ɵsetCurrentInjector(injector: Injector | null | undefin
  */
 export declare function ɵsetDocument(document: Document | undefined): void;
 
-export declare function ɵsetEnsureDirtyViewsAreAlwaysReachable(v: boolean): void;
-
 export declare function ɵsetInjectorProfilerContext(context: ɵInjectorProfilerContext): ɵInjectorProfilerContext;
 
 
@@ -13555,7 +13652,7 @@ export declare type ɵUnwrapDirectiveSignalInputs<Dir, Fields extends keyof Dir>
     [P in Fields]: ɵUnwrapInputSignalWriteType<Dir[P]>;
 };
 
-/** Retrieves the `WriteT` of an `InputSignal` and `InputSignalWithTransform`. */
+/** Retrieves the write type of an `InputSignal` and `InputSignalWithTransform`. */
 declare type ɵUnwrapInputSignalWriteType<Field> = Field extends InputSignalWithTransform<any, infer WriteT> ? WriteT : never;
 
 export declare function ɵunwrapSafeValue(value: ɵSafeValue): string;
@@ -13820,7 +13917,7 @@ export declare function ɵwithDomHydration(): EnvironmentProviders;
  * Returns a set of providers required to setup support for i18n hydration.
  * Requires hydration to be enabled separately.
  */
-export declare function ɵwithI18nHydration(): EnvironmentProviders;
+export declare function ɵwithI18nSupport(): Provider[];
 
 /**
  * Returns a writable type version of type.
@@ -13859,6 +13956,9 @@ declare const ɵWRITABLE_SIGNAL: unique symbol;
  */
 export declare const ɵXSS_SECURITY_URL = "https://g.co/ng/security#xss";
 
+/** Token used to indicate if zoneless was enabled via provideZonelessChangeDetection(). */
+export declare const ɵZONELESS_ENABLED: InjectionToken<boolean>;
+
 /**
  * Advances to an element for later binding instructions.
  *
@@ -14534,8 +14634,6 @@ export declare function ɵɵcomponentInstance(): unknown;
  * built-in "if" and "switch". On the high level this instruction is responsible for adding and
  * removing views selected by a conditional expression.
  *
- * @param containerIndex index of a container in a host view (indexed from HEADER_OFFSET) where
- *     conditional views should be inserted.
  * @param matchingTemplateIndex index of a template TNode representing a conditional view to be
  *     inserted; -1 represents a special case when there is no view to insert.
  * @codeGenApi
@@ -15409,6 +15507,23 @@ export declare function ɵɵngDeclareClassMetadata(decl: {
     };
 }): void;
 
+/**
+ * Evaluates the class metadata of a component that contains deferred blocks.
+ *
+ * @codeGenApi
+ */
+export declare function ɵɵngDeclareClassMetadataAsync(decl: {
+    type: Type<any>;
+    resolveDeferredDeps: () => Promise<Type<unknown>>[];
+    resolveMetadata: (...types: Type<unknown>[]) => {
+        decorators: any[];
+        ctorParameters: (() => any[]) | null;
+        propDecorators: ({
+            [field: string]: any;
+        }) | null;
+    };
+}): void;
+
 /**
  * Compiles a partial component declaration object into a full component definition object.
  *
@@ -15584,14 +15699,19 @@ export declare type ɵɵPipeDeclaration<T, Name extends string, IsStandalone ext
  * Inserts previously re-distributed projected nodes. This instruction must be preceded by a call
  * to the projectionDef instruction.
  *
- * @param nodeIndex
- * @param selectorIndex:
- *        - 0 when the selector is `*` (or unspecified as this is the default value),
- *        - 1 based index of the selector from the {@link projectionDef}
+ * @param nodeIndex Index of the projection node.
+ * @param selectorIndex Index of the slot selector.
+ *  - 0 when the selector is `*` (or unspecified as this is the default value),
+ *  - 1 based index of the selector from the {@link projectionDef}
+ * @param attrs Static attributes set on the `ng-content` node.
+ * @param fallbackTemplateFn Template function with fallback content.
+ *   Will be rendered if the slot is empty at runtime.
+ * @param fallbackDecls Number of declarations in the fallback template.
+ * @param fallbackVars Number of variables in the fallback template.
  *
  * @codeGenApi
  */
-export declare function ɵɵprojection(nodeIndex: number, selectorIndex?: number, attrs?: TAttributes): void;
+export declare function ɵɵprojection(nodeIndex: number, selectorIndex?: number, attrs?: TAttributes, fallbackTemplateFn?: ComponentTemplate<unknown>, fallbackDecls?: number, fallbackVars?: number): void;
 
 /**
  * Instruction to distribute projectable nodes among <ng-content> occurrences in a given template.