@livestorm/ui-vue 2.0.5 → 4.0.0

package/dist/types/src/components/UiInputRadio/UiInputRadioGroup.vue.d.ts

@@ -0,0 +1,86 @@
+import type { RadioSize, RadioValue } from './types';
+interface UiInputRadioGroupProps {
+    /**
+     * The selected value. `undefined` means no selection;
+     * `null` is a valid option value.
+     */
+    modelValue?: RadioValue;
+    /**
+     * Name attribute, submitted with the form via a hidden input
+     */
+    name?: string;
+    /**
+     * Whether the whole group is disabled
+     * @default false
+     */
+    disabled?: boolean;
+    /**
+     * Whether arrow-key navigation loops from last item to first
+     * @default true
+     */
+    loop?: boolean;
+    /**
+     * Whether a selection is required
+     * @default false
+     */
+    required?: boolean;
+    /**
+     * Whether the group is in an error state
+     * @default false
+     */
+    error?: boolean;
+    /**
+     * Error message displayed below the group
+     */
+    errorMessage?: string;
+    /**
+     * Size of the radio items
+     * @default 'md'
+     */
+    size?: RadioSize;
+    /**
+     * Layout direction of the items. Also sets the group's `aria-orientation`
+     * and the arrow-key navigation axis to match.
+     * @default 'vertical'
+     */
+    orientation?: 'vertical' | 'horizontal';
+    /**
+     * Whether the group stretches to fill its container instead of
+     * shrink-wrapping its items
+     * @default false
+     */
+    fullWidth?: boolean;
+    /**
+     * Id of the element naming the group, set on the radiogroup itself
+     */
+    ariaLabelledby?: string;
+}
+declare var __VLS_9: {};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_9) => any;
+};
+declare const __VLS_base: import("vue").DefineComponent<UiInputRadioGroupProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    "update:modelValue": (value: import("reka-ui").AcceptableValue) => any;
+}, string, import("vue").PublicProps, Readonly<UiInputRadioGroupProps> & Readonly<{
+    "onUpdate:modelValue"?: ((value: import("reka-ui").AcceptableValue) => any) | undefined;
+}>, {
+    orientation: "vertical" | "horizontal";
+    size: RadioSize;
+    disabled: boolean;
+    required: boolean;
+    loop: boolean;
+    error: boolean;
+    name: string;
+    modelValue: RadioValue;
+    fullWidth: boolean;
+    errorMessage: string;
+    ariaLabelledby: string;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/types/src/components/UiInputRadio/types.d.ts

@@ -0,0 +1,19 @@
+import type { InjectionKey, Ref } from 'vue';
+import type { AcceptableValue } from 'reka-ui';
+export type RadioSize = 'sm' | 'md' | 'lg';
+/**
+ * Valid radio option values. `null` is a supported option value;
+ * `undefined` means "no selection". Object values must be reference-stable.
+ */
+export type RadioValue = AcceptableValue;
+export interface RadioGroupContext {
+    /** Current group value (kept in sync in both controlled and uncontrolled mode) */
+    modelValue: Readonly<Ref<RadioValue | undefined>>;
+    error: Readonly<Ref<boolean>>;
+    size: Readonly<Ref<RadioSize>>;
+    orientation: Readonly<Ref<'vertical' | 'horizontal'>>;
+    disabled: Readonly<Ref<boolean>>;
+    /** id of the group error message, for aria-describedby on items */
+    messageId: Readonly<Ref<string | undefined>>;
+}
+export declare const RADIO_GROUP_KEY: InjectionKey<RadioGroupContext>;

package/dist/types/src/components/UiInputSelect/UiInputSelect.vue.d.ts

@@ -44,17 +44,17 @@ declare const __VLS_base: import("vue").DefineComponent<UiInputSelectProps, {},
     defaultOpen: boolean;
     required: boolean;
     error: boolean;
-    loading: boolean;
     name: string;
+    loading: boolean;
     modelValue: string | string[] | null;
     multiple: boolean;
-    placeholder: string;
-    id: string;
     labelInfo: string;
-    helperMessage: string;
     errorMessage: string;
-    clearable: boolean;
+    id: string;
     ariaDescribedby: string;
+    placeholder: string;
+    helperMessage: string;
+    clearable: boolean;
 }, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
 declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
 declare const _default: typeof __VLS_export;

package/dist/types/src/components/UiInputTextarea/UiInputTextarea.vue.d.ts

@@ -22,16 +22,16 @@ declare const __VLS_export: import("vue").DefineComponent<UiInputTextareaProps,
     focus: () => void | undefined;
     blur: () => void | undefined;
 }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    keydown: (event: KeyboardEvent) => any;
     "update:modelValue": (value: string) => any;
-    blur: (event: FocusEvent) => any;
     focus: (event: FocusEvent) => any;
-    keydown: (event: KeyboardEvent) => any;
+    blur: (event: FocusEvent) => any;
     keyup: (event: KeyboardEvent) => any;
 }, string, import("vue").PublicProps, Readonly<UiInputTextareaProps> & Readonly<{
+    onKeydown?: ((event: KeyboardEvent) => any) | undefined;
     "onUpdate:modelValue"?: ((value: string) => any) | undefined;
-    onBlur?: ((event: FocusEvent) => any) | undefined;
     onFocus?: ((event: FocusEvent) => any) | undefined;
-    onKeydown?: ((event: KeyboardEvent) => any) | undefined;
+    onBlur?: ((event: FocusEvent) => any) | undefined;
     onKeyup?: ((event: KeyboardEvent) => any) | undefined;
 }>, {
     size: TextareaSize;
@@ -40,8 +40,8 @@ declare const __VLS_export: import("vue").DefineComponent<UiInputTextareaProps,
     error: boolean;
     loading: boolean;
     modelValue: string;
-    placeholder: string;
     ariaDescribedby: string;
+    placeholder: string;
     rows: number;
     resizable: boolean;
 }, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;

package/dist/types/src/components/UiListItem/UiListItem.vue.d.ts

@@ -13,18 +13,32 @@ type __VLS_Props = {
     additionalInfo?: string;
     to?: RouteLocationRaw;
     href?: string;
+    /**
+     * Aligns the content with the container edge; the hover and active fill bleeds past it without widening the row
+     */
+    flush?: boolean;
+    /**
+     * Aligns the content with the list's top and bottom edges: the row drops its vertical padding and minimum height,
+     * and the hover and active fill bleeds 0.25rem above and below. It is designed for rows spaced 0.5rem (8px) apart,
+     * where the fill reaches the middle of the gap and never covers the neighbour row
+     */
+    flushVertical?: boolean;
+    /**
+     * 'comfortable' adds vertical padding, for rows holding several lines beside an avatar
+     */
+    density?: 'compact' | 'comfortable';
 };
-declare var __VLS_1: {}, __VLS_3: {}, __VLS_5: {}, __VLS_7: {};
+declare var __VLS_1: {}, __VLS_3: {}, __VLS_5: {};
 type __VLS_Slots = {} & {
     avatar?: (props: typeof __VLS_1) => any;
 } & {
     default?: (props: typeof __VLS_3) => any;
 } & {
     aside?: (props: typeof __VLS_5) => any;
-} & {
-    default?: (props: typeof __VLS_7) => any;
 };
-declare const __VLS_base: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const __VLS_base: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {
+    density: "compact" | "comfortable";
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
 declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
 declare const _default: typeof __VLS_export;
 export default _default;

package/dist/types/src/components/UiLoader/UiLoader.vue.d.ts

@@ -1,17 +1,18 @@
+import { type Size } from '../../constants';
 declare const __VLS_export: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
     size: {
-        type: StringConstructor;
+        type: () => Size;
         default: string;
-        validator: (value: string) => boolean;
+        validator: (value: Size) => boolean;
     };
 }>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
     size: {
-        type: StringConstructor;
+        type: () => Size;
         default: string;
-        validator: (value: string) => boolean;
+        validator: (value: Size) => boolean;
     };
 }>> & Readonly<{}>, {
-    size: string;
+    size: "xs" | "sm" | "md" | "lg";
 }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
 declare const _default: typeof __VLS_export;
 export default _default;

package/dist/types/src/components/UiLoader/UiSpinnerIcon.vue.d.ts

@@ -0,0 +1,3 @@
+declare const __VLS_export: import("vue").DefineComponent<{}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/types/src/components/UiLogo/UiLogo.vue.d.ts

@@ -5,14 +5,20 @@ interface Props {
     width: number;
     /** Follow the brand palette (--color-brand-800) instead of the Livestorm navy. */
     themed?: boolean;
-    /** Dark badge + white mark, for light backgrounds. */
-    inverted?: boolean;
+    /**
+     * Dark badge + white mark, for light backgrounds. `"auto"` inverts
+     * whenever the logo sits inside a light `data-colors-semantic` scope.
+     */
+    inverted?: boolean | "auto";
     /** When false, renders the static logo (the resting pose). */
     animated?: boolean;
+    /** Accessible name announced for the logo. */
+    label?: string;
 }
 declare const __VLS_export: import("vue").DefineComponent<Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<Props> & Readonly<{}>, {
+    label: string;
     variant: UiLogoVariant;
-    inverted: boolean;
+    inverted: boolean | "auto";
     themed: boolean;
     animated: boolean;
 }, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;

package/dist/types/src/components/UiMenu/UiMenuContent.vue.d.ts

@@ -1,21 +1,34 @@
 import type { DropdownMenuContentProps } from 'reka-ui';
+declare const WIDTH_CLASSES: {
+    readonly auto: "";
+    readonly sm: "min-w-48";
+    readonly md: "min-w-56";
+};
+interface Props extends DropdownMenuContentProps {
+    /**
+     * 'auto' sizes the menu to its items; 'sm' and 'md' set a 192px and 224px minimum, and longer items still widen it
+     * @default 'auto'
+     */
+    width?: keyof typeof WIDTH_CLASSES;
+}
 declare var __VLS_14: {};
 type __VLS_Slots = {} & {
     default?: (props: typeof __VLS_14) => any;
 };
-declare const __VLS_base: import("vue").DefineComponent<DropdownMenuContentProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+declare const __VLS_base: import("vue").DefineComponent<Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
     escapeKeyDown: (event: KeyboardEvent) => any;
     pointerDownOutside: (event: import("reka-ui").PointerDownOutsideEvent) => any;
     focusOutside: (event: import("reka-ui").FocusOutsideEvent) => any;
     interactOutside: (event: import("reka-ui").PointerDownOutsideEvent | import("reka-ui").FocusOutsideEvent) => any;
     closeAutoFocus: (event: Event) => any;
-}, string, import("vue").PublicProps, Readonly<DropdownMenuContentProps> & Readonly<{
+}, string, import("vue").PublicProps, Readonly<Props> & Readonly<{
     onEscapeKeyDown?: ((event: KeyboardEvent) => any) | undefined;
     onPointerDownOutside?: ((event: import("reka-ui").PointerDownOutsideEvent) => any) | undefined;
     onFocusOutside?: ((event: import("reka-ui").FocusOutsideEvent) => any) | undefined;
     onInteractOutside?: ((event: import("reka-ui").PointerDownOutsideEvent | import("reka-ui").FocusOutsideEvent) => any) | undefined;
     onCloseAutoFocus?: ((event: Event) => any) | undefined;
 }>, {
+    width: keyof typeof WIDTH_CLASSES;
     side: "top" | "right" | "bottom" | "left";
     sideOffset: number;
     align: "center" | "start" | "end";

package/dist/types/src/components/UiMenu/UiMenuItem.vue.d.ts

@@ -1,13 +1,19 @@
 import type { DropdownMenuItemProps } from 'reka-ui';
+export interface UiMenuItemProps extends DropdownMenuItemProps {
+    /** `danger` marks a destructive action such as Remove or Delete. */
+    variant?: 'default' | 'danger';
+}
 declare var __VLS_8: {};
 type __VLS_Slots = {} & {
     default?: (props: typeof __VLS_8) => any;
 };
-declare const __VLS_base: import("vue").DefineComponent<DropdownMenuItemProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+declare const __VLS_base: import("vue").DefineComponent<UiMenuItemProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
     select: (event: Event) => any;
-}, string, import("vue").PublicProps, Readonly<DropdownMenuItemProps> & Readonly<{
+}, string, import("vue").PublicProps, Readonly<UiMenuItemProps> & Readonly<{
     onSelect?: ((event: Event) => any) | undefined;
-}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+}>, {
+    variant: "default" | "danger";
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
 declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
 declare const _default: typeof __VLS_export;
 export default _default;

package/dist/types/src/components/UiNestedOptions/UiNestedOptions.vue.d.ts

@@ -0,0 +1,13 @@
+declare var __VLS_1: {};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_1) => any;
+};
+declare const __VLS_base: import("vue").DefineComponent<{}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/types/src/components/UiPage/UiPage.vue.d.ts

@@ -1,23 +1,115 @@
 import { type Slot } from 'vue';
+/**
+ * Headroom sizes, in px: the gap above the content card that lets the shell
+ * background show through. One map so the page frame has a single source of
+ * truth — retune here rather than at call sites.
+ */
+declare const HEADROOM_GAP_PX: {
+    readonly none: 0;
+    readonly sm: 4;
+    readonly md: 10;
+    readonly lg: 16;
+    readonly xl: 24;
+};
+type HeadroomGap = keyof typeof HEADROOM_GAP_PX;
 type __VLS_Props = {
-    /**
-     * Extra classes for the inner content `<section>`. Use to override the
-     * default surface, e.g. `bg-surface-neutral-300` instead of the standard
-     * `bg-surface-neutral-bg-main`. Appended after the defaults so it wins on
-     * conflicting utilities.
-     */
-    pageContentClasses?: string;
     /**
      * Page title surfaced as the label of UiShell's fallback mobile menu topbar
      * (shown on a headerless page that has a side menu). Lets a page name its
      * menu row — e.g. "Home" — without reaching into useMobileMenu directly.
      */
     title?: string;
+    /**
+     * The shape of the page inside the content card. Padded shapes use the
+     * page padding P (16px below md, 24px from md), which the page exposes to
+     * its content as `var(--ui-page-padding)`. P applies inside the card only:
+     * the page header and the tabs above it keep their own spacing.
+     * - `document` (default): the card scrolls as a single column and pads
+     *   its content with P on every side. Forms, settings, content blocks.
+     * - `list`: like `document`, but the content is padded with P at the top
+     *   only: toolbars, tables and pagination run from card edge to card edge
+     *   and pad their sides with `--ui-page-inline`. The content is held to the
+     *   card height, so a child that may shrink (`flex-1 min-h-0`) becomes the
+     *   scroll region and a table header in it stays in view; anything taller
+     *   still scrolls the card.
+     * - `app`: the card fills the available height and never scrolls itself;
+     *   the page owns its scroll regions and layout, so the content is not
+     *   padded. Each region pads itself with `var(--ui-page-padding)`.
+     *
+     * Edge-to-edge bands (toolbars, pagination) read `--ui-page-inline` for
+     * their side padding. UiDataTable pads its scroll region with it, so a
+     * wide table scrolls from card edge to card edge. It is set to P on a
+     * `list` page only and left unset everywhere else, so a band
+     * picks its inset with one class:
+     * - `px-(--ui-page-inline)`: P on a list page, 0 elsewhere.
+     * - `px-(--ui-page-inline,var(--spacing-space-4))`: P on a list page, the
+     *   band's own inset elsewhere.
+     *
+     * A page with a `leftSlot` keeps the split layout insets instead of P: its
+     * header slot aligns with the aside, not with the content.
+     */
+    variant?: 'document' | 'list' | 'app';
+    /**
+     * Column split when a leftSlot is present: `third` (default) gives the
+     * aside 1/3 and the card 2/3; `half` splits them evenly; `fill` lets the
+     * aside take all remaining width while the card hugs its content — for
+     * app pages whose card is a fixed-width side panel (e.g. the room's
+     * interactions sidepane).
+     */
+    leftSlotRatio?: 'third' | 'half' | 'fill';
+    /**
+     * How the content card sits in the frame.
+     * - `anchored` (default): the dashboard page card — flush to the bottom and
+     *   right edges, rounded top-left, page-card chrome (level-3 elevation).
+     * - `floating`: a detached card with a thin gutter on every side, rounded
+     *   all around, elevated-card chrome (level-2 elevation + inner glow +
+     *   container border). The room's panel treatment.
+     */
+    frame?: 'anchored' | 'floating';
+    /**
+     * Viewport gate for the leftSlot: `lg` (default) renders the aside only
+     * from the lg breakpoint — the dashboard behavior, where the aside is
+     * secondary. `none` keeps the aside at every width, for app pages whose
+     * aside is primary content (the room's stage, the lobby's session
+     * information) and must never unmount with the viewport.
+     */
+    leftSlotBreakpoint?: 'lg' | 'none';
+    /**
+     * Headroom above the content card, letting the shell background show
+     * through. Sizes map to px via `HEADROOM_GAP_PX`.
+     *
+     * Left unset, the card gets `DEFAULT_HEADROOM_GAP` only when it sits flush
+     * at the top — i.e. there is no page header or left slot already offsetting
+     * it. Naming a size applies it in either case, and `none` removes the gap
+     * on a page that would otherwise get the default.
+     */
+    headroomGap?: HeadroomGap;
+    /**
+     * Drops the content padding a `document` or `list` page gets by default, so the
+     * page's content reaches the card edges. Only for pages whose layout is
+     * edge-to-edge by design: full-bleed bands, or scroll regions that must
+     * sit against the card edge. Has no effect on `app` pages, which never get
+     * the padding.
+     */
+    flush?: boolean;
+    /**
+     * The fill of an anchored content card.
+     * - `container` (default): the white content surface.
+     * - `background`: the grey page background, for screens whose content is
+     *   already cards or regions, so they do not sit in a second white box.
+     * A floating card keeps its elevated fill.
+     */
+    surface?: 'container' | 'background';
 };
 type __VLS_Slots = {
     banner?(): Slot;
     pageHeader?(): Slot;
     pageTabs?(): Slot;
+    /**
+     * Summary on the page background, between the page header (and tabs) and
+     * the content card, e.g. stat cards. It shares the page header's edges.
+     */
+    pageSummary?(): Slot;
     leftSlot?(): Slot;
     header?(): Slot;
     footer?(): Slot;
@@ -25,7 +117,13 @@ type __VLS_Slots = {
 };
 declare const __VLS_base: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {
     title: string;
-    pageContentClasses: string;
+    variant: "document" | "list" | "app";
+    frame: "anchored" | "floating";
+    flush: boolean;
+    leftSlotRatio: "third" | "half" | "fill";
+    leftSlotBreakpoint: "lg" | "none";
+    headroomGap: HeadroomGap;
+    surface: "container" | "background";
 }, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
 declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
 declare const _default: typeof __VLS_export;

package/dist/types/src/components/UiPagination/UiPagination.vue.d.ts

@@ -0,0 +1,36 @@
+import type { UiPaginationColor } from './types';
+interface UiPaginationProps {
+    /** Controlled current page. Bind with `v-model:page`. */
+    page?: number;
+    /** Initial page when uncontrolled. */
+    defaultPage?: number;
+    /** Number of items per page. */
+    itemsPerPage?: number;
+    /** Total number of items across all pages. */
+    total: number;
+    /** Number of sibling pages shown around the current page. */
+    siblingCount?: number;
+    disabled?: boolean;
+    /** Always show the first and last page, with an ellipsis in between when needed. */
+    showEdges?: boolean;
+    color?: UiPaginationColor;
+    previousLabel?: string;
+    nextLabel?: string;
+}
+declare const __VLS_export: import("vue").DefineComponent<UiPaginationProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    "update:page": (value: number) => any;
+}, string, import("vue").PublicProps, Readonly<UiPaginationProps> & Readonly<{
+    "onUpdate:page"?: ((value: number) => any) | undefined;
+}>, {
+    disabled: boolean;
+    color: UiPaginationColor;
+    page: number;
+    defaultPage: number;
+    itemsPerPage: number;
+    siblingCount: number;
+    showEdges: boolean;
+    previousLabel: string;
+    nextLabel: string;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/types/src/components/UiPagination/index.d.ts

@@ -0,0 +1,2 @@
+export { default as UiPagination } from './UiPagination.vue';
+export type { UiPaginationColor } from './types';

package/dist/types/src/components/UiPagination/types.d.ts

@@ -0,0 +1,4 @@
+export type UiPaginationColor = 'neutral' | 'neutral-invert' | 'primary' | 'success' | 'warning' | 'error';
+export declare const PAGINATION_IDLE_CLASSES: Record<UiPaginationColor, string>;
+export declare const PAGINATION_ACTIVE_CLASSES: Record<UiPaginationColor, string>;
+export declare const PAGINATION_RAIL_CLASSES: Record<UiPaginationColor, string>;

package/dist/types/src/components/UiPane/UiPane.vue.d.ts

@@ -0,0 +1,22 @@
+import type { DialogRootProps } from 'reka-ui';
+declare var __VLS_8: {};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_8) => any;
+};
+declare const __VLS_base: import("vue").DefineComponent<DialogRootProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    "update:open": (value: boolean) => any;
+}, string, import("vue").PublicProps, Readonly<DialogRootProps> & Readonly<{
+    "onUpdate:open"?: ((value: boolean) => any) | undefined;
+}>, {
+    defaultOpen: boolean;
+    open: boolean;
+    modal: boolean;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/types/src/components/UiPane/UiPaneContent.vue.d.ts

@@ -0,0 +1,75 @@
+import type { DialogContentProps } from 'reka-ui';
+export type UiPaneSize = 'sm' | 'lg';
+export type UiPaneOrientation = 'horizontal' | 'vertical';
+export interface UiPaneContentProps extends DialogContentProps {
+    /**
+     * Header title, also used as the pane's accessible name
+     */
+    title?: string;
+    /**
+     * Density of the header, padding and title
+     * @values sm, lg
+     */
+    size?: UiPaneSize;
+    /**
+     * Layout of the footer actions: in a row, or stacked full width
+     * @values horizontal, vertical
+     */
+    orientation?: UiPaneOrientation;
+    hideClose?: boolean;
+    closeButtonAriaLabel?: string;
+    /**
+     * Removes the body padding, for full-bleed content
+     */
+    noPadding?: boolean;
+    /**
+     * When false, a click outside or Escape no longer closes the pane:
+     * only the close button or the consumer's own actions do
+     */
+    dismissible?: boolean;
+    /**
+     * Any CSS width, for content with a fixed width of its own (an email's 600px column).
+     * Still capped to the viewport.
+     */
+    width?: string;
+}
+declare var __VLS_35: {}, __VLS_48: {}, __VLS_50: {};
+type __VLS_Slots = {} & {
+    header?: (props: typeof __VLS_35) => any;
+} & {
+    default?: (props: typeof __VLS_48) => any;
+} & {
+    footer?: (props: typeof __VLS_50) => any;
+};
+declare const __VLS_base: import("vue").DefineComponent<UiPaneContentProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    escapeKeyDown: (event: KeyboardEvent) => any;
+    pointerDownOutside: (event: import("reka-ui").PointerDownOutsideEvent) => any;
+    focusOutside: (event: import("reka-ui").FocusOutsideEvent) => any;
+    interactOutside: (event: import("reka-ui").PointerDownOutsideEvent | import("reka-ui").FocusOutsideEvent) => any;
+    openAutoFocus: (event: Event) => any;
+    closeAutoFocus: (event: Event) => any;
+}, string, import("vue").PublicProps, Readonly<UiPaneContentProps> & Readonly<{
+    onEscapeKeyDown?: ((event: KeyboardEvent) => any) | undefined;
+    onPointerDownOutside?: ((event: import("reka-ui").PointerDownOutsideEvent) => any) | undefined;
+    onFocusOutside?: ((event: import("reka-ui").FocusOutsideEvent) => any) | undefined;
+    onInteractOutside?: ((event: import("reka-ui").PointerDownOutsideEvent | import("reka-ui").FocusOutsideEvent) => any) | undefined;
+    onOpenAutoFocus?: ((event: Event) => any) | undefined;
+    onCloseAutoFocus?: ((event: Event) => any) | undefined;
+}>, {
+    orientation: UiPaneOrientation;
+    size: UiPaneSize;
+    title: string;
+    width: string;
+    hideClose: boolean;
+    closeButtonAriaLabel: string;
+    noPadding: boolean;
+    dismissible: boolean;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/types/src/components/UiPane/UiPaneTrigger.vue.d.ts

@@ -0,0 +1,14 @@
+import type { DialogTriggerProps } from 'reka-ui';
+declare var __VLS_8: {};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_8) => any;
+};
+declare const __VLS_base: import("vue").DefineComponent<DialogTriggerProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<DialogTriggerProps> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/types/src/components/UiPane/index.d.ts

@@ -0,0 +1,5 @@
+export { default as UiPane } from './UiPane.vue';
+export { default as UiPaneTrigger } from './UiPaneTrigger.vue';
+export { default as UiPaneContent } from './UiPaneContent.vue';
+export type { UiPaneContentProps, UiPaneOrientation, UiPaneSize } from './UiPaneContent.vue';
+export { DialogClose, type DialogRootProps, type DialogRootEmits, type DialogContentProps, type DialogContentEmits, } from 'reka-ui';

package/dist/types/src/components/UiProgress/UiProgress.vue.d.ts

@@ -7,8 +7,8 @@ interface Props {
 }
 declare const __VLS_export: import("vue").DefineComponent<Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<Props> & Readonly<{}>, {
     size: ProgressSize;
-    variant: ProgressVariant;
     value: number | null;
+    variant: ProgressVariant;
     indeterminate: boolean;
 }, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
 declare const _default: typeof __VLS_export;