@angular/core 16.0.0-next.3 → 16.0.0-next.5

package/index.d.ts

@@ -1,5 +1,5 @@
 /**
- * @license Angular v16.0.0-next.3
+ * @license Angular v16.0.0-next.5
  * (c) 2010-2022 Google LLC. https://angular.io/
  * License: MIT
  */
@@ -128,45 +128,6 @@ export declare interface AfterViewInit {
     ngAfterViewInit(): void;
 }
 
-/**
- * A DI token that you can use to create a virtual [provider](guide/glossary#provider)
- * that will populate the `entryComponents` field of components and NgModules
- * based on its `useValue` property value.
- * All components that are referenced in the `useValue` value (either directly
- * or in a nested array or map) are added to the `entryComponents` property.
- *
- * @usageNotes
- *
- * The following example shows how the router can populate the `entryComponents`
- * field of an NgModule based on a router configuration that refers
- * to components.
- *
- * ```typescript
- * // helper function inside the router
- * function provideRoutes(routes) {
- *   return [
- *     {provide: ROUTES, useValue: routes},
- *     {provide: ANALYZE_FOR_ENTRY_COMPONENTS, useValue: routes, multi: true}
- *   ];
- * }
- *
- * // user code
- * let routes = [
- *   {path: '/root', component: RootComp},
- *   {path: '/teams', component: TeamsComp}
- * ];
- *
- * @NgModule({
- *   providers: [provideRoutes(routes)]
- * })
- * class ModuleWithRoutes {}
- * ```
- *
- * @publicApi
- * @deprecated Since 9.0.0. With Ivy, this property is no longer necessary.
- */
-export declare const ANALYZE_FOR_ENTRY_COMPONENTS: InjectionToken<any>;
-
 /**
  * A [DI token](guide/glossary#di-token "DI token definition") that indicates which animations
  * module has been loaded.
@@ -572,6 +533,15 @@ export declare class ApplicationRef {
  */
 export declare function asNativeElements(debugEls: DebugElement[]): any;
 
+/**
+ * Asserts that the current stack frame is within an injection context and has access to `inject`.
+ *
+ * @param debugFn a reference to the function making the assertion (used for the error message).
+ *
+ * @publicApi
+ */
+export declare function assertInInjectionContext(debugFn: Function): void;
+
 /**
  * Checks that there is currently a platform that contains the given token as a provider.
  *
@@ -813,6 +783,9 @@ export declare abstract class ChangeDetectorRef {
     abstract reattach(): void;
 }
 
+declare interface ChangeDetectorRefInterface extends ChangeDetectorRef {
+}
+
 declare const CHILD_HEAD = 13;
 
 declare const CHILD_TAIL = 14;
@@ -882,8 +855,8 @@ declare const CLEANUP = 7;
  */
 export declare class Compiler {
     /**
-     * Compiles the given NgModule and all of its components. All templates of the components listed
-     * in `entryComponents` have to be inlined.
+     * Compiles the given NgModule and all of its components. All templates of the components
+     * have to be inlined.
      */
     compileModuleSync<T>(moduleType: Type<T>): NgModuleFactory<T>;
     /**
@@ -985,6 +958,7 @@ export declare interface Component extends Directive {
      * SystemJS exposes the `__moduleName` variable within each module.
      * In CommonJS, this can  be set to `module.id`.
      *
+     * @deprecated This option does not have any effect. Will be removed in Angular v17.
      */
     moduleId?: string;
     /**
@@ -1036,14 +1010,6 @@ export declare interface Component extends Directive {
      * Overrides the default interpolation start and end delimiters (`{{` and `}}`).
      */
     interpolation?: [string, string];
-    /**
-     * A set of components that should be compiled along with
-     * this component. For each component listed here,
-     * Angular creates a {@link ComponentFactory} and stores it in the
-     * {@link ComponentFactoryResolver}.
-     * @deprecated Since 9.0.0. With Ivy, this property is no longer necessary.
-     */
-    entryComponents?: Array<Type<any> | any[]>;
     /**
      * True to preserve or false to remove potentially superfluous whitespace characters
      * from the compiled template. Whitespace characters are those matching the `\s`
@@ -1538,7 +1504,7 @@ declare type ComponentTemplate<T> = {
  *
  * @developerPreview
  */
-export declare function computed<T>(computation: () => T, equal?: ValueEqualityFn<T>): Signal<T>;
+export declare function computed<T>(computation: () => T, options?: CreateComputedOptions<T>): Signal<T>;
 
 /**
  * Configures the `Injector` to return an instance of a token.
@@ -1588,78 +1554,6 @@ export declare interface ConstructorSansProvider {
     deps?: any[];
 }
 
-/**
- * Represents a reader that can depend on reactive values (`Producer`s) and receive
- * notifications when those values change.
- *
- * `Consumer`s do not wrap the reads they consume themselves, but rather can be set
- * as the active reader via `setActiveConsumer`.
- *
- * The set of dependencies of a `Consumer` is dynamic. Implementers expose a
- * monotonically increasing `trackingVersion` counter, which increments whenever
- * the `Consumer` is about to re-run any reactive reads it needs and establish a
- * new set of dependencies as a result.
- *
- * `Producer`s store the last `trackingVersion` they've seen from `Consumer`s which
- * have read them. This allows a `Producer` to identify whether its record of the
- * dependency is current or stale, by comparing the `Consumer`'s `trackingVersion`
- * to the version at which the dependency was established.
- */
-declare interface Consumer {
-    /**
-     * Numeric identifier of this `Producer`.
-     *
-     * May also be used to satisfy the interface for `Producer`.
-     */
-    readonly id: ConsumerId;
-    /**
-     * A `WeakRef` to this `Consumer` instance.
-     *
-     * An implementer provides this as a cached value to avoid the need to instantiate
-     * multiple `WeakRef` instances for the same `Consumer`.
-     *
-     * May also be used to satisfy the interface for `Producer`.
-     */
-    readonly ref: WeakRef<Consumer>;
-    /**
-     * A map of `Edge`s to `Producer` dependencies, keyed by the `ProducerId`.
-     *
-     * Used to poll `Producer`s to determine if the `Consumer` has really updated
-     * or not.
-     */
-    readonly producers: Map<ProducerId, Edge>;
-    /**
-     * Monotonically increasing counter representing a version of this `Consumer`'s
-     * dependencies.
-     */
-    readonly trackingVersion: number;
-    /**
-     * Called when a `Producer` dependency of this `Consumer` indicates it may
-     * have a new value.
-     *
-     * Notification alone does not mean the `Producer` has definitely produced a
-     * semantically different value, only that it _may_ have changed. Before a
-     * `Consumer` re-runs any computations or side effects, it should use the
-     * `consumerPollValueStatus` method to poll the `Producer`s on which it depends
-     * and determine if any of them have actually updated.
-     */
-    notify(): void;
-}
-
-/**
- * Identifier for a `Consumer`, which is a branded `number`.
- *
- * Note that `ProducerId` and `ConsumerId` are assigned from the same sequence, so the same `number`
- * will never be used for both.
- *
- * Branding provides additional type safety by ensuring that `ProducerId` and `ConsumerId` are
- * mutually unassignable without a cast. Since several `Map`s are keyed by these IDs, this prevents
- * `ConsumerId`s from being inadvertently used to look up `Producer`s or vice versa.
- */
-declare type ConsumerId = number & {
-    __consumer: true;
-};
-
 declare const CONTAINERS = "c";
 
 /**
@@ -1918,6 +1812,39 @@ export declare function createComponent<C>(component: Type<C>, options: {
     projectableNodes?: Node[][];
 }): ComponentRef<C>;
 
+/**
+ * Options passed to the `computed` creation function.
+ *
+ * @developerPreview
+ */
+export declare interface CreateComputedOptions<T> {
+    /**
+     * A comparison function which defines equality for computed values.
+     */
+    equal?: ValueEqualityFn<T>;
+}
+
+/**
+ * Options passed to the `effect` function.
+ *
+ * @developerPreview
+ */
+export declare interface CreateEffectOptions {
+    /**
+     * The `Injector` in which to create the effect.
+     *
+     * If this is not provided, the current injection context will be used instead (via `inject`).
+     */
+    injector?: Injector;
+    /**
+     * Whether the `effect` should require manual cleanup.
+     *
+     * If this is `false` (the default) the effect will automatically register itself to be cleaned up
+     * with the current `DestroyRef`.
+     */
+    manualCleanup?: boolean;
+}
+
 /**
  * Create a new environment injector.
  *
@@ -1974,6 +1901,27 @@ export declare function createPlatform(injector: Injector): PlatformRef;
  */
 export declare function createPlatformFactory(parentPlatformFactory: ((extraProviders?: StaticProvider[]) => PlatformRef) | null, name: string, providers?: StaticProvider[]): (extraProviders?: StaticProvider[]) => PlatformRef;
 
+/**
+ * Options passed to the `signal` creation function.
+ *
+ * @developerPreview
+ */
+export declare interface CreateSignalOptions<T> {
+    /**
+     * A comparison function which defines equality for signal values.
+     */
+    equal?: ValueEqualityFn<T>;
+}
+
+/**
+ * Token used to configure the [Content Security Policy](https://web.dev/strict-csp/) nonce that
+ * Angular will apply when inserting inline styles. If not provided, Angular will look up its value
+ * from the `ngCspNonce` attribute of the application root node.
+ *
+ * @publicApi
+ */
+export declare const CSP_NONCE: InjectionToken<string | null>;
+
 
 /**
  * Expresses a single CSS Selector.
@@ -2209,6 +2157,18 @@ declare const DECLARATION_LCONTAINER = 17;
 
 declare const DECLARATION_VIEW = 15;
 
+/**
+ * Makes `T` read-only at the property level.
+ *
+ * Objects have their properties mapped to `DeepReadonly` types and arrays are converted to
+ * `ReadonlyArray`s of `DeepReadonly` values.
+ *
+ * @developerPreview
+ */
+export declare type DeepReadonly<T> = T extends (infer R)[] ? ReadonlyArray<DeepReadonly<R>> : (T extends Function ? T : (T extends object ? {
+    readonly [P in keyof T]: DeepReadonly<T[P]>;
+} : T));
+
 /**
  * Provide this token to set the default currency code your application uses for
  * CurrencyPipe when there is no currency code passed into it. This is only used by
@@ -2328,6 +2288,18 @@ declare interface DehydratedView {
     segmentHeads?: {
         [index: number]: RNode | null;
     };
+    /**
+     * An instance of a Set that represents nodes disconnected from
+     * the DOM tree at the serialization time, but otherwise present
+     * in the internal data structures.
+     *
+     * The Set is based on the `SerializedView[DISCONNECTED_NODES]` data
+     * and is needed to have constant-time lookups.
+     *
+     * If the value is `null`, it means that there were no disconnected
+     * nodes detected in this view at serialization time.
+     */
+    disconnectedNodes?: Set<number> | null;
 }
 
 declare type DependencyTypeList = (ɵDirectiveType<any> | ɵComponentType<any> | PipeType<any> | Type<any>)[];
@@ -2366,12 +2338,27 @@ export declare function destroyPlatform(): void;
  * The scope of this destruction depends on where `DestroyRef` is injected. If `DestroyRef`
  * is injected in a component or directive, the callbacks run when that component or
  * directive is destroyed. Otherwise the callbacks run when a corresponding injector is destroyed.
+ *
+ * @publicApi
  */
 export declare abstract class DestroyRef {
     /**
-     * Registers a destroy callback in a given lifecycle scope.
+     * Registers a destroy callback in a given lifecycle scope.  Returns a cleanup function that can
+     * be invoked to unregister the callback.
+     *
+     * @usageNotes
+     * ### Example
+     * ```typescript
+     * const destroyRef = inject(DestroyRef);
+     *
+     * // register a destroy callback
+     * const unregisterFn = destroyRef.onDestroy(() => doSomethingOnDestroy());
+     *
+     * // stop the destroy callback from executing if needed
+     * unregisterFn();
+     * ```
      */
-    abstract onDestroy(callback: () => void): void;
+    abstract onDestroy(callback: () => void): () => void;
 }
 
 /**
@@ -2413,13 +2400,19 @@ export declare interface Directive {
      * Enumerates the set of data-bound input properties for a directive
      *
      * Angular automatically updates input properties during change detection.
-     * The `inputs` property defines a set of `directiveProperty` to `bindingProperty`
-     * configuration:
+     * The `inputs` property accepts either strings or object literals that configure the directive
+     * properties that should be exposed as inputs.
      *
-     * - `directiveProperty` specifies the component property where the value is written.
-     * - `bindingProperty` specifies the DOM property where the value is read from.
+     * When an object literal is passed in, the `name` property indicates which property on the
+     * class the input should write to, while the `alias` determines the name under
+     * which the input will be available in template bindings. The `required` property indicates that
+     * the input is required which will trigger a compile-time error if it isn't passed in when the
+     * directive is used.
      *
-     * When `bindingProperty` is not provided, it is assumed to be equal to `directiveProperty`.
+     * When a string is passed into the `inputs` array, it can have a format of `'name'` or
+     * `'name: alias'` where `name` is the property on the class that the directive should write
+     * to, while the `alias` determines the name under which the input will be available in
+     * template bindings. String-based input definitions are assumed to be optional.
      *
      * @usageNotes
      *
@@ -2428,7 +2421,7 @@ export declare interface Directive {
      * ```typescript
      * @Component({
      *   selector: 'bank-account',
-     *   inputs: ['bankName', 'id: account-id'],
+     *   inputs: ['bankName', {name: 'id', alias: 'account-id'}],
      *   template: `
      *     Bank Name: {{bankName}}
      *     Account Id: {{id}}
@@ -2441,18 +2434,22 @@ export declare interface Directive {
      * ```
      *
      */
-    inputs?: string[];
+    inputs?: ({
+        name: string;
+        alias?: string;
+        required?: boolean;
+    } | string)[];
     /**
      * Enumerates the set of event-bound output properties.
      *
      * When an output property emits an event, an event handler attached to that event
      * in the template is invoked.
      *
-     * The `outputs` property defines a set of `directiveProperty` to `bindingProperty`
+     * The `outputs` property defines a set of `directiveProperty` to `alias`
      * configuration:
      *
      * - `directiveProperty` specifies the component property that emits events.
-     * - `bindingProperty` specifies the DOM property the event handler is attached to.
+     * - `alias` specifies the DOM property the event handler is attached to.
      *
      * @usageNotes
      *
@@ -2862,6 +2859,8 @@ declare type DirectiveDefList = (ɵDirectiveDef<any> | ɵComponentDef<any>)[];
  */
 declare type DirectiveDefListOrFactory = (() => DirectiveDefList) | DirectiveDefList;
 
+declare const DISCONNECTED_NODES = "d";
+
 /**
  * @description
  * Hook for manual bootstrapping of the application instead of using `bootstrap` array in @NgModule
@@ -2869,7 +2868,7 @@ declare type DirectiveDefListOrFactory = (() => DirectiveDefList) | DirectiveDef
  *
  * Reference to the current application is provided as a parameter.
  *
- * See ["Bootstrapping"](guide/bootstrapping) and ["Entry components"](guide/entry-components).
+ * See ["Bootstrapping"](guide/bootstrapping).
  *
  * @usageNotes
  * The example below uses `ApplicationRef.bootstrap()` to render the
@@ -2928,59 +2927,32 @@ export declare interface DoCheck {
 }
 
 /**
- * A bidirectional edge in the producer-consumer dependency graph.
+ * Create a global `Effect` for the given reactive function.
+ *
+ * @developerPreview
  */
-declare interface Edge {
-    /**
-     * Weakly held reference to the `Consumer` side of this edge.
-     */
-    readonly consumerRef: WeakRef<Consumer>;
-    /**
-     * Weakly held reference to the `Producer` side of this edge.
-     */
-    readonly producerRef: WeakRef<Producer>;
-    /**
-     * `trackingVersion` of the `Consumer` at which this dependency edge was last observed.
-     *
-     * If this doesn't match the `Consumer`'s current `trackingVersion`, then this dependency record
-     * is stale, and needs to be cleaned up.
-     */
-    atTrackingVersion: number;
-    /**
-     * `valueVersion` of the `Producer` at the time this dependency was last accessed.
-     *
-     * This is used by `consumerPollValueStatus` to determine whether a `Consumer`'s dependencies have
-     * semantically changed.
-     */
-    seenValueVersion: number;
-}
+export declare function effect(effectFn: () => EffectCleanupFn | void, options?: CreateEffectOptions): EffectRef;
 
 /**
- * A global reactive effect, which can be manually scheduled or destroyed.
+ * An effect can, optionally, return a cleanup function. If returned, the cleanup is executed before
+ * the next effect run. The cleanup function makes it possible to "cancel" any work that the
+ * previous effect run might have started.
  *
  * @developerPreview
  */
-export declare interface Effect {
-    /**
-     * Schedule the effect for manual execution, if it's not already.
-     */
-    schedule(): void;
-    /**
-     * Shut down the effect, removing it from any upcoming scheduled executions.
-     */
-    destroy(): void;
-    /**
-     * Direct access to the effect's `Consumer` for advanced use cases.
-     */
-    readonly consumer: Consumer;
-}
+export declare type EffectCleanupFn = () => void;
 
 /**
- * Create a global `Effect` for the given reactive function.
+ * A global reactive effect, which can be manually destroyed.
  *
  * @developerPreview
  */
-export declare function effect(effectFn: () => void): Effect;
+export declare interface EffectRef {
+    /**
+     * Shut down the effect, removing it from any upcoming scheduled executions.
+     */
+    destroy(): void;
+}
 
 /**
  * Keys within serialized view data structure to represent various
@@ -4606,7 +4578,11 @@ export declare interface Input {
     /**
      * The name of the DOM property to which the input property is bound.
      */
-    bindingPropertyName?: string;
+    alias?: string;
+    /**
+     * Whether the input is required for the directive to function.
+     */
+    required?: boolean;
 }
 
 /**
@@ -4664,8 +4640,8 @@ export declare interface InputDecorator {
      *
      * @see [Input and Output properties](guide/inputs-outputs)
      */
-    (bindingPropertyName?: string): any;
-    new (bindingPropertyName?: string): any;
+    (arg?: string | Input): any;
+    new (arg?: string | Input): any;
 }
 
 /**
@@ -5413,6 +5389,17 @@ declare interface LView<T = unknown> extends Array<any> {
      * entries.
      */
     [ON_DESTROY_HOOKS]: Array<() => void> | null;
+    /**
+     * The `Consumer` for this `LView`'s template so that signal reads can be tracked.
+     *
+     * This is initially `null` and gets assigned a consumer after template execution
+     * if any signals were read.
+     */
+    [REACTIVE_TEMPLATE_CONSUMER]: ReactiveLViewConsumer | null;
+    /**
+     * Same as REACTIVE_TEMPLATE_CONSUMER, but for the host bindings of the LView.
+     */
+    [REACTIVE_HOST_BINDING_CONSUMER]: ReactiveLViewConsumer | null;
 }
 
 /** Flags associated with an LView (saved in LView[FLAGS]) */
@@ -5468,6 +5455,22 @@ declare const enum LViewFlags {
  */
 export declare function makeEnvironmentProviders(providers: (Provider | EnvironmentProviders)[]): EnvironmentProviders;
 
+/**
+ * Create a `StateKey<T>` that can be used to store value of type T with `TransferState`.
+ *
+ * Example:
+ *
+ * ```
+ * const COUNTER_KEY = makeStateKey<number>('counter');
+ * let value = 10;
+ *
+ * transferState.set(COUNTER_KEY, value);
+ * ```
+ *
+ * @publicApi
+ */
+export declare function makeStateKey<T = void>(key: string): StateKey<T>;
+
 /**
  * Merge multiple application configurations from left to right.
  *
@@ -5538,6 +5541,8 @@ export declare interface ModuleWithProviders<T> {
 
 declare const MOVED_VIEWS = 9;
 
+declare const MULTIPLIER = "x";
+
 declare type Mutable<T extends {
     [x: string]: any;
 }, K extends string> = {
@@ -5696,28 +5701,7 @@ export declare interface NgModule {
      */
     exports?: Array<Type<any> | any[]>;
     /**
-     * The set of components to compile when this NgModule is defined,
-     * so that they can be dynamically loaded into the view.
-     *
-     * For each component listed here, Angular creates a `ComponentFactory`
-     * and stores it in the `ComponentFactoryResolver`.
-     *
-     * Angular automatically adds components in the module's bootstrap
-     * and route definitions into the `entryComponents` list. Use this
-     * option to add components that are bootstrapped
-     * using one of the imperative techniques, such as `ViewContainerRef.createComponent()`.
-     *
-     * @see [Entry Components](guide/entry-components)
-     * @deprecated
-     * Since 9.0.0. With Ivy, this property is no longer necessary.
-     * (You may need to keep these if building a library that will be consumed by a View Engine
-     * application.)
-     */
-    entryComponents?: Array<Type<any> | any[]>;
-    /**
-     * The set of components that are bootstrapped when
-     * this module is bootstrapped. The components listed here
-     * are automatically added to `entryComponents`.
+     * The set of components that are bootstrapped when this module is bootstrapped.
      */
     bootstrap?: Array<Type<any> | any[]>;
     /**
@@ -5994,6 +5978,8 @@ export declare class NgZone {
  */
 export declare const NO_ERRORS_SCHEMA: SchemaMetadata;
 
+declare const NODES = "n";
+
 declare const NUM_ROOT_NODES = "r";
 
 declare const ON_DESTROY_HOOKS = 22;
@@ -6134,7 +6120,7 @@ export declare interface Output {
     /**
      * The name of the DOM property to which the output property is bound.
      */
-    bindingPropertyName?: string;
+    alias?: string;
 }
 
 /**
@@ -6165,8 +6151,8 @@ export declare interface OutputDecorator {
      * @see [Input and Output properties](guide/inputs-outputs)
      *
      */
-    (bindingPropertyName?: string): any;
-    new (bindingPropertyName?: string): any;
+    (alias?: string): any;
+    new (alias?: string): any;
 }
 
 /**
@@ -6428,74 +6414,6 @@ declare const enum PreOrderHookFlags {
  */
 declare type ProcessProvidersFunction = (providers: Provider[]) => Provider[];
 
-/**
- * Represents a value that can be read reactively, and can notify readers (`Consumer`s)
- * when it changes.
- *
- * Producers maintain a weak reference to any `Consumer`s which may depend on the
- * producer's value.
- *
- * Implementers of `Producer` expose a monotonic `valueVersion` counter, and are responsible
- * for incrementing this version when their value semantically changes. Some Producers may
- * produce this value lazily and thus at times need to be polled for potential updates to
- * their value (and by extension their `valueVersion`). This is accomplished via the
- * `checkForChangedValue` method for Producers, which should perform whatever calculations
- * are necessary to ensure `valueVersion` is up to date.
- *
- * `Producer`s support two operations:
- *   * `producerNotifyConsumers`
- *   * `producerAccessed`
- */
-declare interface Producer {
-    /**
-     * Numeric identifier of this `Producer`.
-     *
-     * May also be used to satisfy the interface for `Consumer`.
-     */
-    readonly id: ProducerId;
-    /**
-     * A `WeakRef` to this `Producer` instance.
-     *
-     * An implementer provides this as a cached value to avoid the need to instantiate
-     * multiple `WeakRef` instances for the same `Producer`.
-     *
-     * May also be used to satisfy the interface for `Consumer`.
-     */
-    readonly ref: WeakRef<Producer>;
-    /**
-     * A map of dependency `Edge`s to `Consumer`s, keyed by the `ConsumerId`.
-     *
-     * Used when the produced value changes to notify interested `Consumer`s.
-     */
-    readonly consumers: Map<ConsumerId, Edge>;
-    /**
-     * Monotonically increasing counter which increases when the value of this `Producer`
-     * semantically changes.
-     */
-    readonly valueVersion: number;
-    /**
-     * Ensure that `valueVersion` is up to date for the `Producer`'s value.
-     *
-     * Some `Producer`s may produce values lazily, and thus require polling before their
-     * `valueVersion` can be compared with the version captured during a previous read.
-     */
-    checkForChangedValue(): void;
-}
-
-/**
- * Identifier for a `Producer`, which is a branded `number`.
- *
- * Note that `ProducerId` and `ConsumerId` are assigned from the same sequence, so the same `number`
- * will never be used for both.
- *
- * Branding provides additional type safety by ensuring that `ProducerId` and `ConsumerId` are
- * mutually unassignable without a cast. Since several `Map`s are keyed by these IDs, this prevents
- * `ProducerId`s from being inadvertently used to look up `Consumer`s or vice versa.
- */
-declare type ProducerId = number & {
-    __producer: true;
-};
-
 /**
  * List of slots for a projection. A slot can be either based on a parsed CSS selector
  * which will be used to determine nodes which are projected into that slot.
@@ -6894,7 +6812,7 @@ declare class R3Injector extends EnvironmentInjector {
      * hook was found.
      */
     destroy(): void;
-    onDestroy(callback: () => void): void;
+    onDestroy(callback: () => void): () => void;
     runInContext<ReturnT>(fn: () => ReturnT): ReturnT;
     get<T>(token: ProviderToken<T>, notFoundValue?: any, flags?: InjectFlags | InjectOptions): T;
     toString(): string;
@@ -6905,6 +6823,7 @@ declare class R3Injector extends EnvironmentInjector {
     private processProvider;
     private hydrate;
     private injectableDefInScope;
+    private removeOnDestroy;
 }
 
 declare interface RComment extends RNode {
@@ -6921,6 +6840,112 @@ declare interface RDomTokenList {
     remove(token: string): void;
 }
 
+declare const REACTIVE_HOST_BINDING_CONSUMER = 25;
+
+declare const REACTIVE_TEMPLATE_CONSUMER = 24;
+
+declare class ReactiveLViewConsumer extends ReactiveNode {
+    private _lView;
+    set lView(lView: LView);
+    protected onConsumerDependencyMayHaveChanged(): void;
+    protected onProducerUpdateValueVersion(): void;
+    get hasReadASignal(): boolean;
+    runInContext(fn: HostBindingsFunction<unknown> | ComponentTemplate<unknown>, rf: ɵRenderFlags, ctx: unknown): void;
+    destroy(): void;
+}
+
+/**
+ * A node in the reactive graph.
+ *
+ * Nodes can be producers of reactive values, consumers of other reactive values, or both.
+ *
+ * Producers are nodes that produce values, and can be depended upon by consumer nodes.
+ *
+ * Producers expose a monotonic `valueVersion` counter, and are responsible for incrementing this
+ * version when their value semantically changes. Some producers may produce their values lazily and
+ * thus at times need to be polled for potential updates to their value (and by extension their
+ * `valueVersion`). This is accomplished via the `onProducerUpdateValueVersion` method for
+ * implemented by producers, which should perform whatever calculations are necessary to ensure
+ * `valueVersion` is up to date.
+ *
+ * Consumers are nodes that depend on the values of producers and are notified when those values
+ * might have changed.
+ *
+ * Consumers do not wrap the reads they consume themselves, but rather can be set as the active
+ * reader via `setActiveConsumer`. Reads of producers that happen while a consumer is active will
+ * result in those producers being added as dependencies of that consumer node.
+ *
+ * The set of dependencies of a consumer is dynamic. Implementers expose a monotonically increasing
+ * `trackingVersion` counter, which increments whenever the consumer is about to re-run any reactive
+ * reads it needs and establish a new set of dependencies as a result.
+ *
+ * Producers store the last `trackingVersion` they've seen from `Consumer`s which have read them.
+ * This allows a producer to identify whether its record of the dependency is current or stale, by
+ * comparing the consumer's `trackingVersion` to the version at which the dependency was
+ * last observed.
+ */
+declare abstract class ReactiveNode {
+    private readonly id;
+    /**
+     * A cached weak reference to this node, which will be used in `ReactiveEdge`s.
+     */
+    private readonly ref;
+    /**
+     * Edges to producers on which this node depends (in its consumer capacity).
+     */
+    private readonly producers;
+    /**
+     * Edges to consumers on which this node depends (in its producer capacity).
+     */
+    private readonly consumers;
+    /**
+     * Monotonically increasing counter representing a version of this `Consumer`'s
+     * dependencies.
+     */
+    protected trackingVersion: number;
+    /**
+     * Monotonically increasing counter which increases when the value of this `Producer`
+     * semantically changes.
+     */
+    protected valueVersion: number;
+    /**
+     * Called for consumers whenever one of their dependencies notifies that it might have a new
+     * value.
+     */
+    protected abstract onConsumerDependencyMayHaveChanged(): void;
+    /**
+     * Called for producers when a dependent consumer is checking if the producer's value has actually
+     * changed.
+     */
+    protected abstract onProducerUpdateValueVersion(): void;
+    /**
+     * Polls dependencies of a consumer to determine if they have actually changed.
+     *
+     * If this returns `false`, then even though the consumer may have previously been notified of a
+     * change, the values of its dependencies have not actually changed and the consumer should not
+     * rerun any reactions.
+     */
+    protected consumerPollProducersForChange(): boolean;
+    /**
+     * Notify all consumers of this producer that its value may have changed.
+     */
+    protected producerMayHaveChanged(): void;
+    /**
+     * Mark that this producer node has been accessed in the current reactive context.
+     */
+    protected producerAccessed(): void;
+    /**
+     * Whether this consumer currently has any producers registered.
+     */
+    protected get hasProducers(): boolean;
+    /**
+     * Checks if a `Producer` has a current value which is different than the value
+     * last seen at a specific version by a `Consumer` which recorded a dependency on
+     * this `Producer`.
+     */
+    private producerPollStatus;
+}
+
 /**
  * Creates an object that allows to retrieve component metadata.
  *
@@ -7741,6 +7766,12 @@ declare const enum RuntimeErrorCode {
     ASYNC_INITIALIZERS_STILL_RUNNING = 405,
     APPLICATION_REF_ALREADY_DESTROYED = 406,
     RENDERER_NOT_FOUND = 407,
+    HYDRATION_NODE_MISMATCH = 500,
+    HYDRATION_MISSING_SIBLINGS = 501,
+    HYDRATION_MISSING_NODE = 502,
+    UNSUPPORTED_PROJECTION_DOM_NODES = 503,
+    INVALID_SKIP_HYDRATION_HOST = 504,
+    HYDRATION_I18N_NOT_YET_SUPPORTED = 518,
     INVALID_I18N_STRUCTURE = 700,
     MISSING_LOCALE_DATA = 701,
     IMPORT_PROVIDERS_FROM_STANDALONE = 800,
@@ -7886,6 +7917,12 @@ declare interface SerializedContainerView extends SerializedView {
      * and identify segments that belong to different views.
      */
     [NUM_ROOT_NODES]: number;
+    /**
+     * Number of times this view is repeated.
+     * This is used to avoid serializing and sending the same hydration
+     * information about similar views (for example, produced by *ngFor).
+     */
+    [MULTIPLIER]?: number;
 }
 
 /**
@@ -7923,28 +7960,22 @@ declare interface SerializedView {
      * of serialized information about views within this container.
      */
     [CONTAINERS]?: Record<number, SerializedContainerView[]>;
-}
-
-/**
- * A `Signal` with a value that can be mutated via a setter interface.
- *
- * @developerPreview
- */
-export declare interface SettableSignal<T> extends Signal<T> {
     /**
-     * Directly set the signal to a new value, and notify any dependents.
-     */
-    set(value: T): void;
-    /**
-     * Update the value of the signal based on its current value, and
-     * notify any dependents.
+     * Serialized information about nodes in a template.
+     * Key-value pairs where a key is an index of the corresponding
+     * DOM node in an LView and the value is a path that describes
+     * the location of this node (as a set of navigation instructions).
      */
-    update(updateFn: (value: T) => T): void;
+    [NODES]?: Record<number, string>;
     /**
-     * Update the current value by mutating it in-place, and
-     * notify any dependents.
+     * A list of ids which represents a set of nodes disconnected
+     * from the DOM tree at the serialization time, but otherwise
+     * present in the internal data structures.
+     *
+     * This information is used to avoid triggering the hydration
+     * logic for such nodes and instead use a regular "creation mode".
      */
-    mutate(mutatorFn: (value: T) => void): void;
+    [DISCONNECTED_NODES]?: number[];
 }
 
 /**
@@ -7970,8 +8001,8 @@ declare const SIGNAL: unique symbol;
  *
  * @developerPreview
  */
-export declare type Signal<T> = (() => T) & {
-    [SIGNAL]: true;
+export declare type Signal<T> = (() => DeepReadonly<T>) & {
+    [SIGNAL]: unknown;
 };
 
 /**
@@ -7979,7 +8010,7 @@ export declare type Signal<T> = (() => T) & {
  *
  * @developerPreview
  */
-export declare function signal<T>(initialValue: T, equal?: ValueEqualityFn<T>): SettableSignal<T>;
+export declare function signal<T>(initialValue: T, options?: CreateSignalOptions<T>): WritableSignal<T>;
 
 
 /**
@@ -8060,6 +8091,25 @@ export declare interface SkipSelfDecorator {
     new (): SkipSelf;
 }
 
+/**
+ * A type-safe key to use with `TransferState`.
+ *
+ * Example:
+ *
+ * ```
+ * const COUNTER_KEY = makeStateKey<number>('counter');
+ * let value = 10;
+ *
+ * transferState.set(COUNTER_KEY, value);
+ * ```
+ *
+ * @publicApi
+ */
+export declare type StateKey<T> = string & {
+    __not_a_string: never;
+    __value_type?: T;
+};
+
 /**
  * Configures the `Injector` to return an instance of `useClass` for a token.
  * @see ["Dependency Injection Guide"](guide/dependency-injection).
@@ -9158,6 +9208,55 @@ export declare interface TrackByFunction<T> {
     <U extends T>(index: number, item: T & U): any;
 }
 
+/**
+ * A key value store that is transferred from the application on the server side to the application
+ * on the client side.
+ *
+ * The `TransferState` is available as an injectable token.
+ * On the client, just inject this token using DI and use it, it will be lazily initialized.
+ * On the server it's already included if `renderApplication` function is used. Otherwise, import
+ * the `ServerTransferStateModule` module to make the `TransferState` available.
+ *
+ * The values in the store are serialized/deserialized using JSON.stringify/JSON.parse. So only
+ * boolean, number, string, null and non-class objects will be serialized and deserialized in a
+ * non-lossy manner.
+ *
+ * @publicApi
+ */
+export declare class TransferState {
+    /** @nocollapse */
+    static ɵprov: unknown;
+    private onSerializeCallbacks;
+    /**
+     * Get the value corresponding to a key. Return `defaultValue` if key is not found.
+     */
+    get<T>(key: StateKey<T>, defaultValue: T): T;
+    /**
+     * Set the value corresponding to a key.
+     */
+    set<T>(key: StateKey<T>, value: T): void;
+    /**
+     * Remove a key from the store.
+     */
+    remove<T>(key: StateKey<T>): void;
+    /**
+     * Test whether a key exists in the store.
+     */
+    hasKey<T>(key: StateKey<T>): boolean;
+    /**
+     * Indicates whether the state is empty.
+     */
+    get isEmpty(): boolean;
+    /**
+     * Register a callback to provide the value for a key when `toJson` is called.
+     */
+    onSerialize<T>(key: StateKey<T>, callback: () => T): void;
+    /**
+     * Serialize the current state of the store to JSON.
+     */
+    toJson(): string;
+}
+
 /**
  * Use this token at bootstrap to provide the content of your translation file (`xtb`,
  * `xlf` or `xlf2`) when you want to translate your application in another language.
@@ -10141,9 +10240,6 @@ declare enum ViewEncapsulation_2 {
     ShadowDom = 3
 }
 
-declare interface viewEngine_ChangeDetectorRef_interface extends ChangeDetectorRef {
-}
-
 /**
  * Definition of what a view queries function should look like.
  */
@@ -10190,12 +10286,32 @@ declare interface WeakRef<T extends object> {
     deref(): T | undefined;
 }
 
-declare const WeakRef: WeakRefCtor;
-
 declare interface WeakRefCtor {
     new <T extends object>(value: T): WeakRef<T>;
 }
 
+/**
+ * A `Signal` with a value that can be mutated via a setter interface.
+ *
+ * @developerPreview
+ */
+export declare interface WritableSignal<T> extends Signal<T> {
+    /**
+     * Directly set the signal to a new value, and notify any dependents.
+     */
+    set(value: T): void;
+    /**
+     * Update the value of the signal based on its current value, and
+     * notify any dependents.
+     */
+    update(updateFn: (value: T) => T): void;
+    /**
+     * Update the current value by mutating it in-place, and
+     * notify any dependents.
+     */
+    mutate(mutatorFn: (value: T) => void): void;
+}
+
 /**
  * Sanitizes the given unsafe, untrusted HTML fragment, and returns HTML text that is safe to add to
  * the DOM in a browser environment.
@@ -10814,13 +10930,6 @@ export declare function ɵflushModuleScopingQueueAsMuchAsPossible(): void;
  */
 export declare function ɵformatRuntimeError<T extends number = RuntimeErrorCode>(code: T, message: null | false | string): string;
 
-/**
- * The following getter methods retrieve the definition from the type. Currently the retrieval
- * honors inheritance, but in the future we may change the rule to require that definitions are
- * explicit. This would require some sort of migration strategy.
- */
-export declare function ɵgetComponentDef<T>(type: any): ɵComponentDef<T> | null;
-
 /**
  * Retrieves directive instances associated with a given DOM node. Does not include
  * component instances.
@@ -10927,6 +11036,31 @@ export declare function ɵgetUnknownPropertyStrictMode(): boolean;
 
 export declare const ɵglobal: any;
 
+/**
+ * *Internal* service that keeps track of pending tasks happening in the system
+ * during the initial rendering. No tasks are tracked after an initial
+ * rendering.
+ *
+ * This information is needed to make sure that the serialization on the server
+ * is delayed until all tasks in the queue (such as an initial navigation or a
+ * pending HTTP request) are completed.
+ */
+export declare class ɵInitialRenderPendingTasks implements OnDestroy {
+    private taskId;
+    private collection;
+    private ngZone;
+    private resolve;
+    private promise;
+    get whenAllTasksComplete(): Promise<void>;
+    completed: boolean;
+    constructor();
+    add(): number;
+    remove(taskId: number): void;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ɵInitialRenderPendingTasks, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ɵInitialRenderPendingTasks>;
+}
+
 /** Returns a ChangeDetectorRef (a.k.a. a ViewRef) */
 export declare function ɵinjectChangeDetectorRef(flags: InjectFlags): ChangeDetectorRef;
 
@@ -11096,22 +11230,6 @@ export declare function ɵmakeDecorator<T>(name: string, props?: (...args: any[]
     (...args: any[]): (cls: any) => any;
 };
 
-/**
- * Create a `StateKey<T>` that can be used to store value of type T with `TransferState`.
- *
- * Example:
- *
- * ```
- * const COUNTER_KEY = makeStateKey<number>('counter');
- * let value = 10;
- *
- * transferState.set(COUNTER_KEY, value);
- * ```
- *
- * @publicApi
- */
-export declare function ɵmakeStateKey<T = void>(key: string): ɵStateKey<T>;
-
 
 export declare const ɵNG_COMP_DEF: string;
 
@@ -11470,6 +11588,7 @@ export declare class ɵRender3ComponentRef<T> extends ComponentRef<T> {
     hostView: ɵViewRef<T>;
     changeDetectorRef: ChangeDetectorRef;
     componentType: Type<T>;
+    private previousInputValues;
     constructor(componentType: Type<T>, instance: T, location: ElementRef, _rootLView: LView, _tNode: TElementNode | TContainerNode | TElementContainerNode);
     setInput(name: string, value: unknown): void;
     get injector(): Injector;
@@ -11620,6 +11739,8 @@ export declare interface ɵSafeValue {
  */
 export declare function ɵsetAllowDuplicateNgModuleIdsForTest(allowDuplicates: boolean): void;
 
+export declare function ɵsetAlternateWeakRefImpl(impl: WeakRefCtor): void;
+
 /**
  * Adds decorator, constructor, and property metadata to a given type via static metadata fields
  * on the type.
@@ -11669,25 +11790,6 @@ export declare function ɵsetUnknownElementStrictMode(shouldThrow: boolean): voi
  */
 export declare function ɵsetUnknownPropertyStrictMode(shouldThrow: boolean): void;
 
-/**
- * A type-safe key to use with `TransferState`.
- *
- * Example:
- *
- * ```
- * const COUNTER_KEY = makeStateKey<number>('counter');
- * let value = 10;
- *
- * transferState.set(COUNTER_KEY, value);
- * ```
- *
- * @publicApi
- */
-export declare type ɵStateKey<T> = string & {
-    __not_a_string: never;
-    __value_type?: T;
-};
-
 /** Store a value in the `data` at a given `index`. */
 export declare function ɵstore<T>(tView: TView, lView: LView, index: number, value: T): void;
 
@@ -11710,55 +11812,6 @@ export declare const ɵTESTABILITY: InjectionToken<Testability>;
  */
 export declare const ɵTESTABILITY_GETTER: InjectionToken<GetTestability>;
 
-/**
- * A key value store that is transferred from the application on the server side to the application
- * on the client side.
- *
- * The `TransferState` is available as an injectable token.
- * On the client, just inject this token using DI and use it, it will be lazily initialized.
- * On the server it's already included if `renderApplication` function is used. Otherwise, import
- * the `ServerTransferStateModule` module to make the `TransferState` available.
- *
- * The values in the store are serialized/deserialized using JSON.stringify/JSON.parse. So only
- * boolean, number, string, null and non-class objects will be serialized and deserialized in a
- * non-lossy manner.
- *
- * @publicApi
- */
-export declare class ɵTransferState {
-    /** @nocollapse */
-    static ɵprov: unknown;
-    private onSerializeCallbacks;
-    /**
-     * Get the value corresponding to a key. Return `defaultValue` if key is not found.
-     */
-    get<T>(key: ɵStateKey<T>, defaultValue: T): T;
-    /**
-     * Set the value corresponding to a key.
-     */
-    set<T>(key: ɵStateKey<T>, value: T): void;
-    /**
-     * Remove a key from the store.
-     */
-    remove<T>(key: ɵStateKey<T>): void;
-    /**
-     * Test whether a key exists in the store.
-     */
-    hasKey<T>(key: ɵStateKey<T>): boolean;
-    /**
-     * Indicates whether the state is empty.
-     */
-    get isEmpty(): boolean;
-    /**
-     * Register a callback to provide the value for a key when `toJson` is called.
-     */
-    onSerialize<T>(key: ɵStateKey<T>, callback: () => T): void;
-    /**
-     * Serialize the current state of the store to JSON.
-     */
-    toJson(): string;
-}
-
 /**
  * Compute the pair of transitive scopes (compilation scope and exported scope) for a given type
  * (either a NgModule or a standalone component / directive / pipe).
@@ -11776,7 +11829,7 @@ export declare function ɵunwrapSafeValue(value: ɵSafeValue): string;
 
 export declare function ɵunwrapSafeValue<T>(value: T): T;
 
-export declare class ɵViewRef<T> implements EmbeddedViewRef<T>, InternalViewRef, viewEngine_ChangeDetectorRef_interface {
+export declare class ɵViewRef<T> implements EmbeddedViewRef<T>, InternalViewRef, ChangeDetectorRefInterface {
     /**
      * This represents the `LView` associated with the point where `ChangeDetectorRef` was
      * requested.
@@ -12647,7 +12700,10 @@ export declare function ɵɵclassProp(className: string, value: boolean | undefi
  * @publicApi
  */
 export declare type ɵɵComponentDeclaration<T, Selector extends String, ExportAs extends string[], InputMap extends {
-    [key: string]: string;
+    [key: string]: string | {
+        alias: string | null;
+        required: boolean;
+    };
 }, OutputMap extends {
     [key: string]: string;
 }, QueryFields extends string[], NgContentSelectors extends string[], IsStandalone extends boolean = false, HostDirectives = never> = unknown;
@@ -12822,7 +12878,10 @@ export declare function ɵɵdefinePipe<T>(pipeDef: {
  * @publicApi
  */
 export declare type ɵɵDirectiveDeclaration<T, Selector extends string, ExportAs extends string[], InputMap extends {
-    [key: string]: string;
+    [key: string]: string | {
+        alias: string | null;
+        required: boolean;
+    };
 }, OutputMap extends {
     [key: string]: string;
 }, QueryFields extends string[], NgContentSelectors extends never = never, IsStandalone extends boolean = false, HostDirectives = never> = unknown;