@mieweb/ui 0.9.0-datavis-submodule-test.1 → 0.9.0-datavis-submodule-test.3

package/dist/datavis.d.cts

@@ -1,7 +1,689 @@
-export { DataVisNitroAggregate, DataVisNitroColumn, DataVisNitroContext, DataVisNitroGraph, DataVisNitroGraphProps, DataVisNitroGrid, DataVisNitroGridProps, DataVisNitroGroupField, LanguageSelector as DataVisNitroLanguageSelector, LanguageSelectorProps as DataVisNitroLanguageSelectorProps, DataVisNitroSource, DataVisNitroSourceProps } from './components';
+import * as React$1 from 'react';
+import React__default from 'react';
 import * as react_jsx_runtime from 'react/jsx-runtime';
 import { P as PatientHistory, a as ProgramsMap, O as OrderRow } from './orderRows-BUJYgSc7.cjs';
 
+/**
+ * EventBridge — Adapts the wcdatavis `mixinEventHandling` pub/sub pattern
+ * to React-friendly patterns (callbacks and hooks).
+ *
+ * The core wcdatavis objects (Source, ComputedView, Prefs) use a custom
+ * event system with `.on(event, callback, opts)` / `.off(event, who)` /
+ * `.fire(event, ...args)`. This module bridges that to React's world.
+ */
+/** Any wcdatavis object that has mixinEventHandling applied. */
+interface EventEmitter {
+    on(event: string, callback: (...args: unknown[]) => void, opts?: {
+        who?: unknown;
+        limit?: number;
+        info?: string;
+    }): void;
+    off(event: string, who: unknown, opts?: Record<string, unknown>): void;
+    fire(event: string, ...args: unknown[]): void;
+}
+
+interface NormalizedViewData {
+    isPlain: boolean;
+    isGroup: boolean;
+    isPivot: boolean;
+    data: unknown[];
+    dataByRowId?: Record<string, unknown>;
+    rowVals?: unknown[];
+    colVals?: unknown[];
+    groupFields?: string[];
+    pivotFields?: string[];
+    groupMetadata?: unknown;
+    agg?: unknown;
+    totalCol?: Record<string, unknown>[];
+    totalRow?: Record<string, unknown>[];
+    grandTotal?: Record<string, unknown>;
+    totalAggregates?: Record<string, unknown>;
+}
+
+/**
+ * useSource — React hook wrapping wcdatavis Source construction and lifecycle.
+ *
+ * Provides reactive state for data fetching progress and type information,
+ * abstracting away the callback-based Source API.
+ */
+
+/** Source instance (from wcdatavis core) */
+interface SourceInstance extends EventEmitter {
+    getData(cont: (ok: boolean, data: unknown) => void): void;
+    getTypeInfo(cont: (ok: boolean, typeInfo: unknown) => void): void;
+    getUniqueVals(cont: (ok: boolean, vals: unknown) => void): void;
+    getDisplayName(cont: (ok: boolean, name: string) => void): void;
+    clearCachedData(): void;
+    refresh(): void;
+    cancel(): void;
+    isCancellable(): boolean;
+    swapRows(oldIdx: number, newIdx: number): void;
+    setToolbar(toolbar: unknown): void;
+}
+/** ComputedView instance (from wcdatavis core) */
+interface ViewInstance extends EventEmitter {
+    source: SourceInstance;
+    data: unknown;
+    typeInfo: unknown;
+    getData(cont?: (ok: boolean, data: unknown) => void, reason?: string): void;
+    getTypeInfo(cont?: (ok: boolean, typeInfo: unknown) => void): void;
+    setSort(spec: unknown, opts?: Record<string, unknown>): void;
+    setFilter(spec: unknown, progress?: unknown, opts?: Record<string, unknown>): void;
+    setGroup(spec: unknown, opts?: Record<string, unknown>): void;
+    setPivot(spec: unknown, opts?: Record<string, unknown>): void;
+    setAggregate(spec: unknown, opts?: Record<string, unknown>): void;
+    clearSort(opts?: Record<string, unknown>): void;
+    clearFilter(opts?: Record<string, unknown>): void;
+    clearGroup(opts?: Record<string, unknown>): void;
+    clearPivot(opts?: Record<string, unknown>): void;
+    clearAggregate(opts?: Record<string, unknown>): void;
+    getSort(): unknown;
+    getFilter(): unknown;
+    getGroup(): unknown;
+    getPivot(): unknown;
+    getAggregate(): unknown;
+    getRowCount(): number;
+    getTotalRowCount(): number;
+    clearCache(): void;
+    refresh(): void;
+    reset(opts?: Record<string, unknown>): void;
+    setColConfig(colConfig: unknown): void;
+    setPrefs(prefs: unknown): void;
+    unlimit(): void;
+    getUniqueVals(cont: (ok: boolean, vals: unknown) => void): void;
+}
+/** View data shape — matches View~Data from wcdatavis */
+type ViewData = NormalizedViewData;
+
+/**
+ * usePrefs — React hook wrapping wcdatavis Prefs for perspective management.
+ */
+
+interface PerspectiveInfo {
+    id: string;
+    name: string;
+    config?: unknown;
+    isTemporary?: boolean;
+    isEssential?: boolean;
+    isUnsaved?: boolean;
+}
+interface RawPerspective {
+    id: string;
+    name?: string;
+    config?: unknown;
+    opts?: {
+        isTemporary?: boolean;
+        isEssential?: boolean;
+    };
+    isUnsaved?: boolean;
+}
+interface PrefsInstance extends EventEmitter {
+    name?: string;
+    isPrimed?: boolean;
+    reset(): void;
+    back(): void;
+    forward(): void;
+    addPerspective(...args: unknown[]): void;
+    deletePerspective(id: string, cont?: (ok: boolean) => void): void;
+    renamePerspective(id: string, name: string, cont?: (ok: boolean) => void): void;
+    setCurrentPerspective(id: string, cont?: (ok: boolean) => void): void;
+    clonePerspective(...args: unknown[]): void;
+    save?(cont?: (ok: boolean) => void): void;
+    reallySave?(cont?: (ok: boolean) => void): void;
+    prime?(cont?: (ok: boolean) => void): void;
+    getPerspectives(cont: (ids: string[]) => void): void;
+    getCurrentPerspective?(): PerspectiveInfo | null;
+    currentPerspective?: RawPerspective | null;
+    perspectives?: Record<string, RawPerspective>;
+    availablePerspectives?: string[];
+}
+
+/**
+ * GroupFunctionDialog — Modal for selecting a group function.
+ *
+ * Displays categorised buttons (Repeating, Date, Date/Time, Time, Other)
+ * for the available group functions. Replaces `wcdatavis/src/group_fun_win.js`.
+ */
+interface GroupFunction {
+    /** Internal function name / key */
+    name: string;
+    /** Translated display label */
+    label: string;
+    /** Category key — maps to column headers in the dialog */
+    category: 'repeating' | 'date' | 'datetime' | 'time' | 'other';
+}
+
+/**
+ * ColumnConfigDialog — Modal for configuring column order, visibility,
+ * display names, and per-column flags.
+ *
+ * Replaces the jQuery UI dialog from `wcdatavis/src/ui/windows/col_config.js`.
+ * Uses @dnd-kit for sortable row reordering.
+ */
+interface ColumnConfig {
+    /** Field name (unique key) */
+    field: string;
+    /** Display name shown in the column header */
+    displayText: string;
+    /** Whether the column is pinned (frozen) */
+    isPinned: boolean;
+    /** Whether the column is hidden */
+    isHidden: boolean;
+    /** Allow raw HTML rendering in cells */
+    allowHtml: boolean;
+    /** Allow type-based formatting */
+    allowFormatting: boolean;
+    /** Whether the column can be hidden (some columns are required) */
+    canHide?: boolean;
+}
+
+/**
+ * AggregateSection — aggregate control for the control panel.
+ *
+ * Unlike Group/Pivot sections, aggregates have a function selector
+ * and potentially multiple field arguments per aggregate entry.
+ */
+interface AggregateFunction {
+    /** Function name (key) */
+    name: string;
+    /** Display label */
+    label: string;
+    /** Number of field arguments this function takes */
+    fieldCount: number;
+}
+
+/**
+ * Filter types — shared type definitions for all filter components.
+ *
+ * Models the wcdatavis filter spec language:
+ *   { fieldName: { $operator: value, ... }, ... }
+ */
+/** All supported filter operators */
+type FilterOperator = '$contains' | '$notcontains' | '$eq' | '$ne' | '$gt' | '$gte' | '$lt' | '$lte' | '$in' | '$nin' | '$exists' | '$notexists' | '$bet' | '$every' | '$this' | '$last';
+/** The type family a column belongs to, governing which filter widget to show */
+type FilterType = 'string' | 'number' | 'currency' | 'date' | 'datetime' | 'boolean';
+/** Filter widget variant hint from column config */
+type FilterWidget = 'textbox' | 'dropdown' | 'checkbox' | 'tribool' | 'single' | 'range' | 'neon';
+/** Column configuration relevant to filtering */
+interface ColumnFilterConfig {
+    /** Field name (key in data rows) */
+    field: string;
+    /** Human-readable column name */
+    displayName: string;
+    /** Type family for selecting the filter component */
+    filterType: FilterType;
+    /** Preferred widget variant (optional — a sensible default is chosen) */
+    widget?: FilterWidget;
+    /** For dropdown filters: available option values */
+    options?: string[];
+    /** Operators to include (override default set) */
+    includeOperators?: FilterOperator[];
+    /** Operators to exclude */
+    excludeOperators?: FilterOperator[];
+    /** Whether the column is currently visible */
+    visible?: boolean;
+}
+
+/**
+ * format-cell — shared cell-value formatting for all table renderers.
+ *
+ * Centralises the "how to display a raw value" logic so PlainTable,
+ * GroupDetailTable (and future renderers) stay DRY.
+ *
+ * The `locale` parameter is a BCP-47 tag (e.g. `'en-US'`, `'fr-FR'`)
+ * obtained from `useLocale()`.  When `undefined` the browser's default
+ * locale is used, which gives US users the familiar MM/DD/YY format.
+ */
+/** All supported date format preset names. */
+type DateFormatPreset = 'short' | 'short4' | 'medium' | 'long' | 'iso' | 'relative';
+
+/**
+ * Table renderer types — shared type definitions for all table sub-renderers.
+ *
+ * Models the column configuration, sorting, cell rendering, and selection
+ * concepts used by the wcdatavis table renderer.
+ */
+
+/** Column definition for the table renderer */
+interface TableColumn {
+    /** Internal field name (key in row data) */
+    field: string;
+    /** Display header text */
+    header: string;
+    /** Column width in pixels (user-resized or from colConfig) */
+    width?: number;
+    /** Minimum width in pixels */
+    minWidth?: number;
+    /** Maximum width in pixels */
+    maxWidth?: number;
+    /** Whether the column is currently visible */
+    visible?: boolean;
+    /** Whether the column is pinned (frozen) */
+    pinned?: boolean;
+    /** Text alignment override */
+    align?: 'left' | 'center' | 'right';
+    /** Custom CSS class for cells in this column */
+    className?: string;
+    /** Whether this column allows HTML rendering */
+    allowHtml?: boolean;
+    /** Field type info for formatting */
+    typeInfo?: {
+        type: string;
+        format?: string | Record<string, unknown>;
+        internalType?: string;
+    };
+    /** Whether this column is sortable */
+    sortable?: boolean;
+    /** Whether this column is filterable */
+    filterable?: boolean;
+    /** Whether this column is resizable */
+    resizable?: boolean;
+    /** Whether this column is reorderable */
+    reorderable?: boolean;
+    /** Searchable display text for custom-rendered cells. */
+    getSearchText?: (value: unknown, row: RowData, column: TableColumn) => string;
+}
+/** Sort direction */
+type SortDirection = 'asc' | 'desc';
+/** Active sort spec for a single column */
+interface SortSpec {
+    field: string;
+    direction: SortDirection;
+}
+/**
+ * Multi-column sort: an ordered list of single-column sort specs in priority
+ * order. The first entry is the primary sort key, the second breaks ties
+ * within equal primary values, and so on.
+ */
+type MultiSortSpec = SortSpec[];
+/** A single row of data — key-value map */
+type RowData = Record<string, unknown>;
+/** Row with row-number metadata */
+interface TableRow {
+    /** Original row index in the dataset */
+    rowNum: number;
+    /** Row ID (if available) */
+    rowId?: string;
+    /** The data values */
+    data: RowData;
+}
+/** Row selection state */
+interface SelectionState {
+    /** Set of selected row numbers */
+    selectedRows: Set<number>;
+    /** Currently active (focused) row number */
+    activeRow: number | null;
+    /** Currently focused column field */
+    activeColumn: string | null;
+}
+/** Feature flags controlling table behavior */
+interface TableFeatures {
+    /** Enable column resizing */
+    columnResize?: boolean;
+    /** Enable column reordering (DnD) */
+    columnReorder?: boolean;
+    /** Enable sticky headers */
+    stickyHeaders?: boolean;
+    /**
+     * Enable row selection.
+     * - `true` — click selects a row, Shift+click extends the selection
+     * - `'checkbox'` — adds a leading checkbox column with a tri-state
+     *   select-all header checkbox (applies to the currently filtered rows)
+     */
+    rowSelection?: boolean | 'checkbox';
+    /** Enable context menu on column headers */
+    headerContextMenu?: boolean;
+    /** Enable zebra striping */
+    zebraStripe?: boolean;
+    /** Enable keyboard navigation (j/k) */
+    keyboardNav?: boolean;
+    /** Enable drill-down on double-click */
+    drillDown?: boolean;
+    /** Enable show-more / limit */
+    showMore?: boolean;
+    /** Row mode — wrapped or clipped */
+    rowMode?: 'wrapped' | 'clipped';
+}
+/** Cell formatter function — returns React node */
+type CellFormatter = (value: unknown, row: RowData, column: TableColumn) => React__default.ReactNode;
+
+/**
+ * OperationsPalette — Inline toolbar of action buttons for row-level operations.
+ *
+ * Replaces `src/operations_palette.js`. Groups operations by category.
+ */
+
+interface Operation {
+    /** Unique index (assigned automatically if not provided) */
+    idx?: number;
+    /** Display label */
+    label?: string;
+    /** Optional icon element */
+    icon?: React__default.ReactNode;
+    /** Category for grouping */
+    category?: string;
+    /** Callback invoked when the operation is triggered */
+    callback: (ctx: OperationContext) => void;
+}
+interface OperationContext {
+    /** Currently selected rows */
+    rows: unknown[];
+    /** The button element (for positioning popovers, etc.) */
+    buttonRef?: React__default.RefObject<HTMLButtonElement>;
+}
+
+/**
+ * TemplateEditorDialog — Modal for editing Handlebars / Squirrelly templates
+ * used by the grid renderer in plain, grouped, and pivot modes.
+ *
+ * Replaces the jQuery UI dialog from `wcdatavis/src/ui/templates.js`.
+ */
+/** Template slots for a single data mode */
+interface TemplateSlots {
+    empty?: string;
+    before?: string;
+    item?: string;
+    after?: string;
+    /** Only used in pivot mode */
+    beforeGroup?: string;
+    /** Only used in pivot mode */
+    afterGroup?: string;
+}
+/** Template data for all three modes */
+interface TemplateData {
+    whenPlain?: TemplateSlots;
+    whenGroup?: TemplateSlots;
+    whenPivot?: TemplateSlots;
+}
+
+/**
+ * GridTableOptionsDialog — Modal for customising cell display-format templates.
+ *
+ * Replaces the jQuery UI dialog from `wcdatavis/src/ui/windows/grid_table_opts.js`.
+ */
+interface DisplayFormatConfig {
+    /** Cell display-format template string (Handlebars / Squirrelly) */
+    cell?: string;
+}
+
+interface TableRendererProps {
+    /** Processed view data from useView() */
+    viewData: ViewData | null;
+    /** Column definitions */
+    columns: TableColumn[];
+    /** Active multi-column sort, in priority order */
+    sorts?: MultiSortSpec | null;
+    /** Feature flags */
+    features?: TableFeatures;
+    /** Total row count (before limit) */
+    totalRows?: number;
+    /** Limit configuration */
+    limit?: {
+        limit: number;
+        autoShowMore?: boolean;
+    };
+    /** Row count loaded so far (for progress bar) */
+    loadedRows?: number;
+    /** Whether data is currently loading */
+    loading?: boolean;
+    /** Custom cell formatter */
+    formatCell?: CellFormatter;
+    /** Per-column date display formats. */
+    dateFormats?: Record<string, DateFormatPreset>;
+    /** Update a column's date display format. */
+    onDateFormatChange?: (field: string, preset: DateFormatPreset) => void;
+    /** Applied plain-mode visual search query. */
+    globalSearchQuery?: string;
+    /** When provided, each plain-mode row gets a disclosure toggle that expands
+        a full-width detail row rendered by this callback. */
+    renderDetailRow?: (row: TableRow) => React.ReactNode;
+    /** Expand (true) or collapse (false) all detail rows. Changing the value
+        overrides individual toggles; leave undefined for per-row control only. */
+    detailRowsExpanded?: boolean;
+    /** Group mode: 'detail' | 'summary' */
+    groupMode?: 'detail' | 'summary';
+    /** Whether to show total row (group/pivot) */
+    showTotalRow?: boolean;
+    /** Whether to show total column (pivot) */
+    showTotalCol?: boolean;
+    /** Whether to hide zero-valued aggregate results (pivot) */
+    hideBottomValueAggResults?: boolean;
+    /** Whether to start groups expanded */
+    groupsExpanded?: boolean;
+    /** Map of aggregate function internal names to display labels */
+    aggFnLabels?: Record<string, string>;
+    /** Custom className */
+    className?: string;
+    /** When true, group data should be displayed as a pivot (pivot without explicit grouping) */
+    syntheticPivot?: boolean;
+    /** Whether to show the "Showing N rows" count in the table footer. Defaults to true. */
+    showRowCount?: boolean;
+    /** Sort requested */
+    onSort?: (field: string, direction: SortDirection, additive?: boolean) => void;
+    /** Row clicked */
+    onRowClick?: (row: TableRow, event: React.MouseEvent) => void;
+    /** Row double-clicked (drill-down) */
+    onRowDoubleClick?: (row: TableRow, event: React.MouseEvent) => void;
+    /** Aggregate cell double-clicked with the coordinates of its source rows */
+    onAggregateCellDoubleClick?: (filters: Record<string, unknown>, event: React.MouseEvent) => void;
+    /** Column resized */
+    onColumnResize?: (field: string, width: number) => void;
+    /** Columns reordered */
+    onColumnReorder?: (fromIndex: number, toIndex: number) => void;
+    /** Context menu on header */
+    onHeaderContextMenu?: (field: string, event: React.MouseEvent) => void;
+    /** Show more rows */
+    onShowMore?: () => void;
+    /** Show all rows */
+    onShowAll?: () => void;
+    /** Selection changed */
+    onSelectionChange?: (selection: SelectionState) => void;
+    /** Seed row selection on mount (stable row ids) */
+    initialSelectedRows?: Set<number>;
+}
+
+/** Grid table definition — mirrors Grid~Defn.table */
+interface GridTableDef {
+    id?: string;
+    columns?: unknown[];
+    features?: Record<string, boolean>;
+    limit?: {
+        autoShowMore?: boolean;
+        limit?: number;
+    };
+    rowMode?: 'wrapped' | 'clipped';
+    groupMode?: 'summary' | 'detail';
+    whenGroup?: {
+        showTotalRow?: boolean;
+        showExpandedGroups?: boolean;
+        pinRowvals?: boolean;
+    };
+    whenPivot?: {
+        showTotalCol?: boolean;
+        hideBottomValueAggResults?: boolean;
+    };
+    [key: string]: unknown;
+}
+/** Grid header display mode. See `DataGridProps.mode`. */
+type GridMode = 'default' | 'full' | 'minimal';
+interface DataGridProps {
+    /** ComputedView instance from wcdatavis core */
+    view: ViewInstance;
+    /** Whether the grid requests data when mounted. */
+    autoFetch?: boolean;
+    /** Optional Prefs instance for perspective management */
+    prefs?: PrefsInstance;
+    /**
+     * Whether pinned-perspective names may persist to localStorage. Set to `false`
+     * on untrusted/public devices so pins stay in memory for the session only
+     * (mirrors a `temporary` Prefs backend). Defaults to `true`.
+     */
+    persistPinnedPerspectives?: boolean;
+    /** Grid table definition */
+    tableDef?: GridTableDef;
+    /** Grid title */
+    title?: string;
+    /** Help text shown as tooltip */
+    helpText?: string;
+    /** Whether to show the toolbar */
+    showToolbar?: boolean;
+    /** Whether to show controls (filter/group/pivot/aggregate) initially */
+    showControls?: boolean;
+    /**
+     * Display mode for the grid header:
+     * - `'default'` (new default): title bar with a smaller title, no seeded count
+     *   footer, and the minimal-mode hamburger menu replacing the inline
+     *   perspective/refresh/gear buttons.
+     * - `'full'`: the classic title bar with row count and inline perspective and
+     *   action buttons.
+     * - `'minimal'`: no title bar — a floating hamburger menu overlays the table.
+     */
+    mode?: GridMode;
+    /**
+     * @deprecated Use `mode="minimal"` instead. Kept for backward compatibility;
+     * when `true` it forces `mode="minimal"`.
+     */
+    minimalMode?: boolean;
+    /** Grid height (CSS value) */
+    height?: string;
+    /** Operations for the operations palette */
+    operations?: Operation[];
+    /** Callback when grid visibility is toggled */
+    onToggle?: (visible: boolean) => void;
+    /** Custom className */
+    className?: string;
+    /** Children rendered in the content area (e.g. table renderer) */
+    children?: React.ReactNode;
+    /** When provided, each plain-mode row gets a disclosure toggle that expands
+        a full-width detail row rendered by this callback. Forwarded to the
+        child table renderer (a renderer's own prop takes precedence). */
+    renderDetailRow?: TableRendererProps['renderDetailRow'];
+    /** Expand (true) or collapse (false) all detail rows. Changing the value
+        overrides individual toggles; leave undefined for per-row control only. */
+    detailRowsExpanded?: boolean;
+    /** Custom actions rendered in the title bar, right-aligned before the
+        built-in controls (hidden in `mode="minimal"`, which has no title bar). */
+    titleActions?: React.ReactNode;
+    /** BCP-47 locale for number/date formatting (e.g. 'en-US'). Defaults to browser locale. */
+    locale?: string;
+    /** Enable debug button */
+    debug?: boolean;
+    /** Preserve a child renderer's explicitly supplied viewData prop instead of replacing it with useView output. */
+    preserveChildViewData?: boolean;
+    /** Column filter configurations for the filter bar */
+    filterColumns?: ColumnFilterConfig[];
+    /** All table columns — used to derive filter configs when filter icon is clicked */
+    allColumns?: TableColumn[];
+    /** Available fields for group/pivot controls */
+    controlFields?: {
+        field: string;
+        displayName: string;
+        disabled?: boolean;
+        type?: string;
+    }[];
+    /** Available fields for aggregate controls */
+    aggregateFields?: {
+        field: string;
+        displayName: string;
+    }[];
+    /** Available aggregate functions */
+    aggregateFunctions?: AggregateFunction[];
+    /** Column configs for the Column Configuration dialog */
+    columnConfigs?: ColumnConfig[];
+    /** Callback when column configuration is saved */
+    onColumnConfigSave?: (columns: ColumnConfig[], clearRenderCache: string[]) => void;
+    /** Template data for the Template Editor dialog */
+    templates?: TemplateData;
+    /** Callback when templates are saved */
+    onTemplateSave?: (templates: TemplateData) => void;
+    /** Display format config for the Grid Table Options dialog */
+    displayFormat?: DisplayFormatConfig;
+    /** Callback when display format is saved */
+    onDisplayFormatSave?: (displayFormat: DisplayFormatConfig) => void;
+    /** Group function definitions for the Group Function dialog */
+    groupFunctionDefs?: GroupFunction[];
+    /** Callback when a group function is selected */
+    onGroupFunctionSelect?: (fieldName: string, functionName: string | null) => void;
+}
+
+type GraphChartType = 'bar' | 'line' | 'area' | 'pie';
+interface GraphConfig {
+    chartType: GraphChartType;
+    xField: string;
+    yFields: string[];
+    stacked: boolean;
+    aggregateKey?: string;
+}
+
+type DataVisNitroColumn = string | TableColumn;
+
+type TranslateFn = (key: string, ...args: unknown[]) => string;
+interface DataVisNitroGroupField {
+    field: string;
+    functionName?: string;
+}
+interface DataVisNitroAggregate {
+    functionName: string;
+    fields: string[];
+}
+interface DataVisNitroSourceConfigurationProps {
+    children?: React__default.ReactNode;
+    groupBy?: Array<string | DataVisNitroGroupField>;
+    aggregates?: DataVisNitroAggregate[];
+}
+interface HttpDataVisNitroSourceProps extends DataVisNitroSourceConfigurationProps {
+    type: 'http';
+    url: string;
+}
+interface LocalDataVisNitroSourceProps extends DataVisNitroSourceConfigurationProps {
+    type: 'local';
+    varName?: string;
+}
+interface FileDataVisNitroSourceProps extends DataVisNitroSourceConfigurationProps {
+    type: 'file';
+}
+type DataVisNitroSourceProps = HttpDataVisNitroSourceProps | LocalDataVisNitroSourceProps | FileDataVisNitroSourceProps;
+
+interface DataVisNitroGridProps extends Omit<DataGridProps, 'view' | 'children' | 'allColumns'>, Pick<TableRendererProps, 'formatCell' | 'onColumnReorder' | 'onColumnResize' | 'onHeaderContextMenu' | 'onRowClick' | 'onRowDoubleClick' | 'onSelectionChange'> {
+    columns?: DataVisNitroColumn[];
+    allColumns?: TableColumn[];
+    features?: TableFeatures;
+    style?: React__default.CSSProperties;
+    trans?: TranslateFn;
+}
+declare const DataVisNitroContext: React__default.Context<ViewInstance | null>;
+declare function DataVisNitroSource(props: DataVisNitroSourceProps): React__default.JSX.Element;
+declare namespace DataVisNitroSource {
+    var displayName: string;
+}
+declare function DataVisNitroGrid(props: DataVisNitroGridProps): React__default.JSX.Element | null;
+declare namespace DataVisNitroGrid {
+    var displayName: string;
+}
+
+interface DataVisNitroGraphProps {
+    columns?: DataVisNitroColumn[];
+    config?: Partial<GraphConfig>;
+    locale?: string;
+    className?: string;
+    height?: string;
+    onConfigChange?: (config: GraphConfig) => void;
+}
+declare function DataVisNitroGraph(props: DataVisNitroGraphProps): React$1.JSX.Element | null;
+declare namespace DataVisNitroGraph {
+    var displayName: string;
+}
+
+interface LanguageSelectorProps {
+    /** Current locale code (BCP-47, e.g. 'en-US'). */
+    value?: string;
+    /** Called when the user picks a new locale. */
+    onLanguageChange?: (code: string) => void;
+    /** Extra CSS class. */
+    className?: string;
+}
+declare function LanguageSelector({ value, onLanguageChange, className, }: LanguageSelectorProps): React$1.JSX.Element;
+
 interface OrdersGridBaseProps {
     history: PatientHistory;
     /** Program metadata — programs.json contents (`programs` field) */
@@ -61,4 +743,4 @@ declare function OrdersGroupPresets({ presets, className, }: {
     className?: string;
 }): react_jsx_runtime.JSX.Element;
 
-export { ChartOrdersGrid, type ChartOrdersGridProps, EncounterOrdersGrid, type EncounterOrdersGridProps, type GroupPreset, OrdersGroupPresets };
+export { ChartOrdersGrid, type ChartOrdersGridProps, type DataVisNitroAggregate, type DataVisNitroColumn, DataVisNitroContext, DataVisNitroGraph, type DataVisNitroGraphProps, DataVisNitroGrid, type DataVisNitroGridProps, type DataVisNitroGroupField, LanguageSelector as DataVisNitroLanguageSelector, type LanguageSelectorProps as DataVisNitroLanguageSelectorProps, DataVisNitroSource, type DataVisNitroSourceProps, EncounterOrdersGrid, type EncounterOrdersGridProps, type GroupPreset, OrdersGroupPresets };