@angular/core 19.0.0-next.6 → 19.0.0-next.8

package/index.d.ts

@@ -1,5 +1,5 @@
 /**
- * @license Angular v19.0.0-next.6
+ * @license Angular v19.0.0-next.8
  * (c) 2010-2024 Google LLC. https://angular.io/
  * License: MIT
  */
@@ -10,12 +10,12 @@ import { EnvironmentProviders as EnvironmentProviders_2 } from '@angular/core';
 import { EventContract } from '@angular/core/primitives/event-dispatch';
 import { Observable } from 'rxjs';
 import { ReactiveNode } from '@angular/core/primitives/signals';
-import { SIGNAL } from '@angular/core/primitives/signals';
 import { SignalNode } from '@angular/core/primitives/signals';
 import { Subject } from 'rxjs';
 import { Subscribable } from 'rxjs';
 import { Subscription } from 'rxjs';
 import { ɵProfiler as ɵProfiler_2 } from '@angular/core';
+import { SIGNAL as ɵSIGNAL } from '@angular/core/primitives/signals';
 
 /**
  * @description
@@ -503,6 +503,13 @@ export declare interface AfterRenderOptions {
      * If this is not provided, the current injection context will be used instead (via `inject`).
      */
     injector?: Injector;
+    /**
+     * Whether the hook should require manual cleanup.
+     *
+     * If this is `false` (the default) the hook will automatically register itself to be cleaned up
+     * with the current `DestroyRef`.
+     */
+    manualCleanup?: boolean;
     /**
      * The phase the callback should be invoked in.
      *
@@ -609,7 +616,7 @@ declare class AfterRenderSequence implements AfterRenderRef {
      */
     pipelinedValue: unknown;
     private unregisterOnDestroy;
-    constructor(impl: AfterRenderImpl, hooks: AfterRenderHooks, once: boolean, destroyRef: DestroyRef);
+    constructor(impl: AfterRenderImpl, hooks: AfterRenderHooks, once: boolean, destroyRef: DestroyRef | null);
     afterRun(): void;
     destroy(): void;
 }
@@ -980,6 +987,7 @@ export declare class ApplicationRef {
     private readonly internalErrorHandler;
     private readonly afterRenderManager;
     private readonly zonelessEnabled;
+    private readonly rootEffectScheduler;
     private externalTestViews;
     /**
      * Indicates whether this instance was destroyed.
@@ -1762,9 +1770,10 @@ export declare interface ComponentDecorator {
      * Unlike other directives, only one component can be instantiated for a given element in a
      * template.
      *
-     * A component must belong to an NgModule in order for it to be available
-     * to another component or application. To make it a member of an NgModule,
-     * list it in the `declarations` field of the `NgModule` metadata.
+     * Standalone components can be directly imported in any other standalone component or NgModule.
+     * NgModule based apps on the other hand require components to belong to an NgModule in
+     * order for them to be available to another component or application. To make a component a
+     * member of an NgModule, list it in the `declarations` field of the `NgModule` metadata.
      *
      * Note that, in addition to these options for configuring a directive,
      * you can control a component's runtime behavior by implementing
@@ -2282,7 +2291,7 @@ export declare const ContentChild: ContentChildDecorator;
  * ```
  *
  * @initializerApiFunction
- * @developerPreview
+ * @publicAPI
  */
 export declare const contentChild: ContentChildFunction;
 
@@ -2369,7 +2378,7 @@ export declare interface ContentChildDecorator {
  * The contentChild function creates a singular content query. It is a special function that also
  * provides access to required query results via the `.required` property.
  *
- * @developerPreview
+ * @publicAPI
  * @docsPrivate Ignored because `contentChild` is the canonical API entry.
  */
 export declare interface ContentChildFunction {
@@ -2377,7 +2386,7 @@ export declare interface ContentChildFunction {
      * Initializes a content child query.
      *
      * Consider using `contentChild.required` for queries that should always match.
-     * @developerPreview
+     * @publicAPI
      */
     <LocatorT>(locator: ProviderToken<LocatorT> | string, opts?: {
         descendants?: boolean;
@@ -2614,10 +2623,12 @@ export declare interface CreateEffectOptions {
      */
     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.
+     * Always create a root effect (which is scheduled as a microtask) regardless of whether `effect`
+     * is called within a component.
+     */
+    forceRoot?: true;
+    /**
+     * @deprecated no longer required, signal writes are allowed by default.
      */
     allowSignalWrites?: boolean;
 }
@@ -3255,7 +3266,6 @@ declare type DestroyHookData = (HookEntry | HookData)[];
  */
 export declare function destroyPlatform(): void;
 
-
 /**
  * `DestroyRef` lets you set callbacks to run for any cleanup or destruction behavior.
  * The scope of this destruction depends on where `DestroyRef` is injected. If `DestroyRef`
@@ -3892,7 +3902,20 @@ export declare interface DoCheck {
 }
 
 /**
- * Create a global `Effect` for the given reactive function.
+ * Registers an "effect" that will be scheduled & executed whenever the signals that it reads
+ * changes.
+ *
+ * Angular has two different kinds of effect: component effects and root effects. Component effects
+ * are created when `effect()` is called from a component, directive, or within a service of a
+ * component/directive. Root effects are created when `effect()` is called from outside the
+ * component tree, such as in a root service, or when the `forceRoot` option is provided.
+ *
+ * The two effect types differ in their timing. Component effects run as a component lifecycle
+ * event during Angular's synchronization (change detection) process, and can safely read input
+ * signals or create/destroy views that depend on component state. Root effects run as microtasks
+ * and have no connection to the component tree or change detection.
+ *
+ * `effect()` must be run in injection context, unless the `injector` option is manually specified.
  *
  * @developerPreview
  */
@@ -3914,6 +3937,17 @@ export declare type EffectCleanupFn = () => void;
  */
 export declare type EffectCleanupRegisterFn = (cleanupFn: EffectCleanupFn) => void;
 
+declare interface EffectNode extends ReactiveNode, SchedulableEffect {
+    hasRun: boolean;
+    cleanupFns: EffectCleanupFn[] | undefined;
+    injector: Injector;
+    onDestroyFn: () => void;
+    fn: (cleanupFn: EffectCleanupRegisterFn) => void;
+    run(): void;
+    destroy(): void;
+    maybeCleanup(): void;
+}
+
 /**
  * A global reactive effect, which can be manually destroyed.
  *
@@ -3926,6 +3960,8 @@ export declare interface EffectRef {
     destroy(): void;
 }
 
+declare const EFFECTS = 23;
+
 declare const EFFECTS_TO_SCHEDULE = 22;
 
 /**
@@ -4305,65 +4341,6 @@ export declare interface ExistingSansProvider {
     useExisting: any;
 }
 
-/**
- * Experimental service that keeps track of pending tasks contributing to the stableness of Angular
- * application. While several existing Angular services (ex.: `HttpClient`) will internally manage
- * tasks influencing stability, this API gives control over stability to library and application
- * developers for specific cases not covered by Angular internals.
- *
- * The concept of stability comes into play in several important scenarios:
- * - SSR process needs to wait for the application stability before serializing and sending rendered
- * HTML;
- * - tests might want to delay assertions until the application becomes stable;
- *
- * @usageNotes
- * ```typescript
- * const pendingTasks = inject(ExperimentalPendingTasks);
- * const taskCleanup = pendingTasks.add();
- * // do work that should block application's stability and then:
- * taskCleanup();
- * ```
- *
- * This API is experimental. Neither the shape, nor the underlying behavior is stable and can change
- * in patch versions. We will iterate on the exact API based on the feedback and our understanding
- * of the problem and solution space.
- *
- * @publicApi
- * @experimental
- */
-export declare class ExperimentalPendingTasks {
-    private internalPendingTasks;
-    private scheduler;
-    /**
-     * Adds a new task that should block application's stability.
-     * @returns A cleanup function that removes a task when called.
-     */
-    add(): () => void;
-    /**
-     * Runs an asynchronous function and blocks the application's stability until the function completes.
-     *
-     * ```
-     * pendingTasks.run(async () => {
-     *   const userData = await fetch('/api/user');
-     *   this.userData.set(userData);
-     * });
-     * ```
-     *
-     * Application stability is at least delayed until the next tick after the `run` method resolves
-     * so it is safe to make additional updates to application state that would require UI synchronization:
-     *
-     * ```
-     * const userData = await pendingTasks.run(() => fetch('/api/user'));
-     * this.userData.set(userData);
-     * ```
-     *
-     * @param fn The asynchronous function to execute
-     */
-    run<T>(fn: () => Promise<T>): Promise<T>;
-    /** @nocollapse */
-    static ɵprov: unknown;
-}
-
 /**
  * Definition of what a factory function should look like.
  */
@@ -4716,21 +4693,6 @@ export declare interface GetTestability {
  * */
 declare const GLOBAL_PUBLISH_EXPANDO_KEY = "ng";
 
-/**
- * This class is the delegate for `EventDelegationPlugin`. It represents the
- * noop version of this class, with the enabled version set when
- * `provideGlobalEventDelegation` is called.
- */
-declare class GlobalEventDelegation implements OnDestroy {
-    private eventContractDetails;
-    ngOnDestroy(): void;
-    supports(eventType: string): boolean;
-    addEventListener(element: HTMLElement, eventType: string, handler: Function): Function;
-    removeEventListener(element: HTMLElement, eventType: string, callback: Function): void;
-    static ɵfac: i0.ɵɵFactoryDeclaration<GlobalEventDelegation, never>;
-    static ɵprov: i0.ɵɵInjectableDeclaration<GlobalEventDelegation>;
-}
-
 /**
  * The goal here is to make sure that the browser DOM API is the Renderer.
  * We do this by defining a subset of DOM API to be the renderer and then
@@ -6300,27 +6262,6 @@ export declare type InputOptionsWithTransform<T, TransformT> = Required<Pick<Inp
 export declare interface InputSignal<T> extends InputSignalWithTransform<T, T> {
 }
 
-/**
- * Reactive node type for an input signal. An input signal extends a signal.
- * There are special properties to enable transforms and required inputs.
- */
-declare interface InputSignalNode<T, TransformT> extends SignalNode<T> {
-    /**
-     * User-configured transform that will run whenever a new value is applied
-     * to the input signal node.
-     */
-    transformFn: ((value: TransformT) => T) | undefined;
-    /**
-     * Applies a new value to the input signal. Expects transforms to be run
-     * manually before.
-     *
-     * This function is called by the framework runtime code whenever a binding
-     * changes. The value can in practice be anything at runtime, but for typing
-     * purposes we assume it's a valid `T` value. Type-checking will enforce that.
-     */
-    applyValueToInputSignal<T, TransformT>(node: InputSignalNode<T, TransformT>, value: T): void;
-}
-
 /**
  * `InputSignalWithTransform` represents a special `Signal` for a
  * directive/component input with a `transform` function.
@@ -6346,7 +6287,7 @@ declare interface InputSignalNode<T, TransformT> extends SignalNode<T> {
  * @publicAPI
  */
 export declare interface InputSignalWithTransform<T, TransformT> extends Signal<T> {
-    [SIGNAL]: InputSignalNode<T, TransformT>;
+    [ɵSIGNAL]: ɵInputSignalNode<T, TransformT>;
     [ɵINPUT_SIGNAL_BRAND_READ_TYPE]: T;
     [ɵINPUT_SIGNAL_BRAND_WRITE_TYPE]: TransformT;
 }
@@ -7143,6 +7084,7 @@ declare interface LView<T = unknown> extends Array<any> {
      * Effect scheduling operations that need to run during this views's update pass.
      */
     [EFFECTS_TO_SCHEDULE]: Array<() => void> | null;
+    [EFFECTS]: Set<ViewEffectNode> | null;
     /**
      * A collection of callbacks functions that are executed when a given LView is destroyed. Those
      * are user defined, LView-specific destroy callbacks that don't have any corresponding TView
@@ -7166,8 +7108,6 @@ declare interface LViewEnvironment {
     rendererFactory: RendererFactory;
     /** An optional custom sanitizer. */
     sanitizer: Sanitizer | null;
-    /** Container for reactivity system `effect`s. */
-    inlineEffectRunner: ɵEffectScheduler | null;
     /** Scheduler for change detection to notify when application state changes. */
     changeDetectionScheduler: ɵChangeDetectionScheduler | null;
 }
@@ -7396,7 +7336,7 @@ export declare interface ModelOptions {
  * @publicAPI
  */
 export declare interface ModelSignal<T> extends WritableSignal<T>, InputSignal<T>, OutputRef<T> {
-    [SIGNAL]: InputSignalNode<T, T>;
+    [ɵSIGNAL]: ɵInputSignalNode<T, T>;
 }
 
 /**
@@ -8317,6 +8257,78 @@ export declare const PACKAGE_ROOT_URL: InjectionToken<string>;
 
 declare const PARENT = 3;
 
+/**
+ * Service that keeps track of pending tasks contributing to the stableness of Angular
+ * application. While several existing Angular services (ex.: `HttpClient`) will internally manage
+ * tasks influencing stability, this API gives control over stability to library and application
+ * developers for specific cases not covered by Angular internals.
+ *
+ * The concept of stability comes into play in several important scenarios:
+ * - SSR process needs to wait for the application stability before serializing and sending rendered
+ * HTML;
+ * - tests might want to delay assertions until the application becomes stable;
+ *
+ * @usageNotes
+ * ```typescript
+ * const pendingTasks = inject(PendingTasks);
+ * const taskCleanup = pendingTasks.add();
+ * // do work that should block application's stability and then:
+ * taskCleanup();
+ * ```
+ *
+ * @publicApi
+ * @developerPreview
+ */
+export declare class PendingTasks {
+    private internalPendingTasks;
+    private scheduler;
+    /**
+     * Adds a new task that should block application's stability.
+     * @returns A cleanup function that removes a task when called.
+     */
+    add(): () => void;
+    /**
+     * Runs an asynchronous function and blocks the application's stability until the function completes.
+     *
+     * ```
+     * pendingTasks.run(async () => {
+     *   const userData = await fetch('/api/user');
+     *   this.userData.set(userData);
+     * });
+     * ```
+     *
+     * Application stability is at least delayed until the next tick after the `run` method resolves
+     * so it is safe to make additional updates to application state that would require UI synchronization:
+     *
+     * ```
+     * const userData = await pendingTasks.run(() => fetch('/api/user'));
+     * this.userData.set(userData);
+     * ```
+     *
+     * @param fn The asynchronous function to execute
+     */
+    run<T>(fn: () => Promise<T>): Promise<T>;
+    /** @nocollapse */
+    static ɵprov: unknown;
+}
+
+/**
+ * Internal implementation of the pending tasks service.
+ */
+declare class PendingTasksInternal implements OnDestroy {
+    private taskId;
+    private pendingTasks;
+    private get _hasPendingTasks();
+    hasPendingTasks: BehaviorSubject<boolean>;
+    add(): number;
+    remove(taskId: number): void;
+    ngOnDestroy(): void;
+    /** @nocollapse */
+    static ɵprov: unknown;
+}
+export { PendingTasksInternal as ɵPendingTasks }
+export { PendingTasksInternal as ɵPendingTasksInternal }
+
 /**
  * Type of the Pipe metadata.
  *
@@ -9030,7 +9042,7 @@ declare interface RDomTokenList {
     remove(token: string): void;
 }
 
-declare const REACTIVE_TEMPLATE_CONSUMER = 23;
+declare const REACTIVE_TEMPLATE_CONSUMER = 24;
 
 declare interface ReactiveLViewConsumer extends ReactiveNode {
     lView: LView | null;
@@ -9391,6 +9403,11 @@ export declare interface RendererType2 {
     data: {
         [kind: string]: any;
     };
+    /**
+     * A function added by the {@link ɵɵExternalStylesFeature} and used by the framework to create
+     * the list of external runtime style URLs.
+     */
+    getExternalStyles?: ((encapsulationId?: string) => string[]) | null;
 }
 
 /**
@@ -9480,9 +9497,15 @@ export declare abstract class Sanitizer {
  */
 declare type SanitizerFn = (value: any, tagName?: string, propName?: string) => string | TrustedHTML | TrustedScript | TrustedScriptURL;
 
+
+/**
+ * Abstraction that encompasses any kind of effect that can be scheduled.
+ */
 declare interface SchedulableEffect {
     run(): void;
-    creationZone: unknown;
+    zone: {
+        run<T>(fn: () => T): T;
+    } | null;
 }
 
 
@@ -9699,7 +9722,7 @@ export declare function setTestabilityGetter(getter: GetTestability): void;
  * Ordinary values can be turned into `Signal`s with the `signal` function.
  */
 export declare type Signal<T> = (() => T) & {
-    [SIGNAL]: unknown;
+    [ɵSIGNAL]: unknown;
 };
 
 /**
@@ -11667,7 +11690,7 @@ export declare const ViewChild: ViewChildDecorator;
  * }
  * ```
  *
- * @developerPreview
+ * @publicAPI
  * @initializerApiFunction
  */
 export declare const viewChild: ViewChildFunction;
@@ -11749,7 +11772,7 @@ export declare interface ViewChildDecorator {
  * It is a special function that also provides access to required query results via the `.required`
  * property.
  *
- * @developerPreview
+ * @publicAPI
  * @docsPrivate Ignored because `viewChild` is the canonical API entry.
  */
 export declare interface ViewChildFunction {
@@ -11757,7 +11780,7 @@ export declare interface ViewChildFunction {
      * Initializes a view child query. Consider using `viewChild.required` for queries that should
      * always match.
      *
-     * @developerPreview
+     * @publicAPI
      */
     <LocatorT>(locator: ProviderToken<LocatorT> | string): Signal<LocatorT | undefined>;
     <LocatorT, ReadT>(locator: ProviderToken<LocatorT> | string, opts: {
@@ -11766,7 +11789,7 @@ export declare interface ViewChildFunction {
     /**
      * Initializes a view child query that is expected to always match an element.
      *
-     * @developerPreview
+     * @publicAPI
      */
     required: {
         <LocatorT>(locator: ProviderToken<LocatorT> | string): Signal<LocatorT>;
@@ -12064,6 +12087,10 @@ export declare abstract class ViewContainerRef {
     abstract detach(index?: number): ViewRef | null;
 }
 
+declare interface ViewEffectNode extends EffectNode {
+    view: LView;
+}
+
 
 /**
  * Defines the CSS styles encapsulation policies for the {@link Component} decorator's
@@ -12170,6 +12197,27 @@ export declare interface WritableSignal<T> extends Signal<T> {
     asReadonly(): Signal<T>;
 }
 
+/**
+ * A wrapper around `ZoneAwareQueueingScheduler` that schedules flushing via the microtask queue
+ * when.
+ */
+declare class ZoneAwareEffectScheduler implements ɵEffectScheduler {
+    private queuedEffectCount;
+    private queues;
+    private readonly pendingTasks;
+    protected taskId: number | null;
+    schedule(handle: SchedulableEffect): void;
+    private enqueue;
+    /**
+     * Run all scheduled effects.
+     *
+     * Execution order of effects within the same zone is guaranteed to be FIFO, but there is no
+     * ordering guarantee between effects scheduled in different zones.
+     */
+    flush(): void;
+    private flushQueue;
+}
+
 /**
  * Sanitizes the given unsafe, untrusted HTML fragment, and returns HTML text that is safe to add to
  * the DOM in a browser environment.
@@ -12624,6 +12672,11 @@ export declare interface ɵComponentDef<T> extends ɵDirectiveDef<T> {
      * standalone injectors.
      */
     getStandaloneInjector: ((parentInjector: EnvironmentInjector) => EnvironmentInjector | null) | null;
+    /**
+     * A function added by the {@link ɵɵExternalStylesFeature} and used by the framework to create
+     * the list of external runtime style URLs.
+     */
+    getExternalStyles: ((encapsulationId?: string) => string[]) | null;
     /**
      * Used to store the result of `noSideEffects` function so that it is not removed by closure
      * compiler. The property should never be read.
@@ -12931,7 +12984,7 @@ export declare interface ɵDirectiveDef<T> {
     findHostDirectiveDefs: ((currentDef: ɵDirectiveDef<unknown>, matchedDefs: ɵDirectiveDef<unknown>[], hostDirectiveDefs: HostDirectiveDefs) => void) | null;
     /** Additional directives to be applied whenever the directive has been matched. */
     hostDirectives: HostDirectiveDef[] | null;
-    setInput: (<U extends T>(this: ɵDirectiveDef<U>, instance: U, inputSignalNode: null | InputSignalNode<unknown, unknown>, value: any, publicName: string, privateName: string) => void) | null;
+    setInput: (<U extends T>(this: ɵDirectiveDef<U>, instance: U, inputSignalNode: null | ɵInputSignalNode<unknown, unknown>, value: any, publicName: string, privateName: string) => void) | null;
 }
 
 /**
@@ -12952,7 +13005,7 @@ export declare abstract class ɵEffectScheduler {
      *
      * It is an error to attempt to execute any effects synchronously during a scheduling operation.
      */
-    abstract scheduleEffect(e: SchedulableEffect): void;
+    abstract schedule(e: SchedulableEffect): void;
     /**
      * Run any scheduled effects.
      */
@@ -13130,8 +13183,6 @@ export declare function ɵgetUnknownPropertyStrictMode(): boolean;
 
 export declare const ɵglobal: any;
 
-export declare const ɵGLOBAL_EVENT_DELEGATION: InjectionToken<GlobalEventDelegation>;
-
 /**
  * Default debug tools available under `window.ng`.
  */
@@ -13216,6 +13267,27 @@ declare const ɵINPUT_SIGNAL_BRAND_READ_TYPE: unique symbol;
 
 export declare const ɵINPUT_SIGNAL_BRAND_WRITE_TYPE: unique symbol;
 
+/**
+ * Reactive node type for an input signal. An input signal extends a signal.
+ * There are special properties to enable transforms and required inputs.
+ */
+export declare interface ɵInputSignalNode<T, TransformT> extends SignalNode<T> {
+    /**
+     * User-configured transform that will run whenever a new value is applied
+     * to the input signal node.
+     */
+    transformFn: ((value: TransformT) => T) | undefined;
+    /**
+     * Applies a new value to the input signal. Expects transforms to be run
+     * manually before.
+     *
+     * This function is called by the framework runtime code whenever a binding
+     * changes. The value can in practice be anything at runtime, but for typing
+     * purposes we assume it's a valid `T` value. Type-checking will enforce that.
+     */
+    applyValueToInputSignal<T, TransformT>(node: ɵInputSignalNode<T, TransformT>, value: T): void;
+}
+
 /**
  * `InjectionToken` used to configure how to call the `ErrorHandler`.
  *
@@ -13385,6 +13457,17 @@ export declare enum ɵLocaleDataIndex {
     ExtraData = 21
 }
 
+/**
+ * Create a global `Effect` for the given reactive function.
+ */
+export declare function ɵmicrotaskEffect(effectFn: (onCleanup: EffectCleanupRegisterFn) => void, options?: CreateEffectOptions): EffectRef;
+
+export declare class ɵMicrotaskEffectScheduler extends ZoneAwareEffectScheduler {
+    schedule(effect: SchedulableEffect): void;
+    /** @nocollapse */
+    static ɵprov: unknown;
+}
+
 
 export declare const ɵNG_COMP_DEF: string;
 
@@ -13530,7 +13613,8 @@ export declare const enum ɵNotificationSource {
     ViewAttached = 9,
     ViewDetachedFromDOM = 10,
     AsyncAnimationsLoaded = 11,
-    PendingTaskRemoved = 12
+    PendingTaskRemoved = 12,
+    RootEffect = 13
 }
 
 /**
@@ -13539,21 +13623,6 @@ export declare const enum ɵNotificationSource {
  */
 export declare function ɵpatchComponentDefWithScope<C>(componentDef: ɵComponentDef<C>, transitiveScopes: ɵNgModuleTransitiveScopes): void;
 
-/**
- * Internal implementation of the pending tasks service.
- */
-export declare class ɵPendingTasks implements OnDestroy {
-    private taskId;
-    private pendingTasks;
-    private get _hasPendingTasks();
-    hasPendingTasks: BehaviorSubject<boolean>;
-    add(): number;
-    remove(taskId: number): void;
-    ngOnDestroy(): void;
-    /** @nocollapse */
-    static ɵprov: unknown;
-}
-
 
 /**
  * A guarded `performance.mark` for feature marking.
@@ -13664,13 +13733,6 @@ export declare const enum ɵProfilerEvent {
  */
 export declare const ɵPROVIDED_NG_ZONE: InjectionToken<boolean>;
 
-/**
- * Returns a set of providers required to setup support for event delegation.
- * @param multiContract - Experimental support to provide one event contract
- * when there are multiple binaries on the page.
- */
-export declare function ɵprovideGlobalEventDelegation(multiContract?: boolean): Provider[];
-
 /**
  * An object that contains information about a provider that has been configured
  *
@@ -14106,6 +14168,8 @@ export declare function ɵsetUnknownElementStrictMode(shouldThrow: boolean): voi
  */
 export declare function ɵsetUnknownPropertyStrictMode(shouldThrow: boolean): void;
 
+export { ɵSIGNAL }
+
 /**
  * Marker used in a comment node to ensure hydration content integrity
  */
@@ -15658,6 +15722,18 @@ export declare function ɵɵelementStart(index: number, name: string, attrsIndex
  */
 export declare function ɵɵenableBindings(): void;
 
+/**
+ * A feature that adds support for external runtime styles for a component.
+ * An external runtime style is a URL to a CSS stylesheet that contains the styles
+ * for a given component. For browsers, this URL will be used in an appended `link` element
+ * when the component is rendered. This feature is typically used for Hot Module Replacement
+ * (HMR) of component stylesheets by leveraging preexisting global stylesheet HMR available
+ * in most development servers.
+ *
+ * @codeGenApi
+ */
+export declare function ɵɵExternalStylesFeature(styleUrls: string[]): ComponentDefFeature;
+
 /**
  * @publicApi
  */
@@ -17006,6 +17082,14 @@ export declare function ɵɵrepeaterTrackByIdentity<T>(_: number, value: T): T;
  */
 export declare function ɵɵrepeaterTrackByIndex(index: number): number;
 
+/**
+ * Replaces the metadata of a component type and re-renders all live instances of the component.
+ * @param type Class whose metadata will be replaced.
+ * @param applyMetadata Callback that will apply a new set of metadata on the `type` when invoked.
+ * @codeGenApi
+ */
+export declare function ɵɵreplaceMetadata(type: Type<unknown>, applyMetadata: () => void): void;
+
 /**
  * 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.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@angular/core",
-  "version": "19.0.0-next.6",
+  "version": "19.0.0-next.8",
   "description": "Angular - the core framework",
   "author": "angular",
   "license": "MIT",

package/primitives/event-dispatch/index.d.ts

@@ -1,5 +1,5 @@
 /**
- * @license Angular v19.0.0-next.6
+ * @license Angular v19.0.0-next.8
  * (c) 2010-2024 Google LLC. https://angular.io/
  * License: MIT
  */