@securitydept/client 0.3.0-beta.3 → 0.3.0-beta.6

package/dist/index-Cg_iY2yY.d.mts

@@ -0,0 +1,608 @@
+import { InjectionToken, Injector } from "injection-js";
+import { BehaviorSubject, Observable, ObservableInput, OperatorFunction, ReplaySubject, Subject } from "rxjs";
+//#region src/injection/types.d.ts
+declare class SecuritydeptInjectionToken<T> extends InjectionToken<T> {}
+type SecuritydeptAbstractType<T> = abstract new (...args: never[]) => T;
+type SecuritydeptDependencyToken<T> = SecuritydeptInjectionToken<T> | SecuritydeptAbstractType<T>;
+type SecuritydeptTypeProvider<T> = SecuritydeptAbstractType<T>;
+declare const SecurityDeptOptional: import("injection-js").OptionalDecorator;
+type SecuritydeptOptionalDependency<T> = readonly [InstanceType<typeof SecurityDeptOptional>, SecuritydeptDependencyToken<T>] | readonly [SecuritydeptDependencyToken<T>, InstanceType<typeof SecurityDeptOptional>];
+type SecuritydeptDependencyDescriptor<T> = SecuritydeptDependencyToken<T> | SecuritydeptOptionalDependency<T>;
+interface SecuritydeptValueProvider<T> {
+  provide: SecuritydeptDependencyToken<T>;
+  useValue: T;
+}
+interface SecuritydeptClassProvider<T> {
+  provide: SecuritydeptDependencyToken<T>;
+  useClass: SecuritydeptAbstractType<T>;
+  deps?: readonly SecuritydeptDependencyDescriptor<unknown>[];
+}
+interface SecuritydeptFactoryProvider<T> {
+  provide: SecuritydeptDependencyToken<T>;
+  useFactory: (...deps: never[]) => T;
+  deps?: readonly SecuritydeptDependencyDescriptor<unknown>[];
+}
+type WithTraitDeps<TDeps extends object> = TDeps;
+interface SecuritydeptExistingProvider<T> {
+  provide: SecuritydeptDependencyToken<T>;
+  useExisting: SecuritydeptDependencyToken<T>;
+}
+type SecuritydeptProvider<T = unknown> = SecuritydeptTypeProvider<T> | SecuritydeptValueProvider<T> | SecuritydeptClassProvider<T> | SecuritydeptFactoryProvider<T> | SecuritydeptExistingProvider<T>;
+declare function getSecuritydeptProviderToken(provider: SecuritydeptProvider): SecuritydeptDependencyToken<unknown>;
+declare function createProviderIfTokenMissing<TProvider extends SecuritydeptProvider>(providedTokens: ReadonlySet<SecuritydeptDependencyToken<unknown>>, token: SecuritydeptDependencyToken<unknown>, createProvider: () => TProvider): TProvider | null;
+declare function notMissingProvider(provider: SecuritydeptProvider | null): provider is SecuritydeptProvider;
+interface SecuritydeptInjectorTrait {
+  get<T>(token: SecuritydeptDependencyToken<T>): T;
+  get<T>(token: SecuritydeptDependencyToken<T>, notFoundValue: T): T;
+}
+//#endregion
+//#region src/injection/context.d.ts
+interface SecuritydeptInjectOptions {
+  optional?: boolean;
+}
+declare function inject$1<T>(token: SecuritydeptDependencyToken<T>, options?: SecuritydeptInjectOptions & {
+  optional?: false;
+}): T;
+declare function inject$1<T>(token: SecuritydeptDependencyToken<T>, options?: SecuritydeptInjectOptions & {
+  optional?: true;
+}): T | null;
+declare function tryInjectInInjectionContext<T>(token: SecuritydeptDependencyToken<T>, options?: SecuritydeptInjectOptions): T | null;
+declare function runInInjectionContext$1<ReturnT>(injector: SecuritydeptInjectorTrait, fn: () => ReturnT): ReturnT;
+//#endregion
+//#region src/compat/disposable.d.ts
+declare const SYMBOL_DISPOSE: typeof Symbol.dispose;
+interface DisposableTrait {
+  dispose(): void;
+  [SYMBOL_DISPOSE](): void;
+}
+declare const SYMBOL_ASYNC_DISPOSE: typeof Symbol.asyncDispose;
+interface AsyncDisposableTrait {
+  dispose(): Promise<void>;
+  [SYMBOL_ASYNC_DISPOSE](): Promise<void>;
+}
+interface DisposableStackTrait extends DisposableTrait {
+  readonly disposed: boolean;
+  use<T extends DisposableTrait>(disposable: T): T;
+  dispose(): void;
+  [SYMBOL_DISPOSE](): void;
+}
+declare const SYMBOL_DISPOSABLE_STACK = "@@disposableStack";
+declare function injectDisposableStackFrom(arg: unknown, isOptions?: boolean): DisposableStackTrait | undefined;
+declare class SimpleDisposableStack implements DisposableStackTrait {
+  private readonly stack;
+  disposed: boolean;
+  use<T extends DisposableTrait>(disposable: T): T;
+  dispose(): void;
+  [SYMBOL_DISPOSE](): void;
+}
+interface NativeDisposableStackLike {
+  readonly disposed: boolean;
+  use<T extends DisposableTrait>(disposable: T): T;
+  dispose(): void;
+}
+type NativeDisposableStackConstructor = new () => NativeDisposableStackLike;
+declare class StdDisposableStack implements DisposableStackTrait {
+  private readonly stack;
+  constructor(Stack?: NativeDisposableStackConstructor);
+  get disposed(): boolean;
+  use<T extends DisposableTrait>(disposable: T): T;
+  dispose(): void;
+  [SYMBOL_DISPOSE](): void;
+}
+declare function createDisposableStack(): DisposableStackTrait;
+declare function withDisposableStack(index: number, isOptions?: boolean): <TThis, TArgs extends unknown[], TReturn>(target: (this: TThis, ...args: TArgs) => TReturn, _context: ClassMethodDecoratorContext<TThis, (this: TThis, ...args: TArgs) => TReturn>) => (this: TThis, ...args: TArgs) => TReturn;
+//#endregion
+//#region src/injection/injector.d.ts
+declare class SecuritydeptInjector implements SecuritydeptInjectorTrait {
+  private readonly runtimeInjector;
+  static resolveAndCreate(providers: readonly SecuritydeptProvider[]): SecuritydeptInjector;
+  static fromParentInjector(parent: SecuritydeptInjectorTrait, providers: readonly SecuritydeptProvider[]): SecuritydeptInjector;
+  static fromRuntimeInjector(runtimeInjector: Injector): SecuritydeptInjector;
+  private constructor();
+  get<T>(token: SecuritydeptDependencyToken<T>): T;
+  get<T>(token: SecuritydeptDependencyToken<T>, notFoundValue: T): T;
+}
+declare const INJECTOR_TOKEN: SecuritydeptInjectionToken<SecuritydeptInjector>;
+//#endregion
+//#region src/compat/observable.d.ts
+declare const SYMBOL_OBSERVABLE: typeof Symbol.observable;
+/** Subscription handle with explicit unsubscribe. */
+interface SubscriptionTrait {
+  unsubscribe(): void;
+}
+/** Observer for event streams — mirrors the Observable observer pattern. */
+interface ObserverTrait<T> {
+  next(value: T): void;
+  error(error: unknown): void;
+  complete(): void;
+}
+interface SubscribableTrait<T> {
+  subscribe(observer: Partial<ObserverTrait<T>>): SubscriptionTrait;
+}
+interface InteropObservableTrait<T> {
+  [SYMBOL_OBSERVABLE](): SubscribableTrait<T>;
+}
+type WithInteropObservableTraitCompat<O extends InteropObservableTrait<unknown>, T extends O extends InteropObservableTrait<infer U> ? U : never> = O & InteropObservableTrait<T>;
+declare function isInteropObservableTrait<T>(value: unknown): value is InteropObservableTrait<T>;
+//#endregion
+//#region src/events/types.d.ts
+/** Subscription handle with explicit unsubscribe. */
+type EventSubscriptionTrait = SubscriptionTrait;
+/** Observer for event streams — mirrors the Observable observer pattern. */
+interface EventObserverTrait<T> {
+  next(value: T): void;
+  error(error: unknown): void;
+  complete(): void;
+}
+/** Read-only event stream — lazy push-based sequence. */
+interface EventStreamTrait<T> extends InteropObservableTrait<T> {
+  subscribe(observer: Partial<EventObserverTrait<T>>): EventSubscriptionTrait;
+}
+/** Hot event producer. */
+interface EventSubjectTrait<T> extends EventStreamTrait<T> {
+  next(value: T): void;
+  error(error: unknown): void;
+  complete(): void;
+}
+declare const EventSourceKind: {
+  readonly User: "user";
+  readonly Timer: "timer";
+  readonly Http: "http";
+  readonly Storage: "storage";
+  readonly Framework: "framework";
+  readonly System: "system";
+};
+type EventSourceKind = (typeof EventSourceKind)[keyof typeof EventSourceKind];
+type EventSource = {
+  kind: typeof EventSourceKind.User;
+  actor?: string;
+} | {
+  kind: typeof EventSourceKind.Timer;
+  timer: string;
+} | {
+  kind: typeof EventSourceKind.Http;
+  requestId: string;
+  endpoint?: string;
+} | {
+  kind: typeof EventSourceKind.Storage;
+  operation: string;
+} | {
+  kind: typeof EventSourceKind.Framework;
+  name: string;
+} | {
+  kind: typeof EventSourceKind.System;
+  subsystem: string;
+};
+interface RuntimeEventEnvelope<TType extends string, TPayload> {
+  id: string;
+  type: TType;
+  at: number;
+  source: EventSource;
+  payload: TPayload;
+}
+type EventOperatorFunction<T, R> = (stream: EventStreamTrait<T>) => EventStreamTrait<R>;
+//#endregion
+//#region src/errors/types.d.ts
+/** Recovery actions the user might take. Aligned with server-side `UserRecovery`. */
+declare const UserRecovery: {
+  readonly None: "none";
+  readonly Retry: "retry";
+  readonly RestartFlow: "restart_flow";
+  readonly Reauthenticate: "reauthenticate";
+  readonly ContactSupport: "contact_support";
+};
+type UserRecovery = (typeof UserRecovery)[keyof typeof UserRecovery];
+/** User-facing error presentation. `code` is the cross-platform stable contract. */
+interface ErrorPresentation {
+  code: string;
+  message: string;
+  recovery: UserRecovery;
+}
+declare const ErrorPresentationTone: {
+  readonly Neutral: "neutral";
+  readonly Warning: "warning";
+  readonly Danger: "danger";
+};
+type ErrorPresentationTone = (typeof ErrorPresentationTone)[keyof typeof ErrorPresentationTone];
+interface ErrorPresentationActionDescriptor {
+  recovery: UserRecovery;
+  label: string;
+  href: string | null;
+}
+interface ErrorPresentationDescriptor {
+  code: string | null;
+  kind: ClientErrorKind | null;
+  source?: string;
+  title: string;
+  description: string;
+  recovery: UserRecovery;
+  retryable: boolean;
+  tone: ErrorPresentationTone;
+  primaryAction: ErrorPresentationActionDescriptor | null;
+}
+interface ReadErrorPresentationDescriptorOptions {
+  fallbackTitle?: string;
+  fallbackDescription?: string;
+  codePresentations?: Readonly<Record<string, ErrorCodePresentationDescriptor>>;
+  recoveryLinks?: Partial<Record<UserRecovery, string>>;
+  recoveryLabels?: Partial<Record<UserRecovery, string>>;
+}
+interface ErrorCodePresentationDescriptor {
+  title: string;
+  description: string;
+  tone?: ErrorPresentationTone;
+  recovery?: UserRecovery;
+}
+/** Machine-facing error kind discriminator. */
+declare const ClientErrorKind: {
+  readonly Authorization: "authorization";
+  readonly Transport: "transport";
+  readonly Server: "server";
+  readonly Protocol: "protocol";
+  readonly Storage: "storage";
+  readonly Configuration: "configuration";
+  readonly Unauthenticated: "unauthenticated";
+  readonly Unauthorized: "unauthorized";
+  readonly Cancelled: "cancelled";
+  readonly Timeout: "timeout";
+  readonly Internal: "internal";
+};
+type ClientErrorKind = (typeof ClientErrorKind)[keyof typeof ClientErrorKind];
+/** Stable source vocabulary for common client error producers. */
+declare const ClientErrorSource: {
+  readonly Transport: "transport";
+  readonly Server: "server";
+  readonly Client: "client";
+};
+type ClientErrorSource = (typeof ClientErrorSource)[keyof typeof ClientErrorSource];
+//#endregion
+//#region src/errors/client-error.d.ts
+interface ClientErrorFromUnknownOptions {
+  message: string;
+  code: string;
+  source: string;
+}
+interface ClientErrorFromHttpResponseOptions {
+  status: number;
+  body?: unknown;
+  source?: string;
+}
+/**
+ * Base client error carrying both machine-facing context and an optional
+ * user-facing presentation layer.
+ *
+ * Top-level `code` and `recovery` provide stable machine contracts for
+ * policy decisions without requiring callers to unwrap `presentation`.
+ */
+declare class ClientError extends Error {
+  readonly kind: ClientErrorKind;
+  /**
+   * Stable machine-readable error code.
+   * Matches `presentation.code` when present, otherwise a default
+   * derived from `kind`.
+   */
+  readonly code: string;
+  /** Recovery hint at the machine level. */
+  readonly recovery: UserRecovery;
+  /** Whether this error is safe to retry. */
+  readonly retryable: boolean;
+  /** Structured user-facing error presentation from the server. */
+  readonly presentation?: ErrorPresentation;
+  /** Source subsystem or component that produced the error. */
+  readonly source?: string;
+  constructor(options: {
+    kind: ClientErrorKind;
+    message: string;
+    code?: string;
+    recovery?: UserRecovery;
+    retryable?: boolean;
+    presentation?: ErrorPresentation;
+    source?: string;
+    cause?: unknown;
+  });
+  /** Create a `ClientError` from a server error response body. */
+  static fromServerError(body: {
+    kind?: string;
+    code?: string;
+    message?: string;
+    recovery?: string;
+    presentation?: {
+      code?: string;
+      message?: string;
+      recovery?: string;
+    };
+  }, overrides?: {
+    kind?: ClientErrorKind;
+    source?: string;
+  }): ClientError;
+  static fromUnknown(error: unknown, options: ClientErrorFromUnknownOptions): ClientError;
+  /**
+   * Create a `ClientError` from an HTTP response status and optional body.
+   * Used when a non-success status is unexpected.
+   */
+  static fromHttpResponse(options: ClientErrorFromHttpResponseOptions): ClientError;
+}
+//#endregion
+//#region src/cancellation/types.d.ts
+/** Cancelable operation handle. */
+interface CancelableHandle {
+  cancel(): void;
+}
+interface CancellationTokenErrorData {
+  readonly cancellationError: ClientError;
+  readonly reason: unknown;
+}
+/** Cooperative cancellation token — consumers check / subscribe to cancellation. */
+interface CancellationTokenTrait extends InteropObservableTrait<CancellationTokenErrorData> {
+  readonly isCancellationRequested: boolean;
+  readonly cancellationError?: ClientError | undefined;
+  readonly reason?: unknown;
+  onCancellationRequested(listener: (data: CancellationTokenErrorData) => void): DisposableTrait;
+  throwIfCancellationRequested(): void;
+}
+interface CancellationTokenOptions {
+  cancellationToken?: CancellationTokenTrait;
+}
+/** Cancellation source — producer-side control. */
+interface CancellationTokenSourceTrait {
+  readonly token: CancellationTokenTrait;
+  cancel(reason?: unknown): void;
+}
+//#endregion
+//#region src/signals/types.d.ts
+interface SignalOptions<T> {
+  equals?: (a: T, b: T) => boolean;
+}
+/**
+ * Read-only signal interface.
+ * Semantics align with TC39 Signals proposal, but uses an SDK-owned thin protocol
+ * to avoid coupling to any specific polyfill or standard implementation.
+ */
+interface ReadableSignalTrait<T> extends InteropObservableTrait<T> {
+  readonly equals: (a: unknown, b: unknown) => boolean;
+  /** Return the current snapshot value. */
+  get(): T;
+  /**
+   * Watch value invalidations.
+   * The stream does not emit the current value on subscription; use
+   * `[SYMBOL_OBSERVABLE]()` when value replay is required.
+   */
+  watchStream(): EventStreamTrait<void>;
+}
+/**
+ * Writable signal interface.
+ * State transitions should be controlled by the client / service layer;
+ * external consumers typically only see the read-only projection.
+ */
+interface WritableSignalTrait<T> extends ReadableSignalTrait<T> {
+  set(value: T): void;
+}
+/**
+ * Computed (derived) signal — always read-only, value is derived from
+ * other signals automatically.
+ */
+interface ComputedSignalTrait<T> extends ReadableSignalTrait<T> {}
+declare const ResourceStatus: {
+  readonly Idle: "idle";
+  readonly Loading: "loading";
+  readonly LoadingError: "loading_error";
+  readonly Reloading: "reloading";
+  readonly Resolved: "resolved";
+  readonly Error: "error";
+};
+type ResourceStatus = (typeof ResourceStatus)[keyof typeof ResourceStatus];
+interface ResourceIdleSnapshot {
+  readonly status: typeof ResourceStatus.Idle;
+}
+interface ResourceLoadingSnapshot {
+  readonly status: typeof ResourceStatus.Loading;
+}
+interface ResourceLoadingErrorSnapshot {
+  readonly status: typeof ResourceStatus.LoadingError;
+  readonly error: unknown;
+}
+interface ResourceReloadingSnapshot<T> {
+  readonly status: typeof ResourceStatus.Reloading;
+  readonly value: T;
+}
+interface ResourceResolvedSnapshot<T> {
+  readonly status: typeof ResourceStatus.Resolved;
+  readonly value: T;
+}
+interface ResourceErrorSnapshot<T> {
+  readonly status: typeof ResourceStatus.Error;
+  readonly value: T;
+  readonly error: unknown;
+}
+type ResourceSnapshot<T> = ResourceIdleSnapshot | ResourceLoadingSnapshot | ResourceLoadingErrorSnapshot | ResourceReloadingSnapshot<T> | ResourceResolvedSnapshot<T> | ResourceErrorSnapshot<T>;
+interface ResourceWhenValueOptions {
+  readonly cancellationToken?: CancellationTokenTrait;
+  readonly staleValueWhenError?: boolean;
+}
+interface ResourceTrait<T> extends DisposableTrait, InteropObservableTrait<ResourceSnapshot<T>> {
+  readonly value: ReadableSignalTrait<T>;
+  readonly status: ReadableSignalTrait<ResourceStatus>;
+  readonly error: ReadableSignalTrait<unknown | undefined>;
+  readonly isLoading: ReadableSignalTrait<boolean>;
+  readonly snapshot: ReadableSignalTrait<ResourceSnapshot<T>>;
+  hasValue(): boolean;
+  whenValue(options?: ResourceWhenValueOptions): Promise<T>;
+}
+//#endregion
+//#region src/scheduling/types.d.ts
+interface TimestampProviderTrait {
+  /** Return current epoch milliseconds. */
+  now(): number;
+}
+/** Injectable time capability for host timers and deterministic tests. */
+interface TimeTrait extends TimestampProviderTrait {
+  /** Return current epoch milliseconds. */
+  setTimeout(handler: () => void, delayMs: number): unknown;
+  clearTimeout(handle: unknown): void;
+}
+declare const TIME_TRAIT_TOKEN: SecuritydeptInjectionToken<TimeTrait>;
+declare const IDLE_CALLBACK_TRAIT_TOKEN: SecuritydeptInjectionToken<IdleCallbackTrait | null>;
+/** Injectable idle-callback capability for hosts that explicitly support it. */
+interface IdleCallbackTrait {
+  requestIdleCallback(callback: () => void): unknown;
+  cancelIdleCallback(handle: unknown): void;
+}
+//#endregion
+//#region src/cancellation/create.d.ts
+/**
+ * Create a `CancellationTokenSource` that produces a cooperative cancellation token.
+ */
+declare function createCancellationTokenSource(): CancellationTokenSourceTrait;
+declare function isCancellationTokenTrait(obj: unknown): obj is CancellationTokenTrait;
+//#endregion
+//#region src/cancellation/linked.d.ts
+/**
+ * Create a cancellation token that fires when ANY of the given source tokens
+ * is cancelled.
+ *
+ * - Zero sources → returns a token that is never cancelled.
+ * - One source   → returns that source directly (no allocation).
+ * - N sources    → creates a linked source, subscribes to all, and cleans up
+ *   subscriptions once the linked token fires.
+ *
+ * @example
+ * const cts = createCancellationTokenSource();
+ * const linked = createLinkedCancellationToken(clientRoot.token, cts.token);
+ * await transport.execute({ ..., cancellationToken: linked });
+ */
+declare function createLinkedCancellationToken(...sources: readonly (CancellationTokenTrait | undefined | null)[]): CancellationTokenTrait & DisposableTrait;
+//#endregion
+//#region src/rx/event.d.ts
+type RxEventStreamProducer<T> = (observer: EventObserverTrait<T>) => (() => void) | void;
+type RxEventStreamInput<T> = ObservableInput<T> | InteropObservableTrait<T> | SubscribableTrait<T>;
+declare class RxEventStream<T> extends Observable<T> implements EventStreamTrait<T>, InteropObservableTrait<T> {
+  constructor(source: RxEventStreamInput<T> | RxEventStreamProducer<T>);
+  [SYMBOL_OBSERVABLE](): RxEventStream<T>;
+  static fromObservableInput<T>(input: RxEventStreamInput<T>): RxEventStream<T>;
+  pipe(): RxEventStream<T>;
+  pipe<A>(op1: OperatorFunction<T, A>): RxEventStream<A>;
+  pipe<A, B>(op1: OperatorFunction<T, A>, op2: OperatorFunction<A, B>): RxEventStream<B>;
+  pipe<A, B, C>(op1: OperatorFunction<T, A>, op2: OperatorFunction<A, B>, op3: OperatorFunction<B, C>): RxEventStream<C>;
+  pipe<A, B, C, D>(op1: OperatorFunction<T, A>, op2: OperatorFunction<A, B>, op3: OperatorFunction<B, C>, op4: OperatorFunction<C, D>): RxEventStream<D>;
+  pipe<A, B, C, D, E>(op1: OperatorFunction<T, A>, op2: OperatorFunction<A, B>, op3: OperatorFunction<B, C>, op4: OperatorFunction<C, D>, op5: OperatorFunction<D, E>): RxEventStream<E>;
+  pipe<A, B, C, D, E, F>(op1: OperatorFunction<T, A>, op2: OperatorFunction<A, B>, op3: OperatorFunction<B, C>, op4: OperatorFunction<C, D>, op5: OperatorFunction<D, E>, op6: OperatorFunction<E, F>): RxEventStream<F>;
+  pipe<A, B, C, D, E, F, G>(op1: OperatorFunction<T, A>, op2: OperatorFunction<A, B>, op3: OperatorFunction<B, C>, op4: OperatorFunction<C, D>, op5: OperatorFunction<D, E>, op6: OperatorFunction<E, F>, op7: OperatorFunction<F, G>): RxEventStream<G>;
+  pipe<A, B, C, D, E, F, G, H>(op1: OperatorFunction<T, A>, op2: OperatorFunction<A, B>, op3: OperatorFunction<B, C>, op4: OperatorFunction<C, D>, op5: OperatorFunction<D, E>, op6: OperatorFunction<E, F>, op7: OperatorFunction<F, G>, op8: OperatorFunction<G, H>): RxEventStream<H>;
+  pipe<A, B, C, D, E, F, G, H, I>(op1: OperatorFunction<T, A>, op2: OperatorFunction<A, B>, op3: OperatorFunction<B, C>, op4: OperatorFunction<C, D>, op5: OperatorFunction<D, E>, op6: OperatorFunction<E, F>, op7: OperatorFunction<F, G>, op8: OperatorFunction<G, H>, op9: OperatorFunction<H, I>): RxEventStream<I>;
+  pipe<A, B, C, D, E, F, G, H, I>(op1: OperatorFunction<T, A>, op2: OperatorFunction<A, B>, op3: OperatorFunction<B, C>, op4: OperatorFunction<C, D>, op5: OperatorFunction<D, E>, op6: OperatorFunction<E, F>, op7: OperatorFunction<F, G>, op8: OperatorFunction<G, H>, op9: OperatorFunction<H, I>, ...operations: OperatorFunction<any, any>[]): RxEventStream<unknown>;
+}
+declare class RxEventSubject<T> extends Subject<T> implements EventSubjectTrait<T> {
+  [SYMBOL_OBSERVABLE](): RxEventStream<T>;
+  asObservable(): RxEventStream<T>;
+}
+declare class RxEventReplaySubject<T> extends ReplaySubject<T> implements EventSubjectTrait<T> {
+  [SYMBOL_OBSERVABLE](): RxEventStream<T>;
+  asObservable(): RxEventStream<T>;
+}
+//#endregion
+//#region src/rx/signal.d.ts
+interface RxSignalDirtyEvent<T> {
+  epoch: number;
+  signal: ReadableSignalTrait<T>;
+}
+type RxSignalOptions<T> = SignalOptions<T>;
+type RxSignalWatchScheduler<THandle = unknown> = (flush: () => void) => THandle;
+type RxSignalWatchCanceller<THandle = unknown> = (handle: THandle) => void;
+interface RxSignalWatchOptions {
+  schedule: RxSignalWatchScheduler;
+  cancel?: RxSignalWatchCanceller;
+}
+declare abstract class RxSignal<T> implements ReadableSignalTrait<T>, InteropObservableTrait<T> {
+  protected static globalEpoch: number;
+  protected static currentContext: RxComputedSignal<any> | null;
+  protected valueEqVersion: number;
+  readonly equals: (a: unknown, b: unknown) => boolean;
+  abstract get(): T;
+  abstract dirtyObservable(): Observable<RxSignalDirtyEvent<T>>;
+  protected constructor(options: RxSignalOptions<T> | undefined);
+  watchStream(options?: RxSignalWatchOptions): RxEventStream<void>;
+  [SYMBOL_OBSERVABLE](): RxEventStream<T>;
+  abstract validateForEpoch(epoch: number): void;
+}
+declare class RxStateSignal<T> extends RxSignal<T> implements InteropObservableTrait<T>, WritableSignalTrait<T> {
+  protected dirtySubject: Subject<RxSignalDirtyEvent<T>>;
+  protected value: BehaviorSubject<T>;
+  protected constructor(initialValue: T, options: RxSignalOptions<T> | undefined);
+  set(input: T): void;
+  static fromInitialValue<T>(initialValue: T, options?: RxSignalOptions<T>): RxStateSignalCompat<T>;
+  get(): T;
+  validateForEpoch(): void;
+  dirtyObservable(): Observable<RxSignalDirtyEvent<T>>;
+  [SYMBOL_OBSERVABLE](): RxEventStream<T>;
+}
+type RxStateSignalCompat<T> = WithInteropObservableTraitCompat<RxStateSignal<T>, T>;
+type AnyRxSignal = RxSignal<any> & {
+  valueEqVersion: number;
+};
+type ComputedCacheState<T> = {
+  kind: "empty";
+} | {
+  kind: "value";
+  value: T;
+} | {
+  kind: "error";
+  error: unknown;
+};
+declare class RxComputedSignal<T> extends RxSignal<T> {
+  protected readonly computeFn: () => T;
+  protected cacheState: ComputedCacheState<T>;
+  protected sources: ReadonlyMap<AnyRxSignal, number>;
+  protected sourcesSubject: BehaviorSubject<ReadonlyMap<AnyRxSignal, number>>;
+  private validatedEpoch;
+  private isComputing;
+  private collectingSources;
+  private dirty$;
+  protected constructor(computeFn: () => T, options: RxSignalOptions<T> | undefined);
+  markDependency(signal: RxSignal<any>): void;
+  protected cacheStatesEqual(left: ComputedCacheState<T>, right: ComputedCacheState<T>): boolean;
+  protected recompute(): void;
+  validateForEpoch(epoch: number): void;
+  get(): T;
+  dirtyObservable(): Observable<RxSignalDirtyEvent<T>>;
+  static computed<T>(fn: () => T, options?: RxSignalOptions<T>): RxComputedSignalCompat<T>;
+}
+type RxComputedSignalCompat<T> = WithInteropObservableTraitCompat<RxComputedSignal<T>, T>;
+//#endregion
+//#region src/rx/resource.d.ts
+interface RxResourceStreamContext<T, R> {
+  readonly request: R;
+  readonly previous: ResourceSnapshot<T>;
+  readonly cancellationToken: CancellationTokenTrait;
+}
+interface RxResourceOptions<T, R = undefined> {
+  readonly request?: ReadableSignalTrait<R | undefined> | (() => R | undefined);
+  readonly stream: (context: RxResourceStreamContext<T, R>) => ObservableInput<T>;
+}
+declare abstract class RxResourceBase<T> implements ResourceTrait<T>, InteropObservableTrait<ResourceSnapshot<T>> {
+  abstract readonly snapshot: ReadableSignalTrait<ResourceSnapshot<T>>;
+  readonly value: RxComputedSignalCompat<T>;
+  readonly status: RxComputedSignalCompat<ResourceStatus>;
+  readonly error: RxComputedSignalCompat<unknown | undefined>;
+  readonly isLoading: RxComputedSignalCompat<boolean>;
+  protected readonly destroyed: RxStateSignalCompat<boolean>;
+  protected readonly destroyed$: Observable<true>;
+  protected constructor();
+  hasValue(): boolean;
+  whenValue(options?: ResourceWhenValueOptions): Promise<T>;
+  dispose(): void;
+  [SYMBOL_DISPOSE](): void;
+  [SYMBOL_OBSERVABLE](): RxEventStream<ResourceSnapshot<T>>;
+}
+declare class RxResource<T, R = undefined> extends RxResourceBase<T> {
+  private readonly options;
+  readonly snapshot: RxStateSignalCompat<ResourceSnapshot<T>>;
+  constructor(options: RxResourceOptions<T, R>);
+  private connect;
+  static create<T, R = undefined>(options: RxResourceOptions<T, R>): RxResource<T, R>;
+}
+declare function resourceFromSnapshots<T>(source: () => ResourceSnapshot<T>): WithInteropObservableTraitCompat<ResourceTrait<T>, ResourceSnapshot<T>>;
+declare function mapResource<T, U>(source: ResourceTrait<T>, mapValue: (value: T) => U): WithInteropObservableTraitCompat<ResourceTrait<U>, ResourceSnapshot<U>>;
+declare function rxResource<T, R = undefined>(options: RxResourceOptions<T, R>): WithInteropObservableTraitCompat<ResourceTrait<T>, ResourceSnapshot<T>>;
+//#endregion
+export { ErrorPresentationDescriptor as $, ResourceIdleSnapshot as A, withDisposableStack as At, WritableSignalTrait as B, SecuritydeptExistingProvider as Bt, IdleCallbackTrait as C, SYMBOL_ASYNC_DISPOSE as Ct, ComputedSignalTrait as D, StdDisposableStack as Dt, TimestampProviderTrait as E, SimpleDisposableStack as Et, ResourceSnapshot as F, SecurityDeptOptional as Ft, ClientError as G, SecuritydeptTypeProvider as Gt, CancellationTokenOptions as H, SecuritydeptInjectionToken as Ht, ResourceStatus as I, SecuritydeptAbstractType as It, ClientErrorKind as J, createProviderIfTokenMissing as Jt, ClientErrorFromHttpResponseOptions as K, SecuritydeptValueProvider as Kt, ResourceTrait as L, SecuritydeptClassProvider as Lt, ResourceLoadingSnapshot as M, inject$1 as Mt, ResourceReloadingSnapshot as N, runInInjectionContext$1 as Nt, ReadableSignalTrait as O, createDisposableStack as Ot, ResourceResolvedSnapshot as P, tryInjectInInjectionContext as Pt, ErrorPresentationActionDescriptor as Q, ResourceWhenValueOptions as R, SecuritydeptDependencyDescriptor as Rt, IDLE_CALLBACK_TRAIT_TOKEN as S, DisposableTrait as St, TimeTrait as T, SYMBOL_DISPOSE as Tt, CancellationTokenSourceTrait as U, SecuritydeptInjectorTrait as Ut, CancelableHandle as V, SecuritydeptFactoryProvider as Vt, CancellationTokenTrait as W, SecuritydeptProvider as Wt, ErrorCodePresentationDescriptor as X, notMissingProvider as Xt, ClientErrorSource as Y, getSecuritydeptProviderToken as Yt, ErrorPresentation as Z, RxEventStream as _, isInteropObservableTrait as _t, resourceFromSnapshots as a, EventSource as at, createCancellationTokenSource as b, AsyncDisposableTrait as bt, RxComputedSignalCompat as c, EventSubjectTrait as ct, RxSignalWatchCanceller as d, InteropObservableTrait as dt, ErrorPresentationTone as et, RxSignalWatchOptions as f, ObserverTrait as ft, RxEventReplaySubject as g, WithInteropObservableTraitCompat as gt, RxStateSignalCompat as h, SubscriptionTrait as ht, mapResource as i, EventOperatorFunction as it, ResourceLoadingErrorSnapshot as j, SecuritydeptInjectOptions as jt, ResourceErrorSnapshot as k, injectDisposableStackFrom as kt, RxSignalDirtyEvent as l, EventSubscriptionTrait as lt, RxStateSignal as m, SubscribableTrait as mt, RxResourceOptions as n, UserRecovery as nt, rxResource as o, EventSourceKind as ot, RxSignalWatchScheduler as p, SYMBOL_OBSERVABLE as pt, ClientErrorFromUnknownOptions as q, WithTraitDeps as qt, RxResourceStreamContext as r, EventObserverTrait as rt, RxComputedSignal as s, EventStreamTrait as st, RxResource as t, ReadErrorPresentationDescriptorOptions as tt, RxSignalOptions as u, RuntimeEventEnvelope as ut, RxEventSubject as v, INJECTOR_TOKEN as vt, TIME_TRAIT_TOKEN as w, SYMBOL_DISPOSABLE_STACK as wt, isCancellationTokenTrait as x, DisposableStackTrait as xt, createLinkedCancellationToken as y, SecuritydeptInjector as yt, SignalOptions as z, SecuritydeptDependencyToken as zt };
+//# sourceMappingURL=index-Cg_iY2yY.d.mts.map