azamat-ui-kit 0.1.0

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

@@ -0,0 +1,35 @@
+import * as React from "react";
+import { Card } from "@/components/ui/card";
+export type ProgressTone = "default" | "success" | "info" | "warning" | "danger" | "muted";
+export type ProgressSize = "sm" | "default" | "lg";
+export type ProgressProps = Omit<React.ComponentProps<"div">, "children"> & {
+    value?: number | null;
+    max?: number;
+    min?: number;
+    label?: React.ReactNode;
+    description?: React.ReactNode;
+    showValue?: boolean;
+    valueFormatter?: (value: number, percent: number) => React.ReactNode;
+    tone?: ProgressTone;
+    size?: ProgressSize;
+    indeterminate?: boolean;
+    trackClassName?: string;
+    indicatorClassName?: string;
+};
+export type ProgressCardProps = React.ComponentProps<typeof Card> & {
+    title?: React.ReactNode;
+    description?: React.ReactNode;
+    value?: number | null;
+    max?: number;
+    min?: number;
+    tone?: ProgressTone;
+    size?: ProgressSize;
+    showValue?: boolean;
+    valueFormatter?: ProgressProps["valueFormatter"];
+    footer?: React.ReactNode;
+    progressClassName?: string;
+};
+declare function getProgressPercent(value: number | null | undefined, min: number, max: number): number;
+declare function Progress({ value, min, max, label, description, showValue, valueFormatter, tone, size, indeterminate, className, trackClassName, indicatorClassName, ...props }: ProgressProps): React.JSX.Element;
+declare function ProgressCard({ title, description, value, min, max, tone, size, showValue, valueFormatter, footer, progressClassName, className, ...props }: ProgressCardProps): React.JSX.Element;
+export { Progress, ProgressCard, getProgressPercent };

package/dist/components/display/result.d.ts

@@ -0,0 +1,18 @@
+import * as React from "react";
+import { Button } from "@/components/ui/button";
+export type ResultStatus = "success" | "error" | "warning" | "info" | "not-found" | "forbidden" | "server-error";
+export type ResultProps = React.ComponentProps<"div"> & {
+    status?: ResultStatus;
+    icon?: React.ReactNode;
+    title?: React.ReactNode;
+    description?: React.ReactNode;
+    actions?: React.ReactNode;
+    extra?: React.ReactNode;
+    compact?: boolean;
+    iconClassName?: string;
+    titleClassName?: string;
+    descriptionClassName?: string;
+};
+declare function Result({ status, icon, title, description, actions, extra, compact, iconClassName, titleClassName, descriptionClassName, className, ...props }: ResultProps): React.JSX.Element;
+declare function ResultAction({ className, ...props }: React.ComponentProps<typeof Button>): React.JSX.Element;
+export { Result, ResultAction };

package/dist/components/display/status-legend.d.ts

@@ -0,0 +1,27 @@
+import * as React from "react";
+import { Card } from "@/components/ui/card";
+export type StatusLegendTone = "default" | "success" | "warning" | "danger" | "info" | "muted";
+export type StatusLegendOrientation = "vertical" | "horizontal" | "grid";
+export type StatusLegendItem = {
+    key: string;
+    label: React.ReactNode;
+    description?: React.ReactNode;
+    count?: React.ReactNode;
+    tone?: StatusLegendTone;
+    icon?: React.ReactNode;
+    hidden?: boolean;
+    className?: string;
+};
+export type StatusLegendProps = React.ComponentProps<typeof Card> & {
+    title?: React.ReactNode;
+    description?: React.ReactNode;
+    actions?: React.ReactNode;
+    items: StatusLegendItem[];
+    orientation?: StatusLegendOrientation;
+    compact?: boolean;
+    showCounts?: boolean;
+    contentClassName?: string;
+    itemClassName?: string;
+};
+declare function StatusLegend({ title, description, actions, items, orientation, compact, showCounts, contentClassName, itemClassName, className, ...props }: StatusLegendProps): React.JSX.Element;
+export { StatusLegend };

package/dist/components/display/timeline.d.ts

@@ -0,0 +1,25 @@
+import * as React from "react";
+export type TimelineTone = "default" | "success" | "info" | "warning" | "danger" | "muted";
+export type TimelineOrientation = "vertical" | "horizontal";
+export type TimelineItem = {
+    key: string;
+    title?: React.ReactNode;
+    description?: React.ReactNode;
+    time?: React.ReactNode;
+    icon?: React.ReactNode;
+    tone?: TimelineTone;
+    content?: React.ReactNode;
+    actions?: React.ReactNode;
+    hidden?: boolean;
+    className?: string;
+};
+export type TimelineProps = React.ComponentProps<"div"> & {
+    items: TimelineItem[];
+    orientation?: TimelineOrientation;
+    pending?: boolean;
+    pendingLabel?: React.ReactNode;
+    compact?: boolean;
+    itemClassName?: string;
+};
+declare function Timeline({ items, orientation, pending, pendingLabel, compact, itemClassName, className, ...props }: TimelineProps): React.JSX.Element;
+export { Timeline };

package/dist/components/feedback/empty-state.d.ts

@@ -0,0 +1,11 @@
+import * as React from "react";
+export type EmptyStateProps = React.ComponentProps<"div"> & {
+    icon?: React.ReactNode;
+    title?: React.ReactNode;
+    description?: React.ReactNode;
+    action?: React.ReactNode;
+    actionLabel?: React.ReactNode;
+    onAction?: () => void;
+};
+declare function EmptyState({ className, icon, title, description, action, actionLabel, onAction, ...props }: EmptyStateProps): React.JSX.Element;
+export { EmptyState };

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

@@ -0,0 +1,3 @@
+export * from "./empty-state";
+export * from "./loading-state";
+export * from "./status-badge";

package/dist/components/feedback/loading-state.d.ts

@@ -0,0 +1,8 @@
+import * as React from "react";
+export type LoadingStateProps = React.ComponentProps<"div"> & {
+    label?: React.ReactNode;
+    description?: React.ReactNode;
+    icon?: React.ReactNode;
+};
+declare function LoadingState({ className, label, description, icon, ...props }: LoadingStateProps): React.JSX.Element;
+export { LoadingState };

package/dist/components/feedback/status-badge.d.ts

@@ -0,0 +1,9 @@
+import * as React from "react";
+import { Badge } from "@/components/ui/badge";
+export type StatusBadgeTone = "default" | "success" | "warning" | "danger" | "info" | "muted" | "outline";
+export type StatusBadgeProps = React.ComponentProps<typeof Badge> & {
+    tone?: StatusBadgeTone;
+    dot?: boolean;
+};
+declare function StatusBadge({ className, tone, dot, children, ...props }: StatusBadgeProps): React.JSX.Element;
+export { StatusBadge };

package/dist/components/filters/filter-bar.d.ts

@@ -0,0 +1,14 @@
+import * as React from "react";
+export type FilterBarProps = React.ComponentProps<"div"> & {
+    search?: React.ReactNode;
+    filters?: React.ReactNode;
+    actions?: React.ReactNode;
+    activeCount?: number;
+    activeLabel?: (count: number) => React.ReactNode;
+    resetLabel?: React.ReactNode;
+    onReset?: () => void;
+    collapsible?: boolean;
+    defaultExpanded?: boolean;
+};
+declare function FilterBar({ className, search, filters, actions, activeCount, activeLabel, resetLabel, onReset, collapsible, defaultExpanded, children, ...props }: FilterBarProps): React.JSX.Element;
+export { FilterBar };

package/dist/components/filters/filter-chips.d.ts

@@ -0,0 +1,18 @@
+import * as React from "react";
+export type FilterChip = {
+    key: string;
+    label: React.ReactNode;
+    value?: React.ReactNode;
+    tone?: "default" | "success" | "warning" | "danger" | "info" | "muted";
+    disabled?: boolean;
+    hidden?: boolean;
+};
+export type FilterChipsProps = React.ComponentProps<"div"> & {
+    chips: FilterChip[];
+    clearLabel?: React.ReactNode;
+    empty?: React.ReactNode;
+    onRemove?: (key: string) => void;
+    onClear?: () => void;
+};
+declare function FilterChips({ chips, clearLabel, empty, onRemove, onClear, className, ...props }: FilterChipsProps): React.JSX.Element;
+export { FilterChips };

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

@@ -0,0 +1,2 @@
+export * from "./filter-bar";
+export * from "./filter-chips";

package/dist/components/form/form-async-select.d.ts

@@ -0,0 +1,12 @@
+import { type Control, type FieldPath, type FieldValues } from "react-hook-form";
+import { type FormFieldShellControlProps } from "@/components/form/form-field-shell";
+import { type AsyncSelectOption, type AsyncSelectProps } from "@/components/inputs/async-select";
+export type FormAsyncSelectProps<TFieldValues extends FieldValues = FieldValues, TName extends FieldPath<TFieldValues> = FieldPath<TFieldValues>, TValue extends string = string, TData = unknown, TOption extends AsyncSelectOption<TValue, TData> = AsyncSelectOption<TValue, TData>> = Omit<AsyncSelectProps<TValue, TData, TOption>, "value" | "onValueChange" | "disabled"> & FormFieldShellControlProps & {
+    control: Control<TFieldValues>;
+    name: TName;
+    fieldClassName?: string;
+    emptyValue?: unknown;
+    onValueChange?: (value: TValue | undefined, option?: TOption) => void;
+};
+declare function FormAsyncSelect<TFieldValues extends FieldValues = FieldValues, TName extends FieldPath<TFieldValues> = FieldPath<TFieldValues>, TValue extends string = string, TData = unknown, TOption extends AsyncSelectOption<TValue, TData> = AsyncSelectOption<TValue, TData>>({ control, name, label, description, required, className, layout, descriptionPosition, labelAction, requiredIndicator, errorIcon, showErrorIcon, disabled, readOnly, labelClassName, labelRowClassName, descriptionClassName, errorClassName, contentClassName, fieldClassName, emptyValue, onValueChange, ...props }: FormAsyncSelectProps<TFieldValues, TName, TValue, TData, TOption>): import("react").JSX.Element;
+export { FormAsyncSelect };

package/dist/components/form/form-date-input.d.ts

@@ -0,0 +1,12 @@
+import { type Control, type FieldPath, type FieldValues } from "react-hook-form";
+import { type FormFieldShellProps } from "@/components/form/form-field-shell";
+import { type DateInputProps } from "@/components/inputs/date-input";
+export type FormDateInputProps<TFieldValues extends FieldValues = FieldValues, TName extends FieldPath<TFieldValues> = FieldPath<TFieldValues>> = Omit<DateInputProps, "name" | "value" | "defaultValue" | "onValueChange"> & Pick<FormFieldShellProps, "label" | "description" | "required" | "className"> & {
+    control: Control<TFieldValues>;
+    name: TName;
+    fieldClassName?: string;
+    emptyValue?: unknown;
+    onValueChange?: (value: string) => void;
+};
+declare function FormDateInput<TFieldValues extends FieldValues = FieldValues, TName extends FieldPath<TFieldValues> = FieldPath<TFieldValues>>({ control, name, label, description, required, className, fieldClassName, emptyValue, onValueChange, ...props }: FormDateInputProps<TFieldValues, TName>): import("react").JSX.Element;
+export { FormDateInput };

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

@@ -0,0 +1,12 @@
+import { type Control, type FieldPath, type FieldValues } from "react-hook-form";
+import { type DatePickerProps } from "@/components/calendar/date-picker";
+import { type FormFieldShellProps } from "@/components/form/form-field-shell";
+export type FormDatePickerProps<TFieldValues extends FieldValues = FieldValues, TName extends FieldPath<TFieldValues> = FieldPath<TFieldValues>> = Omit<DatePickerProps, "value" | "onValueChange"> & Pick<FormFieldShellProps, "label" | "description" | "required" | "className"> & {
+    control: Control<TFieldValues>;
+    name: TName;
+    fieldClassName?: string;
+    emptyValue?: unknown;
+    onValueChange?: (value: string) => void;
+};
+declare function FormDatePicker<TFieldValues extends FieldValues = FieldValues, TName extends FieldPath<TFieldValues> = FieldPath<TFieldValues>>({ control, name, label, description, required, className, fieldClassName, emptyValue, onValueChange, ...props }: FormDatePickerProps<TFieldValues, TName>): import("react").JSX.Element;
+export { FormDatePicker };

package/dist/components/form/form-date-range-input.d.ts

@@ -0,0 +1,12 @@
+import { type Control, type FieldPath, type FieldValues } from "react-hook-form";
+import { type FormFieldShellProps } from "@/components/form/form-field-shell";
+import { type DateRangeInputProps, type DateRangeValue } from "@/components/inputs/date-range-input";
+export type FormDateRangeInputProps<TFieldValues extends FieldValues = FieldValues, TFromName extends FieldPath<TFieldValues> = FieldPath<TFieldValues>, TToName extends FieldPath<TFieldValues> = FieldPath<TFieldValues>> = Omit<DateRangeInputProps, "value" | "onValueChange"> & Pick<FormFieldShellProps, "label" | "description" | "required" | "className"> & {
+    control: Control<TFieldValues>;
+    fromName: TFromName;
+    toName: TToName;
+    emptyValue?: unknown;
+    onValueChange?: (value: DateRangeValue) => void;
+};
+declare function FormDateRangeInput<TFieldValues extends FieldValues = FieldValues, TFromName extends FieldPath<TFieldValues> = FieldPath<TFieldValues>, TToName extends FieldPath<TFieldValues> = FieldPath<TFieldValues>>({ control, fromName, toName, label, description, required, className, emptyValue, onValueChange, ...props }: FormDateRangeInputProps<TFieldValues, TFromName, TToName>): import("react").JSX.Element;
+export { FormDateRangeInput };

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

@@ -0,0 +1,15 @@
+import { type Control, type FieldPath, type FieldValues } from "react-hook-form";
+import { type DateRangePickerProps } from "@/components/calendar/date-range-picker";
+import { type FormFieldShellProps } from "@/components/form/form-field-shell";
+export type FormDateRangePickerProps<TFieldValues extends FieldValues = FieldValues> = Omit<DateRangePickerProps, "value" | "onValueChange"> & Pick<FormFieldShellProps, "label" | "description" | "required" | "className"> & {
+    control: Control<TFieldValues>;
+    fromName: FieldPath<TFieldValues>;
+    toName: FieldPath<TFieldValues>;
+    emptyValue?: unknown;
+    onValueChange?: (value: {
+        from?: string;
+        to?: string;
+    }) => void;
+};
+declare function FormDateRangePicker<TFieldValues extends FieldValues = FieldValues>({ control, fromName, toName, label, description, required, className, emptyValue, onValueChange, ...props }: FormDateRangePickerProps<TFieldValues>): import("react").JSX.Element;
+export { FormDateRangePicker };

package/dist/components/form/form-field-shell.d.ts

@@ -0,0 +1,26 @@
+import * as React from "react";
+export type FormFieldLayout = "vertical" | "horizontal" | "inline";
+export type FormFieldDescriptionPosition = "top" | "bottom";
+export type FormFieldShellProps = React.ComponentProps<"div"> & {
+    label?: React.ReactNode;
+    description?: React.ReactNode;
+    error?: React.ReactNode;
+    required?: boolean;
+    htmlFor?: string;
+    layout?: FormFieldLayout;
+    descriptionPosition?: FormFieldDescriptionPosition;
+    labelAction?: React.ReactNode;
+    requiredIndicator?: React.ReactNode;
+    errorIcon?: React.ReactNode;
+    showErrorIcon?: boolean;
+    disabled?: boolean;
+    readOnly?: boolean;
+    labelClassName?: string;
+    labelRowClassName?: string;
+    descriptionClassName?: string;
+    errorClassName?: string;
+    contentClassName?: string;
+};
+export type FormFieldShellControlProps = Pick<FormFieldShellProps, "label" | "description" | "required" | "className" | "layout" | "descriptionPosition" | "labelAction" | "requiredIndicator" | "errorIcon" | "showErrorIcon" | "disabled" | "readOnly" | "labelClassName" | "labelRowClassName" | "descriptionClassName" | "errorClassName" | "contentClassName">;
+declare function FormFieldShell({ className, label, description, error, required, htmlFor, layout, descriptionPosition, labelAction, requiredIndicator, errorIcon, showErrorIcon, disabled, readOnly, labelClassName, labelRowClassName, descriptionClassName, errorClassName, contentClassName, children, ...props }: FormFieldShellProps): React.JSX.Element;
+export { FormFieldShell };

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

@@ -0,0 +1,13 @@
+import * as React from "react";
+import { type Control, type FieldPath, type FieldValues } from "react-hook-form";
+import { type FormFieldShellControlProps } from "@/components/form/form-field-shell";
+import { Input } from "@/components/ui/input";
+export type FormInputProps<TFieldValues extends FieldValues = FieldValues, TName extends FieldPath<TFieldValues> = FieldPath<TFieldValues>> = Omit<React.ComponentProps<typeof Input>, "name" | "value" | "defaultValue"> & FormFieldShellControlProps & {
+    control: Control<TFieldValues>;
+    name: TName;
+    fieldClassName?: string;
+    transformIn?: (value: unknown) => string | number | readonly string[] | undefined;
+    transformOut?: (event: React.ChangeEvent<HTMLInputElement>) => unknown;
+};
+declare function FormInput<TFieldValues extends FieldValues = FieldValues, TName extends FieldPath<TFieldValues> = FieldPath<TFieldValues>>({ control, name, label, description, required, className, layout, descriptionPosition, labelAction, requiredIndicator, errorIcon, showErrorIcon, disabled, readOnly, labelClassName, labelRowClassName, descriptionClassName, errorClassName, contentClassName, fieldClassName, transformIn, transformOut, id, onChange, onBlur, ...props }: FormInputProps<TFieldValues, TName>): React.JSX.Element;
+export { FormInput };

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

@@ -0,0 +1,12 @@
+import { type Control, type FieldPath, type FieldValues } from "react-hook-form";
+import { type FormFieldShellProps } from "@/components/form/form-field-shell";
+import { type NumberInputProps } from "@/components/inputs/number-input";
+export type FormNumberInputProps<TFieldValues extends FieldValues = FieldValues, TName extends FieldPath<TFieldValues> = FieldPath<TFieldValues>> = Omit<NumberInputProps, "name" | "value" | "defaultValue" | "onNumberChange"> & Pick<FormFieldShellProps, "label" | "description" | "required" | "className"> & {
+    control: Control<TFieldValues>;
+    name: TName;
+    fieldClassName?: string;
+    emptyValue?: unknown;
+    onNumberChange?: (value: number | null) => void;
+};
+declare function FormNumberInput<TFieldValues extends FieldValues = FieldValues, TName extends FieldPath<TFieldValues> = FieldPath<TFieldValues>>({ control, name, label, description, required, className, fieldClassName, emptyValue, onNumberChange, ...props }: FormNumberInputProps<TFieldValues, TName>): import("react").JSX.Element;
+export { FormNumberInput };

package/dist/components/form/form-password-input.d.ts

@@ -0,0 +1,11 @@
+import { type Control, type FieldPath, type FieldValues } from "react-hook-form";
+import { type FormFieldShellProps } from "@/components/form/form-field-shell";
+import { type PasswordInputProps } from "@/components/inputs/password-input";
+export type FormPasswordInputProps<TFieldValues extends FieldValues = FieldValues, TName extends FieldPath<TFieldValues> = FieldPath<TFieldValues>> = Omit<PasswordInputProps, "name" | "value" | "defaultValue" | "onValueChange"> & Pick<FormFieldShellProps, "label" | "description" | "required" | "className"> & {
+    control: Control<TFieldValues>;
+    name: TName;
+    fieldClassName?: string;
+    onValueChange?: (value: string) => void;
+};
+declare function FormPasswordInput<TFieldValues extends FieldValues = FieldValues, TName extends FieldPath<TFieldValues> = FieldPath<TFieldValues>>({ control, name, label, description, required, className, fieldClassName, onValueChange, ...props }: FormPasswordInputProps<TFieldValues, TName>): import("react").JSX.Element;
+export { FormPasswordInput };

package/dist/components/form/form-phone-input.d.ts

@@ -0,0 +1,13 @@
+import { type Control, type FieldPath, type FieldValues } from "react-hook-form";
+import { type FormFieldShellProps } from "@/components/form/form-field-shell";
+import { type PhoneInputProps } from "@/components/inputs/phone-input";
+export type FormPhoneInputValueMode = "raw" | "masked";
+export type FormPhoneInputProps<TFieldValues extends FieldValues = FieldValues, TName extends FieldPath<TFieldValues> = FieldPath<TFieldValues>> = Omit<PhoneInputProps, "name" | "value" | "defaultValue" | "onValueChange"> & Pick<FormFieldShellProps, "label" | "description" | "required" | "className"> & {
+    control: Control<TFieldValues>;
+    name: TName;
+    fieldClassName?: string;
+    valueMode?: FormPhoneInputValueMode;
+    onValueChange?: (value: string, rawValue: string, maskedValue: string) => void;
+};
+declare function FormPhoneInput<TFieldValues extends FieldValues = FieldValues, TName extends FieldPath<TFieldValues> = FieldPath<TFieldValues>>({ control, name, label, description, required, className, fieldClassName, valueMode, countryCode, maxDigits, onValueChange, ...props }: FormPhoneInputProps<TFieldValues, TName>): import("react").JSX.Element;
+export { FormPhoneInput };

package/dist/components/form/form-search-input.d.ts

@@ -0,0 +1,11 @@
+import { type Control, type FieldPath, type FieldValues } from "react-hook-form";
+import { type FormFieldShellProps } from "@/components/form/form-field-shell";
+import { type SearchInputProps } from "@/components/inputs/search-input";
+export type FormSearchInputProps<TFieldValues extends FieldValues = FieldValues, TName extends FieldPath<TFieldValues> = FieldPath<TFieldValues>> = Omit<SearchInputProps, "name" | "value" | "defaultValue" | "onValueChange"> & Pick<FormFieldShellProps, "label" | "description" | "required" | "className"> & {
+    control: Control<TFieldValues>;
+    name: TName;
+    fieldClassName?: string;
+    onValueChange?: (value: string) => void;
+};
+declare function FormSearchInput<TFieldValues extends FieldValues = FieldValues, TName extends FieldPath<TFieldValues> = FieldPath<TFieldValues>>({ control, name, label, description, required, className, fieldClassName, onValueChange, ...props }: FormSearchInputProps<TFieldValues, TName>): import("react").JSX.Element;
+export { FormSearchInput };

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

@@ -0,0 +1,12 @@
+import { type Control, type FieldPath, type FieldValues } from "react-hook-form";
+import { type FormFieldShellControlProps } from "@/components/form/form-field-shell";
+import { type SimpleSelectProps } from "@/components/inputs/simple-select";
+export type FormSelectProps<TFieldValues extends FieldValues = FieldValues, TName extends FieldPath<TFieldValues> = FieldPath<TFieldValues>> = Omit<SimpleSelectProps, "value" | "onValueChange" | "disabled"> & FormFieldShellControlProps & {
+    control: Control<TFieldValues>;
+    name: TName;
+    fieldClassName?: string;
+    emptyValue?: unknown;
+    onValueChange?: (value: string) => void;
+};
+declare function FormSelect<TFieldValues extends FieldValues = FieldValues, TName extends FieldPath<TFieldValues> = FieldPath<TFieldValues>>({ control, name, label, description, required, className, layout, descriptionPosition, labelAction, requiredIndicator, errorIcon, showErrorIcon, disabled, readOnly, labelClassName, labelRowClassName, descriptionClassName, errorClassName, contentClassName, fieldClassName, emptyValue, onValueChange, ...props }: FormSelectProps<TFieldValues, TName>): import("react").JSX.Element;
+export { FormSelect };

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

@@ -0,0 +1,14 @@
+import * as React from "react";
+import { type Control, type FieldPath, type FieldValues } from "react-hook-form";
+import { type FormFieldShellControlProps } from "@/components/form/form-field-shell";
+import { Switch } from "@/components/ui/switch";
+export type FormSwitchLabelPlacement = "start" | "end";
+export type FormSwitchProps<TFieldValues extends FieldValues = FieldValues, TName extends FieldPath<TFieldValues> = FieldPath<TFieldValues>> = Omit<React.ComponentProps<typeof Switch>, "name" | "checked" | "defaultChecked" | "disabled"> & FormFieldShellControlProps & {
+    control: Control<TFieldValues>;
+    name: TName;
+    fieldClassName?: string;
+    labelPlacement?: FormSwitchLabelPlacement;
+    onCheckedChange?: (checked: boolean) => void;
+};
+declare function FormSwitch<TFieldValues extends FieldValues = FieldValues, TName extends FieldPath<TFieldValues> = FieldPath<TFieldValues>>({ control, name, label, description, required, className, layout, descriptionPosition, labelAction, requiredIndicator, errorIcon, showErrorIcon, disabled, readOnly, labelClassName, labelRowClassName, descriptionClassName, errorClassName, contentClassName, fieldClassName, labelPlacement, id, onCheckedChange, ...props }: FormSwitchProps<TFieldValues, TName>): React.JSX.Element;
+export { FormSwitch };

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

@@ -0,0 +1,13 @@
+import * as React from "react";
+import { type Control, type FieldPath, type FieldValues } from "react-hook-form";
+import { type FormFieldShellControlProps } from "@/components/form/form-field-shell";
+import { Textarea } from "@/components/ui/textarea";
+export type FormTextareaProps<TFieldValues extends FieldValues = FieldValues, TName extends FieldPath<TFieldValues> = FieldPath<TFieldValues>> = Omit<React.ComponentProps<typeof Textarea>, "name" | "value" | "defaultValue"> & FormFieldShellControlProps & {
+    control: Control<TFieldValues>;
+    name: TName;
+    fieldClassName?: string;
+    transformIn?: (value: unknown) => string | number | readonly string[] | undefined;
+    transformOut?: (event: React.ChangeEvent<HTMLTextAreaElement>) => unknown;
+};
+declare function FormTextarea<TFieldValues extends FieldValues = FieldValues, TName extends FieldPath<TFieldValues> = FieldPath<TFieldValues>>({ control, name, label, description, required, className, layout, descriptionPosition, labelAction, requiredIndicator, errorIcon, showErrorIcon, disabled, readOnly, labelClassName, labelRowClassName, descriptionClassName, errorClassName, contentClassName, fieldClassName, transformIn, transformOut, id, onChange, onBlur, ...props }: FormTextareaProps<TFieldValues, TName>): React.JSX.Element;
+export { FormTextarea };

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

@@ -0,0 +1,14 @@
+export * from "./form-field-shell";
+export * from "./form-input";
+export * from "./form-select";
+export * from "./form-async-select";
+export * from "./form-textarea";
+export * from "./form-switch";
+export * from "./form-search-input";
+export * from "./form-password-input";
+export * from "./form-number-input";
+export * from "./form-phone-input";
+export * from "./form-date-input";
+export * from "./form-date-range-input";
+export * from "./form-date-picker";
+export * from "./form-date-range-picker";

package/dist/components/inputs/async-select.d.ts

@@ -0,0 +1,106 @@
+import * as React from "react";
+export type AsyncSelectOption<TValue extends string = string, TData = unknown> = {
+    value: TValue;
+    label: React.ReactNode;
+    disabled?: boolean;
+    description?: React.ReactNode;
+    data?: TData;
+};
+export type AsyncSelectOptionGroup<TValue extends string = string, TData = unknown, TOption extends AsyncSelectOption<TValue, TData> = AsyncSelectOption<TValue, TData>> = {
+    label?: React.ReactNode;
+    options: TOption[];
+};
+export type AsyncSelectOptionsResult<TValue extends string = string, TData = unknown, TOption extends AsyncSelectOption<TValue, TData> = AsyncSelectOption<TValue, TData>> = TOption[] | AsyncSelectOptionGroup<TValue, TData, TOption>[];
+export type AsyncSelectRenderState<TValue extends string = string, TData = unknown, TOption extends AsyncSelectOption<TValue, TData> = AsyncSelectOption<TValue, TData>> = {
+    search: string;
+    minSearchLength: number;
+    options: TOption[];
+    selectedCount?: number;
+    maxSelected?: number;
+};
+export type AsyncSelectStateRenderer<TValue extends string = string, TData = unknown, TOption extends AsyncSelectOption<TValue, TData> = AsyncSelectOption<TValue, TData>> = (state: AsyncSelectRenderState<TValue, TData, TOption>) => React.ReactNode;
+export type AsyncSelectLabels = {
+    placeholder?: string;
+    searchPlaceholder?: string;
+    loading?: string;
+    creating?: string;
+    empty?: string;
+    error?: string;
+    clear?: string;
+    clearAll?: string;
+    selectAll?: string;
+    minSearchLength?: (minSearchLength: number) => string;
+    maxSelected?: (maxSelected: number) => string;
+    selectedCount?: (count: number) => string;
+};
+export type AsyncSelectProps<TValue extends string = string, TData = unknown, TOption extends AsyncSelectOption<TValue, TData> = AsyncSelectOption<TValue, TData>> = Omit<React.ComponentProps<"div">, "onChange"> & {
+    value?: TValue;
+    selectedOption?: TOption | null;
+    onValueChange?: (value: TValue | undefined, option?: TOption) => void;
+    loadOptions: (search: string) => Promise<AsyncSelectOptionsResult<TValue, TData, TOption>>;
+    loadSelectedOption?: (value: TValue) => Promise<TOption | null | undefined>;
+    defaultOptions?: AsyncSelectOptionsResult<TValue, TData, TOption>;
+    disabled?: boolean;
+    clearable?: boolean;
+    cacheOptions?: boolean;
+    cacheTtl?: number;
+    debounceMs?: number;
+    minSearchLength?: number;
+    labels?: AsyncSelectLabels;
+    renderOption?: (option: TOption, state: {
+        selected: boolean;
+    }) => React.ReactNode;
+    renderValue?: (option: TOption) => React.ReactNode;
+    renderLoading?: AsyncSelectStateRenderer<TValue, TData, TOption>;
+    renderEmpty?: AsyncSelectStateRenderer<TValue, TData, TOption>;
+    renderError?: AsyncSelectStateRenderer<TValue, TData, TOption>;
+    renderMinSearch?: AsyncSelectStateRenderer<TValue, TData, TOption>;
+    onCreateOption?: (search: string) => Promise<TOption> | TOption;
+    createOptionLabel?: (search: string) => React.ReactNode;
+    showCreateOption?: (search: string, options: TOption[]) => boolean;
+    triggerClassName?: string;
+    contentClassName?: string;
+    searchClassName?: string;
+    optionClassName?: string;
+};
+export type AsyncMultiSelectProps<TValue extends string = string, TData = unknown, TOption extends AsyncSelectOption<TValue, TData> = AsyncSelectOption<TValue, TData>> = Omit<React.ComponentProps<"div">, "onChange"> & {
+    value?: TValue[];
+    selectedOptions?: TOption[];
+    onValueChange?: (value: TValue[], options: TOption[]) => void;
+    loadOptions: (search: string) => Promise<AsyncSelectOptionsResult<TValue, TData, TOption>>;
+    loadSelectedOptions?: (values: TValue[]) => Promise<TOption[]>;
+    defaultOptions?: AsyncSelectOptionsResult<TValue, TData, TOption>;
+    disabled?: boolean;
+    clearable?: boolean;
+    cacheOptions?: boolean;
+    cacheTtl?: number;
+    closeOnSelect?: boolean;
+    debounceMs?: number;
+    minSearchLength?: number;
+    maxSelected?: number;
+    showSelectAll?: boolean;
+    labels?: AsyncSelectLabels;
+    renderOption?: (option: TOption, state: {
+        selected: boolean;
+    }) => React.ReactNode;
+    renderValue?: (option: TOption) => React.ReactNode;
+    renderTag?: (option: TOption, state: {
+        remove: () => void;
+    }) => React.ReactNode;
+    renderLoading?: AsyncSelectStateRenderer<TValue, TData, TOption>;
+    renderEmpty?: AsyncSelectStateRenderer<TValue, TData, TOption>;
+    renderError?: AsyncSelectStateRenderer<TValue, TData, TOption>;
+    renderMinSearch?: AsyncSelectStateRenderer<TValue, TData, TOption>;
+    renderMaxSelected?: AsyncSelectStateRenderer<TValue, TData, TOption>;
+    onCreateOption?: (search: string) => Promise<TOption> | TOption;
+    createOptionLabel?: (search: string) => React.ReactNode;
+    showCreateOption?: (search: string, options: TOption[]) => boolean;
+    triggerClassName?: string;
+    contentClassName?: string;
+    searchClassName?: string;
+    optionClassName?: string;
+    tagClassName?: string;
+};
+declare function AsyncSelect<TValue extends string = string, TData = unknown, TOption extends AsyncSelectOption<TValue, TData> = AsyncSelectOption<TValue, TData>>({ className, value, selectedOption, onValueChange, loadOptions, loadSelectedOption, defaultOptions, disabled, clearable, cacheOptions, cacheTtl, debounceMs, minSearchLength, labels, renderOption, renderValue, renderLoading, renderEmpty, renderError, renderMinSearch, onCreateOption, createOptionLabel, showCreateOption, triggerClassName, contentClassName, searchClassName, optionClassName, ...props }: AsyncSelectProps<TValue, TData, TOption>): React.JSX.Element;
+declare function AsyncMultiSelect<TValue extends string = string, TData = unknown, TOption extends AsyncSelectOption<TValue, TData> = AsyncSelectOption<TValue, TData>>({ className, value, selectedOptions, onValueChange, loadOptions, loadSelectedOptions, defaultOptions, disabled, clearable, cacheOptions, cacheTtl, closeOnSelect, debounceMs, minSearchLength, maxSelected, showSelectAll, labels, renderOption, renderValue, renderTag, renderLoading, renderEmpty, renderError, renderMinSearch, renderMaxSelected, onCreateOption, createOptionLabel, showCreateOption, triggerClassName, contentClassName, searchClassName, optionClassName, tagClassName, ...props }: AsyncMultiSelectProps<TValue, TData, TOption>): React.JSX.Element;
+export { AsyncSelect, AsyncMultiSelect };

package/dist/components/inputs/clearable-input.d.ts

@@ -0,0 +1,16 @@
+import * as React from "react";
+import { Input } from "@/components/ui/input";
+export type ClearableInputProps = Omit<React.ComponentProps<typeof Input>, "value" | "onChange"> & {
+    value?: string | number | null;
+    onChange?: React.ChangeEventHandler<HTMLInputElement>;
+    onValueChange?: (value: string) => void;
+    onClear?: () => void;
+    clearable?: boolean;
+    clearLabel?: string;
+    leadingIcon?: React.ReactNode;
+    trailing?: React.ReactNode;
+    wrapperClassName?: string;
+    inputClassName?: string;
+};
+declare const ClearableInput: React.ForwardRefExoticComponent<Omit<ClearableInputProps, "ref"> & React.RefAttributes<HTMLInputElement>>;
+export { ClearableInput };

package/dist/components/inputs/combobox.d.ts

@@ -0,0 +1,20 @@
+import * as React from "react";
+export type ComboboxOption<TValue extends string = string> = {
+    value: TValue;
+    label: React.ReactNode;
+    searchValue?: string;
+    description?: React.ReactNode;
+    disabled?: boolean;
+    hidden?: boolean;
+};
+export type ComboboxProps<TValue extends string = string> = React.ComponentProps<"div"> & {
+    value?: TValue;
+    options: ComboboxOption<TValue>[];
+    onValueChange?: (value: TValue | undefined, option?: ComboboxOption<TValue>) => void;
+    placeholder?: React.ReactNode;
+    searchPlaceholder?: string;
+    emptyLabel?: React.ReactNode;
+    disabled?: boolean;
+};
+declare function Combobox<TValue extends string = string>({ value, options, onValueChange, placeholder, searchPlaceholder, emptyLabel, disabled, className, ...props }: ComboboxProps<TValue>): React.JSX.Element;
+export { Combobox };

package/dist/components/inputs/date-input.d.ts

@@ -0,0 +1,9 @@
+import * as React from "react";
+import { Input } from "@/components/ui/input";
+export type DateInputProps = Omit<React.ComponentProps<typeof Input>, "type" | "value" | "onChange"> & {
+    value?: string | null;
+    onChange?: React.ChangeEventHandler<HTMLInputElement>;
+    onValueChange?: (value: string) => void;
+};
+declare const DateInput: React.ForwardRefExoticComponent<Omit<DateInputProps, "ref"> & React.RefAttributes<HTMLInputElement>>;
+export { DateInput };

package/dist/components/inputs/date-range-input.d.ts

@@ -0,0 +1,18 @@
+import * as React from "react";
+import { type DateInputProps } from "@/components/inputs/date-input";
+export type DateRangeValue = {
+    from?: string;
+    to?: string;
+};
+export type DateRangeInputProps = Omit<React.ComponentProps<"div">, "onChange"> & {
+    value?: DateRangeValue;
+    onValueChange?: (value: DateRangeValue) => void;
+    fromPlaceholder?: string;
+    toPlaceholder?: string;
+    fromInputProps?: Omit<DateInputProps, "value" | "onValueChange">;
+    toInputProps?: Omit<DateInputProps, "value" | "onValueChange">;
+    separator?: React.ReactNode;
+    inputClassName?: string;
+};
+declare function DateRangeInput({ className, value, onValueChange, fromPlaceholder, toPlaceholder, fromInputProps, toInputProps, separator, inputClassName, ...props }: DateRangeInputProps): React.JSX.Element;
+export { DateRangeInput };

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

@@ -0,0 +1,14 @@
+export * from "./simple-select";
+export * from "./async-select";
+export * from "./clearable-input";
+export * from "./search-input";
+export * from "./password-input";
+export * from "./number-input";
+export * from "./date-input";
+export * from "./date-range-input";
+export * from "./money-input";
+export * from "./quantity-input";
+export * from "./masked-input";
+export * from "./phone-input";
+export * from "./tag-input";
+export * from "./combobox";