static-injector 6.4.0 → 7.0.0

package/import/pending_tasks_internal.d.ts

@@ -0,0 +1,31 @@
+/**
+ * @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 { Observable } from 'rxjs';
+import { OnDestroy } from './change_detection/lifecycle_hooks';
+/**
+ * Internal implementation of the pending tasks service.
+ */
+export declare class PendingTasksInternal implements OnDestroy {
+    private taskId;
+    private pendingTasks;
+    private destroyed;
+    private pendingTask;
+    private debugTaskTracker;
+    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: import("./di/interface/defs").ɵɵInjectableDeclaration<PendingTasksInternal>;
+}

package/import/render3/debug/injector_profiler.d.ts

@@ -10,7 +10,7 @@ import type { Injector } from '../../di/injector';
 import { InternalInjectFlags } from '../../di/interface/injector';
 import type { SingleProvider } from '../../di/provider_collection';
 import { Type } from '../../interface/type';
-import type { EffectRef } from '../reactivity/effect';
+import type { EffectRefImpl } from '../reactivity/effect';
 /**
  * An enum describing the types of events that can be emitted from the injector profiler
  */
@@ -31,10 +31,14 @@ export declare const enum InjectorProfilerEventType {
      * Emits when an effect is created.
      */
     EffectCreated = 3,
+    /**
+     * Emits when an after render effect phase is created.
+     */
+    AfterRenderEffectPhaseCreated = 4,
     /**
      * Emits when an Angular DI system is about to create an instance corresponding to a given token.
      */
-    InjectorToCreateInstanceEvent = 4
+    InjectorToCreateInstanceEvent = 5
 }
 /**
  * An object that defines an injection context for the injector profiler.
@@ -51,10 +55,12 @@ export interface ProviderConfiguredEvent {
 }
 export interface EffectCreatedEvent {
 }
+export interface AfterRenderEffectPhaseCreatedEvent {
+}
 /**
  * An object representing an event that is emitted through the injector profiler
  */
-export type InjectorProfilerEvent = InjectedServiceEvent | InjectorToCreateInstanceEvent | InjectorCreatedInstanceEvent | ProviderConfiguredEvent | EffectCreatedEvent;
+export type InjectorProfilerEvent = InjectedServiceEvent | InjectorToCreateInstanceEvent | InjectorCreatedInstanceEvent | ProviderConfiguredEvent | EffectCreatedEvent | AfterRenderEffectPhaseCreatedEvent;
 /**
  * An object that contains information about a provider that has been configured
  *
@@ -129,5 +135,5 @@ export declare function emitInstanceCreatedByInjectorEvent(instance: unknown): v
  * @param flags the flags that the token was injected with
  */
 export declare function emitInjectEvent(token: Type<unknown>, value: unknown, flags: InternalInjectFlags): void;
-export declare function emitEffectCreatedEvent(effect: EffectRef): void;
+export declare function emitEffectCreatedEvent(effect: EffectRefImpl): void;
 export declare function runInInjectorProfilerContext(injector: Injector, token: Type<unknown>, callback: () => void): void;

package/import/render3/debug/special_providers.d.ts

@@ -0,0 +1,17 @@
+/**
+ * @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
+ */
+/**
+ * Registers a class as a special provider for debug tooling.
+ *
+ * @param clazz The class to register
+ */
+export declare function registerSpecialProvider(clazz: any): void;
+/**
+ * Gets all special providers that have been registered.
+ */
+export declare function getAllSpecialProviders(): ReadonlySet<any>;

package/import/render3/reactivity/api.d.ts

@@ -6,6 +6,7 @@
  * found in the LICENSE file at https://angular.dev/license
  */
 import { SIGNAL } from '../../../primitives/signals';
+import type { WritableSignal } from './signal';
 /**
  * A reactive value which notifies consumers of any changes.
  *
@@ -14,6 +15,8 @@ import { SIGNAL } from '../../../primitives/signals';
  *
  * Ordinary values can be turned into `Signal`s with the `signal` function.
  *
+ * @see [What are signals?](guide/signals#what-are-signals)
+ *
  * @publicApi 17.0
  */
 export type Signal<T> = (() => T) & {
@@ -22,12 +25,24 @@ export type Signal<T> = (() => T) & {
 /**
  * Checks if the given `value` is a reactive `Signal`.
  *
+ * @see [Type checking signals](guide/signals#type-checking-signals)
+ *
  * @publicApi 17.0
  */
 export declare function isSignal(value: unknown): value is Signal<unknown>;
 /**
  * A comparison function which can determine if two values are equal.
  *
+ * @see [Signal equality functions](guide/signals#signal-equality-functions)
+ *
  * @publicApi 17.0
  */
 export type ValueEqualityFn<T> = (a: T, b: T) => boolean;
+/**
+ * Checks if the given `value` is a writeable signal.
+ *
+ * @see [Type checking signals](guide/signals#type-checking-signals)
+ *
+ * @publicApi 21.1
+ */
+export declare function isWritableSignal(value: unknown): value is WritableSignal<unknown>;

package/import/render3/reactivity/asserts.d.ts

@@ -10,6 +10,7 @@
  * to disallow certain code from running inside a reactive context (see {@link /api/core/rxjs-interop/toSignal toSignal})
  *
  * @param debugFn a reference to the function making the assertion (used for the error message).
+ * @see [Asserts the reactive context](guide/signals#asserts-the-reactive-context)
  *
  * @publicApi
  */

package/import/render3/reactivity/effect.d.ts

@@ -13,6 +13,8 @@ import { EffectScheduler, SchedulableEffect } from './root_effect_scheduler';
  * A global reactive effect, which can be manually destroyed.
  *
  * @publicApi 20.0
+ *
+ * @see [Destroying effects](guide/signals/effect#destroying-effects)
  */
 export interface EffectRef {
     /**
@@ -100,7 +102,7 @@ export interface EffectNode extends BaseEffectNode, SchedulableEffect {
     cleanupFns: EffectCleanupFn[] | undefined;
     injector: Injector;
     notifier: ChangeDetectionScheduler;
-    onDestroyFn: () => void;
+    onDestroyFns: (() => void)[] | null;
 }
 export interface RootEffectNode extends EffectNode {
     scheduler: EffectScheduler;

package/import/render3/reactivity/root_effect_scheduler.d.ts

@@ -33,7 +33,7 @@ export declare abstract class EffectScheduler {
     /** Remove a scheduled effect */
     abstract remove(e: SchedulableEffect): void;
     /** @nocollapse */
-    static ɵprov: unknown;
+    static ɵprov: import("../../di/interface/defs").ɵɵInjectableDeclaration<ZoneAwareEffectScheduler>;
 }
 /**
  * A wrapper around `ZoneAwareQueueingScheduler` that schedules flushing via the microtask queue

package/import/render3/reactivity/signal.d.ts

@@ -58,7 +58,3 @@ export interface CreateSignalOptions<T> {
  */
 export declare function signal<T>(initialValue: T, options?: CreateSignalOptions<T>): WritableSignal<T>;
 export declare function signalAsReadonlyFn<T>(this: SignalGetter<T>): Signal<T>;
-/**
- * Checks if the given `value` is a writeable signal.
- */
-export declare function isWritableSignal(value: unknown): value is WritableSignal<unknown>;

package/import/render3/util/stringify_utils.d.ts

@@ -11,7 +11,7 @@
  * be extra careful not to introduce megamorphic reads in it.
  * Check `core/test/render3/perf/render_stringify` for benchmarks and alternate implementations.
  */
-export declare function renderStringify(value: any): string;
+export declare function renderStringify(value: unknown): string;
 /**
  * Used to stringify a value so that it can be displayed in an error message.
  *

package/import/resource/api.d.ts

@@ -8,6 +8,37 @@
 import { Injector } from '../di/injector';
 import { Signal, ValueEqualityFn } from '../render3/reactivity/api';
 import { WritableSignal } from '../render3/reactivity/signal';
+/** Error thrown when a `Resource` dependency of another resource errors. */
+export declare class ResourceDependencyError extends Error {
+    /** The dependency that errored. */
+    readonly dependency: Resource<unknown>;
+    constructor(dependency: Resource<unknown>);
+}
+/**
+ * Special status codes that can be thrown from a resource's `params` or `request` function to
+ * indicate that the resource should transition to that status.
+ */
+export declare class ResourceParamsStatus extends Error {
+    private readonly _brand;
+    private constructor();
+    /** Status code that transitions the resource to `idle` status. */
+    static readonly IDLE: ResourceParamsStatus;
+    /** Status code that transitions the resource to `loading` status. */
+    static readonly LOADING: ResourceParamsStatus;
+}
+/**
+ * Context received by a resource's `params` or `request` function.
+ *
+ * @see [Chaining resources](guide/signals/resource#chaining-resources)
+ */
+export interface ResourceParamsContext {
+    /**
+     * Chains the current params off of the value of another resource, returning the value
+     * of the other resource if it is available, or propagating the status to the current resource by
+     * throwing the appropriate status code if the value is not available.
+     */
+    readonly chain: <T>(resource: Resource<T>) => T;
+}
 /**
  * String value capturing the status of a `Resource`.
  *
@@ -29,7 +60,7 @@ import { WritableSignal } from '../render3/reactivity/signal';
  *
  * `local` - The resource's value was set locally via `.set()` or `.update()`.
  *
- * @experimental
+ * @publicApi 22.0
  */
 export type ResourceStatus = 'idle' | 'error' | 'loading' | 'reloading' | 'resolved' | 'local';
 /**
@@ -39,7 +70,7 @@ export type ResourceStatus = 'idle' | 'error' | 'loading' | 'reloading' | 'resol
  * The usual way of creating a `Resource` is through the `resource` function, but various other APIs
  * may present `Resource` instances to describe their own concepts.
  *
- * @experimental
+ * @publicApi 22.0
  */
 export interface Resource<T> {
     /**
@@ -59,6 +90,10 @@ export interface Resource<T> {
      * Whether this resource is loading a new value (or reloading the existing one).
      */
     readonly isLoading: Signal<boolean>;
+    /**
+     * The current state of this resource, represented as a `ResourceSnapshot`.
+     */
+    readonly snapshot: Signal<ResourceSnapshot<T>>;
     /**
      * Whether this resource has a valid current value.
      *
@@ -72,7 +107,7 @@ export interface Resource<T> {
  *
  * Overwriting the value of a resource sets it to the 'local' state.
  *
- * @experimental
+ * @publicApi 22.0
  */
 export interface WritableResource<T> extends Resource<T> {
     readonly value: WritableSignal<T>;
@@ -100,7 +135,7 @@ export interface WritableResource<T> extends Resource<T> {
 /**
  * A `WritableResource` created through the `resource` function.
  *
- * @experimental
+ * @publicApi 22.0
  */
 export interface ResourceRef<T> extends WritableResource<T> {
     hasValue(this: T extends undefined ? this : never): this is ResourceRef<Exclude<T, undefined>>;
@@ -114,7 +149,7 @@ export interface ResourceRef<T> extends WritableResource<T> {
  * Parameter to a `ResourceLoader` which gives the request and other options for the current loading
  * operation.
  *
- * @experimental
+ * @publicApi 22.0
  */
 export interface ResourceLoaderParams<R> {
     params: NoInfer<Exclude<R, undefined>>;
@@ -126,19 +161,19 @@ export interface ResourceLoaderParams<R> {
 /**
  * Loading function for a `Resource`.
  *
- * @experimental
+ * @publicApi 22.0
  */
 export type ResourceLoader<T, R> = (param: ResourceLoaderParams<R>) => PromiseLike<T>;
 /**
  * Streaming loader for a `Resource`.
  *
- * @experimental
+ * @publicApi 22.0
  */
-export type ResourceStreamingLoader<T, R> = (param: ResourceLoaderParams<R>) => PromiseLike<Signal<ResourceStreamItem<T>>>;
+export type ResourceStreamingLoader<T, R> = (param: ResourceLoaderParams<R>) => Signal<ResourceStreamItem<T>> | PromiseLike<Signal<ResourceStreamItem<T>>> | undefined;
 /**
  * Options to the `resource` function, for creating a resource.
  *
- * @experimental
+ * @publicApi 22.0
  */
 export interface BaseResourceOptions<T, R> {
     /**
@@ -147,7 +182,7 @@ export interface BaseResourceOptions<T, R> {
      *
      * If a params function isn't provided, the loader won't rerun unless the resource is reloaded.
      */
-    params?: () => R;
+    params?: (ctx: ResourceParamsContext) => R;
     /**
      * The value which will be returned from the resource when a server value is unavailable, such as
      * when the resource is still loading.
@@ -161,11 +196,16 @@ export interface BaseResourceOptions<T, R> {
      * Overrides the `Injector` used by `resource`.
      */
     injector?: Injector;
+    /**
+     * Identifier used to cache the resource data in the `TransferState` during server-side rendering and to retrieve it on the client side.
+     * This value value needs to be identical for both the client and server.
+     */
+    id?: string;
 }
 /**
  * Options to the `resource` function, for creating a resource.
  *
- * @experimental
+ * @publicApi 22.0
  */
 export interface PromiseResourceOptions<T, R> extends BaseResourceOptions<T, R> {
     /**
@@ -180,7 +220,7 @@ export interface PromiseResourceOptions<T, R> extends BaseResourceOptions<T, R>
 /**
  * Options to the `resource` function, for creating a resource.
  *
- * @experimental
+ * @publicApi 22.0
  */
 export interface StreamingResourceOptions<T, R> extends BaseResourceOptions<T, R> {
     /**
@@ -194,14 +234,60 @@ export interface StreamingResourceOptions<T, R> extends BaseResourceOptions<T, R
     loader?: never;
 }
 /**
- * @experimental
+ * @publicApi 22.0
  */
-export type ResourceOptions<T, R> = PromiseResourceOptions<T, R> | StreamingResourceOptions<T, R>;
+export type ResourceOptions<T, R> = (PromiseResourceOptions<T, R> | StreamingResourceOptions<T, R>) & {
+    /**
+     * A debug name for the reactive node. Used in Angular DevTools to identify the node.
+     */
+    debugName?: string;
+};
 /**
- * @experimental
+ * @publicApi 22.0
  */
 export type ResourceStreamItem<T> = {
     value: T;
 } | {
     error: Error;
 };
+/**
+ * An explicit representation of a resource's state.
+ *
+ * @publicApi 22.0
+ * @see [Resource composition with snapshots](guide/signals/resource#resource-composition-with-snapshots)
+ */
+export type ResourceSnapshot<T> = {
+    readonly status: 'idle';
+    readonly value: T;
+} | {
+    readonly status: 'loading' | 'reloading';
+    readonly value: T;
+} | {
+    readonly status: 'resolved' | 'local';
+    readonly value: T;
+} | {
+    readonly status: 'error';
+    readonly error: Error;
+};
+/**
+ * Options for `debounced`.
+ *
+ * @see [Debouncing signals with `debounced`](guide/signals/debounced)
+ *
+ * @experimental 22.0
+ */
+export interface DebouncedOptions<T> {
+    /** The `Injector` to use for the debounced resource. */
+    injector?: Injector;
+    /** The equality function to use for comparing values. */
+    equal?: ValueEqualityFn<T>;
+}
+/**
+ * Represents the wait condition for item debouncing.
+ * Can be a number of milliseconds or a function that returns a Promise.
+ *
+ * @see [Debouncing signals with `debounced`](guide/signals/debounced)
+ *
+ * @experimental 22.0
+ */
+export type DebounceTimer<T> = number | ((value: T, lastValue: ResourceSnapshot<T>) => Promise<void> | void);

package/import/resource/debounce.d.ts

@@ -0,0 +1,21 @@
+/**
+ * @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 { Resource, type DebounceTimer, type DebouncedOptions } from './api';
+/**
+ * Creates a resource representing a debounced version of the source signal.
+ *
+ * @param source The source signal to debounce.
+ * @param wait The amount of time to wait before calling the source signal, or a function that
+ *   returns a promise that resolves when the debounced value should be updated.
+ * @param options The options to use for the debounced signal.
+ * @returns A resource representing the debounced signal.
+ * @experimental 22.0
+ *
+ * @see [Debouncing signals with `debounced`](guide/signals/debounced)
+ */
+export declare function debounced<T>(source: () => T, wait: NoInfer<DebounceTimer<T>>, options?: NoInfer<DebouncedOptions<T>>): Resource<T>;

package/import/resource/from_snapshots.d.ts

@@ -0,0 +1,16 @@
+/**
+ * @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 { Resource, ResourceSnapshot } from './api';
+/**
+ * Creates a `Resource` driven by a source of `ResourceSnapshot`s.
+ *
+ * @see [Resource composition with snapshots](guide/signals/resource#resource-composition-with-snapshots)
+ *
+ * @experimental
+ */
+export declare function resourceFromSnapshots<T>(source: () => ResourceSnapshot<T>): Resource<T>;

package/import/resource/index.d.ts

@@ -6,4 +6,6 @@
  * found in the LICENSE file at https://angular.dev/license
  */
 export * from './api';
+export { debounced } from './debounce';
+export { resourceFromSnapshots } from './from_snapshots';
 export { resource } from './resource';

package/import/resource/resource.d.ts

@@ -5,10 +5,11 @@
  * 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 { WritableSignal } from '../render3/reactivity/signal';
 import { Signal, ValueEqualityFn } from '../render3/reactivity/api';
-import { ResourceOptions, ResourceStatus, WritableResource, Resource, ResourceRef, ResourceStreamingLoader } from './api';
+import { WritableSignal } from '../render3/reactivity/signal';
+import { Resource, ResourceOptions, ResourceSnapshot, ResourceStatus, ResourceStreamingLoader, ResourceStreamItem, type ResourceParamsContext, type ResourceRef, type WritableResource } from './api';
 import { Injector } from '../di/injector';
+import { StateKey } from '../transfer_state';
 /**
  * Constructs a `Resource` that projects a reactive request to an asynchronous operation defined by
  * a loader function, which exposes the result of the loading operation via signals.
@@ -19,7 +20,7 @@ import { Injector } from '../di/injector';
  *
  * @see [Async reactivity with resources](guide/signals/resource)
  *
- * @experimental 19.0
+ * @publicApi 22.0
  */
 export declare function resource<T, R>(options: ResourceOptions<T, R> & {
     defaultValue: NoInfer<T>;
@@ -32,13 +33,16 @@ export declare function resource<T, R>(options: ResourceOptions<T, R> & {
  * `resource` will cancel in-progress loads via the `AbortSignal` when destroyed or when a new
  * request object becomes available, which could prematurely abort mutations.
  *
- * @experimental 19.0
+ * @publicApi 22.0
  * @see [Async reactivity with resources](guide/signals/resource)
  */
 export declare function resource<T, R>(options: ResourceOptions<T, R>): ResourceRef<T | undefined>;
+type ResourceInternalStatus = 'idle' | 'loading' | 'resolved' | 'local';
 type WrappedRequest = {
-    request: unknown;
+    request?: unknown;
     reload: number;
+    status?: ResourceInternalStatus;
+    error?: Error;
 };
 /**
  * Base class which implements `.value` as a `WritableSignal` by delegating `.set` and `.update`.
@@ -48,12 +52,14 @@ declare abstract class BaseWritableResource<T> implements WritableResource<T> {
     abstract readonly status: Signal<ResourceStatus>;
     abstract readonly error: Signal<Error | undefined>;
     abstract reload(): boolean;
-    constructor(value: Signal<T>);
+    readonly isLoading: Signal<boolean>;
+    constructor(value: Signal<T>, debugName: string | undefined);
     abstract set(value: T): void;
     private readonly isError;
     update(updateFn: (value: T) => T): void;
-    readonly isLoading: Signal<boolean>;
     private readonly isValueDefined;
+    private _snapshot;
+    get snapshot(): Signal<ResourceSnapshot<T>>;
     hasValue(): this is ResourceRef<Exclude<T, undefined>>;
     asReadonly(): Resource<T>;
 }
@@ -63,6 +69,8 @@ declare abstract class BaseWritableResource<T> implements WritableResource<T> {
 export declare class ResourceImpl<T, R> extends BaseWritableResource<T> implements ResourceRef<T> {
     private readonly loaderFn;
     private readonly equal;
+    private readonly debugName;
+    private transferCacheKey;
     private readonly pendingTasks;
     /**
      * The current state of the resource. Status, value, and error are derived from this.
@@ -78,9 +86,10 @@ export declare class ResourceImpl<T, R> extends BaseWritableResource<T> implemen
     private resolvePendingTask;
     private destroyed;
     private unregisterOnDestroy;
-    constructor(request: () => R, loaderFn: ResourceStreamingLoader<T, R>, defaultValue: T, equal: ValueEqualityFn<T> | undefined, injector: Injector);
     readonly status: Signal<ResourceStatus>;
     readonly error: Signal<Error | undefined>;
+    private readonly transferState;
+    constructor(request: (ctx: ResourceParamsContext) => R, loaderFn: ResourceStreamingLoader<T, R>, defaultValue: T, equal: ValueEqualityFn<T> | undefined, debugName: string | undefined, injector: Injector, transferCacheKey: StateKey<T> | undefined, getInitialStream?: (request: R) => Signal<ResourceStreamItem<T>> | undefined);
     /**
      * Called either directly via `WritableResource.set` or via `.value.set()`.
      */
@@ -91,4 +100,19 @@ export declare class ResourceImpl<T, R> extends BaseWritableResource<T> implemen
     private abortInProgressLoad;
 }
 export declare function encapsulateResourceError(error: unknown): Error;
+export declare function isErrorLike(error: unknown): error is Error;
+export declare class ResourceValueError extends Error {
+    constructor(error: Error);
+}
+/**
+ * Chains the value of another resource into the params of the current resource, returning the value
+ * of the other resource if it is available, or propagating the status to the current resource if it
+ * is not.
+ */
+export declare function chain<T>(resource: Resource<T>): T;
+export declare const paramsContext: ResourceParamsContext;
+export declare function isInParamsFunction(): boolean;
+export declare function setInParamsFunction(value: boolean): void;
+export declare function invalidResourceCreationInParams(): Error;
+export declare function rethrowFatalErrors(error: unknown): void;
 export {};

package/import/transfer_state.d.ts

@@ -0,0 +1,89 @@
+/**
+ * @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
+ */
+/**
+ * A type-safe key to use with `TransferState`.
+ *
+ * Example:
+ *
+ * ```ts
+ * const COUNTER_KEY = makeStateKey<number>('counter');
+ * let value = 10;
+ *
+ * transferState.set(COUNTER_KEY, value);
+ * ```
+ *
+ * @publicApi
+ */
+export type StateKey<T> = string & {
+    __not_a_string: never;
+    __value_type?: T;
+};
+/**
+ * Create a `StateKey<T>` that can be used to store value of type T with `TransferState`.
+ *
+ * Example:
+ *
+ * ```ts
+ * const COUNTER_KEY = makeStateKey<number>('counter');
+ * let value = 10;
+ *
+ * transferState.set(COUNTER_KEY, value);
+ * ```
+ *
+ * @publicApi
+ */
+export declare function makeStateKey<T = void>(key: string): StateKey<T>;
+/**
+ * A key value store that is transferred from the application on the server side to the application
+ * on the client side.
+ *
+ * The `TransferState` is available as an injectable token.
+ * On the client, just inject this token using DI and use it, it will be lazily initialized.
+ * On the server it's already included if `renderApplication` function is used. Otherwise, import
+ * the `ServerTransferStateModule` module to make the `TransferState` available.
+ *
+ * The values in the store are serialized/deserialized using JSON.stringify/JSON.parse. So only
+ * boolean, number, string, null and non-class objects will be serialized and deserialized in a
+ * non-lossy manner.
+ *
+ * @publicApi
+ */
+export declare class TransferState {
+    /** @nocollapse */
+    static ɵprov: import("./di/interface/defs").ɵɵInjectableDeclaration<TransferState>;
+    private onSerializeCallbacks;
+    /**
+     * Get the value corresponding to a key. Return `defaultValue` if key is not found.
+     */
+    get<T>(key: StateKey<T>, defaultValue: T): T;
+    /**
+     * Set the value corresponding to a key.
+     */
+    set<T>(key: StateKey<T>, value: T): void;
+    /**
+     * Remove a key from the store.
+     */
+    remove<T>(key: StateKey<T>): void;
+    /**
+     * Test whether a key exists in the store.
+     */
+    hasKey<T>(key: StateKey<T>): boolean;
+    /**
+     * Indicates whether the state is empty.
+     */
+    get isEmpty(): boolean;
+    /**
+     * Register a callback to provide the value for a key when `toJson` is called.
+     */
+    onSerialize<T>(key: StateKey<T>, callback: () => T): void;
+    /**
+     * Serialize the current state of the store to JSON.
+     */
+    toJson(): string;
+}
+export declare function retrieveTransferredState(doc: Document, appId: string): Record<string, unknown | undefined>;

package/import/util/default_export.d.ts

@@ -0,0 +1,24 @@
+/**
+ * @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
+ */
+/**
+ * An ES Module object with a default export of the given type.
+ *
+ * @see {@link injectAsync}
+ * @see [Route#loadComponent](/api/router/Route#loadComponent)
+ * @see [LoadChildrenCallback](/api/router/LoadChildrenCallback)
+ *
+ * @publicApi
+ */
+export interface DefaultExport<T> {
+    /**
+     * Default exports are bound under the name `"default"`, per the ES Module spec:
+     * https://tc39.es/ecma262/#table-export-forms-mapping-to-exportentry-records
+     */
+    default: T;
+}
+export declare function maybeUnwrapDefaultExport<T>(input: T | DefaultExport<T>): T;