@maestro_io/maestro-web-sdk 2.1.3 → 2.2.1

package/dist/modules/stats/view/MatchPredictor/MatchPredictorView.d.ts

@@ -1,53 +1,18 @@
-/// <reference types="prop-types" />
-import React from 'react';
+import React, { Component } from 'react';
 import './MatchPredictorView.styles.css';
 import { WithFocusableProps } from '@/external/spatial-navigation';
-import { Predictor, EntityMap, Team } from '../../interfaces/IStats';
+import { Layout } from '@/external/spatial-navigation/utils';
+import { StatsMatchPredictorItem } from '../../view-model/StatsViewModel';
 export interface MatchPredictorProps {
-    predictor: Predictor;
-    teams: EntityMap<Team>;
+    item: StatsMatchPredictorItem;
 }
-declare const _default: {
-    new (props?: (MatchPredictorProps & WithFocusableProps) | undefined, context?: any): {
-        state: import("../../../../external/spatial-navigation/withFocusable").WithFocusableState;
-        navigation: import("../../../../external/spatial-navigation/spatialNavigation").default;
-        getChildContext(): {
-            parentFocusKey: string;
-        };
-        setFocus: (focusKey: string) => void;
-        navigateByDirection: (direction: import("../../../../external/spatial-navigation/utils").Direction, details?: Record<string, any>) => void;
-        stealFocus: () => void;
-        onUpdateFocus: (focused: boolean) => void;
-        onUpdateHasFocusedChild: (hasFocusedChild: boolean) => void;
-        onEnterPressHandler: (details: import("../../../../external/spatial-navigation/utils").Details) => void;
-        onEnterReleaseHandler: () => void;
-        onBackPressHandler: (details: import("../../../../external/spatial-navigation/utils").Details) => void;
-        onArrowPressHandler: (direction: import("../../../../external/spatial-navigation/utils").Direction, details: import("../../../../external/spatial-navigation/utils").Details) => boolean | void;
-        onBecameFocusedHandler: (layout: import("../../../../external/spatial-navigation/utils").Layout, details: import("../../../../external/spatial-navigation/utils").Details) => void;
-        onBecameBlurredHandler: (layout: import("../../../../external/spatial-navigation/utils").Layout, details: import("../../../../external/spatial-navigation/utils").Details) => void;
-        componentDidMount(): void;
-        componentDidUpdate(): void;
-        componentWillUnmount(): void;
-        render(): React.ReactElement<MatchPredictorProps & WithFocusableProps>;
-        setState<K extends keyof import("../../../../external/spatial-navigation/withFocusable").WithFocusableState>(state: import("../../../../external/spatial-navigation/withFocusable").WithFocusableState | ((prevState: Readonly<import("../../../../external/spatial-navigation/withFocusable").WithFocusableState>, props: MatchPredictorProps & WithFocusableProps) => import("../../../../external/spatial-navigation/withFocusable").WithFocusableState | Pick<import("../../../../external/spatial-navigation/withFocusable").WithFocusableState, K>) | Pick<import("../../../../external/spatial-navigation/withFocusable").WithFocusableState, K>, callback?: (() => any) | undefined): void;
-        forceUpdate(callBack?: (() => any) | undefined): void;
-        props: Readonly<{
-            children?: React.ReactNode;
-        }> & Readonly<MatchPredictorProps & WithFocusableProps>;
-        context: any;
-        refs: {
-            [key: string]: React.ReactInstance;
-        };
-        componentWillMount?(): void;
-        componentWillReceiveProps?(nextProps: Readonly<MatchPredictorProps & WithFocusableProps>, nextContext: any): void;
-        shouldComponentUpdate?(nextProps: Readonly<MatchPredictorProps & WithFocusableProps>, nextState: Readonly<import("../../../../external/spatial-navigation/withFocusable").WithFocusableState>, nextContext: any): boolean;
-        componentWillUpdate?(nextProps: Readonly<MatchPredictorProps & WithFocusableProps>, nextState: Readonly<import("../../../../external/spatial-navigation/withFocusable").WithFocusableState>, nextContext: any): void;
+export default class MatchPredictorView extends Component<MatchPredictorProps & WithFocusableProps> {
+    static contextTypes: {
+        refsMap: React.Requireable<any>;
+        setRef: React.Requireable<any>;
+        scrollToFocusedElement: React.Requireable<any>;
     };
-    contextTypes: {
-        parentFocusKey: import("prop-types").Requireable<string>;
-    };
-    childContextTypes: {
-        parentFocusKey: import("prop-types").Requireable<string>;
-    };
-};
-export default _default;
+    context: import("@/components/core/ScrollableContainer/ScrollableContainer").ScrollableContainerContextType;
+    onBecameFocused: (layout: Layout) => void;
+    render(): React.JSX.Element;
+}

package/dist/modules/stats/view/RecentGames/RecentGames.d.ts

@@ -2,23 +2,12 @@
 import { WithFocusableProps } from '@/external/spatial-navigation';
 import React from 'react';
 import './RecentGames.styles.css';
-type PreviousGame = {
-    score: string;
-    gameResult: string;
-    teamLogo: string;
-    homeAway: string;
-};
-type Team = {
-    logo: string;
-    name?: string;
-    events: PreviousGame[];
-};
-export type RecentGamesStatsItem = {
-    awayTeam: Team;
-    homeTeam: Team;
+import { RecentGamesStatsItem } from '../../view-model/StatsViewModel';
+type RecentGamesProps = {
+    item: RecentGamesStatsItem;
 };
 declare const _default: {
-    new (props?: (RecentGamesStatsItem & WithFocusableProps) | undefined, context?: any): {
+    new (props?: (RecentGamesProps & WithFocusableProps) | undefined, context?: any): {
         state: import("../../../../external/spatial-navigation/withFocusable").WithFocusableState;
         navigation: import("../../../../external/spatial-navigation/spatialNavigation").default;
         getChildContext(): {
@@ -38,20 +27,20 @@ declare const _default: {
         componentDidMount(): void;
         componentDidUpdate(): void;
         componentWillUnmount(): void;
-        render(): React.ReactElement<RecentGamesStatsItem & WithFocusableProps>;
-        setState<K extends keyof import("../../../../external/spatial-navigation/withFocusable").WithFocusableState>(state: import("../../../../external/spatial-navigation/withFocusable").WithFocusableState | ((prevState: Readonly<import("../../../../external/spatial-navigation/withFocusable").WithFocusableState>, props: RecentGamesStatsItem & WithFocusableProps) => import("../../../../external/spatial-navigation/withFocusable").WithFocusableState | Pick<import("../../../../external/spatial-navigation/withFocusable").WithFocusableState, K>) | Pick<import("../../../../external/spatial-navigation/withFocusable").WithFocusableState, K>, callback?: (() => any) | undefined): void;
+        render(): React.ReactElement<RecentGamesProps & WithFocusableProps>;
+        setState<K extends keyof import("../../../../external/spatial-navigation/withFocusable").WithFocusableState>(state: import("../../../../external/spatial-navigation/withFocusable").WithFocusableState | ((prevState: Readonly<import("../../../../external/spatial-navigation/withFocusable").WithFocusableState>, props: RecentGamesProps & WithFocusableProps) => import("../../../../external/spatial-navigation/withFocusable").WithFocusableState | Pick<import("../../../../external/spatial-navigation/withFocusable").WithFocusableState, K>) | Pick<import("../../../../external/spatial-navigation/withFocusable").WithFocusableState, K>, callback?: (() => any) | undefined): void;
         forceUpdate(callBack?: (() => any) | undefined): void;
         props: Readonly<{
             children?: React.ReactNode;
-        }> & Readonly<RecentGamesStatsItem & WithFocusableProps>;
+        }> & Readonly<RecentGamesProps & WithFocusableProps>;
         context: any;
         refs: {
             [key: string]: React.ReactInstance;
         };
         componentWillMount?(): void;
-        componentWillReceiveProps?(nextProps: Readonly<RecentGamesStatsItem & WithFocusableProps>, nextContext: any): void;
-        shouldComponentUpdate?(nextProps: Readonly<RecentGamesStatsItem & WithFocusableProps>, nextState: Readonly<import("../../../../external/spatial-navigation/withFocusable").WithFocusableState>, nextContext: any): boolean;
-        componentWillUpdate?(nextProps: Readonly<RecentGamesStatsItem & WithFocusableProps>, nextState: Readonly<import("../../../../external/spatial-navigation/withFocusable").WithFocusableState>, nextContext: any): void;
+        componentWillReceiveProps?(nextProps: Readonly<RecentGamesProps & WithFocusableProps>, nextContext: any): void;
+        shouldComponentUpdate?(nextProps: Readonly<RecentGamesProps & WithFocusableProps>, nextState: Readonly<import("../../../../external/spatial-navigation/withFocusable").WithFocusableState>, nextContext: any): boolean;
+        componentWillUpdate?(nextProps: Readonly<RecentGamesProps & WithFocusableProps>, nextState: Readonly<import("../../../../external/spatial-navigation/withFocusable").WithFocusableState>, nextContext: any): void;
     };
     contextTypes: {
         parentFocusKey: import("prop-types").Requireable<string>;

package/dist/modules/stats/view/StatsItemView.d.ts

@@ -0,0 +1,19 @@
+import React from 'react';
+import { StatsItem } from '../view-model/StatsViewModel';
+import { Direction, Layout } from '@/external/spatial-navigation/utils';
+type Props = {
+    item: StatsItem;
+};
+declare class StatsItemView extends React.Component<Props> {
+    static contextTypes: {
+        refsMap: React.Requireable<any>;
+        setRef: React.Requireable<any>;
+        scrollToFocusedElement: React.Requireable<any>;
+    };
+    context: import("@/components/core/ScrollableContainer/ScrollableContainer").ScrollableContainerContextType;
+    onBecameFocused: (layout: Layout) => void;
+    onArrowPress: (d: Direction) => void;
+    renderItem(): React.JSX.Element | null;
+    render(): React.JSX.Element;
+}
+export default StatsItemView;

package/dist/modules/stats/view/StatsView.d.ts

@@ -1,9 +1,9 @@
 import React, { Component } from 'react';
 import './StatsView.styles.css';
-import { StatsApiResponse } from '../interfaces/IStats';
+import { StatsItem } from '../view-model/StatsViewModel';
 interface StatsViewState {
     container: HTMLDivElement | null;
-    statsData: StatsApiResponse | null;
+    statsItems: StatsItem[];
     isDataLoading: boolean;
 }
 declare class StatsView extends Component<{}, StatsViewState> {
@@ -14,7 +14,7 @@ declare class StatsView extends Component<{}, StatsViewState> {
     constructor(props: {});
     componentDidMount(): void;
     componentWillUnmount(): void;
-    renderStatsComponents: () => React.ReactElement[];
+    renderItems: () => React.JSX.Element[] | null;
     render(): React.JSX.Element;
 }
 export default StatsView;

package/dist/modules/stats/view/TeamStats/TeamStatsView.d.ts

@@ -2,11 +2,9 @@
 import React from 'react';
 import './TeamStatsView.styles.css';
 import { WithFocusableProps } from '@/external/spatial-navigation';
-import { Team, TeamStatistic } from '../../interfaces/IStats';
+import { TeamStatsItem } from '../../view-model/StatsViewModel';
 export interface TeamStatsViewProps {
-    homeTeam: Team;
-    awayTeam: Team;
-    statistics?: TeamStatistic[];
+    item: TeamStatsItem;
 }
 declare const _default: {
     new (props?: (TeamStatsViewProps & WithFocusableProps) | undefined, context?: any): {

package/dist/modules/stats/view/Teams/Teams.d.ts

@@ -2,28 +2,12 @@
 import React from 'react';
 import './TeamsView.styles.css';
 import { WithFocusableProps } from '@/external/spatial-navigation';
-type Team = {
-    color?: string;
-    id: string;
-    logo: string;
-    name?: string;
-    abbreviation: string;
-    record?: string;
-    linescores: string[];
-};
-export type HeaderTeamStatItem = {
-    isLive: boolean;
-    linescoresHeader: string[];
-    statistics?: {
-        displayName: string;
-        homeTeamValue: number;
-        awayTeamValue: number;
-    }[];
-    homeTeam: Team;
-    awayTeam: Team;
+import { HeaderTeamStatItem } from '../../view-model/StatsViewModel';
+type TeamsProps = {
+    item: HeaderTeamStatItem;
 };
 declare const _default: {
-    new (props?: (HeaderTeamStatItem & WithFocusableProps) | undefined, context?: any): {
+    new (props?: (TeamsProps & WithFocusableProps) | undefined, context?: any): {
         state: import("../../../../external/spatial-navigation/withFocusable").WithFocusableState;
         navigation: import("../../../../external/spatial-navigation/spatialNavigation").default;
         getChildContext(): {
@@ -43,20 +27,20 @@ declare const _default: {
         componentDidMount(): void;
         componentDidUpdate(): void;
         componentWillUnmount(): void;
-        render(): React.ReactElement<HeaderTeamStatItem & WithFocusableProps>;
-        setState<K extends keyof import("../../../../external/spatial-navigation/withFocusable").WithFocusableState>(state: import("../../../../external/spatial-navigation/withFocusable").WithFocusableState | ((prevState: Readonly<import("../../../../external/spatial-navigation/withFocusable").WithFocusableState>, props: HeaderTeamStatItem & WithFocusableProps) => import("../../../../external/spatial-navigation/withFocusable").WithFocusableState | Pick<import("../../../../external/spatial-navigation/withFocusable").WithFocusableState, K>) | Pick<import("../../../../external/spatial-navigation/withFocusable").WithFocusableState, K>, callback?: (() => any) | undefined): void;
+        render(): React.ReactElement<TeamsProps & WithFocusableProps>;
+        setState<K extends keyof import("../../../../external/spatial-navigation/withFocusable").WithFocusableState>(state: import("../../../../external/spatial-navigation/withFocusable").WithFocusableState | ((prevState: Readonly<import("../../../../external/spatial-navigation/withFocusable").WithFocusableState>, props: TeamsProps & WithFocusableProps) => import("../../../../external/spatial-navigation/withFocusable").WithFocusableState | Pick<import("../../../../external/spatial-navigation/withFocusable").WithFocusableState, K>) | Pick<import("../../../../external/spatial-navigation/withFocusable").WithFocusableState, K>, callback?: (() => any) | undefined): void;
         forceUpdate(callBack?: (() => any) | undefined): void;
         props: Readonly<{
             children?: React.ReactNode;
-        }> & Readonly<HeaderTeamStatItem & WithFocusableProps>;
+        }> & Readonly<TeamsProps & WithFocusableProps>;
         context: any;
         refs: {
             [key: string]: React.ReactInstance;
         };
         componentWillMount?(): void;
-        componentWillReceiveProps?(nextProps: Readonly<HeaderTeamStatItem & WithFocusableProps>, nextContext: any): void;
-        shouldComponentUpdate?(nextProps: Readonly<HeaderTeamStatItem & WithFocusableProps>, nextState: Readonly<import("../../../../external/spatial-navigation/withFocusable").WithFocusableState>, nextContext: any): boolean;
-        componentWillUpdate?(nextProps: Readonly<HeaderTeamStatItem & WithFocusableProps>, nextState: Readonly<import("../../../../external/spatial-navigation/withFocusable").WithFocusableState>, nextContext: any): void;
+        componentWillReceiveProps?(nextProps: Readonly<TeamsProps & WithFocusableProps>, nextContext: any): void;
+        shouldComponentUpdate?(nextProps: Readonly<TeamsProps & WithFocusableProps>, nextState: Readonly<import("../../../../external/spatial-navigation/withFocusable").WithFocusableState>, nextContext: any): boolean;
+        componentWillUpdate?(nextProps: Readonly<TeamsProps & WithFocusableProps>, nextState: Readonly<import("../../../../external/spatial-navigation/withFocusable").WithFocusableState>, nextContext: any): void;
     };
     contextTypes: {
         parentFocusKey: import("prop-types").Requireable<string>;

package/dist/modules/stats/view/WinProbability/WinProbability.d.ts

@@ -2,23 +2,12 @@
 import React from 'react';
 import './WinProbability.styles.css';
 import { WithFocusableProps } from '@/external/spatial-navigation';
-export type WinProbabilityStatsItem = {
-    chartImageUrl: string;
-    awayTeam: {
-        id: string;
-        abbreviation: string;
-        logo: string;
-        winPercentage: string;
-    };
-    homeTeam: {
-        id: string;
-        abbreviation: string;
-        logo: string;
-        winPercentage: string;
-    };
+import { WinProbabilityStatsItem } from '../../view-model/StatsViewModel';
+type WinProbabilityProps = {
+    item: WinProbabilityStatsItem;
 };
 declare const _default: {
-    new (props?: (WinProbabilityStatsItem & WithFocusableProps) | undefined, context?: any): {
+    new (props?: (WinProbabilityProps & WithFocusableProps) | undefined, context?: any): {
         state: import("../../../../external/spatial-navigation/withFocusable").WithFocusableState;
         navigation: import("../../../../external/spatial-navigation/spatialNavigation").default;
         getChildContext(): {
@@ -38,20 +27,20 @@ declare const _default: {
         componentDidMount(): void;
         componentDidUpdate(): void;
         componentWillUnmount(): void;
-        render(): React.ReactElement<WinProbabilityStatsItem & WithFocusableProps>;
-        setState<K extends keyof import("../../../../external/spatial-navigation/withFocusable").WithFocusableState>(state: import("../../../../external/spatial-navigation/withFocusable").WithFocusableState | ((prevState: Readonly<import("../../../../external/spatial-navigation/withFocusable").WithFocusableState>, props: WinProbabilityStatsItem & WithFocusableProps) => import("../../../../external/spatial-navigation/withFocusable").WithFocusableState | Pick<import("../../../../external/spatial-navigation/withFocusable").WithFocusableState, K>) | Pick<import("../../../../external/spatial-navigation/withFocusable").WithFocusableState, K>, callback?: (() => any) | undefined): void;
+        render(): React.ReactElement<WinProbabilityProps & WithFocusableProps>;
+        setState<K extends keyof import("../../../../external/spatial-navigation/withFocusable").WithFocusableState>(state: import("../../../../external/spatial-navigation/withFocusable").WithFocusableState | ((prevState: Readonly<import("../../../../external/spatial-navigation/withFocusable").WithFocusableState>, props: WinProbabilityProps & WithFocusableProps) => import("../../../../external/spatial-navigation/withFocusable").WithFocusableState | Pick<import("../../../../external/spatial-navigation/withFocusable").WithFocusableState, K>) | Pick<import("../../../../external/spatial-navigation/withFocusable").WithFocusableState, K>, callback?: (() => any) | undefined): void;
         forceUpdate(callBack?: (() => any) | undefined): void;
         props: Readonly<{
             children?: React.ReactNode;
-        }> & Readonly<WinProbabilityStatsItem & WithFocusableProps>;
+        }> & Readonly<WinProbabilityProps & WithFocusableProps>;
         context: any;
         refs: {
             [key: string]: React.ReactInstance;
         };
         componentWillMount?(): void;
-        componentWillReceiveProps?(nextProps: Readonly<WinProbabilityStatsItem & WithFocusableProps>, nextContext: any): void;
-        shouldComponentUpdate?(nextProps: Readonly<WinProbabilityStatsItem & WithFocusableProps>, nextState: Readonly<import("../../../../external/spatial-navigation/withFocusable").WithFocusableState>, nextContext: any): boolean;
-        componentWillUpdate?(nextProps: Readonly<WinProbabilityStatsItem & WithFocusableProps>, nextState: Readonly<import("../../../../external/spatial-navigation/withFocusable").WithFocusableState>, nextContext: any): void;
+        componentWillReceiveProps?(nextProps: Readonly<WinProbabilityProps & WithFocusableProps>, nextContext: any): void;
+        shouldComponentUpdate?(nextProps: Readonly<WinProbabilityProps & WithFocusableProps>, nextState: Readonly<import("../../../../external/spatial-navigation/withFocusable").WithFocusableState>, nextContext: any): boolean;
+        componentWillUpdate?(nextProps: Readonly<WinProbabilityProps & WithFocusableProps>, nextState: Readonly<import("../../../../external/spatial-navigation/withFocusable").WithFocusableState>, nextContext: any): void;
     };
     contextTypes: {
         parentFocusKey: import("prop-types").Requireable<string>;

package/dist/modules/stats/view-model/StatsViewModel.d.ts

@@ -1,14 +1,122 @@
 import { Observable } from '../../../helpers/Observable';
 import { ViewModel } from '../../../view-models/ViewModel';
-import { StatsApiResponse } from '../interfaces/IStats';
+import { DrivePlay, Team } from '../interfaces/IStats';
+import { AthletesStatisticsItem } from '../view/components/AthletesStatistics/AthletesStatistics';
+import StatsService from '@/services/StatsService';
+import IMaestroEventDelegate from '@/interfaces/IMaestroEventDelegate';
+declare const STATS_ERROR_STATE: {
+    readonly NONE: "none";
+    readonly TAB_LOAD_FAILURE: "tabLoadFailure";
+};
+export type BetsErrorState = typeof STATS_ERROR_STATE[keyof typeof STATS_ERROR_STATE];
+export type HeaderTeamStatItem = {
+    type: 'headerTeam';
+    isLive: boolean;
+    linescoresHeader: string[];
+    statistics?: {
+        displayName: string;
+        homeTeamValue: number;
+        awayTeamValue: number;
+    }[];
+    homeTeam: Pick<Team, 'color' | 'id' | 'logo' | 'name' | 'abbreviation' | 'record'> & {
+        linescores: string[];
+    };
+    awayTeam: Pick<Team, 'color' | 'id' | 'logo' | 'name' | 'abbreviation' | 'record'> & {
+        linescores: string[];
+    };
+};
+type RecentGamesPreviousGame = {
+    score: string;
+    gameResult: string;
+    teamLogo: string;
+    homeAway: string;
+};
+type RecentGamesTeam = {
+    logo: string;
+    name?: string;
+    events: RecentGamesPreviousGame[];
+};
+export type RecentGamesStatsItem = {
+    type: 'recentGames';
+    awayTeam: RecentGamesTeam;
+    homeTeam: RecentGamesTeam;
+};
+export type WinProbabilityStatsItem = {
+    type: 'winProbability';
+    chartImageUrl: string;
+    awayTeam: Pick<Team, 'id' | 'abbreviation' | 'logo'> & {
+        winPercentage: string;
+    };
+    homeTeam: Pick<Team, 'id' | 'abbreviation' | 'logo'> & {
+        winPercentage: string;
+    };
+};
+export type GameLeadersStatsItem = {
+    type: 'gameLeaders';
+    items: AthletesStatisticsItem[];
+};
+export type ActiveAthletesItem = {
+    type: 'activeAthletes';
+    displayText: string;
+    awayTeam: Pick<Team, 'id' | 'logo' | 'name'>;
+    homeTeam: Pick<Team, 'id' | 'logo' | 'name'>;
+    athletes: AthletesStatisticsItem[];
+};
+export type StatsPromotionItem = {
+    type: 'promotion';
+    title: string;
+    description: string;
+    logo: string;
+    qrCode: string;
+    backgroundImage: string;
+};
+export type StatsMatchPredictorItem = {
+    type: 'matchPredictor';
+    header: string;
+    imageUrl: string;
+    awayTeam: Pick<Team, 'abbreviation' | 'logo' | 'displayName'> & {
+        percentage: number;
+    };
+    homeTeam: Pick<Team, 'abbreviation' | 'logo' | 'displayName'> & {
+        percentage: number;
+    };
+};
+export type TeamStatsItem = {
+    type: 'teamStats';
+    awayTeam: Pick<Team, 'logo' | 'displayName' | 'color' | 'abbreviation'>;
+    homeTeam: Pick<Team, 'logo' | 'displayName' | 'color' | 'abbreviation'>;
+    statistics: {
+        displayName: string;
+        awayTeamDisplayValue: string;
+        homeTeamDisplayValue: string;
+        awayTeamValue: number;
+        homeTeamValue: number;
+    }[];
+};
+export type DriveSummaryItem = {
+    type: 'driveSummary';
+    id: string;
+    team: Pick<Team, 'logo' | 'displayName'>;
+    playsQuantity: string;
+    yards: string;
+    time: string;
+    lastPlayMarquee: string;
+    plays: DrivePlay[];
+};
+export type StatsItem = HeaderTeamStatItem | RecentGamesStatsItem | WinProbabilityStatsItem | GameLeadersStatsItem | ActiveAthletesItem | StatsPromotionItem | StatsMatchPredictorItem | TeamStatsItem | DriveSummaryItem;
 export declare class StatsViewModel extends ViewModel {
-    statsData: Observable<StatsApiResponse | null>;
     isDataLoading: Observable<boolean>;
     hasEverSuccessfullyLoaded: Observable<boolean>;
+    eventId: string;
+    statsItems: Observable<StatsItem[]>;
+    errorState: Observable<BetsErrorState>;
+    statsService: StatsService;
+    private pollingInterval;
     private useMockData;
-    initialized: boolean;
-    constructor(_eventId: string, // TODO: Will be used when implementing real API calls
-    options?: {
+    private pollingTask;
+    private lastResponseHash;
+    constructor(eventId: string, delegate: IMaestroEventDelegate, options?: {
+        pollingInterval?: number;
         useMockData?: boolean;
     });
     /**
@@ -27,5 +135,41 @@ export declare class StatsViewModel extends ViewModel {
      * Fetch mock data for testing
      */
     private fetchMockData;
+    /**
+     * Refresh polling for bet data
+     */
+    refreshPolling(): void;
+    /**
+     * Poll with the correct method based on authentication status
+     */
+    private pollWithInterval;
+    /**
+     * Handle errors that occur during polling
+     */
+    private handlePollingError;
+    /**
+     * Process data received from polling
+     */
+    private processPolledData;
+    private processData;
+    private parseDriveSummary;
+    private parseTeamsStatistics;
+    private parseMatchPredictor;
+    private parsePromotion;
+    private parseHeaderTeams;
+    private parseRecentGames;
+    private parseWinProbability;
+    private parseGameLeaders;
+    private parseActiveAthletes;
+    private getActiveAthletesTeamInfo;
+    /**
+     * Stop polling for bet data
+     */
+    stopPolling(): void;
+}
+declare global {
+    interface String {
+        hashCode(): number;
+    }
 }
 export default StatsViewModel;

package/dist/services/BetsService.d.ts

@@ -1,11 +1,11 @@
-import NetworkManager from './NetworkManager/NetworkManager';
+import { IBetsNetworkManager } from './NetworkManager/types';
 import { IBetsResponse, IPersonalizedBetsResponse } from '../modules/bets/interfaces/IBets';
 import IMaestroEventDelegate from '@/interfaces/IMaestroEventDelegate';
 /**
  * Service for handling bets-related API calls
  */
 declare class BetsService {
-    networkManager: NetworkManager;
+    networkManager: IBetsNetworkManager;
     constructor(delegate: IMaestroEventDelegate);
     /**
      * Get non-personalized bets for an event

package/dist/services/NetworkManager/NetworkManager.d.ts

@@ -30,15 +30,13 @@ export interface NetworkManagerOptions {
     defaultCacheDuration?: number;
 }
 declare class NetworkManager {
-    private static instance;
     private cacheManager;
     private maestroClient;
     private externalClient;
     private environment;
     private pollingTasks;
     private localStorage;
-    private constructor();
-    static getInstance(options?: NetworkManagerOptions, localStorageOverride?: Storage): NetworkManager;
+    constructor(options?: NetworkManagerOptions, localStorageOverride?: Storage);
     /**
      * Sets the working environment (development, staging, production)
      */

package/dist/services/NetworkManager/NetworkManagerFactory.d.ts

@@ -0,0 +1,42 @@
+import NetworkManager, { NetworkManagerOptions } from './NetworkManager';
+import { ServiceType, ServiceNetworkManagerConfig, IStatsNetworkManager, IBetsNetworkManager, IMaestroNetworkManager, NetworkManagerFactoryConfig } from './types';
+/**
+ * Service-specific NetworkManager that includes metadata about its service type
+ */
+declare class ServiceNetworkManager extends NetworkManager {
+    readonly serviceType: ServiceType;
+    readonly externalBaseURL: string;
+    constructor(serviceType: ServiceType, externalBaseURL: string, options?: NetworkManagerOptions, localStorageOverride?: Storage);
+}
+/**
+ * Factory for creating service-specific NetworkManager instances
+ * This replaces the singleton pattern with a factory pattern
+ */
+export declare class NetworkManagerFactory {
+    private static defaultConfig;
+    /**
+     * Configure factory defaults
+     */
+    static configure(config: NetworkManagerFactoryConfig): void;
+    /**
+     * Create a Stats service NetworkManager
+     */
+    static createStatsNetworkManager(externalBaseURL: string, options?: Partial<NetworkManagerOptions>): IStatsNetworkManager;
+    /**
+     * Create a Bets service NetworkManager
+     */
+    static createBetsNetworkManager(externalBaseURL: string, options?: Partial<NetworkManagerOptions>): IBetsNetworkManager;
+    /**
+     * Create a Maestro service NetworkManager
+     */
+    static createMaestroNetworkManager(options?: Partial<NetworkManagerOptions>): IMaestroNetworkManager;
+    /**
+     * Create a NetworkManager for any service type
+     */
+    static createForService(config: ServiceNetworkManagerConfig, options?: Partial<NetworkManagerOptions>): ServiceNetworkManager;
+    /**
+     * Reset factory to defaults (useful for testing)
+     */
+    static reset(): void;
+}
+export default NetworkManagerFactory;

package/dist/services/NetworkManager/types.d.ts

@@ -0,0 +1,77 @@
+import { WorkingEnvironment } from './NetworkManager';
+/**
+ * Service types for different NetworkManager contexts
+ */
+export declare const ServiceType: {
+    readonly STATS: "stats";
+    readonly BETS: "bets";
+    readonly MAESTRO: "maestro";
+};
+export type ServiceType = typeof ServiceType[keyof typeof ServiceType];
+/**
+ * Configuration for creating service-specific NetworkManager instances
+ */
+export interface ServiceNetworkManagerConfig {
+    serviceType: ServiceType;
+    externalBaseURL: string;
+    environment?: WorkingEnvironment;
+    defaultCacheDuration?: number;
+}
+/**
+ * Base interface for all NetworkManager instances
+ */
+export interface IServiceNetworkManager {
+    readonly serviceType: ServiceType;
+    readonly externalBaseURL: string;
+    getEnvironment(): WorkingEnvironment;
+    externalApiRequest<T = any>(options: {
+        endpoint: string;
+        method?: string;
+        params?: Record<string, any>;
+        headers?: Record<string, string>;
+        data?: any;
+        useCache?: boolean;
+        skipResponseBodyDeserialization?: boolean;
+    }): Promise<T>;
+    pollExternalApiRequest<T = any>(options: {
+        endpoint: string;
+        interval: number;
+        method?: string;
+        params?: Record<string, any>;
+        headers?: Record<string, string>;
+        data?: any;
+        onData: (data: T) => void;
+        onError?: (error: Error) => void;
+    }): {
+        stop: () => void;
+    };
+}
+/**
+ * Stats service NetworkManager interface
+ */
+export interface IStatsNetworkManager extends IServiceNetworkManager {
+    serviceType: 'stats';
+}
+/**
+ * Bets service NetworkManager interface
+ */
+export interface IBetsNetworkManager extends IServiceNetworkManager {
+    serviceType: 'bets';
+}
+/**
+ * Maestro service NetworkManager interface
+ */
+export interface IMaestroNetworkManager extends IServiceNetworkManager {
+    serviceType: 'maestro';
+}
+/**
+ * Union type for all service NetworkManager types
+ */
+export type ServiceNetworkManager = IStatsNetworkManager | IBetsNetworkManager | IMaestroNetworkManager;
+/**
+ * Factory configuration for different service types
+ */
+export interface NetworkManagerFactoryConfig {
+    environment?: WorkingEnvironment;
+    defaultCacheDuration?: number;
+}

package/dist/services/StatsService.d.ts

@@ -1,11 +1,11 @@
-import NetworkManager from './NetworkManager/NetworkManager';
+import { IStatsNetworkManager } from './NetworkManager/types';
 import { StatsApiResponse } from '../modules/stats/interfaces/IStats';
 import IMaestroEventDelegate from '@/interfaces/IMaestroEventDelegate';
 /**
  * Service for handling stats-related API calls
  */
 declare class StatsService {
-    networkManager: NetworkManager;
+    networkManager: IStatsNetworkManager;
     constructor(delegate: IMaestroEventDelegate);
     /**
      * Get stats for an event