react-semaphor 0.1.503 → 0.1.505

package/dist/types/components/visual/aggregated-table/utils/metric-format-resolver.d.ts

@@ -0,0 +1,66 @@
+import { QueryColumnKeyMap } from '../../../../lib/types/explorer-types.js';
+import { TCard } from '../../../../lib/types/common-types.js';
+import { ColumnSettings, ColumnSettingsMap } from '../../data-table/types/data-table.js';
+import { PresentationFormatField } from '../../../../lib/formatters/metric-formatting.js';
+import { ResolvedValueFormatPreferences } from '../../../../shared/value-format-preferences/index.js';
+import { CardNumericPresentationContext } from '../../../../lib/formatters/numeric-presentation.js';
+import { NumericCanonicalFormat } from '../../../../shared/format-utils/types/index.js';
+import { coerceNumericValue } from '../../../../lib/formatters/numeric-value-coercion.js';
+export { hasNumericFieldFormat } from '../../../../lib/table-formatting/table-presentation-fields.js';
+export { coerceNumericValue };
+type ResolveMetricSettingsParams = {
+    card: TCard;
+    columnId: string;
+    metricIndex: number;
+    groupByColumnCount: number;
+    columnSettingsMap?: ColumnSettingsMap;
+    valueFormatPreferences?: ResolvedValueFormatPreferences | null;
+    boundCurrency?: string;
+    preserveOmittedProperties?: boolean;
+};
+export declare function resolveAggregateMetricSettings({ card, columnId, metricIndex, groupByColumnCount, columnSettingsMap, valueFormatPreferences, boundCurrency, preserveOmittedProperties, }: ResolveMetricSettingsParams): ColumnSettings;
+/**
+ * Resolves the column settings for a group-by (row) column. Row fields with a
+ * numeric `format` flow through the same metric resolver as measures so the
+ * table column override, live locale/currency preferences, and persisted
+ * settings all compose identically. Row fields without a numeric format keep
+ * their plain table settings untouched, so unformatted numeric dimensions such
+ * as years render exactly as before.
+ */
+export declare function resolveAggregateGroupBySettings(params: {
+    card: TCard;
+    columnId: string;
+    groupByField: PresentationFormatField | undefined;
+    columnKeyMap?: QueryColumnKeyMap;
+    columnSettingsMap?: ColumnSettingsMap;
+    valueFormatPreferences?: ResolvedValueFormatPreferences | null;
+    preserveOmittedProperties?: boolean;
+}): ColumnSettings | undefined;
+/** Numeric column settings keyed by the physical group column key. */
+export type AggregateGroupNumericPresentation = ReadonlyMap<string, ColumnSettings>;
+/**
+ * Resolves numeric presentation for every group-by column that has an
+ * authored numeric format. Shared by the browser cells, CSV export, and the
+ * PDF fast path so all three render row values identically.
+ */
+export declare function resolveAggregateGroupNumericPresentation(params: {
+    card: TCard;
+    groupByColumns: readonly PresentationFormatField[];
+    groupColumnKeys: readonly string[];
+    columnKeyMap?: QueryColumnKeyMap;
+    columnSettingsMap?: ColumnSettingsMap;
+    valueFormatPreferences?: ResolvedValueFormatPreferences | null;
+}): AggregateGroupNumericPresentation;
+export declare function resolveAggregateMetricCanonicalPresentation(params: {
+    card: TCard;
+    columnId: string;
+    metricIndex: number;
+    groupByColumnCount: number;
+    columnSettingsMap?: ColumnSettingsMap;
+    presentation?: CardNumericPresentationContext;
+}): NumericCanonicalFormat | undefined;
+export declare function formatNumericWithSettings(value: unknown, settings?: ColumnSettings): string | null;
+export declare function formatAggregateMetricValue(value: unknown, presentation?: {
+    settings?: ColumnSettings;
+    canonical?: NumericCanonicalFormat;
+}): string;

package/dist/types/components/visual/aggregated-table/utils/temporal-presentation.d.ts

@@ -0,0 +1,17 @@
+import { CardConfig, QueryColumnKeyMap } from '../../../../lib/types/explorer-types.js';
+import { RowData } from '../types/aggregate-table.js';
+import { GroupedTemporalPresentation } from '../../../../lib/formatters/grouped-temporal-presentation.js';
+import { ColumnSettings } from '../../data-table/types/data-table.js';
+export type AggregateTemporalPresentation = GroupedTemporalPresentation;
+export declare function resolveAggregateGroupColumnKey(fieldId: string, fallbackKey: string, columnKeyMap?: QueryColumnKeyMap): string;
+export declare function formatAggregateGroupValue(input: {
+    value: unknown;
+    columnKey: string;
+    presentation?: AggregateTemporalPresentation;
+    /**
+     * Resolved numeric column settings for a row field that carries an
+     * authored number format (see `resolveAggregateGroupNumericPresentation`).
+     */
+    numericSettings?: ColumnSettings;
+}): string;
+export declare function resolveAggregateInteractionConfig(config: CardConfig, row: RowData, columnKeyMap?: QueryColumnKeyMap): CardConfig;

package/dist/types/components/visual/chart-utils.d.ts

@@ -0,0 +1,15 @@
+import { default as React } from 'react';
+export declare const chartTypes: ({
+    id: string;
+    icon: React.ForwardRefExoticComponent<Omit<import('lucide-react').LucideProps, "ref"> & React.RefAttributes<SVGSVGElement>>;
+    label: string;
+} | {
+    id: string;
+    icon: import('react-icons/lib').IconType;
+    label: string;
+})[];
+/**
+ * Returns a chart type icon React element based on a visual's name or description.
+ * If no match is found, returns null.
+ */
+export declare function getChartTypeIconFromName(nameOrDescription: string, className?: string): React.FunctionComponentElement<Omit<import('lucide-react').LucideProps, "ref"> & React.RefAttributes<SVGSVGElement>> | null;

package/dist/types/components/visual/chartjs-visual.d.ts

@@ -0,0 +1,9 @@
+import { RefObject, MouseEvent } from 'react';
+import { Chart } from 'chart.js/auto';
+import { ChartConfiguration } from 'chart.js';
+export type VisualProps = {
+    cfg: ChartConfiguration;
+    onChartClick?: (e: MouseEvent<HTMLDivElement>, chart: Chart, canvasRef: RefObject<HTMLCanvasElement | null>) => void;
+    onDatapointClick?: (chart: Chart, datasetIndex: number, clickIndex: number, data: number) => void;
+};
+export declare function ChartJsVisual({ cfg, onDatapointClick, onChartClick, }: VisualProps): import("react/jsx-runtime").JSX.Element;

package/dist/types/components/visual/column-display-utils.d.ts

@@ -0,0 +1,2 @@
+import { DateOptions } from '../index.js';
+export declare function getDateOptions(locale: string, format: string): DateOptions;

package/dist/types/components/visual/custom-visual/build-inline-filter-nodes.d.ts

@@ -0,0 +1,21 @@
+import { default as React } from 'react';
+import { TCard } from '../../surfboard/index.js';
+import { TFilterValue } from '../../surfboard/filter/types.js';
+type BuildInlineFilterNodesParams = {
+    card: TCard;
+    sheetId: string;
+    inlineFilterValues?: TFilterValue[];
+    setInlineFilterValue?: (filterValue: TFilterValue) => void;
+    removeInlineFilterValue?: (filterId: string) => void;
+};
+/**
+ * Builds an array of React nodes for inline filters that can be passed to custom visual plugins.
+ * Plugin developers can render these nodes wherever they want in their component layout.
+ *
+ * @param card - The card containing inline filter configuration
+ * @param sheetId - The current sheet ID
+ * @param inlineFilterValues - Current filter values from the dashboard store
+ * @returns Array of React nodes (empty array if no inline filters)
+ */
+export declare function buildInlineFilterNodes({ card, sheetId, inlineFilterValues, setInlineFilterValue, removeInlineFilterValue, }: BuildInlineFilterNodesParams): React.ReactNode[];
+export {};

package/dist/types/components/visual/custom-visual/build-multi-input-props.d.ts

@@ -0,0 +1,48 @@
+import { ReactNode } from 'react';
+import { TCard } from '../../../lib/types/common-types.js';
+import { TFilter, TFilterValue } from '../../surfboard/filter/types.js';
+import { CardMetadata, CustomVisualInputResult, CustomCardTheme, TabMetadata } from './custom-visual-types.js';
+import { SemaphorResultColumn } from '../../../shared/analytics-protocol/index.js';
+import { FormatCustomVisualTemporalBucketValue } from './custom-visual-temporal-presentation.js';
+type MultiInputDataMap = Record<string, CustomVisualInputResult>;
+export type MultiInputCustomVisualProps = {
+    data: Record<string, any>[][];
+    columns: SemaphorResultColumn[][];
+    formatTemporalBucketValue: FormatCustomVisualTemporalBucketValue;
+    settings?: Record<string, any>;
+    slotSettings?: Array<Record<string, any> | undefined>;
+    tabMetadata: TabMetadata;
+    cardMetadata: CardMetadata[];
+    params?: Record<string, any>;
+    theme?: CustomCardTheme;
+    chartSettings?: Record<string, any>;
+    filters?: TFilter[];
+    filterValues?: TFilterValue[];
+    inlineFilters?: ReactNode[];
+};
+type BuildMultiInputCustomVisualPropsArgs = {
+    configCard?: TCard | null;
+    slotOrderedCards: Array<TCard | null>;
+    slotTypes: Array<TCard['type'] | undefined | null>;
+    multiInputData?: MultiInputDataMap;
+    params?: Record<string, any>;
+    theme?: CustomCardTheme;
+    chartSettings?: Record<string, any>;
+    filters?: TFilter[];
+    filterValues?: TFilterValue[];
+    inlineFilters?: ReactNode[];
+    formatTemporalBucketValue: FormatCustomVisualTemporalBucketValue;
+};
+export declare function applyTitleDescriptionDefaults(settings: Record<string, any> | undefined, card?: TCard | null): Record<string, any> | undefined;
+export declare function buildCardMetadataForSlot({ inputCard, slotType, slotIndex, multiInputData, }: {
+    inputCard: TCard | null;
+    slotType: string | undefined | null;
+    slotIndex: number;
+    multiInputData?: MultiInputDataMap;
+}): CardMetadata;
+export declare function buildSingleInputCardMetadata({ card, dataMetadata, }: {
+    card: TCard;
+    dataMetadata?: Record<string, any>;
+}): CardMetadata;
+export declare function buildMultiInputCustomVisualProps({ configCard, slotOrderedCards, slotTypes, multiInputData, params, theme, chartSettings, filters, filterValues, inlineFilters, formatTemporalBucketValue, }: BuildMultiInputCustomVisualPropsArgs): MultiInputCustomVisualProps;
+export {};

package/dist/types/components/visual/custom-visual/component-combo-box.d.ts

@@ -0,0 +1,10 @@
+interface ComponentComboBoxProps {
+    value: string;
+    onValueChange: (value: string) => void;
+    components: {
+        value: string;
+        label: string;
+    }[];
+}
+export declare function ComponentComboBox({ value, onValueChange, components, }: ComponentComboBoxProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/types/components/visual/custom-visual/custom-card-theme-adapter.d.ts

@@ -0,0 +1,3 @@
+import { CompiledAppearance } from '../../../lib/appearance/types.js';
+import { CustomCardTheme } from './custom-visual-types.js';
+export declare function buildCustomCardTheme(compiledAppearance: CompiledAppearance): CustomCardTheme;

package/dist/types/components/visual/custom-visual/custom-visual-settings.d.ts

@@ -0,0 +1 @@
+export declare function CustomVisualSettings(): import("react/jsx-runtime").JSX.Element;

package/dist/types/components/visual/custom-visual/custom-visual-temporal-presentation.d.ts

@@ -0,0 +1,35 @@
+import { TCard } from '../../../lib/types/common-types.js';
+import { CardConfig, QueryColumnKeyMap } from '../../../lib/types/explorer-types.js';
+import { SemaphorResultColumn } from '../../../shared/analytics-protocol/index.js';
+import { PresentationExecutionSnapshot } from '../../../shared/format-utils/index.js';
+import { ResolvedTemporalValueFormatPreferences } from '../../../shared/value-format-preferences/index.js';
+import { CustomVisualInputResult } from './custom-visual-types.js';
+export type FormatCustomVisualTemporalBucketValue = (value: unknown, column: SemaphorResultColumn) => string;
+export type CustomVisualTemporalInput = {
+    card: TCard;
+    cardConfig?: CardConfig;
+    columns?: readonly SemaphorResultColumn[];
+    columnKeyMap?: QueryColumnKeyMap;
+    executionSnapshot?: PresentationExecutionSnapshot | null;
+    dashboardId?: string;
+    attachmentIndex?: number;
+    valueFormatPreferences?: ResolvedTemporalValueFormatPreferences | null;
+};
+export declare function buildMultiInputTemporalPresentationInputs(input: {
+    slotOrderedCards: readonly (TCard | null)[];
+    multiInputData: Readonly<Record<string, CustomVisualInputResult>>;
+    executionSnapshot?: PresentationExecutionSnapshot | null;
+    dashboardId?: string;
+    attachmentIndex?: number;
+    valueFormatPreferences?: ResolvedTemporalValueFormatPreferences | null;
+}): CustomVisualTemporalInput[];
+export declare class CustomVisualTemporalColumnError extends Error {
+    readonly code = "invalid_custom_visual_temporal_column";
+    constructor(columnKey: string);
+}
+/**
+ * Builds the one host-owned formatter shared by all input slots. Descriptor
+ * identity deliberately scopes duplicate result keys to the card result that
+ * supplied them; plugins must pass the actual descriptor from `columns`.
+ */
+export declare function createCustomVisualTemporalBucketFormatter(inputs: readonly CustomVisualTemporalInput[]): FormatCustomVisualTemporalBucketValue;

package/dist/types/components/visual/custom-visual/custom-visual-types.d.ts

@@ -0,0 +1,171 @@
+import { ReactNode } from 'react';
+import { TFilter, TFilterValue } from '../../surfboard/filter/types.js';
+import { ComparisonMetadataMap } from '../../../lib/types/query-types.js';
+import { ComparisonPresentationSpec, MetricComparisonPolarity, SemaphorResultColumn } from '../../../shared/analytics-protocol/index.js';
+import { ColorRange, NumberAxisFormat, TFormatOptions } from '../../../lib/types/common-types.js';
+import { ColumnSettings } from '../data-table/types/data-table.js';
+import { AppearanceColorTokens, AppearanceDensity, AppearanceTokens, ResolvedAppearanceMode, TableAppearance } from '../../../lib/appearance/types.js';
+import { FormatCustomVisualTemporalBucketValue } from './custom-visual-temporal-presentation.js';
+import { CardConfig, QueryColumnKeyMap } from '../../../lib/types/explorer-types.js';
+export type CustomCardAppearanceTheme = {
+    version: 1;
+    mode: ResolvedAppearanceMode;
+    colors: AppearanceColorTokens;
+    typography?: AppearanceTokens['typography'];
+    radius?: AppearanceTokens['radius'];
+    spacing?: AppearanceTokens['spacing'];
+    shadow?: AppearanceTokens['shadow'];
+    density?: AppearanceDensity;
+    chartPalette: string[];
+    table?: TableAppearance;
+};
+export type CustomCardTheme = {
+    colors: string[];
+    mode: 'light' | 'dark' | 'system';
+    appearance?: CustomCardAppearanceTheme;
+};
+export type Data = Record<string, unknown>[];
+export type CustomVisualInputResult = {
+    records: Data;
+    columns?: SemaphorResultColumn[];
+    columnKeyMap?: QueryColumnKeyMap;
+    effectiveCardConfig?: CardConfig;
+    metadata?: Record<string, any>;
+};
+export type SlotDefinition = {
+    position: number | string;
+    label: string;
+    description?: string;
+    expectedType?: string | string[];
+    required?: boolean;
+};
+export type TabMetadata = {
+    titles: string[];
+    cardTypes: string[];
+    cardIds: string[];
+};
+export type CardMetadata = {
+    cardType: string;
+    title: string;
+    description?: string;
+    kpiConfig?: {
+        comparisonMetadata?: ComparisonMetadataMap;
+        options?: {
+            comparisonPolarity?: MetricComparisonPolarity;
+            comparisonPresentation?: ComparisonPresentationSpec;
+            showComparison?: boolean;
+        };
+        formatNumber?: LegacyFormatNumber;
+    };
+    formatConfig?: CustomVisualFormatConfig;
+};
+export type LegacyFormatNumber = {
+    decimalPlaces?: number;
+    currency?: string;
+    locale?: string;
+    suffix?: string;
+    enabled?: boolean | string;
+    colorRanges?: ColorRange[];
+    [key: string]: unknown;
+};
+export type NormalizedTableColumnFormat = {
+    id?: string;
+    label?: string;
+    position?: number;
+    numberFormat?: ColumnSettings['numberFormat'] | TFormatOptions;
+};
+export type CustomVisualFormatConfig = {
+    kpi?: {
+        primary?: TFormatOptions;
+        comparison?: TFormatOptions;
+        colorRanges?: ColorRange[];
+    };
+    axes?: {
+        xAxis?: TFormatOptions;
+        yAxis?: TFormatOptions;
+        secondaryYAxis?: TFormatOptions;
+    };
+    dataLabels?: TFormatOptions;
+    tables?: {
+        columns?: NormalizedTableColumnFormat[];
+        columnMap?: Record<string, {
+            numberFormat?: ColumnSettings['numberFormat'] | TFormatOptions;
+        }>;
+        comparison?: TFormatOptions;
+        defaultNumberFormat?: TFormatOptions;
+    };
+    legacy?: {
+        formatNumber?: LegacyFormatNumber;
+        numberAxisFormat?: NumberAxisFormat;
+    };
+};
+/**
+ * Props passed to single-input custom visual components.
+ */
+export type SingleInputVisualProps = {
+    /** Query results array */
+    data: Data;
+    /** Authoritative result columns aligned with `data`. */
+    columns: SemaphorResultColumn[];
+    /** Formats only canonical temporal values using their supplied descriptor. */
+    formatTemporalBucketValue: FormatCustomVisualTemporalBucketValue;
+    /** Component settings from manifest */
+    settings?: Record<string, string | number | boolean>;
+    /** Card metadata (read-only context) */
+    cardMetadata?: CardMetadata;
+    /** Theme configuration */
+    theme?: CustomCardTheme;
+    /** Auth token parameters */
+    params?: Record<string, any>;
+    /** Active filters */
+    filters?: TFilter[];
+    /** Filter values */
+    filterValues?: TFilterValue[];
+    /**
+     * Pre-rendered inline filter components.
+     * Plugin developers can render these wherever they want in their layout.
+     * Always an array (empty if no inline filters configured).
+     */
+    inlineFilters?: ReactNode[];
+    /** True when rendered in the editor */
+    editing?: boolean;
+    /** Callback for data updates (multi-input visuals) */
+    onDataChange?: (cardId: string, data: any) => void;
+};
+/**
+ * Props passed to multi-input custom visual components.
+ */
+export type MultiInputVisualProps = {
+    /** Array of datasets, one per input */
+    data: Data[];
+    /** Authoritative result columns aligned with each `data` input. */
+    columns: SemaphorResultColumn[][];
+    /** Formats only canonical temporal values using their supplied descriptor. */
+    formatTemporalBucketValue: FormatCustomVisualTemporalBucketValue;
+    /** Global settings (config card) */
+    settings?: Record<string, string | number | boolean>;
+    /** Per-slot settings (aligned with data array) */
+    slotSettings?: Array<Record<string, string | number | boolean> | undefined>;
+    /** Theme configuration */
+    theme?: CustomCardTheme;
+    /** Auth token parameters */
+    params?: Record<string, any>;
+    /** Active filters */
+    filters?: TFilter[];
+    /** Filter values */
+    filterValues?: TFilterValue[];
+    /**
+     * Pre-rendered inline filter components.
+     * Plugin developers can render these wherever they want in their layout.
+     * Always an array (empty if no inline filters configured).
+     */
+    inlineFilters?: ReactNode[];
+    /** Callback for data updates */
+    onDataChange?: (cardId: string, data: any) => void;
+    /** Additional metadata about tabs/cards */
+    tabMetadata?: TabMetadata;
+    /** True when rendered in the editor */
+    editing?: boolean;
+    /** Rich metadata for each tab/card */
+    cardMetadata?: CardMetadata[];
+};

package/dist/types/components/visual/custom-visual/custom-visual-utils.d.ts

@@ -0,0 +1,57 @@
+import { default as React, ComponentProps } from 'react';
+import { SlotDefinition } from './custom-visual-types.js';
+export type VisualComponent = {
+    name: string;
+    componentName: string;
+    type: 'single' | 'multiple';
+    Component: React.LazyExoticComponent<(props: ComponentProps<any>) => React.ReactNode>;
+};
+export type Setting = {
+    title: string;
+    options?: {
+        value: string;
+        label: string;
+    }[];
+    defaultValue: string | number | boolean;
+    ui: 'input' | 'select';
+    docs?: {
+        description?: string;
+    };
+};
+export type Settings = Record<string, Setting>;
+export type Manifest = {
+    visuals: ExportedComponent[];
+    filters?: ExportedFilterComponent[];
+};
+export type ExportedFilterComponent = {
+    name: string;
+    component: string;
+    icon?: string;
+    filterType?: string;
+    settings?: Settings;
+    supportedDataTypes?: string[];
+};
+export type ExportedComponent = {
+    name: string;
+    component: string;
+    componentType?: 'chart' | 'editor' | 'settings';
+    icon?: string;
+    settings?: Settings;
+    slotSettings?: Settings;
+    dataInputs?: string[];
+    visualType?: 'single' | 'multiple';
+    minInputs?: number;
+    maxInputs?: number;
+    slots?: SlotDefinition[];
+    chartType?: string;
+    docs?: {
+        description?: string;
+        dataSchema?: string;
+        useCases?: string[];
+    };
+};
+export declare function loadComponent(url: string, componentName: string): Promise<{
+    default: any;
+}>;
+export declare function getComponentNamesFromLibrary(url: string): Promise<ExportedComponent[]>;
+export declare function loadManifest(url: string): Promise<Manifest>;

package/dist/types/components/visual/custom-visual/dashboard-custom-visual.d.ts

@@ -0,0 +1,7 @@
+import { TCard, TFrame } from '../../surfboard/index.js';
+declare function DashboardCustomVisualComponent({ card, frame, }: {
+    card: TCard;
+    frame: TFrame;
+}): import("react/jsx-runtime").JSX.Element | null;
+export declare const DashboardCustomVisual: typeof DashboardCustomVisualComponent;
+export {};

package/dist/types/components/visual/custom-visual/editor-custom-visual.d.ts

@@ -0,0 +1,6 @@
+import { TCard } from '../../surfboard/index.js';
+declare function EditorCustomVisualComponent({ card }: {
+    card: TCard;
+}): import("react/jsx-runtime").JSX.Element | null;
+export declare const EditorCustomVisual: import('react').MemoExoticComponent<typeof EditorCustomVisualComponent>;
+export {};

package/dist/types/components/visual/custom-visual/hooks/use-ensure-react-globals.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Hook to ensure React and ReactDOM are available on the window object
+ * for custom visual plugins to use.
+ *
+ * This MUST be called before any dynamic imports of custom visual plugins
+ * to prevent "React is not defined" errors.
+ *
+ * @returns isReactMounted - true when React globals are set up
+ */
+export declare function useEnsureReactGlobals(): boolean;

package/dist/types/components/visual/custom-visual/hooks/use-remote-chart-store.d.ts

@@ -0,0 +1,9 @@
+export type RemoteChartState = {
+    settings: any;
+};
+type ChartStoreHook = {
+    (selector: (state: RemoteChartState) => any): any;
+    getState: () => RemoteChartState;
+};
+export declare function useRemoteChartStore(url: string | null): ChartStoreHook | null;
+export {};

package/dist/types/components/visual/custom-visual/multi-input-empty-renderer.d.ts

@@ -0,0 +1,8 @@
+import { TCard } from '../../../lib/types/index.js';
+import { CustomVisualInputResult } from './custom-visual-types.js';
+export declare function MultiInputEmptyRenderer({ onLoadingStatus, onDataChange, card, effectiveCardType, }: {
+    onDataChange: (cardId: string, data: CustomVisualInputResult) => void;
+    onLoadingStatus?: (cardId: string, status: boolean) => void;
+    card: TCard;
+    effectiveCardType?: TCard['type'];
+}): import("react/jsx-runtime").JSX.Element;

package/dist/types/components/visual/custom-visual/use-custom-visual.d.ts

@@ -0,0 +1,16 @@
+import { default as React } from 'react';
+import { VisualComponent, Manifest } from './custom-visual-utils.js';
+export type FilterComponent = {
+    name: string;
+    componentName: string;
+    Component: React.LazyExoticComponent<React.ComponentType<any>>;
+};
+export declare const useCustomVisual: (url: string) => {
+    getCard: (componentName: string) => React.LazyExoticComponent<(props: React.ComponentProps<any>) => React.ReactNode> | null;
+    getFilter: (componentName: string) => React.LazyExoticComponent<React.ComponentType<any>> | null;
+    components: VisualComponent[];
+    filterComponents: FilterComponent[];
+    manifest: Manifest | null;
+    isLoading: boolean;
+    isError: boolean;
+};

package/dist/types/components/visual/data-table/column-def.d.ts

@@ -0,0 +1,54 @@
+import { SemaphorResultColumn } from '../../../shared/analytics-protocol/index.js';
+import { ColumnDef } from '@tanstack/react-table';
+import { ColumnSettingsMap, DataTableRow } from './types/data-table.js';
+import { QueryColumnKeyMap } from '../../../lib/types/explorer-types.js';
+import { ComparisonMetadataMap } from '../../../lib/types/query-types.js';
+import { CurrencyPresentationTarget } from '../../../lib/types/common-types.js';
+import { ResolvedValueFormatPreferences } from '../../../shared/value-format-preferences/index.js';
+import { ConditionalFormattingResult, ConditionalFormattingRenderContext } from '../../../lib/table-formatting/index.js';
+import { RegularTableTemporalPresentation } from '../../../lib/formatters/regular-table-temporal-presentation.js';
+import { RawTemporalPresentation } from '../../../lib/formatters/raw-temporal-presentation.js';
+interface CreateColumnsOptions {
+    data: DataTableRow[];
+    formattingFullRows?: DataTableRow[];
+    formattingRenderContext?: ConditionalFormattingRenderContext;
+    sorting: any;
+    columnSettings: ColumnSettingsMap;
+    selectColumnVisible?: boolean;
+    isVisualEditing: boolean;
+    onOpenColumnSettings: (columnId: string) => void;
+    contextTimezone?: string;
+    browserTimezone?: string;
+    card?: any;
+    comparisonMetadata?: ComparisonMetadataMap;
+    columnKeyMap?: QueryColumnKeyMap;
+    /** Authoritative result columns; the sole source of pivot identity. */
+    resultColumns?: readonly SemaphorResultColumn[];
+    suppressSortControls?: boolean;
+    suppressCellHoverCards?: boolean;
+    headerTextClassName?: string;
+    headerWrapText?: boolean;
+    appearanceWrapText?: boolean;
+    showColumnReorderControls?: boolean;
+    /**
+     * Whether this is a raw SQL card (bypasses timezone-aware query pipeline).
+     * For card-config cards (isSqlCard=false), the backend already formats dates,
+     * so we skip UI formatting and display the raw value.
+     */
+    isSqlCard?: boolean;
+    valueFormatPreferences?: ResolvedValueFormatPreferences | null;
+    resolveBoundCurrency?: (target: CurrencyPresentationTarget) => string | undefined;
+    temporalPresentation?: RegularTableTemporalPresentation;
+    rawTemporalPresentation?: RawTemporalPresentation;
+    /** Keep SQL temporal strings raw until the author explicitly selects Date. */
+    inferTemporalColumnType?: boolean;
+}
+export type DataTableColumnFormattingMeta = {
+    isNumeric?: boolean;
+    textAlign?: ColumnSettingsMap[string]['textAlign'];
+    getConditionalFormatting?: (row: Record<string, unknown>, rowIndex: number) => ConditionalFormattingResult;
+};
+export declare function createColumns({ data, formattingFullRows, formattingRenderContext, sorting, columnSettings, selectColumnVisible, onOpenColumnSettings, isVisualEditing, contextTimezone, browserTimezone, card, // Used for lazy initialization of column settings
+comparisonMetadata, columnKeyMap, resultColumns, suppressSortControls, suppressCellHoverCards, headerTextClassName, headerWrapText, appearanceWrapText, showColumnReorderControls, isSqlCard, // Whether this is a raw SQL card (for date formatting decisions)
+valueFormatPreferences, resolveBoundCurrency, temporalPresentation, rawTemporalPresentation, inferTemporalColumnType, }: CreateColumnsOptions): ColumnDef<DataTableRow>[];
+export {};

package/dist/types/components/visual/data-table/column-resize-handle.d.ts

@@ -0,0 +1,8 @@
+import { Header } from '@tanstack/react-table';
+interface ColumnResizeHandleProps<TData> {
+    header: Header<TData, unknown>;
+    isResizing?: boolean;
+    inset?: boolean;
+}
+export declare function ColumnResizeHandle<TData>({ header, isResizing, inset, }: ColumnResizeHandleProps<TData>): import("react/jsx-runtime").JSX.Element | null;
+export {};

package/dist/types/components/visual/data-table/copyable-cell.d.ts

@@ -0,0 +1,9 @@
+import { ReactNode } from 'react';
+interface CopyableCellProps {
+    children: ReactNode;
+    value: string;
+    className?: string;
+    style?: React.CSSProperties;
+}
+export declare function CopyableCell({ children, value, className, style, }: CopyableCellProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/types/components/visual/data-table/data-table-column-settings.d.ts

@@ -0,0 +1,2 @@
+import { DataTableColumnSettingsProps } from './types/data-table.js';
+export declare function DataTableColumnSettings({ column, settings, onSettingsChange, baseStyle, onBaseStyleChange, onApply, onReset, onResetAll, open, onOpenChange, availableColumns, tableType, isSqlCard, persistedSettings, usesDeclaredSqlRawTemporalPresentation, rawTemporalValueKind, }: DataTableColumnSettingsProps): import("react/jsx-runtime").JSX.Element;

package/dist/types/components/visual/data-table/data-table-conditional-formatting-settings.d.ts

@@ -0,0 +1,21 @@
+import { ConditionalFormatRule } from '../../../lib/table-formatting/index.js';
+import { TableConditionalFormattingColumnOption } from './table-conditional-formatting-authoring.js';
+import { ConditionalRuleKind } from './table-conditional-formatting-rule-model.js';
+type DataTableConditionalFormattingSettingsProps = {
+    columnId: string;
+    availableColumns?: Array<string | TableConditionalFormattingColumnOption>;
+    conditionalRules: ConditionalFormatRule[];
+    onConditionalRulesChange?: (rules: ConditionalFormatRule[]) => void;
+    startRulesWithNoTrigger?: boolean;
+    capabilities?: {
+        ruleKinds: readonly ConditionalRuleKind[];
+        automaticRanges: boolean;
+        separateApplyTargets?: boolean;
+        /** The host owns role/part/total scope; this editor owns measure conditions and styles. */
+        targetScope?: {
+            defaultRowRoles: string[];
+        };
+    };
+};
+export declare function DataTableConditionalFormattingSettings({ columnId, availableColumns, conditionalRules, onConditionalRulesChange, startRulesWithNoTrigger, capabilities, }: DataTableConditionalFormattingSettingsProps): import("react/jsx-runtime").JSX.Element | null;
+export {};

package/dist/types/components/visual/data-table/data-table-pagination.d.ts

@@ -0,0 +1,2 @@
+import { DataTablePaginationProps } from './types/data-table.js';
+export declare function DataTablePagination({ pageCount, pageIndex, pageSize, rowCount, selectedRowCount, setPageIndex, setPageSize, canPreviousPage, canNextPage, previousPage, nextPage, onClearSelection, onPageSizePreferenceChange, paginationMode, onPaginationModeChange, showPaginationControls, showExport, card, frameId, exportData, appearance, }: DataTablePaginationProps): import("react/jsx-runtime").JSX.Element;

package/dist/types/components/visual/data-table/data-table-toolbar.d.ts

@@ -0,0 +1,2 @@
+import { DataTableToolbarProps } from './types/data-table.js';
+export declare function DataTableToolbar({ globalFilter, onGlobalFilterChange, totalRows, columns, selectColumnVisible, onToggleSelectColumn, onColumnVisibilityChange, card, data, exportFileName, }: DataTableToolbarProps): import("react/jsx-runtime").JSX.Element | null;