@maestro_io/maestro-web-sdk 4.0.0 → 4.0.2

package/dist/src/index.js

@@ -0,0 +1,165 @@
+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 initSentry from './sentry';
+import AnalyticsService from './services/AnalyticsService/AnalyticsService';
+// Export overlay components and types for client apps
+export { default as Overlay } from './components/molecules/Overlay/Overlay';
+export { OverlayType, } from './types/OverlayTypes';
+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: new AnalyticsService()
+        });
+        Object.defineProperty(this, "staticService", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new StaticService()
+        });
+        this.renderer = renderer;
+    }
+    /**
+     * @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, delegate, userSettings) {
+        // 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 || eventID.trim() === '') {
+            throw new Error('eventID must be provided to watch an event.');
+        }
+        this.pageConfig = await this.staticService.fetchPageConfig(siteId, eventID);
+        if (!this.pageConfig) {
+            throw new Error(`Could not determine page configuration for siteId: ${siteId} and eventID: ${eventID}.`);
+        }
+        this.globalConfigPoller = this.staticService.pollGlobalConfig((data) => {
+            this.globalConfig = data;
+        });
+        // Initialize user settings if provided
+        if (userSettings) {
+            UserSettingsManager.getInstance().updateSettings(userSettings);
+        }
+        initSentry();
+        await this.analyticsService.SDKSessionStart();
+        this.maestroEventViewModel = new MaestroEventViewModel(eventID, delegate);
+        await this.analyticsService.pageSessionStart();
+        return this.maestroEventViewModel;
+    }
+    async userDidStopWatchingEvent(_) {
+        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;
+    }
+    /**
+     * 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);
+        return async () => {
+            await this.analyticsService.pinchBackSessionEnd();
+            panelUnmountFn();
+        };
+    }
+    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,126 @@
+import { MaestroPanelType } from '@/models/IPanel';
+import IMaestroKeyPlaysResponse from '../modules/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;
+    simulateUseCase<T = any>(useCase: TestUseCase, panelType: MaestroPanelType, testData?: T): 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;
+}
+declare const TEST_USE_CASES: {
+    readonly betsTabLoadFailure: "betsTabLoadFailure";
+    readonly betsMockData: "betsMockData";
+    readonly betsLiveData: "betsLiveData";
+    readonly showBasketballPreGameStatsMockData: "showBasketballPreGameStatsMockData";
+    readonly showBasketballInGameStatsMockData: "showBasketballInGameStatsMockData";
+    readonly showFootballPreGameStatsMockData: "showFootballPreGameStatsMockData";
+    readonly showFootballInGameStatsMockData: "showFootballInGameStatsMockData";
+    readonly showHockeyPreGameStatsMockData: "showHockeyPreGameStatsMockData";
+    readonly showHockeyInGameStatsMockData: "showHockeyInGameStatsMockData";
+    readonly shopTabLoadFailure: "shopTabLoadFailure";
+    readonly shopEmptyState: "shopEmptyState";
+    readonly shopMockData: "shopMockData";
+    readonly shopLiveData: "shopLiveData";
+};
+export type TestUseCase = typeof TEST_USE_CASES[keyof typeof TEST_USE_CASES];
+export {};

package/dist/src/interfaces/IMaestroEvent.js

@@ -0,0 +1,18 @@
+const TEST_USE_CASES = {
+    betsTabLoadFailure: 'betsTabLoadFailure',
+    betsMockData: 'betsMockData',
+    betsLiveData: 'betsLiveData',
+    // Stats use cases
+    showBasketballPreGameStatsMockData: 'showBasketballPreGameStatsMockData',
+    showBasketballInGameStatsMockData: 'showBasketballInGameStatsMockData',
+    showFootballPreGameStatsMockData: 'showFootballPreGameStatsMockData',
+    showFootballInGameStatsMockData: 'showFootballInGameStatsMockData',
+    showHockeyPreGameStatsMockData: 'showHockeyPreGameStatsMockData',
+    showHockeyInGameStatsMockData: 'showHockeyInGameStatsMockData',
+    // Shop use cases
+    shopTabLoadFailure: 'shopTabLoadFailure',
+    shopEmptyState: 'shopEmptyState',
+    shopMockData: 'shopMockData',
+    shopLiveData: 'shopLiveData',
+};
+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,45 @@
+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;
+};
+/**
+ 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(eventID: string, delegate: IMaestroEventDelegate, userSettings?: IUserSettings): Promise<IMaestroEvent>;
+    /**
+     * @description Tells the SDK the user has closed an event that was open in the app's player.
+     * @param eventID
+     */
+    userDidStopWatchingEvent(eventID: string): 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,15 @@
+export declare const MaestroPanelType: {
+    readonly KEY_PLAYS: "keyPlays";
+    readonly STATS: "stats";
+    readonly BETS: "bets";
+    readonly FANTASY: "fantasy";
+    readonly SHOP: "shop";
+};
+export type MaestroPanelType = typeof MaestroPanelType[keyof typeof MaestroPanelType];
+export interface PanelTypeInfo {
+    id: MaestroPanelType;
+    name: string;
+    imageNamePrefix: string;
+    iconName: string;
+}
+export declare const PANEL_TYPE_INFO: Record<MaestroPanelType, PanelTypeInfo>;

package/dist/src/models/IPanel.js

@@ -0,0 +1,40 @@
+export const MaestroPanelType = {
+    KEY_PLAYS: 'keyPlays',
+    STATS: 'stats',
+    BETS: 'bets',
+    FANTASY: 'fantasy',
+    SHOP: 'shop',
+};
+// The mapping information for each panel type
+export const PANEL_TYPE_INFO = {
+    [MaestroPanelType.KEY_PLAYS]: {
+        id: MaestroPanelType.KEY_PLAYS,
+        name: 'Key Plays',
+        imageNamePrefix: 'Key-Plays',
+        iconName: 'keyPlays',
+    },
+    [MaestroPanelType.STATS]: {
+        id: MaestroPanelType.STATS,
+        name: 'Stats',
+        imageNamePrefix: 'Stats',
+        iconName: 'stats',
+    },
+    [MaestroPanelType.BETS]: {
+        id: MaestroPanelType.BETS,
+        name: 'Bets',
+        imageNamePrefix: 'Bets',
+        iconName: 'bets',
+    },
+    [MaestroPanelType.FANTASY]: {
+        iconName: 'fantasy',
+        id: MaestroPanelType.FANTASY,
+        imageNamePrefix: 'Fantasy',
+        name: 'Fantasy',
+    },
+    [MaestroPanelType.SHOP]: {
+        iconName: 'shop',
+        id: MaestroPanelType.SHOP,
+        imageNamePrefix: 'Shop',
+        name: 'Shop',
+    },
+};

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

@@ -0,0 +1,77 @@
+import IModel from './IModel';
+type ObjectValues<T> = T[keyof T];
+export default interface ITheme extends IModel {
+    button: IThemeButton;
+    channelOfflineThumbnail?: string;
+    colors: IThemeColors;
+    creator: string;
+    desktopBackground?: string;
+    icon?: string;
+    logo?: string;
+    mobileBackground?: string;
+    mode?: ThemeModes;
+    name: string;
+    owner: string;
+    siteId?: string;
+    type: ThemeTypes;
+    typography: IThemeTypography;
+}
+export interface IThemeColors {
+    accentPrimary: string;
+    accentSecondary: string;
+    accentTertiary: string;
+    alertConfirmation: string;
+    alertError: string;
+    alertWarning: string;
+    highlightPrimary: string;
+    highlightSecondary: string;
+    highlightTertiary: string;
+    surface1: string;
+    surface2: string;
+    surface3: string;
+    surface4: string;
+    surface5: string;
+    surface6: string;
+    text100: string;
+    text200: string;
+    text300: string;
+    text400: string;
+    text500: string;
+}
+export interface IThemeButton {
+    borderRadius: BorderRadius;
+    textCapitalization: TextCapitalization;
+}
+export interface IThemeTypography {
+    body: string;
+    headline: string;
+}
+export interface IClassicThemeOptions {
+    accentPrimary: string;
+    accentSecondary: string;
+}
+export declare const BORDER_RADIUS: {
+    readonly rounded: "rounded";
+    readonly square: "square";
+    readonly pill: "pill";
+};
+export type BorderRadius = ObjectValues<typeof BORDER_RADIUS>;
+export declare const TEXT_CAPITALIZATION: {
+    readonly lowercase: "lowercase";
+    readonly original: "original";
+    readonly uppercase: "uppercase";
+};
+export type TextCapitalization = ObjectValues<typeof TEXT_CAPITALIZATION>;
+export declare const THEME_TYPES: {
+    readonly ADMIN: "admin";
+    readonly ADVANCED: "advanced";
+    readonly CLASSIC: "classic";
+    readonly CUSTOM: "custom";
+};
+export type ThemeTypes = ObjectValues<typeof THEME_TYPES>;
+export declare const THEME_MODES: {
+    readonly DARK: "dark";
+    readonly LIGHT: "light";
+};
+export type ThemeModes = ObjectValues<typeof THEME_MODES>;
+export {};

package/dist/src/models/ITheme.js

@@ -0,0 +1,20 @@
+export const BORDER_RADIUS = {
+    rounded: 'rounded',
+    square: 'square',
+    pill: 'pill',
+};
+export const TEXT_CAPITALIZATION = {
+    lowercase: 'lowercase',
+    original: 'original',
+    uppercase: 'uppercase',
+};
+export const THEME_TYPES = {
+    ADMIN: 'admin',
+    ADVANCED: 'advanced',
+    CLASSIC: 'classic',
+    CUSTOM: 'custom',
+};
+export const THEME_MODES = {
+    DARK: 'dark',
+    LIGHT: 'light',
+};