static-injector 6.4.0 → 7.0.0

package/import/application/application_tokens.d.ts

@@ -0,0 +1,58 @@
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.dev/license
+ */
+import { InjectionToken } from '../di/injection_token';
+/**
+ * A DI token representing a string ID, used
+ * primarily for prefixing application attributes and CSS styles when
+ * {@link ViewEncapsulation#Emulated} is being used.
+ *
+ * The token is needed in cases when multiple applications are bootstrapped on a page
+ * (for example, using `bootstrapApplication` calls). In this case, ensure that those applications
+ * have different `APP_ID` value setup. For example:
+ *
+ * ```ts
+ * bootstrapApplication(ComponentA, {
+ *   providers: [
+ *     { provide: APP_ID, useValue: 'app-a' },
+ *     // ... other providers ...
+ *   ]
+ * });
+ *
+ * bootstrapApplication(ComponentB, {
+ *   providers: [
+ *     { provide: APP_ID, useValue: 'app-b' },
+ *     // ... other providers ...
+ *   ]
+ * });
+ * ```
+ *
+ * By default, when there is only one application bootstrapped, you don't need to provide the
+ * `APP_ID` token (the `ng` will be used as an app ID).
+ *
+ * @publicApi
+ */
+export declare const APP_ID: InjectionToken<string>;
+/**
+ * A configuration object for the image-related options. Contains:
+ * - breakpoints: An array of integer breakpoints used to generate
+ *      srcsets for responsive images.
+ * - disableImageSizeWarning: A boolean value. Setting this to true will
+ *      disable console warnings about oversized images.
+ * - disableImageLazyLoadWarning: A boolean value. Setting this to true will
+ *      disable console warnings about LCP images configured with `loading="lazy"`.
+ * Learn more about the responsive image configuration in [the NgOptimizedImage
+ * guide](guide/image-optimization).
+ * Learn more about image warning options in [the related error page](errors/NG0913).
+ * @publicApi
+ */
+export type ImageConfig = {
+    breakpoints?: number[];
+    placeholderResolution?: number;
+    disableImageSizeWarning?: boolean;
+    disableImageLazyLoadWarning?: boolean;
+};

package/import/application/stability_debug.d.ts

@@ -0,0 +1,13 @@
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.dev/license
+ */
+import { InjectionToken } from '../di/injection_token';
+export declare const DEBUG_TASK_TRACKER: InjectionToken<DebugTaskTracker>;
+export interface DebugTaskTracker {
+    add(taskId: number): void;
+    remove(taskId: number): void;
+}

package/import/authoring/output/output_ref.d.ts

@@ -0,0 +1,37 @@
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.dev/license
+ */
+/**
+ * Function that can be used to manually clean up a
+ * programmatic {@link OutputRef#subscribe} subscription.
+ *
+ * Note: Angular will automatically clean up subscriptions
+ * when the directive/component of the output is destroyed.
+ *
+ * @see [Subscribing to outputs programmatically](guide/components/outputs#subscribing-to-outputs-programmatically)
+ *
+ * @publicAPI
+ */
+export interface OutputRefSubscription {
+    unsubscribe(): void;
+}
+/**
+ * A reference to an Angular output.
+ *
+ * @publicAPI
+ * @see [Subscribing to outputs programmatically](guide/components/outputs#subscribing-to-outputs-programmatically)
+ */
+export interface OutputRef<T> {
+    /**
+     * Registers a callback that is invoked whenever the output
+     * emits a new value of type `T`.
+     *
+     * Angular will automatically clean up the subscription when
+     * the directive/component of the output is destroyed.
+     */
+    subscribe(callback: (value: T) => void): OutputRefSubscription;
+}

package/import/change_detection/scheduling/zoneless_scheduling.d.ts

@@ -5,7 +5,6 @@
  * Use of this source code is governed by an MIT-style license that can be
  * found in the LICENSE file at https://angular.dev/license
  */
-import { InjectionToken } from '../../di/injection_token';
 export declare const enum NotificationSource {
     MarkAncestorsForTraversal = 0,
     SetInput = 1,
@@ -29,9 +28,3 @@ export declare abstract class ChangeDetectionScheduler {
     abstract notify(source: NotificationSource): void;
     abstract runningTick: boolean;
 }
-/** Token used to indicate if zoneless was enabled via provideZonelessChangeDetection(). */
-export declare const ZONELESS_ENABLED: InjectionToken<boolean>;
-/** Token used to indicate `provideZonelessChangeDetection` was used. */
-export declare const PROVIDED_ZONELESS: InjectionToken<boolean>;
-export declare const ZONELESS_SCHEDULER_DISABLED: InjectionToken<boolean>;
-export declare const SCHEDULE_IN_ROOT_ZONE: InjectionToken<boolean>;

package/import/core_reactivity_export_internal.d.ts

@@ -6,7 +6,7 @@
  * found in the LICENSE file at https://angular.dev/license
  */
 export { SIGNAL as ɵSIGNAL } from '../primitives/signals';
-export { isSignal, Signal, ValueEqualityFn } from './render3/reactivity/api';
+export { isSignal, isWritableSignal, Signal, ValueEqualityFn } from './render3/reactivity/api';
 export { computed, CreateComputedOptions } from './render3/reactivity/computed';
 export { CreateSignalOptions, signal, WritableSignal, ɵunwrapWritableSignal } from './render3/reactivity/signal';
 export { linkedSignal } from './render3/reactivity/linked_signal';

package/import/defer/idle_service.d.ts

@@ -0,0 +1,42 @@
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.dev/license
+ */
+import { AbstractType } from '../interface/type';
+import { InjectionToken } from '../di/injection_token';
+import type { EnvironmentProviders } from '../di/interface/provider';
+/**
+ * Service which configures custom 'on idle' behavior for Angular features like `@defer`.
+ *
+ * @publicApi
+ *
+ * @see [Customizing `idle` behavior](guide/templates/defer#customizing-idle-behavior)
+ *
+ */
+export interface IdleService {
+    /**
+     * Schedule `callback` to be executed when the current application or browser is considered idle.
+     *
+     * @returns an id which allows the scheduled callback to be cancelled before it executes.
+     */
+    requestOnIdle(callback: (deadline?: IdleDeadline) => void, options?: IdleRequestOptions): number;
+    /**
+     * Cancel a previously scheduled callback using the id associated with it.
+     */
+    cancelOnIdle(id: number): void;
+}
+export declare const IDLE_SERVICE: InjectionToken<IdleService>;
+/**
+ * Configures Angular to use the given DI token as its `IdleService`.
+ *
+ * The given token must be available for injection from the root injector, and the injected value
+ * must implement the `IdleService` interface.
+ *
+ * @publicApi
+ *
+ * @see [Customizing `idle` behavior](guide/templates/defer#customizing-idle-behavior)
+ */
+export declare function provideIdleServiceWith(useExisting: AbstractType<IdleService> | InjectionToken<IdleService>): EnvironmentProviders;

package/import/di/create_injector.d.ts

@@ -6,7 +6,7 @@
  * found in the LICENSE file at https://angular.dev/license
  */
 import type { Injector } from './injector';
-import type { Provider, StaticProvider } from './interface/provider';
+import type { EnvironmentProviders, Provider, StaticProvider } from './interface/provider';
 import { R3Injector } from './r3_injector';
 import { InjectorScope } from './scope';
 /**
@@ -18,4 +18,4 @@ export declare function createInjector(defType: any, parent?: Injector | null, a
  * where resolving the injector types immediately can lead to an infinite loop. The injector types
  * should be resolved at a later point by calling `_resolveInjectorDefTypes`.
  */
-export declare function createInjectorWithoutInjectorInstances(defType: any, parent?: Injector | null, additionalProviders?: Array<Provider | StaticProvider> | null, name?: string, scopes?: Set<InjectorScope>): R3Injector;
+export declare function createInjectorWithoutInjectorInstances(defType: any, parent?: Injector | null, additionalProviders?: Array<Provider | EnvironmentProviders> | null, name?: string, scopes?: Set<InjectorScope>): R3Injector;

package/import/di/forward_ref.d.ts

@@ -36,7 +36,7 @@ export interface ForwardRefFn {
  * @Component({
  *   imports: [ChildComponent],
  *   selector: 'app-parent',
- *   template: `<app-child [hideParent]="hideParent()"></app-child>`,
+ *   template: `<app-child [hideParent]="hideParent()"/>`,
  * })
  * export class ParentComponent {
  *    hideParent = input.required<boolean>();
@@ -47,7 +47,7 @@ export interface ForwardRefFn {
  *   imports: [forwardRef(() => ParentComponent)],
  *   selector: 'app-child',
  *   template: `
- *    @if(!hideParent() {
+ *    @if(!hideParent()) {
  *       <app-parent/>
  *    }
  *  `,

package/import/di/index.d.ts

@@ -2,3 +2,7 @@ export { ProviderToken } from './provider_token';
 export { assertInInjectionContext, runInInjectionContext } from './contextual';
 export { EnvironmentInjector } from './r3_injector';
 export { FactoryProvider } from './interface/provider';
+export { inject } from './injector_compatibility';
+export { InjectionToken } from './injection_token';
+export { Injector } from './injector';
+export { injectAsync, InjectAsyncOptions, PrefetchTrigger, onIdle } from './inject_async';

package/import/di/inject_async.d.ts

@@ -0,0 +1,91 @@
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.dev/license
+ */
+import { DefaultExport } from '../util/default_export';
+import { ProviderToken } from './provider_token';
+/**
+ * A helper function that allows to inject dependencies asynchronously,
+ * which can be useful in cases when the dependency is not needed immediately and can be loaded lazily.
+ *
+ * NOTE: To enable lazy loading, the injected service must be auto-provided. This means it should be decorated with either `@Injectable({providedIn: 'root'})` or `@Service()`.
+ *
+ * @param loader A function that returns a promise resolving to the injectable service
+ * @param options Configuration options for the async injection
+ *
+ * @returns A function that returns a promise resolving to the requested service instance.
+ *
+ * @usageNotes
+ *
+ * ```ts
+ * class MyCmp {
+ *  someSvc = injectAsync(() => import('..'));
+ *
+ *  async onClick() {
+ *    (await this.someSvc()).handleClick();
+ *  }
+ * }
+ *
+ * // we can also configure prefetching:
+ * injectAsync(.., {prefetch: onIdle})
+ * ```
+ *
+ * @see [Lazy loading services](guide/di/lazy-loading-services)
+ * @see [Injection context](guide/di/dependency-injection-context)
+ *
+ * @publicApi 22.0
+ */
+export declare function injectAsync<T>(loader: () => Promise<ProviderToken<T>>, options?: InjectAsyncOptions): () => Promise<T>;
+export declare function injectAsync<T>(loader: () => Promise<DefaultExport<ProviderToken<T>>>, options?: InjectAsyncOptions): () => Promise<T>;
+/**
+ * Interface for `options` argument used within `injectAsync` call.
+ *
+ * @see [Prefetching the dependency](guide/di/lazy-loading-services#prefetching-the-dependency)
+ *
+ * @publicApi 22.0
+ */
+export interface InjectAsyncOptions {
+    /**
+     * A trigger to eagerly prefetch the lazy-loaded dependency before it is requested.
+     *
+     */
+    prefetch?: PrefetchTrigger;
+}
+/**
+ * A function that returns a promise which, when resolved, will trigger the prefetching of
+ * the lazy-loaded dependency.
+ *
+ * @see {@link onIdle}
+ * @see [Prefetching the dependency](guide/di/lazy-loading-services#prefetching-the-dependency)
+ *
+ * @publicApi 22.0
+ */
+export type PrefetchTrigger = () => Promise<void>;
+/**
+ * A `PrefetchTrigger` helper function to provide the logic of triggering dependency loading
+ * when the browser becomes idle.
+ *
+ * Internally delegates to the configured {@link IdleService}, whose default implementation uses
+ * [`requestIdleCallback`](https://developer.mozilla.org/docs/Web/API/Window/requestIdleCallback)
+ * when available and falls back to `setTimeout` otherwise. The default behavior can be replaced
+ * with `provideIdleServiceWith`.
+ *
+ * @usageNotes
+ *
+ * ```ts
+ * injectAsync(import(...), {prefetch: onIdle})
+ *
+ * // or with custom idle options:
+ * injectAsync(import(...), {prefetch: () => onIdle({timeout: 100})})
+ * ```
+ *
+ * @see [Prefetching the dependency](guide/di/lazy-loading-services#prefetching-the-dependency)
+ *
+ * @publicApi 22.0
+ */
+export declare function onIdle(options?: {
+    timeout?: number;
+}): Promise<void>;

package/import/di/injectable.d.ts

@@ -41,8 +41,14 @@ export interface InjectableDecorator {
      *
      */
     (): TypeDecorator;
+    /**
+     * @deprecated The `providedIn: NgModule` or `providedIn:'any'` options are deprecated. Please use the other signatures.
+     */
     (options?: {
-        providedIn: Type<any> | 'root' | 'platform' | 'any' | null;
+        providedIn: Type<any> | 'any';
+    } & InjectableProvider): TypeDecorator;
+    (options?: {
+        providedIn: 'root' | 'platform' | null;
     } & InjectableProvider): TypeDecorator;
     new (): Injectable;
     new (options?: {

package/import/di/injection_token.d.ts

@@ -60,6 +60,13 @@ import { Type } from '../interface/type';
 export declare class InjectionToken<T> {
     protected _desc: string;
     readonly ɵprov: unknown;
+    /**
+     * @deprecated The `providedIn: NgModule` or `providedIn:'any'` options are deprecated. Please use the other signature.
+     */
+    constructor(_desc: string, options: {
+        providedIn: Type<any> | 'any';
+        factory: () => T;
+    });
     /**
      * @param _desc   Description for the token,
      *                used only for debugging purposes,

package/import/di/injector.d.ts

@@ -84,7 +84,7 @@ export declare abstract class Injector {
         name?: string;
     }): DestroyableInjector;
     /** @nocollapse */
-    static ɵprov: unknown;
+    static ɵprov: import("./interface/defs").ɵɵInjectableDeclaration<Injector>;
 }
 /**
  * An Injector that the owner can destroy and trigger the DestroyRef.destroy hooks.

package/import/di/injector_compatibility.d.ts

@@ -108,4 +108,3 @@ export declare function attachInjectFlag(decorator: any, flag: InternalInjectFla
  * @param token Token that may contain monkey-patched DI flags property.
  */
 export declare function getInjectFlag(token: any): number | undefined;
-export declare function formatError(text: string, obj: any, injectorErrorName: string, source?: string | null): string;

package/import/di/interface/defs.d.ts

@@ -123,8 +123,8 @@ export interface InjectorTypeWithProviders<T> {
 export declare function ɵɵdefineInjectable<T>(opts: {
     token: unknown;
     providedIn?: Type<any> | 'root' | 'platform' | 'any' | 'environment' | null;
-    factory: () => T;
-}): unknown;
+    factory: (parent?: Type<any>) => T;
+}): ɵɵInjectableDeclaration<T>;
 /**
  * Construct an `InjectorDef` which configures an injector.
  *

package/import/di/interface/provider.d.ts

@@ -348,18 +348,3 @@ export interface ModuleWithProviders<T> {
     ngModule: Type<T>;
     providers?: Array<Provider | EnvironmentProviders>;
 }
-/**
- * Providers that were imported from NgModules via the `importProvidersFrom` function.
- *
- * These providers are meant for use in an application injector (or other environment injectors) and
- * should not be used in component injectors.
- *
- * This type cannot be directly implemented. It's returned from the `importProvidersFrom` function
- * and serves to prevent the extracted NgModule providers from being used in the wrong contexts.
- *
- * @see {@link importProvidersFrom}
- *
- * @publicApi
- * @deprecated replaced by `EnvironmentProviders`
- */
-export type ImportedNgModuleProviders = EnvironmentProviders;

package/import/document.d.ts

@@ -0,0 +1,18 @@
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.dev/license
+ */
+import { InjectionToken } from './di';
+/**
+ * A DI Token representing the main rendering context.
+ * In a browser and SSR this is the DOM Document.
+ * When using SSR, that document is created by [Domino](https://github.com/angular/domino).
+ *
+ * @see [Accessing Document via DI](guide/ssr#accessing-document-via-di)
+ *
+ * @publicApi
+ */
+export declare const DOCUMENT: InjectionToken<Document>;

package/import/errors.d.ts

@@ -22,6 +22,8 @@
  *  - animations: 3000-3999
  *  - router: 4000-4999
  *  - platform-browser: 5000-5500
+ *  - service-worker: 5600-5699
+ *  - platform-server: 5700-5800
  */
 export declare const enum RuntimeErrorCode {
     EXPRESSION_CHANGED_AFTER_CHECKED = -100,
@@ -31,12 +33,13 @@ export declare const enum RuntimeErrorCode {
     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,
+    INVALID_INJECTION_TOKEN = -204,
+    INJECTOR_ALREADY_DESTROYED = -205,
+    PROVIDER_IN_WRONG_CONTEXT = -207,
     MISSING_INJECTION_TOKEN = 208,
     INVALID_MULTI_PROVIDER = -209,
     MISSING_DOCUMENT = 210,
+    INVALID_APP_ID = 211,
     MULTIPLE_COMPONENTS_MATCH = -300,
     EXPORT_NOT_FOUND = -301,
     PIPE_NOT_FOUND = -302,
@@ -93,18 +96,18 @@ export declare const enum RuntimeErrorCode {
     MISSING_ZONEJS = 908,
     UNEXPECTED_ZONE_STATE = 909,
     UNSAFE_ATTRIBUTE_BINDING = -910,
-    /**
-     * @deprecated use `UNSAFE_ATTRIBUTE_BINDING` instead.
-     */
-    UNSAFE_IFRAME_ATTRS = -910,
     VIEW_ALREADY_DESTROYED = 911,
     COMPONENT_ID_COLLISION = -912,
     IMAGE_PERFORMANCE_WARNING = -913,
     UNEXPECTED_ZONEJS_PRESENT_IN_ZONELESS_MODE = 914,
     MISSING_NG_MODULE_DEFINITION = 915,
     MISSING_DIRECTIVE_DEFINITION = 916,
-    NO_COMPONENT_FACTORY_FOUND = 917,
     EXTERNAL_RESOURCE_LOADING_FAILED = 918,
+    DEF_TYPE_UNDEFINED = -919,
+    NG_MODULE_ID_NOT_FOUND = 920,
+    DUPLICATE_NG_MODULE_ID = 921,
+    VIEW_DESTROYED_INSERT_ERROR = 922,
+    VIEW_DESTROYED_MOVE_ERROR = 923,
     REQUIRED_INPUT_NO_VALUE = -950,
     REQUIRED_QUERY_NO_VALUE = -951,
     REQUIRED_MODEL_NO_VALUE = 952,
@@ -114,7 +117,8 @@ export declare const enum RuntimeErrorCode {
     RUNTIME_DEPS_INVALID_IMPORTED_TYPE = 980,
     RUNTIME_DEPS_ORPHAN_COMPONENT = 981,
     MUST_PROVIDE_STREAM_OPTION = 990,
-    RESOURCE_COMPLETED_BEFORE_PRODUCING_VALUE = 991
+    RESOURCE_COMPLETED_BEFORE_PRODUCING_VALUE = 991,
+    INVALID_RESOURCE_CREATION_IN_PARAMS = 992
 }
 /**
  * Class that represents a runtime error.

package/import/event_emitter.d.ts

@@ -0,0 +1,101 @@
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.dev/license
+ */
+import { Subject, Subscription } from 'rxjs';
+import { OutputRef } from './authoring/output/output_ref';
+/**
+ * Use in components with the `@Output` directive to emit custom events
+ * synchronously or asynchronously, and register handlers for those events
+ * by subscribing to an instance.
+ *
+ * @usageNotes
+ *
+ * Extends
+ * [RxJS `Subject`](https://rxjs.dev/api/index/class/Subject)
+ * for Angular by adding the `emit()` method.
+ *
+ * In the following example, a component defines two output properties
+ * that create event emitters. When the title is clicked, the emitter
+ * emits an open or close event to toggle the current visibility state.
+ *
+ * ```angular-ts
+ * @Component({
+ *   selector: 'zippy',
+ *   template: `
+ *   <div class="zippy">
+ *     <div (click)="toggle()">Toggle</div>
+ *     <div [hidden]="!visible">
+ *       <ng-content></ng-content>
+ *     </div>
+ *  </div>`})
+ * export class Zippy {
+ *   visible: boolean = true;
+ *   @Output() open: EventEmitter<any> = new EventEmitter();
+ *   @Output() close: EventEmitter<any> = new EventEmitter();
+ *
+ *   toggle() {
+ *     this.visible = !this.visible;
+ *     if (this.visible) {
+ *       this.open.emit(null);
+ *     } else {
+ *       this.close.emit(null);
+ *     }
+ *   }
+ * }
+ * ```
+ *
+ * Access the event object with the `$event` argument passed to the output event
+ * handler:
+ *
+ * ```html
+ * <zippy (open)="onOpen($event)" (close)="onClose($event)"></zippy>
+ * ```
+ *
+ * @see [Declaring outputs with the @Output decorator](guide/components/outputs#declaring-outputs-with-the-output-decorator)
+ *
+ * @publicApi
+ */
+export interface EventEmitter<T> extends Subject<T>, OutputRef<T> {
+    /**
+     * Creates an instance of this class that can
+     * deliver events synchronously or asynchronously.
+     *
+     * @param [isAsync=false] When true, deliver events asynchronously.
+     *
+     */
+    new (isAsync?: boolean): EventEmitter<T>;
+    /**
+     * Emits an event containing a given value.
+     * @param value The value to emit.
+     */
+    emit(value?: T): void;
+    /**
+     * Registers handlers for events emitted by this instance.
+     * @param next When supplied, a custom handler for emitted events.
+     * @param error When supplied, a custom handler for an error notification from this emitter.
+     * @param complete When supplied, a custom handler for a completion notification from this
+     *     emitter.
+     */
+    subscribe(next?: (value: T) => void, error?: (error: any) => void, complete?: () => void): Subscription;
+    /**
+     * Registers handlers for events emitted by this instance.
+     * @param observerOrNext When supplied, a custom handler for emitted events, or an observer
+     *     object.
+     * @param error When supplied, a custom handler for an error notification from this emitter.
+     * @param complete When supplied, a custom handler for a completion notification from this
+     *     emitter.
+     */
+    subscribe(observerOrNext?: any, error?: any, complete?: any): Subscription;
+}
+/**
+ * @publicApi
+ */
+export declare const EventEmitter: {
+    new (isAsync?: boolean): EventEmitter<any>;
+    new <T>(isAsync?: boolean): EventEmitter<T>;
+    readonly prototype: EventEmitter<any>;
+};

package/import/hydration/cache.d.ts

@@ -0,0 +1,14 @@
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.dev/license
+ */
+import { InjectionToken } from '../di';
+/**
+ * Token used to the determine if the transfer cache should be used, for example for resources.
+ */
+export declare const CACHE_ACTIVE: InjectionToken<{
+    isActive: boolean;
+}>;

package/import/index.d.ts

@@ -23,6 +23,22 @@ export * from './di/provider_token';
 export * from './error_handler';
 export * from './pending_tasks';
 export * from './linker/destroy_ref';
+export { StateKey, makeStateKey, TransferState } from './transfer_state';
+export { EventEmitter } from './event_emitter';
+export { Type, AbstractType } from './interface/type';
+export { IdleService, provideIdleServiceWith } from './defer/idle_service';
+export { OnDestroy } from './change_detection/lifecycle_hooks';
+export { runInInjectionContext, assertInInjectionContext } from './di/contextual';
+export { APP_ID } from './application/application_tokens';
+export { ForwardRefFn, forwardRef, resolveForwardRef } from './di/forward_ref';
+export { OutputRefSubscription, OutputRef } from './authoring/output/output_ref';
+export { TypeDecorator } from './util/decorators';
+export { injectAsync, InjectAsyncOptions, PrefetchTrigger, onIdle } from './di/inject_async';
+export { Signal, isSignal, ValueEqualityFn, isWritableSignal } from './render3/reactivity/api';
+export { assertNotInReactiveContext } from './render3/reactivity/asserts';
+export { EffectRef, CreateEffectOptions, EffectCleanupFn, EffectCleanupRegisterFn, effect } from './render3/reactivity/effect';
+export { linkedSignal } from './render3/reactivity/linked_signal';
+export { WritableSignal, signal } from './render3/reactivity/signal';
 export { StaticProvider } from './di/interface/provider';
 export { EffectScheduler } from './render3/reactivity/root_effect_scheduler';
 export declare function Injectable(args?: any): (constructor: Function) => void;

package/import/linker.d.ts

@@ -0,0 +1 @@
+export { DestroyRef } from './linker/destroy_ref';

package/import/pending_tasks.d.ts

@@ -5,29 +5,6 @@
  * Use of this source code is governed by an MIT-style license that can be
  * found in the LICENSE file at https://angular.dev/license
  */
-import { Observable } from 'rxjs';
-import { OnDestroy } from './interface/lifecycle_hooks';
-/**
- * Internal implementation of the pending tasks service.
- */
-export declare class PendingTasksInternal implements OnDestroy {
-    private taskId;
-    private pendingTasks;
-    private destroyed;
-    private pendingTask;
-    get hasPendingTasks(): boolean;
-    /**
-     * In case the service is about to be destroyed, return a self-completing observable.
-     * Otherwise, return the observable that emits the current state of pending tasks.
-     */
-    get hasPendingTasksObservable(): Observable<boolean>;
-    add(): number;
-    has(taskId: number): boolean;
-    remove(taskId: number): void;
-    ngOnDestroy(): void;
-    /** @nocollapse */
-    static ɵprov: unknown;
-}
 /**
  * Service that keeps track of pending tasks contributing to the stableness of Angular
  * application. While several existing Angular services (ex.: `HttpClient`) will internally manage
@@ -76,5 +53,5 @@ export declare class PendingTasks {
      */
     run(fn: () => Promise<unknown>): void;
     /** @nocollapse */
-    static ɵprov: unknown;
+    static ɵprov: import("./di/interface/defs").ɵɵInjectableDeclaration<PendingTasks>;
 }