@maestro_io/maestro-web-sdk 2.2.0 → 2.2.2

package/dist/modules/bets/types/BetsAnalyticsTypes.d.ts

@@ -0,0 +1,25 @@
+import { BaseMetadata } from '../../../services/AnalyticsService/types';
+/**
+ * Valid bet types as specified in the analytics spec
+ */
+export type BetType = 'straight' | 'parlay' | 'parlay_plus' | 'teaser' | 'boost';
+/**
+ * Valid card types for bets module
+ */
+export type BetCardType = '6-pack' | 'my bets > live' | 'my bets > settled' | 'my bets > upcoming' | 'hot-props' | 'promo' | 'disclaimer';
+/**
+ * Metadata for bet panel view events
+ */
+export interface BetPanelViewMetadata extends BaseMetadata {
+    in_game_bets: number;
+    total_bets: number;
+}
+/**
+ * Metadata for bet card click events
+ */
+export interface BetCardClickMetadata extends BaseMetadata {
+    card: BetCardType;
+    in_game_bets: number;
+    total_bets: number;
+    bet_type: BetType | null;
+}

package/dist/modules/bets/view/BetsView.d.ts

@@ -1,23 +1,27 @@
 import React, { Component } from 'react';
 import './BetsView.styles.css';
 import { BetItem, BetsErrorState } from '../view-model/BetsViewModel';
+import { Direction } from '@/external/spatial-navigation/utils';
 interface BetsViewState {
     container: HTMLDivElement | null;
     betsItems: BetItem[];
     isDataLoading: boolean;
     errorState: BetsErrorState;
+    hideWagers: boolean;
 }
 declare class BetsView extends Component<{}, BetsViewState> {
     private container;
     private betsItemsUnsub;
     private isDataLoadingUnsub;
     private errorStateUnsub;
+    private hideWagersUnsub;
     private vm;
     constructor(props: {});
     componentDidMount(): void;
     componentWillUnmount(): void;
     renderBetItem: (item: BetItem) => React.JSX.Element | null;
     clearTabLoadFailure: () => void;
+    onArrowPress: (d: Direction) => void;
     render(): React.JSX.Element;
 }
 export default BetsView;

package/dist/modules/bets/view/SixPack/SixPackView.d.ts

@@ -15,6 +15,7 @@ export default class FocusableSixPackViewWrapper extends React.Component<Props>
     context: import("@/components/core/ScrollableContainer/ScrollableContainer").ScrollableContainerContextType;
     onBecameFocused: (layout: Layout) => void;
     onArrowPress: (d: Direction, _props: any) => void;
+    onEnterPress: () => void;
     render(): React.JSX.Element;
 }
 export {};

package/dist/modules/bets/view/UserBets/BetsCard/BetsCard.d.ts

@@ -7,6 +7,7 @@ export declare const EVENTS_COUNT_THRESHOLD = 3;
 export type BaseBetCardProps = {
     bet: IUserBet;
     renderHeaderContent?: (props: WithFocusableProps) => React.ReactNode;
+    hideWagers?: boolean;
 };
 declare const _default: {
     new (props?: (BaseBetCardProps & WithFocusableProps) | undefined, context?: any): {

package/dist/modules/bets/view/UserBets/BetsCard/BetsCardEvent.d.ts

@@ -10,6 +10,7 @@ type BetsCardEventProps = {
     betType: string;
     onBetArrowPress: (eventIndex: number, legIndex: number) => (direction: Direction, props: any, details: Details) => void;
     onBetBackPress: () => void;
+    hideWagers?: boolean;
 };
 declare class BetsCardEvent extends React.Component<BetsCardEventProps> {
     static contextTypes: {

package/dist/modules/bets/view/UserBets/BetsCard/BetsCardFooter.d.ts

@@ -2,6 +2,7 @@ import React from 'react';
 import { IUserBet } from '@/modules/bets/interfaces/IBets';
 type BetsCardFooterProps = {
     bet: IUserBet;
+    hideWagers?: boolean;
 };
-declare const BetsCardFooter: (props: BetsCardFooterProps) => React.JSX.Element;
+declare const BetsCardFooter: (props: BetsCardFooterProps) => React.JSX.Element | null;
 export default BetsCardFooter;

package/dist/modules/bets/view/UserBets/Boost/Boost.d.ts

@@ -2,6 +2,7 @@ import React from 'react';
 import { IUserBet } from '@/modules/bets/interfaces/IBets';
 type BoostProps = {
     bet: IUserBet;
+    hideWagers?: boolean;
 };
-declare const Boost: ({ bet }: BoostProps) => React.JSX.Element;
+declare const Boost: ({ bet, hideWagers }: BoostProps) => React.JSX.Element;
 export default Boost;

package/dist/modules/bets/view/UserBets/Parlay/Parlay.d.ts

@@ -3,6 +3,7 @@ import './Parlay.styles.css';
 import { IUserBet } from '@/modules/bets/interfaces/IBets';
 type ParlayProps = {
     bet: IUserBet;
+    hideWagers?: boolean;
 };
-declare const Parlay: ({ bet }: ParlayProps) => React.JSX.Element;
+declare const Parlay: ({ bet, hideWagers }: ParlayProps) => React.JSX.Element;
 export default Parlay;

package/dist/modules/bets/view/UserBets/Straight/Straight.d.ts

@@ -2,6 +2,7 @@ import React from 'react';
 import { IUserBet } from '@/modules/bets/interfaces/IBets';
 type StraightProps = {
     bet: IUserBet;
+    hideWagers?: boolean;
 };
-declare const Straight: ({ bet }: StraightProps) => React.JSX.Element;
+declare const Straight: ({ bet, hideWagers }: StraightProps) => React.JSX.Element;
 export default Straight;

package/dist/modules/bets/view/UserBets/Teaser/Teaser.d.ts

@@ -2,6 +2,7 @@ import React from 'react';
 import { IUserBet } from '@/modules/bets/interfaces/IBets';
 type TeaserProps = {
     bet: IUserBet;
+    hideWagers?: boolean;
 };
-declare const Teaser: ({ bet }: TeaserProps) => React.JSX.Element;
+declare const Teaser: ({ bet, hideWagers }: TeaserProps) => React.JSX.Element;
 export default Teaser;

package/dist/modules/bets/view/UserBets/UserBetsView.d.ts

@@ -17,7 +17,6 @@ declare class UserBetsView extends React.Component<UserBetsViewProps, {
     segmentItems: (SegmentItem & {
         type: Segments;
     })[];
-    onSegmentChange: (segment: Segments) => void;
     renderBet: (bet: IUserBet) => React.JSX.Element | null;
     renderBets: () => React.JSX.Element | (React.JSX.Element | null)[];
     get bets(): IUserBet[] | null;

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

@@ -6,6 +6,7 @@ import { IBetLeg } from '@/modules/bets/interfaces/IBets';
 declare const _default: {
     new (props?: ({
         leg: IBetLeg;
+        hideWagers?: boolean | undefined;
     } & WithFocusableProps) | undefined, context?: any): {
         state: import("../../../../../external/spatial-navigation/withFocusable").WithFocusableState;
         navigation: import("../../../../../external/spatial-navigation/spatialNavigation").default;
@@ -28,15 +29,18 @@ declare const _default: {
         componentWillUnmount(): void;
         render(): React.ReactElement<{
             leg: IBetLeg;
+            hideWagers?: boolean | undefined;
         } & 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: {
             leg: IBetLeg;
+            hideWagers?: boolean | undefined;
         } & 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<{
             leg: IBetLeg;
+            hideWagers?: boolean | undefined;
         } & WithFocusableProps>;
         context: any;
         refs: {
@@ -45,12 +49,15 @@ declare const _default: {
         componentWillMount?(): void;
         componentWillReceiveProps?(nextProps: Readonly<{
             leg: IBetLeg;
+            hideWagers?: boolean | undefined;
         } & WithFocusableProps>, nextContext: any): void;
         shouldComponentUpdate?(nextProps: Readonly<{
             leg: IBetLeg;
+            hideWagers?: boolean | undefined;
         } & WithFocusableProps>, nextState: Readonly<import("../../../../../external/spatial-navigation/withFocusable").WithFocusableState>, nextContext: any): boolean;
         componentWillUpdate?(nextProps: Readonly<{
             leg: IBetLeg;
+            hideWagers?: boolean | undefined;
         } & WithFocusableProps>, nextState: Readonly<import("../../../../../external/spatial-navigation/withFocusable").WithFocusableState>, nextContext: any): void;
     };
     contextTypes: {

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

@@ -18,5 +18,6 @@ export default class FocusablePromoCodeBannerWrapper extends React.Component<Pro
     context: import("@/components/core/ScrollableContainer/ScrollableContainer").ScrollableContainerContextType;
     onBecameFocused: (layout: Layout) => void;
     onArrowPress: (d: Direction, _props: any) => void;
+    onEnterPress: () => void;
     render(): React.JSX.Element;
 }

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

@@ -3,6 +3,7 @@ import { ITeam, IUserBet, IBetLeg } from '../interfaces/IBets';
 import { ViewModel } from '../../../view-models/ViewModel';
 import { TestUseCase } from '@/interfaces/IMaestroEvent';
 import IMaestroEventDelegate from '@/interfaces/IMaestroEventDelegate';
+import { BetCardType, BetType } from '../types/BetsAnalyticsTypes';
 declare const BET_ITEM_TYPE: {
     readonly ODDS: "odds";
     readonly USER_BETS: "userBets";
@@ -74,16 +75,19 @@ export type SixPackBetItem = {
         away: ITeam;
     };
     id: string;
+    hideWagers: boolean;
 };
 export type UserBetsBetItem = {
     type: 'userBets';
     data: IUserBets;
     id: string;
+    hideWagers: boolean;
 };
 export type HotPropsBetItem = {
     type: 'hotProps';
     data: IHotProps;
     id: string;
+    hideWagers: boolean;
 };
 export type BetItem = SixPackBetItem | UserBetsBetItem | PromoBetItem | HotPropsBetItem | LocationDisclaimerBetItem | GamblingMessageBetItem;
 declare const BET_ERROR_STATE: {
@@ -101,14 +105,18 @@ export declare class BetsViewModel extends ViewModel {
     isDataLoading: Observable<boolean>;
     errorState: Observable<BetsErrorState>;
     hasEverSuccessfullyLoaded: Observable<boolean>;
+    hideWagers: Observable<boolean>;
     private eventId;
     private delegate;
     private betsService;
+    private analyticsService;
     private pollingInterval;
     private pollingTask;
     private lastNonPersonalizedResponseHash;
     private lastPersonalizedResponseHash;
     private useMockData;
+    private userSettingsManager;
+    private settingsSubscription;
     initialized: boolean;
     constructor(eventId: string, delegate: IMaestroEventDelegate, options?: {
         pollingInterval?: number;
@@ -122,6 +130,22 @@ export declare class BetsViewModel extends ViewModel {
      * Clean up resources when the ViewModel is no longer needed
      */
     cleanup(): void;
+    /**
+     * Track panel view event
+     */
+    private trackPanelView;
+    /**
+     * Track card click event
+     */
+    trackCardClick(cardType: BetCardType, betType?: BetType | null): Promise<void>;
+    /**
+     * Get base metadata for analytics events
+     */
+    private getBaseMetadata;
+    /**
+     * Get user bet counts for analytics
+     */
+    private getUserBetCounts;
     /**
      * Refresh polling for bet data
      */
@@ -170,6 +194,15 @@ export declare class BetsViewModel extends ViewModel {
     private fetchMockData;
     simulateUseCase<T = any>(useCase: TestUseCase, _: T): void;
     clearTabLoadFailure(): void;
+    /**
+     * Check if wagers should be hidden based on user settings
+     */
+    shouldHideWagers(): boolean;
+    /**
+     * Update hideWagers Observable from current settings
+     */
+    private updateHideWagersFromSettings;
+    private refreshBetItemsWithNewSettings;
 }
 declare global {
     interface String {

package/dist/modules/key-plays/interfaces/IKeyPlays.d.ts

@@ -9,6 +9,7 @@ export default interface IKeyPlay {
     teamImageUrl?: string;
     playerImageUrl?: string;
     thumbnailImageUrl?: string;
+    wallClock?: string;
     section?: string;
 }
 export declare const KEY_PLAYS_LOAD_FAILURE_STATUS: {

package/dist/modules/key-plays/interfaces/IKeyPlaysResponse.d.ts

@@ -29,12 +29,12 @@ interface MaestroKeyPlaysSection {
 }
 interface MaestroKeyPlay {
     description: string;
-    team: string;
-    wallClock: string;
-    displayClock: string;
-    shortPeriod: string;
-    scoringPlay: boolean;
-    athlete: string;
+    team?: string;
+    wallClock?: string;
+    displayClock?: string;
+    shortPeriod?: string;
+    scoringPlay?: boolean;
+    athlete?: string;
     thumbnail: string;
     thumbnailType: string;
     clipID: string;

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

@@ -10,17 +10,20 @@ type KeyPlayCardViewProps = IKeyPlay & {
 };
 type KeyPlaysCardViewState = {
     failedClip: KeyPlayLoadFailureStatus | null;
+    imageLoaded: boolean;
 };
 export declare class KeyPlayCardView extends React.Component<KeyPlayCardViewProps & WithFocusableProps, KeyPlaysCardViewState> {
     private failedClipListener;
     private vm;
     state: {
         failedClip: null;
+        imageLoaded: boolean;
     };
     constructor(props: KeyPlayCardViewProps);
     componentDidMount(): void;
     componentWillUnmount(): void;
-    renderImage: () => React.JSX.Element;
+    onLoad: () => void;
+    renderImage: () => React.JSX.Element | null;
     render(): React.JSX.Element;
 }
 export default class KeyPlayCard extends React.Component<Omit<KeyPlayCardViewProps, 'setRef'> & WithFocusableProps> {

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

@@ -1,11 +1,13 @@
 import { KeyPlaysErrorState } from '../interfaces/IKeyPlays';
 import './KeyPlayErrorStateView.styles.css';
 import React from 'react';
+import { Direction } from '@/external/spatial-navigation/utils';
 type Props = {
     errorState: KeyPlaysErrorState;
     onRetry: () => void;
 };
 declare class KeyPlayErrorStateView extends React.Component<Props, {}> {
+    onArrowPress: (d: Direction) => void;
     render(): React.JSX.Element | null;
 }
 export default KeyPlayErrorStateView;

package/dist/modules/key-plays/view-model/KeyPlaysViewModel.d.ts

@@ -1,6 +1,7 @@
 import IMaestroKeyPlaysResponse from '../interfaces/IKeyPlaysResponse';
 import IKeyPlay, { KeyPlayLoadFailureStatus, KeyPlaysErrorState } from '../interfaces/IKeyPlays';
 import { Observable } from '@/helpers/Observable';
+import AnalyticsService from '@/services/AnalyticsService/AnalyticsService';
 type KeyPlayItem = {
     title: string;
     items: IKeyPlay[];
@@ -14,10 +15,17 @@ declare class KeyPlaysViewModel {
         [key: string]: KeyPlayLoadFailureStatus;
     }>;
     items: Observable<KeyPlayItem[]>;
+    filteredItems: Observable<KeyPlayItem[]>;
+    analyticsService: AnalyticsService;
+    constructor();
+    onUpdatePlayerTimeCode(playerTimeCode: number | null): void;
+    private filterItemsByPlayerTimeCode;
+    private shouldShowKeyPlay;
     isCurrentlyPlaying(index: number): boolean;
-    setKeyPlays(items: IMaestroKeyPlaysResponse | null): Promise<void>;
+    setKeyPlays(items: IMaestroKeyPlaysResponse | null, playerTimeCode: number | null): Promise<void>;
     private cleanErrors;
     playKeyPlay(atIndex: number): Promise<void>;
+    init(): Promise<void>;
     parseNetworkResponse(response: IMaestroKeyPlaysResponse): KeyPlayItem[];
     get allItems(): IKeyPlay[];
     clipID(forKeyPlayAtIndex: number): string | undefined;

package/dist/modules/stats/interfaces/IStats.d.ts

@@ -15,7 +15,7 @@ export interface Team {
     shortDisplayName?: string;
     color?: string;
     alternateColor?: string;
-    logo: string;
+    logo?: string;
     statistics?: TeamStatistic[];
     homeAway?: string;
     record?: string;

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

@@ -5,6 +5,7 @@ import { ActiveAthletesItem } from '../../view-model/StatsViewModel';
 export type ActiveAthletesProps = {
     item: ActiveAthletesItem;
     onBecameFocused: (layout: Layout) => void;
+    onEnterPress: () => void;
 };
 declare class ActiveAthletes extends React.Component<ActiveAthletesProps, {
     expanded: boolean;

package/dist/modules/stats/view/ActiveAthletes/CollapsedAthletes/CollapsedAthletes.d.ts

@@ -1,5 +1,5 @@
 import React from 'react';
 import './CollapsedAthletes.styles.css';
 import { ActiveAthletesProps } from '../ActiveAthletes';
-declare const CollapsedAthletes: (props: ActiveAthletesProps) => React.JSX.Element;
+declare const CollapsedAthletes: (props: Pick<ActiveAthletesProps, 'item'>) => React.JSX.Element;
 export default CollapsedAthletes;

package/dist/modules/stats/view/ActiveAthletes/ExpandedAthletes/ExpandedAthletes.d.ts

@@ -5,6 +5,6 @@ import { Direction } from '@/external/spatial-navigation/utils';
 type Props = {
     onArrowPress: (index: number) => (direction: Direction) => void;
     onBackPress: () => void;
-} & ActiveAthletesProps;
+} & Pick<ActiveAthletesProps, 'item' | 'onBecameFocused' | 'onEnterPress'>;
 declare const ExpandedAthletes: (props: Props) => React.JSX.Element;
 export default ExpandedAthletes;

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

@@ -5,6 +5,7 @@ import './DriveSummary.styles.css';
 import { DriveSummaryItem } from '../../view-model/StatsViewModel';
 type DriveSummaryProps = {
     item: DriveSummaryItem;
+    onItemEnterPress: () => void;
 };
 export default class DriveSummary extends React.Component<DriveSummaryProps & WithFocusableProps> {
     static contextTypes: {

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

@@ -4,6 +4,7 @@ import { GameLeadersStatsItem } from '../../view-model/StatsViewModel';
 import { Direction, Layout } from '@/external/spatial-navigation/utils';
 export type GameLeaderProps = {
     item: GameLeadersStatsItem;
+    onEnterPress: () => void;
 };
 declare class GameLeaders extends React.Component<GameLeaderProps> {
     static contextTypes: {

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

@@ -3,6 +3,7 @@ import { StatsItem } from '../view-model/StatsViewModel';
 import { Direction, Layout } from '@/external/spatial-navigation/utils';
 type Props = {
     item: StatsItem;
+    onEnterPress: (item: StatsItem) => void;
 };
 declare class StatsItemView extends React.Component<Props> {
     static contextTypes: {
@@ -13,6 +14,7 @@ declare class StatsItemView extends React.Component<Props> {
     context: import("@/components/core/ScrollableContainer/ScrollableContainer").ScrollableContainerContextType;
     onBecameFocused: (layout: Layout) => void;
     onArrowPress: (d: Direction) => void;
+    onEnterPress: (item: StatsItem) => () => void;
     renderItem(): React.JSX.Element | null;
     render(): React.JSX.Element;
 }

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

@@ -15,6 +15,7 @@ declare class StatsView extends Component<{}, StatsViewState> {
     componentDidMount(): void;
     componentWillUnmount(): void;
     renderItems: () => React.JSX.Element[] | null;
+    onEnterPress: (item: StatsItem) => void;
     render(): React.JSX.Element;
 }
 export default StatsView;

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

@@ -4,6 +4,7 @@ import { DrivePlay, Team } from '../interfaces/IStats';
 import { AthletesStatisticsItem } from '../view/components/AthletesStatistics/AthletesStatistics';
 import StatsService from '@/services/StatsService';
 import IMaestroEventDelegate from '@/interfaces/IMaestroEventDelegate';
+import AnalyticsService from '@/services/AnalyticsService/AnalyticsService';
 declare const STATS_ERROR_STATE: {
     readonly NONE: "none";
     readonly TAB_LOAD_FAILURE: "tabLoadFailure";
@@ -28,11 +29,11 @@ export type HeaderTeamStatItem = {
 type RecentGamesPreviousGame = {
     score: string;
     gameResult: string;
-    teamLogo: string;
+    teamLogo?: string;
     homeAway: string;
 };
 type RecentGamesTeam = {
-    logo: string;
+    logo?: string;
     name?: string;
     events: RecentGamesPreviousGame[];
 };
@@ -110,7 +111,9 @@ export declare class StatsViewModel extends ViewModel {
     eventId: string;
     statsItems: Observable<StatsItem[]>;
     errorState: Observable<BetsErrorState>;
+    currentGameState: Observable<string>;
     statsService: StatsService;
+    analyticsService: AnalyticsService;
     private pollingInterval;
     private useMockData;
     private pollingTask;
@@ -123,6 +126,7 @@ export declare class StatsViewModel extends ViewModel {
      * Initialize the ViewModel and start data fetching
      */
     init(): Promise<void>;
+    onEngage: (type: StatsItem['type']) => void;
     /**
      * Clean up resources when the ViewModel is no longer needed
      */

package/dist/services/AnalyticsService/AnalyticsService.d.ts

@@ -0,0 +1,65 @@
+import InsightsPayloadBuilder from '../InsightsService/InsightsPayloadBuilder';
+import InsightsService from '../InsightsService/InsightsService';
+import { Metadata } from './types';
+type KeyPlaysClickedAction = {
+    panel_id: string;
+    panel_name: string;
+    panel_type: string;
+    name: 'key_play_clicked';
+    metadata: {
+        league: string;
+        event: string;
+        airing: string;
+        sport: string;
+        action: string;
+        clip: string;
+        key_play: string;
+    };
+};
+type BetsItemClickedAction = {
+    panel_id: string;
+    panel_name: string;
+    panel_type: string;
+    name: 'bets_item_clicked';
+    metadata: {
+        league: string;
+        event: string;
+        airing: string;
+        sport: string;
+        card: string;
+        bet_type: string | null;
+        in_game_bets: number;
+        total_bets: number;
+    };
+};
+type StatsItemClickedAction = {
+    panel_id: string;
+    panel_name: string;
+    panel_type: string;
+    name: 'stats_item_clicked';
+    metadata: {
+        league: string;
+        event: string;
+        airing: string;
+        sport: string;
+        card: string[];
+        game_state: string[];
+    };
+};
+type PanelClickPayload = KeyPlaysClickedAction | BetsItemClickedAction | StatsItemClickedAction;
+type PanelViewPayload = {
+    panel_type: string;
+    panel_id: string;
+    panel_name: string;
+    metadata: Metadata;
+};
+declare class AnalyticsService {
+    insightsService: InsightsService;
+    insightsPayloadBuilder: InsightsPayloadBuilder;
+    constructor();
+    private trackAction;
+    private trackImpression;
+    panelView({ panel_type, panel_id, panel_name, metadata, }: PanelViewPayload): Promise<void>;
+    panelClick({ panel_type, panel_id, panel_name, metadata, name, }: PanelClickPayload): Promise<void>;
+}
+export default AnalyticsService;

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

@@ -0,0 +1,65 @@
+/**
+ * Generic metadata type that accepts any object extending BaseMetadata
+ */
+export type Metadata = BaseMetadata & {
+    [key: string]: any;
+};
+export type Kingdom = 'panel';
+export type Phylum = 'view' | 'engage';
+/**
+ * Base metadata analytics events should include
+ */
+export interface BaseMetadata {
+    league: string;
+    event: string;
+    airing: string;
+    sport: string;
+}
+export type PanelViewAction = {
+    name: 'panel_selected';
+    e0_kingdom: Kingdom;
+    e1_phylum: Phylum;
+    /**
+     * Panel Type
+     */
+    e2_class: string;
+    /**
+     * Panel ID
+     */
+    e3_order: string;
+    /**
+     * Panel Name
+     */
+    e4_family: string;
+    e5_genus?: string;
+    e6_species?: string;
+    /**
+     * Additional metadata for the panel view action.
+     */
+    metadata: Metadata;
+};
+export type ImpressionTrackEvent = PanelViewAction;
+export type PanelClickAction = {
+    name: string;
+    e0_kingdom: 'panel';
+    e1_phylum: 'engage';
+    /**
+     * Panel Type
+     */
+    e2_class: string;
+    /**
+     * Panel ID.
+     */
+    e3_order: string;
+    /**
+     * Panel Name
+     */
+    e4_family: string;
+    e5_genus?: string;
+    e6_species?: string;
+    /**
+     * Additional metadata for the panel click action.
+     */
+    metadata: Metadata;
+};
+export type ActionTrackEvent = PanelClickAction;

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