sa2kit 1.6.34 → 1.6.36

package/dist/mikuFireworks3D/index.d.ts

@@ -1,55 +1,9 @@
 import * as React from 'react';
 import React__default from 'react';
+import { M as MikuFireworks3DProps, F as FireworkKind, g as FireworksRealtimeConfig, h as FireworksRealtimeState, f as FireworksRealtimeUser, a as FireworkLaunchPayload, c as FireworkEngineOptions, D as DanmakuMessage, e as DanmakuControllerOptions, d as DanmakuSendResult } from '../types-DBVDr8Mu.js';
+export { b as FireworkPosition } from '../types-DBVDr8Mu.js';
 
-type FireworkKind = 'normal' | 'miku' | 'avatar';
-interface DanmakuMessage {
-    id: string;
-    userId?: string;
-    text: string;
-    color?: string;
-    timestamp: number;
-}
-interface FireworkPosition {
-    x: number;
-    y: number;
-    z: number;
-}
-interface FireworkLaunchPayload {
-    kind: FireworkKind;
-    position?: FireworkPosition;
-    color?: string;
-    avatarUrl?: string;
-    message?: DanmakuMessage;
-}
-interface FireworkEngineOptions {
-    maxParticles?: number;
-    maxActiveFireworks?: number;
-    onError?: (error: Error) => void;
-    onFpsReport?: (fps: number) => void;
-}
-interface MikuFireworks3DProps {
-    width?: number | string;
-    height?: number | string;
-    className?: string;
-    defaultKind?: FireworkKind;
-    autoLaunchOnDanmaku?: boolean;
-    maxParticles?: number;
-    maxActiveFireworks?: number;
-    defaultAvatarUrl?: string;
-    onLaunch?: (payload: FireworkLaunchPayload) => void;
-    onDanmakuSend?: (message: DanmakuMessage) => void;
-    onError?: (error: Error) => void;
-    onFpsReport?: (fps: number) => void;
-}
-interface DanmakuSendResult {
-    message: DanmakuMessage;
-    launchKind?: FireworkKind;
-}
-interface DanmakuControllerOptions {
-    onSend?: (message: DanmakuMessage) => void;
-}
-
-declare function MikuFireworks3D({ width, height, className, defaultKind, autoLaunchOnDanmaku, maxParticles, maxActiveFireworks, defaultAvatarUrl, onLaunch, onDanmakuSend, onError, onFpsReport, }: MikuFireworks3DProps): React__default.JSX.Element;
+declare function MikuFireworks3D({ width, height, className, defaultKind, autoLaunchOnDanmaku, maxParticles, maxActiveFireworks, defaultAvatarUrl, onLaunch, onDanmakuSend, onError, onFpsReport, onRealtimeStateChange, realtime, }: MikuFireworks3DProps): React__default.JSX.Element;
 
 interface FireworksCanvasProps {
     canvasRef: React__default.RefObject<HTMLCanvasElement>;
@@ -65,14 +19,103 @@ interface FireworksControlPanelProps {
     onAvatarUrlChange: (value: string) => void;
     onLaunch: () => void;
     fps: number;
+    realtimeConnected?: boolean;
+    onlineCount?: number;
 }
-declare function FireworksControlPanel({ selectedKind, onKindChange, autoLaunchOnDanmaku, onAutoLaunchChange, avatarUrl, onAvatarUrlChange, onLaunch, fps, }: FireworksControlPanelProps): React__default.JSX.Element;
+declare function FireworksControlPanel({ selectedKind, onKindChange, autoLaunchOnDanmaku, onAutoLaunchChange, avatarUrl, onAvatarUrlChange, onLaunch, fps, realtimeConnected, onlineCount, }: FireworksControlPanelProps): React__default.JSX.Element;
 
 interface DanmakuPanelProps {
     onSend: (text: string) => void;
 }
 declare function DanmakuPanel({ onSend }: DanmakuPanelProps): React__default.JSX.Element;
 
+interface RealtimeDanmakuEvent {
+    id: string;
+    roomId: string;
+    text: string;
+    color?: string;
+    kind?: FireworkKind;
+    user: FireworksRealtimeUser;
+    timestamp: number;
+}
+interface RealtimeFireworkEvent {
+    id: string;
+    roomId: string;
+    payload: FireworkLaunchPayload;
+    user: FireworksRealtimeUser;
+    timestamp: number;
+}
+type ServerMessage = {
+    type: 'joined';
+    roomId: string;
+    onlineCount: number;
+    self: FireworksRealtimeUser;
+} | {
+    type: 'room.snapshot';
+    roomId: string;
+    users: FireworksRealtimeUser[];
+    danmakuHistory: RealtimeDanmakuEvent[];
+    fireworkHistory: RealtimeFireworkEvent[];
+} | {
+    type: 'room.user_joined';
+    roomId: string;
+    user: FireworksRealtimeUser;
+    onlineCount: number;
+} | {
+    type: 'room.user_left';
+    roomId: string;
+    userId: string;
+    onlineCount: number;
+} | {
+    type: 'danmaku.broadcast';
+    roomId: string;
+    event: RealtimeDanmakuEvent;
+} | {
+    type: 'firework.broadcast';
+    roomId: string;
+    event: RealtimeFireworkEvent;
+} | {
+    type: 'error';
+    code: string;
+    message: string;
+} | {
+    type: 'pong';
+    ts: number;
+};
+interface WebSocketTransportCallbacks {
+    onStateChange?: (state: FireworksRealtimeState) => void;
+    onDanmakuBroadcast?: (event: RealtimeDanmakuEvent) => void;
+    onFireworkBroadcast?: (event: RealtimeFireworkEvent) => void;
+    onSnapshot?: (snapshot: Extract<ServerMessage, {
+        type: 'room.snapshot';
+    }>) => void;
+    onError?: (error: Error) => void;
+}
+declare class WebSocketTransport {
+    private socket;
+    private reconnectTimer;
+    private isManualClose;
+    private readonly pendingQueue;
+    private readonly config;
+    private readonly callbacks;
+    private state;
+    constructor(config: FireworksRealtimeConfig, callbacks?: WebSocketTransportCallbacks);
+    connect(): void;
+    disconnect(): void;
+    sendDanmaku(payload: {
+        text: string;
+        color?: string;
+        kind?: FireworkKind;
+    }): void;
+    sendFirework(payload: FireworkLaunchPayload): void;
+    getState(): FireworksRealtimeState;
+    private send;
+    private updateState;
+    private handleServerMessage;
+    private scheduleReconnect;
+    private flushPendingQueue;
+}
+
 interface UseFireworksEngineOptions extends FireworkEngineOptions {
     onLaunch?: (payload: FireworkLaunchPayload) => void;
 }
@@ -87,12 +130,63 @@ interface DanmakuOverlayItem extends DanmakuMessage {
     track: number;
     durationMs: number;
 }
+interface SendDanmakuOptions {
+    optimistic?: boolean;
+}
 declare function useDanmakuController(options?: DanmakuControllerOptions): {
     items: DanmakuOverlayItem[];
-    send: (text: string, color?: string) => DanmakuSendResult | null;
+    send: (text: string, color?: string, sendOptions?: SendDanmakuOptions) => DanmakuSendResult | null;
+    addIncoming: (message: DanmakuMessage) => void;
     removeItem: (id: string) => void;
 };
 
+interface UseFireworksRealtimeOptions {
+    config?: FireworksRealtimeConfig;
+    enabled?: boolean;
+    onDanmakuBroadcast?: (event: {
+        text: string;
+        color?: string;
+        kind?: FireworkKind;
+        userId: string;
+        timestamp: number;
+        id: string;
+    }) => void;
+    onFireworkBroadcast?: (event: {
+        id: string;
+        payload: FireworkLaunchPayload;
+        userId: string;
+        timestamp: number;
+    }) => void;
+    onSnapshot?: (snapshot: {
+        roomId: string;
+        danmakuHistory: Array<{
+            id: string;
+            text: string;
+            color?: string;
+            kind?: FireworkKind;
+            userId: string;
+            timestamp: number;
+        }>;
+        fireworkHistory: Array<{
+            id: string;
+            payload: FireworkLaunchPayload;
+            userId: string;
+            timestamp: number;
+        }>;
+    }) => void;
+    onError?: (error: Error) => void;
+    onStateChange?: (state: FireworksRealtimeState) => void;
+}
+declare function useFireworksRealtime(options: UseFireworksRealtimeOptions): {
+    state: FireworksRealtimeState;
+    sendDanmaku: (payload: {
+        text: string;
+        color?: string;
+        kind?: FireworkKind;
+    }) => void;
+    sendFirework: (payload: FireworkLaunchPayload) => void;
+};
+
 declare const DEFAULT_MAX_PARTICLES = 5000;
 declare const DEFAULT_MAX_ACTIVE_FIREWORKS = 12;
 declare const FIREWORK_KIND_LABELS: Record<FireworkKind, string>;
@@ -101,4 +195,4 @@ declare const NORMAL_PALETTE: string[];
 declare const DANMAKU_MAX_LENGTH = 32;
 declare const DANMAKU_TRACK_COUNT = 8;
 
-export { DANMAKU_MAX_LENGTH, DANMAKU_TRACK_COUNT, DEFAULT_MAX_ACTIVE_FIREWORKS, DEFAULT_MAX_PARTICLES, type DanmakuControllerOptions, type DanmakuMessage, type DanmakuOverlayItem, DanmakuPanel, type DanmakuSendResult, FIREWORK_KIND_LABELS, type FireworkEngineOptions, type FireworkKind, type FireworkLaunchPayload, type FireworkPosition, FireworksCanvas, FireworksControlPanel, MIKU_PALETTE, MikuFireworks3D, type MikuFireworks3DProps, NORMAL_PALETTE, type UseFireworksEngineOptions, useDanmakuController, useFireworksEngine };
+export { DANMAKU_MAX_LENGTH, DANMAKU_TRACK_COUNT, DEFAULT_MAX_ACTIVE_FIREWORKS, DEFAULT_MAX_PARTICLES, DanmakuControllerOptions, DanmakuMessage, type DanmakuOverlayItem, DanmakuPanel, DanmakuSendResult, FIREWORK_KIND_LABELS, FireworkEngineOptions, FireworkKind, FireworkLaunchPayload, FireworksCanvas, FireworksControlPanel, FireworksRealtimeConfig, FireworksRealtimeState, FireworksRealtimeUser, MIKU_PALETTE, MikuFireworks3D, MikuFireworks3DProps, NORMAL_PALETTE, type UseFireworksEngineOptions, WebSocketTransport, type WebSocketTransportCallbacks, useDanmakuController, useFireworksEngine, useFireworksRealtime };

package/dist/mikuFireworks3D/index.js

@@ -1,61 +1,69 @@
 'use strict';
 
-var chunkB34YUZRL_js = require('../chunk-B34YUZRL.js');
+var chunkXXDMARU7_js = require('../chunk-XXDMARU7.js');
 require('../chunk-DGUM43GV.js');
 
 
 
 Object.defineProperty(exports, "DANMAKU_MAX_LENGTH", {
   enumerable: true,
-  get: function () { return chunkB34YUZRL_js.DANMAKU_MAX_LENGTH; }
+  get: function () { return chunkXXDMARU7_js.DANMAKU_MAX_LENGTH; }
 });
 Object.defineProperty(exports, "DANMAKU_TRACK_COUNT", {
   enumerable: true,
-  get: function () { return chunkB34YUZRL_js.DANMAKU_TRACK_COUNT; }
+  get: function () { return chunkXXDMARU7_js.DANMAKU_TRACK_COUNT; }
 });
 Object.defineProperty(exports, "DEFAULT_MAX_ACTIVE_FIREWORKS", {
   enumerable: true,
-  get: function () { return chunkB34YUZRL_js.DEFAULT_MAX_ACTIVE_FIREWORKS; }
+  get: function () { return chunkXXDMARU7_js.DEFAULT_MAX_ACTIVE_FIREWORKS; }
 });
 Object.defineProperty(exports, "DEFAULT_MAX_PARTICLES", {
   enumerable: true,
-  get: function () { return chunkB34YUZRL_js.DEFAULT_MAX_PARTICLES; }
+  get: function () { return chunkXXDMARU7_js.DEFAULT_MAX_PARTICLES; }
 });
 Object.defineProperty(exports, "DanmakuPanel", {
   enumerable: true,
-  get: function () { return chunkB34YUZRL_js.DanmakuPanel; }
+  get: function () { return chunkXXDMARU7_js.DanmakuPanel; }
 });
 Object.defineProperty(exports, "FIREWORK_KIND_LABELS", {
   enumerable: true,
-  get: function () { return chunkB34YUZRL_js.FIREWORK_KIND_LABELS; }
+  get: function () { return chunkXXDMARU7_js.FIREWORK_KIND_LABELS; }
 });
 Object.defineProperty(exports, "FireworksCanvas", {
   enumerable: true,
-  get: function () { return chunkB34YUZRL_js.FireworksCanvas; }
+  get: function () { return chunkXXDMARU7_js.FireworksCanvas; }
 });
 Object.defineProperty(exports, "FireworksControlPanel", {
   enumerable: true,
-  get: function () { return chunkB34YUZRL_js.FireworksControlPanel; }
+  get: function () { return chunkXXDMARU7_js.FireworksControlPanel; }
 });
 Object.defineProperty(exports, "MIKU_PALETTE", {
   enumerable: true,
-  get: function () { return chunkB34YUZRL_js.MIKU_PALETTE; }
+  get: function () { return chunkXXDMARU7_js.MIKU_PALETTE; }
 });
 Object.defineProperty(exports, "MikuFireworks3D", {
   enumerable: true,
-  get: function () { return chunkB34YUZRL_js.MikuFireworks3D; }
+  get: function () { return chunkXXDMARU7_js.MikuFireworks3D; }
 });
 Object.defineProperty(exports, "NORMAL_PALETTE", {
   enumerable: true,
-  get: function () { return chunkB34YUZRL_js.NORMAL_PALETTE; }
+  get: function () { return chunkXXDMARU7_js.NORMAL_PALETTE; }
+});
+Object.defineProperty(exports, "WebSocketTransport", {
+  enumerable: true,
+  get: function () { return chunkXXDMARU7_js.WebSocketTransport; }
 });
 Object.defineProperty(exports, "useDanmakuController", {
   enumerable: true,
-  get: function () { return chunkB34YUZRL_js.useDanmakuController; }
+  get: function () { return chunkXXDMARU7_js.useDanmakuController; }
 });
 Object.defineProperty(exports, "useFireworksEngine", {
   enumerable: true,
-  get: function () { return chunkB34YUZRL_js.useFireworksEngine; }
+  get: function () { return chunkXXDMARU7_js.useFireworksEngine; }
+});
+Object.defineProperty(exports, "useFireworksRealtime", {
+  enumerable: true,
+  get: function () { return chunkXXDMARU7_js.useFireworksRealtime; }
 });
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map

package/dist/mikuFireworks3D/index.mjs

@@ -1,4 +1,4 @@
-export { DANMAKU_MAX_LENGTH, DANMAKU_TRACK_COUNT, DEFAULT_MAX_ACTIVE_FIREWORKS, DEFAULT_MAX_PARTICLES, DanmakuPanel, FIREWORK_KIND_LABELS, FireworksCanvas, FireworksControlPanel, MIKU_PALETTE, MikuFireworks3D, NORMAL_PALETTE, useDanmakuController, useFireworksEngine } from '../chunk-HQ7VHIEK.mjs';
+export { DANMAKU_MAX_LENGTH, DANMAKU_TRACK_COUNT, DEFAULT_MAX_ACTIVE_FIREWORKS, DEFAULT_MAX_PARTICLES, DanmakuPanel, FIREWORK_KIND_LABELS, FireworksCanvas, FireworksControlPanel, MIKU_PALETTE, MikuFireworks3D, NORMAL_PALETTE, WebSocketTransport, useDanmakuController, useFireworksEngine, useFireworksRealtime } from '../chunk-55FBYGRK.mjs';
 import '../chunk-BJTO5JO5.mjs';
 //# sourceMappingURL=index.mjs.map
 //# sourceMappingURL=index.mjs.map

package/dist/mikuFireworks3D/server/index.d.mts

@@ -0,0 +1,146 @@
+import { F as FireworkKind, a as FireworkLaunchPayload } from '../../types-DBVDr8Mu.mjs';
+
+interface FireworksUserIdentity {
+    userId: string;
+    nickname?: string;
+    avatarUrl?: string;
+}
+interface DanmakuBroadcastEvent {
+    id: string;
+    roomId: string;
+    text: string;
+    color?: string;
+    kind?: FireworkKind;
+    user: FireworksUserIdentity;
+    timestamp: number;
+}
+interface FireworkBroadcastEvent {
+    id: string;
+    roomId: string;
+    payload: FireworkLaunchPayload;
+    user: FireworksUserIdentity;
+    timestamp: number;
+}
+type FireworksClientMessage = {
+    type: 'join';
+    roomId: string;
+    user: FireworksUserIdentity;
+} | {
+    type: 'leave';
+} | {
+    type: 'danmaku.send';
+    payload: {
+        text: string;
+        color?: string;
+        kind?: FireworkKind;
+    };
+} | {
+    type: 'firework.launch';
+    payload: FireworkLaunchPayload;
+} | {
+    type: 'ping';
+    ts?: number;
+};
+type FireworksServerMessage = {
+    type: 'joined';
+    roomId: string;
+    self: FireworksUserIdentity;
+    onlineCount: number;
+} | {
+    type: 'room.snapshot';
+    roomId: string;
+    users: FireworksUserIdentity[];
+    danmakuHistory: DanmakuBroadcastEvent[];
+    fireworkHistory: FireworkBroadcastEvent[];
+} | {
+    type: 'room.user_joined';
+    roomId: string;
+    user: FireworksUserIdentity;
+    onlineCount: number;
+} | {
+    type: 'room.user_left';
+    roomId: string;
+    userId: string;
+    onlineCount: number;
+} | {
+    type: 'danmaku.broadcast';
+    roomId: string;
+    event: DanmakuBroadcastEvent;
+} | {
+    type: 'firework.broadcast';
+    roomId: string;
+    event: FireworkBroadcastEvent;
+} | {
+    type: 'pong';
+    ts: number;
+} | {
+    type: 'error';
+    code: string;
+    message: string;
+};
+interface FireworksConnectionTransport {
+    send: (encodedMessage: string) => void;
+    close?: (code?: number, reason?: string) => void;
+}
+interface FireworksConnection {
+    id: string;
+    handleMessage: (raw: unknown) => void;
+    disconnect: (reason?: string) => void;
+    send: (message: FireworksServerMessage) => void;
+}
+interface FireworksRoomHubOptions {
+    maxUsersPerRoom?: number;
+    historyLimit?: number;
+    maxDanmakuLength?: number;
+    logger?: Pick<Console, 'info' | 'warn' | 'error'>;
+}
+interface FireworksHubStats {
+    rooms: number;
+    connections: number;
+}
+interface WsLikeSocket {
+    send: (data: string) => void;
+    on: (event: 'message' | 'close' | 'error', listener: (...args: unknown[]) => void) => void;
+}
+
+declare class FireworksRoomHub {
+    private readonly rooms;
+    private readonly sessions;
+    private readonly maxUsersPerRoom;
+    private readonly historyLimit;
+    private readonly maxDanmakuLength;
+    private readonly logger?;
+    constructor(options?: FireworksRoomHubOptions);
+    connect(transport: FireworksConnectionTransport, id?: string): FireworksConnection;
+    disconnect(connectionId: string, reason?: string): void;
+    getStats(): {
+        rooms: number;
+        connections: number;
+    };
+    getRoomOnlineCount(roomId: string): number;
+    private handleRawMessage;
+    private joinRoom;
+    private leaveRoom;
+    private handleDanmaku;
+    private handleFirework;
+    private createRoom;
+    private sendToConnection;
+    private broadcastToRoom;
+    private sendError;
+}
+
+interface BindWsSocketOptions {
+    connectionId?: string;
+    onConnected?: (connection: FireworksConnection) => void;
+    onDisconnected?: (connectionId: string) => void;
+}
+/**
+ * Bind a ws-like socket to FireworksRoomHub.
+ *
+ * Example (ws package):
+ * const hub = new FireworksRoomHub();
+ * wss.on('connection', (socket) => bindWsSocket(hub, socket));
+ */
+declare function bindWsSocket(hub: FireworksRoomHub, socket: WsLikeSocket, options?: BindWsSocketOptions): FireworksConnection;
+
+export { type BindWsSocketOptions, type DanmakuBroadcastEvent, type FireworkBroadcastEvent, type FireworksClientMessage, type FireworksConnection, type FireworksConnectionTransport, type FireworksHubStats, FireworksRoomHub, type FireworksRoomHubOptions, type FireworksServerMessage, type FireworksUserIdentity, type WsLikeSocket, bindWsSocket };

package/dist/mikuFireworks3D/server/index.d.ts

@@ -0,0 +1,146 @@
+import { F as FireworkKind, a as FireworkLaunchPayload } from '../../types-DBVDr8Mu.js';
+
+interface FireworksUserIdentity {
+    userId: string;
+    nickname?: string;
+    avatarUrl?: string;
+}
+interface DanmakuBroadcastEvent {
+    id: string;
+    roomId: string;
+    text: string;
+    color?: string;
+    kind?: FireworkKind;
+    user: FireworksUserIdentity;
+    timestamp: number;
+}
+interface FireworkBroadcastEvent {
+    id: string;
+    roomId: string;
+    payload: FireworkLaunchPayload;
+    user: FireworksUserIdentity;
+    timestamp: number;
+}
+type FireworksClientMessage = {
+    type: 'join';
+    roomId: string;
+    user: FireworksUserIdentity;
+} | {
+    type: 'leave';
+} | {
+    type: 'danmaku.send';
+    payload: {
+        text: string;
+        color?: string;
+        kind?: FireworkKind;
+    };
+} | {
+    type: 'firework.launch';
+    payload: FireworkLaunchPayload;
+} | {
+    type: 'ping';
+    ts?: number;
+};
+type FireworksServerMessage = {
+    type: 'joined';
+    roomId: string;
+    self: FireworksUserIdentity;
+    onlineCount: number;
+} | {
+    type: 'room.snapshot';
+    roomId: string;
+    users: FireworksUserIdentity[];
+    danmakuHistory: DanmakuBroadcastEvent[];
+    fireworkHistory: FireworkBroadcastEvent[];
+} | {
+    type: 'room.user_joined';
+    roomId: string;
+    user: FireworksUserIdentity;
+    onlineCount: number;
+} | {
+    type: 'room.user_left';
+    roomId: string;
+    userId: string;
+    onlineCount: number;
+} | {
+    type: 'danmaku.broadcast';
+    roomId: string;
+    event: DanmakuBroadcastEvent;
+} | {
+    type: 'firework.broadcast';
+    roomId: string;
+    event: FireworkBroadcastEvent;
+} | {
+    type: 'pong';
+    ts: number;
+} | {
+    type: 'error';
+    code: string;
+    message: string;
+};
+interface FireworksConnectionTransport {
+    send: (encodedMessage: string) => void;
+    close?: (code?: number, reason?: string) => void;
+}
+interface FireworksConnection {
+    id: string;
+    handleMessage: (raw: unknown) => void;
+    disconnect: (reason?: string) => void;
+    send: (message: FireworksServerMessage) => void;
+}
+interface FireworksRoomHubOptions {
+    maxUsersPerRoom?: number;
+    historyLimit?: number;
+    maxDanmakuLength?: number;
+    logger?: Pick<Console, 'info' | 'warn' | 'error'>;
+}
+interface FireworksHubStats {
+    rooms: number;
+    connections: number;
+}
+interface WsLikeSocket {
+    send: (data: string) => void;
+    on: (event: 'message' | 'close' | 'error', listener: (...args: unknown[]) => void) => void;
+}
+
+declare class FireworksRoomHub {
+    private readonly rooms;
+    private readonly sessions;
+    private readonly maxUsersPerRoom;
+    private readonly historyLimit;
+    private readonly maxDanmakuLength;
+    private readonly logger?;
+    constructor(options?: FireworksRoomHubOptions);
+    connect(transport: FireworksConnectionTransport, id?: string): FireworksConnection;
+    disconnect(connectionId: string, reason?: string): void;
+    getStats(): {
+        rooms: number;
+        connections: number;
+    };
+    getRoomOnlineCount(roomId: string): number;
+    private handleRawMessage;
+    private joinRoom;
+    private leaveRoom;
+    private handleDanmaku;
+    private handleFirework;
+    private createRoom;
+    private sendToConnection;
+    private broadcastToRoom;
+    private sendError;
+}
+
+interface BindWsSocketOptions {
+    connectionId?: string;
+    onConnected?: (connection: FireworksConnection) => void;
+    onDisconnected?: (connectionId: string) => void;
+}
+/**
+ * Bind a ws-like socket to FireworksRoomHub.
+ *
+ * Example (ws package):
+ * const hub = new FireworksRoomHub();
+ * wss.on('connection', (socket) => bindWsSocket(hub, socket));
+ */
+declare function bindWsSocket(hub: FireworksRoomHub, socket: WsLikeSocket, options?: BindWsSocketOptions): FireworksConnection;
+
+export { type BindWsSocketOptions, type DanmakuBroadcastEvent, type FireworkBroadcastEvent, type FireworksClientMessage, type FireworksConnection, type FireworksConnectionTransport, type FireworksHubStats, FireworksRoomHub, type FireworksRoomHubOptions, type FireworksServerMessage, type FireworksUserIdentity, type WsLikeSocket, bindWsSocket };