@mkbabb/glass-ui 0.2.0 → 2.0.0

package/dist/components/custom/typewriter/TypewriterText.vue.d.ts

@@ -0,0 +1,85 @@
+import type { TypewriterWord } from "./types";
+interface Props {
+    /** Single text to type. Use this OR `words`, not both. */
+    text?: string;
+    /** Array of words to cycle through in rotation mode. Use this OR `text`, not both. */
+    words?: TypewriterWord[];
+    ngramSize?: number | {
+        min: number;
+        max: number;
+    };
+    baseSpeed?: number;
+    variance?: number;
+    errorRate?: number;
+    firstAnimationSpeedFactor?: number;
+    maxCharsBeforeNotice?: number;
+    continueAfterTypoProbability?: number;
+    sequentialTypoDecay?: number;
+    correctionSpeedMultiplier?: number;
+    cursorVisible?: boolean;
+    cursorBlink?: boolean;
+    cursorChar?: string;
+    startDelay?: number;
+    loop?: boolean;
+    /** Pause after typing a word before deleting (ms). Word-rotation mode only. */
+    pauseAfterType?: number;
+    /** Pause after deleting a word before typing the next (ms). Word-rotation mode only. */
+    pauseAfterDelete?: number;
+    /** Backspace speed in word-rotation mode (ms per char). */
+    deletingSpeed?: number;
+    /** Whether clicking characters triggers interactive backspace. */
+    interactive?: boolean;
+    respectReducedMotion?: boolean;
+}
+declare const __VLS_export: import("vue").DefineComponent<Props, {
+    startTyping: () => Promise<void>;
+    stopTyping: () => void;
+    reset: () => void;
+    isTyping: import("vue").Ref<boolean, boolean>;
+    isDeleting: import("vue").Ref<boolean, boolean>;
+    currentWord: import("vue").ComputedRef<{
+        text: string;
+        className?: string | undefined;
+        isCode?: boolean | undefined;
+    }>;
+    currentWordIndex: import("vue").ComputedRef<number>;
+    pause: () => void;
+    resume: () => void;
+    setCharPosition: (n: number) => void;
+    forceWord: (idx: number, charPos: number) => void;
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    start: () => any;
+    complete: () => any;
+    wordComplete: (index: number) => any;
+}, string, import("vue").PublicProps, Readonly<Props> & Readonly<{
+    onStart?: (() => any) | undefined;
+    onComplete?: (() => any) | undefined;
+    onWordComplete?: ((index: number) => any) | undefined;
+}>, {
+    respectReducedMotion: boolean;
+    text: string;
+    loop: boolean;
+    words: TypewriterWord[];
+    ngramSize: number | {
+        min: number;
+        max: number;
+    };
+    baseSpeed: number;
+    variance: number;
+    errorRate: number;
+    firstAnimationSpeedFactor: number;
+    maxCharsBeforeNotice: number;
+    continueAfterTypoProbability: number;
+    sequentialTypoDecay: number;
+    correctionSpeedMultiplier: number;
+    cursorVisible: boolean;
+    cursorBlink: boolean;
+    cursorChar: string;
+    pauseAfterType: number;
+    pauseAfterDelete: number;
+    deletingSpeed: number;
+    startDelay: number;
+    interactive: boolean;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/components/custom/typewriter/composables/useTypewriter.d.ts

@@ -0,0 +1,22 @@
+import type { TypewriterOptions } from "../types";
+export declare function useTypewriter(options: TypewriterOptions): {
+    displayText: import("vue").Ref<string, string>;
+    isTyping: import("vue").Ref<boolean, boolean>;
+    isFirstAnimation: import("vue").Ref<boolean, boolean>;
+    isDeleting: import("vue").Ref<boolean, boolean>;
+    currentWordIndex: import("vue").ComputedRef<number>;
+    currentWord: import("vue").ComputedRef<{
+        text: string;
+        className?: string | undefined;
+        isCode?: boolean | undefined;
+    }>;
+    startTyping: () => Promise<void>;
+    stopTyping: () => void;
+    reset: () => void;
+    updateText: (newText: string) => void;
+    backspaceToPosition: (targetLength: number) => Promise<void>;
+    pause: () => void;
+    resume: () => void;
+    setCharPosition: (n: number) => void;
+    forceWord: (idx: number, charPos: number) => void;
+};

package/dist/components/custom/typewriter/types.d.ts

@@ -0,0 +1,137 @@
+import type { KeyPosition } from "./utils/keyboard";
+export type { KeyPosition };
+/** A single word entry for word-rotation mode. */
+export interface TypewriterWord {
+    /** The text to type. */
+    text: string;
+    /** Optional CSS class applied to the word span. */
+    className?: string;
+    /** Whether to render with a monospace/code style. */
+    isCode?: boolean;
+}
+export type TypoState = "normal" | "typo_injected" | "typing_past" | "noticed" | "correcting" | "resuming";
+export interface TypoContext {
+    state: TypoState;
+    /** Number of chars typed past the typo position */
+    charsPastTypo: number;
+    /** Total chars to delete when correcting (typo char + chars past) */
+    charsToDelete: number;
+    /** Number of sequential typos in this burst */
+    sequentialTypoCount: number;
+}
+export type TypoAction = {
+    type: "type_correct";
+    char: string;
+} | {
+    type: "type_wrong";
+    char: string;
+    intended: string;
+} | {
+    type: "type_past_correct";
+    char: string;
+} | {
+    type: "notice";
+    pauseMs: number;
+} | {
+    type: "backspace";
+    count: number;
+    frantic: boolean;
+} | {
+    type: "resume";
+    pauseMs: number;
+};
+export interface CancellationToken {
+    readonly cancelled: boolean;
+    cancel(): void;
+    onCancel(fn: () => void): void;
+    offCancel(fn: () => void): void;
+}
+export interface TypewriterOptions {
+    /** Single text to type. Mutually exclusive with `words`. */
+    text?: string;
+    /**
+     * Array of words to cycle through (word-rotation mode).
+     * When provided, the typewriter types each word, pauses, backspaces,
+     * then types the next word in a loop.
+     * Mutually exclusive with `text`.
+     */
+    words?: TypewriterWord[];
+    /** N-gram chunk size for typing. Fixed number or {min, max} range. */
+    ngramSize?: number | {
+        min: number;
+        max: number;
+    };
+    /** Base typing speed in ms per keystroke. */
+    baseSpeed?: number;
+    /** Speed variance factor (0-1). */
+    variance?: number;
+    /** Probability of introducing a typo per character (0-1). */
+    errorRate?: number;
+    /** Speed multiplier for the first animation pass (lower = faster). */
+    firstAnimationSpeedFactor?: number;
+    /** Maximum chars typed past a typo before noticing. */
+    maxCharsBeforeNotice?: number;
+    /** Probability of continuing to type after a typo (0-1). */
+    continueAfterTypoProbability?: number;
+    /** Decay factor for sequential typo probability (0-1). */
+    sequentialTypoDecay?: number;
+    /** Speed multiplier for correction typing (lower = faster). */
+    correctionSpeedMultiplier?: number;
+    /** Base delay for correction backspace in ms. */
+    correctionBaseDelay?: number;
+    /** Base delay for normal backspace in ms. */
+    backspaceBaseDelay?: number;
+    /** Acceleration factor for consecutive backspaces. */
+    backspaceAcceleration?: number;
+    /** Pause before starting backspace animation in ms. */
+    preBackspacePause?: number;
+    /** Pause after backspace animation before retyping in ms. */
+    postBackspacePause?: number;
+    /** Whether to show the cursor. */
+    cursorVisible?: boolean;
+    /** Whether the cursor blinks when idle. */
+    cursorBlink?: boolean;
+    /** Cursor character. */
+    cursorChar?: string;
+    /** Pause after fully typing a word before deleting (ms). Only for word-rotation mode. */
+    pauseAfterType?: number;
+    /** Pause after deleting a word before typing the next (ms). Only for word-rotation mode. */
+    pauseAfterDelete?: number;
+    /** Typing speed for deletion in word-rotation mode (ms). Falls back to backspaceBaseDelay. */
+    deletingSpeed?: number;
+    /** Respect prefers-reduced-motion media query. */
+    respectReducedMotion?: boolean;
+    /** Loop the single-text typing animation. */
+    loop?: boolean;
+    /** Callback when typing completes. */
+    onComplete?: () => void;
+    /** Callback when a word rotation completes (word-rotation mode). Receives the word index. */
+    onWordComplete?: (index: number) => void;
+}
+export declare const DEFAULTS: {
+    readonly ngramSize: {
+        min: number;
+        max: number;
+    };
+    readonly baseSpeed: 150;
+    readonly variance: 0.4;
+    readonly errorRate: 0.015;
+    readonly firstAnimationSpeedFactor: 0.6;
+    readonly maxCharsBeforeNotice: 4;
+    readonly continueAfterTypoProbability: 0.6;
+    readonly sequentialTypoDecay: 0.3;
+    readonly correctionSpeedMultiplier: 0.5;
+    readonly correctionBaseDelay: 40;
+    readonly backspaceBaseDelay: 30;
+    readonly backspaceAcceleration: 0.08;
+    readonly preBackspacePause: 200;
+    readonly postBackspacePause: 150;
+    readonly cursorVisible: true;
+    readonly cursorBlink: true;
+    readonly cursorChar: "|";
+    readonly pauseAfterType: 3000;
+    readonly pauseAfterDelete: 800;
+    readonly deletingSpeed: 70;
+    readonly respectReducedMotion: true;
+    readonly loop: false;
+};

package/dist/components/custom/typewriter/utils/keyboard.d.ts

@@ -0,0 +1,15 @@
+export interface KeyPosition {
+    row: number;
+    col: number;
+    finger: "pinky" | "ring" | "middle" | "index" | "thumb";
+    hand: "left" | "right";
+}
+export declare const QWERTY_MAP: Record<string, KeyPosition>;
+export declare const calculateKeyDelay: (prevChar: string, nextChar: string) => number;
+export declare function getAdjacentKeys(char: string): string[];
+/**
+ * Pick a plausible typo character for the intended character.
+ * Weighted: same-finger 2x, same-hand 1.5x, other 1x.
+ * Preserves case. Falls back to home row for unmapped chars.
+ */
+export declare function pickTypoChar(intendedChar: string): string;

package/dist/components/custom/typewriter/utils/pausePatterns.d.ts

@@ -0,0 +1,28 @@
+export interface PausePatterns {
+    sentenceEnd: {
+        min: number;
+        max: number;
+    };
+    commaBreak: {
+        min: number;
+        max: number;
+    };
+    wordBoundary: {
+        min: number;
+        max: number;
+    };
+    thinkingPause: {
+        min: number;
+        max: number;
+    };
+    colonPause: {
+        min: number;
+        max: number;
+    };
+    dashPause: {
+        min: number;
+        max: number;
+    };
+}
+export declare const PAUSE_PATTERNS: PausePatterns;
+export declare const getPauseDelay: (char: string, nextChar: string, patterns: PausePatterns) => number;

package/dist/components/custom/typewriter/utils/timing.d.ts

@@ -0,0 +1,17 @@
+import type { CancellationToken } from "../types";
+export declare function createCancellationToken(): CancellationToken;
+/** Resolves `true` if elapsed normally, `false` if cancelled. */
+export declare function sleep(ms: number, token: CancellationToken): Promise<boolean>;
+/** Uniform noise around base: `base * (1 + uniform(-variance, +variance))`, clamped to [min, max]. */
+export declare function stochasticDelay(base: number, variance: number, min?: number, max?: number): number;
+/** Accelerating backspace delay: gets faster with each consecutive backspace. */
+export declare function backspaceDelay(base: number, variance: number, index: number, acceleration: number): number;
+/** Pick n-gram size. Fixed number passthrough, or geometric distribution biased small. */
+export declare function pickNgramSize(config: number | {
+    min: number;
+    max: number;
+}): number;
+/** Uniform random integer in [min, max] (inclusive). */
+export declare function randomInRange(min: number, max: number): number;
+/** Check if user prefers reduced motion. SSR-safe. */
+export declare function prefersReducedMotion(): boolean;

package/dist/components/custom/typewriter/utils/typoStateMachine.d.ts

@@ -0,0 +1,24 @@
+import type { TypoContext, TypoAction } from "../types";
+export interface TypoConfig {
+    maxCharsBeforeNotice: number;
+    continueAfterTypoProbability: number;
+    sequentialTypoDecay: number;
+    noticePauseMin: number;
+    noticePauseMax: number;
+    resumePauseMin: number;
+    resumePauseMax: number;
+}
+export declare const DEFAULT_TYPO_CONFIG: TypoConfig;
+export declare function createTypoContext(): TypoContext;
+/**
+ * Pure FSM transition.
+ *
+ * States: normal -> typo_injected -> typing_past -> noticed -> correcting -> resuming -> normal
+ *
+ * The caller provides the intended character(s) at the current position.
+ * Returns the action to perform and the new context.
+ */
+export declare function nextTypoAction(ctx: TypoContext, intendedChar: string, config: TypoConfig, errorRate: number): {
+    action: TypoAction;
+    ctx: TypoContext;
+};

package/dist/components/ui/_shared/ModalOverlay.vue.d.ts

@@ -0,0 +1,90 @@
+import { type HTMLAttributes } from "vue";
+/**
+ * ModalOverlay — canonical wrapper for Dialog / Sheet / AlertDialog scrim
+ * declarations (V.W3.T4 / A5 §4). Three near-bit-identical class strings
+ * (DialogContent, DialogScrollContent, SheetContent) collapse onto one
+ * primitive parameterised by:
+ *
+ * - `scrim`: `glass` (default — `bg-overlay-scrim`) | `dim`
+ *   (`bg-overlay-scrim-strong`) | `clear` (`bg-overlay-scrim-subtle`)
+ * - `animate`: `fade` (default — composes `.sheet-animate`) | `scale`
+ *   | `slide` | `none` (Drawer / vaul-vue case)
+ * - `layout`: `centered` (default flat overlay) | `edge` (reserved alias —
+ *   maps to no-op today; held for future right/bottom edge-pinned overlays
+ *   per A5 §4.4 forward-reservation) | `scroll` (the DialogScrollContent
+ *   pattern: grid place-items-center overflow-y-auto so content scrolls
+ *   inside the scrim)
+ * - `scrimAnimation` (AJ-W4-δ): a CSS `animation` shorthand value forwarded
+ *   to the portaled overlay element via the typed `--scrim-animation`
+ *   cascade variable. Consumers that need a long-running scrim-breath
+ *   (e.g. CellularWarningDialog's slow opacity pulse) cannot reach the
+ *   portaled overlay through their scoped CSS — reka-ui's DialogPortal
+ *   teleports it outside the consumer's component subtree. The publisher
+ *   owns the bridge: the prop value lands as `--scrim-animation` on the
+ *   overlay's inline style, and the rule
+ *   `[data-scrim-animation] { animation: var(--scrim-animation, none) }`
+ *   in the canonical animations.css consumes it.
+ *
+ * Drawer / vaul-vue stays carved per A5 §4.4 — its transform-driven motion
+ * conflicts with `.sheet-animate`'s data-state animation, and the
+ * vaul-vue overlay is a different reka-ui primitive entirely.
+ */
+interface ModalOverlayProps {
+    class?: HTMLAttributes["class"];
+    /**
+     * Scrim intensity. `glass` reads `--overlay-scrim` (the default Dialog /
+     * Sheet paint); `clear` reads `--overlay-scrim-subtle` (DialogScrollContent
+     * — quieter so chassis content shows through); `dim` reads
+     * `--overlay-scrim-strong` (Drawer / heavy-modal host).
+     */
+    scrim?: "glass" | "clear" | "dim";
+    /**
+     * Animation grammar. `fade` enables the canonical `.sheet-animate`
+     * data-state pair (Dialog, Sheet); `none` skips it for hosts whose
+     * portal library drives its own motion.
+     */
+    animate?: "fade" | "scale" | "slide" | "none";
+    /**
+     * Layout — `centered` is the default flat overlay. `scroll` adds
+     * `grid place-items-center overflow-y-auto` so content scrolls inside
+     * the scrim (DialogScrollContent's "scrollable centred dialog" pattern).
+     * `edge` is a forward-reserved alias that maps to no-op today (held for
+     * future right/bottom edge-pinned overlays per A5 §4.4).
+     */
+    layout?: "centered" | "edge" | "scroll";
+    /**
+     * Optional CSS `animation` shorthand applied to the portaled overlay
+     * via the `--scrim-animation` typed cascade variable. Pairs with the
+     * `[data-scrim-animation] { animation: var(--scrim-animation, none) }`
+     * rule in `animations.css` so consumers can drive a long-running
+     * scrim-breath without owning the portal traversal. Composes with the
+     * `animate="fade"` data-state enter/exit (the fade rides
+     * `tw-animate-css` keyframes on `data-[state]`; the scrim-breath
+     * rides the typed variable on `data-scrim-animation` — distinct
+     * selectors, no cascade fight).
+     *
+     * Example: `scrimAnimation="scrim-breath 6s ease-in-out infinite"`
+     * — pairs with a `@keyframes scrim-breath` declared at the consumer
+     * (or in `animations.css` if the rhythm is canonical).
+     *
+     * AJ-W4-δ.
+     */
+    scrimAnimation?: string;
+}
+declare var __VLS_8: {};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_8) => any;
+};
+declare const __VLS_base: import("vue").DefineComponent<ModalOverlayProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<ModalOverlayProps> & Readonly<{}>, {
+    animate: "fade" | "scale" | "slide" | "none";
+    scrim: "glass" | "clear" | "dim";
+    layout: "centered" | "edge" | "scroll";
+}, {}, {}, {}, 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/_shared/index.d.ts

@@ -0,0 +1,2 @@
+export { menuItemVariants } from "./menuItemVariants";
+export type { MenuItemVariants } from "./menuItemVariants";

package/dist/components/ui/_shared/menuItemVariants.d.ts

@@ -0,0 +1,32 @@
+import { type VariantProps } from "class-variance-authority";
+/**
+ * `menuItemVariants` — canonical CVA shared by 9 menu-family + picker-family
+ * primitives. Promotes the four-state contract (hover / focus / data-highlighted /
+ * data-disabled) above reka-ui's base classes so consumer-side overrides win
+ * via `cn()`'s tailwind-merge ordering.
+ *
+ * Substrate composition:
+ * - `interactive-item` (utilities.css) provides `border-radius: var(--radius-lg)`,
+ *   the active-scale (`:active { transform: scale(0.98); }`), the focus-visible
+ *   box-shadow ring, and the `data-disabled` paint extension (V.W3 patch — the
+ *   :disabled pseudo doesn't fire on reka-ui's `data-disabled="true"` attr,
+ *   so utilities.css now paints both).
+ *
+ * Three input modes paint identical hover/focus accent:
+ * - `:hover` — pointer hover.
+ * - `:focus` — keyboard focus (also handled at the substrate via :focus-visible).
+ * - `[data-highlighted]` — reka-ui's internal navigation highlight (Combobox /
+ *   Command / Select families emit this attr instead of relying on browser focus).
+ *
+ * The CVA composes ABOVE reka-ui's base classes (R4 §4.2 pre-empt): consumer
+ * SFCs call `menuItemVariants(...)` last in the `cn()` chain so any radius /
+ * background / spacing the upstream library writes is overridden.
+ *
+ * Indicator slot variants reserve the gutter for radio-dot / check / chevron
+ * indicator spans the consumer SFCs render absolutely-positioned.
+ */
+export declare const menuItemVariants: (props?: ({
+    indicator?: "none" | "start" | "start-wide" | null | undefined;
+    density?: "comfortable" | "audacious" | null | undefined;
+} & import("class-variance-authority/types").ClassProp) | undefined) => string;
+export type MenuItemVariants = VariantProps<typeof menuItemVariants>;

package/dist/components/ui/_shared/useStalePropWarning.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Canonical stale / undeclared prop names the glass-ui surface primitives
+ * watch for. Each entry pairs the dead prop with the canonical replacement
+ * recipe quoted verbatim in the dev-warning.
+ *
+ * EXTENSIBLE SEAM — W6's typed-reject hardening promotes these into the
+ * primitives' `defineProps` unions. Add new stale names here (one place),
+ * not at the call sites.
+ */
+export declare const STALE_PROP_RECIPES: {
+    /** Pre-glass-ui `Card` API axis. Never existed on the glass-ui `Card`. */
+    readonly variant: "variant=\"pane\" → tier=\"wash\" :grain=\"false\"  (variant=\"cartoon\" → surface=\"cartoon\")";
+    /** bbnf-buddy `<Card variant="pane" flush>` — `flush` was never a glass-ui prop. */
+    readonly flush: "flush → class=\"p-0\"  (padding is a consumer utility, not a Card prop)";
+};
+/** Union of the stale prop names — the W6 typed-reject seam. */
+export type StalePropName = keyof typeof STALE_PROP_RECIPES;
+/**
+ * Dev-mode watcher: warns when a stale prop name falls through to a
+ * primitive's `$attrs`. No-op in production (`import.meta.env.DEV` gate).
+ *
+ * @param componentName  the primitive's display name, used in the warning.
+ * @param staleNames     which stale names to watch — defaults to all of
+ *                       `STALE_PROP_RECIPES`. A primitive that legitimately
+ *                       declares one of these names passes a narrowed list.
+ */
+export declare function useStalePropWarning(componentName: string, staleNames?: readonly StalePropName[]): void;

package/dist/components/ui/accordion/Accordion.vue.d.ts

@@ -0,0 +1,19 @@
+import { type AccordionRootProps } from 'reka-ui';
+type __VLS_Props = AccordionRootProps;
+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, {
+    "update:modelValue": (value: string | string[] | undefined) => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
+    "onUpdate:modelValue"?: ((value: string | string[] | undefined) => 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/accordion/AccordionContent.vue.d.ts

@@ -0,0 +1,18 @@
+import { type HTMLAttributes } from 'vue';
+import { type AccordionContentProps } from 'reka-ui';
+type __VLS_Props = AccordionContentProps & {
+    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/accordion/AccordionItem.vue.d.ts

@@ -0,0 +1,18 @@
+import { type HTMLAttributes } from 'vue';
+import { type AccordionItemProps } from 'reka-ui';
+type __VLS_Props = AccordionItemProps & {
+    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/accordion/AccordionTrigger.vue.d.ts

@@ -0,0 +1,20 @@
+import { type HTMLAttributes } from 'vue';
+import { type AccordionTriggerProps } from 'reka-ui';
+type __VLS_Props = AccordionTriggerProps & {
+    class?: HTMLAttributes['class'];
+};
+declare var __VLS_14: {}, __VLS_16: {};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_14) => any;
+} & {
+    icon?: (props: typeof __VLS_16) => 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/accordion/index.d.ts

@@ -0,0 +1,4 @@
+export { default as Accordion } from './Accordion.vue';
+export { default as AccordionContent } from './AccordionContent.vue';
+export { default as AccordionItem } from './AccordionItem.vue';
+export { default as AccordionTrigger } from './AccordionTrigger.vue';

package/dist/components/ui/alert/Alert.vue.d.ts

@@ -0,0 +1,19 @@
+import type { HTMLAttributes } from 'vue';
+import { type AlertVariants } from '.';
+type __VLS_Props = {
+    class?: HTMLAttributes['class'];
+    variant?: AlertVariants['variant'];
+};
+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/alert/AlertDescription.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/alert/AlertTitle.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/alert/index.d.ts

@@ -0,0 +1,8 @@
+import { type VariantProps } from 'class-variance-authority';
+export { default as Alert } from './Alert.vue';
+export { default as AlertDescription } from './AlertDescription.vue';
+export { default as AlertTitle } from './AlertTitle.vue';
+export declare const alertVariants: (props?: ({
+    variant?: "default" | "destructive" | null | undefined;
+} & import("class-variance-authority/types").ClassProp) | undefined) => string;
+export type AlertVariants = VariantProps<typeof alertVariants>;