kodenique-game-sdk 1.0.0

package/dist/hooks/useWebRTC.js

@@ -0,0 +1,555 @@
+import { useRef, useEffect, useCallback, useState } from "react";
+const MAX_RECONNECT_ATTEMPTS = 5;
+const MIN_CONNECTION_INTERVAL = 200;
+const CONNECTION_TIMEOUT = 10000;
+const FETCH_TIMEOUT = 10000;
+export function useWebRTC(options) {
+    const { streamUrl, serverUrl, streamName, onLoad, onError, onConnectionStateChange, } = options;
+    const videoRef = useRef(null);
+    const pcRef = useRef(null);
+    const statsIntervalRef = useRef(null);
+    const reconnectTimeoutRef = useRef(null);
+    const lastBytesRef = useRef(0);
+    const lastTimestampRef = useRef(Date.now());
+    const isConnectingRef = useRef(false);
+    const isConnectedRef = useRef(false);
+    const reconnectAttemptsRef = useRef(0);
+    const lastConnectionAttemptRef = useRef(0);
+    const prevStreamUrlRef = useRef();
+    const [isLoading, setIsLoading] = useState(true);
+    const [hasError, setHasError] = useState(false);
+    const [errorMessage, setErrorMessage] = useState("");
+    const [networkQuality, setNetworkQuality] = useState("good");
+    const [latency, setLatency] = useState(0);
+    const [bitrate, setBitrate] = useState(0);
+    const startStatsMonitor = useCallback(() => {
+        if (statsIntervalRef.current)
+            clearInterval(statsIntervalRef.current);
+        statsIntervalRef.current = setInterval(async () => {
+            if (!pcRef.current || pcRef.current.connectionState !== "connected")
+                return;
+            try {
+                const stats = await pcRef.current.getStats();
+                let totalBytesReceived = 0;
+                let jitterBufferDelay = 0;
+                let jitterBufferEmittedCount = 0;
+                let packetsLost = 0;
+                let packetsReceived = 0;
+                stats.forEach((report) => {
+                    if (report.type === "inbound-rtp" && report.kind === "video") {
+                        totalBytesReceived += report.bytesReceived || 0;
+                        packetsLost += report.packetsLost || 0;
+                        packetsReceived += report.packetsReceived || 0;
+                        if (report.jitterBufferDelay && report.jitterBufferEmittedCount) {
+                            jitterBufferDelay = report.jitterBufferDelay;
+                            jitterBufferEmittedCount = report.jitterBufferEmittedCount;
+                        }
+                    }
+                });
+                // Calculate latency
+                if (jitterBufferEmittedCount > 0) {
+                    const calculatedLatency = Math.round((jitterBufferDelay / jitterBufferEmittedCount) * 1000);
+                    setLatency(calculatedLatency);
+                }
+                // Calculate bitrate
+                const now = Date.now();
+                const timeDiff = (now - lastTimestampRef.current) / 1000;
+                if (timeDiff > 0 && lastBytesRef.current > 0) {
+                    const calculatedBitrate = Math.round(((totalBytesReceived - lastBytesRef.current) * 8) / timeDiff / 1000);
+                    setBitrate(calculatedBitrate);
+                    // Determine network quality based on bitrate
+                    if (calculatedBitrate > 1500) {
+                        setNetworkQuality("good");
+                    }
+                    else if (calculatedBitrate > 800) {
+                        setNetworkQuality("fair");
+                    }
+                    else if (calculatedBitrate > 300) {
+                        setNetworkQuality("poor");
+                    }
+                    else {
+                        setNetworkQuality("bad");
+                    }
+                }
+                lastBytesRef.current = totalBytesReceived;
+                lastTimestampRef.current = now;
+                // Check packet loss
+                if (packetsReceived > 0) {
+                    const lossRate = packetsLost / (packetsLost + packetsReceived);
+                    if (lossRate > 0.05) {
+                        setNetworkQuality("poor");
+                    }
+                }
+            }
+            catch (error) {
+                console.error("[useWebRTC] Stats error:", error);
+            }
+        }, 1000);
+    }, []);
+    const scheduleReconnect = useCallback((delay = 3000) => {
+        if (reconnectTimeoutRef.current) {
+            clearTimeout(reconnectTimeoutRef.current);
+            reconnectTimeoutRef.current = null;
+        }
+        if (reconnectAttemptsRef.current >= MAX_RECONNECT_ATTEMPTS) {
+            console.error("[useWebRTC] Max reconnection attempts reached");
+            setErrorMessage("Unable to connect - please refresh the page");
+            return;
+        }
+        reconnectAttemptsRef.current++;
+        console.log(`[useWebRTC] Scheduling reconnect attempt ${reconnectAttemptsRef.current}/${MAX_RECONNECT_ATTEMPTS} in ${delay}ms`);
+        reconnectTimeoutRef.current = setTimeout(() => {
+            console.log("[useWebRTC] Auto-reconnecting...");
+            if (videoRef.current) {
+                connectWebRTC();
+            }
+        }, delay);
+    }, []);
+    const buildWhepUrl = useCallback((streamUrl, serverUrl, streamName) => {
+        if (streamUrl) {
+            console.log("[useWebRTC] Original stream URL:", streamUrl);
+            const urlMatch = streamUrl.match(/stream=([^&]+)/);
+            const streamId = urlMatch ? urlMatch[1] : null;
+            console.log("[useWebRTC] Extracted stream ID:", streamId);
+            if (streamId) {
+                const serverMatch = streamUrl.match(/\/\/([^:\/]+)/);
+                const server = serverMatch ? serverMatch[1] : "stg-srs.wspo.club";
+                console.log("[useWebRTC] Server:", server);
+                const whepUrl = `http://${server}:1985/rtc/v1/whep/?app=live&stream=${streamId}`;
+                console.log("[useWebRTC] Rebuilt clean URL:", whepUrl);
+                return whepUrl;
+            }
+            else {
+                let fixedUrl = streamUrl;
+                if (fixedUrl.includes("https://")) {
+                    fixedUrl = fixedUrl.replace("https://", "http://");
+                }
+                if (fixedUrl.includes(":1985/v1/whep/")) {
+                    fixedUrl = fixedUrl.replace(":1985/v1/whep/", ":1985/rtc/v1/whep/");
+                }
+                if (fixedUrl.includes("&access_key=")) {
+                    fixedUrl = fixedUrl.split("&access_key=")[0];
+                }
+                console.log("[useWebRTC] Fallback fixed URL:", fixedUrl);
+                return fixedUrl;
+            }
+        }
+        else if (serverUrl && streamName) {
+            const whepUrl = `http://${serverUrl}:1985/rtc/v1/whep/?app=live&stream=${streamName}`;
+            console.log("[useWebRTC] Constructed stream URL:", whepUrl);
+            return whepUrl;
+        }
+        else {
+            throw new Error("No stream URL or server/stream configuration provided");
+        }
+    }, []);
+    const setupVideoPlayback = useCallback((video, stream) => {
+        console.log("[useWebRTC] Setting srcObject on video element");
+        video.srcObject = stream;
+        video.muted = true;
+        video.volume = 0;
+        video.defaultMuted = true;
+        video.setAttribute("autoplay", "true");
+        video.setAttribute("playsinline", "true");
+        video.setAttribute("muted", "true");
+        console.log("[useWebRTC] Video element state:", {
+            readyState: video.readyState,
+            networkState: video.networkState,
+            paused: video.paused,
+            muted: video.muted,
+            autoplay: video.autoplay,
+            srcObject: !!video.srcObject,
+        });
+        isConnectedRef.current = true;
+        isConnectingRef.current = false;
+        reconnectAttemptsRef.current = 0;
+        const handlePlaying = () => {
+            console.log("[useWebRTC] Video playing event fired!");
+            setIsLoading(false);
+            setHasError(false);
+            onLoad === null || onLoad === void 0 ? void 0 : onLoad();
+        };
+        video.addEventListener("playing", handlePlaying, { once: true });
+        const attemptPlay = (attempt = 1, maxAttempts = 30) => {
+            const state = {
+                readyState: video.readyState,
+                paused: video.paused,
+                networkState: video.networkState,
+                currentTime: video.currentTime,
+            };
+            console.log(`[useWebRTC] Play attempt ${attempt}/${maxAttempts}`, state);
+            if (video.readyState > 0 || attempt > 5) {
+                const playPromise = video.play();
+                if (playPromise !== undefined) {
+                    playPromise
+                        .then(() => {
+                        console.log(`[useWebRTC] Play promise resolved on attempt ${attempt}`);
+                    })
+                        .catch((err) => {
+                        console.log(`[useWebRTC] Play promise rejected on attempt ${attempt}:`, err.message);
+                    });
+                }
+            }
+            else {
+                console.log(`[useWebRTC] Waiting for data... readyState is still 0`);
+            }
+            if (attempt < maxAttempts && video.paused) {
+                setTimeout(() => {
+                    if (video.paused) {
+                        attemptPlay(attempt + 1, maxAttempts);
+                    }
+                }, 200);
+            }
+            else if (attempt >= maxAttempts && video.paused) {
+                console.log("[useWebRTC] All play attempts exhausted - user may need to click");
+            }
+        };
+        setTimeout(() => attemptPlay(), 100);
+    }, [onLoad]);
+    const connectWebRTC = useCallback(async () => {
+        console.log("[useWebRTC] Starting connectWebRTC...");
+        if (isConnectingRef.current) {
+            console.log("[useWebRTC] Already connecting, skipping duplicate attempt");
+            return;
+        }
+        const now = Date.now();
+        if (now - lastConnectionAttemptRef.current < MIN_CONNECTION_INTERVAL) {
+            console.log("[useWebRTC] Too soon since last connection attempt, skipping");
+            return;
+        }
+        try {
+            if (pcRef.current &&
+                (pcRef.current.connectionState === "connected" ||
+                    pcRef.current.connectionState === "connecting")) {
+                console.log("[useWebRTC] Already connected/connecting, skipping reconnection");
+                return;
+            }
+            isConnectingRef.current = true;
+            lastConnectionAttemptRef.current = now;
+            if (pcRef.current) {
+                console.log("[useWebRTC] Cleaning up existing connection");
+                try {
+                    pcRef.current.close();
+                }
+                catch (e) {
+                    console.log("[useWebRTC] Error closing connection:", e);
+                }
+                pcRef.current = null;
+            }
+            if (videoRef.current && videoRef.current.srcObject) {
+                console.log("[useWebRTC] Clearing existing video stream");
+                const stream = videoRef.current.srcObject;
+                stream.getTracks().forEach((track) => track.stop());
+                videoRef.current.srcObject = null;
+            }
+            setIsLoading(true);
+            setHasError(false);
+            setErrorMessage("");
+            const whepUrl = buildWhepUrl(streamUrl, serverUrl, streamName);
+            const pc = new RTCPeerConnection({
+                iceServers: [],
+                bundlePolicy: "max-bundle",
+                rtcpMuxPolicy: "require",
+            });
+            pc.addTransceiver("video", { direction: "recvonly" });
+            pc.addTransceiver("audio", { direction: "recvonly" });
+            let connectionEstablished = false;
+            let connectionTimeout = null;
+            let streamSet = false;
+            pc.ontrack = (event) => {
+                console.log("[useWebRTC] Got track:", event.track.kind, "ID:", event.track.id);
+                const video = videoRef.current;
+                if (video && event.streams[0] && !streamSet && !video.srcObject) {
+                    streamSet = true;
+                    setupVideoPlayback(video, event.streams[0]);
+                    if (connectionTimeout) {
+                        clearTimeout(connectionTimeout);
+                        connectionTimeout = null;
+                    }
+                }
+                else if (event.track.kind === "video" && video) {
+                    console.log("[useWebRTC] Video track received, ensuring playback...");
+                    video.play().catch(() => {
+                        console.log("[useWebRTC] Autoplay prevented - user interaction required");
+                    });
+                }
+            };
+            pc.oniceconnectionstatechange = () => {
+                var _a, _b;
+                const state = pc.iceConnectionState;
+                console.log("[useWebRTC] ICE connection state:", state);
+                if (state === "connected" || state === "completed") {
+                    clearTimeout(connectionTimeout);
+                    connectionEstablished = true;
+                    reconnectAttemptsRef.current = 0;
+                    if ((_a = videoRef.current) === null || _a === void 0 ? void 0 : _a.srcObject) {
+                        console.log("[useWebRTC] ICE connected and video stream present - clearing loading");
+                        setIsLoading(false);
+                        setHasError(false);
+                    }
+                    if (!statsIntervalRef.current) {
+                        startStatsMonitor();
+                    }
+                    console.log("[useWebRTC] ICE connected to stream");
+                }
+                else if (state === "failed") {
+                    isConnectedRef.current = false;
+                    isConnectingRef.current = false;
+                    clearTimeout(connectionTimeout);
+                    console.error("[useWebRTC] ICE connection failed");
+                    if (reconnectAttemptsRef.current < MAX_RECONNECT_ATTEMPTS) {
+                        scheduleReconnect(1000);
+                    }
+                    else {
+                        setHasError(true);
+                        setIsLoading(false);
+                        setErrorMessage("Connection failed - click to retry");
+                    }
+                }
+                else if (state === "disconnected") {
+                    console.warn("[useWebRTC] ICE disconnected - but we have tracks, ignoring!");
+                    if ((_b = videoRef.current) === null || _b === void 0 ? void 0 : _b.srcObject) {
+                        console.log("[useWebRTC] Video stream exists, continuing playback");
+                        setIsLoading(false);
+                        setHasError(false);
+                        if (videoRef.current.paused) {
+                            videoRef.current.play().catch(() => { });
+                        }
+                    }
+                    else if (connectionEstablished) {
+                        setTimeout(() => {
+                            var _a, _b;
+                            if (((_a = pcRef.current) === null || _a === void 0 ? void 0 : _a.iceConnectionState) === "disconnected" &&
+                                !((_b = videoRef.current) === null || _b === void 0 ? void 0 : _b.srcObject)) {
+                                console.warn("[useWebRTC] Still disconnected and no video - reconnecting");
+                                isConnectedRef.current = false;
+                                setErrorMessage("Connection lost - reconnecting...");
+                                scheduleReconnect(1000);
+                            }
+                        }, 3000);
+                    }
+                }
+            };
+            pc.onconnectionstatechange = () => {
+                const state = pc.connectionState;
+                console.log("[useWebRTC] Connection state:", state);
+                onConnectionStateChange === null || onConnectionStateChange === void 0 ? void 0 : onConnectionStateChange(state);
+                if (state === "connected") {
+                    setIsLoading(false);
+                    setHasError(false);
+                }
+            };
+            const offer = await pc.createOffer();
+            await pc.setLocalDescription(offer);
+            console.log("[useWebRTC] Sending WHEP request to:", whepUrl);
+            connectionTimeout = setTimeout(() => {
+                var _a;
+                if (pcRef.current === pc && !((_a = videoRef.current) === null || _a === void 0 ? void 0 : _a.srcObject)) {
+                    console.warn("[useWebRTC] No video after 10s - timing out");
+                    pc.close();
+                    pcRef.current = null;
+                    isConnectingRef.current = false;
+                    setHasError(true);
+                    setIsLoading(false);
+                    setErrorMessage("No stream - click to retry");
+                    if (reconnectAttemptsRef.current < MAX_RECONNECT_ATTEMPTS) {
+                        scheduleReconnect(1000);
+                    }
+                }
+            }, CONNECTION_TIMEOUT);
+            const controller = new AbortController();
+            const fetchTimeout = setTimeout(() => controller.abort(), FETCH_TIMEOUT);
+            try {
+                console.log("[useWebRTC] Sending POST request to WHEP endpoint...");
+                const response = await fetch(whepUrl, {
+                    method: "POST",
+                    headers: { "Content-Type": "application/sdp" },
+                    body: offer.sdp,
+                    signal: controller.signal,
+                });
+                clearTimeout(fetchTimeout);
+                console.log("[useWebRTC] WHEP Response status:", response.status);
+                if (!response.ok) {
+                    let errorDetails = "";
+                    try {
+                        errorDetails = await response.text();
+                        console.error("[useWebRTC] Server error response:", errorDetails);
+                    }
+                    catch (e) {
+                        // Ignore if can't read response
+                    }
+                    if (response.status === 500 || response.status === 404) {
+                        console.warn(`[useWebRTC] HTTP ${response.status} error - will retry automatically`);
+                        throw new Error("RETRY_SILENT");
+                    }
+                    else {
+                        throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+                    }
+                }
+                const answerSdp = await response.text();
+                console.log("[useWebRTC] Got SDP answer, setting remote description");
+                await pc.setRemoteDescription({ type: "answer", sdp: answerSdp });
+                pcRef.current = pc;
+                console.log("[useWebRTC] WebRTC setup complete, waiting for ICE connection...");
+                clearTimeout(connectionTimeout);
+            }
+            catch (fetchError) {
+                clearTimeout(fetchTimeout);
+                clearTimeout(connectionTimeout);
+                if (fetchError.name === "AbortError") {
+                    throw new Error("Connection timeout - server not responding");
+                }
+                throw fetchError;
+            }
+        }
+        catch (error) {
+            console.error("[useWebRTC] WebRTC connection error:", error);
+            isConnectingRef.current = false;
+            let shouldAutoReconnect = true;
+            let showError = false;
+            if (error instanceof Error) {
+                if (error.message.includes("RETRY_SILENT")) {
+                    shouldAutoReconnect = true;
+                    showError = false;
+                }
+                else {
+                    shouldAutoReconnect =
+                        reconnectAttemptsRef.current < MAX_RECONNECT_ATTEMPTS;
+                    showError = reconnectAttemptsRef.current >= MAX_RECONNECT_ATTEMPTS - 1;
+                }
+            }
+            if (showError || !shouldAutoReconnect) {
+                setHasError(true);
+                setIsLoading(false);
+                setErrorMessage("Stream unavailable - click to retry");
+                onError === null || onError === void 0 ? void 0 : onError(error instanceof Error ? error : new Error("Connection failed"));
+            }
+            else {
+                setIsLoading(true);
+                setHasError(false);
+            }
+            if (shouldAutoReconnect) {
+                const delay = 500 + reconnectAttemptsRef.current * 500;
+                scheduleReconnect(Math.min(delay, 2500));
+            }
+        }
+    }, [
+        streamUrl,
+        serverUrl,
+        streamName,
+        buildWhepUrl,
+        setupVideoPlayback,
+        startStatsMonitor,
+        scheduleReconnect,
+        onConnectionStateChange,
+        onError,
+    ]);
+    const retry = useCallback(() => {
+        console.log("[useWebRTC] Manual retry triggered");
+        reconnectAttemptsRef.current = 0;
+        isConnectedRef.current = false;
+        isConnectingRef.current = false;
+        lastConnectionAttemptRef.current = 0;
+        setHasError(false);
+        setIsLoading(true);
+        connectWebRTC();
+    }, [connectWebRTC]);
+    const extractStreamKey = useCallback((url) => {
+        if (!url)
+            return null;
+        const match = url.match(/stream=([^&]+)/);
+        return match ? match[1] : url;
+    }, []);
+    useEffect(() => {
+        var _a;
+        console.log("[useWebRTC] useEffect triggered", {
+            streamUrl,
+            serverUrl,
+            streamName,
+            hasPeerConnection: !!pcRef.current,
+            peerConnectionState: (_a = pcRef.current) === null || _a === void 0 ? void 0 : _a.connectionState,
+            isConnecting: isConnectingRef.current,
+        });
+        if (!streamUrl && (!serverUrl || !streamName)) {
+            console.error("[useWebRTC] Missing stream configuration");
+            setHasError(true);
+            setErrorMessage("Missing stream configuration");
+            setIsLoading(false);
+            return;
+        }
+        const currentStreamKey = extractStreamKey(streamUrl) || `${serverUrl}:${streamName}`;
+        const prevStreamKey = extractStreamKey(prevStreamUrlRef.current);
+        console.log("[useWebRTC] Stream comparison", {
+            currentStreamKey,
+            prevStreamKey,
+            same: currentStreamKey === prevStreamKey,
+        });
+        if (currentStreamKey === prevStreamKey) {
+            if (pcRef.current &&
+                (pcRef.current.connectionState === "connected" ||
+                    pcRef.current.connectionState === "connecting")) {
+                console.log("[useWebRTC] Same stream, already connected/connecting - ignoring re-render");
+                return;
+            }
+        }
+        prevStreamUrlRef.current = streamUrl || `${serverUrl}:${streamName}`;
+        if (prevStreamKey && currentStreamKey !== prevStreamKey && pcRef.current) {
+            console.log("[useWebRTC] Stream changed, disconnecting old connection");
+            pcRef.current.close();
+            pcRef.current = null;
+            isConnectedRef.current = false;
+            isConnectingRef.current = false;
+        }
+        if ((!pcRef.current || pcRef.current.connectionState === "closed") &&
+            !isConnectingRef.current) {
+            console.log("[useWebRTC] Initiating new connection...");
+            reconnectAttemptsRef.current = 0;
+            setTimeout(() => connectWebRTC(), 0);
+        }
+        else {
+            console.log("[useWebRTC] Skipping connection - already exists or connecting");
+        }
+    }, [streamUrl, serverUrl, streamName, extractStreamKey, connectWebRTC]);
+    useEffect(() => {
+        return () => {
+            console.log("[useWebRTC] Cleanup - unmounting");
+            isConnectedRef.current = false;
+            isConnectingRef.current = false;
+            prevStreamUrlRef.current = undefined;
+            if (statsIntervalRef.current) {
+                clearInterval(statsIntervalRef.current);
+                statsIntervalRef.current = null;
+            }
+            if (reconnectTimeoutRef.current) {
+                clearTimeout(reconnectTimeoutRef.current);
+                reconnectTimeoutRef.current = null;
+            }
+            if (videoRef.current && videoRef.current.srcObject) {
+                const stream = videoRef.current.srcObject;
+                stream.getTracks().forEach((track) => {
+                    track.stop();
+                });
+                videoRef.current.srcObject = null;
+            }
+            if (pcRef.current) {
+                try {
+                    pcRef.current.close();
+                }
+                catch (e) {
+                    console.log("[useWebRTC] Error closing peer connection:", e);
+                }
+                pcRef.current = null;
+            }
+        };
+    }, []);
+    return {
+        videoRef,
+        isLoading,
+        hasError,
+        errorMessage,
+        networkQuality,
+        latency,
+        bitrate,
+        retry,
+    };
+}

package/dist/index.d.ts

@@ -0,0 +1,13 @@
+export { GameProvider } from "./GameContext";
+export { useGames } from "./useGames";
+export { GamePlayer } from "./GamePlayer";
+export { SimplePlayer } from "./SimplePlayer";
+export { API_CONFIG, getConfig, getWebRTCUrl, getWebSocketUrl } from "./config";
+export { useGameStream } from "./hooks/useGameStream";
+export { useWebRTC } from "./hooks/useWebRTC";
+export { NetworkIndicator, ErrorOverlay, LoadingOverlay, ScoreOverlay, } from "./components/GamePlayerOverlays";
+export { GamePlayerVideo } from "./components/GamePlayerVideo";
+export type { Game, Team, Round, Creator, GamesApiResponse, GameProviderProps, GameContextType, UseGamesOptions, UseGamesReturn, } from "./types";
+export type { GamePlayerProps } from "./GamePlayer";
+export type { SimplePlayerProps } from "./SimplePlayer";
+export type { UseWebRTCOptions, UseWebRTCReturn } from "./hooks/useWebRTC";

package/dist/index.js

@@ -0,0 +1,12 @@
+// Main exports
+export { GameProvider } from "./GameContext";
+export { useGames } from "./useGames";
+export { GamePlayer } from "./GamePlayer";
+export { SimplePlayer } from "./SimplePlayer";
+export { API_CONFIG, getConfig, getWebRTCUrl, getWebSocketUrl } from "./config";
+// Subscription system exports
+export { useGameStream } from "./hooks/useGameStream";
+// Component exports
+export { useWebRTC } from "./hooks/useWebRTC";
+export { NetworkIndicator, ErrorOverlay, LoadingOverlay, ScoreOverlay, } from "./components/GamePlayerOverlays";
+export { GamePlayerVideo } from "./components/GamePlayerVideo";

package/dist/lib/pusher.d.ts

@@ -0,0 +1,50 @@
+/**
+ * Pusher integration for real-time game updates
+ * Alternative to WebSocket for easier setup
+ *
+ * Note: Install pusher-js to use this: npm install pusher-js
+ */
+export interface PusherConfig {
+    key: string;
+    cluster: string;
+    authEndpoint?: string;
+}
+export declare class GamePusherClient {
+    private config;
+    private pusher;
+    private channels;
+    constructor(config: PusherConfig);
+    /**
+     * Initialize Pusher connection
+     */
+    connect(): Promise<void>;
+    /**
+     * Subscribe to a game channel
+     */
+    subscribeToGame(gameId: string, callbacks: {
+        onGameUpdate?: (game: any) => void;
+        onScoreUpdate?: (scores: any) => void;
+        onStatusUpdate?: (status: string) => void;
+        onGameEnded?: () => void;
+    }): void;
+    /**
+     * Unsubscribe from a game channel
+     */
+    unsubscribeFromGame(gameId: string): void;
+    /**
+     * Disconnect from Pusher
+     */
+    disconnect(): void;
+    /**
+     * Check if connected
+     */
+    isConnected(): boolean;
+}
+/**
+ * Initialize the global Pusher client
+ */
+export declare function initializePusher(config: PusherConfig): GamePusherClient;
+/**
+ * Get the global Pusher client
+ */
+export declare function getPusherClient(): GamePusherClient | null;