@angular/core 19.0.0-next.10 → 19.0.0-next.11

package/index.d.ts

@@ -1,5 +1,5 @@
 /**
- * @license Angular v19.0.0-next.10
+ * @license Angular v19.0.0-next.11
  * (c) 2010-2024 Google LLC. https://angular.io/
  * License: MIT
  */
@@ -738,7 +738,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 +752,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 +766,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 +775,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 +789,8 @@ export declare const APP_ID: InjectionToken<string>;
  *     provideHttpClient(),
  *     {
  *       provide: APP_INITIALIZER,
- *       useFactory: initializeApp,
+ *       useValue: initializeApp,
  *       multi: true,
- *       deps: [HttpClient],
  *     },
  *   ],
  * });
@@ -799,44 +805,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 +878,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>;
@@ -2391,10 +2400,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 +2414,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 +2445,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 +2615,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 +2650,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 +2717,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 +3039,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 +3190,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>;
 }
 
 /**
@@ -4097,6 +4160,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`.
  *
@@ -5115,6 +5182,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__";
@@ -6233,6 +6308,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;
 }
 
 /**
@@ -6730,6 +6809,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
@@ -7325,6 +7420,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;
 }
 
 /**
@@ -8319,6 +8418,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 */
@@ -8453,6 +8553,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)[]>;
@@ -8584,6 +8689,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(
+ *   [
+ *     provideEnvironmentInjector(() => {
+ *       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.
  *
@@ -8651,6 +8825,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.
@@ -9425,6 +9614,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
@@ -9647,6 +9994,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
@@ -9658,6 +10032,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
@@ -9705,6 +10084,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;
 }
 
 /**
@@ -10040,6 +10428,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> */
@@ -11782,19 +12178,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>;
     };
 }
@@ -11814,10 +12216,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>>;
 
 /**
@@ -12165,6 +12570,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.
  */
@@ -12792,10 +13220,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;
 }
 
@@ -13291,6 +13716,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;
 }
 
 /**
@@ -13340,6 +13769,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;
@@ -14547,6 +14982,14 @@ 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.
+ *
+ * @developerPreview
+ */
+export declare function ɵwithIncrementalHydration(): Provider[];
+
 /**
  * Returns a writable type version of type.
  *
@@ -15349,21 +15792,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.