azamat-ui-kit 0.1.0

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

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

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

@@ -0,0 +1,13 @@
+import * as React from "react";
+export type MoneyInputProps = Omit<React.ComponentProps<"input">, "value" | "onChange" | "type"> & {
+    value?: number | string | null;
+    onChange?: React.ChangeEventHandler<HTMLInputElement>;
+    onValueChange?: (value: number | null, rawValue: string) => void;
+    prefix?: React.ReactNode;
+    suffix?: React.ReactNode;
+    wrapperClassName?: string;
+    inputClassName?: string;
+};
+declare function parseMoneyInput(value: string): number | null;
+declare function MoneyInput({ value, onChange, onValueChange, prefix, suffix, wrapperClassName, inputClassName, className, inputMode, ...props }: MoneyInputProps): React.JSX.Element;
+export { MoneyInput, parseMoneyInput };

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

@@ -0,0 +1,16 @@
+import * as React from "react";
+import { Input } from "@/components/ui/input";
+export type NumberInputProps = Omit<React.ComponentProps<typeof Input>, "type" | "value" | "onChange" | "min" | "max" | "step"> & {
+    value?: number | string | null;
+    onChange?: React.ChangeEventHandler<HTMLInputElement>;
+    onValueChange?: (value: string) => void;
+    onNumberChange?: (value: number | null) => void;
+    min?: number;
+    max?: number;
+    step?: number;
+    allowEmpty?: boolean;
+};
+declare function parseNumberInput(value: string): number | null;
+declare function clampNumber(value: number, min?: number, max?: number): number;
+declare const NumberInput: React.ForwardRefExoticComponent<Omit<NumberInputProps, "ref"> & React.RefAttributes<HTMLInputElement>>;
+export { NumberInput, parseNumberInput, clampNumber };

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

@@ -0,0 +1,17 @@
+import * as React from "react";
+import { Input } from "@/components/ui/input";
+export type PasswordInputProps = Omit<React.ComponentProps<typeof Input>, "type" | "value" | "onChange"> & {
+    value?: string | null;
+    onChange?: React.ChangeEventHandler<HTMLInputElement>;
+    onValueChange?: (value: string) => void;
+    visible?: boolean;
+    defaultVisible?: boolean;
+    onVisibleChange?: (visible: boolean) => void;
+    showToggle?: boolean;
+    wrapperClassName?: string;
+    inputClassName?: string;
+    showLabel?: string;
+    hideLabel?: string;
+};
+declare const PasswordInput: React.ForwardRefExoticComponent<Omit<PasswordInputProps, "ref"> & React.RefAttributes<HTMLInputElement>>;
+export { PasswordInput };

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

@@ -0,0 +1,10 @@
+import * as React from "react";
+import { type MaskedInputProps } from "@/components/inputs/masked-input";
+export type PhoneInputProps = Omit<MaskedInputProps, "mask" | "unmask" | "inputMode"> & {
+    countryCode?: string;
+    maxDigits?: number;
+};
+declare function onlyDigits(value: string): string;
+declare function formatPhoneDigits(digits: string, countryCode?: string, maxDigits?: number): string;
+declare const PhoneInput: React.ForwardRefExoticComponent<Omit<PhoneInputProps, "ref"> & React.RefAttributes<HTMLInputElement>>;
+export { PhoneInput, formatPhoneDigits, onlyDigits };

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

@@ -0,0 +1,15 @@
+import * as React from "react";
+export type QuantityInputProps = Omit<React.ComponentProps<"input">, "value" | "onChange" | "type"> & {
+    value?: number | null;
+    onChange?: React.ChangeEventHandler<HTMLInputElement>;
+    onValueChange?: (value: number | null) => void;
+    min?: number;
+    max?: number;
+    step?: number;
+    showControls?: boolean;
+    wrapperClassName?: string;
+    inputClassName?: string;
+};
+declare function clampQuantity(value: number, min?: number, max?: number): number;
+declare function QuantityInput({ value, onChange, onValueChange, min, max, step, showControls, wrapperClassName, inputClassName, className, inputMode, ...props }: QuantityInputProps): React.JSX.Element;
+export { QuantityInput, clampQuantity };

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

@@ -0,0 +1,7 @@
+import * as React from "react";
+import { type ClearableInputProps } from "@/components/inputs/clearable-input";
+export type SearchInputProps = Omit<ClearableInputProps, "leadingIcon" | "type"> & {
+    searchIcon?: React.ReactNode;
+};
+declare const SearchInput: React.ForwardRefExoticComponent<Omit<SearchInputProps, "ref"> & React.RefAttributes<HTMLInputElement>>;
+export { SearchInput };

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

@@ -0,0 +1,20 @@
+import * as React from "react";
+import { Select } from "@/components/ui/select";
+export type SimpleSelectOption = {
+    label: React.ReactNode;
+    value: string;
+    disabled?: boolean;
+    description?: React.ReactNode;
+};
+export type SimpleSelectProps = Omit<React.ComponentProps<typeof Select>, "value" | "onValueChange"> & {
+    value?: string;
+    onValueChange?: (value: string) => void;
+    options: SimpleSelectOption[];
+    placeholder?: string;
+    size?: "sm" | "default";
+    triggerClassName?: string;
+    contentClassName?: string;
+    itemClassName?: string;
+};
+declare function SimpleSelect({ value, onValueChange, options, placeholder, size, triggerClassName, contentClassName, itemClassName, ...props }: SimpleSelectProps): React.JSX.Element;
+export { SimpleSelect };

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

@@ -0,0 +1,15 @@
+import * as React from "react";
+export type TagInputProps = Omit<React.ComponentProps<"div">, "onChange"> & {
+    value?: string[];
+    defaultValue?: string[];
+    onValueChange?: (value: string[]) => void;
+    placeholder?: string;
+    disabled?: boolean;
+    readOnly?: boolean;
+    maxTags?: number;
+    allowDuplicates?: boolean;
+    separators?: string[];
+    normalizeTag?: (tag: string) => string;
+};
+declare function TagInput({ value, defaultValue, onValueChange, placeholder, disabled, readOnly, maxTags, allowDuplicates, separators, normalizeTag, className, ...props }: TagInputProps): React.JSX.Element;
+export { TagInput };

package/dist/components/layout/app-header.d.ts

@@ -0,0 +1,10 @@
+import * as React from "react";
+export type AppHeaderProps = React.ComponentProps<"header"> & {
+    left?: React.ReactNode;
+    center?: React.ReactNode;
+    right?: React.ReactNode;
+    sticky?: boolean;
+    heightClassName?: string;
+};
+declare function AppHeader({ className, left, center, right, sticky, heightClassName, children, ...props }: AppHeaderProps): React.JSX.Element;
+export { AppHeader };

package/dist/components/layout/app-shell.d.ts

@@ -0,0 +1,32 @@
+import * as React from "react";
+export type AppShellSidebarWidth = "sm" | "default" | "lg" | "xl";
+export type AppShellAsideWidth = "sm" | "default" | "lg";
+export type AppShellProps = React.ComponentProps<"div"> & {
+    header?: React.ReactNode;
+    sidebar?: React.ReactNode;
+    aside?: React.ReactNode;
+    footer?: React.ReactNode;
+    sidebarCollapsed?: boolean;
+    defaultSidebarCollapsed?: boolean;
+    onSidebarCollapsedChange?: (collapsed: boolean) => void;
+    mobileSidebarOpen?: boolean;
+    defaultMobileSidebarOpen?: boolean;
+    onMobileSidebarOpenChange?: (open: boolean) => void;
+    sidebarWidth?: AppShellSidebarWidth;
+    asideWidth?: AppShellAsideWidth;
+    sidebarMode?: "fixed" | "static";
+    mobileSidebar?: React.ReactNode;
+    mobileOverlay?: boolean;
+    collapseBreakpoint?: "sm" | "md" | "lg" | "xl";
+    showMobileMenuButton?: boolean;
+    mobileMenuLabel?: string;
+    mobileCloseLabel?: string;
+    contentClassName?: string;
+    mainClassName?: string;
+    mainWrapperClassName?: string;
+    sidebarClassName?: string;
+    mobileSidebarClassName?: string;
+    asideClassName?: string;
+};
+declare function AppShell({ className, header, sidebar, aside, footer, sidebarCollapsed, defaultSidebarCollapsed, onSidebarCollapsedChange, mobileSidebarOpen, defaultMobileSidebarOpen, onMobileSidebarOpenChange, sidebarWidth, asideWidth, sidebarMode, mobileSidebar, mobileOverlay, showMobileMenuButton, mobileMenuLabel, mobileCloseLabel, contentClassName, mainClassName, mainWrapperClassName, sidebarClassName, mobileSidebarClassName, asideClassName, children, ...props }: AppShellProps): React.JSX.Element;
+export { AppShell };

package/dist/components/layout/app-sidebar.d.ts

@@ -0,0 +1,28 @@
+import * as React from "react";
+export type AppSidebarNavItem = {
+    key: string;
+    label: React.ReactNode;
+    icon?: React.ReactNode;
+    href?: string;
+    active?: boolean;
+    disabled?: boolean;
+    badge?: React.ReactNode;
+    hidden?: boolean;
+    onSelect?: () => void;
+};
+export type AppSidebarProps = React.ComponentProps<"aside"> & {
+    header?: React.ReactNode;
+    footer?: React.ReactNode;
+    items?: AppSidebarNavItem[];
+    collapsed?: boolean;
+    onItemSelect?: (item: AppSidebarNavItem) => void;
+    renderItem?: (item: AppSidebarNavItem, state: {
+        collapsed: boolean;
+    }) => React.ReactNode;
+    renderLink?: (props: React.ComponentProps<"a"> & {
+        item: AppSidebarNavItem;
+        [key: `data-${string}`]: string | boolean | undefined;
+    }) => React.ReactNode;
+};
+declare function AppSidebar({ className, header, footer, items, collapsed, onItemSelect, renderItem, renderLink, children, ...props }: AppSidebarProps): React.JSX.Element;
+export { AppSidebar };

package/dist/components/layout/breadcrumbs.d.ts

@@ -0,0 +1,18 @@
+import * as React from "react";
+export type BreadcrumbItem = {
+    key: string;
+    label: React.ReactNode;
+    href?: string;
+    current?: boolean;
+    onSelect?: () => void;
+};
+export type BreadcrumbsProps = React.ComponentProps<"nav"> & {
+    items: BreadcrumbItem[];
+    separator?: React.ReactNode;
+    renderLink?: (props: React.ComponentProps<"a"> & {
+        item: BreadcrumbItem;
+        [key: `data-${string}`]: string | boolean | undefined;
+    }) => React.ReactNode;
+};
+declare function Breadcrumbs({ className, items, separator, renderLink, ...props }: BreadcrumbsProps): React.JSX.Element;
+export { Breadcrumbs };

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

@@ -0,0 +1,8 @@
+export * from "./app-shell";
+export * from "./app-header";
+export * from "./app-sidebar";
+export * from "./page-header";
+export * from "./stat-card";
+export * from "./sidebar-nav";
+export * from "./breadcrumbs";
+export * from "./page-container";

package/dist/components/layout/page-container.d.ts

@@ -0,0 +1,7 @@
+import * as React from "react";
+export type PageContainerSize = "default" | "sm" | "md" | "lg" | "xl" | "full";
+export type PageContainerProps = React.ComponentProps<"div"> & {
+    size?: PageContainerSize;
+};
+declare function PageContainer({ className, size, ...props }: PageContainerProps): React.JSX.Element;
+export { PageContainer };

package/dist/components/layout/page-header.d.ts

@@ -0,0 +1,12 @@
+import * as React from "react";
+export type PageHeaderProps = React.ComponentProps<"div"> & {
+    title?: React.ReactNode;
+    description?: React.ReactNode;
+    eyebrow?: React.ReactNode;
+    breadcrumbs?: React.ReactNode;
+    actions?: React.ReactNode;
+    meta?: React.ReactNode;
+    sticky?: boolean;
+};
+declare function PageHeader({ className, title, description, eyebrow, breadcrumbs, actions, meta, sticky, children, ...props }: PageHeaderProps): React.JSX.Element;
+export { PageHeader };

package/dist/components/layout/sidebar-nav.d.ts

@@ -0,0 +1,25 @@
+import * as React from "react";
+export type SidebarNavItem = {
+    key: string;
+    label: React.ReactNode;
+    icon?: React.ReactNode;
+    badge?: React.ReactNode;
+    href?: string;
+    active?: boolean;
+    disabled?: boolean;
+    hidden?: boolean;
+    onSelect?: () => void;
+};
+export type SidebarNavProps = React.ComponentProps<"nav"> & {
+    items: SidebarNavItem[];
+    collapsed?: boolean;
+    itemClassName?: string;
+    activeItemClassName?: string;
+    renderItem?: (item: SidebarNavItem, element: React.ReactNode) => React.ReactNode;
+    renderLink?: (props: React.ComponentProps<"a"> & {
+        item: SidebarNavItem;
+        [key: `data-${string}`]: string | boolean | undefined;
+    }) => React.ReactNode;
+};
+declare function SidebarNav({ className, items, collapsed, itemClassName, activeItemClassName, renderItem, renderLink, ...props }: SidebarNavProps): React.JSX.Element;
+export { SidebarNav };

package/dist/components/layout/stat-card.d.ts

@@ -0,0 +1,18 @@
+import * as React from "react";
+import { Card } from "@/components/ui/card";
+export type StatCardTrend = {
+    value: React.ReactNode;
+    tone?: "success" | "warning" | "danger" | "muted" | "default";
+};
+export type StatCardProps = React.ComponentProps<typeof Card> & {
+    title?: React.ReactNode;
+    value?: React.ReactNode;
+    description?: React.ReactNode;
+    icon?: React.ReactNode;
+    action?: React.ReactNode;
+    trend?: StatCardTrend;
+    footer?: React.ReactNode;
+    contentClassName?: string;
+};
+declare function StatCard({ className, title, value, description, icon, action, trend, footer, contentClassName, ...props }: StatCardProps): React.JSX.Element;
+export { StatCard };

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

@@ -0,0 +1,3 @@
+export * from "./pagination";
+export * from "./page-tabs";
+export * from "./stepper-tabs";

package/dist/components/navigation/page-tabs.d.ts

@@ -0,0 +1,18 @@
+import * as React from "react";
+export type PageTabItem<TValue extends string = string> = {
+    value: TValue;
+    label: React.ReactNode;
+    icon?: React.ReactNode;
+    badge?: React.ReactNode;
+    disabled?: boolean;
+    hidden?: boolean;
+};
+export type PageTabsProps<TValue extends string = string> = React.ComponentProps<"div"> & {
+    value?: TValue;
+    items: PageTabItem<TValue>[];
+    onValueChange?: (value: TValue, item: PageTabItem<TValue>) => void;
+    variant?: "underline" | "pills" | "cards";
+    size?: "sm" | "default";
+};
+declare function PageTabs<TValue extends string = string>({ value, items, onValueChange, variant, size, className, ...props }: PageTabsProps<TValue>): React.JSX.Element;
+export { PageTabs };

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

@@ -0,0 +1,21 @@
+import * as React from "react";
+export type PaginationItem = number | "ellipsis";
+export type PaginationLabels = {
+    first?: string;
+    previous?: string;
+    next?: string;
+    last?: string;
+    page?: (page: number) => string;
+};
+export type PaginationProps = Omit<React.ComponentProps<"nav">, "onChange"> & {
+    page: number;
+    pageCount: number;
+    onPageChange: (page: number) => void;
+    siblingCount?: number;
+    showEdges?: boolean;
+    disabled?: boolean;
+    labels?: PaginationLabels;
+};
+declare function getPaginationItems(page: number, pageCount: number, siblingCount?: number): PaginationItem[];
+declare function Pagination({ className, page, pageCount, onPageChange, siblingCount, showEdges, disabled, labels, ...props }: PaginationProps): React.JSX.Element;
+export { Pagination, getPaginationItems };

package/dist/components/navigation/stepper-tabs.d.ts

@@ -0,0 +1,19 @@
+import * as React from "react";
+export type StepperTabItem<TValue extends string = string> = {
+    value: TValue;
+    label: React.ReactNode;
+    description?: React.ReactNode;
+    icon?: React.ReactNode;
+    completed?: boolean;
+    disabled?: boolean;
+    hidden?: boolean;
+};
+export type StepperTabsProps<TValue extends string = string> = React.ComponentProps<"div"> & {
+    value?: TValue;
+    items: StepperTabItem<TValue>[];
+    onValueChange?: (value: TValue, item: StepperTabItem<TValue>) => void;
+    orientation?: "horizontal" | "vertical";
+    compact?: boolean;
+};
+declare function StepperTabs<TValue extends string = string>({ value, items, onValueChange, orientation, compact, className, ...props }: StepperTabsProps<TValue>): React.JSX.Element;
+export { StepperTabs };

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

@@ -0,0 +1 @@
+export * from "./toast";

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

@@ -0,0 +1,42 @@
+import * as React from "react";
+export type ToastTone = "default" | "success" | "info" | "warning" | "danger" | "loading";
+export type ToastItem = {
+    id: string;
+    title?: React.ReactNode;
+    description?: React.ReactNode;
+    tone?: ToastTone;
+    action?: React.ReactNode;
+    duration?: number;
+    dismissible?: boolean;
+};
+export type CreateToastInput = Omit<ToastItem, "id"> & {
+    id?: string;
+};
+export type ToastShortcutInput = React.ReactNode | CreateToastInput;
+export type ToastPromiseMessages<TData = unknown> = {
+    loading: ToastShortcutInput;
+    success: ToastShortcutInput | ((data: TData) => ToastShortcutInput);
+    error: ToastShortcutInput | ((error: unknown) => ToastShortcutInput);
+};
+export type ToastContextValue = {
+    toasts: ToastItem[];
+    addToast: (toast: CreateToastInput) => string;
+    updateToast: (id: string, toast: Partial<Omit<ToastItem, "id">>) => void;
+    dismissToast: (id: string) => void;
+    clearToasts: () => void;
+    success: (toast: ToastShortcutInput) => string;
+    info: (toast: ToastShortcutInput) => string;
+    warning: (toast: ToastShortcutInput) => string;
+    error: (toast: ToastShortcutInput) => string;
+    loading: (toast: ToastShortcutInput) => string;
+    promise: <TData>(promise: Promise<TData>, messages: ToastPromiseMessages<TData>) => Promise<TData>;
+};
+export type ToastProviderProps = React.PropsWithChildren<{
+    defaultDuration?: number;
+    maxToasts?: number;
+    pauseOnHover?: boolean;
+    position?: "top-right" | "top-left" | "bottom-right" | "bottom-left" | "top-center" | "bottom-center";
+}>;
+declare function ToastProvider({ children, defaultDuration, maxToasts, pauseOnHover, position, }: ToastProviderProps): React.JSX.Element;
+declare function useToast(): ToastContextValue;
+export { ToastProvider, useToast };

package/dist/components/overlay/confirm-dialog.d.ts

@@ -0,0 +1,17 @@
+import * as React from "react";
+import { DialogActionButton } from "@/components/overlay/dialog-actions";
+import { type ModalShellProps } from "@/components/overlay/modal-shell";
+type ConfirmVariant = React.ComponentProps<typeof DialogActionButton>["variant"];
+type ConfirmDialogProps = Omit<ModalShellProps, "footer"> & {
+    cancelText?: React.ReactNode;
+    confirmText?: React.ReactNode;
+    confirmVariant?: ConfirmVariant;
+    confirmDisabled?: boolean;
+    cancelDisabled?: boolean;
+    isLoading?: boolean;
+    onCancel?: () => void;
+    onConfirm?: () => void;
+};
+declare function ConfirmDialog({ cancelText, confirmText, confirmVariant, confirmDisabled, cancelDisabled, isLoading, onCancel, onConfirm, onOpenChange, ...props }: ConfirmDialogProps): React.JSX.Element;
+export { ConfirmDialog };
+export type { ConfirmDialogProps };

package/dist/components/overlay/dialog-actions.d.ts

@@ -0,0 +1,14 @@
+import * as React from "react";
+import { Button } from "@/components/ui/button";
+type DialogActionsAlign = "start" | "center" | "end" | "between";
+export type DialogActionButtonProps = React.ComponentProps<typeof Button> & {
+    isLoading?: boolean;
+    loadingLabel?: React.ReactNode;
+};
+export type DialogActionsProps = React.ComponentProps<"div"> & {
+    align?: DialogActionsAlign;
+    stackOnMobile?: boolean;
+};
+declare function DialogActionButton({ children, disabled, isLoading, loadingLabel, className, ...props }: DialogActionButtonProps): React.JSX.Element;
+declare function DialogActions({ className, align, stackOnMobile, ...props }: DialogActionsProps): React.JSX.Element;
+export { DialogActions, DialogActionButton };

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

@@ -0,0 +1,4 @@
+export * from "./dialog-actions";
+export * from "./modal-shell";
+export * from "./confirm-dialog";
+export * from "./sheet-shell";

package/dist/components/overlay/modal-shell.d.ts

@@ -0,0 +1,20 @@
+import * as React from "react";
+type ModalShellSize = "sm" | "md" | "lg" | "xl" | "full";
+export type ModalShellProps = {
+    open?: boolean;
+    defaultOpen?: boolean;
+    onOpenChange?: (open: boolean) => void;
+    trigger?: React.ReactNode;
+    title?: React.ReactNode;
+    description?: React.ReactNode;
+    children?: React.ReactNode;
+    footer?: React.ReactNode;
+    size?: ModalShellSize;
+    showCloseButton?: boolean;
+    contentClassName?: string;
+    headerClassName?: string;
+    bodyClassName?: string;
+};
+declare function ModalShell({ open, defaultOpen, onOpenChange, trigger, title, description, children, footer, size, showCloseButton, contentClassName, headerClassName, bodyClassName, }: ModalShellProps): React.JSX.Element;
+export { ModalShell };
+export type { ModalShellSize };

package/dist/components/overlay/sheet-shell.d.ts

@@ -0,0 +1,34 @@
+import * as React from "react";
+import { Dialog as DialogPrimitive } from "@base-ui/react/dialog";
+type SheetSide = "top" | "right" | "bottom" | "left";
+type SheetShellProps = {
+    open?: boolean;
+    defaultOpen?: boolean;
+    onOpenChange?: (open: boolean) => void;
+    trigger?: React.ReactNode;
+    title?: React.ReactNode;
+    description?: React.ReactNode;
+    children?: React.ReactNode;
+    footer?: React.ReactNode;
+    side?: SheetSide;
+    showCloseButton?: boolean;
+    contentClassName?: string;
+    headerClassName?: string;
+    bodyClassName?: string;
+};
+declare const Sheet: typeof DialogPrimitive.Root;
+declare function SheetTrigger({ ...props }: DialogPrimitive.Trigger.Props): React.JSX.Element;
+declare function SheetPortal({ ...props }: DialogPrimitive.Portal.Props): React.JSX.Element;
+declare function SheetClose({ ...props }: DialogPrimitive.Close.Props): React.JSX.Element;
+declare function SheetOverlay({ className, ...props }: DialogPrimitive.Backdrop.Props): React.JSX.Element;
+declare function SheetContent({ className, children, side, showCloseButton, ...props }: DialogPrimitive.Popup.Props & {
+    side?: SheetSide;
+    showCloseButton?: boolean;
+}): React.JSX.Element;
+declare function SheetHeader({ className, ...props }: React.ComponentProps<"div">): React.JSX.Element;
+declare function SheetFooter({ className, ...props }: React.ComponentProps<"div">): React.JSX.Element;
+declare function SheetTitle({ className, ...props }: DialogPrimitive.Title.Props): React.JSX.Element;
+declare function SheetDescription({ className, ...props }: DialogPrimitive.Description.Props): React.JSX.Element;
+declare function SheetShell({ open, defaultOpen, onOpenChange, trigger, title, description, children, footer, side, showCloseButton, contentClassName, headerClassName, bodyClassName, }: SheetShellProps): React.JSX.Element;
+export { Sheet, SheetClose, SheetContent, SheetDescription, SheetFooter, SheetHeader, SheetOverlay, SheetPortal, SheetShell, SheetTitle, SheetTrigger, };
+export type { SheetShellProps, SheetSide };

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

@@ -0,0 +1,23 @@
+import type { FieldPath, FieldValues } from "react-hook-form";
+import type { FormBuilderAsyncSelectField, FormBuilderCustomField, FormBuilderDateField, FormBuilderDateRangeField, FormBuilderInputField, FormBuilderNumberField, FormBuilderPhoneField, FormBuilderSection, FormBuilderSelectField, FormBuilderSwitchField, FormBuilderTextareaField } from "./form-builder";
+type FieldBase = {
+    id: string;
+    hidden?: boolean;
+    className?: string;
+    colSpan?: 1 | 2 | 3 | 4 | "full";
+};
+type FieldPresetOptions<TProps> = FieldBase & {
+    props: TProps;
+};
+declare function inputField<TFieldValues extends FieldValues, TName extends FieldPath<TFieldValues> = FieldPath<TFieldValues>>(options: FieldPresetOptions<FormBuilderInputField<TFieldValues, TName>["props"]>): FormBuilderInputField<TFieldValues, TName>;
+declare function textareaField<TFieldValues extends FieldValues, TName extends FieldPath<TFieldValues> = FieldPath<TFieldValues>>(options: FieldPresetOptions<FormBuilderTextareaField<TFieldValues, TName>["props"]>): FormBuilderTextareaField<TFieldValues, TName>;
+declare function selectField<TFieldValues extends FieldValues, TName extends FieldPath<TFieldValues> = FieldPath<TFieldValues>>(options: FieldPresetOptions<FormBuilderSelectField<TFieldValues, TName>["props"]>): FormBuilderSelectField<TFieldValues, TName>;
+declare function asyncSelectField<TFieldValues extends FieldValues, TName extends FieldPath<TFieldValues> = FieldPath<TFieldValues>>(options: FieldPresetOptions<FormBuilderAsyncSelectField<TFieldValues, TName>["props"]>): FormBuilderAsyncSelectField<TFieldValues, TName>;
+declare function switchField<TFieldValues extends FieldValues, TName extends FieldPath<TFieldValues> = FieldPath<TFieldValues>>(options: FieldPresetOptions<FormBuilderSwitchField<TFieldValues, TName>["props"]>): FormBuilderSwitchField<TFieldValues, TName>;
+declare function numberField<TFieldValues extends FieldValues, TName extends FieldPath<TFieldValues> = FieldPath<TFieldValues>>(options: FieldPresetOptions<FormBuilderNumberField<TFieldValues, TName>["props"]>): FormBuilderNumberField<TFieldValues, TName>;
+declare function phoneField<TFieldValues extends FieldValues, TName extends FieldPath<TFieldValues> = FieldPath<TFieldValues>>(options: FieldPresetOptions<FormBuilderPhoneField<TFieldValues, TName>["props"]>): FormBuilderPhoneField<TFieldValues, TName>;
+declare function dateField<TFieldValues extends FieldValues, TName extends FieldPath<TFieldValues> = FieldPath<TFieldValues>>(options: FieldPresetOptions<FormBuilderDateField<TFieldValues, TName>["props"]>): FormBuilderDateField<TFieldValues, TName>;
+declare function dateRangeField<TFieldValues extends FieldValues, TFromName extends FieldPath<TFieldValues> = FieldPath<TFieldValues>, TToName extends FieldPath<TFieldValues> = FieldPath<TFieldValues>>(options: FieldPresetOptions<FormBuilderDateRangeField<TFieldValues, TFromName, TToName>["props"]>): FormBuilderDateRangeField<TFieldValues, TFromName, TToName>;
+declare function customField<TFieldValues extends FieldValues>(options: FieldBase & Pick<FormBuilderCustomField<TFieldValues>, "render">): FormBuilderCustomField<TFieldValues>;
+declare function formSection<TFieldValues extends FieldValues>(section: FormBuilderSection<TFieldValues>): FormBuilderSection<TFieldValues>;
+export { asyncSelectField, customField, dateField, dateRangeField, formSection, inputField, numberField, phoneField, selectField, switchField, textareaField, };