react-semaphor 0.1.504 → 0.1.505

package/dist/types/components/visual/pivot-table/pivot-table.d.ts

@@ -0,0 +1,100 @@
+import { TCard } from '../../dashboard/index.js';
+import { AggregateFunction, GroupByField } from '../../../lib/types/explorer-types.js';
+import { PivotColumnSchema, ColumnSubtotalMeta, PivotTableResponse, ColumnMetadata } from './types.js';
+import { GroupedTemporalPresentation } from '../../../lib/formatters/grouped-temporal-presentation.js';
+import { ResolvedValueFormatPreferences } from '../../../shared/value-format-preferences/index.js';
+export interface PivotTableConfigParams {
+    card: TCard;
+    data: PivotTableResponse;
+    temporalPresentation?: GroupedTemporalPresentation;
+    /** Live locale/currency preferences applied to authored row number formats. */
+    valueFormatPreferences?: ResolvedValueFormatPreferences | null;
+}
+export interface PivotTableData {
+    rowHeaders: string[];
+    columnHeaders: string[];
+    cells: {
+        [rowKey: string]: {
+            [colKey: string]: {
+                value: number | string | null;
+                formattedValue?: string;
+                metricId: string;
+            };
+        };
+    };
+    columnGroups?: ColumnGroup[];
+    rowGroups?: RowGroup[];
+    columnDisplayNames?: {
+        [columnKey: string]: string;
+    };
+    groupByColumns?: GroupByField[];
+    columnSubtotalMeta?: ColumnSubtotalMeta[];
+    columnMetadata?: Record<string, ColumnMetadata>;
+    resultColumns?: PivotTableResponse['columns'];
+    columnKeyMap?: PivotTableResponse['columnKeyMap'];
+    temporalPresentation?: GroupedTemporalPresentation;
+    grandTotalRows?: Array<{
+        aggregateDisplayLabel: string;
+        aggregateFunction?: AggregateFunction;
+        data: {
+            [colKey: string]: {
+                value: number | string | null;
+                formattedValue?: string;
+                metricId: string;
+            };
+        };
+    }>;
+    rowData?: Array<{
+        rowKey: string;
+        fieldValues: string[];
+        canonicalFieldValues?: Array<string | null>;
+        isSubtotal?: boolean;
+        subtotalLevel?: string;
+        aggregateDisplayLabel?: string;
+        aggregateFunction?: string;
+        subtotalContext?: any;
+    }>;
+}
+export interface ColumnGroup {
+    name: string;
+    level: number;
+    colspan: number;
+    children?: ColumnGroup[];
+    columnKey?: string;
+    fieldId?: string;
+    canonicalValue?: string | null;
+}
+export interface RowGroup {
+    name: string;
+    level: number;
+    children?: RowGroup[];
+    rowKey?: string;
+}
+export interface PivotTableOptions {
+    showRowTotals?: boolean;
+    showColumnTotals?: boolean;
+    showGrandTotal?: boolean;
+    numberFormat?: {
+        decimalPlaces?: number;
+        prefix?: string;
+        suffix?: string;
+        locale?: string;
+    };
+}
+/** Physical column id used for pivot row-level header columns. */
+export declare function pivotRowLevelColumnId(levelIndex: number): string;
+/**
+ * Transform pivot table data from backend response
+ */
+export declare function transformPivotTableData(response: PivotTableResponse, options?: PivotTableOptions, card?: TCard, temporalPresentation?: GroupedTemporalPresentation, valueFormatPreferences?: ResolvedValueFormatPreferences | null): PivotTableData;
+export interface PivotTableConfig {
+    type: 'pivotTable';
+    data: PivotTableData;
+    config: TCard['config'];
+    options: PivotTableOptions;
+    pivotSchema?: PivotColumnSchema[];
+}
+/**
+ * Main function to get pivot table configuration
+ */
+export declare function getPivotTableConfig({ data, card, temporalPresentation, valueFormatPreferences, }: PivotTableConfigParams): PivotTableConfig;

package/dist/types/components/visual/pivot-table/types.d.ts

@@ -0,0 +1,80 @@
+import { AggregateFunction, GroupByField, QueryColumnKeyMap } from '../../../lib/types/explorer-types.js';
+import { ComparisonMetadataMap } from '../../../lib/types/query-types.js';
+import { SemaphorResultColumn } from '../../../shared/analytics-protocol/index.js';
+import { CanonicalPivotResultContract, CanonicalPivotResultState } from '../../../shared/format-utils/index.js';
+import { TemporalResultOwner } from '../../../shared/dashboard-authoring/index.js';
+export type { AggregateFunction } from '../../../lib/types/explorer-types.js';
+export declare enum PivotMarkerEnum {
+    SUBTOTAL = "__SUBTOTAL__",
+    TOTAL = "__TOTAL__"
+}
+export interface ColumnAggregate {
+    function: AggregateFunction;
+    pivotLevel: string | 'ALL';
+}
+export interface RowAggregate {
+    function: AggregateFunction;
+    groupLevel?: string;
+}
+export interface PivotCardConfig {
+    columnAggregates?: ColumnAggregate[];
+    rowAggregates?: RowAggregate[];
+}
+export interface PivotRowMetadata {
+    isSubtotal?: boolean;
+    isGrandTotal?: boolean;
+    subtotalLevel?: string | 'grandTotal';
+    aggregate?: AggregateFunction;
+    subtotalContext?: {
+        fieldAlias: string;
+        value: string;
+        groupByValues: Record<string, any>;
+    };
+}
+export interface ColumnSubtotalMeta {
+    columnName: string;
+    isSubtotal: boolean;
+    subtotalLevel: string;
+    aggregate: AggregateFunction;
+    pivotFieldId?: string | 'ALL';
+    pivotFieldIds?: string[];
+    pivotPath?: (string | null)[];
+    subtotalScope?: 'pivot-value' | 'grand-total';
+}
+export interface PivotColumnSchema {
+    alias: string;
+    metricAlias?: string;
+    metricId: string;
+    metricName: string;
+    metricLabel: string;
+    pivotValues: (string | null)[];
+    pivotFieldIds?: string[];
+    pivotFields: string[];
+    displayLabel?: string;
+    isPivotColumn?: boolean;
+    isMetricColumn?: boolean;
+}
+export interface ColumnMetadata {
+    metricAlias: string;
+    metricId: string;
+    pivotValues: (string | null)[];
+    pivotFieldIds?: string[];
+    isSubtotal: boolean;
+    aggregateFunction?: string;
+    subtotalScope?: 'base' | 'pivot-value' | 'grand-total';
+}
+export interface PivotTableResponse {
+    records: (Record<string, any> & PivotRowMetadata)[];
+    resultOwner?: TemporalResultOwner;
+    pivotResultState?: CanonicalPivotResultState;
+    pivotResultContract?: CanonicalPivotResultContract;
+    pivotSchema: PivotColumnSchema[];
+    subtotalColumns: string[];
+    columnSubtotalMeta?: ColumnSubtotalMeta[];
+    groupByColumns?: GroupByField[];
+    columnMetadata?: Record<string, ColumnMetadata>;
+    comparisonMetadata?: ComparisonMetadataMap;
+    columns?: SemaphorResultColumn[];
+    columnKeyMap?: QueryColumnKeyMap;
+}
+export type PivotTableData = (Record<string, any> & PivotRowMetadata)[];

package/dist/types/components/visual/pivot-table/utils/cell-value-formatter.d.ts

@@ -0,0 +1,14 @@
+import { default as React } from 'react';
+import { ColumnSettings } from '../../data-table/types/data-table.js';
+/**
+ * Format and render cell values for pivot table
+ */
+export declare function renderCellValue(value: any, settings?: ColumnSettings, contextTimezone?: string, browserTimezone?: string, isSqlCard?: boolean): React.ReactNode;
+/**
+ * Check if a column key represents a subtotal column
+ */
+export declare function isSubtotalColumn(columnKey: string): boolean;
+/**
+ * Check if a column key represents a grand total column
+ */
+export declare function isGrandTotalColumn(columnKey: string, columnSubtotalMeta?: any[]): boolean;

package/dist/types/components/visual/pivot-table/utils/pivot-field-identity.d.ts

@@ -0,0 +1,8 @@
+export type PivotGroupFieldIdentity = {
+    id?: string;
+    alias?: string;
+    name?: string;
+};
+export declare function matchesPivotGroupFieldIdentity(field: PivotGroupFieldIdentity, identity: string | undefined): boolean;
+export declare function resolvePivotGroupFieldIndex(fields: readonly PivotGroupFieldIdentity[] | undefined, identity: string | undefined): number;
+export declare function resolvePivotGroupField<T extends PivotGroupFieldIdentity>(fields: readonly T[] | undefined, identity: string | undefined): T | undefined;

package/dist/types/components/visual/pivot-table/utils/pivot-formatting-utils.d.ts

@@ -0,0 +1,24 @@
+import { ColumnSettings } from '../../data-table/types/data-table.js';
+/**
+ * Format a pivot table cell value based on column settings
+ */
+export declare function formatPivotCellValue(value: any, settings?: ColumnSettings, contextTimezone?: string, browserTimezone?: string, isSqlCard?: boolean): string | number;
+/**
+ * Get default column settings for a pivot column
+ */
+export declare function getDefaultPivotColumnSettings(): ColumnSettings;
+/**
+ * Determine if a value should use number formatting based on its type
+ */
+export declare function shouldUseNumberFormatting(value: any): boolean;
+/**
+ * Check if column settings have conditional formatting
+ */
+export declare function hasConditionalFormatting(settings?: ColumnSettings): boolean;
+/**
+ * Get conditional formatting style for a value
+ */
+export declare function getConditionalFormattingStyle(value: any, settings?: ColumnSettings): {
+    backgroundColor?: string;
+    color?: string;
+} | null;

package/dist/types/components/visual/pivot-table/utils/pivot-metric-formatting.d.ts

@@ -0,0 +1,18 @@
+import { CurrencyPresentationTarget, TCard } from '../../../../lib/types/common-types.js';
+import { ResolvedValueFormatPreferences } from '../../../../shared/value-format-preferences/index.js';
+import { ColumnSettings, ColumnSettingsMap } from '../../data-table/types/data-table.js';
+import { NumericCanonicalFormat } from '../../../../shared/format-utils/types/index.js';
+type PivotColumnMetadata = Record<string, {
+    metricId?: string;
+    metricAlias?: string;
+}>;
+export declare function resolvePivotRowTotalSettings(params: {
+    card: TCard;
+    columnHeaders: string[];
+    columnMetadata?: PivotColumnMetadata;
+    columnSettings?: ColumnSettingsMap;
+    valueFormatPreferences: ResolvedValueFormatPreferences | null;
+    resolveBoundCurrency: (target: CurrencyPresentationTarget) => string | undefined;
+}): ColumnSettings | undefined;
+export declare function resolvePivotRowTotalCanonicalFormat(params: Parameters<typeof resolvePivotRowTotalSettings>[0]): NumericCanonicalFormat | undefined;
+export {};

package/dist/types/components/visual/pivot-table/utils/pivot-physical-schema.d.ts

@@ -0,0 +1,14 @@
+import { PivotByField } from '../../../../lib/types/explorer-types.js';
+import { SemaphorResultColumn } from '../../../../shared/analytics-protocol/index.js';
+import { PivotColumnSchema } from '../types.js';
+/**
+ * Adapts already-wide physical results to the same hierarchy schema used by
+ * the tall/reshape path. Authoritative result-column member identity owns the
+ * tuple; legacy schema flags are used only when the producer already supplied
+ * a complete tall-path hierarchy.
+ */
+export declare function normalizePivotPhysicalSchema(input: {
+    pivotSchema: readonly PivotColumnSchema[];
+    resultColumns: readonly SemaphorResultColumn[];
+    pivotByColumns: readonly PivotByField[];
+}): PivotColumnSchema[];

package/dist/types/components/visual/pivot-table/utils/pivot-table-aggregation-helpers.d.ts

@@ -0,0 +1,21 @@
+import { TCard } from '../../../../lib/types/common-types.js';
+import { AggregateFunction } from '../../../../lib/types/explorer-types.js';
+/**
+ * Helper function to handle aggregation changes
+ * Returns an updated config object with the new aggregation settings
+ */
+export declare function handleAggregationChange(aggregation: {
+    function: string;
+    rowLevel?: string;
+    columnLevel?: string;
+}, currentConfig: TCard['config']): TCard['config'];
+/**
+ * Helper function to handle aggregation label changes
+ * Returns an updated config object with the new label for a specific aggregation
+ */
+export declare function handleAggregationLabelChange(update: {
+    type: 'row' | 'column';
+    level: string | 'ALL';
+    function: AggregateFunction;
+    label: string;
+}, currentConfig: TCard['config']): TCard['config'];

package/dist/types/components/visual/pivot-table/utils/pivot-table-data-processor.d.ts

@@ -0,0 +1,35 @@
+import { PivotTableData } from '../pivot-table.js';
+export interface TableRow {
+    id: string;
+    rowKey: string;
+    fieldValues: string[];
+    canonicalFieldValues?: Array<string | null>;
+    isSubtotal?: boolean;
+    isGrandTotal?: boolean;
+    subtotalLevel?: string;
+    aggregateFunction?: string;
+    cells: Record<string, any>;
+    _depth?: number;
+    _parentId?: string;
+}
+export interface ProcessedTableData {
+    tableData: TableRow[];
+    grandTotalRows: TableRow[];
+}
+export declare function getPivotRowCanonicalValue(row: Pick<TableRow, 'canonicalFieldValues' | 'fieldValues'>, index: number): string | null;
+export declare function shouldPresentPivotGroupValue(row: TableRow, previousRow: TableRow | undefined, levelIndex: number): boolean;
+/**
+ * Process pivot table data into rows for TanStack Table
+ */
+export declare function processPivotTableData(data: PivotTableData): ProcessedTableData;
+/**
+ * Identify subtotal columns based on metadata
+ */
+export declare function identifySubtotalColumns(columnSubtotalMeta?: any[]): {
+    subtotalColumnKeys: Set<string>;
+    grandTotalColumnKeys: Set<string>;
+};
+/**
+ * Calculate row total for a given row
+ */
+export declare function calculateRowTotal(row: TableRow, columnHeaders: string[]): number;

package/dist/types/components/visual/pivot-table/utils/pivot-table-export-utils.d.ts

@@ -0,0 +1,23 @@
+import { PivotTableData } from '../pivot-table.js';
+import { TCard } from '../../../../lib/types/common-types.js';
+import { CardNumericPresentationContext } from '../../../../lib/formatters/numeric-presentation.js';
+type PivotTableCsvOptions = {
+    includeHeaders?: boolean;
+    includeSubtotals?: boolean;
+    includeGrandTotal?: boolean;
+    delimiter?: string;
+    showRowTotals?: boolean;
+    numericPresentation?: CardNumericPresentationContext;
+};
+/**
+ * Flattens the authoritative live pivot hierarchy for async CSV. Group keys
+ * require exact result bindings; pivot leaves already come from the same
+ * PivotTableData hierarchy used by the live table, local CSV, and PDF.
+ */
+export declare function resolvePivotTableFlatExportColumnOrder(data: PivotTableData): string[] | null;
+export declare function generatePivotTableFormattedCSV(data: PivotTableData, card: TCard, options?: PivotTableCsvOptions): string;
+/**
+ * Export pivot table as CSV with formatted headers and values
+ */
+export declare function exportPivotTableAsFormattedCSV(data: PivotTableData, card: TCard, fileName: string, options?: PivotTableCsvOptions): void;
+export {};

package/dist/types/components/visual/pivot-table/utils/pivot-table-response.d.ts

@@ -0,0 +1,50 @@
+import { TCard } from '../../../../lib/types/common-types.js';
+import { CardConfig } from '../../../../lib/types/explorer-types.js';
+import { PivotResultLifecycleError, LoadedEmptyPivotResult, LoadedValidPivotResult } from '../../../../shared/format-utils/index.js';
+import { PivotTableResponse } from '../types.js';
+type PivotTableQueryResult = Partial<Omit<PivotTableResponse, 'records' | 'pivotSchema' | 'subtotalColumns'>> & {
+    error?: unknown;
+    records?: PivotTableResponse['records'];
+    pivotSchema?: PivotTableResponse['pivotSchema'];
+    subtotalColumns?: PivotTableResponse['subtotalColumns'];
+};
+export type PivotTableResultState = {
+    kind: 'not_loaded';
+} | {
+    kind: 'loaded_empty';
+    response: PivotTableResponse;
+    canonical: LoadedEmptyPivotResult;
+} | {
+    kind: 'loaded_valid';
+    response: PivotTableResponse;
+    canonical: LoadedValidPivotResult;
+} | {
+    kind: 'legacy_raw';
+    response: PivotTableResponse;
+} | {
+    kind: 'invalid';
+    error: PivotResultLifecycleError;
+};
+/**
+ * Parses query lifecycle and canonical transport at the browser boundary.
+ * Config-owned pivot consumers receive one discriminated state; raw SQL/Python
+ * pivots retain their explicit legacy result contract.
+ */
+export declare function resolvePivotTableResultState(input: {
+    data: PivotTableQueryResult | null | undefined;
+    card: TCard;
+    cardConfig?: CardConfig;
+}): PivotTableResultState;
+/**
+ * During a query-key transition, React Query may briefly retain the response
+ * produced by the previous card configuration. A strict lifecycle failure is
+ * still authoritative once the replacement query settles, but it must not
+ * replace the editor's loading state while that request is in flight.
+ */
+export declare function resolvePendingPivotTableResultState(input: {
+    data: PivotTableQueryResult | null | undefined;
+    card: TCard;
+    cardConfig?: CardConfig;
+    isPending: boolean;
+}): PivotTableResultState;
+export {};

package/dist/types/components/visual/pivot-table/utils/pivot-table-sorter.d.ts

@@ -0,0 +1,7 @@
+import { SortingState } from '@tanstack/react-table';
+import { TableRow } from './pivot-table-data-processor.js';
+import { PivotTableData } from '../pivot-table.js';
+/**
+ * Sort table data based on sorting state and column configuration
+ */
+export declare function sortPivotTableData(tableData: TableRow[], sorting: SortingState, data: PivotTableData): TableRow[];

package/dist/types/components/visual/pivot-table/utils/row-span-calculator.d.ts

@@ -0,0 +1,14 @@
+import { TableRow } from './pivot-table-data-processor.js';
+export interface RowSpanInfo {
+    shouldRender: boolean;
+    rowSpan: number;
+    colSpan?: number;
+}
+/**
+ * Calculate row span for a cell at given row and level index
+ */
+export declare function calculateRowSpan(rows: TableRow[], rowIndex: number, levelIndex: number): RowSpanInfo;
+/**
+ * Calculate colspan for subtotal rows based on the subtotal level
+ */
+export declare function calculateSubtotalColspan(subtotalLevel: string | undefined, groupByColumns: any[] | undefined, numRowLevels: number): number;

package/dist/types/components/visual/settings/axis-mapping.d.ts

@@ -0,0 +1,9 @@
+import { default as React } from 'react';
+export default function AxisMapping(): import("react/jsx-runtime").JSX.Element | null;
+export declare function MetricFragment({ col, idx, className, iconClassName, children, }: {
+    col: string;
+    idx: number;
+    className?: string;
+    iconClassName?: string;
+    children?: React.ReactNode;
+}): import("react/jsx-runtime").JSX.Element;

package/dist/types/components/visual/settings/chart-documentation.d.ts

@@ -0,0 +1,28 @@
+import { TChartType } from '../../../lib/charts/types.js';
+interface ChartDocumentationContentProps {
+    chartType: TChartType;
+    showDocsLink?: boolean;
+}
+/**
+ * Renders the documentation content for a chart type
+ * Used inside hover cards and standalone documentation sections
+ */
+export declare function ChartDocumentationContent({ chartType, showDocsLink, }: ChartDocumentationContentProps): import("react/jsx-runtime").JSX.Element | null;
+interface ChartDocumentationBadgeProps {
+    chartType: TChartType;
+}
+/**
+ * SQL badge that shows documentation on hover
+ * Used in chart configuration headers
+ */
+export declare function ChartDocumentationBadge({ chartType, }: ChartDocumentationBadgeProps): import("react/jsx-runtime").JSX.Element | null;
+interface ChartDocumentationHeaderProps {
+    chartType: TChartType;
+    suffix?: string;
+}
+/**
+ * Configuration header with SQL badge
+ * Used at the top of chart configuration panels
+ */
+export declare function ChartDocumentationHeader({ chartType, suffix, }: ChartDocumentationHeaderProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/types/components/visual/settings/chart-orientation.d.ts

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

package/dist/types/components/visual/settings/color-format.d.ts

@@ -0,0 +1,7 @@
+import { ColorRange } from '../../index.js';
+type ColorFormatProps = {
+    colorRanges: ColorRange[];
+    setColorRanges: (ranges: ColorRange[]) => void;
+};
+export default function ColorFormat({ colorRanges, setColorRanges, }: ColorFormatProps): import("react/jsx-runtime").JSX.Element;
+export {};

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

@@ -0,0 +1,7 @@
+interface ControlsSettingsProps {
+    className?: string;
+    triggerVariant?: 'icon' | 'menu';
+    label?: string;
+}
+export declare function ControlsSettings({ className, triggerVariant, label, }: ControlsSettingsProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/types/components/visual/settings/dataset-label-popover.d.ts

@@ -0,0 +1,3 @@
+export default function DatasetLabelPopover({ idx }: {
+    idx: number;
+}): import("react/jsx-runtime").JSX.Element;

package/dist/types/components/visual/settings/display-labels.d.ts

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

package/dist/types/components/visual/settings/filter-on-click-columns.d.ts

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

package/dist/types/components/visual/settings/frame-filters.d.ts

@@ -0,0 +1,6 @@
+import { Field } from '../../../lib/types/explorer-types.js';
+export default function FrameFilters(): import("react/jsx-runtime").JSX.Element;
+export declare function FilterColumnsCombobox({ columns, onSelect, }: {
+    columns: Field[];
+    onSelect: (value: Field) => void;
+}): import("react/jsx-runtime").JSX.Element;

package/dist/types/components/visual/settings/inline-filters-settings.d.ts

@@ -0,0 +1,11 @@
+interface InlineFiltersSettingsProps {
+    className?: string;
+    triggerVariant?: 'icon' | 'menu';
+    label?: string;
+}
+/**
+ * Popover component for configuring inline filters on a card.
+ * Displays as an icon button in the toolbar, with added filters shown as badges.
+ */
+export declare function InlineFiltersSettings({ className, triggerVariant, label, }: InlineFiltersSettingsProps): import("react/jsx-runtime").JSX.Element | null;
+export {};

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

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

package/dist/types/components/visual/settings/map-chart-settings.d.ts

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

package/dist/types/components/visual/settings/scale-options.d.ts

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

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

@@ -0,0 +1,16 @@
+import { TableColumnVisibility } from '../../../lib/table-formatting/table-column-visibility.js';
+type TableColumnVisibilityOption = {
+    value: string;
+    label: string;
+};
+type TableColumnVisibilitySettingsProps = {
+    columns: TableColumnVisibilityOption[];
+    columnVisibility?: TableColumnVisibility;
+    onColumnVisibilityChange: (columnId: string, isVisible: boolean) => void;
+    onShowAllColumns: () => void;
+    emptyMessage?: string;
+    helperText?: string;
+    className?: string;
+};
+export declare function TableColumnVisibilitySettings({ columns, columnVisibility, onColumnVisibilityChange, onShowAllColumns, emptyMessage, helperText, className, }: TableColumnVisibilitySettingsProps): import("react/jsx-runtime").JSX.Element;
+export {};

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

@@ -0,0 +1,27 @@
+import { TableDensity, TableStylePreferences, TableTotalsStylePreferences } from '../data-table/types/data-table.js';
+import { ResolvedTablePresentationStyle } from '../../../lib/table-formatting/table-presentation-style.js';
+import { ReactNode } from 'react';
+type TablePresentationSettingsProps = {
+    style: ResolvedTablePresentationStyle;
+    onDensityChange: (density: TableDensity) => void;
+    onStyleChange: (update: Partial<TableStylePreferences>) => void;
+    totals?: {
+        enabled?: boolean;
+        helperText?: string;
+        onEnabledChange?: (enabled: boolean) => void;
+        onStyleChange?: (update: Partial<TableTotalsStylePreferences>) => void;
+    };
+    /** Hide presentation knobs that this renderer can't honor (e.g. pivot
+     * tables only support density). When false the panel collapses to the
+     * Layout section. Defaults to true. */
+    showFullStyle?: boolean;
+    showBorderStyle?: boolean;
+    /** Optional extra section rendered at the bottom (e.g. Comparison) so
+     * the surrounding "Appearance" tab can hand custom content in without
+     * forking the layout. */
+    extraSection?: ReactNode;
+    onReset?: () => void;
+    className?: string;
+};
+export declare function TablePresentationSettings({ style, onDensityChange, onStyleChange, totals, showFullStyle, showBorderStyle, extraSection, onReset, className, }: TablePresentationSettingsProps): import("react/jsx-runtime").JSX.Element;
+export {};

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

@@ -0,0 +1,8 @@
+import { TChartType } from '../../../lib/charts/types.js';
+import { TableVisualSettingsFocus } from '../data-table/table-conditional-formatting-authoring.js';
+export default function TableVisualSettings({ cardType, queryResultColumns, focusSection, focusRequestId, }: {
+    cardType?: TChartType;
+    queryResultColumns?: string[];
+    focusSection?: TableVisualSettingsFocus | null;
+    focusRequestId?: number;
+}): import("react/jsx-runtime").JSX.Element;

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

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

package/dist/types/components/visual/settings/text-type-radio.d.ts

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

package/dist/types/components/visual/shared/hooks/use-column-resizing.d.ts

@@ -0,0 +1,15 @@
+import { ColumnSizingState } from '@tanstack/react-table';
+import { TCard } from '../../../../lib/types/common-types.js';
+interface UseColumnResizingProps {
+    card: TCard;
+    enabled?: boolean;
+    columnSizing?: ColumnSizingState;
+    onColumnSizingCommit?: (sizing: ColumnSizingState) => void;
+    onResizeStateChange?: (isResizing: boolean) => void;
+}
+interface UseColumnResizingReturn {
+    columnSizing: ColumnSizingState;
+    onColumnSizingChange: (updater: ColumnSizingState | ((old: ColumnSizingState) => ColumnSizingState)) => void;
+}
+export declare function useColumnResizing({ card, enabled, columnSizing: controlledColumnSizing, onColumnSizingCommit, onResizeStateChange, }: UseColumnResizingProps): UseColumnResizingReturn;
+export {};

package/dist/types/components/visual/shared/utils/column-type-detector.d.ts

@@ -0,0 +1,25 @@
+import { ColumnSettings } from '../../data-table/types/data-table.js';
+import { CardConfig } from '../../../../lib/types/explorer-types.js';
+/**
+ * Build a column metadata lookup map from card config
+ * Returns: { columnId: { dataType: string, isMetric: boolean } }
+ * Note: Keys match column IDs used in table (alias ?? name ?? label)
+ */
+export declare function buildColumnMetadataMap(cardConfig?: CardConfig): Record<string, {
+    dataType: string;
+    isMetric: boolean;
+}>;
+/**
+ * Detect column type based on data values
+ */
+export declare function detectColumnTypeFromData(columnId: string, data: any[], columnMetadata?: any): 'number' | 'date' | 'text';
+/**
+ * Get smart default column settings based on detected type
+ * @param columnId - The column identifier (label)
+ * @param data - Array of data rows
+ * @param columnMetadata - Legacy column metadata (for backward compatibility with pivot tables)
+ * @param cardConfig - Optional card config with metadata about columns
+ */
+export declare function getSmartColumnDefaults(columnId: string, data: any[], columnMetadata?: any, cardConfig?: CardConfig, options?: {
+    inferTemporalType?: boolean;
+}): ColumnSettings;