@pythia-software/query-table-ui 0.5.0 → 0.7.0

package/dist/index.d.ts

@@ -1,8 +1,9 @@
 import * as react from 'react';
-import { ReactNode, SetStateAction } from 'react';
-import { FieldDef, QueryState, RowId, FieldStats, WhereClause } from '@pythia-software/query-table-core';
+import { ReactNode, SetStateAction, ButtonHTMLAttributes, CSSProperties, PointerEvent, Ref, MutableRefObject } from 'react';
+import { FieldDef, QueryState, JsonCellDisplay, RowId, AggregationClause, AggregationBucket, AggregationResultEntry, MetricValue, SavedQuery, FieldStats, WhereClause, MetricValueFormat, FieldSchema, PropertyViewState, RelationshipAdapter, ObjectReference, PropertyFormat, PropertyViewStorage, ItemPropertyMode, FormulaFunction, GroupedRow } from '@pythia-software/query-table-core';
 import * as react_jsx_runtime from 'react/jsx-runtime';
-import { SelectionApi, ColumnDragApi, QueryTableApi, AggregationsApi, SavedQueriesApi } from '@pythia-software/query-table-react';
+import { ItemDetailsApi, SelectionApi, ColumnDragApi, QueryTableApi, QueryFilterApi, AggregationsApi, SavedQueriesApi, RequestActivityApi, PropertyViewApi, GroupingApi } from '@pythia-software/query-table-react';
+import { Placement } from '@floating-ui/react';
 
 interface CellContext<Row = any, V = unknown> {
     value: V;
@@ -10,6 +11,8 @@ interface CellContext<Row = any, V = unknown> {
     field: FieldDef<Row, V>;
     /** Current query — lets renderers reflect active state (e.g. highlight matches). */
     query: QueryState;
+    /** Detail surfaces can embed richer content directly instead of opening another dialog. */
+    presentation?: "cell" | "property";
 }
 type CellRenderer<Row = any, V = unknown> = (ctx: CellContext<Row, V>) => ReactNode;
 type RenderRegistry<Row = any> = Record<string, CellRenderer<Row>>;
@@ -21,10 +24,21 @@ declare function safeLinkHref(value: unknown): string | null;
  *  referenced from FieldDef.render. Consumers spread these and add their own. */
 declare const defaultRenderers: RenderRegistry;
 /** Resolve a FieldDef's renderer: inline fn wins, else registry lookup, else
- *  the `text` fallback. */
+ *  declarative display, else the `text` fallback. */
 declare function resolveRenderer<Row>(field: FieldDef<Row>, registry: RenderRegistry<Row>): CellRenderer<Row>;
 
 declare const artwork: {
+    externalLink: react_jsx_runtime.JSX.Element;
+    itemHover: react_jsx_runtime.JSX.Element;
+    itemModal: react_jsx_runtime.JSX.Element;
+    itemExpand: react_jsx_runtime.JSX.Element;
+    panelList: react_jsx_runtime.JSX.Element;
+    panelDefinition: react_jsx_runtime.JSX.Element;
+    panelReference: react_jsx_runtime.JSX.Element;
+    panelPreview: react_jsx_runtime.JSX.Element;
+    dashboard: react_jsx_runtime.JSX.Element;
+    resize: react_jsx_runtime.JSX.Element;
+    alert: react_jsx_runtime.JSX.Element;
     add: react_jsx_runtime.JSX.Element;
     close: react_jsx_runtime.JSX.Element;
     check: react_jsx_runtime.JSX.Element;
@@ -34,6 +48,9 @@ declare const artwork: {
     arrowDown: react_jsx_runtime.JSX.Element;
     arrowLeft: react_jsx_runtime.JSX.Element;
     arrowRight: react_jsx_runtime.JSX.Element;
+    skipForward: react_jsx_runtime.JSX.Element;
+    pointer: react_jsx_runtime.JSX.Element;
+    eye: react_jsx_runtime.JSX.Element;
     grip: react_jsx_runtime.JSX.Element;
     pencil: react_jsx_runtime.JSX.Element;
     star: react_jsx_runtime.JSX.Element;
@@ -42,6 +59,7 @@ declare const artwork: {
     copy: react_jsx_runtime.JSX.Element;
     share: react_jsx_runtime.JSX.Element;
     refresh: react_jsx_runtime.JSX.Element;
+    stopwatch: react_jsx_runtime.JSX.Element;
     clock: react_jsx_runtime.JSX.Element;
     reset: react_jsx_runtime.JSX.Element;
     bookmark: react_jsx_runtime.JSX.Element;
@@ -55,6 +73,42 @@ interface IconProps {
 }
 declare function Icon({ name, size, className, filled }: IconProps): react_jsx_runtime.JSX.Element;
 
+interface JsonCellProps {
+    value: unknown;
+    label?: string;
+    display?: JsonCellDisplay | undefined;
+}
+/** Compact cell plus a shared searchable inspector. Mountable outside DataTable. */
+declare function JsonCell({ value, label, display }: JsonCellProps): ReactNode;
+/** The same searchable JSON value embedded in item details, pages or host cards. */
+declare function JsonValueView({ value, label, display, compact }: JsonCellProps & {
+    compact?: boolean;
+}): ReactNode;
+
+interface JsonEntry {
+    /** Unambiguous JSONPath; bracket notation preserves dots/quotes in keys. */
+    path: string;
+    parent: string | null;
+    key: string;
+    depth: number;
+    type: "object" | "array" | "string" | "number" | "boolean" | "null";
+    text: string;
+    children: number;
+    value: unknown;
+}
+interface JsonInspection {
+    value: unknown;
+    raw: string;
+    formatted: string;
+    preview: string;
+    entries: JsonEntry[];
+    error?: string;
+    limited?: boolean;
+}
+declare function inspectJsonValue(input: unknown, display?: JsonCellDisplay, includeEntries?: boolean): JsonInspection;
+/** Search keys, full paths and typed values; case insensitive, literal matching. */
+declare function searchJsonEntries(entries: JsonEntry[], search: string): JsonEntry[];
+
 interface TableClassNames {
     wrap?: string;
     table?: string;
@@ -88,11 +142,16 @@ interface QueryBuilderClassNames {
 }
 interface MenuClassNames {
     popover?: string;
+    submenu?: string;
     item?: string;
     separator?: string;
 }
 
 interface DataTableProps<Row> {
+    /** Built-in details from api.itemDetails; no render or route callbacks needed. */
+    itemDetails?: ItemDetailsApi<Row>;
+    /** Optional detail renderer overrides, layered over the table registry. */
+    itemRenderers?: RenderRegistry<Row>;
     /** Ordered visible fields (widths already resolved), from `api.visibleFields`. */
     fields: FieldDef<Row>[];
     rows: Row[];
@@ -111,6 +170,8 @@ interface DataTableProps<Row> {
     /** Always-visible trailing column (row actions, links). */
     trailing?: (row: Row) => ReactNode;
     trailingLabel?: string;
+    /** Optional compact role badge before the column label. */
+    headerAdornment?: ((field: FieldDef<Row>) => ReactNode) | undefined;
     /** Total matching rows before pagination, when known. */
     total?: number | null;
     loading?: boolean;
@@ -126,7 +187,64 @@ interface DataTableProps<Row> {
 }
 declare function DataTable<Row>(props: DataTableProps<Row>): ReactNode;
 
+/** Core owns computation and serialized presentation types. These aliases keep rendering imports focused. */
+
+type MetricBucket = AggregationBucket;
+type RenderingClause = AggregationClause;
+/** Optional exact remainder for transports that truncate additive groups. */
+type MetricRenderResult = Pick<AggregationResultEntry, "buckets" | "error" | "groupCount" | "coverage" | "scope" | "processedRows"> & {
+    other?: AggregationBucket;
+};
+
+type MetricToken = "accent" | "text" | "muted" | "grid" | "surface" | "other" | "null" | "error";
+interface MetricTheme {
+    layers?: ReadonlyArray<{
+        id: string;
+        colors: ReadonlyArray<string>;
+    }>;
+    dimensions?: Readonly<Record<string, {
+        layer: string;
+        domain?: ReadonlyArray<MetricValue>;
+        overrides?: ReadonlyArray<{
+            value: MetricValue;
+            color: string;
+        }>;
+        identity?: string;
+    }>>;
+    tokens?: Partial<Record<MetricToken, string>>;
+}
+interface MetricClassNames {
+    root?: string;
+    metric?: string;
+    title?: string;
+    plot?: string;
+    axis?: string;
+    grid?: string;
+    legend?: string;
+    mark?: string;
+}
+declare function createMetricColorResolver(theme?: MetricTheme): {
+    token: (name: MetricToken) => string;
+    color(field: string, value: MetricValue): string;
+};
+
 interface QueryBuilderProps<Row> {
+    /** Collect unused clauses into a compact row of add actions. */
+    compact?: boolean;
+    /** Additional clauses, inserted after WHERE and before ORDER BY. */
+    clauses?: ReactNode;
+    /** Replace WHERE when its inputs belong to a different result stage. */
+    whereRow?: ReactNode;
+    /** Host-owned summary shown when the editor is collapsed. */
+    summary?: ReactNode;
+    selectPresentation?: SelectPresentation;
+    /** Match/share the entire host definition when it contains more than QueryState. */
+    matchesSavedQuery?: (saved: SavedQuery) => boolean;
+    /** Replace the built-in saved-query controls with host-owned controls. */
+    savedQueryControls?: ReactNode;
+    shareUrl?: string;
+    /** Additional diagnostics shown inside request activity. */
+    requestActivityDetails?: ReactNode;
     /** The controller; QueryBuilder drives it through the intent helpers. */
     api: QueryTableApi<Row>;
     /** All schema fields (for the field picker / sort picker). */
@@ -142,10 +260,31 @@ interface QueryBuilderProps<Row> {
     onCollapsedChange?: (collapsed: boolean) => void;
     /** Initial collapse state for uncontrolled mode. */
     defaultCollapsed?: boolean;
+    metricTheme?: MetricTheme;
+    metricLocale?: string;
+}
+interface SelectPresentation {
+    /** Replaces a chip's label; existing drag and remove controls are retained. */
+    renderChip?: (field: string, label: string) => ReactNode;
+    /** Replaces the add-column picker; call onClose after a selection or dismissal. */
+    renderPicker?: (onClose: () => void) => ReactNode;
+    renderEditor?: (onClose: () => void) => ReactNode;
+    hint?: ReactNode;
+    editorNotice?: ReactNode;
 }
-declare function QueryBuilder<Row>({ api, fields, total, running, classNames, collapsed, onCollapsedChange, defaultCollapsed, }: QueryBuilderProps<Row>): ReactNode;
+declare function QueryBuilder<Row>({ api, fields, total, running, classNames, collapsed, onCollapsedChange, defaultCollapsed, compact, metricTheme, metricLocale, requestActivityDetails, clauses, whereRow, summary, selectPresentation, matchesSavedQuery, savedQueryControls, shareUrl, }: QueryBuilderProps<Row>): ReactNode;
+/** Reuse the same typed predicates for a host's source or result filter stage. */
+declare function QueryFilterRow<Row>({ api, fields, label, }: {
+    api: QueryFilterApi<Row>;
+    fields: FieldDef<Row>[];
+    label?: "where" | "having";
+}): react_jsx_runtime.JSX.Element;
 
 interface MetricsPanelProps<Row> {
+    /** Enables quick editing using the transactional metrics editor. */
+    api?: QueryTableApi<Row>;
+    onEditMetric?: (id: string) => void;
+    onEditDashboard?: () => void;
     /** The aggregation API from useQueryTable (clauses + results + status). */
     aggregations: AggregationsApi;
     /** All schema fields, to resolve labels + the measure field's renderer. */
@@ -154,15 +293,106 @@ interface MetricsPanelProps<Row> {
     renderers?: RenderRegistry<Row>;
     /** Hidden entirely when there are no metrics unless this is set. */
     emptyMessage?: string;
-    classNames?: {
-        root?: string;
-        metric?: string;
-    };
+    classNames?: MetricClassNames;
+    theme?: MetricTheme;
+    locale?: string;
+    onInspect?: (bucket: MetricBucket, clause: RenderingClause) => void;
+}
+declare function MetricsPanel<Row>({ aggregations, api, onEditMetric, onEditDashboard, fields, renderers, emptyMessage, classNames, theme, locale, onInspect, }: MetricsPanelProps<Row>): ReactNode;
+interface MetricCardProps<Row> {
+    /** Sparse cover axes and labelled box rows with independent whisker scales. */
+    compact?: boolean | undefined;
+    onEdit?: (() => void) | undefined;
+    clause: RenderingClause;
+    buckets?: MetricBucket[] | undefined;
+    result?: MetricRenderResult | undefined;
+    fields: FieldDef<Row>[];
+    loading?: boolean | undefined;
+    renderers?: RenderRegistry<Row> | undefined;
+    theme?: MetricTheme | undefined;
+    locale?: string | undefined;
+    className?: string | undefined;
+    classNames?: MetricClassNames | undefined;
+    onInspect?: ((bucket: MetricBucket, clause: RenderingClause) => void) | undefined;
 }
-declare function MetricsPanel<Row>({ aggregations, fields, renderers, emptyMessage, classNames, }: MetricsPanelProps<Row>): ReactNode;
+declare function MetricCard<Row>({ compact, clause, buckets: explicitBuckets, onEdit, result, fields, loading, renderers, theme, locale, className, classNames, onInspect, }: MetricCardProps<Row>): ReactNode;
+
+type OverlayAnchor = HTMLElement | {
+    x: number;
+    y: number;
+};
+interface FloatingOverlayOptions {
+    anchor: OverlayAnchor;
+    onClose: () => void;
+    returnFocus?: HTMLElement | null | undefined;
+    width?: number | undefined;
+    placement?: Placement | undefined;
+    nodeId?: string | undefined;
+}
+
+/** A trigger element, or viewport coordinates for a context menu. */
+type MenuAnchor = OverlayAnchor;
+interface MenuProps {
+    label: string;
+    anchor: MenuAnchor;
+    onClose: () => void;
+    children: ReactNode;
+    width?: number;
+    initialFocus?: "first" | "last";
+    classNames?: MenuClassNames | undefined;
+    /** Focus destination after selection or Escape (defaults to the trigger/current focus). */
+    returnFocus?: HTMLElement | null | undefined;
+}
+/** Mounted while open. Desktop menus escape clipping; phones use the shared sheet. */
+declare function Menu(props: MenuProps): ReactNode;
+interface MenuItemProps extends Omit<ButtonHTMLAttributes<HTMLButtonElement>, "onClick" | "onSelect"> {
+    onSelect?: (() => void) | undefined;
+    closeOnSelect?: boolean;
+    checked?: boolean | undefined;
+    selectionType?: "checkbox" | "radio";
+    icon?: ReactNode;
+    shortcut?: string;
+    tone?: "default" | "danger";
+    /** Typeahead label for rich content (defaults to visible text). */
+    textValue?: string;
+}
+declare const MenuItem: react.ForwardRefExoticComponent<MenuItemProps & react.RefAttributes<HTMLButtonElement>>;
+interface MenuSubmenuProps {
+    label: string;
+    children: ReactNode;
+    disabled?: boolean;
+    width?: number;
+}
+declare function MenuSubmenu({ label, children, disabled, width }: MenuSubmenuProps): ReactNode;
+declare function MenuSeparator(): ReactNode;
+interface MenuGroupProps {
+    label: string;
+    children: ReactNode;
+    className?: string;
+    /** Column count for paired action grids; arrows follow rows and columns. */
+    columns?: number;
+}
+interface MenuButtonProps extends Omit<MenuProps, "anchor" | "onClose" | "returnFocus" | "initialFocus"> {
+    trigger: ReactNode;
+    buttonProps?: Omit<ButtonHTMLAttributes<HTMLButtonElement>, "onClick" | "onKeyDown" | "children" | "type">;
+}
+/** Uncontrolled action trigger, including ArrowUp/Down opening and focus return. */
+declare function MenuButton({ trigger, buttonProps, ...menuProps }: MenuButtonProps): ReactNode;
+declare function MenuGroup({ label, children, className, columns }: MenuGroupProps): ReactNode;
 
 interface FieldPickerProps<Row> {
+    /** Optional next-step content, sharing the same anchored header and Back/Close controls. */
+    children?: ReactNode;
+    title?: string;
+    onBack?: () => void;
+    searchValue?: string;
+    onSearchChange?: (value: string) => void;
+    description?: string;
     fields: FieldDef<Row>[];
+    /** Optional field content; the picker retains search, focus, and selection. */
+    renderField?: (field: FieldDef<Row>) => ReactNode;
+    /** With onClose, supply a trigger (or wrap in PickerAnchor) for a floating picker; otherwise inline on desktop. */
+    anchor?: MenuAnchor | undefined;
     /** Already-shown field names, so the picker can mark/hide them. */
     excluded?: string[];
     /** Stats keyed by field name (optional). */
@@ -170,9 +400,10 @@ interface FieldPickerProps<Row> {
     /** When true, dim/disable fields with ≤1 distinct value ("gate on distinct"). */
     gateOnDistinct?: boolean;
     onPick: (field: FieldDef<Row>) => void;
+    /** Enables a dismissible overlay on mobile. Omit to stay inline at every viewport size. */
     onClose?: () => void;
 }
-declare function FieldPicker<Row>({ fields, excluded, stats, gateOnDistinct, onPick, onClose, }: FieldPickerProps<Row>): ReactNode;
+declare function FieldPicker<Row>({ children, fields, renderField, anchor, excluded, stats, gateOnDistinct, onPick, onClose, title, description, onBack, searchValue, onSearchChange, }: FieldPickerProps<Row>): ReactNode;
 
 interface CellMenuProps<Row> {
     field: FieldDef<Row>;
@@ -183,8 +414,9 @@ interface CellMenuProps<Row> {
     onAddFilter: (clause: WhereClause) => void;
     onClose: () => void;
     classNames?: MenuClassNames;
+    returnFocus?: HTMLElement | null | undefined;
 }
-declare function CellMenu<Row>({ field, value, x, y, onAddFilter, onClose, classNames }: CellMenuProps<Row>): ReactNode;
+declare function CellMenu<Row>({ field, value, x, y, onAddFilter, onClose, classNames, returnFocus }: CellMenuProps<Row>): ReactNode;
 
 interface SelectionToolbarProps {
     selection: SelectionApi;
@@ -207,8 +439,12 @@ declare function SavedQueriesModal({ saved, onClose, onLoad }: SavedQueriesModal
 interface SelectColumnEditorProps<Row> {
     api: QueryTableApi<Row>;
     onClose: () => void;
+    /** Jump directly to this column's settings when opening the editor. */
+    initialField?: string;
+    /** Context for the result fields being selected, e.g. a grouped-row schema. */
+    notice?: ReactNode;
 }
-declare function SelectColumnEditor<Row>({ api, onClose, }: SelectColumnEditorProps<Row>): react_jsx_runtime.JSX.Element;
+declare function SelectColumnEditor<Row>({ api, onClose, initialField, notice: contextNotice, }: SelectColumnEditorProps<Row>): react_jsx_runtime.JSX.Element;
 
 /** Consumer-owned presentation; canonical values remain in queries and URLs. */
 interface FilterValuePresentation {
@@ -222,4 +458,281 @@ declare function PresentedFilterValue({ field, value, label }: {
     label?: string;
 }): react_jsx_runtime.JSX.Element;
 
-export { type CellContext, CellMenu, type CellMenuProps, type CellRenderer, DataTable, type DataTableProps, FieldPicker, type FieldPickerProps, type FilterValuePresentation, FilterValueProvider, Icon, type IconName, type IconProps, type MenuClassNames, MetricsPanel, type MetricsPanelProps, PresentedFilterValue, QueryBuilder, type QueryBuilderClassNames, type QueryBuilderProps, type RenderRegistry, SavedQueriesModal, type SavedQueriesModalProps, SelectColumnEditor, type SelectColumnEditorProps, SelectionToolbar, type SelectionToolbarProps, type TableClassNames, defaultRenderers, resolveRenderer, safeLinkHref };
+interface MetricsEditorProps<Row> {
+    api: QueryTableApi<Row>;
+    fields: FieldDef<Row>[];
+    onClose: () => void;
+    initialMetricId?: string;
+    initialView?: "editor" | "dashboard";
+    theme?: MetricTheme;
+    locale?: string;
+}
+/** Transactional query-local authoring; previews never mutate the table query. */
+declare function MetricsEditor<Row>({ api, fields, onClose, initialMetricId, initialView, theme, locale, }: MetricsEditorProps<Row>): ReactNode;
+
+interface MetricFormattedValue {
+    text: string;
+    error?: string;
+    raw: MetricValue | undefined;
+}
+declare function validateMetricFormat(format: MetricValueFormat): string | undefined;
+/** Strict coordinate parser shared by calendar formatting and chronological charts. */
+declare function metricTimestamp(value: MetricValue, format?: MetricValueFormat): {
+    date: Date;
+    timeZone: string | undefined;
+};
+declare function formatMetricOutput(value: MetricValue | undefined, format?: MetricValueFormat, locale?: string): MetricFormattedValue;
+
+interface RequestActivityProps {
+    activity: RequestActivityApi;
+    /** Optional host diagnostics, e.g. database and network timings. */
+    children?: ReactNode;
+    id?: string;
+}
+declare function RequestActivity({ activity, children, id, }: RequestActivityProps): react_jsx_runtime.JSX.Element;
+
+interface ObjectPropertiesProps<Row> {
+    schema: FieldSchema<Row>;
+    row: Row;
+    view: PropertyViewState;
+    onViewChange?: (view: PropertyViewState) => void;
+    renderers?: RenderRegistry<Row>;
+    relationships?: RelationshipAdapter;
+    onOpenReference?: (reference: ObjectReference) => void;
+    /** Explicit projection coverage distinguishes unloaded fields from NULL values. */
+    loadedFields?: readonly string[];
+    locale?: string;
+    theme?: MetricTheme;
+    now?: number;
+    className?: string;
+}
+declare function formatPropertyValue(value: unknown, format: PropertyFormat, locale?: string, now?: number): {
+    text: string;
+    error?: string;
+};
+declare function ObjectProperties<Row>(props: ObjectPropertiesProps<Row>): ReactNode;
+
+declare function PropertyViewEditor<Row>({ schema, view, onApply, onClose, preview, scope, }: {
+    preview?: Omit<ObjectPropertiesProps<Row>, "view">;
+    scope?: string;
+    schema: FieldSchema<Row>;
+    view: PropertyViewState;
+    onApply: (view: PropertyViewState) => void;
+    onClose: () => void;
+}): ReactNode;
+declare function PropertyViewControls<Row>({ api, schema, preview, scope, shareAction, onClose, closeLabel, compact, }: {
+    onClose?: () => void;
+    closeLabel?: string;
+    compact?: boolean;
+    shareAction?: ReactNode;
+    preview?: Omit<ObjectPropertiesProps<Row>, "view">;
+    scope?: string;
+    api: PropertyViewApi;
+    schema: FieldSchema<Row>;
+}): ReactNode;
+
+interface ObjectInspectorProps<Row> extends Omit<ObjectPropertiesProps<Row>, "view"> {
+    storage?: PropertyViewStorage;
+    initialView?: PropertyViewState;
+    objectType?: string;
+    /** Accessible identity; surrounding page/modal owns visible item headings. */
+    typeLabel?: string;
+    title?: ReactNode;
+    subtitle?: ReactNode;
+    /** Share one controller across table details and standalone cards. */
+    propertyApi?: PropertyViewApi;
+    /** Names the edited modality in the properties editor's context strip. */
+    viewScope?: string;
+    /** Host-owned share URL, including identity and the supplied property snapshot. */
+    shareUrl?: (view: PropertyViewState) => string;
+    shareAction?: ReactNode;
+    /** Show a close control beside the view history when this card is a dialog. */
+    onClose?: () => void;
+    closeLabel?: string;
+    /** Icon controls for a compact surface such as a popover. */
+    compact?: boolean;
+}
+/** Opinionated read-only item card, starting with the same state bar as the builder. */
+declare function ObjectInspector<Row>(props: ObjectInspectorProps<Row>): ReactNode;
+
+/** Snapshot the item and collection state, even when URL synchronization is off.
+ * A popover is shared as a modal with that popover's current appearance. */
+declare function itemDetailHref<Row>(api: ItemDetailsApi<Row>, query: QueryState, id: RowId, mode?: ItemPropertyMode): string;
+declare function ItemDetailShare<Row>({ api, query, id, mode, compact }: {
+    api: ItemDetailsApi<Row>;
+    query: QueryState;
+    id: RowId;
+    mode?: ItemPropertyMode;
+    compact?: boolean;
+}): ReactNode;
+
+interface PopoverProps extends Omit<FloatingOverlayOptions, "nodeId"> {
+    label: string;
+    children: ReactNode;
+    className?: string;
+    /** Desktop focus selector, scoped to this surface (defaults to its first control). */
+    initialFocus?: string;
+}
+/** A form or searchable picker sharing menus' floating and mobile surface. */
+declare function Popover({ label, children, className, initialFocus, ...options }: PopoverProps): react_jsx_runtime.JSX.Element;
+
+/** Keeps a button and its chooser together without inserting an input into the query. */
+declare function PickerAnchor({ children }: {
+    children: ReactNode;
+}): react_jsx_runtime.JSX.Element;
+declare function PickerSurface({ title, children, onClose, mobileChrome, }: {
+    title: string;
+    children: ReactNode;
+    onClose: () => void;
+    /** Editors with their own Apply/Cancel header can keep that chrome on mobile. */
+    mobileChrome?: boolean;
+}): react_jsx_runtime.JSX.Element;
+
+/** Shared chrome for query-local metric and column workbenches. */
+declare function EditorContext({ shown, total, filters, noun, locale, children, }: {
+    shown: number;
+    total: number | null;
+    filters: number;
+    noun?: string;
+    locale?: string | undefined;
+    children?: ReactNode;
+}): react_jsx_runtime.JSX.Element;
+declare function EditorPaneTitle({ children, actions, }: {
+    children: ReactNode;
+    actions?: ReactNode;
+}): react_jsx_runtime.JSX.Element;
+declare function EditorChoice({ selected, title, detail, code, onClick, }: {
+    selected: boolean;
+    title: string;
+    detail?: string;
+    code?: string;
+    onClick: () => void;
+}): react_jsx_runtime.JSX.Element;
+
+declare function useMobileLayout(): boolean;
+declare function ModalSurface({ title, onClose, children, className, chrome, returnFocus, backdropClassName, initialFocus, }: {
+    title: string;
+    onClose: () => void;
+    children?: ReactNode;
+    className?: string;
+    chrome?: boolean;
+    returnFocus?: HTMLElement | null | undefined;
+    backdropClassName?: string | undefined;
+    initialFocus?: string | undefined;
+}): ReactNode;
+
+interface ReorderItem {
+    id: string;
+    label: string;
+}
+declare function ReorderList({ items, onMove, disabled, className, renderItem, showHint, layout, itemStyle, itemClassName, }: {
+    items: ReorderItem[];
+    onMove: (id: string, position: number) => void;
+    disabled?: boolean | undefined;
+    className?: string;
+    renderItem?: (item: ReorderItem, position: number) => ReactNode;
+    showHint?: boolean;
+    layout?: "vertical" | "wrap";
+    itemStyle?: (item: ReorderItem, position: number) => CSSProperties;
+    itemClassName?: (item: ReorderItem, position: number) => string;
+}): ReactNode;
+
+interface EditorPaneSize {
+    width: number;
+    minWidth: number;
+    /** Initial/reset visibility. Updated defaults take effect on the next reset. */
+    defaultVisible?: boolean;
+}
+declare function useEditorWorkbench(panes: readonly EditorPaneSize[], isEditor?: boolean): {
+    root: react.MutableRefObject<HTMLDivElement | null>;
+    header: react.MutableRefObject<HTMLElement | null>;
+    widths: number[];
+    minWidths: number[];
+    visiblePanes: boolean[];
+    visibleIndices: number[];
+    nextPane: (index: number) => number | undefined;
+    togglePane: (index: number) => void;
+    showPane: (index: number) => void;
+    hidePane: (index: number) => void;
+    startResize: (event: PointerEvent<HTMLElement>, index: number) => void;
+    resetPanes: () => void;
+    stepResize: (index: number, delta: number) => void;
+    reset: () => void;
+};
+
+type EditorWorkbench = ReturnType<typeof useEditorWorkbench>;
+/** Shared shell for transactional editors. Panel geometry never changes query state. */
+declare function EditorModal({ title, titleId, closeLabel, onClose, workbench, headerActions, panelControls, children, className, }: {
+    title: string;
+    titleId?: string;
+    closeLabel?: string;
+    onClose: () => void;
+    workbench: EditorWorkbench;
+    headerActions?: ReactNode;
+    panelControls?: ReactNode;
+    children: ReactNode;
+    className?: string;
+}): react_jsx_runtime.JSX.Element;
+declare function EditorPanelToggle({ workbench, index, label, icon, paneId, collapse, }: {
+    workbench: EditorWorkbench;
+    index: number;
+    label: string;
+    icon: IconName;
+    paneId: string;
+    collapse?: boolean;
+}): react_jsx_runtime.JSX.Element;
+declare function EditorPanelSeparator({ workbench, index, label, controls, }: {
+    workbench: EditorWorkbench;
+    index: number;
+    label: string;
+    controls: string;
+}): react_jsx_runtime.JSX.Element | null;
+
+interface FormulaEditorActions {
+    insertFunction: (name: string) => void;
+}
+interface FormulaEditorProps {
+    actionsRef?: Ref<FormulaEditorActions>;
+    functions?: readonly FormulaFunction[];
+    value: string;
+    onChange: (value: string) => void;
+    fields: FieldDef[];
+    compile: (value: string) => unknown;
+    /** Metric authoring uses a separate reference pane and no suggestions. */
+    suggestions?: boolean;
+    showLibrary?: boolean;
+    rows?: number;
+    ariaLabel?: string;
+    inputRef?: MutableRefObject<HTMLTextAreaElement | null>;
+    onFocus?: () => void;
+    onReady?: (input: HTMLTextAreaElement) => void;
+}
+declare function FormulaEditor({ value, actionsRef, functions, onChange, fields, compile, suggestions, showLibrary, ariaLabel, inputRef, onFocus, onReady, rows, }: FormulaEditorProps): react_jsx_runtime.JSX.Element;
+
+declare function FormulaFunctionBrowser({ onInsert, functions, variant, }: {
+    onInsert?: (name: string) => void;
+    functions?: readonly FormulaFunction[];
+    variant?: "card" | "panel";
+}): react_jsx_runtime.JSX.Element;
+
+/** Presentation metadata supplied by the host, independent of field type. */
+interface ColumnRole {
+    kind: "row" | "key" | "aggregate";
+    badge: string;
+    title: string;
+}
+/** Role colors inherit the instance's --qt-column-{role}-* CSS tokens. */
+declare function ColumnRoleBadge({ role, className, }: {
+    role: ColumnRole | undefined;
+    className?: string;
+}): react_jsx_runtime.JSX.Element | null;
+
+type Controller = GroupingApi<GroupedRow>;
+declare function GroupedColumnsEditor({ controller, onClose, renderers, initialFormulaField, }: {
+    initialFormulaField?: string;
+    controller: Controller;
+    onClose: () => void;
+    renderers?: RenderRegistry<GroupedRow>;
+}): react_jsx_runtime.JSX.Element;
+
+export { type CellContext, CellMenu, type CellMenuProps, type CellRenderer, type ColumnRole, ColumnRoleBadge, DataTable, type DataTableProps, EditorChoice, EditorContext, EditorModal, type EditorPaneSize, EditorPaneTitle, EditorPanelSeparator, EditorPanelToggle, type EditorWorkbench, FieldPicker, type FieldPickerProps, type FilterValuePresentation, FilterValueProvider, FormulaEditor, type FormulaEditorActions, type FormulaEditorProps, FormulaFunctionBrowser, GroupedColumnsEditor, Icon, type IconName, type IconProps, ItemDetailShare, JsonCell, type JsonCellProps, type JsonEntry, type JsonInspection, JsonValueView, Menu, type MenuAnchor, MenuButton, type MenuButtonProps, type MenuClassNames, MenuGroup, type MenuGroupProps, MenuItem, type MenuItemProps, type MenuProps, MenuSeparator, MenuSubmenu, type MenuSubmenuProps, MetricCard, type MetricCardProps, type MetricClassNames, type MetricTheme, MetricsEditor, type MetricsEditorProps, MetricsPanel, type MetricsPanelProps, ModalSurface, ObjectInspector, type ObjectInspectorProps, ObjectProperties, type ObjectPropertiesProps, PickerAnchor, PickerSurface, Popover, type PopoverProps, PresentedFilterValue, PropertyViewControls, PropertyViewEditor, QueryBuilder, type QueryBuilderClassNames, type QueryBuilderProps, QueryFilterRow, type RenderRegistry, ReorderList, RequestActivity, type RequestActivityProps, SavedQueriesModal, type SavedQueriesModalProps, SelectColumnEditor, type SelectColumnEditorProps, type SelectPresentation, SelectionToolbar, type SelectionToolbarProps, type TableClassNames, createMetricColorResolver, defaultRenderers, formatMetricOutput, formatPropertyValue, inspectJsonValue, itemDetailHref, metricTimestamp, resolveRenderer, safeLinkHref, searchJsonEntries, useEditorWorkbench, useMobileLayout, validateMetricFormat };