@securitydept/client 0.3.0-beta.1 → 0.3.0-beta.11

package/dist/index-CFAJ969E.d.mts

@@ -0,0 +1,674 @@
+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/span/types.d.ts
+interface SpanCreateOptions {
+  idFactory?: () => string;
+  attributes?: SpanAttributes;
+  mutable?: false;
+}
+type SpanAttributeValue = string | number | boolean | null | readonly SpanAttributeValue[] | {
+  readonly [name: string]: SpanAttributeValue;
+};
+type SpanAttributes = Readonly<Record<string, SpanAttributeValue>>;
+interface SpanAttributeReadOptions {
+  providerId: string;
+  withShared?: boolean;
+}
+interface SpanPathOptions {
+  skipSelf?: boolean;
+}
+interface SpanNodeAttributes {
+  readonly spanId: string;
+  readonly parentSpanId?: string;
+  readonly attributes: SpanAttributes;
+}
+interface MutableSpanCreateOptions extends Omit<SpanCreateOptions, "mutable"> {
+  mutable: true;
+}
+interface SpanTrait {
+  readonly id: string;
+  readonly parent?: SpanTrait;
+  getAttributes(options?: SpanAttributeReadOptions): SpanAttributes;
+  getRootToNodePath(options?: SpanPathOptions): readonly SpanTrait[];
+  getRootToNodeAttributes(options?: SpanPathOptions & {
+    providerId?: string;
+  }): readonly SpanNodeAttributes[];
+  fork(options: MutableSpanCreateOptions): MutableSpanTrait;
+  fork(options?: SpanCreateOptions): SpanTrait;
+  fork(options?: SpanCreateOptions | MutableSpanCreateOptions): SpanTrait | MutableSpanTrait;
+}
+interface MutableSpanTrait extends SpanTrait {
+  setAttributes(attributes: SpanAttributes, options?: {
+    providerId?: string;
+  }): void;
+}
+declare const SPAN_TRAIT_TOKEN: SecuritydeptInjectionToken<SpanTrait>;
+//#endregion
+//#region src/errors/types.d.ts
+type ClientErrorSpanContext = readonly SpanNodeAttributes[];
+/** 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];
+/** Safe user-facing presentation supplied by a server error response. */
+interface ServerErrorPresentation {
+  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 ErrorRecoveryActionDescriptor {
+  recovery: UserRecovery;
+  label: string;
+  href: string | null;
+}
+interface ErrorPresentationDescriptor {
+  code: string | null;
+  title: string;
+  description: string;
+  recovery: UserRecovery;
+  tone: ErrorPresentationTone;
+  primaryAction: ErrorRecoveryActionDescriptor | null;
+}
+interface ReadErrorPresentationDescriptorOptions {
+  fallbackTitle?: string;
+  fallbackDescription?: string;
+  codePresentations?: Readonly<Record<string, ErrorCodePresentation>>;
+  recoveryLinks?: Partial<Record<UserRecovery, string>>;
+  recoveryLabels?: Partial<Record<UserRecovery, string>>;
+  contextFormatter?: ClientErrorContextFormatter | null;
+}
+type ClientErrorContextFormatter = (context: ClientErrorSpanContext) => string | undefined;
+interface ErrorCodePresentation {
+  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
+declare const CLIENT_ERROR_SPAN_ATTRIBUTE_PROVIDER_ID = "@securitydept/client/error";
+interface ClientErrorFromUnknownOptions {
+  message: string;
+  code: string;
+  source: string;
+  span?: SpanTrait;
+}
+interface ClientErrorFromHttpResponseOptions {
+  status: number;
+  body?: unknown;
+  source?: string;
+  span?: SpanTrait;
+}
+/**
+ * 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 {
+  private _spanContext;
+  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?: ServerErrorPresentation;
+  /** Source subsystem or component that produced the error. */
+  readonly source?: string;
+  get spanContext(): ClientErrorSpanContext | undefined;
+  constructor(options: {
+    kind: ClientErrorKind;
+    message: string;
+    code?: string;
+    recovery?: UserRecovery;
+    retryable?: boolean;
+    presentation?: ServerErrorPresentation;
+    source?: string;
+    cause?: unknown;
+    span?: SpanTrait;
+  });
+  captureSpanContext(span: SpanTrait): this;
+  /** 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;
+    span?: SpanTrait;
+  }): 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/errors/error-attributes.d.ts
+interface ErrorSummary {
+  errorName: string;
+  errorKind?: ClientErrorKind;
+  errorCode?: string;
+  recovery?: UserRecovery;
+}
+/** Extract secret-safe diagnostic attributes without copying runtime messages. */
+declare function describeError(error: unknown): ErrorSummary;
+//#endregion
+//#region src/errors/presentation-descriptor.d.ts
+declare const formatClientErrorContext: ClientErrorContextFormatter;
+declare function readErrorPresentationDescriptor(error: unknown, options?: ReadErrorPresentationDescriptorOptions): ErrorPresentationDescriptor;
+//#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 { ClientErrorContextFormatter as $, SecuritydeptClassProvider as $t, ResourceIdleSnapshot as A, SubscribableTrait as At, WritableSignalTrait as B, SYMBOL_DISPOSABLE_STACK as Bt, IdleCallbackTrait as C, EventStreamTrait as Ct, ComputedSignalTrait as D, InteropObservableTrait as Dt, TimestampProviderTrait as E, RuntimeEventEnvelope as Et, ResourceSnapshot as F, SecuritydeptInjector as Ft, formatClientErrorContext as G, injectDisposableStackFrom as Gt, CancellationTokenOptions as H, SimpleDisposableStack as Ht, ResourceStatus as I, AsyncDisposableTrait as It, describeError as J, inject$1 as Jt, readErrorPresentationDescriptor as K, withDisposableStack as Kt, ResourceTrait as L, DisposableStackTrait as Lt, ResourceLoadingSnapshot as M, WithInteropObservableTraitCompat as Mt, ResourceReloadingSnapshot as N, isInteropObservableTrait as Nt, ReadableSignalTrait as O, ObserverTrait as Ot, ResourceResolvedSnapshot as P, INJECTOR_TOKEN as Pt, ClientErrorFromUnknownOptions as Q, SecuritydeptAbstractType as Qt, ResourceWhenValueOptions as R, DisposableTrait as Rt, IDLE_CALLBACK_TRAIT_TOKEN as S, EventSourceKind as St, TimeTrait as T, EventSubscriptionTrait as Tt, CancellationTokenSourceTrait as U, StdDisposableStack as Ut, CancelableHandle as V, SYMBOL_DISPOSE as Vt, CancellationTokenTrait as W, createDisposableStack as Wt, ClientError as X, tryInjectInInjectionContext as Xt, CLIENT_ERROR_SPAN_ATTRIBUTE_PROVIDER_ID as Y, runInInjectionContext$1 as Yt, ClientErrorFromHttpResponseOptions as Z, SecurityDeptOptional as Zt, RxEventStream as _, SpanPathOptions as _t, resourceFromSnapshots as a, SecuritydeptInjectorTrait as an, ErrorPresentationTone as at, createCancellationTokenSource as b, EventOperatorFunction as bt, RxComputedSignalCompat as c, SecuritydeptValueProvider as cn, ServerErrorPresentation as ct, RxSignalWatchCanceller as d, getSecuritydeptProviderToken as dn, SPAN_TRAIT_TOKEN as dt, SecuritydeptDependencyDescriptor as en, ClientErrorKind as et, RxSignalWatchOptions as f, notMissingProvider as fn, SpanAttributeReadOptions as ft, RxEventReplaySubject as g, SpanNodeAttributes as gt, RxStateSignalCompat as h, SpanCreateOptions as ht, mapResource as i, SecuritydeptInjectionToken as in, ErrorPresentationDescriptor as it, ResourceLoadingErrorSnapshot as j, SubscriptionTrait as jt, ResourceErrorSnapshot as k, SYMBOL_OBSERVABLE as kt, RxSignalDirtyEvent as l, WithTraitDeps as ln, UserRecovery as lt, RxStateSignal as m, SpanAttributes as mt, RxResourceOptions as n, SecuritydeptExistingProvider as nn, ClientErrorSpanContext as nt, rxResource as o, SecuritydeptProvider as on, ErrorRecoveryActionDescriptor as ot, RxSignalWatchScheduler as p, SpanAttributeValue as pt, ErrorSummary as q, SecuritydeptInjectOptions as qt, RxResourceStreamContext as r, SecuritydeptFactoryProvider as rn, ErrorCodePresentation as rt, RxComputedSignal as s, SecuritydeptTypeProvider as sn, ReadErrorPresentationDescriptorOptions as st, RxResource as t, SecuritydeptDependencyToken as tn, ClientErrorSource as tt, RxSignalOptions as u, createProviderIfTokenMissing as un, MutableSpanTrait as ut, RxEventSubject as v, SpanTrait as vt, TIME_TRAIT_TOKEN as w, EventSubjectTrait as wt, isCancellationTokenTrait as x, EventSource as xt, createLinkedCancellationToken as y, EventObserverTrait as yt, SignalOptions as z, SYMBOL_ASYNC_DISPOSE as zt };
+//# sourceMappingURL=index-CFAJ969E.d.mts.map