@angular/core 19.0.0-next.9 → 19.0.0-rc.0

package/index.d.ts

@@ -1,5 +1,5 @@
 /**
- * @license Angular v19.0.0-next.9
+ * @license Angular v19.0.0-rc.0
  * (c) 2010-2024 Google LLC. https://angular.io/
  * License: MIT
  */
@@ -470,7 +470,6 @@ AfterRenderHook | undefined
 ];
 
 declare class AfterRenderImpl {
-    static readonly PHASES: readonly [AfterRenderPhase.EarlyRead, AfterRenderPhase.Write, AfterRenderPhase.MixedReadWrite, AfterRenderPhase.Read];
     private readonly ngZone;
     private readonly scheduler;
     private readonly errorHandler;
@@ -738,7 +737,12 @@ export declare const APP_ID: InjectionToken<string>;
  * The function is executed during the application bootstrap process,
  * and the needed data is available on startup.
  *
+ * Note that the provided initializer is run in the injection context.
+ *
+ * @deprecated from v19.0.0, use provideAppInitializer instead
+ *
  * @see {@link ApplicationInitStatus}
+ * @see {@link provideAppInitializer}
  *
  * @usageNotes
  *
@@ -747,10 +751,12 @@ export declare const APP_ID: InjectionToken<string>;
  * ### Example with NgModule-based application
  * ```
  *  function initializeApp(): Promise<any> {
- *    return new Promise((resolve, reject) => {
- *      // Do some asynchronous stuff
- *      resolve();
- *    });
+ *    const http = inject(HttpClient);
+ *    return firstValueFrom(
+ *      http
+ *        .get("https://someUrl.com/api/user")
+ *        .pipe(tap(user => { ... }))
+ *    );
  *  }
  *
  *  @NgModule({
@@ -759,8 +765,8 @@ export declare const APP_ID: InjectionToken<string>;
  *   bootstrap: [AppComponent],
  *   providers: [{
  *     provide: APP_INITIALIZER,
- *     useFactory: () => initializeApp,
- *     multi: true
+ *     useValue: initializeApp,
+ *     multi: true,
  *    }]
  *   })
  *  export class AppModule {}
@@ -768,13 +774,13 @@ export declare const APP_ID: InjectionToken<string>;
  *
  * ### Example with standalone application
  * ```
- * export function initializeApp(http: HttpClient) {
- *   return (): Promise<any> =>
- *     firstValueFrom(
- *       http
- *         .get("https://someUrl.com/api/user")
- *         .pipe(tap(user => { ... }))
- *     );
+ * function initializeApp() {
+ *   const http = inject(HttpClient);
+ *   return firstValueFrom(
+ *     http
+ *       .get("https://someUrl.com/api/user")
+ *       .pipe(tap(user => { ... }))
+ *   );
  * }
  *
  * bootstrapApplication(App, {
@@ -782,9 +788,8 @@ export declare const APP_ID: InjectionToken<string>;
  *     provideHttpClient(),
  *     {
  *       provide: APP_INITIALIZER,
- *       useFactory: initializeApp,
+ *       useValue: initializeApp,
  *       multi: true,
- *       deps: [HttpClient],
  *     },
  *   ],
  * });
@@ -799,44 +804,46 @@ export declare const APP_ID: InjectionToken<string>;
  *
  * ### Example with NgModule-based application
  * ```
- *  function initializeAppFactory(httpClient: HttpClient): () => Observable<any> {
- *   return () => httpClient.get("https://someUrl.com/api/user")
- *     .pipe(
- *        tap(user => { ... })
- *     );
- *  }
+ * function initializeApp() {
+ *   const http = inject(HttpClient);
+ *   return firstValueFrom(
+ *     http
+ *       .get("https://someUrl.com/api/user")
+ *       .pipe(tap(user => { ... }))
+ *   );
+ * }
  *
- *  @NgModule({
- *    imports: [BrowserModule, HttpClientModule],
- *    declarations: [AppComponent],
- *    bootstrap: [AppComponent],
- *    providers: [{
- *      provide: APP_INITIALIZER,
- *      useFactory: initializeAppFactory,
- *      deps: [HttpClient],
- *      multi: true
- *    }]
- *  })
- *  export class AppModule {}
+ * @NgModule({
+ *   imports: [BrowserModule, HttpClientModule],
+ *   declarations: [AppComponent],
+ *   bootstrap: [AppComponent],
+ *   providers: [{
+ *     provide: APP_INITIALIZER,
+ *     useValue: initializeApp,
+ *     multi: true,
+ *   }]
+ * })
+ * export class AppModule {}
  * ```
  *
  * ### Example with standalone application
  * ```
- *  function initializeAppFactory(httpClient: HttpClient): () => Observable<any> {
- *   return () => httpClient.get("https://someUrl.com/api/user")
- *     .pipe(
- *        tap(user => { ... })
- *     );
- *  }
+ * function initializeApp() {
+ *   const http = inject(HttpClient);
+ *   return firstValueFrom(
+ *     http
+ *       .get("https://someUrl.com/api/user")
+ *       .pipe(tap(user => { ... }))
+ *   );
+ * }
  *
  * bootstrapApplication(App, {
  *   providers: [
  *     provideHttpClient(),
  *     {
  *       provide: APP_INITIALIZER,
- *       useFactory: initializeAppFactory,
+ *       useValue: initializeApp,
  *       multi: true,
- *       deps: [HttpClient],
  *     },
  *   ],
  * });
@@ -870,6 +877,7 @@ export declare class ApplicationInitStatus {
     readonly done = false;
     readonly donePromise: Promise<any>;
     private readonly appInits;
+    private readonly injector;
     constructor();
     static ɵfac: i0.ɵɵFactoryDeclaration<ApplicationInitStatus, never>;
     static ɵprov: i0.ɵɵInjectableDeclaration<ApplicationInitStatus>;
@@ -1170,7 +1178,6 @@ export declare class ApplicationRef {
  * @param component Component to {@link ChangeDetectorRef#markForCheck mark for check}.
  *
  * @publicApi
- * @globalApi ng
  */
 declare function applyChanges(component: {}): void;
 
@@ -2391,10 +2398,12 @@ export declare interface ContentChildFunction {
     <LocatorT>(locator: ProviderToken<LocatorT> | string, opts?: {
         descendants?: boolean;
         read?: undefined;
+        debugName?: string;
     }): Signal<LocatorT | undefined>;
     <LocatorT, ReadT>(locator: ProviderToken<LocatorT> | string, opts: {
         descendants?: boolean;
         read: ProviderToken<ReadT>;
+        debugName?: string;
     }): Signal<ReadT | undefined>;
     /**
      * Initializes a content child query that is always expected to match.
@@ -2403,10 +2412,12 @@ export declare interface ContentChildFunction {
         <LocatorT>(locator: ProviderToken<LocatorT> | string, opts?: {
             descendants?: boolean;
             read?: undefined;
+            debugName?: string;
         }): Signal<LocatorT>;
         <LocatorT, ReadT>(locator: ProviderToken<LocatorT> | string, opts: {
             descendants?: boolean;
             read: ProviderToken<ReadT>;
+            debugName?: string;
         }): Signal<ReadT>;
     };
 }
@@ -2432,11 +2443,13 @@ export declare const ContentChildren: ContentChildrenDecorator;
 export declare function contentChildren<LocatorT>(locator: ProviderToken<LocatorT> | string, opts?: {
     descendants?: boolean;
     read?: undefined;
+    debugName?: string;
 }): Signal<ReadonlyArray<LocatorT>>;
 
 export declare function contentChildren<LocatorT, ReadT>(locator: ProviderToken<LocatorT> | string, opts: {
     descendants?: boolean;
     read: ProviderToken<ReadT>;
+    debugName?: string;
 }): Signal<ReadonlyArray<ReadT>>;
 
 /**
@@ -2600,6 +2613,10 @@ export declare interface CreateComputedOptions<T> {
      * A comparison function which defines equality for computed values.
      */
     equal?: ValueEqualityFn<T>;
+    /**
+     * A debug name for the computed signal. Used in Angular DevTools to identify the signal.
+     */
+    debugName?: string;
 }
 
 /**
@@ -2631,6 +2648,10 @@ export declare interface CreateEffectOptions {
      * @deprecated no longer required, signal writes are allowed by default.
      */
     allowSignalWrites?: boolean;
+    /**
+     * A debug name for the effect. Used in Angular DevTools to identify the effect.
+     */
+    debugName?: string;
 }
 
 /**
@@ -2694,6 +2715,10 @@ export declare interface CreateSignalOptions<T> {
      * A comparison function which defines equality for signal values.
      */
     equal?: ValueEqualityFn<T>;
+    /**
+     * A debug name for the signal. Used in Angular DevTools to identify the signal.
+     */
+    debugName?: string;
 }
 
 /**
@@ -3012,6 +3037,38 @@ export declare class DefaultIterableDiffer<V> implements IterableDiffer<V>, Iter
     private _addToRemovals;
 }
 
+declare const DEFER_BLOCK_ID = "di";
+
+declare const DEFER_BLOCK_STATE = "s";
+
+declare const DEFER_HYDRATE_TRIGGERS = "t";
+
+declare const DEFER_PARENT_BLOCK_ID = "p";
+
+/**
+ * Basic set of data structures used for identifying a defer block
+ * and triggering defer blocks
+ */
+declare interface DeferBlock {
+    lView: LView;
+    tNode: TNode;
+    lContainer: LContainer;
+}
+
+/**
+ * Represents defer trigger types.
+ */
+declare const enum DeferBlockTrigger {
+    Idle = 0,
+    Immediate = 1,
+    Viewport = 2,
+    Interaction = 3,
+    Hover = 4,
+    Timer = 5,
+    When = 6,
+    Never = 7
+}
+
 /**
  * Describes the state of defer block dependency loading.
  */
@@ -3131,6 +3188,10 @@ declare interface DehydratedView {
      * removed from the DOM during hydration cleanup.
      */
     dehydratedIcuData?: Map<number, DehydratedIcuData>;
+    /**
+     * A mapping of defer block unique ids to the defer block data
+     */
+    dehydratedDeferBlockData?: Record<string, SerializedDeferBlock>;
 }
 
 /**
@@ -3941,6 +4002,7 @@ declare interface EffectNode extends ReactiveNode, SchedulableEffect {
     hasRun: boolean;
     cleanupFns: EffectCleanupFn[] | undefined;
     injector: Injector;
+    notifier: ɵChangeDetectionScheduler;
     onDestroyFn: () => void;
     fn: (cleanupFn: EffectCleanupRegisterFn) => void;
     run(): void;
@@ -4096,6 +4158,10 @@ declare const ENVIRONMENT = 10;
  * A multi-provider token for initialization functions that will run upon construction of an
  * environment injector.
  *
+ * @deprecated from v19.0.0, use provideEnvironmentInitializer instead
+ *
+ * @see {@link provideEnvironmentInitializer}
+ *
  * Note: As opposed to the `APP_INITIALIZER` token, the `ENVIRONMENT_INITIALIZER` functions are not awaited,
  * hence they should not be `async`.
  *
@@ -4490,7 +4556,6 @@ export declare interface ForwardRefFn {
  *    is no component associated with it.
  *
  * @publicApi
- * @globalApi ng
  */
 declare function getComponent<T>(element: Element): T | null;
 
@@ -4504,7 +4569,6 @@ declare function getComponent<T>(element: Element): T | null;
  *    inside any component.
  *
  * @publicApi
- * @globalApi ng
  */
 declare function getContext<T extends {}>(element: Element): T | null;
 
@@ -4539,7 +4603,6 @@ declare function getDependenciesFromInjectable<T>(injector: Injector, token: Typ
  * @returns metadata of the passed directive or component
  *
  * @publicApi
- * @globalApi ng
  */
 declare function getDirectiveMetadata(directiveOrComponentInstance: any): ɵComponentDebugMetadata | DirectiveDebugMetadata | null;
 
@@ -4551,7 +4614,6 @@ declare function getDirectiveMetadata(directiveOrComponentInstance: any): ɵComp
  * @returns Injector associated with the element, component or directive instance.
  *
  * @publicApi
- * @globalApi ng
  */
 declare function getInjector(elementOrDir: Element | {}): Injector;
 
@@ -4620,7 +4682,6 @@ declare function getInjectorResolutionPath(injector: Injector): Injector[];
  * @returns Array of event listeners on the DOM element.
  *
  * @publicApi
- * @globalApi ng
  */
 declare function getListeners(element: Element): Listener[];
 
@@ -4654,7 +4715,6 @@ export declare function getNgModuleById<T>(id: string): Type<T>;
  *    part of a component view.
  *
  * @publicApi
- * @globalApi ng
  */
 declare function getOwningComponent<T>(elementOrDir: Element | {}): T | null;
 
@@ -4674,7 +4734,6 @@ export declare function getPlatform(): PlatformRef | null;
  * @returns Root components associated with the target object.
  *
  * @publicApi
- * @globalApi ng
  */
 declare function getRootComponents(elementOrDir: Element | {}): {}[];
 
@@ -5114,6 +5173,14 @@ export declare interface HostListenerDecorator {
     new (eventName: string, args?: string[]): any;
 }
 
+/** * Describes specified delay (in ms) in the `hydrate on timer()` trigger. */
+declare interface HydrateTimerTriggerDetails {
+    delay: number;
+}
+
+/** * Describes all possible hydration trigger details specified in a template. */
+declare type HydrateTriggerDetails = HydrateTimerTriggerDetails;
+
 declare const HYDRATION = 6;
 
 declare const HYDRATION_INFO_KEY = "__ngDebugHydrationInfo__";
@@ -6232,6 +6299,10 @@ export declare interface InputOptions<T, TransformT> {
      * handle such string values and convert them to `boolean`. See: {@link booleanAttribute}.
      */
     transform?: (v: TransformT) => T;
+    /**
+     * A debug name for the input signal. Used in Angular DevTools to identify the signal.
+     */
+    debugName?: string;
 }
 
 /**
@@ -6729,6 +6800,22 @@ declare enum LContainerFlags {
 
 declare type LegacyInputPartialMapping = string | [bindingPropertyName: string, classPropertyName: string, transformFunction?: Function];
 
+/**
+ * @experimental
+ */
+export declare function linkedSignal<D>(computation: () => D, options?: {
+    equal?: ValueEqualityFn<NoInfer<D>>;
+}): WritableSignal<D>;
+
+export declare function linkedSignal<S, D>(options: {
+    source: () => S;
+    computation: (source: NoInfer<S>, previous?: {
+        source: NoInfer<S>;
+        value: NoInfer<D>;
+    }) => D;
+    equal?: ValueEqualityFn<NoInfer<D>>;
+}): WritableSignal<D>;
+
 /**
  * Event listener configuration returned from `getListeners`.
  * @publicApi
@@ -7324,6 +7411,10 @@ export declare interface ModelOptions {
      * name as the input, but suffixed with `Change`. By default, the class field name is used.
      */
     alias?: string;
+    /**
+     * A debug name for the model signal. Used in Angular DevTools to identify the signal.
+     */
+    debugName?: string;
 }
 
 /**
@@ -7367,12 +7458,6 @@ declare const MOVED_VIEWS = 9;
 
 declare const MULTIPLIER = "x";
 
-declare type Mutable<T extends {
-    [x: string]: any;
-}, K extends string> = {
-    [P in K]: T[P];
-};
-
 declare const NATIVE = 7;
 
 declare const NEXT = 4;
@@ -8324,6 +8409,7 @@ declare class PendingTasksInternal implements OnDestroy {
     private get _hasPendingTasks();
     hasPendingTasks: BehaviorSubject<boolean>;
     add(): number;
+    has(taskId: number): boolean;
     remove(taskId: number): void;
     ngOnDestroy(): void;
     /** @nocollapse */
@@ -8458,6 +8544,11 @@ export declare const PLATFORM_ID: InjectionToken<Object>;
 
 /**
  * A function that is executed when a platform is initialized.
+ *
+ * @deprecated from v19.0.0, use providePlatformInitializer instead
+ *
+ * @see {@link providePlatformInitializer}
+ *
  * @publicApi
  */
 export declare const PLATFORM_INITIALIZER: InjectionToken<readonly (() => void)[]>;
@@ -8589,6 +8680,75 @@ declare type ProcessProvidersFunction = (providers: Provider[]) => Provider[];
  */
 declare type ProjectionSlots = (ɵCssSelectorList | '*')[];
 
+/**
+ * @description
+ * The provided function is injected at application startup and executed during
+ * app initialization. If the function returns a Promise or an Observable, initialization
+ * does not complete until the Promise is resolved or the Observable is completed.
+ *
+ * You can, for example, create a function that loads language data
+ * or an external configuration, and provide that function using `provideAppInitializer()`.
+ * The function is executed during the application bootstrap process,
+ * and the needed data is available on startup.
+ *
+ * Note that the provided initializer is run in the injection context.
+ *
+ * Previously, this was achieved using the `APP_INITIALIZER` token which is now deprecated.
+ *
+ * @see {@link APP_INITIALIZER}
+ *
+ * @usageNotes
+ * The following example illustrates how to configure an initialization function using
+ * `provideAppInitializer()`
+ * ```
+ * bootstrapApplication(App, {
+ *   providers: [
+ *     provideAppInitializer(() => {
+ *       const http = inject(HttpClient);
+ *       return firstValueFrom(
+ *         http
+ *           .get("https://someUrl.com/api/user")
+ *           .pipe(tap(user => { ... }))
+ *       );
+ *     }),
+ *     provideHttpClient(),
+ *   ],
+ * });
+ * ```
+ *
+ * @publicApi
+ */
+export declare function provideAppInitializer(initializerFn: () => Observable<unknown> | Promise<unknown> | void): EnvironmentProviders;
+
+/**
+ * @description
+ * This function is used to provide initialization functions that will be executed upon construction
+ * of an environment injector.
+ *
+ * Note that the provided initializer is run in the injection context.
+ *
+ * Previously, this was achieved using the `ENVIRONMENT_INITIALIZER` token which is now deprecated.
+ *
+ * @see {@link ENVIRONMENT_INITIALIZER}
+ *
+ * @usageNotes
+ * The following example illustrates how to configure an initialization function using
+ * `provideEnvironmentInitializer()`
+ * ```
+ * createEnvironmentInjector(
+ *   [
+ *     provideEnvironmentInitializer(() => {
+ *       console.log('environment initialized');
+ *     }),
+ *   ],
+ *   parentInjector
+ * );
+ * ```
+ *
+ * @publicApi
+ */
+export declare function provideEnvironmentInitializer(initializerFn: () => void): EnvironmentProviders;
+
 /**
  * Used to periodically verify no expressions have changed after they were checked.
  *
@@ -8656,6 +8816,21 @@ export declare function provideExperimentalCheckNoChangesForDebug(options: {
  */
 export declare function provideExperimentalZonelessChangeDetection(): EnvironmentProviders;
 
+/**
+ * @description
+ * This function is used to provide initialization functions that will be executed upon
+ * initialization of the platform injector.
+ *
+ * Note that the provided initializer is run in the injection context.
+ *
+ * Previously, this was achieved using the `PLATFORM_INITIALIZER` token which is now deprecated.
+ *
+ * @see {@link PLATFORM_INITIALIZER}
+ *
+ * @publicApi
+ */
+export declare function providePlatformInitializer(initializerFn: () => void): EnvironmentProviders;
+
 /**
  * Describes how the `Injector` should be configured.
  * @see [Dependency Injection Guide](guide/di/dependency-injection.
@@ -8917,6 +9092,7 @@ declare interface R3DeclareDirectiveDependencyFacade {
 declare interface R3DeclareDirectiveFacade {
     selector?: string;
     type: Type_2;
+    version: string;
     inputs?: {
         [fieldName: string]: {
             classPropertyName: string;
@@ -8999,6 +9175,7 @@ declare interface R3DeclarePipeDependencyFacade {
 declare interface R3DeclarePipeFacade {
     type: Type_2;
     name: string;
+    version: string;
     pure?: boolean;
     isStandalone?: boolean;
 }
@@ -9428,6 +9605,164 @@ export declare interface RendererType2 {
  */
 export declare function resolveForwardRef<T>(type: T): T;
 
+/**
+ * A Resource is an asynchronous dependency (for example, the results of an API call) that is
+ * managed and delivered through signals.
+ *
+ * The usual way of creating a `Resource` is through the `resource` function, but various other APIs
+ * may present `Resource` instances to describe their own concepts.
+ *
+ * @experimental
+ */
+export declare interface Resource<T> {
+    /**
+     * The current value of the `Resource`, or `undefined` if there is no current value.
+     */
+    readonly value: Signal<T | undefined>;
+    /**
+     * The current status of the `Resource`, which describes what the resource is currently doing and
+     * what can be expected of its `value`.
+     */
+    readonly status: Signal<ResourceStatus>;
+    /**
+     * When in the `error` state, this returns the last known error from the `Resource`.
+     */
+    readonly error: Signal<unknown>;
+    /**
+     * Whether this resource is loading a new value (or reloading the existing one).
+     */
+    readonly isLoading: Signal<boolean>;
+    /**
+     * Whether this resource has a valid current value.
+     *
+     * This function is reactive.
+     */
+    hasValue(): this is Resource<T> & {
+        value: Signal<T>;
+    };
+    /**
+     * Instructs the resource to re-load any asynchronous dependency it may have.
+     *
+     * Note that the resource will not enter its reloading state until the actual backend request is
+     * made.
+     *
+     * @returns true if a reload was initiated, false if a reload was unnecessary or unsupported
+     */
+    reload(): boolean;
+}
+
+/**
+ * Constructs a `Resource` that projects a reactive request to an asynchronous operation defined by
+ * a loader function, which exposes the result of the loading operation via signals.
+ *
+ * Note that `resource` is intended for _read_ operations, not operations which perform mutations.
+ * `resource` will cancel in-progress loads via the `AbortSignal` when destroyed or when a new
+ * request object becomes available, which could prematurely abort mutations.
+ *
+ * @experimental
+ */
+export declare function resource<T, R>(options: ResourceOptions<T, R>): ResourceRef<T>;
+
+/**
+ * Loading function for a `Resource`.
+ *
+ * @experimental
+ */
+export declare type ResourceLoader<T, R> = (param: ResourceLoaderParams<R>) => PromiseLike<T>;
+
+/**
+ * Parameter to a `ResourceLoader` which gives the request and other options for the current loading
+ * operation.
+ *
+ * @experimental
+ */
+export declare interface ResourceLoaderParams<R> {
+    request: Exclude<NoInfer<R>, undefined>;
+    abortSignal: AbortSignal;
+    previous: {
+        status: ResourceStatus;
+    };
+}
+
+/**
+ * Options to the `resource` function, for creating a resource.
+ *
+ * @experimental
+ */
+export declare interface ResourceOptions<T, R> {
+    /**
+     * A reactive function which determines the request to be made. Whenever the request changes, the
+     * loader will be triggered to fetch a new value for the resource.
+     *
+     * If a request function isn't provided, the loader won't rerun unless the resource is reloaded.
+     */
+    request?: () => R;
+    /**
+     * Loading function which returns a `Promise` of the resource's value for a given request.
+     */
+    loader: ResourceLoader<T, R>;
+    /**
+     * Equality function used to compare the return value of the loader.
+     */
+    equal?: ValueEqualityFn<T>;
+    /**
+     * Overrides the `Injector` used by `resource`.
+     */
+    injector?: Injector;
+}
+
+/**
+ * A `WritableResource` created through the `resource` function.
+ *
+ * @experimental
+ */
+export declare interface ResourceRef<T> extends WritableResource<T> {
+    /**
+     * Manually destroy the resource, which cancels pending requests and returns it to `idle` state.
+     */
+    destroy(): void;
+}
+
+/**
+ * Status of a `Resource`.
+ *
+ * @experimental
+ */
+export declare enum ResourceStatus {
+    /**
+     * The resource has no valid request and will not perform any loading.
+     *
+     * `value()` will be `undefined`.
+     */
+    Idle = 0,
+    /**
+     * Loading failed with an error.
+     *
+     * `value()` will be `undefined`.
+     */
+    Error = 1,
+    /**
+     * The resource is currently loading a new value as a result of a change in its `request`.
+     *
+     * `value()` will be `undefined`.
+     */
+    Loading = 2,
+    /**
+     * The resource is currently reloading a fresh value for the same request.
+     *
+     * `value()` will continue to return the previously fetched value during the reloading operation.
+     */
+    Reloading = 3,
+    /**
+     * Loading has completed and the resource has the value returned from the loader.
+     */
+    Resolved = 4,
+    /**
+     * The resource's value was set locally via `.set()` or `.update()`.
+     */
+    Local = 5
+}
+
 /**
  * The goal here is to make sure that the browser DOM API is the Renderer.
  * We do this by defining a subset of DOM API to be the renderer and then
@@ -9650,6 +9985,33 @@ declare interface SerializedContainerView extends SerializedView {
     [MULTIPLIER]?: number;
 }
 
+/**
+ * Serialized data structure that contains relevant defer block
+ * information that describes a given incremental hydration boundary
+ */
+declare interface SerializedDeferBlock {
+    /**
+     * This contains the unique id of this defer block's parent, if it exists.
+     */
+    [DEFER_PARENT_BLOCK_ID]: string | null;
+    /**
+     * This field represents a status, based on the `DeferBlockState` enum.
+     */
+    [DEFER_BLOCK_STATE]?: number;
+    /**
+     * Number of root nodes that belong to this defer block's template.
+     * This information is needed to effectively traverse the DOM tree
+     * and add jsaction attributes to root nodes appropriately for
+     * incremental hydration.
+     */
+    [NUM_ROOT_NODES]: number;
+    /**
+     * The list of triggers that exist for incremental hydration, based on the
+     * `Trigger` enum.
+     */
+    [DEFER_HYDRATE_TRIGGERS]: (DeferBlockTrigger | SerializedTriggerDetails)[] | null;
+}
+
 /**
  * Represents element containers within this view, stored as key-value pairs
  * where key is an index of a container in an LView (also used in the
@@ -9661,6 +10023,11 @@ declare interface SerializedElementContainers {
     [key: number]: number;
 }
 
+declare interface SerializedTriggerDetails {
+    trigger: DeferBlockTrigger;
+    delay?: number;
+}
+
 /**
  * Serialized data structure that contains relevant hydration
  * annotation information that describes a given hydration boundary
@@ -9708,6 +10075,15 @@ declare interface SerializedView {
      * active ICU cases.
      */
     [I18N_DATA]?: Record<number, number[]>;
+    /**
+     * If this view represents a `@defer` block, this field contains
+     * unique id of the block.
+     */
+    [DEFER_BLOCK_ID]?: string;
+    /**
+     * This field represents a status, based on the `DeferBlockState` enum.
+     */
+    [DEFER_BLOCK_STATE]?: number;
 }
 
 /**
@@ -10043,6 +10419,14 @@ declare interface TDeferBlockDetails {
      * standalone components used within this defer block.
      */
     providers: Provider[] | null;
+    /**
+     * List of hydrate triggers for a given block
+     */
+    hydrateTriggers: Map<DeferBlockTrigger, HydrateTriggerDetails | null> | null;
+    /**
+     * List of prefetch triggers for a given block
+     */
+    prefetchTriggers: Set<DeferBlockTrigger> | null;
 }
 
 /** Static data for an <ng-container> */
@@ -11785,19 +12169,25 @@ export declare interface ViewChildFunction {
      *
      * @publicAPI
      */
-    <LocatorT>(locator: ProviderToken<LocatorT> | string): Signal<LocatorT | undefined>;
     <LocatorT, ReadT>(locator: ProviderToken<LocatorT> | string, opts: {
         read: ProviderToken<ReadT>;
+        debugName?: string;
     }): Signal<ReadT | undefined>;
+    <LocatorT>(locator: ProviderToken<LocatorT> | string, opts?: {
+        debugName?: string;
+    }): Signal<LocatorT | undefined>;
     /**
      * Initializes a view child query that is expected to always match an element.
      *
      * @publicAPI
      */
     required: {
-        <LocatorT>(locator: ProviderToken<LocatorT> | string): Signal<LocatorT>;
+        <LocatorT>(locator: ProviderToken<LocatorT> | string, opts?: {
+            debugName?: string;
+        }): Signal<LocatorT>;
         <LocatorT, ReadT>(locator: ProviderToken<LocatorT> | string, opts: {
             read: ProviderToken<ReadT>;
+            debugName?: string;
         }): Signal<ReadT>;
     };
 }
@@ -11817,10 +12207,13 @@ export declare type ViewChildren = Query;
  */
 export declare const ViewChildren: ViewChildrenDecorator;
 
-export declare function viewChildren<LocatorT>(locator: ProviderToken<LocatorT> | string): Signal<ReadonlyArray<LocatorT>>;
+export declare function viewChildren<LocatorT>(locator: ProviderToken<LocatorT> | string, opts?: {
+    debugName?: string;
+}): Signal<ReadonlyArray<LocatorT>>;
 
 export declare function viewChildren<LocatorT, ReadT>(locator: ProviderToken<LocatorT> | string, opts: {
     read: ProviderToken<ReadT>;
+    debugName?: string;
 }): Signal<ReadonlyArray<ReadT>>;
 
 /**
@@ -12168,6 +12561,29 @@ export declare abstract class ViewRef extends ChangeDetectorRef {
     abstract onDestroy(callback: Function): void;
 }
 
+/**
+ * A `Resource` with a mutable value.
+ *
+ * Overwriting the value of a resource sets it to the 'local' state.
+ *
+ * @experimental
+ */
+export declare interface WritableResource<T> extends Resource<T> {
+    readonly value: WritableSignal<T | undefined>;
+    hasValue(): this is WritableResource<T> & {
+        value: WritableSignal<T>;
+    };
+    /**
+     * Convenience wrapper for `value.set`.
+     */
+    set(value: T | undefined): void;
+    /**
+     * Convenience wrapper for `value.update`.
+     */
+    update(updater: (value: T | undefined) => T | undefined): void;
+    asReadonly(): Resource<T>;
+}
+
 /**
  * A `Signal` with a value that can be mutated via a setter interface.
  */
@@ -12197,8 +12613,6 @@ export declare interface WritableSignal<T> extends Signal<T> {
 declare class ZoneAwareEffectScheduler implements ɵEffectScheduler {
     private queuedEffectCount;
     private queues;
-    private readonly pendingTasks;
-    protected taskId: number | null;
     schedule(handle: SchedulableEffect): void;
     private enqueue;
     /**
@@ -12661,8 +13075,7 @@ export declare interface ɵComponentDef<T> extends ɵDirectiveDef<T> {
      */
     tView: TView | null;
     /**
-     * A function added by the {@link ɵɵStandaloneFeature} and used by the framework to create
-     * standalone injectors.
+     * A function used by the framework to create standalone injectors.
      */
     getStandaloneInjector: ((parentInjector: EnvironmentInjector) => EnvironmentInjector | null) | null;
     /**
@@ -12797,10 +13210,7 @@ export declare interface ɵDeferBlockDependencyInterceptor {
 /**
  * Defer block instance for testing.
  */
-export declare interface ɵDeferBlockDetails {
-    lContainer: LContainer;
-    lView: LView;
-    tNode: TNode;
+export declare interface ɵDeferBlockDetails extends DeferBlock {
     tDetails: TDeferBlockDetails;
 }
 
@@ -13068,6 +13478,14 @@ export declare function ɵgenerateStandaloneInDeclarationsError(type: Type<any>,
  */
 export declare function ɵgetAsyncClassMetadataFn(type: Type<unknown>): (() => Promise<Array<Type<unknown>>>) | null;
 
+/**
+ * Gets the class name of the closest component to a node.
+ * Warning! this function will return minified names if the name of the component is minified. The
+ * consumer of the function is responsible for resolving the minified name to its original name.
+ * @param node Node from which to start the search.
+ */
+export declare function ɵgetClosestComponentName(node: Node): string | null;
+
 /**
  * Retrieves all defer blocks in a given LView.
  *
@@ -13099,7 +13517,6 @@ export declare function ɵgetDeferBlocks(lView: LView, deferBlocks: ɵDeferBlock
  * @returns Array of directives associated with the node.
  *
  * @publicApi
- * @globalApi ng
  */
 export declare function ɵgetDirectives(node: Node): {}[];
 
@@ -13112,7 +13529,6 @@ export declare function ɵgetDirectives(node: Node): {}[];
  * @returns Host element of the target.
  *
  * @publicApi
- * @globalApi ng
  */
 export declare function ɵgetHostElement(componentOrDirective: {}): Element;
 
@@ -13288,6 +13704,10 @@ export declare interface ɵInputSignalNode<T, TransformT> extends SignalNode<T>
      * purposes we assume it's a valid `T` value. Type-checking will enforce that.
      */
     applyValueToInputSignal<T, TransformT>(node: ɵInputSignalNode<T, TransformT>, value: T): void;
+    /**
+     * A debug name for the input signal. Used in Angular DevTools to identify the signal.
+     */
+    debugName?: string;
 }
 
 /**
@@ -13337,6 +13757,12 @@ export declare function ɵinternalProvideZoneChangeDetection({ ngZoneFactory, ig
  */
 export declare const ɵIS_HYDRATION_DOM_REUSE_ENABLED: InjectionToken<boolean>;
 
+/**
+ * Internal token that indicates whether incremental hydration support
+ * is enabled.
+ */
+export declare const ɵIS_INCREMENTAL_HYDRATION_ENABLED: InjectionToken<boolean>;
+
 export declare function ɵisBoundToModule<C>(cf: ComponentFactory<C>): boolean;
 
 export declare function ɵisComponentDefPendingResolution(type: Type<any>): boolean;
@@ -13465,7 +13891,10 @@ export declare enum ɵLocaleDataIndex {
 export declare function ɵmicrotaskEffect(effectFn: (onCleanup: EffectCleanupRegisterFn) => void, options?: CreateEffectOptions): EffectRef;
 
 export declare class ɵMicrotaskEffectScheduler extends ZoneAwareEffectScheduler {
+    private readonly pendingTasks;
+    private taskId;
     schedule(effect: SchedulableEffect): void;
+    flush(): void;
     /** @nocollapse */
     static ɵprov: unknown;
 }
@@ -13490,6 +13919,12 @@ export declare const ɵNG_PIPE_DEF: string;
 
 export declare const ɵNG_PROV_DEF: string;
 
+/**
+ * A constant defining the default value for the standalone attribute in Directive and Pipes decorators.
+ * Extracted to a separate file to facilitate G3 patches.
+ */
+export declare const ɵNG_STANDALONE_DEFAULT_VALUE = true;
+
 /**
  * Runtime link information for NgModules.
  *
@@ -13616,7 +14051,8 @@ export declare const enum ɵNotificationSource {
     ViewDetachedFromDOM = 10,
     AsyncAnimationsLoaded = 11,
     PendingTaskRemoved = 12,
-    RootEffect = 13
+    RootEffect = 13,
+    ViewEffect = 14
 }
 
 /**
@@ -14534,6 +14970,15 @@ export declare function ɵwithEventReplay(): Provider[];
  */
 export declare function ɵwithI18nSupport(): Provider[];
 
+/**
+ * Returns a set of providers required to setup support for incremental hydration.
+ * Requires hydration to be enabled separately.
+ * Enabling incremental hydration also enables event replay for the entire app.
+ *
+ * @developerPreview
+ */
+export declare function ɵwithIncrementalHydration(): Provider[];
+
 /**
  * Returns a writable type version of type.
  *
@@ -15336,21 +15781,54 @@ export declare function ɵɵdefer(index: number, primaryTmplIndex: number, depen
  */
 export declare function ɵɵdeferEnableTimerScheduling(tView: TView, tDetails: TDeferBlockDetails, placeholderConfigIndex?: number | null, loadingConfigIndex?: number | null): void;
 
+/**
+ * Specifies that hydration never occurs.
+ * @codeGenApi
+ */
 export declare function ɵɵdeferHydrateNever(): void;
 
+/**
+ * Creates runtime data structures for the `on hover` hydrate trigger.
+ * @codeGenApi
+ */
 export declare function ɵɵdeferHydrateOnHover(): void;
 
+/**
+ * Sets up logic to handle the `on idle` deferred trigger.
+ * @codeGenApi
+ */
 export declare function ɵɵdeferHydrateOnIdle(): void;
 
+/**
+ * Sets up logic to handle the `on immediate` hydrate trigger.
+ * @codeGenApi
+ */
 export declare function ɵɵdeferHydrateOnImmediate(): void;
 
+/**
+ * Creates runtime data structures for the `on interaction` hydrate trigger.
+ * @codeGenApi
+ */
 export declare function ɵɵdeferHydrateOnInteraction(): void;
 
-export declare function ɵɵdeferHydrateOnTimer(): void;
+/**
+ * Creates runtime data structures for the `on timer` hydrate trigger.
+ * @param delay Amount of time to wait before loading the content.
+ * @codeGenApi
+ */
+export declare function ɵɵdeferHydrateOnTimer(delay: number): void;
 
+/**
+ * Creates runtime data structures for the `on viewport` hydrate trigger.
+ * @codeGenApi
+ */
 export declare function ɵɵdeferHydrateOnViewport(): void;
 
-export declare function ɵɵdeferHydrateWhen(): void;
+/**
+ * Hydrates the deferred content when a value becomes truthy.
+ * @codeGenApi
+ */
+export declare function ɵɵdeferHydrateWhen(rawValue: unknown): void;
 
 /**
  * Creates runtime data structures for the `on hover` deferred trigger.
@@ -15466,7 +15944,7 @@ export declare function ɵɵdeferWhen(rawValue: unknown): void;
  * ```
  * @codeGenApi
  */
-export declare function ɵɵdefineComponent<T>(componentDefinition: ComponentDefinition<T>): Mutable<ɵComponentDef<any>, keyof ɵComponentDef<any>>;
+export declare function ɵɵdefineComponent<T>(componentDefinition: ComponentDefinition<T>): ɵComponentDef<any>;
 
 /**
  * Create a directive definition object.
@@ -15484,7 +15962,7 @@ export declare function ɵɵdefineComponent<T>(componentDefinition: ComponentDef
  *
  * @codeGenApi
  */
-export declare function ɵɵdefineDirective<T>(directiveDefinition: DirectiveDefinition<T>): Mutable<ɵDirectiveDef<any>, keyof ɵDirectiveDef<any>>;
+export declare function ɵɵdefineDirective<T>(directiveDefinition: DirectiveDefinition<T>): ɵDirectiveDef<any>;
 
 /**
  * Construct an injectable definition which defines how a token will be constructed by the DI
@@ -16245,7 +16723,7 @@ export declare type ɵɵNgModuleDeclaration<T, Declarations, Imports, Exports> =
  *
  * @codeGenApi
  */
-export declare function ɵɵNgOnChangesFeature<T>(): DirectiveDefFeature;
+export declare const ɵɵNgOnChangesFeature: () => DirectiveDefFeature;
 
 
 /**
@@ -17109,9 +17587,10 @@ export declare function ɵɵrepeaterTrackByIndex(index: number): number;
  * Replaces the metadata of a component type and re-renders all live instances of the component.
  * @param type Class whose metadata will be replaced.
  * @param applyMetadata Callback that will apply a new set of metadata on the `type` when invoked.
+ * @param locals Local symbols from the source location that have to be exposed to the callback.
  * @codeGenApi
  */
-export declare function ɵɵreplaceMetadata(type: Type<unknown>, applyMetadata: () => void): void;
+export declare function ɵɵreplaceMetadata(type: Type<unknown>, applyMetadata: (...args: [Type<unknown>, Record<string, unknown>, ...unknown[]]) => void, locals: unknown[]): void;
 
 /**
  * Clears the view set in `ɵɵrestoreView` from memory. Returns the passed in
@@ -17274,18 +17753,6 @@ export declare function ɵɵsetComponentScope(type: ɵComponentType<any>, direct
  */
 export declare function ɵɵsetNgModuleScope(type: any, scope: NgModuleScopeInfoFromDecorator): unknown;
 
-/**
- * A feature that acts as a setup code for the {@link StandaloneService}.
- *
- * The most important responsibility of this feature is to expose the "getStandaloneInjector"
- * function (an entry points to a standalone injector creation) on a component definition object. We
- * go through the features infrastructure to make sure that the standalone injector creation logic
- * is tree-shakable and not included in applications that don't use standalone components.
- *
- * @codeGenApi
- */
-export declare function ɵɵStandaloneFeature(definition: ɵComponentDef<unknown>): void;
-
 /**
  * Instruction that stores the value of a `@let` declaration on the current view.
  * Returns the value to allow usage inside variable initializers.