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

package/index.d.ts

@@ -1,5 +1,5 @@
 /**
- * @license Angular v16.0.0-next.5
+ * @license Angular v16.0.0-next.7
  * (c) 2010-2022 Google LLC. https://angular.io/
  * License: MIT
  */
@@ -513,6 +513,13 @@ export declare class ApplicationRef {
      */
     detachView(viewRef: ViewRef): void;
     private _loadComponent;
+    /**
+     * Registers a listener to be called when an instance is destroyed.
+     *
+     * @param callback A callback function to add as a listener.
+     * @returns A function which unregisters a listener.
+     */
+    onDestroy(callback: () => void): VoidFunction;
     /**
      * Destroys an Angular application represented by this `ApplicationRef`. Calling this function
      * will destroy the associated environment injectors as well as all the bootstrapped components
@@ -786,9 +793,9 @@ export declare abstract class ChangeDetectorRef {
 declare interface ChangeDetectorRefInterface extends ChangeDetectorRef {
 }
 
-declare const CHILD_HEAD = 13;
+declare const CHILD_HEAD = 12;
 
-declare const CHILD_TAIL = 14;
+declare const CHILD_TAIL = 13;
 
 /**
  * Configures the `Injector` to return an instance of `useClass` for a token.
@@ -1467,7 +1474,7 @@ export declare abstract class ComponentRef<C> {
      */
     abstract get instance(): C;
     /**
-     * The [host view](guide/glossary#view-tree) defined by the template
+     * The [host view](guide/glossary#view-hierarchy) defined by the template
      * for this component instance.
      */
     abstract get hostView(): ViewRef;
@@ -1843,6 +1850,13 @@ export declare interface CreateEffectOptions {
      * with the current `DestroyRef`.
      */
     manualCleanup?: boolean;
+    /**
+     * Whether the `effect` should allow writing to signals.
+     *
+     * Using effects to synchronize data by writing to signals can lead to confusing and potentially
+     * incorrect behavior, and should be enabled only when necessary.
+     */
+    allowSignalWrites?: boolean;
 }
 
 /**
@@ -2151,23 +2165,11 @@ export declare class DebugNode {
     get providerTokens(): any[];
 }
 
-declare const DECLARATION_COMPONENT_VIEW = 16;
-
-declare const DECLARATION_LCONTAINER = 17;
+declare const DECLARATION_COMPONENT_VIEW = 15;
 
-declare const DECLARATION_VIEW = 15;
+declare const DECLARATION_LCONTAINER = 16;
 
-/**
- * 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));
+declare const DECLARATION_VIEW = 14;
 
 /**
  * Provide this token to set the default currency code your application uses for
@@ -2942,6 +2944,19 @@ export declare function effect(effectFn: () => EffectCleanupFn | void, options?:
  */
 export declare type EffectCleanupFn = () => void;
 
+/**
+ * Tracks all effects registered within a given application and runs them via `flush`.
+ */
+declare class EffectManager {
+    private all;
+    private queue;
+    create(effectFn: () => void, destroyRef: DestroyRef | null, allowSignalWrites: boolean): EffectRef;
+    flush(): void;
+    get isQueueEmpty(): boolean;
+    /** @nocollapse */
+    static ɵprov: unknown;
+}
+
 /**
  * A global reactive effect, which can be manually destroyed.
  *
@@ -3009,11 +3024,11 @@ export declare class ElementRef<T = any> {
     constructor(nativeElement: T);
 }
 
-declare const EMBEDDED_VIEW_INJECTOR = 21;
+declare const EMBEDDED_VIEW_INJECTOR = 20;
 
 /**
  * Represents an Angular [view](guide/glossary#view) in a view container.
- * An [embedded view](guide/glossary#view-tree) can be referenced from a component
+ * An [embedded view](guide/glossary#view-hierarchy) can be referenced from a component
  * other than the hosting component whose template defines it, or it can be defined
  * independently by a `TemplateRef`.
  *
@@ -3091,6 +3106,8 @@ export declare abstract class EmbeddedViewRef<C> extends ViewRef {
  */
 export declare function enableProdMode(): void;
 
+declare const ENVIRONMENT = 10;
+
 /**
  * A multi-provider token for initialization functions that will run upon construction of an
  * environment injector.
@@ -3818,7 +3835,7 @@ export declare interface HostListenerDecorator {
     new (eventName: string, args?: string[]): any;
 }
 
-declare const HYDRATION = 23;
+declare const HYDRATION = 22;
 
 declare namespace i0 {
     export {
@@ -4041,7 +4058,7 @@ declare const enum IcuType {
     plural = 1
 }
 
-declare const ID = 20;
+declare const ID = 19;
 
 /**
  * Providers that were imported from NgModules via the `importProvidersFrom` function.
@@ -4789,12 +4806,9 @@ export declare interface IterableDifferFactory {
  * @publicApi
  */
 export declare class IterableDiffers {
+    private factories;
     /** @nocollapse */
     static ɵprov: unknown;
-    /**
-     * @deprecated v4.0.0 - Should be private
-     */
-    factories: IterableDifferFactory[];
     constructor(factories: IterableDifferFactory[]);
     static create(factories: IterableDifferFactory[], parent?: IterableDiffers): IterableDiffers;
     /**
@@ -5238,12 +5252,12 @@ declare interface LView<T = unknown> extends Array<any> {
     [CONTEXT]: T;
     /** An optional Module Injector to be used as fall back after Element Injectors are consulted. */
     readonly [INJECTOR_2]: Injector | null;
-    /** Factory to be used for creating Renderer. */
-    [RENDERER_FACTORY]: RendererFactory;
+    /**
+     * Contextual data that is shared across multiple instances of `LView` in the same application.
+     */
+    [ENVIRONMENT]: LViewEnvironment;
     /** Renderer to be used for this view. */
     [RENDERER]: Renderer;
-    /** An optional custom sanitizer. */
-    [SANITIZER]: Sanitizer | null;
     /**
      * Reference to the first LView or LContainer beneath this LView in
      * the hierarchy.
@@ -5402,6 +5416,18 @@ declare interface LView<T = unknown> extends Array<any> {
     [REACTIVE_HOST_BINDING_CONSUMER]: ReactiveLViewConsumer | null;
 }
 
+/**
+ * Contextual data that is shared across multiple instances of `LView` in the same application.
+ */
+declare interface LViewEnvironment {
+    /** Factory to be used for creating Renderer. */
+    rendererFactory: RendererFactory;
+    /** An optional custom sanitizer. */
+    sanitizer: Sanitizer | null;
+    /** Container for reactivity system `effect`s. */
+    effectManager: EffectManager | null;
+}
+
 /** Flags associated with an LView (saved in LView[FLAGS]) */
 declare const enum LViewFlags {
     /** The state of the init phase on the first 2 bits */
@@ -5731,7 +5757,6 @@ export declare interface NgModule {
 
 /**
  * @Annotation
- * @publicApi
  */
 export declare const NgModule: NgModuleDecorator;
 
@@ -5967,6 +5992,57 @@ export declare class NgZone {
     runOutsideAngular<T>(fn: (...args: any[]) => T): T;
 }
 
+/**
+ * Used to configure event and run coalescing with `provideZoneChangeDetection`.
+ *
+ * @publicApi
+ *
+ * @see provideZoneChangeDetection
+ */
+export declare interface NgZoneOptions {
+    /**
+     * Optionally specify coalescing event change detections or not.
+     * Consider the following case.
+     *
+     * ```
+     * <div (click)="doSomething()">
+     *   <button (click)="doSomethingElse()"></button>
+     * </div>
+     * ```
+     *
+     * When button is clicked, because of the event bubbling, both
+     * event handlers will be called and 2 change detections will be
+     * triggered. We can coalesce such kind of events to only trigger
+     * change detection only once.
+     *
+     * By default, this option will be false. So the events will not be
+     * coalesced and the change detection will be triggered multiple times.
+     * And if this option be set to true, the change detection will be
+     * triggered async by scheduling a animation frame. So in the case above,
+     * the change detection will only be triggered once.
+     */
+    eventCoalescing?: boolean;
+    /**
+     * Optionally specify if `NgZone#run()` method invocations should be coalesced
+     * into a single change detection.
+     *
+     * Consider the following case.
+     * ```
+     * for (let i = 0; i < 10; i ++) {
+     *   ngZone.run(() => {
+     *     // do something
+     *   });
+     * }
+     * ```
+     *
+     * This case triggers the change detection multiple times.
+     * With ngZoneRunCoalescing options, all change detections in an event loop trigger only once.
+     * In addition, the change detection executes in requestAnimation.
+     *
+     */
+    runCoalescing?: boolean;
+}
+
 /**
  * Defines a schema that allows any property on any element.
  *
@@ -5982,7 +6058,7 @@ declare const NODES = "n";
 
 declare const NUM_ROOT_NODES = "r";
 
-declare const ON_DESTROY_HOOKS = 22;
+declare const ON_DESTROY_HOOKS = 21;
 
 /**
  * @description
@@ -6391,7 +6467,7 @@ export declare interface Predicate<T> {
     (value: T): boolean;
 }
 
-declare const PREORDER_HOOK_FLAGS = 18;
+declare const PREORDER_HOOK_FLAGS = 17;
 
 /** More flags associated with an LView (saved in LView[PREORDER_HOOK_FLAGS]) */
 declare const enum PreOrderHookFlags {
@@ -6467,6 +6543,28 @@ export declare type Provider = TypeProvider | ValueProvider | ClassProvider | Co
  */
 export declare type ProviderToken<T> = Type<T> | AbstractType<T> | InjectionToken<T>;
 
+/**
+ * Provides `NgZone`-based change detection for the application bootstrapped using
+ * `bootstrapApplication`.
+ *
+ * `NgZone` is already provided in applications by default. This provider allows you to configure
+ * options like `eventCoalescing` in the `NgZone`.
+ * This provider is not available for `platformBrowser().bootstrapModule`, which uses
+ * `BootstrapOptions` instead.
+ *
+ * @usageNotes
+ * ```typescript=
+ * bootstrapApplication(MyApp, {providers: [
+ *   provideZoneChangeDetection({eventCoalescing: true}),
+ * ]});
+ * ```
+ *
+ * @publicApi
+ * @see bootstrapApplication
+ * @see NgZoneOptions
+ */
+export declare function provideZoneChangeDetection(options?: NgZoneOptions): EnvironmentProviders;
+
 /**
  * Testability API.
  * `declare` keyword causes tsickle to generate externs, so these methods are
@@ -6479,7 +6577,7 @@ declare interface PublicTestability {
     findProviders(using: any, provider: string, exactMatch: boolean): any[];
 }
 
-declare const QUERIES = 19;
+declare const QUERIES = 18;
 
 /**
  * Type of the Query metadata.
@@ -6595,7 +6693,8 @@ export declare class QueryList<T> implements Iterable<T> {
      * See
      * [Array.filter](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/filter)
      */
-    filter(fn: (item: T, index: number, array: T[]) => boolean): T[];
+    filter<S extends T>(predicate: (value: T, index: number, array: readonly T[]) => value is S): S[];
+    filter(predicate: (value: T, index: number, array: readonly T[]) => unknown): T[];
     /**
      * See
      * [Array.find](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/find)
@@ -6840,11 +6939,12 @@ declare interface RDomTokenList {
     remove(token: string): void;
 }
 
-declare const REACTIVE_HOST_BINDING_CONSUMER = 25;
+declare const REACTIVE_HOST_BINDING_CONSUMER = 24;
 
-declare const REACTIVE_TEMPLATE_CONSUMER = 24;
+declare const REACTIVE_TEMPLATE_CONSUMER = 23;
 
 declare class ReactiveLViewConsumer extends ReactiveNode {
+    protected consumerAllowSignalWrites: boolean;
     private _lView;
     set lView(lView: LView);
     protected onConsumerDependencyMayHaveChanged(): void;
@@ -6908,6 +7008,10 @@ declare abstract class ReactiveNode {
      * semantically changes.
      */
     protected valueVersion: number;
+    /**
+     * Whether signal writes should be allowed while this `ReactiveNode` is the current consumer.
+     */
+    protected abstract readonly consumerAllowSignalWrites: boolean;
     /**
      * Called for consumers whenever one of their dependencies notifies that it might have a new
      * value.
@@ -6938,6 +7042,11 @@ declare abstract class ReactiveNode {
      * Whether this consumer currently has any producers registered.
      */
     protected get hasProducers(): boolean;
+    /**
+     * Whether this `ReactiveNode` in its producer capacity is currently allowed to initiate updates,
+     * based on the current consumer context.
+     */
+    protected get producerUpdatesAllowed(): 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
@@ -6987,291 +7096,6 @@ declare abstract class ReactiveNode {
  */
 export declare function reflectComponentType<C>(component: Type<C>): ComponentMirror<C> | null;
 
-/**
- * `Dependency` is used by the framework to extend DI.
- * This is internal to Angular and should not be used directly.
- */
-declare class ReflectiveDependency {
-    key: ReflectiveKey;
-    optional: boolean;
-    visibility: Self | SkipSelf | null;
-    constructor(key: ReflectiveKey, optional: boolean, visibility: Self | SkipSelf | null);
-    static fromKey(key: ReflectiveKey): ReflectiveDependency;
-}
-
-/**
- * A ReflectiveDependency injection container used for instantiating objects and resolving
- * dependencies.
- *
- * An `Injector` is a replacement for a `new` operator, which can automatically resolve the
- * constructor dependencies.
- *
- * In typical use, application code asks for the dependencies in the constructor and they are
- * resolved by the `Injector`.
- *
- * @usageNotes
- * ### Example
- *
- * The following example creates an `Injector` configured to create `Engine` and `Car`.
- *
- * ```typescript
- * @Injectable()
- * class Engine {
- * }
- *
- * @Injectable()
- * class Car {
- *   constructor(public engine:Engine) {}
- * }
- *
- * var injector = ReflectiveInjector.resolveAndCreate([Car, Engine]);
- * var car = injector.get(Car);
- * expect(car instanceof Car).toBe(true);
- * expect(car.engine instanceof Engine).toBe(true);
- * ```
- *
- * Notice, we don't use the `new` operator because we explicitly want to have the `Injector`
- * resolve all of the object's dependencies automatically.
- *
- * TODO: delete in v14.
- *
- * @deprecated from v5 - slow and brings in a lot of code, Use `Injector.create` instead.
- * @publicApi
- */
-export declare abstract class ReflectiveInjector implements Injector {
-    /**
-     * Turns an array of provider definitions into an array of resolved providers.
-     *
-     * A resolution is a process of flattening multiple nested arrays and converting individual
-     * providers into an array of `ResolvedReflectiveProvider`s.
-     *
-     * @usageNotes
-     * ### Example
-     *
-     * ```typescript
-     * @Injectable()
-     * class Engine {
-     * }
-     *
-     * @Injectable()
-     * class Car {
-     *   constructor(public engine:Engine) {}
-     * }
-     *
-     * var providers = ReflectiveInjector.resolve([Car, [[Engine]]]);
-     *
-     * expect(providers.length).toEqual(2);
-     *
-     * expect(providers[0] instanceof ResolvedReflectiveProvider).toBe(true);
-     * expect(providers[0].key.displayName).toBe("Car");
-     * expect(providers[0].dependencies.length).toEqual(1);
-     * expect(providers[0].factory).toBeDefined();
-     *
-     * expect(providers[1].key.displayName).toBe("Engine");
-     * });
-     * ```
-     *
-     */
-    static resolve(providers: Provider[]): ResolvedReflectiveProvider[];
-    /**
-     * Resolves an array of providers and creates an injector from those providers.
-     *
-     * The passed-in providers can be an array of `Type`, `Provider`,
-     * or a recursive array of more providers.
-     *
-     * @usageNotes
-     * ### Example
-     *
-     * ```typescript
-     * @Injectable()
-     * class Engine {
-     * }
-     *
-     * @Injectable()
-     * class Car {
-     *   constructor(public engine:Engine) {}
-     * }
-     *
-     * var injector = ReflectiveInjector.resolveAndCreate([Car, Engine]);
-     * expect(injector.get(Car) instanceof Car).toBe(true);
-     * ```
-     */
-    static resolveAndCreate(providers: Provider[], parent?: Injector): ReflectiveInjector;
-    /**
-     * Creates an injector from previously resolved providers.
-     *
-     * This API is the recommended way to construct injectors in performance-sensitive parts.
-     *
-     * @usageNotes
-     * ### Example
-     *
-     * ```typescript
-     * @Injectable()
-     * class Engine {
-     * }
-     *
-     * @Injectable()
-     * class Car {
-     *   constructor(public engine:Engine) {}
-     * }
-     *
-     * var providers = ReflectiveInjector.resolve([Car, Engine]);
-     * var injector = ReflectiveInjector.fromResolvedProviders(providers);
-     * expect(injector.get(Car) instanceof Car).toBe(true);
-     * ```
-     */
-    static fromResolvedProviders(providers: ResolvedReflectiveProvider[], parent?: Injector): ReflectiveInjector;
-    /**
-     * Parent of this injector.
-     *
-     * <!-- TODO: Add a link to the section of the user guide talking about hierarchical injection.
-     * -->
-     */
-    abstract get parent(): Injector | null;
-    /**
-     * Resolves an array of providers and creates a child injector from those providers.
-     *
-     * <!-- TODO: Add a link to the section of the user guide talking about hierarchical injection.
-     * -->
-     *
-     * The passed-in providers can be an array of `Type`, `Provider`,
-     * or a recursive array of more providers.
-     *
-     * @usageNotes
-     * ### Example
-     *
-     * ```typescript
-     * class ParentProvider {}
-     * class ChildProvider {}
-     *
-     * var parent = ReflectiveInjector.resolveAndCreate([ParentProvider]);
-     * var child = parent.resolveAndCreateChild([ChildProvider]);
-     *
-     * expect(child.get(ParentProvider) instanceof ParentProvider).toBe(true);
-     * expect(child.get(ChildProvider) instanceof ChildProvider).toBe(true);
-     * expect(child.get(ParentProvider)).toBe(parent.get(ParentProvider));
-     * ```
-     */
-    abstract resolveAndCreateChild(providers: Provider[]): ReflectiveInjector;
-    /**
-     * Creates a child injector from previously resolved providers.
-     *
-     * <!-- TODO: Add a link to the section of the user guide talking about hierarchical injection.
-     * -->
-     *
-     * This API is the recommended way to construct injectors in performance-sensitive parts.
-     *
-     * @usageNotes
-     * ### Example
-     *
-     * ```typescript
-     * class ParentProvider {}
-     * class ChildProvider {}
-     *
-     * var parentProviders = ReflectiveInjector.resolve([ParentProvider]);
-     * var childProviders = ReflectiveInjector.resolve([ChildProvider]);
-     *
-     * var parent = ReflectiveInjector.fromResolvedProviders(parentProviders);
-     * var child = parent.createChildFromResolved(childProviders);
-     *
-     * expect(child.get(ParentProvider) instanceof ParentProvider).toBe(true);
-     * expect(child.get(ChildProvider) instanceof ChildProvider).toBe(true);
-     * expect(child.get(ParentProvider)).toBe(parent.get(ParentProvider));
-     * ```
-     */
-    abstract createChildFromResolved(providers: ResolvedReflectiveProvider[]): ReflectiveInjector;
-    /**
-     * Resolves a provider and instantiates an object in the context of the injector.
-     *
-     * The created object does not get cached by the injector.
-     *
-     * @usageNotes
-     * ### Example
-     *
-     * ```typescript
-     * @Injectable()
-     * class Engine {
-     * }
-     *
-     * @Injectable()
-     * class Car {
-     *   constructor(public engine:Engine) {}
-     * }
-     *
-     * var injector = ReflectiveInjector.resolveAndCreate([Engine]);
-     *
-     * var car = injector.resolveAndInstantiate(Car);
-     * expect(car.engine).toBe(injector.get(Engine));
-     * expect(car).not.toBe(injector.resolveAndInstantiate(Car));
-     * ```
-     */
-    abstract resolveAndInstantiate(provider: Provider): any;
-    /**
-     * Instantiates an object using a resolved provider in the context of the injector.
-     *
-     * The created object does not get cached by the injector.
-     *
-     * @usageNotes
-     * ### Example
-     *
-     * ```typescript
-     * @Injectable()
-     * class Engine {
-     * }
-     *
-     * @Injectable()
-     * class Car {
-     *   constructor(public engine:Engine) {}
-     * }
-     *
-     * var injector = ReflectiveInjector.resolveAndCreate([Engine]);
-     * var carProvider = ReflectiveInjector.resolve([Car])[0];
-     * var car = injector.instantiateResolved(carProvider);
-     * expect(car.engine).toBe(injector.get(Engine));
-     * expect(car).not.toBe(injector.instantiateResolved(carProvider));
-     * ```
-     */
-    abstract instantiateResolved(provider: ResolvedReflectiveProvider): any;
-    abstract get(token: any, notFoundValue?: any): any;
-}
-
-
-/**
- * A unique object used for retrieving items from the {@link ReflectiveInjector}.
- *
- * Keys have:
- * - a system-wide unique `id`.
- * - a `token`.
- *
- * `Key` is used internally by {@link ReflectiveInjector} because its system-wide unique `id` allows
- * the
- * injector to store created objects in a more efficient way.
- *
- * `Key` should not be created directly. {@link ReflectiveInjector} creates keys automatically when
- * resolving
- * providers.
- *
- * @deprecated No replacement
- * @publicApi
- */
-export declare class ReflectiveKey {
-    token: Object;
-    id: number;
-    readonly displayName: string;
-    /**
-     * Private
-     */
-    constructor(token: Object, id: number);
-    /**
-     * Retrieves a `Key` for a token.
-     */
-    static get(token: Object): ReflectiveKey;
-    /**
-     * @returns the number of keys registered in the system.
-     */
-    static get numberOfKeys(): number;
-}
-
 /**
  * Subset of API needed for writing attributes, properties, and setting up
  * listeners on Element.
@@ -7504,8 +7328,6 @@ export declare abstract class Renderer2 {
     abstract listen(target: 'window' | 'document' | 'body' | any, eventName: string, callback: (event: any) => boolean | void): () => void;
 }
 
-declare const RENDERER_FACTORY = 10;
-
 declare interface RendererFactory {
     createRenderer(hostElement: RElement | null, rendererType: RendererType2 | null): Renderer;
     begin?(): void;
@@ -7590,64 +7412,6 @@ export declare interface RendererType2 {
     };
 }
 
-/**
- * An internal resolved representation of a factory function created by resolving `Provider`.
- * @publicApi
- */
-export declare class ResolvedReflectiveFactory {
-    /**
-     * Factory function which can return an instance of an object represented by a key.
-     */
-    factory: Function;
-    /**
-     * Arguments (dependencies) to the `factory` function.
-     */
-    dependencies: ReflectiveDependency[];
-    constructor(
-    /**
-     * Factory function which can return an instance of an object represented by a key.
-     */
-    factory: Function, 
-    /**
-     * Arguments (dependencies) to the `factory` function.
-     */
-    dependencies: ReflectiveDependency[]);
-}
-
-/**
- * An internal resolved representation of a `Provider` used by the `Injector`.
- *
- * @usageNotes
- * This is usually created automatically by `Injector.resolveAndCreate`.
- *
- * It can be created manually, as follows:
- *
- * ### Example
- *
- * ```typescript
- * var resolvedProviders = Injector.resolve([{ provide: 'message', useValue: 'Hello' }]);
- * var injector = Injector.fromResolvedProviders(resolvedProviders);
- *
- * expect(injector.get('message')).toEqual('Hello');
- * ```
- *
- * @publicApi
- */
-export declare interface ResolvedReflectiveProvider {
-    /**
-     * A key, usually a `Type<any>`.
-     */
-    key: ReflectiveKey;
-    /**
-     * Factory function which can return an instance of an object represented by a key.
-     */
-    resolvedFactories: ResolvedReflectiveFactory[];
-    /**
-     * Indicates if the provider is a multi-provider or a regular provider.
-     */
-    multiProvider: boolean;
-}
-
 /**
  * Lazily retrieves the reference value from a forwardRef.
  *
@@ -7766,12 +7530,13 @@ 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_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,
+    SIGNAL_WRITE_FROM_ILLEGAL_CONTEXT = 600,
     INVALID_I18N_STRUCTURE = 700,
     MISSING_LOCALE_DATA = 701,
     IMPORT_PROVIDERS_FROM_STANDALONE = 800,
@@ -7788,8 +7553,6 @@ declare const enum RuntimeErrorCode {
     UNSAFE_IFRAME_ATTRS = -910
 }
 
-declare const SANITIZER = 12;
-
 /**
  * Sanitizer is used by the views to sanitize potentially dangerous values.
  *
@@ -8001,7 +7764,7 @@ declare const SIGNAL: unique symbol;
  *
  * @developerPreview
  */
-export declare type Signal<T> = (() => DeepReadonly<T>) & {
+export declare type Signal<T> = (() => T) & {
     [SIGNAL]: unknown;
 };
 
@@ -9773,6 +9536,7 @@ export declare interface TypeDecorator {
      */
     <T extends Type<any>>(type: T): T;
     (target: Object, propertyKey?: string | symbol, parameterIndex?: number): void;
+    (target: unknown, context: unknown): void;
 }
 
 declare type TypeOrFactory<T> = T | (() => T);
@@ -10041,7 +9805,7 @@ export declare interface ViewChildrenDecorator {
  * (created by instantiating a `TemplateRef` with the `createEmbeddedView()` method).
  *
  * A view container instance can contain other view containers,
- * creating a [view hierarchy](guide/glossary#view-tree).
+ * creating a [view hierarchy](guide/glossary#view-hierarchy).
  *
  * @see `ComponentRef`
  * @see `EmbeddedViewRef`
@@ -10268,7 +10032,7 @@ export declare abstract class ViewRef extends ChangeDetectorRef {
      * @param callback A handler function that cleans up developer-defined data
      * associated with a view. Called when the `destroy()` method is invoked.
      */
-    abstract onDestroy(callback: Function): any /** TODO #9100, replace by void in a major release*/;
+    abstract onDestroy(callback: Function): void;
 }
 
 /**
@@ -10281,7 +10045,6 @@ declare interface ViewRefTracker {
     detachView(viewRef: ViewRef): void;
 }
 
-
 declare interface WeakRef<T extends object> {
     deref(): T | undefined;
 }
@@ -11221,15 +10984,6 @@ export declare enum ɵLocaleDataIndex {
     ExtraData = 21
 }
 
-/**
- * @suppress {globalThis}
- */
-export declare function ɵmakeDecorator<T>(name: string, props?: (...args: any[]) => any, parentClass?: any, additionalProcessing?: (type: Type<T>) => void, typeFn?: (type: Type<T>, ...args: any[]) => void): {
-    new (...args: any[]): any;
-    (...args: any[]): any;
-    (...args: any[]): (cls: any) => any;
-};
-
 
 export declare const ɵNG_COMP_DEF: string;
 
@@ -11459,52 +11213,6 @@ export declare const enum ɵProfilerEvent {
     OutputEnd = 7
 }
 
-/**
- * Returns a set of providers required to setup hydration support
- * for an application that is server side rendered.
- *
- * ## NgModule-based bootstrap
- *
- * You can add the function call to the root AppModule of an application:
- * ```
- * import {provideHydrationSupport} from '@angular/core';
- *
- * @NgModule({
- *   providers: [
- *     // ... other providers ...
- *     provideHydrationSupport()
- *   ],
- *   declarations: [AppComponent],
- *   bootstrap: [AppComponent]
- * })
- * class AppModule {}
- * ```
- *
- * ## Standalone-based bootstrap
- *
- * Add the function to the `bootstrapApplication` call:
- * ```
- * import {provideHydrationSupport} from '@angular/core';
- *
- * bootstrapApplication(RootComponent, {
- *   providers: [
- *     // ... other providers ...
- *     provideHydrationSupport()
- *   ]
- * });
- * ```
- *
- * The function sets up an internal flag that would be recognized during
- * the server side rendering time as well, so there is no need to
- * configure or change anything in NgUniversal to enable the feature.
- *
- * @publicApi
- * @developerPreview
- */
-export declare function ɵprovideHydrationSupport(): EnvironmentProviders;
-
-export declare function ɵprovideNgZoneChangeDetection(ngZone: NgZone): StaticProvider[];
-
 /**
  * Publishes a collection of default debug tools onto`window.ng`.
  *
@@ -11675,7 +11383,8 @@ export declare function ɵresolveComponentResources(resourceResolver: (url: stri
  *
  * Note: the `message` argument contains a descriptive error message as a string in development
  * mode (when the `ngDevMode` is defined). In production mode (after tree-shaking pass), the
- * `message` argument becomes `false`, thus we account for it in the typings and the runtime logic.
+ * `message` argument becomes `false`, thus we account for it in the typings and the runtime
+ * logic.
  */
 export declare class ɵRuntimeError<T extends number = RuntimeErrorCode> extends Error {
     code: T;
@@ -12042,6 +11751,18 @@ export declare class ɵViewRef<T> implements EmbeddedViewRef<T>, InternalViewRef
     attachToAppRef(appRef: ViewRefTracker): void;
 }
 
+/**
+ * Returns a set of providers required to setup hydration support
+ * for an application that is server side rendered. This function is
+ * included into the `provideClientHydration` public API function from
+ * the `platform-browser` package.
+ *
+ * The function sets up an internal flag that would be recognized during
+ * the server side rendering time as well, so there is no need to
+ * configure or change anything in NgUniversal to enable the feature.
+ */
+export declare function ɵwithDomHydration(): EnvironmentProviders;
+
 /**
  * URL for the XSS security documentation.
  */