static-injector 6.1.2 → 6.2.0

package/import/di/contextual.d.ts

@@ -14,6 +14,8 @@ import type { Injector } from './injector';
  * from the given `Injector`. Note that `inject` is only usable synchronously, and cannot be used in
  * any asynchronous callbacks or after any `await` points.
  *
+ * @see [Run within an injection context](guide/di/dependency-injection-context#run-within-an-injection-context)
+ *
  * @param injector the injector which will satisfy calls to [`inject`](api/core/inject) while `fn`
  *     is executing
  * @param fn the closure to be run in the context of `injector`
@@ -31,6 +33,8 @@ export declare function isInInjectionContext(): boolean;
  *
  * @param debugFn a reference to the function making the assertion (used for the error message).
  *
+ * @see [Asserts the context](guide/di/dependency-injection-context#asserts-the-context)
+ *
  * @publicApi
  */
 export declare function assertInInjectionContext(debugFn: Function): void;

package/import/di/forward_ref.d.ts

@@ -56,7 +56,7 @@ export interface ForwardRefFn {
  *    hideParent = input.required<boolean>();
  * }
  * ```
- *
+ * @see [Resolve circular dependencies with a forward reference](guide/di/di-in-action#resolve-circular-dependencies-with-a-forward-reference)
  * @publicApi
  */
 export declare function forwardRef(forwardRefFn: ForwardRefFn): Type<any>;

package/import/di/injectable.d.ts

@@ -25,7 +25,8 @@ export interface InjectableDecorator {
      * provided and injected as a dependency.
      *
      * @see [Introduction to Services and DI](guide/di)
-     * @see [Dependency Injection Guide](guide/di/dependency-injection
+     * @see [Creating and using services](guide/di/creating-and-using-services)
+     * @see [Defining dependency providers](guide/di/defining-dependency-providers)
      *
      * @usageNotes
      *
@@ -51,6 +52,7 @@ export interface InjectableDecorator {
 /**
  * Type of the Injectable metadata.
  *
+ *
  * @publicApi
  */
 export interface Injectable {
@@ -60,8 +62,7 @@ export interface Injectable {
      * - `Type<any>` - associates the injectable with an `@NgModule` or other `InjectorType`. This
      * option is DEPRECATED.
      * - 'null' : Equivalent to `undefined`. The injectable is not provided in any scope automatically
-     * and must be added to a `providers` array of an [@NgModule](api/core/NgModule#providers),
-     * [@Component](api/core/Directive#providers) or [@Directive](api/core/Directive#providers).
+     * and must be added to a `providers` array.
      *
      * The following options specify that this injectable should be provided in one of the following
      * injectors:

package/import/di/injection_token.d.ts

@@ -52,6 +52,9 @@ import { Type } from '../interface/type';
  *
  * {@example core/di/ts/injector_spec.ts region='ShakableInjectionToken'}
  *
+ *
+ * @see [What is an InjectionToken?](guide/di/defining-dependency-providers#what-is-an-injectiontoken)
+ *
  * @publicApi
  */
 export declare class InjectionToken<T> {

package/import/di/injector.d.ts

@@ -30,6 +30,8 @@ import { ProviderToken } from './provider_token';
  *
  * {@example core/di/ts/injector_spec.ts region='injectInjector'}
  *
+ * @see [Types of injector hierarchies](guide/di/hierarchical-dependency-injection#types-of-injector-hierarchies)
+ *
  * @publicApi
  */
 export declare abstract class Injector {

package/import/di/injector_compatibility.d.ts

@@ -108,5 +108,4 @@ 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 catchInjectorError(e: any, token: any, injectorErrorName: string, source: string | null): never;
 export declare function formatError(text: string, obj: any, injectorErrorName: string, source?: string | null): string;

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

@@ -20,7 +20,7 @@ export interface ValueSansProvider {
 }
 /**
  * Configures the `Injector` to return a value for a token.
- * @see [Dependency Injection Guide](guide/di/dependency-injection.
+ * @see [Dependency Injection Guide](guide/di/dependency-injection)
  *
  * @usageNotes
  *
@@ -65,7 +65,7 @@ export interface StaticClassSansProvider {
 }
 /**
  * Configures the `Injector` to return an instance of `useClass` for a token.
- * @see [Dependency Injection Guide](guide/di/dependency-injection.
+ * @see [Dependency Injection Guide](guide/di/dependency-injection)
  *
  * @usageNotes
  *
@@ -95,7 +95,7 @@ export interface StaticClassProvider extends StaticClassSansProvider {
 /**
  * Configures the `Injector` to return an instance of a token.
  *
- * @see [Dependency Injection Guide](guide/di/dependency-injection.
+ * @see [Dependency Injection Guide](guide/di/dependency-injection)
  *
  * @usageNotes
  *
@@ -115,7 +115,7 @@ export interface ConstructorSansProvider {
 /**
  * Configures the `Injector` to return an instance of a token.
  *
- * @see [Dependency Injection Guide](guide/di/dependency-injection.
+ * @see [Dependency Injection Guide](guide/di/dependency-injection)
  *
  * @usageNotes
  *
@@ -142,7 +142,7 @@ export interface ConstructorProvider extends ConstructorSansProvider {
  * Configures the `Injector` to return a value of another `useExisting` token.
  *
  * @see {@link ExistingProvider}
- * @see [Dependency Injection Guide](guide/di/dependency-injection.
+ * @see [Dependency Injection Guide](guide/di/dependency-injection)
  *
  * @publicApi
  */
@@ -155,7 +155,7 @@ export interface ExistingSansProvider {
 /**
  * Configures the `Injector` to return a value of another `useExisting` token.
  *
- * @see [Dependency Injection Guide](guide/di/dependency-injection.
+ * @see [Dependency Injection Guide](guide/di/dependency-injection)
  *
  * @usageNotes
  *
@@ -182,7 +182,7 @@ export interface ExistingProvider extends ExistingSansProvider {
  * Configures the `Injector` to return a value by invoking a `useFactory` function.
  *
  * @see {@link FactoryProvider}
- * @see [Dependency Injection Guide](guide/di/dependency-injection.
+ * @see [Dependency Injection Guide](guide/di/dependency-injection)
  *
  * @publicApi
  */
@@ -200,7 +200,7 @@ export interface FactorySansProvider {
 }
 /**
  * Configures the `Injector` to return a value by invoking a `useFactory` function.
- * @see [Dependency Injection Guide](guide/di/dependency-injection.
+ * @see [Dependency Injection Guide](guide/di/dependency-injection)
  *
  * @usageNotes
  *
@@ -257,7 +257,7 @@ export interface TypeProvider extends Type<any> {
  * Configures the `Injector` to return a value by invoking a `useClass` function.
  * Base for `ClassProvider` decorator.
  *
- * @see [Dependency Injection Guide](guide/di/dependency-injection.
+ * @see [Dependency Injection Guide](guide/di/dependency-injection)
  *
  * @publicApi
  */
@@ -269,7 +269,7 @@ export interface ClassSansProvider {
 }
 /**
  * Configures the `Injector` to return an instance of `useClass` for a token.
- * @see [Dependency Injection Guide](guide/di/dependency-injection.
+ * @see [Dependency Injection Guide](guide/di/dependency-injection)
  *
  * @usageNotes
  *
@@ -298,7 +298,7 @@ export interface ClassProvider extends ClassSansProvider {
 }
 /**
  * Describes how the `Injector` should be configured.
- * @see [Dependency Injection Guide](guide/di/dependency-injection.
+ * @see [Dependency Injection Guide](guide/di/dependency-injection)
  *
  * @see {@link StaticProvider}
  *

package/import/di/metadata.d.ts

@@ -31,7 +31,7 @@ export interface InjectDecorator {
      *
      * {@example core/di/ts/metadata_spec.ts region='InjectWithoutDecorator'}
      *
-     * @see [Dependency Injection Guide](guide/di/dependency-injection
+     * @see [Dependency Injection Guide](guide/di/dependency-injection)
      *
      */
     (token: any): any;
@@ -75,7 +75,7 @@ export interface OptionalDecorator {
      *
      * {@example core/di/ts/metadata_spec.ts region='Optional'}
      *
-     * @see [Dependency Injection Guide](guide/di/dependency-injection.
+     * @see [Dependency Injection Guide](guide/di/dependency-injection)
      */
     (): any;
     new (): Optional;

package/import/di/r3_injector.d.ts

@@ -5,6 +5,7 @@
  * 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 { Type } from '../interface/type';
 import type { Injector } from './injector';
 import { InjectorType } from './interface/defs';
 import { InjectOptions } from './interface/injector';
@@ -18,6 +19,8 @@ export declare function getNullInjector(): Injector;
  * An `Injector` that's part of the environment injector hierarchy, which exists outside of the
  * component tree.
  *
+ * @see [Types of injector hierarchies](guide/di/hierarchical-dependency-injection#types-of-injector-hierarchies)
+ *
  * @publicApi
  */
 export declare abstract class EnvironmentInjector implements Injector {
@@ -59,6 +62,10 @@ export declare abstract class EnvironmentInjector implements Injector {
      */
     abstract runInContext<ReturnT>(fn: () => ReturnT): ReturnT;
     abstract destroy(): void;
+    /**
+     * Indicates whether the instance has already been destroyed.
+     */
+    abstract get destroyed(): boolean;
 }
 export declare class R3Injector extends EnvironmentInjector implements PrimitivesInjector {
     readonly parent: Injector;
@@ -107,5 +114,5 @@ export declare class R3Injector extends EnvironmentInjector implements Primitive
  *
  * @param provider provider to convert to factory
  */
-export declare function providerToFactory(provider: SingleProvider, ngModuleType?: InjectorType<any>, providers?: any[]): () => any;
+export declare function providerToFactory(provider: SingleProvider, ngModuleType?: InjectorType<any>, providers?: any[]): (type?: Type<unknown>, flags?: number) => any;
 export declare function assertNotDestroyed(injector: R3Injector): void;

package/import/error_handler.d.ts

@@ -36,6 +36,9 @@ import { InjectionToken } from './di/injection_token';
  * ```
  *
  * @publicApi
+ *
+ * @see [Unhandled errors in Angular](best-practices/error-handling)
+ *
  */
 export declare class ErrorHandler {
     handleError(error: any): void;

package/import/errors.d.ts

@@ -56,7 +56,7 @@ export declare const enum RuntimeErrorCode {
     INVALID_BINDING_TARGET = 316,
     INVALID_SET_INPUT_CALL = 317,
     MULTIPLE_PLATFORMS = 400,
-    PLATFORM_NOT_FOUND = 401,
+    PLATFORM_NOT_FOUND = -401,
     MISSING_REQUIRED_INJECTABLE_IN_BOOTSTRAP = 402,
     BOOTSTRAP_COMPONENTS_NOT_FOUND = -403,
     PLATFORM_ALREADY_DESTROYED = 404,
@@ -76,6 +76,7 @@ export declare const enum RuntimeErrorCode {
     SIGNAL_WRITE_FROM_ILLEGAL_CONTEXT = 600,
     REQUIRE_SYNC_WITHOUT_SYNC_EMIT = 601,
     ASSERTION_NOT_INSIDE_REACTIVE_CONTEXT = -602,
+    ANIMATE_INVALID_VALUE = 650,
     INVALID_I18N_STRUCTURE = 700,
     MISSING_LOCALE_DATA = 701,
     DEFER_LOADING_FAILED = -750,
@@ -91,6 +92,10 @@ export declare const enum RuntimeErrorCode {
     TYPE_IS_NOT_STANDALONE = 907,
     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,
@@ -99,6 +104,7 @@ export declare const enum RuntimeErrorCode {
     MISSING_NG_MODULE_DEFINITION = 915,
     MISSING_DIRECTIVE_DEFINITION = 916,
     NO_COMPONENT_FACTORY_FOUND = 917,
+    EXTERNAL_RESOURCE_LOADING_FAILED = 918,
     REQUIRED_INPUT_NO_VALUE = -950,
     REQUIRED_QUERY_NO_VALUE = -951,
     REQUIRED_MODEL_NO_VALUE = 952,

package/import/index.d.ts

@@ -23,6 +23,7 @@ export * from './di/provider_token';
 export * from './error_handler';
 export * from './pending_tasks';
 export * from './linker/destroy_ref';
+export { StaticProvider } from './di/interface/provider';
 export declare function Injectable(args?: any): (constructor: Function) => void;
 export declare class StaticInjectOptions {
     static injectOptions: Parameters<InjectableDecorator>[0];

package/import/linker/destroy_ref.d.ts

@@ -11,6 +11,8 @@
  * is injected in a component or directive, the callbacks run when that component or
  * directive is destroyed. Otherwise the callbacks run when a corresponding injector is destroyed.
  *
+ * @see [Lifecycle DestroyRef](guide/components/lifecycle#destroyref)
+ *
  * @publicApi
  */
 export declare abstract class DestroyRef {
@@ -29,6 +31,16 @@ export declare abstract class DestroyRef {
      * // stop the destroy callback from executing if needed
      * unregisterFn();
      * ```
+     *
+     * @see [Lifecycle DestroyRef](guide/components/lifecycle#destroyref)
+     *
      */
     abstract onDestroy(callback: () => void): () => void;
+    /**
+     * Indicates whether the instance has already been destroyed.
+     *
+     * @see [Detecting instance destruction](guide/components/lifecycle#detecting-instance-destruction)
+     *
+     */
+    abstract get destroyed(): boolean;
 }

package/import/pending_tasks.d.ts

@@ -47,6 +47,9 @@ export declare class PendingTasksInternal implements OnDestroy {
  * taskCleanup();
  * ```
  *
+ *
+ * @see [PendingTasks for Server Side Rendering (SSR)](guide/zoneless#pendingtasks-for-server-side-rendering-ssr)
+ *
  * @publicApi 20.0
  */
 export declare class PendingTasks {

package/import/render3/errors_di.d.ts

@@ -6,7 +6,17 @@
  * found in the LICENSE file at https://angular.dev/license
  */
 import type { ProviderToken } from '../di';
-/** Called when directives inject each other (creating a circular dependency) */
-export declare function throwCyclicDependencyError(token: string, path?: string[]): never;
+/** Creates a circular dependency runtime error. */
+export declare function cyclicDependencyError(token: string, path?: string[]): Error;
 /** Throws an error when a token is not found in DI. */
 export declare function throwProviderNotFoundError(token: ProviderToken<unknown>, injectorName?: string): never;
+/**
+ * Creates an initial RuntimeError instance when a problem is detected.
+ * Monkey-patches extra info in the RuntimeError instance, so that it can
+ * be reused later, before throwing the final error.
+ */
+export declare function createRuntimeError(message: string, code: number, path?: string[]): Error;
+/**
+ * Reads monkey-patched error code from the given Error instance.
+ */
+export declare function getRuntimeErrorCode(error: any): number | undefined;

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

@@ -27,5 +27,7 @@ export type Signal<T> = (() => T) & {
 export declare function isSignal(value: unknown): value is Signal<unknown>;
 /**
  * A comparison function which can determine if two values are equal.
+ *
+ * @publicApi 17.0
  */
 export type ValueEqualityFn<T> = (a: T, b: T) => boolean;

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

@@ -7,7 +7,7 @@
  */
 /**
  * Asserts that the current stack frame is not within a reactive context. Useful
- * to disallow certain code from running inside a reactive context (see {@link /api/core/rxjs/toSignal toSignal})
+ * 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).
  *

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

@@ -21,5 +21,6 @@ export interface CreateComputedOptions<T> {
 }
 /**
  * Create a computed `Signal` which derives a reactive value from an expression.
+ * @see [Computed signals](guide/signals#computed-signals)
  */
 export declare function computed<T>(computation: () => T, options?: CreateComputedOptions<T>): Signal<T>;

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

@@ -5,7 +5,7 @@
  * 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 { ReactiveNode, SIGNAL } from '../../../primitives/signals';
+import { SIGNAL, BaseEffectNode } from '../../../primitives/signals';
 import { Injector } from '../../di/injector';
 import { ChangeDetectionScheduler } from '../../change_detection/scheduling/zoneless_scheduling';
 import { EffectScheduler, SchedulableEffect } from './root_effect_scheduler';
@@ -62,12 +62,16 @@ export interface CreateEffectOptions {
  * before the next effect run. The cleanup function makes it possible to "cancel" any work that the
  * previous effect run might have started.
  *
+ * @see [Effect cleanup functions](guide/signals#effect-cleanup-functions)
+ *
  * @publicApi 20.0
  */
 export type EffectCleanupFn = () => void;
 /**
  * A callback passed to the effect function that makes it possible to register cleanup logic.
  *
+ * @see [Effect cleanup functions](guide/signals#effect-cleanup-functions)
+ *
  * @publicApi 20.0
  */
 export type EffectCleanupRegisterFn = (cleanupFn: EffectCleanupFn) => void;
@@ -87,23 +91,20 @@ export type EffectCleanupRegisterFn = (cleanupFn: EffectCleanupFn) => void;
  *
  * `effect()` must be run in injection context, unless the `injector` option is manually specified.
  *
+ * @see [Effects](guide/signals#effects)
+ *
  * @publicApi 20.0
  */
 export declare function effect(effectFn: (onCleanup: EffectCleanupRegisterFn) => void, options?: CreateEffectOptions): EffectRef;
-export interface EffectNode extends ReactiveNode, SchedulableEffect {
-    hasRun: boolean;
+export interface EffectNode extends BaseEffectNode, SchedulableEffect {
     cleanupFns: EffectCleanupFn[] | undefined;
     injector: Injector;
     notifier: ChangeDetectionScheduler;
     onDestroyFn: () => void;
-    fn: (cleanupFn: EffectCleanupRegisterFn) => void;
-    run(): void;
-    destroy(): void;
-    maybeCleanup(): void;
 }
 export interface RootEffectNode extends EffectNode {
     scheduler: EffectScheduler;
 }
-export declare const BASE_EFFECT_NODE: Omit<EffectNode, 'fn' | 'destroy' | 'injector' | 'notifier'>;
+export declare const EFFECT_NODE: Omit<EffectNode, 'fn' | 'destroy' | 'injector' | 'notifier'>;
 export declare const ROOT_EFFECT_NODE: Omit<RootEffectNode, 'fn' | 'scheduler' | 'notifier' | 'injector'>;
 export declare function createRootEffect(fn: (onCleanup: EffectCleanupRegisterFn) => void, scheduler: EffectScheduler, notifier: ChangeDetectionScheduler): RootEffectNode;

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

@@ -14,6 +14,7 @@ import { WritableSignal } from './signal';
  */
 export declare function linkedSignal<D>(computation: () => D, options?: {
     equal?: ValueEqualityFn<NoInfer<D>>;
+    debugName?: string;
 }): WritableSignal<D>;
 /**
  * Creates a writable signal whose value is initialized and reset by the linked, reactive computation.
@@ -22,6 +23,7 @@ export declare function linkedSignal<D>(computation: () => D, options?: {
  * Note: The computation is reactive, meaning the linked signal will automatically update whenever any of the signals used within the computation change.
  *
  * @publicApi 20.0
+ * @see [Dependent state with linkedSignal](guide/signals/linked-signal)
  */
 export declare function linkedSignal<S, D>(options: {
     source: () => S;
@@ -30,4 +32,5 @@ export declare function linkedSignal<S, D>(options: {
         value: NoInfer<D>;
     }) => D;
     equal?: ValueEqualityFn<NoInfer<D>>;
+    debugName?: string;
 }): WritableSignal<D>;

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

@@ -54,6 +54,7 @@ export interface CreateSignalOptions<T> {
 }
 /**
  * Create a `Signal` that can be set or updated directly.
+ * @see [Angular Signals](guide/signals)
  */
 export declare function signal<T>(initialValue: T, options?: CreateSignalOptions<T>): WritableSignal<T>;
 export declare function signalAsReadonlyFn<T>(this: SignalGetter<T>): Signal<T>;

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

@@ -8,5 +8,6 @@
 /**
  * Execute an arbitrary function in a non-reactive (non-tracking) context. The executed function
  * can, optionally, return a value.
+ * @see [Reading without tracking dependencies](guide/signals#reading-without-tracking-dependencies)
  */
 export declare function untracked<T>(nonReactiveReadsFn: () => T): T;

package/import/resource/api.d.ts

@@ -64,7 +64,8 @@ export interface Resource<T> {
      *
      * This function is reactive.
      */
-    hasValue(): this is Resource<Exclude<T, undefined>>;
+    hasValue(this: T extends undefined ? this : never): this is Resource<Exclude<T, undefined>>;
+    hasValue(): boolean;
 }
 /**
  * A `Resource` with a mutable value.
@@ -75,7 +76,8 @@ export interface Resource<T> {
  */
 export interface WritableResource<T> extends Resource<T> {
     readonly value: WritableSignal<T>;
-    hasValue(): this is WritableResource<Exclude<T, undefined>>;
+    hasValue(this: T extends undefined ? this : never): this is WritableResource<Exclude<T, undefined>>;
+    hasValue(): boolean;
     /**
      * Convenience wrapper for `value.set`.
      */
@@ -101,7 +103,8 @@ export interface WritableResource<T> extends Resource<T> {
  * @experimental
  */
 export interface ResourceRef<T> extends WritableResource<T> {
-    hasValue(): this is ResourceRef<Exclude<T, undefined>>;
+    hasValue(this: T extends undefined ? this : never): this is ResourceRef<Exclude<T, undefined>>;
+    hasValue(): boolean;
     /**
      * Manually destroy the resource, which cancels pending requests and returns it to `idle` state.
      */
@@ -142,7 +145,7 @@ export interface BaseResourceOptions<T, R> {
      * A reactive function which determines the request to be made. Whenever the request changes, the
      * loader will be triggered to fetch a new value for the resource.
      *
-     * If a request function isn't provided, the loader won't rerun unless the resource is reloaded.
+     * If a params function isn't provided, the loader won't rerun unless the resource is reloaded.
      */
     params?: () => R;
     /**

package/import/resource/resource.d.ts

@@ -6,9 +6,8 @@
  * found in the LICENSE file at https://angular.dev/license
  */
 import { WritableSignal } from '../render3/reactivity/signal';
-import { Signal } from '../render3/reactivity/api';
+import { Signal, ValueEqualityFn } from '../render3/reactivity/api';
 import { ResourceOptions, ResourceStatus, WritableResource, Resource, ResourceRef, ResourceStreamingLoader } from './api';
-import { ValueEqualityFn } from '../../primitives/signals';
 import { Injector } from '../di/injector';
 /**
  * Constructs a `Resource` that projects a reactive request to an asynchronous operation defined by
@@ -18,6 +17,8 @@ import { Injector } from '../di/injector';
  * `resource` will cancel in-progress loads via the `AbortSignal` when destroyed or when a new
  * request object becomes available, which could prematurely abort mutations.
  *
+ * @see [Async reactivity with resources](guide/signals/resource)
+ *
  * @experimental 19.0
  */
 export declare function resource<T, R>(options: ResourceOptions<T, R> & {
@@ -32,6 +33,7 @@ export declare function resource<T, R>(options: ResourceOptions<T, R> & {
  * request object becomes available, which could prematurely abort mutations.
  *
  * @experimental 19.0
+ * @see [Async reactivity with resources](guide/signals/resource)
  */
 export declare function resource<T, R>(options: ResourceOptions<T, R>): ResourceRef<T | undefined>;
 type WrappedRequest = {
@@ -51,6 +53,7 @@ declare abstract class BaseWritableResource<T> implements WritableResource<T> {
     private readonly isError;
     update(updateFn: (value: T) => T): void;
     readonly isLoading: Signal<boolean>;
+    private readonly isValueDefined;
     hasValue(): this is ResourceRef<Exclude<T, undefined>>;
     asReadonly(): Resource<T>;
 }
@@ -75,7 +78,7 @@ 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, throwErrorsFromValue?: boolean);
+    constructor(request: () => R, loaderFn: ResourceStreamingLoader<T, R>, defaultValue: T, equal: ValueEqualityFn<T> | undefined, injector: Injector);
     readonly status: Signal<ResourceStatus>;
     readonly error: Signal<Error | undefined>;
     /**