@moving-walls/design-system 1.0.0

package/dist/src/components/ui/CollapsibleCode.d.ts

@@ -0,0 +1,9 @@
+interface CollapsibleCodeProps {
+    code: string;
+    language?: string;
+    title?: string;
+    defaultExpanded?: boolean;
+    className?: string;
+}
+export declare function CollapsibleCode({ code, language, title, defaultExpanded, className }: CollapsibleCodeProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/src/components/ui/ColumnCustomizationDrawer.d.ts

@@ -0,0 +1,15 @@
+export interface ColumnConfig {
+    id: string;
+    label: string;
+    visible: boolean;
+    locked?: boolean;
+}
+export interface ColumnCustomizationDrawerProps {
+    isOpen: boolean;
+    onClose: () => void;
+    columns: ColumnConfig[];
+    onApply: (columns: ColumnConfig[]) => void;
+    title?: string;
+}
+export declare function ColumnCustomizationDrawer({ isOpen, onClose, columns, onApply, title, }: ColumnCustomizationDrawerProps): import("react/jsx-runtime").JSX.Element;
+export default ColumnCustomizationDrawer;

package/dist/src/components/ui/Command.d.ts

@@ -0,0 +1,18 @@
+export interface CommandProps extends React.HTMLAttributes<HTMLDivElement> {
+    value?: string;
+    onValueChange?: (value: string) => void;
+    placeholder?: string;
+    disabled?: boolean;
+}
+export interface CommandItemProps extends Omit<React.HTMLAttributes<HTMLDivElement>, 'onSelect'> {
+    value?: string;
+    onSelect?: (value: string) => void;
+    disabled?: boolean;
+}
+export interface CommandGroupProps extends React.HTMLAttributes<HTMLDivElement> {
+    heading?: string;
+}
+export declare const Command: import("react").ForwardRefExoticComponent<CommandProps & import("react").RefAttributes<HTMLDivElement>>;
+export declare const CommandGroup: import("react").ForwardRefExoticComponent<CommandGroupProps & import("react").RefAttributes<HTMLDivElement>>;
+export declare const CommandItem: import("react").ForwardRefExoticComponent<CommandItemProps & import("react").RefAttributes<HTMLDivElement>>;
+export declare const CommandSeparator: import("react").ForwardRefExoticComponent<import("react").HTMLAttributes<HTMLDivElement> & import("react").RefAttributes<HTMLDivElement>>;

package/dist/src/components/ui/Container.d.ts

@@ -0,0 +1,70 @@
+import React from 'react';
+interface ContainerProps {
+    children: React.ReactNode;
+    size?: 'xs' | 'sm' | 'md' | 'lg' | 'xl' | '2xl' | 'full';
+    padding?: 'none' | 'sm' | 'md' | 'lg' | 'xl';
+    centered?: boolean;
+    className?: string;
+    as?: keyof JSX.IntrinsicElements;
+}
+declare const containerSizes: {
+    xs: string;
+    sm: string;
+    md: string;
+    lg: string;
+    xl: string;
+    '2xl': string;
+    full: string;
+};
+export declare function Container({ children, size, padding, centered, className, as: Component }: ContainerProps): import("react/jsx-runtime").JSX.Element;
+interface ResponsiveContainerProps extends Omit<ContainerProps, 'size'> {
+    breakpoints?: {
+        sm?: keyof typeof containerSizes;
+        md?: keyof typeof containerSizes;
+        lg?: keyof typeof containerSizes;
+        xl?: keyof typeof containerSizes;
+        '2xl'?: keyof typeof containerSizes;
+    };
+}
+export declare function ResponsiveContainer({ children, breakpoints, padding, centered, className, as: Component }: ResponsiveContainerProps): import("react/jsx-runtime").JSX.Element;
+interface GridContainerProps {
+    children: React.ReactNode;
+    cols?: number | {
+        sm?: number;
+        md?: number;
+        lg?: number;
+        xl?: number;
+    };
+    gap?: number | {
+        x?: number;
+        y?: number;
+    };
+    className?: string;
+}
+export declare function GridContainer({ children, cols, gap, className }: GridContainerProps): import("react/jsx-runtime").JSX.Element;
+interface FlexContainerProps {
+    children: React.ReactNode;
+    direction?: 'row' | 'row-reverse' | 'col' | 'col-reverse';
+    wrap?: 'wrap' | 'wrap-reverse' | 'nowrap';
+    align?: 'start' | 'end' | 'center' | 'baseline' | 'stretch';
+    justify?: 'start' | 'end' | 'center' | 'between' | 'around' | 'evenly';
+    gap?: number;
+    className?: string;
+}
+export declare function FlexContainer({ children, direction, wrap, align, justify, gap, className }: FlexContainerProps): import("react/jsx-runtime").JSX.Element;
+interface StackProps {
+    children: React.ReactNode;
+    spacing?: number;
+    divider?: React.ReactNode;
+    className?: string;
+}
+export declare function Stack({ children, spacing, divider, className }: StackProps): import("react/jsx-runtime").JSX.Element;
+interface HStackProps {
+    children: React.ReactNode;
+    spacing?: number;
+    divider?: React.ReactNode;
+    align?: 'start' | 'end' | 'center' | 'baseline' | 'stretch';
+    className?: string;
+}
+export declare function HStack({ children, spacing, divider, align, className }: HStackProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/src/components/ui/DataGrid.d.ts

@@ -0,0 +1,64 @@
+import React from 'react';
+export type DataGridColumnType = 'text' | 'number' | 'date' | 'boolean' | 'custom';
+export type DataGridSortDirection = 'asc' | 'desc' | null;
+export interface DataGridColumn<T = any> {
+    id: string;
+    header: string;
+    accessorKey?: keyof T;
+    cell?: (value: any, row: T) => React.ReactNode;
+    sortable?: boolean;
+    filterable?: boolean;
+    type?: DataGridColumnType;
+    width?: number | string;
+    minWidth?: number;
+    maxWidth?: number;
+    align?: 'left' | 'center' | 'right';
+    sticky?: 'left' | 'right';
+}
+export interface DataGridSort {
+    columnId: string;
+    direction: DataGridSortDirection;
+}
+export interface DataGridFilter {
+    columnId: string;
+    value: any;
+    operator?: 'equals' | 'contains' | 'startsWith' | 'endsWith' | 'gt' | 'lt' | 'gte' | 'lte';
+}
+export interface DataGridSelection<T = any> {
+    mode: 'none' | 'single' | 'multiple';
+    selectedRows: Set<string | number>;
+    onSelectionChange?: (selectedRows: Set<string | number>, selectedData: T[]) => void;
+}
+interface DataGridProps<T = any> {
+    data: T[];
+    columns: DataGridColumn<T>[];
+    getRowId?: (row: T, index: number) => string | number;
+    sorting?: DataGridSort[];
+    onSortingChange?: (sorting: DataGridSort[]) => void;
+    filters?: DataGridFilter[];
+    onFiltersChange?: (filters: DataGridFilter[]) => void;
+    selection?: DataGridSelection<T>;
+    pagination?: {
+        pageIndex: number;
+        pageSize: number;
+        total: number;
+        onPageChange: (pageIndex: number) => void;
+        onPageSizeChange: (pageSize: number) => void;
+    };
+    rowActions?: Array<{
+        label: string;
+        icon?: React.ReactNode;
+        onClick: (row: T) => void;
+        variant?: 'default' | 'destructive';
+    }>;
+    loading?: boolean;
+    emptyMessage?: string;
+    striped?: boolean;
+    bordered?: boolean;
+    compact?: boolean;
+    stickyHeader?: boolean;
+    maxHeight?: string;
+    className?: string;
+}
+export declare function DataGrid<T extends Record<string, any>>({ data, columns, getRowId, sorting, onSortingChange, filters, onFiltersChange, selection, pagination, rowActions, loading, emptyMessage, striped, bordered, compact, stickyHeader, maxHeight, className }: DataGridProps<T>): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/src/components/ui/DatePicker.d.ts

@@ -0,0 +1,12 @@
+export interface DatePickerProps {
+    value?: Date;
+    onChange?: (date: Date) => void;
+    placeholder?: string;
+    disabled?: boolean;
+    className?: string;
+    label?: string;
+    error?: string;
+    minDate?: Date;
+    maxDate?: Date;
+}
+export declare function DatePicker({ value, onChange, placeholder, disabled, className, label, error, minDate, maxDate }: DatePickerProps): import("react/jsx-runtime").JSX.Element;

package/dist/src/components/ui/DateRangePicker.d.ts

@@ -0,0 +1,24 @@
+interface DateRange {
+    from: Date | null;
+    to: Date | null;
+}
+interface DateRangePickerProps {
+    value?: DateRange;
+    onChange?: (range: DateRange) => void;
+    placeholder?: string;
+    disabled?: boolean;
+    required?: boolean;
+    clearable?: boolean;
+    minDate?: Date;
+    maxDate?: Date;
+    selectsRange?: boolean;
+    numberOfMonths?: 1 | 2;
+    className?: string;
+    format?: string;
+    presets?: Array<{
+        label: string;
+        range: DateRange;
+    }>;
+}
+export declare function DateRangePicker({ value, onChange, placeholder, disabled, required, clearable, minDate, maxDate, numberOfMonths, className, format, presets }: DateRangePickerProps): import("react/jsx-runtime").JSX.Element;
+export default DateRangePicker;

package/dist/src/components/ui/Dialog.d.ts

@@ -0,0 +1,40 @@
+import React from 'react';
+export interface DialogProps {
+    open?: boolean;
+    onOpenChange?: (open: boolean) => void;
+    children: React.ReactNode;
+}
+export interface DialogContentProps extends React.HTMLAttributes<HTMLDivElement> {
+    children: React.ReactNode;
+    showCloseButton?: boolean;
+}
+export interface DialogHeaderProps extends React.HTMLAttributes<HTMLDivElement> {
+    children: React.ReactNode;
+}
+export interface DialogFooterProps extends React.HTMLAttributes<HTMLDivElement> {
+    children: React.ReactNode;
+}
+export interface DialogTitleProps extends React.HTMLAttributes<HTMLHeadingElement> {
+    children: React.ReactNode;
+}
+export interface DialogDescriptionProps extends React.HTMLAttributes<HTMLParagraphElement> {
+    children: React.ReactNode;
+}
+export interface DialogTriggerProps extends React.HTMLAttributes<HTMLElement> {
+    children: React.ReactNode;
+    asChild?: boolean;
+}
+export declare function Dialog({ open, onOpenChange, children }: DialogProps): import("react/jsx-runtime").JSX.Element;
+export declare function DialogTrigger({ children, asChild, onClick, ...props }: DialogTriggerProps): import("react/jsx-runtime").JSX.Element;
+export declare function DialogContent({ children, className, showCloseButton, ...props }: DialogContentProps): import("react/jsx-runtime").JSX.Element | null;
+export declare function DialogHeader({ children, className, ...props }: DialogHeaderProps): import("react/jsx-runtime").JSX.Element;
+export declare function DialogFooter({ children, className, ...props }: DialogFooterProps): import("react/jsx-runtime").JSX.Element;
+export declare function DialogTitle({ children, className, ...props }: DialogTitleProps): import("react/jsx-runtime").JSX.Element;
+export declare function DialogDescription({ children, className, ...props }: DialogDescriptionProps): import("react/jsx-runtime").JSX.Element;
+export declare function useDialog(): {
+    open: boolean;
+    setOpen: React.Dispatch<React.SetStateAction<boolean>>;
+    onOpenChange: React.Dispatch<React.SetStateAction<boolean>>;
+    close: () => void;
+    toggle: () => void;
+};

package/dist/src/components/ui/DocumentEditor.d.ts

@@ -0,0 +1,21 @@
+interface DocumentEditorProps {
+    value?: string;
+    onChange?: (value: string) => void;
+    title?: string;
+    onTitleChange?: (title: string) => void;
+    mode?: 'edit' | 'view' | 'split';
+    showToolbar?: boolean;
+    showSidebar?: boolean;
+    showStatusBar?: boolean;
+    autoSave?: boolean;
+    autoSaveInterval?: number;
+    className?: string;
+    onSave?: (content: string) => void;
+    onExport?: (format: 'pdf' | 'docx' | 'txt') => void;
+    readOnly?: boolean;
+    collaborative?: boolean;
+    zoom?: number;
+    onZoomChange?: (zoom: number) => void;
+}
+export declare function DocumentEditor({ value, onChange, title, onTitleChange, mode, showToolbar, showSidebar, showStatusBar, autoSave, autoSaveInterval, className, onSave, onExport, readOnly, collaborative, zoom, onZoomChange }: DocumentEditorProps): import("react/jsx-runtime").JSX.Element;
+export default DocumentEditor;

package/dist/src/components/ui/DragDrop.d.ts

@@ -0,0 +1,50 @@
+import React from 'react';
+export interface DroppedFile {
+    id: string;
+    file: File;
+    status: 'pending' | 'uploading' | 'success' | 'error';
+    progress?: number;
+    error?: string;
+    preview?: string;
+}
+export declare function useDragDrop({ onDrop, accept, multiple, maxSize, onError }: {
+    onDrop: (files: File[]) => void;
+    accept?: string[];
+    multiple?: boolean;
+    maxSize?: number;
+    onError?: (error: string) => void;
+}): {
+    isDragActive: boolean;
+    isDragReject: boolean;
+    dragProps: {
+        onDrop: (e: React.DragEvent) => void;
+        onDragEnter: (e: React.DragEvent) => void;
+        onDragLeave: (e: React.DragEvent) => void;
+        onDragOver: (e: React.DragEvent) => void;
+    };
+};
+interface DragDropProps {
+    onFileDrop: (files: File[]) => void;
+    accept?: string[];
+    multiple?: boolean;
+    maxSize?: number;
+    maxFiles?: number;
+    disabled?: boolean;
+    className?: string;
+    children?: React.ReactNode;
+    showPreview?: boolean;
+    compact?: boolean;
+}
+export declare function DragDrop({ onFileDrop, accept, multiple, maxSize, maxFiles, disabled, className, children, showPreview, compact }: DragDropProps): import("react/jsx-runtime").JSX.Element;
+interface SortableItem {
+    id: string;
+    content: React.ReactNode;
+}
+interface SortableListProps {
+    items: SortableItem[];
+    onReorder: (items: SortableItem[]) => void;
+    className?: string;
+    itemClassName?: string;
+}
+export declare function SortableList({ items, onReorder, className, itemClassName }: SortableListProps): import("react/jsx-runtime").JSX.Element;
+export default DragDrop;

package/dist/src/components/ui/Dropdown.d.ts

@@ -0,0 +1,30 @@
+import { ReactNode } from 'react';
+export interface DropdownProps {
+    children: ReactNode;
+    className?: string;
+}
+export declare const Dropdown: ({ children, className }: DropdownProps) => import("react/jsx-runtime").JSX.Element;
+export interface DropdownTriggerProps {
+    children: ReactNode;
+    asChild?: boolean;
+    className?: string;
+}
+export declare const DropdownTrigger: ({ children, asChild, className }: DropdownTriggerProps) => import("react/jsx-runtime").JSX.Element;
+export interface DropdownContentProps {
+    children: ReactNode;
+    className?: string;
+    align?: 'left' | 'right' | 'center' | 'end';
+    sideOffset?: number;
+}
+export declare const DropdownContent: ({ children, className, align, sideOffset }: DropdownContentProps) => import("react").ReactPortal | null;
+export interface DropdownItemProps {
+    children: ReactNode;
+    onClick?: () => void;
+    disabled?: boolean;
+    className?: string;
+}
+export declare const DropdownItem: ({ children, onClick, disabled, className }: DropdownItemProps) => import("react/jsx-runtime").JSX.Element;
+export interface DropdownSeparatorProps {
+    className?: string;
+}
+export declare const DropdownSeparator: ({ className }: DropdownSeparatorProps) => import("react/jsx-runtime").JSX.Element;

package/dist/src/components/ui/DropdownMenu.d.ts

@@ -0,0 +1,46 @@
+import React from 'react';
+export { Dropdown as DropdownMenu, DropdownTrigger as DropdownMenuTrigger, DropdownContent as DropdownMenuContent, DropdownItem as DropdownMenuItem, DropdownSeparator as DropdownMenuSeparator, } from './Dropdown';
+export { DropdownTrigger, DropdownContent, DropdownItem, DropdownSeparator, } from './Dropdown';
+export interface DropdownMenuLabelProps extends React.HTMLAttributes<HTMLDivElement> {
+    children?: React.ReactNode;
+    inset?: boolean;
+}
+export declare const DropdownMenuLabel: React.ForwardRefExoticComponent<DropdownMenuLabelProps & React.RefAttributes<HTMLDivElement>>;
+export interface DropdownMenuCheckboxItemProps extends React.HTMLAttributes<HTMLDivElement> {
+    children?: React.ReactNode;
+    checked?: boolean;
+    onCheckedChange?: (checked: boolean) => void;
+    disabled?: boolean;
+}
+export declare const DropdownMenuCheckboxItem: React.ForwardRefExoticComponent<DropdownMenuCheckboxItemProps & React.RefAttributes<HTMLDivElement>>;
+export interface DropdownMenuRadioGroupProps extends React.HTMLAttributes<HTMLDivElement> {
+    children?: React.ReactNode;
+    value?: string;
+    onValueChange?: (value: string) => void;
+}
+export declare const DropdownMenuRadioGroup: React.ForwardRefExoticComponent<DropdownMenuRadioGroupProps & React.RefAttributes<HTMLDivElement>>;
+export interface DropdownMenuRadioItemProps extends React.HTMLAttributes<HTMLDivElement> {
+    children?: React.ReactNode;
+    value: string;
+    disabled?: boolean;
+    checked?: boolean;
+    onSelect?: () => void;
+}
+export declare const DropdownMenuRadioItem: React.ForwardRefExoticComponent<DropdownMenuRadioItemProps & React.RefAttributes<HTMLDivElement>>;
+export interface DropdownMenuGroupProps extends React.HTMLAttributes<HTMLDivElement> {
+    children?: React.ReactNode;
+}
+export declare const DropdownMenuGroup: React.ForwardRefExoticComponent<DropdownMenuGroupProps & React.RefAttributes<HTMLDivElement>>;
+export interface DropdownMenuSubProps extends React.HTMLAttributes<HTMLDivElement> {
+    children?: React.ReactNode;
+}
+export declare const DropdownMenuSub: React.ForwardRefExoticComponent<DropdownMenuSubProps & React.RefAttributes<HTMLDivElement>>;
+export interface DropdownMenuSubTriggerProps extends React.HTMLAttributes<HTMLDivElement> {
+    children?: React.ReactNode;
+    inset?: boolean;
+}
+export declare const DropdownMenuSubTrigger: React.ForwardRefExoticComponent<DropdownMenuSubTriggerProps & React.RefAttributes<HTMLDivElement>>;
+export interface DropdownMenuSubContentProps extends React.HTMLAttributes<HTMLDivElement> {
+    children?: React.ReactNode;
+}
+export declare const DropdownMenuSubContent: React.ForwardRefExoticComponent<DropdownMenuSubContentProps & React.RefAttributes<HTMLDivElement>>;

package/dist/src/components/ui/EmptyState.d.ts

@@ -0,0 +1,27 @@
+export interface EmptyStateProps extends React.HTMLAttributes<HTMLDivElement> {
+    icon?: React.ReactNode;
+    title: string;
+    description?: string;
+    action?: {
+        label: string;
+        onClick: () => void;
+        variant?: 'primary' | 'secondary' | 'outline';
+        icon?: React.ReactNode;
+    };
+    secondaryAction?: {
+        label: string;
+        onClick: () => void;
+        variant?: 'primary' | 'secondary' | 'outline' | 'ghost';
+        icon?: React.ReactNode;
+    };
+    size?: 'sm' | 'md' | 'lg';
+    showBackground?: boolean;
+}
+export declare function EmptyState({ icon, title, description, action, secondaryAction, size, showBackground, className, ...props }: EmptyStateProps): import("react/jsx-runtime").JSX.Element;
+export declare function NoDataEmptyState(props: Omit<EmptyStateProps, 'icon'>): import("react/jsx-runtime").JSX.Element;
+export declare function NoResultsEmptyState(props: Omit<EmptyStateProps, 'icon'>): import("react/jsx-runtime").JSX.Element;
+export declare function NoFilesEmptyState(props: Omit<EmptyStateProps, 'icon'>): import("react/jsx-runtime").JSX.Element;
+export declare function NoUsersEmptyState(props: Omit<EmptyStateProps, 'icon'>): import("react/jsx-runtime").JSX.Element;
+export declare function NoCreativesEmptyState(props: Omit<EmptyStateProps, 'icon'>): import("react/jsx-runtime").JSX.Element;
+export declare function NoImagesEmptyState(props: Omit<EmptyStateProps, 'icon'>): import("react/jsx-runtime").JSX.Element;
+export declare function NoDocumentsEmptyState(props: Omit<EmptyStateProps, 'icon'>): import("react/jsx-runtime").JSX.Element;

package/dist/src/components/ui/FileUpload.d.ts

@@ -0,0 +1,16 @@
+import React from 'react';
+interface FileUploadProps {
+    onFilesChange?: (files: File[]) => void;
+    onError?: (error: string) => void;
+    multiple?: boolean;
+    accept?: string;
+    maxSize?: number;
+    maxFiles?: number;
+    disabled?: boolean;
+    className?: string;
+    children?: React.ReactNode;
+    variant?: 'dropzone' | 'button' | 'input';
+    showPreview?: boolean;
+}
+export declare function FileUpload({ onFilesChange, onError, multiple, accept, maxSize, maxFiles, disabled, className, children, variant, showPreview }: FileUploadProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/src/components/ui/Filter.d.ts

@@ -0,0 +1,38 @@
+type FilterOperator = 'equals' | 'not_equals' | 'contains' | 'not_contains' | 'starts_with' | 'ends_with' | 'greater_than' | 'less_than' | 'greater_equal' | 'less_equal' | 'between' | 'in' | 'not_in' | 'is_empty' | 'is_not_empty';
+type FilterType = 'text' | 'number' | 'select' | 'multiselect' | 'date' | 'daterange' | 'boolean' | 'custom';
+interface FilterRule {
+    id: string;
+    field: string;
+    operator: FilterOperator;
+    value: any;
+    type: FilterType;
+}
+interface FilterField {
+    key: string;
+    label: string;
+    type: FilterType;
+    options?: Array<{
+        value: any;
+        label: string;
+    }>;
+    operators?: FilterOperator[];
+    placeholder?: string;
+}
+interface FilterProps {
+    fields: FilterField[];
+    value?: FilterRule[];
+    onChange?: (filters: FilterRule[]) => void;
+    placeholder?: string;
+    showCount?: boolean;
+    allowMultiple?: boolean;
+    presets?: Array<{
+        label: string;
+        filters: FilterRule[];
+    }>;
+    className?: string;
+    onApply?: (filters: FilterRule[]) => void;
+    onClear?: () => void;
+}
+export declare function Filter({ fields, value, onChange, placeholder, showCount, allowMultiple, presets, className, onApply, onClear }: FilterProps): import("react/jsx-runtime").JSX.Element;
+export default Filter;
+export type { FilterRule, FilterField, FilterOperator, FilterType };

package/dist/src/components/ui/Form.d.ts

@@ -0,0 +1,79 @@
+import React from 'react';
+interface FormContextValue {
+    disabled?: boolean;
+    size?: 'sm' | 'md' | 'lg';
+}
+interface FormProps {
+    children: React.ReactNode;
+    onSubmit?: (event: React.FormEvent<HTMLFormElement>) => void;
+    className?: string;
+    disabled?: boolean;
+    size?: 'sm' | 'md' | 'lg';
+    layout?: 'vertical' | 'horizontal' | 'inline';
+}
+interface FormSectionProps {
+    children: React.ReactNode;
+    title?: string;
+    description?: string;
+    className?: string;
+}
+interface FormGroupProps {
+    children: React.ReactNode;
+    className?: string;
+    required?: boolean;
+}
+interface FormFieldProps {
+    children: React.ReactNode;
+    className?: string;
+}
+interface FormLabelProps {
+    children: React.ReactNode;
+    htmlFor?: string;
+    required?: boolean;
+    className?: string;
+}
+interface FormControlProps {
+    children: React.ReactNode;
+    className?: string;
+}
+interface FormDescriptionProps {
+    children: React.ReactNode;
+    className?: string;
+}
+interface FormErrorProps {
+    children: React.ReactNode;
+    className?: string;
+}
+interface FormActionsProps {
+    children: React.ReactNode;
+    className?: string;
+    align?: 'left' | 'center' | 'right';
+}
+export declare function Form({ children, onSubmit, className, disabled, size, layout }: FormProps): import("react/jsx-runtime").JSX.Element;
+export declare function FormSection({ children, title, description, className }: FormSectionProps): import("react/jsx-runtime").JSX.Element;
+export declare function FormGroup({ children, className, required }: FormGroupProps): import("react/jsx-runtime").JSX.Element;
+export declare function FormField({ children, className }: FormFieldProps): import("react/jsx-runtime").JSX.Element;
+export interface FormItemProps {
+    children: React.ReactNode;
+    className?: string;
+}
+export declare function FormItem({ children, className }: FormItemProps): import("react/jsx-runtime").JSX.Element;
+export declare function FormLabel({ children, htmlFor, required, className }: FormLabelProps): import("react/jsx-runtime").JSX.Element;
+export declare function FormControl({ children, className }: FormControlProps): import("react/jsx-runtime").JSX.Element;
+export declare function FormDescription({ children, className }: FormDescriptionProps): import("react/jsx-runtime").JSX.Element;
+export declare function FormError({ children, className }: FormErrorProps): import("react/jsx-runtime").JSX.Element;
+export interface FormMessageProps {
+    children?: React.ReactNode;
+    className?: string;
+}
+export declare function FormMessage({ children, className }: FormMessageProps): import("react/jsx-runtime").JSX.Element | null;
+export declare function FormActions({ children, className, align }: FormActionsProps): import("react/jsx-runtime").JSX.Element;
+export declare function useFormContext(): FormContextValue;
+interface FieldsetProps {
+    children: React.ReactNode;
+    legend?: string;
+    className?: string;
+    disabled?: boolean;
+}
+export declare function Fieldset({ children, legend, className, disabled }: FieldsetProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/src/components/ui/Icon.d.ts

@@ -0,0 +1,22 @@
+import { LucideIcon } from 'lucide-react';
+interface IconProps {
+    icon: LucideIcon;
+    size?: 'xs' | 'sm' | 'md' | 'lg' | 'xl';
+    variant?: 'default' | 'primary' | 'secondary' | 'success' | 'warning' | 'error';
+    className?: string;
+    onClick?: () => void;
+}
+export declare function Icon({ icon: IconComponent, size, variant, className, onClick, ...props }: IconProps): import("react/jsx-runtime").JSX.Element;
+export declare function ChevronDownIcon(props: Omit<IconProps, 'icon'>): import("react/jsx-runtime").JSX.Element;
+export declare function ChevronUpIcon(props: Omit<IconProps, 'icon'>): import("react/jsx-runtime").JSX.Element;
+export declare function ChevronLeftIcon(props: Omit<IconProps, 'icon'>): import("react/jsx-runtime").JSX.Element;
+export declare function ChevronRightIcon(props: Omit<IconProps, 'icon'>): import("react/jsx-runtime").JSX.Element;
+export declare function SearchIcon(props: Omit<IconProps, 'icon'>): import("react/jsx-runtime").JSX.Element;
+export declare function CloseIcon(props: Omit<IconProps, 'icon'>): import("react/jsx-runtime").JSX.Element;
+export declare function CheckIcon(props: Omit<IconProps, 'icon'>): import("react/jsx-runtime").JSX.Element;
+export declare function PlusIcon(props: Omit<IconProps, 'icon'>): import("react/jsx-runtime").JSX.Element;
+export declare function MinusIcon(props: Omit<IconProps, 'icon'>): import("react/jsx-runtime").JSX.Element;
+export declare function InfoIcon(props: Omit<IconProps, 'icon'>): import("react/jsx-runtime").JSX.Element;
+export declare function AlertTriangleIcon(props: Omit<IconProps, 'icon'>): import("react/jsx-runtime").JSX.Element;
+export declare function AlertCircleIcon(props: Omit<IconProps, 'icon'>): import("react/jsx-runtime").JSX.Element;
+export {};

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

@@ -0,0 +1,6 @@
+export interface InputProps extends React.InputHTMLAttributes<HTMLInputElement> {
+    label?: string;
+    error?: string;
+    helpText?: string;
+}
+export declare const Input: import("react").ForwardRefExoticComponent<InputProps & import("react").RefAttributes<HTMLInputElement>>;

package/dist/src/components/ui/Label.d.ts

@@ -0,0 +1,2 @@
+export { Label } from './Typography';
+export type { LabelProps } from './Typography';

package/dist/src/components/ui/List.d.ts

@@ -0,0 +1,38 @@
+import React from 'react';
+interface ListProps {
+    children: React.ReactNode;
+    variant?: 'ordered' | 'unordered' | 'none';
+    size?: 'sm' | 'md' | 'lg';
+    spacing?: 'tight' | 'normal' | 'loose';
+    className?: string;
+}
+interface ListItemProps {
+    children: React.ReactNode;
+    className?: string;
+    startContent?: React.ReactNode;
+    endContent?: React.ReactNode;
+}
+export declare function List({ children, variant, size, spacing, className }: ListProps): import("react/jsx-runtime").JSX.Element;
+export declare function ListItem({ children, className, startContent, endContent }: ListItemProps): import("react/jsx-runtime").JSX.Element;
+interface DescriptionListProps {
+    items: Array<{
+        term: React.ReactNode;
+        description: React.ReactNode;
+    }>;
+    layout?: 'vertical' | 'horizontal';
+    className?: string;
+}
+export declare function DescriptionList({ items, layout, className }: DescriptionListProps): import("react/jsx-runtime").JSX.Element;
+interface NavigationListProps {
+    items: Array<{
+        label: React.ReactNode;
+        href?: string;
+        onClick?: () => void;
+        active?: boolean;
+        disabled?: boolean;
+        icon?: React.ReactNode;
+    }>;
+    className?: string;
+}
+export declare function NavigationList({ items, className }: NavigationListProps): import("react/jsx-runtime").JSX.Element;
+export {};