@aivex/ui 0.1.0

package/dist/components/Modal/Modal.d.ts

@@ -0,0 +1,26 @@
+import { type VariantProps } from "class-variance-authority";
+import { type HTMLAttributes, type Ref } from "react";
+declare const modalHeaderVariants: (props?: ({
+    type?: "basic" | "alert-center" | "alert-left" | null | undefined;
+} & import("class-variance-authority/types").ClassProp) | undefined) => string;
+export interface ModalHeaderProps extends HTMLAttributes<HTMLDivElement>, VariantProps<typeof modalHeaderVariants> {
+    title: string;
+    description?: string;
+    onClose?: () => void;
+    ref?: Ref<HTMLDivElement>;
+}
+declare function ModalHeader({ className, type, title, description, onClose, ref, ...props }: ModalHeaderProps): import("react/jsx-runtime").JSX.Element;
+declare const modalFooterVariants: (props?: ({
+    type?: "flex" | "fixed" | null | undefined;
+} & import("class-variance-authority/types").ClassProp) | undefined) => string;
+export interface ModalFooterProps extends HTMLAttributes<HTMLDivElement>, VariantProps<typeof modalFooterVariants> {
+    ref?: Ref<HTMLDivElement>;
+}
+declare function ModalFooter({ className, type, children, ref, ...props }: ModalFooterProps): import("react/jsx-runtime").JSX.Element;
+export interface ModalRootProps extends HTMLAttributes<HTMLDivElement> {
+    open: boolean;
+    onClose: () => void;
+    ref?: Ref<HTMLDivElement>;
+}
+declare function ModalRoot({ className, open, onClose, children, ref, ...props }: ModalRootProps): import("react/jsx-runtime").JSX.Element | null;
+export { ModalFooter, ModalHeader, ModalRoot };

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

@@ -0,0 +1,2 @@
+export type { ModalFooterProps, ModalHeaderProps, ModalRootProps } from "./Modal";
+export { ModalFooter, ModalHeader, ModalRoot } from "./Modal";

package/dist/components/Nav/Nav.d.ts

@@ -0,0 +1,25 @@
+import { type VariantProps } from "class-variance-authority";
+import type { ButtonHTMLAttributes, HTMLAttributes, ReactNode, Ref } from "react";
+declare const navTileVariants: (props?: ({
+    active?: boolean | null | undefined;
+} & import("class-variance-authority/types").ClassProp) | undefined) => string;
+export interface NavTileProps extends ButtonHTMLAttributes<HTMLButtonElement>, VariantProps<typeof navTileVariants> {
+    icon?: ReactNode;
+    label?: string;
+    ref?: Ref<HTMLButtonElement>;
+}
+declare function NavTile({ className, active, icon, label, children, ref, ...props }: NavTileProps): import("react/jsx-runtime").JSX.Element;
+declare const navItemVariants: (props?: ({
+    selected?: boolean | null | undefined;
+} & import("class-variance-authority/types").ClassProp) | undefined) => string;
+export interface NavItemProps extends ButtonHTMLAttributes<HTMLButtonElement>, VariantProps<typeof navItemVariants> {
+    icon?: ReactNode;
+    label?: string;
+    ref?: Ref<HTMLButtonElement>;
+}
+declare function NavItem({ className, selected, icon, label, children, ref, ...props }: NavItemProps): import("react/jsx-runtime").JSX.Element;
+export interface NavProps extends HTMLAttributes<HTMLElement> {
+    ref?: Ref<HTMLElement>;
+}
+declare function Nav({ className, children, ref, ...props }: NavProps): import("react/jsx-runtime").JSX.Element;
+export { Nav, NavItem, NavTile, navItemVariants, navTileVariants };

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

@@ -0,0 +1,2 @@
+export type { NavItemProps, NavProps, NavTileProps } from "./Nav";
+export { Nav, NavItem, NavTile, navItemVariants, navTileVariants } from "./Nav";

package/dist/components/Overlay/Overlay.d.ts

@@ -0,0 +1,10 @@
+import { type VariantProps } from "class-variance-authority";
+import type { HTMLAttributes, Ref } from "react";
+declare const overlayVariants: (props?: ({
+    type?: "dim" | "frost" | null | undefined;
+} & import("class-variance-authority/types").ClassProp) | undefined) => string;
+export interface OverlayProps extends HTMLAttributes<HTMLDivElement>, VariantProps<typeof overlayVariants> {
+    ref?: Ref<HTMLDivElement>;
+}
+declare function Overlay({ className, type, ref, ...props }: OverlayProps): import("react/jsx-runtime").JSX.Element;
+export { Overlay, overlayVariants };

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

@@ -0,0 +1,2 @@
+export type { OverlayProps } from "./Overlay";
+export { Overlay, overlayVariants } from "./Overlay";

package/dist/components/Pagination/Pagination.d.ts

@@ -0,0 +1,11 @@
+import { type HTMLAttributes, type Ref } from "react";
+export interface PaginationProps extends Omit<HTMLAttributes<HTMLElement>, "onChange"> {
+    total: number;
+    page?: number;
+    defaultPage?: number;
+    pageSize?: number;
+    onChange?: (page: number) => void;
+    ref?: Ref<HTMLElement>;
+}
+declare function Pagination({ className, total, page, defaultPage, pageSize, onChange, ref, ...props }: PaginationProps): import("react/jsx-runtime").JSX.Element;
+export { Pagination };

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

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

package/dist/components/Radio/Radio.d.ts

@@ -0,0 +1,11 @@
+import { type VariantProps } from "class-variance-authority";
+import type { InputHTMLAttributes, Ref } from "react";
+declare const radioVariants: (props?: ({
+    size?: "sm" | "md" | "lg" | null | undefined;
+} & import("class-variance-authority/types").ClassProp) | undefined) => string;
+export interface RadioProps extends Omit<InputHTMLAttributes<HTMLInputElement>, "size" | "type">, VariantProps<typeof radioVariants> {
+    label?: string;
+    ref?: Ref<HTMLInputElement>;
+}
+declare function Radio({ className, label, size, disabled, checked, id, ref, ...props }: RadioProps): import("react/jsx-runtime").JSX.Element;
+export { Radio, radioVariants };

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

@@ -0,0 +1,2 @@
+export type { RadioProps } from "./Radio";
+export { Radio, radioVariants } from "./Radio";

package/dist/components/Segmented/Segmented.d.ts

@@ -0,0 +1,21 @@
+import { type VariantProps } from "class-variance-authority";
+import { type ButtonHTMLAttributes, type HTMLAttributes, type ReactNode, type Ref } from "react";
+declare const segmentedRootVariants: (props?: ({
+    size?: "sm" | "md" | "lg" | null | undefined;
+} & import("class-variance-authority/types").ClassProp) | undefined) => string;
+export interface SegmentedRootProps extends Omit<HTMLAttributes<HTMLDivElement>, "onChange">, VariantProps<typeof segmentedRootVariants> {
+    value?: string;
+    defaultValue?: string;
+    onChange?: (value: string) => void;
+    iconOnly?: boolean;
+    children?: ReactNode;
+    ref?: Ref<HTMLDivElement>;
+}
+declare function SegmentedRoot({ className, size, value, defaultValue, onChange, iconOnly, children, ref, ...props }: SegmentedRootProps): import("react/jsx-runtime").JSX.Element;
+export interface SegmentedItemProps extends ButtonHTMLAttributes<HTMLButtonElement> {
+    value: string;
+    children?: ReactNode;
+    ref?: Ref<HTMLButtonElement>;
+}
+declare function SegmentedItem({ className, value, children, onClick, ref, ...props }: SegmentedItemProps): import("react/jsx-runtime").JSX.Element;
+export { SegmentedItem, SegmentedRoot };

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

@@ -0,0 +1,2 @@
+export type { SegmentedItemProps, SegmentedRootProps } from "./Segmented";
+export { SegmentedItem, SegmentedRoot } from "./Segmented";

package/dist/components/Select/Select.d.ts

@@ -0,0 +1,13 @@
+import { type VariantProps } from "class-variance-authority";
+import type { Ref, SelectHTMLAttributes } from "react";
+declare const selectWrapperVariants: (props?: ({
+    state?: "default" | "disabled" | "focused" | "error" | null | undefined;
+    size?: "sm" | "md" | null | undefined;
+} & import("class-variance-authority/types").ClassProp) | undefined) => string;
+export interface SelectProps extends Omit<SelectHTMLAttributes<HTMLSelectElement>, "size">, Pick<VariantProps<typeof selectWrapperVariants>, "size"> {
+    label?: string;
+    error?: boolean;
+    ref?: Ref<HTMLSelectElement>;
+}
+declare function Select({ className, label, error, disabled, size, id, children, ref, onFocus, onBlur, ...props }: SelectProps): import("react/jsx-runtime").JSX.Element;
+export { Select, selectWrapperVariants };

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

@@ -0,0 +1,2 @@
+export type { SelectProps } from "./Select";
+export { Select, selectWrapperVariants } from "./Select";

package/dist/components/Shortcut/Shortcut.d.ts

@@ -0,0 +1,7 @@
+import { type HTMLAttributes, type Ref } from "react";
+export interface ShortcutProps extends HTMLAttributes<HTMLSpanElement> {
+    keys: string[];
+    ref?: Ref<HTMLSpanElement>;
+}
+declare function Shortcut({ className, keys, ref, ...props }: ShortcutProps): import("react/jsx-runtime").JSX.Element;
+export { Shortcut };

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

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

package/dist/components/Switch/Switch.d.ts

@@ -0,0 +1,11 @@
+import { type VariantProps } from "class-variance-authority";
+import { type InputHTMLAttributes, type Ref } from "react";
+declare const switchTrackVariants: (props?: ({
+    size?: "sm" | "md" | "lg" | null | undefined;
+} & import("class-variance-authority/types").ClassProp) | undefined) => string;
+export interface SwitchProps extends Omit<InputHTMLAttributes<HTMLInputElement>, "size" | "type">, VariantProps<typeof switchTrackVariants> {
+    label?: string;
+    ref?: Ref<HTMLInputElement>;
+}
+declare function Switch({ className, label, size, checked, defaultChecked, disabled, id, onChange, ref, ...props }: SwitchProps): import("react/jsx-runtime").JSX.Element;
+export { Switch };

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

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

package/dist/components/Tab/Tab.d.ts

@@ -0,0 +1,18 @@
+import { type VariantProps } from "class-variance-authority";
+import { type ButtonHTMLAttributes, type HTMLAttributes, type Ref } from "react";
+export interface TabRootProps extends Omit<HTMLAttributes<HTMLDivElement>, "onChange"> {
+    value?: string;
+    defaultValue?: string;
+    onChange?: (value: string) => void;
+    ref?: Ref<HTMLDivElement>;
+}
+declare function TabRoot({ className, value, defaultValue, onChange, children, ref, ...props }: TabRootProps): import("react/jsx-runtime").JSX.Element;
+declare const tabItemVariants: (props?: ({
+    active?: boolean | null | undefined;
+} & import("class-variance-authority/types").ClassProp) | undefined) => string;
+export interface TabItemProps extends ButtonHTMLAttributes<HTMLButtonElement>, VariantProps<typeof tabItemVariants> {
+    value: string;
+    ref?: Ref<HTMLButtonElement>;
+}
+declare function TabItem({ className, value, children, active: activeProp, ref, ...props }: TabItemProps): import("react/jsx-runtime").JSX.Element;
+export { TabItem, TabRoot, tabItemVariants };

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

@@ -0,0 +1,2 @@
+export type { TabItemProps, TabRootProps } from "./Tab";
+export { TabItem, TabRoot, tabItemVariants } from "./Tab";

package/dist/components/Table/Table.d.ts

@@ -0,0 +1,29 @@
+import type { HTMLAttributes, Ref, TdHTMLAttributes, ThHTMLAttributes } from "react";
+export interface TableProps extends HTMLAttributes<HTMLDivElement> {
+    ref?: Ref<HTMLDivElement>;
+}
+declare function Table({ className, children, ref, ...props }: TableProps): import("react/jsx-runtime").JSX.Element;
+export interface TableHeaderProps extends HTMLAttributes<HTMLTableSectionElement> {
+    ref?: Ref<HTMLTableSectionElement>;
+}
+declare function TableHeader({ className, children, ref, ...props }: TableHeaderProps): import("react/jsx-runtime").JSX.Element;
+export interface TableBodyProps extends HTMLAttributes<HTMLTableSectionElement> {
+    ref?: Ref<HTMLTableSectionElement>;
+}
+declare function TableBody({ className, children, ref, ...props }: TableBodyProps): import("react/jsx-runtime").JSX.Element;
+export interface TableRowProps extends HTMLAttributes<HTMLTableRowElement> {
+    ref?: Ref<HTMLTableRowElement>;
+}
+declare function TableRow({ className, children, ref, ...props }: TableRowProps): import("react/jsx-runtime").JSX.Element;
+export interface TableHeadProps extends ThHTMLAttributes<HTMLTableCellElement> {
+    sortable?: boolean;
+    sortDirection?: "asc" | "desc" | null;
+    onSort?: () => void;
+    ref?: Ref<HTMLTableCellElement>;
+}
+declare function TableHead({ className, children, sortable, sortDirection, onSort, ref, ...props }: TableHeadProps): import("react/jsx-runtime").JSX.Element;
+export interface TableCellProps extends TdHTMLAttributes<HTMLTableCellElement> {
+    ref?: Ref<HTMLTableCellElement>;
+}
+declare function TableCell({ className, children, ref, ...props }: TableCellProps): import("react/jsx-runtime").JSX.Element;
+export { Table, TableBody, TableCell, TableHead, TableHeader, TableRow };

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

@@ -0,0 +1,2 @@
+export type { TableBodyProps, TableCellProps, TableHeaderProps, TableHeadProps, TableProps, TableRowProps, } from "./Table";
+export { Table, TableBody, TableCell, TableHead, TableHeader, TableRow } from "./Table";

package/dist/components/Tag/Tag.d.ts

@@ -0,0 +1,15 @@
+import { type VariantProps } from "class-variance-authority";
+import type { HTMLAttributes, ReactNode, Ref } from "react";
+declare const tagVariants: (props?: ({
+    size?: "sm" | "md" | null | undefined;
+    type?: "default" | "error" | null | undefined;
+} & import("class-variance-authority/types").ClassProp) | undefined) => string;
+export interface TagProps extends Omit<HTMLAttributes<HTMLDivElement>, "type">, VariantProps<typeof tagVariants> {
+    showIcon?: boolean;
+    disabled?: boolean;
+    onRemove?: () => void;
+    children?: ReactNode;
+    ref?: Ref<HTMLDivElement>;
+}
+declare function Tag({ className, size, type, showIcon, disabled, onRemove, children, ref, ...props }: TagProps): import("react/jsx-runtime").JSX.Element;
+export { Tag, tagVariants };

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

@@ -0,0 +1,2 @@
+export type { TagProps } from "./Tag";
+export { Tag, tagVariants } from "./Tag";

package/dist/components/Tagbox/Tagbox.d.ts

@@ -0,0 +1,12 @@
+import { type InputHTMLAttributes, type Ref } from "react";
+export interface TagboxProps extends Omit<InputHTMLAttributes<HTMLInputElement>, "size" | "value" | "onChange"> {
+    size?: "sm" | "md";
+    label?: string;
+    error?: boolean;
+    value?: string[];
+    defaultValue?: string[];
+    onChange?: (tags: string[]) => void;
+    ref?: Ref<HTMLInputElement>;
+}
+declare function Tagbox({ className, size, label, error, disabled, value, defaultValue, onChange, placeholder, id, ref, onBlur, onCompositionEnd, onCompositionStart, onFocus, onKeyDown, ...props }: TagboxProps): import("react/jsx-runtime").JSX.Element;
+export { Tagbox };

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

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

package/dist/components/Textarea/Textarea.d.ts

@@ -0,0 +1,13 @@
+import { type VariantProps } from "class-variance-authority";
+import type { Ref, TextareaHTMLAttributes } from "react";
+declare const textareaWrapperVariants: (props?: ({
+    state?: "default" | "disabled" | "focused" | "error" | null | undefined;
+    size?: "sm" | "md" | null | undefined;
+} & import("class-variance-authority/types").ClassProp) | undefined) => string;
+export interface TextareaProps extends Omit<TextareaHTMLAttributes<HTMLTextAreaElement>, "size">, Pick<VariantProps<typeof textareaWrapperVariants>, "size"> {
+    label?: string;
+    error?: boolean;
+    ref?: Ref<HTMLTextAreaElement>;
+}
+declare function Textarea({ className, label, error, disabled, size, id, ref, onFocus, onBlur, ...props }: TextareaProps): import("react/jsx-runtime").JSX.Element;
+export { Textarea, textareaWrapperVariants };

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

@@ -0,0 +1,2 @@
+export type { TextareaProps } from "./Textarea";
+export { Textarea, textareaWrapperVariants } from "./Textarea";

package/dist/components/Toast/Toast.d.ts

@@ -0,0 +1,17 @@
+import { type VariantProps } from "class-variance-authority";
+import type { HTMLAttributes, Ref } from "react";
+import { type ExternalToast, type ToasterProps, toast } from "sonner";
+declare const toastVariants: (props?: ({
+    type?: "default" | "danger" | "success" | null | undefined;
+} & import("class-variance-authority/types").ClassProp) | undefined) => string;
+export interface ToastProps extends HTMLAttributes<HTMLDivElement>, VariantProps<typeof toastVariants> {
+    open?: boolean;
+    message: string;
+    onClose?: () => void;
+    ref?: Ref<HTMLDivElement>;
+}
+export type ToastToasterProps = ToasterProps;
+export type ToastOptions = ExternalToast;
+declare function Toast({ className, type, open, message, onClose, ref, ...props }: ToastProps): import("react/jsx-runtime").JSX.Element | null;
+declare function ToastToaster({ position, duration, visibleToasts, gap, toastOptions, ...props }: ToastToasterProps): import("react/jsx-runtime").JSX.Element;
+export { Toast, ToastToaster, toast, toastVariants };

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

@@ -0,0 +1,2 @@
+export type { ToastOptions, ToastProps, ToastToasterProps } from "./Toast";
+export { Toast, ToastToaster, toast, toastVariants } from "./Toast";

package/dist/components/Tooltip/Tooltip.d.ts

@@ -0,0 +1,13 @@
+import { type VariantProps } from "class-variance-authority";
+import { type HTMLAttributes, type ReactNode, type Ref } from "react";
+declare const tooltipContentVariants: (props?: ({
+    placement?: "bottom" | "left" | "right" | "top" | null | undefined;
+} & import("class-variance-authority/types").ClassProp) | undefined) => string;
+export interface TooltipProps extends Omit<HTMLAttributes<HTMLDivElement>, "content">, VariantProps<typeof tooltipContentVariants> {
+    content: ReactNode;
+    children: ReactNode;
+    showArrow?: boolean;
+    ref?: Ref<HTMLDivElement>;
+}
+declare function Tooltip({ className, content, children, placement, showArrow, ref, ...props }: TooltipProps): import("react/jsx-runtime").JSX.Element;
+export { Tooltip, tooltipContentVariants };

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

@@ -0,0 +1,2 @@
+export type { TooltipProps } from "./Tooltip";
+export { Tooltip, tooltipContentVariants } from "./Tooltip";

package/dist/components/Typography/Typography.d.ts

@@ -0,0 +1,12 @@
+import { type VariantProps } from "class-variance-authority";
+import type { ElementType, HTMLAttributes, ReactNode, Ref } from "react";
+declare const typographyVariants: (props?: ({
+    variant?: "display-lg" | "display-md" | "heading-xl" | "heading-lg" | "heading-md" | "heading-sm" | "heading-xs" | "body-lg-regular" | "body-lg-medium" | "body-md-regular" | "body-md-medium" | "body-sm-regular" | "body-sm-medium" | "label-xl" | "label-lg" | "label-md" | "label-sm" | "caption-md" | null | undefined;
+} & import("class-variance-authority/types").ClassProp) | undefined) => string;
+export interface TypographyProps extends HTMLAttributes<HTMLElement>, VariantProps<typeof typographyVariants> {
+    as?: ElementType;
+    children?: ReactNode;
+    ref?: Ref<HTMLElement>;
+}
+declare function Typography({ as, variant, className, children, ref, ...props }: TypographyProps): import("react/jsx-runtime").JSX.Element;
+export { Typography, typographyVariants };

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

@@ -0,0 +1,2 @@
+export type { TypographyProps } from "./Typography";
+export { Typography, typographyVariants } from "./Typography";

package/dist/components/UploadArea/UploadArea.d.ts

@@ -0,0 +1,11 @@
+import { type HTMLAttributes, type Ref } from "react";
+export interface UploadAreaProps extends Omit<HTMLAttributes<HTMLDivElement>, "onDrop" | "onClick"> {
+    formats?: string[];
+    maxSize?: string;
+    accept?: string;
+    onFileSelect?: (files: FileList) => void;
+    onFolderSelect?: (files: FileList) => void;
+    ref?: Ref<HTMLDivElement>;
+}
+declare function UploadArea({ className, formats, maxSize, accept, onFileSelect, onFolderSelect, ref, ...props }: UploadAreaProps): import("react/jsx-runtime").JSX.Element;
+export { UploadArea };

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

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