react-semaphor 0.1.504 → 0.1.505

package/dist/types/lib/query-context/global-date-filter-materialization.d.ts

@@ -0,0 +1,65 @@
+import { TFilter, TFilterValue } from '../../components/surfboard/filter/types.js';
+import { ResolvedDashboardDateComparisonInput, TCard, TDashboard } from '../types/common-types.js';
+import { CardConfig } from '../types/explorer-types.js';
+import { ResolvedPrimaryDateField, SemanticExecutionPayload } from '../types/semantic-runtime-types.js';
+import { ResolvedCardDateFields } from './resolve-card-primary-date-field.js';
+import { DashboardDateComparisonPlan } from '../dashboard-inputs/dashboard-date-comparison-plan.js';
+export declare function normalizeDashboardGlobalDateFilterValue(params: {
+    globalDateFilter?: TFilter;
+    globalDateFilterValue?: TFilterValue;
+    timezone?: string;
+    allowMinutePrecision?: boolean;
+}): TFilterValue | undefined;
+export declare function normalizeDashboardGlobalDateFilterValues(params: {
+    filters?: TFilter[];
+    filterValues: TFilterValue[];
+    dashboard?: TDashboard | Pick<TDashboard, 'filters' | 'sheets'>;
+    semanticExecutionPayload?: SemanticExecutionPayload;
+    timezone?: string;
+    allowMinutePrecision?: boolean;
+}): TFilterValue[];
+export declare function buildMaterializedGlobalDateFilterValue(params: {
+    globalDateFilter?: TFilter;
+    globalDateFilterValue?: TFilterValue;
+    resolvedPrimaryDateField?: ResolvedPrimaryDateField;
+    semanticContext?: TFilterValue['semanticContext'];
+    timezone?: string;
+    allowMinutePrecision?: boolean;
+}): TFilterValue | null;
+export declare function stripGlobalDateFilterValues(params: {
+    filters?: TFilter[];
+    filterValues: TFilterValue[];
+}): TFilterValue[];
+export declare function resolveMaterializedFilterQueryFilterValues(params: {
+    filter: TFilter;
+    filters?: TFilter[];
+    filterValues: TFilterValue[];
+    semanticExecutionPayload?: SemanticExecutionPayload;
+    timezone?: string;
+    allowMinutePrecision?: boolean;
+}): TFilterValue[];
+export declare function resolveMaterializedCardFilterValues(params: {
+    card: TCard;
+    cardConfig: CardConfig;
+    filters?: TFilter[];
+    cardFilterValues: TFilterValue[];
+    semanticExecutionPayload?: SemanticExecutionPayload;
+    resolvedPrimaryDateField?: ResolvedPrimaryDateField | null;
+    resolvedFields?: ResolvedCardDateFields;
+    dateComparisonInputs?: ResolvedDashboardDateComparisonInput[];
+    mappedFilterValuesByInputId?: ReadonlyMap<string, TFilterValue>;
+    timezone?: string;
+    allowMinutePrecision?: boolean;
+}): {
+    cardFilterValues: TFilterValue[];
+    resolvedPrimaryDateField: ResolvedPrimaryDateField | null;
+    dateComparisonPlan: DashboardDateComparisonPlan;
+};
+export declare function buildSummaryFilterValues(params: {
+    filters?: TFilter[];
+    filterValues: TFilterValue[];
+    dashboard?: TDashboard | Pick<TDashboard, 'filters' | 'sheets'>;
+    semanticExecutionPayload?: SemanticExecutionPayload;
+    timezone?: string;
+    allowMinutePrecision?: boolean;
+}): TFilterValue[];

package/dist/types/lib/query-context/normalize-dashboard-card-execution.d.ts

@@ -0,0 +1,7 @@
+import { TCard } from '../types/common-types.js';
+import { CardConfig } from '../types/explorer-types.js';
+import { TableConfig } from '../types/query-types.js';
+import { TemporalResultOwner } from '../../shared/dashboard-authoring/index.js';
+export declare function buildDashboardCardTableConfig(card: TCard): TableConfig;
+export declare function normalizeDashboardCardPythonCode(pythonCode: string): string;
+export declare function resolveDashboardCardResultOwner(card: Pick<TCard, 'config' | 'sql' | 'python'> & Partial<Pick<TCard, 'type'>>, cardConfig?: CardConfig | undefined): TemporalResultOwner;

package/dist/types/lib/query-context/resolve-card-primary-date-field.d.ts

@@ -0,0 +1,35 @@
+import { TCard } from '../types/common-types.js';
+import { CardConfig, GroupByField, PivotByField } from '../types/explorer-types.js';
+import { ResolvedPrimaryDateField, SemanticExecutionPayload } from '../types/semantic-runtime-types.js';
+import { SemanticDatasetReference } from '../dashboard/semantic-dataset-references.js';
+type TemporalAxisField = GroupByField | PivotByField;
+export type ResolvedCardDateFields = {
+    rows: readonly TemporalAxisField[];
+    columns: readonly TemporalAxisField[];
+};
+export type CardPrimaryDateResolutionPlan = {
+    kind: 'matrix_temporal';
+    field: NonNullable<ResolvedPrimaryDateField>;
+} | {
+    kind: 'none';
+} | {
+    kind: 'explicit_temporal';
+    field: TemporalAxisField;
+} | {
+    kind: 'semantic_fallback';
+    datasetReference: SemanticDatasetReference;
+};
+export declare function resolveCardPrimaryDateField(params: {
+    card: TCard;
+    cardConfig?: CardConfig;
+    resolvedFields?: ResolvedCardDateFields;
+    semanticExecutionPayload?: SemanticExecutionPayload;
+}): ResolvedPrimaryDateField;
+/** A resolved null means ineligible; a missing dataset entry means not ready. */
+export declare function isCardPrimaryDateMetadataReady(params: Parameters<typeof resolveCardPrimaryDateField>[0]): boolean;
+export declare function getCardPrimaryDateResolutionPlan(params: {
+    card: TCard;
+    cardConfig?: CardConfig;
+    resolvedFields?: ResolvedCardDateFields;
+}): CardPrimaryDateResolutionPlan;
+export {};

package/dist/types/lib/query-context/resolve-render-card-config.d.ts

@@ -0,0 +1,16 @@
+import { CardConfig } from '../types/explorer-types.js';
+/**
+ * Chooses the card config a fetched result should render with.
+ *
+ * The config bound to the result at fetch time stays authoritative while the
+ * current context merely rebuilt an equivalent object (stable identity avoids
+ * recompiling charts on unrelated store updates) or while the rows belong to
+ * a different query identity (a retained previous result must keep its own
+ * config). When the rows are current and the config content changed, the
+ * change was presentation-only (formats, labels), so the current config wins.
+ */
+export declare function resolveRenderCardConfig(input: {
+    resultBoundConfig: CardConfig | undefined;
+    currentConfig: CardConfig | undefined;
+    isCurrentQueryResult: boolean;
+}): CardConfig | undefined;

package/dist/types/lib/query-context/temporal-context-preview.d.ts

@@ -0,0 +1,14 @@
+import { GroupByField } from '../types/explorer-types.js';
+import { ResolvedPrimaryDateField } from '../types/semantic-runtime-types.js';
+import { ResolveTemporalContextInput, ResolvedTemporalContext, SemaphorSourceRef } from '../../shared/analytics-protocol/index.js';
+type ClientTemporalField = {
+    field: GroupByField | NonNullable<ResolvedPrimaryDateField>;
+    source: SemaphorSourceRef;
+};
+export type ClientTemporalContextPreviewInput = Omit<ResolveTemporalContextInput, 'candidates'> & {
+    visibleAxisFields?: ClientTemporalField[];
+    explicitHiddenFields?: ClientTemporalField[];
+    semanticPrimaryFields?: ClientTemporalField[];
+};
+export declare function previewClientTemporalContext(input: ClientTemporalContextPreviewInput): ResolvedTemporalContext;
+export {};

package/dist/types/lib/query-context/use-semantic-execution-payload-for-cards.d.ts

@@ -0,0 +1,24 @@
+import { TCard } from '../types/common-types.js';
+import { CardConfig } from '../types/explorer-types.js';
+import { SemanticExecutionPayload } from '../types/semantic-runtime-types.js';
+export type SemanticExecutionPayloadAuthority = 'runtime' | 'editor';
+export type SemanticExecutionPayloadCardState = {
+    status: 'ready' | 'loading' | 'error';
+    errorMessage: string | null;
+};
+export type SemanticExecutionPayloadForCardsResult = {
+    payload: SemanticExecutionPayload;
+    cardStatesById: Record<string, SemanticExecutionPayloadCardState>;
+};
+type QueryRelevantConfigsByCardId = Record<string, CardConfig | undefined>;
+export declare function useSemanticExecutionPayloadForCards(cards: TCard[], options?: {
+    authority?: SemanticExecutionPayloadAuthority;
+    queryRelevantConfigsByCardId?: QueryRelevantConfigsByCardId;
+    /** Standalone authoring supplies its own authority instead of borrowing a dashboard session. */
+    environment?: {
+        token?: string;
+        apiServiceUrl?: string;
+        authorizationScope: string;
+    };
+}): SemanticExecutionPayloadForCardsResult;
+export {};

package/dist/types/lib/resize-observer-utils.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Utility to suppress common ResizeObserver errors in the console
+ *
+ * ResizeObserver errors are often harmless but noisy in the console,
+ * especially in applications with complex layouts, drag-and-drop functionality,
+ * or dynamic visualizations.
+ *
+ * @returns A cleanup function to restore original error handling
+ */
+export declare const suppressResizeObserverErrors: () => () => void;

package/dist/types/lib/stores/ai-interaction-store.d.ts

@@ -0,0 +1,97 @@
+import { AIContext, FileAttachment } from '../types/assistant-types.js';
+import { SelectedEntities } from '../types/explorer-types.js';
+import { ReasoningEffort } from '../../components/ai/reasoning-effort-slider.js';
+export type QueuedMessage = {
+    id: string;
+    text: string;
+    timestamp: number;
+    fileAttachments?: FileAttachment[];
+};
+export type AssistantType = 'dashboard' | 'editor';
+type MessageQueues = {
+    dashboard: QueuedMessage[];
+    editor: QueuedMessage[];
+};
+type FileAttachments = {
+    dashboard: FileAttachment[];
+    editor: FileAttachment[];
+};
+type UploadProgress = Map<string, number>;
+type DashboardEntitySelectionOverrides = Record<string, SelectedEntities>;
+type AssistantMessageContexts = Record<string, AIContext>;
+type PendingDashboardDraftMigration = {
+    scopeKey: string;
+    canSurviveBlankReset: boolean;
+    expectedDashboardId?: string | null;
+} | null;
+type AIInteractionStore = {
+    currentAIContext: AIContext;
+    hasEditorEntitySelectionOverride: boolean;
+    activeAssistantType: AssistantType | null;
+    dashboardEntitySelectionOverrides: DashboardEntitySelectionOverrides;
+    pendingDashboardDraftMigration: PendingDashboardDraftMigration;
+    assistantMessageContexts: AssistantMessageContexts;
+    reasoningEffort: ReasoningEffort;
+    showReasoning: boolean;
+    messageQueues: MessageQueues;
+    fileAttachments: FileAttachments;
+    uploadProgress: UploadProgress;
+    actions: Actions;
+};
+type Actions = {
+    setCurrentAIContext: (context: AIContext) => void;
+    setHasEditorEntitySelectionOverride: (hasOverride: boolean) => void;
+    setActiveAssistantType: (type: AssistantType | null) => void;
+    updateSelectedEntities: (selectedEntities: SelectedEntities) => void;
+    setDashboardEntitySelectionOverride: (dashboardScopeKey: string, selectedEntities: SelectedEntities) => void;
+    clearDashboardEntitySelectionOverride: (dashboardScopeKey: string) => void;
+    setPendingDashboardDraftMigration: (migration: PendingDashboardDraftMigration) => void;
+    setPendingDashboardDraftMigrationExpectedDashboardId: (dashboardId: string | null) => void;
+    clearPendingDashboardDraftMigration: () => void;
+    setAssistantMessageContext: (messageId: string, context: AIContext) => void;
+    clearAssistantMessageContext: (messageId: string) => void;
+    clearAssistantMessageContexts: (messageIds?: string[]) => void;
+    clearAIContext: () => void;
+    mergeAIContext: (context: Partial<AIContext>) => void;
+    setReasoningEffort: (effort: ReasoningEffort) => void;
+    setShowReasoning: (show: boolean) => void;
+    queueMessage: (assistantType: AssistantType, message: string, fileAttachments?: FileAttachment[]) => void;
+    dequeueMessage: (assistantType: AssistantType) => QueuedMessage | undefined;
+    removeFromQueue: (assistantType: AssistantType, messageId: string) => void;
+    clearQueue: (assistantType: AssistantType) => void;
+    addFileAttachment: (assistantType: AssistantType, file: FileAttachment) => void;
+    removeFileAttachment: (assistantType: AssistantType, fileId: string) => void;
+    clearFileAttachments: (assistantType: AssistantType) => void;
+    updateUploadProgress: (fileId: string, progress: number) => void;
+    getFileAttachments: (assistantType: AssistantType) => FileAttachment[];
+};
+export declare const useAIInteractionStore: import('zustand').UseBoundStore<Omit<import('zustand').StoreApi<AIInteractionStore>, "setState"> & {
+    setState(nextStateOrUpdater: AIInteractionStore | Partial<AIInteractionStore> | ((state: import('immer').WritableDraft<AIInteractionStore>) => void), shouldReplace?: false): void;
+    setState(nextStateOrUpdater: AIInteractionStore | ((state: import('immer').WritableDraft<AIInteractionStore>) => void), shouldReplace: true): void;
+}>;
+export declare const useCurrentAIContext: () => AIContext;
+export declare const useActiveAssistantType: () => AssistantType | null;
+export declare const useAISelectedEntities: () => SelectedEntities;
+export declare const useDashboardEntitySelectionOverrides: () => DashboardEntitySelectionOverrides;
+export declare const usePendingDashboardDraftMigration: () => PendingDashboardDraftMigration;
+export declare const useAssistantMessageContext: (messageId?: string | null) => AIContext | undefined;
+export declare const useReasoningEffort: () => ReasoningEffort;
+export declare const useShowReasoning: () => boolean;
+export declare const useAIActions: () => Actions;
+export declare const useMessageQueue: (assistantType: AssistantType) => QueuedMessage[];
+export declare const useQueueActions: () => {
+    queueMessage: (assistantType: AssistantType, message: string, fileAttachments?: FileAttachment[]) => void;
+    dequeueMessage: (assistantType: AssistantType) => QueuedMessage | undefined;
+    removeFromQueue: (assistantType: AssistantType, messageId: string) => void;
+    clearQueue: (assistantType: AssistantType) => void;
+};
+export declare const useFileAttachments: (assistantType: AssistantType) => FileAttachment[];
+export declare const useUploadProgress: () => UploadProgress;
+export declare const useFileActions: () => {
+    addFileAttachment: (assistantType: AssistantType, file: FileAttachment) => void;
+    removeFileAttachment: (assistantType: AssistantType, fileId: string) => void;
+    clearFileAttachments: (assistantType: AssistantType) => void;
+    updateUploadProgress: (fileId: string, progress: number) => void;
+    getFileAttachments: (assistantType: AssistantType) => FileAttachment[];
+};
+export {};

package/dist/types/lib/stores/assistant-layout-store.d.ts

@@ -0,0 +1,17 @@
+export type AssistantType = 'dashboard' | 'editor';
+type PanelState = {
+    isOpen: boolean;
+    container: HTMLElement | null;
+};
+type AssistantLayoutState = {
+    panels: Record<AssistantType, PanelState>;
+    fullscreen: AssistantType | null;
+    setPanelOpen: (assistant: AssistantType, isOpen: boolean) => void;
+    setFullscreen: (assistant: AssistantType | null) => void;
+    setContainer: (assistant: AssistantType, container: HTMLElement | null) => void;
+};
+export declare const useAssistantLayoutStore: import('zustand').UseBoundStore<import('zustand').StoreApi<AssistantLayoutState>>;
+export declare const useAssistantPanel: (assistant: AssistantType) => PanelState;
+export declare const useFullscreenAssistant: () => AssistantType | null;
+export declare const useAssistantContainer: (assistant: AssistantType) => HTMLElement | null;
+export {};

package/dist/types/lib/stores/chartjs-store.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Store for managing Chart.js blur effects across different cards
+ * Handles registration and execution of blur clear callbacks
+ */
+interface ChartJSStore {
+    /** Maps card IDs to their blur clear callback functions */
+    clearBlurCallbacks: Record<string, (() => void) | null>;
+    /** Registers a blur clear callback for a specific card */
+    registerClearBlurCallback: (cardId: string, callback: (() => void) | null) => void;
+    /** Executes the blur clear callback for a specific card */
+    clearBlurForCard: (cardId: string) => void;
+    /** Executes blur clear callbacks for all cards */
+    clearAllBlur: () => void;
+    /** Removes a card's blur callback registration */
+    unregisterCard: (cardId: string) => void;
+    /** Resets the store to its initial state. Called when loading a new dashboard. */
+    resetStore: () => void;
+}
+export declare const useChartJSStore: import('zustand').UseBoundStore<Omit<import('zustand').StoreApi<ChartJSStore>, "setState" | "devtools"> & {
+    setState(partial: ChartJSStore | Partial<ChartJSStore> | ((state: ChartJSStore) => ChartJSStore | Partial<ChartJSStore>), replace?: false | undefined, action?: (string | {
+        [x: string]: unknown;
+        [x: number]: unknown;
+        [x: symbol]: unknown;
+        type: string;
+    }) | undefined): void;
+    setState(state: ChartJSStore | ((state: ChartJSStore) => ChartJSStore), replace: true, action?: (string | {
+        [x: string]: unknown;
+        [x: number]: unknown;
+        [x: symbol]: unknown;
+        type: string;
+    }) | undefined): void;
+    devtools: {
+        cleanup: () => void;
+    };
+}>;
+export {};

package/dist/types/lib/stores/dashboard-store.d.ts

@@ -0,0 +1,321 @@
+import { AuthToken, TBaseQuery, Breakpoint, ControlDefinition, CustomCard, StyleProps, TCard, TDashboard, TEvent, TFrame, TSheet, TStyle, AIScopeTable, TLens, CacheConfig, EmailSettings, FilterLayoutSettings, DocumentDefinition, DashboardInput, DashboardInputSlot, DashboardInputValues, DashboardLifecycleEvent } from '../types/common-types.js';
+import { TFilter, TFilterValue } from '../../components/surfboard/filter/types.js';
+import { ClickFilterCondition } from '../types/interaction-types.js';
+import { default as ReactGridLayout } from 'react-grid-layout';
+import { DashboardAIContext } from '../types/assistant-types.js';
+import { FilterGroup, Field } from '../types/explorer-types.js';
+import { DashboardControlsModelOptions } from '../controls/control-authoring-types.js';
+import { SemanticExecutionPayload } from '../types/semantic-runtime-types.js';
+import { DocumentFilterMode } from '../document/document-input-runtime.js';
+import { DashboardInputRuntimeTarget } from '../dashboard-inputs/dashboard-input-values.js';
+import { DashboardFilterMappingAuthoringIssue, DashboardFilterInputAcceptanceResult, DashboardFilterMappingAcceptanceResult, DashboardFilterMappingAuthoringRequest, DashboardFilterMappingDisableResult } from '../dashboard-inputs/dashboard-filter-mapping-authoring.js';
+import { DashboardFilterOptionSource } from '../../shared/dashboard-authoring/index.js';
+import { DashboardFilterAuthoringSettingsUpdate } from '../dashboard-inputs/dashboard-filter-mapping-storage-transition.js';
+import { GlobalDateComparisonSelection } from '../../shared/analytics-protocol/index.js';
+import { CalendarPreferencesResponse, ReportRuntimeContext, ResolvedCalendarPreferenceSources } from '../../shared/report-runtime-context/index.js';
+import { ResolvedValueFormatPreferenceSources, ResolvedValueFormatPreferences } from '../../shared/value-format-preferences/index.js';
+type AddFrameOptions = {
+    position?: 'start' | 'end';
+    insertAfterFrameId?: string;
+    copyLayoutFromFrameId?: string;
+    semanticExecutionPayload?: SemanticExecutionPayload;
+};
+export type FilterDashboardInputDefinitionUpdateMetadata = {
+    variableName?: string;
+    label?: string;
+    forceSelection?: boolean;
+    exports?: DashboardInput['exports'];
+    /**
+     * Option source, dependency and population edits for an embedded Input,
+     * persisted through the same contract validation as mapped dashboard
+     * filters. Presentations that bind an embedded Input (the document input
+     * bar) carry these; dashboard-filter references persist through
+     * `acceptDashboardFilterInput` and `acceptDashboardFilterMapping` instead.
+     */
+    optionSettings?: DashboardFilterAuthoringSettingsUpdate;
+};
+export type FilterDashboardInputDefinitionUpdateResult = {
+    ok: true;
+} | {
+    ok: false;
+    issues: DashboardFilterMappingAuthoringIssue[];
+};
+export type DashboardStore = {
+    handleOpenAssistantProfile?: () => void;
+    isDownloadingPdf?: boolean;
+    isSessionExpired: boolean;
+    authToken?: AuthToken;
+    currentBreakpoint: Breakpoint;
+    theme?: 'light' | 'dark' | 'system';
+    themeStyle?: StyleProps;
+    lenses?: TLens[];
+    selectedLensId?: string;
+    filteringCards?: TCard[];
+    dashboard: TDashboard;
+    dashboardAssistantDraftScopeKey: string;
+    relaodToken?: number;
+    selectedSheetId?: string | null | undefined;
+    selectedFrameId?: string | null;
+    selectedCardId?: string | null;
+    selectedCard?: TCard | null;
+    selectedDocumentSectionIdsBySheetId: Record<string, string | null>;
+    documentInspectorTabsBySheetId: Record<string, DocumentInspectorTab>;
+    documentInputRuntimeBySheetId: Record<string, DocumentInputRuntimeState>;
+    /**
+     * Pending sheet-wide frame rewrites produced while visual editing. These stay
+     * draft-only until the editor Save path applies the current frame.
+     */
+    visualEditPendingFrameRewrites: Record<string, TFrame[]>;
+    /**
+     * Pending dashboard-filter metadata rewrites produced while visual editing.
+     * These stay draft-only until the editor Save path applies the current frame.
+     */
+    visualEditPendingFilterRewrites: Record<string, TFilter[]>;
+    /**
+     * Pending dashboard-scoped calculated-field rewrites produced while visual
+     * editing. These stay draft-only until the editor Save path applies the
+     * current frame.
+     */
+    visualEditPendingDashboardCalculatedFields?: Field[];
+    /** Live edit-session check for host navigation; owned by dashboard controls. */
+    checkUnsavedDashboardChanges: (() => boolean) | null;
+    isDashboardEditing: boolean;
+    isVisualEditing: boolean;
+    showContext: boolean;
+    showDashboardJSON: boolean;
+    showFilters: boolean;
+    filterValues?: TFilterValue[];
+    /** Runtime-only inline filter values, keyed by cardId. Not persisted with dashboard. */
+    inlineFilterValuesMap: Record<string, TFilterValue[]>;
+    /** Runtime-only dashboard control values keyed by globally unique controlId. */
+    controlValues: Record<string, unknown>;
+    /** Runtime-only card-scoped control values, keyed by cardId then controlId. */
+    cardControlValuesMap: Record<string, Record<string, unknown>>;
+    /** Runtime-only dashboard input values keyed by input runtime scope. */
+    dashboardInputValues: DashboardInputValues;
+    /** Fixed execution clock from a strict dashboard input replay snapshot. */
+    dashboardInputReferenceTime?: string;
+    semanticExecutionPayload: SemanticExecutionPayload;
+    reportContext: ReportRuntimeContext | null;
+    /** Access-token session that owns the hydrated report context. */
+    reportContextSessionAccessToken: string | null;
+    drillHistory: Array<{
+        sourceDashboardId: string;
+        targetDashboardId: string;
+        sourceDashboardTitle?: string;
+        filters: ClickFilterCondition[];
+        contextMode: 'interactionFilters' | 'full' | 'none';
+        timestamp: number;
+    }>;
+    drillContext: {
+        filters: ClickFilterCondition[];
+        sourceDashboardId: string;
+        sourceDashboardTitle?: string;
+    } | null;
+    onEvent?: (event: TEvent) => void;
+    onDashboardLifecycleEvent?: (event: DashboardLifecycleEvent) => void;
+    onSaveFunction?: (dashboard: TDashboard, description?: string) => void;
+    onAddFrame?: (card: TFrame, sheetId: string) => void;
+    onAcceptChanges?: (frame: TFrame, dashboard: TDashboard) => void;
+    onUpdateCard?: (card: TCard, sheetId: string) => void;
+    onRemoveCard?: (card: TCard, sheetId: string) => void;
+    actions: Actions;
+};
+export type DocumentInspectorTab = 'section' | 'page' | 'header' | 'footer' | 'inputs';
+export type DocumentInputRuntimeState = {
+    filterValuesByInputId: Record<string, TFilterValue | undefined>;
+    filterModesByInputId: Record<string, DocumentFilterMode>;
+    controlValuesByInputId: Record<string, unknown>;
+};
+type Actions = {
+    applyResolvedCalendarPreferences: (resolved: CalendarPreferencesResponse['resolved'], sources: ResolvedCalendarPreferenceSources) => void;
+    applyResolvedValueFormatPreferences: (resolved: ResolvedValueFormatPreferences, sources: ResolvedValueFormatPreferenceSources) => void;
+    triggerReload: () => void;
+    setAiContext: (aiContext: DashboardAIContext) => void;
+    setHandleOpenAssistantProfile: (handleOpenAssistantProfile: () => void) => void;
+    setFilterMode: (filterId: string, filterMode: 'include' | 'exclude') => void;
+    setInitStore: () => void;
+    setGlobalStyle: (style: TStyle) => void;
+    setDefaultFilterValues: (filterValues: TFilterValue[] | undefined) => void;
+    setDefaultControlValues: (controlValues: Record<string, unknown> | undefined) => void;
+    setDashboardInputs: (inputs: DashboardInput[]) => void;
+    upsertDashboardInput: (input: DashboardInput) => void;
+    updateFilterDashboardInputDefinition: (inputId: string, filter: TFilter, metadata?: FilterDashboardInputDefinitionUpdateMetadata) => FilterDashboardInputDefinitionUpdateResult;
+    acceptDashboardFilterInput: (updatedFilter: TFilter, optionSource: DashboardFilterOptionSource | undefined, settings?: DashboardFilterAuthoringSettingsUpdate, inputMetadata?: {
+        variableName?: string;
+    }) => DashboardFilterInputAcceptanceResult;
+    acceptDashboardFilterMapping: (request: DashboardFilterMappingAuthoringRequest, updatedFilter?: TFilter, settings?: DashboardFilterAuthoringSettingsUpdate) => DashboardFilterMappingAcceptanceResult;
+    disableDashboardFilterMapping: (filterId: string, updatedFilter?: TFilter, settings?: DashboardFilterAuthoringSettingsUpdate) => DashboardFilterMappingDisableResult;
+    removeDashboardInput: (inputId: string) => void;
+    reorderDashboardInputs: (orderedInputIds: string[]) => void;
+    setDefaultDashboardInputValues: (values: DashboardInputValues | undefined) => void;
+    setDefaultDashboardInputComparisonSelection: (input: Pick<DashboardInput, 'id' | 'runtimeScope'>, target: DashboardInputRuntimeTarget, selection: GlobalDateComparisonSelection | undefined) => void;
+    setDashboardInputValues: (values: DashboardInputValues) => void;
+    setDashboardInputSlot: (input: Pick<DashboardInput, 'id' | 'runtimeScope'>, target: DashboardInputRuntimeTarget, slot: DashboardInputSlot) => void;
+    setDashboardInputComparisonSelection: (input: Pick<DashboardInput, 'id' | 'runtimeScope'>, target: DashboardInputRuntimeTarget, selection: GlobalDateComparisonSelection) => void;
+    resetDashboardInputComparisonSelection: (input: Pick<DashboardInput, 'id' | 'runtimeScope'>, target: DashboardInputRuntimeTarget) => void;
+    clearDashboardInputSlot: (input: Pick<DashboardInput, 'id' | 'runtimeScope'>, target: DashboardInputRuntimeTarget) => void;
+    removeDashboardInputSlot: (input: Pick<DashboardInput, 'id' | 'runtimeScope'>, target: DashboardInputRuntimeTarget) => void;
+    setDashboardControlsModel: (controls: ControlDefinition[], defaultValues?: Record<string, unknown>, options?: DashboardControlsModelOptions) => void;
+    updateDashboardControl: (controlId: string, updates: Partial<ControlDefinition>) => void;
+    reorderDashboardControls: (orderedControlIds: string[]) => void;
+    updateEmailSettings: (emailSettings: EmailSettings) => void;
+    setIsDownloadingPdf: (isDownloadingPdf: boolean) => void;
+    setLenses: (lenses: TLens[]) => void;
+    setSelectedLensId: (lensId: string) => void;
+    setAIScopeTables: (aiScopeTables: AIScopeTable[]) => void;
+    addToAIScope: (scopeTable: AIScopeTable) => void;
+    removeFromAIScope: (scopeTable: AIScopeTable) => void;
+    setIsSessionExpired: (isSessionExpired: boolean) => void;
+    setCurrentBreakpoint: (breakpoint: Breakpoint) => void;
+    setFilteringCards: (cards: TCard[]) => void;
+    addFilteringCard: (card: TCard) => void;
+    removeFilteringCard: (card: TCard) => void;
+    setGlobalCacheConfig: (cacheConfig: CacheConfig) => void;
+    setCustomCards: (customCards: CustomCard[]) => void;
+    setAuthToken: (authToken: AuthToken) => void;
+    setThemeStyle: (themeStyle: StyleProps) => void;
+    setDashboard: (dashboard: TDashboard, options?: {
+        semanticExecutionPayload?: SemanticExecutionPayload;
+        dashboardInputValues?: DashboardInputValues;
+        dashboardInputReferenceTime?: string;
+        reportContext?: ReportRuntimeContext;
+    }) => void;
+    setDashboardWithFilterValues: (dashboard: TDashboard, filterValues: TFilterValue[], runtimeOverrides?: Record<string, unknown>, options?: {
+        selectedSheetId?: string | null;
+        semanticExecutionPayload?: SemanticExecutionPayload;
+        dashboardInputValues?: DashboardInputValues;
+        dashboardInputReferenceTime?: string;
+        reportContext?: ReportRuntimeContext;
+        authToken?: AuthToken;
+    }) => void;
+    hydrateRuntimeControlValues: (dashboard: TDashboard, runtimeOverrides?: Record<string, unknown>) => void;
+    mergeSemanticExecutionPayload: (semanticExecutionPayload: SemanticExecutionPayload) => void;
+    setDashboardTheme: (theme: 'light' | 'dark' | 'system') => void;
+    setDashboardTitle: (title: string) => void;
+    setDashboardDescription: (description: string) => void;
+    setSheets: (sheets: TSheet[]) => void;
+    addSheet: (sheet: TSheet) => void;
+    duplicateSheet: (sheetId: string) => string | null;
+    deleteSheet: (sheetId: string) => void;
+    setSheetTitle: (sheetId: string, title: string) => void;
+    updateSheetDocument: (sheetId: string, updater: (document: DocumentDefinition) => DocumentDefinition) => void;
+    updateDocumentSectionCard: (sheetId: string, sectionId: string, card: TCard, options?: {
+        calculatedFields?: Field[];
+    }) => void;
+    setSelectedDocumentSectionId: (sheetId: string, sectionId: string | null) => void;
+    setDocumentInspectorTab: (sheetId: string, tab: DocumentInspectorTab) => void;
+    setDocumentInputFilterValues: (sheetId: string, valuesByInputId: Record<string, TFilterValue | undefined>) => void;
+    setDocumentInputFilterValue: (sheetId: string, inputId: string, filterValue: TFilterValue) => void;
+    removeDocumentInputFilterValue: (sheetId: string, inputId: string) => void;
+    setDocumentInputFilterModes: (sheetId: string, modesByInputId: Record<string, DocumentFilterMode>) => void;
+    setDocumentInputFilterMode: (sheetId: string, inputId: string, filterMode: DocumentFilterMode) => void;
+    setDocumentInputControlValues: (sheetId: string, valuesByInputId: Record<string, unknown>) => void;
+    setDocumentInputControlValue: (sheetId: string, inputId: string, value: unknown) => void;
+    clearDocumentInputRuntime: (sheetId?: string) => void;
+    setSelectedSheetId: (sheetId: string | null) => void;
+    setSheetLayout: (sheetId: string, layout: ReactGridLayout.Layout[]) => void;
+    setSheetLayouts: (sheetId: string, layouts: ReactGridLayout.Layouts) => void;
+    setSelectedCardId: (sheetId: string, cardId: string | null) => void;
+    setSelectedFrameId: (frameId: string) => void;
+    clearSelectedFrameId: () => void;
+    setCardTitle: (sheetId: string, cardId: string, title: string) => void;
+    setCardInfo: (cardId: string, info: string) => void;
+    setCardSql: (sheetId: string, cardId: string, sql: string) => void;
+    setCardPython: (cardId: string, pythonCode: string) => void;
+    setCardDescription: (sheetId: string, cardId: string, description: string, preferences?: TCard['preferences']) => void;
+    setCardKpiOptions: (sheetId: string, cardId: string, kpiOptions: Record<string, any>) => void;
+    updateCardFilters: (cardId: string, filters: FilterGroup | undefined) => void;
+    clearCardFilters: (cardId: string) => void;
+    setCardInlineFilterValue: (cardId: string, filterValue: TFilterValue) => void;
+    removeCardInlineFilterValue: (cardId: string, filterId: string) => void;
+    getCardInlineFilterValues: (cardId: string) => TFilterValue[];
+    setControlValue: (controlId: string, value: unknown) => void;
+    removeControlValue: (controlId: string) => void;
+    setCardControlValue: (cardId: string, controlId: string, value: unknown) => void;
+    removeCardControlValue: (cardId: string, controlId: string) => void;
+    setCardControlRuntimeModel: (cardId: string, controls: ControlDefinition[], options?: {
+        renamed?: {
+            oldId: string;
+            newId: string;
+        };
+    }) => void;
+    clearAllInlineFilterValues: () => void;
+    setInlineFilterValuesMap: (map: Record<string, TFilterValue[]>) => void;
+    setCardInlineFilterMode: (sheetId: string, cardId: string, filterId: string, filterMode: 'include' | 'exclude') => void;
+    setCardInlineFilterDefaultValues: (sheetId: string, cardId: string, filterId: string, defaultValues: (string | number)[] | undefined) => void;
+    addFrame: (sheetId: string, frame: TFrame, positionOrOptions?: 'start' | 'end' | AddFrameOptions) => void;
+    updateFrame: (sheetId: string, frame: TFrame, options?: {
+        semanticExecutionPayload?: SemanticExecutionPayload;
+    }) => void;
+    updateSheetCalculatedFields: (sheetId: string, calculatedFields: Field[]) => void;
+    updateDashboardCalculatedFields: (calculatedFields: Field[]) => void;
+    setVisualEditPendingFrameRewrites: (sheetId: string, frames: TFrame[]) => void;
+    setVisualEditPendingFilterRewrites: (sheetId: string, filters: TFilter[]) => void;
+    clearVisualEditPendingFrameRewrites: (sheetId?: string) => void;
+    clearVisualEditPendingFilterRewrites: (sheetId?: string) => void;
+    updateCard: (sheetId: string, card: TCard) => void;
+    updateFrameCard?: (sheetId: string, frameId: string, card: TCard) => void;
+    updateCurrentDashboardCard: (card: TCard) => void;
+    removeFrame: (sheetId: string, frameId: string) => void;
+    removeCard: (sheetId: string, card: TCard) => void;
+    setIsDashboardEditing: (editing: boolean) => void;
+    setShowContext: (show: boolean) => void;
+    setShowDashboardJSON: (show: boolean) => void;
+    setIsVisualEditing: (editing: boolean) => void;
+    setShowFilters: (show: boolean) => void;
+    setFilterLayout: (settings: Partial<FilterLayoutSettings>) => void;
+    addFilter: (filter: TFilter) => void;
+    removeFilter: (filterId: string) => void;
+    reorderFilters: (orderedFilterIds: string[]) => void;
+    updateFilter: (filter: TFilter) => void;
+    updateFilterId: (filterId: string, newId: string) => void;
+    setFilterDefaultValues: (filterId: string, defaultValues: (string | number)[] | undefined) => void;
+    setFilterValues: (filterValues: TFilterValue[] | undefined) => void;
+    addOrUpdateFilterValue: (filterValue: TFilterValue) => void;
+    addOrUpdateFilterValues: (filterValues: TFilterValue[]) => void;
+    removeFilterValues: (filterId: string) => void;
+    replaceFilterValue: (filterValue: TFilterValue) => void;
+    setStyle: (style: TStyle) => void;
+    getStyle: () => TStyle | undefined;
+    setOnSaveFunction: (onSaveFunction: (dashboard: TDashboard) => void) => void;
+    setOnAddCard: (onAddCard: (card: TCard, sheetId: string) => void) => void;
+    setOnAcceptChanges: (onAcceptChanges: (frame: TFrame, dashboard: TDashboard) => void) => void;
+    setOnUpdateCard: (onUpdateCard: (card: TCard, sheetId: string) => void) => void;
+    setOnRemoveCard: (onRemoveCard: (card: TCard, sheetId: string) => void) => void;
+    setOnEvent: (onEvent: (event: TEvent) => void) => void;
+    setOnDashboardLifecycleEvent: (onDashboardLifecycleEvent: ((event: DashboardLifecycleEvent) => void) | undefined) => void;
+    getDashboard: () => TDashboard | undefined;
+    getSelectedSheet: () => TSheet | undefined;
+    getCard: (cardId: string) => TCard | undefined;
+    getSelectedFrame: () => TFrame | undefined;
+    getCardFrame: (cardId: string) => TFrame | undefined;
+    getCardSheet: (cardId: string) => TSheet | undefined;
+    getSelectedSheetLayout: () => ReactGridLayout.Layout[] | undefined;
+    getSelectedSheetLayouts: () => ReactGridLayout.Layouts | undefined;
+    handleDataPointClickAction: (card: TCard, dataPoint: any) => void;
+    addBaseQuery: (baseQuery: TBaseQuery) => void;
+    removeBaseQuery: (baseQueryId: string) => void;
+    setBaseQueries: (baseQueries: TBaseQuery[]) => void;
+    updateCardId: (oldCardId: string, newCardId: string) => {
+        success: boolean;
+        error?: string;
+    };
+    isCardIdUnique: (cardId: string, currentCardId?: string) => boolean;
+    navigateWithDrill: (targetDashboardId: string, sourceDashboardId: string, sourceDashboardTitle: string | undefined, filters: ClickFilterCondition[], contextMode: 'interactionFilters' | 'full' | 'none') => void;
+    goBackFromDrill: () => void;
+    clearDrillContext: () => void;
+};
+export declare const useDashboardStore: import('zustand').UseBoundStore<Omit<import('zustand').StoreApi<DashboardStore>, "setState"> & {
+    setState(nextStateOrUpdater: DashboardStore | Partial<DashboardStore> | ((state: import('immer').WritableDraft<DashboardStore>) => void), shouldReplace?: false): void;
+    setState(nextStateOrUpdater: DashboardStore | ((state: import('immer').WritableDraft<DashboardStore>) => void), shouldReplace: true): void;
+}>;
+export declare const useCurrentActiveCard: () => TCard | undefined;
+export declare const useCurrentSheetActiveCards: () => TCard[];
+export declare const useCurrentCardConfig: () => {
+    metricFields: Field[];
+    groupByFields: Field[];
+    pivotByFields: Field[];
+};
+export declare const useDashboardActions: () => Actions;
+export {};