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

package/index.d.ts

@@ -1,5 +1,5 @@
 /**
- * @license Angular v17.0.0-next.1
+ * @license Angular v17.0.0-next.3
  * (c) 2010-2022 Google LLC. https://angular.io/
  * License: MIT
  */
@@ -164,16 +164,6 @@ export declare function afterNextRender(callback: VoidFunction, options?: AfterR
  */
 export declare function afterRender(callback: VoidFunction, options?: AfterRenderOptions): AfterRenderRef;
 
-/**
- * A wrapper around a function to be used as an after render callback.
- * @private
- */
-declare class AfterRenderCallback {
-    private callback;
-    constructor(callback: VoidFunction);
-    invoke(): void;
-}
-
 /**
  * Options passed to `afterRender` and `afterNextRender`.
  *
@@ -1466,6 +1456,11 @@ declare interface ComponentDefinition<T> extends Omit<DirectiveDefinition<T>, 'f
     schemas?: SchemaMetadata[] | null;
 }
 
+/** Component dependencies info as calculated during runtime by the deps tracker. */
+declare interface ComponentDependencies {
+    dependencies: DependencyTypeList;
+}
+
 /**
  * Base class for a factory that can create a component dynamically.
  * Instantiate a factory for a given type of component with `resolveComponentFactory()`.
@@ -1937,17 +1932,18 @@ declare const CONTEXT = 8;
  * const applicationRef = await bootstrapApplication(RootComponent);
  *
  * // Locate a DOM node that would be used as a host.
- * const host = document.getElementById('hello-component-host');
+ * const hostElement = document.getElementById('hello-component-host');
  *
  * // Get an `EnvironmentInjector` instance from the `ApplicationRef`.
  * const environmentInjector = applicationRef.injector;
  *
  * // We can now create a `ComponentRef` instance.
- * const componentRef = createComponent(HelloComponent, {host, environmentInjector});
+ * const componentRef = createComponent(HelloComponent, {hostElement, environmentInjector});
  *
  * // Last step is to register the newly created ref using the `ApplicationRef` instance
  * // to include the component view into change detection cycles.
  * applicationRef.attachView(componentRef.hostView);
+ * componentRef.changeDetectorRef.detectChanges();
  * ```
  *
  * @param component Component class reference.
@@ -2401,7 +2397,27 @@ export declare class DefaultIterableDiffer<V> implements IterableDiffer<V>, Iter
     private _addToRemovals;
 }
 
-declare type DeferredDepsFn = () => Array<Promise<Type<unknown>> | Type<unknown>>;
+/**
+ * Describes the state of defer block dependency loading.
+ */
+declare const enum DeferDependenciesLoadingState {
+    /** Initial state, dependency loading is not yet triggered */
+    NOT_STARTED = 0,
+    /** Dependency loading was scheduled (e.g. `on idle`), but has not started yet */
+    SCHEDULED = 1,
+    /** Dependency loading is in progress */
+    IN_PROGRESS = 2,
+    /** Dependency loading has completed successfully */
+    COMPLETE = 3,
+    /** Dependency loading has failed */
+    FAILED = 4
+}
+
+/** Configuration object for a `{:loading}` block as it is stored in the component constants. */
+declare type DeferredLoadingBlockConfig = [minimumTime: number | null, afterTime: number | null];
+
+/** Configuration object for a `{:placeholder}` block as it is stored in the component constants. */
+declare type DeferredPlaceholderBlockConfig = [afterTime: number | null];
 
 /**
  * @deprecated in v8, delete after v10. This API should be used only by generated code, and that
@@ -2460,7 +2476,103 @@ declare interface DehydratedView {
     disconnectedNodes?: Set<number> | null;
 }
 
-declare type DependencyTypeList = (ɵDirectiveType<any> | ɵComponentType<any> | PipeType<any> | Type<any>)[];
+/**
+ * Describes the shape of a function generated by the compiler
+ * to download dependencies that can be defer-loaded.
+ */
+declare type DependencyResolverFn = () => Array<Promise<DependencyType>>;
+
+declare type DependencyType = ɵDirectiveType<any> | ɵComponentType<any> | PipeType<any> | Type<any>;
+
+declare type DependencyTypeList = Array<DependencyType>;
+
+/**
+ * An implementation of DepsTrackerApi which will be used for JIT and local compilation.
+ */
+declare class DepsTracker implements DepsTrackerApi {
+    private ownerNgModule;
+    private ngModulesWithSomeUnresolvedDecls;
+    private ngModulesScopeCache;
+    private standaloneComponentsScopeCache;
+    /**
+     * Attempts to resolve ng module's forward ref declarations as much as possible and add them to
+     * the `ownerNgModule` map. This method normally should be called after the initial parsing when
+     * all the forward refs are resolved (e.g., when trying to render a component)
+     */
+    private resolveNgModulesDecls;
+    /** @override */
+    getComponentDependencies(type: ɵComponentType<any>, rawImports?: RawScopeInfoFromDecorator[]): ComponentDependencies;
+    /**
+     * @override
+     * This implementation does not make use of param scopeInfo since it assumes the scope info is
+     * already added to the type itself through methods like {@link ɵɵsetNgModuleScope}
+     */
+    registerNgModule(type: Type<any>, scopeInfo: NgModuleScopeInfoFromDecorator): void;
+    /** @override */
+    clearScopeCacheFor(type: Type<any>): void;
+    /** @override */
+    getNgModuleScope(type: ɵNgModuleType<any>): NgModuleScope;
+    /** Compute NgModule scope afresh. */
+    private computeNgModuleScope;
+    /** @override */
+    getStandaloneComponentScope(type: ɵComponentType<any>, rawImports?: RawScopeInfoFromDecorator[]): StandaloneComponentScope;
+    private computeStandaloneComponentScope;
+}
+
+/**
+ * Public API for runtime deps tracker (RDT).
+ *
+ * All downstream tools should only use these methods.
+ */
+declare interface DepsTrackerApi {
+    /**
+     * Computes the component dependencies, i.e., a set of components/directive/pipes that could be
+     * present in the component's template (This set might contain directives/components/pipes not
+     * necessarily used in the component's template depending on the implementation).
+     *
+     * Standalone components should specify `rawImports` as this information is not available from
+     * their type. The consumer (e.g., {@link getStandaloneDefFunctions}) is expected to pass this
+     * parameter.
+     *
+     * The implementation is expected to use some caching mechanism in order to optimize the resources
+     * needed to do this computation.
+     */
+    getComponentDependencies(cmp: ɵComponentType<any>, rawImports?: (Type<any> | (() => Type<any>))[]): ComponentDependencies;
+    /**
+     * Registers an NgModule into the tracker with the given scope info.
+     *
+     * This method should be called for every NgModule whether it is compiled in local mode or not.
+     * This is needed in order to compute component's dependencies as some dependencies might be in
+     * different compilation units with different compilation mode.
+     */
+    registerNgModule(type: Type<any>, scopeInfo: NgModuleScopeInfoFromDecorator): void;
+    /**
+     * Clears the scope cache for NgModule or standalone component. This will force re-calculation of
+     * the scope, which could be an expensive operation as it involves aggregating transitive closure.
+     *
+     * The main application of this method is for test beds where we want to clear the cache to
+     * enforce scope update after overriding.
+     */
+    clearScopeCacheFor(type: Type<any>): void;
+    /**
+     * Returns the scope of NgModule. Mainly to be used by JIT and test bed.
+     *
+     * The scope value here is memoized. To enforce a new calculation bust the cache by using
+     * `clearScopeCacheFor` method.
+     */
+    getNgModuleScope(type: ɵNgModuleType<any>): NgModuleScope;
+    /**
+     * Returns the scope of standalone component. Mainly to be used by JIT. This method should be
+     * called lazily after the initial parsing so that all the forward refs can be resolved.
+     *
+     * @param rawImports the imports statement as appears on the component decorate which consists of
+     *     Type as well as forward refs.
+     *
+     * The scope value here is memoized. To enforce a new calculation bust the cache by using
+     * `clearScopeCacheFor` method.
+     */
+    getStandaloneComponentScope(type: ɵComponentType<any>, rawImports: (Type<any> | (() => Type<any>))[]): StandaloneComponentScope;
+}
 
 declare const DESCENDANT_VIEWS_TO_REFRESH = 5;
 
@@ -4592,11 +4704,17 @@ export declare enum InjectFlags {
  * `InjectionToken` is parameterized on `T` which is the type of object which will be returned by
  * the `Injector`. This provides an additional level of type safety.
  *
- * ```
- * interface MyInterface {...}
- * const myInterface = injector.get(new InjectionToken<MyInterface>('SomeToken'));
- * // myInterface is inferred to be MyInterface.
- * ```
+ * <div class="alert is-helpful">
+ *
+ * **Important Note**: Ensure that you use the same instance of the `InjectionToken` in both the
+ * provider and the injection call. Creating a new instance of `InjectionToken` in different places,
+ * even with the same description, will be treated as different tokens by Angular's DI system,
+ * leading to a `NullInjectorError`.
+ *
+ * </div>
+ *
+ * <code-example format="typescript" language="typescript" path="injection-token/src/main.ts"
+ * region="InjectionToken"></code-example>
  *
  * When creating an `InjectionToken`, you can optionally specify a factory function which returns
  * (possibly by creating) a default value of the parameterized type `T`. This sets up the
@@ -4623,7 +4741,6 @@ export declare enum InjectFlags {
  *
  * {@example core/di/ts/injector_spec.ts region='ShakableInjectionToken'}
  *
- *
  * @publicApi
  */
 export declare class InjectionToken<T> {
@@ -6067,6 +6184,12 @@ export declare abstract class NgModuleRef<T> {
     abstract onDestroy(callback: () => void): void;
 }
 
+/** Represents scope data for NgModule as calculated during runtime by the deps tracker. */
+declare interface NgModuleScope {
+    compilation: ScopeData;
+    exported: ScopeData;
+}
+
 /**
  * NgModule scope info as provided by AoT compiler
  *
@@ -7245,116 +7368,94 @@ declare const REACTIVE_HOST_BINDING_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;
-    protected onProducerUpdateValueVersion(): void;
-    get hasReadASignal(): boolean;
-    runInContext(fn: HostBindingsFunction<unknown> | ComponentTemplate<unknown>, rf: ɵRenderFlags, ctx: unknown): void;
-    destroy(): void;
+declare interface ReactiveLViewConsumer extends ReactiveNode {
+    lView: LView | null;
 }
 
 /**
- * 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.
+ * A producer and/or consumer which participates in the reactive graph.
  *
- * 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.
+ * Producer `ReactiveNode`s which are accessed when a consumer `ReactiveNode` is the
+ * `activeConsumer` are tracked as dependencies of that consumer.
  *
- * Consumers are nodes that depend on the values of producers and are notified when those values
- * might have changed.
+ * Certain consumers are also tracked as "live" consumers and create edges in the other direction,
+ * from producer to consumer. These edges are used to propagate change notifications when a
+ * producer's value is updated.
  *
- * 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.
+ * A `ReactiveNode` may be both a producer and consumer.
  */
-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;
+declare interface ReactiveNode {
     /**
-     * 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.
+     * Version of the value that this node produces.
+     *
+     * This is incremented whenever a new value is produced by this node which is not equal to the
+     * previous value (by whatever definition of equality is in use).
      */
-    protected valueVersion: number;
+    version: Version_2;
     /**
-     * Whether signal writes should be allowed while this `ReactiveNode` is the current consumer.
+     * Whether this node (in its consumer capacity) is dirty.
+     *
+     * Only live consumers become dirty, when receiving a change notification from a dependency
+     * producer.
      */
-    protected abstract readonly consumerAllowSignalWrites: boolean;
+    dirty: boolean;
     /**
-     * Called for consumers whenever one of their dependencies notifies that it might have a new
-     * value.
+     * Producers which are dependencies of this consumer.
+     *
+     * Uses the same indices as the `producerLastReadVersion` and `producerIndexOfThis` arrays.
      */
-    protected abstract onConsumerDependencyMayHaveChanged(): void;
+    producerNode: ReactiveNode[] | undefined;
     /**
-     * Called for producers when a dependent consumer is checking if the producer's value has actually
-     * changed.
+     * `Version` of the value last read by a given producer.
+     *
+     * Uses the same indices as the `producerNode` and `producerIndexOfThis` arrays.
      */
-    protected abstract onProducerUpdateValueVersion(): void;
+    producerLastReadVersion: Version_2[] | undefined;
     /**
-     * Polls dependencies of a consumer to determine if they have actually changed.
+     * Index of `this` (consumer) in each producer's `liveConsumers` array.
+     *
+     * This value is only meaningful if this node is live (`liveConsumers.length > 0`). Otherwise
+     * these indices are stale.
      *
-     * 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.
+     * Uses the same indices as the `producerNode` and `producerLastReadVersion` arrays.
      */
-    protected consumerPollProducersForChange(): boolean;
+    producerIndexOfThis: number[] | undefined;
     /**
-     * Notify all consumers of this producer that its value may have changed.
+     * Index into the producer arrays that the next dependency of this node as a consumer will use.
+     *
+     * This index is zeroed before this node as a consumer begins executing. When a producer is read,
+     * it gets inserted into the producers arrays at this index. There may be an existing dependency
+     * in this location which may or may not match the incoming producer, depending on whether the
+     * same producers were read in the same order as the last computation.
      */
-    protected producerMayHaveChanged(): void;
+    nextProducerIndex: number;
     /**
-     * Mark that this producer node has been accessed in the current reactive context.
+     * Array of consumers of this producer that are "live" (they require push notifications).
+     *
+     * `liveConsumerNode.length` is effectively our reference count for this node.
      */
-    protected producerAccessed(): void;
+    liveConsumerNode: ReactiveNode[] | undefined;
     /**
-     * Whether this consumer currently has any producers registered.
+     * Index of `this` (producer) in each consumer's `producerNode` array.
+     *
+     * Uses the same indices as the `liveConsumerNode` array.
      */
-    protected get hasProducers(): boolean;
+    liveConsumerIndexOfThis: number[] | undefined;
     /**
-     * Whether this `ReactiveNode` in its producer capacity is currently allowed to initiate updates,
-     * based on the current consumer context.
+     * Whether writes to signals are allowed when this consumer is the `activeConsumer`.
+     *
+     * This is used to enforce guardrails such as preventing writes to writable signals in the
+     * computation function of computed signals, which is supposed to be pure.
      */
-    protected get producerUpdatesAllowed(): boolean;
+    consumerAllowSignalWrites: boolean;
+    readonly consumerIsAlwaysLive: 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`.
+     * Tracks whether producers need to recompute their value independently of the reactive graph (for
+     * example, if no initial value has been computed).
      */
-    private producerPollStatus;
+    producerMustRecompute(node: unknown): boolean;
+    producerRecomputeValue(node: unknown): void;
+    consumerMarkedDirty(node: unknown): void;
 }
 
 /**
@@ -7789,90 +7890,6 @@ declare interface RText extends RNode {
  */
 export declare function runInInjectionContext<ReturnT>(injector: Injector, fn: () => ReturnT): ReturnT;
 
-
-/**
- * The list of error codes used in runtime code of the `core` package.
- * Reserved error code range: 100-999.
- *
- * Note: the minus sign denotes the fact that a particular code has a detailed guide on
- * angular.io. This extra annotation is needed to avoid introducing a separate set to store
- * error codes which have guides, which might leak into runtime code.
- *
- * Full list of available error guides can be found at https://angular.io/errors.
- *
- * Error code ranges per package:
- *  - core (this package): 100-999
- *  - forms: 1000-1999
- *  - common: 2000-2999
- *  - animations: 3000-3999
- *  - router: 4000-4999
- *  - platform-browser: 5000-5500
- */
-declare const enum RuntimeErrorCode {
-    EXPRESSION_CHANGED_AFTER_CHECKED = -100,
-    RECURSIVE_APPLICATION_REF_TICK = 101,
-    RECURSIVE_APPLICATION_RENDER = 102,
-    CYCLIC_DI_DEPENDENCY = -200,
-    PROVIDER_NOT_FOUND = -201,
-    INVALID_FACTORY_DEPENDENCY = 202,
-    MISSING_INJECTION_CONTEXT = -203,
-    INVALID_INJECTION_TOKEN = 204,
-    INJECTOR_ALREADY_DESTROYED = 205,
-    PROVIDER_IN_WRONG_CONTEXT = 207,
-    MISSING_INJECTION_TOKEN = 208,
-    INVALID_MULTI_PROVIDER = -209,
-    MISSING_DOCUMENT = 210,
-    MULTIPLE_COMPONENTS_MATCH = -300,
-    EXPORT_NOT_FOUND = -301,
-    PIPE_NOT_FOUND = -302,
-    UNKNOWN_BINDING = 303,
-    UNKNOWN_ELEMENT = 304,
-    TEMPLATE_STRUCTURE_ERROR = 305,
-    INVALID_EVENT_BINDING = 306,
-    HOST_DIRECTIVE_UNRESOLVABLE = 307,
-    HOST_DIRECTIVE_NOT_STANDALONE = 308,
-    DUPLICATE_DIRECTITVE = 309,
-    HOST_DIRECTIVE_COMPONENT = 310,
-    HOST_DIRECTIVE_UNDEFINED_BINDING = 311,
-    HOST_DIRECTIVE_CONFLICTING_ALIAS = 312,
-    MULTIPLE_MATCHING_PIPES = 313,
-    MULTIPLE_PLATFORMS = 400,
-    PLATFORM_NOT_FOUND = 401,
-    MISSING_REQUIRED_INJECTABLE_IN_BOOTSTRAP = 402,
-    BOOTSTRAP_COMPONENTS_NOT_FOUND = -403,
-    PLATFORM_ALREADY_DESTROYED = 404,
-    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,
-    MISSING_HYDRATION_ANNOTATIONS = -505,
-    HYDRATION_STABLE_TIMEDOUT = -506,
-    MISSING_SSR_CONTENT_INTEGRITY_MARKER = -507,
-    SIGNAL_WRITE_FROM_ILLEGAL_CONTEXT = 600,
-    REQUIRE_SYNC_WITHOUT_SYNC_EMIT = 601,
-    INVALID_I18N_STRUCTURE = 700,
-    MISSING_LOCALE_DATA = 701,
-    IMPORT_PROVIDERS_FROM_STANDALONE = 800,
-    INVALID_DIFFER_INPUT = 900,
-    NO_SUPPORTING_DIFFER_FACTORY = 901,
-    VIEW_ALREADY_ATTACHED = 902,
-    INVALID_INHERITANCE = 903,
-    UNSAFE_VALUE_IN_RESOURCE_URL = 904,
-    UNSAFE_VALUE_IN_SCRIPT = 905,
-    MISSING_GENERATED_DEF = 906,
-    TYPE_IS_NOT_STANDALONE = 907,
-    MISSING_ZONEJS = 908,
-    UNEXPECTED_ZONE_STATE = 909,
-    UNSAFE_IFRAME_ATTRS = -910,
-    VIEW_ALREADY_DESTROYED = 911,
-    COMPONENT_ID_COLLISION = -912,
-    RUNTIME_DEPS_INVALID_IMPORTED_TYPE = 1000
-}
-
 /**
  * Sanitizer is used by the views to sanitize potentially dangerous values.
  *
@@ -7905,6 +7922,24 @@ export declare interface SchemaMetadata {
     name: string;
 }
 
+/**
+ * Represents the set of dependencies of a type in a certain context.
+ */
+declare interface ScopeData {
+    pipes: Set<PipeType<any>>;
+    directives: Set<ɵDirectiveType<any> | ɵComponentType<any> | Type<any>>;
+    /**
+     * If true it indicates that calculating this scope somehow was not successful. The consumers
+     * should interpret this as empty dependencies. The application of this flag is when calculating
+     * scope recursively, the presence of this flag in a scope dependency implies that the scope is
+     * also poisoned and thus we can return immediately without having to continue the recursion. The
+     * reason for this error is displayed as an error message in the console as per JIT behavior
+     * today. In addition to that, in local compilation the other build/compilations run in parallel
+     * with local compilation may or may not reveal some details about the error as well.
+     */
+    isPoisoned?: boolean;
+}
+
 
 /**
  * A SecurityContext marks a location that has dangerous security implications, e.g. a DOM property
@@ -8176,6 +8211,13 @@ export declare interface SkipSelfDecorator {
     new (): SkipSelf;
 }
 
+/**
+ * Represents scope data for standalone component as calculated during runtime by the deps tracker.
+ */
+declare interface StandaloneComponentScope {
+    compilation: ScopeData;
+}
+
 
 /**
  * A type-safe key to use with `TransferState`.
@@ -8337,7 +8379,57 @@ declare interface TContainerNode extends TNode {
  *
  * Injector bloom filters are also stored here.
  */
-declare type TData = (TNode | ɵPipeDef<any> | ɵDirectiveDef<any> | ɵComponentDef<any> | number | TStylingRange | TStylingKey | ProviderToken<any> | TI18n | I18nUpdateOpCodes | TIcu | null | string)[];
+declare type TData = (TNode | ɵPipeDef<any> | ɵDirectiveDef<any> | ɵComponentDef<any> | number | TStylingRange | TStylingKey | ProviderToken<any> | TI18n | I18nUpdateOpCodes | TIcu | null | string | TDeferBlockDetails)[];
+
+/**
+ * Describes the data shared across all instances of a {#defer} block.
+ */
+declare interface TDeferBlockDetails {
+    /**
+     * Index in an LView and TData arrays where a template for the primary content
+     * can be found.
+     */
+    primaryTmplIndex: number;
+    /**
+     * Index in an LView and TData arrays where a template for the `{:loading}`
+     * block can be found.
+     */
+    loadingTmplIndex: number | null;
+    /**
+     * Extra configuration parameters (such as `after` and `minimum`)
+     * for the `{:loading}` block.
+     */
+    loadingBlockConfig: DeferredLoadingBlockConfig | null;
+    /**
+     * Index in an LView and TData arrays where a template for the `{:placeholder}`
+     * block can be found.
+     */
+    placeholderTmplIndex: number | null;
+    /**
+     * Extra configuration parameters (such as `after` and `minimum`)
+     * for the `{:placeholder}` block.
+     */
+    placeholderBlockConfig: DeferredPlaceholderBlockConfig | null;
+    /**
+     * Index in an LView and TData arrays where a template for the `{:error}`
+     * block can be found.
+     */
+    errorTmplIndex: number | null;
+    /**
+     * Compiler-generated function that loads all dependencies for a `{#defer}` block.
+     */
+    dependencyResolverFn: DependencyResolverFn | null;
+    /**
+     * Keeps track of the current loading state of defer block dependencies.
+     */
+    loadingState: DeferDependenciesLoadingState;
+    /**
+     * Dependency loading Promise. This Promise is helpful for cases when there
+     * are multiple instances of a defer block (e.g. if it was used inside of an *ngFor),
+     * which all await the same set of dependencies.
+     */
+    loadingPromise: Promise<unknown> | null;
+}
 
 /** Static data for an <ng-container> */
 declare interface TElementContainerNode extends TNode {
@@ -9415,17 +9507,17 @@ export declare const TRANSLATIONS_FORMAT: InjectionToken<string>;
  * https://github.com/DefinitelyTyped/DefinitelyTyped/blob/master/types/trusted-types/index.d.ts
  * but restricted to the API surface used within Angular.
  */
-declare interface TrustedHTML {
+declare type TrustedHTML = string & {
     __brand__: 'TrustedHTML';
-}
+};
 
-declare interface TrustedScript {
+declare type TrustedScript = string & {
     __brand__: 'TrustedScript';
-}
+};
 
-declare interface TrustedScriptURL {
+declare type TrustedScriptURL = string & {
     __brand__: 'TrustedScriptURL';
-}
+};
 
 /**
  * Value stored in the `TData` which is needed to re-concatenate the styling.
@@ -9474,9 +9566,9 @@ declare type TStylingKeyPrimitive = string | null | false;
  *
  * NOTE: `0` has special significance and represents `null` as in no additional pointer.
  */
-declare interface TStylingRange {
+declare type TStylingRange = number & {
     __brand__: 'TStylingRange';
-}
+};
 
 /**
  * Store the static values for the styling binding.
@@ -9959,6 +10051,10 @@ export declare class Version {
     constructor(full: string);
 }
 
+declare type Version_2 = number & {
+    __brand: 'Version';
+};
+
 declare const VIEW_REFS = 8;
 
 /**
@@ -10141,6 +10237,40 @@ export declare interface ViewChildrenDecorator {
  * A view container instance can contain other view containers,
  * creating a [view hierarchy](guide/glossary#view-hierarchy).
  *
+ * @usageNotes
+ *
+ * The example below demonstrates how the `createComponent` function can be used
+ * to create an instance of a ComponentRef dynamically and attach it to an ApplicationRef,
+ * so that it gets included into change detection cycles.
+ *
+ * Note: the example uses standalone components, but the function can also be used for
+ * non-standalone components (declared in an NgModule) as well.
+ *
+ * ```typescript
+ * @Component({
+ *   standalone: true,
+ *   selector: 'dynamic',
+ *   template: `<span>This is a content of a dynamic component.</span>`,
+ * })
+ * class DynamicComponent {
+ *   vcr = inject(ViewContainerRef);
+ * }
+ *
+ * @Component({
+ *   standalone: true,
+ *   selector: 'app',
+ *   template: `<main>Hi! This is the main content.</main>`,
+ * })
+ * class AppComponent {
+ *   vcr = inject(ViewContainerRef);
+ *
+ *   ngAfterViewInit() {
+ *     const compRef = this.vcr.createComponent(DynamicComponent);
+ *     compRef.changeDetectorRef.detectChanges();
+ *   }
+ * }
+ * ```
+ *
  * @see {@link ComponentRef}
  * @see {@link EmbeddedViewRef}
  *
@@ -10379,14 +10509,6 @@ declare interface ViewRefTracker {
     detachView(viewRef: ViewRef): void;
 }
 
-declare interface WeakRef<T extends object> {
-    deref(): T | undefined;
-}
-
-declare interface WeakRefCtor {
-    new <T extends object>(value: T): WeakRef<T>;
-}
-
 /**
  * A `Signal` with a value that can be mutated via a setter interface.
  *
@@ -10425,25 +10547,21 @@ export declare function ɵ_sanitizeHtml(defaultDoc: any, unsafeHtmlInput: string
 export declare function ɵ_sanitizeUrl(url: string): string;
 
 /**
- * Implements `afterRender` and `afterNextRender` callback manager logic.
+ * Implements core timing for `afterRender` and `afterNextRender` events.
+ * Delegates to an optional `AfterRenderCallbackHandler` for implementation.
  */
 export declare class ɵAfterRenderEventManager {
-    private callbacks;
-    private deferredCallbacks;
     private renderDepth;
-    private runningCallbacks;
     /**
      * Mark the beginning of a render operation (i.e. CD cycle).
-     * Throws if called from an `afterRender` callback.
+     * Throws if called while executing callbacks.
      */
     begin(): void;
     /**
-     * Mark the end of a render operation. Registered callbacks
-     * are invoked if there are no more pending operations.
+     * Mark the end of a render operation. Callbacks will be
+     * executed if there are no more pending operations.
      */
     end(): void;
-    register(callback: AfterRenderCallback): void;
-    unregister(callback: AfterRenderCallback): void;
     ngOnDestroy(): void;
     /** @nocollapse */
     static ɵprov: unknown;
@@ -10870,6 +10988,36 @@ export declare const ɵdefaultIterableDiffers: IterableDiffers;
 
 export declare const ɵdefaultKeyValueDiffers: KeyValueDiffers;
 
+/**
+ * **INTERNAL**, avoid referencing it in application code.
+ *
+ * Injector token that allows to provide `DeferBlockDependencyInterceptor` class
+ * implementation.
+ */
+export declare const ɵDEFER_BLOCK_DEPENDENCY_INTERCEPTOR: InjectionToken<ɵDeferBlockDependencyInterceptor>;
+
+/**
+ * **INTERNAL**, avoid referencing it in application code.
+ *
+ * Describes a helper class that allows to intercept a call to retrieve current
+ * dependency loading function and replace it with a different implementation.
+ * This interceptor class is needed to allow testing blocks in different states
+ * by simulating loading response.
+ */
+export declare interface ɵDeferBlockDependencyInterceptor {
+    /**
+     * Invoked for each defer block when dependency loading function is accessed.
+     */
+    intercept(dependencyFn: DependencyResolverFn | null): DependencyResolverFn | null;
+    /**
+     * Allows to configure an interceptor function.
+     */
+    setInterceptor(interceptorFn: (current: DependencyResolverFn) => DependencyResolverFn): void;
+}
+
+/** The deps tracker to be used in the current Angular app in dev mode. */
+export declare const ɵdepsTracker: DepsTracker;
+
 /**
  * Synchronously perform change detection on a component (and possibly its sub-components).
  *
@@ -11075,7 +11223,15 @@ export declare function ɵflushModuleScopingQueueAsMuchAsPossible(): void;
  * Called to format a runtime error.
  * See additional info on the `message` argument type in the `RuntimeError` class description.
  */
-export declare function ɵformatRuntimeError<T extends number = RuntimeErrorCode>(code: T, message: null | false | string): string;
+export declare function ɵformatRuntimeError<T extends number = ɵRuntimeErrorCode>(code: T, message: null | false | string): string;
+
+export declare function ɵgenerateStandaloneInDeclarationsError(type: Type<any>, location: string): string;
+
+/**
+ * If a given component has unresolved async metadata - this function returns a reference to
+ * a Promise that represents dependency loading. Otherwise - this function returns `null`.
+ */
+export declare function ɵgetAsyncClassMetadata(type: Type<unknown>): Promise<Array<Type<unknown>>> | null;
 
 /**
  * Retrieves directive instances associated with a given DOM node. Does not include
@@ -11266,6 +11422,8 @@ export declare const ɵIS_HYDRATION_DOM_REUSE_ENABLED: InjectionToken<boolean>;
 
 export declare function ɵisBoundToModule<C>(cf: ComponentFactory<C>): boolean;
 
+export declare function ɵisComponentDefPendingResolution(type: Type<any>): boolean;
+
 export declare function ɵisEnvironmentProviders(value: Provider | EnvironmentProviders | ɵInternalEnvironmentProviders): value is ɵInternalEnvironmentProviders;
 
 export declare function ɵisInjectable(type: any): boolean;
@@ -11769,6 +11927,8 @@ export declare function ɵresolveComponentResources(resourceResolver: (url: stri
     text(): Promise<string>;
 }>)): Promise<void>;
 
+export declare function ɵrestoreComponentResolutionQueue(queue: Map<Type<any>, Component>): void;
+
 /**
  * Class that represents a runtime error.
  * Formats and outputs the error message in a consistent way.
@@ -11785,11 +11945,95 @@ export declare function ɵresolveComponentResources(resourceResolver: (url: stri
  * `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 {
+export declare class ɵRuntimeError<T extends number = ɵRuntimeErrorCode> extends Error {
     code: T;
     constructor(code: T, message: null | false | string);
 }
 
+
+/**
+ * The list of error codes used in runtime code of the `core` package.
+ * Reserved error code range: 100-999.
+ *
+ * Note: the minus sign denotes the fact that a particular code has a detailed guide on
+ * angular.io. This extra annotation is needed to avoid introducing a separate set to store
+ * error codes which have guides, which might leak into runtime code.
+ *
+ * Full list of available error guides can be found at https://angular.io/errors.
+ *
+ * Error code ranges per package:
+ *  - core (this package): 100-999
+ *  - forms: 1000-1999
+ *  - common: 2000-2999
+ *  - animations: 3000-3999
+ *  - router: 4000-4999
+ *  - platform-browser: 5000-5500
+ */
+export declare const enum ɵRuntimeErrorCode {
+    EXPRESSION_CHANGED_AFTER_CHECKED = -100,
+    RECURSIVE_APPLICATION_REF_TICK = 101,
+    RECURSIVE_APPLICATION_RENDER = 102,
+    CYCLIC_DI_DEPENDENCY = -200,
+    PROVIDER_NOT_FOUND = -201,
+    INVALID_FACTORY_DEPENDENCY = 202,
+    MISSING_INJECTION_CONTEXT = -203,
+    INVALID_INJECTION_TOKEN = 204,
+    INJECTOR_ALREADY_DESTROYED = 205,
+    PROVIDER_IN_WRONG_CONTEXT = 207,
+    MISSING_INJECTION_TOKEN = 208,
+    INVALID_MULTI_PROVIDER = -209,
+    MISSING_DOCUMENT = 210,
+    MULTIPLE_COMPONENTS_MATCH = -300,
+    EXPORT_NOT_FOUND = -301,
+    PIPE_NOT_FOUND = -302,
+    UNKNOWN_BINDING = 303,
+    UNKNOWN_ELEMENT = 304,
+    TEMPLATE_STRUCTURE_ERROR = 305,
+    INVALID_EVENT_BINDING = 306,
+    HOST_DIRECTIVE_UNRESOLVABLE = 307,
+    HOST_DIRECTIVE_NOT_STANDALONE = 308,
+    DUPLICATE_DIRECTITVE = 309,
+    HOST_DIRECTIVE_COMPONENT = 310,
+    HOST_DIRECTIVE_UNDEFINED_BINDING = 311,
+    HOST_DIRECTIVE_CONFLICTING_ALIAS = 312,
+    MULTIPLE_MATCHING_PIPES = 313,
+    MULTIPLE_PLATFORMS = 400,
+    PLATFORM_NOT_FOUND = 401,
+    MISSING_REQUIRED_INJECTABLE_IN_BOOTSTRAP = 402,
+    BOOTSTRAP_COMPONENTS_NOT_FOUND = -403,
+    PLATFORM_ALREADY_DESTROYED = 404,
+    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,
+    MISSING_HYDRATION_ANNOTATIONS = -505,
+    HYDRATION_STABLE_TIMEDOUT = -506,
+    MISSING_SSR_CONTENT_INTEGRITY_MARKER = -507,
+    SIGNAL_WRITE_FROM_ILLEGAL_CONTEXT = 600,
+    REQUIRE_SYNC_WITHOUT_SYNC_EMIT = 601,
+    INVALID_I18N_STRUCTURE = 700,
+    MISSING_LOCALE_DATA = 701,
+    IMPORT_PROVIDERS_FROM_STANDALONE = 800,
+    INVALID_DIFFER_INPUT = 900,
+    NO_SUPPORTING_DIFFER_FACTORY = 901,
+    VIEW_ALREADY_ATTACHED = 902,
+    INVALID_INHERITANCE = 903,
+    UNSAFE_VALUE_IN_RESOURCE_URL = 904,
+    UNSAFE_VALUE_IN_SCRIPT = 905,
+    MISSING_GENERATED_DEF = 906,
+    TYPE_IS_NOT_STANDALONE = 907,
+    MISSING_ZONEJS = 908,
+    UNEXPECTED_ZONE_STATE = 909,
+    UNSAFE_IFRAME_ATTRS = -910,
+    VIEW_ALREADY_DESTROYED = 911,
+    COMPONENT_ID_COLLISION = -912,
+    RUNTIME_DEPS_INVALID_IMPORTED_TYPE = 1000
+}
+
 /**
  * Marker interface for a value that's safe to use as HTML.
  *
@@ -11847,7 +12091,8 @@ export declare interface ɵSafeValue {
  */
 export declare function ɵsetAllowDuplicateNgModuleIdsForTest(allowDuplicates: boolean): void;
 
-export declare function ɵsetAlternateWeakRefImpl(impl: WeakRefCtor): void;
+
+export declare function ɵsetAlternateWeakRefImpl(impl: unknown): void;
 
 /**
  * Adds decorator, constructor, and property metadata to a given type via static metadata fields
@@ -11952,6 +12197,15 @@ export declare function ɵunwrapSafeValue(value: ɵSafeValue): string;
 
 export declare function ɵunwrapSafeValue<T>(value: T): T;
 
+/**
+ * Indicates whether to use the runtime dependency tracker for scope calculation in JIT compilation.
+ * The value "false" means the old code path based on patching scope info into the types will be
+ * used.
+ *
+ * @deprecated For migration purposes only, to be removed soon.
+ */
+export declare const ɵUSE_RUNTIME_DEPS_TRACKER_FOR_JIT = false;
+
 export declare class ɵViewRef<T> implements EmbeddedViewRef<T>, InternalViewRef, ChangeDetectorRefInterface {
     /**
      * This represents the `LView` associated with the point where `ChangeDetectorRef` was
@@ -12843,6 +13097,14 @@ export declare type ɵɵComponentDeclaration<T, Selector extends String, ExportA
     [key: string]: string;
 }, QueryFields extends string[], NgContentSelectors extends string[], IsStandalone extends boolean = false, HostDirectives = never, IsSignal extends boolean = false> = unknown;
 
+/**
+ * Instruction that returns the component instance in which the current instruction is executing.
+ * This is a constant-time version of `nextContent` for the case where we know that we need the
+ * component instance specifically, rather than the context of a particular template.
+ *
+ * @codeGenApi
+ */
+export declare function ɵɵcomponentInstance(): unknown;
 
 /**
  * The conditional instruction represents the basic building block on the runtime side to support
@@ -12892,20 +13154,20 @@ export declare function ɵɵCopyDefinitionFeature(definition: ɵDirectiveDef<any
 /**
  * Creates runtime data structures for `{#defer}` blocks.
  *
- * @param deferIndex Index of the underlying deferred block data structure.
- * @param primaryTemplateIndex Index of the template function with the block's content.
- * @param deferredDepsFn Function that contains dependencies for this defer block
- * @param loadingIndex Index of the template with the `{:loading}` block content.
- * @param placeholderIndex Index of the template with the `{:placeholder}` block content.
- * @param error Index of the template with the `{:error}` block content.
- * @param loadingConfigIndex Index in the constants array of the configuration of the `{:loading}`
+ * @param index Index of the `defer` instruction.
+ * @param primaryTmplIndex Index of the template with the primary block content.
+ * @param dependencyResolverFn Function that contains dependencies for this defer block.
+ * @param loadingTmplIndex Index of the template with the `{:loading}` block content.
+ * @param placeholderTmplIndex Index of the template with the `{:placeholder}` block content.
+ * @param errorTmplIndex Index of the template with the `{:error}` block content.
+ * @param loadingConfigIndex Index in the constants array of the configuration of the `{:loading}`.
  *     block.
  * @param placeholderConfigIndexIndex in the constants array of the configuration of the
  *     `{:placeholder}` block.
  *
  * @codeGenApi
  */
-export declare function ɵɵdefer(deferIndex: number, primaryTemplateIndex: number, deferredDepsFn?: DeferredDepsFn | null, loadingIndex?: number | null, placeholderIndex?: number | null, errorIndex?: number | null, loadingConfigIndex?: number | null, placeholderConfigIndex?: number | null): void;
+export declare function ɵɵdefer(index: number, primaryTmplIndex: number, dependencyResolverFn?: DependencyResolverFn | null, loadingTmplIndex?: number | null, placeholderTmplIndex?: number | null, errorTmplIndex?: number | null, loadingConfigIndex?: number | null, placeholderConfigIndex?: number | null): void;
 
 /**
  * Creates runtime data structures for the `on hover` deferred trigger.
@@ -12914,7 +13176,7 @@ export declare function ɵɵdefer(deferIndex: number, primaryTemplateIndex: numb
 export declare function ɵɵdeferOnHover(): void;
 
 /**
- * Creates runtime data structures for the `on idle` deferred trigger.
+ * Sets up handlers that represent `on idle` deferred trigger.
  * @codeGenApi
  */
 export declare function ɵɵdeferOnIdle(): void;
@@ -12947,19 +13209,19 @@ export declare function ɵɵdeferOnTimer(delay: number): void;
 export declare function ɵɵdeferOnViewport(target?: unknown): void;
 
 /**
- * Creates runtime data structures for the `prefetech on hover` deferred trigger.
+ * Creates runtime data structures for the `prefetch on hover` deferred trigger.
  * @codeGenApi
  */
 export declare function ɵɵdeferPrefetchOnHover(): void;
 
 /**
- * Creates runtime data structures for the `prefetech on idle` deferred trigger.
+ * Creates runtime data structures for the `prefetch on idle` deferred trigger.
  * @codeGenApi
  */
 export declare function ɵɵdeferPrefetchOnIdle(): void;
 
 /**
- * Creates runtime data structures for the `prefetech on immediate` deferred trigger.
+ * Creates runtime data structures for the `prefetch on immediate` deferred trigger.
  * @codeGenApi
  */
 export declare function ɵɵdeferPrefetchOnImmediate(): void;
@@ -12989,13 +13251,13 @@ export declare function ɵɵdeferPrefetchOnViewport(target?: unknown): void;
  * Prefetches the deferred content when a value becomes truthy.
  * @codeGenApi
  */
-export declare function ɵɵdeferPrefetchWhen(value: unknown): void;
+export declare function ɵɵdeferPrefetchWhen(rawValue: unknown): void;
 
 /**
- * Loads the deferred content when a value becomes truthy.
+ * Loads defer block dependencies when a trigger value becomes truthy.
  * @codeGenApi
  */
-export declare function ɵɵdeferWhen(value: unknown): void;
+export declare function ɵɵdeferWhen(rawValue: unknown): void;
 
 /**
  * Create a component definition object.
@@ -14532,6 +14794,61 @@ export declare function ɵɵreference<T>(index: number): T;
  */
 export declare function ɵɵregisterNgModuleType(ngModuleType: ɵNgModuleType, id: string): void;
 
+/**
+ * The repeater instruction does update-time diffing of a provided collection (against the
+ * collection seen previously) and maps changes in the collection to views structure (by adding,
+ * removing or moving views as needed).
+ * @param metadataSlotIdx - index in data where we can find an instance of RepeaterMetadata with
+ *     additional information (ex. differ) needed to process collection diffing and view
+ *     manipulation
+ * @param collection - the collection instance to be checked for changes
+ * @codeGenApi
+ */
+export declare function ɵɵrepeater(metadataSlotIdx: number, collection: Iterable<unknown> | undefined | null): void;
+
+/**
+ * The repeaterCreate instruction runs in the creation part of the template pass and initializes
+ * internal data structures required by the update pass of the built-in repeater logic. Repeater
+ * metadata are allocated in the data part of LView with the following layout:
+ * - LView[HEADER_OFFSET + index] - metadata
+ * - LView[HEADER_OFFSET + index + 1] - reference to a template function rendering an item
+ * - LView[HEADER_OFFSET + index + 2] - optional reference to a template function rendering an empty
+ * block
+ *
+ * @param index Index at which to store the metadata of the repeater.
+ * @param templateFn Reference to the template of the main repeater block.
+ * @param decls The number of nodes, local refs, and pipes for the main block.
+ * @param vars The number of bindings for the main block.
+ * @param trackByFn Reference to the tracking function.
+ * @param trackByUsesComponentInstance Whether the tracking function has any references to the
+ *  component instance. If it doesn't, we can avoid rebinding it.
+ * @param emptyTemplateFn Reference to the template function of the empty block.
+ * @param emptyDecls The number of nodes, local refs, and pipes for the empty block.
+ * @param emptyVars The number of bindings for the empty block.
+ *
+ * @codeGenApi
+ */
+export declare function ɵɵrepeaterCreate(index: number, templateFn: ComponentTemplate<unknown>, decls: number, vars: number, trackByFn: TrackByFunction<unknown>, trackByUsesComponentInstance?: boolean, emptyTemplateFn?: ComponentTemplate<unknown>, emptyDecls?: number, emptyVars?: number): void;
+
+/**
+ * A built-in trackBy function used for situations where users specified collection item reference
+ * as a tracking expression. Having this function body in the runtime avoids unnecessary code
+ * generation.
+ *
+ * @param index
+ * @returns
+ */
+export declare function ɵɵrepeaterTrackByIdentity<T>(_: number, value: T): T;
+
+/**
+ * A built-in trackBy function used for situations where users specified collection index as a
+ * tracking expression. Having this function body in the runtime avoids unnecessary code generation.
+ *
+ * @param index
+ * @returns
+ */
+export declare function ɵɵrepeaterTrackByIndex(index: number): number;
+
 /**
  * Clears the view set in `ɵɵrestoreView` from memory. Returns the passed in
  * value so that it can be used as a return value of an instruction.
@@ -15408,7 +15725,7 @@ export declare function ɵɵsyntheticHostProperty<T>(propName: string, value: T
  *
  * @codeGenApi
  */
-export declare function ɵɵtemplate(index: number, templateFn: ComponentTemplate<any> | null, decls: number, vars: number, tagName?: string | null, attrsIndex?: number | null, localRefsIndex?: number | null, localRefExtractor?: LocalRefExtractor): void;
+export declare function ɵɵtemplate(index: number, templateFn: ComponentTemplate<any> | null, decls: number, vars: number, tagName?: string | null, attrsIndex?: number | null, localRefsIndex?: number | null, localRefExtractor?: LocalRefExtractor): typeof ɵɵtemplate;
 
 /**
  * Retrieves `TemplateRef` instance from `Injector` when a local reference is placed on the