@cjlapao/ui-kit 0.2.0 → 0.2.4

package/dist/CapsuleBlueprint-DwDZ7nii.d.ts

@@ -0,0 +1,1211 @@
+import React__default from 'react';
+
+/**
+ * common/theme/glass.ts — Framework-agnostic glass utility module.
+ *
+ * Extracts all glass logic from Panel into reusable functions and types
+ * so that any control (Button, IconButton, DropdownButton, etc.) can
+ * compose glass styling without duplicating the Panel implementation.
+ *
+ * This file is pure TypeScript — no React, Vue, or DOM imports.
+ */
+
+/**
+ * Backdrop vibrancy level for glass surfaces.
+ * - `"low"`     → 1.0× saturation
+ * - `"medium"`  → 1.2× saturation (default)
+ * - `"high"`    → 1.4× saturation
+ * - `number`    → arbitrary multiplier (0 – 2 recommended)
+ */
+type GlassVibrancy = "low" | "medium" | "high" | number;
+/**
+ * Glass fill transparency level.
+ * - `"frosted"` → 65 % light / 25 % dark  (default)
+ * - `"light"`   → 85 % light / 35 % dark
+ * - `"clear"`   → 30 % light / 10 % dark  (sheer — pair with a light backdrop)
+ * - `number`    → 0–1 fraction; light = round(frac × 100), dark = min(round(frac × 30), 30)
+ *
+ * Only the three presets (and their +10 hover steps) are safelisted. A numeric
+ * value emits an arbitrary opacity that Tailwind's scanner cannot see, so the
+ * fill silently disappears unless that exact step happens to be generated —
+ * see `scripts/generate-safelist.mjs`.
+ */
+type GlassOpacity = "frosted" | "light" | "clear" | number;
+/**
+ * Specular highlight mode for glass surfaces.
+ * - `"none"`    → no specular overlay
+ * - `"classic"` → sheen falling from the top edge
+ * - `"halo"`    → broad bloom plus two off-centre corner glints
+ */
+type SpecularMode = "none" | "classic" | "halo";
+
+declare const BUTTON_VARIANTS: readonly ["solid", "soft", "outline", "ghost", "link", "clear", "icon", "glass"];
+type ButtonVariant = (typeof BUTTON_VARIANTS)[number];
+/** Label weight. Derived from the runtime list for the same reason. */
+declare const BUTTON_WEIGHTS: readonly ["normal", "medium", "semibold", "bold"];
+type ButtonWeight = (typeof BUTTON_WEIGHTS)[number];
+/**
+ * The 21 Tailwind palette colours the kit supports.
+ *
+ * `TrueColor` is derived from this array rather than declared alongside it, so
+ * the runtime list and the type can never drift — adding a colour here adds it
+ * to the type, the generated theme, and every consumer that enumerates colours.
+ */
+declare const TRUE_COLORS: readonly ["red", "orange", "amber", "yellow", "lime", "green", "emerald", "teal", "cyan", "sky", "blue", "indigo", "violet", "purple", "fuchsia", "rose", "slate", "gray", "zinc", "neutral", "stone"];
+/**
+ * TrueColor is the only valid color type in the ui-kit theme system.
+ * All components, tokens, and utilities must use TrueColor exclusively.
+ */
+type TrueColor = (typeof TRUE_COLORS)[number];
+/**
+ * The fill class for a dot/swatch of each TrueColor: the 500 step in light
+ * mode, the 400 step in dark. Literal per colour — never interpolated — so
+ * Tailwind's scanner always sees them; the helper is what components share.
+ */
+declare const TRUE_COLOR_DOT_CLASSES: Record<TrueColor, string>;
+/** Dot/swatch fill for a TrueColor. */
+declare function getTrueColorDotClass(tone: TrueColor): string;
+/**
+ * The ink class for a TrueColor: the 500 step in light mode, the 400 step
+ * in dark — what SVG strokes (`stroke-current`) and legends use where a
+ * fill class would not apply. Literal per colour, as above.
+ */
+declare const TRUE_COLOR_TEXT_CLASSES: Record<TrueColor, string>;
+/** Ink (stroke/text) class for a TrueColor. */
+declare function getTrueColorTextClass(tone: TrueColor): string;
+/**
+ * Shared size type used across all frameworks and components.
+ * Replaces both the old ThemeSize (dead code) and ModalSize.
+ */
+type Size = "xs" | "sm" | "md" | "lg" | "xl" | "xxl" | "xxxl" | "2xl" | "3xl" | "full";
+/**
+ * The size scale every interactive control shares. Derived from the runtime
+ * list so the two cannot drift, and so demos/docs can enumerate it.
+ */
+declare const CONTROL_SIZES: readonly ["xs", "sm", "md", "lg", "xl"];
+type ControlSize = (typeof CONTROL_SIZES)[number];
+/**
+ * The two layouts a linear control can take.
+ *
+ * This union was declared independently in `Slider`, `Rating`, `AppDivider`,
+ * `Stepper` and `Tabs` (five names for one scale), so a rename or addition in
+ * the theme would never reach any of them. It lives here once; each control
+ * keeps its own alias (`SliderOrientation`, …) so call sites and the barrels
+ * are unaffected.
+ */
+declare const ORIENTATIONS: readonly ["horizontal", "vertical"];
+type Orientation = (typeof ORIENTATIONS)[number];
+/**
+ * The geometry of an interactive control at each shared size.
+ *
+ * Every control in the trigger family needs the same answer to "how big is the
+ * icon, the box, the spinner at this size". That table was copy-pasted into
+ * `Button` (text padding, icon-only padding, icon and spinner sizes) and
+ * `IconButton` (square box, icon, `<Spinner>` size) — two copies of one scale,
+ * drifting independently. It lives here once; the components import it.
+ */
+type ControlSizeTokens = {
+    /** Font size and padding of a labelled control. */
+    text: string;
+    /** Padding of a square (icon-only) control. */
+    iconOnly: string;
+    /** Fixed box of a square control (`IconButton`). */
+    box: string;
+    /** Space between an icon and its label. */
+    gap: string;
+    /** Icon dimensions at this control size — identical across controls. */
+    icon: string;
+    /** Dimensions of the inline spinner inside a labelled control. */
+    spinner: string;
+    /** Size to pass to `<Spinner>` inside a square control. */
+    spinnerSize: ControlSize;
+};
+declare const getControlSizeTokens: (size: ControlSize) => ControlSizeTokens;
+/**
+ * The corner radius every trigger-family control shares, so a `Button` next to
+ * an `Input` is the same box (both `rounded-lg`). Panel-family containers use
+ * `DEFAULT_SURFACE_CORNER` instead — a different scale, deliberately.
+ */
+declare const DEFAULT_TRIGGER_CORNER = "rounded-lg";
+/**
+ * Strength of a decorative glow behind a control (currently `SearchBar`'s
+ * gradient variant).
+ */
+declare const GLOW_INTENSITIES: readonly ["subtle", "soft", "medium", "strong"];
+type GlowIntensity = (typeof GLOW_INTENSITIES)[number];
+/**
+ * The kit's standing glow intensity: the tone reads as a hint at rest and
+ * the field itself brightens it on focus — the glow should never be the
+ * loudest thing in a form. Gradient fields destructure this as their prop
+ * default, and `getGlowTokens` falls back to it.
+ */
+declare const DEFAULT_GLOW_INTENSITY: GlowIntensity;
+/**
+ * Surface treatments shared by every text-entry control — `Input`, `Textarea`,
+ * `SearchBar`. Defined once here so the three are the same box when they sit
+ * next to each other in a form.
+ */
+declare const INPUT_VARIANTS: readonly ["flat", "elevated", "ghost", "underline", "glass", "gradient"];
+type InputVariant = (typeof INPUT_VARIANTS)[number];
+type InputVariantTokens = {
+    /** Border, fill, radius, shadow, backdrop. */
+    surface: string;
+    /** Text and placeholder colours. */
+    text: string;
+    /** Resting colour for a leading icon or other adornment. */
+    icon: string;
+    /** True when the surface is see-through and sits over unknown content. */
+    translucent: boolean;
+};
+/**
+ * The variant's surface with its border colour removed, keeping the width and
+ * sides.
+ *
+ * A validation state paints its own border colour, and `border-rose-500`
+ * beside the variant's `border-neutral-300` is a same-specificity collision
+ * whose winner is emission order — measured in the built stylesheet,
+ * `.border-emerald-500` lands *before* `.border-neutral-300` and
+ * `.border-rose-500` after it, so an errored field turned rose and a
+ * successful one stayed grey. Strip the colour so only one class can apply.
+ */
+declare const stripBorderColor: (surface: string) => string;
+/** True when a caller-supplied class string sets a text colour of its own. */
+declare const hasTextColor: (className?: string) => boolean;
+/**
+ * A class string with its text colour removed.
+ *
+ * Same trap as `stripBorderColor`: a component's own `text-neutral-500` and a
+ * caller's `text-emerald-600` are the same specificity, so the winner is
+ * emission order in the built stylesheet — which means a documented override
+ * works for some colours and silently does nothing for others.
+ */
+declare const stripTextColor: (className: string) => string;
+/**
+ * The field surface tokens. `corner="auto"` (the default) leaves the radius
+ * baked into the surface in place — `rounded-lg`, the theme's control corner
+ * (`DEFAULT_CONTROL_CORNER`), one step looser than the container default so
+ * a field sits proud of the card it lives in. Any other corner token
+ * replaces it. (`underline` paints no box, so a corner there has nowhere
+ * to land — honestly no-op.)
+ */
+declare const getInputVariantTokens: (variant: InputVariant, tone?: TrueColor, corner?: SurfaceCorner) => InputVariantTokens;
+type FieldToneTokens = {
+    /** Border colour while anything inside the field has focus. */
+    focusBorder: string;
+    /** Glow ring while anything inside the field has focus. */
+    focusRing: string;
+    /** Leading/trailing icon colour while the field has focus. */
+    icon: string;
+    /** Focus ring for an inline trailing button. */
+    buttonFocusRing: string;
+};
+declare const getFieldToneTokens: (color: TrueColor) => FieldToneTokens;
+type FieldSizeTokens = {
+    px: string;
+    py: string;
+    /** `underline` has no box to inset from, and needs room above the rule. */
+    underlinePy: string;
+    text: string;
+    icon: ControlSize;
+    /** Inline trailing button. */
+    button: string;
+};
+/** Padding and type scale, so any two fields line up when stacked. */
+declare const FIELD_SIZE_STYLES: Record<ControlSize, FieldSizeTokens>;
+declare const getFieldSizeTokens: (size: ControlSize) => FieldSizeTokens;
+/**
+ * Border only at rest; the ring is part of the focus state, exactly as it is
+ * for the tone tokens. A status used to add a bare `ring-2 ring-inset` at rest
+ * with no ring *colour* — an unset ring colour resolves to `currentColor`, so
+ * every errored or successful field carried a near-black 2px halo inside its
+ * coloured border.
+ *
+ * These also carry no copy colour. Forcing `text-neutral-900 dark:text-neutral-100`
+ * alongside the border costs an errored `underline` or `glass` field the
+ * high-contrast pair it needs to stay legible over a backdrop.
+ */
+declare const FIELD_STATUS_CLASSES: Record<"error" | "success", string>;
+/**
+ * Surface treatments for containers — `Panel` and anything built on it
+ * (`FormSection`). Kept here so the type and the text that sits on those
+ * surfaces are defined once, not per component.
+ */
+declare const SURFACE_VARIANTS: readonly ["elevated", "outlined", "subtle", "tonal", "default", "glass", "simple", "liquid-glass"];
+type SurfaceVariant = (typeof SURFACE_VARIANTS)[number];
+/**
+ * The button a card surface implies — what a card CTA wears when it is not
+ * given a variant of its own. An outlined card offers an outlined button.
+ */
+declare const SURFACE_TO_BUTTON_VARIANT: Record<SurfaceVariant, ButtonVariant>;
+/**
+ * The surface family plus `plain` — "draw a card, or draw nothing at all".
+ *
+ * A control that may already sit inside a card the app owns needs a way to say
+ * "no surface of my own"; nine components had each spelled that out for
+ * themselves (`PanelVariant | "plain"` seven times, `[...SURFACE_VARIANTS,
+ * "plain"]` twice) and only one of them exported a runtime list, so demos could
+ * not enumerate the others. Same list, nine names: the day `SURFACE_VARIANTS`
+ * gains a member, eight of them keep working only by luck.
+ */
+declare const PLAIN_SURFACE_VARIANTS: readonly ["elevated", "outlined", "subtle", "tonal", "default", "glass", "simple", "liquid-glass", "plain"];
+type PlainSurfaceVariant = (typeof PLAIN_SURFACE_VARIANTS)[number];
+type SurfaceTextTokens = {
+    /** Section and card headings. */
+    heading: string;
+    /** Body copy. */
+    body: string;
+    /** Secondary copy — descriptions under a label. */
+    description: string;
+    /** Tertiary copy — hints, counters, "optional" markers. */
+    muted: string;
+    /** Hairline between regions of the surface. */
+    divider: string;
+    translucent: boolean;
+};
+declare const getSurfaceTextTokens: (variant: SurfaceVariant) => SurfaceTextTokens;
+/**
+ * A full-bleed interactive region on a container surface — a disclosure header,
+ * a clickable card row.
+ *
+ * Two rules learned the hard way, both encoded here so callers cannot get them
+ * wrong: a ring colour is inert without a ring *width*, and an outer ring is
+ * clipped by any ancestor with `overflow: hidden` (which every `Panel` has), so
+ * the ring is inset.
+ */
+type SurfaceTriggerTokens = {
+    /** Background wash on hover. Low-alpha, so it works on glass too. */
+    hover: string;
+    /** Complete focus indicator: outline reset, width, inset, colour. */
+    focusRing: string;
+};
+declare const getSurfaceTriggerTokens: (color: TrueColor) => SurfaceTriggerTokens;
+/**
+ * The `CollapsibleHelpText` trigger — the shared surface-trigger tokens plus
+ * the accent glyph, icon chip and title line.
+ *
+ * The accent sits ON a same-hue `bg-{c}-50` chip, so it steps to the 700
+ * light shade rather than the usual 600: hue stacked on its own 50 shade is
+ * where 600 dropped under the 3:1 non-text bar (yellow landed ≈2.5:1).
+ */
+type CollapsibleHelpToneTokens = SurfaceTriggerTokens & {
+    /** Chevron and icon glyph. */
+    accent: string;
+    /** Icon chip fill. */
+    iconBg: string;
+    /** Title line. */
+    title: string;
+};
+declare const getCollapsibleHelpToneTokens: (color: TrueColor) => CollapsibleHelpToneTokens;
+declare const getAppDividerToneTokens: (color: TrueColor) => string;
+/**
+ * Corner radius scale for container surfaces.
+ *
+ * The token names are historical and do NOT map 1:1 onto Tailwind's radius
+ * utilities — `rounded-sm` here is Tailwind's `rounded-lg`. They are kept as
+ * they are because the whole kit already calls them by these names and the
+ * scale itself is monotonic and correct; renaming would silently reshape every
+ * existing card. `getSurfaceCornerRem` exposes the real radius so a demo can
+ * label them honestly.
+ *
+ * Capsule radii (`rounded-full` / `pill`) are not part of the container scale:
+ * a capsule is a shape, and the `Pill` component owns it. Containers that need
+ * one take a `rounded-full` class directly.
+ */
+declare const SURFACE_CORNERS: readonly ["auto", "none", "rounded", "rounded-sm", "rounded-md", "rounded-lg", "rounded-xl"];
+type SurfaceCorner = (typeof SURFACE_CORNERS)[number];
+/** The radius a container uses when the caller does not pick one. */
+declare const DEFAULT_SURFACE_CORNER: Exclude<SurfaceCorner, "auto">;
+/**
+ * The radius a control uses when the caller does not pick one — the
+ * input/button/segment scale, one step looser than the container default
+ * (`rounded-md` → `rounded-lg`) on purpose, so a control sits visibly proud
+ * of the card it lives in. Components whose docs say "the control corner
+ * from the theme" take this.
+ */
+declare const DEFAULT_CONTROL_CORNER: Exclude<SurfaceCorner, "auto">;
+/**
+ * The container surface a field implies — used by composite controls (the
+ * `DatePicker` calendar's `panelVariant="auto"`) so their furniture reads as
+ * part of the field instead of a foreign surface dropped beside it. Field
+ * surfaces have no exact container twin, so this picks the nearest fit:
+ * `flat` is a bordered box → `outlined`; `elevated` and the lifted `gradient`
+ * → `elevated`; `ghost`/`underline` carry no box, so `subtle`; `glass` →
+ * `glass`. (Deliberately not `tonal`/`simple` — the hover-filled tints read
+ * as chrome, not as a floating calendar.)
+ */
+declare const SURFACE_VARIANT_FOR_FIELD: Record<InputVariant, SurfaceVariant>;
+/**
+ * The surface variants that *are* glass — the ones where chrome has to sit
+ * *in* glass rather than on it. Every composite (calendar panels, array
+ * cards, the variable picker) used to keep its own copy of this two-item
+ * list, which is exactly how one of them ends up rendering a solid button
+ * on a blurred card.
+ */
+declare const isGlassSurface: (variant: PlainSurfaceVariant) => boolean;
+/** The panel tone that follows a field: the field keeps its accent as the
+ *  selected-day tint either way, so the fill takes the neutral default. */
+declare const PANEL_TONE_FOR_FIELD: "neutral";
+/**
+ * The field surface a container implies — the reverse pairing: composite
+ * controls whose rows of inputs sit *inside* a card (the `KeyValueArrayField`)
+ * take their inputs' variant from the card so nothing reads as slabs punched
+ * through it (`"auto"`). It is SplitView's search mapping, generalised: boxed
+ * surfaces carry bordered `flat` fields, tinted ones the boxless `ghost`,
+ * glass needs glass, and a plain (cardless) host gives the default field.
+ */
+declare const INPUT_VARIANT_FOR_SURFACE: Record<PlainSurfaceVariant, InputVariant>;
+/**
+ * The tone a surface takes when the caller does not pick one. Every surface
+ * component — `Panel` and its wrappers — resolves to this same constant, so a
+ * default cannot be restated wrongly in one of them.
+ */
+declare const DEFAULT_SURFACE_TONE: TrueColor;
+/**
+ * The `EmptyState` size for a pane that has its own header — a `Panel`
+ * sibling like `PagedPanel` or `TagPanel`. `EmptyState`'s own scale is tuned
+ * for full-page views (its `md` is a text-lg title with an h-12 disc), so
+ * inside a pane the empty/error state must never outgrow the pane's header:
+ * pick it at least two steps under the pane's control size.
+ */
+/**
+ * The expand/retract cascade shared by the kit's unfolding collections —
+ * `ColorSwatches`, `TagPanel`: a left-to-right step per item opening, a
+ * swifter reverse ripple closing, and a hold long enough for the fade to
+ * finish before the condensed geometry commits.
+ */
+declare const CASCADE_EXPAND: {
+    /** Per-item cascade step, expanding. */
+    readonly stepMs: 20;
+    /** Per-item step, retracting — swift, right to left. */
+    readonly retractStepMs: 8;
+    /** How long the expanded layout is held while items step away. */
+    readonly holdMs: 300;
+    /** How long the clip takes to grow. */
+    readonly growMs: 400;
+};
+declare const PANE_EMPTY_STATE_SIZE: Record<ControlSize, ControlSize>;
+declare const getSurfaceCornerClass: (corner: SurfaceCorner) => string;
+declare const getSurfaceCornerRem: (corner: SurfaceCorner) => string;
+/**
+ * Container padding, on the same scale every control uses plus a `none` step,
+ * so a Panel's padding and the Button inside it are described in one language.
+ */
+declare const SURFACE_PADDINGS: readonly ["none", "xs", "sm", "md", "lg", "xl"];
+type SurfacePadding = "none" | ControlSize;
+/**
+ * The header seam. `SideMenu` draws it below its logo block, and `PageHeader`
+ * continues it into the main column; both paint these same classes on their
+ * facing edges, so the horizontal line the user sees crossing the shell is
+ * spelled exactly once. A component that rounded, padded or recoloured past
+ * these would visibly break the seam where the two meet.
+ */
+declare const SIDE_MENU_HEADER_HEIGHT = "h-15";
+declare const SIDE_MENU_HEADER_SEAM = "border-neutral-200 dark:border-neutral-700";
+declare const SIDE_MENU_HEADER_FILL = "bg-white dark:bg-neutral-900";
+/**
+ * The webkit scrollbar paint every native scroller in the kit shares — a thin
+ * rounded thumb on a transparent track. These live here as complete literals
+ * (Tailwind extracts them from this file) so no component re-derives the
+ * recipe and quietly drifts a shade.
+ *
+ * Two tiers, one shade apart:
+ * - `THIN_SCROLLBAR` for card and panel bodies, where the surface itself
+ *   frames the gutter.
+ * - `THIN_SCROLLBAR_FIELD` steps the thumb one shade darker for white
+ *   popovers, inputs and bare scroll regions, where the panel-tier thumb
+ *   disappears against the field.
+ *
+ * Scrollers that also scroll horizontally add their own
+ * `[&::-webkit-scrollbar]:h-*` alongside the constant. `ScrollArea`
+ * deliberately opts out — it hides the native scrollbar and paints its own
+ * overlay thumb.
+ */
+declare const THIN_SCROLLBAR = "[&::-webkit-scrollbar]:w-1.5 [&::-webkit-scrollbar-thumb]:rounded-full [&::-webkit-scrollbar-thumb]:bg-neutral-200 dark:[&::-webkit-scrollbar-thumb]:bg-neutral-700 hover:[&::-webkit-scrollbar-thumb]:bg-neutral-300 dark:hover:[&::-webkit-scrollbar-thumb]:bg-neutral-600 [&::-webkit-scrollbar-track]:bg-transparent";
+declare const THIN_SCROLLBAR_FIELD = "[&::-webkit-scrollbar]:w-1.5 [&::-webkit-scrollbar-thumb]:rounded-full [&::-webkit-scrollbar-thumb]:bg-neutral-300 dark:[&::-webkit-scrollbar-thumb]:bg-neutral-600 hover:[&::-webkit-scrollbar-thumb]:bg-neutral-400 dark:hover:[&::-webkit-scrollbar-thumb]:bg-neutral-500 [&::-webkit-scrollbar-track]:bg-transparent";
+/** The padding a container uses when the caller does not pick one. */
+declare const DEFAULT_SURFACE_PADDING: SurfacePadding;
+declare const getSurfacePaddingClass: (padding: SurfacePadding) => string;
+/** Every padding token but `none`, for the callers that require a real inset. */
+declare const getSurfacePaddingClasses: () => Record<SurfacePadding, string>;
+/**
+ * The tones that read as "no tint". Consumers that tint chrome per tone
+ * (Table's header band, for instance) route these through the neutral
+ * treatment instead of painting a grey-blue header.
+ */
+declare const NEUTRAL_TONES: TrueColor[];
+/**
+ * Cell density for data grids. Deliberately orthogonal to the surface
+ * variant: the variant decides how the container is drawn, the density how
+ * tight the cells inside it sit. A compact table on glass must read the same
+ * as a compact table on an outlined card.
+ */
+declare const TABLE_DENSITIES: readonly ["default", "compact", "minimal"];
+type TableDensity = (typeof TABLE_DENSITIES)[number];
+type TableDensityTokens = {
+    /** Padding + text size for body and header cells. */
+    cell: string;
+    /** Leading cell of a row (overrides `cell`'s left padding). */
+    sideLeft: string;
+    /** Trailing cell of a row (overrides `cell`'s right padding). */
+    sideRight: string;
+    /** Vertical padding inside the cell's inner flex wrapper. */
+    contentVertical: string;
+};
+declare const getTableDensityTokens: (density: TableDensity) => TableDensityTokens;
+/**
+ * Geometry and opacity of the `gradient` variant's glow.
+ *
+ * `pad` is reserved on the control's own wrapper and `inset` positions the glow
+ * inside it, so the halo is drawn **within the control's layout box**. Painting
+ * it outside — the obvious way — means any ancestor with `overflow: auto`
+ * clips it, and `Panel`'s body is `overflow-auto` by default. Same rule as the
+ * inset focus ring.
+ */
+type GlowTokens = {
+    /**
+     * Padding on the wrapper — sized so the shadow's full reach (offset +
+     * spread + blur/2) lands inside the box, where no clipping ancestor can
+     * slice the glow.
+     */
+    pad: string;
+    /** Positions the emitter exactly over the field, inside the pad. */
+    inset: string;
+    /** Shadow blur radius in px. */
+    blur: number;
+    /** Shadow spread in px. */
+    spread: number;
+    /** How far apart the two colour lobes sit, in px — the gradient axis. */
+    offset: number;
+    idleOpacity: number;
+    focusOpacity: number;
+};
+declare const getGlowTokens: (intensity: GlowIntensity) => GlowTokens;
+/**
+ * Glow gradient stops: the tone's 600 and 400 shades, read from Tailwind's own
+ * custom properties rather than a hard-coded hex table.
+ */
+declare const resolveGlowGradient: (tone: TrueColor, from?: string, to?: string) => [string, string];
+/**
+ * Surface treatments for the `SideMenu` container.
+ *
+ * `sidebar` is the kit's standing look (a translucent blur pushed into the
+ * layout), `inset` is a flat panel with a hairline on the content edge,
+ * `floating` is a detached rounded card, `floating-glass` is that card in the
+ * kit's liquid-glass language, and `glass` is the liquid-glass language flush
+ * in the layout — both glass treatments are tinted with the menu's tone. The
+ * rows inside a menu take the matching treatment automatically.
+ */
+declare const SIDEBAR_VARIANTS: readonly ["sidebar", "inset", "floating", "floating-glass", "glass"];
+type SidebarVariant = (typeof SIDEBAR_VARIANTS)[number];
+/**
+ * How a `SideMenu` collapses on desktop.
+ *
+ * `icon` shrinks it to an icon rail, `offcanvas` removes the panel from the
+ * layout entirely (a small handle at the edge opens it again), and `none`
+ * makes the panel non-collapsible.
+ */
+declare const SIDEBAR_COLLAPSIBLE_MODES: readonly ["icon", "offcanvas", "none"];
+type SidebarCollapsible = (typeof SIDEBAR_COLLAPSIBLE_MODES)[number];
+/** Which edge of the layout the `SideMenu` sits on. */
+declare const SIDEBAR_SIDES: readonly ["left", "right"];
+type SidebarSide = (typeof SIDEBAR_SIDES)[number];
+/**
+ * The media query at which a responsive `SideMenu` becomes an offcanvas
+ * overlay (below it) instead of using its desktop collapsible mode (above it).
+ */
+declare const SIDEBAR_MOBILE_QUERY = "(max-width: 1023px)";
+interface SideMenuItemTokens {
+    /** Fill of the active row. */
+    bg: string;
+    /** Copy of the active row. */
+    text: string;
+    /** Wash under the cursor on an idle row. */
+    hoverBg: string;
+    /** Copy of an idle row under the cursor. */
+    hoverText: string;
+    /** Icon of the active row. */
+    iconActive: string;
+    /** Icon of an idle row under the cursor. */
+    iconHover: string;
+}
+declare const getSideMenuItemTokens: (color: TrueColor) => SideMenuItemTokens;
+/**
+ * Resting copy for an idle `SideMenu` row, per surface context.
+ *
+ * A see-through surface composites over unknown content, so the light end of
+ * the neutral scale disappears on it — the same two-step rule as
+ * `getSurfaceTextTokens`.
+ */
+declare const SIDEBAR_IDLE_COPY: {
+    readonly solid: {
+        readonly text: "text-neutral-600 dark:text-neutral-400";
+        readonly icon: "text-neutral-400 dark:text-neutral-500";
+    };
+    readonly glass: {
+        readonly text: "text-neutral-800 dark:text-neutral-100";
+        readonly icon: "text-neutral-600 dark:text-neutral-300";
+    };
+};
+type SidebarIdleCopyKind = keyof typeof SIDEBAR_IDLE_COPY;
+interface SidebarSurfaceTokens {
+    /** Fill and blur of the layer painted behind the content. */
+    fill: string;
+    /**
+     * Opaque counterpart of `fill`, for states where the panel grows over other
+     * content (the hover-rail expansion) and must not show it through. A
+     * translucent `fill` there reads as a second, see-through layer.
+     */
+    solidFill: string;
+    /** Edge treatment. Empty when the panel is flush and borderless. */
+    border: string;
+    /** Which edges carry the border: the content-facing one only, or all. */
+    borderSides: "start" | "all";
+    /** Shadow cast toward the content (left-side panel). */
+    shadow: string;
+    /** Shadow cast toward the content (right-side panel). */
+    shadowRight: string;
+    /** Corner radius. Empty when flush. */
+    radius: string;
+    /** Offset from the layout edges ("" = flush, a margin when detached). */
+    offset: string;
+    /** Whether the row copy needs the see-through contrast step. */
+    idleCopy: SidebarIdleCopyKind;
+    /** Hairline between regions of the panel (dividers, section seams). */
+    divider: string;
+    /** Tertiary copy — section titles, the empty-search note, idle glyphs. */
+    muted: string;
+}
+/**
+ * The container treatment for a `SideMenu` variant. The glass treatments are
+ * resolved from the shared glass module at the call site, so their fill is
+ * tinted with the menu's tone and cannot drift from `Panel`'s glass.
+ * `floating-glass` is the glass treatment with the floating card's geometry
+ * (offset, radius) layered on top.
+ */
+declare const getSidebarSurfaceTokens: (variant: SidebarVariant, color: TrueColor) => SidebarSurfaceTokens;
+/**
+ * The tone of a `Breadcrumb` — what the links turn into under the cursor,
+ * what the current crumb is painted with, and the ring a crumb focuses with.
+ *
+ * The copy pair follows the kit's contrast rule for text on the page
+ * background (the one `Button`'s `link` treatment follows): `-700` light —
+ * measured min 4.93:1 across the 21 tones — and `-300` dark. The old inline
+ * `-600`/`-400` hover pair was the mid-luminance band that whole rule exists
+ * to leave: `{c}-600` on white measured 2.94:1 on yellow.
+ */
+type BreadcrumbToneTokens = {
+    /** Copy of a crumb under the cursor. */
+    hover: string;
+    /** Copy of the crumb that *is* the current page. */
+    current: string;
+    /** Focus ring of a crumb link, including its `focus-visible:` prefix. */
+    focusRing: string;
+};
+declare const getBreadcrumbToneTokens: (color: TrueColor) => BreadcrumbToneTokens;
+/**
+ * Geometry of a `Breadcrumb` at each shared control size.
+ *
+ * Anchored to the control scale — the text step is `getControlSizeTokens`'
+ * at every size — but the chip insets and icons are the compact versions of
+ * those steps, because a crumb is hierarchy copy that happens to be a link,
+ * not a control: the trigger-family paddings would space the trail wider
+ * than the sentence it sits in. Same precedent as the Toast size table.
+ */
+type BreadcrumbSizeTokens = {
+    /** Crumb text size — the control scale's step. */
+    text: string;
+    /** Hit-area inset of the crumb chip. */
+    chip: string;
+    /** Space between a crumb's icon and its label. */
+    gap: string;
+    /** Icon dimensions. */
+    icon: string;
+    /** Separator glyph dimensions. */
+    separator: string;
+};
+declare const getBreadcrumbSizeTokens: (size: ControlSize) => BreadcrumbSizeTokens;
+type ButtonTheme = Record<ButtonVariant, Record<TrueColor, string>>;
+type ButtonHoverTheme = Record<ButtonVariant, Record<TrueColor, string>>;
+type ButtonActiveTheme = Record<ButtonVariant, Record<TrueColor, string>>;
+type ButtonActiveHoverTheme = Record<ButtonVariant, Record<TrueColor, string>>;
+type ToggleTheme = Record<TrueColor, string>;
+type CheckboxTheme = Record<TrueColor, string>;
+type SpinnerTheme = Record<TrueColor, [string, string, string, string]>;
+type LoaderTheme = Record<TrueColor, {
+    track: string;
+    bar: string;
+}>;
+type MultiToggleTheme = Record<TrueColor, {
+    active: string;
+    activeText: string;
+    indicator: string;
+    hover: string;
+}>;
+type MultiToggleVariantTokens = {
+    softIndicator: string;
+    activeText: string;
+    hover: string;
+};
+type MultiToggleVariantTheme = Record<TrueColor, MultiToggleVariantTokens>;
+type TabsColorTokens = {
+    hoverText: string;
+    activeText: string;
+    onAccentText: string;
+    focusRing: string;
+    accentBg: string;
+    subtleBg: string;
+    subtleHoverBg: string;
+    segmentedContainer: string;
+    badgeSubtle: string;
+    badgeStrong: string;
+    badgeOnAccent: string;
+    underlineActive: string;
+};
+type TabsTheme = Record<TrueColor, TabsColorTokens>;
+type PanelToneConfig = {
+    border: string;
+    /**
+     * Hairline for the `outlined` variant. Deliberately lighter than `border`
+     * and paired with a low-alpha dark value, so the outline reads as a hairline
+     * in both modes instead of a hard rule in light mode.
+     */
+    outlineBorder: string;
+    heading: string;
+    muted: string;
+    badge: string;
+    subtleBg: string;
+    tonalBg: string;
+    glassBg: string;
+    glassBorder: string;
+    liquidBg: string;
+    liquidBorder: string;
+    liquidShadow: string;
+    liquidHeading: string;
+    overlayGradient: string;
+    decorationShape: string;
+    decorationGradient: string;
+};
+type PanelTheme = Record<TrueColor, PanelToneConfig>;
+type StepperToneConfig = {
+    activeBg: string;
+    activeText: string;
+    completedBg: string;
+    completedText: string;
+    pendingBorder: string;
+    pendingText: string;
+    underlineBase: string;
+};
+type StepperTheme = Record<TrueColor, StepperToneConfig>;
+type BadgeTheme = Record<TrueColor, string>;
+type PillTheme = Record<TrueColor, Record<"solid" | "soft" | "outline", {
+    base: string;
+    border?: string;
+    hover?: string;
+}>>;
+type AlertTheme = Record<TrueColor, {
+    subtle: string;
+    solid: string;
+    outline: string;
+    icon: string;
+    text: string;
+    border: string;
+    dismiss: string;
+}>;
+type StatTileTheme = Record<TrueColor, {
+    decorationBg: string;
+    iconColor: string;
+    divider: string;
+}>;
+type ButtonSelectorColorTokens = {
+    selectedBorder: string;
+    selectedBg: string;
+    selectedIcon: string;
+    selectedLabel: string;
+    selectedIndicatorBg: string;
+    selectedIndicatorBorder: string;
+    selectedIndicatorDot: string;
+};
+type ButtonSelectorTheme = Record<TrueColor, ButtonSelectorColorTokens>;
+interface ThemeDefinition {
+    button: ButtonTheme;
+    buttonHover: ButtonHoverTheme;
+    buttonActive: ButtonActiveTheme;
+    buttonActiveHover: ButtonActiveHoverTheme;
+    toggle: ToggleTheme;
+    checkbox: CheckboxTheme;
+    spinner: SpinnerTheme;
+    loader: LoaderTheme;
+    multiToggle: MultiToggleTheme;
+    multiToggleVariant: MultiToggleVariantTheme;
+    tabs: TabsTheme;
+    panel: PanelTheme;
+    stepper: StepperTheme;
+    badge: BadgeTheme;
+    pill: PillTheme;
+    alert: AlertTheme;
+    statTile: StatTileTheme;
+    buttonSelector: ButtonSelectorTheme;
+}
+type DeepPartial<T> = {
+    [K in keyof T]?: T[K] extends Record<string, unknown> ? DeepPartial<T[K]> : T[K];
+};
+declare const configureTheme: (overrides: DeepPartial<ThemeDefinition>) => void;
+declare const resetTheme: () => void;
+declare const getButtonColorClasses: (variant: ButtonVariant, color: TrueColor) => string;
+declare const getButtonHoverClasses: (variant: ButtonVariant, color: TrueColor) => string;
+declare const getButtonActiveClasses: (variant: ButtonVariant, color: TrueColor) => string;
+declare const getButtonActiveHoverClasses: (variant: ButtonVariant, color: TrueColor) => string;
+declare const getButtonBaseClasses: (variant: ButtonVariant, color: TrueColor) => string;
+/**
+ * The `ButtonVariant`s that read as a slider.
+ *
+ * `link` and `clear` are text treatments — a slider has no text to treat —
+ * and `icon` is a square affordance, so all three are excluded rather than
+ * aliased onto something else. What remains covers the full range a track
+ * can express: a saturated fill, a tinted one, a bordered wash, a quiet
+ * translucent one and a frosted one.
+ */
+declare const SLIDER_VARIANTS: readonly ["solid", "soft", "outline", "ghost", "glass"];
+type SliderVariant = (typeof SLIDER_VARIANTS)[number];
+interface SliderVariantTokens {
+    /** Paint for the active track segment, from the start (or min handle) to the value. */
+    fill: string;
+    /** Border of the handle. */
+    handle: string;
+    /** The handle's focus-ring colour, including its `focus-visible:` prefix. */
+    ring: string;
+}
+/**
+ * Slider treatments — the same visual language `Button` uses, mapped onto a
+ * slider's two paintable surfaces (the track segment and the handle) so a
+ * slider dropped next to a button row reads as part of the same UI.
+ */
+declare const getSliderVariantTokens: (color: TrueColor, variant: SliderVariant) => SliderVariantTokens;
+/**
+ * The `ButtonVariant`s that read as a toggle.
+ *
+ * Same rationale as `SLIDER_VARIANTS`: `link` and `clear` are text treatments
+ * a track has nothing to treat, and `icon` is a square affordance. What
+ * remains covers the full range a track can express — a saturated fill, a
+ * tinted one, a bordered wash, a quiet translucent one and a frosted one.
+ */
+declare const TOGGLE_VARIANTS: readonly ["solid", "soft", "outline", "ghost", "glass"];
+type ToggleVariant = (typeof TOGGLE_VARIANTS)[number];
+interface ToggleVariantTokens {
+    /** Paint for the track when the switch is on (carries `peer-checked:`). */
+    track: string;
+    /** The thumb's focus-ring colour, driven off the input's `focus-visible`. */
+    ring: string;
+    /** True when the on-state fill is see-through and sits over unknown content. */
+    translucent: boolean;
+}
+/**
+ * Toggle treatments — the same visual language `Button` and `Slider` use,
+ * mapped onto the toggle's one paintable surface (the on-state track fill) so
+ * a toggle dropped next to a button or slider reads as part of the same UI.
+ *
+ * The off-state track is deliberately identical across variants — the neutral
+ * base — so the on-state fill is what expresses the treatment, exactly as a
+ * slider's neutral track does.
+ *
+ * The `glass` token only carries the frosted fill; the backdrop blur,
+ * vibrancy and specular overlay stay with the component, because they depend
+ * on the `glassOpacity` / `vibrancy` / `specularMode` props. The same numeric
+ * opacity caveat as `getGlassFillClass` applies: only the three presets are
+ * safelisted.
+ */
+declare const getToggleVariantTokens: (color: TrueColor, variant: ToggleVariant, glassOpacity?: GlassOpacity) => ToggleVariantTokens;
+declare const getToggleColorClasses: (color: TrueColor) => string;
+/**
+ * @deprecated Returns `accent-{color}-600`, which only paints a *native*
+ * checkbox — and a native checkbox ignores border, radius and background, so
+ * every other class the control carried was dead. Use
+ * `getCheckboxControlTokens`, which styles a real box.
+ */
+declare const getCheckboxColorClasses: (color: TrueColor) => string;
+interface CheckboxControlTokens {
+    /** Fill and border of the box once checked or indeterminate. */
+    checked: string;
+    /** Focus ring, driven off the sibling input's focus. */
+    ring: string;
+    /** Colour of the tick/dash glyph, which sits on the checked fill. */
+    glyph: string;
+}
+/**
+ * Fills step to `-700` light / `-400` dark rather than the `-600` / `-500` the
+ * native `accent-color` used, for the same reason `Alert`'s solid variant does:
+ * a white glyph on `{color}-600` measures 2.94:1 on yellow and 3.06 on lime,
+ * under even the 3:1 that WCAG asks of a *graphical* object, and on a `-500`
+ * fill it is worse. At `-700` under white and `-400` under `{color}-950` the
+ * worst case across all 21 tones is 4.93:1.
+ */
+interface CheckboxVariantTokens {
+    /** Fill, shadow and backdrop of the resting box. */
+    fill: string;
+    /** Resting border colour. Replaced wholesale by the error state. */
+    border: string;
+    /** Border colour under the cursor. */
+    hover: string;
+    /** True when the box is see-through and sits over unknown content. */
+    translucent: boolean;
+}
+declare const getCheckboxVariantTokens: (variant: InputVariant) => CheckboxVariantTokens;
+/**
+ * The checked/indeterminate fill for the checkbox `glass` variant — Toggle's
+ * glass rule in miniature: the full-chroma 500 step at a translucent alpha
+ * (600 in dark), never the `100` pastel, so the box reads as *tinted glass*
+ * on any surface. The border is deliberately left out: unlike the opaque
+ * variants, glass keeps its frost edge in the on-state and lets the fill
+ * alone carry the tone.
+ */
+declare const getCheckboxGlassCheckedTokens: (color: TrueColor) => string;
+declare const getCheckboxControlTokens: (color: TrueColor) => CheckboxControlTokens;
+declare const getSpinnerColorTokens: (color: TrueColor) => [string, string, string, string];
+/**
+ * The geometry of a `StatusSpinner` at each shared control size.
+ *
+ * The wrapper is the same circle `Spinner` draws at that size, so the two can
+ * sit side by side and line up; the dot and the ring width scale with it.
+ */
+interface StatusSpinnerSizeTokens {
+    /** Outer circle. Matches `Spinner`'s diameter at the same size. */
+    wrapper: string;
+    /** Centre dot. */
+    dot: string;
+    /** Ring border width. */
+    border: string;
+}
+declare const getStatusSpinnerSizeTokens: (size: ControlSize) => StatusSpinnerSizeTokens;
+/**
+ * The paint of a `StatusSpinner` in one tone.
+ *
+ * Generated from `TRUE_COLORS` — there is no hand-written per-colour map to
+ * drift. `dot` is the one class-shaped token (both steps are already in the
+ * generated safelist); the arc and track are CSS colours rather than classes,
+ * because the four border sides carry four different values and a `dark:`
+ * variant cannot reach an inline style. They read the tone's own Tailwind
+ * variable — emitted for all 21 tones — and `color-mix` derives the track and
+ * the glow from it, so a tone can never render as another colour.
+ */
+interface StatusSpinnerToneTokens {
+    /** Centre dot fill. */
+    dot: string;
+    /** The rotating arc, as a CSS colour. */
+    arc: string;
+    /** The idle ring (30% of the tone), as a CSS colour. */
+    track: string;
+    /** The halo around the dot, as a CSS colour. */
+    glow: string;
+}
+declare const getStatusSpinnerToneTokens: (tone: TrueColor) => StatusSpinnerToneTokens;
+/**
+ * The paint of a `ProgressSpinner` in one tone.
+ *
+ * The same generated-from-`TRUE_COLORS` approach as `StatusSpinner`: the arc
+ * reads the tone's own Tailwind variable and `color-mix` derives the idle
+ * track from it, so a tone can never render as another colour. The inline
+ * SVG cannot use `dark:` variants, which is why these are CSS colours rather
+ * than classes.
+ */
+interface ProgressSpinnerToneTokens {
+    /** The moving arc (or the determinate range), as a CSS colour. */
+    arc: string;
+    /** The idle ring (30% of the tone), as a CSS colour. */
+    track: string;
+}
+declare const getProgressSpinnerToneTokens: (tone: TrueColor) => ProgressSpinnerToneTokens;
+declare const getLoaderProgressColors: (color: TrueColor) => {
+    track: string;
+    bar: string;
+};
+declare const getMultiToggleColorTokens: (color: TrueColor) => {
+    active: string;
+    activeText: string;
+    indicator: string;
+    hover: string;
+};
+declare const getMultiToggleVariantTokens: (color: TrueColor) => MultiToggleVariantTokens;
+declare const getTabsColorTokens: (color: TrueColor) => TabsColorTokens;
+/**
+ * Base treatment per surface variant — the shadow, ring, blur and fill that do
+ * not depend on tone.
+ *
+ * Lifted out of `Panel` so any control that draws a *surface* can mirror it
+ * exactly rather than copying the switch. `MultiToggle`'s track is the first
+ * other consumer: a segmented control is a container holding segments, so it
+ * belongs to the same family and has to read identically beside a `Panel`.
+ */
+declare const SURFACE_VARIANT_BASE: Record<SurfaceVariant, string>;
+/**
+ * Rim for the translucent variants. Deliberately tone-independent: a saturated
+ * `{tone}-500` edge fights the backdrop it is meant to sit over, so glass gets
+ * a light rim that reads as a bevel instead of an outline.
+ */
+declare const SURFACE_GLASS_RIM = "border-white/50 dark:border-white/10";
+/** Variants whose surface is see-through. */
+declare const TRANSLUCENT_SURFACE_VARIANTS: readonly SurfaceVariant[];
+interface SurfaceVariantOverrides {
+    /** Replaces the variant's own fill, keeping its shadow and ring. */
+    bgClass?: string;
+    /** Replaces the variant's own rim colour. */
+    borderClass?: string;
+    /** Extra classes folded in for `liquid-glass` (vibrancy, glass fill). */
+    liquidExtras?: string;
+}
+/**
+ * The full class set for a surface variant at a tone — the same combination
+ * `Panel` renders, so a control using this sits flush beside one.
+ */
+declare const getSurfaceVariantClasses: (variant: SurfaceVariant, tone: TrueColor, overrides?: SurfaceVariantOverrides) => string;
+declare const getPanelToneStyles: (tone: TrueColor) => PanelToneConfig;
+declare const getStepperTonePalette: (tone: TrueColor) => StepperToneConfig;
+declare const getBadgeColorClasses: (color: TrueColor) => string;
+declare const getPillColorClasses: (color: TrueColor, variant: "solid" | "soft" | "outline") => {
+    base: string;
+    border?: string;
+    hover?: string;
+};
+/**
+ * @deprecated Use `getAlertVariantTokens(color, variant)`. This bag hands the
+ * same icon/text/dismiss classes to every variant, which is unreadable on
+ * `solid`. Kept so existing call sites keep compiling.
+ */
+declare const getAlertColorClasses: (color: TrueColor) => AlertTheme[TrueColor];
+/**
+ * Alert treatments. `glass` and `liquid-glass` are the same pair `Panel` and
+ * `Pill` offer, so a callout dropped on a glass card no longer has to be the
+ * one opaque slab in the layout.
+ */
+declare const ALERT_VARIANTS: readonly ["subtle", "solid", "outline", "glass", "liquid-glass"];
+type AlertVariant = (typeof ALERT_VARIANTS)[number];
+/**
+ * Where the leading icon sits against the callout's content.
+ *
+ * `top` is the default and the only one that was previously possible: the icon
+ * centres on the *title's* line box, which is what you want for a one- or
+ * two-line callout. `center` centres it against the whole block — right when
+ * the body runs long enough that a top-aligned glyph looks stranded — and
+ * `bottom` pins it to the last line.
+ */
+declare const ALERT_ICON_ALIGNMENTS: readonly ["top", "center", "bottom"];
+type AlertIconAlign = (typeof ALERT_ICON_ALIGNMENTS)[number];
+/**
+ * What the callout *means*, as opposed to what colour it is.
+ *
+ * Both kits' demos have been passing `tone="info"` / `"success"` / `"warning"`
+ * / `"danger"` since tone became a `TrueColor` — none of them are one, so every
+ * such alert fell through to the blue fallback and four "different" tones
+ * rendered identically. The semantics were real and worth keeping; they just
+ * belong in their own prop, which resolves to a tone *and* the right icon *and*
+ * the right live-region politeness.
+ */
+declare const ALERT_INTENTS: readonly ["info", "success", "warning", "danger", "neutral"];
+type AlertIntent = (typeof ALERT_INTENTS)[number];
+interface AlertIntentConfig {
+    tone: TrueColor;
+    /** Registry icon name used when the caller does not supply one. */
+    icon: string;
+    /**
+     * How assistive technology should announce it. `role="alert"` is an
+     * *assertive* live region: it interrupts whatever the user is reading, which
+     * is right for a failure and wrong for a page that merely renders an
+     * informational banner on load.
+     */
+    live: "assertive" | "polite";
+}
+declare const ALERT_INTENT_CONFIG: Record<AlertIntent, AlertIntentConfig>;
+/**
+ * Where a toast viewport sits on the screen — PrimeVue's seven anchor
+ * positions, kept as a runtime list so demos and docs enumerate the same
+ * seven. `center` is the only one without a corner.
+ */
+declare const TOAST_POSITIONS: readonly ["top-left", "top-center", "top-right", "bottom-left", "bottom-center", "bottom-right", "center"];
+type ToastPosition = (typeof TOAST_POSITIONS)[number];
+/**
+ * How the stack reads: `stacked` (the PrimeVue 4.5.5 default — a deck of
+ * collapsed cards that fans out on hover) or `expanded` (always fanned out,
+ * the classic list).
+ */
+declare const TOAST_MODES: readonly ["stacked", "expanded"];
+type ToastMode = (typeof TOAST_MODES)[number];
+declare const DEFAULT_TOAST_POSITION: ToastPosition;
+declare const DEFAULT_TOAST_MODE: ToastMode;
+/** Distance the stack offsets each card (stacked peek and expanded seam). */
+declare const DEFAULT_TOAST_GAP_PX = 12;
+/** How many newest toasts stay visible; older ones wait their turn. */
+declare const DEFAULT_TOAST_LIMIT = 3;
+/**
+ * Kit default — PrimeVue has no default auto-dismiss, and a toast that never
+ * dies is a trap. `life: 0` or `sticky: true` for a persistent message.
+ */
+declare const DEFAULT_TOAST_LIFE_MS = 5000;
+/** Above Modal's 1600: a toast raised while a modal is open sits above it. */
+declare const DEFAULT_TOAST_Z_INDEX = 2000;
+/** PrimeVue's viewport width (18.75rem = 300px). */
+declare const TOAST_DEFAULT_WIDTH = "18.75rem";
+/**
+ * The geometry of a toast card at each shared control size.
+ *
+ * Same reasoning as Alert's size table, promoted to the theme because the
+ * card lives in a different folder than the callout it shares its language
+ * with, and a second size table for the same scale would drift (brief §2).
+ * The close button and the action buttons sit on the trigger family's scale,
+ * so a toast and the Button beside it are described in the same language.
+ */
+interface ToastSizeTokens {
+    /** The card's own padding. */
+    container: string;
+    /** Space between the leading glyph and the copy. */
+    gap: string;
+    /** Title type. */
+    title: string;
+    /** Detail type. */
+    detail: string;
+    /** The intent glyph, on the shared control scale. */
+    icon: ControlSize;
+    /**
+     * Height of the glyph's box: exactly the title's line box, so the glyph
+     * centres on the title's cap height at any size (Alert's calibration).
+     */
+    iconBox: string;
+    /** The close button's square box. */
+    close: string;
+    /** The close glyph's size. */
+    closeIcon: ControlSize;
+    /** The progress bar's height, on the shared scale. */
+    progress: ControlSize;
+    /** The action buttons' size (trigger family). */
+    action: ControlSize;
+    /** Space above the actions row. */
+    actions: string;
+}
+declare const getToastSizeTokens: (size: ControlSize) => ToastSizeTokens;
+/**
+ * Whether a field is reporting a problem.
+ *
+ * One list, because it was six: `INPUT_`, `SELECT_`, `CHECKBOX_` and
+ * `INPUT_GROUP_VALIDATION_STATUSES` each declared it, and `Textarea` and
+ * `FormField` had bare unions exporting no runtime list at all — so their
+ * demos could not enumerate the states they support. Same three strings, six
+ * names: the day one changes, the other five will not.
+ */
+declare const VALIDATION_STATUSES: readonly ["none", "error", "success"];
+type ValidationStatus = (typeof VALIDATION_STATUSES)[number];
+/**
+ * What went wrong with a request, as opposed to what colour to paint it.
+ *
+ * The same reasoning as `ALERT_INTENTS`: a failing call already knows whether
+ * it was refused, throttled, or simply could not be reached, and every caller
+ * translating that into a tone *and* a glyph *and* two strings is how one
+ * screen ends up saying "Connection Error" for a 403. The kind resolves all
+ * four; anything the caller states explicitly still wins.
+ */
+declare const API_ERROR_KINDS: readonly ["unknown", "offline", "server", "forbidden", "notFound", "rateLimited"];
+type ApiErrorKind = (typeof API_ERROR_KINDS)[number];
+interface ApiErrorKindConfig {
+    tone: TrueColor;
+    /** Registry icon name used when the caller does not supply one. */
+    icon: string;
+    title: string;
+    subtitle: string;
+    /**
+     * Whether retrying it stands a chance. A 403 does not get a "Try again"
+     * button by default — offering one for a failure the user cannot clear is
+     * how a dead end starts looking like a bug.
+     */
+    retryable: boolean;
+}
+declare const API_ERROR_KIND_CONFIG: Record<ApiErrorKind, ApiErrorKindConfig>;
+interface AlertVariantTokens {
+    /** Fill plus the callout's base copy colour. */
+    surface: string;
+    /** Border colour. The `border` utility itself is on the base class. */
+    border: string;
+    /** Leading icon. */
+    icon: string;
+    /** Secondary copy under the title. */
+    text: string;
+    /** Dismiss button: rest, hover and focus ring. */
+    dismiss: string;
+}
+/**
+ * Replaces the old flat `getAlertColorClasses` bag, which handed the *same*
+ * `icon`, `text` and `dismiss` classes to every variant. On `solid` — a
+ * `{color}-600` fill — that painted the description `{color}-700` and the icon
+ * `{color}-500`, i.e. a dark tone on a saturated tone of itself. It was
+ * unreadable at every tone and no test could see it.
+ */
+declare const getAlertVariantTokens: (color: TrueColor, variant: AlertVariant) => AlertVariantTokens;
+declare const getStatTileColorClasses: (color: TrueColor) => StatTileTheme[TrueColor];
+
+type IconName = "Accordion" | "Add" | "Apple" | "ArrowChevronLeft" | "ArrowChevronRight" | "ArrowDown" | "ArrowLeft" | "ArrowRight" | "ArrowUp" | "Artifactory" | "Attached" | "Attachment" | "Aws" | "Azure" | "Back" | "Blueprint" | "Bug" | "Cache" | "Calendar" | "CatalogManifest" | "CatalogVersion" | "CentOS" | "ChartLine" | "Chat" | "Check" | "CheckCircle" | "ChevronLeft" | "ChevronRight" | "Claim" | "Claims" | "Clean" | "CleanBrush" | "Clone" | "Close" | "Close1" | "CloudOff" | "Cog" | "Complete" | "Container" | "Copy" | "CopyClipboard" | "Dashboard" | "Database" | "Debian" | "Details" | "Docker" | "DockerCopy" | "Dots" | "DotsVertical" | "Download" | "Drag" | "Edit" | "Equal" | "Error" | "Export" | "EyeClosed" | "EyeOpen" | "Fedora" | "File" | "Folder" | "Globe" | "Group" | "HealthCheck" | "Help" | "Host" | "Idea" | "Image" | "Info" | "Jobs" | "KaliLinux" | "Key" | "KeyManagement" | "LXC" | "LXCOld" | "Library" | "Live" | "Log" | "Login" | "Logout" | "Minio" | "Moon" | "Notification" | "Official" | "Offline" | "OpenApp" | "Orchestrator" | "Parameter" | "Pause" | "Pin" | "Podman" | "PodmanDesktop" | "Praise" | "Pull" | "Push" | "RedHat" | "Refresh" | "RemoteHost" | "ReportFeedback" | "Reset" | "Restart" | "ReverseProxy" | "ReverseProxyCORS" | "ReverseProxyFrom" | "ReverseProxyHTTP" | "ReverseProxyHeadersRequest" | "ReverseProxyHeadersResponse" | "ReverseProxyRoutes" | "ReverseProxyTCP" | "ReverseProxyTLS" | "ReverseProxyTo" | "Revert" | "Revoke" | "Rocket" | "Role" | "Roles" | "Run" | "Save" | "Scale" | "Script" | "Search" | "Send" | "Settings" | "Shop" | "Snapshot" | "Star" | "Stop" | "Sun" | "Suspend" | "Taint" | "ThemeAuto" | "ThemeDark" | "ThemeLight" | "Trash" | "UX" | "Ubuntu" | "Unlock" | "User" | "Users" | "Verified" | "ViewGrid" | "ViewRows" | "VirtualMachine" | "Warning" | "Windows" | (string & {});
+declare const iconRegistry: Record<IconName, React__default.ForwardRefExoticComponent<React__default.SVGProps<SVGSVGElement>>>;
+
+type HelpButtonPlacement = "top" | "bottom" | "left" | "right" | "auto";
+interface HelpButtonProps {
+    /**
+     * Help content to display in the panel.
+     * Pass a `string` to render as Markdown (tables and URLs supported).
+     * Pass a `ReactNode` to render arbitrary JSX directly.
+     */
+    content: string | React__default.ReactNode;
+    /** Optional title shown in the panel header. Defaults to "Help". */
+    title?: React__default.ReactNode;
+    /**
+     * Preferred placement of the floating panel relative to the trigger button.
+     * "auto" (default) picks the side with the most available space.
+     */
+    placement?: HelpButtonPlacement;
+    /** Accent color for the trigger button and the panel header band. @default "sky" */
+    color?: TrueColor;
+    /**
+     * Surface treatment of the floating panel — the shared container family the
+     * `Panel` reference owns, so a help panel and a card beside it read the same.
+     * @default "elevated"
+     */
+    variant?: SurfaceVariant;
+    /** Corner radius of the panel, on the shared container scale. @default "rounded-md" */
+    corner?: SurfaceCorner;
+    /** Size of the trigger icon button, on the shared control scale. @default "xs" */
+    size?: ControlSize;
+    /** Icon for the trigger button. Defaults to "Help". */
+    icon?: IconName;
+    /** Maximum width of the floating panel in px. Defaults to 360. */
+    maxWidth?: number;
+    /**
+     * When true the panel body is a pulsing skeleton shaped like the help copy,
+     * so a slow help fetch does not flash empty text. @default false
+     */
+    loading?: boolean;
+    /** Extra class applied to the root wrapper. */
+    className?: string;
+}
+declare const HelpButton: React__default.FC<HelpButtonProps>;
+
+declare enum CapsuleBlueprintValueType {
+    String = "string",
+    Int = "int",
+    Boolean = "boolean",
+    Select = "select",
+    List = "list",
+    Map = "map"
+}
+interface CapsuleBlueprintParameter {
+    name: string;
+    key: string;
+    description?: string;
+    type?: string;
+    value_type?: CapsuleBlueprintValueType;
+    default?: any;
+    required?: boolean;
+    is_required?: boolean;
+    is_secret?: boolean;
+    options?: any;
+    hint?: string;
+    help?: string;
+    service_name?: string;
+    depends_on?: string[];
+    [key: string]: any;
+}
+
+export { DEFAULT_GLOW_INTENSITY as $, type AlertIntent as A, type ButtonVariant as B, type ControlSize as C, API_ERROR_KIND_CONFIG as D, type AlertIntentConfig as E, type AlertVariantTokens as F, type GlassOpacity as G, type HelpButtonProps as H, type IconName as I, type ApiErrorKindConfig as J, BUTTON_VARIANTS as K, BUTTON_WEIGHTS as L, type BreadcrumbSizeTokens as M, type BreadcrumbToneTokens as N, type Orientation as O, type PlainSurfaceVariant as P, CASCADE_EXPAND as Q, CONTROL_SIZES as R, type SurfaceCorner as S, type TrueColor as T, CapsuleBlueprintValueType as U, type ValidationStatus as V, type CheckboxControlTokens as W, type CheckboxVariantTokens as X, type CollapsibleHelpToneTokens as Y, type ControlSizeTokens as Z, DEFAULT_CONTROL_CORNER as _, type AlertVariant as a, type ToastSizeTokens as a$, DEFAULT_SURFACE_CORNER as a0, DEFAULT_SURFACE_PADDING as a1, DEFAULT_SURFACE_TONE as a2, DEFAULT_TOAST_GAP_PX as a3, DEFAULT_TOAST_LIFE_MS as a4, DEFAULT_TOAST_LIMIT as a5, DEFAULT_TOAST_MODE as a6, DEFAULT_TOAST_POSITION as a7, DEFAULT_TOAST_Z_INDEX as a8, DEFAULT_TRIGGER_CORNER as a9, SURFACE_VARIANTS as aA, SURFACE_CORNERS as aB, SURFACE_GLASS_RIM as aC, SURFACE_PADDINGS as aD, SURFACE_TO_BUTTON_VARIANT as aE, SURFACE_VARIANT_BASE as aF, SURFACE_VARIANT_FOR_FIELD as aG, type SideMenuItemTokens as aH, type SidebarIdleCopyKind as aI, type SidebarSurfaceTokens as aJ, type SliderVariantTokens as aK, type StatusSpinnerSizeTokens as aL, type StatusSpinnerToneTokens as aM, type SurfaceTriggerTokens as aN, type SurfaceVariantOverrides as aO, TABLE_DENSITIES as aP, THIN_SCROLLBAR as aQ, THIN_SCROLLBAR_FIELD as aR, TOAST_DEFAULT_WIDTH as aS, TOAST_MODES as aT, TOAST_POSITIONS as aU, TOGGLE_VARIANTS as aV, TRANSLUCENT_SURFACE_VARIANTS as aW, TRUE_COLORS as aX, TRUE_COLOR_DOT_CLASSES as aY, TRUE_COLOR_TEXT_CLASSES as aZ, type TableDensityTokens as a_, FIELD_SIZE_STYLES as aa, FIELD_STATUS_CLASSES as ab, type FieldSizeTokens as ac, type FieldToneTokens as ad, GLOW_INTENSITIES as ae, type GlowTokens as af, HelpButton as ag, type HelpButtonPlacement as ah, INPUT_VARIANTS as ai, INPUT_VARIANT_FOR_SURFACE as aj, type InputVariantTokens as ak, NEUTRAL_TONES as al, ORIENTATIONS as am, PANEL_TONE_FOR_FIELD as an, PANE_EMPTY_STATE_SIZE as ao, PLAIN_SURFACE_VARIANTS as ap, type ProgressSpinnerToneTokens as aq, SIDEBAR_COLLAPSIBLE_MODES as ar, SIDEBAR_IDLE_COPY as as, SIDEBAR_MOBILE_QUERY as at, SIDEBAR_SIDES as au, SIDEBAR_VARIANTS as av, SIDE_MENU_HEADER_FILL as aw, SIDE_MENU_HEADER_HEIGHT as ax, SIDE_MENU_HEADER_SEAM as ay, SLIDER_VARIANTS as az, type AlertIconAlign as b, type ToggleVariantTokens as b0, VALIDATION_STATUSES as b1, configureTheme as b2, getAlertColorClasses as b3, getAlertVariantTokens as b4, getAppDividerToneTokens as b5, getBadgeColorClasses as b6, getBreadcrumbSizeTokens as b7, getBreadcrumbToneTokens as b8, getButtonActiveClasses as b9, getStatusSpinnerToneTokens as bA, getStepperTonePalette as bB, getSurfaceCornerClass as bC, getSurfaceCornerRem as bD, getSurfacePaddingClass as bE, getSurfacePaddingClasses as bF, getSurfaceTextTokens as bG, getSurfaceTriggerTokens as bH, getSurfaceVariantClasses as bI, getTableDensityTokens as bJ, getTabsColorTokens as bK, getToastSizeTokens as bL, getToggleColorClasses as bM, getToggleVariantTokens as bN, getTrueColorDotClass as bO, getTrueColorTextClass as bP, hasTextColor as bQ, iconRegistry as bR, isGlassSurface as bS, resetTheme as bT, resolveGlowGradient as bU, stripBorderColor as bV, stripTextColor as bW, getButtonActiveHoverClasses as ba, getButtonBaseClasses as bb, getButtonColorClasses as bc, getButtonHoverClasses as bd, getCheckboxColorClasses as be, getCheckboxControlTokens as bf, getCheckboxGlassCheckedTokens as bg, getCheckboxVariantTokens as bh, getCollapsibleHelpToneTokens as bi, getControlSizeTokens as bj, getFieldSizeTokens as bk, getFieldToneTokens as bl, getGlowTokens as bm, getInputVariantTokens as bn, getLoaderProgressColors as bo, getMultiToggleColorTokens as bp, getMultiToggleVariantTokens as bq, getPanelToneStyles as br, getPillColorClasses as bs, getProgressSpinnerToneTokens as bt, getSideMenuItemTokens as bu, getSidebarSurfaceTokens as bv, getSliderVariantTokens as bw, getSpinnerColorTokens as bx, getStatTileColorClasses as by, getStatusSpinnerSizeTokens as bz, type GlassVibrancy as c, type SpecularMode as d, type ButtonWeight as e, type SurfacePadding as f, type SurfaceVariant as g, type GlowIntensity as h, type InputVariant as i, type SliderVariant as j, type ToggleVariant as k, type ToastPosition as l, type ToastMode as m, type Size as n, type SidebarVariant as o, type SidebarSide as p, type SidebarCollapsible as q, type SurfaceTextTokens as r, type TableDensity as s, type ApiErrorKind as t, type CapsuleBlueprintParameter as u, ALERT_ICON_ALIGNMENTS as v, ALERT_INTENTS as w, ALERT_INTENT_CONFIG as x, ALERT_VARIANTS as y, API_ERROR_KINDS as z };