@ethlete/query 6.0.0-next.6 → 6.0.0-next.60

package/types/ethlete-query-ngrx-toolkit.d.ts

@@ -0,0 +1,131 @@
+import * as i0 from "@angular/core";
+import { Injector, PipeTransform } from "@angular/core";
+import { Observable, Subject } from "rxjs";
+import { AnyQueryCreator, QueryArgsOf, QueryHeaders, ResponseType } from "@ethlete/query";
+/** The call state of a toolkit handle, as `@tomtomb/ngrx-toolkit` names it. */
+export declare const CallState: {
+  readonly INIT: "INIT";
+  readonly LOADING: "LOADING";
+  readonly SUCCESS: "SUCCESS";
+  readonly ERROR: "ERROR";
+};
+export type CallState = (typeof CallState)[keyof typeof CallState];
+/** The error shape of `@tomtomb/ngrx-toolkit`: the HTTP status, the error message and the response body. */
+export type ToolkitError<T = unknown> = {
+  status: number | string;
+  message: string;
+  data: T | null;
+};
+export type ToolkitActionOptions = {
+  headers?: QueryHeaders;
+  extras?: {
+    skipCache?: boolean;
+  };
+};
+/**
+ * The toolkit-shaped args of a query creator: `queryParams` holds the path params, `params` the query string and
+ * `body` the body, the way `@tomtomb/ngrx-toolkit` action groups named them.
+ */
+export type ActionCallArgs<TCreator extends AnyQueryCreator> = { [K in keyof QueryArgsOf<TCreator> as K extends 'pathParams' ? 'queryParams' : K extends 'queryParams' ? 'params' : K extends 'body' ? 'body' : never]: QueryArgsOf<TCreator>[K]; } & {
+  actionOptions?: ToolkitActionOptions;
+};
+export type ToolkitPollingOptions = {
+  intervalDuration: number;
+  killSwitch: Subject<boolean>;
+};
+/** The handle `toolkitCall` returns, shaped like the `MappedEntityState` of `@tomtomb/ngrx-toolkit`. */
+export type MappedEntityState<TCreator extends AnyQueryCreator> = {
+  response$: Observable<ResponseType<QueryArgsOf<TCreator>> | null>;
+  cachedResponse$: Observable<ResponseType<QueryArgsOf<TCreator>>>;
+  error$: Observable<ToolkitError | null>;
+  args$: Observable<ActionCallArgs<TCreator> | null>;
+  isInit$: Observable<boolean | null>;
+  isLoading$: Observable<boolean | null>;
+  isSuccess$: Observable<boolean | null>;
+  isError$: Observable<boolean | null>;
+  timestamp$: Observable<number | null>;
+  callState$: Observable<CallState | null>;
+  refresh: () => void;
+  remove: () => void;
+  startPolling: (options: ToolkitPollingOptions) => void;
+  stopPolling: () => void;
+};
+export type AnyMappedEntityState = MappedEntityState<any>;
+type ExtractFrom<T> = T extends Observable<infer U> ? U : never;
+/** What `suspense` and `suspenseMulti` render for a handle: every stream's current value, plus the handle's methods. */
+type ToolkitSuspenseState<T extends AnyMappedEntityState | null | undefined> = T extends AnyMappedEntityState ? {
+  args: ExtractFrom<T['args$']>;
+  cachedResponse: ExtractFrom<T['cachedResponse$']> | null;
+  callState: ExtractFrom<T['callState$']>;
+  error: ExtractFrom<T['error$']>;
+  isError: ExtractFrom<T['isError$']>;
+  isInit: ExtractFrom<T['isInit$']>;
+  isLoading: ExtractFrom<T['isLoading$']>;
+  isSuccess: ExtractFrom<T['isSuccess$']>;
+  response: ExtractFrom<T['response$']>;
+  timestamp: ExtractFrom<T['timestamp$']>;
+  refresh: () => void;
+  remove: () => void;
+  startPolling: (options: ToolkitPollingOptions) => void;
+  stopPolling: () => void;
+} : T;
+/** Subscribes to a toolkit handle and renders its current state, like the `suspense` pipe of `@tomtomb/ngrx-toolkit`. */
+export declare class SuspensePipe implements PipeTransform {
+  transform: <T extends AnyMappedEntityState>(value: T | null | undefined) => ToolkitSuspenseState<T>;
+  static ɵfac: i0.ɵɵFactoryDeclaration<SuspensePipe, never>;
+  static ɵpipe: i0.ɵɵPipeDeclaration<SuspensePipe, "suspense", true>;
+}
+type AnyHandleRecord = Record<string, AnyMappedEntityState | null | undefined>;
+export type ToolkitSuspenseMultiState<T extends AnyHandleRecord> = { [K in keyof T]: ToolkitSuspenseState<T[K]>; };
+/**
+ * Subscribes to a record of toolkit handles and renders each one's current state, like the `suspenseMulti` pipe of
+ * `@tomtomb/ngrx-toolkit`. Nothing renders until every non-null handle has emitted.
+ */
+export declare class SuspenseMultiPipe implements PipeTransform {
+  transform: <T extends AnyHandleRecord>(value: T | null | undefined) => ToolkitSuspenseMultiState<T>;
+  static ɵfac: i0.ɵɵFactoryDeclaration<SuspenseMultiPipe, never>;
+  static ɵpipe: i0.ɵɵPipeDeclaration<SuspenseMultiPipe, "suspenseMulti", true>;
+}
+/** Exports the `suspense` and `suspenseMulti` pipes, like the `NgRxToolkitModule` of `@tomtomb/ngrx-toolkit`. */
+export declare class NgRxToolkitModule {
+  static ɵfac: i0.ɵɵFactoryDeclaration<NgRxToolkitModule, never>;
+  static ɵmod: i0.ɵɵNgModuleDeclaration<NgRxToolkitModule, never, [typeof SuspensePipe, typeof SuspenseMultiPipe], [typeof SuspensePipe, typeof SuspenseMultiPipe]>;
+  static ɵinj: i0.ɵɵInjectorDeclaration<NgRxToolkitModule>;
+}
+export type ToolkitCallOptions = {
+  /**
+   * The injector the handle's query lives in. Required outside an injection context, which is where a
+   * `providedIn: 'root'` facade calls from; pass the facade's `inject(Injector)`.
+   */
+  injector?: Injector;
+};
+/**
+ * Returns the handle for a creator and args without executing it - the `FacadeBase.select(group, actionId)` of
+ * `@tomtomb/ngrx-toolkit`. Args that build the same request (in any key order, other keys ignored) give the same
+ * handle `toolkitCall` returns, so `toolkitSelect(getTeam, args, { injector }).refresh()` re-runs a request another
+ * component started.
+ */
+export declare const toolkitSelect: <TCreator extends AnyQueryCreator>(creator: TCreator, args: ActionCallArgs<TCreator>, options?: ToolkitCallOptions) => MappedEntityState<TCreator>;
+/**
+ * Executes a query creator with toolkit-shaped args and returns its handle - the `FacadeBase.call(group, args)` of
+ * `@tomtomb/ngrx-toolkit`. Every call sends the request again, unless one with equal args is still in flight, which it
+ * joins; equal args return the same handle, which lives as long as the injector.
+ *
+ * @example
+ * ```ts
+ * @Injectable({ providedIn: 'root' })
+ * export class TeamFacade {
+ *   private injector = inject(Injector);
+ *
+ *   getTeam(args: ActionCallArgs<typeof getTeam>) {
+ *     return toolkitCall(getTeam, args, { injector: this.injector });
+ *   }
+ * }
+ * ```
+ */
+export declare const toolkitCall: <TCreator extends AnyQueryCreator>(creator: TCreator, args: ActionCallArgs<TCreator>, options?: ToolkitCallOptions) => MappedEntityState<TCreator>;
+/** Emits `true` while any of the given loading streams is `true`. Nullish entries are skipped. */
+export declare const joinLoading: (observables: (Observable<boolean | null> | null | undefined)[]) => Observable<boolean>;
+/** Emits every non-null error of the given error streams, or `null` when there is none. Nullish entries are skipped. */
+export declare const joinErrors: (observables: (Observable<ToolkitError | null> | null | undefined)[]) => Observable<ToolkitError[] | null>;
+export type { ToolkitSuspenseState };

package/types/ethlete-query-testing.d.ts

@@ -1,167 +1,302 @@
-import { AnyCreateQueryClientResult, QueryClientRef, createGetQuery, createPostQuery, createPutQuery, createPatchQuery, createDeleteQuery, BearerAuthProviderFeatureContext, AnyQueryBuilder, BearerAuthProvider, AuthQueryBuilder, TokenRefreshQueryBuilder, TokenRefreshQueryConfig } from '@ethlete/query';
-import { HttpClient } from '@angular/common/http';
-import { HttpTestingController } from '@angular/common/http/testing';
-import { Injector } from '@angular/core';
-
-type QueryTestSetup = {
-    queryClient: NonNullable<ReturnType<AnyCreateQueryClientResult[1]>>;
-    queryClientRef: QueryClientRef;
-    httpClient: HttpClient;
-    httpTesting: HttpTestingController;
-    injector: Injector;
-    baseUrl: string;
-    createGet: ReturnType<typeof createGetQuery>;
-    createPost: ReturnType<typeof createPostQuery>;
-    createPut: ReturnType<typeof createPutQuery>;
-    createPatch: ReturnType<typeof createPatchQuery>;
-    createDelete: ReturnType<typeof createDeleteQuery>;
+import { AnyCreateQueryClientResult, AnyQueryBuilder, AuthQueryBuilder, BearerAuthProvider, BearerAuthProviderFeatureContext, FeatureRegistry, PersistedQueryEntry, QueryClientRef, QueryPersistenceAdapter, SocketMessageView, TokenRefreshQueryBuilder, TokenRefreshQueryConfig, WebSocketClientIo, createDeleteQuery, createGetQuery, createPatchQuery, createPostQuery, createPutQuery } from "@ethlete/query";
+import { HttpClient } from "@angular/common/http";
+import { HttpTestingController } from "@angular/common/http/testing";
+import { Injector } from "@angular/core";
+export type QueryTestSetup = {
+  queryClient: NonNullable<ReturnType<AnyCreateQueryClientResult['inject']>>;
+  queryClientRef: QueryClientRef;
+  httpClient: HttpClient;
+  httpTesting: HttpTestingController;
+  injector: Injector;
+  baseUrl: string;
+  createGet: ReturnType<typeof createGetQuery>;
+  createPost: ReturnType<typeof createPostQuery>;
+  createPut: ReturnType<typeof createPutQuery>;
+  createPatch: ReturnType<typeof createPatchQuery>;
+  createDelete: ReturnType<typeof createDeleteQuery>;
+  /**
+   * Puts back the `console.error` that was installed before the first {@link setupQueryTest} call. Runs
+   * on its own when the `TestBed` module is reset; idempotent, and safe to call from any setup.
+   */
+  restoreConsole: () => void;
 };
-type QueryTestSetupConfig = {
-    baseUrl?: string;
-    name?: string;
-    mockErrorHandler?: boolean;
+export type QueryTestSetupConfig = {
+  baseUrl?: string;
+  name?: string;
+  /**
+   * `true` swallows the `ErrorHandler` reports of failed requests and rethrows every other error, `'all'`
+   * swallows everything, `false` keeps Angular's own handler.
+   * @default true
+   */
+  mockErrorHandler?: boolean | 'all';
 };
-declare const setupQueryTest: (config?: QueryTestSetupConfig) => QueryTestSetup;
-
-type AnyFeatureBuilder = (context: BearerAuthProviderFeatureContext<any, readonly AnyQueryBuilder[]>) => {
-    type: string;
-    instance: unknown;
+export declare const setupQueryTest: (config?: QueryTestSetupConfig) => QueryTestSetup;
+export type AnyFeatureBuilder = (context: BearerAuthProviderFeatureContext<any, readonly AnyQueryBuilder[]>) => {
+  type: string;
+  instance: unknown;
 };
-type AuthTestSetupConfig<TLoginArgs extends {
-    body: Record<string, unknown>;
-    response: {
-        accessToken: string;
-        refreshToken: string;
-    };
-} = {
-    body: Record<string, unknown>;
-    response: {
-        accessToken: string;
-        refreshToken: string;
-    };
-}, TRefreshArgs extends {
-    body: Record<string, unknown>;
-    response: {
-        accessToken: string;
-        refreshToken: string;
-    };
-} = {
-    body: Record<string, unknown>;
-    response: {
-        accessToken: string;
-        refreshToken: string;
-    };
-}, TFeatures extends readonly AnyFeatureBuilder[] = [], TBearerData = unknown> = {
-    /** The query test setup instance */
-    querySetup: QueryTestSetup;
-    /** Login endpoint path. Default: '/auth/login' */
-    loginPath?: string;
-    /** Refresh endpoint path. Default: '/auth/refresh' */
-    refreshPath?: string;
-    /** Whether to enable auto-retry on 401. Default: false */
-    autoRetryOn401?: boolean;
-    /** Function to extract tokens from login response */
-    extractLoginTokens?: (response: TLoginArgs['response']) => {
-        accessToken: string;
-        refreshToken: string;
-    };
-    /** Function to extract tokens from refresh response */
-    extractRefreshTokens?: (response: TRefreshArgs['response']) => {
-        accessToken: string;
-        refreshToken: string;
-    };
-    /** Feature builders for additional auth functionality */
-    features?: [...TFeatures];
-    /** Custom bearer decrypt function for testing */
-    bearerDecryptFn?: (token: string) => TBearerData;
-    /** Whether to disable multi-tab sync. Default: false */
-    multiTabSync?: false | {
-        enabled?: boolean;
-        channelName?: string;
-        syncTokens?: boolean;
-        syncLogout?: boolean;
-        leaderElection?: boolean;
-    };
-    /** Refresh strategy configuration. See TokenRefreshQueryConfig for details */
-    refreshStrategy?: TokenRefreshQueryConfig<TRefreshArgs>['refreshStrategy'];
-    /** Minimum refresh interval in milliseconds */
-    minRefreshInterval?: number;
-    /** Whether to refresh if token is already expired */
-    refreshIfExpired?: boolean;
-    /** Property name for expiration in JWT */
-    expiresInPropertyName?: string;
+type AuthTestArgs = {
+  body: Record<string, unknown>;
+  response: {
+    accessToken: string;
+    refreshToken: string;
+  };
 };
-type AuthTestSetup<TLoginArgs extends {
-    body: Record<string, unknown>;
-    response: {
-        accessToken: string;
-        refreshToken: string;
-    };
-} = {
-    body: Record<string, unknown>;
-    response: {
-        accessToken: string;
-        refreshToken: string;
-    };
-}, TRefreshArgs extends {
-    body: Record<string, unknown>;
-    response: {
-        accessToken: string;
-        refreshToken: string;
-    };
-} = {
-    body: Record<string, unknown>;
-    response: {
-        accessToken: string;
-        refreshToken: string;
-    };
-}, TFeatures extends readonly AnyFeatureBuilder[] = [], TBearerData = unknown> = {
-    /** The bearer auth provider instance */
-    auth: BearerAuthProvider<[
-        AuthQueryBuilder<'login', TLoginArgs>,
-        TokenRefreshQueryBuilder<'refresh', TRefreshArgs>
-    ], TFeatures, TBearerData>;
-    /** Helper to login a user and flush the HTTP request */
-    login: (credentials: TLoginArgs['body'], response: TLoginArgs['response']) => void;
-    /** Helper to trigger a refresh and flush the HTTP request */
-    refresh: (token: string, response: TRefreshArgs['response']) => void;
-    /** Helper to make a secure request that requires authentication */
-    makeSecureRequest: (route: string) => void;
+/** The query builders of the provider {@link setupAuthTest} builds: a `login` and a `refresh` query. */
+export type AuthTestQueryBuilders<TLoginArgs extends AuthTestArgs = AuthTestArgs, TRefreshArgs extends AuthTestArgs = AuthTestArgs> = [AuthQueryBuilder<'login', TLoginArgs>, TokenRefreshQueryBuilder<'refresh', TRefreshArgs>];
+/** A feature for the provider {@link setupAuthTest} builds, typed against its `login`/`refresh` queries. */
+export type AuthTestFeatureBuilder = (context: BearerAuthProviderFeatureContext<any, AuthTestQueryBuilders>) => unknown;
+export type AuthTestSetupConfig<TLoginArgs extends AuthTestArgs = AuthTestArgs, TRefreshArgs extends AuthTestArgs = AuthTestArgs, TFeatures extends readonly AuthTestFeatureBuilder[] = [], TBearerData = unknown> = {
+  /** The query test setup instance */
+  querySetup: QueryTestSetup;
+  /** Login endpoint path. Default: '/auth/login' */
+  loginPath?: string;
+  /** Refresh endpoint path. Default: '/auth/refresh' */
+  refreshPath?: string;
+  /** Whether to refresh and retry a secure request that answers 401. Default: true, as in production */
+  autoRetryOn401?: boolean;
+  /** Function to extract tokens from login response */
+  extractLoginTokens?: (response: TLoginArgs['response']) => {
+    accessToken: string;
+    refreshToken: string;
+  };
+  /** Function to extract tokens from refresh response */
+  extractRefreshTokens?: (response: TRefreshArgs['response']) => {
+    accessToken: string;
+    refreshToken: string;
+  };
+  /** Builds the refresh request from the refresh token. See TokenRefreshQueryConfig for details */
+  buildRefreshArgs?: TokenRefreshQueryConfig<TRefreshArgs>['buildArgs'];
+  /** Feature builders for additional auth functionality */
+  features?: TFeatures;
+  /** Custom bearer decrypt function for testing */
+  bearerDecryptFn?: (token: string) => TBearerData;
+  /** Refresh strategy configuration. See TokenRefreshQueryConfig for details */
+  refreshStrategy?: TokenRefreshQueryConfig<TRefreshArgs>['refreshStrategy'];
+  /** Minimum refresh interval in milliseconds */
+  minRefreshInterval?: number;
+  /** Whether to refresh if token is already expired */
+  refreshIfExpired?: boolean;
+  /** Property name for expiration in JWT */
+  expiresInPropertyName?: string;
+  /** What to do when the refresh query fails for good. Defaults to the provider's own policy */
+  onRefreshFailure?: TokenRefreshQueryConfig<TRefreshArgs>['onRefreshFailure'];
 };
-declare const setupAuthTest: <TLoginArgs extends {
-    body: Record<string, unknown>;
-    response: {
-        accessToken: string;
-        refreshToken: string;
-    };
-} = {
-    body: Record<string, unknown>;
-    response: {
-        accessToken: string;
-        refreshToken: string;
-    };
-}, TRefreshArgs extends {
-    body: Record<string, unknown>;
-    response: {
-        accessToken: string;
-        refreshToken: string;
-    };
-} = {
-    body: Record<string, unknown>;
-    response: {
-        accessToken: string;
-        refreshToken: string;
-    };
-}, TFeatures extends readonly AnyFeatureBuilder[] = readonly AnyFeatureBuilder[], TBearerData = unknown>(config: AuthTestSetupConfig<TLoginArgs, TRefreshArgs, TFeatures, TBearerData>) => AuthTestSetup<TLoginArgs, TRefreshArgs, TFeatures, TBearerData>;
-
-declare const expectAndFlush: <T = unknown>(httpTesting: HttpTestingController, url: string, response: T, statusOpts?: {
-    status: number;
-    statusText: string;
+export type AuthTestSetup<TLoginArgs extends AuthTestArgs = AuthTestArgs, TRefreshArgs extends AuthTestArgs = AuthTestArgs, TFeatures extends readonly AuthTestFeatureBuilder[] = [], TBearerData = unknown> = {
+  /** The bearer auth provider instance */
+  auth: Omit<BearerAuthProvider<AuthTestQueryBuilders<TLoginArgs, TRefreshArgs>, [], TBearerData>, 'features'> & {
+    features: FeatureRegistry<TFeatures, AuthTestQueryBuilders<TLoginArgs, TRefreshArgs>>;
+  };
+  /** Helper to login a user and flush the HTTP request */
+  login: (credentials: TLoginArgs['body'], response: TLoginArgs['response']) => void;
+  /** Helper to trigger a refresh and flush the HTTP request. Sends `buildRefreshArgs(token)` when configured, else `{ body: { token } }` */
+  refresh: (token: string, response: TRefreshArgs['response']) => void;
+  /** Helper to make a secure request that requires authentication */
+  makeSecureRequest: (route: string) => void;
+};
+export declare const setupAuthTest: <TLoginArgs extends AuthTestArgs = AuthTestArgs, TRefreshArgs extends AuthTestArgs = AuthTestArgs, TFeatures extends readonly AuthTestFeatureBuilder[] = readonly AuthTestFeatureBuilder[], TBearerData = unknown>(config: AuthTestSetupConfig<TLoginArgs, TRefreshArgs, TFeatures, TBearerData>) => AuthTestSetup<TLoginArgs, TRefreshArgs, TFeatures, TBearerData>;
+/**
+ * Test doubles for the two browser APIs the query client's multi-tab sync is built on:
+ * `BroadcastChannel` and the Web Locks API (`navigator.locks`).
+ *
+ * Both fakes are process-wide and shared between every consumer created while they are installed,
+ * which is exactly what makes "two tabs" testable: create two query clients in one test and they
+ * talk to each other over the fake bus and contend for the same fake locks, going through the real
+ * production code path on both sides.
+ *
+ * Neither jsdom nor happy-dom can stand in here - jsdom ships a `BroadcastChannel` that never
+ * delivers to other instances, and no `navigator.locks` at all.
+ */
+/** Something posted on the fake bus, as seen by a receiver. */
+export type FakeBroadcastMessage = {
+  /** The channel name it was posted on. */
+  channel: string;
+  /** The structured-cloned payload. */
+  data: unknown;
+};
+export type FakeBroadcastChannelHandle = {
+  /** Every message posted on the bus, in order, across all channel names. */
+  posted: FakeBroadcastMessage[];
+  /** Uninstalls the fake and restores whatever `BroadcastChannel` was there before. */
+  restore: () => void;
+};
+/**
+ * Replaces `globalThis.BroadcastChannel` with an in-memory bus.
+ *
+ * Messages are structured-cloned at post time (so a non-cloneable payload throws exactly like the
+ * real API does), delivered as a task (never synchronously, and after every pending microtask), and
+ * never delivered back to the channel that posted them - all three matching browser behavior. Delivery
+ * does not depend on fake timers; `await flushMultiTabSync()` in a spec flushes it.
+ */
+export declare const installFakeBroadcastChannel: () => FakeBroadcastChannelHandle;
+export type FakeWebLocksHandle = {
+  /** The names currently held, in no particular order. */
+  heldNames: () => string[];
+  /** The names with at least one request queued behind the holder. */
+  pendingNames: () => string[];
+  /** Uninstalls the fake and restores whatever `navigator.locks` was there before. */
+  restore: () => void;
+};
+/**
+ * Installs an in-memory `navigator.locks` implementing exclusive locks: one holder per name, the
+ * rest queued FIFO, granted on a microtask (never synchronously), released when the callback's
+ * promise settles. `signal` is honored for queued requests and - as in the real API - ignored once a
+ * request has been granted.
+ *
+ * `ifAvailable` is a try-lock: a request that cannot be granted straight away runs its callback with
+ * `null` instead of queueing, exactly as the real API does. `steal` releases the current holder -
+ * rejecting its request with an `AbortError` - and is granted ahead of everything queued.
+ *
+ * `mode: 'shared'` is not implemented; nothing in the library uses it.
+ */
+export declare const installFakeWebLocks: () => FakeWebLocksHandle;
+/**
+ * Waits for the fakes' pending work - message delivery (a task) and lock grants (a microtask) - even
+ * under fake timers. Awaiting it once is enough for a single hop; a grant that has to wait for another
+ * tab's release, or a reply to a delivered message, needs one await per hop.
+ */
+export declare const flushMultiTabSync: () => Promise<void>;
+/**
+ * An in-memory stand-in for the query client's persisted response store.
+ *
+ * jsdom has no IndexedDB at all, so this is how persistence is tested - and because the storage
+ * adapter is a documented seam rather than a mock of one, a spec running against this exercises the
+ * real engine, repository and request code on both the write and the read side.
+ *
+ * Everything resolves on a microtask, never synchronously, matching the real thing: `await
+ * Promise.resolve()` (or `flushMicrotasks`) is what lets a hydration land in a spec.
+ */
+export type FakeQueryPersistenceStoreHandle = {
+  /** Pass this as `persistence: { adapter }`. Two clients sharing one handle share one store. */
+  adapter: QueryPersistenceAdapter;
+  /** Pre-populates the store, as if a previous session had written these entries. */
+  seed: (entries: PersistedQueryEntry[]) => void;
+  /** Every entry currently held, in insertion order. */
+  entries: () => PersistedQueryEntry[];
+  /** The entry held under `key`, or `undefined`. */
+  entry: (key: string) => PersistedQueryEntry | undefined;
+  /** How often each adapter method has been called. */
+  calls: () => Record<'loadIndex' | 'read' | 'write' | 'remove' | 'clear', number>;
+  /** Makes the next `count` writes reject - a full disk, by default. */
+  failNextWrites: (count: number, error?: unknown) => void;
+  /** Makes the next `count` removals reject. */
+  failNextRemoves: (count: number, error?: unknown) => void;
+  /** Makes the next `loadIndex` reject. */
+  failNextLoadIndex: (error?: unknown) => void;
+  /**
+   * Holds every subsequent `read` pending until {@link flushReads} is called, for testing the window
+   * between a cold mount and its hydration (a slow disk, or a mount that happened before startup
+   * finished). Each held read returns what the store held when it started, as `loadIndex` does.
+   */
+  deferReads: () => void;
+  /** Settles the reads held by {@link deferReads} and stops deferring. */
+  flushReads: () => Promise<void>;
+  /**
+   * Holds every subsequent `loadIndex` pending until {@link flushLoadIndex} is called, for testing
+   * what happens to the store while a client's startup is still reading its index (a real disk takes
+   * milliseconds). The snapshot each held load returns is the one it would have read when it started.
+   */
+  deferLoadIndex: () => void;
+  /** Settles the index loads held by {@link deferLoadIndex} and stops deferring. */
+  flushLoadIndex: () => Promise<void>;
+};
+export declare const createFakeQueryPersistenceStore: () => FakeQueryPersistenceStoreHandle;
+export declare const expectAndFlush: <T = unknown>(httpTesting: HttpTestingController, url: string, response: T, statusOpts?: {
+  status: number;
+  statusText: string;
 }) => void;
-declare const expectFlushAndWait: <T = unknown>(httpTesting: HttpTestingController, url: string, response: T, statusOpts?: {
-    status: number;
-    statusText: string;
+export declare const expectFlushAndWait: <T = unknown>(httpTesting: HttpTestingController, url: string, response: T, statusOpts?: {
+  status: number;
+  statusText: string;
 }) => void;
-
-export { expectAndFlush, expectFlushAndWait, setupAuthTest, setupQueryTest };
-export type { AnyFeatureBuilder, AuthTestSetup, AuthTestSetupConfig, QueryTestSetup, QueryTestSetupConfig };
+/** A scripted stand-in for `socket.io-client`'s `io`, driven from a spec. */
+export type WebSocketTestDouble = {
+  /** Pass this as `createWebSocketClient({ io })`. */
+  io: WebSocketClientIo;
+  /** The url and options the client called the factory with, or `null` until it did. */
+  connection: () => {
+    url: string;
+    transports: string[] | undefined;
+  } | null;
+  /** The `withCredentials` the client asked the factory for, or `null` until it called it. */
+  withCredentials: () => boolean | null;
+  /** The auth payload of every handshake, oldest first - `null` for one made without `auth`. */
+  handshakes: () => (object | null)[];
+  /** Every message the client emitted, newest last - room joins and leaves included, buffered ones too. */
+  sent: () => {
+    event: string;
+    data: unknown;
+  }[];
+  /** Every message that reached the server, newest last. An emit buffered while offline lands here on the next connect. */
+  delivered: () => {
+    event: string;
+    data: unknown;
+  }[];
+  /**
+   * Whether the client asked the socket to connect, and whether it has since disconnected it. `active` is
+   * socket.io's own flag - `false` after a server disconnect or a rejected handshake, until the next
+   * `connect()`; `connectCalls` counts every `connect()`.
+   */
+  state: () => {
+    connectRequested: boolean;
+    disconnected: boolean;
+    active: boolean;
+    connectCalls: number;
+  };
+  /**
+   * Complete the handshake: flush every buffered emit, then turn the client's `isConnected` true. Pass
+   * `recovered: true` for a connection-state-recovered reconnect, in which the server kept the rooms.
+   */
+  serverConnect: (options?: {
+    recovered?: boolean;
+  }) => void;
+  /**
+   * Drop the connection, so `isConnected` turns false. The default reason, `'transport close'`, is one
+   * socket.io recovers from itself; `'io server disconnect'` is the server kicking the socket, after which
+   * socket.io only reconnects when `connect()` is called again.
+   */
+  serverDisconnect: (options?: {
+    reason?: 'transport close' | 'io server disconnect';
+  }) => void;
+  /**
+   * Reject the handshake the way a server middleware does: the `auth` payload is recorded in
+   * {@link handshakes}, `connect_error` fires and the socket stops reconnecting on its own.
+   */
+  serverRejectHandshake: (message?: string) => void;
+  /**
+   * Let the ping expire: the socket still reports itself connected, but buffers every emit like socket.io
+   * does until it notices and closes. Follow it with {@link serverDisconnect}.
+   */
+  serverPingExpire: () => void;
+  /** Deliver a message the way the server would. */
+  serverSend: (message: SocketMessageView) => void;
+  /** Deliver a raw frame, for the malformed-payload path. */
+  serverSendRaw: (frame: string) => void;
+};
+/**
+ * A socket io test double, for specs around `createWebSocketClient` - which takes its `io` factory as
+ * an option precisely so a spec (or an app that never opens a socket) needs no `socket.io-client`.
+ *
+ * Nothing here connects on its own: the client's own `connect()` only flips
+ * {@link WebSocketTestDouble.state}, and it is {@link WebSocketTestDouble.serverConnect} that fires
+ * the `connect` listener. That split is what makes "joined a room while disconnected, and it was
+ * re-joined after a reconnect" testable.
+ */
+export declare const createWebSocketTestDouble: () => WebSocketTestDouble;
+export type MintTestTokenOptions = {
+  /** @default 900000 (15 minutes) */
+  expiresInMs?: number;
+  /** Extra payload claims, e.g. the user id or roles `bearerData()` and the auth guards read. */
+  claims?: Record<string, unknown>;
+};
+/**
+ * Mints an unsigned JWT the bearer auth provider can decode, with `iat`, `exp` and a unique `jti`.
+ * Hand it to `setTokens()` to put the app's own provider into a session.
+ *
+ * @example
+ * ```ts
+ * TestBed.runInInjectionContext(() => authProviderRef.inject().setTokens(mintTestToken({ claims: { sub: '1' } }), 'refresh'));
+ * ```
+ */
+export declare const mintTestToken: (options?: MintTestTokenOptions) => string;
+export {};