@mkbabb/glass-ui 0.3.0 → 2.1.0

package/dist/components/ui/context-menu/ContextMenuShortcut.vue.d.ts

@@ -0,0 +1,17 @@
+import type { HTMLAttributes } from 'vue';
+type __VLS_Props = {
+    class?: HTMLAttributes['class'];
+};
+declare var __VLS_1: {};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_1) => 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_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/components/ui/context-menu/ContextMenuSubContent.vue.d.ts

@@ -0,0 +1,34 @@
+import { type HTMLAttributes } from 'vue';
+import { type DropdownMenuSubContentProps } from 'reka-ui';
+type __VLS_Props = DropdownMenuSubContentProps & {
+    class?: HTMLAttributes['class'];
+};
+declare var __VLS_8: {};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_8) => any;
+};
+declare const __VLS_base: import("vue").DefineComponent<__VLS_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;
+    openAutoFocus: (event: Event) => any;
+    closeAutoFocus: (event: Event) => any;
+    entryFocus: (event: Event) => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_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;
+    onOpenAutoFocus?: ((event: Event) => any) | undefined;
+    onCloseAutoFocus?: ((event: Event) => any) | undefined;
+    onEntryFocus?: ((event: Event) => any) | undefined;
+}>, {}, {}, {}, {}, 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/components/ui/context-menu/ContextMenuSubTrigger.vue.d.ts

@@ -0,0 +1,19 @@
+import { type HTMLAttributes } from 'vue';
+import { type ContextMenuSubTriggerProps } from 'reka-ui';
+type __VLS_Props = ContextMenuSubTriggerProps & {
+    class?: HTMLAttributes['class'];
+    inset?: boolean;
+};
+declare var __VLS_8: {};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_8) => 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_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/components/ui/context-menu/ContextMenuTrigger.vue.d.ts

@@ -0,0 +1,14 @@
+import { type ContextMenuTriggerProps } from 'reka-ui';
+declare var __VLS_8: {};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_8) => any;
+};
+declare const __VLS_base: import("vue").DefineComponent<ContextMenuTriggerProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<ContextMenuTriggerProps> & 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/components/ui/context-menu/index.d.ts

@@ -0,0 +1,12 @@
+export { default as ContextMenu } from './ContextMenu.vue';
+export { default as ContextMenuTrigger } from './ContextMenuTrigger.vue';
+export { default as ContextMenuContent } from './ContextMenuContent.vue';
+export { default as ContextMenuRadioGroup } from './ContextMenuRadioGroup.vue';
+export { default as ContextMenuItem } from './ContextMenuItem.vue';
+export { default as ContextMenuCheckboxItem } from './ContextMenuCheckboxItem.vue';
+export { default as ContextMenuRadioItem } from './ContextMenuRadioItem.vue';
+export { default as ContextMenuShortcut } from './ContextMenuShortcut.vue';
+export { default as ContextMenuSeparator } from './ContextMenuSeparator.vue';
+export { default as ContextMenuLabel } from './ContextMenuLabel.vue';
+export { default as ContextMenuSubTrigger } from './ContextMenuSubTrigger.vue';
+export { default as ContextMenuSubContent } from './ContextMenuSubContent.vue';

package/dist/components/ui/data-table/DataTable.vue.d.ts

@@ -0,0 +1,81 @@
+import type { DataTableColumn, DataTableSort } from "./types";
+declare const __VLS_export: <T extends Record<string, any>>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: __VLS_PrettifyLocal<Pick<NonNullable<Awaited<typeof __VLS_setup>>, "attrs" | "emit" | "slots">>, __VLS_exposed?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
+    props: import("vue").PublicProps & __VLS_PrettifyLocal<{
+        columns: DataTableColumn<T>[];
+        rows: T[];
+        total: number;
+        page: number;
+        pageSize: number;
+        isLoading?: boolean;
+        rowKey?: string;
+        getRowId?: (row: T) => PropertyKey | null | undefined;
+        sort?: DataTableSort;
+        infinite?: boolean;
+        hasMore?: boolean;
+        /**
+         * When true, the table collapses to a stacked card-per-row
+         * projection once its own container measures below
+         * `cardBreakpoint`. A dense multi-column table has no responsive
+         * story at narrow widths — a horizontal-scroll wrapper leaves
+         * half the columns invisible. The card projection keeps every
+         * field reachable: the first column becomes the card header
+         * (with the row-actions menu docked beside it), every other
+         * column renders as a label/value pair below. At/above the
+         * breakpoint the unchanged tabular layout renders.
+         */
+        responsive?: boolean;
+        /**
+         * Container-width (CSS px) below which `responsive` swaps to the
+         * card projection. Container-driven (not viewport-driven) so a
+         * table inside a narrow column collapses at any viewport width.
+         */
+        cardBreakpoint?: number;
+        class?: string;
+    } & {
+        onSelect?: ((row: T) => any) | undefined;
+        "onUpdate:page"?: ((page: number) => any) | undefined;
+        "onUpdate:sort"?: ((sort: DataTableSort) => any) | undefined;
+        "onLoad-more"?: (() => any) | undefined;
+    }> & (typeof globalThis extends {
+        __VLS_PROPS_FALLBACK: infer P;
+    } ? P : {});
+    expose: (exposed: {}) => void;
+    attrs: any;
+    slots: {
+        'row-actions'?: (props: {
+            row: T;
+        }) => any;
+    } & {
+        'row-context-menu'?: (props: {
+            row: T;
+        }) => any;
+    } & {
+        empty?: (props: {}) => any;
+    } & {
+        'row-actions'?: (props: {
+            row: T;
+        }) => any;
+    } & {
+        'row-context-menu'?: (props: {
+            row: T;
+        }) => any;
+    } & {
+        'row-actions'?: (props: {
+            row: T;
+        }) => any;
+    } & {
+        empty?: (props: {}) => any;
+    } & {
+        sentinel?: (props: {}) => any;
+    };
+    emit: ((evt: "select", row: T) => void) & ((evt: "update:page", page: number) => void) & ((evt: "update:sort", sort: DataTableSort) => void) & ((evt: "load-more") => void);
+}>) => import("vue").VNode & {
+    __ctx?: Awaited<typeof __VLS_setup>;
+};
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_PrettifyLocal<T> = (T extends any ? {
+    [K in keyof T]: T[K];
+} : {
+    [K in keyof T as K]: T[K];
+}) & {};

package/dist/components/ui/data-table/DataTablePagination.vue.d.ts

@@ -0,0 +1,13 @@
+type __VLS_Props = {
+    page: number;
+    pageSize: number;
+    total: number;
+    class?: string;
+};
+declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    "update:page": (page: number) => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
+    "onUpdate:page"?: ((page: number) => any) | undefined;
+}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/components/ui/data-table/types.d.ts

@@ -0,0 +1,56 @@
+import type { Component } from "vue";
+export interface DataTableColumn<T = any> {
+    /** Unique key matching a property on the row object */
+    key: string;
+    /** Display label for the column header */
+    label: string;
+    /** Optional formatter for cell values */
+    formatter?: (value: any, row: T) => string;
+    /** Optional custom component to render in the cell. Receives `value` and `row` props. */
+    component?: Component;
+    /** Whether this column is sortable */
+    sortable?: boolean;
+    /** Text alignment */
+    align?: "left" | "center" | "right";
+    /** Additional CSS classes for the column cells */
+    class?: string;
+    /** Additional CSS classes for the header cell */
+    headerClass?: string;
+}
+export interface DataTableSort {
+    key: string;
+    direction: "asc" | "desc";
+}
+export interface DataTableProps<T = any> {
+    /** Column definitions */
+    columns: DataTableColumn<T>[];
+    /** Row data to display */
+    rows: T[];
+    /** Total number of rows across all pages (for pagination display) */
+    total: number;
+    /** Current page number (1-indexed) */
+    page: number;
+    /** Number of rows per page */
+    pageSize: number;
+    /** Whether data is currently loading */
+    isLoading?: boolean;
+    /** Unique key field on each row (defaults to "_id") */
+    rowKey?: string;
+    /** Optional resolver for stable unique row identities. Takes precedence over rowKey. */
+    getRowId?: (row: T) => PropertyKey | null | undefined;
+    /** Current sort state */
+    sort?: DataTableSort;
+    /** When true, hides pagination and shows infinite scroll sentinel */
+    infinite?: boolean;
+    /** Whether more data is available (for infinite scroll mode) */
+    hasMore?: boolean;
+    /**
+     * When true, the table collapses to a stacked card-per-row
+     * projection once its container measures below `cardBreakpoint` —
+     * the responsive story for a dense multi-column table at narrow
+     * widths. At/above the breakpoint the tabular layout renders.
+     */
+    responsive?: boolean;
+    /** Container-width (CSS px) below which `responsive` swaps to cards. Defaults to 640. */
+    cardBreakpoint?: number;
+}

package/dist/components/ui/dialog/Dialog.vue.d.ts

@@ -0,0 +1,18 @@
+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;
+}>, {}, {}, {}, {}, 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/components/ui/dialog/DialogClose.vue.d.ts

@@ -0,0 +1,14 @@
+import { type DialogCloseProps } from 'reka-ui';
+declare var __VLS_8: {};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_8) => any;
+};
+declare const __VLS_base: import("vue").DefineComponent<DialogCloseProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<DialogCloseProps> & 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/components/ui/dialog/DialogContent.vue.d.ts

@@ -0,0 +1,71 @@
+import { type HTMLAttributes } from 'vue';
+import { type DialogContentProps } from 'reka-ui';
+import { type SpringPreset } from '../../../composables/motion/useSpringMount';
+type __VLS_Props = DialogContentProps & {
+    class?: HTMLAttributes['class'];
+    /** Visual variant: "glass" (translucent blur, default) or "opaque" (solid background). */
+    variant?: 'glass' | 'opaque';
+    /**
+     * Optional CSS `animation` shorthand forwarded to the portaled scrim
+     * via the `--scrim-animation` typed cascade variable. reka-ui's
+     * `DialogPortal` teleports the `DialogOverlay` outside the consumer's
+     * component subtree, so a scoped `--scrim-animation` declaration on a
+     * parent of `<Dialog>` never reaches the overlay — the publisher owns
+     * the bridge.
+     *
+     * Pass a complete `animation` shorthand (e.g. `"scrim-breath 6s
+     * ease-in-out infinite"`); the rule
+     * `[data-scrim-animation] { animation: var(--scrim-animation, none) }`
+     * in `animations.css` consumes it on the portaled overlay element.
+     * Composes with the default `animate="fade"` enter/exit (distinct
+     * selectors: `[data-state]` keys the fade, `[data-scrim-animation]`
+     * keys the breath — no cascade fight).
+     *
+     * Reduced-motion: the global `@media (prefers-reduced-motion: reduce)`
+     * bracket in `animations.css` retires the breath automatically.
+     *
+     * AJ-W4-δ.
+     */
+    scrimAnimation?: string;
+    /**
+     * Opt into iOS spring-physics entrance via `useSpringMount` (W13). When
+     * truthy, the dialog content scales+fades via a `useSpring`-driven
+     * transform instead of the default `popover-animate` cubic transition.
+     * Pass `true` for the canonical `smooth` preset, or name one of
+     * `'smooth' | 'snappy' | 'bouncy' | 'gentle'` to pick a different
+     * (response, ζ) pair (matches the `--spring-*` tokens).
+     *
+     * PRM: `useSpring`'s `respectReducedMotion` snaps the spring to target
+     * immediately — entrance becomes a no-op transform.
+     */
+    spring?: boolean | SpringPreset;
+};
+declare var __VLS_19: {};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_19) => any;
+};
+declare const __VLS_base: import("vue").DefineComponent<__VLS_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;
+    openAutoFocus: (event: Event) => any;
+    closeAutoFocus: (event: Event) => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_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;
+    onOpenAutoFocus?: ((event: Event) => any) | undefined;
+    onCloseAutoFocus?: ((event: Event) => any) | undefined;
+}>, {
+    variant: "glass" | "opaque";
+}, {}, {}, {}, 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/components/ui/dialog/DialogDescription.vue.d.ts

@@ -0,0 +1,18 @@
+import { type HTMLAttributes } from 'vue';
+import { type DialogDescriptionProps } from 'reka-ui';
+type __VLS_Props = DialogDescriptionProps & {
+    class?: HTMLAttributes['class'];
+};
+declare var __VLS_8: {};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_8) => 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_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/components/ui/dialog/DialogFooter.vue.d.ts

@@ -0,0 +1,17 @@
+import type { HTMLAttributes } from 'vue';
+type __VLS_Props = {
+    class?: HTMLAttributes['class'];
+};
+declare var __VLS_1: {};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_1) => 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_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/components/ui/dialog/DialogHeader.vue.d.ts

@@ -0,0 +1,17 @@
+import type { HTMLAttributes } from 'vue';
+type __VLS_Props = {
+    class?: HTMLAttributes['class'];
+};
+declare var __VLS_1: {};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_1) => 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_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/components/ui/dialog/DialogScrollContent.vue.d.ts

@@ -0,0 +1,33 @@
+import { type HTMLAttributes } from 'vue';
+import { type DialogContentProps } from 'reka-ui';
+type __VLS_Props = DialogContentProps & {
+    class?: HTMLAttributes['class'];
+    overlayClass?: HTMLAttributes['class'];
+};
+declare var __VLS_22: {};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_22) => any;
+};
+declare const __VLS_base: import("vue").DefineComponent<__VLS_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;
+    openAutoFocus: (event: Event) => any;
+    closeAutoFocus: (event: Event) => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_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;
+    onOpenAutoFocus?: ((event: Event) => any) | undefined;
+    onCloseAutoFocus?: ((event: Event) => any) | undefined;
+}>, {}, {}, {}, {}, 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/components/ui/dialog/DialogTitle.vue.d.ts

@@ -0,0 +1,18 @@
+import { type HTMLAttributes } from 'vue';
+import { type DialogTitleProps } from 'reka-ui';
+type __VLS_Props = DialogTitleProps & {
+    class?: HTMLAttributes['class'];
+};
+declare var __VLS_8: {};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_8) => 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_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/components/ui/dialog/DialogTrigger.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/components/ui/dialog/index.d.ts

@@ -0,0 +1,9 @@
+export { default as Dialog } from './Dialog.vue';
+export { default as DialogClose } from './DialogClose.vue';
+export { default as DialogTrigger } from './DialogTrigger.vue';
+export { default as DialogHeader } from './DialogHeader.vue';
+export { default as DialogTitle } from './DialogTitle.vue';
+export { default as DialogDescription } from './DialogDescription.vue';
+export { default as DialogContent } from './DialogContent.vue';
+export { default as DialogScrollContent } from './DialogScrollContent.vue';
+export { default as DialogFooter } from './DialogFooter.vue';

package/dist/components/ui/drawer/Drawer.vue.d.ts

@@ -0,0 +1,53 @@
+import type { DrawerRootProps } from 'vaul-vue';
+import type { DrawerMode } from './index';
+/**
+ * `mode` — additive shorthand (AN.W3). `"modal"` (default) keeps the iOS
+ * scale-down look: `shouldScaleBackground: true`, `modal: true`. `"live-behind"`
+ * bundles the non-modal peek/half/full bottom-sheet contract — `modal: false`
+ * (no focus trap, no page `aria-hidden`, page-behind stays interactive),
+ * `shouldScaleBackground: false` (page-behind stays at native size), and the
+ * default `snapPoints: [0.12, 0.5, 1]` detent ladder. Every prop the mode sets
+ * is still overridable by an explicit prop — `mode` only supplies defaults.
+ *
+ * NOTE: we do NOT route through `useForwardPropsEmits` here. That helper
+ * reflects only props the parent vnode actually passed (plus component-declared
+ * defaults), so the values our `resolved` computed derives for keys the consumer
+ * did NOT pass (e.g. `modal:false` under `mode="live-behind"`) would be dropped.
+ * Binding `resolved` directly + merging emit-as-props is the correct shape for a
+ * computed-default wrapper.
+ */
+type __VLS_Props = DrawerRootProps & {
+    mode?: DrawerMode;
+};
+declare var __VLS_8: {};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_8) => any;
+};
+declare const __VLS_base: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {} & {
+    close: () => any;
+    drag: (percentageDragged: number) => any;
+    "update:open": (open: boolean) => any;
+    release: (open: boolean) => any;
+    animationEnd: (open: boolean) => any;
+    "update:activeSnapPoint": (val: string | number) => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
+    onClose?: (() => any) | undefined;
+    onDrag?: ((percentageDragged: number) => any) | undefined;
+    "onUpdate:open"?: ((open: boolean) => any) | undefined;
+    onRelease?: ((open: boolean) => any) | undefined;
+    onAnimationEnd?: ((open: boolean) => any) | undefined;
+    "onUpdate:activeSnapPoint"?: ((val: string | number) => any) | undefined;
+}>, {
+    mode: DrawerMode;
+    modal: boolean;
+    shouldScaleBackground: boolean;
+    snapPoints: (number | 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/components/ui/drawer/DrawerContent.vue.d.ts

@@ -0,0 +1,43 @@
+import type { DialogContentProps } from 'reka-ui';
+import type { HtmlHTMLAttributes } from 'vue';
+/**
+ * `showOverlay` — render the scrim (AN.W3). Defaults `true` for the modal
+ * sheet. The live-behind pattern (`<Drawer mode="live-behind">`) passes
+ * `:show-overlay="false"` so the page-behind stays visible AND interactive;
+ * vaul-vue's `modal:false` already drops `disableOutsidePointerEvents`, but a
+ * painted scrim would still visually occlude the live verdict, so the overlay
+ * is opt-out at the content level.
+ */
+type __VLS_Props = DialogContentProps & {
+    class?: HtmlHTMLAttributes['class'];
+    showOverlay?: boolean;
+};
+declare var __VLS_19: {};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_19) => any;
+};
+declare const __VLS_base: import("vue").DefineComponent<__VLS_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;
+    openAutoFocus: (event: Event) => any;
+    closeAutoFocus: (event: Event) => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_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;
+    onOpenAutoFocus?: ((event: Event) => any) | undefined;
+    onCloseAutoFocus?: ((event: Event) => any) | undefined;
+}>, {
+    showOverlay: 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/components/ui/drawer/DrawerDescription.vue.d.ts

@@ -0,0 +1,18 @@
+import type { DrawerDescriptionProps } from 'vaul-vue';
+import { type HtmlHTMLAttributes } from 'vue';
+type __VLS_Props = DrawerDescriptionProps & {
+    class?: HtmlHTMLAttributes['class'];
+};
+declare var __VLS_8: {};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_8) => 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_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/components/ui/drawer/DrawerFooter.vue.d.ts

@@ -0,0 +1,17 @@
+import type { HtmlHTMLAttributes } from 'vue';
+type __VLS_Props = {
+    class?: HtmlHTMLAttributes['class'];
+};
+declare var __VLS_1: {};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_1) => 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_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;
+    };
+};