azamat-ui-kit 0.1.0

package/dist/components/patterns/form-builder.d.ts

@@ -0,0 +1,95 @@
+import * as React from "react";
+import type { Control, FieldPath, FieldValues } from "react-hook-form";
+import { type FormInputProps } from "@/components/form/form-input";
+import { type FormTextareaProps } from "@/components/form/form-textarea";
+import { type FormSelectProps } from "@/components/form/form-select";
+import { type FormAsyncSelectProps } from "@/components/form/form-async-select";
+import { type FormSwitchProps } from "@/components/form/form-switch";
+import { type FormNumberInputProps } from "@/components/form/form-number-input";
+import { type FormPhoneInputProps } from "@/components/form/form-phone-input";
+import { type FormDateInputProps } from "@/components/form/form-date-input";
+import { type FormDateRangeInputProps } from "@/components/form/form-date-range-input";
+export type FormBuilderLayout = "grid" | "stack";
+export type FormBuilderDensity = "compact" | "default" | "comfortable";
+export type FormBuilderFieldRenderContext<TFieldValues extends FieldValues> = {
+    control: Control<TFieldValues>;
+    disabled?: boolean;
+    readOnly?: boolean;
+};
+type BaseFormBuilderField = {
+    id: string;
+    hidden?: boolean;
+    className?: string;
+    colSpan?: 1 | 2 | 3 | 4 | "full";
+};
+export type FormBuilderCustomField<TFieldValues extends FieldValues> = BaseFormBuilderField & {
+    type: "custom";
+    render: (context: FormBuilderFieldRenderContext<TFieldValues>) => React.ReactNode;
+};
+export type FormBuilderInputField<TFieldValues extends FieldValues, TName extends FieldPath<TFieldValues> = FieldPath<TFieldValues>> = BaseFormBuilderField & {
+    type: "input";
+    props: Omit<FormInputProps<TFieldValues, TName>, "control">;
+};
+export type FormBuilderTextareaField<TFieldValues extends FieldValues, TName extends FieldPath<TFieldValues> = FieldPath<TFieldValues>> = BaseFormBuilderField & {
+    type: "textarea";
+    props: Omit<FormTextareaProps<TFieldValues, TName>, "control">;
+};
+export type FormBuilderSelectField<TFieldValues extends FieldValues, TName extends FieldPath<TFieldValues> = FieldPath<TFieldValues>> = BaseFormBuilderField & {
+    type: "select";
+    props: Omit<FormSelectProps<TFieldValues, TName>, "control">;
+};
+export type FormBuilderAsyncSelectField<TFieldValues extends FieldValues, TName extends FieldPath<TFieldValues> = FieldPath<TFieldValues>> = BaseFormBuilderField & {
+    type: "async-select";
+    props: Omit<FormAsyncSelectProps<TFieldValues, TName>, "control">;
+};
+export type FormBuilderSwitchField<TFieldValues extends FieldValues, TName extends FieldPath<TFieldValues> = FieldPath<TFieldValues>> = BaseFormBuilderField & {
+    type: "switch";
+    props: Omit<FormSwitchProps<TFieldValues, TName>, "control">;
+};
+export type FormBuilderNumberField<TFieldValues extends FieldValues, TName extends FieldPath<TFieldValues> = FieldPath<TFieldValues>> = BaseFormBuilderField & {
+    type: "number";
+    props: Omit<FormNumberInputProps<TFieldValues, TName>, "control">;
+};
+export type FormBuilderPhoneField<TFieldValues extends FieldValues, TName extends FieldPath<TFieldValues> = FieldPath<TFieldValues>> = BaseFormBuilderField & {
+    type: "phone";
+    props: Omit<FormPhoneInputProps<TFieldValues, TName>, "control">;
+};
+export type FormBuilderDateField<TFieldValues extends FieldValues, TName extends FieldPath<TFieldValues> = FieldPath<TFieldValues>> = BaseFormBuilderField & {
+    type: "date";
+    props: Omit<FormDateInputProps<TFieldValues, TName>, "control">;
+};
+export type FormBuilderDateRangeField<TFieldValues extends FieldValues, TFromName extends FieldPath<TFieldValues> = FieldPath<TFieldValues>, TToName extends FieldPath<TFieldValues> = FieldPath<TFieldValues>> = BaseFormBuilderField & {
+    type: "date-range";
+    props: Omit<FormDateRangeInputProps<TFieldValues, TFromName, TToName>, "control">;
+};
+export type FormBuilderField<TFieldValues extends FieldValues> = FormBuilderCustomField<TFieldValues> | FormBuilderInputField<TFieldValues> | FormBuilderTextareaField<TFieldValues> | FormBuilderSelectField<TFieldValues> | FormBuilderAsyncSelectField<TFieldValues> | FormBuilderSwitchField<TFieldValues> | FormBuilderNumberField<TFieldValues> | FormBuilderPhoneField<TFieldValues> | FormBuilderDateField<TFieldValues> | FormBuilderDateRangeField<TFieldValues>;
+export type FormBuilderSection<TFieldValues extends FieldValues> = {
+    id: string;
+    title?: React.ReactNode;
+    description?: React.ReactNode;
+    actions?: React.ReactNode;
+    hidden?: boolean;
+    className?: string;
+    fields: FormBuilderField<TFieldValues>[];
+};
+export type FormBuilderProps<TFieldValues extends FieldValues> = Omit<React.ComponentProps<"form">, "children"> & {
+    control: Control<TFieldValues>;
+    fields?: FormBuilderField<TFieldValues>[];
+    sections?: FormBuilderSection<TFieldValues>[];
+    layout?: FormBuilderLayout;
+    density?: FormBuilderDensity;
+    columns?: 1 | 2 | 3 | 4;
+    disabled?: boolean;
+    readOnly?: boolean;
+    footer?: React.ReactNode;
+    submitLabel?: React.ReactNode;
+    resetLabel?: React.ReactNode;
+    onResetClick?: () => void;
+    isSubmitting?: boolean;
+    sectionClassName?: string;
+    fieldClassName?: string;
+    footerClassName?: string;
+};
+declare function renderFormBuilderField<TFieldValues extends FieldValues>(field: FormBuilderField<TFieldValues>, context: FormBuilderFieldRenderContext<TFieldValues>): string | number | bigint | boolean | React.JSX.Element | Iterable<React.ReactNode> | Promise<string | number | bigint | boolean | React.ReactPortal | React.ReactElement<unknown, string | React.JSXElementConstructor<any>> | Iterable<React.ReactNode> | null | undefined> | null | undefined;
+declare function FormBuilder<TFieldValues extends FieldValues>({ className, control, fields, sections, layout, density, columns, disabled, readOnly, footer, submitLabel, resetLabel, onResetClick, isSubmitting, sectionClassName, fieldClassName, footerClassName, ...props }: FormBuilderProps<TFieldValues>): React.JSX.Element;
+export { FormBuilder, renderFormBuilderField };

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

@@ -0,0 +1,4 @@
+export * from "./resource-page";
+export * from "./resource-detail-page";
+export * from "./form-builder";
+export * from "./form-builder-presets";

package/dist/components/patterns/resource-detail-page.d.ts

@@ -0,0 +1,39 @@
+import * as React from "react";
+import { type DescriptionListItem } from "@/components/display/description-list";
+import { type PageHeaderProps } from "@/components/layout/page-header";
+export type ResourceDetailPageDensity = "default" | "compact" | "comfortable";
+export type ResourceDetailPageSection = {
+    id: string;
+    title?: React.ReactNode;
+    description?: React.ReactNode;
+    actions?: React.ReactNode;
+    hidden?: boolean;
+    className?: string;
+    bodyClassName?: string;
+    items?: DescriptionListItem[];
+    children?: React.ReactNode;
+};
+export type ResourceDetailPageProps = Omit<React.ComponentProps<"div">, "children"> & {
+    title?: React.ReactNode;
+    description?: React.ReactNode;
+    eyebrow?: React.ReactNode;
+    actions?: React.ReactNode;
+    breadcrumbs?: React.ReactNode;
+    status?: React.ReactNode;
+    summary?: React.ReactNode;
+    meta?: React.ReactNode;
+    sections?: ResourceDetailPageSection[];
+    children?: React.ReactNode;
+    aside?: React.ReactNode;
+    footer?: React.ReactNode;
+    backLabel?: React.ReactNode;
+    onBack?: () => void;
+    headerProps?: Omit<PageHeaderProps, "title" | "description" | "actions" | "eyebrow">;
+    density?: ResourceDetailPageDensity;
+    pageHeaderClassName?: string;
+    contentClassName?: string;
+    asideClassName?: string;
+    sectionClassName?: string;
+};
+declare function ResourceDetailPage({ className, title, description, eyebrow, actions, breadcrumbs, status, summary, meta, sections, children, aside, footer, backLabel, onBack, headerProps, density, pageHeaderClassName, contentClassName, asideClassName, sectionClassName, ...props }: ResourceDetailPageProps): React.JSX.Element;
+export { ResourceDetailPage };

package/dist/components/patterns/resource-page.d.ts

@@ -0,0 +1,34 @@
+import * as React from "react";
+import { type DataTableProps } from "@/components/data-table/data-table";
+import { type PageHeaderProps } from "@/components/layout/page-header";
+export type ResourcePageDensity = "default" | "compact" | "comfortable";
+export type ResourcePageSectionProps = React.ComponentProps<"section"> & {
+    title?: React.ReactNode;
+    description?: React.ReactNode;
+    actions?: React.ReactNode;
+    headerClassName?: string;
+    bodyClassName?: string;
+};
+declare function ResourcePageSection({ className, title, description, actions, headerClassName, bodyClassName, children, ...props }: ResourcePageSectionProps): React.JSX.Element;
+export type ResourcePageProps<TData, TValue = unknown> = Omit<React.ComponentProps<"div">, "children"> & {
+    title?: React.ReactNode;
+    description?: React.ReactNode;
+    eyebrow?: React.ReactNode;
+    actions?: React.ReactNode;
+    breadcrumbs?: React.ReactNode;
+    stats?: React.ReactNode;
+    filters?: React.ReactNode;
+    tabs?: React.ReactNode;
+    table?: DataTableProps<TData, TValue>;
+    children?: React.ReactNode;
+    aside?: React.ReactNode;
+    footer?: React.ReactNode;
+    headerProps?: Omit<PageHeaderProps, "title" | "description" | "actions" | "eyebrow">;
+    density?: ResourcePageDensity;
+    pageHeaderClassName?: string;
+    toolbarClassName?: string;
+    contentClassName?: string;
+    asideClassName?: string;
+};
+declare function ResourcePage<TData, TValue = unknown>({ className, title, description, eyebrow, actions, breadcrumbs, stats, filters, tabs, table, children, aside, footer, headerProps, density, pageHeaderClassName, toolbarClassName, contentClassName, asideClassName, ...props }: ResourcePageProps<TData, TValue>): React.JSX.Element;
+export { ResourcePage, ResourcePageSection };

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

@@ -0,0 +1,7 @@
+import { useRender } from "@base-ui/react/use-render";
+import { type VariantProps } from "class-variance-authority";
+declare const badgeVariants: (props?: ({
+    variant?: "default" | "outline" | "secondary" | "ghost" | "destructive" | "link" | null | undefined;
+} & import("class-variance-authority/types").ClassProp) | undefined) => string;
+declare function Badge({ className, variant, render, ...props }: useRender.ComponentProps<"span"> & VariantProps<typeof badgeVariants>): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
+export { Badge, badgeVariants };

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

@@ -0,0 +1,8 @@
+import { Button as ButtonPrimitive } from "@base-ui/react/button";
+import { type VariantProps } from "class-variance-authority";
+declare const buttonVariants: (props?: ({
+    variant?: "default" | "outline" | "secondary" | "ghost" | "destructive" | "link" | null | undefined;
+    size?: "default" | "xs" | "sm" | "lg" | "icon" | "icon-xs" | "icon-sm" | "icon-lg" | null | undefined;
+} & import("class-variance-authority/types").ClassProp) | undefined) => string;
+declare function Button({ className, variant, size, ...props }: ButtonPrimitive.Props & VariantProps<typeof buttonVariants>): import("react").JSX.Element;
+export { Button, buttonVariants };

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

@@ -0,0 +1,11 @@
+import * as React from "react";
+declare function Card({ className, size, ...props }: React.ComponentProps<"div"> & {
+    size?: "default" | "sm";
+}): React.JSX.Element;
+declare function CardHeader({ className, ...props }: React.ComponentProps<"div">): React.JSX.Element;
+declare function CardTitle({ className, ...props }: React.ComponentProps<"div">): React.JSX.Element;
+declare function CardDescription({ className, ...props }: React.ComponentProps<"div">): React.JSX.Element;
+declare function CardAction({ className, ...props }: React.ComponentProps<"div">): React.JSX.Element;
+declare function CardContent({ className, ...props }: React.ComponentProps<"div">): React.JSX.Element;
+declare function CardFooter({ className, ...props }: React.ComponentProps<"div">): React.JSX.Element;
+export { Card, CardHeader, CardFooter, CardTitle, CardAction, CardDescription, CardContent, };

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

@@ -0,0 +1,13 @@
+import * as React from "react";
+export type CheckboxCheckedState = boolean | "indeterminate";
+export type CheckboxProps = Omit<React.ComponentPropsWithoutRef<"button">, "checked" | "defaultChecked" | "onChange" | "value"> & {
+    checked?: CheckboxCheckedState;
+    defaultChecked?: CheckboxCheckedState;
+    onCheckedChange?: (checked: boolean) => void;
+};
+declare const Checkbox: React.ForwardRefExoticComponent<Omit<Omit<React.DetailedHTMLProps<React.ButtonHTMLAttributes<HTMLButtonElement>, HTMLButtonElement>, "ref">, "defaultChecked" | "value" | "onChange" | "checked"> & {
+    checked?: CheckboxCheckedState;
+    defaultChecked?: CheckboxCheckedState;
+    onCheckedChange?: (checked: boolean) => void;
+} & React.RefAttributes<HTMLButtonElement>>;
+export { Checkbox };

package/dist/components/ui/component-preview.d.ts

@@ -0,0 +1,10 @@
+import * as React from "react";
+export interface ComponentPreviewProps extends Omit<React.HTMLAttributes<HTMLDivElement>, "title" | "description"> {
+    code: string;
+    language?: string;
+    title?: React.ReactNode;
+    description?: React.ReactNode;
+    dependencies?: string[];
+    children: React.ReactNode;
+}
+export declare function ComponentPreview({ code, language, title, description, dependencies, children, className, ...props }: ComponentPreviewProps): React.JSX.Element;

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

@@ -0,0 +1,17 @@
+import * as React from "react";
+import { Dialog as DialogPrimitive } from "@base-ui/react/dialog";
+declare function Dialog({ ...props }: DialogPrimitive.Root.Props): React.JSX.Element;
+declare function DialogTrigger({ ...props }: DialogPrimitive.Trigger.Props): React.JSX.Element;
+declare function DialogPortal({ ...props }: DialogPrimitive.Portal.Props): React.JSX.Element;
+declare function DialogClose({ ...props }: DialogPrimitive.Close.Props): React.JSX.Element;
+declare function DialogOverlay({ className, ...props }: DialogPrimitive.Backdrop.Props): React.JSX.Element;
+declare function DialogContent({ className, children, showCloseButton, ...props }: DialogPrimitive.Popup.Props & {
+    showCloseButton?: boolean;
+}): React.JSX.Element;
+declare function DialogHeader({ className, ...props }: React.ComponentProps<"div">): React.JSX.Element;
+declare function DialogFooter({ className, showCloseButton, children, ...props }: React.ComponentProps<"div"> & {
+    showCloseButton?: boolean;
+}): React.JSX.Element;
+declare function DialogTitle({ className, ...props }: DialogPrimitive.Title.Props): React.JSX.Element;
+declare function DialogDescription({ className, ...props }: DialogPrimitive.Description.Props): React.JSX.Element;
+export { Dialog, DialogClose, DialogContent, DialogDescription, DialogFooter, DialogHeader, DialogOverlay, DialogPortal, DialogTitle, DialogTrigger, };

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

@@ -0,0 +1,29 @@
+import * as React from "react";
+import { Menu as MenuPrimitive } from "@base-ui/react/menu";
+declare function DropdownMenu({ ...props }: MenuPrimitive.Root.Props): React.JSX.Element;
+declare function DropdownMenuPortal({ ...props }: MenuPrimitive.Portal.Props): React.JSX.Element;
+declare function DropdownMenuTrigger({ ...props }: MenuPrimitive.Trigger.Props): React.JSX.Element;
+declare function DropdownMenuContent({ align, alignOffset, side, sideOffset, className, ...props }: MenuPrimitive.Popup.Props & Pick<MenuPrimitive.Positioner.Props, "align" | "alignOffset" | "side" | "sideOffset">): React.JSX.Element;
+declare function DropdownMenuGroup({ ...props }: MenuPrimitive.Group.Props): React.JSX.Element;
+declare function DropdownMenuLabel({ className, inset, ...props }: React.ComponentProps<"div"> & {
+    inset?: boolean;
+}): React.JSX.Element;
+declare function DropdownMenuItem({ className, inset, variant, ...props }: MenuPrimitive.Item.Props & {
+    inset?: boolean;
+    variant?: "default" | "destructive";
+}): React.JSX.Element;
+declare function DropdownMenuSub({ ...props }: MenuPrimitive.SubmenuRoot.Props): React.JSX.Element;
+declare function DropdownMenuSubTrigger({ className, inset, children, ...props }: MenuPrimitive.SubmenuTrigger.Props & {
+    inset?: boolean;
+}): React.JSX.Element;
+declare function DropdownMenuSubContent({ align, alignOffset, side, sideOffset, className, ...props }: React.ComponentProps<typeof DropdownMenuContent>): React.JSX.Element;
+declare function DropdownMenuCheckboxItem({ className, children, checked, inset, ...props }: MenuPrimitive.CheckboxItem.Props & {
+    inset?: boolean;
+}): React.JSX.Element;
+declare function DropdownMenuRadioGroup({ ...props }: MenuPrimitive.RadioGroup.Props): React.JSX.Element;
+declare function DropdownMenuRadioItem({ className, children, inset, ...props }: MenuPrimitive.RadioItem.Props & {
+    inset?: boolean;
+}): React.JSX.Element;
+declare function DropdownMenuSeparator({ className, ...props }: MenuPrimitive.Separator.Props): React.JSX.Element;
+declare function DropdownMenuShortcut({ className, ...props }: React.ComponentProps<"span">): React.JSX.Element;
+export { DropdownMenu, DropdownMenuPortal, DropdownMenuTrigger, DropdownMenuContent, DropdownMenuGroup, DropdownMenuLabel, DropdownMenuItem, DropdownMenuCheckboxItem, DropdownMenuRadioGroup, DropdownMenuRadioItem, DropdownMenuSeparator, DropdownMenuShortcut, DropdownMenuSub, DropdownMenuSubTrigger, DropdownMenuSubContent, };

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

@@ -0,0 +1,3 @@
+import * as React from "react";
+declare function Input({ className, type, ...props }: React.ComponentProps<"input">): React.JSX.Element;
+export { Input };

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

@@ -0,0 +1,9 @@
+import * as React from "react";
+import { Popover as PopoverPrimitive } from "@base-ui/react/popover";
+declare function Popover({ ...props }: PopoverPrimitive.Root.Props): React.JSX.Element;
+declare function PopoverTrigger({ ...props }: PopoverPrimitive.Trigger.Props): React.JSX.Element;
+declare function PopoverContent({ className, align, alignOffset, side, sideOffset, ...props }: PopoverPrimitive.Popup.Props & Pick<PopoverPrimitive.Positioner.Props, "align" | "alignOffset" | "side" | "sideOffset">): React.JSX.Element;
+declare function PopoverHeader({ className, ...props }: React.ComponentProps<"div">): React.JSX.Element;
+declare function PopoverTitle({ className, ...props }: PopoverPrimitive.Title.Props): React.JSX.Element;
+declare function PopoverDescription({ className, ...props }: PopoverPrimitive.Description.Props): React.JSX.Element;
+export { Popover, PopoverContent, PopoverDescription, PopoverHeader, PopoverTitle, PopoverTrigger, };

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

@@ -0,0 +1,15 @@
+import * as React from "react";
+import { Select as SelectPrimitive } from "@base-ui/react/select";
+declare const Select: typeof SelectPrimitive.Root;
+declare function SelectGroup({ className, ...props }: SelectPrimitive.Group.Props): React.JSX.Element;
+declare function SelectValue({ className, ...props }: SelectPrimitive.Value.Props): React.JSX.Element;
+declare function SelectTrigger({ className, size, children, ...props }: SelectPrimitive.Trigger.Props & {
+    size?: "sm" | "default";
+}): React.JSX.Element;
+declare function SelectContent({ className, children, side, sideOffset, align, alignOffset, alignItemWithTrigger, ...props }: SelectPrimitive.Popup.Props & Pick<SelectPrimitive.Positioner.Props, "align" | "alignOffset" | "side" | "sideOffset" | "alignItemWithTrigger">): React.JSX.Element;
+declare function SelectLabel({ className, ...props }: SelectPrimitive.GroupLabel.Props): React.JSX.Element;
+declare function SelectItem({ className, children, ...props }: SelectPrimitive.Item.Props): React.JSX.Element;
+declare function SelectSeparator({ className, ...props }: SelectPrimitive.Separator.Props): React.JSX.Element;
+declare function SelectScrollUpButton({ className, ...props }: React.ComponentProps<typeof SelectPrimitive.ScrollUpArrow>): React.JSX.Element;
+declare function SelectScrollDownButton({ className, ...props }: React.ComponentProps<typeof SelectPrimitive.ScrollDownArrow>): React.JSX.Element;
+export { Select, SelectContent, SelectGroup, SelectItem, SelectLabel, SelectScrollDownButton, SelectScrollUpButton, SelectSeparator, SelectTrigger, SelectValue, };

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

@@ -0,0 +1,12 @@
+import * as React from "react";
+export type SwitchProps = Omit<React.ComponentPropsWithoutRef<"button">, "onChange" | "value"> & {
+    checked?: boolean;
+    defaultChecked?: boolean;
+    onCheckedChange?: (checked: boolean) => void;
+};
+declare const Switch: React.ForwardRefExoticComponent<Omit<Omit<React.DetailedHTMLProps<React.ButtonHTMLAttributes<HTMLButtonElement>, HTMLButtonElement>, "ref">, "value" | "onChange"> & {
+    checked?: boolean;
+    defaultChecked?: boolean;
+    onCheckedChange?: (checked: boolean) => void;
+} & React.RefAttributes<HTMLButtonElement>>;
+export { Switch };

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

@@ -0,0 +1,10 @@
+import * as React from "react";
+declare function Table({ className, ...props }: React.ComponentProps<"table">): React.JSX.Element;
+declare function TableHeader({ className, ...props }: React.ComponentProps<"thead">): React.JSX.Element;
+declare function TableBody({ className, ...props }: React.ComponentProps<"tbody">): React.JSX.Element;
+declare function TableFooter({ className, ...props }: React.ComponentProps<"tfoot">): React.JSX.Element;
+declare function TableRow({ className, ...props }: React.ComponentProps<"tr">): React.JSX.Element;
+declare function TableHead({ className, ...props }: React.ComponentProps<"th">): React.JSX.Element;
+declare function TableCell({ className, ...props }: React.ComponentProps<"td">): React.JSX.Element;
+declare function TableCaption({ className, ...props }: React.ComponentProps<"caption">): React.JSX.Element;
+export { Table, TableHeader, TableBody, TableFooter, TableHead, TableRow, TableCell, TableCaption, };

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

@@ -0,0 +1,6 @@
+import * as React from "react";
+declare const Tabs: React.ForwardRefExoticComponent<Omit<import("@base-ui/react").TabsRootProps, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const TabsList: React.ForwardRefExoticComponent<Omit<Omit<import("@base-ui/react").TabsListProps, "ref"> & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const TabsTrigger: React.ForwardRefExoticComponent<Omit<Omit<import("@base-ui/react").TabsTabProps, "ref"> & React.RefAttributes<HTMLElement>, "ref"> & React.RefAttributes<HTMLElement>>;
+declare const TabsContent: React.ForwardRefExoticComponent<Omit<Omit<import("@base-ui/react").TabsPanelProps, "ref"> & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+export { Tabs, TabsList, TabsTrigger, TabsContent };

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

@@ -0,0 +1,3 @@
+import * as React from "react";
+declare function Textarea({ className, ...props }: React.ComponentProps<"textarea">): React.JSX.Element;
+export { Textarea };

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

@@ -0,0 +1,61 @@
+import * as React from "react";
+export type FileUploadRejectReason = "max-files" | "max-size" | "type";
+export type FileUploadRejectedFile = {
+    file: File;
+    reason: FileUploadRejectReason;
+    message: string;
+};
+export type FileUploadRenderFileState = {
+    file: File;
+    index: number;
+    progress?: number;
+    remove: () => void;
+    removeLabel?: string;
+};
+export type FileUploadRenderRejectedFileState = {
+    rejectedFile: FileUploadRejectedFile;
+    index: number;
+};
+type NativeFileInputProps = Omit<React.InputHTMLAttributes<HTMLInputElement>, "type" | "value" | "onChange" | "className" | "children" | "onDragEnter" | "onDragLeave" | "onDragOver" | "onDrop">;
+export type FileUploadProps = NativeFileInputProps & {
+    files?: File[];
+    onFilesChange?: (files: File[]) => void;
+    rejectedFiles?: FileUploadRejectedFile[];
+    onRejectedFilesChange?: (files: FileUploadRejectedFile[]) => void;
+    onDragEnter?: React.DragEventHandler<HTMLDivElement>;
+    onDragLeave?: React.DragEventHandler<HTMLDivElement>;
+    onDragOver?: React.DragEventHandler<HTMLDivElement>;
+    onDrop?: React.DragEventHandler<HTMLDivElement>;
+    buttonLabel?: React.ReactNode;
+    dropzoneLabel?: React.ReactNode;
+    dropzoneDescription?: React.ReactNode;
+    dragActiveLabel?: React.ReactNode;
+    helperText?: React.ReactNode;
+    clearLabel?: React.ReactNode;
+    removeLabel?: string;
+    maxFiles?: number;
+    maxSize?: number;
+    appendFiles?: boolean;
+    showFileList?: boolean;
+    showClearButton?: boolean;
+    loading?: boolean;
+    progress?: number | Record<string, number>;
+    renderFile?: (state: FileUploadRenderFileState) => React.ReactNode;
+    renderRejectedFile?: (state: FileUploadRenderRejectedFileState) => React.ReactNode;
+    renderActions?: (state: {
+        openFileDialog: () => void;
+        clearFiles: () => void;
+        files: File[];
+    }) => React.ReactNode;
+    className?: string;
+    inputClassName?: string;
+    dropzoneClassName?: string;
+    fileListClassName?: string;
+    fileItemClassName?: string;
+    rejectedListClassName?: string;
+};
+declare function formatBytes(bytes: number): string;
+declare function fileMatchesAccept(file: File, accept?: string): boolean;
+declare function getFileKey(file: File): string;
+declare function FileUpload({ files, onFilesChange, rejectedFiles, onRejectedFilesChange, buttonLabel, dropzoneLabel, dropzoneDescription, dragActiveLabel, helperText, clearLabel, removeLabel, maxFiles, maxSize, appendFiles, showFileList, showClearButton, loading, progress, renderFile, renderRejectedFile, renderActions, className, inputClassName, dropzoneClassName, fileListClassName, fileItemClassName, rejectedListClassName, accept, multiple, disabled, onDragEnter, onDragLeave, onDragOver, onDrop, ...props }: FileUploadProps): React.JSX.Element;
+export { FileUpload, fileMatchesAccept, formatBytes, getFileKey };

package/dist/components/upload/image-upload.d.ts

@@ -0,0 +1,14 @@
+import * as React from "react";
+import { type FileUploadProps, type FileUploadRenderFileState } from "@/components/upload/file-upload";
+export type ImageUploadProps = Omit<FileUploadProps, "accept" | "renderFile"> & {
+    accept?: string;
+    preview?: boolean;
+    previewClassName?: string;
+    imageClassName?: string;
+    renderImageFile?: (state: FileUploadRenderFileState & {
+        previewUrl?: string;
+    }) => React.ReactNode;
+};
+declare function useImagePreviewUrls(files: File[], enabled?: boolean): Record<string, string>;
+declare function ImageUpload({ accept, buttonLabel, dropzoneLabel, preview, previewClassName, imageClassName, files, renderImageFile, ...props }: ImageUploadProps): React.JSX.Element;
+export { ImageUpload, useImagePreviewUrls };

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

@@ -0,0 +1,2 @@
+export { FileUpload } from "./file-upload";
+export { ImageUpload } from "./image-upload";

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

@@ -0,0 +1,2 @@
+export * from "./stepper";
+export * from "./wizard";

package/dist/components/wizard/stepper.d.ts

@@ -0,0 +1,16 @@
+import * as React from "react";
+export type StepperStep = {
+    id: string;
+    title: React.ReactNode;
+    description?: React.ReactNode;
+    disabled?: boolean;
+    completed?: boolean;
+};
+export type StepperProps = React.ComponentProps<"div"> & {
+    steps: StepperStep[];
+    currentStep: string;
+    onStepChange?: (stepId: string) => void;
+    orientation?: "horizontal" | "vertical";
+};
+declare function Stepper({ className, steps, currentStep, onStepChange, orientation, ...props }: StepperProps): React.JSX.Element;
+export { Stepper };

package/dist/components/wizard/wizard.d.ts

@@ -0,0 +1,17 @@
+import * as React from "react";
+import { type StepperStep } from "@/components/wizard/stepper";
+export type WizardProps = React.ComponentProps<"div"> & {
+    steps: StepperStep[];
+    currentStep: string;
+    onStepChange?: (stepId: string) => void;
+    onNext?: () => void;
+    onPrevious?: () => void;
+    onFinish?: () => void;
+    nextLabel?: React.ReactNode;
+    previousLabel?: React.ReactNode;
+    finishLabel?: React.ReactNode;
+    children?: React.ReactNode;
+    footer?: React.ReactNode;
+};
+declare function Wizard({ className, steps, currentStep, onStepChange, onNext, onPrevious, onFinish, nextLabel, previousLabel, finishLabel, children, footer, ...props }: WizardProps): React.JSX.Element;
+export { Wizard };

package/dist/hooks/index.d.ts

@@ -0,0 +1,6 @@
+export * from "./use-session-storage-state";
+export * from "./use-before-unload-when-dirty";
+export * from "./use-is-mobile";
+export * from "./use-disclosure";
+export * from "./use-debounce";
+export * from "./use-data-table-view-state";

package/dist/hooks/use-before-unload-when-dirty.d.ts

@@ -0,0 +1,2 @@
+declare function useBeforeUnloadWhenDirty(isDirty: boolean, message?: string): void;
+export { useBeforeUnloadWhenDirty };

package/dist/hooks/use-data-table-view-state.d.ts

@@ -0,0 +1,20 @@
+export type DataTableViewStorage = "local" | "session" | "memory";
+export type UseDataTableViewStateOptions<TValue extends string> = {
+    key: string;
+    defaultValue?: TValue;
+    allowedValues?: readonly TValue[];
+    storage?: DataTableViewStorage;
+    syncAcrossTabs?: boolean;
+    serialize?: (value: TValue) => string;
+    deserialize?: (value: string) => TValue;
+    onValueChange?: (value: TValue | undefined) => void;
+};
+export type UseDataTableViewStateReturn<TValue extends string> = {
+    value: TValue | undefined;
+    setValue: (value: TValue | undefined) => void;
+    clearValue: () => void;
+    resetValue: () => void;
+    isDefaultValue: boolean;
+};
+declare function useDataTableViewState<TValue extends string>({ key, defaultValue, allowedValues, storage, syncAcrossTabs, serialize, deserialize, onValueChange, }: UseDataTableViewStateOptions<TValue>): UseDataTableViewStateReturn<TValue>;
+export { useDataTableViewState };

package/dist/hooks/use-debounce.d.ts

@@ -0,0 +1,3 @@
+declare function useDebouncedValue<TValue>(value: TValue, delay?: number): TValue;
+declare function useDebouncedCallback<TArgs extends unknown[]>(callback: (...args: TArgs) => void, delay?: number): (...args: TArgs) => void;
+export { useDebouncedCallback, useDebouncedValue };

package/dist/hooks/use-disclosure.d.ts

@@ -0,0 +1,13 @@
+export type UseDisclosureOptions = {
+    defaultOpen?: boolean;
+    open?: boolean;
+    onOpenChange?: (open: boolean) => void;
+};
+declare function useDisclosure({ defaultOpen, open, onOpenChange }?: UseDisclosureOptions): {
+    readonly open: boolean;
+    readonly setOpen: (nextOpen: boolean) => void;
+    readonly openDisclosure: () => void;
+    readonly closeDisclosure: () => void;
+    readonly toggleDisclosure: () => void;
+};
+export { useDisclosure };

package/dist/hooks/use-is-mobile.d.ts

@@ -0,0 +1,3 @@
+declare const DEFAULT_MOBILE_BREAKPOINT = 768;
+declare function useIsMobile(breakpoint?: number): boolean;
+export { useIsMobile, DEFAULT_MOBILE_BREAKPOINT };

package/dist/hooks/use-session-storage-state.d.ts

@@ -0,0 +1,8 @@
+type SessionStorageOptions<T> = {
+    serialize?: (value: T) => string;
+    deserialize?: (value: string) => T;
+};
+type SetSessionStorageStateAction<T> = T | ((previousValue: T) => T);
+declare function useSessionStorageState<T>(key: string, initialValue: T | (() => T), options?: SessionStorageOptions<T>): readonly [T, (value: SetSessionStorageStateAction<T>) => void, () => void];
+export { useSessionStorageState };
+export type { SessionStorageOptions, SetSessionStorageStateAction };