@vadimcomanescu/nadicode-design-system 2.0.0

package/dist/components/ui/Form.js

@@ -0,0 +1,4 @@
+'use client';
+export { Form, FormControl, FormDescription, FormField, FormItem, FormLabel, FormMessage, useFormField } from '../../chunk-UN2SJ42K.js';
+import '../../chunk-LIBXYD5Q.js';
+import '../../chunk-QYZT24TS.js';

package/dist/components/ui/FormWizard.d.ts

@@ -0,0 +1,31 @@
+import * as React from "react";
+import { type VariantProps } from "class-variance-authority";
+declare const formWizardVariants: (props?: ({
+    variant?: "default" | "card" | null | undefined;
+    size?: "default" | "lg" | "sm" | null | undefined;
+} & import("class-variance-authority/types").ClassProp) | undefined) => string;
+export interface WizardStep {
+    id: string;
+    title: string;
+    description?: string;
+    content: React.ReactNode;
+    /** Optional validation, return true if step is valid */
+    validate?: () => boolean;
+}
+export interface FormWizardProps extends React.HTMLAttributes<HTMLDivElement>, VariantProps<typeof formWizardVariants> {
+    steps: WizardStep[];
+    /** Current step index (controlled) */
+    activeStep?: number;
+    /** Called when step changes */
+    onStepChange?: (step: number) => void;
+    /** Called when wizard is completed (last step next) */
+    onComplete?: () => void;
+    /** Custom labels */
+    nextLabel?: string;
+    backLabel?: string;
+    completeLabel?: string;
+}
+declare function FormWizard({ className, variant, size, steps, activeStep: controlledStep, onStepChange, onComplete, nextLabel, backLabel, completeLabel, ref, ...props }: FormWizardProps & {
+    ref?: React.Ref<HTMLDivElement>;
+}): import("react/jsx-runtime").JSX.Element;
+export { FormWizard, formWizardVariants };

package/dist/components/ui/FormWizard.js

@@ -0,0 +1,9 @@
+'use client';
+export { FormWizard, formWizardVariants } from '../../chunk-T5LXQNIP.js';
+import '../../chunk-7KIDDF3I.js';
+import '../../chunk-PD2YEH3H.js';
+import '../../chunk-CRY67BIF.js';
+import '../../chunk-HJC6U46F.js';
+import '../../chunk-CXACRCZ4.js';
+import '../../chunk-ASKFAYYR.js';
+import '../../chunk-QYZT24TS.js';

package/dist/components/ui/HandoffIndicator.d.ts

@@ -0,0 +1,14 @@
+import * as React from "react";
+type AgentInfo = {
+    name: string;
+    avatar?: React.ReactNode;
+};
+export interface HandoffIndicatorProps extends React.HTMLAttributes<HTMLDivElement> {
+    fromAgent: AgentInfo;
+    toAgent: AgentInfo;
+    reason?: string;
+}
+declare function HandoffIndicator({ className, fromAgent, toAgent, reason, ref, ...props }: HandoffIndicatorProps & {
+    ref?: React.Ref<HTMLDivElement>;
+}): import("react/jsx-runtime").JSX.Element;
+export { HandoffIndicator };

package/dist/components/ui/HandoffIndicator.js

@@ -0,0 +1,46 @@
+'use client';
+import { m, motionSpring } from '../../chunk-PD2YEH3H.js';
+import '../../chunk-CRY67BIF.js';
+import '../../chunk-HJC6U46F.js';
+import { ArrowRightIcon } from '../../chunk-T7H53CK2.js';
+import '../../chunk-ASKFAYYR.js';
+import { cn } from '../../chunk-QYZT24TS.js';
+import { useReducedMotion } from 'motion/react';
+import { jsxs, jsx } from 'react/jsx-runtime';
+
+var AgentChip = ({ agent }) => /* @__PURE__ */ jsxs("div", { className: "flex items-center gap-2", children: [
+  agent.avatar && /* @__PURE__ */ jsx("div", { className: "flex-shrink-0", children: agent.avatar }),
+  /* @__PURE__ */ jsx("span", { className: "text-sm font-medium text-text-primary", children: agent.name })
+] });
+function HandoffIndicator({ className, fromAgent, toAgent, reason, ref, ...props }) {
+  const prefersReduced = useReducedMotion();
+  return /* @__PURE__ */ jsxs(
+    "div",
+    {
+      ref,
+      className: cn(
+        "inline-flex flex-col items-center gap-1.5 rounded-lg border border-border glass-panel p-4",
+        className
+      ),
+      ...props,
+      children: [
+        /* @__PURE__ */ jsxs("div", { className: "flex items-center gap-4", children: [
+          /* @__PURE__ */ jsx(AgentChip, { agent: fromAgent }),
+          /* @__PURE__ */ jsx(
+            m.div,
+            {
+              initial: prefersReduced ? void 0 : { x: -6, opacity: 0 },
+              animate: prefersReduced ? void 0 : { x: 0, opacity: 1 },
+              transition: prefersReduced ? void 0 : motionSpring.snappy,
+              children: /* @__PURE__ */ jsx(ArrowRightIcon, { size: 18, className: "text-accent" })
+            }
+          ),
+          /* @__PURE__ */ jsx(AgentChip, { agent: toAgent })
+        ] }),
+        !!reason && /* @__PURE__ */ jsx("span", { className: "text-xs text-text-tertiary", children: reason })
+      ]
+    }
+  );
+}
+
+export { HandoffIndicator };

package/dist/components/ui/Heading.d.ts

@@ -0,0 +1,293 @@
+import * as React from "react";
+import { type VariantProps } from "class-variance-authority";
+export declare const headingVariants: (props?: ({
+    size?: "title" | "display" | "label" | "section" | "subsection" | "eyebrow" | null | undefined;
+} & import("class-variance-authority/types").ClassProp) | undefined) => string;
+export type HeadingLevel = 1 | 2 | 3 | 4 | 5 | 6;
+export interface HeadingProps extends React.HTMLAttributes<HTMLHeadingElement>, VariantProps<typeof headingVariants> {
+    level?: HeadingLevel;
+    ref?: React.Ref<HTMLHeadingElement>;
+}
+export declare function Heading({ className, level, size, ref, ...props }: HeadingProps): React.DetailedReactHTMLElement<{
+    ref: React.Ref<HTMLHeadingElement> | undefined;
+    className: string;
+    defaultChecked?: boolean | undefined;
+    defaultValue?: string | number | readonly string[] | undefined;
+    suppressContentEditableWarning?: boolean | undefined;
+    suppressHydrationWarning?: boolean | undefined;
+    accessKey?: string | undefined;
+    autoCapitalize?: "off" | "none" | "on" | "sentences" | "words" | "characters" | undefined | (string & {});
+    autoFocus?: boolean | undefined;
+    contentEditable?: (boolean | "true" | "false") | "inherit" | "plaintext-only" | undefined;
+    contextMenu?: string | undefined;
+    dir?: string | undefined;
+    draggable?: (boolean | "true" | "false") | undefined;
+    enterKeyHint?: "enter" | "done" | "go" | "next" | "previous" | "search" | "send" | undefined;
+    hidden?: boolean | undefined;
+    id?: string | undefined;
+    lang?: string | undefined;
+    nonce?: string | undefined;
+    slot?: string | undefined;
+    spellCheck?: (boolean | "true" | "false") | undefined;
+    style?: React.CSSProperties | undefined;
+    tabIndex?: number | undefined;
+    title?: string | undefined;
+    translate?: "yes" | "no" | undefined;
+    radioGroup?: string | undefined;
+    role?: React.AriaRole | undefined;
+    about?: string | undefined;
+    content?: string | undefined;
+    datatype?: string | undefined;
+    inlist?: any;
+    prefix?: string | undefined;
+    property?: string | undefined;
+    rel?: string | undefined;
+    resource?: string | undefined;
+    rev?: string | undefined;
+    typeof?: string | undefined;
+    vocab?: string | undefined;
+    autoCorrect?: string | undefined;
+    autoSave?: string | undefined;
+    color?: string | undefined;
+    itemProp?: string | undefined;
+    itemScope?: boolean | undefined;
+    itemType?: string | undefined;
+    itemID?: string | undefined;
+    itemRef?: string | undefined;
+    results?: number | undefined;
+    security?: string | undefined;
+    unselectable?: "on" | "off" | undefined;
+    popover?: "" | "auto" | "manual" | "hint" | undefined;
+    popoverTargetAction?: "toggle" | "show" | "hide" | undefined;
+    popoverTarget?: string | undefined;
+    inert?: boolean | undefined;
+    inputMode?: "none" | "text" | "tel" | "url" | "email" | "numeric" | "decimal" | "search" | undefined;
+    is?: string | undefined;
+    exportparts?: string | undefined;
+    part?: string | undefined;
+    "aria-activedescendant"?: string | undefined;
+    "aria-atomic"?: (boolean | "true" | "false") | undefined;
+    "aria-autocomplete"?: "none" | "inline" | "list" | "both" | undefined;
+    "aria-braillelabel"?: string | undefined;
+    "aria-brailleroledescription"?: string | undefined;
+    "aria-busy"?: (boolean | "true" | "false") | undefined;
+    "aria-checked"?: boolean | "false" | "mixed" | "true" | undefined;
+    "aria-colcount"?: number | undefined;
+    "aria-colindex"?: number | undefined;
+    "aria-colindextext"?: string | undefined;
+    "aria-colspan"?: number | undefined;
+    "aria-controls"?: string | undefined;
+    "aria-current"?: boolean | "false" | "true" | "page" | "step" | "location" | "date" | "time" | undefined;
+    "aria-describedby"?: string | undefined;
+    "aria-description"?: string | undefined;
+    "aria-details"?: string | undefined;
+    "aria-disabled"?: (boolean | "true" | "false") | undefined;
+    "aria-dropeffect"?: "none" | "copy" | "execute" | "link" | "move" | "popup" | undefined;
+    "aria-errormessage"?: string | undefined;
+    "aria-expanded"?: (boolean | "true" | "false") | undefined;
+    "aria-flowto"?: string | undefined;
+    "aria-grabbed"?: (boolean | "true" | "false") | undefined;
+    "aria-haspopup"?: boolean | "false" | "true" | "menu" | "listbox" | "tree" | "grid" | "dialog" | undefined;
+    "aria-hidden"?: (boolean | "true" | "false") | undefined;
+    "aria-invalid"?: boolean | "false" | "true" | "grammar" | "spelling" | undefined;
+    "aria-keyshortcuts"?: string | undefined;
+    "aria-label"?: string | undefined;
+    "aria-labelledby"?: string | undefined;
+    "aria-level"?: number | undefined;
+    "aria-live"?: "off" | "assertive" | "polite" | undefined;
+    "aria-modal"?: (boolean | "true" | "false") | undefined;
+    "aria-multiline"?: (boolean | "true" | "false") | undefined;
+    "aria-multiselectable"?: (boolean | "true" | "false") | undefined;
+    "aria-orientation"?: "horizontal" | "vertical" | undefined;
+    "aria-owns"?: string | undefined;
+    "aria-placeholder"?: string | undefined;
+    "aria-posinset"?: number | undefined;
+    "aria-pressed"?: boolean | "false" | "mixed" | "true" | undefined;
+    "aria-readonly"?: (boolean | "true" | "false") | undefined;
+    "aria-relevant"?: "additions" | "additions removals" | "additions text" | "all" | "removals" | "removals additions" | "removals text" | "text" | "text additions" | "text removals" | undefined;
+    "aria-required"?: (boolean | "true" | "false") | undefined;
+    "aria-roledescription"?: string | undefined;
+    "aria-rowcount"?: number | undefined;
+    "aria-rowindex"?: number | undefined;
+    "aria-rowindextext"?: string | undefined;
+    "aria-rowspan"?: number | undefined;
+    "aria-selected"?: (boolean | "true" | "false") | undefined;
+    "aria-setsize"?: number | undefined;
+    "aria-sort"?: "none" | "ascending" | "descending" | "other" | undefined;
+    "aria-valuemax"?: number | undefined;
+    "aria-valuemin"?: number | undefined;
+    "aria-valuenow"?: number | undefined;
+    "aria-valuetext"?: string | undefined;
+    children?: React.ReactNode | undefined;
+    dangerouslySetInnerHTML?: {
+        __html: string | TrustedHTML;
+    } | undefined;
+    onCopy?: React.ClipboardEventHandler<HTMLHeadingElement> | undefined;
+    onCopyCapture?: React.ClipboardEventHandler<HTMLHeadingElement> | undefined;
+    onCut?: React.ClipboardEventHandler<HTMLHeadingElement> | undefined;
+    onCutCapture?: React.ClipboardEventHandler<HTMLHeadingElement> | undefined;
+    onPaste?: React.ClipboardEventHandler<HTMLHeadingElement> | undefined;
+    onPasteCapture?: React.ClipboardEventHandler<HTMLHeadingElement> | undefined;
+    onCompositionEnd?: React.CompositionEventHandler<HTMLHeadingElement> | undefined;
+    onCompositionEndCapture?: React.CompositionEventHandler<HTMLHeadingElement> | undefined;
+    onCompositionStart?: React.CompositionEventHandler<HTMLHeadingElement> | undefined;
+    onCompositionStartCapture?: React.CompositionEventHandler<HTMLHeadingElement> | undefined;
+    onCompositionUpdate?: React.CompositionEventHandler<HTMLHeadingElement> | undefined;
+    onCompositionUpdateCapture?: React.CompositionEventHandler<HTMLHeadingElement> | undefined;
+    onFocus?: React.FocusEventHandler<HTMLHeadingElement> | undefined;
+    onFocusCapture?: React.FocusEventHandler<HTMLHeadingElement> | undefined;
+    onBlur?: React.FocusEventHandler<HTMLHeadingElement> | undefined;
+    onBlurCapture?: React.FocusEventHandler<HTMLHeadingElement> | undefined;
+    onChange?: React.FormEventHandler<HTMLHeadingElement> | undefined;
+    onChangeCapture?: React.FormEventHandler<HTMLHeadingElement> | undefined;
+    onBeforeInput?: React.InputEventHandler<HTMLHeadingElement> | undefined;
+    onBeforeInputCapture?: React.FormEventHandler<HTMLHeadingElement> | undefined;
+    onInput?: React.FormEventHandler<HTMLHeadingElement> | undefined;
+    onInputCapture?: React.FormEventHandler<HTMLHeadingElement> | undefined;
+    onReset?: React.FormEventHandler<HTMLHeadingElement> | undefined;
+    onResetCapture?: React.FormEventHandler<HTMLHeadingElement> | undefined;
+    onSubmit?: React.FormEventHandler<HTMLHeadingElement> | undefined;
+    onSubmitCapture?: React.FormEventHandler<HTMLHeadingElement> | undefined;
+    onInvalid?: React.FormEventHandler<HTMLHeadingElement> | undefined;
+    onInvalidCapture?: React.FormEventHandler<HTMLHeadingElement> | undefined;
+    onLoad?: React.ReactEventHandler<HTMLHeadingElement> | undefined;
+    onLoadCapture?: React.ReactEventHandler<HTMLHeadingElement> | undefined;
+    onError?: React.ReactEventHandler<HTMLHeadingElement> | undefined;
+    onErrorCapture?: React.ReactEventHandler<HTMLHeadingElement> | undefined;
+    onKeyDown?: React.KeyboardEventHandler<HTMLHeadingElement> | undefined;
+    onKeyDownCapture?: React.KeyboardEventHandler<HTMLHeadingElement> | undefined;
+    onKeyPress?: React.KeyboardEventHandler<HTMLHeadingElement> | undefined;
+    onKeyPressCapture?: React.KeyboardEventHandler<HTMLHeadingElement> | undefined;
+    onKeyUp?: React.KeyboardEventHandler<HTMLHeadingElement> | undefined;
+    onKeyUpCapture?: React.KeyboardEventHandler<HTMLHeadingElement> | undefined;
+    onAbort?: React.ReactEventHandler<HTMLHeadingElement> | undefined;
+    onAbortCapture?: React.ReactEventHandler<HTMLHeadingElement> | undefined;
+    onCanPlay?: React.ReactEventHandler<HTMLHeadingElement> | undefined;
+    onCanPlayCapture?: React.ReactEventHandler<HTMLHeadingElement> | undefined;
+    onCanPlayThrough?: React.ReactEventHandler<HTMLHeadingElement> | undefined;
+    onCanPlayThroughCapture?: React.ReactEventHandler<HTMLHeadingElement> | undefined;
+    onDurationChange?: React.ReactEventHandler<HTMLHeadingElement> | undefined;
+    onDurationChangeCapture?: React.ReactEventHandler<HTMLHeadingElement> | undefined;
+    onEmptied?: React.ReactEventHandler<HTMLHeadingElement> | undefined;
+    onEmptiedCapture?: React.ReactEventHandler<HTMLHeadingElement> | undefined;
+    onEncrypted?: React.ReactEventHandler<HTMLHeadingElement> | undefined;
+    onEncryptedCapture?: React.ReactEventHandler<HTMLHeadingElement> | undefined;
+    onEnded?: React.ReactEventHandler<HTMLHeadingElement> | undefined;
+    onEndedCapture?: React.ReactEventHandler<HTMLHeadingElement> | undefined;
+    onLoadedData?: React.ReactEventHandler<HTMLHeadingElement> | undefined;
+    onLoadedDataCapture?: React.ReactEventHandler<HTMLHeadingElement> | undefined;
+    onLoadedMetadata?: React.ReactEventHandler<HTMLHeadingElement> | undefined;
+    onLoadedMetadataCapture?: React.ReactEventHandler<HTMLHeadingElement> | undefined;
+    onLoadStart?: React.ReactEventHandler<HTMLHeadingElement> | undefined;
+    onLoadStartCapture?: React.ReactEventHandler<HTMLHeadingElement> | undefined;
+    onPause?: React.ReactEventHandler<HTMLHeadingElement> | undefined;
+    onPauseCapture?: React.ReactEventHandler<HTMLHeadingElement> | undefined;
+    onPlay?: React.ReactEventHandler<HTMLHeadingElement> | undefined;
+    onPlayCapture?: React.ReactEventHandler<HTMLHeadingElement> | undefined;
+    onPlaying?: React.ReactEventHandler<HTMLHeadingElement> | undefined;
+    onPlayingCapture?: React.ReactEventHandler<HTMLHeadingElement> | undefined;
+    onProgress?: React.ReactEventHandler<HTMLHeadingElement> | undefined;
+    onProgressCapture?: React.ReactEventHandler<HTMLHeadingElement> | undefined;
+    onRateChange?: React.ReactEventHandler<HTMLHeadingElement> | undefined;
+    onRateChangeCapture?: React.ReactEventHandler<HTMLHeadingElement> | undefined;
+    onSeeked?: React.ReactEventHandler<HTMLHeadingElement> | undefined;
+    onSeekedCapture?: React.ReactEventHandler<HTMLHeadingElement> | undefined;
+    onSeeking?: React.ReactEventHandler<HTMLHeadingElement> | undefined;
+    onSeekingCapture?: React.ReactEventHandler<HTMLHeadingElement> | undefined;
+    onStalled?: React.ReactEventHandler<HTMLHeadingElement> | undefined;
+    onStalledCapture?: React.ReactEventHandler<HTMLHeadingElement> | undefined;
+    onSuspend?: React.ReactEventHandler<HTMLHeadingElement> | undefined;
+    onSuspendCapture?: React.ReactEventHandler<HTMLHeadingElement> | undefined;
+    onTimeUpdate?: React.ReactEventHandler<HTMLHeadingElement> | undefined;
+    onTimeUpdateCapture?: React.ReactEventHandler<HTMLHeadingElement> | undefined;
+    onVolumeChange?: React.ReactEventHandler<HTMLHeadingElement> | undefined;
+    onVolumeChangeCapture?: React.ReactEventHandler<HTMLHeadingElement> | undefined;
+    onWaiting?: React.ReactEventHandler<HTMLHeadingElement> | undefined;
+    onWaitingCapture?: React.ReactEventHandler<HTMLHeadingElement> | undefined;
+    onAuxClick?: React.MouseEventHandler<HTMLHeadingElement> | undefined;
+    onAuxClickCapture?: React.MouseEventHandler<HTMLHeadingElement> | undefined;
+    onClick?: React.MouseEventHandler<HTMLHeadingElement> | undefined;
+    onClickCapture?: React.MouseEventHandler<HTMLHeadingElement> | undefined;
+    onContextMenu?: React.MouseEventHandler<HTMLHeadingElement> | undefined;
+    onContextMenuCapture?: React.MouseEventHandler<HTMLHeadingElement> | undefined;
+    onDoubleClick?: React.MouseEventHandler<HTMLHeadingElement> | undefined;
+    onDoubleClickCapture?: React.MouseEventHandler<HTMLHeadingElement> | undefined;
+    onDrag?: React.DragEventHandler<HTMLHeadingElement> | undefined;
+    onDragCapture?: React.DragEventHandler<HTMLHeadingElement> | undefined;
+    onDragEnd?: React.DragEventHandler<HTMLHeadingElement> | undefined;
+    onDragEndCapture?: React.DragEventHandler<HTMLHeadingElement> | undefined;
+    onDragEnter?: React.DragEventHandler<HTMLHeadingElement> | undefined;
+    onDragEnterCapture?: React.DragEventHandler<HTMLHeadingElement> | undefined;
+    onDragExit?: React.DragEventHandler<HTMLHeadingElement> | undefined;
+    onDragExitCapture?: React.DragEventHandler<HTMLHeadingElement> | undefined;
+    onDragLeave?: React.DragEventHandler<HTMLHeadingElement> | undefined;
+    onDragLeaveCapture?: React.DragEventHandler<HTMLHeadingElement> | undefined;
+    onDragOver?: React.DragEventHandler<HTMLHeadingElement> | undefined;
+    onDragOverCapture?: React.DragEventHandler<HTMLHeadingElement> | undefined;
+    onDragStart?: React.DragEventHandler<HTMLHeadingElement> | undefined;
+    onDragStartCapture?: React.DragEventHandler<HTMLHeadingElement> | undefined;
+    onDrop?: React.DragEventHandler<HTMLHeadingElement> | undefined;
+    onDropCapture?: React.DragEventHandler<HTMLHeadingElement> | undefined;
+    onMouseDown?: React.MouseEventHandler<HTMLHeadingElement> | undefined;
+    onMouseDownCapture?: React.MouseEventHandler<HTMLHeadingElement> | undefined;
+    onMouseEnter?: React.MouseEventHandler<HTMLHeadingElement> | undefined;
+    onMouseLeave?: React.MouseEventHandler<HTMLHeadingElement> | undefined;
+    onMouseMove?: React.MouseEventHandler<HTMLHeadingElement> | undefined;
+    onMouseMoveCapture?: React.MouseEventHandler<HTMLHeadingElement> | undefined;
+    onMouseOut?: React.MouseEventHandler<HTMLHeadingElement> | undefined;
+    onMouseOutCapture?: React.MouseEventHandler<HTMLHeadingElement> | undefined;
+    onMouseOver?: React.MouseEventHandler<HTMLHeadingElement> | undefined;
+    onMouseOverCapture?: React.MouseEventHandler<HTMLHeadingElement> | undefined;
+    onMouseUp?: React.MouseEventHandler<HTMLHeadingElement> | undefined;
+    onMouseUpCapture?: React.MouseEventHandler<HTMLHeadingElement> | undefined;
+    onSelect?: React.ReactEventHandler<HTMLHeadingElement> | undefined;
+    onSelectCapture?: React.ReactEventHandler<HTMLHeadingElement> | undefined;
+    onTouchCancel?: React.TouchEventHandler<HTMLHeadingElement> | undefined;
+    onTouchCancelCapture?: React.TouchEventHandler<HTMLHeadingElement> | undefined;
+    onTouchEnd?: React.TouchEventHandler<HTMLHeadingElement> | undefined;
+    onTouchEndCapture?: React.TouchEventHandler<HTMLHeadingElement> | undefined;
+    onTouchMove?: React.TouchEventHandler<HTMLHeadingElement> | undefined;
+    onTouchMoveCapture?: React.TouchEventHandler<HTMLHeadingElement> | undefined;
+    onTouchStart?: React.TouchEventHandler<HTMLHeadingElement> | undefined;
+    onTouchStartCapture?: React.TouchEventHandler<HTMLHeadingElement> | undefined;
+    onPointerDown?: React.PointerEventHandler<HTMLHeadingElement> | undefined;
+    onPointerDownCapture?: React.PointerEventHandler<HTMLHeadingElement> | undefined;
+    onPointerMove?: React.PointerEventHandler<HTMLHeadingElement> | undefined;
+    onPointerMoveCapture?: React.PointerEventHandler<HTMLHeadingElement> | undefined;
+    onPointerUp?: React.PointerEventHandler<HTMLHeadingElement> | undefined;
+    onPointerUpCapture?: React.PointerEventHandler<HTMLHeadingElement> | undefined;
+    onPointerCancel?: React.PointerEventHandler<HTMLHeadingElement> | undefined;
+    onPointerCancelCapture?: React.PointerEventHandler<HTMLHeadingElement> | undefined;
+    onPointerEnter?: React.PointerEventHandler<HTMLHeadingElement> | undefined;
+    onPointerLeave?: React.PointerEventHandler<HTMLHeadingElement> | undefined;
+    onPointerOver?: React.PointerEventHandler<HTMLHeadingElement> | undefined;
+    onPointerOverCapture?: React.PointerEventHandler<HTMLHeadingElement> | undefined;
+    onPointerOut?: React.PointerEventHandler<HTMLHeadingElement> | undefined;
+    onPointerOutCapture?: React.PointerEventHandler<HTMLHeadingElement> | undefined;
+    onGotPointerCapture?: React.PointerEventHandler<HTMLHeadingElement> | undefined;
+    onGotPointerCaptureCapture?: React.PointerEventHandler<HTMLHeadingElement> | undefined;
+    onLostPointerCapture?: React.PointerEventHandler<HTMLHeadingElement> | undefined;
+    onLostPointerCaptureCapture?: React.PointerEventHandler<HTMLHeadingElement> | undefined;
+    onScroll?: React.UIEventHandler<HTMLHeadingElement> | undefined;
+    onScrollCapture?: React.UIEventHandler<HTMLHeadingElement> | undefined;
+    onScrollEnd?: React.UIEventHandler<HTMLHeadingElement> | undefined;
+    onScrollEndCapture?: React.UIEventHandler<HTMLHeadingElement> | undefined;
+    onWheel?: React.WheelEventHandler<HTMLHeadingElement> | undefined;
+    onWheelCapture?: React.WheelEventHandler<HTMLHeadingElement> | undefined;
+    onAnimationStart?: React.AnimationEventHandler<HTMLHeadingElement> | undefined;
+    onAnimationStartCapture?: React.AnimationEventHandler<HTMLHeadingElement> | undefined;
+    onAnimationEnd?: React.AnimationEventHandler<HTMLHeadingElement> | undefined;
+    onAnimationEndCapture?: React.AnimationEventHandler<HTMLHeadingElement> | undefined;
+    onAnimationIteration?: React.AnimationEventHandler<HTMLHeadingElement> | undefined;
+    onAnimationIterationCapture?: React.AnimationEventHandler<HTMLHeadingElement> | undefined;
+    onToggle?: React.ToggleEventHandler<HTMLHeadingElement> | undefined;
+    onBeforeToggle?: React.ToggleEventHandler<HTMLHeadingElement> | undefined;
+    onTransitionCancel?: React.TransitionEventHandler<HTMLHeadingElement> | undefined;
+    onTransitionCancelCapture?: React.TransitionEventHandler<HTMLHeadingElement> | undefined;
+    onTransitionEnd?: React.TransitionEventHandler<HTMLHeadingElement> | undefined;
+    onTransitionEndCapture?: React.TransitionEventHandler<HTMLHeadingElement> | undefined;
+    onTransitionRun?: React.TransitionEventHandler<HTMLHeadingElement> | undefined;
+    onTransitionRunCapture?: React.TransitionEventHandler<HTMLHeadingElement> | undefined;
+    onTransitionStart?: React.TransitionEventHandler<HTMLHeadingElement> | undefined;
+    onTransitionStartCapture?: React.TransitionEventHandler<HTMLHeadingElement> | undefined;
+}, HTMLHeadingElement>;

package/dist/components/ui/Heading.js

@@ -0,0 +1,3 @@
+'use client';
+export { Heading, headingVariants } from '../../chunk-WI547C47.js';
+import '../../chunk-QYZT24TS.js';

package/dist/components/ui/HoverCard.d.ts

@@ -0,0 +1,8 @@
+import * as React from "react";
+import * as HoverCardPrimitive from "@radix-ui/react-hover-card";
+declare const HoverCard: React.FC<HoverCardPrimitive.HoverCardProps>;
+declare const HoverCardTrigger: React.ForwardRefExoticComponent<HoverCardPrimitive.HoverCardTriggerProps & React.RefAttributes<HTMLAnchorElement>>;
+declare function HoverCardContent({ className, align, sideOffset, ref, ...props }: React.ComponentPropsWithoutRef<typeof HoverCardPrimitive.Content> & {
+    ref?: React.Ref<React.ElementRef<typeof HoverCardPrimitive.Content>>;
+}): import("react/jsx-runtime").JSX.Element;
+export { HoverCard, HoverCardTrigger, HoverCardContent };

package/dist/components/ui/HoverCard.js

@@ -0,0 +1,24 @@
+'use client';
+import { cn } from '../../chunk-QYZT24TS.js';
+import * as HoverCardPrimitive from '@radix-ui/react-hover-card';
+import { jsx } from 'react/jsx-runtime';
+
+var HoverCard = HoverCardPrimitive.Root;
+var HoverCardTrigger = HoverCardPrimitive.Trigger;
+function HoverCardContent({ className, align = "center", sideOffset = 4, ref, ...props }) {
+  return /* @__PURE__ */ jsx(
+    HoverCardPrimitive.Content,
+    {
+      ref,
+      align,
+      sideOffset,
+      className: cn(
+        "z-50 w-64 rounded-md glass-panel p-4 text-text-primary outline-none focus-visible:ring-2 focus-visible:ring-focus-ring data-[state=open]:animate-in data-[state=closed]:animate-out data-[state=closed]:fade-out-0 data-[state=open]:fade-in-0 data-[state=closed]:zoom-out-95 data-[state=open]:zoom-in-95 data-[side=bottom]:slide-in-from-top-2 data-[side=left]:slide-in-from-right-2 data-[side=right]:slide-in-from-left-2 data-[side=top]:slide-in-from-bottom-2",
+        className
+      ),
+      ...props
+    }
+  );
+}
+
+export { HoverCard, HoverCardContent, HoverCardTrigger };

package/dist/components/ui/InfiniteSlider.d.ts

@@ -0,0 +1,11 @@
+import React from 'react';
+interface InfiniteSliderProps {
+    children: React.ReactNode;
+    gap?: number;
+    speed?: number;
+    className?: string;
+    reverse?: boolean;
+    direction?: "horizontal" | "vertical";
+}
+export declare const InfiniteSlider: ({ children, gap, speed, className, reverse, direction, }: InfiniteSliderProps) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/components/ui/InfiniteSlider.js

@@ -0,0 +1,3 @@
+'use client';
+export { InfiniteSlider } from '../../chunk-IFIDWZ5M.js';
+import '../../chunk-QYZT24TS.js';

package/dist/components/ui/Input.d.ts

@@ -0,0 +1,15 @@
+import * as React from 'react';
+import { type VariantProps } from "class-variance-authority";
+declare const inputVariants: (props?: ({
+    size?: "default" | "lg" | "sm" | null | undefined;
+} & import("class-variance-authority/types").ClassProp) | undefined) => string;
+export interface InputProps extends Omit<React.InputHTMLAttributes<HTMLInputElement>, "size">, VariantProps<typeof inputVariants> {
+    label?: React.ReactNode;
+    error?: string | boolean;
+    startIcon?: React.ReactNode;
+    endIcon?: React.ReactNode;
+}
+export declare function Input({ className, type, label, error, startIcon, endIcon, id, size, ref, ...props }: InputProps & {
+    ref?: React.Ref<HTMLInputElement>;
+}): import("react/jsx-runtime").JSX.Element;
+export { inputVariants };

package/dist/components/ui/Input.js

@@ -0,0 +1,4 @@
+'use client';
+export { Input, inputVariants } from '../../chunk-AP3XXYAY.js';
+import '../../chunk-LIBXYD5Q.js';
+import '../../chunk-QYZT24TS.js';

package/dist/components/ui/InputGroup.d.ts

@@ -0,0 +1,8 @@
+import * as React from "react";
+declare function InputGroup({ className, ref, ...props }: React.HTMLAttributes<HTMLDivElement> & {
+    ref?: React.Ref<HTMLDivElement>;
+}): import("react/jsx-runtime").JSX.Element;
+declare function InputGroupAddon({ className, ref, ...props }: React.HTMLAttributes<HTMLDivElement> & {
+    ref?: React.Ref<HTMLDivElement>;
+}): import("react/jsx-runtime").JSX.Element;
+export { InputGroup, InputGroupAddon };

package/dist/components/ui/InputGroup.js

@@ -0,0 +1,37 @@
+'use client';
+import { cn } from '../../chunk-QYZT24TS.js';
+import { jsx } from 'react/jsx-runtime';
+
+function InputGroup({
+  className,
+  ref,
+  ...props
+}) {
+  return /* @__PURE__ */ jsx(
+    "div",
+    {
+      ref,
+      className: cn("flex w-full items-center", className),
+      ...props
+    }
+  );
+}
+function InputGroupAddon({
+  className,
+  ref,
+  ...props
+}) {
+  return /* @__PURE__ */ jsx(
+    "div",
+    {
+      ref,
+      className: cn(
+        "flex h-9 items-center justify-center border border-border bg-secondary px-4 py-1.5 text-sm text-text-secondary first:rounded-l-md last:rounded-r-md first:border-r-0 last:border-l-0",
+        className
+      ),
+      ...props
+    }
+  );
+}
+
+export { InputGroup, InputGroupAddon };

package/dist/components/ui/InputOTP.d.ts

@@ -0,0 +1,17 @@
+import * as React from "react";
+import { OTPInput } from "input-otp";
+declare function InputOTP({ className, containerClassName, ref, ...props }: React.ComponentPropsWithoutRef<typeof OTPInput> & {
+    ref?: React.Ref<React.ElementRef<typeof OTPInput>>;
+}): import("react/jsx-runtime").JSX.Element;
+declare function InputOTPGroup({ className, ref, ...props }: React.HTMLAttributes<HTMLDivElement> & {
+    ref?: React.Ref<HTMLDivElement>;
+}): import("react/jsx-runtime").JSX.Element;
+declare function InputOTPSlot({ index, className, ref, ...props }: React.ComponentPropsWithoutRef<"div"> & {
+    index: number;
+} & {
+    ref?: React.Ref<HTMLDivElement>;
+}): import("react/jsx-runtime").JSX.Element;
+declare function InputOTPSeparator({ ref, ...props }: React.ComponentPropsWithoutRef<"div"> & {
+    ref?: React.Ref<HTMLDivElement>;
+}): import("react/jsx-runtime").JSX.Element;
+export { InputOTP, InputOTPGroup, InputOTPSlot, InputOTPSeparator };