@maestro_io/maestro-web-sdk 5.0.0 → 5.1.1

package/dist/src/index.d.ts

@@ -0,0 +1,53 @@
+import IMaestroEventDelegate, { PanelEvent } from './interfaces/IMaestroEventDelegate';
+import IMaestroManager, { SDKConfigParams, SDKEventConfigParams, SDKStopEventParams } from './interfaces/IMaestroManager';
+import IMaestroEvent from './interfaces/IMaestroEvent';
+import { MaestroEventViewModel } from './view-models/MaestroEventViewModel';
+import IMaestroKeyPlaysResponse from './modules/espn/key-plays/interfaces/IKeyPlaysResponse';
+import { GlobalConfig, PageConfig } from './services/StaticService/types';
+import { MaestroPanelType } from './models/IPanel';
+export { ActionTrackEvent, ImpressionTrackEvent, Metadata, PanelClickAction, PanelViewAction, } from './services/AnalyticsService/types';
+export { PanelEvent, IMaestroEventDelegate, IMaestroEvent, IMaestroKeyPlaysResponse, MaestroPanelType, SDKEventConfigParams, SDKStopEventParams, };
+export { IUserSettings, DEFAULT_USER_SETTINGS, } from './interfaces/IUserSettings';
+/**
+ * Main SDK class that serves as the entry point for the Maestro TV SDK
+ * Follows a singleton pattern similar to the Swift implementation
+ */
+declare class MaestroWebSDK implements IMaestroManager {
+    private static instance;
+    private renderer;
+    private siteID;
+    private maestroEventViewModel;
+    private pageConfig;
+    private globalConfig;
+    private globalConfigPoller;
+    private _analyticsService;
+    private isProdEnv;
+    private activePanelUnmountFn;
+    private constructor();
+    private get analyticsService();
+    /**
+     * @description Returns the MaestroWebSDK instance
+     * @returns {MaestroWebSDK} - The MaestroWebSDK instance
+     */
+    static getInstance(): MaestroWebSDK;
+    userDidStartWatchingEvent({ eventId, pageId, userSettings, delegate, useProdEnv, }: SDKEventConfigParams): Promise<IMaestroEvent>;
+    userDidStopWatchingEvent(_config: SDKStopEventParams): Promise<void>;
+    configure(configParams: SDKConfigParams): void;
+    /**
+     * Sets the site ID for the SDK
+     * @param siteID The site ID to set
+     */
+    setSiteID(siteID: string): void;
+    getSiteID(): string;
+    getIsProdEnv(): boolean;
+    /**
+     * Gets the event view model
+     * @returns The current event view model
+     */
+    getMaestroEventViewModel(): MaestroEventViewModel;
+    renderPanel(id: string): Promise<() => Promise<void>>;
+    getPageConfig(): PageConfig | null;
+    getGlobalConfig(): GlobalConfig | null;
+}
+declare const SDK: MaestroWebSDK;
+export default SDK;

package/dist/src/index.js

@@ -0,0 +1,197 @@
+import ReactRenderer from './external/ReactRenderer';
+import { MaestroEventViewModel } from './view-models/MaestroEventViewModel';
+import { UserSettingsManager } from './services/UserSettingsManager';
+import StaticService from './services/StaticService';
+import { MaestroPanelType } from './models/IPanel';
+import AnalyticsService from './services/AnalyticsService/AnalyticsService';
+export { MaestroPanelType, };
+export { DEFAULT_USER_SETTINGS, } from './interfaces/IUserSettings';
+/**
+ * Main SDK class that serves as the entry point for the Maestro TV SDK
+ * Follows a singleton pattern similar to the Swift implementation
+ */
+class MaestroWebSDK {
+    constructor(renderer) {
+        Object.defineProperty(this, "renderer", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "siteID", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: ''
+        });
+        Object.defineProperty(this, "maestroEventViewModel", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: null
+        });
+        Object.defineProperty(this, "pageConfig", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: null
+        });
+        Object.defineProperty(this, "globalConfig", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: null
+        });
+        Object.defineProperty(this, "globalConfigPoller", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: null
+        });
+        Object.defineProperty(this, "_analyticsService", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: null
+        });
+        Object.defineProperty(this, "isProdEnv", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: true
+        });
+        Object.defineProperty(this, "activePanelUnmountFn", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: null
+        });
+        this.renderer = renderer;
+    }
+    get analyticsService() {
+        if (!this._analyticsService) {
+            this._analyticsService = new AnalyticsService();
+        }
+        return this._analyticsService;
+    }
+    /**
+     * @description Returns the MaestroWebSDK instance
+     * @returns {MaestroWebSDK} - The MaestroWebSDK instance
+     */
+    static getInstance() {
+        if (!MaestroWebSDK.instance) {
+            const renderer = new ReactRenderer();
+            MaestroWebSDK.instance = new MaestroWebSDK(renderer);
+        }
+        return MaestroWebSDK.instance;
+    }
+    async userDidStartWatchingEvent({ eventId, pageId, userSettings, delegate, useProdEnv = true, }) {
+        this.isProdEnv = useProdEnv;
+        // Fetch page config before initializing view models
+        const siteId = this.getSiteID();
+        if (!siteId || siteId.trim() === '') {
+            throw new Error('siteID must be set before calling userDidStartWatchingEvent.');
+        }
+        if (!eventId && !pageId) {
+            throw new Error('Either eventId or pageId must be provided to load the page configuration.');
+        }
+        const staticService = new StaticService(siteId);
+        this.pageConfig = await staticService.fetchPageConfig({
+            siteId,
+            metadataValue: eventId,
+            pageId,
+        });
+        if (!this.pageConfig) {
+            throw new Error(`Could not determine page configuration for siteId: ${siteId}, pageId: ${pageId} and eventId: ${eventId}.`);
+        }
+        this.globalConfigPoller = staticService.pollGlobalConfig((data) => {
+            this.globalConfig = data;
+        });
+        // Initialize user settings if provided
+        if (userSettings) {
+            UserSettingsManager.getInstance().updateSettings(userSettings);
+        }
+        await this.analyticsService.SDKSessionStart();
+        this.maestroEventViewModel = new MaestroEventViewModel(eventId, pageId, delegate, this.analyticsService);
+        await this.maestroEventViewModel.initViewModels();
+        await this.analyticsService.pageSessionStart();
+        return this.maestroEventViewModel;
+    }
+    async userDidStopWatchingEvent(_config) {
+        if (this.activePanelUnmountFn) {
+            await this.activePanelUnmountFn();
+        }
+        await this.analyticsService.pageSessionEnd();
+        if (this.maestroEventViewModel) {
+            await this.maestroEventViewModel.deinit();
+            this.maestroEventViewModel = null;
+        }
+        await this.analyticsService.SDKSessionEnd();
+        if (this.globalConfigPoller) {
+            this.globalConfigPoller.stop();
+            this.globalConfigPoller = null;
+        }
+    }
+    configure(configParams) {
+        this.setSiteID(configParams.siteID);
+        // Configure user settings if provided
+        if (configParams.userSettings) {
+            UserSettingsManager.getInstance().updateSettings(configParams.userSettings);
+        }
+        console.info('MaestroWebSDK configured', configParams);
+    }
+    /**
+     * Sets the site ID for the SDK
+     * @param siteID The site ID to set
+     */
+    setSiteID(siteID) {
+        if (!siteID || siteID.trim() === '') {
+            throw new Error('Site ID must be provided');
+        }
+        this.siteID = siteID;
+    }
+    getSiteID() {
+        return this.siteID;
+    }
+    getIsProdEnv() {
+        return this.isProdEnv;
+    }
+    /**
+     * Gets the event view model
+     * @returns The current event view model
+     */
+    getMaestroEventViewModel() {
+        if (!this.maestroEventViewModel) {
+            throw new Error('No Maestro Event View Model set');
+        }
+        return this.maestroEventViewModel;
+    }
+    async renderPanel(id) {
+        await this.analyticsService.pinchBackSessionStart();
+        const panelUnmountFn = await this.renderer.renderPanel(id);
+        let isCleanedUp = false;
+        const cleanupFn = async () => {
+            if (isCleanedUp) {
+                return;
+            }
+            isCleanedUp = true;
+            // Unmount first so the UI is torn down immediately and any portals/handlers
+            // are cleaned up even if the caller doesn't await this async function.
+            panelUnmountFn();
+            await this.analyticsService.pinchBackSessionEnd();
+            if (this.activePanelUnmountFn === cleanupFn) {
+                this.activePanelUnmountFn = null;
+            }
+        };
+        this.activePanelUnmountFn = cleanupFn;
+        return cleanupFn;
+    }
+    getPageConfig() {
+        return this.pageConfig;
+    }
+    getGlobalConfig() {
+        return this.globalConfig;
+    }
+}
+const SDK = MaestroWebSDK.getInstance();
+export default SDK;

package/dist/src/interfaces/IMaestroEvent.d.ts

@@ -0,0 +1,108 @@
+import { MaestroPanelType } from '@/models/IPanel';
+import IMaestroKeyPlaysResponse from '../modules/espn/key-plays/interfaces/IKeyPlaysResponse';
+import { IUserSettings } from './IUserSettings';
+/**
+ * This is the public API that the app can use to make calls to the SDK related to the currently-loaded event.
+ */
+export default interface IMaestroEvent {
+    /**
+     * @description Tells the SDK that the user just started playing a new key play clip at the given index.
+     * https://developers.maestro.io/sdk/web/maestro-event-interface/playback-controls/didStartPlayingClip
+     */
+    didStartPlayingClip(index: number): void;
+    /**
+     * @description Tells the SDK that the user just stopped playing a key play clip at the given index.
+     * https://developers.maestro.io/sdk/web/maestro-event-interface/playback-controls/didStopPlayingClip
+     */
+    didStopPlayingClip(index: number): void;
+    /**
+     * @description Tells the SDK that the user tried to play the clip but it failed to play back.
+     * https://developers.maestro.io/sdk/web/maestro-event-interface/playback-controls/didFailToPlayClip
+     */
+    didFailToPlayClip(index: number): void;
+    /**
+     * @description Updates the SDK with the latest progress in the playback of the currently-played key play clip, from 0 to 1.
+     * https://developers.maestro.io/sdk/web/maestro-event-interface/playback-controls/didUpdatePlaybackProgressOfClip
+     */
+    didUpdatePlaybackProgressOfClip(index: number, to: number): void;
+    /**
+     * @description Tells the SDK that the app displayed the MaestroPanel.
+     * https://developers.maestro.io/sdk/web/maestro-event-interface/panel-management/didShowPanel
+     */
+    didShowPanel(): Promise<void>;
+    /**
+     * @description Tells the SDK that the app hid the MaestroPanel.
+     * https://developers.maestro.io/sdk/web/maestro-event-interface/panel-management/didHidePanel
+     */
+    didHidePanel(): Promise<void>;
+    /**
+     * @description Alerts the SDK that the current event does not support key plays.
+     * https://developers.maestro.io/sdk/web/maestro-event-interface/panel-management/currentEventDoesNotSupportKeyPlays
+     */
+    currentEventDoesNotSupportKeyPlays(): void;
+    /**
+     * @description Retrieves the event ID for the currently loaded event.
+     * https://developers.maestro.io/sdk/web/maestro-event-interface/state/getCurrentEventID
+     */
+    getCurrentEventID(): string | null;
+    /**
+     * @description Retrieves the array index of the key play clip that is currently being played.
+     * https://developers.maestro.io/sdk/web/maestro-event-interface/state/getCurrentlyPlayingClipIndex
+     */
+    getCurrentlyPlayingClipIndex(): number | null;
+    /**
+     * @description Retrieves the array index of the key plays clip that was most recently played.
+     * https://developers.maestro.io/sdk/web/maestro-event-interface/state/getLastPlayedClipIndex
+     */
+    getLastPlayedClipIndex(): number | null;
+    /**
+     * @description Retrieves the progress (between 0 and 1) of the currently-played key play clip.
+     * https://developers.maestro.io/sdk/web/maestro-event-interface/state/getCurrentClipPlaybackProgress
+     */
+    getCurrentClipPlaybackProgress(): number | null;
+    /**
+     * @description Retrieves the number of key plays.
+     * https://developers.maestro.io/sdk/web/maestro-event-interface/state/getKeyPlaysCount
+     */
+    getKeyPlaysCount(): number | null;
+    /**
+     * @description Tells the SDK to start managing focus.
+     * https://developers.maestro.io/sdk/web/focus-management/parent-app-focus
+     */
+    startFocusManagement(): Promise<void>;
+    /**
+     * @description Feeds the SDK new key plays data. A null value indicates a failure to retrieve the data.
+     * https://developers.maestro.io/sdk/web/maestro-event-interface/state/updateKeyPlaysData
+     */
+    updateKeyPlaysData(data: IMaestroKeyPlaysResponse | null): Promise<void>;
+    updateUserSettings(settings: IUserSettings): Promise<void>;
+    /**
+     * @description Updates the SDK with the current time code of the player.
+     * This is used to synchronize the SDK with the player's current time code.
+     * https://developers.maestro.io/sdk/web/maestro-event-interface/state/updatePlayerTimeCode
+     */
+    updatePlayerTimeCode(timestamp: number): void;
+    /**
+     * @description Retrieves the current player time code stored in the SDK.
+     * https://developers.maestro.io/sdk/web/maestro-event-interface/state/getPlayerTimeCode
+     */
+    getPlayerTimeCode(): number | null;
+    /**
+     * @description Sets data on panel view models. Interface to pass any data to any panel.
+     * @param {Record<string, any>} panelData - Object with panel names as keys and their data as values
+     * @example
+     * setDataToPanel({
+     *   [panelType]: {
+     *    overrideUrl: 'https://...',
+     *    customProperty: 'value'
+     *   },
+     * })
+     */
+    setDataToPanel(panelData: Record<string, any>): void;
+    /**
+     * @description Sets the active panel in the Maestro SDK, if the panel is available and not hidden.
+     * @param {MaestroPanelType} panelType - The type of the panel to set as active
+     * https://developers.maestro.io/sdk/web/maestro-event-interface/state/setActivePanel
+     */
+    setActivePanel(panelType: MaestroPanelType): void;
+}

package/dist/src/interfaces/IMaestroEvent.js

@@ -0,0 +1 @@
+export {};

package/dist/src/interfaces/IMaestroEventDelegate.d.ts

@@ -0,0 +1,74 @@
+import { ActionTrackEvent, ImpressionTrackEvent } from '@/services/AnalyticsService/types';
+export type RequestLoginPanelEvent = {
+    type: 'fantasy:request:login';
+    payload: {
+        /**
+         * @description Callback to be called by the client app once the login process is completed, so the SDK can refresh its state accordingly.
+         */
+        onLoginSuccess: () => void;
+    };
+};
+export type PanelEvent = RequestLoginPanelEvent;
+/**
+ * @description Interface for the client app to implement in order to handle Maestro TV SDK events.
+ */
+export default interface IMaestroEventDelegate {
+    /**
+     * @description Allows the SDK to tell the client app that the user has encountered an error screen for lack of valid key
+       plays data, indicating the client app should call `updateKeyPlaysData` as soon as possible.
+       https://developers.maestro.io/sdk/web/event-delegate/userRequestedNewKeyPlaysData
+     */
+    userRequestedNewKeyPlaysData(): Promise<void>;
+    /**
+     * Allows the SDK to request the client app play a particular key plays clip, given its array index in the key plays list.  Note that the `MaestroKeyPlaysResponse` subdivides the key plays by section, so the `index` referenced here assumes the client app has access to a flattened list of the key plays, disregarding the sectional subdivisions.
+     * https://developers.maestro.io/sdk/web/event-delegate/playClip
+     */
+    playClip(atIndex: number): void;
+    /**
+     * @description SDK can notify the client app when its time to handle the focus management.
+     * https://developers.maestro.io/sdk/web/event-delegate/startFocusManagement
+     */
+    startFocusManagement(): Promise<void>;
+    /**
+     * @description Check if the user is authenticated for betting.
+     * https://developers.maestro.io/sdk/web/event-delegate/userIsAuthenticated
+     */
+    userIsAuthenticated(): Promise<boolean>;
+    /**
+     * @description Get the user's SWID for authenticated betting requests.
+     * https://developers.maestro.io/sdk/web/event-delegate/getUserSWID
+     */
+    getUserSWID(): Promise<string | null>;
+    /**
+     * @description Get the user's Cookie token for authenticated betting requests.
+     * https://developers.maestro.io/sdk/web/event-delegate/getUserToken
+     */
+    getUserToken(): Promise<string | null>;
+    /**
+     * @description Get the API base URL for betting-related requests.
+     * This baseURL is used to fetch betting data, such as odds and betting lines.
+     * https://developers.maestro.io/sdk/web/event-delegate/getBettingAPIBaseURL
+     */
+    getBettingAPIBaseURL(): string;
+    /**
+     * @description Get the API base URL for stats-related requests.
+     * This baseURL is used to fetch stats data for the event.
+     *
+     */
+    getStatsAPIBaseURL(): string;
+    /**
+     * @description Track an user's action event for analytics. (i.e. key play clicked)
+     * https://developers.maestro.io/sdk/web/event-delegate/trackAction
+     */
+    trackAction(action: ActionTrackEvent): void;
+    /**
+     * @description Track an impression event for analytics. (i.e. panel view)
+     * https://developers.maestro.io/sdk/web/event-delegate/trackImpression
+     */
+    trackImpression(impression: ImpressionTrackEvent): void;
+    /**
+     * @description Notify the client app of a panel event within the SDK that may require handling by the client app. (i.e. request login)
+     * https://developers.maestro.io/sdk/web/event-delegate/onPanelEvent
+     */
+    onPanelEvent(event: PanelEvent): void;
+}

package/dist/src/interfaces/IMaestroEventDelegate.js

@@ -0,0 +1 @@
+export {};

package/dist/src/interfaces/IMaestroManager.d.ts

@@ -0,0 +1,81 @@
+import IMaestroEventDelegate from './IMaestroEventDelegate';
+import IMaestroEvent from './IMaestroEvent';
+import { IUserSettings } from './IUserSettings';
+export type SDKConfigParams = {
+    /**
+     * The site ID to use for the SDK.
+     */
+    siteID: string;
+    /**
+     * User settings for customizing SDK behavior (panel visibility, feature toggles, etc.)
+     */
+    userSettings?: IUserSettings;
+};
+export type SDKStopEventParams = {
+    /**
+     * Event ID for the event being stopped.
+     */
+    eventId?: string;
+    /**
+     * Page ID for the event being stopped.
+     */
+    pageId?: string;
+};
+export type SDKEventConfigParams = {
+    /**
+     * The page ID to use to load the page configuration.
+     */
+    pageId?: string;
+    /**
+     * User settings for customizing SDK behavior (panel visibility, feature toggles, etc.)
+     */
+    userSettings?: IUserSettings;
+    /**
+     * Event ID as metadata value to use to load the page configuration.
+     * This is typically used when the page ID is not known, but a metadata value is available.
+     */
+    eventId?: string;
+    /**
+     * The instance of the app's implementation of IMaestroEventDelegate
+     */
+    delegate: IMaestroEventDelegate;
+    /**
+     * @description - Indicates whether to use the production environment for this event.
+     * @default true
+     */
+    useProdEnv?: boolean;
+};
+/**
+ This is the MaestroKit top-level API for initializing and configuring the framework.  It encompasses all functionality that is not specific to an event.
+ */
+export default interface IMaestroManager {
+    /**
+     * @description Configure the MaestroWebSDK.
+     * @param {SDKConfigParams} configParams - Configuration parameters
+     * @param {SDKConfigParams['siteID']} configParams.siteID - The site ID to use for the SDK.
+     * @param {SDKConfigParams['userSettings']} configParams.userSettings - User settings for customizing SDK behavior.
+     */
+    configure(configParams: SDKConfigParams): void;
+    /**
+       Tells the SDK the user has opened an event in the app's player.
+       Arguments:
+       - eventID: The Event ID for the event opened in the player.
+       - delegate: an instance of the app's implementation of IMaestroEventDelegate
+       - userSettings: Optional user settings to override the configured settings for this event
+       The function returns an instance of MaestroEventViewModel, which includes an implementation of IMaestroEvent.  IMaestroEvent represents the app-facing portion of the MaestroKit API related to the currently-loaded event.  So after `userDidStartWatchingEvent` is called, the SDK has access to the API detailed in `MaestroEventDelegate` for making calls to the app, and the app has access to the API detailed in `IMaestroEvent` for making calls to the SDK.
+      */
+    userDidStartWatchingEvent(config: SDKEventConfigParams): Promise<IMaestroEvent>;
+    /**
+     * @description Tells the SDK the user has closed an event that was open in the app's player.
+     * @param params - Parameters including eventId or pageId to identify the event being stopped.
+     * @param params.eventId - The Event ID for the event being stopped.
+     * @param params.pageId - The Page ID for the event being stopped.
+     */
+    userDidStopWatchingEvent(params: SDKStopEventParams): Promise<void>;
+    /**
+     * Render the PanelManager with the available panels for the current event in the specified HTML id element.
+     * @param id - The ID of the HTML element where the panel will be rendered.
+     * @return A Promise that resolves to an async function to remove the panel when no longer needed.
+     */
+    renderPanel(id: string): Promise<() => Promise<void>>;
+}

package/dist/src/interfaces/IMaestroManager.js

@@ -0,0 +1 @@
+export {};

package/dist/src/interfaces/IUserSettings.d.ts

@@ -0,0 +1,44 @@
+/**
+ * User settings interface for customizing Maestro Web SDK behavior
+ * Supports panel-level and feature-level customizations
+ */
+export interface IUserSettings {
+    panels?: {
+        bets?: {
+            /** Hide the entire bets panel from panel selection */
+            hidePanel?: boolean;
+            /** Hide wager values (dollar amounts) in betting cards */
+            hideWagers?: boolean;
+        };
+        stats?: {
+            /** Hide the entire stats panel from panel selection */
+            hidePanel?: boolean;
+        };
+        keyPlays?: {
+            /** Hide the entire key plays panel from panel selection */
+            hidePanel?: boolean;
+        };
+        fantasy?: {
+            /** Hide the entire fantasy panel from panel selection */
+            hidePanel?: boolean;
+        };
+        shop?: {
+            /** Hide the entire shop panel from panel selection */
+            hidePanel?: boolean;
+        };
+    };
+}
+/**
+ * Default user settings - all features enabled by default
+ */
+export declare const DEFAULT_USER_SETTINGS: IUserSettings;
+/**
+ * Panel-specific settings type helpers
+ */
+export type BetsSettings = NonNullable<IUserSettings['panels']>['bets'];
+export type StatsSettings = NonNullable<IUserSettings['panels']>['stats'];
+export type KeyPlaysSettings = NonNullable<IUserSettings['panels']>['keyPlays'];
+/**
+ * Utility type for getting panel settings by panel type
+ */
+export type PanelSettings<T extends keyof NonNullable<IUserSettings['panels']>> = NonNullable<IUserSettings['panels']>[T];

package/dist/src/interfaces/IUserSettings.js

@@ -0,0 +1,20 @@
+/**
+ * Default user settings - all features enabled by default
+ */
+export const DEFAULT_USER_SETTINGS = {
+    panels: {
+        bets: {
+            hidePanel: false,
+            hideWagers: false,
+        },
+        stats: {
+            hidePanel: false,
+        },
+        keyPlays: {
+            hidePanel: false,
+        },
+        fantasy: {
+            hidePanel: false,
+        },
+    },
+};

package/dist/src/models/IModel.d.ts

@@ -0,0 +1,7 @@
+export default interface IModel {
+    _id?: string;
+    archived?: boolean;
+    created?: number;
+    modified?: number;
+    tags?: string[];
+}

package/dist/src/models/IModel.js

@@ -0,0 +1 @@
+export {};

package/dist/src/models/IPanel.d.ts

@@ -0,0 +1,19 @@
+export declare const MaestroPanelType: {
+    readonly ESPN_KEY_PLAYS: "espnKeyPlays";
+    readonly ESPN_STATS: "espnStats";
+    readonly ESPN_BETS: "espnBet";
+    readonly ESPN_FANTASY: "espnFantasy";
+    readonly ESPN_SHOP: "espnShop";
+    readonly HELLO_WORLD: "helloWorld";
+    readonly FOX_KEY_PLAYS: "foxKeyPlays";
+    readonly FOX_MULTI_VIEW: "foxMultiview";
+    readonly FOX_STATS: "foxStats";
+    readonly BUILDER_BLOCK_PANEL: "builderBlockPanel";
+};
+export type MaestroPanelType = typeof MaestroPanelType[keyof typeof MaestroPanelType];
+export interface PanelTypeInfo {
+    id: MaestroPanelType;
+    name: string;
+    imageNamePrefix: string;
+    iconName: string;
+}

package/dist/src/models/IPanel.js

@@ -0,0 +1,12 @@
+export const MaestroPanelType = {
+    ESPN_KEY_PLAYS: 'espnKeyPlays',
+    ESPN_STATS: 'espnStats',
+    ESPN_BETS: 'espnBet',
+    ESPN_FANTASY: 'espnFantasy',
+    ESPN_SHOP: 'espnShop',
+    HELLO_WORLD: 'helloWorld',
+    FOX_KEY_PLAYS: 'foxKeyPlays',
+    FOX_MULTI_VIEW: 'foxMultiview',
+    FOX_STATS: 'foxStats',
+    BUILDER_BLOCK_PANEL: 'builderBlockPanel',
+};