@securitydept/client 0.3.0-beta.2 → 0.3.0-beta.5

package/dist/index-Ch8lrE44.d.mts

@@ -0,0 +1,625 @@
+import * as _$injection_js0 from "injection-js";
+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: _$injection_js0.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/destroy.d.ts
+declare abstract class SecuritydeptDestroyRef implements DisposableTrait {
+  abstract readonly destroyed: boolean;
+  abstract onDestroy(callback: () => void): () => void;
+  abstract dispose(): void;
+  [SYMBOL_DISPOSE](): void;
+}
+declare function createSecuritydeptDestroyRef(): SecuritydeptDestroyRef;
+//#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
+//#region src/scheduling/duration.d.ts
+/**
+ * Parse a human-readable duration string (for example `5m` or `300s`) into
+ * milliseconds.
+ */
+declare function parseDurationToMs(duration: string): number;
+//#endregion
+export { ErrorPresentationActionDescriptor as $, notMissingProvider as $t, ResourceErrorSnapshot as A, StdDisposableStack as At, SignalOptions as B, SecuritydeptClassProvider as Bt, IDLE_CALLBACK_TRAIT_TOKEN as C, AsyncDisposableTrait as Ct, TimestampProviderTrait as D, SYMBOL_DISPOSABLE_STACK as Dt, TimeTrait as E, SYMBOL_ASYNC_DISPOSE as Et, ResourceResolvedSnapshot as F, inject$1 as Ft, CancellationTokenTrait as G, SecuritydeptInjectionToken as Gt, CancelableHandle as H, SecuritydeptDependencyToken as Ht, ResourceSnapshot as I, runInInjectionContext$1 as It, ClientErrorFromUnknownOptions as J, SecuritydeptTypeProvider as Jt, ClientError as K, SecuritydeptInjectorTrait as Kt, ResourceStatus as L, tryInjectInInjectionContext as Lt, ResourceLoadingErrorSnapshot as M, injectDisposableStackFrom as Mt, ResourceLoadingSnapshot as N, withDisposableStack as Nt, ComputedSignalTrait as O, SYMBOL_DISPOSE as Ot, ResourceReloadingSnapshot as P, SecuritydeptInjectOptions as Pt, ErrorPresentation as Q, getSecuritydeptProviderToken as Qt, ResourceTrait as R, SecurityDeptOptional as Rt, isCancellationTokenTrait as S, createSecuritydeptDestroyRef as St, TIME_TRAIT_TOKEN as T, DisposableTrait as Tt, CancellationTokenOptions as U, SecuritydeptExistingProvider as Ut, WritableSignalTrait as V, SecuritydeptDependencyDescriptor as Vt, CancellationTokenSourceTrait as W, SecuritydeptFactoryProvider as Wt, ClientErrorSource as X, WithTraitDeps as Xt, ClientErrorKind as Y, SecuritydeptValueProvider as Yt, ErrorCodePresentationDescriptor as Z, createProviderIfTokenMissing as Zt, RxEventReplaySubject as _, WithInteropObservableTraitCompat as _t, mapResource as a, EventOperatorFunction as at, createLinkedCancellationToken as b, SecuritydeptInjector as bt, RxComputedSignal as c, EventStreamTrait as ct, RxSignalOptions as d, RuntimeEventEnvelope as dt, ErrorPresentationDescriptor as et, RxSignalWatchCanceller as f, InteropObservableTrait as ft, RxStateSignalCompat as g, SubscriptionTrait as gt, RxStateSignal as h, SubscribableTrait as ht, RxResourceStreamContext as i, EventObserverTrait as it, ResourceIdleSnapshot as j, createDisposableStack as jt, ReadableSignalTrait as k, SimpleDisposableStack as kt, RxComputedSignalCompat as l, EventSubjectTrait as lt, RxSignalWatchScheduler as m, SYMBOL_OBSERVABLE as mt, RxResource as n, ReadErrorPresentationDescriptorOptions as nt, resourceFromSnapshots as o, EventSource as ot, RxSignalWatchOptions as p, ObserverTrait as pt, ClientErrorFromHttpResponseOptions as q, SecuritydeptProvider as qt, RxResourceOptions as r, UserRecovery as rt, rxResource as s, EventSourceKind as st, parseDurationToMs as t, ErrorPresentationTone as tt, RxSignalDirtyEvent as u, EventSubscriptionTrait as ut, RxEventStream as v, isInteropObservableTrait as vt, IdleCallbackTrait as w, DisposableStackTrait as wt, createCancellationTokenSource as x, SecuritydeptDestroyRef as xt, RxEventSubject as y, INJECTOR_TOKEN as yt, ResourceWhenValueOptions as z, SecuritydeptAbstractType as zt };
+//# sourceMappingURL=index-Ch8lrE44.d.mts.map