@maestro_io/maestro-web-sdk 2.0.2 → 2.1.0

package/dist/modules/bets/view/components/PromoCodeBanner/PromoCodeBanner.d.ts

@@ -0,0 +1,22 @@
+import React from 'react';
+import './PromoCodeBanner.styles.css';
+import { WithFocusableProps } from '@/external/spatial-navigation';
+import { Details, Direction, Layout } from '@/external/spatial-navigation/utils';
+export interface PromoCodeBannerProps extends WithFocusableProps {
+    title: string;
+    description: string;
+    logo: string;
+    qrCode: string;
+    showLogo?: boolean;
+}
+export default class FocusablePromoCodeBannerWrapper extends React.Component<PromoCodeBannerProps> {
+    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, _props: any, details: Details) => void;
+    render(): React.JSX.Element;
+}

package/dist/modules/bets/view/components/PromoCodeBanner/index.d.ts

@@ -0,0 +1,2 @@
+export { default as BetItemPromoCode } from './PromoCodeBanner';
+export type { PromoCodeBannerProps } from './PromoCodeBanner';

package/dist/modules/bets/view-model/BetsViewModel.d.ts

@@ -0,0 +1,179 @@
+import { Observable } from '../../../helpers/Observable';
+import { ITeam, IUserBet, IBetLeg } from '../interfaces/IBets';
+import { ViewModel } from '../../../view-models/ViewModel';
+import { TestUseCase } from '@/interfaces/IMaestroEvent';
+import IMaestroEventDelegate from '@/interfaces/IMaestroEventDelegate';
+declare const BET_ITEM_TYPE: {
+    readonly ODDS: "odds";
+    readonly USER_BETS: "userBets";
+    readonly PROMO: "promo";
+    readonly HOT_PROPS: "hotProps";
+    readonly LOCATION_DISCLAIMER: "locationDisclaimer";
+    readonly GAMBLING_MESSAGE: "gamblingMessage";
+};
+export type BetItemType = typeof BET_ITEM_TYPE[keyof typeof BET_ITEM_TYPE];
+type TeamOdd = {
+    teamAbbreviation: string;
+    startOfGameFirstLine: string;
+    startOfGameSecondLine: string;
+    gameSpreadFirstLine: string;
+    gameSpreadSecondLine: string;
+    totalPointsFirstLine: string;
+    totalPointsSecondLine: string;
+    moneylineFirstLine: string;
+};
+export type ISixPackOdds = {
+    awayTeamOdds: TeamOdd;
+    homeTeamOdds: TeamOdd;
+    gameState: string;
+    sport: string;
+};
+export type IUserBets = {
+    defaultTab: string;
+    bets: {
+        live: IUserBet[];
+        upcoming: IUserBet[];
+        settled: IUserBet[];
+    };
+};
+export type IHotProps = {
+    items: IBetLeg[];
+};
+export type ILocationDisclaimer = {
+    text: string;
+};
+export type IGamblingMessage = {
+    text: string;
+};
+export type IBetPromo = {
+    title: string;
+    description: string;
+    logo: string;
+    qrCode: string;
+};
+export type PromoBetItem = {
+    id: string;
+    type: 'promo';
+    data: IBetPromo;
+};
+export type LocationDisclaimerBetItem = {
+    type: 'locationDisclaimer';
+    id: string;
+    data: ILocationDisclaimer;
+};
+export type GamblingMessageBetItem = {
+    type: 'gamblingMessage';
+    id: string;
+    data: IGamblingMessage;
+};
+export type SixPackBetItem = {
+    type: 'sixPack';
+    data: ISixPackOdds;
+    teamInfo?: {
+        home: ITeam;
+        away: ITeam;
+    };
+    id: string;
+};
+export type UserBetsBetItem = {
+    type: 'userBets';
+    data: IUserBets;
+    id: string;
+};
+export type HotPropsBetItem = {
+    type: 'hotProps';
+    data: IHotProps;
+    id: string;
+};
+export type BetItem = SixPackBetItem | UserBetsBetItem | PromoBetItem | HotPropsBetItem | LocationDisclaimerBetItem | GamblingMessageBetItem;
+declare const BET_ERROR_STATE: {
+    readonly NONE: "none";
+    readonly TAB_LOAD_FAILURE: "tabLoadFailure";
+};
+export type BetsErrorState = typeof BET_ERROR_STATE[keyof typeof BET_ERROR_STATE];
+export interface IBetsViewModelDelegate {
+    userIsAuthenticated(): Promise<boolean>;
+    getUserSWID(): Promise<string | null>;
+    getUserToken(): Promise<string | null>;
+}
+export declare class BetsViewModel extends ViewModel {
+    betsItems: Observable<BetItem[]>;
+    isDataLoading: Observable<boolean>;
+    errorState: Observable<BetsErrorState>;
+    hasEverSuccessfullyLoaded: Observable<boolean>;
+    private eventId;
+    private delegate;
+    private betsService;
+    private pollingInterval;
+    private pollingTask;
+    private lastNonPersonalizedResponseHash;
+    private lastPersonalizedResponseHash;
+    private useMockData;
+    initialized: boolean;
+    constructor(eventId: string, delegate: IMaestroEventDelegate, options?: {
+        pollingInterval?: number;
+        useMockData?: boolean;
+    });
+    /**
+     * Initialize the ViewModel and start data fetching
+     */
+    init(): Promise<void>;
+    /**
+     * Clean up resources when the ViewModel is no longer needed
+     */
+    cleanup(): void;
+    /**
+     * Refresh polling for bet data
+     */
+    refreshPolling(): void;
+    /**
+     * Poll with the correct method based on authentication status
+     */
+    private pollWithInterval;
+    /**
+     * Process data received from polling
+     */
+    private processPolledData;
+    /**
+     * Process the bets data and update the betsItems
+     */
+    private processBetsData;
+    private processLocationDisclaimer;
+    private processPromoCode;
+    private processGamblingMessage;
+    private processSixPackData;
+    private processUserBetsData;
+    private processHotProps;
+    /**
+     * Handle errors that occur during polling
+     */
+    private handlePollingError;
+    /**
+     * Stop polling for bet data
+     */
+    stopPolling(): void;
+    /**
+     * Fetch new bet data immediately (one-time)
+     */
+    fetchNewData(): Promise<void>;
+    /**
+     * Fetch personalized bet data
+     */
+    private fetchPersonalizedData;
+    /**
+     * Fetch non-personalized bet data
+     */
+    private fetchNonPersonalizedData;
+    /**
+     * Fetch mock data for testing
+     */
+    private fetchMockData;
+    simulateUseCase<T = any>(useCase: TestUseCase, _: T): void;
+    clearTabLoadFailure(): void;
+}
+declare global {
+    interface String {
+        hashCode(): number;
+    }
+}
+export default BetsViewModel;

package/dist/modules/key-plays/view/KeyPlayCardView.d.ts

@@ -1,115 +1,41 @@
-/// <reference types="prop-types" />
-import IKeyPlay from '../interfaces/IKeyPlays';
+import IKeyPlay, { KeyPlayLoadFailureStatus } from '../interfaces/IKeyPlays';
 import './KeyPlayCardView.styles.css';
 import React from 'react';
 import { WithFocusableProps } from '@/external/spatial-navigation';
-import { RemoteControlProps } from '@/helpers/withRemoteControl';
+import { Direction, Layout } from '@/external/spatial-navigation/utils';
 type KeyPlayCardViewProps = IKeyPlay & {
     isPlaying: boolean;
     playbackProgress: number | null;
     isScoring: boolean;
-    setFocus?: (focusKey: string) => void;
-    focused?: boolean;
     setRef: (ref: HTMLDivElement | null) => void;
 };
-export declare class KeyPlayCard extends React.Component<KeyPlayCardViewProps & WithFocusableProps & RemoteControlProps> {
+type KeyPlaysCardViewState = {
+    failedClip: KeyPlayLoadFailureStatus | null;
+};
+export declare class KeyPlayCardView extends React.Component<KeyPlayCardViewProps & WithFocusableProps, KeyPlaysCardViewState> {
+    private failedClipListener;
     private ref;
-    setRef: (ref: HTMLDivElement | null) => void;
-    handleLeftPressed: () => void;
+    private vm;
+    state: {
+        failedClip: null;
+    };
+    constructor(props: KeyPlayCardViewProps);
+    componentDidMount(): void;
+    componentWillUnmount(): void;
+    renderImage: () => React.JSX.Element;
     render(): React.JSX.Element;
 }
-declare const _default: {
-    new (props?: (IKeyPlay & {
-        isPlaying: boolean;
-        playbackProgress: number | null;
-        isScoring: boolean;
-        setFocus?: ((focusKey: string) => void) | undefined;
-        focused?: boolean | undefined;
-        setRef: (ref: HTMLDivElement | null) => void;
-    } & WithFocusableProps & RemoteControlProps) | undefined, context?: any): {
-        state: import("../../../external/spatial-navigation/withFocusable").WithFocusableState;
-        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: {
-            pressedKeys: Record<string, number>;
-        }) => void;
-        onEnterReleaseHandler: () => void;
-        onArrowPressHandler: (direction: import("../../../external/spatial-navigation/utils").Direction, details: {
-            pressedKeys: Record<string, number>;
-        }) => boolean | void;
-        onBecameFocusedHandler: (layout: import("../../../external/spatial-navigation/utils").Layout, details: any) => void;
-        onBecameBlurredHandler: (layout: import("../../../external/spatial-navigation/utils").Layout, details: any) => void;
-        componentDidMount(): void;
-        componentDidUpdate(): void;
-        componentWillUnmount(): void;
-        render(): React.ReactElement<IKeyPlay & {
-            isPlaying: boolean;
-            playbackProgress: number | null;
-            isScoring: boolean;
-            setFocus?: ((focusKey: string) => void) | undefined;
-            focused?: boolean | undefined;
-            setRef: (ref: HTMLDivElement | null) => void;
-        } & WithFocusableProps & RemoteControlProps>;
-        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: IKeyPlay & {
-            isPlaying: boolean;
-            playbackProgress: number | null;
-            isScoring: boolean;
-            setFocus?: ((focusKey: string) => void) | undefined;
-            focused?: boolean | undefined;
-            setRef: (ref: HTMLDivElement | null) => void;
-        } & WithFocusableProps & RemoteControlProps) => 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<IKeyPlay & {
-            isPlaying: boolean;
-            playbackProgress: number | null;
-            isScoring: boolean;
-            setFocus?: ((focusKey: string) => void) | undefined;
-            focused?: boolean | undefined;
-            setRef: (ref: HTMLDivElement | null) => void;
-        } & WithFocusableProps & RemoteControlProps>;
-        context: any;
-        refs: {
-            [key: string]: React.ReactInstance;
-        };
-        componentWillMount?(): void;
-        componentWillReceiveProps?(nextProps: Readonly<IKeyPlay & {
-            isPlaying: boolean;
-            playbackProgress: number | null;
-            isScoring: boolean;
-            setFocus?: ((focusKey: string) => void) | undefined;
-            focused?: boolean | undefined;
-            setRef: (ref: HTMLDivElement | null) => void;
-        } & WithFocusableProps & RemoteControlProps>, nextContext: any): void;
-        shouldComponentUpdate?(nextProps: Readonly<IKeyPlay & {
-            isPlaying: boolean;
-            playbackProgress: number | null;
-            isScoring: boolean;
-            setFocus?: ((focusKey: string) => void) | undefined;
-            focused?: boolean | undefined;
-            setRef: (ref: HTMLDivElement | null) => void;
-        } & WithFocusableProps & RemoteControlProps>, nextState: Readonly<import("../../../external/spatial-navigation/withFocusable").WithFocusableState>, nextContext: any): boolean;
-        componentWillUpdate?(nextProps: Readonly<IKeyPlay & {
-            isPlaying: boolean;
-            playbackProgress: number | null;
-            isScoring: boolean;
-            setFocus?: ((focusKey: string) => void) | undefined;
-            focused?: boolean | undefined;
-            setRef: (ref: HTMLDivElement | null) => void;
-        } & WithFocusableProps & RemoteControlProps>, 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>;
+export default class KeyPlayCard extends React.Component<Omit<KeyPlayCardViewProps, 'setRef'> & WithFocusableProps> {
+    private ref;
+    context: import("@/components/core/ScrollableContainer/ScrollableContainer").ScrollableContainerContextType;
+    static contextTypes: {
+        refsMap: React.Requireable<any>;
+        setRef: React.Requireable<any>;
+        scrollToFocusedElement: React.Requireable<any>;
     };
-};
-export default _default;
+    setRef: (ref: HTMLDivElement | null) => void;
+    handleLeftPressed: (d: Direction) => void;
+    onBecameFocused: (layout: Layout) => void;
+    render(): React.JSX.Element;
+}
+export {};

package/dist/modules/key-plays/view/KeyPlaysView.d.ts

@@ -18,14 +18,13 @@ interface IKeyPlaySection {
     items: IKeyPlayItem[];
 }
 interface IKeyPlaysState {
-    scrolled: boolean;
     playbackProgress: number | null;
     playbackIndex: number | null;
     items: IKeyPlaySection[];
+    scrollableContainer: HTMLDivElement | null;
 }
 export declare class KeyPlays extends Component<{}, IKeyPlaysState> {
     private container;
-    private refsMap;
     private playbackProgressUnsub;
     private playbackIndexUnsub;
     private itemsUnsub;
@@ -34,8 +33,6 @@ export declare class KeyPlays extends Component<{}, IKeyPlaysState> {
     componentDidMount(): void;
     componentWillUnmount(): void;
     private handlePlayClip;
-    private handleItemFocus;
-    private setRef;
     render(): React.JSX.Element;
 }
 interface KeyPlaysWithErrorStateState {

package/dist/services/BetsService.d.ts

@@ -0,0 +1,61 @@
+import NetworkManager from './NetworkManager/NetworkManager';
+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;
+    constructor(delegate: IMaestroEventDelegate);
+    /**
+     * Get non-personalized bets for an event
+     *
+     * @param eventID - The ID of the event
+     * @returns Promise with the bets data
+     */
+    getNonPersonalizedBets(eventID: string): Promise<IBetsResponse>;
+    /**
+     * Get personalized bets for an event
+     *
+     * @param eventID - The ID of the event
+     * @param swid - The ESPN SWID parameter
+     * @param jwt - The authorization JWT
+     * @returns Promise with the personalized bets data
+     */
+    getPersonalizedBets(eventID: string, swid: string, jwt: string): Promise<IPersonalizedBetsResponse>;
+    /**
+     * Start polling for non-personalized bets
+     *
+     * @param eventID - The ID of the event
+     * @param interval - The polling interval in milliseconds
+     * @param onData - Callback for successful data fetch
+     * @param onError - Callback for errors
+     * @returns Object with a stop function to stop polling
+     */
+    pollNonPersonalizedBets(eventID: string, interval: number, onData: (data: IBetsResponse) => void, onError?: (error: Error) => void): {
+        stop: () => void;
+    };
+    /**
+     * Start polling for personalized bets
+     *
+     * @param eventID - The ID of the event
+     * @param swid - The ESPN SWID parameter
+     * @param jwt - The authorization JWT
+     * @param interval - The polling interval in milliseconds
+     * @param onData - Callback for successful data fetch
+     * @param onError - Callback for errors
+     * @returns Object with a stop function to stop polling
+     */
+    pollPersonalizedBets(eventID: string, swid: string, jwt: string, interval: number, onData: (data: IPersonalizedBetsResponse) => void, onError?: (error: Error) => void): {
+        stop: () => void;
+    };
+    /**
+     * Get the endpoint for non-personalized bets
+     */
+    nonPersonalizedBetsEndpoint(eventID: string): string;
+    /**
+     * Get the endpoint for personalized bets
+     */
+    personalizedBetsEndpoint(eventID: string): string;
+}
+export default BetsService;

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

@@ -0,0 +1,131 @@
+import { ICacheManager } from '../../external/ports/cacheManager';
+import { INetworkClient } from '../../external/ports/networkClient';
+export declare const WorkingEnvironment: {
+    readonly DEVELOPMENT: "development";
+    readonly STAGING: "staging";
+    readonly PRODUCTION: "production";
+};
+export type WorkingEnvironment = typeof WorkingEnvironment[keyof typeof WorkingEnvironment];
+export declare const MAESTRO_BASE_URLS: Record<WorkingEnvironment, string>;
+export declare const SDK_FLAVOR = "MaestroKit_Web";
+export declare const ENDPOINTS: {
+    CAN_I_PLAY: string;
+    STREAM: string;
+    USER_PROFILE: string;
+    ACTIVE_USER: string;
+};
+export declare const HttpMethod: {
+    readonly GET: "GET";
+    readonly POST: "POST";
+    readonly PUT: "PUT";
+    readonly DELETE: "DELETE";
+};
+export type HttpMethod = typeof HttpMethod[keyof typeof HttpMethod];
+export interface NetworkManagerOptions {
+    environment?: WorkingEnvironment;
+    networkClient?: INetworkClient;
+    externalNetworkClient?: INetworkClient;
+    externalBaseURL?: string;
+    cacheManager?: ICacheManager;
+    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;
+    /**
+     * Sets the working environment (development, staging, production)
+     */
+    setEnvironment(environment: WorkingEnvironment): void;
+    /**
+     * Get current environment
+     */
+    getEnvironment(): WorkingEnvironment;
+    /**
+     * Set authentication for Maestro APIs
+     */
+    setAuthentication(token: string | null, apiKey: string | null): void;
+    /**
+     * Handle errors from network requests
+     */
+    private handleError;
+    /**
+     * Make a request to the Maestro API
+     */
+    maestroApiRequest<T = any>({ endpoint, method, params, data, headers, useCache, maestroDefaultHeaders, skipResponseBodyDeserialization, }: {
+        endpoint: string;
+        method?: HttpMethod;
+        params?: Record<string, any>;
+        data?: any;
+        headers?: Record<string, string>;
+        useCache?: boolean;
+        maestroDefaultHeaders?: {
+            siteId: string;
+            jwt: string;
+        } | null;
+        skipResponseBodyDeserialization?: boolean;
+    }): Promise<T>;
+    /**
+     * Make a request to an external API
+     */
+    externalApiRequest<T = any>({ endpoint, method, params, data, headers, useCache, skipResponseBodyDeserialization, }: {
+        endpoint: string;
+        method?: HttpMethod;
+        params?: Record<string, any>;
+        data?: any;
+        headers?: Record<string, string>;
+        useCache?: boolean;
+        skipResponseBodyDeserialization?: boolean;
+    }): Promise<T>;
+    /**
+     * Start polling a Maestro API endpoint at specified interval
+     */
+    pollMaestroApiRequest<T = any>({ endpoint, interval, method, params, data, headers, maestroDefaultHeaders, skipResponseBodyDeserialization, onData, onError, }: {
+        endpoint: string;
+        interval: number;
+        method?: HttpMethod;
+        params?: Record<string, any>;
+        data?: any;
+        headers?: Record<string, string>;
+        maestroDefaultHeaders?: {
+            siteId: string;
+            jwt: string;
+        } | null;
+        skipResponseBodyDeserialization?: boolean;
+        onData: (data: T) => void;
+        onError?: (error: Error) => void;
+    }): {
+        stop: () => void;
+    };
+    /**
+     * Start polling an external API endpoint at specified interval
+     */
+    pollExternalApiRequest<T = any>({ endpoint, interval, method, params, data, headers, skipResponseBodyDeserialization, onData, onError, }: {
+        endpoint: string;
+        interval: number;
+        method?: HttpMethod;
+        params?: Record<string, any>;
+        data?: any;
+        headers?: Record<string, string>;
+        skipResponseBodyDeserialization?: boolean;
+        onData: (data: T) => void;
+        onError?: (error: Error) => void;
+    }): {
+        stop: () => void;
+    };
+    /**
+     * Stop all polling tasks
+     */
+    stopAllPolling(): void;
+    /**
+     * Clear all cached data
+     */
+    clearAllCache(): void;
+}
+export default NetworkManager;

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

@@ -0,0 +1,17 @@
+export declare class NetworkError extends Error {
+    constructor(message: string);
+}
+export declare class AuthError extends Error {
+    constructor(message: string);
+}
+export declare class NotFoundError extends Error {
+    constructor(message: string);
+}
+export declare class ServerError extends Error {
+    statusCode: number;
+    constructor(statusCode: number, message: string);
+}
+export declare class BadRequestError extends Error {
+    statusCode: number;
+    constructor(statusCode: number, message: string);
+}

package/dist/types/OverlayTypes.d.ts

@@ -0,0 +1,43 @@
+import { WinningBet } from '../models/IWinningBet';
+export declare const OverlayType: {
+    readonly WinningBet: "winningBet";
+    readonly FantasyPlayerEvent: "fantasyPlayerEvent";
+};
+export type OverlayType = typeof OverlayType[keyof typeof OverlayType];
+export interface IOverlayPosition {
+    top?: number;
+    left?: number;
+    right?: number;
+    bottom?: number;
+}
+export interface IOverlaySize {
+    width: number;
+    height: number;
+}
+export interface IFantasyPayload {
+    athleteId: string;
+    title: string;
+    metadata: string;
+    headline: string;
+    description: string;
+    image?: string;
+    sportsType: string;
+}
+export interface IMaestroOverlayEvent {
+    type: OverlayType;
+    size: IOverlaySize;
+    position: IOverlayPosition;
+    winningBet?: WinningBet;
+    fantasy?: IFantasyPayload;
+}
+export interface IOverlayAnalyticsEvent {
+    eventName: 'overlayViewed' | 'overlayClicked';
+    attributes: {
+        template: string;
+        templateId?: string;
+        instanceName: string;
+        instanceId: string;
+        fullscreen?: boolean;
+        overlayType: string;
+    };
+}

package/dist/view-models/MaestroEventViewModel.d.ts

@@ -1,9 +1,11 @@
 import IMaestroEventDelegate from '../interfaces/IMaestroEventDelegate';
-import IMaestroEvent from '../interfaces/IMaestroEvent';
+import IMaestroEvent, { TestUseCase } from '../interfaces/IMaestroEvent';
 import { Observable } from '../helpers/Observable';
 import { ViewModel } from './ViewModel';
 import KeyPlaysViewModel from '../modules/key-plays/view-model/KeyPlaysViewModel';
+import BetsViewModel from '../modules/bets/view-model/BetsViewModel';
 import IMaestroKeyPlaysResponse from '../modules/key-plays/interfaces/IKeyPlaysResponse';
+import { MaestroPanelType } from '@/models/IPanel';
 export declare class MaestroEventViewModel extends ViewModel implements IMaestroEvent {
     private _eventId;
     private _title;
@@ -11,6 +13,7 @@ export declare class MaestroEventViewModel extends ViewModel implements IMaestro
     private _isShowingPanel;
     delegate: IMaestroEventDelegate;
     keyPlaysViewModel: KeyPlaysViewModel;
+    betsViewModel: BetsViewModel;
     constructor(eventId: string | undefined, delegate: IMaestroEventDelegate);
     deinit(): void;
     updateKeyPlaysData(data: IMaestroKeyPlaysResponse | null): Promise<void>;
@@ -34,4 +37,5 @@ export declare class MaestroEventViewModel extends ViewModel implements IMaestro
     get isLive(): Observable<boolean>;
     get isShowingPanel(): boolean;
     set isShowingPanel(value: boolean);
+    simulateUseCase<T = any>(useCase: TestUseCase, panelType: MaestroPanelType, testData?: T): void;
 }