@nxgt/material 1.0.0

package/dist/lib/components/ui/filter/filter-validation.utils.d.ts

@@ -0,0 +1,48 @@
+import { FilterField, FilterSchema, FilterValidationErrors, FilterValidationRule, FilterValue, FilterValues } from './types';
+/**
+ * Validate a single filter value against its validation rules
+ */
+export declare function validateFilterValue(field: FilterField, value: FilterValue): string | null;
+/**
+ * Validate all filter values against their schema
+ */
+export declare function validateAllFilters(schema: FilterSchema, values: FilterValues): FilterValidationErrors;
+/**
+ * Validate a single field and return error
+ */
+export declare function validateField(schema: FilterSchema, fieldId: string, values: FilterValues): string | null;
+/**
+ * Check if there are any validation errors
+ */
+export declare function hasValidationErrors(errors: FilterValidationErrors): boolean;
+/**
+ * Get validation error for a specific field
+ */
+export declare function getValidationError(errors: FilterValidationErrors, fieldId: string): string | undefined;
+/**
+ * Create a validation rule helper
+ */
+export declare function createValidationRule(rule: Partial<FilterValidationRule>): FilterValidationRule;
+/**
+ * Common validation patterns
+ */
+export declare const VALIDATION_PATTERNS: {
+    readonly EMAIL: RegExp;
+    readonly URL: RegExp;
+    readonly PHONE: RegExp;
+    readonly ZIP_CODE: RegExp;
+    readonly ALPHANUMERIC: RegExp;
+    readonly NUMERIC: RegExp;
+};
+/**
+ * Common validation rule presets
+ */
+export declare const VALIDATION_PRESETS: {
+    readonly required: () => FilterValidationRule;
+    readonly email: () => FilterValidationRule;
+    readonly url: () => FilterValidationRule;
+    readonly phone: () => FilterValidationRule;
+    readonly positiveNumber: () => FilterValidationRule;
+    readonly percentage: () => FilterValidationRule;
+    readonly range: (min: number, max: number) => FilterValidationRule;
+};

package/dist/lib/components/ui/filter/filter-validation.utils.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/lib/components/ui/filter/filter-value.utils.d.ts

@@ -0,0 +1,29 @@
+import { FilterField, FilterValue, FilterValues } from './types';
+/**
+ * Check if a filter value is empty/falsy
+ */
+export declare function isFilterValueEmpty(value: FilterValue): boolean;
+/**
+ * Count the number of active (non-empty) filters
+ */
+export declare function countActiveFilters(values: FilterValues): number;
+/**
+ * Check if any filters are active
+ */
+export declare function hasActiveFilters(values: FilterValues): boolean;
+/**
+ * Check if two filter values are equal
+ */
+export declare function areFilterValuesEqual(value1: FilterValue, value2: FilterValue): boolean;
+/**
+ * Check if filter values have changed
+ */
+export declare function haveFiltersChanged(values1: FilterValues, values2: FilterValues): boolean;
+/**
+ * Remove empty values from filter values
+ */
+export declare function cleanFilterValues(values: FilterValues): FilterValues;
+/**
+ * Format filter value for display
+ */
+export declare function formatFilterValue(field: FilterField, value: FilterValue): string;

package/dist/lib/components/ui/filter/filter-value.utils.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/lib/components/ui/filter/filter.d.ts

@@ -0,0 +1,59 @@
+import { ReactNode } from 'react';
+import { FilterProviderProps } from './filter-context';
+import { FilterVariant } from './types';
+export type FilterProps = Omit<FilterProviderProps, 'children'> & {
+    variant?: FilterVariant;
+    showActions?: boolean;
+    contentClassName?: string;
+    actionsClassName?: string;
+    trigger?: ReactNode;
+    title?: string;
+    description?: string;
+    triggerLabel?: string;
+    showTriggerCount?: boolean;
+    side?: 'top' | 'right' | 'bottom' | 'left';
+    direction?: 'top' | 'bottom' | 'left' | 'right';
+    align?: 'start' | 'center' | 'end';
+    popoverSide?: 'top' | 'right' | 'bottom' | 'left';
+    className?: string;
+};
+/**
+ * Filter - Unified filter component with multiple layout variants
+ *
+ * Provides a single interface for all filter layout patterns:
+ * - `dialog`: Modal popup (default) - Best for desktop, full-featured filtering
+ * - `sheet`: Side sheet - Desktop-focused, persistent filtering panel
+ * - `drawer`: Bottom drawer - Mobile-friendly, swipe-up interface
+ * - `popover`: Compact dropdown - Space-efficient, table/list filtering
+ * - `inline`: Embedded - Direct page integration, no trigger needed
+ *
+ * @example
+ * ```tsx
+ * // Dialog variant (default)
+ * <Filter schema={filterSchema} onApply={handleApply} />
+ *
+ * // Inline variant with live updates
+ * <Filter
+ *   variant="inline"
+ *   schema={filterSchema}
+ *   liveUpdate
+ *   onChange={handleChange}
+ * />
+ *
+ * // Popover variant for compact spaces
+ * <Filter
+ *   variant="popover"
+ *   schema={filterSchema}
+ *   triggerLabel="Filter results"
+ * />
+ *
+ * // Sheet variant with custom trigger
+ * <Filter
+ *   variant="sheet"
+ *   schema={filterSchema}
+ *   side="right"
+ *   trigger={<CustomButton />}
+ * />
+ * ```
+ */
+export declare function Filter({ variant, schema, values, defaultValues, onChange, onApply, onReset, persistence, presetConfig, liveUpdate, disabled, showActions, contentClassName, actionsClassName, trigger, title, description, triggerLabel, showTriggerCount, side, direction, align, popoverSide, className, }: FilterProps): import("react").JSX.Element;

package/dist/lib/components/ui/filter/filter.utils.d.ts

@@ -0,0 +1,3 @@
+export * from './filter-preset.utils';
+export * from './filter-schema.utils';
+export * from './filter-value.utils';

package/dist/lib/components/ui/filter/filter.utils.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/lib/components/ui/filter/forms/filter-form-field.d.ts

@@ -0,0 +1,52 @@
+import { Control, Path } from 'react-hook-form';
+import { FilterSchema, FilterVariant } from '../types';
+export type FilterFormFieldProps<T extends Record<string, any>> = {
+    control: Control<T>;
+    name: Path<T>;
+    schema: FilterSchema;
+    variant?: FilterVariant;
+    disabled?: boolean;
+    showActions?: boolean;
+    contentClassName?: string;
+    actionsClassName?: string;
+    trigger?: React.ReactNode;
+    title?: string;
+    description?: string;
+    triggerLabel?: string;
+    showTriggerCount?: boolean;
+    side?: 'top' | 'right' | 'bottom' | 'left';
+    liveUpdate?: boolean;
+    className?: string;
+};
+/**
+ * FilterFormField - React Hook Form integration for Filter component
+ *
+ * Provides seamless integration between Filter components and React Hook Form,
+ * supporting all filter variants (inline, dialog, sheet, drawer, popover).
+ *
+ * @example
+ * ```tsx
+ * import { useForm } from 'react-hook-form';
+ * import { FilterFormField } from '@/components/ui/filter';
+ *
+ * function MyForm() {
+ *   const { control, handleSubmit } = useForm({
+ *     defaultValues: {
+ *       filters: {}
+ *     }
+ *   });
+ *
+ *   return (
+ *     <form onSubmit={handleSubmit(console.log)}>
+ *       <FilterFormField
+ *         control={control}
+ *         name="filters"
+ *         schema={filterSchema}
+ *         variant="dialog"
+ *       />
+ *     </form>
+ *   );
+ * }
+ * ```
+ */
+export declare function FilterFormField<T extends Record<string, any>>({ control, name, schema, variant, disabled, showActions, contentClassName, actionsClassName, trigger, title, description, triggerLabel, showTriggerCount, side, liveUpdate, className, }: FilterFormFieldProps<T>): import("react").JSX.Element;

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

@@ -0,0 +1,21 @@
+export * from './consts';
+export type { FilterActions as FilterActionsType, FilterBaseProps, FilterChipsProps, FilterContextValue, FilterCustomStorage, FilterField as FilterFieldSchema, FilterFieldRenderFunction, FilterGroup as FilterGroupSchema, FilterGroupState, FilterOption, FilterPersistenceConfig, FilterPersistenceStrategy, FilterPreset, FilterPresetConfig, FilterPresetsProps, FilterSchema, FilterState, FilterTriggerProps, FilterType, FilterUrlParamsConfig, FilterValidationError, FilterValidationErrors, FilterValidationRule, FilterValue, FilterValues, FilterVariant, } from './types';
+export * from './filter-context';
+export * from './use-filter';
+export * from './use-filter-selector';
+export * from './filter.utils';
+export * from './filter-persistence.utils';
+export * from './filter-validation.utils';
+export { FilterActions, type FilterActionsProps } from './filter-actions';
+export * from './filter-chips';
+export * from './filter-content';
+export { FilterField, type FilterFieldProps } from './filter-field';
+export { FilterGroup, type FilterGroupProps, FilterGroups, } from './filter-groups';
+export * from './filter-presets';
+export { Filter, type FilterProps } from './filter';
+export * from './filter-dialog';
+export * from './filter-drawer';
+export * from './filter-inline';
+export * from './filter-popover';
+export * from './filter-sheet';
+export * from './forms/filter-form-field';

package/dist/lib/components/ui/filter/types.d.ts

@@ -0,0 +1,293 @@
+import { ReactNode } from 'react';
+/**
+ * Available filter field types
+ */
+export type FilterType = 'text' | 'number' | 'select' | 'multi-select' | 'date' | 'date-range' | 'number-range' | 'checkbox-group' | 'radio-group' | 'chips-multiple' | 'chips-single' | 'slider' | 'slider-range' | 'switch' | 'custom';
+/**
+ * Filter component layout variants
+ */
+export type FilterVariant = 'inline' | 'dialog' | 'sheet' | 'drawer' | 'popover';
+/**
+ * Option for select, multi-select, checkbox-group, and radio-group filters
+ */
+export type FilterOption = {
+    label: string;
+    value: string | number;
+    description?: string;
+    icon?: ReactNode;
+    disabled?: boolean;
+};
+/**
+ * Filter field value types
+ */
+export type FilterValue = string | number | boolean | string[] | number[] | {
+    min?: number;
+    max?: number;
+} | {
+    start?: Date | string;
+    end?: Date | string;
+} | Date | null | undefined;
+/**
+ * Record of filter values keyed by field ID
+ */
+export type FilterValues = Record<string, FilterValue>;
+/**
+ * Validation rule for a filter field
+ */
+export type FilterValidationRule = {
+    required?: boolean;
+    min?: number;
+    max?: number;
+    minLength?: number;
+    maxLength?: number;
+    pattern?: RegExp;
+    custom?: (value: FilterValue) => string | null | undefined;
+    minLessThanMax?: boolean;
+    minRequired?: boolean;
+    maxRequired?: boolean;
+};
+/**
+ * Validation error for a filter field
+ */
+export type FilterValidationError = {
+    field: string;
+    message: string;
+};
+/**
+ * Validation errors keyed by field ID
+ */
+export type FilterValidationErrors = Record<string, string>;
+/**
+ * Custom render function for filter fields
+ */
+export type FilterFieldRenderFunction = (props: {
+    value: FilterValue;
+    onChange: (value: FilterValue) => void;
+    onBlur?: () => void;
+    error?: string;
+    disabled?: boolean;
+}) => ReactNode;
+/**
+ * Filter field configuration
+ */
+export type FilterField = {
+    id: string;
+    type: FilterType;
+    label: string;
+    description?: string;
+    placeholder?: string;
+    className?: string;
+    icon?: ReactNode;
+    defaultValue?: FilterValue;
+    validation?: FilterValidationRule;
+    disabled?: boolean;
+    options?: FilterOption[];
+    min?: number;
+    max?: number;
+    step?: number;
+    maxLength?: number;
+    minDate?: Date | string;
+    maxDate?: Date | string;
+    collapsible?: boolean;
+    defaultExpanded?: boolean;
+    searchable?: boolean;
+    render?: FilterFieldRenderFunction;
+    visibleWhen?: (values: FilterValues) => boolean;
+    separator?: 'before' | 'after';
+};
+/**
+ * Filter group configuration
+ */
+export type FilterGroup = {
+    id: string;
+    label: string;
+    description?: string;
+    icon?: ReactNode;
+    collapsible?: boolean;
+    defaultExpanded?: boolean;
+    fields: string[];
+};
+/**
+ * Complete filter schema with fields and optional groups
+ */
+export type FilterSchema = {
+    fields: FilterField[];
+    groups?: FilterGroup[];
+};
+/**
+ * Storage strategy for filter persistence
+ */
+export type FilterPersistenceStrategy = 'localStorage' | 'sessionStorage' | 'url' | 'custom';
+/**
+ * URL params configuration
+ */
+export type FilterUrlParamsConfig = {
+    enabled: boolean;
+    prefix?: string;
+    parseUrl?: (searchParams: URLSearchParams) => FilterValues;
+    serializeUrl?: (values: FilterValues) => URLSearchParams;
+};
+/**
+ * Custom storage implementation
+ */
+export type FilterCustomStorage = {
+    save: (values: FilterValues) => void | Promise<void>;
+    load: () => FilterValues | Promise<FilterValues> | null;
+    clear: () => void | Promise<void>;
+};
+/**
+ * Filter persistence configuration
+ */
+export type FilterPersistenceConfig = {
+    enabled: boolean;
+    strategy: FilterPersistenceStrategy;
+    storageKey?: string;
+    version?: number;
+    urlParams?: FilterUrlParamsConfig;
+    customStorage?: FilterCustomStorage;
+};
+/**
+ * Filter preset
+ */
+export type FilterPreset = {
+    id: string;
+    name: string;
+    description?: string;
+    icon?: ReactNode;
+    values: FilterValues;
+    isDefault?: boolean;
+    createdAt: Date | string;
+    updatedAt?: Date | string;
+};
+/**
+ * Preset configuration
+ */
+export type FilterPresetConfig = {
+    enabled: boolean;
+    storage?: 'localStorage' | 'sessionStorage' | 'custom';
+    storageKey?: string;
+    maxPresets?: number;
+    customStorage?: {
+        save: (presets: FilterPreset[]) => void | Promise<void>;
+        load: () => FilterPreset[] | Promise<FilterPreset[]> | null;
+        clear: () => void | Promise<void>;
+    };
+};
+/**
+ * UI state for filter groups
+ */
+export type FilterGroupState = {
+    expandedGroups: string[];
+};
+/**
+ * Complete filter state managed by the slice
+ */
+export type FilterState = {
+    values: FilterValues;
+    appliedValues: FilterValues;
+    isDirty: boolean;
+    errors: FilterValidationErrors;
+    isOpen: boolean;
+    groupState: FilterGroupState;
+    presets: FilterPreset[];
+    currentPresetId: string | null;
+    isValidating: boolean;
+    isApplying: boolean;
+    disabled: boolean;
+    liveUpdate: boolean;
+};
+/**
+ * Filter actions available to components
+ */
+export type FilterActions = {
+    setValue: (field: string, value: FilterValue) => void;
+    setValues: (values: FilterValues) => void;
+    clearValue: (field: string) => void;
+    clearAllValues: () => void;
+    applyFilters: () => void;
+    resetFilters: () => void;
+    validateField: (field: string) => void;
+    validateAll: () => boolean;
+    clearError: (field: string) => void;
+    clearAllErrors: () => void;
+    toggleOpen: () => void;
+    setOpen: (open: boolean) => void;
+    toggleGroup: (groupId: string) => void;
+    setGroupExpanded: (groupId: string, expanded: boolean) => void;
+    savePreset: (name: string, description?: string) => void;
+    loadPreset: (presetId: string) => void;
+    deletePreset: (presetId: string) => void;
+    updatePreset: (presetId: string, updates: Partial<FilterPreset>) => void;
+    setDefaultPreset: (presetId: string | null) => void;
+    loadPersistedFilters: () => void;
+    persistFilters: () => void;
+    clearPersistedFilters: () => void;
+};
+/**
+ * Filter context value provided to child components
+ */
+export type FilterContextValue = {
+    state: FilterState;
+    actions: FilterActions;
+    schema: FilterSchema;
+    persistence?: FilterPersistenceConfig;
+    presetConfig?: FilterPresetConfig;
+    activeFilterCount: number;
+    hasActiveFilters: boolean;
+    hasErrors: boolean;
+    canApply: boolean;
+    canReset: boolean;
+};
+/**
+ * Base filter component props
+ */
+export type FilterBaseProps = {
+    schema: FilterSchema;
+    values?: FilterValues;
+    defaultValues?: FilterValues;
+    onChange?: (values: FilterValues) => void;
+    onApply?: (values: FilterValues) => void;
+    onReset?: () => void;
+    persistence?: FilterPersistenceConfig;
+    presetConfig?: FilterPresetConfig;
+    disabled?: boolean;
+    liveUpdate?: boolean;
+    className?: string;
+};
+/**
+ * Filter trigger props
+ */
+export type FilterTriggerProps = {
+    activeCount?: number;
+    icon?: ReactNode;
+    label?: string;
+    showCount?: boolean;
+    className?: string;
+    variant?: 'filled' | 'outlined' | 'tonal' | 'ghost';
+    color?: 'primary' | 'secondary' | 'default';
+};
+/**
+ * Filter chips display props
+ */
+export type FilterChipsProps = {
+    schema: FilterSchema;
+    values: FilterValues;
+    onRemove?: (field: string) => void;
+    onClearAll?: () => void;
+    maxVisible?: number;
+    className?: string;
+};
+/**
+ * Filter preset selector props
+ */
+export type FilterPresetsProps = {
+    presets: FilterPreset[];
+    currentPresetId: string | null;
+    onLoad: (presetId: string) => void;
+    onSave: (name: string, description?: string) => void;
+    onDelete: (presetId: string) => void;
+    onSetDefault: (presetId: string | null) => void;
+    maxPresets?: number;
+    disabled?: boolean;
+    className?: string;
+};

package/dist/lib/components/ui/filter/use-filter-modal.d.ts

@@ -0,0 +1,6 @@
+import { FilterValues } from './types';
+export declare function useFilterModal(onApply?: (values: FilterValues) => void): {
+    open: boolean;
+    handleOpenChange: import('react').Dispatch<import('react').SetStateAction<boolean>>;
+    handleApply: (values: FilterValues) => void;
+};

package/dist/lib/components/ui/filter/use-filter-selector.d.ts

@@ -0,0 +1,11 @@
+import { FilterState } from './types';
+/**
+ * Custom hook for using filter selectors with automatic memoization
+ *
+ * @example
+ * ```typescript
+ * const activeCount = useFilterSelector(state, filterSelectors.selectActiveFilterCount);
+ * const canApply = useFilterSelector(state, filterSelectors.selectCanApply);
+ * ```
+ */
+export declare function useFilterSelector<T>(state: FilterState, selector: (state: FilterState) => T): T;

package/dist/lib/components/ui/filter/use-filter.d.ts

@@ -0,0 +1,42 @@
+import { FilterActions, FilterPersistenceConfig, FilterPreset, FilterPresetConfig, FilterSchema, FilterValues } from './types';
+export type UseFilterOptions = {
+    schema: FilterSchema;
+    values?: FilterValues;
+    defaultValues?: FilterValues;
+    onChange?: (values: FilterValues) => void;
+    onApply?: (values: FilterValues) => void;
+    onReset?: () => void;
+    persistence?: FilterPersistenceConfig;
+    presetConfig?: FilterPresetConfig;
+    liveUpdate?: boolean;
+    disabled?: boolean;
+};
+export declare function useFilter(options: UseFilterOptions): {
+    state: import('./types').FilterState;
+    actions: FilterActions;
+    schema: FilterSchema;
+    persistence: {
+        enabled: boolean;
+        strategy: import('./types').FilterPersistenceStrategy;
+        storageKey?: string;
+        version?: number;
+        urlParams?: import('./types').FilterUrlParamsConfig;
+        customStorage?: import('./types').FilterCustomStorage;
+    };
+    presetConfig: {
+        enabled: boolean;
+        storage?: "localStorage" | "sessionStorage" | "custom";
+        storageKey?: string;
+        maxPresets?: number;
+        customStorage?: {
+            save: (presets: FilterPreset[]) => void | Promise<void>;
+            load: () => FilterPreset[] | Promise<FilterPreset[]> | null;
+            clear: () => void | Promise<void>;
+        };
+    };
+    activeFilterCount: number;
+    hasActiveFilters: boolean;
+    hasErrors: boolean;
+    canApply: boolean;
+    canReset: boolean;
+};

package/dist/lib/components/ui/format-count.d.ts

@@ -0,0 +1 @@
+export declare function formatCount(count: number, max?: number): string;

package/dist/lib/components/ui/format-count.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/lib/components/ui/forms/autocomplete-form-field.d.ts

@@ -0,0 +1,3 @@
+import { UseControllerProps } from 'react-hook-form';
+import { AutocompleteOption, AutocompleteProps } from '../autocomplete';
+export declare function AutocompleteFormField<T extends Record<string, any>, U extends AutocompleteOption>({ control, name, ...props }: Pick<UseControllerProps<T>, 'control' | 'name'> & Omit<AutocompleteProps<U>, 'name' | 'value'>): import("react").JSX.Element;

package/dist/lib/components/ui/forms/check-card-form-field.d.ts

@@ -0,0 +1,3 @@
+import { UseControllerProps } from 'react-hook-form';
+import { CheckCardFieldProps } from '../check-card-field';
+export declare function CheckCardFormField<T extends Record<string, any>>({ control, name, ...props }: Pick<UseControllerProps<T>, 'control' | 'name'> & Omit<CheckCardFieldProps, 'name' | 'value'>): import("react").JSX.Element;

package/dist/lib/components/ui/forms/checkbox-form-field.d.ts

@@ -0,0 +1,3 @@
+import { UseControllerProps } from 'react-hook-form';
+import { CheckboxProps } from '../checkbox';
+export declare function CheckboxFormField<T extends Record<string, any>>({ control, name, ...props }: Pick<UseControllerProps<T>, 'control' | 'name'> & Omit<CheckboxProps, 'name'>): import("react").JSX.Element;

package/dist/lib/components/ui/forms/checkbox-group-form-field.d.ts

@@ -0,0 +1,3 @@
+import { UseControllerProps } from 'react-hook-form';
+import { CheckboxGroupProps } from '../checkbox-group';
+export declare function CheckboxGroupFormField<T extends Record<string, any>>({ control, name, ...props }: Pick<UseControllerProps<T>, 'control' | 'name'> & Omit<CheckboxGroupProps, 'name'>): import("react").JSX.Element;

package/dist/lib/components/ui/forms/code-editor-form-field.d.ts

@@ -0,0 +1,3 @@
+import { UseControllerProps } from 'react-hook-form';
+import { CodeEditorProps } from '../code-editor';
+export declare function CodeEditorFormField<T extends Record<string, any>>({ control, name, ...props }: Pick<UseControllerProps<T>, 'control' | 'name'> & Omit<CodeEditorProps, 'name' | 'value' | 'onChange'>): import("react").JSX.Element;

package/dist/lib/components/ui/forms/color-form-field.d.ts

@@ -0,0 +1,3 @@
+import { UseControllerProps } from 'react-hook-form';
+import { ColorFieldProps } from '../color-field';
+export declare function ColorFormField<T extends Record<string, any>>({ control, name, ...props }: Pick<UseControllerProps<T>, 'control' | 'name'> & Omit<ColorFieldProps, 'name' | 'value' | 'onChange'>): import("react").JSX.Element;

package/dist/lib/components/ui/forms/combobox-form-field.d.ts

@@ -0,0 +1,3 @@
+import { UseControllerProps } from 'react-hook-form';
+import { ComboboxFieldProps } from '../combobox-field';
+export declare function ComboboxFormField<T extends Record<string, any>>({ control, name, ...props }: Pick<UseControllerProps<T>, 'control' | 'name'> & Omit<ComboboxFieldProps, 'name' | 'value' | 'onChange'>): import("react").JSX.Element;

package/dist/lib/components/ui/forms/country-form-field.d.ts

@@ -0,0 +1,3 @@
+import { UseControllerProps } from 'react-hook-form';
+import { CountryFieldProps } from '../country-field';
+export declare function CountryFormField<T extends Record<string, any>>({ countries, placeholder, mode, ...props }: Pick<UseControllerProps<T>, 'control' | 'name'> & Omit<CountryFieldProps, 'name' | 'value'>): import("react").JSX.Element;

package/dist/lib/components/ui/forms/currency-form-field.d.ts

@@ -0,0 +1,3 @@
+import { UseControllerProps } from 'react-hook-form';
+import { CurrencyFieldProps } from '../currency-field';
+export declare function CurrencyFormField<T extends Record<string, any>>({ control, name, ...props }: Pick<UseControllerProps<T>, 'control' | 'name'> & Omit<CurrencyFieldProps, 'name' | 'value' | 'onChange'>): import("react").JSX.Element;

package/dist/lib/components/ui/forms/date-form-field.d.ts

@@ -0,0 +1,3 @@
+import { UseControllerProps } from 'react-hook-form';
+import { DateFieldProps } from '../date-field';
+export declare function DateFormField<T extends Record<string, any>>({ control, name, ...props }: Pick<UseControllerProps<T>, 'control' | 'name'> & Omit<DateFieldProps, 'name'>): import("react").JSX.Element;

package/dist/lib/components/ui/forms/date-range-form-field.d.ts

@@ -0,0 +1,3 @@
+import { UseControllerProps } from 'react-hook-form';
+import { DateRangeFieldProps } from '../date-range-field';
+export declare function DateRangeFormField<T extends Record<string, any>>({ control, name, ...props }: Pick<UseControllerProps<T>, 'control' | 'name'> & Omit<DateRangeFieldProps, 'name'>): import("react").JSX.Element;

package/dist/lib/components/ui/forms/duration-form-field.d.ts

@@ -0,0 +1,3 @@
+import { UseControllerProps } from 'react-hook-form';
+import { DurationFieldProps } from '../duration-field';
+export declare function DurationFormField<T extends Record<string, any>>({ control, name, ...props }: Pick<UseControllerProps<T>, 'control' | 'name'> & Omit<DurationFieldProps, 'name' | 'value' | 'onChange'>): import("react").JSX.Element;

package/dist/lib/components/ui/forms/email-form-field.d.ts

@@ -0,0 +1,3 @@
+import { UseControllerProps } from 'react-hook-form';
+import { EmailFieldProps } from '../email-field';
+export declare function EmailFormField<T extends Record<string, any>>({ control, name, ...props }: Pick<UseControllerProps<T>, 'control' | 'name'> & Omit<EmailFieldProps, 'name'>): import("react").JSX.Element;

package/dist/lib/components/ui/forms/file-list-form-field.d.ts

@@ -0,0 +1,3 @@
+import { UseControllerProps } from 'react-hook-form';
+import { FileListFieldProps } from '../file-list/file-list-field';
+export declare function FileListFormField<T extends Record<string, any>>({ control, name, ...props }: Pick<UseControllerProps<T>, 'control' | 'name'> & Omit<FileListFieldProps, 'name' | 'value' | 'onValueChange'>): import("react").JSX.Element;