cortena-ui 1.3.0 → 1.4.0

package/dist/index.d.ts

@@ -1,2679 +1,76 @@
 "use client";
-import { ClassValue } from "clsx";
-import { z } from "zod";
-import * as React$1 from "react";
-import { ReactNode } from "react";
-import { VariantProps } from "class-variance-authority";
-import { Button as Button$1 } from "@base-ui/react/button";
-import { Area, AreaChart, Bar, BarChart, CartesianGrid, Cell, ComposedChart, Funnel, FunnelChart, LabelList, Legend as RechartsLegend, LegendPayload, LegendProps, Line, LineChart, Pie, PieChart, PolarAngleAxis, PolarGrid, PolarRadiusAxis, Radar, RadarChart, ReferenceLine, ResponsiveContainer, Scatter, ScatterChart, Tooltip as RechartsTooltip, TooltipContentProps as TooltipContentProps$1, TooltipProps, XAxis, YAxis } from "recharts";
-import { Checkbox as Checkbox$1 } from "@base-ui/react/checkbox";
-import { Menu } from "@base-ui/react/menu";
-import { Select as Select$1 } from "@base-ui/react/select";
-import { Cell as Cell$2, Column, ColumnDef, ColumnHelper, ReactTable, Row, RowData, TableState } from "@tanstack/react-table";
-import { DateRange, DayButtonProps, DayPickerProps } from "react-day-picker";
-import { Popover as Popover$1 } from "@base-ui/react/popover";
-import { Field as Field$1 } from "@base-ui/react/field";
-import { Fieldset as Fieldset$1 } from "@base-ui/react/fieldset";
-import { Components, Options } from "react-markdown";
-import { Options as Options$1 } from "rehype-sanitize";
-import { Progress as Progress$1 } from "@base-ui/react/progress";
-import { Radio } from "@base-ui/react/radio";
-import { RadioGroup as RadioGroup$1 } from "@base-ui/react/radio-group";
-import { Separator as Separator$1 } from "@base-ui/react/separator";
-import { Switch as Switch$1 } from "@base-ui/react/switch";
-import { Tabs as Tabs$1 } from "@base-ui/react/tabs";
-import { Accordion as Accordion$1 } from "@base-ui/react/accordion";
-import { Avatar as Avatar$1 } from "@base-ui/react/avatar";
-import { Combobox as Combobox$1 } from "@base-ui/react/combobox";
-import { Command as Command$1 } from "cmdk";
-import { Dialog as Dialog$1 } from "@base-ui/react/dialog";
-import { Accept, DropzoneState, FileRejection } from "react-dropzone";
-import { ControllerProps, FieldError as FieldError$1, FieldPath, FieldValues, SubmitHandler, UseFormReturn, useForm } from "react-hook-form";
-import { zodResolver } from "@hookform/resolvers/zod";
-import { ScrollArea as ScrollArea$1 } from "@base-ui/react/scroll-area";
-import { DraggableAttributes, UniqueIdentifier } from "@dnd-kit/core";
-import { arrayMove } from "@dnd-kit/sortable";
-import { Toast as Toast$1 } from "@base-ui/react/toast";
-import { Tooltip as Tooltip$2 } from "@base-ui/react/tooltip";
-//#region src/lib/cn.d.ts
-/**
- * Merge class names the shadcn way: clsx for conditionals, tailwind-merge so a
- * consumer's `className` wins over a component's default for the same utility.
- */
-export declare function cn(...inputs: ClassValue[]): string;
-//#endregion
-//#region src/a2ui/message.d.ts
-/**
- * A2UI message layer.
- *
- * The wire format cortena-ui accepts, and the fold from a stream of messages
- * onto a set of surfaces. Deliberately free of React so it can be reused by a
- * canvas host, a test fixture, or the catalogue doc generator.
- *
- * ## Two dialects, one fold
- *
- * **v0.9** is the current A2UI protocol (`createSurface`, `updateComponents`,
- * `updateDataModel`, `deleteSurface`) and is what an agent should emit.
- *
- * **v0.8** is what Cortena already speaks: core bundles Google's A2UI Lit
- * renderer at `src/canvas-host/a2ui/` and its `A2uiMessageProcessor` handles
- * `beginRendering`, `surfaceUpdate`, `dataModelUpdate` and `deleteSurface`.
- * The `canvas` agent tool pushes exactly those, as JSON lines, through
- * `canvas.a2ui.pushJSONL`. Accepting both means one renderer serves the chat,
- * the web canvas panel and every payload already written against the native
- * nodes.
- *
- * ## Transport
- *
- * Per `05-agent-ui.md`, an A2UI block travels as an AG-UI `CUSTOM` event. The
- * event value is a message, an array of messages, or the JSONL text the canvas
- * tool sends; {@link parseA2UIMessages} takes all three.
- */
-/** Surface id used when a message omits one, matching core's Lit processor. */
-export declare const A2UI_DEFAULT_SURFACE_ID = "@default";
-/** Protocol version this package speaks. */
-export declare const A2UI_VERSION = "v0.9";
-/** A reference to a value in the surface's data model, as a JSON pointer. */
-interface A2UIDataBinding {
-  path: string;
-}
-/**
- * A property value as an agent writes it: a literal, a data binding, or one of
- * the v0.8 literal wrappers the Lit renderer accepts.
- */
-type A2UIPropertyValue = string | number | boolean | null | A2UIDataBinding | {
-  literal: unknown;
-} | {
-  literalString: string;
-} | readonly A2UIPropertyValue[] | {
-  readonly [key: string]: unknown;
-};
-/**
- * A component's children. v0.9 uses a plain id array or a `{ componentId, path }`
- * template; v0.8 wraps the same two in `explicitList` / `template`.
- */
-type A2UIChildList = readonly string[] | {
-  componentId: string;
-  path: string;
-} | {
-  explicitList: readonly string[];
-} | {
-  template: {
-    componentId: string;
-    dataBinding: string;
-  };
-};
-/** An action an agent attaches to an interactive property. */
-type A2UIActionSpec = string | {
-  event: {
-    name: string;
-    context?: Record<string, unknown>;
-  };
-} | {
-  name: string;
-  context?: Record<string, unknown>;
-};
-/**
- * One component in a surface.
- *
- * v0.9 is flat — `{ id, component: "Text", text: "hi" }` — and v0.8 wraps the
- * properties under the type name — `{ id, component: { Text: { text: "hi" } } }`.
- */
-interface A2UIComponentSpec {
-  id: string;
-  component: string | Record<string, Record<string, unknown>>;
-  children?: A2UIChildList;
-  /** v0.8 flex weight; carried through but not used for layout here. */
-  weight?: number | string;
-  [property: string]: unknown;
-}
-interface A2UICreateSurface {
-  surfaceId?: string;
-  catalogId?: string;
-  /** Not in the v0.9 schema; accepted so a single message can seed a surface. */
-  root?: string;
-  sendDataModel?: boolean;
-}
-interface A2UIUpdateComponents {
-  surfaceId?: string;
-  components: A2UIComponentSpec[];
-  root?: string;
-}
-interface A2UIUpdateDataModel {
-  surfaceId?: string;
-  path?: string;
-  value?: unknown;
-  /** v0.8 spelling of `value`. */
-  contents?: unknown;
-}
-interface A2UIBeginRendering {
-  surfaceId?: string;
-  root?: string;
-  styles?: Record<string, unknown>;
-}
-interface A2UIDeleteSurface {
-  surfaceId?: string;
-}
-/** One message on the wire. Exactly one operation key is read per message. */
-interface A2UIMessage {
-  version?: string;
-  createSurface?: A2UICreateSurface;
-  updateComponents?: A2UIUpdateComponents;
-  updateDataModel?: A2UIUpdateDataModel;
-  deleteSurface?: A2UIDeleteSurface;
-  /** v0.8 */
-  beginRendering?: A2UIBeginRendering;
-  /** v0.8 */
-  surfaceUpdate?: A2UIUpdateComponents;
-  /** v0.8 */
-  dataModelUpdate?: A2UIUpdateDataModel;
-}
-/**
- * Everything the renderer's `message` prop takes: one message, a list of them
- * (the AG-UI `CUSTOM` payload), or JSONL / a JSON array as text (the canvas
- * tool's `a2ui_push`).
- */
-type A2UIMessageInput = A2UIMessage | readonly A2UIMessage[] | string | null | undefined;
-/** A folded surface: what the renderer draws. */
-interface A2UISurface {
-  id: string;
-  /** Id of the root component; `undefined` until a message names one. */
-  root: string | undefined;
-  components: ReadonlyMap<string, A2UIComponentSpec>;
-  dataModel: Record<string, unknown>;
-  styles: Record<string, unknown>;
-}
-interface A2UIFoldResult {
-  surfaces: A2UISurface[];
-  /** One line per malformed message; the renderer shows these in an error card. */
-  errors: string[];
-}
-/** True when a value is a `{ path }` data binding rather than a literal object. */
-export declare function isDataBinding(value: unknown): value is A2UIDataBinding;
-/**
- * Parse whatever arrived into a message list.
- *
- * A string is tried as JSON first (an array or a single message) and then as
- * JSONL, which is the form `canvas.a2ui.pushJSONL` sends. A line that does not
- * parse is reported rather than dropped: silently rendering three of four
- * pushed messages is the failure mode this returns errors for.
- */
-export declare function parseA2UIMessages(input: A2UIMessageInput): {
-  messages: A2UIMessage[];
-  errors: string[];
-};
-/**
- * Fold a message stream onto surfaces.
- *
- * Updates accumulate: a later `updateComponents` replaces the components it
- * names and leaves the rest, and a later `updateDataModel` writes at its path
- * only. That is what makes the JSONL push form work — the agent sends the
- * shell, then the rows, then a correction, and each one folds onto the same
- * surface.
- */
-export declare function foldMessages(input: A2UIMessageInput): A2UIFoldResult;
-/** Split a JSON pointer into its unescaped segments. */
-export declare function pointerSegments(pointer: string): string[];
-/** Resolve a possibly relative pointer against a data context. */
-export declare function resolvePointer(path: string, contextPath: string): string;
-/** Read a JSON pointer out of the data model. */
-export declare function getAtPointer(model: unknown, pointer: string): unknown;
-/**
- * Write a JSON pointer into the data model, returning a new model.
- *
- * Immutable because the renderer keeps the model in React state: a mutation in
- * place would not re-render, which is the kind of silent nothing-happens bug
- * that is hard to see in a browser test.
- */
-export declare function setAtPointer(model: Record<string, unknown>, pointer: string, value: unknown): Record<string, unknown>;
-/** Normalise the children of a component spec into a single description. */
-type A2UIChildren = {
-  kind: "list";
-  ids: readonly string[];
-} | {
-  kind: "template";
-  componentId: string;
-  path: string;
-} | {
-  kind: "none";
-};
-export declare function readChildren(spec: A2UIComponentSpec, properties: Record<string, unknown>): A2UIChildren;
-/**
- * Split a component spec into its type name and its raw (unresolved) properties,
- * across both dialects. Returns `undefined` when the spec names no type.
- */
-export declare function readComponent(spec: A2UIComponentSpec): {
-  name: string;
-  properties: Record<string, unknown>;
-} | undefined;
-/**
- * Resolve one property value against the data model.
- *
- * `{ path }` reads the model, `{ literal }` / `{ literalString }` unwrap, and
- * everything else is returned as written, recursing through arrays and objects
- * so a binding nested inside a prop object still resolves.
- */
-export declare function resolveValue(value: unknown, model: Record<string, unknown>, contextPath: string): unknown;
-/** A user action leaving the renderer, shaped like A2UI's client-to-server action. */
-interface A2UIAction {
-  surfaceId: string;
-  componentId: string;
-  name: string;
-  payload: Record<string, unknown>;
-}
-/**
- * Normalise an action property into `{ name, context }`.
- *
- * Accepts v0.9's `{ event: { name, context } }`, the bare `{ name, context }`
- * shape, and a plain string, which is what an agent writes most often.
- */
-export declare function readAction(value: unknown): {
-  name: string;
-  context: Record<string, unknown>;
-} | undefined;
-//#endregion
-//#region src/components/chart/types.d.ts
-/**
- * Chart types and the data shape each one expects.
- *
- * Engine per type (see cortena-docs/cortenaUI&Design/03-charting.md):
- *
- * | type                                                     | engine                    |
- * | -------------------------------------------------------- | ------------------------- |
- * | bar, line, area, pie, donut, scatter, radar, funnel      | Recharts (static import)  |
- * | heatmap, calendar, treemap, sunburst                     | Nivo (lazy, per package)  |
- *
- * Data shapes (the webchat renderer's legacy shapes are all accepted):
- *
- * - **bar**, **radar**: `ChartRow[]` — one object per category with a string
- *   category key (`indexBy`, inferred as the first string field) and one
- *   numeric field per series (`keys`, inferred as every numeric field).
- *   `[{ month: "Jan", revenue: 12, cost: 8 }, …]`. The series shape below is
- *   also accepted and pivoted.
- * - **line**, **area**: `ChartSeries[]` — `[{ id: "revenue", data: [{ x, y }] }]`
- *   (the Nivo line shape the webchat emits). `ChartRow[]` is also accepted.
- * - **pie**, **donut**, **funnel**: `ChartSlice[]` — `[{ id, label?, value }]`.
- * - **scatter** (alias `scatterplot`): `ChartSeries[]` — one series per group.
- * - **heatmap**: `ChartSeries[]` — Nivo heatmap shape, `[{ id: row, data: [{ x: column, y: value }] }]` —
- *   or `ChartMatrix`, the categorical form a correlation / confusion matrix
- *   already has: `{ rows, columns, values }` with `values[r][c]` at
- *   `rows[r] × columns[c]`.
- * - **calendar**: `ChartDay[]` — `[{ day: "2026-01-31", value }]`; `from`/`to`
- *   default to the data's range.
- * - **treemap**, **sunburst**: `ChartTree` — Nivo tree, `{ id, children?: [...], value? }`
- *   (`name` is accepted in place of `id`).
- */
-type ChartType = "bar" | "line" | "area" | "pie" | "donut" | "scatter" | "scatterplot" | "radar" | "funnel" | "heatmap" | "calendar" | "treemap" | "sunburst";
-/** The engine that draws a given type. */
-type ChartEngine = "recharts" | "nivo";
-/** Nivo renderer; only the Nivo types honour it (Recharts is SVG only). */
-type ChartRenderer = "svg" | "canvas";
-/** One category with a numeric value per series. */
-type ChartRow = Record<string, string | number | null | undefined>;
-/** One series of points; x may be a category or a number, y a number. */
-interface ChartPoint {
-  x: string | number;
-  y: number | null;
-}
-interface ChartSeries {
-  id: string | number;
-  data: ChartPoint[];
-}
-/** One slice of a pie, donut or funnel. */
-interface ChartSlice {
-  id: string | number;
-  label?: string;
-  value: number;
-}
-/**
- * A categorical matrix: `values[r][c]` is the cell at `rows[r]` × `columns[c]`.
- * The shape a correlation matrix, a confusion matrix or a day × hour grid is
- * already in, so it needs no pivot at the call site. Short rows are padded
- * with `null` (drawn as the empty colour) rather than treated as zero.
- */
-interface ChartMatrix {
-  rows: string[];
-  columns: string[];
-  values: Array<Array<number | null | undefined>>;
-}
-/** One day of a calendar heatmap. */
-interface ChartDay {
-  day: string;
-  value: number;
-}
-/** A Nivo tree node for treemap and sunburst. */
-interface ChartTree {
-  id?: string | number;
-  name?: string;
-  value?: number;
-  children?: ChartTree[];
-  [key: string]: unknown;
-}
-/** The data type accepted for each chart type. */
-type ChartDataFor<T extends ChartType> = T extends "bar" | "radar" ? ChartRow[] | ChartSeries[] : T extends "line" | "area" ? ChartSeries[] | ChartRow[] : T extends "pie" | "donut" | "funnel" ? ChartSlice[] : T extends "heatmap" ? ChartSeries[] | ChartMatrix : T extends "scatter" | "scatterplot" ? ChartSeries[] : T extends "calendar" ? ChartDay[] : T extends "treemap" | "sunburst" ? ChartTree : never;
-/**
- * Per-series presentation, keyed by series id (the `keys` of a row chart, the
- * `id` of a series or slice). Colours default to `var(--ds-viz-1..n)` in key
- * order, so the same category index gets the same colour in every app; set
- * `color` only to pin a category to a semantic colour, and then only to a
- * token (`var(--ds-success)`), never a literal.
- */
-type ChartConfig = Record<string, {
-  label?: React$1.ReactNode;
-  icon?: React$1.ComponentType;
-  color?: string;
-}>;
-/** Which continuous scale a heatmap or calendar uses. */
-type ChartScale = "sequential" | "diverging";
-export declare const RECHARTS_TYPES: ReadonlySet<ChartType>;
-export declare const NIVO_TYPES: ReadonlySet<ChartType>;
-/** The engine the package uses for a chart type. */
-export declare function chartEngine(type: ChartType): ChartEngine;
-//#endregion
-//#region src/components/chart/container.d.ts
-interface ChartContextValue {
-  config: ChartConfig;
-  /** The container element, so token resolution can honour a nested theme scope. */
-  element: HTMLDivElement | null;
-}
-/** The nearest ChartContainer's config and element; null outside one. */
-export declare function useChart(): ChartContextValue | null;
-/**
- * Resolve the colour a series key paints with: `config[key].color` when set,
- * otherwise `var(--ds-viz-N)` by the key's position in the config (or the
- * `index` given). Recharts consumers reference it as `var(--color-<key>)`,
- * which ChartContainer defines on its element.
- */
-export declare function seriesColor(config: ChartConfig | undefined, key: string, index?: number): string;
-interface ChartContainerProps extends Omit<React$1.ComponentProps<"div">, "children"> {
-  /** Series presentation; colours default to `--ds-viz-1..n` in key order. */
-  config?: ChartConfig;
-  /** Height of the drawing area; width is always 100% of the parent. Default 300. */
-  height?: number | string;
-  /**
-   * Wrap children in Recharts' ResponsiveContainer (default). Nivo's
-   * `Responsive*` components size themselves, so the Nivo renderers pass
-   * `responsive={false}`.
-   */
-  responsive?: boolean;
-  /**
-   * Give the drawing area a floor of 600×300 so it draws where the layout
-   * gives it none.
-   *
-   * Both engines size themselves from the parent box. Under jsdom nothing has
-   * layout — every element measures 0×0 — so a page test that renders a screen
-   * containing a Chart gets an empty `<div>` and can assert nothing about it.
-   * `testMode` sets `min-width` / `min-height` on the container and hands the
-   * same floor to Recharts' ResponsiveContainer, so the chart draws at
-   * 600×300. It is a floor, not a fixed size: a parent that *does* give the
-   * chart 900px still gets 900px, so a screenshot test is unaffected.
-   */
-  testMode?: boolean;
-  children: React$1.ReactNode;
-}
-/**
- * ChartContainer — the sized, token-styled surface every chart draws in.
- *
- * It defines `--color-<key>` for each config key (so Recharts parts can say
- * `fill="var(--color-revenue)"`) and styles Recharts' axis, grid, tick and
- * cursor classes from tokens with a caption-sm floor for text, so a custom
- * chart composed inside it needs no local colours or fonts.
- */
-declare function ChartContainer({ config, height, responsive, testMode, className, style, children, ...props }: ChartContainerProps): React$1.JSX.Element;
-/** "No data" placeholder; rendered by Chart when the data is empty. */
-declare function ChartEmpty({ children, ...props }: React$1.ComponentProps<"div">): React$1.JSX.Element;
-/** Error placeholder; rendered by Chart for an `error` prop or a failed Nivo chunk. */
-declare function ChartError({ className, children, ...props }: React$1.ComponentProps<"div">): React$1.JSX.Element;
-/** Loading placeholder: a skeleton the size of the drawing area, shown while a Nivo chunk loads. */
-declare function ChartLoading({ className, ...props }: React$1.ComponentProps<"div">): React$1.JSX.Element;
-interface ChartTooltipContentProps extends Partial<Pick<TooltipContentProps$1, "active" | "payload" | "label">> {
-  className?: string;
-  /** Hide the series label column. */
-  hideLabel?: boolean;
-  /** Hide the colour swatch. */
-  hideIndicator?: boolean;
-  /** Format a value; defaults to `toLocaleString`. */
-  formatter?: (value: number | string, name: string) => React$1.ReactNode;
-  /** Format the header (the category). */
-  labelFormatter?: (label: React$1.ReactNode) => React$1.ReactNode;
-}
-/**
- * ChartTooltipContent — the popover body for Recharts' Tooltip, styled like
- * the package Tooltip on the popover tokens. Pass as `content` to
- * ChartTooltip; reads series labels and colours from the ChartContainer config.
- */
-declare function ChartTooltipContent({ active, payload, label, className, hideLabel, hideIndicator, formatter, labelFormatter }: ChartTooltipContentProps): React$1.JSX.Element | null;
-/** Recharts' Tooltip with the token-styled content and a subtle cursor. */
-declare function ChartTooltip(props: TooltipProps): React$1.JSX.Element;
-interface ChartLegendContentProps {
-  payload?: readonly LegendPayload[];
-  verticalAlign?: "top" | "bottom" | "middle";
-  className?: string;
-  hideIcon?: boolean;
-}
-/** ChartLegendContent — Recharts' legend on tokens; reads labels from the config. */
-declare function ChartLegendContent({ payload, verticalAlign, className, hideIcon }: ChartLegendContentProps): React$1.JSX.Element | null;
-/** Recharts' Legend with the token-styled content. */
-declare function ChartLegend(props: LegendProps): React$1.JSX.Element;
-//#endregion
-//#region src/components/chart/chart.d.ts
-interface ChartProps<T extends ChartType = ChartType> extends Omit<ChartContainerProps, "children" | "config" | "responsive"> {
-  /** Which chart to draw; the package picks the engine. See {@link ChartType} for the data shape per type. */
-  type: T;
-  /** The data, in the shape documented on {@link ChartType}. */
-  data: ChartDataFor<T>;
-  /** Series presentation keyed by series id; colours default to `--ds-viz-1..n` in order. */
-  config?: ChartConfig;
-  /** Nivo renderer; `canvas` for large series. Ignored by the Recharts types and by sunburst. */
-  renderer?: ChartRenderer;
-  /** Category key for row data (bar, line, area, radar); inferred as the first string field. */
-  indexBy?: string;
-  /** Series keys for row data; inferred as every numeric field. */
-  keys?: string[];
-  /** Stack bars and areas instead of grouping them. */
-  stacked?: boolean;
-  /** Continuous scale for heatmap and calendar. Default sequential. */
-  scale?: ChartScale;
-  /** Show a legend. Default: when there is more than one series. */
-  legend?: boolean;
-  /** Draw grid lines (cartesian and radar types). Default true. */
-  grid?: boolean;
-  /** Show a tooltip on hover. Default true. */
-  tooltip?: boolean;
-  /** Format values in axes, tooltips and labels. */
-  valueFormatter?: (value: number) => string;
-  /** Calendar range (ISO dates); defaults to the data's extent. */
-  from?: string;
-  to?: string;
-  /** Render the loading skeleton instead of the data. */
-  loading?: boolean;
-  /** Render the error state with this message instead of the data. */
-  error?: React$1.ReactNode | Error | null;
-  /** Content of the empty state. Default "No data". */
-  emptyMessage?: React$1.ReactNode;
-}
-/**
- * Chart — one component for every chart type the fleet draws.
- *
- * `type` picks the engine: Recharts (bundled) for bar, line, area, pie, donut,
- * scatter, radar and funnel; Nivo, lazy-loaded per package, for heatmap,
- * calendar, treemap and sunburst, with `renderer="canvas"` for large series.
- * Colours, fonts, axes, grid, tooltip, legend and the empty, loading and
- * error states all come from cortena-design tokens; a consumer passes data
- * and, optionally, a `config` of labels.
- *
- * `heatmap` takes either the Nivo series shape or a categorical
- * {@link ChartMatrix} — `{ rows, columns, values }` — for the correlation and
- * confusion matrices that are already in that form.
- *
- * `testMode` gives the drawing area a 600×300 floor so a chart still draws
- * where the layout gives it no size; see {@link ChartContainerProps.testMode}
- * and README.md, "Charts in tests".
- */
-declare function Chart<T extends ChartType>({ type, data, config, renderer, indexBy, keys, stacked, scale, legend, grid, tooltip, valueFormatter, from, to, loading, error, emptyMessage, className, height, ...props }: ChartProps<T>): React$1.JSX.Element;
-//#endregion
-//#region src/components/chart/nivo-theme.d.ts
-/**
- * The Nivo theme object, typed structurally so no `@nivo/*` package is a
- * static import of this module (the Nivo packages are lazy-loaded). It is a
- * subset of `PartialTheme` from `@nivo/theming` and assignable to every
- * chart's `theme` prop.
- */
-interface NivoTheme {
-  background: string;
-  text: {
-    fontFamily: string;
-    fontSize: number;
-    fill: string;
-  };
-  axis: {
-    domain: {
-      line: {
-        stroke: string;
-        strokeWidth: number;
-      };
-    };
-    ticks: {
-      line: {
-        stroke: string;
-        strokeWidth: number;
-      };
-      text: {
-        fill: string;
-        fontSize: number;
-      };
-    };
-    legend: {
-      text: {
-        fill: string;
-        fontSize: number;
-        fontWeight: number;
-      };
-    };
-  };
-  grid: {
-    line: {
-      stroke: string;
-      strokeWidth: number;
-    };
-  };
-  crosshair: {
-    line: {
-      stroke: string;
-      strokeWidth: number;
-      strokeOpacity: number;
-      strokeDasharray: string;
-    };
-  };
-  legends: {
-    text: {
-      fill: string;
-      fontSize: number;
-    };
-    title: {
-      text: {
-        fill: string;
-        fontSize: number;
-      };
-    };
-    ticks: {
-      line: {
-        stroke: string;
-        strokeWidth: number;
-      };
-      text: {
-        fill: string;
-        fontSize: number;
-      };
-    };
-  };
-  labels: {
-    text: {
-      fill: string;
-      fontSize: number;
-      fontWeight: number;
-    };
-  };
-  dots: {
-    text: {
-      fill: string;
-      fontSize: number;
-    };
-  };
-  markers: {
-    lineColor: string;
-    lineStrokeWidth: number;
-    text: {
-      fill: string;
-      fontSize: number;
-    };
-  };
-  annotations: {
-    text: {
-      fill: string;
-      fontSize: number;
-      outlineWidth: number;
-      outlineColor: string;
-    };
-    link: {
-      stroke: string;
-      strokeWidth: number;
-      outlineWidth: number;
-      outlineColor: string;
-    };
-    outline: {
-      stroke: string;
-      strokeWidth: number;
-      outlineWidth: number;
-      outlineColor: string;
-    };
-    symbol: {
-      fill: string;
-      outlineWidth: number;
-      outlineColor: string;
-    };
-  };
-  tooltip: {
-    container: {
-      background: string;
-      color: string;
-      fontSize: number;
-      fontFamily: string;
-      borderRadius: number;
-      boxShadow: string;
-      border: string;
-      padding: string;
-    };
-    chip: {
-      borderRadius: number;
-    };
-  };
-}
-/**
- * Build the Nivo theme from the tokens, resolved on `el` (default `<html>`).
- * Every colour is read from a `--ds-*` custom property and converted to hex,
- * because Nivo's canvas renderer and its colour derivation cannot read
- * `var()`. Sizes come from the type scale with `--ds-text-caption-sm` (11px)
- * as the floor for ticks and labels.
- *
- * Moved here from cortenaweb's webchat renderer; nothing is hard-coded.
- */
-export declare function nivoTheme(el?: Element | null): NivoTheme;
-/**
- * The Nivo theme for the current theme, re-resolved when `data-theme` or the
- * OS scheme flips. Inside a ChartContainer the tokens are read on its element,
- * so a nested theme scope is honoured.
- */
-export declare function useNivoTheme(): NivoTheme;
-//#endregion
-//#region src/components/chart/tokens.d.ts
-/**
- * Token plumbing for the chart engines.
- *
- * Recharts draws SVG, so it can take `var(--ds-viz-1)` verbatim and the
- * browser resolves it. Nivo cannot: its canvas renderer hands colours to a
- * 2D context, and its SVG renderer runs colours through d3-color for label and
- * border derivation, and neither understands `var()`. So every Nivo value is
- * read from the `--ds-*` custom property at runtime and handed over as a
- * concrete hex. Nothing in this file is a literal; on the server (no DOM) the
- * `var()` form is returned so SSR markup still resolves in the browser.
- */
-/** Number of categorical series colours the design system defines (`--ds-viz-1..n`). */
-export declare const VIZ_SERIES_COUNT: number;
-/** `var(--ds-viz-N)` for a zero-based series index, wrapping past the palette. */
-export declare function vizVar(index: number): string;
-/** The categorical palette as `var()` references, in series order. */
-export declare const vizSeriesVars: readonly string[];
-/**
- * Convert any CSS colour the browser understands (oklch, color-mix, rgba…) to
- * `#rrggbb`, by painting it into an offscreen 2D context. Alpha is composited
- * against transparent, so translucent tokens come back opaque; chart fills
- * never use those.
- */
-export declare function toHex(css: string): string | undefined;
-/**
- * A token as a concrete colour. Returns hex in the browser; on the server the
- * `var()` form, which is fine for SVG markup and irrelevant for canvas.
- */
-export declare function resolveColor(token: string, el?: Element | null): string;
-/** The categorical palette resolved to concrete colours, in series order. */
-export declare function resolveVizSeries(el?: Element | null): string[];
-interface ChartScales {
-  /** Low → high, as concrete hex stops. */
-  sequential: string[];
-  /** Negative → neutral → positive, as concrete hex stops. */
-  diverging: string[];
-  /** Interpolators over the stops, `t` in [0, 1], for Nivo's `interpolator` configs. */
-  sequentialInterpolator: (t: number) => string;
-  divergingInterpolator: (t: number) => string;
-  /** `n` evenly spaced sequential swatches, for quantised fills like the calendar. */
-  sequentialSteps: (n: number) => string[];
-  /** Fill for cells with no value. */
-  empty: string;
-  /** The chart's surface (`--ds-background`), for the gaps between cells and arcs. */
-  surface: string;
-}
-/**
- * Sequential and diverging scales from the tokens.
- *
- * The token set has only the eight categorical `--ds-viz-*` colours and no
- * sequential ramp, so the sequential scale is derived from the
- * `--ds-primary-100..900` ladder: light surfaces run 100 → 700 (pale to deep),
- * dark surfaces run 900 → 400 (deep to bright), so low values sit near the
- * background in both themes. The diverging scale runs `--ds-viz-5` (rose)
- * through the theme's neutral (`--ds-neutral-200` light, `--ds-neutral-700`
- * dark) to `--ds-viz-1` (blue).
- */
-export declare function chartScales(el?: Element | null): ChartScales;
-//#endregion
-//#region src/components/data-table/features.d.ts
-declare const baseFeatures: {
-  columnFilteringFeature: import("@tanstack/react-table").TableFeature;
-  globalFilteringFeature: import("@tanstack/react-table").TableFeature;
-  columnFacetingFeature: import("@tanstack/react-table").TableFeature;
-  rowSortingFeature: import("@tanstack/react-table").TableFeature;
-  rowPaginationFeature: import("@tanstack/react-table").TableFeature;
-  rowSelectionFeature: import("@tanstack/react-table").TableFeature;
-  rowExpandingFeature: import("@tanstack/react-table").TableFeature;
-  columnVisibilityFeature: import("@tanstack/react-table").TableFeature;
-  columnPinningFeature: import("@tanstack/react-table").TableFeature;
-  columnSizingFeature: import("@tanstack/react-table").TableFeature;
-  columnResizingFeature: import("@tanstack/react-table").TableFeature;
-  filteredRowModel: (table: import("@tanstack/react-table").Table<any, any>) => () => import("@tanstack/react-table").RowModel<any, any>;
-  sortedRowModel: (table: import("@tanstack/react-table").Table<any, any>) => () => import("@tanstack/react-table").RowModel<any, any>;
-  paginatedRowModel: (table: import("@tanstack/react-table").Table<any, any>) => () => import("@tanstack/react-table").RowModel<any, any>;
-  expandedRowModel: (table: import("@tanstack/react-table").Table<any, any>) => () => import("@tanstack/react-table").RowModel<any, any>;
-  facetedRowModel: (table: import("@tanstack/react-table").Table<any, any>, columnId: string) => () => import("@tanstack/react-table").RowModel<any, any>;
-  facetedUniqueValues: (table: import("@tanstack/react-table").Table<import("@tanstack/react-table").TableFeatures, any>, columnId: string) => () => Map<any, number>;
-  filterFns: {
-    includesString: import("@tanstack/react-table").CreatedFilterFn<any, any>;
-    equals: import("@tanstack/react-table").CreatedFilterFn<any, any>;
-    equalsString: import("@tanstack/react-table").CreatedFilterFn<any, any>;
-    inNumberRange: import("@tanstack/react-table").CreatedFilterFn<any, any>;
-    arrIncludes: import("@tanstack/react-table").CreatedFilterFn<any, any>;
-    arrIncludesSome: import("@tanstack/react-table").CreatedFilterFn<any, any>;
-    inDateRange: import("@tanstack/react-table").CreatedFilterFn<any, any>;
-    weakEquals: import("@tanstack/react-table").CreatedFilterFn<any, any>;
-    oneOf: import("@tanstack/react-table").CreatedFilterFn<any, any>;
-  };
-  sortFns: {
-    alphanumeric: import("@tanstack/react-table").CreatedSortFn<any, any>;
-    basic: import("@tanstack/react-table").CreatedSortFn<any, any>;
-    datetime: import("@tanstack/react-table").CreatedSortFn<any, any>;
-    text: import("@tanstack/react-table").CreatedSortFn<any, any>;
-  };
-  columnMeta: DataTableColumnMeta<any>;
-};
-/**
- * The registry type, re-keyed to the consumer's row type so `meta.onCommit`
- * receives a typed row. The runtime object is the same for every table.
- */
-type DataTableFeatures<Row extends RowData> = Omit<typeof baseFeatures, "columnMeta"> & {
-  columnMeta: DataTableColumnMeta<Row>;
-};
-export declare function dataTableFeatures<Row extends RowData>(): DataTableFeatures<Row>;
-/**
- * `createColumnHelper` bound to the DataTable feature set. v9's helper takes
- * the features as its first type argument; this saves consumers from
- * importing the registry.
- *
- * @example
- * const helper = createColumnHelper<Contact>();
- * const columns = helper.columns([
- *   helper.accessor("name", { header: "Name" }),
- *   helper.accessor("status", { header: "Status", meta: { filter: "faceted" } }),
- * ]);
- */
-export declare function createColumnHelper<Row extends RowData>(): ColumnHelper<DataTableFeatures<Row>, Row>;
-//#endregion
-//#region src/components/data-table/types.d.ts
-/**
- * Data sources (the contract in cortenaUI&Design/04-data-tables.md).
- *
- * A client source hands the table every row and lets it filter, sort and page
- * in memory. A server source hands the table one page at a time: the table
- * owns the search box, filter, sort and page state, turns it into a
- * `TableQuery`, and the app answers with the already filtered, sorted page and
- * the total. `TableQuery` / `TableResult` are also the backend contract every
- * extension's list endpoint is expected to speak.
- */
-type ClientSource<Row> = {
-  kind: "client";
-  rows: Row[];
-};
-type ServerSource<Row> = {
-  kind: "server";
-  /**
-   * Fetch one page. The optional `signal` is aborted when the query changes
-   * before the request settles, so a fetch that forwards it to `fetch()` is
-   * cancelled rather than raced.
-   */
-  fetch: (query: TableQuery, signal?: AbortSignal) => Promise<TableResult<Row>>;
-  /**
-   * TanStack Query cache scope. Two tables that share a key share pages;
-   * defaults to a key private to the component instance.
-   */
-  queryKey?: readonly unknown[];
-};
-type DataSource<Row> = ClientSource<Row> | ServerSource<Row>;
-type TableQuery = {
-  q?: string;
-  filters?: Array<{
-    id: string;
-    value: unknown;
-  }>;
-  sort?: Array<{
-    id: string;
-    desc: boolean;
-  }>;
-  page: number;
-  pageSize: number;
-};
-type TableResult<Row> = {
-  rows: Row[];
-  total: number;
-};
-/** Inline-editing options for a column (`meta.editable`). */
-interface DataTableEditable {
-  /** Input type; `number` parses the draft with `Number()` before commit. */
-  type?: "text" | "number";
-  /** Turn the raw input string into the committed value. */
-  parse?: (raw: string) => unknown;
-}
-/**
- * Per-column `meta`. Typed through the v9 `columnMeta` feature slot, so
- * `helper.accessor("x", { meta: { ... } })` is checked without declaration
- * merging.
- */
-interface DataTableColumnMeta<Row = unknown> {
-  /**
-   * Toolbar filter for this column. `faceted` renders a checkbox list of the
-   * column's distinct values (or `filterOptions`) and filters with `oneOf`.
-   */
-  filter?: "faceted" | "text";
-  /** Fixed facet options; required for a server source, where only one page is loaded. */
-  filterOptions?: Array<{
-    value: string | number | boolean;
-    label?: string;
-    icon?: React.ComponentType<{
-      className?: string;
-    }>;
-  }>;
-  /** Text alignment of the header and cells. Numbers usually want `end`. */
-  align?: "start" | "center" | "end";
-  /** Enter or double-click opens an editor; Enter commits, Escape cancels. */
-  editable?: boolean | DataTableEditable;
-  /** Receives the committed value. Falls back to the table's `onCellCommit`. */
-  onCommit?: (row: Row, columnId: string, value: unknown) => void | Promise<void>;
-  /** Column label for the view menu and exports when `header` is not a string. */
-  label?: string;
-  /** Set `false` to leave the column out of CSV / Excel exports. */
-  exportable?: boolean;
-  /** Value written to exports instead of the accessor value. */
-  exportValue?: (row: Row) => string | number | boolean | Date | null | undefined;
-  /** Extra classes for every cell in this column. */
-  cellClassName?: string;
-  /** Extra classes for the header cell. */
-  headerClassName?: string;
-}
-type DataTableColumnDef<Row extends RowData, Value = unknown> = ColumnDef<DataTableFeatures<Row>, Row, Value>;
-type DataTableColumn<Row extends RowData, Value = unknown> = Column<DataTableFeatures<Row>, Row, Value>;
-type DataTableRow<Row$1 extends RowData> = Row<DataTableFeatures<Row$1>, Row$1>;
-type DataTableCell<Row extends RowData, Value = unknown> = Cell$2<DataTableFeatures<Row>, Row, Value>;
-type DataTableState<Row extends RowData> = TableState<DataTableFeatures<Row>>;
-/** The TanStack table instance every part takes as `table`. */
-type DataTableTable<Row extends RowData> = ReactTable<DataTableFeatures<Row>, Row>;
-type DataTablePaginationMode = "pages" | "infinite" | "none";
-interface UseDataTableOptions<Row extends RowData> {
-  columns: ReadonlyArray<DataTableColumnDef<Row, any>>;
-  dataSource: DataSource<Row>;
-  /** Stable row identity; defaults to the row index. Needed for selection and editing to survive re-sorts. */
-  getRowId?: (row: Row, index: number) => string;
-  /** Tree data: return a row's children. */
-  getSubRows?: (row: Row, index: number) => Row[] | undefined;
-  /** `pages` (default) renders a pager; `infinite` appends pages on scroll; `none` shows every row. */
-  pagination?: DataTablePaginationMode;
-  /** @default 25 */
-  pageSize?: number;
-  /** Adds a checkbox column and enables `bulkActions`. */
-  enableRowSelection?: boolean | ((row: DataTableRow<Row>) => boolean);
-  /** Adds an expander column; set automatically by `renderSubComponent`. */
-  enableExpanding?: boolean;
-  getRowCanExpand?: (row: DataTableRow<Row>) => boolean;
-  /** @default true */
-  enableSorting?: boolean;
-  /** @default false */
-  enableMultiSort?: boolean;
-  /** @default true */
-  enableGlobalFilter?: boolean;
-  /** @default true */
-  enableColumnFilters?: boolean;
-  /** @default true */
-  enableHiding?: boolean;
-  /** @default true */
-  enableColumnPinning?: boolean;
-  /** @default false */
-  enableColumnResizing?: boolean;
-  /** Starting sort, filters, visibility, pinning, sizing. */
-  initialState?: Partial<DataTableState<Row>>;
-  /** Table-wide commit handler for editable cells without their own `meta.onCommit`. */
-  onCellCommit?: (row: Row, columnId: string, value: unknown) => void | Promise<void>;
-  /** Fires with the selected original rows whenever selection changes. */
-  onRowSelectionChange?: (rows: Row[]) => void;
-  /** Debounce applied to the search box before it reaches a server source. @default 250 */
-  searchDebounceMs?: number;
-}
-interface DataTableEditingCell {
-  rowId: string;
-  columnId: string;
-}
-interface DataTableInstance<Row extends RowData> {
-  table: DataTableTable<Row>;
-  dataSource: DataSource<Row>;
-  paginationMode: DataTablePaginationMode;
-  /** Rows currently in the table (the page, for a server source). */
-  rows: Row[];
-  /** Total matching rows (server `total`, or the filtered count for a client source). */
-  total: number;
-  /** True until the first server page arrives; never true for a client source. */
-  isLoading: boolean;
-  /** True while any server request is in flight, including background refetches. */
-  isFetching: boolean;
-  error: Error | null;
-  refetch: () => void;
-  /** Infinite mode: load the next page. No-op elsewhere. */
-  fetchNextPage: () => void;
-  hasNextPage: boolean;
-  /** Search text the server last received (debounced), for consumers rendering their own toolbar. */
-  searchQuery: string;
-  editing: {
-    cell: DataTableEditingCell | null;
-    start: (cell: DataTableEditingCell) => void;
-    stop: () => void;
-    commit: (row: DataTableRow<Row>, columnId: string, value: unknown) => Promise<void>;
-  };
-}
-//#endregion
-//#region src/components/data-table/data-table.d.ts
-interface DataTableViewProps<Row extends RowData> {
-  className?: string;
-  /** Height of the scrolling body. Required for virtualisation to mean anything; defaults to 600px when virtualised. */
-  maxHeight?: number | string;
-  /** Force virtualisation on or off; undefined virtualises above 100 rows. */
-  virtualize?: boolean;
-  /** Estimated row height in px for the virtualizer. @default 40 */
-  rowHeight?: number;
-  /** @default true */
-  stickyHeader?: boolean;
-  /** @default "default" */
-  density?: "default" | "compact";
-  /** Detail panel under an expanded row; enables the expander column. */
-  renderSubComponent?: (row: DataTableRow<Row>) => React$1.ReactNode;
-  /** `false` hides the toolbar; a function replaces it. */
-  toolbar?: boolean | ((ctx: {
-    instance: DataTableInstance<Row>;
-  }) => React$1.ReactNode);
-  /** Rendered in the toolbar while rows are selected. */
-  bulkActions?: (ctx: {
-    rows: Row[];
-    table: DataTableTable<Row>;
-  }) => React$1.ReactNode;
-  /** Extra toolbar controls (right side). */
-  toolbarActions?: React$1.ReactNode;
-  searchPlaceholder?: string;
-  emptyState?: React$1.ReactNode;
-  /** @default "No results" */
-  emptyMessage?: string;
-  pageSizeOptions?: number[];
-  /** @default true */
-  enableExport?: boolean;
-  /** @default "export" */
-  exportFileName?: string;
-  /** Show the loading skeleton regardless of the source's own state. */
-  loading?: boolean;
-  /** Error to show above the table, in addition to the server source's. */
-  error?: string | Error | null;
-  onRowClick?: (row: Row, event: React$1.MouseEvent<HTMLTableRowElement>) => void;
-  /**
-   * The row a detail pane is currently showing, matched against the row id
-   * (`getRowId`, the row index when that is not set). It gets `data-active`
-   * and the `--ds-primary-soft` tint, independent of checkbox selection — a
-   * master/detail list highlights one row without selecting it, and a table
-   * with both can show a selected set and one open row at once.
-   */
-  activeRowId?: string | null;
-  /** Extra classes per row, e.g. to dim rows the app considers stale. */
-  rowClassName?: (row: Row) => string | undefined;
-}
-type DataTableProps<Row extends RowData> = DataTableViewProps<Row> & ({
-  instance: DataTableInstance<Row>;
-} | UseDataTableOptions<Row>);
-declare function DataTable<Row extends RowData>(props: DataTableProps<Row>): React$1.JSX.Element;
-declare function DataTableView<Row extends RowData>({ instance, className, maxHeight, virtualize, rowHeight, stickyHeader, density, renderSubComponent, toolbar, bulkActions, toolbarActions, searchPlaceholder, emptyState, emptyMessage, pageSizeOptions, enableExport, exportFileName, loading, error, onRowClick, activeRowId, rowClassName }: DataTableViewProps<Row> & {
-  instance: DataTableInstance<Row>;
-}): React$1.JSX.Element;
-//#endregion
-//#region src/components/data-table/parts.d.ts
-interface DataTableColumnHeaderProps<Row extends RowData> extends Omit<React$1.ComponentProps<"div">, "title"> {
-  column: DataTableColumn<Row, any>;
-  title: React$1.ReactNode;
-}
-/**
- * Header content for one column: the title as a sort toggle when the column
- * sorts, and a menu with sort, pin and hide when any of those apply. The
- * table renders it for every string `header` automatically; use it inside a
- * custom header function to keep the same affordances.
- */
-declare function DataTableColumnHeader<Row extends RowData>({ column, title, className, ...props }: DataTableColumnHeaderProps<Row>): React$1.JSX.Element;
-interface DataTableFacetedFilterOption {
-  value: string | number | boolean;
-  label?: string;
-  icon?: React$1.ComponentType<{
-    className?: string;
-  }>;
-}
-interface DataTableFacetedFilterProps<Row extends RowData> {
-  column: DataTableColumn<Row, any>;
-  title?: React$1.ReactNode;
-  /** Fixed options; defaults to the column's distinct values with counts (client source only). */
-  options?: DataTableFacetedFilterOption[];
-  className?: string;
-}
-/**
- * A checkbox list of a column's values. The filter value is the array of
- * picked values; the column's `filterFn` (`oneOf` by default for
- * `meta.filter: "faceted"`) decides what that means, and a server source
- * receives it verbatim in `TableQuery.filters`.
- */
-declare function DataTableFacetedFilter<Row extends RowData>({ column, title, options, className }: DataTableFacetedFilterProps<Row>): React$1.JSX.Element;
-interface DataTableViewOptionsProps<Row extends RowData> {
-  table: DataTableTable<Row>;
-  className?: string;
-}
-/** Column visibility menu. */
-declare function DataTableViewOptions<Row extends RowData>({ table, className }: DataTableViewOptionsProps<Row>): React$1.JSX.Element | null;
-interface DataTableExportMenuProps<Row extends RowData> {
-  table: DataTableTable<Row>;
-  fileName?: string;
-  className?: string;
-}
-declare function DataTableExportMenu<Row extends RowData>({ table, fileName, className }: DataTableExportMenuProps<Row>): React$1.JSX.Element;
-interface DataTableToolbarProps<Row extends RowData> extends Omit<React$1.ComponentProps<"div">, "children"> {
-  table: DataTableTable<Row>;
-  /** Placeholder for the search box. @default "Search…" */
-  searchPlaceholder?: string;
-  /** Rendered while rows are selected, in place of the filters. */
-  bulkActions?: (ctx: {
-    rows: Row[];
-    table: DataTableTable<Row>;
-  }) => React$1.ReactNode;
-  /** Extra controls on the right, before the view and export menus. */
-  children?: React$1.ReactNode;
-  /** @default true */
-  enableExport?: boolean;
-  exportFileName?: string;
-}
-/**
- * Search box, one faceted filter per `meta.filter: "faceted"` column, a reset
- * when anything is filtered, and the view / export menus. While rows are
- * selected the left side becomes the selection summary and `bulkActions`.
- */
-declare function DataTableToolbar<Row extends RowData>({ table, searchPlaceholder, bulkActions, children, enableExport, exportFileName, className, ...props }: DataTableToolbarProps<Row>): React$1.JSX.Element;
-interface DataTablePaginationProps<Row extends RowData> extends React$1.ComponentProps<"div"> {
-  table: DataTableTable<Row>;
-  /** @default [10, 25, 50, 100] */
-  pageSizeOptions?: number[];
-}
-declare function DataTablePagination<Row extends RowData>({ table, pageSizeOptions, className, ...props }: DataTablePaginationProps<Row>): React$1.JSX.Element;
-//#endregion
-//#region src/components/data-table/use-data-table.d.ts
-/**
- * Builds the table for a `dataSource`. This is where the design decision's
- * "the component sets the manual flags itself" lives: a server source flips
- * `manualFiltering`, `manualSorting` and `manualPagination` and feeds the
- * table's own filter / sort / page state back out as a `TableQuery`; a client
- * source leaves every row model in memory. Everything else (selection,
- * expansion, visibility, pinning, sizing) is owned by the table.
- *
- * Use it directly when the default layout is not enough: pass the returned
- * `table` to `DataTableToolbar`, `DataTablePagination` and friends, or the
- * whole instance to `<DataTable instance={...} />`.
- */
-export declare function useDataTable<Row extends RowData>(options: UseDataTableOptions<Row>): DataTableInstance<Row>;
-//#endregion
-//#region src/components/data-table/export.d.ts
-type ExportCell = string | number | boolean | Date | null;
-interface ExportSheet {
-  headers: string[];
-  records: ExportCell[][];
-}
-export declare function toSheet<Row extends RowData>(table: DataTableTable<Row>, rows?: DataTableRow<Row>[]): ExportSheet;
-/** RFC 4180 text: comma separated, CRLF lines, quotes doubled. */
-export declare function toCsv<Row extends RowData>(table: DataTableTable<Row>, rows?: DataTableRow<Row>[]): string;
-export declare function downloadCsv<Row extends RowData>(table: DataTableTable<Row>, fileName?: string, rows?: DataTableRow<Row>[]): void;
-/**
- * Excel through exceljs, loaded on first use so the workbook code (about
- * 300 KB) never sits in a bundle that only ever exports CSV.
- */
-export declare function downloadExcel<Row extends RowData>(table: DataTableTable<Row>, fileName?: string, rows?: DataTableRow<Row>[]): Promise<void>;
-//#endregion
-//#region src/a2ui/views.d.ts
-/** A row in an agent-drawn table. Every value is opaque until a column reads it. */
-type A2UIRow = Record<string, unknown>;
-/** Where a node sits, carried into every action the view emits. */
-interface A2UINodeInfo {
-  surfaceId: string;
-  componentId: string;
-  /** JSON pointer this node's relative bindings resolve against. */
-  dataContextPath: string;
-}
-/** A normalised action attached to an interactive property. */
-interface A2UIResolvedAction {
-  name: string;
-  context?: Record<string, unknown>;
-}
-/** What every view receives. */
-interface A2UIViewProps<P> {
-  props: P;
-  node: A2UINodeInfo;
-  /** Already-rendered child nodes, in the order the component listed them. */
-  children: React$1.ReactNode[];
-  /** The surface data model, for actions that report the whole form. */
-  dataModel: Record<string, unknown>;
-  /**
-   * Send an action. `action` is what the agent attached to the property; when
-   * it is absent the event still fires under `fallbackName` so a host can
-   * observe interactions the agent did not ask for.
-   */
-  emit: (action: A2UIResolvedAction | undefined, fallbackName: string, payload?: Record<string, unknown>) => void;
-  /** Write a value back to the data model where this prop was bound. No-op for a literal. */
-  writeBack: (property: string, value: unknown) => void;
-  /** Resolve a `{ kind: "server", sourceId }` handle into a real data source. */
-  resolveDataSource: (sourceId: string) => DataSource<A2UIRow> | undefined;
-  /** Debounce applied to continuous inputs before they become actions. */
-  debounceMs: number;
-}
-type A2UIView<P> = React$1.FC<A2UIViewProps<P>>;
-interface A2UIColumn {
-  id: string;
-  label?: string;
-  align?: "start" | "center" | "end";
-  filter?: "faceted" | "text";
-  width?: number;
-}
-/**
- * Where a table's rows come from.
- *
- * `client` carries the rows inline, which suits a short result an agent
- * already has. `server` carries a handle instead: the agent obtains a
- * `sourceId` from a tool and the host resolves it through
- * `resolveDataSource`, so search, sort and paging run on the backend and the
- * agent never has to put ten thousand rows in a message.
- */
-type A2UITableSource = {
-  kind: "client";
-  rows: A2UIRow[];
-} | {
-  kind: "server";
-  sourceId: string;
-};
-/**
- * What the renderer draws instead of a component it cannot draw.
- *
- * Never raw markup and never the offending payload as HTML: the detail is set
- * as text, so a malformed message cannot inject anything. This is the
- * "fallback: an error card on malformed payloads" of `05-agent-ui.md`.
- */
-export declare function A2UIErrorCard({ title, detail, componentId }: {
-  title: string;
-  detail?: string;
-  componentId?: string;
-}): React$1.JSX.Element;
-//#endregion
-//#region src/a2ui/catalogue.d.ts
-/** The five families the doc and the prompt group components by. */
-type A2UIGroup = "layout" | "text" | "input" | "feedback" | "data";
-/** A ready-to-render example: the components, plus any data model they bind to. */
-interface A2UIExample {
-  /** Components for this entry. The first is the one being demonstrated. */
-  components: A2UIComponentSpec[];
-  /** Seed data for `{ path }` bindings used by the example. */
-  data?: Record<string, unknown>;
-}
-interface A2UICatalogueEntry<P = unknown> {
-  /** The name an agent writes in `component`. */
-  name: string;
-  group: A2UIGroup;
-  /** One sentence, used verbatim in the generated prompt section. */
-  summary: string;
-  /** Schema of the resolved properties. */
-  props: z.ZodType<P>;
-  /** Event names this component can raise through `onAction`. */
-  events: readonly string[];
-  /** `many` takes a `children` list; `none` ignores one. */
-  children: "none" | "many";
-  example: A2UIExample;
-  view: A2UIView<P>;
-}
-type A2UICatalogue = Readonly<Record<string, A2UICatalogueEntry<never>>>;
-/**
- * The catalogue an agent draws from, and the renderer's default.
- *
- * A host may narrow it (hand the renderer a subset) but should not widen it
- * with components the prompt does not describe: an agent can only usefully
- * emit what `catalogue-doc.ts` told it about.
- */
-export declare const defaultCatalogue: A2UICatalogue;
-/** Catalogue id an agent may echo in `createSurface.catalogId`. */
-export declare const A2UI_CATALOGUE_ID = "https://cortena.ai/a2ui/catalogues/cortena-ui/v1.json";
-/** Every component name in the catalogue, sorted. */
-export declare function catalogueNames(catalogue?: A2UICatalogue): string[];
-//#endregion
-//#region src/a2ui/catalogue-doc.d.ts
-/** A JSON Schema object, as far as this module cares. */
-type JsonSchema = Record<string, unknown>;
-interface A2UIComponentDoc {
-  name: string;
-  group: A2UIGroup;
-  summary: string;
-  /** Whether the component takes a `children` list. */
-  children: "none" | "many";
-  /** Event names the component raises through `onAction`. */
-  events: string[];
-  /** JSON Schema of the resolved properties, derived from the zod schema. */
-  props: JsonSchema;
-  /** Property names that must be present. */
-  required: string[];
-  /** A complete, renderable example: the components and any data they bind to. */
-  example: {
-    components: A2UIComponentSpec[];
-    data?: Record<string, unknown>;
-  };
-}
-interface A2UICatalogueDoc {
-  catalogueId: string;
-  protocol: string;
-  generator: string;
-  components: A2UIComponentDoc[];
-}
-/** Build the machine-readable catalogue document. */
-export declare function buildCatalogueDoc(catalogue?: A2UICatalogue): A2UICatalogueDoc;
-/**
- * Render the catalogue document as markdown.
- *
- * The output is written to be pasted into a system prompt: one table per
- * component listing every property with its type, whether it is required and
- * what it means, then a fenced example an agent can copy.
- */
-export declare function catalogueMarkdown(doc?: A2UICatalogueDoc): string;
-/** Turn an entry's example into the messages an agent would actually send. */
-export declare function exampleMessages(component: A2UIComponentDoc): unknown[];
-//#endregion
-//#region src/a2ui/renderer.d.ts
-interface A2UIRendererProps {
-  /**
-   * The payload. One message, the list an AG-UI `CUSTOM` event carries, or the
-   * JSONL text `canvas.a2ui.pushJSONL` sends. Later messages fold onto earlier
-   * ones, so a push stream can be accumulated by the host and handed here whole.
-   */
-  message: A2UIMessageInput;
-  /** The component vocabulary. Defaults to the whole cortena-ui catalogue. */
-  catalogue?: A2UICatalogue;
-  /** Receives every user event, shaped like A2UI's client-to-server action. */
-  onAction?: (action: A2UIAction) => void;
-  /**
-   * Resolves a `{ kind: "server", sourceId }` table handle into a real data
-   * source. Without it, a server table renders an error card rather than an
-   * empty one, because a silently empty table reads as "no results".
-   */
-  resolveDataSource?: (sourceId: string) => DataSource<A2UIRow> | undefined;
-  /** Render only this surface. Default: every surface, in arrival order. */
-  surfaceId?: string;
-  /** Debounce before a continuous input becomes an action. @default 300 */
-  debounceMs?: number;
-  className?: string;
-}
-/**
- * A2UIRenderer — draws A2UI messages through cortena-ui.
- *
- * ```tsx
- * <A2UIRenderer
- *   message={customEvent.value}
- *   catalogue={defaultCatalogue}
- *   onAction={(action) => agent.send(action)}
- *   resolveDataSource={(id) => sources[id]}
- * />
- * ```
- */
-export declare function A2UIRenderer({ message, catalogue, onAction, resolveDataSource, surfaceId, debounceMs, className }: A2UIRendererProps): React$1.JSX.Element;
-//#endregion
-//#region src/components/accordion.d.ts
-/**
- * Accordion.
- *
- * Base UI's Accordion is a list of Collapsibles: `Root > Item > Header > Trigger`
- * plus `Panel`. The panel animates on height through Base UI's
- * `--accordion-panel-height`, and marks its first/last frame with
- * `data-starting-style` / `data-ending-style`, which is where it collapses to 0.
- *
- * Radix users: `type="single" | "multiple"` is now the boolean `multiple`, and
- * `value` is always an array. `collapsible` is the default. `data-state="open"`
- * is `data-open` on the item and panel, `data-panel-open` on the trigger.
- */
-declare function Accordion({ className, ...props }: Accordion$1.Root.Props): import("react").JSX.Element;
-declare function AccordionItem({ className, ...props }: Accordion$1.Item.Props): import("react").JSX.Element;
-declare function AccordionTrigger({ className, children, ...props }: Accordion$1.Trigger.Props): import("react").JSX.Element;
-declare function AccordionContent({ className, children, ...props }: Accordion$1.Panel.Props): import("react").JSX.Element;
-//#endregion
-//#region src/components/alert.d.ts
-declare const alertVariants: (props?: ({
-  variant?: "default" | "success" | "warn" | "destructive" | "danger" | "info" | null | undefined;
-} & import("class-variance-authority/types").ClassProp) | undefined) => string;
-interface AlertProps extends React$1.ComponentProps<"div">, VariantProps<typeof alertVariants> {}
-declare function Alert({ className, variant, ...props }: AlertProps): React$1.JSX.Element;
-declare function AlertIcon({ className, ...props }: React$1.ComponentProps<"div">): React$1.JSX.Element;
-declare function AlertTitle({ className, ...props }: React$1.ComponentProps<"div">): React$1.JSX.Element;
-declare function AlertDescription({ className, ...props }: React$1.ComponentProps<"div">): React$1.JSX.Element;
-//#endregion
-//#region src/components/avatar.d.ts
-/**
- * Avatar.
- *
- * Base UI preloads the image and only mounts `<img>` once it has loaded, so
- * the fallback is what paints while loading and after an error. Initials sit
- * on the primary fill in inverse text.
- *
- * Radix users: `delayMs` on the fallback is now `delay`.
- */
-declare function Avatar({ className, ...props }: Avatar$1.Root.Props): import("react").JSX.Element;
-declare function AvatarImage({ className, ...props }: Avatar$1.Image.Props): import("react").JSX.Element;
-declare function AvatarFallback({ className, ...props }: Avatar$1.Fallback.Props): import("react").JSX.Element;
-//#endregion
-//#region src/components/badge.d.ts
-declare const badgeVariants: (props?: ({
-  variant?: "default" | "success" | "warn" | "destructive" | "danger" | "info" | "warning" | "neutral" | "secondary" | "outline" | null | undefined;
-} & import("class-variance-authority/types").ClassProp) | undefined) => string;
-interface BadgeProps extends React$1.ComponentProps<"span">, VariantProps<typeof badgeVariants> {}
-declare function Badge({ className, variant, ...props }: BadgeProps): React$1.JSX.Element;
-//#endregion
-//#region src/lib/render.d.ts
-/**
- * The `render` prop for the components that are plain markup rather than Base
- * UI primitives (Card, SectionCard, ButtonLink, BreadcrumbLink).
- *
- * Base UI parts take their own `render` and need nothing from here. The rest
- * are a `<div>` or an `<a>` this package writes itself, and a consumer
- * sometimes needs a different element under the same styling: a Card that is
- * the page's `<aside>` landmark, or a link that is the router's `<Link>`.
- * Passing an element rather than a component keeps the call site readable and
- * lets the caller set props on it (`render={<Link to="/x" />}`).
- *
- * `props` wins over the passed element's own props, so the `className` and
- * handlers a component computed are not silently dropped, while the element's
- * own props (`href`, `to`, `aria-labelledby`) come through untouched. What a
- * component lets a *caller* override is decided by the order it builds `props`
- * in, not here. Children are `children`, falling back to the element's.
- */
-type RenderProp = React$1.ReactElement<Record<string, unknown>>;
-//#endregion
-//#region src/components/breadcrumb.d.ts
-/**
- * Breadcrumb — the trail above a page title.
- *
- * A `<nav aria-label="Breadcrumb">` around an ordered list, which is what
- * assistive technology expects: the list order is the hierarchy, so a screen
- * reader announces "list, 4 items" and reads the path in order. Separators are
- * decorative list items, not text inside the links, so a link's accessible
- * name is the crumb and nothing else.
- *
- * The last crumb is `BreadcrumbPage`, not a link: it is the page you are on,
- * so it carries `aria-current="page"` and is not focusable. Everything before
- * it is a `BreadcrumbLink`.
- *
- * ```tsx
- * <Breadcrumb>
- *   <BreadcrumbList>
- *     <BreadcrumbItem>
- *       <BreadcrumbLink href="/">Home</BreadcrumbLink>
- *     </BreadcrumbItem>
- *     <BreadcrumbSeparator />
- *     <BreadcrumbItem>
- *       <BreadcrumbEllipsis />
- *     </BreadcrumbItem>
- *     <BreadcrumbSeparator />
- *     <BreadcrumbItem>
- *       <BreadcrumbPage>Invoice 4021</BreadcrumbPage>
- *     </BreadcrumbItem>
- *   </BreadcrumbList>
- * </Breadcrumb>
- * ```
- *
- * **Router links.** `BreadcrumbLink` renders an `<a>` by default. Pass
- * `render` with the router's link component and the class name, `href` and
- * handlers are merged onto it, the same contract as `ButtonLink`:
- * `render={<NextLink href="/projects" />}` or
- * `render={<Link to="/projects" />}`. This is deliberately not Base UI's
- * `render` — a breadcrumb is markup, not a Base UI primitive — but it takes
- * the same shape so there is one thing to remember.
- */
-declare function Breadcrumb({ className, ...props }: React$1.ComponentProps<"nav">): React$1.JSX.Element;
-declare function BreadcrumbList({ className, ...props }: React$1.ComponentProps<"ol">): React$1.JSX.Element;
-declare function BreadcrumbItem({ className, ...props }: React$1.ComponentProps<"li">): React$1.JSX.Element;
-interface BreadcrumbLinkProps extends React$1.ComponentProps<"a"> {
-  /** Replace the rendered `<a>` with a router link; props are merged onto it. */
-  render?: RenderProp;
-}
-declare function BreadcrumbLink({ className, render, children, ...props }: BreadcrumbLinkProps): React$1.ReactElement<unknown, string | React$1.JSXElementConstructor<any>>;
-/**
- * The current page: the last crumb, which is not a link.
- *
- * A plain `<span aria-current="page">`, deliberately not `role="link"` with
- * `aria-disabled` — a disabled link that cannot be focused is a fiction, and
- * it makes `getByRole("link")` return a crumb that navigates nowhere. With a
- * span, the roles in the trail are exactly the crumbs you can travel to.
- */
-declare function BreadcrumbPage({ className, ...props }: React$1.ComponentProps<"span">): React$1.JSX.Element;
-/** Decorative divider between two crumbs; a chevron unless children replace it. */
-declare function BreadcrumbSeparator({ className, children, ...props }: React$1.ComponentProps<"li">): React$1.JSX.Element;
-/**
- * Stands in for the crumbs a long trail collapses; put it inside a
- * BreadcrumbItem. The glyph is hidden and the label is not: an ellipsis that
- * announces nothing leaves a screen-reader user with a gap in the path.
- */
-declare function BreadcrumbEllipsis({ className, children, ...props }: React$1.ComponentProps<"span">): React$1.JSX.Element;
-//#endregion
-//#region src/components/button.d.ts
-/**
- * Button.
- *
- * Base UI supplies the behaviour (native button semantics, `focusableWhenDisabled`,
- * keyboard activation on non-button elements through `render`). Every visual
- * value is a cortena-design token; nothing here is a literal the lint would flag.
- *
- * Radix users: `asChild` is gone. Pass `render={<a href=... />}` to change the
- * rendered element, which is Base UI's equivalent.
- */
-declare const buttonVariants: (props?: ({
-  variant?: "link" | "destructive" | "secondary" | "outline" | "primary" | "ghost" | "soft" | null | undefined;
-  size?: "sm" | "md" | "lg" | "icon" | "icon-sm" | null | undefined;
-} & import("class-variance-authority/types").ClassProp) | undefined) => string;
-interface ButtonProps extends React$1.ComponentProps<typeof Button$1>, VariantProps<typeof buttonVariants> {}
-declare function Button({ className, variant, size, ...props }: ButtonProps): React$1.JSX.Element;
-//#endregion
-//#region src/components/button-link.d.ts
-/**
- * An anchor that looks like a Button and keeps link semantics.
- *
- * `Button render={<a />}` makes Base UI treat the anchor as a button (role,
- * tabindex, its `nativeButton` warning), which demotes real navigation for
- * assistive technology and breaks `getByRole("link")`. Navigation should stay
- * an anchor. This is the migration target for every Radix-era
- * `<Button asChild><Link /></Button>`.
- *
- * Framework routers: pass `render` with the router's link so the styling and
- * `href` land on it, e.g. `render={<NextLink href="/x" />}`; otherwise it
- * renders a plain `<a>`.
- */
-interface ButtonLinkProps extends Omit<React$1.ComponentProps<"a">, "children">, Pick<ButtonProps, "variant" | "size"> {
-  children?: React$1.ReactNode;
-  /** Replace the rendered `<a>` with a router link; props are merged onto it. */
-  render?: RenderProp;
-  disabled?: boolean;
-}
-declare function ButtonLink({ className, variant, size, render, disabled, children, ...props }: ButtonLinkProps): React$1.ReactElement<unknown, string | React$1.JSXElementConstructor<any>>;
-//#endregion
-//#region src/components/calendar.d.ts
-/**
- * Calendar.
- *
- * The shadcn Calendar shape over react-day-picker 10. The library's stylesheet
- * is not imported; every class comes from the `classNames` map below and every
- * visual value in it is a cortena-design token. Structure (nav, caption, grid,
- * dropdown caption) is DayPicker's; the day cells, nav buttons and chevrons are
- * swapped for our Button and lucide icons through `components`.
- *
- * `showOutsideDays` defaults to true and `captionLayout` to `"label"`; pass
- * `captionLayout="dropdown"` for native month/year selects in the caption.
- */
-type CalendarProps = DayPickerProps;
-/**
- * One day cell's button. Selection and range state are exposed as data
- * attributes so the classes below (and a consumer's) can paint them; the
- * `today` attribute is only set when the day is not selected, so the soft
- * fill never competes with the selected fill.
- */
-declare function CalendarDayButton({ className, day, modifiers, ...props }: DayButtonProps): React$1.JSX.Element;
-declare function Calendar({ className, classNames, components, showOutsideDays, captionLayout, formatters, ...props }: CalendarProps): React$1.JSX.Element;
-//#endregion
-//#region src/components/card.d.ts
-interface CardProps extends React$1.ComponentProps<"div"> {
-  /** Lift the border and surface on hover, for clickable cards. */
-  hover?: boolean;
-  /** Draw the border in the ring colour, for a selected or highlighted card. */
-  accent?: boolean;
-  /**
-   * Replace the rendered `<div>` with another element, so a card can *be* the
-   * landmark rather than sit inside a wrapper that is one:
-   * `render={<aside />}` for a sidebar panel, `render={<section />}` (with an
-   * `aria-labelledby` pointing at its title) for a labelled region,
-   * `render={<article />}` for a self-contained item in a feed. Props set on
-   * the passed element come through; the card's own styling wins.
-   */
-  render?: RenderProp;
-}
-/**
- * Card — the bordered surface everything else sits on. `render` changes the
- * element without changing the look, which is how a card becomes a landmark.
- */
-declare function Card({ className, hover, accent, render, children, ...props }: CardProps): React$1.ReactElement<unknown, string | React$1.JSXElementConstructor<any>>;
-declare function CardHeader({ className, ...props }: React$1.ComponentProps<"div">): React$1.JSX.Element;
-declare function CardTitle({ className, ...props }: React$1.ComponentProps<"div">): React$1.JSX.Element;
-declare function CardDescription({ className, ...props }: React$1.ComponentProps<"div">): React$1.JSX.Element;
-declare function CardContent({ className, ...props }: React$1.ComponentProps<"div">): React$1.JSX.Element;
-declare function CardFooter({ className, ...props }: React$1.ComponentProps<"div">): React$1.JSX.Element;
-//#endregion
-//#region src/components/checkbox.d.ts
-/**
- * Checkbox.
- *
- * Base UI renders a `<span role="checkbox">` with a hidden `<input>` beside
- * it, so it submits with forms and takes `checked`/`defaultChecked`. The
- * indicator only mounts while checked or indeterminate; the icon inside it is
- * a lucide Check, or a Minus when `indeterminate` is set.
- *
- * The 16px box takes half the small radius: the 8px ladder step would round
- * it into a circle.
- */
-interface CheckboxProps extends React$1.ComponentProps<typeof Checkbox$1.Root> {}
-declare function Checkbox({ className, indeterminate, ...props }: CheckboxProps): React$1.JSX.Element;
-//#endregion
-//#region src/components/chip.d.ts
-/**
- * Chip — a pill for filters, tags and selected values. Unlike Badge it keeps
- * sentence case and the body font.
- */
-declare const chipVariants: (props?: ({
-  variant?: "default" | "outline" | "accent" | null | undefined;
-  size?: "default" | "sm" | null | undefined;
-} & import("class-variance-authority/types").ClassProp) | undefined) => string;
-interface ChipProps extends React$1.ComponentProps<"span">, VariantProps<typeof chipVariants> {}
-declare function Chip({ className, variant, size, ...props }: ChipProps): React$1.JSX.Element;
-//#endregion
-//#region src/components/combobox.d.ts
-/**
- * Combobox: a filterable text input with a listbox popup, on Base UI.
- *
- * Give the Root `items` (an array, or `[{ value, label }]`) and render the
- * list with `<ComboboxList>{(item) => <ComboboxItem value={item} />}</ComboboxList>`;
- * Base UI filters `items` against the input as the user types. Without
- * `items` nothing is filtered and `ComboboxEmpty` never shows.
- *
- * - `ComboboxInput` is our `Input` with a trailing open/close trigger and,
- *   with `clearable`, an X button that clears the value.
- * - `ComboboxContent` composes Portal + Positioner + Popup + List so
- *   consumers write one element; positioning props go to the Positioner.
- * - Multiple selection: set `multiple` on the Root and wrap `ComboboxValue`
- *   (rendering a `ComboboxChip` per value) plus `ComboboxInput` in
- *   `ComboboxChips`. Inside `ComboboxChips` the input drops its own frame;
- *   the chips container carries the field look and anchors the popup.
- * - `useComboboxFilter` is Base UI's `useFilter` for external filtering via
- *   `filteredItems`.
- *
- * `onValueChange` receives `(value, eventDetails)`; `onInputValueChange`
- * reports the typed text.
- */
-declare function Combobox<Value, Multiple extends boolean | undefined = false, Item = Value>(props: Combobox$1.Root.Props<Value, Multiple, Item>): import("react").JSX.Element;
-declare function ComboboxTrigger({ className, children, ...props }: Combobox$1.Trigger.Props): import("react").JSX.Element;
-declare function ComboboxClear({ className, children, ...props }: Combobox$1.Clear.Props): import("react").JSX.Element;
-interface ComboboxInputProps extends Combobox$1.Input.Props {
-  /** Show an X button that clears the selection while there is one. */
-  clearable?: boolean;
-  /** Class for the wrapper that holds the input and its buttons. */
-  wrapperClassName?: string;
-}
-declare function ComboboxInput({ className, clearable, wrapperClassName, ...props }: ComboboxInputProps): import("react").JSX.Element;
-declare function ComboboxValue(props: Combobox$1.Value.Props): import("react").JSX.Element;
-interface ComboboxChipsProps extends Combobox$1.Chips.Props {
-  /** Class for the inner chip row; `className` styles the field frame. */
-  chipsClassName?: string;
-}
-declare function ComboboxChips({ className, chipsClassName, children, ...props }: ComboboxChipsProps): import("react").JSX.Element;
-interface ComboboxChipProps extends Combobox$1.Chip.Props {
-  /** Hide the remove button. */
-  removable?: boolean;
-}
-declare function ComboboxChip({ className, children, removable, ...props }: ComboboxChipProps): import("react").JSX.Element;
-type PositionerProps$4 = Pick<Combobox$1.Positioner.Props, "side" | "align" | "sideOffset" | "alignOffset" | "anchor" | "collisionBoundary" | "collisionPadding" | "collisionAvoidance" | "sticky" | "positionMethod">;
-interface ComboboxContentProps extends Omit<Combobox$1.Popup.Props, "children">, PositionerProps$4 {
-  /** Items, or a render function called per filtered item (needs `items` on the Root). */
-  children?: Combobox$1.List.Props["children"];
-  /**
-   * Shown (via `ComboboxEmpty`, above the list) when nothing matches the query.
-   * Needs `items` on the Root.
-   */
-  empty?: ReactNode;
-  /** Class for the inner List element. */
-  listClassName?: string;
-  /** Keep the popup mounted in the DOM while hidden. */
-  keepMounted?: boolean;
-  /** Where to portal the popup; defaults to `<body>`. */
-  container?: Combobox$1.Portal.Props["container"];
-}
-declare function ComboboxContent({ className, children, empty, listClassName, side, align, sideOffset, alignOffset, anchor, collisionBoundary, collisionPadding, collisionAvoidance, sticky, positionMethod, keepMounted, container, ...props }: ComboboxContentProps): import("react").JSX.Element;
-declare function ComboboxItem({ className, children, ...props }: Combobox$1.Item.Props): import("react").JSX.Element;
-/** Renders per filtered item; use inside a `ComboboxGroup` given `items`, or for a flat list pass a function as `ComboboxContent` children instead. */
-declare function ComboboxCollection(props: Combobox$1.Collection.Props): import("react").JSX.Element;
-declare function ComboboxEmpty({ className, ...props }: Combobox$1.Empty.Props): import("react").JSX.Element;
-declare function ComboboxStatus({ className, ...props }: Combobox$1.Status.Props): import("react").JSX.Element;
-declare function ComboboxGroup({ className, ...props }: Combobox$1.Group.Props): import("react").JSX.Element;
-declare function ComboboxGroupLabel({ className, ...props }: Combobox$1.GroupLabel.Props): import("react").JSX.Element;
-declare function ComboboxSeparator({ className, ...props }: Combobox$1.Separator.Props): import("react").JSX.Element;
-declare const useComboboxFilter: typeof Combobox$1.useFilter;
-//#endregion
-//#region src/components/dialog.d.ts
-/**
- * Dialog.
- *
- * `DialogContent` composes Base UI's Portal + Backdrop + Popup so consumers
- * keep writing `<DialogContent>…</DialogContent>`. The Radix `Overlay` part is
- * exported as `DialogOverlay` (a styled Backdrop) for anyone composing by hand.
- *
- * Radix users: `asChild` becomes `render={...}`; `onOpenChange` receives
- * `(open, eventDetails)` rather than just `open`; the popup is only
- * dismissable via pointer when `modal` is true (the default), and
- * `disablePointerDismissal` replaces `onPointerDownOutside` preventDefault.
- */
-declare function Dialog(props: Dialog$1.Root.Props): React$1.JSX.Element;
-declare function DialogTrigger(props: Dialog$1.Trigger.Props): React$1.JSX.Element;
-declare function DialogPortal(props: Dialog$1.Portal.Props): React$1.JSX.Element;
-declare function DialogClose(props: Dialog$1.Close.Props): React$1.JSX.Element;
-declare function DialogOverlay({ className, ...props }: Dialog$1.Backdrop.Props): React$1.JSX.Element;
-interface DialogContentProps extends Dialog$1.Popup.Props {
-  /** Keep the dialog mounted in the DOM while hidden. */
-  keepMounted?: boolean;
-  /** Where to portal the dialog; defaults to `<body>`. */
-  container?: Dialog$1.Portal.Props["container"];
-}
-declare function DialogContent({ className, children, keepMounted, container, ...props }: DialogContentProps): React$1.JSX.Element;
-declare function DialogHeader({ className, ...props }: React$1.ComponentProps<"div">): React$1.JSX.Element;
-declare function DialogBody({ className, ...props }: React$1.ComponentProps<"div">): React$1.JSX.Element;
-declare function DialogFooter({ className, ...props }: React$1.ComponentProps<"div">): React$1.JSX.Element;
-declare function DialogTitle({ className, ...props }: Dialog$1.Title.Props): React$1.JSX.Element;
-declare function DialogDescription({ className, ...props }: Dialog$1.Description.Props): React$1.JSX.Element;
-//#endregion
-//#region src/components/command.d.ts
-/**
- * Command palette on cmdk, styled like DropdownMenu.
- *
- * cmdk filters and ranks items itself from each item's text (or `value` /
- * `keywords`); `CommandEmpty` renders when nothing matches. The selected
- * (keyboard-highlighted) item carries `data-selected="true"`; `onSelect` on
- * `CommandItem` fires on click and on Enter.
- *
- * `CommandDialog` puts a palette inside our Dialog with no header padding;
- * it needs a `title` (visually hidden) so the dialog is labelled. Wire
- * `open` / `onOpenChange` to a global shortcut (⌘K) for the usual pattern.
- */
-declare function Command({ className, ...props }: React$1.ComponentProps<typeof Command$1>): React$1.JSX.Element;
-interface CommandDialogProps extends React$1.ComponentProps<typeof Dialog> {
-  /** Accessible name for the dialog; visually hidden. */
-  title?: string;
-  /** Accessible description for the dialog; visually hidden. */
-  description?: string;
-  /** Class for the dialog popup. */
-  className?: string;
-  /** Class for the inner Command root. */
-  commandClassName?: string;
-  /** Where to portal the dialog; defaults to `<body>`. */
-  container?: DialogContentProps["container"];
-  /** Keep the dialog mounted in the DOM while hidden. */
-  keepMounted?: boolean;
-  /** Props for the inner cmdk root (`filter`, `shouldFilter`, `loop`, `value`, ...). */
-  commandProps?: Omit<React$1.ComponentProps<typeof Command$1>, "children" | "className">;
-  children?: React$1.ReactNode;
-}
-declare function CommandDialog({ title, description, className, commandClassName, container, keepMounted, commandProps, children, ...props }: CommandDialogProps): React$1.JSX.Element;
-declare function CommandInput({ className, ...props }: React$1.ComponentProps<typeof Command$1.Input>): React$1.JSX.Element;
-declare function CommandList({ className, ...props }: React$1.ComponentProps<typeof Command$1.List>): React$1.JSX.Element;
-declare function CommandEmpty({ className, ...props }: React$1.ComponentProps<typeof Command$1.Empty>): React$1.JSX.Element;
-declare function CommandGroup({ className, ...props }: React$1.ComponentProps<typeof Command$1.Group>): React$1.JSX.Element;
-declare function CommandSeparator({ className, ...props }: React$1.ComponentProps<typeof Command$1.Separator>): React$1.JSX.Element;
-interface CommandItemProps extends React$1.ComponentProps<typeof Command$1.Item> {
-  variant?: "default" | "destructive";
-}
-declare function CommandItem({ className, variant, ...props }: CommandItemProps): React$1.JSX.Element;
-declare function CommandShortcut({ className, ...props }: React$1.ComponentProps<"span">): React$1.JSX.Element;
-declare function CommandLoading(props: React$1.ComponentProps<typeof Command$1.Loading>): React$1.JSX.Element;
-//#endregion
-//#region src/components/date-field.d.ts
-/** `2026-01-05`. */
-declare function formatDateISO(date: Date): string;
-/** `5 Jan 2026` for en-GB; other locales via `Intl.DateTimeFormat`. */
-declare function formatDateShort(date: Date, locale?: string): string;
-/** `5 January 2026` for en-GB; other locales via `Intl.DateTimeFormat`. */
-declare function formatDateLong(date: Date, locale?: string): string;
-/**
- * Calendar-day distance in words: `today`, `yesterday`, `tomorrow`, `3 days
- * ago`, `in 2 weeks`, `4 months ago`, `in 2 years`. Compares local calendar
- * days, so 23:59 to 00:01 is `tomorrow`. Other locales use
- * `Intl.RelativeTimeFormat`.
- */
-declare function formatRelative(date: Date, options?: {
-  now?: Date;
-  locale?: string;
-}): string;
-/** Strict `yyyy-mm-dd`; rejects impossible days such as `2026-02-30`. */
-declare function parseDateISO(text: string): Date | undefined;
-/** ISO first, then the English `5 Jan 2026` / `5 January 2026` shapes. */
-declare function parseDateDefault(text: string): Date | undefined;
-type CalendarPassthrough$1 = Omit<CalendarProps, "mode" | "selected" | "onSelect" | "required" | "disabled">;
-interface DateFieldProps extends Omit<React$1.ComponentProps<"input">, "value" | "defaultValue" | "onChange" | "min" | "max" | "type"> {
-  /** The date (controlled). */
-  value?: Date | undefined;
-  /** The initial date (uncontrolled). */
-  defaultValue?: Date | undefined;
-  /** Called with the parsed or picked date, or `undefined` when the text is cleared or invalid. */
-  onValueChange?: (date: Date | undefined) => void;
-  /** Input placeholder; defaults to the ISO shape. */
-  placeholder?: string;
-  /** Formats the date into the input; defaults to ISO `yyyy-mm-dd`. */
-  formatDate?: (date: Date) => string;
-  /** Parses typed text; defaults to ISO plus the English day-month-year shapes. */
-  parseDate?: (text: string) => Date | undefined;
-  /** Earliest selectable day. */
-  min?: Date;
-  /** Latest selectable day. */
-  max?: Date;
-  disabled?: boolean;
-  /** Force the invalid look (e.g. from a form validator). */
-  invalid?: boolean;
-  /** Extra props for the Calendar (e.g. `captionLayout`, `today`). */
-  calendarProps?: CalendarPassthrough$1;
-  /** Class name for the wrapper; use `className` for the input itself. */
-  wrapperClassName?: string;
-}
-declare function DateField(props: DateFieldProps): React$1.JSX.Element;
-//#endregion
-//#region src/components/date-picker.d.ts
-/** en-GB order, no library: `15 January 2026`. */
-declare function formatDateDefault(date: Date): string;
-type CalendarPassthrough = Omit<CalendarProps, "mode" | "selected" | "onSelect" | "required" | "disabled">;
-interface DatePickerProps {
-  /** The selected date (controlled). */
-  value?: Date | undefined;
-  /** The initial date (uncontrolled). */
-  defaultValue?: Date | undefined;
-  /** Called with the picked date, or `undefined` when the selected day is clicked again. */
-  onValueChange?: (date: Date | undefined) => void;
-  /** Trigger text while nothing is selected. */
-  placeholder?: string;
-  /** Formats the trigger text; defaults to `15 January 2026`. */
-  formatDate?: (date: Date) => string;
-  /** Disables the trigger. */
-  disabled?: boolean;
-  /** Class name for the trigger button. */
-  className?: string;
-  /** Extra props for the Calendar (e.g. `startMonth`, `captionLayout`, `disabled` matchers via `calendarProps.hidden`). */
-  calendarProps?: CalendarPassthrough & {
-    disabled?: CalendarProps["disabled"];
-  };
-  /** Accessible name for the trigger. */
-  "aria-label"?: string;
-}
-declare function DatePicker(props: DatePickerProps): React$1.JSX.Element;
-interface DateRangePickerProps extends Omit<DatePickerProps, "value" | "defaultValue" | "onValueChange"> {
-  value?: DateRange | undefined;
-  defaultValue?: DateRange | undefined;
-  onValueChange?: (range: DateRange | undefined) => void;
-  /** Separator between the two ends; defaults to an en dash. */
-  separator?: string;
-}
-declare function DateRangePicker(props: DateRangePickerProps): React$1.JSX.Element;
-//#endregion
-//#region src/components/dropdown-menu.d.ts
-/**
- * DropdownMenu over Base UI's Menu.
- *
- * `DropdownMenuContent` and `DropdownMenuSubContent` compose Portal +
- * Positioner + Popup, so consumers keep writing one element; `side`, `align`
- * and `sideOffset` are forwarded to the Positioner where Base UI reads them.
- *
- * Radix users: `asChild` on the trigger becomes `render={<Button />}`;
- * `onSelect` on items is `onClick`; `DropdownMenuLabel` is Base UI's
- * `Menu.GroupLabel` (place it inside a `DropdownMenuGroup` for the
- * `aria-labelledby` wiring); `DropdownMenuCheckboxItem` reports through
- * `onCheckedChange(checked, eventDetails)`; `DropdownMenuRadioGroup` through
- * `onValueChange(value, eventDetails)`. Highlight state is `data-highlighted`,
- * not `:focus`.
- */
-declare function DropdownMenu(props: Menu.Root.Props): React$1.JSX.Element;
-declare function DropdownMenuTrigger(props: Menu.Trigger.Props): React$1.JSX.Element;
-declare function DropdownMenuPortal(props: Menu.Portal.Props): React$1.JSX.Element;
-declare function DropdownMenuGroup(props: Menu.Group.Props): React$1.JSX.Element;
-declare function DropdownMenuSub(props: Menu.SubmenuRoot.Props): React$1.JSX.Element;
-declare function DropdownMenuRadioGroup(props: Menu.RadioGroup.Props): React$1.JSX.Element;
-type PositionerProps$3 = Pick<Menu.Positioner.Props, "side" | "align" | "sideOffset" | "alignOffset" | "anchor" | "collisionBoundary" | "collisionPadding" | "collisionAvoidance" | "sticky" | "positionMethod">;
-interface DropdownMenuContentProps extends Menu.Popup.Props, PositionerProps$3 {
-  /** Keep the menu mounted in the DOM while hidden. */
-  keepMounted?: boolean;
-  /** Where to portal the menu; defaults to `<body>`. */
-  container?: Menu.Portal.Props["container"];
-}
-declare function DropdownMenuContent({ className, side, align, sideOffset, alignOffset, anchor, collisionBoundary, collisionPadding, collisionAvoidance, sticky, positionMethod, keepMounted, container, ...props }: DropdownMenuContentProps): React$1.JSX.Element;
-declare function DropdownMenuSubContent({ className, side, align, sideOffset, alignOffset, anchor, collisionBoundary, collisionPadding, collisionAvoidance, sticky, positionMethod, keepMounted, container, ...props }: DropdownMenuContentProps): React$1.JSX.Element;
-interface DropdownMenuItemProps extends Menu.Item.Props {
-  inset?: boolean;
-  variant?: "default" | "destructive";
-}
-declare function DropdownMenuItem({ className, inset, variant, ...props }: DropdownMenuItemProps): React$1.JSX.Element;
-declare function DropdownMenuCheckboxItem({ className, children, ...props }: Menu.CheckboxItem.Props): React$1.JSX.Element;
-declare function DropdownMenuRadioItem({ className, children, ...props }: Menu.RadioItem.Props): React$1.JSX.Element;
-interface DropdownMenuLabelProps extends Menu.GroupLabel.Props {
-  inset?: boolean;
-}
-declare function DropdownMenuLabel({ className, inset, ...props }: DropdownMenuLabelProps): React$1.JSX.Element;
-declare function DropdownMenuSeparator({ className, ...props }: Menu.Separator.Props): React$1.JSX.Element;
-interface DropdownMenuSubTriggerProps extends Menu.SubmenuTrigger.Props {
-  inset?: boolean;
-}
-declare function DropdownMenuSubTrigger({ className, inset, children, ...props }: DropdownMenuSubTriggerProps): React$1.JSX.Element;
-declare function DropdownMenuShortcut({ className, ...props }: React$1.ComponentProps<"span">): React$1.JSX.Element;
-//#endregion
-//#region src/components/dropzone.d.ts
-/** `1536` → `1.5 KB`, `0` → `0 B`; base 1024, one decimal above bytes. */
-declare function formatFileSize(bytes: number): string;
-interface DropzoneProps extends Omit<React$1.ComponentProps<"div">, "children" | "onDrop" | "onDragEnter" | "onDragOver" | "onDragLeave"> {
-  /** Called with the accepted files after a drop, a paste or the file dialog. */
-  onFiles: (files: File[]) => void;
-  /** Called with the rejected files and their reasons. */
-  onReject?: (rejections: FileRejection[]) => void;
-  /** MIME type to extension map, e.g. `{ "image/png": [".png"] }`. */
-  accept?: Accept;
-  /** Allow more than one file; defaults to true. */
-  multiple?: boolean;
-  /** Largest accepted file in bytes. */
-  maxSize?: number;
-  /** Most files accepted per drop; `0` means unlimited. */
-  maxFiles?: number;
-  disabled?: boolean;
-  /** Do not open the file dialog on click; for a zone that wraps clickable content. @default false */
-  noClick?: boolean;
-  /** Do not open the file dialog on Enter or Space; pair with `noClick`. @default false */
-  noKeyboard?: boolean;
-  /** Primary line of the default body. */
-  label?: React$1.ReactNode;
-  /** Muted second line of the default body; derived from `accept` and `maxSize` when omitted. */
-  hint?: React$1.ReactNode;
-  /** Replace the default body. A function receives react-dropzone's state. */
-  children?: React$1.ReactNode | ((state: DropzoneState) => React$1.ReactNode);
-}
-declare function Dropzone({ onFiles, onReject, accept, multiple, maxSize, maxFiles, disabled, noClick, noKeyboard, label, hint, children, className, ref, ...props }: DropzoneProps): React$1.JSX.Element;
-interface FileListProps extends Omit<React$1.ComponentProps<"ul">, "children"> {
-  files: readonly File[];
-  /** Called with the file and its index when its remove button is pressed; the button is hidden when omitted. */
-  onRemove?: (file: File, index: number) => void;
-  /** Formats the size column; defaults to `formatFileSize`. */
-  formatSize?: (bytes: number) => string;
-}
-/**
- * The files a Dropzone picked: name, size and a remove button per row. Rows
- * are keyed by name, size and last-modified time so re-picking the same file
- * keeps its row stable.
- */
-declare function FileList({ files, onRemove, formatSize, className, ...props }: FileListProps): React$1.JSX.Element | null;
-//#endregion
-//#region src/components/empty-state.d.ts
-interface EmptyStateProps extends Omit<React$1.ComponentProps<"div">, "title"> {
-  /** A lucide icon; sized and coloured by the state. */
-  icon?: React$1.ReactNode;
-  title: React$1.ReactNode;
-  description?: React$1.ReactNode;
-  /** One or two buttons offering the next step. */
-  action?: React$1.ReactNode;
-  /** `compact` for an empty panel inside a card; `default` for an empty page. */
-  size?: "default" | "compact";
-}
-/**
- * EmptyState — the centred, muted "nothing here yet" surface. The icon sits
- * in a soft disc on the muted token; the title stays in the foreground so the
- * eye lands on it, and everything else recedes.
- */
-declare function EmptyState({ className, icon, title, description, action, size, children, ...props }: EmptyStateProps): React$1.JSX.Element;
-//#endregion
-//#region src/components/error-banner.d.ts
-interface ErrorBannerProps extends Omit<React$1.ComponentProps<"div">, "children"> {
-  message: string;
-  onDismiss?: () => void;
-  onRetry?: () => void;
-}
-/**
- * ErrorBanner — the one error surface every screen uses: a warning icon, the
- * message, and optional Retry / Dismiss actions. Renders nothing for an empty
- * message so callers can pass their error state straight through.
- */
-declare function ErrorBanner({ message, onDismiss, onRetry, className, ...props }: ErrorBannerProps): React$1.JSX.Element | null;
-//#endregion
-//#region src/components/field.d.ts
-/**
- * Field.
- *
- * The shadcn Field shape over Base UI's Field and Fieldset. `Field` is
- * `Field.Root`: it owns the label/control/description/error association, so a
- * `FieldLabel` focuses its `FieldControl` (or any Base UI control such as
- * Checkbox, Select, Switch) without an explicit `htmlFor`, and every message
- * ends up in the control's `aria-describedby`.
- *
- * Validity: Base UI puts `data-invalid` on every part once the control fails
- * native constraints or a `validate` callback, and adds `aria-invalid` to the
- * control. Pass `invalid` on `Field` when an external library owns the state
- * (the Form component does this from react-hook-form).
- *
- * `FieldError` follows the field's validity: static children show once the
- * control is invalid or the Field is marked `invalid`; `match="valueMissing"`
- * narrows that to one constraint. Given `errors` (a react-hook-form error
- * list) it renders whenever the list has a message.
- */
-declare const fieldVariants: (props?: ({
-  orientation?: "horizontal" | "vertical" | null | undefined;
-} & import("class-variance-authority/types").ClassProp) | undefined) => string;
-interface FieldProps extends React$1.ComponentProps<typeof Field$1.Root>, VariantProps<typeof fieldVariants> {}
-declare function Field({ className, orientation, invalid, ...props }: FieldProps): React$1.JSX.Element;
-/** Stacks a label and description beside a control in a horizontal Field. */
-declare function FieldContent({ className, ...props }: React$1.ComponentProps<"div">): React$1.JSX.Element;
-interface FieldLabelProps extends React$1.ComponentProps<typeof Field$1.Label> {}
-declare function FieldLabel({ className, ...props }: FieldLabelProps): React$1.JSX.Element;
-interface FieldControlProps extends React$1.ComponentProps<typeof Field$1.Control> {}
-/**
- * The field's `<input>`, styled like Input. Swap the element with `render`
- * (`render={<Textarea />}`); the input styling still applies unless the
- * rendered element's own className wins in tailwind-merge.
- */
-declare function FieldControl({ className, ...props }: FieldControlProps): React$1.JSX.Element;
-interface FieldDescriptionProps extends React$1.ComponentProps<typeof Field$1.Description> {}
-declare function FieldDescription({ className, ...props }: FieldDescriptionProps): React$1.JSX.Element;
-/** The shape react-hook-form gives for a field error; only `message` is read. */
-interface FieldErrorItem {
-  message?: string | undefined;
-}
-interface FieldErrorProps extends React$1.ComponentProps<typeof Field$1.Error> {
-  /**
-   * Errors from an external validator. Duplicate messages collapse; one message
-   * renders as text, several as a list.
-   */
-  errors?: ReadonlyArray<FieldErrorItem | undefined> | undefined;
-}
-declare function FieldError({ className, children, errors, match, ...props }: FieldErrorProps): React$1.JSX.Element | null;
-interface FieldsetProps extends React$1.ComponentProps<typeof Fieldset$1.Root> {}
-declare function Fieldset({ className, ...props }: FieldsetProps): React$1.JSX.Element;
-interface FieldsetLegendProps extends React$1.ComponentProps<typeof Fieldset$1.Legend> {}
-declare function FieldsetLegend({ className, ...props }: FieldsetLegendProps): React$1.JSX.Element;
-/** A vertical stack of Fields with the spacing a form uses between rows. */
-declare function FieldGroup({ className, ...props }: React$1.ComponentProps<"div">): React$1.JSX.Element;
-//#endregion
-//#region src/components/form.d.ts
-declare const Form: <TFieldValues extends FieldValues, TContext = any, TTransformedValues = TFieldValues>({ children, watch, getValues, getErrors, getFieldState, setError, clearErrors, setValue, setValues, trigger, formState, resetField, reset, resetDefaultValues, handleSubmit, unregister, control, register, setFocus, subscribe }: import("react-hook-form").FormProviderProps<TFieldValues, TContext, TTransformedValues>) => React$1.JSX.Element;
-declare function FormField<TFieldValues extends FieldValues = FieldValues, TName extends FieldPath<TFieldValues> = FieldPath<TFieldValues>, TTransformedValues = TFieldValues>(props: ControllerProps<TFieldValues, TName, TTransformedValues>): React$1.JSX.Element;
-interface UseFormFieldReturn {
-  id: string;
-  name: string;
-  formItemId: string;
-  formDescriptionId: string;
-  formMessageId: string;
-  invalid: boolean;
-  isDirty: boolean;
-  isTouched: boolean;
-  isValidating: boolean;
-  error?: FieldError$1 | undefined;
-}
-declare function useFormField(): UseFormFieldReturn;
-interface FormItemProps extends Omit<FieldProps, "invalid" | "name"> {}
-declare function FormItem({ className, ...props }: FormItemProps): React$1.JSX.Element;
-interface FormLabelProps extends FieldLabelProps {}
-declare function FormLabel({ className, ...props }: FormLabelProps): React$1.JSX.Element;
-interface FormControlProps extends React$1.HTMLAttributes<HTMLElement> {
-  /** The single control element; it receives `id`, `aria-describedby` and `aria-invalid`. */
-  children: React$1.ReactElement;
-}
-declare function FormControl({ children, ...props }: FormControlProps): React$1.ReactElement<unknown, string | React$1.JSXElementConstructor<any>>;
-interface FormDescriptionProps extends FieldDescriptionProps {}
-declare function FormDescription({ className, ...props }: FormDescriptionProps): React$1.JSX.Element;
-interface FormMessageProps extends Omit<FieldErrorProps, "errors" | "match"> {}
-declare function FormMessage({ className, children, ...props }: FormMessageProps): React$1.JSX.Element | null;
-//#endregion
-//#region src/components/input.d.ts
-/**
- * Input.
- *
- * A plain `<input>`; Base UI has no primitive for it and none is needed. The
- * look is cortenaweb's: sunken surface, subtle border that strengthens on hover
- * and takes the ring colour on focus. `aria-invalid` swaps the border and ring
- * for the destructive pair so a Field can mark errors without extra classes.
- */
-declare const inputClassName: string;
-interface InputProps extends React$1.ComponentProps<"input"> {}
-declare function Input({ className, type, ...props }: InputProps): React$1.JSX.Element;
-//#endregion
-//#region src/components/kbd.d.ts
-/**
- * Kbd — an inline keyboard-key cap. Mono caption-sm text on the sunken
- * surface, with a heavier bottom border for the key-cap read.
- */
-declare function Kbd({ className, ...props }: React$1.ComponentProps<"kbd">): React$1.JSX.Element;
-//#endregion
-//#region src/components/label.d.ts
-/**
- * Label — a plain `<label>`. Base UI's Label lives inside Field, so this is
- * the standalone form caption for anything that is not a Field.
- */
-declare const labelVariants: (props?: import("class-variance-authority/types").ClassProp | undefined) => string;
-interface LabelProps extends React$1.ComponentProps<"label">, VariantProps<typeof labelVariants> {}
-declare function Label({ className, ...props }: LabelProps): React$1.JSX.Element;
-//#endregion
-//#region src/components/loading-skeleton.d.ts
-type LoadingSkeletonPreset = "list" | "table" | "card" | "form";
-interface LoadingSkeletonProps extends React$1.ComponentProps<"div"> {
-  /** Which shape of content is loading. */
-  preset?: LoadingSkeletonPreset;
-  /** Rows (list, table, form) or cards. Each preset has a sensible default. */
-  rows?: number;
-  /** Columns for `table` and `card`. */
-  columns?: number;
-}
-/**
- * LoadingSkeleton — page-level placeholders assembled from Skeleton, one per
- * shape of content: a list of rows with an avatar, a table with a header row,
- * a grid of cards, or a stacked form. Announces itself as busy so assistive
- * technology knows the region is loading; the blocks themselves are hidden.
- */
-declare function LoadingSkeleton({ className, preset, rows, columns, ...props }: LoadingSkeletonProps): React$1.JSX.Element;
-//#endregion
-//#region src/components/markdown.d.ts
-/** The GitHub schema, plus `class="language-*"` on code and `checked` on task boxes. */
-declare const markdownSanitizeSchema: Options$1;
-interface CodeRendererProps {
-  /** The fenced block's text, without a trailing newline. */
-  code: string;
-  /** From the fence's info string, e.g. `ts` for ```ts. */
-  language: string | undefined;
-}
-interface MarkdownProps extends Omit<React$1.ComponentProps<"div">, "children"> {
-  /** The markdown source. */
-  children: string | null | undefined;
-  /** Tighter rhythm and smaller headings, for chat bubbles. */
-  compact?: boolean;
-  /** Renders fenced code blocks; the copy button is still added. Use for syntax highlighting. */
-  codeRenderer?: (props: CodeRendererProps) => React$1.ReactNode;
-  /** Override or extend the element map. */
-  components?: Components;
-  /** Extra remark plugins, appended after GFM. */
-  remarkPlugins?: NonNullable<Options["remarkPlugins"]>;
-  /** Extra rehype plugins, appended after sanitize. */
-  rehypePlugins?: NonNullable<Options["rehypePlugins"]>;
-  /**
-   * Rehype plugins that must run BEFORE sanitize. The one legitimate use is
-   * `rehype-raw` in a host that embeds trusted custom tags in markdown (the
-   * webchat's `<cortena-*>` blocks): raw HTML has to become nodes before the
-   * sanitizer sees it, and the sanitize schema then decides what survives.
-   * Anything placed here widens what reaches the sanitizer, so keep the
-   * schema strict when you use it.
-   */
-  rehypePluginsBeforeSanitize?: NonNullable<Options["rehypePlugins"]>;
-  /** Replace the sanitize schema; defaults to `markdownSanitizeSchema`. */
-  sanitizeSchema?: Options$1;
-  /** Rewrite URLs; defaults to react-markdown's, which drops non-http(s)/mailto/tel schemes. */
-  urlTransform?: Options["urlTransform"];
-}
-declare function Markdown({ children, compact, codeRenderer, components, remarkPlugins, rehypePlugins, rehypePluginsBeforeSanitize, sanitizeSchema, urlTransform, className, ...props }: MarkdownProps): React$1.JSX.Element;
-//#endregion
-//#region src/components/page-header.d.ts
-interface PageHeaderProps extends Omit<React$1.ComponentProps<"header">, "title"> {
-  /** The page title. Rendered as the h1; use `titleAs` to demote it. */
-  title: React$1.ReactNode;
-  description?: React$1.ReactNode;
-  /** Buttons for the page, right-aligned on wide viewports. */
-  actions?: React$1.ReactNode;
-  /** Short uppercase label above the title, e.g. a section or product name. */
-  eyebrow?: React$1.ReactNode;
-  /** A Breadcrumb or any navigation rendered above the eyebrow. */
-  breadcrumb?: React$1.ReactNode;
-  /** Heading level when the page already has an h1. */
-  titleAs?: "h1" | "h2" | "h3";
-}
-/**
- * PageHeader — the top of every screen: breadcrumb, eyebrow, title,
- * description, and an actions slot. The title is an h1 on the h2 step of the
- * type scale in the display face, so screens read as one product rather than
- * as a stack of card titles.
- */
-declare function PageHeader({ className, title, description, actions, eyebrow, breadcrumb, titleAs: Title, children, ...props }: PageHeaderProps): React$1.JSX.Element;
-//#endregion
-//#region src/components/popover.d.ts
-/**
- * Popover.
- *
- * `PopoverContent` composes Base UI's Portal + Positioner + Popup so consumers
- * keep writing `<PopoverContent side="bottom" align="start">`; the positioning
- * props are forwarded to the Positioner, which is where Base UI reads them.
- *
- * Radix users: `asChild` on the trigger becomes `render={<Button />}`;
- * `PopoverAnchor` is gone — pass `anchor={ref}` to `PopoverContent` instead.
- */
-declare function Popover(props: Popover$1.Root.Props): import("react").JSX.Element;
-declare function PopoverTrigger(props: Popover$1.Trigger.Props): import("react").JSX.Element;
-declare function PopoverClose(props: Popover$1.Close.Props): import("react").JSX.Element;
-declare function PopoverTitle({ className, ...props }: Popover$1.Title.Props): import("react").JSX.Element;
-declare function PopoverDescription({ className, ...props }: Popover$1.Description.Props): import("react").JSX.Element;
-type PositionerProps$2 = Pick<Popover$1.Positioner.Props, "side" | "align" | "sideOffset" | "alignOffset" | "anchor" | "collisionBoundary" | "collisionPadding" | "collisionAvoidance" | "sticky" | "positionMethod">;
-interface PopoverContentProps extends Popover$1.Popup.Props, PositionerProps$2 {
-  /** Keep the popup mounted in the DOM while hidden. */
-  keepMounted?: boolean;
-  /** Where to portal the popup; defaults to `<body>`. */
-  container?: Popover$1.Portal.Props["container"];
-}
-declare function PopoverContent({ className, side, align, sideOffset, alignOffset, anchor, collisionBoundary, collisionPadding, collisionAvoidance, sticky, positionMethod, keepMounted, container, ...props }: PopoverContentProps): import("react").JSX.Element;
-//#endregion
-//#region src/components/progress.d.ts
-/**
- * Progress.
- *
- * `Progress` renders the Base UI root (a `<div role="progressbar">` carrying
- * `aria-valuenow`) with the track and indicator already inside; Base UI sizes
- * the indicator to `value` as a percentage of `min`..`max`. Put a
- * `ProgressLabel` and `ProgressValue` in `children` for a captioned bar; they
- * render in a row above the track. `value={null}` gives an indeterminate bar.
- */
-interface ProgressProps extends React$1.ComponentProps<typeof Progress$1.Root> {}
-declare function Progress({ className, children, ...props }: ProgressProps): React$1.JSX.Element;
-declare function ProgressTrack({ className, ...props }: React$1.ComponentProps<typeof Progress$1.Track>): React$1.JSX.Element;
-declare function ProgressIndicator({ className, ...props }: React$1.ComponentProps<typeof Progress$1.Indicator>): React$1.JSX.Element;
-declare function ProgressLabel({ className, ...props }: React$1.ComponentProps<typeof Progress$1.Label>): React$1.JSX.Element;
-declare function ProgressValue({ className, ...props }: React$1.ComponentProps<typeof Progress$1.Value>): React$1.JSX.Element;
-//#endregion
-//#region src/components/radio-group.d.ts
-/**
- * Radio group.
- *
- * `RadioGroup` owns the value (`value` / `defaultValue` / `onValueChange`) and
- * renders a `<div role="radiogroup">`; each `RadioGroupItem` is a Base UI
- * `Radio.Root` (`<span role="radio">`) with a dot indicator that only mounts
- * while checked. Arrow keys move the selection, as the ARIA pattern requires.
- */
-interface RadioGroupProps extends React$1.ComponentProps<typeof RadioGroup$1> {}
-declare function RadioGroup({ className, ...props }: RadioGroupProps): React$1.JSX.Element;
-interface RadioGroupItemProps extends React$1.ComponentProps<typeof Radio.Root> {}
-declare function RadioGroupItem({ className, ...props }: RadioGroupItemProps): React$1.JSX.Element;
-//#endregion
-//#region src/components/scroll-area.d.ts
-/**
- * ScrollArea.
- *
- * Base UI positions the scrollbar and thumb itself (absolute inside the root,
- * thumb size in `--scroll-area-thumb-*`); this file only sets the track width,
- * the thumb colour and the hover/scroll reveal. Base UI also unmounts the
- * scrollbar when there is nothing to scroll, so an empty list shows no track.
- *
- * Radix users: the `display: table` wrapper is gone, so `truncate` works
- * inside the viewport without the `[&>div]:!block` override cortenaweb needed.
- * `type="always" | "hover"` is gone too; the scrollbar shows on hover and while
- * scrolling, and `keepMounted` on `ScrollBar` keeps it in the DOM otherwise.
- */
-interface ScrollAreaProps extends ScrollArea$1.Root.Props {
-  /** Which scrollbars to render. Defaults to vertical only. */
-  orientation?: "vertical" | "horizontal" | "both";
-}
-declare function ScrollArea({ className, children, orientation, ...props }: ScrollAreaProps): import("react").JSX.Element;
-declare function ScrollBar({ className, orientation, ...props }: ScrollArea$1.Scrollbar.Props): import("react").JSX.Element;
-//#endregion
-//#region src/components/section-card.d.ts
-interface SectionCardProps extends Omit<CardProps, "title"> {
-  title: React$1.ReactNode;
-  description?: React$1.ReactNode;
-  /** Controls for the section, right-aligned in the header row. */
-  actions?: React$1.ReactNode;
-  /** Rendered in a CardFooter under the body. */
-  footer?: React$1.ReactNode;
-  /** Remove the body padding, for a table or list that fills the card. */
-  flush?: boolean;
-  /** Class on the body wrapper. */
-  bodyClassName?: string;
-}
-/**
- * SectionCard — a Card with a header row (title, description, actions), a
- * body and an optional footer. It composes the Card parts rather than
- * restyling them, so a SectionCard and a hand-built Card look identical.
- *
- * `render` is Card's and reaches the outer element, so a section card can be
- * the landmark it is named after: `render={<section aria-labelledby={id} />}`
- * with the same `id` on the title, or `render={<aside />}` for a side panel.
- */
-declare function SectionCard({ title, description, actions, footer, flush, bodyClassName, children, ...props }: SectionCardProps): React$1.JSX.Element;
-//#endregion
-//#region src/components/segmented.d.ts
-/**
- * Segmented control.
- *
- * A single-select row of options exposed as a radiogroup: the same semantics
- * cortenaweb shipped, which screen readers announce as "1 of 3, selected".
- * The active segment lifts onto the raised surface with the small shadow; the
- * others read as muted text until hovered.
- */
-interface SegmentedOption<T extends string = string> {
-  value: T;
-  label: React$1.ReactNode;
-  icon?: React$1.ReactNode;
-  disabled?: boolean;
-}
-interface SegmentedProps<T extends string = string> extends Omit<React$1.ComponentProps<"div">, "onChange"> {
-  value: T;
-  onValueChange: (value: T) => void;
-  options: readonly SegmentedOption<T>[];
-  "aria-label"?: string;
-}
-declare function Segmented<T extends string = string>({ className, value, onValueChange, options, "aria-label": ariaLabel, ...props }: SegmentedProps<T>): React$1.JSX.Element;
-//#endregion
-//#region src/components/select.d.ts
-/**
- * Select.
- *
- * `SelectContent` composes Base UI's Portal + Positioner + Popup so consumers
- * keep writing `<SelectContent side="bottom" align="start">`; positioning
- * props are forwarded to the Positioner, which is where Base UI reads them.
- *
- * Radix users:
- * - `SelectValue` shows the raw value unless the Root is given `items`
- *   (`{ [value]: label }` or `[{ value, label }]`) or `itemToStringLabel`;
- *   Base UI does not read the label out of an unmounted `SelectItem`.
- * - `onValueChange` receives `(value, eventDetails)`.
- * - `SelectContent` defaults to the dropdown layout; pass
- *   `alignItemWithTrigger` for Base UI's native-like overlay of the selected item.
- *
- * ## Typing the value
- *
- * `null` is the cleared / placeholder state, so `onValueChange` always hands
- * back `Value | null`, never bare `Value`. Name the value type on the element
- * to keep that union at `string | null` instead of letting inference widen it:
- *
- * ```tsx
- * const [status, setStatus] = useState("");
- *
- * <Select<string>
- *   // "" is not a value any item carries; `|| null` is the placeholder state,
- *   // which is what makes SelectValue fall back to its `placeholder`.
- *   value={status || null}
- *   onValueChange={(next) => setStatus(next ?? "")} // next: string | null
- * >
- * ```
- *
- * Without the explicit `<string>` the type argument is inferred from `value`,
- * so a `string | null` value widens `Value` and the handler's parameter turns
- * into `string | null | null`. Multi-select narrows too:
- * `<Select<string, true> multiple>` hands back `string[]`, never `null`.
- *
- * `SelectProps` is the same props type, for a wrapper that forwards them.
- */
-type SelectProps<Value = string, Multiple extends boolean | undefined = false> = Select$1.Root.Props<Value, Multiple>;
-declare function Select<Value, Multiple extends boolean | undefined = false>(props: SelectProps<Value, Multiple>): import("react").JSX.Element;
-declare function SelectGroup({ className, ...props }: Select$1.Group.Props): import("react").JSX.Element;
-declare function SelectValue({ className, ...props }: Select$1.Value.Props): import("react").JSX.Element;
-interface SelectTriggerProps extends Select$1.Trigger.Props {
-  size?: "sm" | "md";
-}
-declare function SelectTrigger({ className, size, children, ...props }: SelectTriggerProps): import("react").JSX.Element;
-type PositionerProps$1 = Pick<Select$1.Positioner.Props, "side" | "align" | "sideOffset" | "alignOffset" | "anchor" | "collisionBoundary" | "collisionPadding" | "collisionAvoidance" | "sticky" | "positionMethod" | "alignItemWithTrigger">;
-interface SelectContentProps extends Select$1.Popup.Props, PositionerProps$1 {
-  /** Where to portal the popup; defaults to `<body>`. */
-  container?: Select$1.Portal.Props["container"];
-}
-declare function SelectContent({ className, children, side, align, sideOffset, alignOffset, anchor, collisionBoundary, collisionPadding, collisionAvoidance, sticky, positionMethod, alignItemWithTrigger, container, ...props }: SelectContentProps): import("react").JSX.Element;
-declare function SelectLabel({ className, ...props }: Select$1.GroupLabel.Props): import("react").JSX.Element;
-declare function SelectItem({ className, children, ...props }: Select$1.Item.Props): import("react").JSX.Element;
-declare function SelectSeparator({ className, ...props }: Select$1.Separator.Props): import("react").JSX.Element;
-//#endregion
-//#region src/components/separator.d.ts
-interface SeparatorProps extends React$1.ComponentProps<typeof Separator$1> {
-  /**
-   * Purely visual: renders with `role="none"` so screen readers skip it.
-   * Defaults to true, matching the Radix component this replaces.
-   */
-  decorative?: boolean;
-}
-/**
- * Separator — a one-pixel rule on the border token. Base UI supplies the
- * `role="separator"` and `aria-orientation` semantics when not decorative.
- */
-declare function Separator({ className, orientation, decorative, ...props }: SeparatorProps): React$1.JSX.Element;
-//#endregion
-//#region src/components/sheet.d.ts
-interface SheetProps extends Dialog$1.Root.Props {
-  /**
-   * `true` (default) traps focus, locks page scroll and draws a backdrop.
-   * `false` draws no backdrop and traps nothing, for a panel read alongside
-   * the app. `"trap-focus"` keeps focus in but leaves the page scrollable.
-   */
-  modal?: boolean | "trap-focus";
-}
-declare function Sheet({ modal, ...props }: SheetProps): React$1.JSX.Element;
-declare function SheetTrigger(props: Dialog$1.Trigger.Props): React$1.JSX.Element;
-declare function SheetClose(props: Dialog$1.Close.Props): React$1.JSX.Element;
-declare function SheetPortal(props: Dialog$1.Portal.Props): React$1.JSX.Element;
-declare function SheetOverlay({ className, ...props }: Dialog$1.Backdrop.Props): React$1.JSX.Element;
-declare const sheetVariants: (props?: ({
-  side?: "top" | "bottom" | "left" | "right" | null | undefined;
-} & import("class-variance-authority/types").ClassProp) | undefined) => string;
-interface SheetContentProps extends Dialog$1.Popup.Props, VariantProps<typeof sheetVariants> {
-  /** Keep the sheet mounted in the DOM while hidden. */
-  keepMounted?: boolean;
-  /** Where to portal the sheet; defaults to `<body>`. */
-  container?: Dialog$1.Portal.Props["container"];
-}
-declare function SheetContent({ side, className, children, keepMounted, container, ...props }: SheetContentProps): React$1.JSX.Element;
-declare function SheetHeader({ className, ...props }: React$1.ComponentProps<"div">): React$1.JSX.Element;
-declare function SheetFooter({ className, ...props }: React$1.ComponentProps<"div">): React$1.JSX.Element;
-declare function SheetTitle({ className, ...props }: Dialog$1.Title.Props): React$1.JSX.Element;
-declare function SheetDescription({ className, ...props }: Dialog$1.Description.Props): React$1.JSX.Element;
-//#endregion
-//#region src/components/skeleton.d.ts
-/**
- * Skeleton — a pulsing placeholder block. Sized by the consumer (`h-4 w-40`);
- * the fill is the border token, which reads on the canvas, a card and a
- * popover in both themes.
- */
-declare function Skeleton({ className, ...props }: React$1.ComponentProps<"div">): React$1.JSX.Element;
-//#endregion
-//#region src/components/sortable-list.d.ts
-/** Spread onto the element that should start a drag. */
-interface SortableHandleProps extends Partial<DraggableAttributes> {
-  ref: (element: HTMLElement | null) => void;
-  onKeyDown?: React$1.KeyboardEventHandler<HTMLElement>;
-  onPointerDown?: React$1.PointerEventHandler<HTMLElement>;
-  onMouseDown?: React$1.MouseEventHandler<HTMLElement>;
-  onTouchStart?: React$1.TouchEventHandler<HTMLElement>;
-}
-interface SortableRenderState {
-  /** Attributes, listeners and ref for a custom drag handle. */
-  handleProps: SortableHandleProps;
-  /** True for the item being dragged (and for the overlay copy). */
-  isDragging: boolean;
-}
-/** What moved where, passed to `onReorder` alongside the reordered array. */
-interface SortableReorderDetails {
-  /** Index the item came from, in the array as it was passed in. */
-  from: number;
-  /** Index it landed on. */
-  to: number;
-  /** Id of the item that moved (`getId` of the dragged item). */
-  activeId: UniqueIdentifier;
-  /** Id of the item it was dropped onto. */
-  overId: UniqueIdentifier;
-}
-interface SortableListProps<T> extends Omit<React$1.ComponentProps<"ul">, "children"> {
-  items: readonly T[];
-  /** Stable id per item; must be unique within the list. */
-  getId: (item: T) => UniqueIdentifier;
-  /**
-   * Called with the reordered array after a successful drop, and with the move
-   * itself — `{ from, to, activeId, overId }` — for a server that persists a
-   * position rather than the whole list.
-   */
-  onReorder: (next: T[], details: SortableReorderDetails) => void;
-  renderItem: (item: T, state: SortableRenderState) => React$1.ReactNode;
-  /** Layout axis; also selects the sorting strategy. */
-  orientation?: "vertical" | "horizontal";
-  /** Only a `<SortableHandle>` (or an element given `handleProps`) starts a drag. */
-  handle?: boolean;
-  /**
-   * Let a finger scroll the page over the rows. Defaults to `handle`: `true`
-   * in handle mode, `false` in whole-row mode, which is what each already did.
-   * `true` on a whole-row list drops `touch-none` and uses a TouchSensor with
-   * delay activation, so a swipe scrolls and a held press drags.
-   */
-  touchScroll?: boolean;
-  /** Disables every sensor and hides the handles. */
-  disabled?: boolean;
-  /** Class name for each item wrapper. */
-  itemClassName?: string;
-}
-/**
- * A grip button that starts the drag for its row. Reads the row's activator
- * props from context, so it needs no wiring beyond being rendered inside
- * `renderItem`. Hidden (kept in layout) when the list is disabled.
- */
-declare function SortableHandle({ className, children, ...props }: React$1.ComponentProps<"button">): React$1.JSX.Element;
-declare function SortableList<T>({ items, getId, onReorder, renderItem, orientation, handle, disabled, touchScroll, itemClassName: itemClass, className, ...props }: SortableListProps<T>): React$1.JSX.Element;
-//#endregion
-//#region src/components/spinner.d.ts
-interface SpinnerProps extends React$1.ComponentProps<"span"> {
-  /** Diameter in px. Defaults to 16. */
-  size?: number;
-  /**
-   * `inverse` for a spinner on a filled surface — inside a primary or
-   * destructive Button, on a toast, on any `-foreground` pairing. The default
-   * ring is `--ds-border` with a `--ds-primary` leading edge, which all but
-   * disappears on a primary fill; `inverse` draws both from
-   * `--ds-primary-foreground` instead.
-   */
-  tone?: "default" | "inverse";
-}
-/**
- * Spinner — a ring with a coloured leading edge. Announces itself as
- * `role="status"` with a "Loading" label; pass `aria-label` to override.
- *
- * ```tsx
- * <Button disabled>
- *   <Spinner tone="inverse" /> Saving…
- * </Button>
- * ```
- */
-declare function Spinner({ className, size, tone, style, ...props }: SpinnerProps): React$1.JSX.Element;
-//#endregion
-//#region src/components/status-dot.d.ts
-/**
- * The error tone is `destructive`, the same spelling Button, Alert and Badge
- * use. `danger` is a deprecated alias of it and paints the same.
- */
-type StatusDotTone = "accent" | "success" | "warning" | "destructive" |
-/** @deprecated Use `destructive`; this alias paints the same. */
-"danger" | "info" | "neutral";
-interface StatusDotProps extends Omit<React$1.ComponentProps<"span">, "children"> {
-  tone?: StatusDotTone;
-  /** Adds a pinging halo behind the dot for "currently active" states. */
-  live?: boolean;
-  label?: React$1.ReactNode;
-  /** Dot diameter in px. Defaults to 7. */
-  size?: number;
-}
-/**
- * StatusDot — a coloured dot with an optional caption. `live` layers a ping
- * ring in the same tone behind the dot.
- */
-declare function StatusDot({ className, tone, live, label, size, style, ...props }: StatusDotProps): React$1.JSX.Element;
-//#endregion
-//#region src/components/switch.d.ts
-/**
- * Switch.
- *
- * Base UI renders a `<span role="switch">` with a hidden `<input>` beside it,
- * so the control submits with forms and takes `checked`/`defaultChecked`
- * exactly like a checkbox. State is exposed as `data-checked` /
- * `data-unchecked` / `data-disabled`, which is what the classes key on.
- *
- * cortenaweb users: `checked` and `onCheckedChange` keep their names, but the
- * control is now uncontrolled by default; pass `defaultChecked` if you do not
- * hold the state yourself.
- */
-interface SwitchProps extends React$1.ComponentProps<typeof Switch$1.Root> {}
-declare function Switch({ className, ...props }: SwitchProps): React$1.JSX.Element;
-//#endregion
-//#region src/components/tabs.d.ts
-/**
- * Tabs — the underlined pattern (primary-coloured underline under the active
- * tab). For the inset segmented style use Segmented.
- *
- * The underline is a Base UI `Tabs.Indicator` rendered inside `TabsList`, so it
- * slides between tabs instead of snapping. Base UI exposes the active tab's
- * box as `--active-tab-left` / `--active-tab-width` on the indicator.
- *
- * Radix users: `data-state="active"` is now `data-active`; `TabsTrigger` and
- * `TabsContent` are Base UI's `Tab` and `Panel` under the shadcn names. Arrow
- * keys activate as they move (Radix's `activationMode="automatic"`); pass
- * `activateOnFocus={false}` on `TabsList` for manual activation.
- */
-declare function Tabs({ className, ...props }: Tabs$1.Root.Props): import("react").JSX.Element;
-declare function TabsList({ className, children, activateOnFocus, ...props }: Tabs$1.List.Props): import("react").JSX.Element;
-declare function TabsIndicator({ className, ...props }: Tabs$1.Indicator.Props): import("react").JSX.Element;
-declare function TabsTrigger({ className, ...props }: Tabs$1.Tab.Props): import("react").JSX.Element;
-declare function TabsContent({ className, ...props }: Tabs$1.Panel.Props): import("react").JSX.Element;
-//#endregion
-//#region src/components/textarea.d.ts
-/**
- * Textarea.
- *
- * Same surface, border, focus ring and invalid state as Input so the two sit
- * together in a form. `autoGrow` resizes the element to its content on every
- * change (and on mount), which is how chat composers and note fields use it.
- */
-declare const textareaClassName: string;
-interface TextareaProps extends React$1.ComponentProps<"textarea"> {
-  /** When true the textarea grows to fit its content instead of scrolling. */
-  autoGrow?: boolean;
-}
-declare function Textarea({ className, autoGrow, onChange, ref, ...props }: TextareaProps): React$1.JSX.Element;
-//#endregion
-//#region src/components/toast.d.ts
-/**
- * Toast.
- *
- * Base UI toasts are imperative: `useToast().add({ title, description, type })`
- * from anywhere under the provider. `Toaster` mounts `Toast.Provider` and the
- * `Toast.Viewport`, and renders every toast the manager holds, so it must wrap
- * the part of the tree that calls `useToast` (usually the whole app).
- *
- * The `type` field on a toast picks the variant: `default`, `success`,
- * `warning` or `destructive`, painted from the semantic soft tokens. Anything
- * else falls back to `default`.
- *
- * sonner / Radix users: there is no `toast()` module singleton. Get the manager
- * from `useToast()` inside a component, or build one with
- * `createToastManager()` from `@base-ui/react/toast` and pass it as
- * `toastManager` to `Toaster` when you need to fire toasts outside React.
- */
-declare const toastVariants: (props?: ({
-  variant?: "default" | "success" | "destructive" | "warning" | null | undefined;
-} & import("class-variance-authority/types").ClassProp) | undefined) => string;
-/** The Base UI toast manager: `{ toasts, add, close, update, promise }`. */
-declare const useToast: typeof Toast$1.useToastManager;
-interface ToastProps extends Omit<Toast$1.Root.Props, "toast">, VariantProps<typeof toastVariants> {
-  toast: Toast$1.Root.ToastObject;
-}
-/** One toast. Rendered by `Toaster`; exported for custom viewports. */
-declare function Toast({ className, variant, toast, ...props }: ToastProps): React$1.JSX.Element;
-interface ToasterProps extends Toast$1.Provider.Props {
-  /** Corner of the screen the stack grows from. */
-  position?: "bottom-right" | "bottom-left" | "top-right" | "top-left";
-  /** Extra classes on the viewport. */
-  className?: string;
-  children?: React$1.ReactNode;
-}
-/**
- * Provider + viewport. Wrap the app in it once; `useToast()` works anywhere
- * beneath. Toasts render in a fixed corner as a flat stack (newest last).
- */
-declare function Toaster({ position, className, children, ...props }: ToasterProps): React$1.JSX.Element;
-//#endregion
-//#region src/components/toolbar.d.ts
-interface ToolbarProps extends React$1.ComponentProps<"div"> {
-  /** Draw a rule under the row, for a toolbar that sits above a table or list. */
-  bordered?: boolean;
-}
-/**
- * Toolbar — a single flex row of controls above content. `ToolbarStart` and
- * `ToolbarEnd` group the two ends; `ToolbarSeparator` is a short vertical rule
- * between clusters of controls in the same group.
- */
-declare function Toolbar({ className, bordered, ...props }: ToolbarProps): React$1.JSX.Element;
-declare function ToolbarStart({ className, ...props }: React$1.ComponentProps<"div">): React$1.JSX.Element;
-declare function ToolbarEnd({ className, ...props }: React$1.ComponentProps<"div">): React$1.JSX.Element;
-declare function ToolbarSeparator({ className, ...props }: React$1.ComponentProps<"div">): React$1.JSX.Element;
-//#endregion
-//#region src/components/tooltip.d.ts
-/**
- * Tooltip.
- *
- * Base UI's Tooltip opens on hover and focus (never on click). Radix users:
- * `asChild` on the trigger becomes `render={<Button />}`, and the delay moves
- * from `delayDuration` on the Provider to `delay` on the Provider or Trigger.
- * `TooltipContent` composes Portal + Positioner + Popup so the consumer still
- * writes one element; `side`, `align` and `sideOffset` are forwarded to the
- * Positioner where Base UI expects them. Base UI sets no ARIA role on the
- * popup; `role="tooltip"` is added here so it reads like the Radix version.
- */
-declare function TooltipProvider(props: Tooltip$2.Provider.Props): import("react").JSX.Element;
-declare function Tooltip(props: Tooltip$2.Root.Props): import("react").JSX.Element;
-declare function TooltipTrigger(props: Tooltip$2.Trigger.Props): import("react").JSX.Element;
-type PositionerProps = Pick<Tooltip$2.Positioner.Props, "side" | "align" | "sideOffset" | "alignOffset" | "anchor" | "collisionBoundary" | "collisionPadding" | "collisionAvoidance" | "sticky" | "positionMethod">;
-interface TooltipContentProps extends Tooltip$2.Popup.Props, PositionerProps {
-  /** Keep the popup mounted in the DOM while hidden. */
-  keepMounted?: boolean;
-  /** Where to portal the popup; defaults to `<body>`. */
-  container?: Tooltip$2.Portal.Props["container"];
-}
-declare function TooltipContent({ className, side, align, sideOffset, alignOffset, anchor, collisionBoundary, collisionPadding, collisionAvoidance, sticky, positionMethod, keepMounted, container, ...props }: TooltipContentProps): import("react").JSX.Element;
-//#endregion
-//#region src/hooks/use-cortena-theme.d.ts
-/**
- * useCortenaTheme — the one theme bridge for every Cortena surface.
- *
- * cortena-design drives dark mode off `data-theme="light" | "dark"` on <html>
- * and falls back to `prefers-color-scheme` when the attribute is absent. So the
- * hook has exactly three jobs, consolidated from the flux and engram copies:
- *
- *  1. Remember the last choice in localStorage and put it back before the
- *     first paint (`applyStoredTheme`, or `themeInitScript` as a blocking
- *     <script> for apps that cannot run a module that early).
- *  2. Listen for the message cortenaweb posts into an extension iframe on load
- *     and on every theme change:
- *
- *         iframe.contentWindow.postMessage({ type: "cortena-theme", colors }, "*")
- *
- *     and apply the *mode* it implies. The host may say `mode` or `theme`
- *     explicitly; otherwise the background colour's luminance decides.
- *  3. Expose `{ theme, resolvedTheme, setTheme }` so a settings toggle can
- *     drive the same state.
- *
- * What it deliberately does NOT do is apply the individual colours in the
- * host's message. The palette comes from cortena-design tokens, the single
- * source of truth; writing the host's raw values onto `--ds-*` or `--color-*`
- * would silently override every token the design system publishes. The
- * `colors` object is read for its luminance only, never written to the DOM.
- */
-type CortenaTheme = "light" | "dark" | "system";
-type ResolvedCortenaTheme = "light" | "dark";
-/** The message cortenaweb posts into an embedded iframe. */
-interface CortenaThemeMessage {
-  type: "cortena-theme";
-  /** Explicit mode. Preferred when present. */
-  theme?: CortenaTheme;
-  /** Older name for `theme`, sent by some hosts. */
-  mode?: CortenaTheme;
-  /** Raw palette. Only `background` is read, and only to infer the mode. */
-  colors?: Record<string, unknown>;
-}
-interface UseCortenaThemeOptions {
-  /** localStorage key the choice persists under. Defaults to `"cortena.theme"`. */
-  storageKey?: string;
-  /**
-   * Origins allowed to push a theme via postMessage. When omitted or empty,
-   * every origin is accepted — matching cortenaweb, which posts with `"*"`
-   * to cross-origin extensions. A same-origin embed should pass
-   * `[window.location.origin]`.
-   */
-  allowedOrigins?: readonly string[];
-  /** Set false to keep the state and DOM sync but ignore host messages. */
-  listen?: boolean;
-}
-interface UseCortenaThemeResult {
-  /** The stored choice; `"system"` when nothing has been chosen. */
-  theme: CortenaTheme;
-  /** What is actually painted: `theme`, or the OS scheme when `theme` is `"system"`. */
-  resolvedTheme: ResolvedCortenaTheme;
-  setTheme: (theme: CortenaTheme) => void;
-}
-export declare const DEFAULT_THEME_STORAGE_KEY = "cortena.theme";
-export declare const THEME_MESSAGE_TYPE = "cortena-theme";
-/**
- * Write the mode onto <html>. `"system"` removes the attribute so
- * cortena-design's `:root:not([data-theme])` fallback follows the OS.
- */
-export declare function applyTheme(theme: CortenaTheme, root?: HTMLElement): void;
-export declare function readStoredTheme(storageKey?: string): CortenaTheme;
-/**
- * Put the remembered mode back on <html>. Tiny and synchronous on purpose:
- * call it at the top of the app entry, before `createRoot`, so a reload does
- * not flash the light palette at somebody reading in the dark. Returns what
- * it applied.
- */
-export declare function applyStoredTheme(storageKey?: string): CortenaTheme;
-/**
- * The same logic as `applyStoredTheme` as a self-contained IIFE string, for
- * consumers that inject a blocking `<script>` into <head> (Next.js
- * `dangerouslySetInnerHTML`, or a Vite index.html). It cannot import anything,
- * which is why it is duplicated rather than derived.
- */
-export declare function getThemeInitScript(storageKey?: string): string;
-/** `getThemeInitScript()` for the default storage key. */
-export declare const themeInitScript: string;
-/**
- * Infer the mode from a hex background colour by relative luminance. Any
- * other colour syntax is ignored, since the host only ever sends hex and a
- * wrong guess is worse than no change.
- */
-export declare function themeFromBackground(background: unknown): ResolvedCortenaTheme | null;
-/**
- * The mode a host message asks for, or null when it does not carry one.
- * Explicit `theme` / `mode` win; otherwise the background luminance decides.
- */
-export declare function themeFromMessage(data: unknown): CortenaTheme | null;
-export declare function useCortenaTheme(options?: UseCortenaThemeOptions): UseCortenaThemeResult;
-//#endregion
-export { type A2UIAction, type A2UIActionSpec, type A2UIBeginRendering, type A2UICatalogue, type A2UICatalogueDoc, type A2UICatalogueEntry, type A2UIChildList, type A2UIChildren, type A2UIColumn, type A2UIComponentDoc, type A2UIComponentSpec, type A2UICreateSurface, type A2UIDataBinding, type A2UIDeleteSurface, type A2UIExample, type A2UIFoldResult, type A2UIGroup, type A2UIMessage, type A2UIMessageInput, type A2UINodeInfo, type A2UIPropertyValue, type A2UIRendererProps, type A2UIResolvedAction, type A2UIRow, type A2UISurface, type A2UITableSource, type A2UIUpdateComponents, type A2UIUpdateDataModel, type A2UIView, type A2UIViewProps, type Accept, Accordion, AccordionContent, AccordionItem, AccordionTrigger, Alert, AlertDescription, AlertIcon, type AlertProps, AlertTitle, Area, AreaChart, Avatar, AvatarFallback, AvatarImage, Badge, type BadgeProps, Bar, BarChart, Breadcrumb, BreadcrumbEllipsis, BreadcrumbItem, BreadcrumbLink, type BreadcrumbLinkProps, BreadcrumbList, BreadcrumbPage, BreadcrumbSeparator, Button, ButtonLink, type ButtonLinkProps, type ButtonProps, Calendar, CalendarDayButton, type CalendarProps, Card, CardContent, CardDescription, CardFooter, CardHeader, type CardProps, CardTitle, CartesianGrid, Cell, Chart, type ChartConfig, ChartContainer, type ChartContainerProps, type ChartDataFor, type ChartDay, ChartEmpty, type ChartEngine, ChartError, ChartLegend, ChartLegendContent, type ChartLegendContentProps, ChartLoading, type ChartMatrix, type ChartPoint, type ChartProps, type ChartRenderer, type ChartRow, type ChartScale, type ChartScales, type ChartSeries, type ChartSlice, ChartTooltip, ChartTooltipContent, type ChartTooltipContentProps, type ChartTree, type ChartType, Checkbox, type CheckboxProps, Chip, type ChipProps, type ClientSource, type CodeRendererProps, Combobox, ComboboxChip, type ComboboxChipProps, ComboboxChips, type ComboboxChipsProps, ComboboxClear, ComboboxCollection, ComboboxContent, type ComboboxContentProps, ComboboxEmpty, ComboboxGroup, ComboboxGroupLabel, ComboboxInput, type ComboboxInputProps, ComboboxItem, ComboboxSeparator, ComboboxStatus, ComboboxTrigger, ComboboxValue, Command, CommandDialog, type CommandDialogProps, CommandEmpty, CommandGroup, CommandInput, CommandItem, type CommandItemProps, CommandList, CommandLoading, CommandSeparator, CommandShortcut, ComposedChart, type CortenaTheme, type CortenaThemeMessage, type DataSource, DataTable, type DataTableCell, type DataTableColumn, type DataTableColumnDef, DataTableColumnHeader, type DataTableColumnHeaderProps, type DataTableColumnMeta, type DataTableEditable, type DataTableEditingCell, DataTableExportMenu, type DataTableExportMenuProps, DataTableFacetedFilter, type DataTableFacetedFilterOption, type DataTableFacetedFilterProps, type DataTableFeatures, type DataTableInstance, DataTablePagination, type DataTablePaginationMode, type DataTablePaginationProps, type DataTableProps, type DataTableRow, type DataTableState, type DataTableTable, DataTableToolbar, type DataTableToolbarProps, DataTableView, DataTableViewOptions, type DataTableViewOptionsProps, type DataTableViewProps, DateField, type DateFieldProps, DatePicker, type DatePickerProps, DateRangePicker, type DateRangePickerProps, Dialog, DialogBody, DialogClose, DialogContent, type DialogContentProps, DialogDescription, DialogFooter, DialogHeader, DialogOverlay, DialogPortal, DialogTitle, DialogTrigger, DropdownMenu, DropdownMenuCheckboxItem, DropdownMenuContent, type DropdownMenuContentProps, DropdownMenuGroup, DropdownMenuItem, type DropdownMenuItemProps, DropdownMenuLabel, type DropdownMenuLabelProps, DropdownMenuPortal, DropdownMenuRadioGroup, DropdownMenuRadioItem, DropdownMenuSeparator, DropdownMenuShortcut, DropdownMenuSub, DropdownMenuSubContent, DropdownMenuSubTrigger, type DropdownMenuSubTriggerProps, DropdownMenuTrigger, Dropzone, type DropzoneProps, type DropzoneState, EmptyState, type EmptyStateProps, ErrorBanner, type ErrorBannerProps, type ExportCell, type ExportSheet, Field, FieldContent, FieldControl, type FieldControlProps, FieldDescription, type FieldDescriptionProps, FieldError, type FieldErrorItem, type FieldErrorProps, FieldGroup, FieldLabel, type FieldLabelProps, type FieldProps, Fieldset, FieldsetLegend, type FieldsetLegendProps, type FieldsetProps, FileList, type FileListProps, type FileRejection, Form, FormControl, type FormControlProps, FormDescription, type FormDescriptionProps, FormField, FormItem, type FormItemProps, FormLabel, type FormLabelProps, FormMessage, type FormMessageProps, Funnel, FunnelChart, Input, type InputProps, type JsonSchema, Kbd, Label, LabelList, type LabelProps, Line, LineChart, LoadingSkeleton, type LoadingSkeletonPreset, type LoadingSkeletonProps, Markdown, type Components as MarkdownComponents, type MarkdownProps, type NivoTheme, PageHeader, type PageHeaderProps, Pie, PieChart, PolarAngleAxis, PolarGrid, PolarRadiusAxis, Popover, PopoverClose, PopoverContent, type PopoverContentProps, PopoverDescription, PopoverTitle, PopoverTrigger, Progress, ProgressIndicator, ProgressLabel, type ProgressProps, ProgressTrack, ProgressValue, Radar, RadarChart, RadioGroup, RadioGroupItem, type RadioGroupItemProps, type RadioGroupProps, RechartsLegend, RechartsTooltip, ReferenceLine, type ResolvedCortenaTheme, ResponsiveContainer, Scatter, ScatterChart, ScrollArea, type ScrollAreaProps, ScrollBar, SectionCard, type SectionCardProps, Segmented, type SegmentedOption, type SegmentedProps, Select, SelectContent, type SelectContentProps, SelectGroup, SelectItem, SelectLabel, type SelectProps, SelectSeparator, SelectTrigger, type SelectTriggerProps, SelectValue, Separator, type SeparatorProps, type ServerSource, Sheet, SheetClose, SheetContent, type SheetContentProps, SheetDescription, SheetFooter, SheetHeader, SheetOverlay, SheetPortal, type SheetProps, SheetTitle, SheetTrigger, Skeleton, SortableHandle, type SortableHandleProps, SortableList, type SortableListProps, type SortableRenderState, type SortableReorderDetails, Spinner, type SpinnerProps, StatusDot, type StatusDotProps, type StatusDotTone, type SubmitHandler, Switch, type SwitchProps, type TableQuery, type TableResult, Tabs, TabsContent, TabsIndicator, TabsList, TabsTrigger, Textarea, type TextareaProps, Toast, type ToastProps, Toaster, type ToasterProps, Toolbar, ToolbarEnd, type ToolbarProps, ToolbarSeparator, ToolbarStart, Tooltip, TooltipContent, type TooltipContentProps, TooltipProvider, TooltipTrigger, type UseCortenaThemeOptions, type UseCortenaThemeResult, type UseDataTableOptions, type UseFormFieldReturn, type UseFormReturn, XAxis, YAxis, alertVariants, arrayMove, badgeVariants, buttonVariants, chipVariants, fieldVariants, formatDateDefault, formatDateISO, formatDateLong, formatDateShort, formatFileSize, formatRelative, inputClassName, labelVariants, markdownSanitizeSchema, parseDateDefault, parseDateISO, sheetVariants, textareaClassName, toastVariants, useComboboxFilter, useForm, useFormField, useToast, zodResolver };
-//# sourceMappingURL=index.d.ts.map
+import { A2UIAction, A2UIActionSpec, A2UIBeginRendering, A2UIChildList, A2UIChildren, A2UIComponentSpec, A2UICreateSurface, A2UIDataBinding, A2UIDeleteSurface, A2UIFoldResult, A2UIMessage, A2UIMessageInput, A2UIPropertyValue, A2UISurface, A2UIUpdateComponents, A2UIUpdateDataModel, A2UI_DEFAULT_SURFACE_ID, A2UI_VERSION, foldMessages, getAtPointer, isDataBinding, parseA2UIMessages, pointerSegments, readAction, readChildren, readComponent, resolvePointer, resolveValue, setAtPointer } from "./a2ui/message.js";
+import { ChartConfig, ChartDataFor, ChartDay, ChartEngine, ChartLabels, ChartMatrix, ChartPoint, ChartRenderer, ChartRow, ChartScale, ChartSeries, ChartSlice, ChartTree, ChartType, NIVO_TYPES, RECHARTS_TYPES, chartEngine } from "./components/chart/types.js";
+import { DataTableFeatures, createColumnHelper, dataTableFeatures } from "./components/data-table/features.js";
+import { ClientSource, DataSource, DataTableCell, DataTableColumn, DataTableColumnDef, DataTableColumnMeta, DataTableEditable, DataTableEditingCell, DataTableInstance, DataTablePaginationMode, DataTableRow, DataTableState, DataTableTable, ServerSource, TableQuery, TableResult, UseDataTableOptions } from "./components/data-table/types.js";
+import { DataTable, DataTableProps, DataTableView, DataTableViewProps } from "./components/data-table/data-table.js";
+import { DataTableColumnHeader, DataTableColumnHeaderProps, DataTableExportMenu, DataTableExportMenuProps, DataTableFacetedFilter, DataTableFacetedFilterOption, DataTableFacetedFilterProps, DataTablePagination, DataTablePaginationProps, DataTableToolbar, DataTableToolbarProps, DataTableViewOptions, DataTableViewOptionsProps } from "./components/data-table/parts.js";
+import { useDataTable } from "./components/data-table/use-data-table.js";
+import { ExportCell, ExportSheet, downloadCsv, downloadExcel, toCsv, toSheet } from "./components/data-table/export.js";
+import { A2UIColumn, A2UIErrorCard, A2UINodeInfo, A2UIResolvedAction, A2UIRow, A2UITableSource, A2UIView, A2UIViewProps } from "./a2ui/views.js";
+import { A2UICatalogue, A2UICatalogueEntry, A2UIExample, A2UIGroup, A2UI_CATALOGUE_ID, catalogueNames, defaultCatalogue } from "./a2ui/catalogue.js";
+import { A2UICatalogueDoc, A2UIComponentDoc, JsonSchema, buildCatalogueDoc, catalogueMarkdown, exampleMessages } from "./a2ui/catalogue-doc.js";
+import { A2UIRenderer, A2UIRendererProps } from "./a2ui/renderer.js";
+import "./a2ui.js";
+import { ChartContainer, ChartContainerProps, ChartEmpty, ChartError, ChartLegendContent, ChartLegendContentProps, ChartLoading, ChartTooltipContent, ChartTooltipContentProps, seriesColor, useChart } from "./components/chart/container.js";
+import { Chart, ChartProps } from "./components/chart/chart.js";
+import { ChartLegend, ChartTooltip } from "./components/chart/recharts-parts.js";
+import { NivoTheme, nivoTheme, useNivoTheme } from "./components/chart/nivo-theme.js";
+import { ChartScales, VIZ_SERIES_COUNT, chartScales, resolveColor, resolveVizSeries, toHex, vizSeriesVars, vizVar } from "./components/chart/tokens.js";
+import { Area, AreaChart, Bar, BarChart, CartesianGrid, Cell, ComposedChart, Funnel, FunnelChart, LabelList, Line, LineChart, Pie, PieChart, PolarAngleAxis, PolarGrid, PolarRadiusAxis, Radar, RadarChart, RechartsLegend, RechartsTooltip, ReferenceLine, ResponsiveContainer, Scatter, ScatterChart, XAxis, YAxis } from "./components/chart/index.js";
+import "./chart.js";
+import { Alert, AlertDescription, AlertIcon, AlertProps, AlertTitle, alertVariants } from "./components/alert.js";
+import { Badge, BadgeProps, badgeVariants } from "./components/badge.js";
+import { Breadcrumb, BreadcrumbEllipsis, BreadcrumbItem, BreadcrumbLink, BreadcrumbLinkProps, BreadcrumbList, BreadcrumbPage, BreadcrumbSeparator } from "./components/breadcrumb.js";
+import { Button, ButtonProps, buttonVariants } from "./components/button.js";
+import { ButtonLink, ButtonLinkProps } from "./components/button-link.js";
+import { Card, CardContent, CardDescription, CardFooter, CardHeader, CardProps, CardTitle } from "./components/card.js";
+import { Checkbox, CheckboxProps } from "./components/checkbox.js";
+import { Chip, ChipProps, chipVariants } from "./components/chip.js";
+import { Combobox, ComboboxChip, ComboboxChipProps, ComboboxChips, ComboboxChipsProps, ComboboxClear, ComboboxCollection, ComboboxContent, ComboboxContentProps, ComboboxEmpty, ComboboxGroup, ComboboxGroupLabel, ComboboxInput, ComboboxInputProps, ComboboxItem, ComboboxSeparator, ComboboxStatus, ComboboxTrigger, ComboboxValue, useComboboxFilter } from "./components/combobox.js";
+import { Dialog, DialogBody, DialogClose, DialogContent, DialogContentProps, DialogDescription, DialogFooter, DialogHeader, DialogOverlay, DialogPortal, DialogTitle, DialogTrigger } from "./components/dialog.js";
+import { Command, CommandDialog, CommandDialogProps, CommandEmpty, CommandGroup, CommandInput, CommandItem, CommandItemProps, CommandList, CommandLoading, CommandSeparator, CommandShortcut } from "./components/command.js";
+import { CortenaTheme, CortenaThemeMessage, DEFAULT_THEME_STORAGE_KEY, ResolvedCortenaTheme, THEME_MESSAGE_TYPE, UseCortenaThemeOptions, UseCortenaThemeResult, applyStoredTheme, applyTheme, getThemeInitScript, readStoredTheme, themeFromBackground, themeFromMessage, themeInitScript, useCortenaTheme } from "./hooks/use-cortena-theme.js";
+import { DropdownMenu, DropdownMenuCheckboxItem, DropdownMenuContent, DropdownMenuContentProps, DropdownMenuGroup, DropdownMenuItem, DropdownMenuItemProps, DropdownMenuLabel, DropdownMenuLabelProps, DropdownMenuPortal, DropdownMenuRadioGroup, DropdownMenuRadioItem, DropdownMenuSeparator, DropdownMenuShortcut, DropdownMenuSub, DropdownMenuSubContent, DropdownMenuSubTrigger, DropdownMenuSubTriggerProps, DropdownMenuTrigger } from "./components/dropdown-menu.js";
+import { EmptyState, EmptyStateProps } from "./components/empty-state.js";
+import { ErrorBanner, ErrorBannerProps } from "./components/error-banner.js";
+import { Field, FieldContent, FieldControl, FieldControlProps, FieldDescription, FieldDescriptionProps, FieldError, FieldErrorItem, FieldErrorProps, FieldGroup, FieldLabel, FieldLabelProps, FieldProps, Fieldset, FieldsetLegend, FieldsetLegendProps, FieldsetProps, fieldVariants } from "./components/field.js";
+import { Input, InputProps, inputClassName } from "./components/input.js";
+import { Label, LabelProps, labelVariants } from "./components/label.js";
+import { LoadingSkeleton, LoadingSkeletonPreset, LoadingSkeletonProps } from "./components/loading-skeleton.js";
+import { PageHeader, PageHeaderProps } from "./components/page-header.js";
+import { Popover, PopoverClose, PopoverContent, PopoverContentProps, PopoverDescription, PopoverTitle, PopoverTrigger } from "./components/popover.js";
+import { Progress, ProgressIndicator, ProgressLabel, ProgressProps, ProgressTrack, ProgressValue } from "./components/progress.js";
+import { RadioGroup, RadioGroupItem, RadioGroupItemProps, RadioGroupProps } from "./components/radio-group.js";
+import { ScrollArea, ScrollAreaProps, ScrollBar } from "./components/scroll-area.js";
+import { SectionCard, SectionCardProps } from "./components/section-card.js";
+import { Segmented, SegmentedOption, SegmentedProps } from "./components/segmented.js";
+import { Select, SelectContent, SelectContentProps, SelectGroup, SelectItem, SelectLabel, SelectProps, SelectSeparator, SelectTrigger, SelectTriggerProps, SelectValue } from "./components/select.js";
+import { Separator, SeparatorProps } from "./components/separator.js";
+import { Sheet, SheetClose, SheetContent, SheetContentProps, SheetDescription, SheetFooter, SheetHeader, SheetOverlay, SheetPortal, SheetProps, SheetTitle, SheetTrigger, sheetVariants } from "./components/sheet.js";
+import { Spinner, SpinnerProps } from "./components/spinner.js";
+import { StatusDot, StatusDotProps, StatusDotTone } from "./components/status-dot.js";
+import { Switch, SwitchProps } from "./components/switch.js";
+import { Textarea, TextareaProps, textareaClassName } from "./components/textarea.js";
+import { Toast, ToastProps, Toaster, ToasterProps, toastVariants, useToast } from "./components/toast.js";
+import { Toolbar, ToolbarEnd, ToolbarProps, ToolbarSeparator, ToolbarStart } from "./components/toolbar.js";
+import { Tooltip, TooltipContent, TooltipContentProps, TooltipProvider, TooltipTrigger } from "./components/tooltip.js";
+import { Accordion, AccordionContent, AccordionItem, AccordionTrigger } from "./components/accordion.js";
+import { Avatar, AvatarFallback, AvatarImage } from "./components/avatar.js";
+import { Kbd } from "./components/kbd.js";
+import { Skeleton } from "./components/skeleton.js";
+import { Tabs, TabsContent, TabsIndicator, TabsList, TabsTrigger } from "./components/tabs.js";
+import { cn } from "./lib/cn.js";
+import "./core.js";
+import "./data-table.js";
+import { Accept, Dropzone, DropzoneProps, DropzoneState, FileList, FileListProps, FileRejection, formatFileSize } from "./components/dropzone.js";
+import { Calendar, CalendarDayButton, CalendarProps } from "./components/calendar.js";
+import { DateField, DateFieldProps, formatDateISO, formatDateLong, formatDateShort, formatRelative, parseDateDefault, parseDateISO } from "./components/date-field.js";
+import { DatePicker, DatePickerProps, DateRangePicker, DateRangePickerProps, formatDateDefault } from "./components/date-picker.js";
+import { Form, FormControl, FormControlProps, FormDescription, FormDescriptionProps, FormField, FormItem, FormItemProps, FormLabel, FormLabelProps, FormMessage, FormMessageProps, SubmitHandler, UseFormFieldReturn, UseFormReturn, useForm, useFormField, zodResolver } from "./components/form.js";
+import "./form.js";
+import { CodeRendererProps, Markdown, MarkdownComponents as Components, MarkdownProps, markdownSanitizeSchema } from "./components/markdown.js";
+import "./markdown.js";
+import { SortableHandle, SortableHandleProps, SortableList, SortableListProps, SortableRenderState, SortableReorderDetails, arrayMove } from "./components/sortable-list.js";
+import "./sortable-list.js";
+export { type A2UIAction, type A2UIActionSpec, type A2UIBeginRendering, type A2UICatalogue, type A2UICatalogueDoc, type A2UICatalogueEntry, type A2UIChildList, type A2UIChildren, type A2UIColumn, type A2UIComponentDoc, type A2UIComponentSpec, type A2UICreateSurface, type A2UIDataBinding, type A2UIDeleteSurface, A2UIErrorCard, type A2UIExample, type A2UIFoldResult, type A2UIGroup, type A2UIMessage, type A2UIMessageInput, type A2UINodeInfo, type A2UIPropertyValue, A2UIRenderer, type A2UIRendererProps, type A2UIResolvedAction, type A2UIRow, type A2UISurface, type A2UITableSource, type A2UIUpdateComponents, type A2UIUpdateDataModel, type A2UIView, type A2UIViewProps, A2UI_CATALOGUE_ID, A2UI_DEFAULT_SURFACE_ID, A2UI_VERSION, type Accept, Accordion, AccordionContent, AccordionItem, AccordionTrigger, Alert, AlertDescription, AlertIcon, type AlertProps, AlertTitle, Area, AreaChart, Avatar, AvatarFallback, AvatarImage, Badge, type BadgeProps, Bar, BarChart, Breadcrumb, BreadcrumbEllipsis, BreadcrumbItem, BreadcrumbLink, type BreadcrumbLinkProps, BreadcrumbList, BreadcrumbPage, BreadcrumbSeparator, Button, ButtonLink, type ButtonLinkProps, type ButtonProps, Calendar, CalendarDayButton, type CalendarProps, Card, CardContent, CardDescription, CardFooter, CardHeader, type CardProps, CardTitle, CartesianGrid, Cell, Chart, type ChartConfig, ChartContainer, type ChartContainerProps, type ChartDataFor, type ChartDay, ChartEmpty, type ChartEngine, ChartError, type ChartLabels, ChartLegend, ChartLegendContent, type ChartLegendContentProps, ChartLoading, type ChartMatrix, type ChartPoint, type ChartProps, type ChartRenderer, type ChartRow, type ChartScale, type ChartScales, type ChartSeries, type ChartSlice, ChartTooltip, ChartTooltipContent, type ChartTooltipContentProps, type ChartTree, type ChartType, Checkbox, type CheckboxProps, Chip, type ChipProps, type ClientSource, type CodeRendererProps, Combobox, ComboboxChip, type ComboboxChipProps, ComboboxChips, type ComboboxChipsProps, ComboboxClear, ComboboxCollection, ComboboxContent, type ComboboxContentProps, ComboboxEmpty, ComboboxGroup, ComboboxGroupLabel, ComboboxInput, type ComboboxInputProps, ComboboxItem, ComboboxSeparator, ComboboxStatus, ComboboxTrigger, ComboboxValue, Command, CommandDialog, type CommandDialogProps, CommandEmpty, CommandGroup, CommandInput, CommandItem, type CommandItemProps, CommandList, CommandLoading, CommandSeparator, CommandShortcut, ComposedChart, type CortenaTheme, type CortenaThemeMessage, DEFAULT_THEME_STORAGE_KEY, type DataSource, DataTable, type DataTableCell, type DataTableColumn, type DataTableColumnDef, DataTableColumnHeader, type DataTableColumnHeaderProps, type DataTableColumnMeta, type DataTableEditable, type DataTableEditingCell, DataTableExportMenu, type DataTableExportMenuProps, DataTableFacetedFilter, type DataTableFacetedFilterOption, type DataTableFacetedFilterProps, type DataTableFeatures, type DataTableInstance, DataTablePagination, type DataTablePaginationMode, type DataTablePaginationProps, type DataTableProps, type DataTableRow, type DataTableState, type DataTableTable, DataTableToolbar, type DataTableToolbarProps, DataTableView, DataTableViewOptions, type DataTableViewOptionsProps, type DataTableViewProps, DateField, type DateFieldProps, DatePicker, type DatePickerProps, DateRangePicker, type DateRangePickerProps, Dialog, DialogBody, DialogClose, DialogContent, type DialogContentProps, DialogDescription, DialogFooter, DialogHeader, DialogOverlay, DialogPortal, DialogTitle, DialogTrigger, DropdownMenu, DropdownMenuCheckboxItem, DropdownMenuContent, type DropdownMenuContentProps, DropdownMenuGroup, DropdownMenuItem, type DropdownMenuItemProps, DropdownMenuLabel, type DropdownMenuLabelProps, DropdownMenuPortal, DropdownMenuRadioGroup, DropdownMenuRadioItem, DropdownMenuSeparator, DropdownMenuShortcut, DropdownMenuSub, DropdownMenuSubContent, DropdownMenuSubTrigger, type DropdownMenuSubTriggerProps, DropdownMenuTrigger, Dropzone, type DropzoneProps, type DropzoneState, EmptyState, type EmptyStateProps, ErrorBanner, type ErrorBannerProps, type ExportCell, type ExportSheet, Field, FieldContent, FieldControl, type FieldControlProps, FieldDescription, type FieldDescriptionProps, FieldError, type FieldErrorItem, type FieldErrorProps, FieldGroup, FieldLabel, type FieldLabelProps, type FieldProps, Fieldset, FieldsetLegend, type FieldsetLegendProps, type FieldsetProps, FileList, type FileListProps, type FileRejection, Form, FormControl, type FormControlProps, FormDescription, type FormDescriptionProps, FormField, FormItem, type FormItemProps, FormLabel, type FormLabelProps, FormMessage, type FormMessageProps, Funnel, FunnelChart, Input, type InputProps, type JsonSchema, Kbd, Label, LabelList, type LabelProps, Line, LineChart, LoadingSkeleton, type LoadingSkeletonPreset, type LoadingSkeletonProps, Markdown, type Components as MarkdownComponents, type MarkdownProps, NIVO_TYPES, type NivoTheme, PageHeader, type PageHeaderProps, Pie, PieChart, PolarAngleAxis, PolarGrid, PolarRadiusAxis, Popover, PopoverClose, PopoverContent, type PopoverContentProps, PopoverDescription, PopoverTitle, PopoverTrigger, Progress, ProgressIndicator, ProgressLabel, type ProgressProps, ProgressTrack, ProgressValue, RECHARTS_TYPES, Radar, RadarChart, RadioGroup, RadioGroupItem, type RadioGroupItemProps, type RadioGroupProps, RechartsLegend, RechartsTooltip, ReferenceLine, type ResolvedCortenaTheme, ResponsiveContainer, Scatter, ScatterChart, ScrollArea, type ScrollAreaProps, ScrollBar, SectionCard, type SectionCardProps, Segmented, type SegmentedOption, type SegmentedProps, Select, SelectContent, type SelectContentProps, SelectGroup, SelectItem, SelectLabel, type SelectProps, SelectSeparator, SelectTrigger, type SelectTriggerProps, SelectValue, Separator, type SeparatorProps, type ServerSource, Sheet, SheetClose, SheetContent, type SheetContentProps, SheetDescription, SheetFooter, SheetHeader, SheetOverlay, SheetPortal, type SheetProps, SheetTitle, SheetTrigger, Skeleton, SortableHandle, type SortableHandleProps, SortableList, type SortableListProps, type SortableRenderState, type SortableReorderDetails, Spinner, type SpinnerProps, StatusDot, type StatusDotProps, type StatusDotTone, type SubmitHandler, Switch, type SwitchProps, THEME_MESSAGE_TYPE, type TableQuery, type TableResult, Tabs, TabsContent, TabsIndicator, TabsList, TabsTrigger, Textarea, type TextareaProps, Toast, type ToastProps, Toaster, type ToasterProps, Toolbar, ToolbarEnd, type ToolbarProps, ToolbarSeparator, ToolbarStart, Tooltip, TooltipContent, type TooltipContentProps, TooltipProvider, TooltipTrigger, type UseCortenaThemeOptions, type UseCortenaThemeResult, type UseDataTableOptions, type UseFormFieldReturn, type UseFormReturn, VIZ_SERIES_COUNT, XAxis, YAxis, alertVariants, applyStoredTheme, applyTheme, arrayMove, badgeVariants, buildCatalogueDoc, buttonVariants, catalogueMarkdown, catalogueNames, chartEngine, chartScales, chipVariants, cn, createColumnHelper, dataTableFeatures, defaultCatalogue, downloadCsv, downloadExcel, exampleMessages, fieldVariants, foldMessages, formatDateDefault, formatDateISO, formatDateLong, formatDateShort, formatFileSize, formatRelative, getAtPointer, getThemeInitScript, inputClassName, isDataBinding, labelVariants, markdownSanitizeSchema, nivoTheme, parseA2UIMessages, parseDateDefault, parseDateISO, pointerSegments, readAction, readChildren, readComponent, readStoredTheme, resolveColor, resolvePointer, resolveValue, resolveVizSeries, seriesColor, setAtPointer, sheetVariants, textareaClassName, themeFromBackground, themeFromMessage, themeInitScript, toCsv, toHex, toSheet, toastVariants, useChart, useComboboxFilter, useCortenaTheme, useDataTable, useForm, useFormField, useNivoTheme, useToast, vizSeriesVars, vizVar, zodResolver };