@maestro_io/maestro-web-sdk 4.0.0 → 4.0.2

package/dist/src/modules/fantasy/view/TournamentBracketCard/TournamentBracketCard.d.ts

@@ -0,0 +1,99 @@
+/// <reference types="prop-types" />
+import { WithFocusableProps } from '@/external/spatial-navigation';
+import React from 'react';
+import './TournamentBracketCard.styles.css';
+import { TournamentBracketCardItem } from '../../types';
+type Props = {
+    item: TournamentBracketCardItem;
+};
+export declare const TournamentBracketCard: (props: Props & WithFocusableProps) => JSX.Element;
+declare const _default: {
+    new (props: (Props & WithFocusableProps) | Readonly<Props & WithFocusableProps>): {
+        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<Props & WithFocusableProps, string | React.JSXElementConstructor<any>>;
+        context: any;
+        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: Readonly<Props & WithFocusableProps>) => import("../../../../external/spatial-navigation/withFocusable").WithFocusableState | Pick<import("../../../../external/spatial-navigation/withFocusable").WithFocusableState, K> | null) | Pick<import("../../../../external/spatial-navigation/withFocusable").WithFocusableState, K> | null, callback?: (() => void) | undefined): void;
+        forceUpdate(callback?: (() => void) | undefined): void;
+        readonly props: Readonly<Props & WithFocusableProps> & Readonly<{
+            children?: React.ReactNode;
+        }>;
+        refs: {
+            [key: string]: React.ReactInstance;
+        };
+        shouldComponentUpdate?(nextProps: Readonly<Props & WithFocusableProps>, nextState: Readonly<import("../../../../external/spatial-navigation/withFocusable").WithFocusableState>, nextContext: any): boolean;
+        componentDidCatch?(error: Error, errorInfo: React.ErrorInfo): void;
+        getSnapshotBeforeUpdate?(prevProps: Readonly<Props & WithFocusableProps>, prevState: Readonly<import("../../../../external/spatial-navigation/withFocusable").WithFocusableState>): any;
+        componentWillMount?(): void;
+        UNSAFE_componentWillMount?(): void;
+        componentWillReceiveProps?(nextProps: Readonly<Props & WithFocusableProps>, nextContext: any): void;
+        UNSAFE_componentWillReceiveProps?(nextProps: Readonly<Props & WithFocusableProps>, nextContext: any): void;
+        componentWillUpdate?(nextProps: Readonly<Props & WithFocusableProps>, nextState: Readonly<import("../../../../external/spatial-navigation/withFocusable").WithFocusableState>, nextContext: any): void;
+        UNSAFE_componentWillUpdate?(nextProps: Readonly<Props & WithFocusableProps>, nextState: Readonly<import("../../../../external/spatial-navigation/withFocusable").WithFocusableState>, nextContext: any): void;
+    };
+    new (props: Props & WithFocusableProps, 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<Props & WithFocusableProps, string | React.JSXElementConstructor<any>>;
+        context: any;
+        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: Readonly<Props & WithFocusableProps>) => import("../../../../external/spatial-navigation/withFocusable").WithFocusableState | Pick<import("../../../../external/spatial-navigation/withFocusable").WithFocusableState, K> | null) | Pick<import("../../../../external/spatial-navigation/withFocusable").WithFocusableState, K> | null, callback?: (() => void) | undefined): void;
+        forceUpdate(callback?: (() => void) | undefined): void;
+        readonly props: Readonly<Props & WithFocusableProps> & Readonly<{
+            children?: React.ReactNode;
+        }>;
+        refs: {
+            [key: string]: React.ReactInstance;
+        };
+        shouldComponentUpdate?(nextProps: Readonly<Props & WithFocusableProps>, nextState: Readonly<import("../../../../external/spatial-navigation/withFocusable").WithFocusableState>, nextContext: any): boolean;
+        componentDidCatch?(error: Error, errorInfo: React.ErrorInfo): void;
+        getSnapshotBeforeUpdate?(prevProps: Readonly<Props & WithFocusableProps>, prevState: Readonly<import("../../../../external/spatial-navigation/withFocusable").WithFocusableState>): any;
+        componentWillMount?(): void;
+        UNSAFE_componentWillMount?(): void;
+        componentWillReceiveProps?(nextProps: Readonly<Props & WithFocusableProps>, nextContext: any): void;
+        UNSAFE_componentWillReceiveProps?(nextProps: Readonly<Props & WithFocusableProps>, nextContext: any): void;
+        componentWillUpdate?(nextProps: Readonly<Props & WithFocusableProps>, nextState: Readonly<import("../../../../external/spatial-navigation/withFocusable").WithFocusableState>, nextContext: any): void;
+        UNSAFE_componentWillUpdate?(nextProps: Readonly<Props & WithFocusableProps>, nextState: Readonly<import("../../../../external/spatial-navigation/withFocusable").WithFocusableState>, nextContext: any): void;
+    };
+    contextTypes: {
+        parentFocusKey: import("prop-types").Requireable<string>;
+    };
+    childContextTypes: {
+        parentFocusKey: import("prop-types").Requireable<string>;
+    };
+    contextType?: React.Context<any> | undefined;
+};
+export default _default;

package/dist/src/modules/fantasy/view/TournamentBracketCard/TournamentBracketCard.js

@@ -0,0 +1,33 @@
+import { withFocusable, } from '@/external/spatial-navigation';
+import React from 'react';
+import './TournamentBracketCard.styles.css';
+import Image from '@/components/atoms/Image';
+export const TournamentBracketCard = (props) => {
+    const { item } = props;
+    // Percentile is stored as 0-100, display as percentage
+    const percentileText = `${item.percentile}%`;
+    return (React.createElement("div", { className: "tournament-bracket-card focus-ring", "data-focused": props.focused, "data-complete": item.isComplete, style: {
+            '--league-color': '#F51824',
+        } },
+        React.createElement("div", { className: "tournament-bracket-card-header" },
+            React.createElement(Image, { src: item.tournamentLogo, width: 64, height: 64, className: "tournament-bracket-card-logo", alt: `${item.tournamentAbbrev} Logo` }),
+            React.createElement("div", { className: "tournament-bracket-card-header-info" },
+                React.createElement("div", { className: "tournament-bracket-card-name-row" },
+                    React.createElement("span", { className: "tournament-bracket-card-entry-name T10 FONT_BOLD" }, item.name),
+                    item.entryStatusIcon && (React.createElement(Image, { src: item.entryStatusIcon, width: 24, height: 24, className: "tournament-bracket-card-status-icon", alt: "Entry Status" }))),
+                React.createElement("div", { className: "tournament-bracket-card-subtitle TEXT_200 T02" }, item.tournamentAbbrev))),
+        React.createElement("div", { className: "tournament-bracket-card-divider" }),
+        React.createElement("div", { className: "tournament-bracket-card-content" },
+            item.finalPick?.primaryLogo && (React.createElement(Image, { src: item.finalPick.primaryLogo, width: 64, height: 64, className: "tournament-bracket-card-team-logo", alt: "Final Pick Team Logo" })),
+            React.createElement("div", { className: "tournament-bracket-card-stats" },
+                React.createElement("div", { className: "tournament-bracket-card-stat" },
+                    React.createElement("div", { className: "tournament-bracket-card-stat-value T20 FONT_BOLD" }, item.rank),
+                    React.createElement("div", { className: "tournament-bracket-card-stat-label TEXT_200 T02" }, "RANK")),
+                React.createElement("div", { className: "tournament-bracket-card-stat" },
+                    React.createElement("div", { className: "tournament-bracket-card-stat-value T20 FONT_BOLD" }, percentileText),
+                    React.createElement("div", { className: "tournament-bracket-card-stat-label TEXT_200 T02" }, "PCT")),
+                React.createElement("div", { className: "tournament-bracket-card-stat" },
+                    React.createElement("div", { className: "tournament-bracket-card-stat-value T20 FONT_BOLD" }, item.score.toLocaleString()),
+                    React.createElement("div", { className: "tournament-bracket-card-stat-label TEXT_200 T02" }, "PTS"))))));
+};
+export default withFocusable()(TournamentBracketCard);

package/dist/src/modules/fantasy/view/TournamentBracketCard/index.d.ts

@@ -0,0 +1,2 @@
+import TournamentBracketCard from './TournamentBracketCard';
+export default TournamentBracketCard;

package/dist/src/modules/fantasy/view/TournamentBracketCard/index.js

@@ -0,0 +1,2 @@
+import TournamentBracketCard from './TournamentBracketCard';
+export default TournamentBracketCard;

package/dist/src/modules/fantasy/view/index.d.ts

@@ -0,0 +1,2 @@
+import FantasyView from './FantasyView';
+export default FantasyView;

package/dist/src/modules/fantasy/view/index.js

@@ -0,0 +1,2 @@
+import FantasyView from './FantasyView';
+export default FantasyView;

package/dist/src/modules/fantasy/view-model/FantasyViewModel.FantasyPolling.d.ts

@@ -0,0 +1,32 @@
+import FantasyService, { FantasyPollingParams } from '@/services/FantasyService';
+import { IFantasyResponse } from '../types';
+export default class FantasyPolling {
+    private polling;
+    private fantasyService;
+    constructor(service: FantasyService);
+    /**
+     * Refresh polling for fantasy data
+     */
+    refresh(params: FantasyPollingParams, callback: (data: IFantasyResponse) => void): Promise<void>;
+    /**
+     * Stop polling for fantasy data
+     */
+    stop(): void;
+    removeLastResponseHash(): void;
+    private start;
+    /**
+     * @description Update polling interval checking either response header or panel config.
+     * Refresh polling if necessary.
+     */
+    private updateInterval;
+    private getResponseHeaderPollingIntervalValue;
+    private getPanelConfigInterval;
+    /**
+     * Process data received from polling
+     */
+    private processPolledData;
+    /**
+     * Handle errors that occur during fantasy polling
+     */
+    private handlePollingError;
+}

package/dist/src/modules/fantasy/view-model/FantasyViewModel.FantasyPolling.js

@@ -0,0 +1,132 @@
+import SDK from '@/index';
+import { captureException } from '@/sentry';
+import { stringHashCode } from '@/helpers/strings';
+const DEFAULT_FANTASY_POLLING_INTERVAL = 60000;
+export default class FantasyPolling {
+    constructor(service) {
+        Object.defineProperty(this, "polling", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: {
+                interval: DEFAULT_FANTASY_POLLING_INTERVAL,
+                task: null,
+                lastResponseHash: null,
+            }
+        });
+        Object.defineProperty(this, "fantasyService", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.fantasyService = service;
+    }
+    /**
+     * Refresh polling for fantasy data
+     */
+    async refresh(params, callback) {
+        // First stop any existing polling
+        this.stop();
+        // Start the poll loop
+        await this.start(params, callback);
+    }
+    /**
+     * Stop polling for fantasy data
+     */
+    stop() {
+        if (this.polling.task) {
+            this.polling.task.stop();
+            this.polling.task = null;
+        }
+    }
+    removeLastResponseHash() {
+        this.polling.lastResponseHash = null;
+    }
+    async start(params, callback) {
+        try {
+            this.polling.task = this.fantasyService.pollFantasy(params, this.polling.interval, (response) => {
+                this.updateInterval(params, response.headers, callback);
+                this.processPolledData(response.data, callback);
+            }, (error) => this.handlePollingError(error, params.swid));
+        }
+        catch (error) {
+            captureException(error, {
+                context: 'FantasyViewModel.pollFantasy',
+            });
+            console.error('[FANTASY] Error setting up fantasy polling:', error);
+        }
+    }
+    /**
+     * @description Update polling interval checking either response header or panel config.
+     * Refresh polling if necessary.
+     */
+    updateInterval(params, headers, callback) {
+        const headerInterval = this.getResponseHeaderPollingIntervalValue(headers);
+        const panelConfigInterval = this.getPanelConfigInterval();
+        const newInterval = headerInterval || panelConfigInterval; // order matters here
+        // Only update if we have a valid new interval and it's different from current
+        if (newInterval && newInterval !== this.polling.interval) {
+            console.log(`[Fantasy] Updating fantasy polling interval from ${this.polling.interval}ms to ${newInterval}ms`);
+            this.polling.interval = newInterval;
+            // Restart polling with the new interval
+            this.refresh(params, callback);
+        }
+    }
+    getResponseHeaderPollingIntervalValue(headers) {
+        const newInterval = headers['polling-interval'];
+        if (!newInterval) {
+            return null;
+        }
+        const parsedInterval = parseInt(newInterval, 10);
+        if (isNaN(parsedInterval) || parsedInterval <= 0) {
+            console.warn(`[Fantasy] Invalid polling interval header received: ${newInterval}.`);
+            return null;
+        }
+        return parsedInterval * 1000; // Convert seconds to milliseconds
+    }
+    getPanelConfigInterval() {
+        const config = SDK.getPageConfig();
+        const panel = config?.panels?.find((p) => p.panel_type === 'espnFantasy');
+        if (!panel) {
+            return null;
+        }
+        const fantasyPollingInterval = panel.renderer?.block_data?.fan_polling_interval;
+        if (!fantasyPollingInterval) {
+            return null;
+        }
+        const parsedInterval = parseInt(fantasyPollingInterval, 10);
+        if (isNaN(parsedInterval) || parsedInterval <= 0) {
+            console.warn(`[FANTASY] Invalid fantasy polling interval from panel config: ${fantasyPollingInterval}.`);
+            return null;
+        }
+        return parsedInterval * 1000; // Convert seconds to milliseconds
+    }
+    /**
+     * Process data received from polling
+     */
+    processPolledData(data, callback) {
+        // Calculate hash for the response to check if it's different from the last one
+        const responseHash = stringHashCode(JSON.stringify(data));
+        // Check if this is the same as the last successful response
+        if (this.polling.lastResponseHash === responseHash) {
+            console.log('[Fantasy] Fantasy Response hash is the same as last successful response - skipping update');
+            return;
+        }
+        this.polling.lastResponseHash = responseHash;
+        callback(data);
+    }
+    /**
+     * Handle errors that occur during fantasy polling
+     */
+    handlePollingError(error, swid) {
+        console.error('[FANTASY] Fantasy polling error:', error);
+        captureException(error, {
+            context: 'FantasyViewModel.pollFantasy',
+            extra: {
+                swid: swid ? `${swid.substring(0, 8)}...` : 'unknown',
+                pollingInterval: this.polling.interval,
+            },
+        });
+    }
+}

package/dist/src/modules/fantasy/view-model/FantasyViewModel.LeagueManagerPolling.d.ts

@@ -0,0 +1,32 @@
+import FantasyService, { LeagueManagerPollingParams } from '@/services/FantasyService';
+import { ILeagueManagerResponse, ILeagueManagerRotoResponse } from '../types';
+export default class LeagueManagerPolling {
+    private polling;
+    private fantasyService;
+    constructor(service: FantasyService);
+    /**
+     * Refresh polling for league manager data
+     */
+    refresh(key: string, params: LeagueManagerPollingParams, callback: (data: ILeagueManagerResponse | ILeagueManagerRotoResponse) => void): void;
+    /**
+     * Stop polling for fantasy data
+     */
+    stop(key: string): void;
+    private start;
+    /**
+     * Process data received from polling
+     */
+    private processPolledData;
+    /**
+     * @description Update polling interval checking either response header or panel config.
+     * Refresh polling if necessary.
+     */
+    private updateInterval;
+    private getResponseHeaderPollingIntervalValue;
+    private getPanelConfigInterval;
+    stopAll(): void;
+    /**
+     * Handle errors that occur during league manager polling
+     */
+    private handlePollingError;
+}

package/dist/src/modules/fantasy/view-model/FantasyViewModel.LeagueManagerPolling.js

@@ -0,0 +1,141 @@
+import SDK from '@/index';
+import { captureException } from '@/sentry';
+import { stringHashCode } from '@/helpers/strings';
+const DEFAULT_LEAGUE_MANAGER_POLLING_INTERVAL = 60000;
+export default class LeagueManagerPolling {
+    constructor(service) {
+        Object.defineProperty(this, "polling", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: {}
+        });
+        Object.defineProperty(this, "fantasyService", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.fantasyService = service;
+    }
+    /**
+     * Refresh polling for league manager data
+     */
+    refresh(key, params, callback) {
+        // First stop any existing polling
+        this.stop(key);
+        // Initialize polling state if it doesn't exist
+        if (!this.polling[key]) {
+            this.polling[key] = {
+                interval: DEFAULT_LEAGUE_MANAGER_POLLING_INTERVAL,
+                lastResponseHash: null,
+                task: null,
+            };
+        }
+        // Start the poll loop
+        this.start(key, params, callback);
+    }
+    /**
+     * Stop polling for fantasy data
+     */
+    stop(key) {
+        if (this.polling[key]?.task) {
+            this.polling[key]?.task?.stop?.();
+            this.polling[key].task = null;
+        }
+    }
+    start(key, params, callback) {
+        try {
+            this.polling[key].task = this.fantasyService.pollLeagueManager(params, this.polling[key].interval, (response) => {
+                this.updateInterval(key, params, callback, response.headers);
+                this.processPolledData(key, response.data, callback);
+            }, (error) => this.handlePollingError(error, key, params));
+        }
+        catch (error) {
+            captureException(error, {
+                context: 'FantasyViewModel.pollLeagueManager',
+            });
+            console.error('[FANTASY] Error setting up league manager polling:', error);
+        }
+    }
+    /**
+     * Process data received from polling
+     */
+    processPolledData(key, data, callback) {
+        // Calculate hash for the response to check if it's different from the last one
+        const responseHash = stringHashCode(JSON.stringify(data));
+        // Check if this is the same as the last successful response
+        if (this.polling[key].lastResponseHash === responseHash) {
+            console.log('[Fantasy] League manager Response hash is the same as last successful response - skipping update');
+            return;
+        }
+        this.polling[key].lastResponseHash = responseHash;
+        callback(data);
+    }
+    /**
+     * @description Update polling interval checking either response header or panel config.
+     * Refresh polling if necessary.
+     */
+    updateInterval(key, params, callback, headers) {
+        const headerInterval = this.getResponseHeaderPollingIntervalValue(headers);
+        const panelConfigInterval = this.getPanelConfigInterval();
+        const newInterval = headerInterval || panelConfigInterval; // order matters here
+        // Only update if we have a valid new interval and it's different from current
+        if (newInterval && newInterval !== this.polling[key]?.interval) {
+            console.log(`[Fantasy] Updating league manager polling interval from ${this.polling[key]?.interval}ms to ${newInterval}ms`);
+            this.polling[key].interval = newInterval;
+            // Restart polling with the new interval
+            this.refresh(key, params, callback);
+        }
+    }
+    getResponseHeaderPollingIntervalValue(headers) {
+        const newInterval = headers['polling-interval'];
+        if (!newInterval) {
+            return null;
+        }
+        const parsedInterval = parseInt(newInterval, 10);
+        if (isNaN(parsedInterval) || parsedInterval <= 0) {
+            console.warn(`[Fantasy] Invalid polling interval header received: ${newInterval}.`);
+            return null;
+        }
+        return parsedInterval * 1000; // Convert seconds to milliseconds
+    }
+    getPanelConfigInterval() {
+        const config = SDK.getPageConfig();
+        const panel = config?.panels?.find((p) => p.panel_type === 'espnFantasy');
+        if (!panel) {
+            return null;
+        }
+        const fantasyPollingInterval = panel.renderer?.block_data?.lm_polling_interval;
+        if (!fantasyPollingInterval) {
+            return null;
+        }
+        const parsedInterval = parseInt(fantasyPollingInterval, 10);
+        if (isNaN(parsedInterval) || parsedInterval <= 0) {
+            console.warn(`[FANTASY] Invalid league manager polling interval from panel config: ${fantasyPollingInterval}.`);
+            return null;
+        }
+        return parsedInterval * 1000; // Convert seconds to milliseconds
+    }
+    stopAll() {
+        Object.keys(this.polling).forEach((key) => {
+            this.stop(key);
+        });
+        this.polling = {};
+    }
+    /**
+     * Handle errors that occur during league manager polling
+     */
+    handlePollingError(error, key, params) {
+        console.error('[FANTASY] League manager polling error:', error);
+        captureException(error, {
+            context: 'FantasyViewModel.pollLeagueManager',
+            extra: {
+                key,
+                leagueId: params?.leagueId,
+                game: params?.game,
+                pollingInterval: this.polling[key]?.interval,
+            },
+        });
+    }
+}

package/dist/src/modules/fantasy/view-model/FantasyViewModel.d.ts

@@ -0,0 +1,148 @@
+import { Observable } from '@/helpers/Observable';
+import IMaestroEventDelegate from '@/interfaces/IMaestroEventDelegate';
+type NotLoggedInFantasyItem = {
+    id: string;
+    type: 'notLoggedIn';
+};
+export type PromoFantasyItem = {
+    id: string;
+    type: 'promo';
+    background: string;
+    logo: string;
+    title: string;
+    qrCode: string;
+    description: string;
+};
+export type InactiveLeague = {
+    id: string;
+    type: 'inactiveLeague';
+    leagueName: string;
+    draftDate?: number;
+    leagueLogo: string;
+    leagueColor: string;
+};
+type MatchupSingleTeam = {
+    points: number;
+    logo: string;
+    scoringType: string;
+};
+export type MatchupSingleRoster = {
+    athleteHeadshot: string;
+    athleteAbbrevName: string;
+    athletesSlot: string;
+    teamTriCode: string;
+    proGameStatusLines: string[];
+};
+export type MatchupActiveAthlete = {
+    abbrevName: string;
+    points: string;
+};
+export type MatchupSingleItem = {
+    id: string;
+    type: 'matchup-single';
+    league: {
+        title: string;
+        subtitle: string | undefined;
+        color: string;
+        logo: string;
+    };
+    team: MatchupSingleTeam;
+    roster: MatchupSingleRoster[];
+    activeAthletes: MatchupActiveAthlete[];
+    topPlayers: TopPlayer[];
+};
+export type TopPlayer = {
+    abbrevName: string;
+    headshot: string;
+    position: string;
+    teamTriCode: string;
+    points: number;
+    rosteredBy: string;
+};
+type MatchupPairTeam = {
+    name: string | undefined;
+    record: string | undefined;
+    points: string | undefined;
+    projectedPoints: string | undefined;
+    logo: string | undefined;
+    winProbability: number | undefined;
+};
+type MatchupPairRosterData = {
+    headshot: string;
+    abbrevName: string;
+    slot: string;
+    triCode: string;
+    points?: number;
+    projectedPoints?: number;
+    stats: string[];
+};
+export type MatchupPairRoster = {
+    away: MatchupPairRosterData;
+    home: MatchupPairRosterData;
+};
+export type MatchupPairItem = {
+    id: string;
+    type: 'matchup-pair';
+    league: {
+        title: string | undefined;
+        subtitle: string | undefined;
+        color: string;
+        logo: string;
+    };
+    awayTeam: MatchupPairTeam;
+    homeTeam: MatchupPairTeam;
+    roster: MatchupPairRoster[];
+    activeAthletes: MatchupActiveAthlete[];
+    topPlayers: TopPlayer[];
+};
+export type FantasyItem = NotLoggedInFantasyItem | MatchupPairItem | MatchupSingleItem | InactiveLeague | PromoFantasyItem;
+declare const FANTASY_ERROR_STATE: {
+    readonly NONE: "none";
+    readonly TAB_LOAD_FAILURE: "tabLoadFailure";
+};
+export type FantasyErrorState = typeof FANTASY_ERROR_STATE[keyof typeof FANTASY_ERROR_STATE];
+export declare class FantasyViewModel {
+    fantasyItems: Observable<FantasyItem[]>;
+    isDataLoading: Observable<boolean>;
+    hasEverSuccessfullyLoaded: Observable<boolean>;
+    private eventId;
+    private delegate;
+    private analyticsService;
+    private fantasyService;
+    private fantasyPolling;
+    private leagueManagerPolling;
+    errorState: Observable<FantasyErrorState>;
+    private leagueSortOrder;
+    private itemToLeagueKey;
+    private useMockData;
+    constructor(eventId: string, delegate: IMaestroEventDelegate, options?: {
+        useMockData?: boolean;
+    });
+    /**
+     * Initialize the ViewModel and start data fetching
+     */
+    init(): Promise<void>;
+    private fetchData;
+    onEngage(type: FantasyItem['type']): void;
+    onAskLogin(): void;
+    /**
+     * Clean up resources when the ViewModel is no longer needed
+     */
+    cleanup(): void;
+    /**
+     * Track panel view event
+     */
+    private trackPanelView;
+    private processFantasy;
+    private parseRoto;
+    append(item: FantasyItem | null, leagueKey?: string): void;
+    private parseHeadToHead;
+    private parseTopPlayers;
+    private parseInactiveLeague;
+    /**
+     * Fetch mock data for testing
+     */
+    private fetchMockData;
+    clearTabLoadFailure(): void;
+}
+export default FantasyViewModel;