@silverpoint/core 0.2.0 → 0.6.0

package/dist/ui.d.ts

@@ -0,0 +1,545 @@
+import { n as Seed, t as GroundRef, u as SubstrateName, q as InkMode, ay as ToneLevel, o as Stroke, G as Geometry, aA as UiTokens, am as Ground, az as ToneSpec, v as ProviderConfig } from './props-Dq8FC8GG.js';
+
+/** Control size; heights come from the ground's `ui.controlHeight` (Data Model §3.8). */
+type UiSize = 'sm' | 'md' | 'lg';
+/** Props every UI component takes, as `CommonChartProps` does for charts (API Spec §3). */
+interface CommonUiProps {
+    /** The frame variant and every related id derive from it (REQ-307, REQ-329). */
+    id?: string;
+    /** Overrides `id` for the frame variant only. */
+    seed?: Seed;
+    /** Style ground. Defaults to the dashboard's, then the app provider's, or `silverpoint` (REQ-311). */
+    ground?: GroundRef;
+    /** Prepared substrate within the ground (REQ-046). */
+    substrate?: SubstrateName;
+    /** `ink` by default; `precision` disables inking (REQ-021, REQ-306). */
+    mode?: InkMode;
+    /** Default `'md'`. */
+    size?: UiSize;
+    /** Added to the component's root element, after its own classes. */
+    className?: string;
+}
+/** An item of Tabs, Segmented or RadioGroup; keys are unique (REQ-325). */
+interface UiItem {
+    key: string;
+    label: string;
+    disabled?: boolean;
+}
+type StepStatus = 'wait' | 'process' | 'finish' | 'error';
+interface StepItem {
+    key: string;
+    title: string;
+    description?: string;
+    /** Derived from `current` when omitted; `'error'` must be explicit. */
+    status?: StepStatus;
+}
+/** Button emphasis. Not a tone: `tone` names only a level 1-4 of the ground's ramp (A-07). */
+type UiVariant = 'default' | 'primary' | 'danger';
+type AlertKind = 'info' | 'success' | 'warning' | 'error';
+type UiOrientation = 'horizontal' | 'vertical';
+/** A tonal level a component may ask for; 0 (no fill) is not one. */
+type UiToneLevel = Exclude<ToneLevel, 0>;
+interface SpButtonProps extends CommonUiProps {
+    /** Default `'default'`; `danger` also draws the exact ✕ glyph (REQ-310). */
+    variant?: UiVariant;
+    /** Default `'button'`. */
+    type?: 'button' | 'submit' | 'reset';
+    /** Not focusable, not submitted; drawn with the disabled tone. */
+    disabled?: boolean;
+    /** Accessible name of an icon-only button (REQ-319). */
+    label?: string;
+    /** Fills the width of its container. */
+    block?: boolean;
+    /** Renders an `<a>`. */
+    href?: string;
+}
+interface SpInputProps extends CommonUiProps {
+    /** Native input type. Default `'text'`. */
+    type?: 'text' | 'search' | 'email' | 'url' | 'tel' | 'password' | 'number';
+    /** Hint shown while empty; not a substitute for the accessible name. */
+    placeholder?: string;
+    /** Form field name; the native input submits under it (REQ-323). */
+    name?: string;
+    /** Not focusable and not submitted. */
+    disabled?: boolean;
+    /** Focusable and submitted, but not editable. */
+    readOnly?: boolean;
+    /** Sets `aria-invalid` and draws the exact ⚠ glyph (REQ-334). */
+    invalid?: boolean;
+    /** Help or error text under the control, referenced by `aria-describedby` (REQ-334). */
+    message?: string;
+    /** Accessible name, when no `<label for>` names the control. */
+    label?: string;
+}
+interface SpCheckboxProps extends CommonUiProps {
+    /** The visible text and accessible name. */
+    label: string;
+    /** Form field name; submitted as `on` when checked. */
+    name?: string;
+    /** Not focusable and not submitted. */
+    disabled?: boolean;
+    /** Draws the exact dash and sets the native `indeterminate` state. */
+    indeterminate?: boolean;
+}
+interface SpRadioGroupProps extends CommonUiProps {
+    /** The choices; each a native radio. Keys are unique (REQ-325). */
+    items: readonly UiItem[];
+    /** Required: the native radios submit under it (REQ-323). */
+    name: string;
+    /** The group's name, its `<legend>`. */
+    label: string;
+    /** Default `'vertical'`. */
+    orientation?: UiOrientation;
+}
+interface SpSwitchProps extends CommonUiProps {
+    /** The visible text and accessible name. */
+    label: string;
+    /** Form field name; submitted as `on` when on. */
+    name?: string;
+    /** Not focusable and not submitted. */
+    disabled?: boolean;
+}
+interface SpSliderProps extends CommonUiProps {
+    /** Accessible name of the native range input. */
+    label: string;
+    /** Default `0`. */
+    min?: number;
+    /** Default `100`. */
+    max?: number;
+    /** Default `1`. */
+    step?: number;
+    /** Form field name; the native input submits under it. */
+    name?: string;
+    /** Not focusable and not submitted. */
+    disabled?: boolean;
+    /** Values on the rail that get a labelled mark. */
+    marks?: readonly number[];
+}
+interface SpRateProps extends CommonUiProps {
+    /** The group's name, its `<legend>`. */
+    label: string;
+    /** Default `5`, in 1..10; each mark an exact lozenge. */
+    count?: number;
+    /** Form field name; the native radios submit under it. */
+    name?: string;
+    /** Not focusable and not submitted. */
+    disabled?: boolean;
+    /** Shows the value; the keyboard and the pointer do not change it. */
+    readOnly?: boolean;
+}
+interface SpSegmentedProps extends CommonUiProps {
+    /** The options; each a native radio. Keys are unique (REQ-325). */
+    items: readonly UiItem[];
+    /** The control's name, its `<legend>`. */
+    label: string;
+    /** Form field name; the native radios submit under it. */
+    name?: string;
+    /** Fills the width of its container. */
+    block?: boolean;
+}
+interface SpTabsProps extends CommonUiProps {
+    /** The tabs; a disabled one is skipped by the arrows. Keys are unique (REQ-325). */
+    items: readonly UiItem[];
+    /** Accessible name of the tab list. */
+    label?: string;
+    /** Default `'horizontal'`. */
+    orientation?: UiOrientation;
+    /** Default `'automatic'`: a tab is selected as focus reaches it. */
+    activation?: 'automatic' | 'manual';
+}
+interface SpStepsProps extends CommonUiProps {
+    /** The steps, in order; a status is derived from `current` unless set. */
+    items: readonly StepItem[];
+    /** 0-based. */
+    current: number;
+    /** Default `'horizontal'`. */
+    orientation?: UiOrientation;
+    /** Accessible name of the list. */
+    label?: string;
+}
+interface SpCardProps extends CommonUiProps {
+    /** Heading of the card; without it the card is a plain container. */
+    title?: string;
+    /** Default `3`. */
+    headingLevel?: 2 | 3 | 4 | 5 | 6;
+}
+interface SpTagProps extends CommonUiProps {
+    /** Tonal level, default `1`. */
+    tone?: UiToneLevel;
+    /** Adds a native close button; each adapter raises its close event. */
+    closable?: boolean;
+    /** Accessible name of the close button. Default `Remove <text>`. */
+    closeLabel?: string;
+}
+interface SpBadgeProps extends CommonUiProps {
+    /** The number shown, up to `max`. */
+    count?: number;
+    /** Default `99`; above it the badge reads `99+`. */
+    max?: number;
+    /** A dot with no number. */
+    dot?: boolean;
+    /** Accessible text of the badge, e.g. `unread messages`. */
+    label?: string;
+}
+interface SpDividerProps extends CommonUiProps {
+    /** Default `'horizontal'`. */
+    orientation?: UiOrientation;
+    /** A caption set in the rule. */
+    text?: string;
+    /** Default `'center'`. */
+    align?: 'start' | 'center' | 'end';
+}
+interface SpProgressProps extends CommonUiProps {
+    /** 0..100; omitted, the progress is indeterminate. */
+    value?: number;
+    /** Default `'line'`. */
+    shape?: 'line' | 'circle';
+    /** Accessible name (REQ-318). */
+    label: string;
+    /** Default `true`. */
+    showValue?: boolean;
+}
+interface SpAlertProps extends CommonUiProps {
+    /** Default `'info'`. */
+    kind?: AlertKind;
+    /** Bold first line of the alert. */
+    title?: string;
+    /** Adds a native close button; each adapter raises its close event. */
+    closable?: boolean;
+    /** Accessible name of the close button. Default `'Close'`. */
+    closeLabel?: string;
+}
+interface SpSkeletonProps extends CommonUiProps {
+    /** Default `3`, in 1..8. */
+    lines?: number;
+    /** Draws an avatar placeholder before the lines. */
+    avatar?: boolean;
+    /** Default `'Loading'`. */
+    label?: string;
+}
+
+/** The catalog's groups (PRD §6.11), in the order the documentation lists them. */
+type UiGroup = 'actions' | 'data-entry' | 'navigation' | 'data-display' | 'feedback';
+/** One UI component: every gate, fixture set and example page iterates this list. */
+interface UiComponentRow {
+    /** Catalog name, as the PRD writes it. */
+    readonly name: string;
+    /** Kebab-case subpath: `@silverpoint/<adapter>/ui/<slug>`. */
+    readonly slug: string;
+    /** The exported name, the same in the three adapters (OQ-U2). */
+    readonly component: string;
+    readonly group: UiGroup;
+    /** The batch of step 6c that implements it (plan-and-tasks.md). */
+    readonly batch: 'B1' | 'B2' | 'B3';
+    /** Declared states (Data Model §5); one fixture and one demo each. */
+    readonly states: readonly string[];
+}
+/** The 17 components of `0.3.0` and their 45 declared states (REQ-300, Data Model §5). */
+declare const UI_COMPONENTS: readonly UiComponentRow[];
+
+/** A linear value's domain. Without `step` the value is only clamped (Progress). */
+interface UiRange {
+    readonly min: number;
+    readonly max: number;
+    readonly step?: number;
+}
+interface UiValue {
+    /** The value to render: clamped, on its step. */
+    readonly value: number;
+    /** Where it sits along its range, in [0, 1] with 2 decimals (DD-025, I-22). */
+    readonly fraction: number;
+    /** The input was not drawable as given. */
+    readonly corrected: boolean;
+}
+/** A range as drawn: the given one if valid, else `0..100` step 1, warned `SP017` (REQ-324). */
+declare function uiRange(range: UiRange, component?: string): UiRange;
+/**
+ * A value on its range: clamped, rounded to the nearest step counted from `min` (never past `max`
+ * when `max` is off the step grid), and its exact fraction. Anything corrected warns `SP017`
+ * (REQ-324). Pure apart from the development warning.
+ */
+declare function uiValue(value: number, range: UiRange, component?: string): UiValue;
+/** A Rate's `count`: an integer in 1..10, default 5; anything else corrected with `SP017`. */
+declare function uiRateCount(count: number | undefined, component?: string): number;
+
+/** The circle Progress draws in a fixed 100 × 100 view box (DD-025). */
+declare const UI_PROGRESS_VIEWBOX = 100;
+/**
+ * The circle Progress: the exact track and the exact filled arc, from 12 o'clock clockwise, on the
+ * charts' polar engine. Both are `encoding`, so no inker touches them (REQ-304). `stroke` is the
+ * ring's width in view-box units; the ring is inset by half of it so nothing is clipped.
+ */
+declare function uiProgressArc(fraction: number, stroke: number): {
+    readonly track: Stroke;
+    readonly fill: Stroke;
+};
+
+interface UiStep {
+    readonly key: string;
+    readonly status: StepStatus;
+    /**
+     * The connector after this step carries the status of the step it leads to, written as
+     * `data-status`; a `wait` connector is dashed (C-4). `null` after the last step.
+     */
+    readonly connector: StepStatus | null;
+    /** The step `current` points at, after clamping: it carries `aria-current` (REQ-318). */
+    readonly current: boolean;
+}
+/**
+ * Status per step, derived from `current` (finish before, process at, wait after) unless the item
+ * sets one, and the connectors between them. Keys are de-duplicated (`SP019`); a `current` outside
+ * the list or not an integer is clamped and rounded (`SP017`, REQ-324).
+ */
+declare function uiSteps(items: readonly StepItem[], current: number, component?: string): readonly UiStep[];
+
+/** The composite's root element, as much of the DOM as this reads; the core has no DOM types. */
+interface UiRovingRoot {
+    querySelectorAll(selector: string): ArrayLike<unknown>;
+    closest(selector: string): {
+        getAttribute(name: string): string | null;
+    } | null;
+    readonly ownerDocument: {
+        readonly activeElement: unknown;
+    } | null;
+}
+/**
+ * The keyboard of a composite (REQ-315), for a `keydown` on its root: the transition is
+ * `uiRovingKey`; this finds the items, reads the direction from the nearest `dir` (REQ-321), and
+ * moves focus —and, when `activate`, selects by clicking the item, so the adapter's own click or
+ * change handler runs. `both` takes the axis from the key, as a radio group does. A key it does
+ * not use is left to the browser.
+ */
+declare function uiRovingFocus(event: {
+    readonly key: string;
+    preventDefault(): void;
+}, root: UiRovingRoot, selector: string, orientation: UiOrientation | 'both', activate: boolean): void;
+
+type UiRovingKey = 'ArrowLeft' | 'ArrowRight' | 'ArrowUp' | 'ArrowDown' | 'Home' | 'End';
+interface UiRovingState {
+    /** The focused item; `-1` when none is yet. */
+    readonly index: number;
+    readonly count: number;
+    readonly disabled: readonly boolean[];
+}
+/**
+ * The WAI-ARIA APG roving-focus transition of a tab list or radio-like group (REQ-315): arrows
+ * along the orientation move to the next enabled item and wrap at the ends, `rtl` mirrors the
+ * horizontal arrows (REQ-321), Home and End go to the first and last enabled item, and disabled
+ * items are skipped (REQ-326). Cross-axis arrows, and any key with no enabled item to go to, keep
+ * the index. Pure.
+ */
+declare function uiRovingKey(state: UiRovingState, key: UiRovingKey, orientation: UiOrientation, dir: 'ltr' | 'rtl'): number;
+/** Whether a `KeyboardEvent.key` moves a roving focus: the arrows, Home and End (REQ-315). */
+declare const uiIsRovingKey: (key: string) => key is UiRovingKey;
+
+type UiFrameKind = 'control' | 'pill' | 'box' | 'card' | 'round';
+/**
+ * Each frame kind is drawn once in a square box and cut into slices for the grounds build
+ * (DD-022): four corners of `slice` px, and four edges between them when `size > 2 * slice`.
+ * `round` and `box` have no edges; they frame fixed-size squares.
+ */
+declare const UI_FRAME_KINDS: Readonly<Record<UiFrameKind, Readonly<{
+    size: number;
+    slice: number;
+    radius: number;
+}>>>;
+/**
+ * The frame variant of a component: from `seed`, else `id`, by the charts' seed rule; `0` with
+ * neither (REQ-307, I-21). Never from mount order, randomness or time (Art. 4). `variants` is read
+ * as an integer in 1..6.
+ */
+declare function uiFrameVariant(seed: Seed | undefined, id: string | undefined, variants: number): number;
+/**
+ * The exact outline of a frame kind: the input the grounds build inks, once per variant, into the
+ * pieces of `ui.css` (DD-022). It is an `ornament` stroke —a frame carries no value (Art. 1, as
+ * amended)— so the ground's inker may draw it by hand, with its vertices preserved. Build time only.
+ */
+declare function uiFrameOutline(kind: UiFrameKind): Geometry;
+
+/**
+ * Keeps the first item of each key and skips later ones, and any item without a key, warning
+ * `SP019` without throwing (REQ-325). Returns the input itself when every key is unique.
+ */
+declare function uiItems<T extends {
+    readonly key: string;
+}>(items: readonly T[], component: string): readonly T[];
+/**
+ * The key a composite shows as selected (Data Model §2.14): the given key if an enabled item has
+ * it; otherwise `null` for a RadioGroup (`'none'`), the first enabled key for Segmented and Tabs
+ * (`'first'`). Silent: a key that leaves `items` is an ordinary state of dynamic data (A-06).
+ */
+declare function uiSelectedKey(items: readonly UiItem[], value: string | null | undefined, fallback: 'none' | 'first'): string | null;
+
+/**
+ * A Button or Badge needs an accessible name: its text content or a `label`. Without either it
+ * still renders, and warns `SP018` in development (REQ-319).
+ */
+declare function uiRequireName(component: string, text: string | undefined, label: string | undefined): void;
+
+/** The `ui` tokens of a ground that declares none (Data Model §3.8). */
+declare const UI_TOKEN_DEFAULTS: UiTokens;
+/**
+ * A ground's `ui` tokens, or the defaults, held to their domain: heights ≥ 24 px, focus ≥ 2 px,
+ * 1..6 variants. A `weight` ground has no inker that draws by hand, so its frame is always the
+ * exact `css` one with a single variant (DD-022). Pure.
+ */
+declare function resolveUiTokens(ground: Ground): UiTokens;
+
+/** One repeating layer of a control's tone: a tile the grounds build inks and lays as a CSS mask. */
+interface UiToneLayer {
+    readonly width: number;
+    readonly height: number;
+    readonly strokes: readonly Stroke[];
+}
+/**
+ * The tone of a control at one step of a ground's ramp (DD-026, REQ-308): one layer of hachure,
+ * two for cross-hatch (each its own period, laid as two mask layers), none for a `weight` step,
+ * whose tone is the frame's line weight. Its lines are `ornament`: a tone is not a value, so the
+ * ground's inker may draw them by hand, vertices preserved. Build time only. Pure.
+ */
+declare function uiToneTile(spec: ToneSpec): readonly UiToneLayer[];
+
+/** Exact glyphs in a 16 × 16 box: their strokes are values, never inked (REQ-304, REQ-310). */
+declare const UI_GLYPHS: Readonly<{
+    tick: "M3.5,8.5L6.5,11.5L12.5,4.5";
+    dash: "M4,8H12";
+    cross: "M4.5,4.5L11.5,11.5M11.5,4.5L4.5,11.5";
+    warning: "M8,2.5L14.5,13.5H1.5Z M8,6.5V9.5 M8,11.5V11.5";
+    /** A radio's selection: filled by ui.css. */
+    dot: "M11,8A3,3 0 1,1 5,8A3,3 0 1,1 11,8Z";
+    /** A Rate mark (C-2). */
+    lozenge: "M8,1.5L14.5,8L8,14.5L1.5,8Z";
+    info: "M14.5,8A6.5,6.5 0 1,1 1.5,8A6.5,6.5 0 1,1 14.5,8Z M8,7.5V11.5 M8,4.75V4.75";
+}>;
+type UiGlyph = keyof typeof UI_GLYPHS;
+
+/**
+ * The markup contract of the UI components (API delta §4), as data: every adapter writes this tree
+ * and nothing else, and the parity gate compares each adapter's server render with it (REQ-327).
+ * An adapter binds behaviour —value, events, forms— to the elements marked `bind`, and puts the
+ * consumer's content where a `slot` stands. It computes nothing (Art. 2).
+ */
+type UiAttrValue = string | true;
+interface UiElement {
+    readonly tag: string;
+    /** HTML attribute names; `true` is a boolean attribute. */
+    readonly attrs: Readonly<Record<string, UiAttrValue>>;
+    readonly children: readonly UiNode[];
+    /** What an adapter binds to the element: see `UiBind`. */
+    readonly bind?: UiBind;
+}
+/**
+ * `native`: a control an adapter binds value, events and forms to —one, or one per item of a
+ * composite, told apart by its `value` or `data-key`. `close`: the button that emits `close`.
+ */
+type UiBind = 'native' | 'close';
+type UiSlot = 'content' | 'prefix' | 'suffix' | 'extra' | 'footer';
+type UiNode = UiElement | {
+    readonly text: string;
+} | {
+    readonly slot: UiSlot;
+};
+/** What a component inherits around it: the provider, the dashboard cell, the environment. */
+interface UiEnvironment {
+    readonly provider?: ProviderConfig;
+    /** The configuration of the dashboard whose cell holds the component (REQ-311). */
+    readonly cell?: ProviderConfig;
+    /** `prefers-contrast: more` or `forced-colors: active` holds (REQ-123). */
+    readonly forcedPrecision?: boolean;
+}
+interface UiResolved {
+    readonly ground: string;
+    readonly substrate: SubstrateName;
+    readonly mode: InkMode;
+    readonly size: UiSize;
+    /** 0..5: `ui.css` folds it onto the variants the ground draws. */
+    readonly frame: number;
+}
+/**
+ * Ground, substrate and mode with the charts' precedence: prop, then dashboard, then provider,
+ * then the library default; a forced `precision` applies after, and nothing overrides it (REQ-311).
+ */
+declare function resolveUi(props: CommonUiProps, env: UiEnvironment): UiResolved;
+/** `SpButton`: a native `<button>`, or `<a>` with `href` (REQ-314, REQ-310). */
+declare function uiButtonView(props: SpButtonProps, r: UiResolved, content: {
+    readonly text?: string;
+}): UiElement;
+/** `SpInput`: a native `<input>` in a framed box, its message after it (REQ-314, REQ-334). */
+declare function uiInputView(props: SpInputProps, r: UiResolved, state: {
+    readonly value: string;
+    readonly prefix?: boolean;
+    readonly suffix?: boolean;
+}): UiElement;
+/** `SpCheckbox`: native state; the tick and dash are drawn and shown by it (REQ-310). */
+declare function uiCheckboxView(props: SpCheckboxProps, r: UiResolved, state: {
+    readonly checked: boolean;
+}): UiElement;
+/** `SpSwitch`: a native checkbox with `role="switch"`, a pill track and an exact knob (REQ-314). */
+declare function uiSwitchView(props: SpSwitchProps, r: UiResolved, state: {
+    readonly checked: boolean;
+}): UiElement;
+/** `SpCard`: an `<article>` named by its heading, or a `<section>` without a title (REQ-318). */
+declare function uiCardView(props: SpCardProps, r: UiResolved, slots: {
+    readonly extra?: boolean;
+    readonly footer?: boolean;
+}): UiElement;
+/** `SpDivider`: a `separator`; with text, the text between two rules (REQ-318). */
+declare function uiDividerView(props: SpDividerProps, r: UiResolved): UiElement;
+
+/** `SpRadioGroup`: a `<fieldset>` of native radios; the value `null` checks none (REQ-314, REQ-322). */
+declare function uiRadioGroupView(props: SpRadioGroupProps, r: UiResolved, state: {
+    readonly value: string | null;
+}): UiElement;
+/** `SpSegmented`: native radios in one frame; the selected segment toned and heightened (REQ-308, REQ-309). */
+declare function uiSegmentedView(props: SpSegmentedProps, r: UiResolved, state: {
+    readonly value: string | null;
+}): UiElement;
+/** `SpTabs`: a tablist of native buttons, one tab stop on the selected; panels are the content (REQ-314, REQ-315). */
+declare function uiTabsView(props: SpTabsProps, r: UiResolved, state: {
+    readonly value: string | null;
+}): UiElement;
+/**
+ * `SpTabPanel`: a `tabpanel` labelled by its tab, focusable, hidden unless its tab is selected.
+ * `tabs` is what the enclosing `SpTabs` shares: its `id` and the selected key.
+ */
+declare function uiTabPanelView(props: {
+    readonly value: string;
+}, tabs: {
+    readonly id?: string;
+    readonly value: string | null;
+}): UiElement;
+/**
+ * `SpSlider`: a native range over the drawing. Its fraction is a custom property (DD-025): fill
+ * and thumb sit at it exactly; the thumb is the one heightening (REQ-309).
+ */
+declare function uiSliderView(props: SpSliderProps, r: UiResolved, state: {
+    readonly value: number;
+}): UiElement;
+/** `SpRate`: `count` native radios valued 1..count, drawn as exact lozenges; filled up to the value (C-2). */
+declare function uiRateView(props: SpRateProps, r: UiResolved, state: {
+    readonly value: number;
+}): UiElement;
+
+/** `SpSteps`: an ordered list; the current step has `aria-current="step"` and the heightening (REQ-318, REQ-309). */
+declare function uiStepsView(props: SpStepsProps, r: UiResolved): UiElement;
+/** `SpTag`: framed and toned at its level (default 1); closable, a native close button (REQ-308). */
+declare function uiTagView(props: SpTagProps, r: UiResolved, content: {
+    readonly text?: string;
+}): UiElement;
+/** `SpBadge`: its count is text beside the content, so it is in the accessible name (REQ-318). */
+declare function uiBadgeView(props: SpBadgeProps, r: UiResolved, content: {
+    readonly text?: string;
+}): UiElement;
+/** `SpProgress`: a `progressbar`; without a value, indeterminate: no `aria-valuenow`, a static tone (REQ-318, REQ-320). */
+declare function uiProgressView(props: SpProgressProps, r: UiResolved): UiElement;
+/**
+ * `SpAlert`: `alert` for error and warning, `status` otherwise (REQ-318). Error alone takes a tone,
+ * the ground's `alertError`, with its text on a plate (C-3); every kind has its exact glyph.
+ */
+declare function uiAlertView(props: SpAlertProps, r: UiResolved, state: {
+    readonly closable: boolean;
+}): UiElement;
+/** `SpSkeleton`: `aria-busy`, a label for assistive technology, and hidden toned shapes (REQ-318). */
+declare function uiSkeletonView(props: SpSkeletonProps, r: UiResolved): UiElement;
+
+export { type AlertKind, type CommonUiProps, type SpAlertProps, type SpBadgeProps, type SpButtonProps, type SpCardProps, type SpCheckboxProps, type SpDividerProps, type SpInputProps, type SpProgressProps, type SpRadioGroupProps, type SpRateProps, type SpSegmentedProps, type SpSkeletonProps, type SpSliderProps, type SpStepsProps, type SpSwitchProps, type SpTabsProps, type SpTagProps, type StepItem, type StepStatus, UI_COMPONENTS, UI_FRAME_KINDS, UI_GLYPHS, UI_PROGRESS_VIEWBOX, UI_TOKEN_DEFAULTS, type UiAttrValue, type UiBind, type UiComponentRow, type UiElement, type UiEnvironment, type UiFrameKind, type UiGlyph, type UiGroup, type UiItem, type UiNode, type UiOrientation, type UiRange, type UiResolved, type UiRovingKey, type UiRovingRoot, type UiRovingState, type UiSize, type UiSlot, type UiStep, type UiToneLayer, type UiToneLevel, type UiValue, type UiVariant, resolveUi, resolveUiTokens, uiAlertView, uiBadgeView, uiButtonView, uiCardView, uiCheckboxView, uiDividerView, uiFrameOutline, uiFrameVariant, uiInputView, uiIsRovingKey, uiItems, uiProgressArc, uiProgressView, uiRadioGroupView, uiRange, uiRateCount, uiRateView, uiRequireName, uiRovingFocus, uiRovingKey, uiSegmentedView, uiSelectedKey, uiSkeletonView, uiSliderView, uiSteps, uiStepsView, uiSwitchView, uiTabPanelView, uiTabsView, uiTagView, uiToneTile, uiValue };