nuvox 0.1.4 → 0.1.6

package/dist/pdf-viewer-CF7o-73J.d.cts

@@ -0,0 +1,1092 @@
+interface ColorScale {
+    50: string;
+    100: string;
+    200: string;
+    300: string;
+    400: string;
+    500: string;
+    600: string;
+    700: string;
+    800: string;
+    900: string;
+}
+interface SemanticColor {
+    light: string;
+    subtle: string;
+    base: string;
+    dark: string;
+    deeper: string;
+}
+interface ThemeTokens {
+    meta: {
+        name: string;
+        label: string;
+        /** Short description of the visual identity — kept out of CSS, used in docs/registry UI. */
+        description: string;
+    };
+    color: {
+        neutral: ColorScale & {
+            0: string;
+            950: string;
+        };
+        success: SemanticColor;
+        danger: SemanticColor;
+        warning: SemanticColor;
+        info: SemanticColor;
+        /** Page/app background, not component surface. */
+        background: string;
+        /** Default component surface (card, input, modal body). */
+        surface: string;
+        /** Elevated surface (popover, dropdown, tooltip). */
+        surfaceRaised: string;
+        border: string;
+        borderFocus: string;
+        text: string;
+        textMuted: string;
+        textInverse: string;
+    };
+    radius: {
+        sm: string;
+        md: string;
+        lg: string;
+        xl: string;
+        "2xl": string;
+        full: string;
+    };
+    spacing: {
+        xs: string;
+        sm: string;
+        md: string;
+        lg: string;
+        xl: string;
+        "2xl": string;
+    };
+    typography: {
+        fontSans: string;
+        fontMono: string;
+        sizeXs: string;
+        sizeSm: string;
+        sizeMd: string;
+        sizeLg: string;
+        sizeXl: string;
+        weightNormal: string;
+        weightMedium: string;
+        weightBold: string;
+        lineHeightTight: string;
+        lineHeightNormal: string;
+    };
+    shadow: {
+        xs: string;
+        sm: string;
+        md: string;
+        lg: string;
+        xl: string;
+        "2xl": string;
+        inner: string;
+    };
+    elevation: {
+        /**
+         * z-index steps — must be consistent across every portal-based
+         * component. Deliberately NOT alphabetical-by-concept order:
+         * `modal` is the LOWEST tier, not the highest. Every portal
+         * target shares one stacking context (usually the end of
+         * `<body>`), so a Select/Combobox/DropdownMenu/Popover opened
+         * from *inside* an open Modal must out-rank the Modal itself
+         * to render above its backdrop instead of being swallowed
+         * behind it. Real order, low to high:
+         * modal < dropdown < popover < tooltip < toast.
+         */
+        dropdown: number;
+        popover: number;
+        modal: number;
+        toast: number;
+        tooltip: number;
+    };
+    motion: {
+        durationFast: string;
+        durationNormal: string;
+        durationSlow: string;
+        easeStandard: string;
+        easeEmphasized: string;
+        /** Set to '0.01ms' by a reduced-motion-aware theme variant if needed. */
+        durationInstant: string;
+    };
+    border: {
+        widthThin: string;
+        widthMedium: string;
+        widthThick: string;
+        style: string;
+    };
+    effects: {
+        /**
+         * CSS `backdrop-filter: blur()` amount, e.g. "16px" or "0px".
+         * Every non-glass theme sets this to "0px" — an explicit zero,
+         * not an absent field, so `defineTheme`'s completeness check
+         * still catches an accidentally-forgotten theme. Translucent
+         * `color.surface`/`color.border` values (glass, dark-glass) are
+         * only actually visible as "glass" when something behind them
+         * is blurred; without this, a translucent white surface over a
+         * plain page background is indistinguishable from opaque white.
+         */
+        backdropBlur: string;
+    };
+}
+/**
+ * Identity function with a strict parameter type.
+ * Its only job is to make an incomplete theme a compile error
+ * at the call site, with TypeScript naming the exact missing key.
+ */
+declare function defineTheme(tokens: ThemeTokens): ThemeTokens;
+/** Every top-level and nested key path, used by the completeness test. */
+declare const TOKEN_CATEGORIES: readonly ["meta", "color", "radius", "spacing", "typography", "shadow", "elevation", "motion", "border", "effects"];
+/**
+ * Every required leaf path, hardcoded independently of any
+ * theme instance. This is deliberately NOT derived from
+ * whichever theme happens to register first — that would make
+ * the very first theme registered the unverified "trust me"
+ * reference. Every path listed here corresponds 1:1 to a field
+ * in ThemeTokens; if you add a field to the contract, add its
+ * path here too (a mismatch here is caught by
+ * registry.test.ts's cross-check against `light`).
+ */
+declare const REQUIRED_TOKEN_PATHS: readonly ["meta.name", "meta.label", "meta.description", ...string[], "color.background", "color.surface", "color.surfaceRaised", "color.border", "color.borderFocus", "color.text", "color.textMuted", "color.textInverse", "radius.sm", "radius.md", "radius.lg", "radius.xl", "radius.2xl", "radius.full", "spacing.xs", "spacing.sm", "spacing.md", "spacing.lg", "spacing.xl", "spacing.2xl", "typography.fontSans", "typography.fontMono", "typography.sizeXs", "typography.sizeSm", "typography.sizeMd", "typography.sizeLg", "typography.sizeXl", "typography.weightNormal", "typography.weightMedium", "typography.weightBold", "typography.lineHeightTight", "typography.lineHeightNormal", "shadow.xs", "shadow.sm", "shadow.md", "shadow.lg", "shadow.xl", "shadow.2xl", "shadow.inner", "elevation.dropdown", "elevation.popover", "elevation.modal", "elevation.toast", "elevation.tooltip", "motion.durationFast", "motion.durationNormal", "motion.durationSlow", "motion.easeStandard", "motion.easeEmphasized", "motion.durationInstant", "border.widthThin", "border.widthMedium", "border.widthThick", "border.style", "effects.backdropBlur"];
+/** Returns every required path that is missing or empty on the given theme-like object. */
+declare function findMissingTokenPaths(theme: unknown): string[];
+
+interface AccentDefinition {
+    name: string;
+    label: string;
+    scale: ColorScale;
+}
+declare function registerAccent(def: AccentDefinition): void;
+declare function getAccent(name: string): AccentDefinition | undefined;
+declare function listAccents(): AccentDefinition[];
+declare const DEFAULT_ACCENT = "indigo";
+
+type Size = "xs" | "sm" | "md" | "lg" | "xl";
+/**
+ * Every component accepts these. `theme` and `color` are two
+ * independent axes: `theme` overrides shape (radius, shadow,
+ * motion, glass/gradient/glow — see NuvoxProvider/withThemeOverride),
+ * `color` overrides brand accent only (see accents.ts/withAccentOverride)
+ * and touches nothing structural. A component can use either, both,
+ * or neither without the other being implied.
+ */
+interface BaseComponentProps {
+    className?: string;
+    style?: React.CSSProperties;
+    /** Component-level theme (shape) override. */
+    theme?: string;
+    /** Component-level accent (brand color) override. */
+    color?: string;
+}
+type Variant = "solid" | "outline" | "ghost" | "soft";
+
+interface FieldProps {
+    disabled?: boolean;
+    required?: boolean;
+    /** Whether the field is in an invalid/error state. */
+    error?: boolean;
+    size?: Size;
+}
+interface FieldState {
+    isDisabled: boolean;
+    isRequired: boolean;
+    isInvalid: boolean;
+    size: Size;
+}
+
+interface RatingCoreProps {
+    /** Number of stars. Default 5. */
+    max?: number;
+    /** Allow half-star increments (0.5 steps) instead of whole stars only. Default false. */
+    allowHalf?: boolean;
+    disabled?: boolean;
+    /** Displays the current value but blocks changing it — distinct from `disabled` (still focusable/announced, just not editable). Default false. */
+    readOnly?: boolean;
+    size?: Size;
+}
+type StarFill = "empty" | "half" | "full";
+
+type OTPInputType = "numeric" | "alphanumeric";
+interface OTPInputCoreProps extends FieldProps {
+    /** Number of boxes. Default 6. */
+    length?: number;
+    /** Which characters are accepted. Default "numeric". */
+    type?: OTPInputType;
+    /** Renders each filled box as a dot instead of the character — the "Pin Input" variant of this same component. Default false. */
+    mask?: boolean;
+}
+
+type Placement = "top" | "bottom" | "left" | "right";
+type Alignment = "start" | "center" | "end";
+
+interface SelectOptionItem {
+    value: string;
+    label: string;
+    /**
+     * Optional shorter label for the closed trigger only. Falls back
+     * to `label` when omitted. Exists for cases like PhoneInput's
+     * country select, where the listbox row needs more context
+     * ("🇺🇸 US +1") than the narrow, fixed-width trigger has room for
+     * — rather than forcing one string to serve both and either
+     * cramping the trigger or truncating it.
+     */
+    triggerLabel?: string;
+    disabled?: boolean;
+}
+interface SelectCoreProps extends FieldProps {
+    placement?: Placement;
+    align?: Alignment;
+}
+
+interface PhoneCountry {
+    iso2: string;
+    name: string;
+    /** Digits only, no "+". */
+    dialCode: string;
+    /** Emoji flag — zero-dependency, no icon/image asset needed. */
+    flag: string;
+}
+interface PhoneInputCoreProps extends FieldProps {
+    /** Overrides DEFAULT_COUNTRIES with a consumer-supplied list. */
+    countries?: PhoneCountry[];
+    /** ISO 3166-1 alpha-2 code to preselect when the value has no recognizable dial code yet. Default "US". */
+    defaultCountry?: string;
+}
+
+type BadgeVariant = "solid" | "outline" | "soft";
+interface BadgeCoreProps {
+    variant?: BadgeVariant;
+    size?: Size;
+    /** Renders a small status dot instead of any label/count content. */
+    dot?: boolean;
+    /** Numeric count — 999+ caps display, same convention as the old codebase. */
+    count?: number;
+    /** Derived by the React layer from whether onDismiss was passed, not set directly. */
+    dismissible?: boolean;
+    hasIconLeft?: boolean;
+    hasIconRight?: boolean;
+}
+
+type AvatarSize = Size | "2xl";
+type AvatarShape = "circle" | "square";
+type AvatarStatus = "online" | "offline" | "away" | "busy";
+interface AvatarCoreProps {
+    size?: AvatarSize;
+    shape?: AvatarShape;
+    status?: AvatarStatus;
+    /** Derived by the React layer (image present and not errored), not set directly. */
+    hasImage?: boolean;
+    /** Derived by the React layer from whether an onClick was passed. */
+    isClickable?: boolean;
+}
+
+type SpinnerVariant = "ring" | "dots" | "bars" | "pulse" | "dual-ring" | "ripple" | "orbit" | "bounce" | "conic" | "buffer" | "linear" | "heartbeat" | "infinity" | "hourglass" | "pinwheel" | "radar" | "wave" | "helix" | "atom" | "comet" | "gauge" | "stack" | "spiral" | "burst" | "eclipse" | "petal" | "sine" | "gear" | "pendulum" | "dancer";
+interface SpinnerCoreProps {
+    size?: Size;
+    variant?: SpinnerVariant;
+    /** Accessible label — defaults to "Loading" if not given. */
+    label?: string;
+}
+
+type DividerOrientation = "horizontal" | "vertical";
+interface DividerCoreProps {
+    orientation?: DividerOrientation;
+    /** Derived by the React layer from whether label content was passed. */
+    hasLabel?: boolean;
+}
+
+type CardVariant = "elevated" | "outlined" | "flat" | "filled";
+type CardPadding = "none" | "sm" | "md" | "lg";
+/** vertical: media stacked above/below content (default). horizontal: media beside content, fixed-width. */
+type CardLayout = "vertical" | "horizontal";
+interface CardCoreProps {
+    variant?: CardVariant;
+    padding?: CardPadding;
+    layout?: CardLayout;
+    /** Renders header/footer/badge/children on top of media with a gradient scrim, instead of stacked below it. */
+    overlay?: boolean;
+    disabled?: boolean;
+    /** Derived by the React layer from whether onClick was passed. */
+    isClickable?: boolean;
+}
+
+type ScrollAreaOrientation = "vertical" | "horizontal" | "both";
+/**
+ * - "always": the scrollbar is permanently visible.
+ * - "hover": fades in while the pointer is over the scroll area (or a
+ *   thumb is being dragged), fades out otherwise — the common desktop
+ *   app convention.
+ * - "auto": fades in only while actively scrolling (wheel, touch, or
+ *   thumb drag) and fades out shortly after activity stops — the
+ *   common OS convention (e.g. macOS "Show scroll bars: When
+ *   scrolling").
+ * - "never": no custom scrollbar is rendered at all. This is the
+ *   "hide the scrollbar entirely" option — content still scrolls by
+ *   every other means, it's just never indicated visually.
+ */
+type ScrollbarVisibility = "always" | "hover" | "auto" | "never";
+/**
+ * The thumb's color is a separate choice from the ambient theme/accent
+ * split every other component follows, because a scrollbar is UI
+ * chrome, not a branded surface — so it defaults to a neutral,
+ * theme-adaptive gray rather than always taking the accent color the
+ * way e.g. Slider's thumb does.
+ * - "neutral" (default): theme-adaptive gray (`--color-textMuted`).
+ * - "accent": the active accent's brand color (`--color-brand-500`,
+ *   same variable Slider's thumb uses), for when a scroll area should
+ *   read as more prominent/branded.
+ * - any other string: used as a literal CSS color value directly —
+ *   an escape hatch for a one-off color that isn't a theme token.
+ */
+type ScrollAreaThumbColor = "neutral" | "accent" | string;
+interface ScrollAreaCoreProps {
+    orientation?: ScrollAreaOrientation;
+    scrollbarVisibility?: ScrollbarVisibility;
+    thumbColor?: ScrollAreaThumbColor;
+}
+
+type AlertVariant = "info" | "success" | "warning" | "danger";
+interface AlertCoreProps {
+    variant?: AlertVariant;
+    /** Derived by the React layer from whether onDismiss was passed. */
+    dismissible?: boolean;
+    /** Derived by the React layer from whether an icon slot was explicitly hidden. */
+    hasIcon?: boolean;
+}
+
+type ModalSize = Size | "full";
+interface ModalCoreProps {
+    size?: ModalSize;
+    /** Clicking the backdrop closes the modal. Default true. */
+    closeOnBackdropClick?: boolean;
+    /** Escape closes the modal. Default true. */
+    closeOnEscape?: boolean;
+    hasTitle?: boolean;
+}
+
+type ToastVariant = "info" | "success" | "warning" | "danger";
+type ToastPosition = "top-left" | "top-center" | "top-right" | "bottom-left" | "bottom-center" | "bottom-right";
+
+/**
+ * A tone, not a shape. Progress deliberately does NOT reuse the
+ * shared `Variant` union ("solid" | "outline" | "ghost" | "soft") —
+ * that describes fill treatment for interactive controls and means
+ * nothing for a meter. What varies here is semantic color, so this
+ * is its own small union, and (per CONTRACT.md Rule 5b) `success`/
+ * `warning`/`danger` are the theme-defined SEMANTIC colors, kept
+ * separate from the brand accent. `brand` is the default and is the
+ * one tone that tracks the accent.
+ */
+type ProgressVariant = "brand" | "success" | "warning" | "danger";
+interface ProgressCoreProps {
+    /** 0..max. Ignored (and the bar animates) when `indeterminate`. */
+    value?: number;
+    /** Upper bound. Default 100. */
+    max?: number;
+    /** Unknown-duration state: an animated bar, no numeric value. */
+    indeterminate?: boolean;
+    size?: Size;
+    variant?: ProgressVariant;
+    /** Render the numeric percent next to the track. Default false. */
+    showValue?: boolean;
+}
+
+/**
+ * Horizontal is the default (a row of tabs above their panels).
+ * Vertical changes two things at once, which is why it's a single
+ * flag and not two: the visual layout AND — per WAI-ARIA — which
+ * arrow keys move between tabs (Up/Down instead of Left/Right).
+ */
+type TabsOrientation = "horizontal" | "vertical";
+/**
+ * "automatic" (the WAI-ARIA default) selects a tab the moment it's
+ * focused via the arrow keys — good for cheap panels. "manual"
+ * moves focus without selecting, requiring Enter/Space to commit —
+ * the right choice when showing a panel is expensive (a network
+ * fetch, a heavy chart) and you don't want every arrow press to
+ * trigger it.
+ */
+type TabsActivationMode = "automatic" | "manual";
+/** Visual treatment of the tab row. Shape only — never encodes color meaning. */
+type TabsVariant = "line" | "soft" | "solid";
+interface TabsCoreProps {
+    orientation?: TabsOrientation;
+    activationMode?: TabsActivationMode;
+    variant?: TabsVariant;
+    size?: Size;
+}
+
+type StepWizardOrientation = "horizontal" | "vertical";
+/** Visual treatment of the step indicator. Shape only — never encodes color meaning (Rule 5b). */
+type StepWizardVariant = "numbered" | "dots" | "progress";
+type StepStatus = "complete" | "current" | "upcoming" | "disabled";
+/**
+ * The minimal shape the core logic needs per step. The React layer's
+ * public `<StepWizardStep>` accepts a `label`/description as JSX
+ * children, which have no meaning here — this module only ever sees
+ * the fields that affect navigation and status math.
+ */
+interface StepWizardStepDef {
+    id: string;
+    disabled?: boolean;
+    /**
+     * Explicit completion override. Left unset (the common case), a
+     * step's completeness is derived purely from its position relative
+     * to the active step (everything before it is done). Set this when
+     * that default is wrong for your flow — e.g. an optional step the
+     * user skipped shouldn't read as "complete" just because the wizard
+     * has moved past it.
+     */
+    completed?: boolean;
+}
+interface StepWizardCoreProps {
+    orientation?: StepWizardOrientation;
+    variant?: StepWizardVariant;
+    size?: Size;
+    /**
+     * When true (default), a step can only be reached by completing the
+     * ones before it: going backward is always allowed, but going
+     * forward is limited to the very next step, unless a later step was
+     * explicitly marked `completed`. Set false for a free-navigation
+     * wizard (e.g. an already-submitted form the user can revisit and
+     * edit any section of).
+     */
+    linear?: boolean;
+}
+
+/**
+ * "single" allows one open section at a time (optionally
+ * `collapsible`, so the open one can be closed to leave all shut).
+ * "multiple" lets any number be open at once. The two modes carry
+ * different value shapes (a string vs. a string[]), which is why
+ * the React props are a discriminated union on this field.
+ */
+type AccordionType = "single" | "multiple";
+interface AccordionCoreProps {
+    size?: Size;
+}
+
+/**
+ * A menu opens below its trigger, left-aligned, by default — the
+ * conventional action-menu placement (unlike Tooltip, which centers
+ * above). Both are passthroughs to core/floating.ts so a consumer
+ * can flip a menu that would collide with the viewport edge; the
+ * positioner also flips automatically when it doesn't fit.
+ */
+interface DropdownCoreProps {
+    size?: Size;
+    placement?: Placement;
+    align?: Alignment;
+}
+/**
+ * Menu items have two visual variants: the default, and a
+ * destructive one ("danger") for actions like Delete. "danger" is a
+ * SEMANTIC color drawn from the separate success/warning/danger
+ * registry (CONTRACT.md Rule 5b) — it is not the theme accent, and
+ * it stays red across every accent so a destructive action never
+ * blends into a brand-colored menu.
+ */
+type DropdownItemVariant = "default" | "danger";
+
+type SliderValue = number | readonly [number, number];
+interface SliderCoreProps {
+    min?: number;
+    max?: number;
+    step?: number;
+    disabled?: boolean;
+    size?: Size;
+}
+
+interface ComboboxOption {
+    value: string;
+    label: string;
+    disabled?: boolean;
+}
+interface ComboboxCoreProps extends FieldProps {
+    placement?: Placement;
+    align?: Alignment;
+    /**
+     * When the typed query matches no option and the field loses
+     * focus or Enter is pressed, this controls what happens to it:
+     * `false` (default) reverts the input back to the last committed
+     * value's label (or clears it if nothing was ever selected) — the
+     * same "you must pick a real option" behavior Select enforces.
+     * `true` commits the typed text itself as the value, letting
+     * Combobox double as a free-text field with suggestions rather
+     * than a strict picker.
+     */
+    allowCustomValue?: boolean;
+}
+
+interface SearchSuggestion {
+    id: string;
+    label: string;
+    disabled?: boolean;
+}
+interface SearchBarCoreProps extends FieldProps {
+    placement?: Placement;
+    align?: Alignment;
+}
+
+type WeekStart = 0 | 1;
+interface CalendarDay {
+    date: Date;
+    /** False for the leading/trailing days from adjacent months that fill out the grid. */
+    isCurrentMonth: boolean;
+    isToday: boolean;
+}
+
+interface DatePickerCoreProps extends FieldProps {
+    min?: Date;
+    max?: Date;
+    /** An extra predicate for one-off disabled dates (holidays, already-booked days) beyond the min/max range. */
+    isDateDisabled?: (date: Date) => boolean;
+    weekStartsOn?: 0 | 1;
+    locale?: string;
+}
+
+/** A time of day, no date attached. `hours` is 0-23 (24-hour, locale-independent internally); `minutes` is 0-59. */
+interface TimeValue {
+    hours: number;
+    minutes: number;
+}
+interface TimePickerCoreProps extends FieldProps {
+    min?: TimeValue;
+    max?: TimeValue;
+    /** 12-hour (AM/PM) vs 24-hour display and parsing. Default true. */
+    use12Hour?: boolean;
+    /** An extra predicate for one-off disabled slots (e.g. already-booked times) beyond min/max. */
+    isTimeDisabled?: (time: TimeValue) => boolean;
+    locale?: string;
+}
+type TimePanelMode = "dial" | "digital";
+
+type ColorPickerVariant = "both" | "presets" | "custom";
+interface ColorPickerCoreProps extends FieldProps {
+    /** Preset swatches offered in the popover, as hex strings. Defaults to DEFAULT_PRESETS. */
+    presets?: string[];
+    /**
+     * Which part(s) of the popover to show. `"both"` (default) is the
+     * preset grid plus the custom saturation/hue panel underneath it.
+     * `"presets"` shows only the grid — a fixed palette with no
+     * arbitrary-color escape hatch. `"custom"` shows only the
+     * saturation/hue panel — no preset shortcuts at all.
+     */
+    variant?: ColorPickerVariant;
+}
+declare const DEFAULT_PRESETS: string[];
+
+type CarouselOrientation = "horizontal" | "vertical";
+interface CarouselCoreProps {
+    /** Wrap past the last slide back to the first (and vice versa). Default false. */
+    loop?: boolean;
+    orientation?: CarouselOrientation;
+    /** Auto-advance on a timer. Default false. */
+    autoPlay?: boolean;
+    /** Milliseconds between auto-advances. Default 5000. */
+    autoPlayInterval?: number;
+    /** Pause the autoplay timer while the pointer is over the carousel. Default true. */
+    pauseOnHover?: boolean;
+}
+
+type TimelineOrientation = "vertical" | "horizontal";
+/** Vertical only — which side of the line each item's content sits on. "alternate" ignores this per-item and flips by list position (even/odd), in CSS. Ignored for horizontal orientation. */
+type TimelineAlign = "start" | "end" | "alternate";
+type TimelineStatus = "default" | "success" | "warning" | "danger" | "info";
+interface TimelineCoreProps {
+    orientation?: TimelineOrientation;
+    align?: TimelineAlign;
+}
+interface TimelineItemCoreProps {
+    status?: TimelineStatus;
+}
+
+type ChatBubbleAlign = "start" | "end";
+type ChatBubbleStatus = "sent" | "delivered" | "read";
+interface ChatBubbleCoreProps {
+    align?: ChatBubbleAlign;
+    variant?: Variant;
+    /** Shows a small pointer on the bubble, on the side that points toward the avatar. Default false — a plain rounded bubble with no pointer is this component's own default look; pass true for the classic speech-bubble tail. */
+    hasTail?: boolean;
+    hasAvatar?: boolean;
+    hasName?: boolean;
+    hasTimestamp?: boolean;
+    status?: ChatBubbleStatus;
+}
+interface ChatBubbleReaction {
+    emoji: string;
+    count: number;
+    /** Whether the current viewer is included in this reaction's count — toggles its active styling. */
+    reactedByMe?: boolean;
+}
+
+type PanelGroupDirection = "horizontal" | "vertical";
+interface PanelConstraints {
+    /** Percent (0-100) of the group's main axis. */
+    minSize: number;
+    /** Percent (0-100) of the group's main axis. */
+    maxSize: number;
+    /** Initial percent, if specified. Panels without one split the remainder evenly. */
+    defaultSize?: number;
+}
+
+interface SidebarCoreProps {
+    size?: Size;
+}
+
+interface SpeedDialCoreProps {
+    size?: Size;
+    /** Which side the actions expand toward from the trigger. Default "top" — the common bottom-corner-FAB convention. */
+    placement?: Placement;
+    align?: Alignment;
+}
+
+interface CommandItem {
+    id: string;
+    label: string;
+    description?: string;
+    /** A short label for the keyboard shortcut, shown but not wired up — the consumer's own global key listener is what actually triggers `onSelect`, this is display only (e.g. "⌘K"). */
+    shortcut?: string;
+    disabled?: boolean;
+    group?: string;
+    /** Extra terms that count toward a match without being shown (e.g. "settings" also matching an item labeled "Preferences"). */
+    keywords?: string[];
+}
+interface CommandGroup {
+    /** `undefined` for items with no `group` set — still a real group (rendered without a header), not dropped. */
+    group: string | undefined;
+    items: CommandItem[];
+}
+
+interface PopoverCoreProps {
+    placement?: Placement;
+    align?: Alignment;
+    /**
+     * Whether the popover behaves like a modal dialog — traps focus
+     * inside (Tab cycles rather than leaving), sets aria-modal, and
+     * is the right choice when the content is itself a small form the
+     * user must finish or dismiss. Default false: a non-modal popup
+     * that still receives real focus and closes on Escape or an
+     * outside click, but doesn't trap Tab — the right default for
+     * lighter content like a menu-adjacent info panel. This is
+     * exactly the axis DatePicker's calendar panel needs to be false
+     * on: focus must be able to move between the Input and the grid
+     * without Tab getting trapped inside just the calendar.
+     */
+    modal?: boolean;
+}
+
+type SkeletonVariant = "text" | "circular" | "rectangular";
+type SkeletonAnimation = "pulse" | "wave" | "shine" | "glow" | "none";
+interface SkeletonCoreProps {
+    variant?: SkeletonVariant;
+    animation?: SkeletonAnimation;
+    /**
+     * Category-A-specific radius override (BUILDING-COMPONENTS.md's
+     * Category A note: "radius as an extra override prop... display
+     * primitives are the case where overriding a single shape
+     * property without a full theme override makes sense"). Only
+     * meaningful for "rectangular" — "circular" always renders fully
+     * round and "text" uses a small fixed radius regardless, the same
+     * way Card's radius prop only affects Card's own corners.
+     */
+    radius?: string;
+}
+
+type PaginationItem = number | "ellipsis";
+interface PaginationCoreProps {
+    totalPages: number;
+    /** How many page numbers show on each side of the current page. Default 1. */
+    siblingCount?: number;
+    /** How many page numbers are always pinned at the start and end. Default 1. */
+    boundaryCount?: number;
+    size?: Size;
+    disabled?: boolean;
+    /** Renders "first page" / "last page" jump buttons. Default false. */
+    showFirstLast?: boolean;
+    /** Renders previous/next buttons. Default true. */
+    showPrevNext?: boolean;
+}
+
+interface BreadcrumbCoreProps {
+    size?: Size;
+}
+type BreadcrumbSlot = number | "ellipsis";
+
+interface FileUploadCoreProps extends FieldProps {
+    /** Same syntax as the native <input accept>: comma-separated extensions (".png"), MIME types ("image/png"), or MIME wildcards ("image/*"). Undefined accepts anything. */
+    accept?: string;
+    multiple?: boolean;
+    /** Files larger than this are rejected. Undefined means no limit. */
+    maxSizeBytes?: number;
+}
+type FileVerdict = "ok" | "type" | "size";
+
+interface TableCoreProps {
+    size?: Size;
+    /** Alternating row background. Default false. */
+    striped?: boolean;
+    /** Borders around every cell, not just horizontal row rules. Default false. */
+    bordered?: boolean;
+    /** Keeps the header visible while the body scrolls — only has something to stick within if an ancestor bounds the table's height (e.g. a wrapping div with max-height). Default false. */
+    stickyHeader?: boolean;
+}
+type SortDirection = "asc" | "desc" | null;
+/** The conventional 3-state cycle a sortable header click steps through: unsorted → asc → desc → unsorted. */
+declare function getNextSortDirection(current: SortDirection): SortDirection;
+type SelectAllState = "none" | "some" | "all";
+/** The tri-state a "select all" header checkbox should show, computed from how many of the total rows are currently selected. */
+declare function getSelectAllState(totalCount: number, selectedCount: number): SelectAllState;
+
+/** Movement (in px) a pointer-down must travel before it commits to a drag — below this, it's treated as a click/tap instead, so interactive content inside a card's children still works. */
+declare const DRAG_START_THRESHOLD_PX = 4;
+interface KanbanCoreProps {
+    /** Tighter column padding/gaps and smaller card chrome. Default false. */
+    compact?: boolean;
+}
+interface KanbanColumnValue {
+    id: string;
+    cardIds: string[];
+}
+interface KanbanBoardValue {
+    columns: KanbanColumnValue[];
+}
+interface KanbanCardLocation {
+    columnId: string;
+    index: number;
+}
+/** Where a card currently sits, or null if it isn't in any column's cardIds — either it hasn't been added to the board value yet, or it was just removed. */
+declare function findCardLocation(value: KanbanBoardValue, cardId: string): KanbanCardLocation | null;
+/**
+ * Pure, immutable removal of a card from wherever it currently sits.
+ * A no-op if the card isn't found. There's no delete UI in KanbanCard
+ * itself — a delete affordance is card CONTENT, same as everything
+ * else `renderCard` returns — this is just the board-state half: call
+ * it, then `onChange` the result the same way a move does.
+ */
+declare function removeCard(value: KanbanBoardValue, cardId: string): KanbanBoardValue;
+interface MoveCardTarget {
+    cardId: string;
+    toColumnId: string;
+    /** Insertion index within the destination column's list, AFTER the card has been removed from wherever it was. Clamped to [0, length]. */
+    toIndex: number;
+}
+/**
+ * Pure, immutable move: removes `cardId` from wherever it currently
+ * sits (same column or a different one — both are just "wherever it
+ * sits" to this function) and inserts it at `toIndex` in
+ * `toColumnId`. A no-op — returns `value` unchanged — if the card or
+ * the destination column can't be found, so a caller doesn't need to
+ * guard every call site itself.
+ */
+declare function moveCard(value: KanbanBoardValue, target: MoveCardTarget): KanbanBoardValue;
+/** The column immediately before (`-1`) or after (`1`) `columnId`, or null at either end. */
+declare function getAdjacentColumnId(value: KanbanBoardValue, columnId: string, direction: 1 | -1): string | null;
+type KeyboardMoveDirection = "up" | "down" | "prev" | "next";
+/**
+ * Given a picked-up card and a keyboard direction, returns the move
+ * it should perform — or null if that direction is a no-op from here
+ * (already first/last in the column, or no adjacent column that way).
+ * `up`/`down` reorder within the current column; `prev`/`next` move
+ * to the adjacent column, keeping the same relative position (clamped
+ * to that column's length) rather than always landing at the top or
+ * bottom.
+ */
+declare function getKeyboardMoveTarget(value: KanbanBoardValue, cardId: string, direction: KeyboardMoveDirection): MoveCardTarget | null;
+interface RectLike {
+    top: number;
+    bottom: number;
+    left: number;
+    right: number;
+}
+/**
+ * Given the pointer's Y position and the rects of the cards currently
+ * rendered in a column (top-to-bottom render order, with the card
+ * being dragged already excluded by the caller), returns the index a
+ * dropped card would land at: before the first card whose vertical
+ * midpoint the pointer is above, or at the end if the pointer is
+ * below all of them.
+ */
+declare function computeDropIndex(pointerY: number, cardRects: RectLike[]): number;
+/** Which column (by id) the pointer is currently over, given each column body's rect — or null if it's outside all of them. */
+declare function computeDropColumn(pointerX: number, pointerY: number, columns: Array<RectLike & {
+    id: string;
+}>): string | null;
+interface MoveColumnTarget {
+    columnId: string;
+    toIndex: number;
+}
+/** Pure, immutable reorder of the columns array itself. A no-op if columnId isn't found. `toIndex` is clamped to [0, columns.length - 1]. */
+declare function moveColumn(value: KanbanBoardValue, target: MoveColumnTarget): KanbanBoardValue;
+/** Pure, immutable removal of a column (and every card in it). A no-op if columnId isn't found. */
+declare function removeColumn(value: KanbanBoardValue, columnId: string): KanbanBoardValue;
+type ColumnKeyboardMoveDirection = "prev" | "next";
+/** Given a picked-up column and a keyboard direction, the move it should perform — or null at either end of the row. */
+declare function getColumnKeyboardMoveTarget(value: KanbanBoardValue, columnId: string, direction: ColumnKeyboardMoveDirection): MoveColumnTarget | null;
+/**
+ * The horizontal counterpart of computeDropIndex: given the pointer's
+ * X position and the rects of the columns currently in the row (left-
+ * to-right render order, with the column being dragged already
+ * excluded by the caller), returns the index it would land at.
+ */
+declare function computeColumnDropIndex(pointerX: number, columnRects: RectLike[]): number;
+
+type DrawerSide = "left" | "right" | "top" | "bottom";
+type DrawerSize = Size | "full";
+interface DrawerCoreProps {
+    /** Which edge the panel slides in from. Default "right". */
+    side?: DrawerSide;
+    /**
+     * For a left/right drawer this is the panel's width; for a
+     * top/bottom drawer it's the panel's height — "size" always means
+     * "how far the panel extends from its edge," regardless of side.
+     */
+    size?: DrawerSize;
+    closeOnBackdropClick?: boolean;
+    closeOnEscape?: boolean;
+    hasTitle?: boolean;
+}
+
+interface ContextMenuCoreProps {
+    size?: Size;
+}
+/** A right-click position, in viewport coordinates. */
+interface MenuPoint {
+    x: number;
+    y: number;
+}
+
+interface CodeToken {
+    type: string;
+    content: string;
+}
+type CodeLine = CodeToken[];
+/**
+ * The shape any tokenizer must satisfy to plug into CodeBlock via its
+ * `highlighter` prop — including `nuvoxHighlight` itself. A consumer
+ * wiring in Shiki/Prism just needs to adapt that engine's output to
+ * this shape once.
+ */
+type HighlightEngine = (code: string, language: string) => CodeLine[];
+/** Human-readable labels for CodeBlock's default header — overridable via the `filename` prop. */
+declare const LANGUAGE_LABELS: Record<string, string>;
+/**
+ * The built-in, zero-dependency highlighter. Unknown languages (and
+ * any grammar that somehow throws on malformed/adversarial input)
+ * degrade to a single unhighlighted "plain" token per line rather
+ * than surfacing an error — see this module's header for why that's
+ * the deliberate scope boundary here rather than expanding grammar
+ * coverage indefinitely.
+ */
+declare const nuvoxHighlight: HighlightEngine;
+
+interface CodeBlockCoreProps {
+    /** The source code to display. */
+    code: string;
+    /** Language name or common alias (e.g. "js", "ts", "sh"). Defaults to "plaintext" (no highlighting). */
+    language?: string;
+    /** Escape hatch — see module comment. Same signature as `nuvoxHighlight`. */
+    highlighter?: HighlightEngine;
+    withLineNumbers?: boolean;
+    /** 1-indexed line numbers to visually highlight. */
+    highlightLines?: number[];
+    /** Wrap long lines instead of horizontal scroll. */
+    wrap?: boolean;
+    size?: Size;
+}
+
+type RichTextMark = "bold" | "italic" | "underline" | "strike" | "code";
+type RichTextBlock = "paragraph" | "h1" | "h2" | "h3" | "blockquote" | "bulletList" | "orderedList";
+type RichTextCommand = RichTextMark | RichTextBlock | "link" | "unlink" | "textColor" | "clearTextColor" | "highlight" | "clearHighlight";
+/**
+ * The interface a rendering engine must satisfy to plug into
+ * `<RichTextEditor engine={...}>` in place of the built-in
+ * contentEditable engine — the escape hatch described in the
+ * project's design discussion. A consumer needing full-schema
+ * editing can hand-write a thin adapter over Tiptap/ProseMirror
+ * satisfying this shape; Nuvox itself never imports either.
+ */
+interface EditorEngine {
+    getHTML(): string;
+    setHTML(html: string): void;
+    exec(command: RichTextCommand, value?: string): void;
+    isActive(command: RichTextCommand): boolean;
+    canUndo(): boolean;
+    canRedo(): boolean;
+    undo(): void;
+    redo(): void;
+}
+/**
+ * The single dispatch point the React layer's `exec()` calls into.
+ * Mutates the DOM under `root` directly and leaves selection in a
+ * sensible place; does NOT itself read the result back out (the
+ * caller reads `root.innerHTML` afterward) or manage history (the
+ * caller decides when a checkpoint is worth recording).
+ */
+declare function execRichTextCommand(root: HTMLElement, command: RichTextCommand, value?: string): void;
+/**
+ * Walks the current selection's ancestor chain (bounded by `root`)
+ * and returns every command that's currently active — what the
+ * toolbar buttons should render as "pressed". Returns an empty set
+ * outside a browser (SSR) rather than throwing.
+ */
+declare function getActiveCommands(root: HTMLElement): Set<RichTextCommand>;
+/**
+ * Strips any tag/attribute not on the allow-list. Uses DOMParser — a
+ * web-platform API, not a React dependency; see this module's header
+ * for why that's still "framework-agnostic core" the same way
+ * core/calendar.ts's use of Intl/Date is. Never throws; returns an
+ * empty string if DOMParser isn't available rather than passing
+ * unsanitized markup through.
+ */
+declare function sanitizeHtml(html: string): string;
+interface RichTextHistory {
+    past: string[];
+    future: string[];
+}
+declare function createHistory(): RichTextHistory;
+/** Records `previousValue` as a checkpoint to return to. Caller decides checkpoint granularity (e.g. word boundaries). */
+declare function pushHistory(history: RichTextHistory, previousValue: string): RichTextHistory;
+declare function undoHistory(history: RichTextHistory, currentValue: string): {
+    history: RichTextHistory;
+    value: string;
+} | null;
+declare function redoHistory(history: RichTextHistory, currentValue: string): {
+    history: RichTextHistory;
+    value: string;
+} | null;
+interface RichTextEditorCoreProps {
+    disabled?: boolean;
+    readOnly?: boolean;
+    placeholder?: string;
+    size?: Size;
+}
+
+type ImageFit = "cover" | "contain" | "fill" | "none" | "scale-down";
+interface ImageCoreProps {
+    fit?: ImageFit;
+    /** Raw CSS aspect-ratio value, e.g. "16/9", "1/1", "4/3". No aspect-ratio lock when omitted — the image sizes naturally. */
+    aspectRatio?: string;
+    /** Raw CSS radius override, same shape as Card/Skeleton's `radius` prop (a CSS value, not an enum). */
+    radius?: string;
+}
+
+interface LightboxCoreProps {
+    /** Wrap past the last image back to the first (and vice versa) with prev/next. Default true — unlike Carousel, a lightbox is normally an unbounded browse, not a bounded set of slides. */
+    loop?: boolean;
+}
+
+type GalleryLayout = "grid" | "masonry" | "justified";
+interface GalleryCoreProps {
+    layout?: GalleryLayout;
+    /** Column count for "grid" and "masonry". Default 3. Ignored by "justified", which fills rows by width instead. */
+    columns?: number;
+    /** CSS gap value between items. Default undefined (falls back to the CSS file's own token default). */
+    gap?: string;
+    /** Target row height in px for "justified". Default 220. */
+    targetRowHeight?: number;
+}
+/** An item with no known dimensions is treated as a 1:1 square — a reasonable default that keeps the row-packing math well-defined rather than throwing on missing data. */
+declare function aspectRatioFromDims(width?: number, height?: number): number;
+interface JustifiedRow {
+    /** Indices into the original items array, in order. */
+    indices: number[];
+    /** Shared row height in px, after scaling to fill the container width. */
+    height: number;
+    /** Each item's rendered width in px, same order/length as `indices`. */
+    widths: number[];
+}
+/**
+ * Classic row-packing: accumulate items into a row at `targetRowHeight`
+ * until the row's natural width (plus gaps) reaches the container
+ * width, then scale the whole row (height and every item's width) by
+ * the ratio needed to make it land exactly on `containerWidth`. The
+ * last row is left at `targetRowHeight`, unscaled, unless it would
+ * need to be scaled DOWN (i.e. it already overflows) — a short final
+ * row of 1-2 images stretched to fill the full width looks broken,
+ * which is the standard justified-gallery convention (Flickr does
+ * the same).
+ */
+declare function computeJustifiedRows(aspectRatios: number[], containerWidth: number, targetRowHeight: number, gap: number): JustifiedRow[];
+
+declare const PLAYBACK_RATES: readonly [0.5, 0.75, 1, 1.25, 1.5, 1.75, 2];
+type PlaybackRate = (typeof PLAYBACK_RATES)[number];
+/** mm:ss, or h:mm:ss once the duration crosses an hour. NaN/Infinity/negative all render as "0:00" rather than "NaN:NaN" — happens routinely before metadata has loaded. */
+declare function formatMediaTime(seconds: number): string;
+/** Seconds each seek-back/seek-forward button press moves by, when the consumer doesn't say otherwise. */
+declare const SKIP_SECONDS = 10;
+/**
+ * The skip amounts that have a dedicated, number-bearing seek icon
+ * (`seek-minus-ten`, `seek-plus-thirty`, ...). Any other amount is
+ * still perfectly valid — it just falls back to the unnumbered
+ * `seek-minus`/`seek-plus` pair, so `skipSeconds={7}` never renders a
+ * button whose icon claims "10".
+ */
+declare const LABELED_SKIP_SECONDS: readonly [5, 10, 15, 30];
+type LabeledSkipSeconds = (typeof LABELED_SKIP_SECONDS)[number];
+/** Whether `seconds` is one of the amounts with a numbered seek icon — the icon lookup in the React layer is a `hasLabeledSkipIcon` check plus a map, so the "which icon" decision stays testable here rather than living only inside JSX. */
+declare function hasLabeledSkipIcon(seconds: number): seconds is LabeledSkipSeconds;
+/** A skip amount is always a positive, finite number of seconds; anything else (0, negative, NaN, Infinity) would render a button that visibly does nothing, so it falls back to the default rather than being honored. Direction comes from which button was pressed, never from the sign of this prop. */
+declare function resolveSkipSeconds(skipSeconds?: number): number;
+interface MediaTransportProps {
+    /** Seconds each seek-back/seek-forward press moves by. Default 10. Positive number; direction comes from the button, not the sign. */
+    skipSeconds?: number;
+    /** Called when the next-track button is pressed. Omit and no next-track button is rendered at all. */
+    onNext?: () => void;
+    /** Called when the previous-track button is pressed. Omit and no previous-track button is rendered at all. */
+    onPrevious?: () => void;
+    /** Whether a next track exists. Default true. False keeps the button in place but disables it. */
+    hasNext?: boolean;
+    /** Whether a previous track exists. Default true. False keeps the button in place but disables it. */
+    hasPrevious?: boolean;
+}
+interface MediaTransportState {
+    skipSeconds: number;
+    showNext: boolean;
+    showPrevious: boolean;
+    nextDisabled: boolean;
+    previousDisabled: boolean;
+}
+declare function resolveMediaTransport(props: MediaTransportProps): MediaTransportState;
+type MediaKeyAction = "toggle-play" | "seek-back" | "seek-forward" | "volume-up" | "volume-down";
+/** Maps a KeyboardEvent.key to the player-wide action it triggers, or null for a key this layer doesn't own. "Spacebar" is IE11/old-Edge's name for the same key " " reports everywhere else. */
+declare function getMediaKeyAction(key: string): MediaKeyAction | null;
+
+interface VideoPlayerCoreProps extends MediaTransportProps {
+    /** Show the built-in control bar over the video. Default true — set false to render a bare, unstyled <video> (e.g. to build fully custom controls against the forwarded ref). */
+    controls?: boolean;
+    /** Rates offered in the playback-speed menu. Default [0.5, 0.75, 1, 1.25, 1.5, 1.75, 2]. */
+    playbackRates?: readonly number[];
+}
+
+interface AudioPlayerCoreProps extends MediaTransportProps {
+    /** Rates offered in the playback-speed menu. Default [0.5, 0.75, 1, 1.25, 1.5, 1.75, 2]. */
+    playbackRates?: readonly number[];
+}
+
+interface PdfViewerCoreProps {
+    /** Page to open on first render. Default 1. */
+    initialPage?: number;
+    /** Zoom level to open at, where 1 = 100%. Left unset, the viewer opens fit-to-width instead of a fixed percentage — see initialScale on PdfViewerState. */
+    initialScale?: number;
+    minScale?: number;
+    maxScale?: number;
+    /** How much each zoom-in/out step changes the scale. Default 0.25. */
+    scaleStep?: number;
+}
+/**
+ * "auto" means fit-to-width (the PDF open-parameters spec's own
+ * `zoom=page-width`) rather than a fixed percentage — it's the
+ * default so a page opens fully visible instead of at a literal 100%
+ * that's wider than the viewer and gets clipped, forcing a manual
+ * zoom-out just to see the page. It only ever applies before the
+ * first zoom interaction: clicking zoom in/out always resolves to a
+ * concrete percentage from there (see zoomIn/zoomOut below), since
+ * "step in/out from fit-to-width" isn't a well-defined percentage.
+ */
+type PdfZoom = number | "auto";
+declare function formatZoomPercent(scale: PdfZoom): string;
+
+export { LANGUAGE_LABELS as $, type AccentDefinition as A, type BadgeVariant as B, type CalendarDay as C, type DropdownItemVariant as D, DEFAULT_PRESETS as E, DRAG_START_THRESHOLD_PX as F, type DatePickerCoreProps as G, type DividerOrientation as H, type DrawerSide as I, type DrawerSize as J, type EditorEngine as K, type FieldProps as L, type FieldState as M, type FileVerdict as N, type GalleryCoreProps as O, type GalleryLayout as P, type HighlightEngine as Q, type ImageCoreProps as R, type ImageFit as S, type ThemeTokens as T, type JustifiedRow as U, type KanbanBoardValue as V, type KanbanCardLocation as W, type KanbanColumnValue as X, type KanbanCoreProps as Y, type KeyboardMoveDirection as Z, LABELED_SKIP_SECONDS as _, type AccordionType as a, type ToastVariant as a$, type LabeledSkipSeconds as a0, type LightboxCoreProps as a1, type MediaKeyAction as a2, type MediaTransportProps as a3, type MediaTransportState as a4, type MenuPoint as a5, type ModalSize as a6, type MoveCardTarget as a7, type MoveColumnTarget as a8, type OTPInputCoreProps as a9, type SemanticColor as aA, type SidebarCoreProps as aB, type Size as aC, type SkeletonAnimation as aD, type SkeletonVariant as aE, type SliderValue as aF, type SortDirection as aG, type SpeedDialCoreProps as aH, type SpinnerVariant as aI, type StarFill as aJ, type StepStatus as aK, type StepWizardOrientation as aL, type StepWizardStepDef as aM, type StepWizardVariant as aN, TOKEN_CATEGORIES as aO, type TableCoreProps as aP, type TabsActivationMode as aQ, type TabsOrientation as aR, type TabsVariant as aS, type TimePickerCoreProps as aT, type TimeValue as aU, type TimelineAlign as aV, type TimelineCoreProps as aW, type TimelineItemCoreProps as aX, type TimelineOrientation as aY, type TimelineStatus as aZ, type ToastPosition as a_, type OTPInputType as aa, PLAYBACK_RATES as ab, type PaginationItem as ac, type PanelConstraints as ad, type PanelGroupDirection as ae, type PdfViewerCoreProps as af, type PhoneCountry as ag, type PhoneInputCoreProps as ah, type Placement as ai, type PlaybackRate as aj, type PopoverCoreProps as ak, type ProgressVariant as al, REQUIRED_TOKEN_PATHS as am, type RatingCoreProps as an, type RectLike as ao, type RichTextBlock as ap, type RichTextCommand as aq, type RichTextEditorCoreProps as ar, type RichTextHistory as as, type RichTextMark as at, SKIP_SECONDS as au, type ScrollAreaOrientation as av, type ScrollbarVisibility as aw, type SearchSuggestion as ax, type SelectAllState as ay, type SelectOptionItem as az, type AlertVariant as b, type Variant as b0, type VideoPlayerCoreProps as b1, type WeekStart as b2, aspectRatioFromDims as b3, computeColumnDropIndex as b4, computeDropColumn as b5, computeDropIndex as b6, computeJustifiedRows as b7, createHistory as b8, defineTheme as b9, undoHistory as bA, type BadgeCoreProps as bB, type AvatarCoreProps as bC, type SpinnerCoreProps as bD, type DividerCoreProps as bE, type CardCoreProps as bF, type ScrollAreaCoreProps as bG, type AlertCoreProps as bH, type ModalCoreProps as bI, type ProgressCoreProps as bJ, type TabsCoreProps as bK, type AccordionCoreProps as bL, type DropdownCoreProps as bM, type SelectCoreProps as bN, type StepWizardCoreProps as bO, type SliderCoreProps as bP, type ComboboxCoreProps as bQ, type SearchBarCoreProps as bR, type TimePanelMode as bS, type ChatBubbleReaction as bT, type FileUploadCoreProps as bU, type PaginationCoreProps as bV, type BreadcrumbCoreProps as bW, type SkeletonCoreProps as bX, type DrawerCoreProps as bY, type ContextMenuCoreProps as bZ, DEFAULT_ACCENT as b_, execRichTextCommand as ba, findCardLocation as bb, findMissingTokenPaths as bc, formatMediaTime as bd, formatZoomPercent as be, getAccent as bf, getActiveCommands as bg, getAdjacentColumnId as bh, getColumnKeyboardMoveTarget as bi, getKeyboardMoveTarget as bj, getMediaKeyAction as bk, getNextSortDirection as bl, getSelectAllState as bm, hasLabeledSkipIcon as bn, listAccents as bo, moveCard as bp, moveColumn as bq, nuvoxHighlight as br, pushHistory as bs, redoHistory as bt, registerAccent as bu, removeCard as bv, removeColumn as bw, resolveMediaTransport as bx, resolveSkipSeconds as by, sanitizeHtml as bz, type Alignment as c, type AudioPlayerCoreProps as d, type AvatarShape as e, type AvatarSize as f, type AvatarStatus as g, type BaseComponentProps as h, type BreadcrumbSlot as i, type CardLayout as j, type CardPadding as k, type CardVariant as l, type CarouselCoreProps as m, type CarouselOrientation as n, type ChatBubbleAlign as o, type ChatBubbleCoreProps as p, type ChatBubbleStatus as q, type CodeBlockCoreProps as r, type CodeLine as s, type CodeToken as t, type ColorPickerCoreProps as u, type ColorScale as v, type ColumnKeyboardMoveDirection as w, type ComboboxOption as x, type CommandGroup as y, type CommandItem as z };