@gala-chain/launchpad-sdk 9.0.0-rc.0 → 9.0.0-rc.2

package/dist/services/StreamWebSocketService.d.ts

@@ -1,283 +1,252 @@
 /**
  * Stream WebSocket Service
  *
- * Handles real-time streaming and chat events via Socket.IO including:
- * - Stream status updates (IDLE/ACTIVE/DISABLED)
- * - Viewer count updates
- * - Chat messages
- * - Subscription management
+ * The launchpad backend's realtime socket: stream status, viewer counts, chat, comments, trades,
+ * moderation, the global feed and the overseers' events firehose.
+ *
+ * ## One registry
+ *
+ * Every subscription is an entry in one registry:
+ *
+ * - Any number of subscribers per event, per token and per room. A subscribe method returns that
+ *   subscriber's own unsubscribe; releasing one never touches another. A subscriber that throws (or
+ *   rejects) is logged and skipped: it never stops the others.
+ * - A room (a token room, a comment room, the global feed, the firehose) is joined when its FIRST
+ *   subscriber arrives and left when its LAST subscriber is released: never two server subscriptions for
+ *   one room, however many subscribers share it. A leave waits for the join's acknowledgement, so a
+ *   subscribe followed at once by an unsubscribe cannot leave the server holding a room nobody wants.
+ * - A subscribe method is synchronous and never fails for want of a connection: it registers, and the
+ *   room is joined once the socket is connected (and, for the firehose, authenticated). With
+ *   `autoConnect` (the default) a subscription also opens the socket.
+ * - Socket listeners are registered once per socket, when it is created, and removed when it is closed.
+ *
+ * ## Reconnecting
+ *
+ * socket.io reconnects by itself. On every connection after the first the service re-authenticates FIRST
+ * (with the token its `tokenProvider` hands out at that moment, never a remembered one) if the socket was
+ * authenticated, THEN re-joins every room that still has a subscriber, THEN tells `onReconnect` listeners
+ * so they can refetch what they missed.
  *
  * @category Services
  * @since 5.1.0
  */
 import type { Socket } from 'socket.io-client';
-import type { GlobalFeedEventCallbacks, GlobalFeedSubscribedEvent } from '../types/global-feed.dto';
-import type { StreamChatAuthenticatedEvent, StreamChatAuthErrorEvent, StreamChatErrorEvent, StreamChatGlobalStatusEvent, StreamChatMessageEvent, StreamChatPinnedEvent, StreamChatSentEvent, StreamChatStatusEvent, StreamChatUnpinnedEvent, StreamReactionErrorEvent, StreamReactionEvent, TypingIndicatorEvent } from '../types/stream-chat.dto';
-import type { StreamCountdownEvent, StreamGlobalStatusEvent, StreamLanguageEvent, StreamStatusEvent, StreamSubscribedEvent, StreamUnsubscribedEvent, ViewerCountEvent } from '../types/streaming.dto';
-import type { ApiKeyCreatedEvent, ApiKeyRevokedEvent, ApiKeyUpdatedEvent, BalanceUpdatedEvent, CommentCreatedEvent, EngagementStatsUpdatedEvent, HolderCountUpdatedEvent, ModeratorAddedEvent, ModeratorInviteCreatedEvent, ModeratorRemovedEvent, ModeratorRoleUpdatedEvent, OverseerAddedEvent, OverseerRemovedEvent, PoolBadgeAssignedEvent, PoolMetadataUpdatedEvent, PoolSocialLinksUpdatedEvent, StatsUpdatedEvent, TokenBannedEvent, TokenConfigUpdatedEvent, TokenUnbannedEvent, TradeExecutedEvent, UserProfileUpdatedEvent } from '../types/websocket-events.dto';
+import type { SiteConfigState } from '../types/global-feed.dto';
+import type { RealtimeEventName, RealtimeEventPayloads } from '../types/realtime-events.dto';
+import type { StreamSubscribedEvent } from '../types/streaming.dto';
 import { LoggerBase } from './BaseService';
-import type { StreamingEventService } from './StreamingEventService';
+import { type CommentRoomEventName, type FeedEventName, type FeedTokenEvent, type GlobalFeedEventCallbacks, type StreamEventCallbacks, type TokenRoomEventName } from './realtime/event-catalog';
 /**
  * Stream WebSocket configuration
  */
 export interface StreamWebSocketConfig {
     /** Stream WebSocket server URL (SEPARATE from bundleBaseUrl) */
     url: string;
-    /** JWT token for authentication (optional - required for chat) */
-    authToken?: string;
-    /** Maximum reconnection attempts (default: 5) */
+    /** Maximum reconnection attempts (default: 5; `Infinity` never gives up) */
     reconnectAttempts?: number;
-    /** Delay between reconnection attempts in ms (default: 2000) */
+    /** Delay before the first reconnection attempt in ms (default: 2000) */
     reconnectDelay?: number;
-    /** Subscription timeout in ms (default: 10000) */
+    /** Longest delay between reconnection attempts in ms (socket.io's default: 5000) */
+    reconnectDelayMax?: number;
+    /** How long a room join or an authentication may wait for the server's answer in ms (default: 10000) */
     subscriptionTimeout?: number;
+    /**
+     * The JWT to authenticate with, asked for whenever the service authenticates without being handed a token
+     * (and on every reconnect). It must answer with the token current at that moment. `null`: none.
+     */
+    tokenProvider?: () => Promise<string | null>;
+    /** Open the socket when a subscription is registered and none is open (default: true). */
+    autoConnect?: boolean;
 }
+/** A subscriber's unsubscribe. Calling it twice is harmless. */
+export type Unsubscribe = () => void;
+/** A subscriber: it may be async; a rejection is logged, never thrown. */
+export type RealtimeListener<E extends RealtimeEventName> = (event: RealtimeEventPayloads[E]) => void | Promise<void>;
 /**
- * Stream event names used by the backend.
- *
- * BREAKING CHANGE (v7.2.0): Event values changed from snake_case to SCREAMING_CASE
- * to match backend websocket-events.constant.ts. Frontend and SDK consumers must
- * update their event listeners to use these new names.
- *
- * Migration: 'stream_status' → 'STREAM_STATUS', 'token_banned' → 'TOKEN_BANNED', etc.
- */
-export declare const STREAM_EVENTS: {
-    readonly SUBSCRIBE: "subscribe_token";
-    readonly UNSUBSCRIBE: "unsubscribe_token";
-    readonly AUTHENTICATE: "authenticate";
-    readonly SEND_CHAT: "send_stream_chat";
-    readonly SEND_REACTION: "SEND_STREAM_REACTION";
-    readonly TYPING_START: "typing_start";
-    readonly TYPING_STOP: "typing_stop";
-    readonly STREAM_STATUS: "STREAM_STATUS";
-    readonly RECORDING_STATUS: "RECORDING_STATUS";
-    readonly RECORDINGS_COUNT_UPDATED: "RECORDINGS_COUNT_UPDATED";
-    readonly SIMULCAST_STATUS: "SIMULCAST_STATUS";
-    readonly DOWNLOAD_READY: "DOWNLOAD_READY";
-    readonly STREAM_COUNTDOWN_UPDATED: "STREAM_COUNTDOWN_UPDATED";
-    readonly STREAM_LANGUAGE_UPDATED: "STREAM_LANGUAGE_UPDATED";
-    readonly VIEWER_COUNT: "VIEWER_COUNT";
-    readonly STREAM_SUBSCRIBED: "token_subscribed";
-    readonly STREAM_UNSUBSCRIBED: "token_unsubscribed";
-    readonly STREAM_GLOBAL_STATUS: "STREAM_GLOBAL_STATUS";
-    readonly ENGAGEMENT_STATS_UPDATED: "ENGAGEMENT_STATS_UPDATED";
-    readonly CHAT_MESSAGE: "STREAM_CHAT_MESSAGE";
-    readonly CHAT_SENT: "STREAM_CHAT_SENT";
-    readonly CHAT_UPDATED: "STREAM_CHAT_UPDATED";
-    readonly CHAT_DELETED: "STREAM_CHAT_DELETED";
-    readonly CHAT_ERROR: "stream_chat_error";
-    readonly CHAT_STATUS: "CHAT_STATUS_CHANGED";
-    readonly CHAT_GLOBAL_STATUS: "STREAM_CHAT_GLOBAL_STATUS";
-    readonly CHAT_AUTHENTICATED: "authenticated";
-    readonly CHAT_AUTH_ERROR: "stream_chat_auth_error";
-    readonly STREAM_CONTROL_STATUS_CHANGED: "STREAM_CONTROL_STATUS_CHANGED";
-    readonly REACTION: "STREAM_REACTION";
-    readonly CONTENT_REACTION_ADDED: "CONTENT_REACTION_ADDED";
-    readonly CONTENT_REACTION_REMOVED: "CONTENT_REACTION_REMOVED";
-    readonly REACTION_ERROR: "stream_reaction_error";
-    readonly USER_TYPING: "USER_TYPING";
-    readonly CHAT_PINNED: "STREAM_CHAT_PINNED";
-    readonly CHAT_UNPINNED: "STREAM_CHAT_UNPINNED";
-    readonly COMMENT_CREATED: "COMMENT_CREATED";
-    readonly COMMENT_UPDATED: "COMMENT_UPDATED";
-    readonly COMMENT_DELETED: "COMMENT_DELETED";
-    readonly USER_BANNED: "USER_BANNED";
-    readonly USER_UNBANNED: "USER_UNBANNED";
-    readonly BAN_ENFORCEMENT: "BAN_ENFORCEMENT";
-    readonly TOKEN_BANNED: "TOKEN_BANNED";
-    readonly TOKEN_UNBANNED: "TOKEN_UNBANNED";
-    readonly CONTENT_FLAGGED: "CONTENT_FLAGGED";
-    readonly FLAG_RESOLVED: "FLAG_RESOLVED";
-    readonly MODERATOR_INVITE_CREATED: "MODERATOR_INVITE_CREATED";
-    readonly MODERATOR_ADDED: "MODERATOR_ADDED";
-    readonly MODERATOR_REMOVED: "MODERATOR_REMOVED";
-    readonly MODERATOR_ROLE_UPDATED: "MODERATOR_ROLE_UPDATED";
-    readonly OVERSEER_ADDED: "OVERSEER_ADDED";
-    readonly OVERSEER_REMOVED: "OVERSEER_REMOVED";
-    readonly TRADE_EXECUTED: "TRADE_EXECUTED";
-    readonly BALANCE_UPDATED: "BALANCE_UPDATED";
-    readonly STATS_UPDATED: "STATS_UPDATED";
-    readonly POOL_METADATA_UPDATED: "POOL_METADATA_UPDATED";
-    readonly POOL_SOCIAL_LINKS_UPDATED: "POOL_SOCIAL_LINKS_UPDATED";
-    readonly POOL_BADGE_ASSIGNED: "POOL_BADGE_ASSIGNED";
-    readonly HOLDER_COUNT_UPDATED: "HOLDER_COUNT_UPDATED";
-    readonly USER_PROFILE_UPDATED: "USER_PROFILE_UPDATED";
-    readonly API_KEY_CREATED: "API_KEY_CREATED";
-    readonly API_KEY_UPDATED: "API_KEY_UPDATED";
-    readonly API_KEY_REVOKED: "API_KEY_REVOKED";
-    readonly TOKEN_CONFIG_UPDATED: "TOKEN_CONFIG_UPDATED";
-    readonly SITE_CONFIG_CHANGED: "SITE_CONFIG_CHANGED";
-    readonly COMMENTS_GLOBAL_STATUS: "COMMENTS_GLOBAL_STATUS";
-    readonly WEBHOOKS_GLOBAL_STATUS: "WEBHOOKS_GLOBAL_STATUS";
-    readonly SUBSCRIBE_GLOBAL_FEED: "subscribe_global_feed";
-    readonly UNSUBSCRIBE_GLOBAL_FEED: "unsubscribe_global_feed";
-    readonly GLOBAL_FEED_SUBSCRIBED: "global_feed_subscribed";
-    readonly GLOBAL_FEED_UNSUBSCRIBED: "global_feed_unsubscribed";
-};
-/**
- * Callback types for stream events
+ * Client-side filters of a firehose subscriber. The backend's firehose takes no filters (every overseer
+ * socket in the room receives every event), so each subscriber's filters are applied here.
  */
-export interface StreamEventCallbacks {
-    onStreamStatus?: (event: StreamStatusEvent) => void;
-    onStreamSubscribed?: (event: StreamSubscribedEvent) => void;
-    onStreamUnsubscribed?: (event: StreamUnsubscribedEvent) => void;
-    onViewerCount?: (event: ViewerCountEvent) => void;
-    onStreamGlobalStatus?: (event: StreamGlobalStatusEvent) => void;
-    onChatMessage?: (event: StreamChatMessageEvent) => void;
-    onChatSent?: (event: StreamChatSentEvent) => void;
-    onChatError?: (event: StreamChatErrorEvent) => void;
-    onChatStatus?: (event: StreamChatStatusEvent) => void;
-    onChatGlobalStatus?: (event: StreamChatGlobalStatusEvent) => void;
-    onChatAuthenticated?: (event: StreamChatAuthenticatedEvent) => void;
-    onChatAuthError?: (event: StreamChatAuthErrorEvent) => void;
-    onReaction?: (event: StreamReactionEvent) => void;
-    onReactionError?: (event: StreamReactionErrorEvent) => void;
-    onTypingIndicator?: (event: TypingIndicatorEvent) => void;
-    onChatPinned?: (event: StreamChatPinnedEvent) => void;
-    onChatUnpinned?: (event: StreamChatUnpinnedEvent) => void;
-    onCountdownUpdated?: (event: StreamCountdownEvent) => void;
-    onLanguageUpdated?: (event: StreamLanguageEvent) => void;
-    onTokenBanned?: (event: TokenBannedEvent) => void;
-    onTokenUnbanned?: (event: TokenUnbannedEvent) => void;
-    onModeratorInviteCreated?: (event: ModeratorInviteCreatedEvent) => void;
-    onModeratorAdded?: (event: ModeratorAddedEvent) => void;
-    onModeratorRemoved?: (event: ModeratorRemovedEvent) => void;
-    onModeratorRoleUpdated?: (event: ModeratorRoleUpdatedEvent) => void;
-    onOverseerAdded?: (event: OverseerAddedEvent) => void;
-    onOverseerRemoved?: (event: OverseerRemovedEvent) => void;
-    onTradeExecuted?: (event: TradeExecutedEvent) => void;
-    onBalanceUpdated?: (event: BalanceUpdatedEvent) => void;
-    onPoolMetadataUpdated?: (event: PoolMetadataUpdatedEvent) => void;
-    onPoolSocialLinksUpdated?: (event: PoolSocialLinksUpdatedEvent) => void;
-    onPoolBadgeAssigned?: (event: PoolBadgeAssignedEvent) => void;
-    onHolderCountUpdated?: (event: HolderCountUpdatedEvent) => void;
-    onCommentCreated?: (event: CommentCreatedEvent) => void;
-    onUserProfileUpdated?: (event: UserProfileUpdatedEvent) => void;
-    onApiKeyCreated?: (event: ApiKeyCreatedEvent) => void;
-    onApiKeyUpdated?: (event: ApiKeyUpdatedEvent) => void;
-    onApiKeyRevoked?: (event: ApiKeyRevokedEvent) => void;
-    onTokenConfigUpdated?: (event: TokenConfigUpdatedEvent) => void;
-    onStatsUpdated?: (event: StatsUpdatedEvent) => void;
-    onEngagementStatsUpdated?: (event: EngagementStatsUpdatedEvent) => void;
+export interface EventsFirehoseFilters {
+    /** Only events of these `eventType`s (compared case-insensitively). */
+    eventTypes?: string[];
+    /** Only events about this token. */
+    tokenName?: string;
+    /** Only events caused by this user address (compared case-insensitively). */
+    userAddress?: string;
 }
 /**
  * Stream WebSocket Service
  *
- * Manages real-time connections for streaming and chat functionality.
- * Uses a SEPARATE WebSocket endpoint from the bundle backend.
- *
- * Key features:
- * - Event buffering to prevent race conditions
- * - Room-based subscriptions per token
- * - Automatic reconnection with re-subscription
- * - Memory-safe listener cleanup
- *
  * @example
  * ```typescript
- * import { getEnvironmentConfig } from '../config/environments';
- *
- * const wsService = new StreamWebSocketService({
- *   url: getEnvironmentConfig('stage').webSocketUrl,
- *   authToken: 'jwt-token-here'
- * });
+ * const ws = new StreamWebSocketService({ url: getEnvironmentConfig('stage').launchpadBaseUrl });
  *
- * await wsService.connect();
+ * // Two components watch the same token: both are served, the room is joined once.
+ * const offStatus = ws.subscribeStreamStatus('mytoken', (event) => console.log(event.status));
+ * const offTrades = ws.subscribeTradeExecuted('mytoken', (event) => console.log(event.tradeType));
  *
- * // Subscribe to a stream
- * await wsService.subscribeToStream('mytoken', {
- *   onStreamStatus: (event) => console.log('Status:', event.status),
- *   onViewerCount: (event) => console.log('Viewers:', event.count),
- *   onChatMessage: (event) => console.log('Chat:', event.message.content)
- * });
+ * // Leaving the last subscriber leaves the room.
+ * offStatus();
+ * offTrades();
  *
- * // Send a chat message
- * wsService.sendChatMessage('mytoken', 'Hello everyone!');
- *
- * // Cleanup
- * wsService.unsubscribeFromStream('mytoken');
- * wsService.disconnect();
+ * ws.disconnect();
  * ```
  */
 export declare class StreamWebSocketService extends LoggerBase {
     private socket;
-    private config;
-    private isSocketIOAvailable;
-    private reconnectionManager;
-    private isAuthenticated;
-    private streamingEventService;
-    private subscribedRooms;
-    private roomCallbacks;
-    private pendingSubscriptions;
-    private eventBuffer;
-    private eventBufferTimeouts;
-    private readonly MAX_BUFFER_SIZE;
-    private readonly BUFFER_CLEANUP_MS;
-    private globalCallbacks;
-    private isGlobalFeedSubscribed;
-    private globalFeedCallbacks;
-    private pendingGlobalFeedSubscription;
+    private readonly config;
+    private readonly isSocketIOAvailable;
+    private disposed;
+    /** Bumped by every `disconnect()`: an async call that started before it must not register after it. */
+    private epoch;
+    private connectionGeneration;
+    private hasConnected;
+    private connectAttempt;
+    /** socket.io gave up reconnecting (`reconnect_failed`); it does not try again by itself. */
+    private reconnectExhausted;
+    private managerCleanups;
+    private readonly connectionStateListeners;
+    private readonly reconnectListeners;
+    private readonly subscribers;
+    private readonly roomRefs;
+    private readonly roomStates;
+    private readonly roomWaiters;
+    private readonly explicitHolds;
+    private readonly recentOccurrences;
+    private siteConfig;
+    private authenticated;
+    private authenticatedToken;
+    private authenticatedGeneration;
+    private wantsAuthentication;
+    private lastExplicitToken;
+    private authSequence;
+    private inFlight;
+    private lastEmitted;
+    private pendingAuthenticate;
     constructor(config: StreamWebSocketConfig, debug?: boolean);
     /**
-     * Check if Socket.IO is available
+     * Register a subscriber. Every public subscribe method ends here.
      */
-    private checkSocketIOAvailability;
+    private register;
+    private release;
+    /** A room reference with no event subscriber behind it (an explicit `subscribeToStream`). */
+    private hold;
+    private openIfNeeded;
+    private acquireRoom;
+    private releaseRoom;
     /**
-     * Get room name for token
+     * Bring one room to what the registry wants: joined when it has a subscriber, left when it has none.
+     * Idempotent; called on every change and on every (re)connect.
      */
-    private getRoomName;
+    private syncRoom;
+    private syncAllRooms;
+    private joinRoom;
+    private onRoomAcknowledged;
+    private rejectWaiters;
+    private clearRoomStates;
     /**
-     * Buffer an event for potential late listeners
+     * One incoming occurrence: what it changes in the service, then every subscriber it is for.
      */
-    private bufferEvent;
+    private onServerEvent;
+    private isDuplicate;
+    private deliver;
+    private passes;
+    private invoke;
+    /** What an incoming event changes in the service itself. */
+    private applyEffects;
     /**
-     * Process buffered events for a newly subscribed token
+     * The socket, if it is connected right now.
      */
-    private processBufferedEvents;
+    private liveSocket;
     /**
-     * Setup global event listeners
+     * Connect to the stream WebSocket server.
+     *
+     * Idempotent and safe to call concurrently: there is one socket however many callers wait for it. Calling
+     * it while connected resolves at once; while socket.io is retrying it waits for the next connection.
+     *
+     * @returns Promise that resolves when connected, rejects when the next connection attempt fails
+     * @throws ConfigurationError if Socket.IO is not available (the promise rejects)
      */
-    private setupGlobalListeners;
+    connect(): Promise<void>;
+    private createSocket;
     /**
-     * Re-subscribe to all active rooms after reconnection
+     * Every socket listener the service has, registered here and nowhere else, once per socket.
      */
-    private resubscribeAll;
+    private attachListeners;
+    private onSocketConnect;
     /**
-     * Attach the StreamingEventService instance this connection forwards raw
-     * USER_BANNED/USER_UNBANNED/BAN_ENFORCEMENT socket events into, so LaunchpadSDK's
-     * onUserBanned()/onUserUnbanned()/onBanEnforcement() subscribers actually receive events.
-     *
-     * @internal
+     * Re-authenticate with the token current now, then re-join the rooms, then tell the reconnect listeners.
+     * Aborts if the connection changed again while it waited.
      */
-    setStreamingEventService(service: StreamingEventService): void;
+    private restoreAfterReconnect;
+    private onSocketDisconnect;
+    private settleConnectWaiters;
+    private notifyConnectionState;
+    private notifyReconnect;
     /**
-     * Connect to the stream WebSocket server
+     * Listen for the connection coming up (`true`) and going down (`false`).
      *
-     * @returns Promise that resolves when connected
-     * @throws ConfigurationError if Socket.IO is not available
+     * @returns Function to stop listening
+     * @since 9.0.0
      */
-    connect(): Promise<void>;
+    onConnectionStateChange(listener: (connected: boolean) => void): Unsubscribe;
     /**
-     * Authenticate with the stream server for chat operations
+     * Listen for the socket coming back after a drop. Fires after the service has re-authenticated and
+     * re-joined its rooms, never for the first connection. Use it to refetch what was missed.
      *
-     * @param token JWT token for authentication
+     * @returns Function to stop listening
+     * @since 9.0.0
      */
-    authenticate(token: string): void;
+    onReconnect(listener: () => void): Unsubscribe;
+    private resolveToken;
     /**
-     * Subscribe to a token's stream events
+     * Authenticate the connection (opening it first if needed).
      *
-     * @param tokenName Token name to subscribe to
-     * @param callbacks Event callbacks for this subscription
-     * @returns Promise that resolves when subscription is confirmed
-     * @throws ValidationError if WebSocket is not connected
-     * @throws Error if subscription times out
+     * Resolves `true` when the server answers `authenticated`; `false` when it answers `exception` or
+     * `stream_chat_auth_error`, when the answer does not come within `subscriptionTimeout`, when the
+     * connection drops meanwhile, when there is no token, or when a newer `authenticate` / `deauthenticate`
+     * replaced this call.
+     *
+     * - The same token on the same connection resolves `true` without sending anything.
+     * - The same token while that token is being authenticated shares the pending call.
+     * - A different token replaces the pending one (that call resolves `false`); the new token is sent after
+     *   the server has answered the one in flight, so the server's final identity is the newest token.
+     * - Without a token argument the service asks its `tokenProvider` (so a refreshed token is used).
+     *
+     * @param token JWT to authenticate with (default: the token provider's current token)
+     * @since 5.1.0
      */
-    subscribeToStream(tokenName: string, callbacks?: StreamEventCallbacks): Promise<StreamSubscribedEvent>;
+    authenticate(token?: string): Promise<boolean>;
+    private runAuthenticate;
+    private beginAuthentication;
+    private finishAuthentication;
+    private markAuthenticated;
     /**
-     * Unsubscribe from a token's stream events
+     * The server answered `authenticated` after the service had stopped waiting (the 10 seconds ran out, or
+     * an unrelated `exception` was read as the failure): when that answer is to the newest authenticate sent
+     * on this connection, the socket IS authenticated, whatever the caller was told.
+     */
+    private adoptLateAuthentication;
+    /**
+     * Forget the authenticated identity.
      *
-     * @param tokenName Token name to unsubscribe from
+     * Cancels a pending `authenticate`, stops re-authenticating on reconnect, and: the server has no message
+     * that drops a socket's identity (its user room, and the overseer room, stay joined until the connection
+     * closes), so when the socket was authenticated it is closed and opened again. The registry survives; the
+     * new connection joins the public rooms again and `onReconnect` listeners fire.
+     *
+     * @since 9.0.0
      */
-    unsubscribeFromStream(tokenName: string): void;
+    deauthenticate(): void;
+    /**
+     * Check if authenticated for chat operations
+     */
+    isAuthenticatedForChat(): boolean;
+    /**
+     * Check if connected to the WebSocket server
+     */
+    isConnected(): boolean;
+    private requireReady;
     /**
      * Send a chat message via WebSocket (faster than REST)
      *
@@ -300,13 +269,7 @@ export declare class StreamWebSocketService extends LoggerBase {
      */
     sendReaction(tokenName: string, emoji: string, streamTime?: number): void;
     /**
-     * Send typing indicator start event
-     *
-     * Indicates user has started typing in chat. Server broadcasts typing
-     * status to all viewers in the room except the sender.
-     *
-     * Auto-expires after 5 seconds if no typing activity.
-     * Use sendTypingStop() to explicitly stop the indicator.
+     * Send typing indicator start event (the server auto-expires it after 5 seconds)
      *
      * @param tokenName Token name for the chat room
      * @throws ValidationError if not authenticated or not connected
@@ -316,9 +279,6 @@ export declare class StreamWebSocketService extends LoggerBase {
     /**
      * Send typing indicator stop event
      *
-     * Indicates user has stopped typing (e.g., message sent, input cleared, blur).
-     * Call this when user sends message, clears input, or loses focus.
-     *
      * @param tokenName Token name for the chat room
      * @throws ValidationError if not authenticated or not connected
      * @since 5.11.0
@@ -326,274 +286,286 @@ export declare class StreamWebSocketService extends LoggerBase {
     sendTypingStop(tokenName: string): void;
     private sendTypingEvent;
     /**
-     * Subscribe to token banned events for a specific token
+     * Subscribe to a token room event. The token's room is joined for as long as any subscriber of the
+     * token (any event) is registered.
      *
-     * @param tokenName Token name to listen for
-     * @param callback Callback function
-     * @returns Function to unsubscribe
-     * @since 6.0.0
+     * @param event A token room event
+     * @param tokenName Token name
+     * @param listener Called for every occurrence about that token
+     * @returns This subscriber's own unsubscribe
+     * @since 9.0.0
      */
-    subscribeTokenBanned(tokenName: string, callback: (event: TokenBannedEvent) => void): () => void;
+    subscribeToken<E extends TokenRoomEventName>(event: E, tokenName: string, listener: RealtimeListener<E>): Unsubscribe;
     /**
-     * Subscribe to token unbanned events for a specific token
+     * Hold a token's room without listening to any event of it: the room is joined for as long as this (or
+     * any other subscriber of the token) is registered. For a caller that wants the room to stay joined while
+     * its listeners come and go.
      *
-     * @param tokenName Token name to listen for
-     * @param callback Callback function
-     * @returns Function to unsubscribe
-     * @since 6.0.0
+     * @returns This hold's own release
+     * @since 9.0.0
      */
-    subscribeTokenUnbanned(tokenName: string, callback: (event: TokenUnbannedEvent) => void): () => void;
+    joinTokenRoom(tokenName: string): Unsubscribe;
     /**
-     * Subscribe to moderator invite created events for a specific token
+     * Subscribe to a comment room event. The token's comment room (not its token room) is joined for as
+     * long as any comment subscriber of the token is registered.
      *
-     * @param tokenName Token name to listen for
-     * @param callback Callback function
-     * @returns Function to unsubscribe
-     * @since 8.5.0
+     * @since 9.0.0
      */
-    subscribeModeratorInviteCreated(tokenName: string, callback: (event: ModeratorInviteCreatedEvent) => void): () => void;
+    subscribeComment<E extends CommentRoomEventName>(event: E, tokenName: string, listener: RealtimeListener<E>): Unsubscribe;
     /**
-     * Subscribe to moderator added events for a specific token
+     * Subscribe to a global feed event, for every token. The feed room is joined for as long as any feed
+     * subscriber is registered. Feed subscribers are served whether or not the token's own room is joined.
      *
-     * @param tokenName Token name to listen for
-     * @param callback Callback function
-     * @returns Function to unsubscribe
-     * @since 6.0.0
+     * @since 9.0.0
      */
-    subscribeModeratorAdded(tokenName: string, callback: (event: ModeratorAddedEvent) => void): () => void;
+    subscribeFeed<E extends FeedEventName>(event: E, listener: RealtimeListener<E>): Unsubscribe;
     /**
-     * Subscribe to moderator removed events for a specific token
+     * Subscribe to every occurrence of an event the socket receives, for any token, joining no room. For the
+     * events the server sends to the connection's own rooms (the user room and the overseer room, joined by
+     * authenticating) and the broadcasts.
      *
-     * @param tokenName Token name to listen for
-     * @param callback Callback function
-     * @returns Function to unsubscribe
-     * @since 6.0.0
+     * @since 9.0.0
      */
-    subscribeModeratorRemoved(tokenName: string, callback: (event: ModeratorRemovedEvent) => void): () => void;
+    subscribeEvent<E extends RealtimeEventName>(event: E, listener: RealtimeListener<E>): Unsubscribe;
     /**
-     * Subscribe to moderator role updated events for a specific token
+     * Subscribe to the overseers' events firehose. ONE server subscription serves every subscriber; each
+     * subscriber's `filters` are applied here (the server filters nothing). The server admits overseers
+     * only, so the room is joined once the socket is authenticated (and re-joined, after
+     * re-authenticating, on every reconnect).
      *
-     * @param tokenName Token name to listen for
-     * @param callback Callback function
-     * @returns Function to unsubscribe
-     * @since 6.0.0
+     * @param listener Called for each event that passes `filters`
+     * @param filters Optional client-side filters
+     * @since 9.0.0
      */
-    subscribeModeratorRoleUpdated(tokenName: string, callback: (event: ModeratorRoleUpdatedEvent) => void): () => void;
+    subscribeEventsFirehose(listener: RealtimeListener<'EVENT'>, filters?: EventsFirehoseFilters): Unsubscribe;
     /**
-     * Subscribe to overseer added events (global)
+     * Subscribe to every global feed token event through one callback. Each occurrence is handed over with
+     * the event's name, so a caller tells them apart by `event`.
      *
-     * @param callback Callback function
-     * @returns Function to unsubscribe
-     * @since 6.0.0
+     * @since 9.0.0
      */
-    subscribeOverseerAdded(callback: (event: OverseerAddedEvent) => void): () => void;
+    subscribeFeedTokenEvents(listener: (event: FeedTokenEvent) => void | Promise<void>): Unsubscribe;
     /**
-     * Subscribe to overseer removed events (global)
+     * Subscribe to the global feed with a callback object: each `onX` becomes its own subscriber.
      *
-     * @param callback Callback function
-     * @returns Function to unsubscribe
-     * @since 6.0.0
-     */
-    subscribeOverseerRemoved(callback: (event: OverseerRemovedEvent) => void): () => void;
-    /**
-     * Subscribe to trade executed events for a specific token
-     *
-     * @param tokenName Token name to listen for
-     * @param callback Callback function
-     * @returns Function to unsubscribe
-     * @since 6.0.0
-     */
-    subscribeTradeExecuted(tokenName: string, callback: (event: TradeExecutedEvent) => void): () => void;
-    /**
-     * Subscribe to pool metadata updated events for a specific token
-     *
-     * @param tokenName Token name to listen for
-     * @param callback Callback function
-     * @returns Function to unsubscribe
-     * @since 6.0.0
-     */
-    subscribePoolMetadataUpdated(tokenName: string, callback: (event: PoolMetadataUpdatedEvent) => void): () => void;
-    /**
-     * Subscribe to pool social links updated events for a specific token
-     *
-     * @param tokenName Token name to listen for
-     * @param callback Callback function
-     * @returns Function to unsubscribe
-     * @since 6.0.0
-     */
-    subscribePoolSocialLinksUpdated(tokenName: string, callback: (event: PoolSocialLinksUpdatedEvent) => void): () => void;
-    /**
-     * Subscribe to pool badge assigned events for a specific token
-     *
-     * @param tokenName Token name to listen for
-     * @param callback Callback function
-     * @returns Function to unsubscribe
-     * @since 6.0.0
-     */
-    subscribePoolBadgeAssigned(tokenName: string, callback: (event: PoolBadgeAssignedEvent) => void): () => void;
-    /**
-     * Subscribe to holder count updated events for a specific token
-     *
-     * @param tokenName Token name to listen for
-     * @param callback Callback function
-     * @returns Function to unsubscribe
-     * @since 6.0.0
-     */
-    subscribeHolderCountUpdated(tokenName: string, callback: (event: HolderCountUpdatedEvent) => void): () => void;
-    /**
-     * Subscribe to comment created events for a specific token
-     *
-     * @param tokenName Token name to listen for
-     * @param callback Callback function
-     * @returns Function to unsubscribe
-     * @since 6.0.0
-     */
-    subscribeCommentCreated(tokenName: string, callback: (event: CommentCreatedEvent) => void): () => void;
-    /**
-     * Subscribe to user profile updated events (global)
-     *
-     * @param callback Callback function
-     * @returns Function to unsubscribe
-     * @since 6.0.0
+     * @returns Function that removes every callback this call registered (and leaves the feed room if
+     * nothing else needs it)
+     * @since 7.0.0
      */
-    subscribeUserProfileUpdated(callback: (event: UserProfileUpdatedEvent) => void): () => void;
+    subscribeToGlobalFeed(callbacks?: GlobalFeedEventCallbacks): Unsubscribe;
     /**
-     * Subscribe to API key created events (global)
+     * Add a callback object's callbacks as subscribers of their events on every token, joining no room.
+     * Each callback is its own subscriber; none replaces another.
      *
-     * @param callback Callback function
-     * @returns Function to unsubscribe
-     * @since 6.0.0
+     * @returns Function that removes the callbacks this call added
+     * @since 9.0.0
      */
-    subscribeApiKeyCreated(callback: (event: ApiKeyCreatedEvent) => void): () => void;
+    addCallbacks(callbacks: StreamEventCallbacks): Unsubscribe;
+    private registerCallbacks;
     /**
-     * Subscribe to API key updated events (global)
+     * Subscribe to a token's events with a callback object, and wait for the server to confirm the room.
      *
-     * @param callback Callback function
-     * @returns Function to unsubscribe
-     * @since 6.0.0
-     */
-    subscribeApiKeyUpdated(callback: (event: ApiKeyUpdatedEvent) => void): () => void;
-    /**
-     * Subscribe to API key revoked events (global)
+     * Each callback in `callbacks` is a subscriber of that token; the room is joined while at least one
+     * `subscribeToStream` call for it, or any other subscriber, is registered. Calling it again for a token
+     * ADDS callbacks: it never replaces the ones already registered.
+     * {@link StreamWebSocketService.unsubscribeFromStream} removes what `subscribeToStream` registered.
      *
-     * @param callback Callback function
-     * @returns Function to unsubscribe
-     * @since 6.0.0
-     */
-    subscribeApiKeyRevoked(callback: (event: ApiKeyRevokedEvent) => void): () => void;
-    /**
-     * Subscribe to platform stats updated events (global).
-     * Emitted after every trade with enriched token price, market cap, and supply data.
-     *
-     * @param callback Callback function receiving StatsUpdatedEvent
-     * @returns Function to unsubscribe
-     * @since 8.3.0
-     */
-    subscribeStatsUpdated(callback: (event: StatsUpdatedEvent) => void): () => void;
-    /**
-     * Subscribe to engagement stats updated events (global).
-     * Emitted by the chat flush job every ~15 seconds when chat activity occurs.
-     * Contains updated chat/comment counts for the token.
-     *
-     * @param callback Callback function receiving EngagementStatsUpdatedEvent
-     * @returns Function to unsubscribe
-     * @since 8.5.0
+     * @param tokenName Token name to subscribe to
+     * @param callbacks Event callbacks for this token
+     * @returns Promise that resolves when the server confirms the room
+     * @throws ValidationError if the token name is empty
+     * @throws Error if the connection fails or the confirmation times out (what this call registered is then released)
      */
-    subscribeEngagementStatsUpdated(callback: (event: EngagementStatsUpdatedEvent) => void): () => void;
+    subscribeToStream(tokenName: string, callbacks?: StreamEventCallbacks): Promise<StreamSubscribedEvent>;
+    private waitForRoom;
+    private dropExplicitHold;
     /**
-     * Set global event callbacks (not per-room)
+     * Remove everything `subscribeToStream` registered for a token. Other subscribers of the token (from the
+     * `subscribe*` methods) are untouched, and the room is left only when none remains.
      *
-     * @param callbacks Global event callbacks
+     * @param tokenName Token name to unsubscribe from
      */
-    setGlobalCallbacks(callbacks: StreamEventCallbacks): void;
-    /**
-     * Get list of currently subscribed tokens
+    unsubscribeFromStream(tokenName: string): void;
+    /** Stream status changes (`STREAM_STATUS`) of a token. @since 9.0.0 */
+    subscribeStreamStatus(tokenName: string, listener: RealtimeListener<'STREAM_STATUS'>): Unsubscribe;
+    /** Viewer count changes (`VIEWER_COUNT`) of a token. @since 9.0.0 */
+    subscribeViewerCount(tokenName: string, listener: RealtimeListener<'VIEWER_COUNT'>): Unsubscribe;
+    /** Recording changes (`RECORDING_STATUS`) of a token. @since 9.0.0 */
+    subscribeRecordingStatus(tokenName: string, listener: RealtimeListener<'RECORDING_STATUS'>): Unsubscribe;
+    /** Recording count changes (`RECORDINGS_COUNT_UPDATED`) of a token. @since 9.0.0 */
+    subscribeRecordingsCountUpdated(tokenName: string, listener: RealtimeListener<'RECORDINGS_COUNT_UPDATED'>): Unsubscribe;
+    /** Simulcast target changes (`SIMULCAST_STATUS`) of a token. @since 9.0.0 */
+    subscribeSimulcastStatus(tokenName: string, listener: RealtimeListener<'SIMULCAST_STATUS'>): Unsubscribe;
+    /** A recording's download is ready (`DOWNLOAD_READY`, sent to the stream owner). @since 9.0.0 */
+    subscribeDownloadReady(tokenName: string, listener: RealtimeListener<'DOWNLOAD_READY'>): Unsubscribe;
+    /**
+     * The next live stream's countdown changed (`STREAM_COUNTDOWN_UPDATED`). Fed from `TOKEN_CONFIG_UPDATED`
+     * (the backend folds the countdown into the config delta). @since 9.0.0
+     */
+    subscribeCountdownUpdated(tokenName: string, listener: RealtimeListener<'STREAM_COUNTDOWN_UPDATED'>): Unsubscribe;
+    /**
+     * The stream language changed (`STREAM_LANGUAGE_UPDATED`). Fed from `TOKEN_CONFIG_UPDATED`.
+     * @since 9.0.0
+     */
+    subscribeLanguageUpdated(tokenName: string, listener: RealtimeListener<'STREAM_LANGUAGE_UPDATED'>): Unsubscribe;
+    /** Stream control changes (`STREAM_CONTROL_STATUS_CHANGED`) of a token. @since 9.0.0 */
+    subscribeStreamControlStatusChanged(tokenName: string, listener: RealtimeListener<'STREAM_CONTROL_STATUS_CHANGED'>): Unsubscribe;
+    /** Chat and comment counts (`ENGAGEMENT_STATS_UPDATED`) of a token, about every 15 seconds. @since 8.5.0 */
+    subscribeEngagementStatsUpdated(tokenName: string, listener: RealtimeListener<'ENGAGEMENT_STATS_UPDATED'>): Unsubscribe;
+    /** New chat messages (`STREAM_CHAT_MESSAGE`) of a token. @since 9.0.0 */
+    subscribeChatMessages(tokenName: string, listener: RealtimeListener<'STREAM_CHAT_MESSAGE'>): Unsubscribe;
+    /** Confirmation that this socket's chat message was stored (`STREAM_CHAT_SENT`). @since 9.0.0 */
+    subscribeChatSent(tokenName: string, listener: RealtimeListener<'STREAM_CHAT_SENT'>): Unsubscribe;
+    /** Edited chat messages (`STREAM_CHAT_UPDATED`) of a token. @since 9.0.0 */
+    subscribeChatUpdated(tokenName: string, listener: RealtimeListener<'STREAM_CHAT_UPDATED'>): Unsubscribe;
+    /** Deleted chat messages (`STREAM_CHAT_DELETED`) of a token. @since 9.0.0 */
+    subscribeChatDeleted(tokenName: string, listener: RealtimeListener<'STREAM_CHAT_DELETED'>): Unsubscribe;
+    /** Pinned chat messages (`STREAM_CHAT_PINNED`) of a token. @since 9.0.0 */
+    subscribeChatPinned(tokenName: string, listener: RealtimeListener<'STREAM_CHAT_PINNED'>): Unsubscribe;
+    /** Unpinned chat messages (`STREAM_CHAT_UNPINNED`) of a token. @since 9.0.0 */
+    subscribeChatUnpinned(tokenName: string, listener: RealtimeListener<'STREAM_CHAT_UNPINNED'>): Unsubscribe;
+    /** A token's chat was enabled or disabled (`CHAT_STATUS_CHANGED`). @since 9.0.0 */
+    subscribeChatStatus(tokenName: string, listener: RealtimeListener<'CHAT_STATUS_CHANGED'>): Unsubscribe;
+    /** A token's chat slow mode changed (`SLOW_MODE_CHANGED`). @since 9.0.0 */
+    subscribeChatSlowMode(tokenName: string, listener: RealtimeListener<'SLOW_MODE_CHANGED'>): Unsubscribe;
+    /** Who is typing in a token's chat (`USER_TYPING`). @since 9.0.0 */
+    subscribeTypingIndicator(tokenName: string, listener: RealtimeListener<'USER_TYPING'>): Unsubscribe;
+    /** Ephemeral emoji reactions (`STREAM_REACTION`) of a token. @since 9.0.0 */
+    subscribeReactions(tokenName: string, listener: RealtimeListener<'STREAM_REACTION'>): Unsubscribe;
+    /** A reaction was added to a message (`CONTENT_REACTION_ADDED`) of a token. @since 9.0.0 */
+    subscribeContentReactionAdded(tokenName: string, listener: RealtimeListener<'CONTENT_REACTION_ADDED'>): Unsubscribe;
+    /** A reaction was removed from a message (`CONTENT_REACTION_REMOVED`) of a token. @since 9.0.0 */
+    subscribeContentReactionRemoved(tokenName: string, listener: RealtimeListener<'CONTENT_REACTION_REMOVED'>): Unsubscribe;
+    /** Trades (`TRADE_EXECUTED`) of a token. @since 6.0.0 */
+    subscribeTradeExecuted(tokenName: string, listener: RealtimeListener<'TRADE_EXECUTED'>): Unsubscribe;
+    /** The authenticated user's balance change after a trade (`BALANCE_UPDATED`) of a token. @since 9.0.0 */
+    subscribeBalanceUpdated(tokenName: string, listener: RealtimeListener<'BALANCE_UPDATED'>): Unsubscribe;
+    /** A token was banned (`TOKEN_BANNED`). @since 6.0.0 */
+    subscribeTokenBanned(tokenName: string, listener: RealtimeListener<'TOKEN_BANNED'>): Unsubscribe;
+    /** A token ban was lifted (`TOKEN_UNBANNED`). @since 6.0.0 */
+    subscribeTokenUnbanned(tokenName: string, listener: RealtimeListener<'TOKEN_UNBANNED'>): Unsubscribe;
+    /** A moderator invite was created (`MODERATOR_INVITE_CREATED`) for a token. @since 8.5.0 */
+    subscribeModeratorInviteCreated(tokenName: string, listener: RealtimeListener<'MODERATOR_INVITE_CREATED'>): Unsubscribe;
+    /** A moderator was added (`MODERATOR_ADDED`) to a token. @since 6.0.0 */
+    subscribeModeratorAdded(tokenName: string, listener: RealtimeListener<'MODERATOR_ADDED'>): Unsubscribe;
+    /** A moderator was removed (`MODERATOR_REMOVED`) from a token. @since 6.0.0 */
+    subscribeModeratorRemoved(tokenName: string, listener: RealtimeListener<'MODERATOR_REMOVED'>): Unsubscribe;
+    /** A moderator's role changed (`MODERATOR_ROLE_UPDATED`) on a token. @since 6.0.0 */
+    subscribeModeratorRoleUpdated(tokenName: string, listener: RealtimeListener<'MODERATOR_ROLE_UPDATED'>): Unsubscribe;
+    /** A token's metadata changed (`POOL_METADATA_UPDATED`). @since 6.0.0 */
+    subscribePoolMetadataUpdated(tokenName: string, listener: RealtimeListener<'POOL_METADATA_UPDATED'>): Unsubscribe;
+    /** A token's social links changed (`POOL_SOCIAL_LINKS_UPDATED`). @since 6.0.0 */
+    subscribePoolSocialLinksUpdated(tokenName: string, listener: RealtimeListener<'POOL_SOCIAL_LINKS_UPDATED'>): Unsubscribe;
+    /** A badge was assigned to a token (`POOL_BADGE_ASSIGNED`). @since 6.0.0 */
+    subscribePoolBadgeAssigned(tokenName: string, listener: RealtimeListener<'POOL_BADGE_ASSIGNED'>): Unsubscribe;
+    /** A token's holder count changed (`HOLDER_COUNT_UPDATED`). @since 6.0.0 */
+    subscribeHolderCountUpdated(tokenName: string, listener: RealtimeListener<'HOLDER_COUNT_UPDATED'>): Unsubscribe;
+    /** A token's configuration changed (`TOKEN_CONFIG_UPDATED`, a delta of the changed fields). @since 8.4.0 */
+    subscribeTokenConfigUpdated(tokenName: string, listener: RealtimeListener<'TOKEN_CONFIG_UPDATED'>): Unsubscribe;
+    /** New comments (`COMMENT_CREATED`) on a token. Joins the token's comment room. @since 6.0.0 */
+    subscribeCommentCreated(tokenName: string, listener: RealtimeListener<'COMMENT_CREATED'>): Unsubscribe;
+    /** Edited comments (`COMMENT_UPDATED`) on a token. Joins the token's comment room. @since 9.0.0 */
+    subscribeCommentUpdated(tokenName: string, listener: RealtimeListener<'COMMENT_UPDATED'>): Unsubscribe;
+    /** Deleted comments (`COMMENT_DELETED`) on a token. Joins the token's comment room. @since 9.0.0 */
+    subscribeCommentDeleted(tokenName: string, listener: RealtimeListener<'COMMENT_DELETED'>): Unsubscribe;
+    /** Price, market cap and supply after a trade (`STATS_UPDATED`), every token. Joins the global feed. @since 8.3.0 */
+    subscribeStatsUpdated(listener: RealtimeListener<'STATS_UPDATED'>): Unsubscribe;
+    /** A token pool was created (`POOL_CREATED`). Joins the global feed. @since 9.0.0 */
+    subscribePoolCreated(listener: RealtimeListener<'POOL_CREATED'>): Unsubscribe;
+    /** Streaming was switched on or off site-wide (`STREAM_GLOBAL_STATUS`). Joins the global feed. @since 9.0.0 */
+    subscribeStreamGlobalStatus(listener: RealtimeListener<'STREAM_GLOBAL_STATUS'>): Unsubscribe;
+    /** Chat was switched on or off site-wide (`STREAM_CHAT_GLOBAL_STATUS`). Joins the global feed. @since 9.0.0 */
+    subscribeChatGlobalStatus(listener: RealtimeListener<'STREAM_CHAT_GLOBAL_STATUS'>): Unsubscribe;
+    /** Comments were switched on or off site-wide (`COMMENTS_GLOBAL_STATUS`). Joins the global feed. @since 9.0.0 */
+    subscribeCommentsGlobalStatus(listener: RealtimeListener<'COMMENTS_GLOBAL_STATUS'>): Unsubscribe;
+    /** Webhooks were switched on or off site-wide (`WEBHOOKS_GLOBAL_STATUS`). Joins the global feed. @since 9.0.0 */
+    subscribeWebhooksGlobalStatus(listener: RealtimeListener<'WEBHOOKS_GLOBAL_STATUS'>): Unsubscribe;
+    /** AI moderation was switched on or off site-wide (`AI_MODERATION_GLOBAL_STATUS`). Joins the global feed. @since 9.0.0 */
+    subscribeAIModerationGlobalStatus(listener: RealtimeListener<'AI_MODERATION_GLOBAL_STATUS'>): Unsubscribe;
+    /** A site-wide switch changed (`SITE_CONFIG_CHANGED`). Joins the global feed. @since 9.0.0 */
+    subscribeSiteConfigChanged(listener: RealtimeListener<'SITE_CONFIG_CHANGED'>): Unsubscribe;
+    /**
+     * The site-wide switches announced since the feed was joined (`undefined`: none announced yet).
+     *
+     * @since 9.0.0
+     */
+    getSiteConfigState(): SiteConfigState;
+    /** An overseer was added (`OVERSEER_ADDED`). @since 6.0.0 */
+    subscribeOverseerAdded(listener: RealtimeListener<'OVERSEER_ADDED'>): Unsubscribe;
+    /** An overseer was removed (`OVERSEER_REMOVED`). @since 6.0.0 */
+    subscribeOverseerRemoved(listener: RealtimeListener<'OVERSEER_REMOVED'>): Unsubscribe;
+    /** The authenticated user's profile changed (`USER_PROFILE_UPDATED`). @since 6.0.0 */
+    subscribeUserProfileUpdated(listener: RealtimeListener<'USER_PROFILE_UPDATED'>): Unsubscribe;
+    /** An API key was created (`API_KEY_CREATED`). @since 6.0.0 */
+    subscribeApiKeyCreated(listener: RealtimeListener<'API_KEY_CREATED'>): Unsubscribe;
+    /** An API key was updated (`API_KEY_UPDATED`). @since 6.0.0 */
+    subscribeApiKeyUpdated(listener: RealtimeListener<'API_KEY_UPDATED'>): Unsubscribe;
+    /** An API key was revoked (`API_KEY_REVOKED`). @since 6.0.0 */
+    subscribeApiKeyRevoked(listener: RealtimeListener<'API_KEY_REVOKED'>): Unsubscribe;
+    /** A token was banned, any token (`TOKEN_BANNED`, the overseer room). @since 9.0.0 */
+    subscribeGlobalTokenBanned(listener: RealtimeListener<'TOKEN_BANNED'>): Unsubscribe;
+    /** A token ban was lifted, any token (`TOKEN_UNBANNED`, the overseer room). @since 9.0.0 */
+    subscribeGlobalTokenUnbanned(listener: RealtimeListener<'TOKEN_UNBANNED'>): Unsubscribe;
+    /** The authenticated user was added as a moderator, any token (`MODERATOR_ADDED`, the user room). @since 9.0.0 */
+    subscribeGlobalModeratorAdded(listener: RealtimeListener<'MODERATOR_ADDED'>): Unsubscribe;
+    /** The authenticated user was removed as a moderator, any token (`MODERATOR_REMOVED`). @since 9.0.0 */
+    subscribeGlobalModeratorRemoved(listener: RealtimeListener<'MODERATOR_REMOVED'>): Unsubscribe;
+    /** The authenticated user's moderator role changed, any token (`MODERATOR_ROLE_UPDATED`). @since 9.0.0 */
+    subscribeGlobalModeratorRoleUpdated(listener: RealtimeListener<'MODERATOR_ROLE_UPDATED'>): Unsubscribe;
+    /** A moderator invite the authenticated user made, any token (`MODERATOR_INVITE_CREATED`). @since 9.0.0 */
+    subscribeGlobalModeratorInviteCreated(listener: RealtimeListener<'MODERATOR_INVITE_CREATED'>): Unsubscribe;
+    /** Content was flagged, any token (`CONTENT_FLAGGED`, the overseer room). @since 9.0.0 */
+    subscribeContentFlagged(listener: RealtimeListener<'CONTENT_FLAGGED'>): Unsubscribe;
+    /** A flag was resolved, any token (`FLAG_RESOLVED`, the overseer room). @since 9.0.0 */
+    subscribeFlagResolved(listener: RealtimeListener<'FLAG_RESOLVED'>): Unsubscribe;
+    /** An AI analysis of a flag finished (`AI_MODERATION_COMPLETE`, the overseer room). @since 9.0.0 */
+    subscribeAIModerationComplete(listener: RealtimeListener<'AI_MODERATION_COMPLETE'>): Unsubscribe;
+    /** An AI analysis of a flag failed (`AI_MODERATION_FAILED`, the overseer room). @since 9.0.0 */
+    subscribeAIModerationFailed(listener: RealtimeListener<'AI_MODERATION_FAILED'>): Unsubscribe;
+    /** The authenticated user was banned (`USER_BANNED`; overseers see every ban). @since 9.0.0 */
+    subscribeUserBanned(listener: RealtimeListener<'USER_BANNED'>): Unsubscribe;
+    /** The authenticated user was unbanned (`USER_UNBANNED`; overseers see every unban). @since 9.0.0 */
+    subscribeUserUnbanned(listener: RealtimeListener<'USER_UNBANNED'>): Unsubscribe;
+    /** A banned user's action was refused (`BAN_ENFORCEMENT`). @since 9.0.0 */
+    subscribeBanEnforcement(listener: RealtimeListener<'BAN_ENFORCEMENT'>): Unsubscribe;
+    /** The most recent trades, broadcast to every client (`TRADE_UPDATE_NOTIFY`). @since 9.0.0 */
+    subscribeTradeUpdateNotify(listener: RealtimeListener<'TRADE_UPDATE_NOTIFY'>): Unsubscribe;
+    /** A reaction was refused (`stream_reaction_error`), any token. @since 9.0.0 */
+    subscribeReactionErrors(listener: RealtimeListener<'stream_reaction_error'>): Unsubscribe;
+    /** A chat message was refused (`stream_chat_error`), any token. @since 9.0.0 */
+    subscribeChatErrors(listener: RealtimeListener<'stream_chat_error'>): Unsubscribe;
+    /**
+     * A server handler failed (`exception`): an unauthenticated call, an invalid token. Authentication
+     * failures also resolve the pending {@link StreamWebSocketService.authenticate} with `false`.
+     *
+     * @since 9.0.0
+     */
+    subscribeException(listener: RealtimeListener<'exception'>): Unsubscribe;
+    /**
+     * Get list of tokens whose room has a subscriber
      */
     getSubscribedTokens(): string[];
     /**
-     * Check if connected to the WebSocket server
-     */
-    isConnected(): boolean;
-    /**
-     * Check if authenticated for chat operations
-     */
-    isAuthenticatedForChat(): boolean;
-    /**
-     * Subscribe to the global feed for unified real-time updates
-     *
-     * Provides homepage/listing views with token summary events and site config events.
-     * Automatically reconnects on disconnect if configured.
-     *
-     * Feed token events routed through global feed:
-     * - STREAM_STATUS, TRADE_EXECUTED, HOLDER_COUNT_UPDATED, POOL_BADGE_ASSIGNED,
-     *   VIEWER_COUNT, TOKEN_CONFIG_UPDATED, STATS_UPDATED
-     *
-     * Dedup behavior: When a client is subscribed to both a token room AND the global
-     * feed, overlapping events are delivered only via the token room callbacks (the backend
-     * uses `.except()` to prevent double delivery). Global feed callbacks fire only for
-     * tokens the client has NOT individually subscribed to.
-     *
-     * @param callbacks Optional callbacks for feed events
-     * @returns Promise resolving to subscription confirmation
-     * @throws ValidationError if WebSocket not connected
-     *
-     * @example
-     * ```typescript
-     * const subscription = await service.subscribeToGlobalFeed({
-     *   onStreamStatus: (event) => updateCard(event.tokenName, event),
-     *   onTradeExecuted: (event) => addTradeNotification(event),
-     *   onStatsUpdated: (event) => updatePriceCard(event.tokenName, event),
-     *   onTokenConfigUpdated: (event) => updateConfigCard(event.tokenName, event),
-     *   onStreamGlobalStatus: (event) => setStreamingEnabled(event.enabled),
-     * });
-     *
-     * // Later: unsubscribe
-     * service.unsubscribeFromGlobalFeed();
-     * ```
-     *
-     * @since 7.0.0
-     */
-    subscribeToGlobalFeed(callbacks?: GlobalFeedEventCallbacks): Promise<GlobalFeedSubscribedEvent>;
-    /**
-     * Unsubscribe from the global feed
-     *
-     * Stops receiving feed events and cleans up subscriptions.
-     *
-     * @example
-     * ```typescript
-     * service.unsubscribeFromGlobalFeed();
-     * ```
+     * Check if the global feed has a subscriber
      *
      * @since 7.0.0
      */
-    unsubscribeFromGlobalFeed(): void;
-    /**
-     * Check if currently subscribed to global feed
-     *
-     * @returns True if subscribed to global feed
-     * @since 7.0.0
-     */
     isSubscribedToGlobalFeed(): boolean;
-    /**
-     * Update global feed event callbacks
-     *
-     * Allows updating which events you want to receive after subscription.
-     *
-     * @param callbacks Callbacks for feed events
-     * @since 7.0.0
-     */
-    setGlobalFeedCallbacks(callbacks: GlobalFeedEventCallbacks): void;
     /**
      * Get the underlying Socket.IO instance
      */
     getSocket(): Socket | null;
     /**
-     * Disconnect from the stream WebSocket server
-     *
-     * Cleans up all listeners, subscriptions, and buffers.
-     * All cleanup operations are wrapped in try-catch to ensure
-     * complete cleanup even if individual steps fail.
+     * Close the socket and release everything the service holds: every socket listener (the Socket's and
+     * the Manager's), every timer, every subscriber, every pending connect / authenticate / subscribe (they
+     * settle: connects reject, authenticates resolve `false`, subscribes reject). An unsubscribe handed out
+     * earlier stays harmless. The service can connect and subscribe again afterwards.
      */
     disconnect(): void;
+    /**
+     * {@link StreamWebSocketService.disconnect}, and the service refuses everything afterwards (a
+     * subscribe returns an inert unsubscribe, a connect rejects). Called when the owning SDK is disposed.
+     */
+    dispose(): void;
 }
 //# sourceMappingURL=StreamWebSocketService.d.ts.map