react-semaphor 0.1.503 → 0.1.505

package/dist/types/components/briefings/briefing-recipient-field.d.ts

@@ -0,0 +1,17 @@
+import { ReactNode } from 'react';
+import { BriefingRecipient } from '../../lib/types/briefing-types.js';
+export type BriefingRecipientFieldProps = {
+    value: BriefingRecipient[];
+    onChange: (next: BriefingRecipient[]) => void;
+    className?: string;
+    disabled?: boolean;
+    /** Optional inline label rendered inside the chip row before the pills.
+        Used by the Slack mention row ("THREAD @") so the label and chips
+        share one bordered container — matches the chip-input pattern in
+        /design/briefings instead of stacking a caption above the field. */
+    prefix?: ReactNode;
+    /** Placeholder for the inline input. Override the default "Add people…"
+        text for context-specific copy (e.g. "Mention people in the thread"). */
+    placeholder?: string;
+};
+export declare function BriefingRecipientField({ value, onChange, className, disabled, prefix, placeholder, }: BriefingRecipientFieldProps): import("react/jsx-runtime").JSX.Element;

package/dist/types/components/briefings/briefing-tones.d.ts

@@ -0,0 +1,30 @@
+export declare const briefingTone: {
+    readonly info: {
+        readonly surface: "border-border bg-blue-50/60 text-foreground dark:border-border dark:bg-blue-950/30";
+        readonly icon: "text-blue-600 dark:text-blue-400";
+        readonly spinner: "text-blue-600 dark:text-blue-400";
+    };
+    readonly success: {
+        readonly surface: "border-emerald-200 bg-emerald-50/70 text-foreground dark:border-emerald-900/50 dark:bg-emerald-950/30";
+        readonly icon: "text-emerald-700 dark:text-emerald-300";
+        readonly dot: "bg-emerald-500";
+        readonly label: "text-emerald-700 dark:text-emerald-400";
+        readonly iconBg: "bg-emerald-100 dark:bg-emerald-900/60";
+    };
+    readonly danger: {
+        readonly surface: "border-destructive/30 bg-destructive/10 text-destructive";
+        readonly icon: "text-destructive";
+        readonly dot: "bg-destructive";
+        readonly iconBg: "bg-destructive/15";
+    };
+    readonly warning: {
+        readonly surface: "border-amber-200 bg-amber-50 text-amber-800 dark:border-amber-900/60 dark:bg-amber-950/30 dark:text-amber-300";
+        readonly icon: "text-amber-700 dark:text-amber-300";
+        readonly dot: "bg-amber-500";
+    };
+    readonly neutral: {
+        readonly surface: "border-border bg-muted text-muted-foreground";
+        readonly icon: "text-muted-foreground";
+        readonly dot: "bg-border";
+    };
+};

package/dist/types/components/briefings/briefing-ui-capabilities.d.ts

@@ -0,0 +1,16 @@
+import { ReactNode } from 'react';
+export type BriefingUiCapabilities = {
+    surfaceVisible: boolean;
+    canCreate: boolean;
+    analyticalBriefingsEnabled: boolean;
+    userType: 'organization' | 'tenant' | null;
+    loading: boolean;
+    error: boolean;
+};
+export declare function BriefingUiCapabilitiesProvider({ children, }: {
+    children: ReactNode;
+}): import("react/jsx-runtime").JSX.Element;
+export declare function BriefingUiCapabilitiesBoundary({ children, }: {
+    children: ReactNode;
+}): string | number | bigint | boolean | Iterable<ReactNode> | Promise<string | number | bigint | boolean | import('react').ReactPortal | import('react').ReactElement<unknown, string | import('react').JSXElementConstructor<any>> | Iterable<ReactNode> | null | undefined> | import("react/jsx-runtime").JSX.Element | null | undefined;
+export declare function useBriefingUiCapabilities(): BriefingUiCapabilities;

package/dist/types/components/briefings/dashboard-briefing-launcher-list.d.ts

@@ -0,0 +1,25 @@
+import { BriefingListItem } from '../../lib/types/briefing-types.js';
+import { BriefingAuthorIntent } from './briefing-author.js';
+import { BriefingSourceView } from './dashboard-briefing-launcher-model.js';
+export declare function ExistingBriefingsPanel({ briefings, dashboardLabel: label, sourceView, error, loading, onSourceViewChange, onClose, onEdit, onNew, canCreate, canCreateScheduledReport, analyticalBriefingsEnabled, onRunNow, onTogglePause, onDelete, selectingId, busyId, manageBriefingsHref, contentKind, hideHeader, }: {
+    briefings: BriefingListItem[];
+    dashboardLabel: string;
+    sourceView: BriefingSourceView;
+    error: string | null;
+    loading: boolean;
+    onSourceViewChange: (view: BriefingSourceView) => void;
+    onClose: () => void;
+    onEdit: (briefingId: string) => void;
+    onNew: (intent: BriefingAuthorIntent) => void;
+    canCreate: boolean;
+    canCreateScheduledReport: boolean;
+    analyticalBriefingsEnabled: boolean;
+    onRunNow: (briefing: BriefingListItem) => void;
+    onTogglePause: (briefing: BriefingListItem) => void;
+    onDelete: (briefing: BriefingListItem) => void;
+    selectingId: string | null;
+    busyId: string | null;
+    manageBriefingsHref?: string;
+    contentKind?: 'reports' | 'briefings';
+    hideHeader?: boolean;
+}): import("react/jsx-runtime").JSX.Element;

package/dist/types/components/briefings/dashboard-briefing-launcher-model.d.ts

@@ -0,0 +1,14 @@
+import { BriefingListItem } from '../../lib/types/briefing-types.js';
+import { DashboardBriefingLauncherClient } from './dashboard-briefing-launcher.js';
+export type LauncherView = 'list' | 'author';
+export type BriefingSourceView = 'project' | 'dashboard';
+export declare const BACKGROUND_RUN_POLL_INTERVAL_MS = 2000;
+export declare const BACKGROUND_RUN_POLL_TIMEOUT_MS: number;
+export declare function dashboardLabel(dashboardTitle?: string | null): string;
+export declare function dashboardDetail(label: string): string;
+export declare function filterBriefingsForSourceView(briefings: BriefingListItem[], view: BriefingSourceView, dashboardId: string): BriefingListItem[];
+export declare function listProjectBriefings(input: {
+    apiClient: DashboardBriefingLauncherClient;
+    apiServiceUrl: string;
+    token: string;
+}): Promise<BriefingListItem[]>;

package/dist/types/components/briefings/dashboard-briefing-launcher.d.ts

@@ -0,0 +1,25 @@
+import { deleteBriefing, getBriefing, listBriefings, pauseBriefing, resumeBriefing, runBriefingNow } from '../../lib/api/briefings-api.js';
+import { BriefingAuthorIntent } from './briefing-author.js';
+export type DashboardBriefingLauncherProps = {
+    dashboardId: string;
+    dashboardTitle?: string | null;
+    apiServiceUrl?: string;
+    token?: string;
+    disabled?: boolean;
+    className?: string;
+    manageBriefingsHref?: string;
+    open?: boolean;
+    onOpenChange?: (open: boolean) => void;
+    hideTrigger?: boolean;
+    workflowIntent?: BriefingAuthorIntent;
+    client?: Partial<DashboardBriefingLauncherClient>;
+};
+export type DashboardBriefingLauncherClient = {
+    listBriefings: typeof listBriefings;
+    getBriefing: typeof getBriefing;
+    pauseBriefing: typeof pauseBriefing;
+    resumeBriefing: typeof resumeBriefing;
+    deleteBriefing: typeof deleteBriefing;
+    runBriefingNow: typeof runBriefingNow;
+};
+export declare function DashboardBriefingLauncher(props: DashboardBriefingLauncherProps): import("react/jsx-runtime").JSX.Element;

package/dist/types/components/briefings/dashboard-schedule-report-menu-item.d.ts

@@ -0,0 +1,11 @@
+export type DashboardScheduleReportMenuItemProps = {
+    visible: boolean;
+    onSelect: () => void;
+};
+export declare function DashboardScheduleReportMenuItem({ visible, onSelect, }: DashboardScheduleReportMenuItemProps): import("react/jsx-runtime").JSX.Element | null;
+export declare function DashboardBriefingWorkflowMenuItems({ scheduleReportVisible, analyticalBriefingVisible, onScheduleReport, onCreateAnalyticalBriefing, }: {
+    scheduleReportVisible: boolean;
+    analyticalBriefingVisible: boolean;
+    onScheduleReport: () => void;
+    onCreateAnalyticalBriefing: () => void;
+}): import("react/jsx-runtime").JSX.Element;

package/dist/types/components/briefings/index.d.ts

@@ -0,0 +1,9 @@
+export { BriefingAuthor } from './briefing-author.js';
+export type { BriefingAuthorClient, BriefingAuthorIntent, BriefingAuthorProps, BriefingAuthorSourceContext, } from './briefing-author.js';
+export { BriefingAuthorDialog } from './briefing-author-dialog.js';
+export type { BriefingAuthorDialogProps, BriefingAuthorLaunchRequest, } from './briefing-author-dialog.js';
+export { WatchDashboardButton } from './watch-dashboard-button.js';
+export type { WatchDashboardButtonProps } from './watch-dashboard-button.js';
+export { DashboardBriefingLauncher } from './dashboard-briefing-launcher.js';
+export type { DashboardBriefingLauncherProps } from './dashboard-briefing-launcher.js';
+export { BriefingUiCapabilitiesBoundary, BriefingUiCapabilitiesProvider, useBriefingUiCapabilities, type BriefingUiCapabilities, } from './briefing-ui-capabilities.js';

package/dist/types/components/briefings/use-briefing-run-polling.d.ts

@@ -0,0 +1,34 @@
+type PollableBriefingRun = {
+    id: string;
+    status: string;
+    error?: string | null;
+};
+type PollingStatus = 'idle' | 'polling' | 'terminal' | 'timed_out' | 'error';
+type PollingInput = {
+    apiServiceUrl: string;
+    token: string;
+    runId: string;
+};
+type UseBriefingRunPollingOptions<Run extends PollableBriefingRun> = {
+    apiServiceUrl?: string;
+    token?: string;
+    intervalMs: number;
+    timeoutMs: number;
+    fetchRun: (input: PollingInput) => Promise<Run>;
+    onRun: (run: Run) => void;
+    onTerminalRun?: (run: Run) => void;
+    onError?: (error: unknown) => void;
+    onTimeout?: (runId: string) => void;
+};
+export declare function isTerminalBriefingRunStatus(status: string | undefined): boolean;
+export declare function isActiveBriefingRunStatus(status: string | undefined): boolean;
+export declare function useBriefingRunPolling<Run extends PollableBriefingRun>({ apiServiceUrl, token, intervalMs, timeoutMs, fetchRun, onRun, onTerminalRun, onError, onTimeout, }: UseBriefingRunPollingOptions<Run>): {
+    activeRunId: string | null;
+    isPolling: boolean;
+    resetTerminalRun: () => void;
+    startRun: (run: Run) => void;
+    startRunId: (runId: string) => void;
+    status: PollingStatus;
+    stop: () => void;
+};
+export {};

package/dist/types/components/briefings/watch-dashboard-button.d.ts

@@ -0,0 +1,7 @@
+export type WatchDashboardButtonProps = {
+    disabled?: boolean;
+    briefingCount?: number;
+    className?: string;
+    onClick?: () => void;
+};
+export declare function WatchDashboardButton({ disabled, briefingCount, className, onClick, }: WatchDashboardButtonProps): import("react/jsx-runtime").JSX.Element;

package/dist/types/components/calculated-fields/ai-compose-panel.d.ts

@@ -0,0 +1,19 @@
+import { CalculatedFieldType } from '../../lib/types/calculated-field-editor-types.js';
+export type AIComposeMode = 'prompt' | 'loading' | 'result';
+export type AIComposePanelProps = {
+    mode: AIComposeMode;
+    fieldType: CalculatedFieldType;
+    prompt: string;
+    onPromptChange: (value: string) => void;
+    generated: string;
+    explanation?: string;
+    isGenerating: boolean;
+    error?: string | null;
+    onGenerate: () => void;
+    onTryAgain: () => void;
+    onCancel: () => void;
+    onUseDraft: () => void;
+    /** When true, the whole panel is interaction-disabled (e.g. tenant viewer). */
+    disabled?: boolean;
+};
+export declare function AIComposePanel({ mode, fieldType, prompt, onPromptChange, generated, explanation, isGenerating, error, onGenerate, onTryAgain, onCancel, onUseDraft, disabled, }: AIComposePanelProps): import("react/jsx-runtime").JSX.Element;

package/dist/types/components/calculated-fields/calculated-field-editor-utils.d.ts

@@ -0,0 +1,44 @@
+import { Field, FieldScope, MetricField, GroupByField } from '../../lib/types/explorer-types.js';
+import { CalculatedFieldType } from '../../lib/types/calculated-field-editor-types.js';
+/**
+ * The type toggle chooses WHEN the formula runs, and everything else
+ * follows (which functions are allowed, whether Output type appears,
+ * whether the result is a column or a metric). So the labels name the
+ * compute level, not a field noun: a numeric per-row calculation is not a
+ * "Dimension". Matches the ƒ / Σ glyphs and the preview card wording.
+ * Internal values stay `dimension` / `metric`.
+ */
+export declare function getCalculatedFieldTypeLabel(fieldType: CalculatedFieldType): string;
+export declare function getCalculatedFieldTypeDescription(fieldType: CalculatedFieldType): string;
+export declare function getCalculatedDependencyShapeLabel(kind: 'inline' | 'multi-entity'): string;
+export declare function getCalculatedFieldAvailabilityLabel(scope: FieldScope): string;
+export declare function getEditableMetricExpression(field: MetricField): string;
+type MetricEditGuard = {
+    readOnly: boolean;
+    reason?: string;
+};
+export declare function getMetricEditGuard(field: MetricField): MetricEditGuard;
+export declare function mergeEditedMetricField(existingField: MetricField, newField: MetricField): MetricField;
+export declare function buildMetricInputFieldsForExpression(inputFields: Array<Field | MetricField | GroupByField>, existingField?: MetricField): MetricField[];
+type DomainConflictParams = {
+    fields: Array<MetricField | GroupByField>;
+    normalizedName: string;
+    existingFieldId?: string;
+    targetKind: 'inline' | 'root';
+    targetEntityName?: string;
+    targetQualifiedEntityName?: string;
+};
+export declare function hasDomainFieldNameConflict({ fields, normalizedName, existingFieldId, targetKind, targetEntityName, targetQualifiedEntityName, }: DomainConflictParams): boolean;
+export declare function hasUnsupportedQualifiedInlineDatasetMove(args: {
+    existingField?: MetricField | GroupByField;
+    existingFieldScope?: FieldScope;
+    nextField: Field;
+}): boolean;
+export declare function shouldSaveQualifiedInlineExpressionAsRootDomainField(field: Field | MetricField | GroupByField): boolean;
+export declare function serializeExpressionWithNamedTokens(expression: string, inputFields: Array<Field | MetricField | GroupByField>): {
+    expression: string;
+    tokenNames: string[];
+};
+export declare function serializeExpressionForInlineDimensionDomainSave(expression: string, inputFields: Array<Field | MetricField | GroupByField>): string;
+export declare function serializeExpressionForInlineMetricDomainSave(expression: string, inputFields: Array<Field | MetricField | GroupByField>): string;
+export {};

package/dist/types/components/calculated-fields/calculated-field-editor.d.ts

@@ -0,0 +1,26 @@
+import { Field, FieldScope, GroupByField, MetricField } from '../../lib/types/explorer-types.js';
+import { CalculatedFieldType } from '../../lib/types/calculated-field-editor-types.js';
+import { DomainDefinitionStatus } from './domain-definition-notice.js';
+export declare function CalculatedFieldEditor({ open, onOpenChange, availableFields, unavailableFieldReasons, existingField, existingFieldScope, domainDefinitionStatus, onSave, onSaveToSheet, onSaveToDashboard, cardId, initialFieldType, allowedFieldTypes, }: {
+    open: boolean;
+    onOpenChange: (open: boolean) => void;
+    availableFields: Field[];
+    /**
+     * Base fields the CURRENT visual cannot use, keyed by field id, with the
+     * customer-facing reason. Informational only in the picker: a shared
+     * (sheet/dashboard) calculation may be meant for another visual, so these
+     * inputs stay selectable. Supplied by the field list from the shared
+     * field-state calculator so the note agrees with the list.
+     */
+    unavailableFieldReasons?: Record<string, string>;
+    existingField?: MetricField | GroupByField;
+    existingFieldScope?: FieldScope;
+    /** Whether a governed definition shown here came from the current catalog. */
+    domainDefinitionStatus?: DomainDefinitionStatus;
+    onSave: (field: MetricField | GroupByField) => void | Promise<void>;
+    onSaveToSheet?: (field: MetricField | GroupByField) => void | Promise<void>;
+    onSaveToDashboard?: (field: MetricField | GroupByField) => void | Promise<void>;
+    cardId: string;
+    initialFieldType?: CalculatedFieldType;
+    allowedFieldTypes?: CalculatedFieldType[];
+}): import("react/jsx-runtime").JSX.Element;

package/dist/types/components/calculated-fields/domain-definition-notice.d.ts

@@ -0,0 +1,4 @@
+export type DomainDefinitionStatus = 'effective' | 'unverified' | 'loading' | 'unavailable';
+export declare function DomainDefinitionNotice({ status, }: {
+    status: DomainDefinitionStatus;
+}): import("react/jsx-runtime").JSX.Element;

package/dist/types/components/calculated-fields/expression-validator.d.ts

@@ -0,0 +1,8 @@
+import { ExpressionValidationResult } from '../../lib/types/calculated-field-editor-types.js';
+export declare function ExpressionValidator({ onValidate, isValidating, validationResult, error, disabled, }: {
+    onValidate: () => void;
+    isValidating: boolean;
+    validationResult: ExpressionValidationResult | null;
+    error?: string | null;
+    disabled?: boolean;
+}): import("react/jsx-runtime").JSX.Element;

package/dist/types/components/calculated-fields/field-picker-panel.d.ts

@@ -0,0 +1,16 @@
+import { AvailableFieldGroup, AvailableField } from '../../lib/hooks/calculated-fields/use-available-fields.js';
+/**
+ * Token picker for the calculated field editor; a host of `FieldOptionList`.
+ * `useAvailableFields` decides compatibility and grouping (it knows about
+ * the calculated-fields group and aggregate rules); this panel only renders.
+ */
+export declare function FieldPickerPanel({ groups, searchTerm, onSearchTermChange, onFieldClick, selectedFieldIds, unavailableFieldReasons, disabled, }: {
+    groups: AvailableFieldGroup[];
+    searchTerm: string;
+    onSearchTermChange: (value: string) => void;
+    onFieldClick: (field: AvailableField) => void;
+    selectedFieldIds?: string[];
+    /** Fields blocked for the current chart, by id, with the reason. */
+    unavailableFieldReasons?: Record<string, string>;
+    disabled?: boolean;
+}): import("react/jsx-runtime").JSX.Element;

package/dist/types/components/calculated-fields/field-type-toggle.d.ts

@@ -0,0 +1,7 @@
+import { CalculatedFieldType } from '../../lib/types/calculated-field-editor-types.js';
+export declare function FieldTypeToggle({ value, onChange, disabled, options, }: {
+    value: CalculatedFieldType;
+    onChange: (value: CalculatedFieldType) => void;
+    disabled?: boolean;
+    options?: CalculatedFieldType[];
+}): import("react/jsx-runtime").JSX.Element;

package/dist/types/components/calculated-fields/index.d.ts

@@ -0,0 +1,10 @@
+export { CalculatedFieldEditor } from './calculated-field-editor.js';
+export { FieldPickerPanel } from './field-picker-panel.js';
+export { FieldTypeToggle } from './field-type-toggle.js';
+export { ExpressionValidator } from './expression-validator.js';
+export { ValidationResults } from './validation-results.js';
+export { SummaryRibbon, buildSummaryChips } from './summary-ribbon.js';
+export { InsertFieldPopover } from './insert-field-popover.js';
+export { TemplatesMenu } from './templates-menu.js';
+export { AIComposePanel } from './ai-compose-panel.js';
+export type { AIComposeMode, AIComposePanelProps, } from './ai-compose-panel.js';

package/dist/types/components/calculated-fields/insert-field-popover.d.ts

@@ -0,0 +1,18 @@
+import { AvailableField, AvailableFieldGroup } from '../../lib/hooks/calculated-fields/use-available-fields.js';
+export type InsertFieldPopoverProps = {
+    groups: AvailableFieldGroup[];
+    searchTerm: string;
+    onSearchTermChange: (value: string) => void;
+    onFieldSelect: (field: AvailableField) => void;
+    selectedFieldIds?: string[];
+    /** Fields blocked for the current chart, by id, with the reason. */
+    unavailableFieldReasons?: Record<string, string>;
+    disabled?: boolean;
+};
+/**
+ * "Insert field" popover — Variant B's replacement for the always-on
+ * field rail. Anchored to the toolbar button on the formula editor;
+ * selecting a field inserts its `{tokenLabel}` at the cursor and
+ * closes the popover.
+ */
+export declare function InsertFieldPopover({ groups, searchTerm, onSearchTermChange, onFieldSelect, selectedFieldIds, unavailableFieldReasons, disabled, }: InsertFieldPopoverProps): import("react/jsx-runtime").JSX.Element;

package/dist/types/components/calculated-fields/summary-ribbon.d.ts

@@ -0,0 +1,23 @@
+import { InlineExpressionAnalysis } from '../../lib/utils/inline-expression-utils.js';
+type ChipDef = {
+    label: string;
+    value: string;
+};
+/**
+ * The ribbon only carries facts the form does not already show. Type,
+ * compute mode, and availability all have controls above it, so the
+ * ribbon is reserved for what the expression analyzer derives.
+ */
+export type SummaryRibbonProps = {
+    inlineAnalysis: InlineExpressionAnalysis;
+    /**
+     * When false, dependency-shape chips (Uses, Stored with) are hidden.
+     * The expression analyzer treats zero inputs as `multi-entity` for
+     * resolver simplicity, but UX-wise it would be misleading to show
+     * "Cross-entity" before the user has typed anything.
+     */
+    hasInputFields?: boolean;
+};
+export declare function buildSummaryChips({ inlineAnalysis, hasInputFields, }: SummaryRibbonProps): ChipDef[];
+export declare function SummaryRibbon(props: SummaryRibbonProps): import("react/jsx-runtime").JSX.Element | null;
+export {};

package/dist/types/components/calculated-fields/templates-menu.d.ts

@@ -0,0 +1,14 @@
+export type TemplatesMenuProps = {
+    onInsert: (snippet: string) => void;
+    disabled?: boolean;
+};
+/**
+ * Variant B "Templates" menu — replaces the legacy OperationSelector +
+ * A/B input shelf. Selecting a template inserts the formula text into
+ * the formula editor at the cursor; the user replaces `{a}` / `{b}`
+ * placeholders with real fields after.
+ *
+ * Metric-only — caller decides whether to render this. Calculated
+ * Columns are row-level and do not have aggregate templates.
+ */
+export declare function TemplatesMenu({ onInsert, disabled }: TemplatesMenuProps): import("react/jsx-runtime").JSX.Element;

package/dist/types/components/calculated-fields/validation-results.d.ts

@@ -0,0 +1,4 @@
+import { ExpressionValidationResult } from '../../lib/types/calculated-field-editor-types.js';
+export declare function ValidationResults({ result, }: {
+    result: ExpressionValidationResult;
+}): import("react/jsx-runtime").JSX.Element;

package/dist/types/components/calculated-fields/validation-tooltip-content.d.ts

@@ -0,0 +1,4 @@
+import * as React from 'react';
+import * as TooltipPrimitive from '@radix-ui/react-tooltip';
+export declare const ValidationTooltipContent: React.ForwardRefExoticComponent<Omit<TooltipPrimitive.TooltipContentProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+export declare const ValidationTooltipArrow: React.ForwardRefExoticComponent<TooltipPrimitive.TooltipArrowProps & React.RefAttributes<SVGSVGElement>>;

package/dist/types/components/chart-selector/chart-icon.d.ts

@@ -0,0 +1,36 @@
+import { TChartType } from '../../lib/charts/types.js';
+interface ChartIconProps {
+    chartType?: string;
+    chartName: string;
+    isCustom?: boolean;
+    className?: string;
+}
+/**
+ * Generate a consistent color from a string using a simple hash
+ */
+declare function generateColorFromString(str: string): string;
+/**
+ * Get initials from a chart name
+ * - Multi-word: first letter of first two words
+ * - Single word: first two characters
+ */
+declare function getChartInitials(name: string): string;
+/**
+ * ChartIcon component that handles:
+ * 1. Default chart types - uses bundled icons
+ * 2. Custom charts - auto-detects from name, falls back to styled initials
+ */
+export declare function ChartIcon({ chartType, chartName, isCustom, className, }: ChartIconProps): import("react/jsx-runtime").JSX.Element;
+export { generateColorFromString, getChartInitials };
+/**
+ * SelectedChartIcon - displays the icon for the currently selected chart type
+ * Used in trigger buttons to show which chart is selected
+ */
+interface SelectedChartIconProps {
+    chartType: TChartType;
+    className?: string;
+    customIcon?: string;
+    componentName?: string;
+}
+export declare function SelectedChartIcon({ chartType, className, customIcon: _customIcon, // Not used - we use auto-detect + initials instead of dynamic icon loading
+componentName, }: SelectedChartIconProps): import("react/jsx-runtime").JSX.Element;

package/dist/types/components/chart-selector/chart-selector-item.d.ts

@@ -0,0 +1,19 @@
+interface ChartSelectorItemProps {
+    chartType?: string;
+    chartName: string;
+    isCustom?: boolean;
+    pluginName?: string;
+    isStarred: boolean;
+    showStar?: boolean;
+    isSelected?: boolean;
+    onSelect: () => void;
+    onToggleStar: () => void;
+}
+/**
+ * Individual chart item in the selector grid
+ * - Compact card: hairline border, small icon, label below
+ * - Star button appears on hover (top-left)
+ * - Info icon for custom charts (bottom-right, shows plugin name)
+ */
+export declare function ChartSelectorItem({ chartType, chartName, isCustom, pluginName, isStarred, showStar, isSelected, onSelect, onToggleStar, }: ChartSelectorItemProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/types/components/chart-selector/chart-selector.d.ts

@@ -0,0 +1,19 @@
+import { PluginVisual } from '../../lib/hooks/use-custom-visuals-query.js';
+import { TChartType } from '../../lib/charts/types.js';
+declare const defaultChartTypes: Array<{
+    id: TChartType;
+    name: string;
+}>;
+export declare function getAvailableDefaultChartTypes(input: {
+    isDevMode: boolean;
+}): typeof defaultChartTypes;
+interface ChartSelectorProps {
+    onChartSelect?: (chartType: TChartType, customVisual?: PluginVisual) => void;
+    onClose?: () => void;
+}
+/**
+ * Unified chart selector component with search, grid layout,
+ * and star/favorite functionality
+ */
+export declare function ChartSelector({ onChartSelect, onClose }: ChartSelectorProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/types/components/chart-selector/chart-type-picker.d.ts

@@ -0,0 +1,12 @@
+import { ComponentProps } from 'react';
+import { Button } from '../ui/button.js';
+import { TChartType } from '../../lib/charts/types.js';
+type ChartTypePickerVariant = 'header' | ComponentProps<typeof Button>['variant'];
+type ChartTypePickerProps = {
+    selectedChart?: TChartType;
+    onChartChange?: (chartType: TChartType) => void;
+    variant?: ChartTypePickerVariant;
+    className?: string;
+};
+export declare function ChartTypePicker({ selectedChart, onChartChange, variant, className, }: ChartTypePickerProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/types/components/chart-selector/index.d.ts

@@ -0,0 +1,5 @@
+export { ChartSelector } from './chart-selector.js';
+export { ChartSelectorItem } from './chart-selector-item.js';
+export { ChartIcon, SelectedChartIcon, generateColorFromString, getChartInitials } from './chart-icon.js';
+export { StarButton } from './star-button.js';
+export { ChartTypePicker } from './chart-type-picker.js';

package/dist/types/components/chart-selector/star-button.d.ts

@@ -0,0 +1,13 @@
+interface StarButtonProps {
+    isStarred: boolean;
+    onClick: (e: React.MouseEvent) => void;
+    className?: string;
+}
+/**
+ * Star button for favoriting charts
+ * - Outline star when not starred
+ * - Filled yellow star when starred
+ * - Prevents click propagation to not select the chart
+ */
+export declare function StarButton({ isStarred, onClick, className }: StarButtonProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/types/components/chart-selector/use-chart-selector-model.d.ts

@@ -0,0 +1,18 @@
+import { ReactNode } from 'react';
+import { TChartType } from '../../lib/charts/types.js';
+type UseChartSelectorModelArgs = {
+    selectedChart?: TChartType;
+    onChartChange?: (chartType: TChartType) => void;
+};
+export type ChartSelectorModel = {
+    displayChartType: TChartType;
+    displayLabel: string;
+    displayIcon: ReactNode;
+    showBadge: boolean;
+    badgeLabel?: string;
+    isMultiInputContext: boolean;
+    handleChartSelect: (chartType: TChartType) => void;
+    handleClearCustomVisual: (event: React.MouseEvent) => void;
+};
+export declare function useChartSelectorModel({ selectedChart, onChartChange, }: UseChartSelectorModelArgs): ChartSelectorModel;
+export {};

package/dist/types/components/dashboard/ai-dashboard-create-dialog.d.ts

@@ -0,0 +1,38 @@
+import { ReactNode } from 'react';
+import { DashboardPlan, DashboardSuggestion } from '../../shared/dashboard-authoring/index.js';
+import { DashboardAuthoringSource, DashboardPlanRequest, DashboardSuggestionRequest } from '../../lib/hooks/use-dashboard-authoring.js';
+import { DashboardCreateBlankData } from './dashboard-create-template.js';
+interface AiDashboardCreateDialogProps {
+    open: boolean;
+    onOpenChange: (open: boolean) => void;
+    onCreateBlank: (data: DashboardCreateBlankData) => void | Promise<void>;
+    onAiCreateSuccess: (result: any) => void;
+    isCreatingBlank: boolean;
+    aiAuthoringEnabled?: boolean;
+    initialDomainId?: string;
+}
+type AsyncMutation<TInput, TOutput> = {
+    isPending?: boolean;
+    mutateAsync: (input: TInput) => Promise<TOutput>;
+};
+export interface DashboardCreateDialogBaseProps {
+    open: boolean;
+    onOpenChange: (open: boolean) => void;
+    onCreateBlank: (data: DashboardCreateBlankData) => void | Promise<void>;
+    onAiCreateSuccess: (result: any) => void;
+    isCreatingBlank: boolean;
+    sources: DashboardAuthoringSource[];
+    sourcesLoading?: boolean;
+    suggestDashboards: (input: DashboardSuggestionRequest) => Promise<DashboardSuggestion[]>;
+    planDashboard: AsyncMutation<DashboardPlanRequest, DashboardPlan>;
+    createDashboardFromPlan: AsyncMutation<DashboardPlan, any>;
+    settingsSlot?: ReactNode;
+    blankDescription?: string;
+    description?: string;
+    canCreate?: boolean;
+    aiAuthoringEnabled?: boolean;
+    initialDomainId?: string;
+}
+export declare function DashboardCreateDialogBase({ open, onOpenChange, onCreateBlank, onAiCreateSuccess, isCreatingBlank, sources, sourcesLoading, suggestDashboards, planDashboard, createDashboardFromPlan, settingsSlot, blankDescription, description, canCreate, aiAuthoringEnabled, initialDomainId, }: DashboardCreateDialogBaseProps): import("react/jsx-runtime").JSX.Element;
+export declare function AiDashboardCreateDialog({ open, onOpenChange, onCreateBlank, onAiCreateSuccess, isCreatingBlank, aiAuthoringEnabled, initialDomainId, }: AiDashboardCreateDialogProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/types/components/dashboard/card-actions-menu.d.ts

@@ -0,0 +1,10 @@
+import { TCard, TFrame } from '../../lib/types/common-types.js';
+import { MatrixDeliveryContext } from '../../lib/matrix-table/matrix-delivery.js';
+type CardActionsMenuProps = {
+    card: TCard;
+    frame: TFrame;
+    exportData?: unknown;
+    getMatrixDelivery?: () => MatrixDeliveryContext | undefined;
+};
+export declare function CardActionsMenu(props: CardActionsMenuProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/types/components/dashboard/card-summary.d.ts

@@ -0,0 +1,8 @@
+import { TCard } from '../../lib/types/common-types.js';
+type CardSummaryProps = {
+    card: TCard;
+    mode?: 'dashboard' | 'editor';
+    records?: Record<string, unknown>[] | null;
+};
+export declare function CardSummary({ card, mode, records, }: CardSummaryProps): import("react/jsx-runtime").JSX.Element | null;
+export {};

package/dist/types/components/dashboard/comparison-badge-state.d.ts

@@ -0,0 +1,3 @@
+import { ComparisonMetadataMap } from '../../lib/types/query-types.js';
+export type ComparisonBadgeState = 'active' | 'attention' | 'unavailable' | 'hidden';
+export declare function getComparisonBadgeState(metadata: ComparisonMetadataMap | undefined): ComparisonBadgeState;

package/dist/types/components/dashboard/comparison-metadata-badge.d.ts

@@ -0,0 +1,11 @@
+import { ComparisonMetadataEntry, ComparisonMetadataMap } from '../../lib/types/query-types.js';
+interface ComparisonMetadataBadgeProps {
+    metadata: ComparisonMetadataMap;
+    variant?: 'compact' | 'detailed';
+}
+interface ComparisonMetadataHoverContentProps {
+    entries: Array<[string, ComparisonMetadataEntry]>;
+}
+export declare function ComparisonMetadataHoverContent({ entries, }: ComparisonMetadataHoverContentProps): import("react/jsx-runtime").JSX.Element | null;
+export declare function ComparisonMetadataBadge({ metadata, variant, }: ComparisonMetadataBadgeProps): import("react/jsx-runtime").JSX.Element | null;
+export {};