import * as react_jsx_runtime from 'react/jsx-runtime'; import * as react from 'react'; import { ReactNode } from 'react'; /** * MicroStrategy Embedding SDK Event Types * * Runtime constants for all supported event types in the MicroStrategy Embedding SDK. * Use these when registering event handlers on dashboard instances. * * @see https://microstrategy.github.io/embedding-sdk-docs/add-functionality/add-event * * @example * ```ts * import { EVENT_TYPE } from "embed-dossier-mstr-react"; * * dashboard.registerEventHandler( * EVENT_TYPE.ON_PAGE_SWITCHED, * (event) => console.log("Page switched", event) * ); * ``` */ declare const EVENT_TYPE: { readonly ON_COMPONENT_SELECTION_CHANGED: "onComponentSelectionChanged"; readonly ON_DOSSIER_AUTHORING_CLOSED: "onDossierAuthoringClosed"; readonly ON_DOSSIER_AUTHORING_SAVED: "onDossierAuthoringSaved"; readonly ON_DOSSIER_INSTANCE_CHANGED: "onDossierInstanceChanged"; readonly ON_DOSSIER_INSTANCE_ID_CHANGE: "onDossierInstanceIDChange"; readonly ON_ERROR: "onError"; readonly ON_FILTER_UPDATED: "onFilterUpdated"; readonly ON_GRAPHICS_SELECTED: "onGraphicsSelected"; readonly ON_LAYOUT_CHANGED: "onLayoutChanged"; readonly ON_LIBRARY_ITEM_SELECTED: "onLibraryItemSelected"; readonly ON_LIBRARY_ITEM_SELECTION_CLEARED: "onLibraryItemSelectionCleared"; readonly ON_LIBRARY_MENU_SELECTED: "onLibraryMenuSelected"; readonly ON_PAGE_LOADED: "onPageLoaded"; readonly ON_PAGE_RENDER_FINISHED: "onPageRenderFinished"; readonly ON_PAGE_SWITCHED: "onPageSwitched"; readonly ON_PANEL_SWITCHED: "onPanelSwitched"; readonly ON_PROMPT_ANSWERED: "onPromptAnswered"; readonly ON_PROMPT_LOADED: "onPromptLoaded"; readonly ON_SESSION_ERROR: "onSessionError"; readonly ON_VISUALIZATION_RESIZED: "onVisualizationResized"; readonly ON_VIZ_ELEMENT_CHANGED: "onVisualizationElementsChanged"; readonly ON_VIZ_SELECTION_CHANGED: "onVizSelectionChanged"; }; /** Union type of all event type values */ type EventTypeValue = (typeof EVENT_TYPE)[keyof typeof EVENT_TYPE]; /** Union of all MicroStrategy event type string values */ type EventTypes = EventTypeValue; /** * Event handler function signature. * * MicroStrategy SDK passes event-specific data to handlers. * Use `unknown` and narrow the type in your handler for type safety. */ type EventHandler = (event?: any) => void; /** Map of all available event handlers for MicroStrategy dashboards */ interface EventHandlers { onComponentSelectionChanged?: EventHandler; onDossierAuthoringClosed?: EventHandler; onDossierAuthoringSaved?: EventHandler; onDossierInstanceChanged?: EventHandler; onDossierInstanceIDChange?: EventHandler; onError?: EventHandler; onFilterUpdated?: EventHandler; onGraphicsSelected?: EventHandler; onLayoutChanged?: EventHandler; onLibraryItemSelected?: EventHandler; onLibraryItemSelectionCleared?: EventHandler; onLibraryMenuSelected?: EventHandler; onPageLoaded?: EventHandler; onPageRenderFinished?: EventHandler; onPageSwitched?: EventHandler; onPanelSwitched?: EventHandler; onPromptAnswered?: EventHandler; onPromptLoaded?: EventHandler; onSessionError?: EventHandler; onVisualizationResized?: EventHandler; onVisualizationElementsChanged?: EventHandler; onVizSelectionChanged?: EventHandler; } /** * This file contains the types for the filter that we use for applying filters to the dossier. * * For more information, please refer to the MicroStrategy SDK documentation. * @see https://microstrategy.github.io/embedding-sdk-docs/add-functionality/filters */ interface GeneralFilterItems { value: string; name: string; selected: boolean; } interface QualType { type: "highest" | "lowest" | "highest percent" | "lowest percent"; } interface FilterSelection { value?: string; name?: string; } interface FilterTypeInfo { items: GeneralFilterItems[]; supportMultiple: boolean; } interface FilterTypeInfoSlider extends FilterTypeInfo { indexInfo: { itemsLength: number; from: number; to: number; }; } interface FilterTypeInfoCalendar { from: string; to: string; maxDate: string; minDate: string; } interface FilterTypeInfoMetricQualByValue { operator: "equals" | "not equals" | "greater" | "greater equal" | "less" | "less equal" | "between" | "not between" | "in" | "not in" | "is null" | "is not null"; from?: string; to?: string; value?: string; } interface FilterTypeInfoMetricQualByRank { qualType: QualType; value: string; } interface FilterTypeInfoMetricSliderByValue { indexInfo: { itemsLength: number; itemsStep: number; from: number; to: number; }; min: number; max: number; from: number; to: number; } interface FilterTypeInfoMetricSliderByRank { indexInfo: { itemsLength: number; itemsStep: number; value: number; }; min: number; max: number; qualType: QualType; value: number; } interface FilterListType { filterKey: string; filterName: string; filterType: "attributeSelector" | "attributeSearchSelector"; filterDetail: FilterTypeInfo | FilterTypeInfoSlider | FilterTypeInfoCalendar | FilterTypeInfoMetricQualByValue | FilterTypeInfoMetricQualByRank | FilterTypeInfoMetricSliderByValue | FilterTypeInfoMetricSliderByRank; isExclude: boolean; } interface SelectionFilter { id: string; name: string; } interface FilterCreation { key: string; name: string; selections: SelectionFilter[]; } interface FilterJson { filterInfo: { key: string; }; selections?: FilterSelection[] | FilterSelection | number | number[]; date?: { from: string; to: string; }; exp?: { operator: "equals" | "not equals" | "greater" | "greater equal" | "less" | "less equal" | "between" | "not between" | "in" | "not in" | "is null" | "is not null"; firstValue?: string; lastValue?: string; qualType?: "highest" | "lowest" | "highest percent" | "lowest percent"; range?: number[]; value?: number; }; holdSubmit?: boolean; } interface DockedCommentAndFilter { dockedPosition?: "left" | "right"; canClose?: boolean; dockChangeable?: boolean; isDocked?: boolean; } interface DockedTheme extends DockedCommentAndFilter { theme?: "light" | "dark"; } interface NavigationBar { enabled?: boolean; gotoLibrary?: boolean; title?: boolean; toc?: boolean; reset?: boolean; reprompt?: boolean; share?: boolean; comment?: boolean; notification?: boolean; filter?: boolean; options?: boolean; bookmark?: boolean; undoRedo?: boolean; edit?: boolean; } interface CustomUi { library?: { navigationBar?: { enabled?: boolean; sortAndFilter?: boolean; title?: boolean; searchBar?: boolean; createNew?: { enabled?: boolean; }; notification?: boolean; multiSelect?: { enabled?: boolean; }; account?: { enabled?: boolean; }; user?: { enabled?: boolean; }; }; sidebar?: { enabled?: boolean; show?: boolean; }; }; reportConsumption?: { enabled?: boolean; goToLibrary?: boolean; pageBy?: boolean; reset?: boolean; reExecute?: boolean; filter?: boolean; rePrompt?: boolean; account?: { enabled?: boolean; }; share?: { enabled?: boolean; }; }; dossierConsumption?: { navigationBar?: { enabled?: boolean; goToLibrary?: boolean; title?: boolean; toc?: boolean; reset?: boolean; reprompt?: boolean; share?: boolean; comment?: boolean; notification?: boolean; filter?: boolean; options?: boolean; bookmark?: boolean; undoRedo?: boolean; search?: boolean; edit?: boolean; dockedToc?: { isOpen?: boolean; isDocked?: boolean; }; }; }; botConsumption?: { aiBot?: { titleBar?: { enabled?: boolean; }; snapshotPanel?: { enabled?: boolean; }; topicsPanel?: { enabled?: boolean; }; chatPanel?: { showClearHistory?: boolean; showGiveTopics?: boolean; showWelcomePageBotImg?: boolean; showCopyBtn?: boolean; shouldLoadHistory?: boolean; shouldSaveToHistory?: boolean; }; }; navigationBar?: { enabled?: boolean; }; }; dossierAuthoring?: { toolbar?: { tableOfContents?: { visible?: boolean; }; undo?: { visible?: boolean; }; redo?: { visible?: boolean; }; refresh?: { visible?: boolean; }; save?: { visible?: boolean; }; more?: { visible?: boolean; }; nlp?: { visible?: boolean; }; freeformLayout?: { visible?: boolean; }; pauseDataRetrieval?: { visible?: boolean; }; dividerLeft?: { visible?: boolean; }; dividerRight?: { visible?: boolean; }; addData?: { visible?: boolean; }; addChapter?: { visible?: boolean; }; addPage?: { visible?: boolean; }; insertVisualization?: { visible?: boolean; }; insertFilter?: { visible?: boolean; }; insertText?: { visible?: boolean; }; insertImage?: { visible?: boolean; }; insertHtml?: { visible?: boolean; }; insertShape?: { visible?: boolean; }; insertStack?: { visible?: boolean; }; insertInfoWindow?: { visible?: boolean; }; responsiveViewEditor?: { visible?: boolean; }; responsivePreview?: { visible?: boolean; }; }; menubar?: { library?: { visible?: boolean; }; }; }; } interface OptionsFeature { enabled?: boolean; help?: boolean; logout?: boolean; manage?: boolean; showLibraries?: boolean; showTutorials?: boolean; preferences?: boolean; } interface ShareFeature { enabled?: boolean; invite?: boolean; link?: boolean; email?: boolean; export?: boolean; download?: boolean; shareDossier?: boolean; subscribe?: boolean; } interface CurrentPage { key: string; targetGroup?: { id?: string; name?: string; }; } interface PageInfo { applicationId?: string; projectId?: string; objectId?: string; pageKey?: string; isAuthoring?: boolean; } interface ErrorHandlerInterface { title: string; message: string; desc: string; statusCode: string | number; errorCode: string | number; isServerErrorCode: boolean; ticketId: string; } interface TableOfContents { chapters: DossierChapter[]; } interface DossierPage { name: string; nodeKey: string; } interface DossierChapter { name: string; nodeKey: string; pages: DossierPage[]; getNextChapter: () => any; getPrevChapter: () => any; getFirstPage: () => any; getLastPage: () => any; } interface DossierConsumptionSettings { componentSelectionMode: "noSelection" | "singleSelection" | "multipleSelection"; disableManipulationsAutoSaving?: boolean; enablePageSelection?: boolean; disableGroupSelection?: boolean; } interface BotConsumptionSettings { disableManipulationsAutoSaving?: boolean; } interface Settings { dossierConsumption?: DossierConsumptionSettings; botConsumption?: BotConsumptionSettings; } /** * MicroStrategy SDK * * This global declare for MicroStrategy SDK is used to declare the global * window object for MicroStrategy SDK. * * For more information, please refer to the MicroStrategy SDK documentation. * @see https://microstrategy.github.io/embedding-sdk-docs * */ declare global { interface Window { microstrategy: MicroStrategySDK; } } /** * Interface for MicroStrategy SDK * * These are some interfaces that we need for embedding dossier. * Interfaces that we create are based on the MicroStrategy SDK documentation and also the implementation on the MicroStrategy Embedding SDK Playground. * * For more information, please refer to the MicroStrategy SDK documentation. * @see https://microstrategy.github.io/embedding-sdk-docs/playground/ * */ interface MicroStrategySDK { dossier: { create: (config: MicroStrategyDossierConfig) => Promise; destroy: () => void; CustomAuthenticationType: { AUTH_TOKEN: string; IDENTITY_TOKEN: string; }; EventType: Record; }; auth: { oidcLogin: (serverUrl: string) => Promise; samlLogin: (serverUrl: string) => Promise; }; embedding: { featureFlags: Record; }; embeddingContexts: { embedLibraryPage: (config: EmbedLibraryPageConfig) => Promise; embedDossierConsumptionPage: (config: EmbedDossierConsumptionPageConfig) => Promise; embedBotConsumptionPage: (config: EmbedBotConsumptionPageConfig) => Promise; embedReportPage: (config: EmbedReportPageConfig) => Promise; }; } /** * Interfaces for Embedding types of Embedded Dashboard and other Embedding Contexts * * When this package created, we only need to create the interface for MicroStrategy Dossier. * But when we want to create the interface for other Embedding Contexts, we need to create the interface for them. * * Each Embedding Context has its own properties and methods. * * For more information, please refer to the MicroStrategy SDK documentation. * @see https://microstrategy.github.io/embedding-sdk-docs * */ /** * Interface for MicroStrategy Dossier Config Properties * * This interface is used to declare the MicroStrategy Dossier Config Properties. * * For more information, please refer to the MicroStrategy SDK documentation. * @see https://microstrategy.github.io/embedding-sdk-docs/add-functionality/methods-and-properties * */ interface MicroStrategyDossierConfig { placeholder: HTMLDivElement | null; url: string; containerHeight?: string; containerWidth?: string; customAuthenticationType?: MicroStrategyDossierConfigCustomAuthenticationType | string; disableNotification?: boolean; disableErrorPopupWindow?: boolean; dockedComment?: DockedCommentAndFilter; dockedFilter?: DockedCommentAndFilter; dockedTheme?: DockedTheme; dockedToc?: { dockedPosition?: "left" | "right"; theme?: "light" | "dark"; canClose?: boolean; dockChangeable?: boolean; isDocked?: boolean; }; dossierFeature?: { readonly?: boolean; }; enableCollaboration?: boolean; enableCustomAuthentication?: boolean; enableResponsive?: boolean; filterFeature?: { enabled?: boolean; edit?: boolean; summary?: boolean; }; filters?: FilterCreation[]; getLoginToken?: () => Promise; instance?: { mid?: string; id?: string; status?: string | number; partialManipulation?: boolean; }; navigationBar?: NavigationBar; customUi?: CustomUi; optionsFeature?: OptionsFeature; shareFeature?: ShareFeature; smartBanner?: boolean; tocFeature?: { enabled?: boolean; }; uiMessage?: { enabled?: boolean; addToLibrary?: boolean; }; visibleTutorials?: { library: boolean; welcome: boolean; dossier: boolean; notification: boolean; }; dossierRenderingMode?: "consumption" | "authoring"; /** * * The authoring props managed tools or features that are available in the authoring mode. * * For more information, please refer to the MicroStrategy SDK documentation. * @see https://microstrategy.github.io/embedding-sdk-docs/add-functionality/authoring-library * * The following properties are available: * - menubar * - toolbar * - panelVisibility */ authoring?: { menubar?: { library?: { visible?: boolean; }; }; toolbar?: { tableOfContents?: { visible?: boolean; }; undo?: { visible?: boolean; }; redo?: { visible?: boolean; }; refresh?: { visible?: boolean; }; pauseDataRetrieval?: { visible?: boolean; }; reprompt?: { visible?: boolean; }; dividerLeft?: { visible?: boolean; }; addData?: { visible?: boolean; }; addChapter?: { visible?: boolean; }; addPage?: { visible?: boolean; }; insertVisualization?: { visible?: boolean; }; insertFilter?: { visible?: boolean; }; insertText?: { visible?: boolean; }; insertImage?: { visible?: boolean; }; insertHtml?: { visible?: boolean; }; insertShape?: { visible?: boolean; }; insertPanelStack?: { visible?: boolean; }; insertInfoWindow?: { visible?: boolean; }; save?: { visible?: boolean; }; dividerRight?: { visible?: boolean; }; more?: { visible?: boolean; }; freeformLayout?: { visible?: boolean; }; nlp?: { visible?: boolean; }; responsiveViewEditor?: { visible?: boolean; }; responsivePreview?: { visible?: boolean; }; }; panelVisibility?: { contents?: boolean; datasets?: boolean; editor?: boolean; filter?: boolean; format?: boolean; layers?: boolean; }; }; disableCustomErrorHandlerOnCreate?: boolean; sessionErrorHandler?: (error: ErrorHandlerInterface) => void; errorHandler?: (error: ErrorHandlerInterface) => void; } /** * Interface for MicroStrategy Dossier Config Custom Authentication Type * * This interface is used to declare the MicroStrategy Dossier Config Custom Authentication Type. * * In MicroStrategy Embedding SDK, we can use two types of authentication: AUTH_TOKEN and IDENTITY_TOKEN. * * For more information, please refer to the MicroStrategy SDK documentation. * @see https://microstrategy.github.io/embedding-sdk-docs/add-functionality/methods-and-properties * */ interface MicroStrategyDossierConfigCustomAuthenticationType { AUTH_TOKEN: string; IDENTITY_TOKEN: string; } /** * Interface for MicroStrategy Dossier Dashboard APIs * * This interface is used to declare the MicroStrategy Dossier Dashboard that will be viewed on the web page. * * For more information, please refer to the MicroStrategy SDK documentation. * @see https://microstrategy.github.io/embedding-sdk-docs/add-functionality/methods-and-properties * */ interface MicroStrategyDossier { close: () => void; refresh: () => void; resize: (width: string, height: string) => void; /** * Instance * * Get the instance ID of the dossier * @returns Promise */ getDossierInstanceId: () => Promise; /** * Filter * * Get the filter list * @returns Promise */ getFilterList: () => Promise; /** * Filter * * Filter methods * * @params FilterJson (most of the methods are using this type) * For more information, please refer to the MicroStrategy SDK documentation. * @see https://microstrategy.github.io/embedding-sdk-docs/add-functionality/filters */ filterSelectAllAttributes: (params: FilterJson) => void; filterDeselectAllAttributes: (params: FilterJson) => void; filterSelectSingleAttribute: (params: FilterJson) => void; filterSelectMultiAttributes: (params: FilterJson) => void; filterSearchSingleAttribute: (params: FilterJson) => void; filterSearchMultiAttributes: (params: FilterJson) => void; filterAttributeSingleSlider: (params: FilterJson) => void; filterAttributeMultiSlider: (params: FilterJson) => void; filterSetDateRange: (params: FilterJson) => void; filterSetMetricQualByValue: (params: FilterJson) => void; filterSetMetricQualByRank: (params: FilterJson) => void; filterSetMetricSliderByValue: (params: FilterJson) => void; filterSetMetricSliderByRank: (params: FilterJson) => void; filterClearAll: () => void; filterClear: (params: FilterJson) => void; filterSetInclude: (params: FilterJson) => void; filterSetExclude: (params: FilterJson) => void; filterApplyAll: () => void; /** * Switch to Mode * * Switch to the mode of the dossier * @param mode "consumption" | "authoring" * @returns Promise */ switchToMode?: (mode: "consumption" | "authoring") => Promise; /** * Navigation * * Once you have embedded a dashboard, you can use helper methods in the Embedding SDK to let users navigate within the dashboard. * * For example, you can add code to get the table of contents for the dashboard, go to the previous or next page, navigate to a specific page, get the current page or chapter, get a specific page, or get a list of pages, chapters and visualizations. * * For more information, please refer to the MicroStrategy SDK documentation. * @see https://microstrategy.github.io/embedding-sdk-docs/add-functionality/add-nav */ getTableOfContents: () => TableOfContents; goToPrevPage: () => Promise<{ valid: boolean; message: string; } | void>; goToNextPage: () => Promise<{ valid: boolean; message: string; } | void>; navigateToPage: (page: DossierPage) => Promise<{ valid: boolean; message: string; } | void>; getCurrentChapter: () => DossierChapter; getCurrentPage: () => DossierPage; getPageByNodeKey: (nodeKey: string) => DossierPage; getChapterList: () => DossierChapter[]; getCurrentPageVisualizationList: () => Promise<[ { key: string; name: string; } ]>; openFilterSummaryBar: () => void | null; closeFilterSummaryBar: () => void | null; getPageList: () => DossierPage[]; /** * Event Handlers * * You could use these methods to customize the behavior of the dossier. * * For more information, please refer to the MicroStrategy SDK documentation. * @see https://microstrategy.github.io/embedding-sdk-docs/add-functionality/add-event#registereventhandlerevtname-handler */ registerEventHandler: (event: EventTypes, handler: EventHandler) => void; removeEventHandler: (event: EventTypes, handler: EventHandler) => void; /** * Wrapper Functions for Event Handlers * * The following wrapper functions make it easy to register event handlers for specific events. * * For more information, please refer to the MicroStrategy SDK documentation. * @see https://microstrategy.github.io/embedding-sdk-docs/add-functionality/add-event#wrapper-functions */ registerGraphicsSelectEventHandlerToViz: (vizKey: string, handler: EventHandler) => void; registerFilterUpdateHandler: (handler: EventHandler) => void; registerPageSwitchHandler: (handler: EventHandler) => void; registerDossierInstanceIDChangeHandler: (handler: EventHandler) => void; removeCustomErrorHandler?: (error: ErrorHandlerInterface) => void; removeSessionHandler: () => void; /** * * The following methods are used to handle errors. * These methods are used to handle errors that occur during the creation of the dossier. * * @param error * About the params itself would be return ErrorHandlerInterface * * @returns * Return could be any void */ addCustomErrorHandler: (handler: (error: ErrorHandlerInterface) => void, showErrorPopup: boolean) => void; addSessionErrorHandler: (handler: (error: ErrorHandlerInterface) => void, showErrorPopup: boolean) => void; } /** * Interface for Embedding Contexts APIs * * This interface is used to declare the Embedding Contexts APIs. * * For more information, please refer to the MicroStrategy SDK documentation. * @see https://microstrategy.github.io/embedding-sdk-docs/add-functionality/methods-and-properties * */ interface EmbeddingContexts { embedLibraryPage: (params: EmbedLibraryPageConfig) => Promise; embedDossierConsumptionPage: (params: EmbedDossierConsumptionPageConfig) => Promise; embedBotConsumptionPage: (params: EmbedBotConsumptionPageConfig) => Promise; embedReportPage: (params: EmbedReportPageConfig) => Promise; registerEventHandler: (event: EventTypes, handler: EventHandler) => void; removeEventHandler: (event: EventTypes, handler: EventHandler) => void; removeCustomErrorHandler: () => void; removeSessionErrorHandler: () => void; goToPage: (pageInfo: PageInfo) => Promise<{ redirect: boolean; }>; addCustomErrorHandler: (handler: (error: ErrorHandlerInterface) => void, showErrorPopup: boolean) => void; addSessionErrorHandler: (handler: (error: ErrorHandlerInterface) => void, showErrorPopup: boolean) => void; } /** * Interface for Embed Library Page Config * * This interface is used to declare the Embed Library Page Config. * * For more information, please refer to the MicroStrategy SDK documentation. * @see https://microstrategy.github.io/embedding-sdk-docs/add-functionality/methods-and-properties * */ interface EmbedLibraryPageConfig { placeholder: HTMLElement | null; serverUrl: string; containerHeight?: string; containerWidth?: string; enableCustomAuthentication?: boolean; customAuthenticationType?: MicroStrategyDossierConfigCustomAuthenticationType | string; getLoginToken?: () => Promise; disableCustomErrorHandlerOnCreate?: boolean; errorHandler?: (error: ErrorHandlerInterface) => void; sessionErrorHandler?: (error: ErrorHandlerInterface) => void; customUi?: CustomUi; libraryItemSelectMode?: "single" | "multiple"; currentPage?: CurrentPage; } /** * Interface for EmbedLibraryPage APIs * * The LibraryPage object is the manipulator of the MicroStrategy Library home page. It could be got by embeddingContext.libraryPage. * * For more information, please refer to the MicroStrategy SDK documentation. * @see https://microstrategy.github.io/embedding-sdk-docs/add-functionality/methods-and-properties * */ interface EmbedLibraryPage { getAllMyGroups?: () => Promise<{ id: string; name: string; }[]>; getAllDefaultGroups?: () => Promise<{ id: string; name: string; }[]>; setNavigationBarEnabled?: (enabled: boolean) => void; setSidebarVisibility?: (shown: boolean) => void; addCustomErrorHandler?: (handler: (error: ErrorHandlerInterface) => void, showErrorPopup: boolean) => void; addSessionErrorHandler?: (handler: (error: ErrorHandlerInterface) => void, showErrorPopup: boolean) => void; } /** * Interface for Embed Dossier Consumption Page Config * * This interface is used to declare the Embed Dossier Consumption Page Config. * * For more information, please refer to the MicroStrategy SDK documentation. * @see https://microstrategy.github.io/embedding-sdk-docs/add-functionality/methods-and-properties * */ interface EmbedDossierConsumptionPageConfig { placeholder: HTMLDivElement | null; serverUrl: string; projectId: string; objectId: string; customApplicationId?: string; enableCustomAuthentication?: boolean; pageKey?: string; containerHeight?: string; containerWidth?: string; customAuthenticationType?: MicroStrategyDossierConfigCustomAuthenticationType | string; getLoginToken?: () => Promise; disableCustomErrorHandlerOnCreate?: boolean; errorHandler?: (error: ErrorHandlerInterface) => void; sessionErrorHandler?: (error: ErrorHandlerInterface) => void; customUi?: CustomUi; settings?: Pick | Pick; } interface EmbedDossierConsumptionPage { addCustomErrorHandler: (handler: (error: ErrorHandlerInterface) => void, showErrorPopup: boolean) => void; addSessionErrorHandler: (handler: (error: ErrorHandlerInterface) => void, showErrorPopup: boolean) => void; } /** * Interface for Embed Bot Consumption Page Config * * This interface is used to declare the Embed Bot Consumption Page Config. * * For more information, please refer to the MicroStrategy SDK documentation. * @see https://microstrategy.github.io/embedding-sdk-docs/add-functionality/methods-and-properties * */ interface EmbedBotConsumptionPageConfig extends EmbedDossierConsumptionPageConfig { disableHyper?: boolean; permissions?: { allowClipboardWrite?: boolean; }; } /** * Interface for Embed Bot Consumption Page APIs * * This interface is used to declare the Embed Bot Consumption Page APIs. * * For more information, please refer to the MicroStrategy SDK documentation. * @see https://microstrategy.github.io/embedding-sdk-docs/add-functionality/methods-and-properties * */ interface EmbedBotConsumptionPage { } /** * Interface for Embed Report Page Config * * This interface is used to declare the Embed Report Page Config. * */ interface EmbedReportPageConfig extends EmbedDossierConsumptionPageConfig { } /** * Interface for Embed Report Page APIs * * This interface is used to declare the Embed Report Page APIs. * * For more information, please refer to the MicroStrategy SDK documentation. * @see https://microstrategy.github.io/embedding-sdk-docs/add-functionality/methods-and-properties * */ interface EmbedReportPage { } interface DashboardEmbedProps { /** Full MicroStrategy dossier URL: `https://{host}/{libraryName}/app/{projectId}/{dossierId}` */ dossierUrl: string; /** Optional CSS class names */ className?: string; /** Optional inline styles */ style?: React.CSSProperties; /** Dashboard configuration options */ config?: Omit; } /** * Embeds a MicroStrategy Dashboard into your React application. * * This is the simplest way to embed a dashboard — just provide a URL and optional config. * The component handles SDK loading, dashboard creation, and cleanup automatically. * * @example * ```tsx * * ``` */ declare const DashboardEmbed: ({ dossierUrl, className, style, config, }: DashboardEmbedProps) => react_jsx_runtime.JSX.Element; interface DashboardEmbedWithAuthProps { /** Full MicroStrategy dossier URL */ dossierUrl: string; /** Optional CSS class names */ className?: string; /** Optional inline styles */ style?: React.CSSProperties; /** Dashboard configuration options */ config?: Omit; /** Authentication method */ loginMode: "guest" | "standard" | "saml" | "oidc" | "ldap"; /** Username for standard/LDAP authentication */ username?: string; /** Password for standard/LDAP authentication */ password?: string; /** Custom loading component shown during authentication */ loadingComponent?: ReactNode; /** Custom error component — receives the error message string */ errorComponent?: ReactNode | ((error: string) => ReactNode); } /** * Embeds a MicroStrategy Dashboard with built-in authentication. * * Supports Guest, Standard, LDAP, SAML, and OIDC authentication methods. * Provides customizable loading and error states. * * @example * ```tsx * } * errorComponent={(error) => } * /> * ``` */ declare const DashboardEmbedWithAuth: ({ dossierUrl, className, style, config, loginMode, username, password, loadingComponent, errorComponent, }: DashboardEmbedWithAuthProps) => react_jsx_runtime.JSX.Element; interface LibraryPageEmbedProps { /** Base URL of the MicroStrategy Library server */ serverUrlLibrary: string; /** Library page configuration */ config?: Omit; /** Optional CSS class names */ className?: string; /** Optional inline styles */ style?: React.CSSProperties; } /** * Embeds a MicroStrategy Library Page. * * @example * ```tsx * * ``` */ declare const LibraryPageEmbed: ({ serverUrlLibrary, config, className, style, }: LibraryPageEmbedProps) => react_jsx_runtime.JSX.Element; interface LibraryPageEmbedWithAuthProps { /** Base URL of the MicroStrategy Library server */ serverUrlLibrary: string; /** Library page configuration */ config?: Omit; /** Authentication method */ loginMode: "guest" | "standard" | "saml" | "oidc" | "ldap"; /** Username for standard/LDAP authentication */ username?: string; /** Password for standard/LDAP authentication */ password?: string; /** Optional CSS class names */ className?: string; /** Optional inline styles */ style?: React.CSSProperties; /** Custom loading component */ loadingComponent?: React.ReactNode; /** Custom error component — receives error message */ errorComponent?: (error: string) => React.ReactNode; } /** * Embeds a MicroStrategy Library Page with built-in authentication. * * @example * ```tsx * * ``` */ declare const LibraryPageEmbedWithAuth: ({ serverUrlLibrary, config, loginMode, username, password, className, style, loadingComponent, errorComponent, }: LibraryPageEmbedWithAuthProps) => react_jsx_runtime.JSX.Element; interface BotConsumptionPageProps { /** Base URL of the MicroStrategy Library server */ serverUrlLibrary: string; /** MicroStrategy project ID */ projectId: string; /** Bot object ID */ objectId: string; /** Bot page configuration */ config: Omit; /** Optional CSS class names */ className?: string; /** Optional inline styles */ style?: React.CSSProperties; } /** * Embeds a MicroStrategy Bot Consumption Page. * * @example * ```tsx * * ``` */ declare const BotConsumptionPage: ({ serverUrlLibrary, projectId, objectId, config, className, style, }: BotConsumptionPageProps) => react_jsx_runtime.JSX.Element; interface BotConsumptionPageWithAuthProps { /** Base URL of the MicroStrategy Library server */ serverUrlLibrary: string; /** MicroStrategy project ID */ projectId: string; /** Bot object ID */ objectId: string; /** Bot page configuration */ config: Omit; /** Authentication method */ loginMode: "guest" | "standard" | "saml" | "oidc" | "ldap"; /** Username for standard/LDAP authentication */ username?: string; /** Password for standard/LDAP authentication */ password?: string; /** Optional CSS class names */ className?: string; /** Optional inline styles */ style?: React.CSSProperties; /** Custom loading component */ loadingComponent?: React.ReactNode; /** Custom error component — receives error message */ errorComponent?: (error: string) => React.ReactNode; } /** * Embeds a MicroStrategy Bot Consumption Page with built-in authentication. * * @example * ```tsx * * ``` */ declare const BotConsumptionPageWithAuth: ({ serverUrlLibrary, projectId, objectId, config, loginMode, username, password, className, style, loadingComponent, errorComponent, }: BotConsumptionPageWithAuthProps) => react_jsx_runtime.JSX.Element | null; /** * Custom hook to load the MicroStrategy Embedding SDK. * * Dynamically injects the MicroStrategy `embeddinglib.js` script into the page. * Handles the case where the SDK is already loaded, and cleans up on unmount. * * @param serverUrlLibrary - Base URL of the MicroStrategy Library server * @returns `isSdkLoaded` - Whether the SDK script has loaded successfully * @returns `isSdkError` - Error state with `isError` flag and `message` * * @example * ```ts * const { isSdkLoaded, isSdkError } = useLoadMstrSDK({ * serverUrlLibrary: "https://demo.microstrategy.com/MicroStrategyLibrary" * }); * ``` */ declare const useLoadMstrSDK: ({ serverUrlLibrary }: { serverUrlLibrary: string; }) => { isSdkLoaded: boolean; isSdkError: { isError: boolean; message: string; }; }; interface UseCreateDashboardProps { serverUrlLibrary: string; config: Omit; } /** * Custom hook to create and manage a MicroStrategy Dashboard instance. * * Handles SDK loading, dashboard creation, and cleanup on unmount. * * @param serverUrlLibrary - Base URL of the MicroStrategy Library server * @param config - Dashboard configuration (URL, features, etc.) * @returns `dashboard` - The dashboard instance (null until created) * @returns `containerRef` - Ref to attach to the container div * @returns `isSdkLoaded` - Whether the SDK has loaded * @returns `isDashboardError` - Whether dashboard creation failed * * @example * ```tsx * const { dashboard, containerRef, isSdkLoaded, isDashboardError } = * useCreateDashboard({ * serverUrlLibrary: "https://demo.microstrategy.com/MicroStrategyLibrary", * config: { url: dossierUrl }, * }); * * return
; * ``` */ declare const useCreateDashboard: ({ serverUrlLibrary, config, }: UseCreateDashboardProps) => { dashboard: MicroStrategyDossier | null; containerRef: react.RefObject; isSdkLoaded: boolean; isDashboardError: boolean; }; /** * Custom hook for creating and managing authenticated MicroStrategy dashboards * * This hook handles the complete lifecycle of dashboard authentication and creation: * - Multiple authentication methods support * - Token management * - Dashboard initialization * - Error handling * * Supported authentication methods: * - Guest authentication (no credentials required) * - Standard authentication (username/password) * - LDAP authentication (username/password) * - SAML authentication (redirect to identity provider) * - OIDC authentication (OpenID Connect flow) * * @see https://microstrategy.github.io/embedding-sdk-docs/support-for-different-authentication-environments/ */ /** * Props interface for useCreateDashboardWithAuth hook * * @property serverUrlLibrary - Base URL for the MicroStrategy Library server * @property placeholder - DOM element where the dashboard will be rendered * @property config - Dashboard configuration excluding placeholder * @property loginMode - Authentication method to use * @property username - Optional username for standard/LDAP auth * @property password - Optional password for standard/LDAP auth */ interface UseCreateDashboardWithAuthProps { serverUrlLibrary: string; placeholder: HTMLDivElement | null; config: Omit; loginMode: "guest" | "standard" | "saml" | "oidc" | "ldap"; username?: string; password?: string; } /** * Custom hook for creating authenticated MicroStrategy dashboards * * This hook manages the complete lifecycle of an authenticated dashboard: * 1. Loads the MicroStrategy SDK * 2. Handles authentication based on the specified login mode * 3. Creates and initializes the dashboard * 4. Manages authentication state and errors * * @param props - Hook configuration of type UseCreateDashboardWithAuthProps * @returns Object containing dashboard instance and authentication state * * @example * ```tsx * const { dashboard, isAuthenticating, error } = useCreateDashboardWithAuth({ * serverUrlLibrary: "https://your-mstr-server", * placeholder: divRef.current, * config: { url: "dashboard-url", ... }, * loginMode: "standard", * username: "user", * password: "pass" * }); * ``` */ declare const useCreateDashboardWithAuth: ({ serverUrlLibrary, placeholder, config, loginMode, username, password, }: UseCreateDashboardWithAuthProps) => { isAuthenticated: boolean; isAuthenticating: boolean; error: string | null; dashboard: MicroStrategyDossier | null; }; /** * Props interface for useCreateLibraryPage * * @property serverUrlLibrary - Base URL for the MicroStrategy Library * @property config - Library page configuration excluding placeholder and serverUrl */ interface UseCreateLibraryPageProps { serverUrlLibrary: string; config?: Omit; } /** * Custom hook for creating a MicroStrategy Library Page * * This hook handles the creation and management of an embedded Library page. * For more information, see: * @see https://microstrategy.github.io/embedding-sdk-docs/add-functionality/embedding-contexts */ declare const useCreateLibraryPage: ({ serverUrlLibrary, config, }: UseCreateLibraryPageProps) => { libraryPage: EmbedLibraryPage | null; libraryPageRef: react.RefObject; isSdkLoaded: boolean; isLoading: boolean; error: string | null; }; interface UseCreateLibraryPageWithAuthProps { serverUrlLibrary: string; placeholder: HTMLDivElement | null; config?: Omit; loginMode: "guest" | "standard" | "saml" | "oidc" | "ldap"; username?: string; password?: string; } declare const useCreateLibraryPageWithAuth: ({ serverUrlLibrary, placeholder, config, loginMode, username, password, }: UseCreateLibraryPageWithAuthProps) => { isAuthenticated: boolean; error: string | null; libraryPage: EmbedLibraryPage | null; }; interface UseCreateBotConsumptionPageProps { serverUrlLibrary: string; projectId: string; objectId: string; config: Omit; } declare const useCreateBotConsumptionPage: ({ serverUrlLibrary, projectId, objectId, config, }: UseCreateBotConsumptionPageProps) => { botConsumptionPage: EmbedBotConsumptionPage | null; botConsumptionPageRef: react.RefObject; isBotConsumptionPageError: boolean; isSdkError: { isError: boolean; message: string; }; isSdkLoaded: boolean; }; interface UseCreateBotConsumptionPageWithAuthProps { serverUrlLibrary: string; placeholder: HTMLDivElement | null; projectId: string; objectId: string; config: Omit; loginMode: "guest" | "standard" | "saml" | "oidc" | "ldap"; username?: string; password?: string; } declare const useCreateBotConsumptionPageWithAuth: ({ serverUrlLibrary, placeholder, projectId, objectId, config, loginMode, username, password, }: UseCreateBotConsumptionPageWithAuthProps) => { isAuthenticated: boolean; isAuthenticating: boolean; error: string | null; botConsumptionPage: EmbedBotConsumptionPage | null; }; /** * URL Parsing Utilities for MicroStrategy Embedding * * @module utils */ /** * Extracts server URL, library name, project ID, and dossier ID from a MicroStrategy dossier URL. * * @param url - Full MicroStrategy dossier URL * Format: `https://{host}/{libraryName}/app/{projectId}/{dossierId}` * @returns Parsed URL components * @throws {Error} If the URL format is invalid * * @example * ```ts * const info = getInfoFromUrl( * "https://demo.microstrategy.com/MicroStrategyLibrary/app/B7CA92F0/27D332AC" * ); * // info.serverUrl === "https://demo.microstrategy.com" * // info.serverUrlLibrary === "https://demo.microstrategy.com/MicroStrategyLibrary" * // info.libraryName === "MicroStrategyLibrary" * // info.projectId === "B7CA92F0" * // info.dossierId === "27D332AC" * ``` */ declare const getInfoFromUrl: (url: string) => { serverUrl: string; serverUrlLibrary: string; libraryName: string | undefined; projectId: string | undefined; dossierId: string | undefined; }; /** * Extracts the MicroStrategy Library server URL from a full dossier URL. * * @param url - Full dossier URL containing `/app/` path segment * @returns The server URL up to and including the library name * * @example * ```ts * getServerUrl("https://demo.microstrategy.com/MicroStrategyLibrary/app/B7CA/27D3"); * // => "https://demo.microstrategy.com/MicroStrategyLibrary" * ``` */ declare const getServerUrl: (url: string) => string; /** * Retrieves an existing authentication token from the MicroStrategy Library server. * * Uses the session-based token endpoint. Requires an active session (cookies). * * @param serverUrlLibrary - Base URL of the MicroStrategy Library * @returns The authentication token string, or undefined if not authenticated * * @example * ```ts * const token = await getAuthToken({ * serverUrlLibrary: "https://demo.microstrategy.com/MicroStrategyLibrary" * }); * ``` */ declare const getAuthToken: ({ serverUrlLibrary, }: { serverUrlLibrary: string; }) => Promise; export { BotConsumptionPage, type BotConsumptionPageProps, BotConsumptionPageWithAuth, type BotConsumptionPageWithAuthProps, type BotConsumptionSettings, type CurrentPage, type CustomUi, DashboardEmbed, type DashboardEmbedProps, DashboardEmbedWithAuth, type DashboardEmbedWithAuthProps, type DockedCommentAndFilter, type DockedTheme, type DossierChapter, type DossierConsumptionSettings, type DossierPage, EVENT_TYPE, type EmbedBotConsumptionPage, type EmbedBotConsumptionPageConfig, type EmbedDossierConsumptionPage, type EmbedDossierConsumptionPageConfig, type EmbedLibraryPage, type EmbedLibraryPageConfig, type EmbedReportPage, type EmbedReportPageConfig, type EmbeddingContexts, type EventHandler, type EventHandlers, type EventTypeValue, type EventTypes, type FilterTypeInfoCalendar, type FilterTypeInfoMetricQualByValue, LibraryPageEmbed, type LibraryPageEmbedProps, LibraryPageEmbedWithAuth, type LibraryPageEmbedWithAuthProps, type MicroStrategyDossier, type MicroStrategyDossierConfig, type MicroStrategyDossierConfigCustomAuthenticationType, type MicroStrategySDK, type NavigationBar, type OptionsFeature, type PageInfo, type Settings, type ShareFeature, type TableOfContents, type UseCreateDashboardProps, getAuthToken, getInfoFromUrl, getServerUrl, useCreateBotConsumptionPage, useCreateBotConsumptionPageWithAuth, useCreateDashboard, useCreateDashboardWithAuth, useCreateLibraryPage, useCreateLibraryPageWithAuth, useLoadMstrSDK };