@cjlapao/ui-kit-vue 0.2.0 → 0.2.3

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

@@ -1,8 +1,27 @@
 import type { VNode } from "vue";
-import type { TrueColor } from "../theme/Theme";
-export type MultiToggleSize = "sm" | "md" | "lg";
+import { type ControlSize, type SurfaceVariant, type TrueColor } from "../theme/Theme";
+/**
+ * The shared control scale. Was a component-local `sm | md | lg`, so a toggle
+ * could not line up with the `xs` or `xl` Button beside it.
+ */
+export type MultiToggleSize = ControlSize;
 export type MultiToggleShape = "none" | "xs" | "sm" | "md" | "lg" | "xl" | "full";
-export type MultiToggleVariant = "theme" | "solid" | "soft";
+/**
+ * The track is a surface, so it takes the **Panel family** — the same eight
+ * variants, reading identically beside a `Panel` at the same tone.
+ *
+ * This replaces a component-local `theme | solid | soft`, which described the
+ * *indicator* rather than the track and had no relationship to anything else
+ * in the kit.
+ */
+export declare const MULTI_TOGGLE_VARIANTS: readonly ["elevated", "outlined", "subtle", "tonal", "default", "glass", "simple", "liquid-glass"];
+export type MultiToggleVariant = SurfaceVariant;
+/**
+ * How the active segment is drawn. This is what the old `variant` union was
+ * actually describing, now separated from the track's surface.
+ */
+export declare const MULTI_TOGGLE_INDICATORS: readonly ["solid", "soft", "tonal"];
+export type MultiToggleIndicator = (typeof MULTI_TOGGLE_INDICATORS)[number];
 type LiteralUnion<T extends U, U = string> = T | (U & Record<never, never>);
 export type MultiToggleOptionWidth = number | LiteralUnion<"auto">;
 export type MultiToggleActiveWidthStrategy = "auto" | "max";
@@ -25,8 +44,15 @@ export interface MultiToggleProps {
     adaptiveWidth?: boolean;
     optionMaxWidth?: number | string;
     activeWidthStrategy?: MultiToggleActiveWidthStrategy;
+    /** The track's surface, from the Panel family. @default "subtle" */
     variant?: MultiToggleVariant;
-    /** When set, overrides the active option's text color with this color's active-text token. */
+    /** How the active segment is drawn. @default "solid" */
+    indicator?: MultiToggleIndicator;
+    /** Accent for the indicator, the active label and the focus ring. @default "blue" */
+    tone?: TrueColor;
+    /** Overrides the active option's text tone. */
+    accentTone?: TrueColor;
+    /** @deprecated Use `accentTone`. */
     accentColor?: TrueColor;
     disabled?: boolean;
 }
@@ -37,13 +63,14 @@ declare const _default: import("vue").DefineComponent<MultiToggleProps, {}, {},
     onChange?: ((value: string) => any) | undefined;
     "onUpdate:modelValue"?: ((value: string) => any) | undefined;
 }>, {
+    rounded: MultiToggleShape;
+    size: MultiToggleSize;
     color: TrueColor;
     variant: MultiToggleVariant;
-    size: MultiToggleSize;
     fullWidth: boolean;
-    rounded: MultiToggleShape;
     showOnlyActiveLabel: boolean;
     adaptiveWidth: boolean;
     activeWidthStrategy: MultiToggleActiveWidthStrategy;
+    indicator: MultiToggleIndicator;
 }, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
 export default _default;

package/dist/types/vue/src/components/NotificationModal.test.d.ts

@@ -0,0 +1 @@
+export {};

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

@@ -1,11 +1,28 @@
-export type NotificationType = "success" | "error" | "warning" | "info";
+import { type IconName } from "../icons/registry";
+import type { TrueColor } from "../theme/Theme";
+/**
+ * The kit's shared severity vocabulary is `AlertIntent`
+ * (`info | success | warning | danger | neutral`). This component predates it
+ * and ships `error` rather than `danger`; the name is kept so call sites are
+ * not broken, and the mapping below is the single place the two meet.
+ */
+export declare const NOTIFICATION_TYPES: readonly ["success", "error", "warning", "info"];
+export type NotificationType = (typeof NOTIFICATION_TYPES)[number];
 export interface NotificationModalProps {
     isOpen: boolean;
     title: string;
     message?: string;
+    /** @default "info" */
     type?: NotificationType;
+    /** @default "Close" */
     actionLabel?: string;
     secondaryActionLabel?: string;
+    /** Override the glyph the `type` would pick. */
+    icon?: IconName;
+    /** Override the tone the `type` would pick. */
+    tone?: TrueColor;
+    /** @default "sm" */
+    size?: "sm" | "md" | "lg" | "xl";
 }
 declare const _default: __VLS_WithSlots<import("vue").DefineComponent<NotificationModalProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {} & {
     close: () => any;
@@ -17,7 +34,7 @@ declare const _default: __VLS_WithSlots<import("vue").DefineComponent<Notificati
     onSecondaryAction?: (() => any) | undefined;
 }>, {
     type: NotificationType;
-    actionLabel: string;
+    size: "sm" | "md" | "lg" | "xl";
 }, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>, {
     default?: (props: {}) => any;
 }>;

package/dist/types/vue/src/components/PageHeader.test.d.ts

@@ -0,0 +1 @@
+export {};

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

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

package/dist/types/vue/src/components/PagedPanel.test.d.ts

@@ -0,0 +1 @@
+export {};

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

@@ -1,6 +1,14 @@
 import type { VNodeChild } from "vue";
 import type { PanelProps } from "./Panel.vue";
-export interface PagedPanelProps extends Omit<PanelProps, "title" | "subtitle"> {
+import type { ControlSize, TrueColor } from "../theme/Theme";
+/**
+ * The kit's three loader treatments, with `skeleton` the default — a
+ * placeholder shaped like the panel's own content keeps the block at its real
+ * height, where a spinner collapses it and the page jumps when the data lands.
+ */
+export declare const PAGED_PANEL_LOADERS: readonly ["skeleton", "spinner", "progress"];
+export type PagedPanelLoader = (typeof PAGED_PANEL_LOADERS)[number];
+export interface PagedPanelProps extends Omit<PanelProps, "title" | "subtitle" | "loading" | "loaderType" | "progress"> {
     /** One entry per page — rendered one at a time. */
     pages: VNodeChild[];
     /**
@@ -10,28 +18,48 @@ export interface PagedPanelProps extends Omit<PanelProps, "title" | "subtitle">
     title?: VNodeChild | VNodeChild[];
     /** Optional subtitle shown below the title (static). */
     subtitle?: VNodeChild;
-    /** Show a loading overlay over the whole panel. */
+    /** Replaces the page with a loading treatment. */
+    loading?: boolean;
+    /** How `loading` is drawn. @default "skeleton" */
+    loaderType?: PagedPanelLoader;
+    /** Determinate value for `loaderType="progress"`, 0–100. */
+    progress?: number;
+    /** Copy shown beside the spinner or progress bar. */
+    loadingLabel?: string;
+    /** Replaces the page with an error message. */
     error?: string | null;
+    /** Copy for the default empty state. @default "No data available." */
+    emptyMessage?: string;
+    /** Accent for the nav buttons. @default "blue" */
+    tone?: TrueColor;
+    /** Scale of the nav buttons and header type. @default "md" */
+    size?: ControlSize;
+    /** Controlled page index. Omit for uncontrolled paging. */
+    page?: number;
     /**
      * When true, renders without the Panel wrapper (no border, background or
      * shadow). Use this when embedding PagedPanel inside an existing Panel.
      */
     bare?: boolean;
 }
-declare const _default: __VLS_WithSlots<import("vue").DefineComponent<PagedPanelProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<PagedPanelProps> & Readonly<{}>, {
+declare const _default: __VLS_WithSlots<import("vue").DefineComponent<PagedPanelProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    "update:page": (page: number) => any;
+}, string, import("vue").PublicProps, Readonly<PagedPanelProps> & Readonly<{
+    "onUpdate:page"?: ((page: number) => any) | undefined;
+}>, {
+    size: ControlSize;
+    loading: boolean;
+    tone: TrueColor;
+    loaderType: PagedPanelLoader;
     bare: boolean;
 }, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>, {
-    title?: (props: {
-        page: number;
-    }) => any;
+    empty?: (props: {}) => any;
 } & {
-    subtitle?: (props: {}) => any;
+    loading?: (props: {}) => any;
 } & {
-    title?: (props: {
-        page: number;
-    }) => any;
+    empty?: (props: {}) => any;
 } & {
-    subtitle?: (props: {}) => any;
+    loading?: (props: {}) => any;
 }>;
 export default _default;
 type __VLS_WithSlots<T, S> = T & {

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

@@ -1,13 +1,18 @@
 import type { CSSProperties, VNode } from "vue";
 import type { ButtonProps } from "./Button.vue";
 import type { LoaderProps } from "./Loader.vue";
-import type { TrueColor } from "../theme/Theme";
-export type PanelVariant = "elevated" | "outlined" | "subtle" | "tonal" | "default" | "glass" | "simple" | "liquid-glass";
+import type { SurfaceCorner, SurfacePadding, SurfaceVariant, TrueColor } from "../theme/Theme";
+/**
+ * Aliased from the shared theme rather than redeclared, so the Vue and React
+ * kits cannot drift. These were three separate hand-written unions; the corner
+ * one had no `rounded-xl` and its `pill` duplicated `rounded-lg`.
+ */
+export type PanelVariant = SurfaceVariant;
 export type PanelTone = TrueColor;
 export type PanelDecoration = "none" | "gradient" | "shapes" | "both";
 export type PanelMediaPlacement = "top" | "start" | "end" | "overlay";
-export type PanelPadding = "none" | "xs" | "sm" | "md" | "lg";
-export type PanelCorner = "rounded" | "rounded-sm" | "rounded-md" | "rounded-lg" | "rounded-full" | "pill" | "none";
+export type PanelPadding = SurfacePadding;
+export type PanelCorner = SurfaceCorner;
 export type PanelActionLayout = "auto" | "stacked" | "inline";
 export type PanelLoaderType = Exclude<LoaderProps["variant"], undefined>;
 export type PanelSpecularMode = "none" | "classic" | "halo";
@@ -97,19 +102,23 @@ export interface PanelProps {
      */
     specularMode?: PanelSpecularMode;
 }
+/**
+ * Re-exported from the theme for `CollapsiblePanel` and `TimelinePanel`, which
+ * import the map directly rather than taking a Panel.
+ */
 export declare const paddingStyles: Record<PanelPadding, string>;
 declare const _default: __VLS_WithSlots<import("vue").DefineComponent<PanelProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<PanelProps> & Readonly<{}>, {
+    loading: boolean;
     tone: TrueColor;
-    variant: PanelVariant;
     disabled: boolean;
-    loading: boolean;
-    vibrancy: "low" | "medium" | "high" | number;
+    variant: PanelVariant;
+    corner: PanelCorner;
     glassOpacity: "frosted" | "light" | "clear" | number;
+    vibrancy: "low" | "medium" | "high" | number;
     specularMode: PanelSpecularMode;
-    padding: PanelPadding;
     mediaPlacement: PanelMediaPlacement;
     actionLayout: PanelActionLayout;
-    corner: PanelCorner;
+    padding: PanelPadding;
     flexBody: boolean;
     loaderType: PanelLoaderType;
     hoverShadow: boolean;

package/dist/types/vue/src/components/PasswordInput.test.d.ts

@@ -0,0 +1 @@
+export {};

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

@@ -1,6 +1,23 @@
 import type { InputProps } from "./Input.vue";
-export type PasswordInputProps = Omit<InputProps, "trailingIcon" | "onTrailingIconClick">;
-declare const _default: import("vue").DefineComponent<{}, {
+export interface PasswordInputProps extends Omit<InputProps, "type" | "trailingIcon" | "onTrailingIconClick"> {
+    /**
+     * Offer the reveal toggle at all. Turn it off for a field the user should
+     * never be able to read back (a stored secret being re-entered).
+     * @default true
+     */
+    revealable?: boolean;
+    /** Controlled reveal state. Omit for uncontrolled. */
+    revealed?: boolean;
+}
+declare const _default: import("vue").DefineComponent<PasswordInputProps, {
     el: import("vue").ComputedRef<HTMLInputElement | null>;
-}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    "update:revealed": (revealed: boolean) => any;
+}, string, import("vue").PublicProps, Readonly<PasswordInputProps> & Readonly<{
+    "onUpdate:revealed"?: ((revealed: boolean) => any) | undefined;
+}>, {
+    disabled: boolean;
+    revealable: boolean;
+    revealed: boolean;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
 export default _default;

package/dist/types/vue/src/components/Picker.test.d.ts

@@ -0,0 +1 @@
+export {};

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

@@ -69,14 +69,14 @@ declare const _default: import("vue").DefineComponent<PickerProps, {}, {}, {}, {
     onMultiChange?: ((ids: string[]) => any) | undefined;
     "onUpdate:selectedIds"?: ((ids: string[]) => any) | undefined;
 }>, {
-    color: TrueColor;
     size: "sm" | "md";
+    loading: boolean;
+    color: TrueColor;
     placeholder: string;
     fullWidth: boolean;
-    loading: boolean;
     fullHeight: boolean;
-    emptyMessage: string;
     loadingMessage: string;
+    emptyMessage: string;
     escapeBoundary: boolean;
     multi: boolean;
     maxPillsShown: number;

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

@@ -1,26 +1,84 @@
 import type { VNode } from "vue";
-import type { TrueColor } from "../theme/Theme";
-export type PillVariant = "solid" | "soft" | "outline";
-export type PillSize = "xs" | "sm" | "md" | "lg";
+import type { ControlSize, TrueColor } from "../theme/Theme";
+import type { GlassOpacity, GlassVibrancy, SpecularMode } from "../theme/glass";
+export declare const PILL_VARIANTS: readonly ["solid", "soft", "outline", "glass", "liquid-glass"];
+export type PillVariant = (typeof PILL_VARIANTS)[number];
+/** The shared control scale — it used to be its own four-step union. */
+export type PillSize = ControlSize;
 export type PillTone = TrueColor;
+/**
+ * Corner scale for a pill. Deliberately not `SurfaceCorner` — that scale is
+ * tuned for cards, where `rounded-md` means 16px, which on a 24px-tall pill is
+ * almost a capsule anyway.
+ */
+export declare const PILL_CORNERS: readonly ["none", "sm", "md", "lg", "full"];
+export type PillCorner = (typeof PILL_CORNERS)[number];
 export interface PillProps {
     tone?: PillTone;
+    /** @default "soft" */
     variant?: PillVariant;
+    /** @default "md" */
     size?: PillSize;
+    /** @default "full" */
+    corner?: PillCorner;
     uppercase?: boolean;
+    /** Glass fill transparency, for the see-through variants. @default "frosted" */
+    glassOpacity?: GlassOpacity;
+    /** Backdrop vibrancy, for the see-through variants. */
+    vibrancy?: GlassVibrancy;
+    /**
+     * Specular highlight. `liquid-glass` defaults to `classic`; plain `glass`
+     * defaults to none, which is the difference between the two.
+     */
+    specularMode?: SpecularMode;
+    /** Icon before the label. A registry name, or a node via the slot. */
     icon?: string | VNode;
+    /** Icon after the label. */
+    trailingIcon?: string | VNode;
+    /**
+     * Renders as a bare status dot with no label. Any content, icon or remove
+     * button is dropped, so it stays a dot.
+     */
     dot?: boolean;
+    /** Shows a remove button, which emits `remove`. */
+    removable?: boolean;
+    /** Accessible name for that button. @default "Remove" */
+    removeLabel?: string;
+    /** Makes the whole pill activatable — it renders as a real `<button>`. */
+    clickable?: boolean;
+    disabled?: boolean;
+    /** Truncates a long label instead of stretching the pill. */
+    maxWidth?: number | string;
+    /**
+     * Accessible name for a `dot`, which has no text of its own. Without one the
+     * dot is treated as decoration and hidden.
+     */
+    label?: string;
 }
-declare const _default: __VLS_WithSlots<import("vue").DefineComponent<PillProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<PillProps> & Readonly<{}>, {
+declare const _default: __VLS_WithSlots<import("vue").DefineComponent<PillProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {} & {
+    click: (payload: MouseEvent) => any;
+    remove: () => any;
+}, string, import("vue").PublicProps, Readonly<PillProps> & Readonly<{
+    onClick?: ((payload: MouseEvent) => any) | undefined;
+    onRemove?: (() => any) | undefined;
+}>, {
+    size: PillSize;
     tone: PillTone;
+    clickable: boolean;
+    disabled: boolean;
     variant: PillVariant;
+    corner: PillCorner;
+    glassOpacity: GlassOpacity;
+    vibrancy: GlassVibrancy;
     dot: boolean;
-    size: PillSize;
     uppercase: boolean;
+    removable: boolean;
 }, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>, {
     icon?: (props: {}) => any;
 } & {
     default?: (props: {}) => any;
+} & {
+    trailingIcon?: (props: {}) => any;
 }>;
 export default _default;
 type __VLS_WithSlots<T, S> = T & {

package/dist/types/vue/src/components/Progress.test.d.ts

@@ -0,0 +1 @@
+export {};

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

@@ -1,29 +1,78 @@
-import "../../../react/src/components/progress-animations.css";
-import type { SpinnerColor } from "./Spinner.vue";
-export type ProgressSize = "xs" | "sm" | "md" | "lg";
-export type ProgressMotion = "none" | "shimmer" | "pulse" | "shimmer-pulse" | "stripes" | "stripes-shimmer";
-export type ProgressMotionSpeed = "slow" | "normal" | "fast";
-export type ProgressMotionDirection = "forward" | "reverse";
+import type { ControlSize, TrueColor } from "../theme/Theme";
+/** The shared control scale, so a bar lines up with the controls around it. */
+export type ProgressSize = ControlSize;
+export declare const PROGRESS_MOTIONS: readonly ["none", "shimmer", "pulse", "shimmer-pulse", "stripes", "stripes-shimmer"];
+export type ProgressMotion = (typeof PROGRESS_MOTIONS)[number];
+export declare const PROGRESS_MOTION_SPEEDS: readonly ["slow", "normal", "fast"];
+export type ProgressMotionSpeed = (typeof PROGRESS_MOTION_SPEEDS)[number];
+export declare const PROGRESS_MOTION_DIRECTIONS: readonly ["forward", "reverse"];
+export type ProgressMotionDirection = (typeof PROGRESS_MOTION_DIRECTIONS)[number];
+export declare const PROGRESS_CORNERS: readonly ["full", "rounded", "none"];
+export type ProgressCorner = (typeof PROGRESS_CORNERS)[number];
 export interface ProgressProps {
+    /** Current value, clamped between `min` and `max`. @default 0 */
     value?: number;
+    /** @default 0 */
+    min?: number;
+    /** @default 100 */
+    max?: number;
+    /**
+     * Work is happening but its extent is unknown — the bar sweeps instead of
+     * filling. `value` is ignored, and no `aria-valuenow` is published, which is
+     * what tells assistive technology the progress is indeterminate.
+     */
+    indeterminate?: boolean;
+    /** @default "md" */
     size?: ProgressSize;
-    color?: SpinnerColor;
+    /** @default "blue" */
+    color?: TrueColor;
+    /** Alias for `color`, matching the input family's `tone`. */
+    tone?: TrueColor;
+    /** @default "full" */
+    corner?: ProgressCorner;
     motion?: ProgressMotion;
+    /** @default "normal" */
     motionSpeed?: ProgressMotionSpeed;
+    /** @default "forward" */
     motionDirection?: ProgressMotionDirection;
     /**
-     * @deprecated Use `motion="shimmer"` or `motion="none"` instead.
+     * Caption above the bar. Also becomes the bar's accessible name — a
+     * `role="progressbar"` with no name is announced as just "progress bar".
+     */
+    label?: string;
+    /** Show the value beside the label. @default false */
+    showValue?: boolean;
+    /**
+     * Formats the displayed value and `aria-valuetext`. Defaults to a percentage
+     * of the `min`–`max` range.
+     */
+    formatValue?: (value: number, percent: number) => string;
+    /** Classes for the filled bar. */
+    barClassName?: string;
+    /**
+     * @deprecated Use `motion="shimmer"` or `motion="none"`.
      */
     showShimmer?: boolean;
 }
-declare const _default: import("vue").DefineComponent<ProgressProps, {
+declare const _default: __VLS_WithSlots<import("vue").DefineComponent<ProgressProps, {
     el: import("vue").Ref<HTMLDivElement | null, HTMLDivElement | null>;
 }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<ProgressProps> & Readonly<{}>, {
-    color: SpinnerColor;
     size: ProgressSize;
     value: number;
+    corner: ProgressCorner;
+    min: number;
+    max: number;
+    indeterminate: boolean;
     motionSpeed: ProgressMotionSpeed;
     motionDirection: ProgressMotionDirection;
+    showValue: boolean;
     showShimmer: boolean;
-}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>, {
+    label?: (props: {}) => any;
+}>;
 export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/types/vue/src/components/ProgressSpinner.test.d.ts

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,46 @@
+import { type ControlSize, type TrueColor } from "../theme/Theme";
+import type { SpinnerThickness } from "./Spinner.vue";
+/**
+ * The shared control scale, so a progress spinner lines up with the `Spinner`
+ * and `Button` next to it instead of speaking its own size language.
+ */
+export type ProgressSpinnerSize = ControlSize;
+export type ProgressSpinnerColor = TrueColor;
+export interface ProgressSpinnerProps {
+    /**
+     * Progress value. Omit it for an indeterminate spinner — the two modes are
+     * the same component with different ARIA, the way `role="progressbar"` is
+     * specified. Values outside `[min, max]` are clamped.
+     */
+    value?: number;
+    /** @default 0 */
+    min?: number;
+    /** @default 100 */
+    max?: number;
+    /** @default "md" */
+    size?: ProgressSpinnerSize;
+    /** @default "blue" */
+    color?: ProgressSpinnerColor;
+    /** @default "normal" */
+    thickness?: SpinnerThickness;
+    /**
+     * One revolution in indeterminate mode. The dash animation runs at 3/4 of
+     * this, so a single value sets the whole tempo.
+     * @default "2s"
+     */
+    animationDuration?: string;
+    /** Centre percentage readout, determinate mode only. @default true */
+    showValue?: boolean;
+    /** @default "Loading" */
+    ariaLabel?: string;
+}
+declare const _default: import("vue").DefineComponent<ProgressSpinnerProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<ProgressSpinnerProps> & Readonly<{}>, {
+    size: ProgressSpinnerSize;
+    color: ProgressSpinnerColor;
+    thickness: SpinnerThickness;
+    min: number;
+    max: number;
+    showValue: boolean;
+    animationDuration: string;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+export default _default;

package/dist/types/vue/src/components/ScrollArea.test.d.ts

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,52 @@
+/**
+ * A scrollable region with custom overlay scrollbars — PrimeVue's ScrollArea:
+ * the native scrollbar is hidden (scrolling itself stays completely native,
+ * so wheel, touch and keyboard all behave exactly as browsers do), and thin
+ * virtual bars track the content instead, sized by the visible fraction and
+ * shown per the `variant`. Same on every browser, unlike styling the native
+ * scrollbar.
+ *
+ * The viewport joins the tab order only while something actually overflows
+ * — a region that fits has no business one tab deep.
+ *
+ * (These notes live here rather than in the template because a template
+ * comment is a real node, and a comment beside the root makes the component
+ * multi-root — which silently breaks attribute inheritance.)
+ */
+/**
+ * Bar visibility behaviour — PrimeVue's `variant`:
+ * `auto` shows while hovered or scrolling (default), `hover` on hover only,
+ * `scroll` while scrolling and briefly after, `always` whenever the axis
+ * overflows, `hidden` never.
+ */
+type ScrollAreaVariant = "auto" | "hover" | "scroll" | "always" | "hidden";
+interface ScrollAreaProps {
+    /** @default "auto" */
+    variant?: ScrollAreaVariant;
+    /** Fade the content at the edges it can scroll toward. @default false */
+    mask?: boolean;
+    /**
+     * Tab order entry for the viewport while overflowing; the viewport leaves
+     * the tab order when the content fits. @default 0
+     */
+    tabIndex?: number;
+    /** Classes for the content wrapper, styled apart from the frame. */
+    contentClassName?: string;
+}
+declare var __VLS_1: {};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_1) => any;
+};
+declare const __VLS_component: import("vue").DefineComponent<ScrollAreaProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<ScrollAreaProps> & Readonly<{}>, {
+    mask: boolean;
+    variant: ScrollAreaVariant;
+    tabIndex: number;
+    contentClassName: string;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: __VLS_WithSlots<typeof __VLS_component, __VLS_Slots>;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

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

@@ -38,14 +38,13 @@ declare const _default: import("vue").DefineComponent<SearchBarProps, {}, {}, {}
     onSearch?: ((query: string, signal?: AbortSignal | undefined) => any) | undefined;
 }>, {
     color: TrueColor;
-    variant: "default" | "gradient";
     disabled: boolean;
-    placeholder: string;
+    variant: "default" | "gradient";
     leadingIcon: string | VNode;
+    glowIntensity: "subtle" | "soft" | "medium" | "strong";
     debounceMs: number;
     autoSearch: boolean;
     initialValue: string;
     shouldClear: boolean;
-    glowIntensity: "subtle" | "soft" | "medium" | "strong";
 }, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
 export default _default;

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

@@ -52,8 +52,8 @@ export interface SectionProps {
     noPadding?: boolean;
 }
 declare const _default: __VLS_WithSlots<import("vue").DefineComponent<SectionProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<SectionProps> & Readonly<{}>, {
-    variant: SectionVariant;
     size: SectionSize;
+    variant: SectionVariant;
     noPadding: boolean;
 }, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>, {
     title?: (props: {}) => any;

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

@@ -19,9 +19,9 @@ export interface SectionCardProps {
     bodyClassName?: string;
 }
 declare const _default: __VLS_WithSlots<import("vue").DefineComponent<SectionCardProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<SectionCardProps> & Readonly<{}>, {
-    variant: SectionCardVariant;
-    size: SectionCardSize;
     blur: boolean;
+    size: SectionCardSize;
+    variant: SectionCardVariant;
 }, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>, {
     actions?: (props: {}) => any;
 } & {

package/dist/types/vue/src/components/Select.test.d.ts

@@ -0,0 +1 @@
+export {};