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

package/primitives/signals/index.d.ts

@@ -1,166 +1,38 @@
 /**
- * @license Angular v20.0.0-next.1
+ * @license Angular v20.0.0-next.3
  * (c) 2010-2025 Google LLC. https://angular.io/
  * License: MIT
  */
 
-
-export declare type ComputationFn<S, D> = (source: S, previous?: {
-    source: S;
-    value: D;
-}) => D;
-
-declare type ComputedGetter<T> = (() => T) & {
-    [SIGNAL]: ComputedNode<T>;
-};
-
-/**
- * A computation, which derives a value from a declarative reactive expression.
- *
- * `Computed`s are both producers and consumers of reactivity.
- */
-export declare interface ComputedNode<T> extends ReactiveNode {
-    /**
-     * Current value of the computation, or one of the sentinel values above (`UNSET`, `COMPUTING`,
-     * `ERROR`).
-     */
-    value: T;
-    /**
-     * If `value` is `ERRORED`, the error caught from the last computation attempt which will
-     * be re-thrown.
-     */
-    error: unknown;
-    /**
-     * The computation function which will produce a new value.
-     */
-    computation: () => T;
-    equal: ValueEqualityFn<T>;
-}
+export { s as setAlternateWeakRefImpl } from '../../weak_ref.d-ttyj86RV.js';
 
 /**
- * Finalize this consumer's state after a reactive computation has run.
- *
- * Must be called by subclasses which represent reactive computations, after those computations
- * have finished.
- */
-export declare function consumerAfterComputation(node: ReactiveNode | null, prevConsumer: ReactiveNode | null): void;
-
-/**
- * Prepare this consumer to run a computation in its reactive context.
- *
- * Must be called by subclasses which represent reactive computations, before those computations
- * begin.
- */
-export declare function consumerBeforeComputation(node: ReactiveNode | null): ReactiveNode | null;
-
-/**
- * Disconnect this consumer from the graph.
- */
-export declare function consumerDestroy(node: ReactiveNode): void;
-
-export declare function consumerMarkDirty(node: ReactiveNode): void;
-
-/**
- * Determine whether this consumer has any dependencies which have changed since the last time
- * they were read.
- */
-export declare function consumerPollProducersForChange(node: ReactiveNode): boolean;
-
-/**
- * Create a computed signal which derives a reactive value from an expression.
- */
-export declare function createComputed<T>(computation: () => T): ComputedGetter<T>;
-
-export declare function createLinkedSignal<S, D>(sourceFn: () => S, computationFn: ComputationFn<S, D>, equalityFn?: ValueEqualityFn<D>): LinkedSignalGetter<S, D>;
-
-/**
- * Create a `Signal` that can be set or updated directly.
+ * A comparison function which can determine if two values are equal.
  */
-export declare function createSignal<T>(initialValue: T): SignalGetter<T>;
-
-export declare function createWatch(fn: (onCleanup: WatchCleanupRegisterFn) => void, schedule: (watch: Watch) => void, allowSignalWrites: boolean): Watch;
-
+type ValueEqualityFn<T> = (a: T, b: T) => boolean;
 /**
  * The default equality function used for `signal` and `computed`, which uses referential equality.
  */
-export declare function defaultEquals<T>(a: T, b: T): boolean;
-
-export declare function getActiveConsumer(): ReactiveNode | null;
+declare function defaultEquals<T>(a: T, b: T): boolean;
 
-export declare function isInNotificationPhase(): boolean;
-
-export declare function isReactive(value: unknown): value is Reactive;
-
-export declare type LinkedSignalGetter<S, D> = (() => D) & {
-    [SIGNAL]: LinkedSignalNode<S, D>;
+type Version = number & {
+    __brand: 'Version';
 };
-
-export declare interface LinkedSignalNode<S, D> extends ReactiveNode {
-    /**
-     * Value of the source signal that was used to derive the computed value.
-     */
-    sourceValue: S;
-    /**
-     * Current state value, or one of the sentinel values (`UNSET`, `COMPUTING`,
-     * `ERROR`).
-     */
-    value: D;
-    /**
-     * If `value` is `ERRORED`, the error caught from the last computation attempt which will
-     * be re-thrown.
-     */
-    error: unknown;
-    /**
-     * The source function represents reactive dependency based on which the linked state is reset.
-     */
-    source: () => S;
-    /**
-     * The computation function which will produce a new value based on the source and, optionally - previous values.
-     */
-    computation: ComputationFn<S, D>;
-    equal: ValueEqualityFn<D>;
-}
-
-export declare function linkedSignalSetFn<S, D>(node: LinkedSignalNode<S, D>, newValue: D): void;
-
-export declare function linkedSignalUpdateFn<S, D>(node: LinkedSignalNode<S, D>, updater: (value: D) => D): void;
-
+type ReactiveHookFn = (node: ReactiveNode) => void;
 /**
- * Called by implementations when a producer's signal is read.
- */
-export declare function producerAccessed(node: ReactiveNode): void;
-
-/**
- * Increment the global epoch counter.
+ * Symbol used to tell `Signal`s apart from other functions.
  *
- * Called by source producers (that is, not computeds) whenever their values change.
- */
-export declare function producerIncrementEpoch(): void;
-
-export declare function producerMarkClean(node: ReactiveNode): void;
-
-/**
- * Propagate a dirty notification to live consumers of this producer.
- */
-export declare function producerNotifyConsumers(node: ReactiveNode): void;
-
-/**
- * Whether this `ReactiveNode` in its producer capacity is currently allowed to initiate updates,
- * based on the current consumer context.
- */
-export declare function producerUpdatesAllowed(): boolean;
-
-/**
- * Ensure this producer's `version` is up-to-date.
+ * This can be used to auto-unwrap signals in various cases, or to auto-wrap non-signal values.
  */
-export declare function producerUpdateValueVersion(node: ReactiveNode): void;
-
-export declare interface Reactive {
+declare const SIGNAL: unique symbol;
+declare function setActiveConsumer(consumer: ReactiveNode | null): ReactiveNode | null;
+declare function getActiveConsumer(): ReactiveNode | null;
+declare function isInNotificationPhase(): boolean;
+interface Reactive {
     [SIGNAL]: ReactiveNode;
 }
-
-export declare const REACTIVE_NODE: ReactiveNode;
-
+declare function isReactive(value: unknown): value is Reactive;
+declare const REACTIVE_NODE: ReactiveNode;
 /**
  * A producer and/or consumer which participates in the reactive graph.
  *
@@ -173,7 +45,7 @@ export declare const REACTIVE_NODE: ReactiveNode;
  *
  * A `ReactiveNode` may be both a producer and consumer.
  */
-export declare interface ReactiveNode {
+interface ReactiveNode {
     /**
      * Version of the value that this node produces.
      *
@@ -270,56 +142,155 @@ export declare interface ReactiveNode {
      */
     kind: string;
 }
-
-export declare function runPostSignalSetFn(): void;
-
-export declare function setActiveConsumer(consumer: ReactiveNode | null): ReactiveNode | null;
-
-
-export declare function setAlternateWeakRefImpl(impl: unknown): void;
-
-export declare function setPostSignalSetFn(fn: (() => void) | null): (() => void) | null;
-
-export declare function setThrowInvalidWriteToSignalError(fn: <T>(node: SignalNode<T>) => never): void;
-
 /**
- * Symbol used to tell `Signal`s apart from other functions.
+ * Called by implementations when a producer's signal is read.
+ */
+declare function producerAccessed(node: ReactiveNode): void;
+/**
+ * Increment the global epoch counter.
  *
- * This can be used to auto-unwrap signals in various cases, or to auto-wrap non-signal values.
+ * Called by source producers (that is, not computeds) whenever their values change.
  */
-export declare const SIGNAL: unique symbol;
-
-export declare const SIGNAL_NODE: SignalNode<unknown>;
+declare function producerIncrementEpoch(): void;
+/**
+ * Ensure this producer's `version` is up-to-date.
+ */
+declare function producerUpdateValueVersion(node: ReactiveNode): void;
+/**
+ * Propagate a dirty notification to live consumers of this producer.
+ */
+declare function producerNotifyConsumers(node: ReactiveNode): void;
+/**
+ * Whether this `ReactiveNode` in its producer capacity is currently allowed to initiate updates,
+ * based on the current consumer context.
+ */
+declare function producerUpdatesAllowed(): boolean;
+declare function consumerMarkDirty(node: ReactiveNode): void;
+declare function producerMarkClean(node: ReactiveNode): void;
+/**
+ * Prepare this consumer to run a computation in its reactive context.
+ *
+ * Must be called by subclasses which represent reactive computations, before those computations
+ * begin.
+ */
+declare function consumerBeforeComputation(node: ReactiveNode | null): ReactiveNode | null;
+/**
+ * Finalize this consumer's state after a reactive computation has run.
+ *
+ * Must be called by subclasses which represent reactive computations, after those computations
+ * have finished.
+ */
+declare function consumerAfterComputation(node: ReactiveNode | null, prevConsumer: ReactiveNode | null): void;
+/**
+ * Determine whether this consumer has any dependencies which have changed since the last time
+ * they were read.
+ */
+declare function consumerPollProducersForChange(node: ReactiveNode): boolean;
+/**
+ * Disconnect this consumer from the graph.
+ */
+declare function consumerDestroy(node: ReactiveNode): void;
+declare function runPostProducerCreatedFn(node: ReactiveNode): void;
+declare function setPostProducerCreatedFn(fn: ReactiveHookFn | null): ReactiveHookFn | null;
 
-declare type SignalBaseGetter<T> = (() => T) & {
-    readonly [SIGNAL]: unknown;
+/**
+ * A computation, which derives a value from a declarative reactive expression.
+ *
+ * `Computed`s are both producers and consumers of reactivity.
+ */
+interface ComputedNode<T> extends ReactiveNode {
+    /**
+     * Current value of the computation, or one of the sentinel values above (`UNSET`, `COMPUTING`,
+     * `ERROR`).
+     */
+    value: T;
+    /**
+     * If `value` is `ERRORED`, the error caught from the last computation attempt which will
+     * be re-thrown.
+     */
+    error: unknown;
+    /**
+     * The computation function which will produce a new value.
+     */
+    computation: () => T;
+    equal: ValueEqualityFn<T>;
+}
+type ComputedGetter<T> = (() => T) & {
+    [SIGNAL]: ComputedNode<T>;
 };
+/**
+ * Create a computed signal which derives a reactive value from an expression.
+ */
+declare function createComputed<T>(computation: () => T, equal?: ValueEqualityFn<T>): ComputedGetter<T>;
 
-export declare interface SignalGetter<T> extends SignalBaseGetter<T> {
-    readonly [SIGNAL]: SignalNode<T>;
+type ComputationFn<S, D> = (source: S, previous?: {
+    source: S;
+    value: D;
+}) => D;
+interface LinkedSignalNode<S, D> extends ReactiveNode {
+    /**
+     * Value of the source signal that was used to derive the computed value.
+     */
+    sourceValue: S;
+    /**
+     * Current state value, or one of the sentinel values (`UNSET`, `COMPUTING`,
+     * `ERROR`).
+     */
+    value: D;
+    /**
+     * If `value` is `ERRORED`, the error caught from the last computation attempt which will
+     * be re-thrown.
+     */
+    error: unknown;
+    /**
+     * The source function represents reactive dependency based on which the linked state is reset.
+     */
+    source: () => S;
+    /**
+     * The computation function which will produce a new value based on the source and, optionally - previous values.
+     */
+    computation: ComputationFn<S, D>;
+    equal: ValueEqualityFn<D>;
 }
+type LinkedSignalGetter<S, D> = (() => D) & {
+    [SIGNAL]: LinkedSignalNode<S, D>;
+};
+declare function createLinkedSignal<S, D>(sourceFn: () => S, computationFn: ComputationFn<S, D>, equalityFn?: ValueEqualityFn<D>): LinkedSignalGetter<S, D>;
+declare function linkedSignalSetFn<S, D>(node: LinkedSignalNode<S, D>, newValue: D): void;
+declare function linkedSignalUpdateFn<S, D>(node: LinkedSignalNode<S, D>, updater: (value: D) => D): void;
 
-export declare interface SignalNode<T> extends ReactiveNode {
+interface SignalNode<T> extends ReactiveNode {
     value: T;
     equal: ValueEqualityFn<T>;
 }
-
-export declare function signalSetFn<T>(node: SignalNode<T>, newValue: T): void;
-
-export declare function signalUpdateFn<T>(node: SignalNode<T>, updater: (value: T) => T): void;
-
-
+type SignalBaseGetter<T> = (() => T) & {
+    readonly [SIGNAL]: unknown;
+};
+interface SignalGetter<T> extends SignalBaseGetter<T> {
+    readonly [SIGNAL]: SignalNode<T>;
+}
 /**
- * A comparison function which can determine if two values are equal.
+ * Create a `Signal` that can be set or updated directly.
  */
-export declare type ValueEqualityFn<T> = (a: T, b: T) => boolean;
+declare function createSignal<T>(initialValue: T, equal?: ValueEqualityFn<T>): SignalGetter<T>;
+declare function setPostSignalSetFn(fn: ReactiveHookFn | null): ReactiveHookFn | null;
+declare function signalSetFn<T>(node: SignalNode<T>, newValue: T): void;
+declare function signalUpdateFn<T>(node: SignalNode<T>, updater: (value: T) => T): void;
+declare function runPostSignalSetFn<T>(node: SignalNode<T>): void;
+declare const SIGNAL_NODE: SignalNode<unknown>;
 
+declare function setThrowInvalidWriteToSignalError(fn: <T>(node: SignalNode<T>) => never): void;
 
-declare type Version = number & {
-    __brand: 'Version';
-};
-
-export declare interface Watch {
+/**
+ * A cleanup function that can be optionally registered from the watch logic. If registered, the
+ * cleanup logic runs before the next watch execution.
+ */
+type WatchCleanupFn = () => void;
+/**
+ * A callback passed to the watch function that makes it possible to register cleanup logic.
+ */
+type WatchCleanupRegisterFn = (cleanupFn: WatchCleanupFn) => void;
+interface Watch {
     notify(): void;
     /**
      * Execute the reactive expression in the context of this `Watch` consumer.
@@ -337,24 +308,19 @@ export declare interface Watch {
     destroy(): void;
     [SIGNAL]: WatchNode;
 }
-
-/**
- * A cleanup function that can be optionally registered from the watch logic. If registered, the
- * cleanup logic runs before the next watch execution.
- */
-export declare type WatchCleanupFn = () => void;
-
-/**
- * A callback passed to the watch function that makes it possible to register cleanup logic.
- */
-export declare type WatchCleanupRegisterFn = (cleanupFn: WatchCleanupFn) => void;
-
-declare interface WatchNode extends ReactiveNode {
+interface WatchNode extends ReactiveNode {
     hasRun: boolean;
     fn: ((onCleanup: WatchCleanupRegisterFn) => void) | null;
     schedule: ((watch: Watch) => void) | null;
     cleanupFn: WatchCleanupFn;
     ref: Watch;
 }
+declare function createWatch(fn: (onCleanup: WatchCleanupRegisterFn) => void, schedule: (watch: Watch) => void, allowSignalWrites: boolean): Watch;
+
+/**
+ * Execute an arbitrary function in a non-reactive (non-tracking) context. The executed function
+ * can, optionally, return a value.
+ */
+declare function untracked<T>(nonReactiveReadsFn: () => T): T;
 
-export { }
+export { type ComputationFn, type ComputedNode, type LinkedSignalGetter, type LinkedSignalNode, REACTIVE_NODE, type Reactive, type ReactiveHookFn, type ReactiveNode, SIGNAL, SIGNAL_NODE, type SignalGetter, type SignalNode, type ValueEqualityFn, type Watch, type WatchCleanupFn, type WatchCleanupRegisterFn, consumerAfterComputation, consumerBeforeComputation, consumerDestroy, consumerMarkDirty, consumerPollProducersForChange, createComputed, createLinkedSignal, createSignal, createWatch, defaultEquals, getActiveConsumer, isInNotificationPhase, isReactive, linkedSignalSetFn, linkedSignalUpdateFn, producerAccessed, producerIncrementEpoch, producerMarkClean, producerNotifyConsumers, producerUpdateValueVersion, producerUpdatesAllowed, runPostProducerCreatedFn, runPostSignalSetFn, setActiveConsumer, setPostProducerCreatedFn, setPostSignalSetFn, setThrowInvalidWriteToSignalError, signalSetFn, signalUpdateFn, untracked };

package/rxjs-interop/index.d.ts

@@ -1,21 +1,11 @@
 /**
- * @license Angular v20.0.0-next.1
+ * @license Angular v20.0.0-next.3
  * (c) 2010-2025 Google LLC. https://angular.io/
  * License: MIT
  */
 
-
-import { BaseResourceOptions } from '@angular/core';
-import { DestroyRef } from '@angular/core';
-import { Injector } from '@angular/core';
-import { MonoTypeOperatorFunction } from 'rxjs';
-import { Observable } from 'rxjs';
-import { OutputOptions } from '@angular/core';
-import { OutputRef } from '@angular/core';
-import { ResourceLoaderParams } from '@angular/core';
-import { ResourceRef } from '@angular/core';
-import { Signal } from '@angular/core';
-import { Subscribable } from 'rxjs';
+import { OutputOptions, OutputRef, DestroyRef, Signal, Injector, BaseResourceOptions, ResourceLoaderParams, ResourceRef } from '@angular/core';
+import { Observable, MonoTypeOperatorFunction, Subscribable } from 'rxjs';
 import { ValueEqualityFn } from '@angular/core/primitives/signals';
 
 /**
@@ -42,7 +32,7 @@ import { ValueEqualityFn } from '@angular/core/primitives/signals';
  *
  * @publicApi
  */
-export declare function outputFromObservable<T>(observable: Observable<T>, opts?: OutputOptions): OutputRef<T>;
+declare function outputFromObservable<T>(observable: Observable<T>, opts?: OutputOptions): OutputRef<T>;
 
 /**
  * Converts an Angular output declared via `output()` or `outputFromObservable()`
@@ -52,45 +42,7 @@ export declare function outputFromObservable<T>(observable: Observable<T>, opts?
  *
  * @publicApi
  */
-export declare function outputToObservable<T>(ref: OutputRef<T>): Observable<T>;
-
-/**
- * Operator which makes the application unstable until the observable emits, complets, errors, or is unsubscribed.
- *
- * Use this operator in observables whose subscriptions are important for rendering and should be included in SSR serialization.
- *
- * @param injector The `Injector` to use during creation. If this is not provided, the current injection context will be used instead (via `inject`).
- *
- * @experimental
- */
-export declare function pendingUntilEvent<T>(injector?: Injector): MonoTypeOperatorFunction<T>;
-
-/**
- * Like `resource` but uses an RxJS based `loader` which maps the request to an `Observable` of the
- * resource's value.
- *
- * @experimental
- */
-export declare function rxResource<T, R>(opts: RxResourceOptions<T, R> & {
-    defaultValue: NoInfer<T>;
-}): ResourceRef<T>;
-
-/**
- * Like `resource` but uses an RxJS based `loader` which maps the request to an `Observable` of the
- * resource's value.
- *
- * @experimental
- */
-export declare function rxResource<T, R>(opts: RxResourceOptions<T, R>): ResourceRef<T | undefined>;
-
-/**
- * Like `ResourceOptions` but uses an RxJS-based `loader`.
- *
- * @experimental
- */
-export declare interface RxResourceOptions<T, R> extends BaseResourceOptions<T, R> {
-    loader: (params: ResourceLoaderParams<R>) => Observable<T>;
-}
+declare function outputToObservable<T>(ref: OutputRef<T>): Observable<T>;
 
 /**
  * Operator which completes the Observable when the calling context (component, directive, service,
@@ -102,25 +54,14 @@ export declare interface RxResourceOptions<T, R> extends BaseResourceOptions<T,
  *
  * @publicApi
  */
-export declare function takeUntilDestroyed<T>(destroyRef?: DestroyRef): MonoTypeOperatorFunction<T>;
-
-/**
- * Exposes the value of an Angular `Signal` as an RxJS `Observable`.
- *
- * The signal's value will be propagated into the `Observable`'s subscribers using an `effect`.
- *
- * `toObservable` must be called in an injection context unless an injector is provided via options.
- *
- * @developerPreview
- */
-export declare function toObservable<T>(source: Signal<T>, options?: ToObservableOptions): Observable<T>;
+declare function takeUntilDestroyed<T>(destroyRef?: DestroyRef): MonoTypeOperatorFunction<T>;
 
 /**
  * Options for `toObservable`.
  *
  * @developerPreview
  */
-export declare interface ToObservableOptions {
+interface ToObservableOptions {
     /**
      * The `Injector` to use when creating the underlying `effect` which watches the signal.
      *
@@ -129,35 +70,23 @@ export declare interface ToObservableOptions {
      */
     injector?: Injector;
 }
-
-export declare function toSignal<T>(source: Observable<T> | Subscribable<T>): Signal<T | undefined>;
-
-export declare function toSignal<T>(source: Observable<T> | Subscribable<T>, options: NoInfer<ToSignalOptions<T | undefined>> & {
-    initialValue?: undefined;
-    requireSync?: false;
-}): Signal<T | undefined>;
-
-export declare function toSignal<T>(source: Observable<T> | Subscribable<T>, options: NoInfer<ToSignalOptions<T | null>> & {
-    initialValue?: null;
-    requireSync?: false;
-}): Signal<T | null>;
-
-export declare function toSignal<T>(source: Observable<T> | Subscribable<T>, options: NoInfer<ToSignalOptions<T>> & {
-    initialValue?: undefined;
-    requireSync: true;
-}): Signal<T>;
-
-export declare function toSignal<T, const U extends T>(source: Observable<T> | Subscribable<T>, options: NoInfer<ToSignalOptions<T | U>> & {
-    initialValue: U;
-    requireSync?: false;
-}): Signal<T | U>;
+/**
+ * Exposes the value of an Angular `Signal` as an RxJS `Observable`.
+ *
+ * The signal's value will be propagated into the `Observable`'s subscribers using an `effect`.
+ *
+ * `toObservable` must be called in an injection context unless an injector is provided via options.
+ *
+ * @developerPreview
+ */
+declare function toObservable<T>(source: Signal<T>, options?: ToObservableOptions): Observable<T>;
 
 /**
  * Options for `toSignal`.
  *
  * @publicApi
  */
-export declare interface ToSignalOptions<T> {
+interface ToSignalOptions<T> {
     /**
      * Initial value for the signal produced by `toSignal`.
      *
@@ -188,15 +117,6 @@ export declare interface ToSignalOptions<T> {
      * until the `Observable` itself completes.
      */
     manualCleanup?: boolean;
-    /**
-     * Whether `toSignal` should throw errors from the Observable error channel back to RxJS, where
-     * they'll be processed as uncaught exceptions.
-     *
-     * In practice, this means that the signal returned by `toSignal` will keep returning the last
-     * good value forever, as Observables which error produce no further values. This option emulates
-     * the behavior of the `async` pipe.
-     */
-    rejectErrors?: boolean;
     /**
      * A comparison function which defines equality for values emitted by the observable.
      *
@@ -204,7 +124,58 @@ export declare interface ToSignalOptions<T> {
      */
     equal?: ValueEqualityFn<T>;
 }
+declare function toSignal<T>(source: Observable<T> | Subscribable<T>): Signal<T | undefined>;
+declare function toSignal<T>(source: Observable<T> | Subscribable<T>, options: NoInfer<ToSignalOptions<T | undefined>> & {
+    initialValue?: undefined;
+    requireSync?: false;
+}): Signal<T | undefined>;
+declare function toSignal<T>(source: Observable<T> | Subscribable<T>, options: NoInfer<ToSignalOptions<T | null>> & {
+    initialValue?: null;
+    requireSync?: false;
+}): Signal<T | null>;
+declare function toSignal<T>(source: Observable<T> | Subscribable<T>, options: NoInfer<ToSignalOptions<T>> & {
+    initialValue?: undefined;
+    requireSync: true;
+}): Signal<T>;
+declare function toSignal<T, const U extends T>(source: Observable<T> | Subscribable<T>, options: NoInfer<ToSignalOptions<T | U>> & {
+    initialValue: U;
+    requireSync?: false;
+}): Signal<T | U>;
+
+/**
+ * Operator which makes the application unstable until the observable emits, complets, errors, or is unsubscribed.
+ *
+ * Use this operator in observables whose subscriptions are important for rendering and should be included in SSR serialization.
+ *
+ * @param injector The `Injector` to use during creation. If this is not provided, the current injection context will be used instead (via `inject`).
+ *
+ * @experimental
+ */
+declare function pendingUntilEvent<T>(injector?: Injector): MonoTypeOperatorFunction<T>;
 
-export declare function ɵtoObservableMicrotask<T>(source: Signal<T>, options?: ToObservableOptions): Observable<T>;
+/**
+ * Like `ResourceOptions` but uses an RxJS-based `loader`.
+ *
+ * @experimental
+ */
+interface RxResourceOptions<T, R> extends BaseResourceOptions<T, R> {
+    loader: (params: ResourceLoaderParams<R>) => Observable<T>;
+}
+/**
+ * Like `resource` but uses an RxJS based `loader` which maps the request to an `Observable` of the
+ * resource's value.
+ *
+ * @experimental
+ */
+declare function rxResource<T, R>(opts: RxResourceOptions<T, R> & {
+    defaultValue: NoInfer<T>;
+}): ResourceRef<T>;
+/**
+ * Like `resource` but uses an RxJS based `loader` which maps the request to an `Observable` of the
+ * resource's value.
+ *
+ * @experimental
+ */
+declare function rxResource<T, R>(opts: RxResourceOptions<T, R>): ResourceRef<T | undefined>;
 
-export { }
+export { type RxResourceOptions, type ToObservableOptions, type ToSignalOptions, outputFromObservable, outputToObservable, pendingUntilEvent, rxResource, takeUntilDestroyed, toObservable, toSignal };