@dlh.io/bideux 0.1.0

package/dist/react.d.ts

@@ -0,0 +1,1915 @@
+import { F as DashboardModelDiagnostics, V as ModelMarker, L as DashboardSpec, aa as ResponsiveLayouts, c as Breakpoint, ag as WidgetColumn, x as DashboardGridConfig, U as LayoutKey, w as DashboardFilterPanelConfig, i as BuilderDataset, q as BuilderRelationship, n as BuilderModelMetric, h as BuilderDataStore, K as DashboardSectionConfig, ab as ResultTable, t as BuilderWidget, o as BuilderPivot, p as BuilderPivotMeasure } from './result-table-CPls-277.js';
+export { O as FilterControl, Q as FilterModel, R as FilterOption, S as LAYOUT_BREAKPOINT_WIDTHS, am as buildFilterModel, an as cellText, ap as dashboardTabs, as as defaultTabId, at as describeFilter, aw as filterOptions, ax as formatTableCsv, aF as layoutKeyForWidth, aZ as resolveResponsive, a_ as resultColumns, a$ as resultRows, b0 as tabWidgetIds } from './result-table-CPls-277.js';
+import * as react_jsx_runtime from 'react/jsx-runtime';
+import * as react from 'react';
+import { ComponentType, ReactNode, CSSProperties, HTMLAttributes } from 'react';
+import { aw as WidgetSpec, av as WidgetResult, q as PivotDetailResult, an as WidgetInteraction, ao as WidgetInteractionContext, S as RendererContext, c as DrillStackItem, h as KpiRendererModel, aa as TableRendererModel, ac as TableSortState, ax as WidgetTheme, L as LabelBlock } from './types-CHFSsU_X.js';
+import { DefaultRenderersOptions } from './renderers/index.js';
+import 'yaml';
+import './renderers/echarts.js';
+import 'echarts';
+import './renderers/tabulator.js';
+import 'tabulator-tables';
+import './renderers/revogrid.js';
+import '@revolist/revogrid';
+
+/**
+ * The authoring side of the transport seam.
+ *
+ * Same rule as the reader: no fetch, no URL and no host client is written
+ * inside the package, and every call carries the scope it acts on rather than
+ * reading one from an ambient session. Nothing here returns a host database
+ * model: a widget arrives as its YAML text and a preview as plain rows.
+ */
+interface WidgetDocumentRequest {
+    dashboardId: string;
+    widgetId: string;
+    signal?: AbortSignal;
+}
+interface WidgetDocument {
+    widgetId: string;
+    specYaml: string;
+}
+interface WidgetSaveRequest {
+    dashboardId: string;
+    widgetId: string;
+    specYaml: string;
+}
+interface WidgetCreateRequest {
+    dashboardId: string;
+    specYaml: string;
+}
+interface WidgetDeleteRequest {
+    dashboardId: string;
+    widgetId: string;
+}
+interface DashboardDocumentRequest {
+    dashboardId: string;
+    signal?: AbortSignal;
+}
+/** The dashboard document as YAML text, which is all the YAML editor needs. */
+interface DashboardDocument {
+    dashboardId: string;
+    specYaml: string;
+    /** The version stamp the host uses for optimistic concurrency, if it has one. */
+    updatedAt?: string;
+}
+interface DashboardDocumentSaveRequest {
+    dashboardId: string;
+    specYaml: string;
+    expectedUpdatedAt?: string;
+}
+/** Name and description edits made inline on the page header. */
+interface DashboardMetadataSaveRequest {
+    dashboardId: string;
+    name?: string;
+    description?: string;
+}
+interface DashboardCopyRequest {
+    dashboardId: string;
+    name?: string;
+}
+interface DashboardCopyResponse {
+    /** How the host addresses the copy, so the page can navigate to it. */
+    dashboardId: string;
+}
+interface WidgetInventoryRequest {
+    dashboardId: string;
+    signal?: AbortSignal;
+}
+interface WidgetInventoryResponse {
+    widgets: Record<string, WidgetSpec>;
+    /** Widgets belonging to the dashboard that no tab places on its grid. */
+    unplacedWidgetIds: string[];
+}
+interface WidgetDiagnosticsRequest {
+    dashboardId: string;
+    widgetId: string;
+    filters?: Record<string, unknown>;
+    signal?: AbortSignal;
+}
+/** One query a widget ran, as the engine reports it. */
+interface WidgetQueryDiagnostic {
+    kind: string;
+    sql: string;
+    params: Record<string, unknown>;
+    dataStoreId: string | null;
+    filterField: string | null;
+    /** The scope the query was narrowed to, or null when it was not narrowed. */
+    effectiveLocations: string[] | null;
+    note?: string;
+    returnedColumns?: string[];
+    rowCount?: number;
+    cache?: string;
+    cacheTtlSeconds?: number;
+}
+interface WidgetMappingDiagnostic {
+    rowCount: number;
+    availableColumns: string[];
+    mappedFields: Record<string, string>;
+    issues: string[];
+}
+interface WidgetDiagnosticsResponse {
+    widgetId: string;
+    component: string;
+    queries: WidgetQueryDiagnostic[];
+    mapping?: WidgetMappingDiagnostic;
+    notes?: string[];
+    error?: string;
+}
+interface ModelLoadRequest {
+    signal?: AbortSignal;
+}
+interface ModelDocument {
+    specYaml: string;
+    version: number | null;
+    /** False when the caller may read the model but not write it. */
+    editable: boolean;
+}
+interface ModelSaveRequest {
+    specYaml: string;
+    note?: string;
+}
+interface ModelValidateRequest {
+    specYaml: string;
+    signal?: AbortSignal;
+}
+interface ModelVersionSummary {
+    version: number;
+    createdAt: string;
+    sizeBytes: number;
+    datasetCount: number;
+    note: string | null;
+    /** True when this version is exactly what the model says now. */
+    isCurrent: boolean;
+}
+interface ModelVersionRequest {
+    version: number;
+    signal?: AbortSignal;
+}
+interface ModelVersionRestoreRequest {
+    version: number;
+    note?: string;
+}
+/** A warehouse connection the host offers, named without exposing its record. */
+interface DataModelConnection {
+    id: string;
+    label: string;
+    vendor: string | null;
+}
+interface WarehouseColumn {
+    name: string;
+    dataType: string;
+}
+interface WarehouseTable {
+    schemaName: string;
+    tableName: string;
+    tableType: string;
+    columns: WarehouseColumn[];
+}
+interface WarehouseSchemaRequest {
+    connectionId: string | null;
+    signal?: AbortSignal;
+}
+interface DatasetPreviewRequest {
+    /** The model text as it stands in the editor, saved or not. */
+    specYaml: string;
+    datasetId: string;
+    limit: number;
+    columns?: string[];
+    signal?: AbortSignal;
+}
+interface DatasetPreviewResult {
+    columns: string[];
+    rows: Record<string, unknown>[];
+    rowCount: number;
+    /** The scope the preview ran under, or null when it was not narrowed. */
+    effectiveLocations: string[] | null;
+    sql: string | null;
+}
+/** A change an assistant proposes, which an author reads before applying it. */
+interface AuthoringProposal {
+    id: string;
+    summary: string;
+    specYaml: string;
+}
+interface ProposalRequest {
+    dashboardId: string;
+    widgetId: string | null;
+    instruction: string;
+    specYaml: string;
+    signal?: AbortSignal;
+}
+interface ProposalOutcomeRequest {
+    proposalId: string;
+    applied: boolean;
+}
+interface LayoutWidgetRequest {
+    dashboardId: string;
+    widgetId: string;
+}
+interface AuthoringTransport {
+    loadWidgetDocument: (request: WidgetDocumentRequest) => Promise<WidgetDocument>;
+    saveWidget: (request: WidgetSaveRequest) => Promise<void>;
+    createWidget: (request: WidgetCreateRequest) => Promise<WidgetDocument>;
+    deleteWidget: (request: WidgetDeleteRequest) => Promise<void>;
+    listWidgets: (request: WidgetInventoryRequest) => Promise<WidgetInventoryResponse>;
+    diagnoseWidget: (request: WidgetDiagnosticsRequest) => Promise<WidgetDiagnosticsResponse>;
+    loadModel: (request: ModelLoadRequest) => Promise<ModelDocument>;
+    saveModel: (request: ModelSaveRequest) => Promise<ModelDocument>;
+    validateModel: (request: ModelValidateRequest) => Promise<DashboardModelDiagnostics>;
+    listModelVersions: (request: {
+        signal?: AbortSignal;
+    }) => Promise<ModelVersionSummary[]>;
+    loadModelVersion: (request: ModelVersionRequest) => Promise<ModelDocument>;
+    restoreModelVersion: (request: ModelVersionRestoreRequest) => Promise<ModelDocument>;
+    listConnections: (request: {
+        signal?: AbortSignal;
+    }) => Promise<DataModelConnection[]>;
+    listWarehouseTables: (request: WarehouseSchemaRequest) => Promise<WarehouseTable[]>;
+    previewDataset: (request: DatasetPreviewRequest) => Promise<DatasetPreviewResult>;
+    /** Places an existing widget on the dashboard grid. */
+    addWidgetToLayout: (request: LayoutWidgetRequest) => Promise<void>;
+    /** Takes a widget off the grid without deleting the widget itself. */
+    removeWidgetFromLayout: (request: LayoutWidgetRequest) => Promise<void>;
+    /** Optional: the dashboard document itself, for the dashboard YAML editor. */
+    loadDashboardDocument?: (request: DashboardDocumentRequest) => Promise<DashboardDocument>;
+    saveDashboardDocument?: (request: DashboardDocumentSaveRequest) => Promise<DashboardDocument>;
+    /** Optional: inline rename and description edits on the page header. */
+    saveDashboardMetadata?: (request: DashboardMetadataSaveRequest) => Promise<void>;
+    /** Optional: Make a copy. */
+    copyDashboard?: (request: DashboardCopyRequest) => Promise<DashboardCopyResponse>;
+    /** Optional: an assistant that writes a document from a sentence. */
+    proposeDocument?: (request: ProposalRequest) => Promise<AuthoringProposal>;
+    /** Optional: tells the host whether a proposal was kept. */
+    recordProposalOutcome?: (request: ProposalOutcomeRequest) => Promise<void>;
+}
+interface CodeEditorProps {
+    value: string;
+    onChange: (value: string) => void;
+    language: "yaml";
+    readOnly?: boolean | undefined;
+    markers?: ModelMarker[] | undefined;
+    ariaLabel?: string | undefined;
+    className?: string | undefined;
+}
+/**
+ * The editor seam. A host passes Monaco, CodeMirror or anything else, and the
+ * package falls back to a plain textarea, so no editor is bundled here.
+ */
+type CodeEditor = ComponentType<CodeEditorProps>;
+
+/**
+ * Every glyph the reader and builder draw. `defaultIcons` covers them all with
+ * inline SVG; a host maps any subset onto its own icon library and the rest
+ * fall back to the built-in glyphs.
+ */
+type IconName = "activity" | "alert" | "arrowDown" | "arrowLeft" | "arrowUp" | "arrowUpDown" | "building" | "calendar" | "check" | "chevronDown" | "chevronLeft" | "chevronRight" | "close" | "code" | "copy" | "download" | "expand" | "eye" | "filter" | "grip" | "help" | "info" | "layers" | "loader" | "lock" | "minus" | "more" | "plus" | "refresh" | "save" | "search" | "settings" | "share" | "sliders" | "sparkles" | "spreadsheet" | "trash" | "trendDown" | "trendFlat" | "trendUp" | "undo" | "users";
+interface IconProps {
+    className?: string | undefined;
+    title?: string | undefined;
+}
+type IconSet = Record<IconName, ComponentType<IconProps>>;
+interface UiButtonProps {
+    children?: ReactNode;
+    className?: string | undefined;
+    disabled?: boolean | undefined;
+    onClick?: (() => void) | undefined;
+    title?: string | undefined;
+    ariaLabel?: string | undefined;
+    variant?: "primary" | "secondary" | "ghost" | "link" | undefined;
+    size?: "sm" | "md" | undefined;
+    type?: "button" | "submit" | undefined;
+}
+interface UiTooltipProps {
+    label: ReactNode;
+    children: ReactNode;
+    side?: "top" | "bottom" | "left" | "right" | undefined;
+}
+interface UiPopoverProps {
+    open: boolean;
+    onOpenChange: (open: boolean) => void;
+    trigger: ReactNode;
+    children: ReactNode;
+    align?: "start" | "center" | "end" | undefined;
+    className?: string | undefined;
+}
+interface UiModalProps {
+    open: boolean;
+    onOpenChange: (open: boolean) => void;
+    title: ReactNode;
+    description?: ReactNode;
+    /** Replaces the plain title row, for a modal that carries its own navigation. */
+    header?: ReactNode;
+    footer?: ReactNode;
+    children: ReactNode;
+    size?: "md" | "lg" | "xl" | undefined;
+}
+interface UiSelectOption {
+    value: string;
+    label: string;
+    disabled?: boolean | undefined;
+}
+interface UiSelectProps {
+    value: string;
+    options: UiSelectOption[];
+    onChange: (value: string) => void;
+    placeholder?: string | undefined;
+    disabled?: boolean | undefined;
+    ariaLabel?: string | undefined;
+    className?: string | undefined;
+}
+interface UiTextInputProps {
+    value: string;
+    onChange: (value: string) => void;
+    placeholder?: string | undefined;
+    disabled?: boolean | undefined;
+    ariaLabel?: string | undefined;
+    className?: string | undefined;
+    type?: "text" | "number" | "date" | "search" | undefined;
+    onCommit?: (() => void) | undefined;
+}
+interface UiCheckboxProps {
+    checked: boolean;
+    onChange: (checked: boolean) => void;
+    label: ReactNode;
+    disabled?: boolean | undefined;
+    className?: string | undefined;
+}
+interface UiBadgeProps {
+    children: ReactNode;
+    tone?: "neutral" | "info" | "success" | "warning" | "danger" | undefined;
+    className?: string | undefined;
+    title?: string | undefined;
+}
+interface UiSkeletonProps {
+    className?: string | undefined;
+    style?: CSSProperties | undefined;
+}
+interface UiMenuItem {
+    id: string;
+    label: string;
+    icon?: IconName | undefined;
+    disabled?: boolean | undefined;
+    onSelect: () => void;
+}
+interface UiMenuProps {
+    items: UiMenuItem[];
+    trigger: ReactNode;
+    ariaLabel?: string | undefined;
+}
+/**
+ * The design system seam. A host passes its own primitives, so the reader runs
+ * unchanged on shadcn, on Material, or on the plain elements the reference host
+ * uses to prove the package carries no design system of its own.
+ */
+interface UiKit {
+    Badge: ComponentType<UiBadgeProps>;
+    Button: ComponentType<UiButtonProps>;
+    Checkbox: ComponentType<UiCheckboxProps>;
+    Menu: ComponentType<UiMenuProps>;
+    Modal: ComponentType<UiModalProps>;
+    Popover: ComponentType<UiPopoverProps>;
+    Select: ComponentType<UiSelectProps>;
+    Skeleton: ComponentType<UiSkeletonProps>;
+    TextInput: ComponentType<UiTextInputProps>;
+    Tooltip: ComponentType<UiTooltipProps>;
+}
+interface AssetResolver {
+    /** Turns a stored image reference into something an img tag can load. */
+    resolve: (reference: string) => string;
+}
+interface HostLinkProps {
+    href: string;
+    children: ReactNode;
+    className?: string | undefined;
+    target?: "_blank" | "_self" | undefined;
+    onNavigate?: (() => void) | undefined;
+}
+interface HostLinks {
+    Link: ComponentType<HostLinkProps>;
+    /** The route the reader currently sits on, when the host tracks one. */
+    currentHref?: string | undefined;
+    navigate?: (href: string, options?: {
+        newTab?: boolean;
+        params?: Record<string, unknown>;
+    }) => void;
+}
+interface Notice {
+    tone: "info" | "success" | "warning" | "error";
+    message: string;
+    detail?: string;
+}
+type NoticeSink = (notice: Notice) => void;
+interface DashboardRunRequest {
+    dashboardId: string;
+    filters?: Record<string, unknown>;
+    signal?: AbortSignal;
+}
+interface DashboardRunResponse {
+    results: Record<string, WidgetResult>;
+    /** Present when the caller did not already hold the specs, as a drill does. */
+    dashboard: DashboardSpec;
+    widgets: Record<string, WidgetSpec>;
+    name?: string;
+    errors?: Record<string, string>;
+}
+interface WidgetRunRequest {
+    dashboardId: string;
+    widgetId: string;
+    filters?: Record<string, unknown>;
+    signal?: AbortSignal;
+}
+interface WidgetDetailRequest extends WidgetRunRequest {
+    /** The clicked cell, named by the labels the pivot printed. */
+    cell: Record<string, string>;
+    label?: string;
+    limit?: number;
+}
+interface DrillRunRequest {
+    dashboardId: string;
+    widgetId: string;
+    interaction: WidgetInteraction;
+    context: WidgetInteractionContext;
+    filters?: Record<string, unknown>;
+    signal?: AbortSignal;
+}
+interface DrillRunResponse {
+    columns: string[];
+    rows: Record<string, unknown>[];
+    truncated?: boolean;
+}
+interface LayoutSaveRequest {
+    dashboardId: string;
+    /** Positions per breakpoint key (`lg`, `md`, `sm`, `xs`, `xxs`). */
+    layouts: ResponsiveLayouts;
+    /** Row height and column overrides per breakpoint, when the author changed them. */
+    gridOverrides?: Partial<Record<Breakpoint, {
+        rowHeight?: number;
+        cols?: number;
+    }>>;
+    /** Widgets kept off the grid without being deleted. */
+    unplacedWidgetIds?: string[];
+    /** The row limit after any Add rows the author clicked. */
+    maxRows?: number;
+    /** A breakpoint name that caps the dashboard width, or `null` to lift the cap. */
+    maxLayoutWidth?: string | null;
+    /** Dashboard level grid behaviour the author toggled in the Grid popover. */
+    grid?: {
+        isBounded?: boolean;
+        preventCollision?: boolean;
+    };
+    /** The data store widgets query by default, or `null` for the host default. */
+    dataModelId?: string | null;
+    /**
+     * The dashboard's `updatedAt` when editing began. A host that supports
+     * optimistic concurrency rejects the save with `LayoutConflictError` when a
+     * newer version exists.
+     */
+    expectedUpdatedAt?: string;
+    signal?: AbortSignal;
+}
+interface LayoutSaveResponse {
+    /** The dashboard's version stamp after the save, for the next request. */
+    updatedAt?: string;
+}
+/**
+ * Thrown by `saveLayout` when someone else saved first. The reader offers to
+ * overwrite or to reload rather than silently losing either side's work.
+ */
+declare class LayoutConflictError extends Error {
+    readonly conflict = true;
+    constructor(message?: string);
+}
+declare function isLayoutConflict(error: unknown): boolean;
+/**
+ * The only way the reader reaches a server. No fetch, no server action and no
+ * URL is written inside the package.
+ */
+interface DashboardTransport {
+    runDashboard: (request: DashboardRunRequest) => Promise<DashboardRunResponse>;
+    runWidget: (request: WidgetRunRequest) => Promise<WidgetResult>;
+    runWidgetDetail?: (request: WidgetDetailRequest) => Promise<PivotDetailResult>;
+    runDrill?: (request: DrillRunRequest) => Promise<DrillRunResponse>;
+    saveLayout?: (request: LayoutSaveRequest) => Promise<LayoutSaveResponse | void>;
+}
+/**
+ * Structural copy of the lifecycle the browser renderer packages return. It is
+ * declared here rather than imported so the React package keeps its dependency
+ * on the concrete renderers optional and host owned.
+ */
+interface ReaderRenderer {
+    update: (input: RendererMountInput) => void;
+    resize: () => void;
+    destroy: () => void;
+}
+interface RendererMountCallbacks {
+    onInteraction?: (interaction: WidgetInteraction, context: WidgetInteractionContext) => void;
+    onRetry?: () => void;
+    onFilterChange?: (widgetId: string, value: unknown) => void;
+    onFilterLabelChange?: (widgetId: string, label: string) => void;
+    onError?: (error: Error) => void;
+    onPivotDetail?: (payload: PivotDetailPayload) => void;
+    onPivotView?: (widgetId: string, view: Record<string, unknown>) => void;
+    onExport?: (request: RendererExportRequest) => void | Promise<void>;
+}
+/** A CSV or Excel export a concrete renderer's toolbar asked the reader for. */
+interface RendererExportRequest {
+    widgetId: string;
+    format: "csv" | "excel";
+    filename: string;
+}
+/**
+ * A pivot cell a reader asked to see behind, exactly as the concrete pivot
+ * renderer raises it: the cell is named by the dimension labels the pivot
+ * printed, because the labels are all the browser holds.
+ */
+interface PivotDetailPayload {
+    widgetId: string;
+    /** The clicked cell in words, which titles the detail modal. */
+    label: string;
+    filters: Record<string, string>;
+}
+interface RendererMountInput {
+    element: HTMLElement;
+    widget: WidgetSpec;
+    result?: WidgetResult;
+    context?: RendererContext;
+    filterValue?: unknown;
+    callbacks?: RendererMountCallbacks;
+    theme?: Record<string, unknown>;
+}
+type RendererFactory = (input: RendererMountInput) => ReaderRenderer | Promise<ReaderRenderer>;
+/**
+ * Renderer factories keyed by widget component. Hosts wire the phase 8 packages
+ * here: createEChartsRenderer for charts, createTabulatorRenderer for grids,
+ * createRevoGridRenderer for pivots, createNativeWidgetRenderer for the rest.
+ */
+type RendererFactories = Partial<Record<string, RendererFactory>> & {
+    default?: RendererFactory;
+};
+
+/**
+ * The authoring seam, kept separate from the reader context on purpose.
+ *
+ * A reader host wires nothing new to keep reading, and an authoring host adds
+ * one provider. The two nest, so a builder rendered inside a reader still has
+ * the reader's transport for its preview.
+ */
+interface DashboardAuthoringContextValue {
+    transport: AuthoringTransport;
+    ui: UiKit;
+    icons: IconSet;
+    editor: CodeEditor;
+    onNotice: NoticeSink;
+    /** The dashboard every authoring call is scoped to. */
+    dashboardId: string;
+    /** False when the caller may look at the documents but not write them. */
+    canEdit: boolean;
+}
+interface DashboardAuthoringProviderProps {
+    transport: AuthoringTransport;
+    /** Any subset of the kit; the built-in primitives fill the rest. */
+    ui?: Partial<UiKit>;
+    /** Any subset of the glyphs; the built-in SVGs fill the rest. */
+    icons?: Partial<IconSet>;
+    dashboardId: string;
+    editor?: CodeEditor;
+    onNotice?: NoticeSink;
+    canEdit?: boolean;
+    children: ReactNode;
+}
+declare function DashboardAuthoringProvider({ transport, ui, icons, dashboardId, editor, onNotice, canEdit, children, }: DashboardAuthoringProviderProps): react_jsx_runtime.JSX.Element;
+declare function useAuthoring(): DashboardAuthoringContextValue;
+
+interface AutoFitTextProps {
+    children: ReactNode;
+    className?: string;
+    max?: number;
+    min?: number;
+    style?: CSSProperties;
+}
+/**
+ * Shrinks a single line until it fits its box. KPI values are unpredictable in
+ * length and the card must not clip the number it exists to show.
+ */
+declare function AutoFitText({ children, className, max, min, style, }: AutoFitTextProps): react_jsx_runtime.JSX.Element;
+
+interface BreadcrumbItem {
+    label: string;
+    href?: string;
+}
+interface DashboardBreadcrumbProps {
+    items: BreadcrumbItem[];
+    className?: string;
+}
+/** Where the reader is, as links the host renders. */
+declare function DashboardBreadcrumb({ items, className, }: DashboardBreadcrumbProps): react_jsx_runtime.JSX.Element | null;
+
+/** Value a mapping dropdown uses for "leave this unset". */
+declare const UNSET = "__unset__";
+/** The question mark beside a label, for wording that is not self-evident. */
+declare function Info({ text }: {
+    text: string;
+}): react_jsx_runtime.JSX.Element;
+/** A small heading with its own explanation on hover. */
+declare function FieldLabel({ text, help, }: {
+    text: string;
+    help?: string | undefined;
+}): react_jsx_runtime.JSX.Element;
+/** A text field that types like a text field and saves when you leave it. */
+declare function TextField({ label, value, placeholder, hint, help, mono, readOnly, onCommit, }: {
+    label: string;
+    value: string;
+    placeholder: string;
+    hint?: string | undefined;
+    help?: string | undefined;
+    mono?: boolean | undefined;
+    readOnly: boolean;
+    onCommit: (value: string) => void;
+}): react_jsx_runtime.JSX.Element;
+/** An on/off setting, with its own explanation on hover. */
+declare function ToggleField({ label, help, hint, checked, readOnly, onToggle, }: {
+    label: string;
+    help?: string | undefined;
+    hint?: string | undefined;
+    checked: boolean;
+    readOnly: boolean;
+    onToggle: (checked: boolean) => void;
+}): react_jsx_runtime.JSX.Element;
+/** A whole number field that keeps an empty box meaning "the default". */
+declare function NumberField({ label, value, placeholder, hint, help, min, max, readOnly, onCommit, }: {
+    label: string;
+    value: number | null;
+    placeholder: string;
+    hint?: string | undefined;
+    help?: string | undefined;
+    min: number;
+    max: number;
+    readOnly: boolean;
+    onCommit: (value: number | null) => void;
+}): react_jsx_runtime.JSX.Element;
+/** A dropdown that is always ready to use, with no click-to-edit step. */
+declare function ChoiceField({ label, value, options, placeholder, hint, help, readOnly, onPick, }: {
+    label: string;
+    value: string | null;
+    options: {
+        value: string;
+        label: string;
+    }[];
+    placeholder: string;
+    hint?: string | undefined;
+    help?: string | undefined;
+    readOnly: boolean;
+    onPick: (value: string) => void;
+}): react_jsx_runtime.JSX.Element;
+/** A row of choices that commits on one click, with no edit mode in between. */
+declare function PickList<T extends string>({ options, value, readOnly, columns, onPick, }: {
+    options: {
+        id: T;
+        label: string;
+        blurb?: string | undefined;
+    }[];
+    value: T | null;
+    readOnly: boolean;
+    columns?: number;
+    onPick: (id: T) => void;
+}): react_jsx_runtime.JSX.Element;
+declare function ColumnPicker({ title, empty, help, columns, selected, readOnly, onToggle, }: {
+    title: string;
+    empty: string;
+    help?: string | undefined;
+    columns: WidgetColumn[];
+    selected: string[];
+    readOnly: boolean;
+    onToggle: (key: string, checked: boolean) => void;
+}): react_jsx_runtime.JSX.Element;
+/** The YAML a builder panel produces, so the format is learned, not hidden. */
+declare function BuilderYamlStrip({ fragment }: {
+    fragment: string;
+}): react_jsx_runtime.JSX.Element | null;
+/** Keys the builder has no editor for, named rather than silently dropped. */
+declare function PreservedKeysNote({ keys, blocking, }: {
+    keys: string[];
+    blocking?: boolean | undefined;
+}): react_jsx_runtime.JSX.Element | null;
+declare function StepFrame({ anchor, number, title, blurb, help, done, children, }: {
+    anchor: string;
+    number: number;
+    title: string;
+    blurb?: string | undefined;
+    help?: string | undefined;
+    done?: boolean | undefined;
+    children: ReactNode;
+}): react_jsx_runtime.JSX.Element;
+
+/** Per breakpoint overrides an author previews with, before the dashboard saves them. */
+type GridOverrides = Partial<Record<Breakpoint, {
+    rowHeight?: number;
+    cols?: number;
+}>>;
+interface DashboardCanvasProps {
+    dashboard: DashboardSpec;
+    widgets: Record<string, WidgetSpec>;
+    results?: Record<string, WidgetResult>;
+    /** Widget ids the reader is still waiting on, drawn as skeletons. */
+    loadingWidgetIds?: string[];
+    loading?: boolean;
+    className?: string;
+    style?: CSSProperties;
+    /** Overrides the measured width, which is how tests and exports fix a size. */
+    viewportWidth?: number;
+    /** Tiles can be dragged and resized, and carry the edit bar. */
+    editMode?: boolean;
+    /**
+     * Snap on compacts vertically and pushes neighbours aside; snap off places
+     * freely and refuses a drop on top of another tile.
+     */
+    snap?: boolean;
+    /** Positions being edited, in place of the ones the widget specs declare. */
+    draftLayout?: ResponsiveLayouts;
+    gridOverrides?: GridOverrides;
+    /** Grid settings being edited, layered over the dashboard's `config.grid`. */
+    gridConfig?: Pick<DashboardGridConfig, "isBounded" | "preventCollision" | "maxLayoutWidth" | "maxRows">;
+    /** Widgets kept off the grid without being deleted. */
+    unplacedWidgetIds?: string[];
+    widgetActions?: (widget: WidgetSpec) => ReactNode;
+    onLayoutKeyChange?: (key: LayoutKey) => void;
+    onBreakpointChange?: (breakpoint: Breakpoint) => void;
+    /** Every breakpoint after a drag or resize, plus the key that was edited. */
+    onLayoutChange?: (layouts: ResponsiveLayouts, activeKey: LayoutKey) => void;
+    onEditWidget?: (widgetId: string) => void;
+    onAskWidget?: (widgetId: string) => void;
+    onRemoveWidget?: (widgetId: string) => void;
+    onDiagnoseWidget?: (widgetId: string) => void;
+    /** The author asked for more rows; the next value to save as `maxRows`. */
+    onIncreaseMaxRows?: (nextRows: number) => void;
+    onInteraction?: (interaction: WidgetInteraction, context: WidgetInteractionContext) => void;
+    onRetryWidget?: (widgetId: string) => void;
+    /** Rerun one widget, which is what the tile's refresh action asks for. */
+    onRefreshWidget?: (widgetId: string) => void;
+    onPivotDetail?: (payload: PivotDetailPayload) => void;
+}
+/**
+ * The dashboard grid, read or edited.
+ *
+ * Positions come from the same layout maths the builder saves, drawn by
+ * react-grid-layout so that a tile reads and drags at the same pixel. Reading
+ * stacks phones into one column; editing keeps the authored grid because an
+ * author dragging tiles has to see the positions that will be saved.
+ */
+declare function DashboardCanvas({ dashboard, widgets, results, loadingWidgetIds, loading, className, style, viewportWidth, editMode, snap, draftLayout, gridOverrides, gridConfig: gridConfigDraft, unplacedWidgetIds, widgetActions, onLayoutKeyChange, onBreakpointChange, onLayoutChange, onEditWidget, onAskWidget, onRemoveWidget, onDiagnoseWidget, onIncreaseMaxRows, onInteraction, onRetryWidget, onRefreshWidget, onPivotDetail, }: DashboardCanvasProps): react_jsx_runtime.JSX.Element;
+
+declare function cn(...values: (string | false | null | undefined)[]): string | undefined;
+
+/**
+ * The editor a host gets when it passes none.
+ *
+ * Monaco is what the origin application uses, and it is a megabyte of host choice, so the
+ * package ships a textarea that behaves correctly instead: the text edits, and
+ * the markers that Monaco would underline are listed under it with their line
+ * numbers, which keeps the diagnostics readable without an editor library.
+ */
+declare function PlainCodeEditor({ value, onChange, readOnly, markers, ariaLabel, className, }: CodeEditorProps): react_jsx_runtime.JSX.Element;
+
+interface DashboardReaderContextValue {
+    transport: DashboardTransport;
+    ui: UiKit;
+    icons: IconSet;
+    assets: AssetResolver;
+    links: HostLinks;
+    renderers: RendererFactories;
+    onNotice: NoticeSink;
+    /** Capture mode drops hover chrome so exporters photograph a clean canvas. */
+    capture: boolean;
+    embedded: boolean;
+    reducedMotion: boolean;
+}
+interface DashboardReaderProviderProps {
+    transport: DashboardTransport;
+    /** Any subset of the kit; the built-in primitives fill the rest. */
+    ui?: Partial<UiKit>;
+    /** Any subset of the glyphs; the built-in SVGs fill the rest. */
+    icons?: Partial<IconSet>;
+    assets?: AssetResolver;
+    links?: HostLinks;
+    renderers?: RendererFactories;
+    onNotice?: NoticeSink;
+    capture?: boolean;
+    embedded?: boolean;
+    reducedMotion?: boolean;
+    children: ReactNode;
+}
+declare function DashboardReaderProvider({ transport, ui, icons, assets, links, renderers, onNotice, capture, embedded, reducedMotion, children, }: DashboardReaderProviderProps): react_jsx_runtime.JSX.Element;
+declare function useDashboardReader(): DashboardReaderContextValue;
+declare function useUiKit(): UiKit;
+declare function useIcons(): IconSet;
+
+interface DashboardYamlEditorProps {
+    open: boolean;
+    onOpenChange: (open: boolean) => void;
+    /** Runs after a successful save so the page can redraw in place. */
+    onSaved: () => void | Promise<void>;
+}
+/**
+ * The whole dashboard document as text: pages, widget order, grid and filter
+ * panel settings. Widgets keep their own editor, so the refs listed here are
+ * checked against the inventory but their bodies are not shown.
+ *
+ * Appears only when the host wired `loadDashboardDocument` and
+ * `saveDashboardDocument`.
+ */
+declare function DashboardYamlEditor({ open, onOpenChange, onSaved, }: DashboardYamlEditorProps): react_jsx_runtime.JSX.Element;
+
+/**
+ * Add a column to a hand-written expression without needing a cursor.
+ *
+ * The inline field has no caret to insert at, so the rule is stated in the UI:
+ * an empty expression becomes an aggregation of the column, and anything else
+ * gets the column appended where an operator or bracket left off.
+ */
+declare function appendColumn(expression: string, column: string): string;
+interface DatasetBuilderPanelProps {
+    specYaml: string;
+    onChange: (specYaml: string) => void;
+    readOnly: boolean;
+    connections: DataModelConnection[];
+    /** False while the connection list is still in flight. */
+    connectionsReady: boolean;
+    onEditInYaml: () => void;
+}
+/**
+ * One named source of rows plus the fields widgets may ask for.
+ *
+ * A dataset the builder has no form for is shown rather than edited, because
+ * rewriting a document whose keys are not understood is how an author loses
+ * work. Everything unsupported is named, never dropped.
+ */
+declare function DatasetBuilderPanel({ specYaml, onChange, readOnly, connections, connectionsReady, onEditInYaml, }: DatasetBuilderPanelProps): react_jsx_runtime.JSX.Element;
+
+interface DrilldownModalProps {
+    dashboardId: string;
+    dashboardName: string;
+    initialFilters?: Record<string, unknown>;
+    parentStack?: DrillStackItem[];
+    open: boolean;
+    onOpenChange: (open: boolean) => void;
+}
+/**
+ * A dashboard opened from a widget, in a modal, with a stack behind it.
+ *
+ * Where the frozen reader called a server action and read `window.location`,
+ * this asks the injected transport and the injected links, so the same modal
+ * works under any router.
+ */
+declare function DrilldownModal({ dashboardId, dashboardName, initialFilters, parentStack, open, onOpenChange, }: DrilldownModalProps): react_jsx_runtime.JSX.Element;
+
+interface DashboardFilterBarProps {
+    className?: string;
+    onRefresh?: () => void;
+    refreshing?: boolean;
+}
+/** The one line summary of what the reader is currently looking at. */
+declare function DashboardFilterBar({ className, onRefresh, refreshing, }: DashboardFilterBarProps): react_jsx_runtime.JSX.Element;
+
+interface DashboardFilterPanelProps {
+    widgets: WidgetSpec[];
+    config: DashboardFilterPanelConfig;
+    results?: Record<string, WidgetResult>;
+    className?: string;
+    style?: CSSProperties;
+    /**
+     * Draw the panel across the top or down the side regardless of the configured
+     * position, which is how a side panel folds above the grid on a phone.
+     */
+    orientation?: "horizontal" | "vertical";
+}
+declare function DashboardFilterPanel({ widgets, config, results, className, style, orientation, }: DashboardFilterPanelProps): react_jsx_runtime.JSX.Element | null;
+
+interface FilterWidgetProps {
+    widget: WidgetSpec;
+    result?: WidgetResult;
+    value?: unknown;
+    onChange: (widgetId: string, value: unknown, label: string) => void;
+    /**
+     * Receives the human readable summary of the value currently shown,
+     * including the default before anyone touches the control, so a heading
+     * that reads `{{filter:...}}` says "All" or "last 90 days" from the first
+     * paint rather than after the first change.
+     */
+    onLabel?: (widgetId: string, label: string) => void;
+    className?: string;
+    disabled?: boolean;
+}
+/**
+ * One filter control, driven by the dashboard filter state rather than by any
+ * store of its own. Every change leaves through onChange with the label the
+ * filter bar shows, exactly as the frozen reader does.
+ */
+declare function FilterWidget({ widget, result, value, onChange, onLabel, className, disabled, }: FilterWidgetProps): react_jsx_runtime.JSX.Element;
+
+interface DashboardFiltersValue {
+    filters: Record<string, unknown>;
+    setFilter: (id: string, value: unknown) => void;
+    /**
+     * What each control is showing for its current value, keyed by filter id. A
+     * location filter sends a key and displays a name, and written content that
+     * echoes the selection needs the name.
+     */
+    labels: Record<string, string>;
+    setFilterLabel: (id: string, label: string) => void;
+    clearFilters: () => void;
+}
+interface DashboardFiltersProviderProps {
+    children: ReactNode;
+    filters?: Record<string, unknown>;
+    setFilter?: (id: string, value: unknown) => void;
+    onFilterChange?: (id: string, value: unknown) => void;
+    initialFilters?: Record<string, unknown>;
+}
+declare function DashboardFiltersProvider({ children, filters: controlledFilters, setFilter: controlledSetFilter, onFilterChange, initialFilters, }: DashboardFiltersProviderProps): react_jsx_runtime.JSX.Element;
+declare function useDashboardFilters(): DashboardFiltersValue;
+
+interface LayoutDraftDocuments {
+    dashboard: DashboardSpec;
+    widgets: Record<string, WidgetSpec>;
+    /** Widgets the saved documents keep off the grid. */
+    unplacedWidgetIds: string[];
+    /** The saved version stamp, sent back as `expectedUpdatedAt`. */
+    updatedAt?: string;
+}
+interface UseLayoutDraftOptions {
+    dashboardId: string;
+    /** The documents as last loaded, or null before the first load. */
+    documents: LayoutDraftDocuments | null;
+    saveLayout?: (request: LayoutSaveRequest) => Promise<LayoutSaveResponse | void>;
+    /**
+     * Where an unsaved draft survives a reload. Pass null to keep drafts in
+     * memory only. Hosts usually pass `window.localStorage`.
+     */
+    storage?: Pick<Storage, "getItem" | "setItem" | "removeItem"> | null;
+    /** Runs after a successful save so the page can redraw from the server. */
+    onSaved?: () => void | Promise<void>;
+    onError?: (message: string) => void;
+}
+/**
+ * The dashboard level grid settings the Grid popover edits: they live in
+ * `spec.config.grid` (and `spec.config.dataModelId`) rather than per
+ * breakpoint, and reach the server with Save layout like everything else.
+ */
+interface LayoutGridConfigDraft {
+    isBounded?: boolean;
+    preventCollision?: boolean;
+    /** `null` clears a cap the dashboard had. */
+    maxLayoutWidth?: Breakpoint | null;
+    /** `null` returns to the host's default store. */
+    dataModelId?: string | null;
+}
+type LayoutExitTarget = "edit" | "back";
+interface LayoutDraft {
+    editMode: boolean;
+    /** Turns editing on, or asks about unsaved work before turning it off. */
+    setEditMode: (next: boolean) => void;
+    /** Leaves the page, or asks about unsaved work first. */
+    requestExit: (leave: () => void) => void;
+    draftLayout: ResponsiveLayouts | undefined;
+    draftMaxRows: number | undefined;
+    gridOverrides: GridOverrides;
+    /** Dashboard level grid settings changed since the last save. */
+    gridConfig: LayoutGridConfigDraft;
+    unplacedWidgetIds: string[];
+    activeLayoutKey: LayoutKey;
+    setActiveLayoutKey: (key: LayoutKey) => void;
+    hasUnsavedChanges: boolean;
+    saving: boolean;
+    onLayoutChange: (layouts: ResponsiveLayouts, activeKey: LayoutKey) => void;
+    onIncreaseMaxRows: (nextRows: number) => void;
+    setGridOverride: (breakpoint: Breakpoint, override: {
+        rowHeight?: number;
+        cols?: number;
+    }) => void;
+    setGridConfig: (update: LayoutGridConfigDraft) => void;
+    /** Keeps a widget in the draft but off the grid until the next save. */
+    removeFromGrid: (widgetId: string) => void;
+    /** Puts a widget the saved documents left unplaced back on the draft grid. */
+    placeOnGrid: (widgetId: string) => void;
+    save: (options?: {
+        force?: boolean;
+    }) => Promise<boolean>;
+    reset: () => void;
+    /** Set while the host should show the unsaved changes dialog. */
+    unsavedDialogOpen: boolean;
+    saveAndExit: () => void;
+    discardAndExit: () => void;
+    keepEditing: () => void;
+    /** Set while the host should show the conflict dialog. */
+    conflictDialogOpen: boolean;
+    overwriteAfterConflict: () => void;
+    reloadAfterConflict: () => void;
+}
+/**
+ * The lifecycle behind Edit mode: the draft the grid edits, Save layout, Reset
+ * layout, the unsaved changes dialog on exit and the conflict dialog when
+ * someone else saved first. Nothing here draws; a host composes its own
+ * toolbar and dialogs around the flags.
+ */
+declare function useLayoutDraft({ dashboardId, documents, saveLayout, storage, onSaved, onError, }: UseLayoutDraftOptions): LayoutDraft;
+
+/** A data store the author can point the dashboard at. */
+interface GridSettingsDataStore {
+    id: string;
+    name: string;
+    vendor?: string | undefined;
+}
+interface GridSettingsPanelProps {
+    dashboard: DashboardSpec;
+    /** The breakpoint the canvas is showing, whose columns and row height are edited. */
+    breakpoint: Breakpoint;
+    draft: Pick<LayoutDraft, "gridOverrides" | "gridConfig" | "setGridOverride" | "setGridConfig">;
+    /**
+     * Stores the Data store select offers. Leave undefined to hide the select,
+     * which is right for a host with a single store.
+     */
+    dataStores?: GridSettingsDataStore[] | undefined;
+    className?: string | undefined;
+}
+/** The cell sizes the origin application offers, as columns per row. */
+declare const CELL_SIZE_OPTIONS: ReadonlyArray<{
+    label: string;
+    cols: number;
+}>;
+/**
+ * The body of the Grid popover: data store, row height, columns, cell size,
+ * bounded drag, prevent collision and max layout width, wired to the layout
+ * draft so every change waits for Save layout. Drawn with the authoring
+ * provider's primitives; the host supplies the popover and the button that
+ * opens it.
+ */
+declare function GridSettingsPanel({ dashboard, breakpoint, draft, dataStores, className, }: GridSettingsPanelProps): react_jsx_runtime.JSX.Element;
+
+interface InlineTextProps {
+    label: string;
+    value: string | null;
+    /** What the field says when it holds nothing, for example "Set a label". */
+    empty: string;
+    placeholder?: string | undefined;
+    hint?: string | undefined;
+    readOnly?: boolean | undefined;
+    mono?: boolean | undefined;
+    /**
+     * Opens straight into the input, for a thing the author just created: reading
+     * a field that has never held anything is not worth a click.
+     */
+    startOpen?: boolean | undefined;
+    onCommit: (value: string) => void;
+}
+declare function InlineText({ label, value, empty, placeholder, hint, readOnly, mono, startOpen, onCommit, }: InlineTextProps): react_jsx_runtime.JSX.Element;
+interface InlineOption {
+    value: string;
+    label: string;
+}
+interface InlineSelectProps {
+    label: string;
+    value: string | null;
+    options: InlineOption[];
+    empty: string;
+    hint?: string | undefined;
+    readOnly?: boolean | undefined;
+    onCommit: (value: string) => void;
+}
+declare function InlineSelect({ label, value, options, empty, hint, readOnly, onCommit, }: InlineSelectProps): react_jsx_runtime.JSX.Element;
+
+interface KpiCardProps {
+    model: KpiRendererModel;
+    className?: string;
+    /** Fires when the card is clicked and the widget declares a click interaction. */
+    onClick?: (() => void) | undefined;
+}
+declare function KpiCard({ model, className, onClick }: KpiCardProps): react_jsx_runtime.JSX.Element;
+
+interface LayoutDraftDialogsProps {
+    draft: Pick<LayoutDraft, "unsavedDialogOpen" | "saveAndExit" | "discardAndExit" | "keepEditing" | "conflictDialogOpen" | "overwriteAfterConflict" | "reloadAfterConflict" | "saving">;
+}
+/**
+ * The two questions Edit mode asks on the way out: keep or drop unsaved
+ * changes, and overwrite or reload when someone else saved first. Drawn with
+ * the host's modal so they look like every other dialog on the page.
+ */
+declare function LayoutDraftDialogs({ draft }: LayoutDraftDialogsProps): react_jsx_runtime.JSX.Element;
+
+interface MetricBuilderPanelProps {
+    specYaml: string;
+    onChange: (specYaml: string) => void;
+    readOnly: boolean;
+    datasets: BuilderDataset[];
+    relationships: BuilderRelationship[];
+    metrics: BuilderModelMetric[];
+    onEditInYaml: () => void;
+}
+/**
+ * Metrics that span datasets, such as labor cost over net sales.
+ *
+ * A ratio is offered as two pickers rather than as SQL, because the two ways a
+ * ratio goes wrong are both structural: dividing by zero, and asking the
+ * warehouse for percentage points when the card multiplies by 100 itself.
+ */
+declare function MetricBuilderPanel({ specYaml, onChange, readOnly, datasets, relationships, metrics, onEditInYaml, }: MetricBuilderPanelProps): react_jsx_runtime.JSX.Element;
+
+type ModelLayer = "data_stores" | "datasets" | "relationships" | "metrics";
+interface ModelBuilderProps {
+    specYaml: string;
+    onChange: (specYaml: string) => void;
+    readOnly: boolean;
+    /** Sends the author to the YAML tab for anything the builder cannot edit. */
+    onEditInYaml: () => void;
+}
+/**
+ * The semantic model in four layers, each of which can only break the next.
+ *
+ * The rail carries counts and a badge for anything already broken, because a
+ * dataset with no location column or a join that cannot resolve is exactly what
+ * makes a widget error later, and it should be visible without pressing
+ * anything.
+ */
+declare function ModelBuilder({ specYaml, onChange, readOnly, onEditInYaml, }: ModelBuilderProps): react_jsx_runtime.JSX.Element;
+
+type ModelEditorMode = "builder" | "yaml";
+declare const DEFAULT_MODEL_YAML = "# Shared semantic model\n# Reusable data stores, datasets, relationships, and metrics.\n# Dashboards reference it with spec.semantic_model_ref: default.\nversion: \"1.0\"\nkind: semantic_model\nname: default\ndata_stores: []\ndatasets: []\nrelationships: []\nmetrics: []\n";
+declare function modelIssueLines(diagnostics: DashboardModelDiagnostics): string[];
+declare function modelNoteLines(diagnostics: DashboardModelDiagnostics): string[];
+interface ModelEditorProps {
+    open: boolean;
+    onOpenChange: (open: boolean) => void;
+    onSaved?: (() => void | Promise<void>) | undefined;
+}
+/**
+ * The semantic model, edited as a form or as text, on one document.
+ *
+ * Builder and YAML edit the same string, so switching keeps comments and
+ * anything the builder does not show. A save validates first, because saving a
+ * broken model breaks every dashboard that reads it, and the second click saves
+ * anyway so deliberate work in progress is not trapped behind a checker.
+ */
+declare function ModelEditor({ open, onOpenChange, onSaved }: ModelEditorProps): react_jsx_runtime.JSX.Element;
+
+/**
+ * Labels for the model history list.
+ *
+ * A row has to answer "is this the one I want" without opening it, so it carries
+ * when it was replaced, how big it was, how many datasets it declared, and any
+ * note the host recorded with it.
+ */
+interface VersionRowLabel {
+    title: string;
+    detail: string;
+}
+/** Relative age, coarse on purpose: a version list is scanned, not measured. */
+declare function formatAge(iso: string, now?: Date): string;
+declare function versionRowLabel(version: ModelVersionSummary, now?: Date): VersionRowLabel;
+
+interface PivotDetailModalProps {
+    open: boolean;
+    onOpenChange: (open: boolean) => void;
+    /** The clicked cell, in words: its row path and column values. */
+    cellLabel: string;
+    loading: boolean;
+    error: string | null;
+    result: PivotDetailResult | null;
+}
+/**
+ * The rows behind one pivot cell, as a plain list.
+ *
+ * The pivot shows an aggregate; this shows what it aggregated, under the same
+ * dashboard filters. The server caps the list, and the cap is said out loud
+ * rather than passing a partial list off as the whole answer.
+ */
+declare function PivotDetailModal({ open, onOpenChange, cellLabel, loading, error, result, }: PivotDetailModalProps): react_jsx_runtime.JSX.Element;
+
+interface DashboardReaderProps {
+    dashboard: DashboardSpec;
+    /** How the host addresses this dashboard, when that is not the document id. */
+    dashboardId?: string;
+    widgets: Record<string, WidgetSpec>;
+    results?: Record<string, WidgetResult>;
+    /** Results the host already has, so the reader draws before it runs. */
+    initialResults?: Record<string, WidgetResult>;
+    /** Filters the host has already applied, for a controlled reader. */
+    filters?: Record<string, unknown>;
+    onFiltersChange?: (filters: Record<string, unknown>) => void;
+    loading?: boolean;
+    /** Rerun the dashboard through the transport when a filter changes. */
+    autoRun?: boolean;
+    header?: ReactNode;
+    className?: string;
+    /** Overrides the measured width, for exports and for tests. */
+    viewportWidth?: number;
+    /**
+     * Edit mode and its callbacks, handed straight to the canvas. The reader
+     * keeps its filters and results while these change, so entering edit mode
+     * or dragging a tile never reruns a query.
+     */
+    canvas?: DashboardCanvasEditProps;
+    /** Hide the reader's own refresh bar when the host toolbar carries one. */
+    showFilterBar?: boolean;
+    /** Which tab is open, for a host that wants to drive or remember it. */
+    activeTab?: string;
+    onActiveTabChange?: (tabId: string) => void;
+    /** Fires with every dashboard run, so a host can mirror a busy state. */
+    onRunningChange?: (running: boolean) => void;
+}
+type DashboardCanvasEditProps = Pick<DashboardCanvasProps, "editMode" | "snap" | "draftLayout" | "gridOverrides" | "gridConfig" | "unplacedWidgetIds" | "onLayoutChange" | "onBreakpointChange" | "onLayoutKeyChange" | "onEditWidget" | "onAskWidget" | "onRemoveWidget" | "onDiagnoseWidget" | "onIncreaseMaxRows">;
+/**
+ * A saved dashboard, read. Filters, tiles, drill and pivot detail, over the
+ * transport and the design system the host injected.
+ */
+declare function DashboardReader({ dashboard, dashboardId, widgets, results: providedResults, initialResults, filters: controlledFilters, onFiltersChange, loading: providedLoading, autoRun, header, className, viewportWidth, canvas, showFilterBar, activeTab: controlledTab, onActiveTabChange, onRunningChange, }: DashboardReaderProps): react_jsx_runtime.JSX.Element;
+
+interface LoadedDashboard {
+    dashboard: DashboardSpec;
+    widgets: Record<string, WidgetSpec>;
+    results: Record<string, WidgetResult>;
+}
+interface DashboardReaderLoaderProps extends Pick<DashboardReaderProps, "canvas" | "showFilterBar" | "activeTab" | "onActiveTabChange" | "onRunningChange"> {
+    dashboardId: string;
+    filters?: Record<string, unknown>;
+    /** Fires as the reader's filters change, so a host can mirror them in its URL or exports. */
+    onFiltersChange?: (filters: Record<string, unknown>) => void;
+    header?: ReactNode;
+    className?: string;
+    viewportWidth?: number;
+    /**
+     * Bump to fetch the documents and results again without unmounting the
+     * reader, which is how a host redraws after saving a widget or a layout.
+     * The current filters, tab and scroll position all survive.
+     */
+    reloadToken?: number;
+    /** The documents once they are known, and again after every reload. */
+    onLoaded?: (loaded: LoadedDashboard) => void;
+}
+/**
+ * A reader for a host that holds an identifier rather than the documents. The
+ * transport answers with both the documents and the first results, so a host
+ * needs no loader of its own.
+ */
+declare function DashboardReaderLoader({ dashboardId, filters, onFiltersChange, header, className, viewportWidth, reloadToken, onLoaded, canvas, showFilterBar, activeTab, onActiveTabChange, onRunningChange, }: DashboardReaderLoaderProps): react_jsx_runtime.JSX.Element;
+
+/** Columns of a dataset worth joining on: what it declares it can read. */
+declare function joinableColumns(dataset: BuilderDataset | undefined): string[];
+interface RelationshipBuilderPanelProps {
+    specYaml: string;
+    onChange: (specYaml: string) => void;
+    readOnly: boolean;
+    datasets: BuilderDataset[];
+    stores: BuilderDataStore[];
+    relationships: BuilderRelationship[];
+    onEditInYaml: () => void;
+}
+/**
+ * How two datasets line up.
+ *
+ * A widget that asks for columns from both makes the engine build this join, so
+ * nothing here needs SQL. What it does need is honesty about cardinality: a
+ * join that fans out repeats the left row and double counts its totals.
+ */
+declare function RelationshipBuilderPanel({ specYaml, onChange, readOnly, datasets, stores, relationships, onEditInYaml, }: RelationshipBuilderPanelProps): react_jsx_runtime.JSX.Element;
+
+interface RendererMountProps {
+    factory: RendererFactory;
+    input: Omit<RendererMountInput, "element">;
+    className?: string;
+    style?: React.CSSProperties;
+}
+/**
+ * Mounts one of the framework neutral renderers into a div and drives its
+ * lifecycle from React: create once, update on new input, resize with the
+ * element, destroy on unmount. The chart, grid and pivot behaviour stays in the
+ * renderer packages and is never rebuilt here.
+ */
+declare function RendererMount({ factory, input, className, style, }: RendererMountProps): react_jsx_runtime.JSX.Element;
+
+interface DashboardSectionProps {
+    section: DashboardSectionConfig;
+    results?: Record<string, WidgetResult>;
+    className?: string;
+    style?: CSSProperties;
+}
+/** The dashboard header and footer strips, which hold content, not data tiles. */
+declare function DashboardSection({ section, results, className, style, }: DashboardSectionProps): react_jsx_runtime.JSX.Element | null;
+
+type StyleValue = string | number | boolean | null | undefined;
+/**
+ * Build a style object from generated spec values.
+ *
+ * The generated document types carry `null` for an unset value and name their
+ * property types loosely, so the values are narrowed here once rather than cast
+ * at every call site.
+ */
+declare function cssProps(values: Record<string, StyleValue>): CSSProperties;
+declare function present<T>(value: T | null | undefined): T | undefined;
+
+/**
+ * Ease a KPI number from its previous value to the new one.
+ *
+ * A card that snaps from 12,400 to 9,100 gives no sign that anything happened,
+ * which matters most on the widget people look at first. The first value and
+ * any non-finite value land immediately, and the whole thing is skipped when
+ * the host asked for reduced motion or is capturing a still image.
+ */
+declare function useCountUp(target: number | undefined, duration?: number): number | undefined;
+
+type TableExportFormat = "csv" | "excel";
+interface TableExportRequest {
+    format: TableExportFormat;
+    table: ResultTable;
+    /** File name without extension, from the widget's export settings. */
+    filename: string;
+}
+/**
+ * Hosts that want Excel, or that route downloads through their own storage,
+ * implement this. The reader handles CSV itself when no exporter is given.
+ */
+type TableExporter = (request: TableExportRequest) => void;
+/** Save a UTF-8 CSV of the table through the browser's download flow. */
+declare function downloadTableCsv(table: ResultTable, filename: string): void;
+
+interface TableViewProps {
+    model: TableRendererModel;
+    onSortChange?: (sort: TableSortState | null) => void;
+    onPageChange?: (page: number) => void;
+    onRowClick?: (row: Record<string, unknown>) => void;
+    /** Export buttons and the like, drawn above the grid when no header carries them. */
+    toolbar?: ReactNode;
+    className?: string;
+}
+/**
+ * The plain table the reader draws itself. Grid engines (Tabulator, RevoGrid)
+ * arrive as renderer factories instead, so nothing here reimplements them.
+ */
+declare function TableView({ model, onSortChange, onPageChange, onRowClick, toolbar, className, }: TableViewProps): react_jsx_runtime.JSX.Element;
+
+interface WidgetActionsProps {
+    widget: WidgetSpec;
+    result?: WidgetResult;
+    /** Filter widget id to its name, so an applied filter reads as its label. */
+    filterNames?: Record<string, string>;
+    /** Rerun this widget alone, through the host transport. */
+    onRefresh?: () => void;
+    className?: string;
+}
+/**
+ * Reader actions on the card: what the query answered, that answer as a table,
+ * and that table on the clipboard. Editing, asking and removing belong to the
+ * builder and are absent here.
+ */
+declare function WidgetActions({ widget, result, filterNames, onRefresh, className, }: WidgetActionsProps): react_jsx_runtime.JSX.Element | null;
+
+interface WidgetAskPanelProps {
+    widgetId: string | null;
+    /** The text in the editor, which is what the proposal is asked to change. */
+    specYaml: string;
+    unsaved: boolean;
+    onApply: (specYaml: string, proposalId: string) => void;
+    onBuildByHand: () => void;
+}
+/**
+ * Describe the widget in a sentence and read what comes back before keeping it.
+ *
+ * The assistant itself is the host's: this panel only calls the proposal port,
+ * shows the document it returns, and hands the text to the editor when the
+ * author applies it. Nothing is written until the author saves, so a proposal
+ * is a suggestion rather than an edit.
+ */
+declare function WidgetAskPanel({ widgetId, specYaml, unsaved, onApply, onBuildByHand, }: WidgetAskPanelProps): react_jsx_runtime.JSX.Element;
+
+interface WidgetBuilderProps {
+    specYaml: string;
+    onChange: (specYaml: string) => void;
+    readOnly: boolean;
+    /** Sends the author to the YAML tab for anything the builder cannot edit. */
+    onEditInYaml: () => void;
+}
+/**
+ * Build a widget by clicking, with the YAML still authoritative.
+ *
+ * The panel is a sequence of steps rather than a form, because the order is
+ * what makes the result safe: a mapping can only name a column the widget
+ * selects, and a column can only be one the chosen dataset can answer. That is
+ * the blank chart removed at the source rather than diagnosed after the fact.
+ */
+declare function WidgetBuilder({ specYaml, onChange, readOnly, onEditInYaml, }: WidgetBuilderProps): react_jsx_runtime.JSX.Element;
+
+/**
+ * The edits the widget builder makes, as plain functions on a document object.
+ *
+ * They live apart from the panel because they are where the correctness is: a
+ * mapping that names a column the query does not return is exactly what draws
+ * an empty card, so dropping a column has to drop everything pointing at it.
+ */
+declare function toggleColumn(widget: BuilderWidget, key: string, checked: boolean): BuilderWidget;
+declare function setMapping(widget: BuilderWidget, slot: keyof BuilderWidget["mappings"], value: string): BuilderWidget;
+/**
+ * The axis column, written to both `x` and `category`.
+ *
+ * A chart with named series groups its points by `category`, and one without
+ * them lays them out along `x`. Setting only one is how a chart ends up drawing
+ * against a column the author never picked.
+ */
+declare function setAxis(widget: BuilderWidget, value: string): BuilderWidget;
+/** A dataset change clears what belonged to the old dataset. */
+declare function setDataset(widget: BuilderWidget, datasetId: string): BuilderWidget;
+declare function addSeries(widget: BuilderWidget, field: string): BuilderWidget;
+declare function updateSeries(widget: BuilderWidget, index: number, entry: BuilderWidget["series"][number]): BuilderWidget;
+declare function removeSeries(widget: BuilderWidget, index: number): BuilderWidget;
+/** The first selected measure no series covers yet. */
+declare function nextSeriesField(widget: BuilderWidget, numbers: WidgetColumn[]): string | null;
+declare function addMeasure(pivot: BuilderPivot, field: string): BuilderPivot;
+declare function updateMeasure(pivot: BuilderPivot, index: number, measure: BuilderPivotMeasure): BuilderPivot;
+declare function removeMeasure(pivot: BuilderPivot, index: number): BuilderPivot;
+declare function isMapped(widget: BuilderWidget, column: string): boolean;
+declare const STEP_TITLES: string[];
+interface StepState {
+    identity: {
+        id: string;
+        name: string | null;
+        component: string;
+    };
+    widget: BuilderWidget | null;
+    issues: string[];
+}
+/** Which of the seven steps read as done, in the order the strip shows them. */
+declare function builderStepsDone({ identity, widget, issues, }: StepState): boolean[];
+
+interface WidgetDiagnosticsProps {
+    widgetId: string | null;
+    filters?: Record<string, unknown> | undefined;
+    open: boolean;
+    onOpenChange: (open: boolean) => void;
+}
+/**
+ * What a widget actually asked the warehouse, in the author's own words.
+ *
+ * This is the answer to "why is this card empty": the SQL, the scope it was
+ * narrowed to, the columns that came back, and which of them the mappings
+ * found. The port returns rows and text, never a host record.
+ */
+declare function WidgetDiagnostics({ widgetId, filters, open, onOpenChange, }: WidgetDiagnosticsProps): react_jsx_runtime.JSX.Element;
+
+declare function frameStyle(theme: WidgetTheme): CSSProperties;
+/** Height of the edit bar drawn over the top of the card while the grid is editable. */
+declare const EDIT_BAR_HEIGHT = 28;
+interface WidgetFrameProps extends HTMLAttributes<HTMLDivElement> {
+    widget: WidgetSpec;
+    /** Reader actions for this card, revealed on hover. Absent while editing. */
+    actions?: ReactNode;
+    theme?: WidgetTheme;
+    /** Draws the drag bar and the edit buttons over the card. */
+    editMode?: boolean;
+    onEdit?: (widgetId: string) => void;
+    onRemove?: (widgetId: string) => void;
+    onDiagnose?: (widgetId: string) => void;
+    /** Opens the editor straight on the assistant. Absent where asking makes no sense. */
+    onAsk?: (widgetId: string) => void;
+}
+/**
+ * The widget card. In the reader it is a plain themed box with hover actions;
+ * in edit mode it also carries the origin application's drag bar (`.custom-drag-handle`)
+ * with the widget name and the diagnostics, AI, properties and remove buttons,
+ * whose class names match the dashboard's `draggableHandle` and
+ * `draggableCancel` selectors.
+ */
+declare const WidgetFrame: react.ForwardRefExoticComponent<WidgetFrameProps & react.RefAttributes<HTMLDivElement>>;
+
+interface WidgetHeaderProps {
+    widget: WidgetSpec;
+    className?: string;
+    actions?: ReactNode;
+}
+declare function WidgetHeader({ widget, className, actions, }: WidgetHeaderProps): react_jsx_runtime.JSX.Element | null;
+
+interface WidgetInventoryProps {
+    widgets: Record<string, WidgetSpec>;
+    unplacedWidgetIds: string[];
+    open: boolean;
+    onOpenChange: (open: boolean) => void;
+    onEdit: (widgetId: string) => void;
+    onAdd: (widgetId: string) => void;
+    onRemove: (widgetId: string) => void;
+    onDelete: (widgetId: string) => Promise<void>;
+    onCreated: (widgetId: string) => void | Promise<void>;
+    /** Opens the assistant, which writes the whole widget instead of a blank one. */
+    onCreateWithAssistant?: (() => void) | undefined;
+    onEditWithAssistant?: ((widgetId: string) => void) | undefined;
+}
+/**
+ * Everything belonging to one dashboard, placed or not.
+ *
+ * A widget exists whether or not the layout references it, which is what lets
+ * an author park a half-built card without it appearing on the grid. Blank
+ * widgets are written from the core templates, so a new widget always parses.
+ */
+declare function WidgetInventory({ widgets, unplacedWidgetIds, open, onOpenChange, onEdit, onAdd, onRemove, onDelete, onCreated, onCreateWithAssistant, onEditWithAssistant, }: WidgetInventoryProps): react_jsx_runtime.JSX.Element;
+
+/** A label with its text resolved, which the generated block leaves optional. */
+interface NormalizedLabel {
+    text: string;
+    icon?: string | undefined;
+    tooltip?: string | undefined;
+    position?: string | undefined;
+}
+declare function normalizeLabel(label: string | LabelBlock | NormalizedLabel | null | undefined, fallback?: string): NormalizedLabel | undefined;
+interface WidgetLabelProps {
+    label?: string | LabelBlock | NormalizedLabel | null;
+    fallback?: string;
+    className?: string;
+    style?: CSSProperties;
+    actions?: ReactNode;
+}
+declare function WidgetLabel({ label, fallback, className, style, actions, }: WidgetLabelProps): react_jsx_runtime.JSX.Element | null;
+
+interface WidgetRendererProps {
+    widget: WidgetSpec;
+    result?: WidgetResult;
+    context?: RendererContext;
+    loading?: boolean;
+    className?: string;
+    style?: CSSProperties;
+    actions?: ReactNode;
+    onInteraction?: (interaction: WidgetInteraction, context: WidgetInteractionContext) => void;
+    onRetry?: () => void;
+    onPivotDetail?: (payload: PivotDetailPayload) => void;
+    /**
+     * Handles table exports. Without one the reader downloads CSV itself and
+     * hides the Excel button, since building a workbook is the host's business.
+     */
+    onExport?: TableExporter;
+    /** Draws the frame's drag bar and edit buttons. */
+    editMode?: boolean;
+    onEdit?: (widgetId: string) => void;
+    onAsk?: (widgetId: string) => void;
+    onRemove?: (widgetId: string) => void;
+    onDiagnose?: (widgetId: string) => void;
+}
+declare function WidgetRenderer({ widget, result, context, loading, className, style, actions, onInteraction, onRetry, onPivotDetail, onExport, editMode, onEdit, onAsk, onRemove, onDiagnose, }: WidgetRendererProps): react_jsx_runtime.JSX.Element;
+
+interface DashboardLoadingBarProps {
+    loading: boolean;
+    className?: string;
+}
+declare function DashboardLoadingBar({ loading, className, }: DashboardLoadingBarProps): react_jsx_runtime.JSX.Element | null;
+interface WidgetLoadingProps {
+    skeleton: "kpi" | "chart" | "content";
+    message?: string;
+}
+declare function WidgetLoading({ skeleton, message }: WidgetLoadingProps): react_jsx_runtime.JSX.Element;
+interface WidgetErrorProps {
+    message: string;
+    hint?: string;
+    retryable?: boolean;
+    onRetry?: () => void;
+}
+declare function WidgetError({ message, hint, retryable, onRetry, }: WidgetErrorProps): react_jsx_runtime.JSX.Element;
+interface WidgetNoticeProps {
+    message: string;
+    children?: ReactNode;
+}
+declare function WidgetNotice({ message, children }: WidgetNoticeProps): react_jsx_runtime.JSX.Element;
+interface WidgetRefreshingProps {
+    active: boolean;
+    children: ReactNode;
+    className?: string;
+    style?: CSSProperties;
+}
+/**
+ * Hold the previous answer on screen while the next query runs. The card is
+ * dimmed and marked busy, so the numbers still on it read as the previous
+ * filters' answer rather than the new one.
+ */
+declare function WidgetRefreshing({ active, children, className, style, }: WidgetRefreshingProps): react_jsx_runtime.JSX.Element;
+interface WidgetEmptyProps {
+    message?: string;
+    hint?: string;
+}
+declare function WidgetEmpty({ message, hint }: WidgetEmptyProps): react_jsx_runtime.JSX.Element;
+interface VisibilityBadgeProps {
+    visibility: "private" | "shared" | "public" | "organisation";
+    className?: string;
+}
+declare function VisibilityBadge({ visibility, className, }: VisibilityBadgeProps): react_jsx_runtime.JSX.Element;
+
+type WidgetEditorMode = "ask" | "builder" | "yaml";
+interface WidgetYamlEditorProps {
+    widgetId: string | null;
+    open: boolean;
+    /** Which tab to land on. The host owns remembering a preference. */
+    initialMode?: WidgetEditorMode;
+    onOpenChange: (open: boolean) => void;
+    onSaved: () => void | Promise<void>;
+    onAddToLayout?: (widgetId: string) => void;
+}
+/**
+ * One widget, edited three ways over the same text.
+ *
+ * Builder and YAML are two views of one document, so switching keeps comments
+ * and every key the builder has no form for. Ask appears only when the host
+ * wired a proposal port, because an assistant is a host capability rather than
+ * something this package can assume.
+ */
+declare function WidgetYamlEditor({ widgetId, open, initialMode, onOpenChange, onSaved, onAddToLayout, }: WidgetYamlEditorProps): react_jsx_runtime.JSX.Element;
+
+/** Every `IconName`, drawn inline. Spread and override to replace a few. */
+declare const defaultIcons: IconSet;
+/** The built-in glyphs with a host's own laid over the top. */
+declare function mergeIcons(overrides?: Partial<IconSet>): IconSet;
+
+/** The complete built-in kit. */
+declare const defaultUiKit: UiKit;
+/**
+ * The built-in kit with a host's own primitives laid over the top, so a host
+ * replaces one control (its Button, its Modal) without writing the other nine.
+ */
+declare function createDefaultUiKit(overrides?: Partial<UiKit>): UiKit;
+
+/**
+ * The dashboard management seam: listing, creating, describing, sharing and
+ * exporting dashboards. The reader and builder never touch it; the ready-made
+ * list page, workspace toolbar, share dialog and export menu do.
+ *
+ * Who may see what is the host's decision, made on the server. This port only
+ * carries the answer: a `DashboardSummary` already says what the caller may do
+ * with it, and the share dialog offers whatever principals `searchPrincipals`
+ * returns, or a typed identifier when the host offers no lookup.
+ */
+/** Who the dashboard is visible to. Hosts may add their own values. */
+type DashboardVisibility = "personal" | "shared" | "org" | string;
+interface DashboardSummary {
+    dashboardId: string;
+    name: string;
+    description: string | null;
+    visibility: DashboardVisibility;
+    /** The owner as the host names them, for the list cards. */
+    ownerName: string | null;
+    /** The caller's permission as the host names it, for example `owner`, `edit`, `view`. */
+    permission: string;
+    canRead: boolean;
+    canWrite: boolean;
+    isOwner: boolean;
+    sharedWithCount: number;
+    updatedAt: string | null;
+}
+interface DashboardShare {
+    principalId: string;
+    permission: string;
+    displayName: string | null;
+}
+interface DashboardDetail extends DashboardSummary {
+    /** Empty unless the caller is the owner. */
+    shares: DashboardShare[];
+    /** Whether the caller may publish this dashboard to the organisation. */
+    canPublish: boolean;
+}
+/** Someone or something a dashboard may be shared with. */
+interface Principal {
+    principalId: string;
+    displayName: string;
+    /** A qualifier for the picker, for example a role or team name. */
+    detail?: string | undefined;
+}
+interface ShareGrant {
+    principalId: string;
+    permission: string;
+}
+interface ReportFormat {
+    format: string;
+    label: string;
+    mimeType: string;
+}
+interface DownloadedReport {
+    filename: string;
+    format: string;
+    mimeType: string;
+    blob: Blob;
+}
+interface DashboardManagementTransport {
+    listDashboards: (input: {
+        signal?: AbortSignal | undefined;
+    }) => Promise<DashboardSummary[]>;
+    loadDashboard: (input: {
+        dashboardId: string;
+        signal?: AbortSignal | undefined;
+    }) => Promise<DashboardDetail>;
+    /** Absent when the caller may not create dashboards; the list hides the button. */
+    createDashboard?: (input: {
+        name: string;
+        description: string | null;
+        /** A preferred identifier; the host may grant another and return it. */
+        dashboardId?: string | undefined;
+        specYaml?: string | undefined;
+        visibility?: DashboardVisibility | undefined;
+    }) => Promise<DashboardSummary>;
+    deleteDashboard?: (input: {
+        dashboardId: string;
+    }) => Promise<void>;
+    replaceShares?: (input: {
+        dashboardId: string;
+        grants: ShareGrant[];
+    }) => Promise<DashboardDetail>;
+    revokeShare?: (input: {
+        dashboardId: string;
+        principalId: string;
+    }) => Promise<DashboardDetail>;
+    setVisibility?: (input: {
+        dashboardId: string;
+        visibility: DashboardVisibility;
+    }) => Promise<DashboardDetail>;
+    /** People and roles a dashboard may be shared with; without it the share dialog takes a typed identifier. */
+    searchPrincipals?: (input: {
+        query: string;
+        signal?: AbortSignal | undefined;
+    }) => Promise<Principal[]>;
+    /** The export menu appears only when both report methods exist. */
+    listReportFormats?: (input: {
+        signal?: AbortSignal | undefined;
+    }) => Promise<ReportFormat[]>;
+    downloadReport?: (input: {
+        dashboardId: string;
+        format: string;
+        filters: Record<string, unknown>;
+    }) => Promise<DownloadedReport>;
+}
+
+interface Resource<T> {
+    readonly data: T | null;
+    readonly error: string | null;
+    readonly loading: boolean;
+    readonly reload: () => void;
+}
+/**
+ * Loads once per dependency change and offers a reload. The load in flight is
+ * abandoned when the dependencies move on, so a stale answer never lands.
+ */
+declare function useResource<T>(loader: (signal: AbortSignal) => Promise<T>, deps: readonly unknown[]): Resource<T>;
+
+declare function NoticeList({ notices }: {
+    notices: readonly Notice[];
+}): react_jsx_runtime.JSX.Element | null;
+/** Hands a downloaded report to the browser's download folder. */
+declare function saveBlob(blob: Blob, filename: string): void;
+interface ExportMenuProps {
+    dashboardId: string;
+    transport: Pick<DashboardManagementTransport, "listReportFormats" | "downloadReport">;
+    /** The filters currently applied to the reader, sent with the report run. */
+    filters?: Record<string, unknown> | undefined;
+    onNotice: NoticeSink;
+}
+/** Download as ... with the formats the host's report port offers. */
+declare function ExportMenu({ dashboardId, transport, filters, onNotice, }: ExportMenuProps): react_jsx_runtime.JSX.Element | null;
+interface ShareDialogProps {
+    open: boolean;
+    onOpenChange: (open: boolean) => void;
+    dashboard: DashboardDetail;
+    transport: Pick<DashboardManagementTransport, "replaceShares" | "revokeShare" | "setVisibility" | "searchPrincipals">;
+    onChanged: (detail: DashboardDetail) => void;
+}
+/**
+ * Visibility, the people with access and an add row. With
+ * `searchPrincipals` the add row is a search box over the host's directory;
+ * without it the caller types a principal identifier the host understands.
+ */
+declare function ShareDialog({ open, onOpenChange, dashboard, transport, onChanged, }: ShareDialogProps): react_jsx_runtime.JSX.Element;
+
+type AssistantIntent = "create" | "edit";
+interface DashboardWorkspaceProps {
+    dashboardId: string;
+    /** The reader's data client. */
+    transport: DashboardTransport;
+    /** Without it the page is read only: no edit mode, editors or inventory. */
+    authoringTransport?: AuthoringTransport | undefined;
+    /** Detail, sharing and exports. */
+    management: DashboardManagementTransport;
+    ui?: Partial<UiKit> | undefined;
+    icons?: Partial<IconSet> | undefined;
+    renderers?: RendererFactories | undefined;
+    links?: HostLinks | undefined;
+    assets?: AssetResolver | undefined;
+    editor?: CodeEditor | undefined;
+    /** Shows the Semantic model button in edit mode. */
+    canEditModel?: boolean | undefined;
+    /** Opens in edit mode when the caller may write, for a freshly created dashboard. */
+    startInEditMode?: boolean | undefined;
+    filters?: Record<string, unknown> | undefined;
+    onFiltersChange?: ((filters: Record<string, unknown>) => void) | undefined;
+    /** Where unsaved drafts survive a reload; defaults to localStorage, null keeps them in memory. */
+    storage?: Pick<Storage, "getItem" | "setItem" | "removeItem"> | null | undefined;
+    /** The Dashboards button; hidden when the host gives no way back. */
+    onBack?: (() => void) | undefined;
+    /** Runs after Make a copy with the new identifier. */
+    onOpenDashboard?: ((dashboardId: string) => void) | undefined;
+    /** Create with AI and Edit with AI; hidden when the host has no assistant. */
+    onAssistant?: ((intent: AssistantIntent, dashboardId: string) => void) | undefined;
+    /** Notices also reach the host, for its own toasts or logs. */
+    onNotice?: NoticeSink | undefined;
+    /** Host buttons placed at the end of the toolbar, a Schedule button for example. */
+    toolbarExtra?: ReactNode;
+    className?: string | undefined;
+}
+declare function DashboardWorkspace(props: DashboardWorkspaceProps): react_jsx_runtime.JSX.Element;
+
+interface DashboardShelf {
+    /** Whether a dashboard sits on this shelf; the first shelf that holds it wins. */
+    holds: (item: DashboardSummary) => boolean;
+    title: string;
+    blurb?: string | undefined;
+}
+/** A dashboard the caller owns is theirs wherever it is shared, so ownership is checked before reach. */
+declare const DEFAULT_SHELVES: readonly DashboardShelf[];
+interface DashboardListProps {
+    management: DashboardManagementTransport;
+    /** Opens a dashboard; `editing` is set for a dashboard just created. */
+    onOpen: (dashboardId: string, options: {
+        editing: boolean;
+    }) => void;
+    ui?: Partial<UiKit> | undefined;
+    icons?: Partial<IconSet> | undefined;
+    shelves?: readonly DashboardShelf[] | undefined;
+    title?: string | undefined;
+    description?: string | undefined;
+    /** Extra header actions beside New dashboard. */
+    actions?: ReactNode;
+    /** The visibility a new dashboard starts with. */
+    newVisibility?: string | undefined;
+    className?: string | undefined;
+}
+/** A URL safe identifier from a name; the host may still grant another. */
+declare function slugify(name: string): string;
+declare function DashboardList({ management, onOpen, ui, icons, shelves, title, description, actions, newVisibility, className, }: DashboardListProps): react_jsx_runtime.JSX.Element;
+
+interface HttpTransportOptions {
+    /** The dashboards prefix, for example `/api/custom-dashboards`. */
+    readonly baseUrl: string;
+    /** The authoring prefix; defaults to `${baseUrl}/authoring`. */
+    readonly authoringUrl?: string;
+    /** Defaults to the global `fetch`. */
+    readonly fetch?: typeof fetch;
+    /**
+     * Last word on every request: add an Authorization header, a tenant query
+     * parameter, credentials, whatever the host's API expects.
+     */
+    readonly prepare?: (url: string, init: RequestInit) => RequestInit | void;
+    /** Extra query parameters appended to every URL, for example `{ person }`. */
+    readonly query?: Readonly<Record<string, string>>;
+}
+declare function httpRefusal(response: Response): Promise<string>;
+/** The reader's data client over the `/{id}/reader`, `/reader/{widget}` and `/layout` routes. */
+declare function createHttpDashboardTransport(options: HttpTransportOptions): DashboardTransport;
+/** The builder's client over the `/authoring/*` routes, snake case on the wire. */
+declare function createHttpAuthoringTransport(options: HttpTransportOptions): AuthoringTransport;
+interface HttpManagementOptions extends HttpTransportOptions {
+    /** The reports prefix; defaults to `${baseUrl}/reports`. */
+    readonly reportsUrl?: string;
+    /** Route groups the host serves; the matching optional methods are omitted otherwise. */
+    readonly features?: {
+        /** `DELETE {baseUrl}/{id}`. */
+        readonly delete?: boolean;
+        /** `GET {baseUrl}/principals?q=`. */
+        readonly principals?: boolean;
+        /** `GET {reportsUrl}/formats` and `POST {reportsUrl}/{id}/{format}`. */
+        readonly reports?: boolean;
+    };
+}
+/**
+ * Listing, detail, create, sharing, visibility and reports over the route
+ * shape both example hosts serve: `GET/POST {baseUrl}`, `GET {baseUrl}/{id}`,
+ * `POST {baseUrl}/{id}/shares|shares/revoke|visibility`, `PATCH {baseUrl}/{id}`,
+ * `POST {baseUrl}/{id}/copy`, plus the optional groups in `features`.
+ */
+declare function createHttpManagementTransport(options: HttpManagementOptions): DashboardManagementTransport;
+
+/** How the component reaches the host's API when no transport is given. */
+interface BideuxHttpOptions extends HttpManagementOptions {
+    /** Set to false for a read only page that never builds an authoring transport. */
+    readonly authoring?: boolean;
+}
+type WorkspaceRest = Omit<DashboardWorkspaceProps, "transport" | "authoringTransport" | "management" | "renderers">;
+interface BideuxDashboardProps extends WorkspaceRest {
+    /** The dashboards prefix, for example `/api/custom-dashboards`; the transports are built from it. */
+    baseUrl?: string | undefined;
+    /** Everything about the HTTP client: fetch, prepare, query, reports URL, features. */
+    http?: Omit<BideuxHttpOptions, "baseUrl"> | undefined;
+    /** Custom clients; each one given replaces the HTTP one for that role. */
+    transport?: DashboardTransport | undefined;
+    authoringTransport?: AuthoringTransport | undefined;
+    management?: DashboardManagementTransport | undefined;
+    /** Widget renderers; defaults to ECharts, Tabulator, RevoGrid and the DOM renderer. */
+    renderers?: DashboardWorkspaceProps["renderers"];
+    /** Theme and overrides for the default renderers when `renderers` is not given. */
+    rendererOptions?: DefaultRenderersOptions | undefined;
+}
+declare function BideuxDashboard({ baseUrl, http, transport, authoringTransport, management, renderers, rendererOptions, ...rest }: BideuxDashboardProps): react_jsx_runtime.JSX.Element;
+interface BideuxDashboardListProps extends Omit<DashboardListProps, "management"> {
+    baseUrl?: string | undefined;
+    http?: Omit<HttpManagementOptions, "baseUrl"> | undefined;
+    management?: DashboardManagementTransport | undefined;
+}
+declare function BideuxDashboardList({ baseUrl, http, management, ...rest }: BideuxDashboardListProps): react_jsx_runtime.JSX.Element;
+
+export { type AssetResolver, type AssistantIntent, type AuthoringProposal, type AuthoringTransport, AutoFitText, type AutoFitTextProps, BideuxDashboard, BideuxDashboardList, type BideuxDashboardListProps, type BideuxDashboardProps, type BideuxHttpOptions, type BreadcrumbItem, BuilderYamlStrip, CELL_SIZE_OPTIONS, ChoiceField, type CodeEditor, type CodeEditorProps, ColumnPicker, DEFAULT_MODEL_YAML, DEFAULT_SHELVES, type DashboardAuthoringContextValue, DashboardAuthoringProvider, type DashboardAuthoringProviderProps, DashboardBreadcrumb, type DashboardBreadcrumbProps, DashboardCanvas, type DashboardCanvasEditProps, type DashboardCanvasProps, type DashboardCopyRequest, type DashboardCopyResponse, type DashboardDetail, type DashboardDocument, type DashboardDocumentRequest, type DashboardDocumentSaveRequest, DashboardFilterBar, type DashboardFilterBarProps, DashboardFilterPanel, type DashboardFilterPanelProps, DashboardFiltersProvider, type DashboardFiltersProviderProps, type DashboardFiltersValue, DashboardList, type DashboardListProps, DashboardLoadingBar, type DashboardLoadingBarProps, type DashboardManagementTransport, type DashboardMetadataSaveRequest, DashboardReader, type DashboardReaderContextValue, DashboardReaderLoader, type DashboardReaderLoaderProps, type DashboardReaderProps, DashboardReaderProvider, type DashboardReaderProviderProps, type DashboardRunRequest, type DashboardRunResponse, DashboardSection, type DashboardSectionProps, type DashboardShare, type DashboardShelf, type DashboardSummary, type DashboardTransport, type DashboardVisibility, DashboardWorkspace, type DashboardWorkspaceProps, DashboardYamlEditor, type DashboardYamlEditorProps, type DataModelConnection, DatasetBuilderPanel, type DatasetBuilderPanelProps, type DatasetPreviewRequest, type DatasetPreviewResult, type DownloadedReport, type DrillRunRequest, type DrillRunResponse, DrilldownModal, type DrilldownModalProps, EDIT_BAR_HEIGHT, ExportMenu, type ExportMenuProps, FieldLabel, FilterWidget, type FilterWidgetProps, type GridOverrides, type GridSettingsDataStore, GridSettingsPanel, type GridSettingsPanelProps, type HostLinkProps, type HostLinks, type HttpManagementOptions, type HttpTransportOptions, type IconName, type IconProps, type IconSet, Info, type InlineOption, InlineSelect, type InlineSelectProps, InlineText, type InlineTextProps, KpiCard, type KpiCardProps, LayoutConflictError, type LayoutDraft, LayoutDraftDialogs, type LayoutDraftDialogsProps, type LayoutDraftDocuments, type LayoutExitTarget, type LayoutGridConfigDraft, LayoutKey, type LayoutSaveRequest, type LayoutSaveResponse, type LayoutWidgetRequest, type LoadedDashboard, MetricBuilderPanel, type MetricBuilderPanelProps, ModelBuilder, type ModelBuilderProps, type ModelDocument, ModelEditor, type ModelEditorMode, type ModelEditorProps, type ModelLayer, type ModelLoadRequest, type ModelSaveRequest, type ModelValidateRequest, type ModelVersionRequest, type ModelVersionRestoreRequest, type ModelVersionSummary, type NormalizedLabel, type Notice, NoticeList, type NoticeSink, NumberField, PickList, PivotDetailModal, type PivotDetailModalProps, type PivotDetailPayload, PlainCodeEditor, PreservedKeysNote, type Principal, type ProposalOutcomeRequest, type ProposalRequest, type ReaderRenderer, RelationshipBuilderPanel, type RelationshipBuilderPanelProps, type RendererExportRequest, type RendererFactories, type RendererFactory, RendererMount, type RendererMountCallbacks, type RendererMountInput, type RendererMountProps, type ReportFormat, type Resource, ResultTable, STEP_TITLES, ShareDialog, type ShareDialogProps, type ShareGrant, StepFrame, type StepState, type StyleValue, type TableExportFormat, type TableExportRequest, type TableExporter, TableView, type TableViewProps, TextField, ToggleField, UNSET, type UiBadgeProps, type UiButtonProps, type UiCheckboxProps, type UiKit, type UiMenuItem, type UiMenuProps, type UiModalProps, type UiPopoverProps, type UiSelectOption, type UiSelectProps, type UiSkeletonProps, type UiTextInputProps, type UiTooltipProps, type UseLayoutDraftOptions, type VersionRowLabel, VisibilityBadge, type VisibilityBadgeProps, type WarehouseColumn, type WarehouseSchemaRequest, type WarehouseTable, WidgetActions, type WidgetActionsProps, WidgetAskPanel, type WidgetAskPanelProps, WidgetBuilder, type WidgetBuilderProps, type WidgetCreateRequest, type WidgetDeleteRequest, type WidgetDetailRequest, WidgetDiagnostics, type WidgetDiagnosticsProps, type WidgetDiagnosticsRequest, type WidgetDiagnosticsResponse, type WidgetDocument, type WidgetDocumentRequest, type WidgetEditorMode, WidgetEmpty, type WidgetEmptyProps, WidgetError, type WidgetErrorProps, WidgetFrame, type WidgetFrameProps, WidgetHeader, type WidgetHeaderProps, WidgetInventory, type WidgetInventoryProps, type WidgetInventoryRequest, type WidgetInventoryResponse, WidgetLabel, type WidgetLabelProps, WidgetLoading, type WidgetLoadingProps, type WidgetMappingDiagnostic, WidgetNotice, type WidgetNoticeProps, type WidgetQueryDiagnostic, WidgetRefreshing, type WidgetRefreshingProps, WidgetRenderer, type WidgetRendererProps, type WidgetRunRequest, type WidgetSaveRequest, WidgetYamlEditor, type WidgetYamlEditorProps, addMeasure, addSeries, appendColumn, builderStepsDone, cn, createDefaultUiKit, createHttpAuthoringTransport, createHttpDashboardTransport, createHttpManagementTransport, cssProps, defaultIcons, defaultUiKit, downloadTableCsv, formatAge, frameStyle, httpRefusal, isLayoutConflict, isMapped, joinableColumns, mergeIcons, modelIssueLines, modelNoteLines, nextSeriesField, normalizeLabel, present, removeMeasure, removeSeries, saveBlob, setAxis, setDataset, setMapping, slugify, toggleColumn, updateMeasure, updateSeries, useAuthoring, useCountUp, useDashboardFilters, useDashboardReader, useIcons, useLayoutDraft, useResource, useUiKit, versionRowLabel };