/**
 * TachUI Forms Plugin - Type Definitions
 *
 * Complete type system for form components, validation, and state management.
 * Provides SwiftUI-inspired form APIs with modern web development patterns.
 */
import type { ComponentChildren, ComponentInstance, ComponentProps, Signal } from '@tachui/core';
/**
 * Form validation rule types
 */
/**
 * Built-in validation rule with options
 */
export interface BuiltInValidationRule {
    name: 'min' | 'max' | 'minLength' | 'maxLength' | 'pattern';
    options: Record<string, any>;
}
export type ValidationRule = 'required' | 'email' | 'url' | 'number' | 'integer' | 'min' | 'max' | 'minLength' | 'maxLength' | 'pattern' | 'numeric' | 'phone' | 'creditCard' | 'ssn' | 'postalCode' | 'zipCode' | 'date' | 'time' | 'strongPassword' | BuiltInValidationRule | CustomValidationRule;
/**
 * Custom validation rule interface
 */
export interface CustomValidationRule {
    name: string;
    validate: (value: any, options?: any) => ValidationResult;
    message?: string;
    options?: Record<string, any>;
}
/**
 * Validation result interface
 */
export interface ValidationResult {
    valid: boolean;
    message?: string;
    code?: string;
}
/**
 * Field validation configuration
 */
export interface FieldValidation {
    rules: ValidationRule[];
    validateOn?: 'change' | 'blur' | 'submit';
    debounceMs?: number;
    required?: boolean;
    custom?: CustomValidationRule[];
}
/**
 * Form field state
 */
export interface FieldState<T = any> {
    value: T;
    error?: string;
    touched: boolean;
    dirty: boolean;
    valid: boolean;
    validating: boolean;
    focused: boolean;
}
/**
 * Form state interface
 */
export interface FormState {
    fields: Record<string, FieldState>;
    valid: boolean;
    dirty: boolean;
    submitting: boolean;
    submitted: boolean;
    errors: Record<string, string>;
    touched: Record<string, boolean>;
}
/**
 * Form submission handler
 */
export type FormSubmitHandler<T = Record<string, any>> = (values: T, form: FormState) => void | Promise<void>;
/**
 * Form change handler
 */
export type FormChangeHandler<T = any> = (name: string, value: T, field: FieldState<T>) => void;
/**
 * Base form field props
 */
export interface BaseFieldProps extends ComponentProps {
    name: string;
    label?: string;
    placeholder?: string;
    disabled?: boolean | Signal<boolean>;
    readOnly?: boolean | Signal<boolean>;
    required?: boolean;
    validation?: FieldValidation;
    value?: any;
    defaultValue?: any;
    onChange?: FormChangeHandler;
    onBlur?: (name: string, value: any) => void;
    onFocus?: (name: string, value: any) => void;
    error?: string;
    helperText?: string;
}
/**
 * Input field types - comprehensive SwiftUI-inspired support
 */
export type TextFieldType = 'text' | 'password' | 'email' | 'number' | 'tel' | 'url' | 'search' | 'date' | 'time' | 'datetime-local' | 'month' | 'week' | 'color';
/**
 * Auto-capitalization options
 */
export type AutoCapitalization = 'none' | 'sentences' | 'words' | 'characters';
/**
 * Keyboard type for mobile devices
 */
export type KeyboardType = 'default' | 'numeric' | 'email' | 'phone' | 'url' | 'search';
/**
 * Return key type for mobile keyboards
 */
export type ReturnKeyType = 'done' | 'go' | 'next' | 'search' | 'send';
/**
 * Text field formatter function
 */
export type TextFieldFormatter = (value: string) => string;
/**
 * Text field parser function
 */
export type TextFieldParser = (value: string) => string;
/**
 * Text input specific props - Enhanced with core TextField features
 */
export interface TextFieldProps extends BaseFieldProps {
    type?: TextFieldType;
    multiline?: boolean;
    rows?: number;
    minLength?: number;
    maxLength?: number;
    pattern?: string;
    autocomplete?: string;
    spellcheck?: boolean;
    keyboardType?: KeyboardType;
    returnKeyType?: ReturnKeyType;
    autoCapitalize?: AutoCapitalization;
    autoFocus?: boolean;
    accessibilityLabel?: string;
    accessibilityHint?: string;
    accessibilityRole?: 'textbox' | 'searchbox';
    formatter?: TextFieldFormatter;
    parser?: TextFieldParser;
    validateOnChange?: boolean;
    validateOnBlur?: boolean;
    font?: {
        family?: string;
        size?: number | string;
        weight?: 'normal' | 'bold' | '100' | '200' | '300' | '400' | '500' | '600' | '700' | '800' | '900';
        style?: 'normal' | 'italic';
    };
    textAlign?: 'left' | 'center' | 'right';
    text?: string | (() => string);
    placeholderSignal?: string | (() => string);
    disabledSignal?: boolean | (() => boolean);
    readOnlySignal?: boolean | (() => boolean);
}
/**
 * Number input specific props
 */
export interface NumberFieldProps extends BaseFieldProps {
    min?: number;
    max?: number;
    step?: number;
    precision?: number;
    format?: 'decimal' | 'currency' | 'percentage';
    currency?: string;
}
/**
 * Checkbox/Toggle props
 */
export interface CheckboxProps extends BaseFieldProps {
    checked?: boolean;
    defaultChecked?: boolean;
    indeterminate?: boolean;
}
/**
 * Radio button props
 */
export interface RadioProps extends BaseFieldProps {
    value: any;
    checked?: boolean;
    groupName?: string;
}
/**
 * Select/Picker option interface
 */
export interface SelectOption<T = any> {
    label: string;
    value: T;
    disabled?: boolean;
    group?: string;
}
/**
 * Select/Picker props
 */
export interface SelectProps extends BaseFieldProps {
    options: SelectOption[];
    multiple?: boolean;
    searchable?: boolean;
    clearable?: boolean;
    placeholder?: string;
    noOptionsMessage?: string;
    loadingMessage?: string;
    maxMenuHeight?: number;
}
/**
 * Date picker props
 */
export interface DatePickerProps extends BaseFieldProps {
    format?: string;
    locale?: string;
    minDate?: Date;
    maxDate?: Date;
    disabledDates?: Date[] | ((date: Date) => boolean);
    showTime?: boolean;
    timeFormat?: string;
    startOfWeek?: 0 | 1 | 2 | 3 | 4 | 5 | 6;
    monthsToShow?: number;
    inline?: boolean;
}
/**
 * Slider props
 */
export interface SliderProps extends BaseFieldProps {
    min?: number;
    max?: number;
    step?: number;
    range?: boolean;
    marks?: Record<number, string>;
    vertical?: boolean;
    tooltip?: boolean | 'always' | 'hover';
    formatTooltip?: (value: number) => string;
}
/**
 * Stepper props
 */
export interface StepperProps extends BaseFieldProps {
    min?: number;
    max?: number;
    step?: number;
    precision?: number;
    size?: 'small' | 'medium' | 'large';
    showControls?: boolean;
    allowEmpty?: boolean;
}
/**
 * Form container props
 */
export interface FormProps extends ComponentProps {
    onSubmit?: FormSubmitHandler;
    onChange?: FormChangeHandler;
    validation?: {
        validateOn?: 'change' | 'blur' | 'submit';
        stopOnFirstError?: boolean;
        debounceMs?: number;
    };
    initialValues?: Record<string, any>;
    resetOnSubmit?: boolean;
    preserveValues?: boolean;
    children: ComponentChildren;
}
/**
 * Enhanced FormSection props (combines Core Section features with form semantics)
 */
export interface FormSectionProps extends ComponentProps {
    title?: string;
    description?: string;
    header?: string | (() => string) | ComponentInstance;
    footer?: string | (() => string) | ComponentInstance;
    children: ComponentChildren;
    style?: 'automatic' | 'grouped' | 'inset' | 'plain' | 'sidebar';
    spacing?: number;
    collapsible?: boolean;
    collapsed?: boolean;
    onToggle?: (collapsed: boolean) => void;
    accessibilityLabel?: string;
    accessibilityRole?: string;
}
/**
 * Multi-step form props
 */
export interface MultiStepFormProps extends ComponentProps {
    steps: FormStep[];
    currentStep?: number;
    onStepChange?: (step: number) => void;
    onComplete?: FormSubmitHandler;
    showProgress?: boolean;
    allowSkipSteps?: boolean;
    validateStepOnNext?: boolean;
}
/**
 * Form step interface
 */
export interface FormStep {
    id: string;
    title: string;
    description?: string;
    component: ComponentInstance;
    validation?: FieldValidation;
    optional?: boolean;
}
/**
 * Form builder field configuration
 */
export interface FormFieldConfig {
    type: 'text' | 'number' | 'email' | 'select' | 'checkbox' | 'radio' | 'date' | 'slider';
    name: string;
    label: string;
    placeholder?: string;
    required?: boolean;
    validation?: FieldValidation;
    options?: SelectOption[];
    min?: number;
    max?: number;
    step?: number;
    format?: string;
    defaultValue?: any;
    conditional?: {
        field: string;
        operator: 'equals' | 'not-equals' | 'contains' | 'greater' | 'less';
        value: any;
    };
}
/**
 * Form builder schema
 */
export interface FormSchema {
    id: string;
    title?: string;
    description?: string;
    fields: FormFieldConfig[];
    sections?: FormSectionConfig[];
    validation?: {
        rules?: Record<string, ValidationRule[]>;
        crossFieldValidation?: CrossFieldValidation[];
    };
}
/**
 * Form section configuration for builder
 */
export interface FormSectionConfig {
    id: string;
    title: string;
    description?: string;
    fields: string[];
    collapsible?: boolean;
    conditional?: {
        field: string;
        operator: 'equals' | 'not-equals' | 'contains';
        value: any;
    };
}
/**
 * Cross-field validation interface
 */
export interface CrossFieldValidation {
    fields: string[];
    validate: (values: Record<string, any>) => ValidationResult;
    message: string;
}
/**
 * Form validation configuration
 */
export interface FormValidationConfig {
    rules: Record<string, ValidationRule[]>;
    messages: Record<string, string>;
    validateOn: 'change' | 'blur' | 'submit';
    debounceMs: number;
    stopOnFirstError: boolean;
}
/**
 * Form theme configuration
 */
export interface FormTheme {
    spacing: {
        fieldGap: string;
        sectionGap: string;
        labelGap: string;
    };
    colors: {
        border: string;
        borderFocus: string;
        borderError: string;
        background: string;
        backgroundFocus: string;
        backgroundError: string;
        text: string;
        textError: string;
        textHelper: string;
        label: string;
    };
    typography: {
        labelSize: string;
        inputSize: string;
        helperSize: string;
        errorSize: string;
    };
    borderRadius: string;
    shadows: {
        focus: string;
        error: string;
    };
}
/**
 * Form analytics/tracking interface
 */
export interface FormAnalytics {
    onFieldFocus?: (field: string) => void;
    onFieldBlur?: (field: string, value: any, timeSpent: number) => void;
    onFieldError?: (field: string, error: string) => void;
    onFormStart?: () => void;
    onFormSubmit?: (values: Record<string, any>, timeSpent: number) => void;
    onFormAbandon?: (completedFields: string[], timeSpent: number) => void;
}
/**
 * Form accessibility configuration
 */
export interface FormAccessibility {
    announceErrors?: boolean;
    announceValidation?: boolean;
    errorSummary?: boolean;
    skipLinks?: boolean;
    labelStrategy?: 'label' | 'aria-label' | 'aria-labelledby';
    fieldsetStrategy?: 'auto' | 'manual';
}
/**
 * Field registration result
 */
export interface FieldRegistration {
    register: (name: string, validation?: FieldValidation) => void;
    unregister: (name: string) => void;
    setValue: (name: string, value: any) => void;
    getValue: (name: string) => any;
    getError: (name: string) => string | undefined;
    validateField: (name: string) => Promise<boolean>;
}
/**
 * Form hook return interface
 */
export interface UseFormReturn {
    fields: Record<string, FieldState>;
    state: FormState;
    register: FieldRegistration['register'];
    unregister: FieldRegistration['unregister'];
    setValue: FieldRegistration['setValue'];
    getValue: FieldRegistration['getValue'];
    getError: FieldRegistration['getError'];
    validateField: FieldRegistration['validateField'];
    validateForm: () => Promise<boolean>;
    resetForm: () => void;
    submitForm: (handler?: FormSubmitHandler) => Promise<void>;
    watch: (fields?: string[]) => Record<string, any>;
    trigger: (fields?: string[]) => Promise<boolean>;
}
//# sourceMappingURL=index.d.ts.map