@genispace/geniapp 0.1.0

package/dist/ui/components/ui/dialog-input.d.ts

@@ -0,0 +1,17 @@
+import * as React from "react";
+export interface DialogInputProps {
+    value: string | number;
+    onChange: (value: string | number) => void;
+    type?: 'text' | 'number';
+    placeholder?: string;
+    label?: string;
+    dialogTitle?: string;
+    dialogDescription?: string;
+    confirmText?: string;
+    cancelText?: string;
+    disabled?: boolean;
+    className?: string;
+    style?: React.CSSProperties;
+    minWidth?: string;
+}
+export declare const DialogInput: React.ForwardRefExoticComponent<DialogInputProps & React.RefAttributes<HTMLInputElement>>;

package/dist/ui/components/ui/dialog-safe-select.d.ts

@@ -0,0 +1,13 @@
+import * as React from "react";
+import * as SelectPrimitive from "@radix-ui/react-select";
+declare const DialogSafeSelect: React.FC<SelectPrimitive.SelectProps>;
+declare const DialogSafeSelectGroup: React.ForwardRefExoticComponent<SelectPrimitive.SelectGroupProps & React.RefAttributes<HTMLDivElement>>;
+declare const DialogSafeSelectValue: React.ForwardRefExoticComponent<SelectPrimitive.SelectValueProps & React.RefAttributes<HTMLSpanElement>>;
+declare const DialogSafeSelectTrigger: React.ForwardRefExoticComponent<Omit<SelectPrimitive.SelectTriggerProps & React.RefAttributes<HTMLButtonElement>, "ref"> & React.RefAttributes<HTMLButtonElement>>;
+declare const DialogSafeSelectScrollUpButton: React.ForwardRefExoticComponent<Omit<SelectPrimitive.SelectScrollUpButtonProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const DialogSafeSelectScrollDownButton: React.ForwardRefExoticComponent<Omit<SelectPrimitive.SelectScrollDownButtonProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const DialogSafeSelectContent: React.ForwardRefExoticComponent<Omit<SelectPrimitive.SelectContentProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const DialogSafeSelectLabel: React.ForwardRefExoticComponent<Omit<SelectPrimitive.SelectLabelProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const DialogSafeSelectItem: React.ForwardRefExoticComponent<Omit<SelectPrimitive.SelectItemProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const DialogSafeSelectSeparator: React.ForwardRefExoticComponent<Omit<SelectPrimitive.SelectSeparatorProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+export { DialogSafeSelect, DialogSafeSelectGroup, DialogSafeSelectValue, DialogSafeSelectTrigger, DialogSafeSelectContent, DialogSafeSelectLabel, DialogSafeSelectItem, DialogSafeSelectSeparator, DialogSafeSelectScrollUpButton, DialogSafeSelectScrollDownButton, };

package/dist/ui/components/ui/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>>;
+declare const DialogOverlay: React.ForwardRefExoticComponent<Omit<DialogPrimitive.DialogOverlayProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+interface DialogContentProps extends React.ComponentPropsWithoutRef<typeof DialogPrimitive.Content> {
+    nested?: boolean;
+    /** @default true */
+    showCloseButton?: boolean;
+    closeLabel?: string;
+}
+declare const DialogContent: React.ForwardRefExoticComponent<DialogContentProps & React.RefAttributes<HTMLDivElement>>;
+declare const DialogHeader: {
+    ({ className, ...props }: React.HTMLAttributes<HTMLDivElement>): React.JSX.Element;
+    displayName: string;
+};
+declare const DialogFooter: {
+    ({ className, ...props }: React.HTMLAttributes<HTMLDivElement>): React.JSX.Element;
+    displayName: string;
+};
+declare const DialogTitle: React.ForwardRefExoticComponent<Omit<DialogPrimitive.DialogTitleProps & React.RefAttributes<HTMLHeadingElement>, "ref"> & React.RefAttributes<HTMLHeadingElement>>;
+declare const DialogDescription: React.ForwardRefExoticComponent<Omit<DialogPrimitive.DialogDescriptionProps & React.RefAttributes<HTMLParagraphElement>, "ref"> & React.RefAttributes<HTMLParagraphElement>>;
+export { Dialog, DialogPortal, DialogOverlay, DialogTrigger, DialogClose, DialogContent, DialogHeader, DialogFooter, DialogTitle, DialogDescription, };

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

@@ -0,0 +1,27 @@
+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>>;
+declare const DropdownMenuSubTrigger: React.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuSubTriggerProps & React.RefAttributes<HTMLDivElement>, "ref"> & {
+    inset?: boolean;
+} & React.RefAttributes<HTMLDivElement>>;
+declare const DropdownMenuSubContent: React.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuSubContentProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const DropdownMenuContent: React.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuContentProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const DropdownMenuItem: React.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuItemProps & React.RefAttributes<HTMLDivElement>, "ref"> & {
+    inset?: boolean;
+} & React.RefAttributes<HTMLDivElement>>;
+declare const DropdownMenuCheckboxItem: React.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuCheckboxItemProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const DropdownMenuRadioItem: React.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuRadioItemProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const DropdownMenuLabel: React.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuLabelProps & React.RefAttributes<HTMLDivElement>, "ref"> & {
+    inset?: boolean;
+} & React.RefAttributes<HTMLDivElement>>;
+declare const DropdownMenuSeparator: React.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuSeparatorProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const DropdownMenuShortcut: {
+    ({ className, ...props }: React.HTMLAttributes<HTMLSpanElement>): React.JSX.Element;
+    displayName: string;
+};
+export { DropdownMenu, DropdownMenuTrigger, DropdownMenuContent, DropdownMenuItem, DropdownMenuCheckboxItem, DropdownMenuRadioItem, DropdownMenuLabel, DropdownMenuSeparator, DropdownMenuShortcut, DropdownMenuGroup, DropdownMenuPortal, DropdownMenuSub, DropdownMenuSubContent, DropdownMenuSubTrigger, DropdownMenuRadioGroup, };

package/dist/ui/components/ui/feature-guide.d.ts

@@ -0,0 +1,43 @@
+import { ButtonProps } from './button';
+import * as React from 'react';
+export interface FeatureGuideStep {
+    /** Step heading */
+    title: React.ReactNode;
+    /** Step body — free-form content */
+    body: React.ReactNode;
+    /** Optional illustration URL rendered below the body */
+    image?: string;
+    /** Alt text for the illustration (i18n) */
+    imageAlt?: string;
+}
+export interface FeatureGuideProps {
+    /** Controlled open state */
+    open: boolean;
+    /** Controlled open state change handler */
+    onOpenChange: (open: boolean) => void;
+    /** Guide title */
+    title: React.ReactNode;
+    /** Optional short description under the title */
+    description?: React.ReactNode;
+    /** Ordered walkthrough steps */
+    steps: FeatureGuideStep[];
+    /** Optional footer slot (e.g. docs link, "Got it" button) */
+    footer?: React.ReactNode;
+    /** Extra classes for the sheet content */
+    className?: string;
+}
+/**
+ * FeatureGuide — right-side sheet walking users through a feature in numbered steps.
+ * Fully controlled: callers own the `open` state and wire their own trigger
+ * (or use the `FeatureGuideTrigger` convenience button).
+ */
+export declare function FeatureGuide({ open, onOpenChange, title, description, steps, footer, className, }: FeatureGuideProps): React.JSX.Element;
+export interface FeatureGuideTriggerProps extends Omit<ButtonProps, 'asChild'> {
+    /** Trigger label content */
+    children?: React.ReactNode;
+}
+/**
+ * FeatureGuideTrigger — convenience ghost button with a BookOpen icon.
+ * Wire `onClick` to open the controlled `FeatureGuide`.
+ */
+export declare const FeatureGuideTrigger: React.ForwardRefExoticComponent<FeatureGuideTriggerProps & React.RefAttributes<HTMLButtonElement>>;

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

@@ -0,0 +1,25 @@
+import { ControllerProps, FieldPath, FieldValues } from 'react-hook-form';
+import * as React from "react";
+import * as LabelPrimitive from "@radix-ui/react-label";
+declare const Form: <TFieldValues extends FieldValues, TContext = any, TTransformedValues = TFieldValues>({ children, watch, getValues, getErrors, getFieldState, setError, clearErrors, setValue, setValues, trigger, formState, resetField, reset, resetDefaultValues, handleSubmit, unregister, control, register, setFocus, subscribe, }: import('react-hook-form').FormProviderProps<TFieldValues, TContext, TTransformedValues>) => React.JSX.Element;
+declare const FormField: <TFieldValues extends FieldValues = FieldValues, TName extends FieldPath<TFieldValues> = FieldPath<TFieldValues>>({ ...props }: ControllerProps<TFieldValues, TName>) => React.JSX.Element;
+declare const useFormField: () => {
+    invalid: boolean;
+    isDirty: boolean;
+    isTouched: boolean;
+    isValidating: boolean;
+    error?: import('react-hook-form').FieldError | undefined;
+    id: string;
+    name: string;
+    formItemId: string;
+    formDescriptionId: string;
+    formMessageId: string;
+};
+declare const FormItem: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLDivElement> & React.RefAttributes<HTMLDivElement>>;
+declare const FormLabel: React.ForwardRefExoticComponent<Omit<LabelPrimitive.LabelProps & React.RefAttributes<HTMLLabelElement>, "ref"> & React.RefAttributes<HTMLLabelElement>>;
+declare const FormControl: React.ForwardRefExoticComponent<Omit<React.HTMLAttributes<HTMLElement> & {
+    children?: React.ReactNode;
+} & React.RefAttributes<HTMLElement>, "ref"> & React.RefAttributes<HTMLElement>>;
+declare const FormDescription: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLParagraphElement> & React.RefAttributes<HTMLParagraphElement>>;
+declare const FormMessage: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLParagraphElement> & React.RefAttributes<HTMLParagraphElement>>;
+export { useFormField, Form, FormItem, FormLabel, FormControl, FormDescription, FormMessage, FormField, };

package/dist/ui/components/ui/help-tip.d.ts

@@ -0,0 +1,29 @@
+import * as React from 'react';
+export interface HelpTipProps {
+    /** Optional bold heading rendered above the content */
+    title?: React.ReactNode;
+    /** Explanation body — can be long-form (rendered in a Popover, not a Tooltip) */
+    content: React.ReactNode;
+    /** External/help-center URL for the "Learn more" row */
+    moreHref?: string;
+    /** Click handler alternative to `moreHref` for the "Learn more" row */
+    onMore?: () => void;
+    /** Label for the "Learn more" row (i18n override) */
+    moreLabel?: string;
+    /** Accessible label for the trigger button (i18n override) */
+    label?: string;
+    /** Popover placement side */
+    side?: 'top' | 'right' | 'bottom' | 'left';
+    /** Popover alignment relative to the trigger */
+    align?: 'start' | 'center' | 'end';
+    /** Extra classes for the trigger button */
+    className?: string;
+    /** Extra classes for the popover content */
+    contentClassName?: string;
+}
+/**
+ * HelpTip — small circled "?" affordance that opens a Popover with contextual help.
+ * Use next to field labels, section titles, and toolbar actions where the
+ * explanation may be longer than a one-line tooltip.
+ */
+export declare function HelpTip({ title, content, moreHref, onMore, moreLabel, label, side, align, className, contentClassName, }: HelpTipProps): React.JSX.Element;

package/dist/ui/components/ui/hint-notice.d.ts

@@ -0,0 +1,22 @@
+import { VariantProps } from 'class-variance-authority';
+import * as React from 'react';
+declare const hintNoticeCardVariants: (props?: ({
+    variant?: "info" | "neutral" | "warning" | null | undefined;
+} & import('class-variance-authority/types').ClassProp) | undefined) => string;
+export type HintNoticeVariant = NonNullable<VariantProps<typeof hintNoticeCardVariants>['variant']>;
+export interface HintNoticeProps extends Omit<React.HTMLAttributes<HTMLDivElement>, 'title'>, VariantProps<typeof hintNoticeCardVariants> {
+    /** Optional heading above the body */
+    title?: React.ReactNode;
+    /** Body content */
+    children: React.ReactNode;
+    /** Extra classes for inner `CardContent` */
+    contentClassName?: string;
+    /** When false, hides the leading icon slot */
+    showIcon?: boolean;
+    /** Custom icon node; defaults to Info (or Warning triangle for `warning` variant) */
+    icon?: React.ReactNode;
+    /** Apply `whitespace-pre-line` to the body wrapper */
+    preserveWhitespace?: boolean;
+}
+export declare const HintNotice: React.ForwardRefExoticComponent<HintNoticeProps & React.RefAttributes<HTMLDivElement>>;
+export {};

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

@@ -0,0 +1,6 @@
+export { ModalContainer, useModal, MODAL_SIZES, type ModalSize } from './modal-container';
+export { BaseModal, FormModal, ConfirmModal, ListModal } from './modal-templates';
+export { AlertDialog, AlertProvider, useAlert, useAlertDialog, type AlertType } from './alert-dialog';
+export * from './dialog';
+export * from './dialog-input';
+export * from './sheet';

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

@@ -0,0 +1,3 @@
+import * as React from "react";
+declare const Input: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.InputHTMLAttributes<HTMLInputElement>, HTMLInputElement>, "ref"> & React.RefAttributes<HTMLInputElement>>;
+export { Input };

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

@@ -0,0 +1,5 @@
+import { VariantProps } from 'class-variance-authority';
+import * as React from "react";
+import * as LabelPrimitive from "@radix-ui/react-label";
+declare const Label: React.ForwardRefExoticComponent<Omit<LabelPrimitive.LabelProps & React.RefAttributes<HTMLLabelElement>, "ref"> & VariantProps<(props?: import('class-variance-authority/types').ClassProp | undefined) => string> & React.RefAttributes<HTMLLabelElement>>;
+export { Label };

package/dist/ui/components/ui/modal-container.d.ts

@@ -0,0 +1,56 @@
+import * as React from "react";
+export declare const MODAL_SIZES: {
+    readonly sm: {
+        readonly width: "480px";
+        readonly maxHeight: "90vh";
+    };
+    readonly md: {
+        readonly width: "640px";
+        readonly maxHeight: "90vh";
+    };
+    readonly lg: {
+        readonly width: "896px";
+        readonly maxHeight: "90vh";
+    };
+    readonly xl: {
+        readonly width: "1000px";
+        readonly maxHeight: "90vh";
+    };
+    readonly wide: {
+        readonly width: "min(1152px, 95vw)";
+        readonly maxHeight: "90vh";
+    };
+    readonly full: {
+        readonly width: "95vw";
+        readonly maxHeight: "95vh";
+    };
+    readonly STANDARD: {
+        readonly width: "896px";
+        readonly maxHeight: "90vh";
+    };
+    readonly LARGE: {
+        readonly width: "min(1152px, 95vw)";
+        readonly maxHeight: "90vh";
+    };
+};
+export type ModalSize = keyof typeof MODAL_SIZES;
+interface ModalContainerProps {
+    size?: ModalSize;
+    isOpen: boolean;
+    onClose: () => void;
+    title?: React.ReactNode;
+    showCloseButton?: boolean;
+    closeOnOverlayClick?: boolean;
+    className?: string;
+    contentClassName?: string;
+    usePortal?: boolean;
+    children: React.ReactNode;
+}
+export declare const ModalContainer: React.FC<ModalContainerProps>;
+export declare const useModal: (initialOpen?: boolean) => {
+    isOpen: boolean;
+    openModal: () => void;
+    closeModal: () => void;
+    toggleModal: () => void;
+};
+export default ModalContainer;

package/dist/ui/components/ui/modal-templates.d.ts

@@ -0,0 +1,46 @@
+import { ModalSize } from './modal-container';
+import * as React from "react";
+interface BaseModalProps {
+    size?: ModalSize;
+    isOpen: boolean;
+    onClose: () => void;
+    title?: React.ReactNode;
+    className?: string;
+    children: React.ReactNode;
+    footer?: React.ReactNode;
+    showCloseButton?: boolean;
+    closeOnOverlayClick?: boolean;
+}
+export declare const BaseModal: React.FC<BaseModalProps>;
+interface FormModalProps extends Omit<BaseModalProps, 'footer'> {
+    onSubmit?: () => void;
+    onCancel?: () => void;
+    submitText?: string;
+    cancelText?: string;
+    submitDisabled?: boolean;
+    submitLoading?: boolean;
+    showFooter?: boolean;
+    customFooter?: React.ReactNode;
+}
+export declare const FormModal: React.FC<FormModalProps>;
+interface ConfirmModalProps {
+    isOpen: boolean;
+    onClose: () => void;
+    onConfirm: () => void;
+    title?: React.ReactNode;
+    message: string;
+    confirmText?: string;
+    cancelText?: string;
+    danger?: boolean;
+    loading?: boolean;
+}
+export declare const ConfirmModal: React.FC<ConfirmModalProps>;
+interface ListModalProps extends BaseModalProps {
+    searchable?: boolean;
+    searchPlaceholder?: string;
+    onSearch?: (term: string) => void;
+    emptyMessage?: string;
+    loading?: boolean;
+}
+export declare const ListModal: React.FC<ListModalProps>;
+export {};

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

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

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

@@ -0,0 +1,28 @@
+import { ButtonProps } from './button';
+import * as React from "react";
+declare const Pagination: {
+    ({ className, ...props }: React.ComponentProps<"nav">): React.JSX.Element;
+    displayName: string;
+};
+declare const PaginationContent: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLUListElement>, HTMLUListElement>, "ref"> & React.RefAttributes<HTMLUListElement>>;
+declare const PaginationItem: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.LiHTMLAttributes<HTMLLIElement>, HTMLLIElement>, "ref"> & React.RefAttributes<HTMLLIElement>>;
+type PaginationLinkProps = {
+    isActive?: boolean;
+} & Pick<ButtonProps, "size"> & React.ComponentProps<"a">;
+declare const PaginationLink: {
+    ({ className, isActive, size, ...props }: PaginationLinkProps): React.JSX.Element;
+    displayName: string;
+};
+declare const PaginationPrevious: {
+    ({ className, ...props }: React.ComponentProps<typeof PaginationLink>): React.JSX.Element;
+    displayName: string;
+};
+declare const PaginationNext: {
+    ({ className, ...props }: React.ComponentProps<typeof PaginationLink>): React.JSX.Element;
+    displayName: string;
+};
+declare const PaginationEllipsis: {
+    ({ className, ...props }: React.ComponentProps<"span">): React.JSX.Element;
+    displayName: string;
+};
+export { Pagination, PaginationContent, PaginationLink, PaginationItem, PaginationPrevious, PaginationNext, PaginationEllipsis, };

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

@@ -0,0 +1,7 @@
+import * as React from "react";
+import * as PopoverPrimitive from "@radix-ui/react-popover";
+declare const Popover: React.FC<PopoverPrimitive.PopoverProps>;
+declare const PopoverTrigger: React.ForwardRefExoticComponent<PopoverPrimitive.PopoverTriggerProps & React.RefAttributes<HTMLButtonElement>>;
+declare const PopoverAnchor: React.ForwardRefExoticComponent<PopoverPrimitive.PopoverAnchorProps & React.RefAttributes<HTMLDivElement>>;
+declare const PopoverContent: React.ForwardRefExoticComponent<Omit<PopoverPrimitive.PopoverContentProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+export { Popover, PopoverTrigger, PopoverContent, PopoverAnchor };

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

@@ -0,0 +1,7 @@
+import * as React from "react";
+interface ProgressProps extends React.HTMLAttributes<HTMLDivElement> {
+    value?: number;
+    max?: number;
+}
+declare const Progress: React.ForwardRefExoticComponent<ProgressProps & React.RefAttributes<HTMLDivElement>>;
+export { Progress };

package/dist/ui/components/ui/radio-button-group.d.ts

@@ -0,0 +1,18 @@
+import { default as React } from 'react';
+
+export interface RadioButtonOption {
+    label: string;
+    value: string;
+}
+export interface RadioButtonGroupProps {
+    options: RadioButtonOption[];
+    value?: string | string[];
+    onChange?: (value: string | string[]) => void;
+    label?: string;
+    multiple?: boolean;
+    defaultValue?: string | string[];
+    className?: string;
+    optionsClassName?: string;
+    getOptionClassName?: (option: RadioButtonOption, isSelected: boolean) => string;
+}
+export declare const RadioButtonGroup: React.FC<RadioButtonGroupProps>;

package/dist/ui/components/ui/radio-group.d.ts

@@ -0,0 +1,5 @@
+import * as React from "react";
+import * as RadioGroupPrimitive from "@radix-ui/react-radio-group";
+declare const RadioGroup: React.ForwardRefExoticComponent<Omit<RadioGroupPrimitive.RadioGroupProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const RadioGroupItem: React.ForwardRefExoticComponent<Omit<RadioGroupPrimitive.RadioGroupItemProps & React.RefAttributes<HTMLButtonElement>, "ref"> & React.RefAttributes<HTMLButtonElement>>;
+export { RadioGroup, RadioGroupItem };

package/dist/ui/components/ui/scroll-area.d.ts

@@ -0,0 +1,5 @@
+import * as React from "react";
+import * as ScrollAreaPrimitive from "@radix-ui/react-scroll-area";
+declare const ScrollArea: React.ForwardRefExoticComponent<Omit<ScrollAreaPrimitive.ScrollAreaProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const ScrollBar: React.ForwardRefExoticComponent<Omit<ScrollAreaPrimitive.ScrollAreaScrollbarProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+export { ScrollArea, ScrollBar };

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

@@ -0,0 +1,16 @@
+import * as React from "react";
+import * as SelectPrimitive from "@radix-ui/react-select";
+declare function Select({ onValueChange, ...props }: React.ComponentPropsWithoutRef<typeof SelectPrimitive.Root>): React.JSX.Element;
+declare namespace Select {
+    var displayName: string | undefined;
+}
+declare const SelectGroup: React.ForwardRefExoticComponent<SelectPrimitive.SelectGroupProps & React.RefAttributes<HTMLDivElement>>;
+declare const SelectValue: React.ForwardRefExoticComponent<SelectPrimitive.SelectValueProps & React.RefAttributes<HTMLSpanElement>>;
+declare const SelectTrigger: React.ForwardRefExoticComponent<Omit<SelectPrimitive.SelectTriggerProps & React.RefAttributes<HTMLButtonElement>, "ref"> & React.RefAttributes<HTMLButtonElement>>;
+declare const SelectScrollUpButton: React.ForwardRefExoticComponent<Omit<SelectPrimitive.SelectScrollUpButtonProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const SelectScrollDownButton: React.ForwardRefExoticComponent<Omit<SelectPrimitive.SelectScrollDownButtonProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const SelectContent: React.ForwardRefExoticComponent<Omit<SelectPrimitive.SelectContentProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const SelectLabel: React.ForwardRefExoticComponent<Omit<SelectPrimitive.SelectLabelProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const SelectItem: React.ForwardRefExoticComponent<Omit<SelectPrimitive.SelectItemProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const SelectSeparator: React.ForwardRefExoticComponent<Omit<SelectPrimitive.SelectSeparatorProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+export { Select, SelectGroup, SelectValue, SelectTrigger, SelectContent, SelectLabel, SelectItem, SelectSeparator, SelectScrollUpButton, SelectScrollDownButton, };

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

@@ -0,0 +1,7 @@
+import { default as React } from 'react';
+
+export interface SeparatorProps extends React.HTMLAttributes<HTMLDivElement> {
+    orientation?: 'horizontal' | 'vertical';
+}
+declare const Separator: React.ForwardRefExoticComponent<SeparatorProps & React.RefAttributes<HTMLDivElement>>;
+export { Separator };

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

@@ -0,0 +1,25 @@
+import { VariantProps } from 'class-variance-authority';
+import * as React from "react";
+import * as SheetPrimitive from "@radix-ui/react-dialog";
+declare const Sheet: React.FC<SheetPrimitive.DialogProps>;
+declare const SheetTrigger: React.ForwardRefExoticComponent<SheetPrimitive.DialogTriggerProps & React.RefAttributes<HTMLButtonElement>>;
+declare const SheetClose: React.ForwardRefExoticComponent<SheetPrimitive.DialogCloseProps & React.RefAttributes<HTMLButtonElement>>;
+declare const SheetPortal: React.FC<SheetPrimitive.DialogPortalProps>;
+declare const SheetOverlay: React.ForwardRefExoticComponent<Omit<SheetPrimitive.DialogOverlayProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const sheetVariants: (props?: ({
+    side?: "left" | "top" | "right" | "bottom" | null | undefined;
+} & import('class-variance-authority/types').ClassProp) | undefined) => string;
+interface SheetContentProps extends React.ComponentPropsWithoutRef<typeof SheetPrimitive.Content>, VariantProps<typeof sheetVariants> {
+}
+declare const SheetContent: React.ForwardRefExoticComponent<SheetContentProps & React.RefAttributes<HTMLDivElement>>;
+declare const SheetHeader: {
+    ({ className, ...props }: React.HTMLAttributes<HTMLDivElement>): React.JSX.Element;
+    displayName: string;
+};
+declare const SheetFooter: {
+    ({ className, ...props }: React.HTMLAttributes<HTMLDivElement>): React.JSX.Element;
+    displayName: string;
+};
+declare const SheetTitle: React.ForwardRefExoticComponent<Omit<SheetPrimitive.DialogTitleProps & React.RefAttributes<HTMLHeadingElement>, "ref"> & React.RefAttributes<HTMLHeadingElement>>;
+declare const SheetDescription: React.ForwardRefExoticComponent<Omit<SheetPrimitive.DialogDescriptionProps & React.RefAttributes<HTMLParagraphElement>, "ref"> & React.RefAttributes<HTMLParagraphElement>>;
+export { Sheet, SheetPortal, SheetOverlay, SheetTrigger, SheetClose, SheetContent, SheetHeader, SheetFooter, SheetTitle, SheetDescription, };

package/dist/ui/components/ui/sidebar-rail.d.ts

@@ -0,0 +1,9 @@
+import { default as React } from 'react';
+
+interface SidebarRailProps {
+    collapsed: boolean;
+    onToggle: () => void;
+    show?: boolean;
+}
+export declare const SidebarRail: React.FC<SidebarRailProps>;
+export {};

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

@@ -0,0 +1,2 @@
+declare function Skeleton({ className, ...props }: React.HTMLAttributes<HTMLDivElement>): import("react").JSX.Element;
+export { Skeleton };

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

@@ -0,0 +1,13 @@
+import * as React from "react";
+interface SliderProps {
+    value?: number[];
+    defaultValue?: number[];
+    onValueChange?: (value: number[]) => void;
+    min?: number;
+    max?: number;
+    step?: number;
+    className?: string;
+    disabled?: boolean;
+}
+declare const Slider: React.ForwardRefExoticComponent<SliderProps & React.RefAttributes<HTMLDivElement>>;
+export { Slider };

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

@@ -0,0 +1,4 @@
+import * as React from "react";
+import * as SwitchPrimitives from "@radix-ui/react-switch";
+declare const Switch: React.ForwardRefExoticComponent<Omit<SwitchPrimitives.SwitchProps & React.RefAttributes<HTMLButtonElement>, "ref"> & React.RefAttributes<HTMLButtonElement>>;
+export { Switch };

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

@@ -0,0 +1,10 @@
+import * as React from "react";
+declare const Table: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLTableElement> & React.RefAttributes<HTMLTableElement>>;
+declare const TableHeader: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLTableSectionElement> & React.RefAttributes<HTMLTableSectionElement>>;
+declare const TableBody: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLTableSectionElement> & React.RefAttributes<HTMLTableSectionElement>>;
+declare const TableFooter: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLTableSectionElement> & React.RefAttributes<HTMLTableSectionElement>>;
+declare const TableRow: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLTableRowElement> & React.RefAttributes<HTMLTableRowElement>>;
+declare const TableHead: React.ForwardRefExoticComponent<React.ThHTMLAttributes<HTMLTableCellElement> & React.RefAttributes<HTMLTableCellElement>>;
+declare const TableCell: React.ForwardRefExoticComponent<React.TdHTMLAttributes<HTMLTableCellElement> & React.RefAttributes<HTMLTableCellElement>>;
+declare const TableCaption: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLTableCaptionElement> & React.RefAttributes<HTMLTableCaptionElement>>;
+export { Table, TableHeader, TableBody, TableFooter, TableHead, TableRow, TableCell, TableCaption, };

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

@@ -0,0 +1,10 @@
+import * as React from "react";
+import * as TabsPrimitive from "@radix-ui/react-tabs";
+declare function Tabs({ onValueChange, ...props }: React.ComponentPropsWithoutRef<typeof TabsPrimitive.Root>): React.JSX.Element;
+declare namespace Tabs {
+    var displayName: string | undefined;
+}
+declare const TabsList: React.ForwardRefExoticComponent<Omit<TabsPrimitive.TabsListProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const TabsTrigger: React.ForwardRefExoticComponent<Omit<TabsPrimitive.TabsTriggerProps & React.RefAttributes<HTMLButtonElement>, "ref"> & React.RefAttributes<HTMLButtonElement>>;
+declare const TabsContent: React.ForwardRefExoticComponent<Omit<TabsPrimitive.TabsContentProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+export { Tabs, TabsList, TabsTrigger, TabsContent };

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

@@ -0,0 +1,3 @@
+import * as React from "react";
+declare const Textarea: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.TextareaHTMLAttributes<HTMLTextAreaElement>, HTMLTextAreaElement>, "ref"> & React.RefAttributes<HTMLTextAreaElement>>;
+export { Textarea };

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

@@ -0,0 +1,21 @@
+import { VariantProps } from 'class-variance-authority';
+import * as React from "react";
+import * as ToastPrimitives from "@radix-ui/react-toast";
+declare const ToastProvider: React.FC<ToastPrimitives.ToastProviderProps>;
+declare const ToastViewport: React.ForwardRefExoticComponent<Omit<ToastPrimitives.ToastViewportProps & React.RefAttributes<HTMLOListElement>, "ref"> & React.RefAttributes<HTMLOListElement>>;
+declare const Toast: React.ForwardRefExoticComponent<Omit<ToastPrimitives.ToastProps & React.RefAttributes<HTMLLIElement>, "ref"> & VariantProps<(props?: ({
+    variant?: "default" | "destructive" | "success" | null | undefined;
+} & import('class-variance-authority/types').ClassProp) | undefined) => string> & React.RefAttributes<HTMLLIElement>>;
+declare const ToastAction: React.ForwardRefExoticComponent<Omit<ToastPrimitives.ToastActionProps & React.RefAttributes<HTMLButtonElement>, "ref"> & React.RefAttributes<HTMLButtonElement>>;
+declare const ToastClose: React.ForwardRefExoticComponent<Omit<ToastPrimitives.ToastCloseProps & React.RefAttributes<HTMLButtonElement>, "ref"> & React.RefAttributes<HTMLButtonElement>>;
+declare const ToastTitle: React.ForwardRefExoticComponent<Omit<ToastPrimitives.ToastTitleProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const ToastDescription: React.ForwardRefExoticComponent<Omit<ToastPrimitives.ToastDescriptionProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+interface ToastProgressBarProps {
+    duration: number;
+    variant?: "default" | "destructive" | "success";
+    onComplete?: () => void;
+}
+declare const ToastProgressBar: React.ForwardRefExoticComponent<ToastProgressBarProps & React.RefAttributes<HTMLDivElement>>;
+type ToastProps = React.ComponentPropsWithoutRef<typeof Toast>;
+type ToastActionElement = React.ReactElement<typeof ToastAction>;
+export { type ToastProps, type ToastActionElement, ToastProvider, ToastViewport, Toast, ToastTitle, ToastDescription, ToastClose, ToastAction, ToastProgressBar, };

package/dist/ui/components/ui/toggle-group.d.ts

@@ -0,0 +1,12 @@
+import { VariantProps } from 'class-variance-authority';
+import * as React from "react";
+import * as ToggleGroupPrimitive from "@radix-ui/react-toggle-group";
+declare const ToggleGroup: React.ForwardRefExoticComponent<((Omit<ToggleGroupPrimitive.ToggleGroupSingleProps & React.RefAttributes<HTMLDivElement>, "ref"> | Omit<ToggleGroupPrimitive.ToggleGroupMultipleProps & React.RefAttributes<HTMLDivElement>, "ref">) & VariantProps<(props?: ({
+    variant?: "default" | "outline" | null | undefined;
+    size?: "default" | "sm" | "lg" | null | undefined;
+} & import('class-variance-authority/types').ClassProp) | undefined) => string>) & React.RefAttributes<HTMLDivElement>>;
+declare const ToggleGroupItem: React.ForwardRefExoticComponent<Omit<ToggleGroupPrimitive.ToggleGroupItemProps & React.RefAttributes<HTMLButtonElement>, "ref"> & VariantProps<(props?: ({
+    variant?: "default" | "outline" | null | undefined;
+    size?: "default" | "sm" | "lg" | null | undefined;
+} & import('class-variance-authority/types').ClassProp) | undefined) => string> & React.RefAttributes<HTMLButtonElement>>;
+export { ToggleGroup, ToggleGroupItem };

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

@@ -0,0 +1,12 @@
+import { VariantProps } from 'class-variance-authority';
+import * as React from "react";
+import * as TogglePrimitive from "@radix-ui/react-toggle";
+declare const toggleVariants: (props?: ({
+    variant?: "default" | "outline" | null | undefined;
+    size?: "default" | "sm" | "lg" | null | undefined;
+} & import('class-variance-authority/types').ClassProp) | undefined) => string;
+declare const Toggle: React.ForwardRefExoticComponent<Omit<TogglePrimitive.ToggleProps & React.RefAttributes<HTMLButtonElement>, "ref"> & VariantProps<(props?: ({
+    variant?: "default" | "outline" | null | undefined;
+    size?: "default" | "sm" | "lg" | null | undefined;
+} & import('class-variance-authority/types').ClassProp) | undefined) => string> & React.RefAttributes<HTMLButtonElement>>;
+export { Toggle, toggleVariants };

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

@@ -0,0 +1,7 @@
+import * as React from "react";
+import * as TooltipPrimitive from "@radix-ui/react-tooltip";
+declare const TooltipProvider: React.FC<TooltipPrimitive.TooltipProviderProps>;
+declare const Tooltip: React.FC<TooltipPrimitive.TooltipProps>;
+declare const TooltipTrigger: React.ForwardRefExoticComponent<TooltipPrimitive.TooltipTriggerProps & React.RefAttributes<HTMLButtonElement>>;
+declare const TooltipContent: React.ForwardRefExoticComponent<Omit<TooltipPrimitive.TooltipContentProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+export { Tooltip, TooltipTrigger, TooltipContent, TooltipProvider };