@eluan/core 0.1.0

package/dist/components/context-menu.d.ts

@@ -0,0 +1,33 @@
+import * as React from "react";
+import * as ContextMenuPrimitive from "@radix-ui/react-context-menu";
+declare const ContextMenu: React.FC<ContextMenuPrimitive.ContextMenuProps>;
+declare const ContextMenuTrigger: React.ForwardRefExoticComponent<ContextMenuPrimitive.ContextMenuTriggerProps & React.RefAttributes<HTMLSpanElement>>;
+declare const ContextMenuGroup: React.ForwardRefExoticComponent<ContextMenuPrimitive.ContextMenuGroupProps & React.RefAttributes<HTMLDivElement>>;
+declare const ContextMenuPortal: React.FC<ContextMenuPrimitive.ContextMenuPortalProps>;
+declare const ContextMenuSub: React.FC<ContextMenuPrimitive.ContextMenuSubProps>;
+declare const ContextMenuRadioGroup: React.ForwardRefExoticComponent<ContextMenuPrimitive.ContextMenuRadioGroupProps & React.RefAttributes<HTMLDivElement>>;
+type ContextMenuSubContentProps = Omit<React.ComponentPropsWithoutRef<typeof ContextMenuPrimitive.SubContent>, "className" | "style">;
+type ContextMenuContentProps = Omit<React.ComponentPropsWithoutRef<typeof ContextMenuPrimitive.Content>, "className" | "style">;
+type ContextMenuCheckboxItemProps = Omit<React.ComponentPropsWithoutRef<typeof ContextMenuPrimitive.CheckboxItem>, "className" | "style">;
+type ContextMenuRadioItemProps = Omit<React.ComponentPropsWithoutRef<typeof ContextMenuPrimitive.RadioItem>, "className" | "style">;
+type ContextMenuSeparatorProps = Omit<React.ComponentPropsWithoutRef<typeof ContextMenuPrimitive.Separator>, "className" | "style">;
+type ContextMenuShortcutProps = Omit<React.HTMLAttributes<HTMLSpanElement>, "className" | "style">;
+declare const ContextMenuSubTrigger: React.ForwardRefExoticComponent<Omit<Omit<ContextMenuPrimitive.ContextMenuSubTriggerProps & React.RefAttributes<HTMLDivElement>, "ref">, "style" | "className"> & {
+    inset?: boolean;
+} & React.RefAttributes<HTMLDivElement>>;
+declare const ContextMenuSubContent: React.ForwardRefExoticComponent<ContextMenuSubContentProps & React.RefAttributes<HTMLDivElement>>;
+declare const ContextMenuContent: React.ForwardRefExoticComponent<ContextMenuContentProps & React.RefAttributes<HTMLDivElement>>;
+declare const ContextMenuItem: React.ForwardRefExoticComponent<Omit<Omit<ContextMenuPrimitive.ContextMenuItemProps & React.RefAttributes<HTMLDivElement>, "ref">, "style" | "className"> & {
+    inset?: boolean;
+} & React.RefAttributes<HTMLDivElement>>;
+declare const ContextMenuCheckboxItem: React.ForwardRefExoticComponent<ContextMenuCheckboxItemProps & React.RefAttributes<HTMLDivElement>>;
+declare const ContextMenuRadioItem: React.ForwardRefExoticComponent<ContextMenuRadioItemProps & React.RefAttributes<HTMLDivElement>>;
+declare const ContextMenuLabel: React.ForwardRefExoticComponent<Omit<Omit<ContextMenuPrimitive.ContextMenuLabelProps & React.RefAttributes<HTMLDivElement>, "ref">, "style" | "className"> & {
+    inset?: boolean;
+} & React.RefAttributes<HTMLDivElement>>;
+declare const ContextMenuSeparator: React.ForwardRefExoticComponent<ContextMenuSeparatorProps & React.RefAttributes<HTMLDivElement>>;
+declare const ContextMenuShortcut: {
+    ({ ...props }: ContextMenuShortcutProps): import("react/jsx-runtime").JSX.Element;
+    displayName: string;
+};
+export { ContextMenu, ContextMenuTrigger, ContextMenuContent, ContextMenuItem, ContextMenuCheckboxItem, ContextMenuRadioItem, ContextMenuLabel, ContextMenuSeparator, ContextMenuShortcut, ContextMenuGroup, ContextMenuPortal, ContextMenuSub, ContextMenuSubContent, ContextMenuSubTrigger, ContextMenuRadioGroup, };

package/dist/components/credit-card-input.d.ts

@@ -0,0 +1,27 @@
+import * as React from "react";
+type CardType = "visa" | "mastercard" | "amex" | "discover" | "diners" | "jcb" | "unionpay" | "unknown";
+export interface CreditCardInputProps {
+    onCardChange?: (data: {
+        number: string;
+        expiry: string;
+        cvv: string;
+        cardType: CardType;
+        isValid: boolean;
+    }) => void;
+    disabled?: boolean;
+}
+export interface CreditCardNumberInputProps extends Omit<React.InputHTMLAttributes<HTMLInputElement>, "className" | "size" | "style" | "type" | "onChange"> {
+    onChange?: (value: string, cardType: CardType) => void;
+}
+export interface CreditCardExpiryInputProps extends Omit<React.InputHTMLAttributes<HTMLInputElement>, "className" | "size" | "style" | "type" | "onChange"> {
+    onChange?: (value: string) => void;
+}
+export interface CreditCardCVVInputProps extends Omit<React.InputHTMLAttributes<HTMLInputElement>, "className" | "size" | "style" | "type" | "onChange"> {
+    cardType?: CardType;
+    onChange?: (value: string) => void;
+}
+declare const CreditCardNumberInput: React.ForwardRefExoticComponent<CreditCardNumberInputProps & React.RefAttributes<HTMLInputElement>>;
+declare const CreditCardExpiryInput: React.ForwardRefExoticComponent<CreditCardExpiryInputProps & React.RefAttributes<HTMLInputElement>>;
+declare const CreditCardCVVInput: React.ForwardRefExoticComponent<CreditCardCVVInputProps & React.RefAttributes<HTMLInputElement>>;
+declare const CreditCardInput: React.ForwardRefExoticComponent<CreditCardInputProps & React.RefAttributes<HTMLDivElement>>;
+export { CreditCardInput, CreditCardNumberInput, CreditCardExpiryInput, CreditCardCVVInput, };

package/dist/components/date-picker.d.ts

@@ -0,0 +1,24 @@
+import * as React from "react";
+export interface DatePickerProps {
+    value?: Date;
+    onChange?: (date: Date | undefined) => void;
+    placeholder?: string;
+    disabled?: boolean;
+    dateFormat?: string;
+}
+declare const DatePicker: React.ForwardRefExoticComponent<DatePickerProps & React.RefAttributes<HTMLButtonElement>>;
+export interface DateRangePickerProps {
+    value?: {
+        from: Date | undefined;
+        to: Date | undefined;
+    };
+    onChange?: (range: {
+        from: Date | undefined;
+        to: Date | undefined;
+    }) => void;
+    placeholder?: string;
+    disabled?: boolean;
+    dateFormat?: string;
+}
+declare const DateRangePicker: React.ForwardRefExoticComponent<DateRangePickerProps & React.RefAttributes<HTMLButtonElement>>;
+export { DatePicker, DateRangePicker };

package/dist/components/datetime-picker.d.ts

@@ -0,0 +1,11 @@
+import * as React from "react";
+export interface DateTimePickerProps {
+    value?: Date;
+    onChange?: (date: Date | undefined) => void;
+    placeholder?: string;
+    disabled?: boolean;
+    showSeconds?: boolean;
+    use24Hour?: boolean;
+}
+declare const DateTimePicker: React.ForwardRefExoticComponent<DateTimePickerProps & React.RefAttributes<HTMLButtonElement>>;
+export { DateTimePicker };

package/dist/components/decimal-input.d.ts

@@ -0,0 +1,41 @@
+import * as React from "react";
+type CurrencyCode = "USD" | "EUR" | "GBP" | "JPY" | "CNY" | "KRW" | "INR" | "BRL" | "CAD" | "AUD" | "CHF";
+interface CurrencyInfo {
+    code: CurrencyCode;
+    symbol: string;
+    name: string;
+    decimals: number;
+}
+declare const currencies: Record<CurrencyCode, CurrencyInfo>;
+export interface DecimalInputProps extends Omit<React.InputHTMLAttributes<HTMLInputElement>, "className" | "size" | "style" | "type" | "value" | "onChange"> {
+    value?: number;
+    onChange?: (value: number | undefined) => void;
+    decimals?: number;
+    min?: number;
+    max?: number;
+    prefix?: string;
+    suffix?: string;
+    currency?: CurrencyCode;
+    unit?: string;
+    unitPosition?: "prefix" | "suffix";
+    thousandsSeparator?: string;
+    decimalSeparator?: string;
+    allowNegative?: boolean;
+}
+declare const DecimalInput: React.ForwardRefExoticComponent<DecimalInputProps & React.RefAttributes<HTMLInputElement>>;
+export interface CurrencyInputProps extends Omit<DecimalInputProps, "currency"> {
+    currency: CurrencyCode;
+}
+declare const CurrencyInput: React.ForwardRefExoticComponent<CurrencyInputProps & React.RefAttributes<HTMLInputElement>>;
+export interface PercentageInputProps extends Omit<DecimalInputProps, "suffix" | "min" | "max"> {
+    min?: number;
+    max?: number;
+}
+declare const PercentageInput: React.ForwardRefExoticComponent<PercentageInputProps & React.RefAttributes<HTMLInputElement>>;
+export interface UnitInputProps extends Omit<DecimalInputProps, "unit" | "unitPosition"> {
+    unit: string;
+    unitPosition?: "prefix" | "suffix";
+}
+declare const UnitInput: React.ForwardRefExoticComponent<UnitInputProps & React.RefAttributes<HTMLInputElement>>;
+export { DecimalInput, CurrencyInput, PercentageInput, UnitInput, currencies };
+export type { CurrencyCode, CurrencyInfo };

package/dist/components/dialog.d.ts

@@ -0,0 +1,25 @@
+import * as React from "react";
+import * as DialogPrimitive from "@radix-ui/react-dialog";
+declare const Dialog: React.FC<DialogPrimitive.DialogProps>;
+declare const DialogTrigger: React.ForwardRefExoticComponent<DialogPrimitive.DialogTriggerProps & React.RefAttributes<HTMLButtonElement>>;
+declare const DialogPortal: React.FC<DialogPrimitive.DialogPortalProps>;
+declare const DialogClose: React.ForwardRefExoticComponent<DialogPrimitive.DialogCloseProps & React.RefAttributes<HTMLButtonElement>>;
+type DialogOverlayProps = Omit<React.ComponentPropsWithoutRef<typeof DialogPrimitive.Overlay>, "className" | "style">;
+type DialogDivProps = Omit<React.HTMLAttributes<HTMLDivElement>, "className" | "style">;
+type DialogTitleProps = Omit<React.ComponentPropsWithoutRef<typeof DialogPrimitive.Title>, "className" | "style">;
+type DialogDescriptionProps = Omit<React.ComponentPropsWithoutRef<typeof DialogPrimitive.Description>, "className" | "style">;
+declare const DialogOverlay: React.ForwardRefExoticComponent<DialogOverlayProps & React.RefAttributes<HTMLDivElement>>;
+declare const DialogContent: React.ForwardRefExoticComponent<Omit<Omit<DialogPrimitive.DialogContentProps & React.RefAttributes<HTMLDivElement>, "ref">, "style" | "className"> & {
+    layout?: "default" | "command";
+} & React.RefAttributes<HTMLDivElement>>;
+declare const DialogHeader: {
+    ({ ...props }: DialogDivProps): import("react/jsx-runtime").JSX.Element;
+    displayName: string;
+};
+declare const DialogFooter: {
+    ({ ...props }: DialogDivProps): import("react/jsx-runtime").JSX.Element;
+    displayName: string;
+};
+declare const DialogTitle: React.ForwardRefExoticComponent<DialogTitleProps & React.RefAttributes<HTMLHeadingElement>>;
+declare const DialogDescription: React.ForwardRefExoticComponent<DialogDescriptionProps & React.RefAttributes<HTMLParagraphElement>>;
+export { Dialog, DialogPortal, DialogOverlay, DialogClose, DialogTrigger, DialogContent, DialogHeader, DialogFooter, DialogTitle, DialogDescription, };

package/dist/components/drawer.d.ts

@@ -0,0 +1,33 @@
+import * as React from "react";
+interface DrawerProps {
+    children: React.ReactNode;
+    open?: boolean;
+    defaultOpen?: boolean;
+    onOpenChange?: (open: boolean) => void;
+}
+type DrawerButtonProps = Omit<React.ButtonHTMLAttributes<HTMLButtonElement>, "className" | "style">;
+type DrawerDivProps = Omit<React.HTMLAttributes<HTMLDivElement>, "className" | "style">;
+type DrawerHeadingProps = Omit<React.HTMLAttributes<HTMLHeadingElement>, "className" | "style">;
+type DrawerParagraphProps = Omit<React.HTMLAttributes<HTMLParagraphElement>, "className" | "style">;
+type DrawerSide = "left" | "right";
+declare function Drawer({ children, open: controlledOpen, defaultOpen, onOpenChange, }: DrawerProps): import("react/jsx-runtime").JSX.Element;
+declare const DrawerTrigger: React.ForwardRefExoticComponent<DrawerButtonProps & React.RefAttributes<HTMLButtonElement>>;
+declare const DrawerClose: React.ForwardRefExoticComponent<DrawerButtonProps & React.RefAttributes<HTMLButtonElement>>;
+declare const DrawerPortal: ({ children }: {
+    children: React.ReactNode;
+}) => import("react/jsx-runtime").JSX.Element | null;
+declare const DrawerOverlay: React.ForwardRefExoticComponent<DrawerDivProps & React.RefAttributes<HTMLDivElement>>;
+declare const DrawerContent: React.ForwardRefExoticComponent<DrawerDivProps & {
+    side?: DrawerSide;
+} & React.RefAttributes<HTMLDivElement>>;
+declare const DrawerHeader: {
+    ({ ...props }: DrawerDivProps): import("react/jsx-runtime").JSX.Element;
+    displayName: string;
+};
+declare const DrawerFooter: {
+    ({ ...props }: DrawerDivProps): import("react/jsx-runtime").JSX.Element;
+    displayName: string;
+};
+declare const DrawerTitle: React.ForwardRefExoticComponent<DrawerHeadingProps & React.RefAttributes<HTMLHeadingElement>>;
+declare const DrawerDescription: React.ForwardRefExoticComponent<DrawerParagraphProps & React.RefAttributes<HTMLParagraphElement>>;
+export { Drawer, DrawerPortal, DrawerOverlay, DrawerTrigger, DrawerClose, DrawerContent, DrawerHeader, DrawerFooter, DrawerTitle, DrawerDescription, };

package/dist/components/dropdown-menu.d.ts

@@ -0,0 +1,34 @@
+import * as React from "react";
+import * as DropdownMenuPrimitive from "@radix-ui/react-dropdown-menu";
+declare const DropdownMenu: React.FC<DropdownMenuPrimitive.DropdownMenuProps>;
+declare const DropdownMenuTrigger: React.ForwardRefExoticComponent<DropdownMenuPrimitive.DropdownMenuTriggerProps & React.RefAttributes<HTMLButtonElement>>;
+declare const DropdownMenuGroup: React.ForwardRefExoticComponent<DropdownMenuPrimitive.DropdownMenuGroupProps & React.RefAttributes<HTMLDivElement>>;
+declare const DropdownMenuPortal: React.FC<DropdownMenuPrimitive.DropdownMenuPortalProps>;
+declare const DropdownMenuSub: React.FC<DropdownMenuPrimitive.DropdownMenuSubProps>;
+declare const DropdownMenuRadioGroup: React.ForwardRefExoticComponent<DropdownMenuPrimitive.DropdownMenuRadioGroupProps & React.RefAttributes<HTMLDivElement>>;
+type DropdownMenuSubContentProps = Omit<React.ComponentPropsWithoutRef<typeof DropdownMenuPrimitive.SubContent>, "className" | "style">;
+type DropdownMenuContentProps = Omit<React.ComponentPropsWithoutRef<typeof DropdownMenuPrimitive.Content>, "className" | "style">;
+type DropdownMenuCheckboxItemProps = Omit<React.ComponentPropsWithoutRef<typeof DropdownMenuPrimitive.CheckboxItem>, "className" | "style">;
+type DropdownMenuRadioItemProps = Omit<React.ComponentPropsWithoutRef<typeof DropdownMenuPrimitive.RadioItem>, "className" | "style">;
+type DropdownMenuSeparatorProps = Omit<React.ComponentPropsWithoutRef<typeof DropdownMenuPrimitive.Separator>, "className" | "style">;
+type DropdownMenuShortcutProps = Omit<React.HTMLAttributes<HTMLSpanElement>, "className" | "style">;
+declare const DropdownMenuSubTrigger: React.ForwardRefExoticComponent<Omit<Omit<DropdownMenuPrimitive.DropdownMenuSubTriggerProps & React.RefAttributes<HTMLDivElement>, "ref">, "style" | "className"> & {
+    inset?: boolean;
+} & React.RefAttributes<HTMLDivElement>>;
+declare const DropdownMenuSubContent: React.ForwardRefExoticComponent<DropdownMenuSubContentProps & React.RefAttributes<HTMLDivElement>>;
+declare const DropdownMenuContent: React.ForwardRefExoticComponent<DropdownMenuContentProps & React.RefAttributes<HTMLDivElement>>;
+declare const DropdownMenuItem: React.ForwardRefExoticComponent<Omit<Omit<DropdownMenuPrimitive.DropdownMenuItemProps & React.RefAttributes<HTMLDivElement>, "ref">, "style" | "className"> & {
+    inset?: boolean;
+    tone?: "default" | "destructive";
+} & React.RefAttributes<HTMLDivElement>>;
+declare const DropdownMenuCheckboxItem: React.ForwardRefExoticComponent<DropdownMenuCheckboxItemProps & React.RefAttributes<HTMLDivElement>>;
+declare const DropdownMenuRadioItem: React.ForwardRefExoticComponent<DropdownMenuRadioItemProps & React.RefAttributes<HTMLDivElement>>;
+declare const DropdownMenuLabel: React.ForwardRefExoticComponent<Omit<Omit<DropdownMenuPrimitive.DropdownMenuLabelProps & React.RefAttributes<HTMLDivElement>, "ref">, "style" | "className"> & {
+    inset?: boolean;
+} & React.RefAttributes<HTMLDivElement>>;
+declare const DropdownMenuSeparator: React.ForwardRefExoticComponent<DropdownMenuSeparatorProps & React.RefAttributes<HTMLDivElement>>;
+declare const DropdownMenuShortcut: {
+    ({ ...props }: DropdownMenuShortcutProps): import("react/jsx-runtime").JSX.Element;
+    displayName: string;
+};
+export { DropdownMenu, DropdownMenuTrigger, DropdownMenuContent, DropdownMenuItem, DropdownMenuCheckboxItem, DropdownMenuRadioItem, DropdownMenuLabel, DropdownMenuSeparator, DropdownMenuShortcut, DropdownMenuGroup, DropdownMenuPortal, DropdownMenuSub, DropdownMenuSubContent, DropdownMenuSubTrigger, DropdownMenuRadioGroup, };

package/dist/components/email-input.d.ts

@@ -0,0 +1,7 @@
+import * as React from "react";
+export interface EmailInputProps extends Omit<React.InputHTMLAttributes<HTMLInputElement>, "className" | "size" | "style" | "type"> {
+    onValidationChange?: (isValid: boolean) => void;
+    showValidation?: boolean;
+}
+declare const EmailInput: React.ForwardRefExoticComponent<EmailInputProps & React.RefAttributes<HTMLInputElement>>;
+export { EmailInput };

package/dist/components/fieldset.d.ts

@@ -0,0 +1,7 @@
+import * as React from "react";
+type FieldsetProps = Omit<React.HTMLAttributes<HTMLDivElement>, "className" | "style">;
+type FieldsetDescriptionProps = Omit<React.HTMLAttributes<HTMLParagraphElement>, "className" | "style">;
+declare const Fieldset: React.ForwardRefExoticComponent<FieldsetProps & React.RefAttributes<HTMLDivElement>>;
+declare const FieldsetLegend: React.ForwardRefExoticComponent<FieldsetProps & React.RefAttributes<HTMLDivElement>>;
+declare const FieldsetDescription: React.ForwardRefExoticComponent<FieldsetDescriptionProps & React.RefAttributes<HTMLParagraphElement>>;
+export { Fieldset, FieldsetLegend, FieldsetDescription };

package/dist/components/file-input.d.ts

@@ -0,0 +1,30 @@
+import * as React from "react";
+type FileType = "image" | "document" | "video" | "audio" | "archive" | "other";
+interface FileInfo {
+    file: File;
+    preview?: string;
+    type: FileType;
+}
+declare function getFileType(file: File): FileType;
+declare function formatFileSize(bytes: number): string;
+export interface FileInputProps extends Omit<React.InputHTMLAttributes<HTMLInputElement>, "className" | "style" | "type" | "value" | "onChange"> {
+    value?: File[];
+    onChange?: (files: File[]) => void;
+    maxFiles?: number;
+    maxSize?: number;
+    showPreview?: boolean;
+    variant?: "default" | "dropzone";
+    dragActiveText?: string;
+    dragInactiveText?: string;
+}
+declare const FileInput: React.ForwardRefExoticComponent<FileInputProps & React.RefAttributes<HTMLInputElement>>;
+export interface ImageInputProps extends Omit<FileInputProps, "accept"> {
+    acceptedFormats?: string[];
+}
+declare const ImageInput: React.ForwardRefExoticComponent<ImageInputProps & React.RefAttributes<HTMLInputElement>>;
+export interface DocumentInputProps extends Omit<FileInputProps, "accept"> {
+    acceptedFormats?: string[];
+}
+declare const DocumentInput: React.ForwardRefExoticComponent<DocumentInputProps & React.RefAttributes<HTMLInputElement>>;
+export { FileInput, ImageInput, DocumentInput, formatFileSize, getFileType };
+export type { FileType, FileInfo };

package/dist/components/footer.d.ts

@@ -0,0 +1,38 @@
+import * as React from "react";
+type FooterVariant = "default" | "modern" | null | undefined;
+type FooterSize = "sm" | "default" | "lg" | null | undefined;
+export declare const footerVariants: (_options?: {
+    variant?: FooterVariant;
+    size?: FooterSize;
+}) => string;
+export interface FooterProps extends Omit<React.HTMLAttributes<HTMLElement>, "className" | "style"> {
+    variant?: FooterVariant;
+    size?: FooterSize;
+}
+declare const Footer: React.ForwardRefExoticComponent<FooterProps & React.RefAttributes<HTMLElement>>;
+declare const FooterContent: React.ForwardRefExoticComponent<Omit<React.HTMLAttributes<HTMLDivElement>, "style" | "className"> & React.RefAttributes<HTMLDivElement>>;
+declare const FooterSection: React.ForwardRefExoticComponent<Omit<React.HTMLAttributes<HTMLDivElement>, "style" | "className"> & React.RefAttributes<HTMLDivElement>>;
+declare const FooterTitle: React.ForwardRefExoticComponent<Omit<React.HTMLAttributes<HTMLHeadingElement>, "style" | "className"> & React.RefAttributes<HTMLHeadingElement>>;
+declare const FooterLinks: React.ForwardRefExoticComponent<Omit<React.HTMLAttributes<HTMLUListElement>, "style" | "className"> & React.RefAttributes<HTMLUListElement>>;
+export interface FooterLinkProps extends Omit<React.AnchorHTMLAttributes<HTMLAnchorElement>, "className" | "style"> {
+}
+declare const FooterLink: React.ForwardRefExoticComponent<FooterLinkProps & React.RefAttributes<HTMLAnchorElement>>;
+declare const FooterBottom: React.ForwardRefExoticComponent<Omit<React.HTMLAttributes<HTMLDivElement>, "style" | "className"> & React.RefAttributes<HTMLDivElement>>;
+declare const FooterCopyright: React.ForwardRefExoticComponent<Omit<React.HTMLAttributes<HTMLParagraphElement>, "style" | "className"> & React.RefAttributes<HTMLParagraphElement>>;
+declare const FooterSocial: React.ForwardRefExoticComponent<Omit<React.HTMLAttributes<HTMLDivElement>, "style" | "className"> & React.RefAttributes<HTMLDivElement>>;
+export interface FooterSocialLinkProps extends Omit<React.AnchorHTMLAttributes<HTMLAnchorElement>, "className" | "style"> {
+    label: string;
+}
+declare const FooterSocialLink: React.ForwardRefExoticComponent<FooterSocialLinkProps & React.RefAttributes<HTMLAnchorElement>>;
+export interface FooterBrandProps extends Omit<React.HTMLAttributes<HTMLDivElement>, "className" | "style"> {
+    text?: string;
+}
+declare const FooterBrand: React.ForwardRefExoticComponent<FooterBrandProps & React.RefAttributes<HTMLDivElement>>;
+declare const FooterModernLink: React.ForwardRefExoticComponent<FooterLinkProps & React.RefAttributes<HTMLAnchorElement>>;
+declare const FooterModernSocialLink: React.ForwardRefExoticComponent<FooterSocialLinkProps & React.RefAttributes<HTMLAnchorElement>>;
+export interface FooterStaggerProps extends Omit<React.HTMLAttributes<HTMLDivElement>, "className" | "style"> {
+    /** Delay increment between children in ms (default 80). */
+    delayMs?: number;
+}
+declare const FooterStagger: React.ForwardRefExoticComponent<FooterStaggerProps & React.RefAttributes<HTMLDivElement>>;
+export { Footer, FooterContent, FooterSection, FooterTitle, FooterLinks, FooterLink, FooterBottom, FooterCopyright, FooterSocial, FooterSocialLink, FooterBrand, FooterModernLink, FooterModernSocialLink, FooterStagger, };

package/dist/components/form-label.d.ts

@@ -0,0 +1,16 @@
+import * as React from "react";
+export interface LabelProps extends Omit<React.LabelHTMLAttributes<HTMLLabelElement>, "className" | "style"> {
+    hint?: string;
+    optional?: boolean;
+    required?: boolean;
+}
+type FormDescriptionProps = Omit<React.HTMLAttributes<HTMLParagraphElement>, "className" | "style">;
+interface FormMessageProps extends FormDescriptionProps {
+    error?: boolean;
+}
+declare const Label: React.ForwardRefExoticComponent<LabelProps & React.RefAttributes<HTMLLabelElement>>;
+/** @deprecated Use `Label` instead */
+declare const FormLabel: React.ForwardRefExoticComponent<LabelProps & React.RefAttributes<HTMLLabelElement>>;
+declare const FormDescription: React.ForwardRefExoticComponent<FormDescriptionProps & React.RefAttributes<HTMLParagraphElement>>;
+declare const FormMessage: React.ForwardRefExoticComponent<FormMessageProps & React.RefAttributes<HTMLParagraphElement>>;
+export { Label, FormLabel, FormDescription, FormMessage };

package/dist/components/header-navigation.d.ts

@@ -0,0 +1,18 @@
+import * as React from "react";
+export interface NavItem {
+    label: string;
+    href?: string;
+    onClick?: () => void;
+    children?: NavItem[];
+    active?: boolean;
+}
+export interface HeaderNavigationProps extends Omit<React.HTMLAttributes<HTMLElement>, "className" | "style"> {
+    logo?: React.ReactNode;
+    items?: NavItem[];
+    actions?: React.ReactNode;
+    sticky?: boolean;
+    transparent?: boolean;
+    mobileBreakpoint?: "sm" | "md" | "lg";
+}
+declare const HeaderNavigation: React.ForwardRefExoticComponent<HeaderNavigationProps & React.RefAttributes<HTMLElement>>;
+export { HeaderNavigation };

package/dist/components/header.d.ts

@@ -0,0 +1 @@
+export { HeaderNavigation as Header, type HeaderNavigationProps as HeaderProps, type NavItem, } from "./header-navigation";

package/dist/components/hover-card.d.ts

@@ -0,0 +1,7 @@
+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>>;
+type HoverCardContentProps = Omit<React.ComponentPropsWithoutRef<typeof HoverCardPrimitive.Content>, "className" | "style">;
+declare const HoverCardContent: React.ForwardRefExoticComponent<HoverCardContentProps & React.RefAttributes<HTMLDivElement>>;
+export { HoverCard, HoverCardTrigger, HoverCardContent };

package/dist/components/input-otp.d.ts

@@ -0,0 +1,23 @@
+import * as React from "react";
+export interface InputOTPProps extends Omit<React.InputHTMLAttributes<HTMLInputElement>, "className" | "onChange" | "style"> {
+    /** Number of OTP slots */
+    length?: number;
+    /** Called when OTP value changes */
+    onChange?: (value: string) => void;
+    /** Called when all slots are filled */
+    onComplete?: (value: string) => void;
+    /** Render as password/hidden */
+    mask?: boolean;
+    /** Auto focus first input */
+    autoFocus?: boolean;
+}
+declare const InputOTP: React.ForwardRefExoticComponent<InputOTPProps & React.RefAttributes<HTMLDivElement>>;
+declare const InputOTPSlot: React.ForwardRefExoticComponent<Omit<React.InputHTMLAttributes<HTMLInputElement>, "style" | "className"> & {
+    index: number;
+    char?: string;
+    hasFakeCaret?: boolean;
+    isActive?: boolean;
+} & React.RefAttributes<HTMLInputElement>>;
+declare const InputOTPGroup: React.ForwardRefExoticComponent<Omit<React.HTMLAttributes<HTMLDivElement>, "style" | "className"> & React.RefAttributes<HTMLDivElement>>;
+declare const InputOTPSeparator: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLDivElement> & React.RefAttributes<HTMLDivElement>>;
+export { InputOTP, InputOTPGroup, InputOTPSlot, InputOTPSeparator };

package/dist/components/input.d.ts

@@ -0,0 +1,19 @@
+import * as React from "react";
+export type InputValidationTone = "none" | "positive" | "destructive";
+export type InputTextStyle = "default" | "mono";
+export type InputSize = "default" | "lg";
+export type InputAttachment = "none" | "start" | "middle";
+export type InputTextAlign = "left" | "center";
+export interface InputProps extends Omit<React.InputHTMLAttributes<HTMLInputElement>, "className" | "size" | "style"> {
+    /** Show a leading icon. Overrides the auto-icon for the input type. */
+    icon?: React.ReactNode;
+    /** Show a trailing element (e.g. a button) */
+    trailing?: React.ReactNode;
+    attachment?: InputAttachment;
+    size?: InputSize;
+    textAlign?: InputTextAlign;
+    textStyle?: InputTextStyle;
+    validationTone?: InputValidationTone;
+}
+declare const Input: React.ForwardRefExoticComponent<InputProps & React.RefAttributes<HTMLInputElement>>;
+export { Input };

package/dist/components/kbd.d.ts

@@ -0,0 +1,20 @@
+import * as React from "react";
+type KbdVariant = "default" | "outline" | "ghost";
+type KbdSize = "sm" | "default" | "lg";
+declare const kbdVariants: () => string;
+export interface KbdProps extends Omit<React.HTMLAttributes<HTMLElement>, "className" | "style"> {
+    keys?: string | string[];
+    size?: KbdSize;
+    variant?: KbdVariant;
+}
+export type KbdGroupProps = Omit<React.HTMLAttributes<HTMLDivElement>, "className" | "style">;
+export interface ShortcutProps extends Omit<KbdProps, "keys"> {
+    shortcut: "copy" | "paste" | "cut" | "undo" | "redo" | "save" | "selectAll" | "find" | "new" | "open" | "close" | "refresh" | "print" | "bold" | "italic" | "underline";
+    forceCtrl?: boolean;
+}
+declare const KEY_SYMBOLS: Record<string, string>;
+declare function formatKey(key: string): string;
+declare const Kbd: React.ForwardRefExoticComponent<KbdProps & React.RefAttributes<HTMLElement>>;
+declare const KbdGroup: React.ForwardRefExoticComponent<KbdGroupProps & React.RefAttributes<HTMLDivElement>>;
+declare const Shortcut: React.ForwardRefExoticComponent<ShortcutProps & React.RefAttributes<HTMLElement>>;
+export { Kbd, KbdGroup, Shortcut, kbdVariants, KEY_SYMBOLS, formatKey };

package/dist/components/media.d.ts

@@ -0,0 +1,17 @@
+import * as React from "react";
+export type MediaRatio = "auto" | "square" | "video" | "portrait" | "wide";
+export type MediaRounded = "none" | "sm" | "md" | "lg" | "xl" | "full";
+type MediaVariantOptions = {
+    ratio?: MediaRatio | null;
+    rounded?: MediaRounded | null;
+};
+declare const mediaVariants: (_options?: MediaVariantOptions) => string;
+export interface ImageProps extends Omit<React.ImgHTMLAttributes<HTMLImageElement>, "className" | "style">, MediaVariantOptions {
+    fallback?: React.ReactNode;
+}
+declare const Image: React.ForwardRefExoticComponent<ImageProps & React.RefAttributes<HTMLImageElement>>;
+export interface VideoProps extends Omit<React.VideoHTMLAttributes<HTMLVideoElement>, "className" | "style">, MediaVariantOptions {
+    showControls?: boolean;
+}
+declare const Video: React.ForwardRefExoticComponent<VideoProps & React.RefAttributes<HTMLVideoElement>>;
+export { Image, Video, mediaVariants };

package/dist/components/menubar.d.ts

@@ -0,0 +1,36 @@
+import * as React from "react";
+import * as MenubarPrimitive from "@radix-ui/react-menubar";
+declare const MenubarMenu: typeof MenubarPrimitive.Menu;
+declare const MenubarGroup: typeof MenubarPrimitive.Group;
+declare const MenubarPortal: typeof MenubarPrimitive.Portal;
+declare const MenubarSub: typeof MenubarPrimitive.Sub;
+declare const MenubarRadioGroup: typeof MenubarPrimitive.RadioGroup;
+type MenubarRootProps = Omit<React.ComponentPropsWithoutRef<typeof MenubarPrimitive.Root>, "className" | "style">;
+type MenubarTriggerProps = Omit<React.ComponentPropsWithoutRef<typeof MenubarPrimitive.Trigger>, "className" | "style">;
+type MenubarContentProps = Omit<React.ComponentPropsWithoutRef<typeof MenubarPrimitive.Content>, "className" | "style">;
+type MenubarSubContentProps = Omit<React.ComponentPropsWithoutRef<typeof MenubarPrimitive.SubContent>, "className" | "style">;
+type MenubarCheckboxItemProps = Omit<React.ComponentPropsWithoutRef<typeof MenubarPrimitive.CheckboxItem>, "className" | "style">;
+type MenubarRadioItemProps = Omit<React.ComponentPropsWithoutRef<typeof MenubarPrimitive.RadioItem>, "className" | "style">;
+type MenubarSeparatorProps = Omit<React.ComponentPropsWithoutRef<typeof MenubarPrimitive.Separator>, "className" | "style">;
+type MenubarShortcutProps = Omit<React.HTMLAttributes<HTMLSpanElement>, "className" | "style">;
+declare const Menubar: React.ForwardRefExoticComponent<MenubarRootProps & React.RefAttributes<HTMLDivElement>>;
+declare const MenubarTrigger: React.ForwardRefExoticComponent<MenubarTriggerProps & React.RefAttributes<HTMLButtonElement>>;
+declare const MenubarSubTrigger: React.ForwardRefExoticComponent<Omit<Omit<MenubarPrimitive.MenubarSubTriggerProps & React.RefAttributes<HTMLDivElement>, "ref">, "style" | "className"> & {
+    inset?: boolean;
+} & React.RefAttributes<HTMLDivElement>>;
+declare const MenubarSubContent: React.ForwardRefExoticComponent<MenubarSubContentProps & React.RefAttributes<HTMLDivElement>>;
+declare const MenubarContent: React.ForwardRefExoticComponent<MenubarContentProps & React.RefAttributes<HTMLDivElement>>;
+declare const MenubarItem: React.ForwardRefExoticComponent<Omit<Omit<MenubarPrimitive.MenubarItemProps & React.RefAttributes<HTMLDivElement>, "ref">, "style" | "className"> & {
+    inset?: boolean;
+} & React.RefAttributes<HTMLDivElement>>;
+declare const MenubarCheckboxItem: React.ForwardRefExoticComponent<MenubarCheckboxItemProps & React.RefAttributes<HTMLDivElement>>;
+declare const MenubarRadioItem: React.ForwardRefExoticComponent<MenubarRadioItemProps & React.RefAttributes<HTMLDivElement>>;
+declare const MenubarLabel: React.ForwardRefExoticComponent<Omit<Omit<MenubarPrimitive.MenubarLabelProps & React.RefAttributes<HTMLDivElement>, "ref">, "style" | "className"> & {
+    inset?: boolean;
+} & React.RefAttributes<HTMLDivElement>>;
+declare const MenubarSeparator: React.ForwardRefExoticComponent<MenubarSeparatorProps & React.RefAttributes<HTMLDivElement>>;
+declare const MenubarShortcut: {
+    ({ ...props }: MenubarShortcutProps): import("react/jsx-runtime").JSX.Element;
+    displayName: string;
+};
+export { Menubar, MenubarMenu, MenubarTrigger, MenubarContent, MenubarItem, MenubarSeparator, MenubarLabel, MenubarCheckboxItem, MenubarRadioGroup, MenubarRadioItem, MenubarPortal, MenubarSubContent, MenubarSubTrigger, MenubarGroup, MenubarSub, MenubarShortcut, };

package/dist/components/multi-select.d.ts

@@ -0,0 +1,18 @@
+import * as React from "react";
+export interface MultiSelectOption {
+    disabled?: boolean;
+    label: string;
+    value: string;
+}
+export interface MultiSelectProps {
+    disabled?: boolean;
+    emptyMessage?: string;
+    maxDisplayedItems?: number;
+    onChange?: (value: string[]) => void;
+    options: MultiSelectOption[];
+    placeholder?: string;
+    searchPlaceholder?: string;
+    value?: string[];
+}
+declare const MultiSelect: React.ForwardRefExoticComponent<MultiSelectProps & React.RefAttributes<HTMLButtonElement>>;
+export { MultiSelect };

package/dist/components/navigation-drawer.d.ts

@@ -0,0 +1,54 @@
+import * as React from "react";
+declare const useNavigationDrawer: () => {
+    collapsed: boolean;
+    setCollapsed: (collapsed: boolean) => void;
+    isMobile: boolean;
+};
+interface NavigationDrawerProviderProps {
+    children: React.ReactNode;
+    defaultCollapsed?: boolean;
+}
+declare const NavigationDrawerProvider: ({ children, defaultCollapsed, }: NavigationDrawerProviderProps) => import("react/jsx-runtime").JSX.Element;
+declare const NavigationDrawer: React.ForwardRefExoticComponent<Omit<React.HTMLAttributes<HTMLDivElement>, "style" | "className"> & React.RefAttributes<HTMLDivElement>>;
+declare const NavigationDrawerHeader: React.ForwardRefExoticComponent<Omit<React.HTMLAttributes<HTMLDivElement>, "style" | "className"> & React.RefAttributes<HTMLDivElement>>;
+declare const NavigationDrawerContent: React.ForwardRefExoticComponent<Omit<React.HTMLAttributes<HTMLDivElement>, "style" | "className"> & React.RefAttributes<HTMLDivElement>>;
+declare const NavigationDrawerFooter: React.ForwardRefExoticComponent<Omit<React.HTMLAttributes<HTMLDivElement>, "style" | "className"> & React.RefAttributes<HTMLDivElement>>;
+declare const NavigationDrawerToggle: React.ForwardRefExoticComponent<Omit<React.ButtonHTMLAttributes<HTMLButtonElement>, "style" | "className"> & React.RefAttributes<HTMLButtonElement>>;
+export interface NavigationDrawerItemProps extends Omit<React.AnchorHTMLAttributes<HTMLAnchorElement>, "className" | "style"> {
+    icon?: React.ReactNode;
+    asChild?: boolean;
+    active?: boolean;
+}
+declare const NavigationDrawerItem: React.ForwardRefExoticComponent<NavigationDrawerItemProps & React.RefAttributes<HTMLAnchorElement>>;
+declare const NavigationDrawerGroup: React.ForwardRefExoticComponent<Omit<React.HTMLAttributes<HTMLDivElement>, "style" | "className"> & {
+    label?: string;
+} & React.RefAttributes<HTMLDivElement>>;
+/**
+ * Layout helper that renders the navigation drawer alongside main content.
+ * Wraps everything in the provider so open/close/collapse all work automatically.
+ *
+ * Usage:
+ * ```tsx
+ * <NavigationDrawerLayout
+ *   sidebar={<>
+ *     <NavigationDrawerHeader>Logo</NavigationDrawerHeader>
+ *     <NavigationDrawerContent>
+ *       <NavigationDrawerItem href="/" icon={<Home />} active>Home</NavigationDrawerItem>
+ *     </NavigationDrawerContent>
+ *     <NavigationDrawerFooter><NavigationDrawerToggle /></NavigationDrawerFooter>
+ *   </>}
+ * >
+ *   <main>Page content</main>
+ * </NavigationDrawerLayout>
+ * ```
+ */
+interface NavigationDrawerLayoutProps {
+    children: React.ReactNode;
+    sidebar: React.ReactNode;
+    defaultCollapsed?: boolean;
+}
+declare const NavigationDrawerLayout: {
+    ({ children, sidebar, defaultCollapsed, }: NavigationDrawerLayoutProps): import("react/jsx-runtime").JSX.Element;
+    displayName: string;
+};
+export { NavigationDrawerProvider, NavigationDrawer, NavigationDrawerHeader, NavigationDrawerContent, NavigationDrawerFooter, NavigationDrawerToggle, NavigationDrawerItem, NavigationDrawerGroup, NavigationDrawerLayout, useNavigationDrawer, };

package/dist/components/navigation-menu.d.ts

@@ -0,0 +1,18 @@
+import * as React from "react";
+import * as NavigationMenuPrimitive from "@radix-ui/react-navigation-menu";
+type NavigationMenuRootProps = Omit<React.ComponentPropsWithoutRef<typeof NavigationMenuPrimitive.Root>, "className" | "style">;
+type NavigationMenuListProps = Omit<React.ComponentPropsWithoutRef<typeof NavigationMenuPrimitive.List>, "className" | "style">;
+type NavigationMenuTriggerProps = Omit<React.ComponentPropsWithoutRef<typeof NavigationMenuPrimitive.Trigger>, "className" | "style">;
+type NavigationMenuContentProps = Omit<React.ComponentPropsWithoutRef<typeof NavigationMenuPrimitive.Content>, "className" | "style">;
+type NavigationMenuViewportProps = Omit<React.ComponentPropsWithoutRef<typeof NavigationMenuPrimitive.Viewport>, "className" | "style">;
+type NavigationMenuIndicatorProps = Omit<React.ComponentPropsWithoutRef<typeof NavigationMenuPrimitive.Indicator>, "className" | "style">;
+declare const NavigationMenu: React.ForwardRefExoticComponent<NavigationMenuRootProps & React.RefAttributes<HTMLElement>>;
+declare const NavigationMenuList: React.ForwardRefExoticComponent<NavigationMenuListProps & React.RefAttributes<HTMLUListElement>>;
+declare const NavigationMenuItem: React.ForwardRefExoticComponent<NavigationMenuPrimitive.NavigationMenuItemProps & React.RefAttributes<HTMLLIElement>>;
+declare const navigationMenuTriggerStyle: () => string;
+declare const NavigationMenuTrigger: React.ForwardRefExoticComponent<NavigationMenuTriggerProps & React.RefAttributes<HTMLButtonElement>>;
+declare const NavigationMenuContent: React.ForwardRefExoticComponent<NavigationMenuContentProps & React.RefAttributes<HTMLDivElement>>;
+declare const NavigationMenuLink: React.ForwardRefExoticComponent<NavigationMenuPrimitive.NavigationMenuLinkProps & React.RefAttributes<HTMLAnchorElement>>;
+declare const NavigationMenuViewport: React.ForwardRefExoticComponent<NavigationMenuViewportProps & React.RefAttributes<HTMLDivElement>>;
+declare const NavigationMenuIndicator: React.ForwardRefExoticComponent<NavigationMenuIndicatorProps & React.RefAttributes<HTMLDivElement>>;
+export { navigationMenuTriggerStyle, NavigationMenu, NavigationMenuList, NavigationMenuItem, NavigationMenuContent, NavigationMenuTrigger, NavigationMenuLink, NavigationMenuIndicator, NavigationMenuViewport, };

package/dist/components/number-input.d.ts

@@ -0,0 +1,13 @@
+import * as React from "react";
+export interface NumberInputProps extends Omit<React.InputHTMLAttributes<HTMLInputElement>, "className" | "size" | "style" | "type" | "value" | "onChange"> {
+    value?: number;
+    onChange?: (value: number | undefined) => void;
+    min?: number;
+    max?: number;
+    step?: number;
+    showControls?: boolean;
+    allowNegative?: boolean;
+    clampOnBlur?: boolean;
+}
+declare const NumberInput: React.ForwardRefExoticComponent<NumberInputProps & React.RefAttributes<HTMLInputElement>>;
+export { NumberInput };