@bluebottle_gg/league-broadcast-client 0.1.0 → 0.2.1

package/dist/index.d.ts

@@ -87,7 +87,7 @@ declare class itemWithAsset {
  * This is an auto-generated file.
  * Any changes made to this file can be lost when this file is regenerated.
  */
-declare class simpleChampionData {
+declare class simpleChampionData$1 {
     id: number;
     alias: string;
     name: string;
@@ -104,7 +104,7 @@ declare class simpleChampionData {
  */
 
 declare class damageGraphEntry {
-    champion?: simpleChampionData;
+    champion?: simpleChampionData$1;
     abilities?: ingameAbilityInfo[];
     activeItems?: itemWithAsset[];
     name: string;
@@ -172,7 +172,7 @@ declare class cDragonPerkInfo {
  */
 
 declare class ingameSingleRuneData {
-    champion?: simpleChampionData;
+    champion?: simpleChampionData$1;
     perks: cDragonPerkInfo[];
     name: string;
     team: number;
@@ -193,7 +193,7 @@ declare class ingameRuneData {
  */
 
 declare class ingameScoreboardBottomPlayerData {
-    champion?: simpleChampionData;
+    champion?: simpleChampionData$1;
     name: string;
     kills: number;
     deaths: number;
@@ -234,7 +234,7 @@ declare class ingameScoreboardBottomData {
  * This is an auto-generated file.
  * Any changes made to this file can be lost when this file is regenerated.
  */
-declare enum BestOfType {
+declare enum BestOfType$1 {
     BestOf1 = 1,
     BestOf2 = 2,
     BestOf3 = 3,
@@ -293,7 +293,7 @@ declare class ingameScoreboardTeamData {
 declare class ingameScoreboardData {
     teams: ingameScoreboardTeamData[];
     gameTime: number;
-    bestOf: BestOfType;
+    bestOf: BestOfType$1;
 }
 
 /**
@@ -314,7 +314,7 @@ declare class ingameSideInfoPageDisplayData {
  */
 
 declare class ingameSideInfoPageRow {
-    champion?: simpleChampionData;
+    champion?: simpleChampionData$1;
     playerName?: string;
     team?: number;
     minValue?: number;
@@ -419,11 +419,13 @@ declare class perkInfoV2 {
  * Any changes made to this file can be lost when this file is regenerated.
  */
 
-declare class tabPlayer {
+declare class tabPlayer$1 {
     id: string;
     playerName: string;
     playerHashtag: string;
-    championAssets?: simpleChampionData;
+    givenName: string;
+    familyName: string;
+    championAssets?: simpleChampionData$1;
     abilities: ingameAbilityInfo[];
     perks: perkInfoV2[];
     health: ingameHealthData;
@@ -443,7 +445,7 @@ declare class tabPlayer {
 
 declare class tabTeam {
     id: number;
-    players: tabPlayer[];
+    players: tabPlayer$1[];
 }
 
 /**
@@ -520,7 +522,7 @@ declare enum TeamMemberRole {
  * Any changes made to this file can be lost when this file is regenerated.
  */
 
-declare class teamMember {
+declare class teamMember$1 {
     memberId: number;
     teamId: number;
     alias: string;
@@ -538,8 +540,8 @@ declare class teamMember {
  * Any changes made to this file can be lost when this file is regenerated.
  */
 
-declare class teamWithMembers {
-    members: teamMember[];
+declare class teamWithMembers$1 {
+    members: teamMember$1[];
     teamId: number;
     name: string;
     tag: string;
@@ -563,7 +565,7 @@ declare class ingameFrontendData {
     isTestingEnvironment?: boolean;
     gameVersion: string;
     patch?: string;
-    teams?: teamWithMembers[];
+    teams?: teamWithMembers$1[];
     gameStatus: GameState$1;
     scoreboard?: ingameScoreboardData;
     tabs?: {
@@ -573,6 +575,9 @@ declare class ingameFrontendData {
     baronPitTimer?: iObjectiveRespawnData;
     dragonPitTimer?: iObjectiveRespawnData;
     inhibitors?: teamInhibitorData[];
+    showTwitchPrediction: boolean;
+    showTwitchPoll: boolean;
+    showTwitchChatVote: boolean;
     sideInfoPage?: ingameSideInfoPage;
     goldGraph?: ingameGoldGraphData;
     runes?: ingameRuneData;
@@ -718,6 +723,269 @@ interface GameStateSnapshot {
  */
 declare function shallowEqual<T>(a: T, b: T): boolean;
 
+/**
+ * This is an auto-generated file.
+ * Any changes made to this file can be lost when this file is regenerated.
+ */
+
+declare class championData {
+    id: number;
+    alias: string;
+    name: string;
+    attackSpeed: number;
+    splashCenteredImg: string;
+    splashImg: string;
+    loadingImg: string;
+    squareImg: string;
+    tileImg: string;
+    spells: championAbilityData[];
+}
+
+/**
+ * This is an auto-generated file.
+ * Any changes made to this file can be lost when this file is regenerated.
+ */
+
+declare class banSlot$1 {
+    isActive: boolean;
+    champion?: championData;
+}
+
+/**
+ * This is an auto-generated file.
+ * Any changes made to this file can be lost when this file is regenerated.
+ */
+declare class championStatistics {
+    winRate: number;
+    pickRate: number;
+    banRate: number;
+}
+
+/**
+ * This is an auto-generated file.
+ * Any changes made to this file can be lost when this file is regenerated.
+ */
+declare class summonerSpellData {
+    id?: number;
+    name: string;
+    spellIcon: string;
+    localAsset: string;
+}
+
+/**
+ * This is an auto-generated file.
+ * Any changes made to this file can be lost when this file is regenerated.
+ */
+
+declare class pickSlot$1 {
+    id: number;
+    isActive: boolean;
+    player: string;
+    summonerSpells: summonerSpellData[];
+    champion?: championData;
+    championStatistics?: championStatistics;
+}
+
+/**
+ * This is an auto-generated file.
+ * Any changes made to this file can be lost when this file is regenerated.
+ */
+declare enum PickBanPhase$1 {
+    BEGIN = 0,
+    BAN1 = 1,
+    BAN2 = 2,
+    PICK1 = 3,
+    PICK2 = 4,
+    END = 5,
+    WAIT = 6
+}
+
+/**
+ * This is an auto-generated file.
+ * Any changes made to this file can be lost when this file is regenerated.
+ */
+
+declare class pickBanTimer$1 {
+    phaseName: PickBanPhase$1;
+    phaseDuration: number;
+    timeRemaining: number;
+}
+
+/**
+ * This is an auto-generated file.
+ * Any changes made to this file can be lost when this file is regenerated.
+ */
+declare enum TimeLineActionType$1 {
+    HoverPick = 0,
+    Pick = 1,
+    Ban = 2
+}
+
+/**
+ * This is an auto-generated file.
+ * Any changes made to this file can be lost when this file is regenerated.
+ */
+
+declare class timelineEntry$1 {
+    type: TimeLineActionType$1;
+    champion: championData;
+    timer: pickBanTimer$1;
+}
+
+/**
+ * This is an auto-generated file.
+ * Any changes made to this file can be lost when this file is regenerated.
+ */
+
+declare class championSelectTeam$1 {
+    metaData?: teamWithMembers$1;
+    bans: banSlot$1[];
+    slots: pickSlot$1[];
+    timeline: timelineEntry$1[];
+    index: number;
+    scoreMatch: teamScore;
+    scoreSeason: teamScore;
+    fearlessBans?: {
+        [key: number]: simpleChampionData$1[];
+    };
+}
+
+/**
+ * This is an auto-generated file.
+ * Any changes made to this file can be lost when this file is regenerated.
+ */
+declare class champSelectStatePerformanceData {
+    updateDuration: number;
+}
+
+/**
+ * This is an auto-generated file.
+ * Any changes made to this file can be lost when this file is regenerated.
+ */
+declare enum MatchRuleSet$1 {
+    Standard = 0,
+    PartialFearless = 1,
+    Fearless = 2
+}
+
+/**
+ * This is an auto-generated file.
+ * Any changes made to this file can be lost when this file is regenerated.
+ */
+
+declare class matchData$1 {
+    matchId: number;
+    seasonId: number;
+    winnerId?: number;
+    isActive: boolean;
+    type: BestOfType$1;
+    nextMatchId?: number;
+    winnerNextMatchId?: number;
+    loserNextMatchId?: number;
+    name?: string;
+    date?: Date;
+    ruleSet: MatchRuleSet$1;
+    onStage: boolean;
+}
+
+/**
+ * This is an auto-generated file.
+ * Any changes made to this file can be lost when this file is regenerated.
+ */
+
+declare class champSelectStateMetaData$1 {
+    bestOfType: BestOfType$1;
+    patch: string;
+    performanceData: champSelectStatePerformanceData;
+    matchData?: matchData$1;
+}
+
+/**
+ * This is an auto-generated file.
+ * Any changes made to this file can be lost when this file is regenerated.
+ */
+
+declare class champSelectStateData {
+    isActive: boolean;
+    isConnected: boolean;
+    isTestingEnvironment: boolean;
+    blueTeam: championSelectTeam$1;
+    redTeam: championSelectTeam$1;
+    metaData: champSelectStateMetaData$1;
+    timer: pickBanTimer$1;
+}
+
+/**
+ * Reactive store for League Broadcast champion-select (pre-game) state.
+ *
+ * Follows the same selector-based model as {@link GameStateStore} but holds
+ * `champSelectStateData` instead of ingame data.
+ *
+ * @example Vanilla JS
+ * ```ts
+ * const timer = store.select(s => s.champSelectData.timer);
+ * timer.subscribe(() => {
+ *   console.log('Timer changed:', timer.getSnapshot());
+ * });
+ * ```
+ *
+ * @example React 18+
+ * ```tsx
+ * function Timer() {
+ *   const timer = useSyncExternalStore(
+ *     store.select(s => s.champSelectData.timer).subscribe,
+ *     store.select(s => s.champSelectData.timer).getSnapshot,
+ *   );
+ *   return <div>{timer?.timeRemaining}</div>;
+ * }
+ * ```
+ */
+declare class ChampSelectStateStore {
+    /** Current immutable snapshot. Replaced (never mutated) on every update. */
+    private snapshot;
+    /** Global listeners — called on every state change regardless of selector. */
+    private listeners;
+    /** Monotonically increasing version — used for cheap stale checks. */
+    private version;
+    constructor(initialState: champSelectStateData);
+    /** Return the current full snapshot. */
+    getSnapshot(): ChampSelectSnapshot;
+    /** Return the current version number. */
+    getVersion(): number;
+    /**
+     * Subscribe to **all** state changes (unfiltered).
+     * Returns an unsubscribe function.
+     */
+    subscribe(listener: () => void): () => void;
+    /**
+     * Create a **subscribable slice** that only triggers when the selected
+     * value changes according to `equalityFn` (defaults to `===`).
+     */
+    select<S>(selector: (snapshot: ChampSelectSnapshot) => S, equalityFn?: EqualityFn<S>): Subscribable<S>;
+    /**
+     * Watch a derived value and invoke `callback` whenever it changes.
+     * Returns an unsubscribe function.
+     */
+    watch<S>(selector: (snapshot: ChampSelectSnapshot) => S, callback: (value: S, prev: S) => void, equalityFn?: EqualityFn<S>): () => void;
+    /**
+     * Watch a derived value and invoke `callback` whenever it changes,
+     * **and** invoke it immediately with the current value.
+     */
+    watchImmediate<S>(selector: (snapshot: ChampSelectSnapshot) => S, callback: (value: S, prev: S | undefined) => void, equalityFn?: EqualityFn<S>): () => void;
+    /** @internal Replace champ-select data snapshot and notify listeners. */
+    _setChampSelectData(data: champSelectStateData): void;
+    /** @internal Replace entire snapshot (used on champ select end / reset). */
+    _reset(data: champSelectStateData): void;
+    private emit;
+}
+interface ChampSelectSnapshot {
+    readonly champSelectData: champSelectStateData;
+    /** Whether champ select is currently active. */
+    readonly isActive: boolean;
+    /** Monotonic version counter — useful for cheap stale checks. */
+    readonly version: number;
+}
+
 /**
  * This is an auto-generated file.
  * Any changes made to this file can be lost when this file is regenerated.
@@ -763,8 +1031,8 @@ declare class ingameObjectiveEvent {
  */
 
 declare class announcementParameter {
-    champion?: simpleChampionData;
-    member?: teamMember;
+    champion?: simpleChampionData$1;
+    member?: teamMember$1;
     asset?: string;
     team: number;
 }
@@ -827,156 +1095,870 @@ declare class announcerEvent {
 
 declare class killFeedEvent {
     ingameTeamId: number;
-    killer?: simpleChampionData;
-    victim: simpleChampionData;
-    assisters?: simpleChampionData[];
+    killer?: simpleChampionData$1;
+    victim: simpleChampionData$1;
+    assisters?: simpleChampionData$1[];
 }
 
 /**
  * This is an auto-generated file.
  * Any changes made to this file can be lost when this file is regenerated.
  */
-declare enum Team {
+declare enum Team$1 {
     None = 0,
     Order = 1,
     Chaos = 2,
     Neutral = 3
 }
 
-interface LeagueBroadcastClientConfig {
-    host: string;
-    port?: number;
-    wsRoute?: string;
-    apiRoute?: string;
-    cacheRoute?: string;
-    useHttps?: boolean;
-    autoConnect?: boolean;
-}
-interface GameDataEventHandlers {
-    onPlayerEvent?: (event: playerUpdateEvent) => void;
-    onTeamEvent?: (event: teamUpdateResults) => void;
-    onObjectiveEvent?: (event: ingameObjectiveEvent) => void;
-    onFirstTowerEvent?: (teamId: Team) => void;
-    onAnnouncementEvent?: (event: announcerEvent) => void;
-    onKillFeedEvent?: (event: killFeedEvent) => void;
+/**
+ * This is an auto-generated file.
+ * Any changes made to this file can be lost when this file is regenerated.
+ */
+
+declare class pickBanActionEventArgs {
+    type: string;
+    subType: string;
+    actorId: number;
+    id: number;
+    gameTeamId: number;
+    champion?: championData;
+    puuid?: string;
 }
+
 /**
- * Main client for connecting to League Broadcast backend and receiving game data
+ * Base HTTP client for League Broadcast REST API calls.
+ *
+ * Provides typed `get`, `post`, `put`, `patch`, and `delete` helpers that
+ * handle JSON serialization, error responses, and empty bodies.
+ *
+ * Used internally by the generated API modules — you normally access this
+ * through `LeagueBroadcastClient.api.*` rather than constructing it directly.
  */
-declare class LeagueBroadcastClient {
-    private ws;
-    private config;
-    private gameData;
-    private gameState;
-    private isTestingEnvironment;
-    /** Reactive store — subscribe to fine-grained state slices. */
-    readonly store: GameStateStore;
-    private stateUpdateHandlers;
-    private gameStatusHandlers;
-    private eventHandlers;
-    constructor(config: LeagueBroadcastClientConfig);
-    /**
-     * Connect to the League Broadcast backend
-     */
-    connect(): Promise<void>;
-    /**
-     * Disconnect from the League Broadcast backend
-     */
-    disconnect(): void;
-    /**
-     * Check if connected to the backend
-     */
-    isConnected(): boolean;
-    /**
-     * Get the current game data
-     */
-    getGameData(): ingameFrontendData;
-    /**
-     * Get the current game state
-     */
-    getGameState(): GameState$1;
-    /**
-     * Check if in testing environment
-     */
-    isInTestingEnvironment(): boolean;
-    /**
-     * Register a handler for state updates
-     */
-    onStateUpdate(handler: (state: ingameFrontendData) => void): () => void;
-    /**
-     * Register a handler for game status changes
-     */
-    onGameStatusChange(handler: (status: GameState$1, isTestingEnv: boolean) => void): () => void;
-    /**
-     * Register handlers for game events
-     */
-    onGameEvents(handlers: GameDataEventHandlers): void;
-    /**
-     * Register a handler for connection events
-     */
-    onConnect(handler: () => void): () => void;
-    /**
-     * Register a handler for disconnection events
-     */
-    onDisconnect(handler: () => void): () => void;
-    /**
-     * Register a handler for error events
-     */
-    onError(handler: (error: Event) => void): () => void;
-    /**
-     * Create a subscribable slice of game state.
-     * The slice only notifies listeners when the selected value actually changes.
-     *
-     * Works directly with React 18+ `useSyncExternalStore`:
-     * ```tsx
-     * const kills = client.select(s => s.gameData.scoreboard?.teams[0]?.kills);
-     * function Kills() {
-     *   const value = useSyncExternalStore(kills.subscribe, kills.getSnapshot);
-     *   return <span>{value}</span>;
-     * }
-     * ```
-     */
-    select<S>(selector: (snapshot: GameStateSnapshot) => S, equalityFn?: EqualityFn<S>): Subscribable<S>;
+declare class ApiClient {
+    private baseUrl;
+    constructor(baseUrl: string);
+    /** Update the base URL (e.g. after reconnecting to a different host/port). */
+    updateBaseUrl(baseUrl: string): void;
+    /** Current base URL. */
+    getBaseUrl(): string;
+    get<T>(path: string): Promise<T>;
+    post<T = void>(path: string, body?: unknown): Promise<T>;
+    put<T = void>(path: string, body?: unknown): Promise<T>;
+    patch<T = void>(path: string, body?: unknown): Promise<T>;
+    delete<T = void>(path: string): Promise<T>;
     /**
-     * Watch a derived value and invoke `callback` whenever it changes.
-     * Returns an unsubscribe function.
-     *
-     * ```ts
-     * client.watch(
-     *   s => s.gameData.scoreboard?.teams[0]?.kills,
-     *   (kills, prev) => console.log(`Kills: ${prev} → ${kills}`),
-     * );
-     * ```
+     * POST with a raw string body (e.g. base64 image data).
+     * Sets Content-Type to text/plain instead of application/json.
      */
-    watch<S>(selector: (snapshot: GameStateSnapshot) => S, callback: (value: S, prev: S) => void, equalityFn?: EqualityFn<S>): () => void;
-    /**
-     * Get the base HTTP URL for API requests
-     */
-    getApiUrl(): string;
+    postRaw<T = void>(path: string, rawBody: string): Promise<T>;
     /**
-     * Get the base URL for cache requests
+     * PUT with a raw string body (e.g. base64 image data).
+     * Sets Content-Type to text/plain instead of application/json.
      */
-    getCacheUrl(path?: string): string;
-    /**
-     * Setup message handler for WebSocket messages
-     */
-    private setupMessageHandler;
-    /**
-     * Handle state update from backend
+    putRaw<T = void>(path: string, rawBody: string): Promise<T>;
+    private buildUrl;
+    private request;
+    private parseResponse;
+}
+/**
+ * Error thrown when a REST API call returns a non-2xx status.
+ */
+declare class ApiError extends Error {
+    readonly status: number;
+    readonly statusText: string;
+    readonly body: string;
+    readonly url: string;
+    constructor(status: number, statusText: string, body: string, url: string);
+}
+
+/**
+ * This is an auto-generated file.
+ * Any changes made to this file can be lost when this file is regenerated.
+ */
+declare class simpleChampionData {
+    id: number;
+    alias: string;
+    name: string;
+    splashCenteredImg: string;
+    splashImg: string;
+    loadingImg: string;
+    squareImg: string;
+    tileImg: string;
+}
+
+/**
+ * Auto-generated REST API client for Champion select (pre-game) endpoints.
+ * Do not edit manually. Changes will be lost.
+ *
+ * @generated 2026-03-11
+ */
+
+declare class PreGameApi {
+    private readonly client;
+    constructor(client: ApiClient);
+    /** `POST championselect/mock/{doMocking}` */
+    mockChampionSelect(doMocking: boolean, randomizationinterval?: number): Promise<boolean>;
+    /** `GET championselect/mock` */
+    getMockingStatus(): Promise<boolean>;
+    /** `GET championselect/bans` */
+    getBans(): Promise<Record<number, Record<number, simpleChampionData[]>>>;
+    /** `GET championselect/frontend` */
+    getFrontendUrl(): Promise<string>;
+    /** `GET championselect/stage/{stageSide}/teamid` */
+    getTeamIdOnSide(stageSide: number): Promise<number>;
+    /** `POST championselect/frontend` */
+    changeRouting(uri: string): Promise<void>;
+    /** `GET championselect/stage/{stageside}/{slotid}` */
+    getPlayerPUUIDInSlot(stageside: number, slotid: number): Promise<string>;
+}
+
+/**
+ * This is an auto-generated file.
+ * Any changes made to this file can be lost when this file is regenerated.
+ */
+
+declare class gameWithTeams$1 {
+    teams: teamWithMembers$1[];
+    gameId: number;
+    matchId: number;
+    gameNumber: number;
+    gameWinnerId?: number;
+    isActive: boolean;
+    isComplete: boolean;
+    gameTime?: number;
+    gameDate?: Date;
+    ruleSet: MatchRuleSet$1;
+    patch: string;
+    gameVersion: string;
+    assetPatch: string;
+}
+
+/**
+ * This is an auto-generated file.
+ * Any changes made to this file can be lost when this file is regenerated.
+ */
+declare enum Team {
+    None = 0,
+    Order = 1,
+    Chaos = 2,
+    Neutral = 3
+}
+
+/**
+ * This is an auto-generated file.
+ * Any changes made to this file can be lost when this file is regenerated.
+ */
+
+declare class teamMember {
+    memberId: number;
+    teamId: number;
+    alias: string;
+    puuid: string;
+    isActive: boolean;
+    tag: string;
+    iconUri?: string;
+    role: TeamMemberRole;
+    familyName: string;
+    givenName: string;
+}
+
+/**
+ * This is an auto-generated file.
+ * Any changes made to this file can be lost when this file is regenerated.
+ */
+
+declare class teamWithMembers {
+    members: teamMember$1[];
+    teamId: number;
+    name: string;
+    tag: string;
+    description?: string;
+    iconUri?: string;
+    isActive: boolean;
+    primaryColor?: number;
+    secondaryColor?: number;
+    tertiaryColor?: number;
+    backgroundColor?: number;
+}
+
+/**
+ * Auto-generated REST API client for Game CRUD and draft (picks/bans) endpoints.
+ * Do not edit manually. Changes will be lost.
+ *
+ * @generated 2026-03-11
+ */
+
+declare class GameApi {
+    private readonly client;
+    constructor(client: ApiClient);
+    /** `GET game/current` */
+    getCurrentGame(): Promise<gameWithTeams$1>;
+    /** `GET game/previous` */
+    getPreviousGame(): Promise<number>;
+    /** `GET game/{gameid}` */
+    getGame(gameid: number): Promise<gameWithTeams$1>;
+    /** `PATCH game/{gameid}` */
+    updateGame(gameid: number, game: unknown): Promise<void>;
+    /** `PUT game/{gameid}/teams` */
+    setSideSelection(gameid: number, teams: number[]): Promise<void>;
+    /** `GET game/{gameid}/teams` */
+    getTeamsInGame(gameid: number): Promise<teamWithMembers[]>;
+    /** `DELETE game/{gameid}/winner` */
+    removeGameWinner(gameid: number): Promise<void>;
+    /** `PUT game/{gameid}/winner/{teamid}` */
+    setGameWinner(gameid: number, teamid: number): Promise<void>;
+    /** `GET game/{gameid}/bans` */
+    getBans(gameid: number): Promise<simpleChampionData[]>;
+    /** `GET game/{gameid}/bans/{teamid}` */
+    getBansForTeam(gameid: number, teamid: number): Promise<simpleChampionData[]>;
+    /** `PUT game/{gameid}/bans` */
+    setBans(gameid: number, bans: Record<number, (string | null)[]>): Promise<void>;
+    /** `PUT game/{gameid}/bans/{teamid}` */
+    setBansForTeam(gameid: number, teamid: number, bans: (string | null)[]): Promise<void>;
+    /** `GET game/{gameid}/picks` */
+    getPicks(gameid: number): Promise<Record<number, simpleChampionData[]>>;
+    /** `GET game/{gameid}/picks/{teamid}` */
+    getPicksForTeam(gameid: number, teamid: number): Promise<simpleChampionData[]>;
+    /** `PUT game/{gameid}/picks` */
+    setPicks(gameid: number, picks: Record<number, (string | null)[]>): Promise<void>;
+    /** `PUT game/{gameid}/picks/{teamid}` */
+    setPicksForTeam(gameid: number, teamid: number, picks: (string | null)[]): Promise<void>;
+    /** `GET game/{gameid}/teams/players` */
+    getPlayersInGame(gameid: number): Promise<Record<Team, teamMember[]>>;
+}
+
+/**
+ * This is an auto-generated file.
+ * Any changes made to this file can be lost when this file is regenerated.
+ */
+
+declare class tabPlayer {
+    id: string;
+    playerName: string;
+    playerHashtag: string;
+    givenName: string;
+    familyName: string;
+    championAssets?: simpleChampionData$1;
+    abilities: ingameAbilityInfo[];
+    perks: perkInfoV2[];
+    health: ingameHealthData;
+    resource: ingameResourceData;
+    stacksData?: number;
+    hasBaron: boolean;
+    hasElder: boolean;
+    level: number;
+    experience: ingameExperienceData;
+    timeToRespawn?: number;
+}
+
+/**
+ * Auto-generated REST API client for Live game state endpoints (requires active game).
+ * Do not edit manually. Changes will be lost.
+ *
+ * @generated 2026-03-11
+ */
+
+declare class GameStateApi {
+    private readonly client;
+    constructor(client: ApiClient);
+    /** `GET game/state/time` */
+    getGameTime(): Promise<number>;
+    /** `GET game/state/team/{teamId}/dragons` */
+    getTeamDragons(teamId: number): Promise<string[]>;
+    /** `PATCH game/state/team/{teamId}/dragons` */
+    updateTeamDragons(teamId: number, dragons: string[]): Promise<void>;
+    /** `GET game/state/team/all/index` */
+    getActiveTeams(): Promise<number[]>;
+    /** `GET game/state/team/all/participant` */
+    getAllTeamParticipants(): Promise<Record<number, tabPlayer[]>>;
+    /** `GET game/state/team/{teamId}/participant` */
+    getTeamParticipants(teamId: number): Promise<tabPlayer[]>;
+    /** `GET game/state/team/all/participant/order` */
+    getTeamParticipantOrder(): Promise<string[]>;
+    /** `PUT game/state/team/all/participant/order` */
+    updateTeamParticipantOrder(orderedNames: string[]): Promise<void>;
+}
+
+/**
+ * This is an auto-generated file.
+ * Any changes made to this file can be lost when this file is regenerated.
+ */
+
+declare class matchData {
+    matchId: number;
+    seasonId: number;
+    winnerId?: number;
+    isActive: boolean;
+    type: BestOfType$1;
+    nextMatchId?: number;
+    winnerNextMatchId?: number;
+    loserNextMatchId?: number;
+    name?: string;
+    date?: Date;
+    ruleSet: MatchRuleSet$1;
+    onStage: boolean;
+}
+
+/**
+ * This is an auto-generated file.
+ * Any changes made to this file can be lost when this file is regenerated.
+ */
+
+declare class addMatchRequestArgs {
+    name?: string;
+    type: BestOfType$1;
+    teams: number[];
+    isCurrent: boolean;
+    onStage?: boolean;
+    seasonId?: number;
+    nextMatchId?: number;
+    winnerNextMatchId?: number;
+    loserNextMatchId?: number;
+    matchDate?: string;
+    timePerGame?: number;
+    ruleSet: string;
+}
+
+/**
+ * This is an auto-generated file.
+ * Any changes made to this file can be lost when this file is regenerated.
+ */
+
+declare class optionalMatchData {
+    date?: Date;
+    ruleSet?: MatchRuleSet$1;
+    onStage?: boolean;
+}
+
+/**
+ * This is an auto-generated file.
+ * Any changes made to this file can be lost when this file is regenerated.
+ */
+declare enum BestOfType {
+    BestOf1 = 1,
+    BestOf2 = 2,
+    BestOf3 = 3,
+    BestOf5 = 5,
+    BestOf7 = 7
+}
+
+/**
+ * This is an auto-generated file.
+ * Any changes made to this file can be lost when this file is regenerated.
+ */
+declare enum MatchRuleSet {
+    Standard = 0,
+    PartialFearless = 1,
+    Fearless = 2
+}
+
+/**
+ * This is an auto-generated file.
+ * Any changes made to this file can be lost when this file is regenerated.
+ */
+
+declare class gameWithTeams {
+    teams: teamWithMembers$1[];
+    gameId: number;
+    matchId: number;
+    gameNumber: number;
+    gameWinnerId?: number;
+    isActive: boolean;
+    isComplete: boolean;
+    gameTime?: number;
+    gameDate?: Date;
+    ruleSet: MatchRuleSet$1;
+    patch: string;
+    gameVersion: string;
+    assetPatch: string;
+}
+
+/**
+ * This is an auto-generated file.
+ * Any changes made to this file can be lost when this file is regenerated.
+ */
+
+declare class matchWithGamesAndTeams {
+    games: gameWithTeams[];
+    teams: teamWithMembers$1[];
+    matchId: number;
+    seasonId: number;
+    winnerId?: number;
+    isActive: boolean;
+    type: BestOfType$1;
+    nextMatchId?: number;
+    winnerNextMatchId?: number;
+    loserNextMatchId?: number;
+    name?: string;
+    date?: Date;
+    ruleSet: MatchRuleSet$1;
+    onStage: boolean;
+}
+
+/**
+ * Auto-generated REST API client for Match (series) management endpoints.
+ * Do not edit manually. Changes will be lost.
+ *
+ * @generated 2026-03-11
+ */
+
+declare class MatchApi {
+    private readonly client;
+    constructor(client: ApiClient);
+    /** `GET match/season/{seasonId}/simple` */
+    getSimpleMatches(seasonId: number): Promise<matchData[]>;
+    /** `GET match/season/{seasonId}` */
+    getMatches(seasonId: number): Promise<matchWithGamesAndTeams[]>;
+    /** `GET match/simple` */
+    getAllSimpleMatches(): Promise<matchData[]>;
+    /** `GET match` */
+    getAllMatches(): Promise<matchWithGamesAndTeams[]>;
+    /** `GET match/current` */
+    getCurrentMatch(): Promise<matchWithGamesAndTeams>;
+    /** `POST match/current` */
+    completeCurrentMatch(): Promise<void>;
+    /** `GET match/current/id` */
+    getCurrentMatchId(): Promise<number>;
+    /** `GET match/previous/id` */
+    getPreviousMatchId(): Promise<number>;
+    /** `POST match/current/{seriesid}` */
+    setCurrentMatch(seriesid: number): Promise<void>;
+    /** `GET match/current/bestof` */
+    getCurrentMatchBestOf(): Promise<BestOfType>;
+    /** `PUT match/current/bestof` */
+    setCurrentMatchBestOf(type: BestOfType): Promise<void>;
+    /** `GET match/current/teams` */
+    getCurrentMatchTeams(): Promise<teamWithMembers[]>;
+    /** `PUT match/current/teams` */
+    setCurrentMatchTeams(teamIds: number[]): Promise<void>;
+    /** `GET match/current/game` */
+    getCurrentGame(): Promise<gameWithTeams$1>;
+    /** `GET match/current/ruleset` */
+    getCurrentMatchRuleset(): Promise<MatchRuleSet>;
+    /** `PUT match/current/ruleset/{ruleset}` */
+    setCurrentMatchRuleset(ruleset: MatchRuleSet): Promise<void>;
+    /** `GET match/current/fearless/bans` */
+    getBans(): Promise<Record<number, Record<number, simpleChampionData[]>>>;
+    /** `GET match/current/onstage` */
+    getCurrentMatchOnStage(): Promise<boolean>;
+    /** `GET match/{matchid}` */
+    getMatch(matchid: number): Promise<matchWithGamesAndTeams>;
+    /** `DELETE match/{matchid}` */
+    deleteMatch(matchid: number): Promise<boolean>;
+    /** `GET match/{matchid}/teams` */
+    getMatchTeams(matchid: number): Promise<teamWithMembers[]>;
+    /** `PUT match/{matchid}/teams` */
+    setMatchTeams(matchid: number, teamIds: number[]): Promise<void>;
+    /** `GET match/{matchid}/games` */
+    getMatchGames(matchid: number): Promise<gameWithTeams$1[]>;
+    /** `GET match/{matchid}/winner` */
+    getMatchWinner(matchid: number): Promise<teamWithMembers>;
+    /** `PUT match/{matchid}/winner/{teamid}` */
+    setMatchWinner(matchid: number, teamid: number): Promise<void>;
+    /** `DELETE match/{matchid}/winner` */
+    removeMatchWinner(matchid: number): Promise<void>;
+    /** `GET match/{matchid}/bestof` */
+    getMatchBestOf(matchid: number): Promise<BestOfType>;
+    /** `PUT match/{matchid}/bestof/{type}` */
+    setMatchBestOf(matchid: number, type: BestOfType): Promise<void>;
+    /** `GET match/{matchid}/ruleset` */
+    getMatchRuleset(matchid: number): Promise<MatchRuleSet>;
+    /** `PUT match/{matchid}/ruleset/{ruleset}` */
+    setMatchRuleset(matchid: number, ruleset: MatchRuleSet): Promise<void>;
+    /** `GET match/{matchid}/name` */
+    getMatchName(matchid: number): Promise<string>;
+    /** `PATCH match/{matchid}/name/{matchName}` */
+    setMatchName(matchid: number, matchName: string): Promise<void>;
+    /** `PATCH match/{matchid}` */
+    updateMatch(matchid: number, matchUpdate: optionalMatchData): Promise<void>;
+    /** `GET match/{matchid}/fearless/bans` */
+    getMatchBans(matchid: number): Promise<Record<number, Record<number, simpleChampionData[]>>>;
+    /** `GET match/{seriesid}/onstage` */
+    getMatchOnStage(seriesid: number): Promise<boolean>;
+    /** `PUT match` */
+    addMatch(match: addMatchRequestArgs): Promise<number>;
+    /** `GET match/{matchId}/stage/team/{stageSide}` */
+    getTeamOnStageSide(matchId: number, stageSide: number): Promise<teamWithMembers>;
+    /** `GET match/current/stage/team/{stageSide}` */
+    getTeamOnStageSideCurrent(stageSide: number): Promise<teamWithMembers>;
+}
+
+/**
+ * This is an auto-generated file.
+ * Any changes made to this file can be lost when this file is regenerated.
+ */
+declare class seasonData {
+    seasonId: number;
+    seasonName: string;
+    isActive: boolean;
+    startDate?: Date;
+    endDate?: Date;
+    iconUri?: string;
+}
+
+/**
+ * This is an auto-generated file.
+ * Any changes made to this file can be lost when this file is regenerated.
+ */
+declare class teamData {
+    teamId: number;
+    name: string;
+    tag: string;
+    description?: string;
+    iconUri?: string;
+    isActive: boolean;
+    primaryColor?: number;
+    secondaryColor?: number;
+    tertiaryColor?: number;
+    backgroundColor?: number;
+}
+
+/**
+ * Auto-generated REST API client for Season management endpoints.
+ * Do not edit manually. Changes will be lost.
+ *
+ * @generated 2026-03-11
+ */
+
+declare class SeasonApi {
+    private readonly client;
+    constructor(client: ApiClient);
+    /** `GET season/current` */
+    getCurrentSeason(): Promise<seasonData>;
+    /** `GET season/current/match` */
+    getCurrentSeasonScheduledMatch(): Promise<matchWithGamesAndTeams>;
+    /** `GET season/current/id` */
+    getCurrentSeasonId(): Promise<number>;
+    /** `POST season/current` */
+    setCurrentSeason(newCurrentSeasonId: number): Promise<void>;
+    /** `GET season/current/teams` */
+    getCurrentSeasonTeams(): Promise<teamData[]>;
+    /** `GET season/current/teamswithmembers` */
+    getCurrentSeasonTeamsWithMembers(): Promise<teamWithMembers[]>;
+    /** `GET season/current/icon` */
+    getCurrentSeasonIcon(): Promise<string>;
+    /** `PUT season/current/icon` */
+    setCurrentSeasonIcon(): Promise<string>;
+    /** `GET season` */
+    getAllSeasons(): Promise<seasonData[]>;
+    /** `GET season/{seasonId}` */
+    getSeasonById(seasonId: number): Promise<seasonData>;
+    /** `GET season/{seasonId}/matches` */
+    getMatchesInSeason(seasonId: number): Promise<matchWithGamesAndTeams[]>;
+    /** `GET season/{seasonId}/matches/count` */
+    getMatchesInSeasonCount(seasonId: number): Promise<number>;
+    /** `GET season/{seasonId}/matches/day/{day}` */
+    getMatchesInSeasonOnDay(seasonId: number, day: string): Promise<matchWithGamesAndTeams[]>;
+    /** `GET season/{seasonId}/teams` */
+    getTeamsInSeason(seasonId: number): Promise<teamData[]>;
+    /** `GET season/{seasonId}/teamswithmembers` */
+    getTeamsWithMembersInSeason(seasonId: number): Promise<teamWithMembers[]>;
+    /** `POST season` */
+    createOrUpdateSeason(seasonData: seasonData): Promise<number>;
+    /** `GET season/{seasonId}/icon` */
+    getSeasonIcon(seasonId: number): Promise<string>;
+    /** `PUT season/{seasonId}/icon` */
+    setSeasonIcon(seasonId: number): Promise<string>;
+    /** `DELETE season/{seasonId}` */
+    deleteSeason(seasonId: number): Promise<void>;
+}
+
+/**
+ * Auto-generated REST API client for In-game overlay and serialization endpoints.
+ * Do not edit manually. Changes will be lost.
+ *
+ * @generated 2026-03-11
+ */
+
+declare class IngameApi {
+    private readonly client;
+    constructor(client: ApiClient);
+    /** `GET ingame/status` */
+    getGameState(): Promise<number>;
+    /** `POST ingame/enable` */
+    enableComponent(): Promise<void>;
+    /** `POST ingame/disable` */
+    disableComponent(): Promise<void>;
+    /** `POST ingame/mock/{doMocking}` */
+    mockIngame(doMocking: boolean): Promise<void>;
+    /** `GET ingame/mock` */
+    getMockingStatus(): Promise<boolean>;
+    /** `GET ingame/frontend` */
+    getFrontendUrl(): Promise<string>;
+    /** `GET ingame/showing` */
+    getCurrentCommonSerializationOptions(): Promise<Record<string, unknown>>;
+    /** `POST ingame/showing` */
+    setCurrentCommonSerializationOptions(data: Record<string, unknown>): Promise<void>;
+    /** `GET ingame/showing/{socketid}` */
+    getCurrentFrontendSerializationOptions(socketid: string): Promise<Record<string, unknown>>;
+    /** `POST ingame/showing/{socketid}` */
+    setCurrentFrontendSerializationOptions(socketid: string, data: Record<string, unknown>): Promise<void>;
+    /** `GET ingame/stage/{stageSide}/{playerSlot}/networkId` */
+    getPlayerPUUIDInSlot(stageSide: number, playerSlot: number): Promise<number>;
+    /** `GET ingame/stage/{stageSide}/ingameteamid` */
+    getIngameTeamOnStageSide(stageSide: number): Promise<number>;
+    /** `GET ingame/state/activeOverlays` */
+    getActiveOverlays(): Promise<string[]>;
+}
+
+/**
+ * Composite REST API client that aggregates all generated API modules.
+ *
+ * Access individual API groups via the named properties:
+ *
+ * ```ts
+ * const client = new LeagueBroadcastClient({ host: "localhost" });
+ *
+ * // Games
+ * const game = await client.api.game.getCurrent();
+ *
+ * // Matches
+ * const match = await client.api.match.getCurrent();
+ * await client.api.match.setCurrentBestOf(BestOfType.BestOf3);
+ *
+ * // Seasons
+ * const seasons = await client.api.season.getAll();
+ *
+ * // In-game overlay control
+ * await client.api.ingame.enable();
+ * const overlays = await client.api.ingame.getActiveOverlays();
+ *
+ * // Live game state (requires active game)
+ * const time = await client.api.gameState.getGameTime();
+ * const players = await client.api.gameState.getAllParticipants();
+ *
+ * // Pre-game / champion select
+ * const frontendUrl = await client.api.preGame.getFrontendUrl();
+ * ```
+ */
+
+declare class RestApi {
+    private readonly client;
+    /** In-game overlay and serialization endpoints. */
+    readonly ingame: IngameApi;
+    /** Game CRUD, picks/bans, and winner endpoints. */
+    readonly game: GameApi;
+    /** Match (series) management — current match, teams, fearless bans, etc. */
+    readonly match: MatchApi;
+    /** Season management — CRUD, teams, icons, match listings. */
+    readonly season: SeasonApi;
+    /** Champion select (pre-game) mocking, bans, frontend routing. */
+    readonly preGame: PreGameApi;
+    /** Live game state — participants, dragons, ordering. Requires active game. */
+    readonly gameState: GameStateApi;
+    constructor(baseUrl: string);
+    /**
+     * Update the base URL for all API modules (e.g. after changing host/port).
      */
-    private handleStateUpdate;
+    updateBaseUrl(baseUrl: string): void;
     /**
-     * Handle game status update
+     * Get direct access to the underlying HTTP client for custom requests.
      */
-    private handleGameStatusUpdate;
+    getHttpClient(): ApiClient;
+}
+
+interface LeagueBroadcastClientConfig {
+    host: string;
+    port?: number;
+    /** In-game WebSocket route. @default "/ws/in" */
+    ingameWsRoute?: string;
+    /** Pre-game (champion select) WebSocket route. @default "/ws/pre" */
+    preGameWsRoute?: string;
+    apiRoute?: string;
+    cacheRoute?: string;
+    useHttps?: boolean;
+    autoConnect?: boolean;
+}
+interface IngameEventHandlers {
+    onPlayerEvent?: (event: playerUpdateEvent) => void;
+    onTeamEvent?: (event: teamUpdateResults) => void;
+    onObjectiveEvent?: (event: ingameObjectiveEvent) => void;
+    onFirstTowerEvent?: (teamId: Team$1) => void;
+    onAnnouncementEvent?: (event: announcerEvent) => void;
+    onKillFeedEvent?: (event: killFeedEvent) => void;
+}
+interface ChampSelectEventHandlers {
+    /** Fired for every pick/ban action (hover, lock, ban reveal, phase transition). */
+    onAction?: (action: pickBanActionEventArgs) => void;
+    /** Fired when champ select becomes active (first state update with `isActive === true`). */
+    onChampSelectStart?: () => void;
+    /** Fired when champ select ends (backend sends `isActive === false`). */
+    onChampSelectEnd?: () => void;
+    /** Fired when the frontend route changes (e.g. navigating between pre-game views). */
+    onRouteUpdate?: (uri: string) => void;
+}
+/**
+ * Main client for connecting to the League Broadcast backend.
+ *
+ * Internally manages **two** WebSocket connections:
+ * - `/ws/in`  — real-time in-game data
+ * - `/ws/pre` — champion-select (pre-game) data
+ *
+ * Both connections are opened on {@link connect} (or automatically if
+ * `autoConnect` is `true`) and share the same host / port.
+ *
+ * @example
+ * ```ts
+ * const client = new LeagueBroadcastClient({ host: "localhost" });
+ *
+ * // In-game
+ * client.onIngameStateUpdate(data => console.log("Game time:", data.gameTime));
+ * client.watchIngame(s => s.gameData.scoreboard?.teams[0]?.kills, kills => { });
+ *
+ * // Pre-game
+ * client.onChampSelectUpdate(data => console.log("Phase:", data.timer.phaseName));
+ * client.onChampSelectEvents({ onAction: a => console.log(a) });
+ * client.selectChampSelect(s => s.champSelectData.timer);
+ * ```
+ */
+declare class LeagueBroadcastClient {
+    private ingameWs;
+    private preGameWs;
+    private config;
+    private gameData;
+    private gameState;
+    private _isTestingEnvironment;
+    private champSelectData;
+    private champSelectWasActive;
+    /** Reactive store for **in-game** state. */
+    readonly ingameStore: GameStateStore;
+    /** Reactive store for **pre-game** (champion select) state. */
+    readonly preGameStore: ChampSelectStateStore;
     /**
-     * Handle game events
+     * Typed REST API client for all backend HTTP endpoints.
+     *
+     * Provides access to game, match, season, in-game, pre-game, and
+     * game-state API groups:
+     *
+     * ```ts
+     * const game  = await client.api.game.getCurrent();
+     * const match = await client.api.match.getCurrent();
+     * await client.api.ingame.enable();
+     * ```
      */
-    private handleGameEvents;
+    readonly api: RestApi;
+    private stateUpdateHandlers;
+    private gameStatusHandlers;
+    private ingameEventHandlers;
+    private champSelectUpdateHandlers;
+    private champSelectEventHandlers;
+    constructor(config: LeagueBroadcastClientConfig);
+    /**
+     * Connect to both in-game and pre-game WebSocket endpoints.
+     *
+     * Both connections are attempted in parallel. If either fails the returned
+     * promise rejects, but the other connection may still succeed.
+     */
+    connect(): Promise<void>;
+    /**
+     * Disconnect from both WebSocket endpoints.
+     */
+    disconnect(): void;
+    /**
+     * Whether the in-game WebSocket is connected.
+     */
+    isIngameConnected(): boolean;
+    /**
+     * Whether the pre-game WebSocket is connected.
+     */
+    isPreGameConnected(): boolean;
+    /** Get the current in-game data. */
+    getIngameData(): ingameFrontendData;
+    /** Get the current game state. */
+    getIngameState(): GameState$1;
+    /** Whether the backend is in a testing / replay environment. */
+    isInTestingEnvironment(): boolean;
+    /** Get the current champion-select state. */
+    getChampSelectData(): champSelectStateData;
+    /** Whether champion select is currently active. */
+    isChampSelectActive(): boolean;
+    /** Register a handler for in-game state updates. */
+    onIngameStateUpdate(handler: (state: ingameFrontendData) => void): () => void;
+    /** Register a handler for in-game status changes (running, paused, out of game). */
+    onIngameStatusChange(handler: (status: GameState$1, isTestingEnv: boolean) => void): () => void;
+    /** Register handlers for in-game events (kills, objectives, etc.). */
+    onIngameEvents(handlers: IngameEventHandlers): void;
+    /** Register a handler for champ-select state updates. */
+    onChampSelectUpdate(handler: (state: champSelectStateData) => void): () => void;
+    /** Register handlers for champ-select lifecycle and action events. */
+    onChampSelectEvents(handlers: ChampSelectEventHandlers): void;
+    /** Register a handler for in-game connection. */
+    onIngameConnect(handler: () => void): () => void;
+    /** Register a handler for in-game disconnection. */
+    onIngameDisconnect(handler: () => void): () => void;
+    /** Register a handler for in-game connection errors. */
+    onIngameError(handler: (error: Event) => void): () => void;
+    /** Register a handler for pre-game connection. */
+    onPreGameConnect(handler: () => void): () => void;
+    /** Register a handler for pre-game disconnection. */
+    onPreGameDisconnect(handler: () => void): () => void;
+    /** Register a handler for pre-game connection errors. */
+    onPreGameError(handler: (error: Event) => void): () => void;
+    /**
+     * Create a subscribable slice of **in-game** state.
+     * The slice only notifies listeners when the selected value actually changes.
+     *
+     * Works directly with React 18+ `useSyncExternalStore`:
+     * ```tsx
+     * const kills = client.selectIngame(s => s.gameData.scoreboard?.teams[0]?.kills);
+     * function Kills() {
+     *   const value = useSyncExternalStore(kills.subscribe, kills.getSnapshot);
+     *   return <span>{value}</span>;
+     * }
+     * ```
+     */
+    selectIngame<S>(selector: (snapshot: GameStateSnapshot) => S, equalityFn?: EqualityFn<S>): Subscribable<S>;
     /**
-     * End the game and reset state
+     * Watch a derived **in-game** value and invoke `callback` whenever it changes.
+     * Returns an unsubscribe function.
+     *
+     * ```ts
+     * client.watchIngame(
+     *   s => s.gameData.scoreboard?.teams[0]?.kills,
+     *   (kills, prev) => console.log(`Kills: ${prev} → ${kills}`),
+     * );
+     * ```
      */
+    watchIngame<S>(selector: (snapshot: GameStateSnapshot) => S, callback: (value: S, prev: S) => void, equalityFn?: EqualityFn<S>): () => void;
+    /**
+     * Create a subscribable slice of **pre-game** (champion select) state.
+     *
+     * ```tsx
+     * const timer = client.selectChampSelect(s => s.champSelectData.timer);
+     * function DraftTimer() {
+     *   const value = useSyncExternalStore(timer.subscribe, timer.getSnapshot);
+     *   return <span>{value?.timeRemaining}</span>;
+     * }
+     * ```
+     */
+    selectChampSelect<S>(selector: (snapshot: ChampSelectSnapshot) => S, equalityFn?: EqualityFn<S>): Subscribable<S>;
+    /**
+     * Watch a derived **pre-game** value and invoke `callback` whenever it
+     * changes. Returns an unsubscribe function.
+     *
+     * ```ts
+     * client.watchChampSelect(
+     *   s => s.champSelectData.timer.timeRemaining,
+     *   (remaining, prev) => console.log(`Time: ${prev} → ${remaining}`),
+     * );
+     * ```
+     */
+    watchChampSelect<S>(selector: (snapshot: ChampSelectSnapshot) => S, callback: (value: S, prev: S) => void, equalityFn?: EqualityFn<S>): () => void;
+    /** Get the base HTTP URL for API requests. */
+    getApiUrl(): string;
+    /** Get the base URL for cache requests (optionally resolve a path). */
+    getCacheUrl(path?: string): string;
+    private setupIngameMessageHandler;
+    private handleStateUpdate;
+    private handleGameStatusUpdate;
+    private handleGameEvents;
     private endGame;
+    private setupPreGameMessageHandler;
+    private handleChampSelectStateUpdate;
+    private handleChampSelectAction;
+    private handleRouteUpdate;
+    private endChampSelect;
 }
 
 /**
@@ -1044,9 +2026,134 @@ declare class transitionEvents {
     player?: playerUpdateEvent[];
     team?: teamUpdateResults[];
     objective?: ingameObjectiveEvent[];
-    firstTower?: Team;
+    firstTower?: number;
     announcements?: announcerEvent[];
     killFeed?: killFeedEvent[];
 }
 
-export { type EqualityFn, type GameDataEventHandlers, GameState$1 as GameState, type GameStateSnapshot, GameStateStore, LeagueBroadcastClient, type LeagueBroadcastClientConfig, type Subscribable, WebSocketManager, announcerEvent, ingameFrontendData, ingameObjectiveEvent, killFeedEvent, playerUpdateEvent, shallowEqual, teamUpdateResults, transitionEvents };
+/**
+ * This is an auto-generated file.
+ * Any changes made to this file can be lost when this file is regenerated.
+ */
+
+declare class championSelectTeam {
+    metaData?: teamWithMembers$1;
+    bans: banSlot$1[];
+    slots: pickSlot$1[];
+    timeline: timelineEntry$1[];
+    index: number;
+    scoreMatch: teamScore;
+    scoreSeason: teamScore;
+    fearlessBans?: {
+        [key: number]: simpleChampionData$1[];
+    };
+}
+
+/**
+ * This is an auto-generated file.
+ * Any changes made to this file can be lost when this file is regenerated.
+ */
+
+declare class pickBanTimer {
+    phaseName: PickBanPhase$1;
+    phaseDuration: number;
+    timeRemaining: number;
+}
+
+/**
+ * This is an auto-generated file.
+ * Any changes made to this file can be lost when this file is regenerated.
+ */
+declare enum PickBanPhase {
+    BEGIN = 0,
+    BAN1 = 1,
+    BAN2 = 2,
+    PICK1 = 3,
+    PICK2 = 4,
+    END = 5,
+    WAIT = 6
+}
+
+/**
+ * This is an auto-generated file.
+ * Any changes made to this file can be lost when this file is regenerated.
+ */
+
+declare class banSlot {
+    isActive: boolean;
+    champion?: championData;
+}
+
+/**
+ * This is an auto-generated file.
+ * Any changes made to this file can be lost when this file is regenerated.
+ */
+
+declare class pickSlot {
+    id: number;
+    isActive: boolean;
+    player: string;
+    summonerSpells: summonerSpellData[];
+    champion?: championData;
+    championStatistics?: championStatistics;
+}
+
+/**
+ * This is an auto-generated file.
+ * Any changes made to this file can be lost when this file is regenerated.
+ */
+
+declare class champSelectStateMetaData {
+    bestOfType: BestOfType$1;
+    patch: string;
+    performanceData: champSelectStatePerformanceData;
+    matchData?: matchData$1;
+}
+
+/**
+ * This is an auto-generated file.
+ * Any changes made to this file can be lost when this file is regenerated.
+ */
+declare enum ActionType {
+    TEN_BANS_REVEAL = 0,
+    PHASE_TRANSITION = 1,
+    PICK = 2,
+    BAN = 3
+}
+
+/**
+ * This is an auto-generated file.
+ * Any changes made to this file can be lost when this file is regenerated.
+ */
+declare enum ActionSubType {
+    START = 0,
+    HOVER = 1,
+    LOCK = 2
+}
+
+/**
+ * This is an auto-generated file.
+ * Any changes made to this file can be lost when this file is regenerated.
+ */
+
+declare class timelineEntry {
+    type: TimeLineActionType$1;
+    champion: championData;
+    timer: pickBanTimer$1;
+}
+
+/**
+ * This is an auto-generated file.
+ * Any changes made to this file can be lost when this file is regenerated.
+ */
+declare enum TimeLineActionType {
+    HoverPick = 0,
+    Pick = 1,
+    Ban = 2
+}
+
+declare function getSortedInventory(playerData: ingameScoreboardBottomPlayerData): (itemWithAsset | undefined)[];
+declare function getTrinket(playerData: ingameScoreboardBottomPlayerData): itemWithAsset | undefined;
+declare function getRoleQuest(playerData: ingameScoreboardBottomPlayerData): itemWithAsset | undefined;
+
+export { ActionSubType, ActionType, ApiClient, ApiError, BestOfType, type ChampSelectEventHandlers, type ChampSelectSnapshot, ChampSelectStateStore, type EqualityFn, GameApi, GameState$1 as GameState, GameStateApi, type GameStateSnapshot, GameStateStore, IngameApi, type IngameEventHandlers, LeagueBroadcastClient, type LeagueBroadcastClientConfig, MatchApi, MatchRuleSet, PickBanPhase, PreGameApi, RestApi, SeasonApi, type Subscribable, TimeLineActionType, WebSocketManager, announcerEvent, banSlot, champSelectStateData, champSelectStateMetaData, championSelectTeam, gameWithTeams$1 as gameWithTeams, getRoleQuest, getSortedInventory, getTrinket, ingameFrontendData, ingameObjectiveEvent, killFeedEvent, matchData, matchWithGamesAndTeams, pickBanActionEventArgs, pickBanTimer, pickSlot, playerUpdateEvent, seasonData, shallowEqual, simpleChampionData, tabPlayer, teamData, teamUpdateResults, teamWithMembers, timelineEntry, transitionEvents };