@dlh.io/bideux 0.1.0

package/dist/index.d.ts

@@ -0,0 +1,1041 @@
+import { x as DashboardGridConfig, c as Breakpoint, aa as ResponsiveLayouts, L as DashboardSpec, w as DashboardFilterPanelConfig, T as LayoutItem, q as BuilderRelationship, n as BuilderModelMetric, i as BuilderDataset, h as BuilderDataStore, I as DashboardPivotInfo, a8 as ReadPivotOpenLevels, a4 as PivotExpandEntry, ad as SemanticSummary, V as ModelMarker, U as LayoutKey } from './result-table-CPls-277.js';
+export { A as AGGREGATIONS, a as ALL_COMPONENTS, b as Aggregation, B as BUILDER_COMPONENTS, d as BreakpointConfig, e as BuilderAppearance, f as BuilderCardinality, g as BuilderComponent, j as BuilderDimension, k as BuilderDimensionType, l as BuilderMappings, m as BuilderMetric, o as BuilderPivot, p as BuilderPivotMeasure, r as BuilderRollup, s as BuilderSeries, t as BuilderWidget, C as CHART_TYPES, u as ChartType, D as DELTA_FORMATS, v as DashboardConfig, y as DashboardModelAiGrounding, z as DashboardModelDataStoreDiagnostic, E as DashboardModelDatasetDiagnostic, F as DashboardModelDiagnostics, G as DashboardModelMetricDiagnostic, H as DashboardModelRelationshipDiagnostic, J as DashboardResponsiveConfig, K as DashboardSectionConfig, M as DashboardTab, N as DeltaFormat, O as FilterControl, P as FilterLayout, Q as FilterModel, R as FilterOption, S as LAYOUT_BREAKPOINT_WIDTHS, W as ModelMarkerSeverity, X as ModelOutline, Y as ModelParseError, Z as NUMBER_FORMATS, _ as NumberFormat, $ as PIVOT_AGGREGATIONS, a0 as PIVOT_DIRECTIONS, a1 as PIVOT_SUBTOTALS, a2 as PivotAggregation, a3 as PivotDirection, a5 as PivotOpenLevels, a6 as PivotSubtotals, a7 as RatioSide, a9 as ResizeHandle, ab as ResultTable, ac as SORT_ORDERS, ae as SortOrder, af as WidgetAnchor, ag as WidgetColumn, ah as WidgetFinding, ai as WidgetOutline, aj as WidgetRef, ak as aggregationExpression, al as blockingKeys, am as buildFilterModel, an as cellText, ao as countModelIssues, ap as dashboardTabs, aq as dataStoreFragment, ar as datasetFragment, as as defaultTabId, at as describeFilter, au as diagnosticsToMarkers, av as dimensionTypeFor, aw as filterOptions, ax as formatTableCsv, ay as humanizeColumn, az as indexModelYaml, aA as isBuilderComponent, aB as isDoubleScaledPercent, aC as isIsoDate, aD as isRelativeDateExpression, aE as labelColumns, aF as layoutKeyForWidth, aG as modelMetricFragment, aH as modelText, aI as numericColumns, aJ as parseAggregation, aK as parseModelDocument, aL as parseRatioExpression, aM as preservedKeys, aN as ratioExpression, aO as readDataStores, aP as readDatasets, aQ as readModelMetrics, aR as readModelOutline, aS as readRelationships, aT as readWidgetOutline, aU as relationshipFragment, aV as removeDataStore, aW as removeDataset, aX as removeModelMetric, aY as removeRelationship, aZ as resolveResponsive, a_ as resultColumns, a$ as resultRows, b0 as tabWidgetIds, b1 as upsertDataStore, b2 as upsertDataset, b3 as upsertModelMetric, b4 as upsertRelationship, b5 as widgetColumns, b6 as widgetFindings, b7 as widgetFragment, b8 as widgetIssues, b9 as writeComponent, ba as writeIdentity, bb as writePivotLayout, bc as writeWidget, bd as yamlSyntaxMarkers } from './result-table-CPls-277.js';
+import { aw as WidgetSpec, C as ChartOption, av as WidgetResult, S as RendererContext, b as ChartRendererModel, D as DataRow, ae as TabularRendererModel, ad as TabularGridAdapter, B as BasicRendererModel, h as KpiRendererModel, M as MarkdownRendererModel, ag as TextRendererModel, aq as WidgetRenderResolution, O as PivotTablePayload, u as PivotGridColumnDefinition, H as PivotRowPayload, w as PivotGridRow, y as PivotMeasurePayload, v as PivotGridColumnGroup, r as PivotFieldPayload, x as PivotGridRowMeta, z as PivotRendererModel, R as ReadyPivotRendererModel, t as PivotGridColumn, k as PivotCellAction, l as PivotCellPresentation, a2 as PivotOpenLevels, Q as PivotViewState, J as PivotSortState, m as PivotColumnFilter, a1 as PivotDirection, T as RendererExtension, a3 as RendererRegistry, d as GridColumnModel, aa as TableRendererModel, af as TabulatorRendererModel, G as GridColumnFormatterModel, ac as TableSortState, a9 as TableExportModel, an as WidgetInteraction, ao as WidgetInteractionContext, al as WidgetDefaults, ax as WidgetTheme, ak as WidgetComponent, W as RendererFrame, a4 as RendererThemeTokens, N as NativeWidgetRenderInput, a as BrowserRenderer, as as WidgetRendererFactories, X as RendererHostCallbacks, at as WidgetRendererFactory } from './types-CHFSsU_X.js';
+export { c as DrillStackItem, E as ExtensionRendererModel, F as FieldMapping, e as GridOptionsModel, I as ImageRendererModel, f as InteractionVariableMapping, g as InteractionVariableSource, K as KpiDeltaModel, i as KpiValueFormat, L as LabelBlock, j as MissingPivotRendererModel, P as PIVOT_META_PROP, n as PivotColumnNode, o as PivotControlsModel, p as PivotDetailColumn, q as PivotDetailResult, s as PivotFilterOp, A as PivotRowKind, aj as RendererExportRequest, U as RendererExtensionInput, V as RendererExtensionMount, Y as RendererLabel, Z as RendererLicensePort, _ as RendererLicenseRequest, $ as RendererPivotAggregation, a0 as RendererPivotDetailRequest, a5 as ResponsiveLayout, a6 as SortDirection, a7 as TableCellModel, a8 as TableColumnModel, ab as TableRowModel, ah as TextRendererStyle, ai as UnknownRendererModel, am as WidgetHeaderConfig, ap as WidgetLayout, ar as WidgetRenderState, au as WidgetRendererHandle, ay as buildDrillUrl, az as decodeDrillStack, aA as defaultRendererTheme, aB as encodeDrillStack, aC as findEventRow, aD as getClickInteraction, aE as isUrlInteraction, aF as resolveInteractionValue, aG as resolveInteractionValues, aH as resolveRendererTheme } from './types-CHFSsU_X.js';
+import 'yaml';
+
+/**
+ * Business context available to host authoring tools, including synonyms.
+ */
+type AiContext = {
+    [k: string]: JsonValue;
+} | string | null;
+type JsonValue = unknown;
+type CustomExtensions = {
+    [k: string]: JsonValue;
+}[] | null;
+/**
+ * Warehouse connections datasets may read from.
+ *
+ * @maxItems 3
+ */
+type DataStores = [] | [DataStore] | [DataStore, DataStore] | [DataStore, DataStore, DataStore];
+type AiContext1 = {
+    [k: string]: JsonValue;
+} | string | null;
+type CustomExtensions1 = {
+    [k: string]: JsonValue;
+}[] | null;
+/**
+ * Host data-store identifier holding credentials, database, and schema. Omit to use the host's default active store.
+ */
+type DataModelId = string | null;
+/**
+ * Store used by datasets that do not name one.
+ */
+type Default = boolean;
+type Description = string | null;
+/**
+ * Id datasets use to point at this store, for example ops_dw.
+ */
+type Id = string;
+type Name = string | null;
+/**
+ * Warehouse vendor, for example snowflake, databricks or postgres.
+ */
+type Vendor = string | null;
+type AiContext2 = {
+    [k: string]: JsonValue;
+} | string | null;
+type Enabled = boolean;
+type TtlSeconds = number | null;
+type TtlSeconds1 = number | null;
+type CustomExtensions2 = {
+    [k: string]: JsonValue;
+}[] | null;
+/**
+ * Id of the data store in this model's data_stores list. Omit to use the model's default store.
+ */
+type DataStoreId = string | null;
+type DataStoreIds = string[] | null;
+type DataModelId1 = string | null;
+/**
+ * Id of the data store in this model's data_stores list. Omit to use the model's default store.
+ */
+type DataStoreId1 = string | null;
+type DataStoreIds1 = string[] | null;
+type Description1 = string | null;
+type AiContext3 = {
+    [k: string]: JsonValue;
+} | string | null;
+/**
+ * Warehouse column this dimension reads. Defaults to the id.
+ */
+type Column = string | null;
+type CustomExtensions3 = {
+    [k: string]: JsonValue;
+}[] | null;
+type Description2 = string | null;
+/**
+ * SQL expression to use instead of a plain column.
+ */
+type Expression = string | Expression1 | null;
+type Default1 = string | null;
+type Dialect = string;
+type Expression2 = string;
+type Dialects = ExpressionDialect[];
+type Format = string | null;
+type Group = string | null;
+type Hidden = boolean | null;
+/**
+ * Id widgets use to group or filter by, for example business_date.
+ */
+type Id1 = string;
+type IsTime = boolean | null;
+type Label = string | null;
+type Name1 = string | null;
+type Type = "string" | "number" | "date" | "time" | "boolean";
+/**
+ * Columns widgets can group or filter by.
+ */
+type Dimensions = Dimension[];
+/**
+ * Columns widgets can group or filter by.
+ */
+type Dimensions1 = Dimension[];
+/**
+ * Column carrying the location key. Without it a location-scoped user cannot query this dataset.
+ */
+type FilterField = string | null;
+type FilterParam = string;
+/**
+ * Table or view the rows come from, for example {mart_schema}.RPT_DAILY_SALES_SUMMARY.
+ */
+type From = string | null;
+type GroupBy = string[] | null;
+/**
+ * Id widgets use to ask for this dataset, for example daily_sales.
+ */
+type Id2 = string;
+type Kpi = string | null;
+type Enabled1 = boolean;
+type Grain = string[];
+type Metrics = string[];
+type Source = string | null;
+type Join = "left" | "inner";
+type JoinColumns = string[];
+type MaxRows = number;
+/**
+ * @maxItems 3
+ */
+type Parts = [] | [MeshPart] | [MeshPart, MeshPart] | [MeshPart, MeshPart, MeshPart];
+type Dataset1 = string;
+type AiContext4 = {
+    [k: string]: JsonValue;
+} | string | null;
+type CustomExtensions4 = {
+    [k: string]: JsonValue;
+}[] | null;
+type Dependencies = string[] | null;
+type Description3 = string | null;
+/**
+ * SQL aggregate such as SUM(NET_SALES), or an expression over other metrics such as labor_cost / net_sales.
+ */
+type Expression3 = string | Expression1;
+type Filter = string | null;
+type Format1 = string | null;
+type Group1 = string | null;
+type Hidden1 = boolean | null;
+/**
+ * Id widgets use to ask for this metric, for example net_sales.
+ */
+type Id3 = string;
+type Label1 = string | null;
+type Name2 = string | null;
+/**
+ * sql sends the expression to the warehouse; formula computes it from other metrics after the query.
+ */
+type Type1 = "sql" | "formula";
+/**
+ * Aggregations valid on this dataset's source.
+ */
+type Metrics1 = Metric[];
+/**
+ * Label shown to users. Defaults to the id.
+ */
+type Name3 = string | null;
+type PrimaryKey = string[] | null;
+/**
+ * SQL to run when source_type is query.
+ */
+type Query = string | null;
+type AiContext5 = {
+    [k: string]: JsonValue;
+} | string | null;
+type CustomExtensions5 = {
+    [k: string]: JsonValue;
+}[] | null;
+/**
+ * Id of the dataset on the left of the join.
+ */
+type From1 = string;
+/**
+ * Join columns on the from dataset.
+ */
+type FromColumns = string[];
+/**
+ * Name of the join, for example sales_to_labor.
+ */
+type Name4 = string;
+/**
+ * Cardinality. one_to_many and many_to_many can fan out and double-count.
+ */
+type Relationship1 = ("one_to_one" | "many_to_one" | "one_to_many" | "many_to_many") | null;
+/**
+ * Id of the dataset on the right of the join.
+ */
+type To = string;
+/**
+ * Join columns on the to dataset, positionally matched to from_columns.
+ */
+type ToColumns = string[];
+type Relationships = Relationship[];
+/**
+ * Table or view the rows come from, for example {mart_schema}.RPT_DAILY_SALES_SUMMARY.
+ */
+type From2 = string | null;
+/**
+ * table or view reads source; query runs the query field; mesh combines datasets from different data stores.
+ */
+type SourceType = ("table" | "view" | "query" | "mesh") | null;
+type UniqueKeys = string[][] | null;
+/**
+ * Reusable sources of rows widgets can ask for.
+ */
+type Datasets = Dataset[];
+type Description4 = string | null;
+type Kind = "semantic_model";
+/**
+ * Metrics usable across datasets, including formulas spanning a join.
+ */
+type Metrics2 = Metric[];
+/**
+ * Model name. Dashboards reference the tenant model as default.
+ */
+type Name5 = string;
+/**
+ * Joins between datasets, so one widget can mix their fields.
+ */
+type Relationships1 = Relationship[];
+/**
+ * Spec version of this document. Currently 1.0.
+ */
+type Version = string;
+/**
+ * An OSI semantic model block (data stores, datasets, relationships, metrics).
+ */
+interface SemanticModel {
+    ai_context?: AiContext;
+    custom_extensions?: CustomExtensions;
+    data_stores?: DataStores;
+    datasets?: Datasets;
+    description?: Description4;
+    kind?: Kind;
+    metrics?: Metrics2;
+    name: Name5;
+    relationships?: Relationships1;
+    version?: Version;
+    [k: string]: unknown;
+}
+/**
+ * A data-store (warehouse) connection referenced by datasets.
+ */
+interface DataStore {
+    ai_context?: AiContext1;
+    custom_extensions?: CustomExtensions1;
+    data_model_id?: DataModelId;
+    default?: Default;
+    description?: Description;
+    id: Id;
+    name?: Name;
+    vendor?: Vendor;
+    [k: string]: unknown;
+}
+/**
+ * A reusable semantic dataset: schema/table, dimensions, and metrics.
+ */
+interface Dataset {
+    ai_context?: AiContext2;
+    cache?: DatasetCacheConfig | null;
+    custom_extensions?: CustomExtensions2;
+    dataStoreId?: DataStoreId;
+    dataStoreIds?: DataStoreIds;
+    data_model_id?: DataModelId1;
+    data_store_id?: DataStoreId1;
+    data_store_ids?: DataStoreIds1;
+    description?: Description1;
+    dimensions?: Dimensions;
+    fields?: Dimensions1;
+    filter_field?: FilterField;
+    filter_param?: FilterParam;
+    from?: From;
+    group_by?: GroupBy;
+    id: Id2;
+    kpi?: Kpi;
+    materialization?: DatasetMaterialization | null;
+    mesh?: MeshPlan | null;
+    metrics?: Metrics1;
+    name?: Name3;
+    params?: Params;
+    primary_key?: PrimaryKey;
+    query?: Query;
+    relationships?: Relationships;
+    source?: From2;
+    source_type?: SourceType;
+    unique_keys?: UniqueKeys;
+    [k: string]: unknown;
+}
+/**
+ * How long a dataset's warehouse results may be reused.
+ */
+interface DatasetCacheConfig {
+    enabled?: Enabled;
+    ttlSeconds?: TtlSeconds;
+    ttl_seconds?: TtlSeconds1;
+    [k: string]: unknown;
+}
+/**
+ * A dimension (attribute) inside a Dataset.
+ */
+interface Dimension {
+    ai_context?: AiContext3;
+    column?: Column;
+    custom_extensions?: CustomExtensions3;
+    description?: Description2;
+    expression?: Expression;
+    format?: Format;
+    group?: Group;
+    hidden?: Hidden;
+    id: Id1;
+    is_time?: IsTime;
+    label?: Label;
+    name?: Name1;
+    type?: Type;
+    [k: string]: unknown;
+}
+/**
+ * OSI-style multi-dialect expression block.
+ *
+ * ``dialects`` lists SQL or expression variants per warehouse. ``default`` is
+ * available for row-level formulas or fallback SQL.
+ */
+interface Expression1 {
+    default?: Default1;
+    dialects?: Dialects;
+    [k: string]: unknown;
+}
+/**
+ * A single dialect expression for a field or metric.
+ */
+interface ExpressionDialect {
+    dialect: Dialect;
+    expression: Expression2;
+    [k: string]: unknown;
+}
+/**
+ * A pre-aggregated rollup the engine may read instead of the base source.
+ *
+ * ``grain`` lists the dimensions the rollup is aggregated to and ``metrics``
+ * the measures it carries. A widget selection covered by both is answered from
+ * ``source``; anything wider falls back to the dataset's own source, so the
+ * rollup is an optimisation and never changes what a widget can ask for.
+ */
+interface DatasetMaterialization {
+    enabled?: Enabled1;
+    grain?: Grain;
+    metrics?: Metrics;
+    source?: Source;
+    [k: string]: unknown;
+}
+/**
+ * How a mesh dataset stitches datasets from different data stores together.
+ */
+interface MeshPlan {
+    join?: Join;
+    join_columns?: JoinColumns;
+    max_rows?: MaxRows;
+    parts?: Parts;
+    [k: string]: unknown;
+}
+/**
+ * One dataset taking part in a mesh dataset.
+ */
+interface MeshPart {
+    dataset: Dataset1;
+    [k: string]: unknown;
+}
+/**
+ * A calculated field or metric inside a Dataset.
+ */
+interface Metric {
+    ai_context?: AiContext4;
+    custom_extensions?: CustomExtensions4;
+    dependencies?: Dependencies;
+    description?: Description3;
+    expression: Expression3;
+    filter?: Filter;
+    format?: Format1;
+    group?: Group1;
+    hidden?: Hidden1;
+    id: Id3;
+    label?: Label1;
+    name?: Name2;
+    type?: Type1;
+    [k: string]: unknown;
+}
+interface Params {
+    [k: string]: JsonValue;
+}
+/**
+ * A relationship between two datasets (OSI-style join).
+ */
+interface Relationship {
+    ai_context?: AiContext5;
+    custom_extensions?: CustomExtensions5;
+    from: From1;
+    from_columns?: FromColumns;
+    name: Name4;
+    relationship?: Relationship1;
+    to: To;
+    to_columns?: ToColumns;
+    [k: string]: unknown;
+}
+
+declare const documentVersion = "1.0";
+declare const documentKinds: readonly ["dashboard", "semantic_model", "widget"];
+type DocumentKind = (typeof documentKinds)[number];
+
+/**
+ * Ready-to-edit YAML for a brand new dashboard.
+ *
+ * A new dashboard already has a place for its controls. Without a filter panel
+ * a filter added later becomes an ordinary tile somewhere on the grid, which is
+ * not where a reader looks for one. It also has one tab, because a widget has
+ * to be added to a tab and a dashboard with no tabs has nowhere to put it.
+ */
+interface DashboardTemplateOptions {
+    /** The address the dashboard will be created under. Seeds the document id. */
+    slug: string;
+    /** What the dashboard is called. */
+    name: string;
+    /** What the dashboard is for, written into the manifest as given. */
+    description?: string;
+}
+/** The YAML of a blank dashboard, valid the moment it is read back. */
+declare function dashboardTemplate(options: DashboardTemplateOptions): string;
+
+interface ExpressionRow {
+    [key: string]: unknown;
+}
+interface ExpressionContext {
+    rows?: ExpressionRow[];
+    row?: ExpressionRow;
+    variables?: Record<string, unknown>;
+}
+declare function interpolateVariables(value: unknown, variables: Record<string, unknown>): unknown;
+declare function evaluateExpression(expression: string, context: ExpressionContext): unknown;
+declare function evaluateVariables(variables: Record<string, string> | undefined, rows: ExpressionRow[], existingVariables?: Record<string, unknown>): Record<string, unknown>;
+declare function applyFilter(filter: string | undefined, rows: ExpressionRow[], variables: Record<string, unknown>): ExpressionRow[];
+declare function resolveFilterDefault(defaultValue: unknown, extraVariables?: Record<string, unknown>): unknown;
+
+/**
+ * Printing what a filter is currently set to, inside written content.
+ *
+ * A heading that says "Downtown, last 30 days" is how a reader knows what the
+ * numbers beside it are counting. The wording lives in the widget's content as
+ * `{{filter:some_filter_id}}`, and this fills it in from the dashboard's filter
+ * state, preferring the label the control showed over the raw key it sends.
+ */
+/**
+ * One filter value as a reader should see it.
+ *
+ * An unset filter reads as *empty* rather than as nothing at all, because a
+ * heading that silently loses a word is harder to understand than one that says
+ * the filter is not narrowing anything.
+ */
+declare function formatFilterValue(value: unknown, empty?: string): string;
+/**
+ * Content with every filter token replaced by what that filter is set to.
+ *
+ * *labels* holds the wording the control itself displayed, which is what a
+ * reader recognises: a location filter sends a store key and shows a store name.
+ * A token naming a filter this dashboard does not have is left exactly as
+ * written, so the mistake is visible rather than silently blank.
+ */
+declare function fillFilterTokens(content: string, filters: Record<string, unknown>, labels?: Record<string, string>): string;
+/** Whether content prints any filter at all, which decides if it has to re-render. */
+declare function mentionsFilter(content: string): boolean;
+
+declare const MAX_LAYOUT_WIDTHS: Record<"mobile" | "tablet" | "desktop" | "wide", number>;
+/**
+ * Default grid behavior for dashboards.
+ * Authors can override these values through dashboard.spec.config.grid.
+ */
+declare const DEFAULT_GRID_CONFIG: DashboardGridConfig;
+/**
+ * Resolve the compactType and preventCollision values for the current
+ * snap setting.
+ * - Snap on = vertical compaction + collision re-ordering, so a drag pushes the
+ *   neighbours it lands on out of the way.
+ * - Snap off = no compaction + collision prevention. This gives free placement
+ *   to any empty cell up to maxRows; dragging an item onto another reverts it.
+ *
+ * Collisions are prevented in free placement regardless of what the dashboard
+ * declares, because `preventCollision: false` without compaction is the one
+ * combination that lets a widget be dropped on top of another and stay there.
+ * A dashboard that genuinely wants stacking sets `allowOverlap`.
+ */
+declare function resolveSnap(grid: DashboardGridConfig, snap: boolean): {
+    compactType: "vertical" | "horizontal" | null;
+    preventCollision: boolean;
+};
+
+declare const BREAKPOINT_MAP: Record<string, Breakpoint>;
+/** Components that are controls the reader changes rather than tiles on the grid. */
+declare const CONTROL_COMPONENTS: Set<string>;
+declare function isControlComponent(component: string): boolean;
+/**
+ * The filter panel configuration under either spelling the specification
+ * accepts. A document read straight from YAML keeps `filter_panel`; one read back
+ * from a Pydantic model carries `filterPanel`.
+ */
+declare function filterPanelConfig(dashboard: DashboardSpec): DashboardFilterPanelConfig | undefined;
+/**
+ * True when the dashboard shows this widget in its filter panel rather than as a
+ * tile, so it must not reserve a cell on the grid.
+ */
+declare function isPanelledControl(widget: WidgetSpec, dashboard: DashboardSpec): boolean;
+/**
+ * Drop the panelled controls from every breakpoint of a set of layouts.
+ *
+ * A control drawn in the filter panel that still holds a cell leaves a hole the
+ * tiles around it were placed away from, and free placement never closes it.
+ */
+declare function stripPanelledControls(layouts: ResponsiveLayouts, widgets: Record<string, WidgetSpec>, dashboard: DashboardSpec): ResponsiveLayouts;
+declare function layoutForBreakpoint(widget: WidgetSpec, bp: Breakpoint, colCount: number, maxRows?: number): LayoutItem;
+/** True when two grid items share any cell. */
+declare function itemsCollide(a: LayoutItem, b: LayoutItem): boolean;
+/**
+ * The topmost, then leftmost, empty rectangle that fits a widget of this size.
+ *
+ * Scanning for a gap rather than always appending at the bottom is what makes a
+ * widget land somewhere usable: a dashboard with one tall chart on the left has
+ * room beside it, and dropping the next widget far below that looks broken.
+ */
+declare function firstFreeSlot(existing: LayoutItem[], w: number, h: number, colCount: number): {
+    x: number;
+    y: number;
+};
+/**
+ * Push overlapping items down until nothing shares a cell.
+ *
+ * Positions are honoured where they can be: an item only moves when something
+ * already sits where it wants to be, and it moves down rather than sideways so
+ * columns the author chose survive. Rows are not capped here, because squashing
+ * an item back inside a row limit is what put two widgets on top of each other
+ * in the first place. Callers grow the grid instead.
+ */
+declare function resolveCollisions(items: LayoutItem[]): LayoutItem[];
+/** The rows every breakpoint needs before anything has to overlap. */
+declare function requiredRows(layouts: ResponsiveLayouts): number;
+/** The ids that sit on top of another widget, in the layout as given. */
+declare function overlappingIds(layouts: ResponsiveLayouts): string[];
+/**
+ * The ids whose position or size differ between two sets of layouts.
+ *
+ * *only* narrows this to a single breakpoint. A narrow breakpoint reflows what a
+ * wide one saved, so counting every breakpoint named widgets as moved that
+ * nobody looking at the page could see, and saving never cleared the notice.
+ */
+declare function movedIds(before: ResponsiveLayouts, after: ResponsiveLayouts, only?: string): string[];
+/**
+ * Ensure every grid breakpoint and widget has an explicit layout item.
+ *
+ * Responsive invents absent breakpoints and children while rendering. Keeping
+ * the coverage here means those generated positions never become drafts.
+ */
+declare function ensureLayoutCoverage(layouts: ResponsiveLayouts, widgets: Record<string, WidgetSpec>, dashboard: DashboardSpec, gridOverrides?: Partial<Record<Breakpoint, {
+    rowHeight?: number;
+    cols?: number;
+}>>, unplacedWidgetIds?: string[], maxRows?: number): ResponsiveLayouts;
+/**
+ * Scale horizontal geometry when a breakpoint changes column space.
+ *
+ * Positions and widths stay in the same relative place instead of being
+ * clamped into the new grid and then collision-resolved into a new order.
+ */
+declare function rescaleLayoutColumns(layouts: ResponsiveLayouts, key: string, oldCols: number, newCols: number): ResponsiveLayouts;
+declare function computeRequiredMaxRows(layouts: ResponsiveLayouts, widget: WidgetSpec, dashboard: DashboardSpec, gridOverrides?: Partial<Record<Breakpoint, {
+    rowHeight?: number;
+    cols?: number;
+}>>, currentMaxRows?: number): number | undefined;
+declare function addWidgetToLayouts(layouts: ResponsiveLayouts, widget: WidgetSpec, dashboard: DashboardSpec, gridOverrides?: Partial<Record<Breakpoint, {
+    rowHeight?: number;
+    cols?: number;
+}>>, maxRows?: number): ResponsiveLayouts;
+declare function filterLayoutsByIds(layouts: ResponsiveLayouts, ids: Set<string>): ResponsiveLayouts;
+declare function sanitizeLayouts(layouts: ResponsiveLayouts, cols: {
+    lg: number;
+    md: number;
+    sm: number;
+    xs: number;
+    xxs: number;
+}, maxRows?: number): ResponsiveLayouts;
+declare function mergeLayouts(base: ResponsiveLayouts, overlay: ResponsiveLayouts): ResponsiveLayouts;
+/**
+ * Copy the desktop (md) and wide (lg) layouts to each other when one side is
+ * empty. This keeps the editor and the wide preview in sync for dashboards that
+ * do not define separate responsive positions for desktop vs wide.
+ */
+declare function syncDesktopWideLayouts(layouts: ResponsiveLayouts, cols: {
+    lg: number;
+    md: number;
+    sm: number;
+    xs: number;
+    xxs: number;
+}): ResponsiveLayouts;
+/**
+ * Copy the active layout into its desktop/wide sibling when both breakpoints
+ * use the same number of columns. This ensures that dragging or resizing in one
+ * view is reflected in the other.
+ */
+declare function syncActiveLayoutToDesktopWide(layouts: ResponsiveLayouts, activeKey: string, cols: {
+    lg: number;
+    md: number;
+    sm: number;
+    xs: number;
+    xxs: number;
+}): ResponsiveLayouts;
+/**
+ * Stack the phone breakpoints of a set of layouts, leaving every other
+ * breakpoint untouched.
+ *
+ * Read at render time rather than saved, so a dashboard whose desktop layout
+ * changes later still reflows on a phone, and the YAML keeps whatever its author
+ * wrote.
+ */
+declare function stackNarrowLayouts(layouts: ResponsiveLayouts, cols: {
+    xs: number;
+    xxs: number;
+}): ResponsiveLayouts;
+declare function buildBaseLayouts(widgets: Record<string, WidgetSpec>, dashboard: DashboardSpec, gridOverrides?: Partial<Record<Breakpoint, {
+    rowHeight?: number;
+    cols?: number;
+}>>, unplacedWidgetIds?: string[], maxRows?: number, 
+/**
+ * Set false to read the positions exactly as the specs declare them, which is
+ * how a caller can tell what had to be moved to stop widgets overlapping.
+ */
+options?: {
+    resolve?: boolean;
+}): ResponsiveLayouts;
+/**
+ * The grid's layouts renamed for storage: `lg`, `md`, `sm`, `xs` become
+ * `wide`, `desktop`, `tablet`, `mobile`, which is how a widget document names
+ * its `layout.responsive` entries and what a layout save port expects.
+ * `xxs` only fills `mobile` when `xs` gave nothing.
+ */
+declare function layoutsForSave(layouts: ResponsiveLayouts): Partial<Record<Breakpoint, LayoutItem[]>>;
+
+/**
+ * Checks the Builder runs while you type, before the model reaches the API.
+ *
+ * These are the mistakes that make a widget fail at render time rather than at
+ * save time: a join naming a dataset that is not there, columns that do not pair
+ * up, a metric spanning two datasets nothing joins, or a join the engine cannot
+ * push into one warehouse. Server validation still runs on Validate and Save;
+ * this only shortens the loop.
+ */
+
+/** The store a dataset reads, following the default when it names none. */
+declare function storeOf(dataset: BuilderDataset, stores: BuilderDataStore[]): string | null;
+declare function relationshipIssues(relationship: BuilderRelationship, datasets: BuilderDataset[], stores: BuilderDataStore[]): string[];
+/** Dataset ids a model level metric expression reads, like `daily_sales.X`. */
+declare function datasetsInExpression(expression: string, datasetIds: string[]): string[];
+/** True when relationships connect the two datasets, directly or through others. */
+declare function datasetsAreJoined(a: string, b: string, relationships: BuilderRelationship[]): boolean;
+declare function modelMetricIssues(metric: BuilderModelMetric, datasets: BuilderDataset[], relationships: BuilderRelationship[]): string[];
+
+/**
+ * Ready-to-edit YAML blocks for the semantic model.
+ *
+ * Starting from a correct block with the required fields present is the fastest
+ * path for someone who has never written the model by hand, and it avoids the
+ * two mistakes that cost the most time: a dataset with no `filter_field`, and a
+ * relationship with mismatched join columns.
+ */
+interface ModelTemplate {
+    id: string;
+    label: string;
+    /** Top-level key the block belongs under. */
+    section: "data_stores" | "datasets" | "relationships" | "metrics";
+    description: string;
+    yaml: string;
+}
+declare const MODEL_TEMPLATES: ModelTemplate[];
+/**
+ * Add a template's block to the right section of an existing document.
+ *
+ * Edits the text rather than re-serialising the document, so comments, key order
+ * and formatting survive. Three cases: the section already has entries (append
+ * after the last one), the section exists but is empty (replace the `[]`), or the
+ * section is missing (append it at the end).
+ */
+declare function insertModelTemplate(specYaml: string, template: ModelTemplate): string;
+
+/**
+ * How far each pivot widget opens in a delivery, as form values.
+ *
+ * A pivot on the page is folded and unfolded by whoever is reading it. A
+ * delivered PNG, PDF or CSV has nobody at the keyboard, so how much of the
+ * hierarchy the document shows has to be part of the schedule or export
+ * itself. Each pivot gets two controls: how many row levels open and how many
+ * column header levels open. Everything open is the default; a level count
+ * folds what sits past it, and "widget setting" falls back to the pivot's own
+ * snapshot block. The XLSX and PPTX pivots always carry the whole cross-tab,
+ * so none of this touches them. The logic lives here rather than in the form
+ * component so it is testable on its own.
+ */
+
+/** What one pivot's two controls hold: a level count, or a named choice. */
+interface PivotAxisValues {
+    rows: string;
+    columns: string;
+}
+/** What each pivot's controls hold, keyed by widget id. */
+type PivotExpandValues = Record<string, PivotAxisValues>;
+/** Everything open, which sends the axis's own level count. */
+declare const OPEN_ALL = "all";
+/** Fall back to the widget's own snapshot setting for that axis. */
+declare const WIDGET_SETTING = "widget";
+/** Every pivot fully expanded, which is what a new schedule starts from. */
+declare function defaultPivotExpand(pivots: DashboardPivotInfo[]): PivotExpandValues;
+/**
+ * Each pivot as it stands open on the dashboard right now, so an export
+ * carries the view the reader is looking at. A pivot the page has not drawn
+ * this session falls back to fully expanded.
+ */
+declare function currentViewPivotExpand(pivots: DashboardPivotInfo[], readPivotOpenLevels?: ReadPivotOpenLevels): PivotExpandValues;
+/**
+ * The stored map as the strings the form's controls hold. A stored entry is a
+ * bare number of row levels, which is what older schedules wrote, or an
+ * object with `rows` and `columns`. A pivot or an axis the map does not name
+ * shows "widget setting", which is what its absence meant when it was saved.
+ */
+declare function readPivotExpand(stored: Record<string, PivotExpandEntry> | null | undefined, pivots: DashboardPivotInfo[]): PivotExpandValues;
+/** The controls' values as the map the API stores, or undefined when empty. */
+declare function cleanPivotExpand(values: PivotExpandValues, pivots: DashboardPivotInfo[]): Record<string, {
+    rows?: number;
+    columns?: number;
+}> | undefined;
+/** The reason these values cannot be saved, or null when they can. */
+declare function pivotExpandError(pivots: DashboardPivotInfo[], values: PivotExpandValues): string | null;
+
+/**
+ * What the dashboard YAML editor checks before it lets an author save: that
+ * the text parses, calls itself a dashboard, and that every tab names widgets
+ * that exist. It reads the raw document rather than the typed spec so a
+ * half-written page can still be reported line by line.
+ */
+interface DashboardOutline {
+    id: string | null;
+    name: string | null;
+    /** Tab ids in authored order. Each tab is one dashboard page. */
+    tabIds: string[];
+    /** Widget refs across every tab, in page order. */
+    widgetRefs: string[];
+    /** Why the document cannot be saved, or empty. */
+    issues: string[];
+}
+declare function readDashboardOutline(specYaml: string): DashboardOutline;
+
+/**
+ * Ready-to-edit YAML for a brand new widget.
+ *
+ * A blank widget still has to be a valid document, because the Builder reads it
+ * back the moment it is created. Every template therefore carries the metadata
+ * block, a layout the grid can place, and the display block the component's
+ * renderer reads, with the parts an author fills in left empty rather than
+ * absent.
+ */
+/** Components a blank widget can be created as. */
+declare const TEMPLATE_COMPONENTS: readonly ["kpi", "filter", "table", "tabulator", "pivot_table", "text", "echarts", "image", "markdown"];
+type TemplateComponent = (typeof TEMPLATE_COMPONENTS)[number];
+/** The shapes a filter widget can take, which change its data block. */
+declare const FILTER_CONTROLS: readonly ["select", "date", "date_range", "custom"];
+type FilterControlType = (typeof FILTER_CONTROLS)[number];
+declare function templateComponentLabel(component: TemplateComponent): string;
+interface WidgetTemplateOptions {
+    /** What the widget is called, which also seeds its id. */
+    name?: string;
+    /** Only read for a filter widget. */
+    filterControl?: FilterControlType;
+    /**
+     * The tail of the generated id. Passed in by a caller that needs the same
+     * text twice, and otherwise drawn at random so two blank widgets created in
+     * one sitting do not collide.
+     */
+    suffix?: string;
+}
+/** The YAML of a blank widget of this component. */
+declare function widgetTemplate(component: TemplateComponent, options?: WidgetTemplateOptions): string;
+
+/**
+ * Put widget problems on the line that causes them.
+ *
+ * Same idea as the semantic model editor: a list of sentences under the editor
+ * leaves the reader hunting for the mapping or the column the sentence is about.
+ * These helpers find the node each finding belongs to and return an editor marker,
+ * so the offending line is underlined where it lives.
+ */
+
+/**
+ * Markers for everything that would make this widget render empty.
+ *
+ * A syntax error stops the rest: the document cannot be read, so every other
+ * finding would be guesswork, and one accurate marker beats a list of noise.
+ */
+declare function widgetMarkers(specYaml: string, model: SemanticSummary): ModelMarker[];
+
+declare function valueScaleBounds(values: readonly number[]): {
+    min: number;
+    max: number;
+};
+declare function applyChartDefaults(option: ChartOption): ChartOption;
+
+declare function buildChartRendererModel(widget: WidgetSpec, result: WidgetResult, context?: RendererContext): ChartRendererModel;
+
+interface ChartFields {
+    x: string;
+    category: string;
+    value: string;
+}
+declare function inferChartFields(rows: DataRow[]): ChartFields;
+declare function buildChartOption(widget: WidgetSpec, result: WidgetResult): ChartOption;
+declare function chartAxisKey(option: unknown): string;
+
+interface ChartThemeTokens {
+    foreground: string;
+    mutedForeground: string;
+    border: string;
+    surface: string;
+    surfaceForeground: string;
+    fontFamily: string;
+    seriesColors: readonly string[];
+    heatmapColors?: readonly string[];
+}
+interface ChartLoadingOptions {
+    text: string;
+    color: string;
+    textColor: string;
+    maskColor: string;
+    zlevel: number;
+    fontFamily: string;
+    fontSize: number;
+}
+declare function buildChartTheme(tokens: ChartThemeTokens): ChartOption;
+declare function withChartMotion(option: ChartOption, reduced: boolean): ChartOption;
+declare function chartStructureKey(option: ChartOption): string;
+declare function chartLoadingOptions(tokens: ChartThemeTokens, mode: "light" | "dark"): ChartLoadingOptions;
+
+declare function projectTabularGrid<TOutput>(model: TabularRendererModel, adapter: TabularGridAdapter<TOutput>): TOutput;
+
+declare function buildKpiRendererModel(widget: WidgetSpec, result: WidgetResult, context?: RendererContext): KpiRendererModel;
+declare function buildTextRendererModel(widget: WidgetSpec, context?: RendererContext): TextRendererModel;
+declare function buildMarkdownRendererModel(widget: WidgetSpec, context?: RendererContext): MarkdownRendererModel;
+declare function buildImageRendererModel(widget: WidgetSpec, context?: RendererContext): BasicRendererModel;
+declare function buildBasicRendererModel(widget: WidgetSpec, result?: WidgetResult, context?: RendererContext): BasicRendererModel;
+declare function buildWidgetRendererModel(widget: WidgetSpec, result?: WidgetResult, context?: RendererContext): WidgetRenderResolution;
+
+declare function isPivotColumnGroup(definition: PivotGridColumnDefinition): definition is PivotGridColumnGroup;
+declare function readPivotPayload(result: Record<string, unknown> | undefined): PivotTablePayload | null;
+declare function buildPivotColumns(payload: PivotTablePayload, collapsedColumns?: ReadonlySet<string>): PivotGridColumnDefinition[];
+declare function pivotColumnGroups(payload: PivotTablePayload): PivotFieldPayload[];
+declare function pivotValueColumns(payload: PivotTablePayload, collapsedColumns?: ReadonlySet<string>): PivotFieldPayload[];
+declare function buildPivotRows(payload: PivotTablePayload, rows?: PivotRowPayload[]): PivotGridRow[];
+declare function buildPivotTotalRow(payload: PivotTablePayload): PivotGridRow | null;
+declare function pivotRowFilters(payload: PivotTablePayload, meta: PivotGridRowMeta): Record<string, string>;
+declare function pivotColumnFilters(payload: PivotTablePayload, prop: string): Record<string, string> | null;
+declare function pivotMeasuresByKey(payload: PivotTablePayload): Map<string, PivotMeasurePayload>;
+declare function pivotRowMeta(row: Record<string, unknown> | undefined): PivotGridRowMeta | null;
+declare function formatPivotValue(value: unknown, measure: PivotMeasurePayload | undefined, emptyValue: string): string;
+declare function pivotHeatmapIntensity(value: unknown, range: {
+    min: number;
+    max: number;
+} | undefined): number | null;
+declare function pivotTruncationNote(payload: PivotTablePayload): string | null;
+
+declare function buildPivotRendererModel(widget: WidgetSpec, result: WidgetResult, context?: RendererContext): PivotRendererModel;
+declare function pivotCellPresentation(model: ReadyPivotRendererModel, row: Record<string, unknown>, column: PivotGridColumn): PivotCellPresentation;
+declare function pivotCellAction(model: ReadyPivotRendererModel, widget: WidgetSpec, row: PivotGridRowMeta, column: PivotGridColumn, value: unknown, detailAvailable?: boolean): PivotCellAction | null;
+
+interface PivotOpenLevelsRegistry {
+    publish(widgetId: string, levels: PivotOpenLevels): void;
+    clear(widgetId: string): void;
+    read(widgetId: string): PivotOpenLevels | null;
+}
+declare function createPivotOpenLevelsRegistry(): PivotOpenLevelsRegistry;
+
+declare function initialPivotViewState(payload: PivotTablePayload, capture?: boolean): PivotViewState;
+declare function pivotOpenRowLevels(payload: PivotTablePayload, state: PivotViewState): number | null;
+declare function pivotOpenColumnLevels(payload: PivotTablePayload, state: PivotViewState): number | null;
+declare function pivotSignature(payload: PivotTablePayload): string;
+declare function pivotGroupKeys(payload: PivotTablePayload): string[];
+declare function pivotHasGroups(payload: PivotTablePayload): boolean;
+declare function pivotFilterCount(state: PivotViewState): number;
+declare function setPivotColumnFilter(filters: Readonly<Record<string, PivotColumnFilter>>, column: string, filter: PivotColumnFilter | null): Record<string, PivotColumnFilter>;
+declare function pivotFilterKeeps(value: number, filter: PivotColumnFilter): boolean;
+declare function pivotVisibleRows(payload: PivotTablePayload, state: PivotViewState): PivotRowPayload[];
+declare function pivotSortDirection(state: PivotViewState, payload: PivotTablePayload, column: string): PivotDirection | null;
+declare function nextPivotSort(state: PivotViewState, payload: PivotTablePayload, column: string): PivotSortState | null;
+declare function togglePivotGroup(collapsed: ReadonlySet<string>, key: string): Set<string>;
+
+interface ReaderGridTile {
+    widgetId: string;
+    left: number;
+    top: number;
+    width: number;
+    height: number;
+}
+interface ReaderGrid {
+    layoutKey: LayoutKey;
+    breakpoint: Breakpoint;
+    /** The height the tiles need, so a host can size the canvas it draws into. */
+    height: number;
+    columnCount: number;
+    columnWidth: number;
+    rowHeight: number;
+    tiles: ReaderGridTile[];
+}
+interface ReaderGridInput {
+    dashboard: DashboardSpec;
+    widgets: Record<string, WidgetSpec>;
+    /** The measured canvas width in pixels. */
+    width: number;
+}
+/**
+ * The reader grid in pixels, from the same layout maths the builder saves.
+ *
+ * Every UI binding places the tiles this returns, which is why a dashboard reads
+ * the same in React, in Angular, in Next.js and in a plain browser page.
+ */
+declare function buildReaderGrid(input: ReaderGridInput): ReaderGrid;
+/** The renderer context a dashboard's widget defaults imply, and nothing else. */
+declare function readerRendererContext(dashboard: DashboardSpec): RendererContext;
+
+declare function createRendererRegistry(initial?: Readonly<Record<string, RendererExtension>>): RendererRegistry;
+
+declare function resolveWidgetRenderState(widget: WidgetSpec, result?: WidgetResult, options?: {
+    loading?: boolean;
+    answeredOnce?: boolean;
+    retryable?: boolean;
+}): WidgetRenderResolution;
+
+declare function tableResultColumns(result: WidgetResult, rows?: DataRow[]): string[];
+declare function tableExportModel(display: Record<string, unknown>, fallbackFilename: string, excelExport?: boolean): TableExportModel;
+declare function sortTableRows(rows: DataRow[], sort: TableSortState | null, sortable?: boolean): DataRow[];
+declare function nextTableSort(current: TableSortState | null, column: string, sortable?: boolean): TableSortState | null;
+declare function formatTableCell(value: unknown, emptyValue?: string): string;
+declare function buildTableRendererModel(widget: WidgetSpec, result: WidgetResult, context?: RendererContext): TableRendererModel;
+declare function formatGridCell(value: unknown, formatter: GridColumnFormatterModel | undefined): string;
+declare function buildGridColumns(resultColumns: string[], display: Record<string, unknown>): GridColumnModel[];
+declare function buildTabulatorRendererModel(widget: WidgetSpec, result: WidgetResult, context?: RendererContext): TabulatorRendererModel;
+declare function tableInteraction(widget: WidgetSpec, row: DataRow, columns: string[]): {
+    interaction: WidgetInteraction;
+    context: WidgetInteractionContext;
+} | undefined;
+
+declare const DEFAULT_WIDGET_DEFAULTS: WidgetDefaults;
+declare function resolveTheme(widget: WidgetSpec, component: WidgetComponent, widgetDefaults?: WidgetDefaults): WidgetTheme;
+declare function widgetThemeStyle(theme: WidgetTheme): Record<string, string | number>;
+/**
+ * The theme a renderer applies when a host frame already draws the card. Only
+ * the inner spacing survives; border, radius, shadow and background belong to
+ * the frame, so applying them twice would draw a second box inside the card.
+ */
+declare function innerTheme(theme: WidgetTheme): WidgetTheme;
+declare function rendererFrame(widget: WidgetSpec, component: WidgetComponent, widgetDefaults?: WidgetDefaults, framed?: boolean): RendererFrame;
+
+interface ValueFormatOptions {
+    format?: string;
+    prefix?: string;
+    compact?: boolean;
+    suffix?: string;
+    decimals?: number;
+}
+declare function formatCompactNumber(value: number): string;
+declare function formatValue(value: number | null | undefined, options?: ValueFormatOptions): string;
+declare function applyNamedFormatters(option: ChartOption): ChartOption;
+
+declare function clearElement(element: HTMLElement): void;
+declare function setStyles(element: HTMLElement, styles: Readonly<Record<string, string | number | undefined>>): void;
+declare function applyWidgetTheme(element: HTMLElement, frame: RendererFrame, tokens: RendererThemeTokens): void;
+declare function createLabel(document: Document, text: string, tokens: RendererThemeTokens): HTMLElement;
+declare function createMessage(document: Document, message: string, kind: "error" | "loading" | "notice", tokens: RendererThemeTokens): HTMLElement;
+
+declare function renderInlineMarkdown(document: Document, parent: HTMLElement, content: string): void;
+declare function renderMarkdown(document: Document, parent: HTMLElement, markdown: string): void;
+
+declare function createNativeWidgetRenderer(input: NativeWidgetRenderInput): BrowserRenderer<NativeWidgetRenderInput>;
+
+interface DashboardReaderShellInput {
+    /** The element the reader draws into. It is emptied on mount. */
+    element: HTMLElement;
+    dashboard: DashboardSpec;
+    widgets: Record<string, WidgetSpec>;
+    results?: Record<string, WidgetResult>;
+    /**
+     * Factories keyed by widget component or renderer kind. Anything not named
+     * here is drawn by the native browser renderer.
+     */
+    renderers?: WidgetRendererFactories;
+    /** Filter values by widget id, which the host owns. */
+    filters?: Record<string, unknown>;
+    /** Widget ids the reader is still waiting on. */
+    loadingWidgetIds?: string[];
+    activeTabId?: string;
+    theme?: Partial<RendererThemeTokens>;
+    callbacks?: RendererHostCallbacks;
+    onTabChange?: (tabId: string) => void;
+    /** Overrides the measured width, which is how a test fixes a size. */
+    viewportWidth?: number;
+}
+interface DashboardReaderShell {
+    /** Redraws with a new document, new results, new filters or a new tab. */
+    update(next: DashboardReaderShellInput): void;
+    /** The tab the reader is showing. */
+    activeTabId(): string | undefined;
+    resize(): void;
+    destroy(): void;
+}
+/**
+ * A whole dashboard reader in the browser, with no UI framework.
+ *
+ * The shell owns tabs, the filter panel and the grid; every widget is drawn by a
+ * renderer factory the host wires, so a plain page, an Angular component and a
+ * Next.js page all read a dashboard the same way the React binding does.
+ */
+declare function mountDashboardReader(input: DashboardReaderShellInput): DashboardReaderShell;
+
+interface ResizeObserverAttachment {
+    disconnect(): void;
+}
+declare function observeElementResize(element: HTMLElement, work: () => void): ResizeObserverAttachment | null;
+
+/**
+ * The native renderer as a shell factory, so a host wires one entry rather than
+ * repeating the lifecycle for every component the browser draws itself.
+ */
+declare function createNativeWidgetFactory(): WidgetRendererFactory;
+
+export { BREAKPOINT_MAP, BasicRendererModel, Breakpoint, BrowserRenderer, BuilderDataStore, BuilderDataset, BuilderModelMetric, BuilderRelationship, CONTROL_COMPONENTS, type ChartLoadingOptions, ChartOption, ChartRendererModel, type ChartThemeTokens, DEFAULT_GRID_CONFIG, DEFAULT_WIDGET_DEFAULTS, DashboardFilterPanelConfig, DashboardGridConfig, type DashboardOutline, DashboardPivotInfo, type DashboardReaderShell, type DashboardReaderShellInput, DashboardSpec, type DashboardTemplateOptions, DataRow, type DocumentKind, type ExpressionContext, type ExpressionRow, FILTER_CONTROLS, type FilterControlType, GridColumnFormatterModel, GridColumnModel, KpiRendererModel, LayoutItem, LayoutKey, MAX_LAYOUT_WIDTHS, MODEL_TEMPLATES, MarkdownRendererModel, ModelMarker, type ModelTemplate, NativeWidgetRenderInput, OPEN_ALL, type PivotAxisValues, PivotCellAction, PivotCellPresentation, PivotColumnFilter, PivotExpandEntry, type PivotExpandValues, PivotFieldPayload, PivotGridColumn, PivotGridColumnDefinition, PivotGridColumnGroup, PivotGridRow, PivotGridRowMeta, PivotMeasurePayload, type PivotOpenLevelsRegistry, PivotRendererModel, PivotRowPayload, PivotSortState, PivotTablePayload, PivotViewState, ReadPivotOpenLevels, type ReaderGrid, type ReaderGridInput, type ReaderGridTile, ReadyPivotRendererModel, RendererContext, RendererExtension, RendererFrame, RendererHostCallbacks, PivotDirection as RendererPivotDirection, PivotOpenLevels as RendererPivotOpenLevels, RendererRegistry, RendererThemeTokens, type ResizeObserverAttachment, ResponsiveLayouts, type SemanticModel, SemanticSummary, TEMPLATE_COMPONENTS, TableExportModel, TableRendererModel, TableSortState, TabularGridAdapter, TabularRendererModel, TabulatorRendererModel, type TemplateComponent, TextRendererModel, type ValueFormatOptions, WIDGET_SETTING, WidgetComponent, WidgetDefaults, WidgetInteraction, WidgetInteractionContext, WidgetRenderResolution, WidgetRendererFactories, WidgetRendererFactory, WidgetResult, WidgetSpec, type WidgetTemplateOptions, WidgetTheme, addWidgetToLayouts, applyChartDefaults, applyFilter, applyNamedFormatters, applyWidgetTheme, buildBaseLayouts, buildBasicRendererModel, buildChartOption, buildChartRendererModel, buildChartTheme, buildGridColumns, buildImageRendererModel, buildKpiRendererModel, buildMarkdownRendererModel, buildPivotColumns, buildPivotRendererModel, buildPivotRows, buildPivotTotalRow, buildReaderGrid, buildTableRendererModel, buildTabulatorRendererModel, buildTextRendererModel, buildWidgetRendererModel, chartAxisKey, chartLoadingOptions, chartStructureKey, cleanPivotExpand, clearElement, computeRequiredMaxRows, createLabel, createMessage, createNativeWidgetFactory, createNativeWidgetRenderer, createPivotOpenLevelsRegistry, createRendererRegistry, currentViewPivotExpand, dashboardTemplate, datasetsAreJoined, datasetsInExpression, defaultPivotExpand, documentKinds, documentVersion, ensureLayoutCoverage, evaluateExpression, evaluateVariables, fillFilterTokens, filterLayoutsByIds, filterPanelConfig, firstFreeSlot, formatCompactNumber, formatFilterValue, formatGridCell, formatPivotValue, formatTableCell, formatValue, inferChartFields, initialPivotViewState, innerTheme, insertModelTemplate, interpolateVariables, isControlComponent, isPanelledControl, isPivotColumnGroup, itemsCollide, layoutForBreakpoint, layoutsForSave, mentionsFilter, mergeLayouts, modelMetricIssues, mountDashboardReader, movedIds, nextPivotSort, nextTableSort, observeElementResize, overlappingIds, pivotCellAction, pivotCellPresentation, pivotColumnFilters, pivotColumnGroups, pivotExpandError, pivotFilterCount, pivotFilterKeeps, pivotGroupKeys, pivotHasGroups, pivotHeatmapIntensity, pivotMeasuresByKey, pivotOpenColumnLevels, pivotOpenRowLevels, pivotRowFilters, pivotRowMeta, pivotSignature, pivotSortDirection, pivotTruncationNote, pivotValueColumns, pivotVisibleRows, projectTabularGrid, readDashboardOutline, readPivotExpand, readPivotPayload, readerRendererContext, relationshipIssues, renderInlineMarkdown, renderMarkdown, rendererFrame, requiredRows, rescaleLayoutColumns, resolveCollisions, resolveFilterDefault, resolveSnap, resolveTheme, resolveWidgetRenderState, sanitizeLayouts, setPivotColumnFilter, setStyles, sortTableRows, stackNarrowLayouts, storeOf, stripPanelledControls, syncActiveLayoutToDesktopWide, syncDesktopWideLayouts, tableExportModel, tableInteraction, tableResultColumns, templateComponentLabel, togglePivotGroup, valueScaleBounds, widgetMarkers, widgetTemplate, widgetThemeStyle, withChartMotion };