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

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

@@ -1,103 +1,100 @@
-import { AnyCreateQueryClientResult, QueryClientRef, createGetQuery, createPostQuery, createPutQuery, createPatchQuery, createDeleteQuery, BearerAuthProviderFeatureContext, AnyQueryBuilder, AuthQueryBuilder, TokenRefreshQueryBuilder, BearerAuthProvider, FeatureRegistry, TokenRefreshQueryConfig, QueryPersistenceAdapter, PersistedQueryEntry, WebSocketClientIo, SocketMessageView } 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['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;
+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;
-    /**
-     * `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';
+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 AuthTestArgs = {
-    body: Record<string, unknown>;
-    response: {
-        accessToken: string;
-        refreshToken: string;
-    };
+  body: Record<string, unknown>;
+  response: {
+    accessToken: string;
+    refreshToken: string;
+  };
 };
 /** The query builders of the provider {@link setupAuthTest} builds: a `login` and a `refresh` query. */
-type AuthTestQueryBuilders<TLoginArgs extends AuthTestArgs = AuthTestArgs, TRefreshArgs extends AuthTestArgs = AuthTestArgs> = [AuthQueryBuilder<'login', TLoginArgs>, TokenRefreshQueryBuilder<'refresh', TRefreshArgs>];
+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. */
-type AuthTestFeatureBuilder = (context: BearerAuthProviderFeatureContext<any, AuthTestQueryBuilders>) => unknown;
-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'];
+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'];
 };
-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 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;
 };
-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>;
-
+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`).
@@ -111,17 +108,17 @@ declare const setupAuthTest: <TLoginArgs extends AuthTestArgs = AuthTestArgs, TR
  * delivers to other instances, and no `navigator.locks` at all.
  */
 /** Something posted on the fake bus, as seen by a receiver. */
-type FakeBroadcastMessage = {
-    /** The channel name it was posted on. */
-    channel: string;
-    /** The structured-cloned payload. */
-    data: unknown;
+export type FakeBroadcastMessage = {
+  /** The channel name it was posted on. */
+  channel: string;
+  /** The structured-cloned payload. */
+  data: unknown;
 };
-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;
+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.
@@ -131,14 +128,14 @@ type FakeBroadcastChannelHandle = {
  * 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.
  */
-declare const installFakeBroadcastChannel: () => FakeBroadcastChannelHandle;
-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;
+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
@@ -152,14 +149,13 @@ type FakeWebLocksHandle = {
  *
  * `mode: 'shared'` is not implemented; nothing in the library uses it.
  */
-declare const installFakeWebLocks: () => FakeWebLocksHandle;
+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.
  */
-declare const flushMultiTabSync: () => Promise<void>;
-
+export declare const flushMultiTabSync: () => Promise<void>;
 /**
  * An in-memory stand-in for the query client's persisted response store.
  *
@@ -170,114 +166,112 @@ declare const flushMultiTabSync: () => Promise<void>;
  * 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.
  */
-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 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>;
 };
-declare const createFakeQueryPersistenceStore: () => FakeQueryPersistenceStoreHandle;
-
-declare const expectAndFlush: <T = unknown>(httpTesting: HttpTestingController, url: string, response: T, statusOpts?: {
-    status: number;
-    statusText: string;
+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;
-
 /** A scripted stand-in for `socket.io-client`'s `io`, driven from a spec. */
-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;
+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
@@ -288,13 +282,12 @@ type WebSocketTestDouble = {
  * the `connect` listener. That split is what makes "joined a room while disconnected, and it was
  * re-joined after a reconnect" testable.
  */
-declare const createWebSocketTestDouble: () => WebSocketTestDouble;
-
-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>;
+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`.
@@ -305,7 +298,5 @@ type MintTestTokenOptions = {
  * TestBed.runInInjectionContext(() => authProviderRef.inject().setTokens(mintTestToken({ claims: { sub: '1' } }), 'refresh'));
  * ```
  */
-declare const mintTestToken: (options?: MintTestTokenOptions) => string;
-
-export { createFakeQueryPersistenceStore, createWebSocketTestDouble, expectAndFlush, expectFlushAndWait, flushMultiTabSync, installFakeBroadcastChannel, installFakeWebLocks, mintTestToken, setupAuthTest, setupQueryTest };
-export type { AnyFeatureBuilder, AuthTestFeatureBuilder, AuthTestQueryBuilders, AuthTestSetup, AuthTestSetupConfig, FakeBroadcastChannelHandle, FakeBroadcastMessage, FakeQueryPersistenceStoreHandle, FakeWebLocksHandle, MintTestTokenOptions, QueryTestSetup, QueryTestSetupConfig, WebSocketTestDouble };
+export declare const mintTestToken: (options?: MintTestTokenOptions) => string;
+export {};