@vuehookform/core 0.2.11 → 0.3.3

package/README.md

@@ -7,10 +7,10 @@ A TypeScript-first form library for Vue 3, inspired by React Hook Form.
 ## Features
 
 - **TypeScript First** - Perfect type inference with zero manual typing
-- **Zero Config** - Works out of the box with sensible defaults
+- **Field Arrays** - Dynamic lists with stable keys built-in
 - **Performant** - Minimal re-renders using uncontrolled inputs
 - **Zod Native** - First-class Zod integration for validation
-- **Tiny Bundle** - < 5kb gzipped, tree-shakable
+- **Tiny Bundle** - ~10kb gzipped, tree-shakable
 - **UI Agnostic** - Works with any UI library or custom components
 
 ## Quick Start
@@ -73,6 +73,13 @@ type UserForm = z.infer<typeof userSchema>
 <script setup>
 const { register, fields } = useForm({ schema })
 const addresses = fields('addresses')
+
+// Available methods:
+// addresses.append(value)  - Add to end
+// addresses.remove(index)  - Remove at index
+// addresses.insert(index, value)
+// addresses.swap(i, j)
+// addresses.move(from, to)
 </script>
 
 <template>
@@ -96,40 +103,31 @@ useForm({
 })
 ```
 
-## API Reference
-
-### `useForm(options)`
+- `disabled: ref(true)` - Disable entire form (reactive, blocks submission)
+- `shouldUseNativeValidation: true` - Enable CSS `:valid`/`:invalid` selectors
 
-```typescript
-const {
-  register, // Register input field
-  handleSubmit, // Create submit handler with validation
-  formState, // Reactive form state (errors, isSubmitting, etc.)
-  fields, // Manage dynamic field arrays
-  setValue, // Programmatically set field value
-  getValue, // Get current field value
-  reset, // Reset form to default values
-  watch, // Watch field value changes
-  validate, // Manually trigger validation
-} = useForm({
-  schema, // Zod schema for validation
-  defaultValues: {}, // Initial form values
-  mode: 'onSubmit', // When to validate
-})
-```
+## Tips
 
-### `fields(name)`
+### Controlled vs Uncontrolled
 
 ```typescript
-const addresses = fields('addresses')
+// Default (uncontrolled) - for native inputs
+<input v-bind="register('email')" />
 
-addresses.append({ street: '', city: '' })
-addresses.remove(0)
-addresses.insert(1, value)
-addresses.swap(0, 1)
-addresses.move(0, 2)
+// Controlled - for v-model / custom components
+const { value, ...bindings } = register('field', { controlled: true })
+<CustomInput v-model="value" v-bind="bindings" />
 ```
 
+### Common Mistakes
+
+| Wrong                    | Right                    |
+| ------------------------ | ------------------------ |
+| `items[0].name`          | `items.0.name`           |
+| `:key="index"`           | `:key="field.key"`       |
+| `formState.errors`       | `formState.value.errors` |
+| `v-model` + `register()` | Either one, not both     |
+
 ## Contributing
 
 Contributions welcome! Feel free to report bugs, suggest features, or submit PRs.

package/dist/core/domSync.d.ts

@@ -20,10 +20,3 @@ export declare function syncUncontrolledInputs(fieldRefs: Map<string, Ref<HTMLIn
  * @param value - The value to set
  */
 export declare function updateDomElement(el: HTMLInputElement, value: unknown): void;
-/**
- * Get value from a DOM element based on its type
- *
- * @param el - The DOM input element
- * @returns The current value (checked state for checkboxes, value for others)
- */
-export declare function getDomElementValue(el: HTMLInputElement): unknown;

package/dist/core/formContext.d.ts

@@ -44,6 +44,7 @@ export interface FormContext<FormValues> {
     debounceTimers: Map<string, ReturnType<typeof setTimeout>>;
     validationRequestIds: Map<string, number>;
     resetGeneration: Ref<number>;
+    isDisabled: Ref<boolean>;
     options: UseFormOptions<ZodType>;
 }
 /**

package/dist/index.d.ts

@@ -20,4 +20,4 @@ export { useWatch, type UseWatchOptions } from './useWatch';
 export { useController, type UseControllerOptions, type UseControllerReturn, type ControllerFieldProps, } from './useController';
 export { useFormState, type UseFormStateOptions, type FormStateKey } from './useFormState';
 export { isFieldError } from './types';
-export type { UseFormOptions, UseFormReturn, RegisterOptions, RegisterReturn, FormState, FieldState, FieldErrors, FieldError, FieldErrorValue, ErrorOption, FieldArray, FieldArrayItem, InferSchema, FormValues, FormPath, Path, PathValue, ArrayElement, ArrayPath, ValidationMode, SetFocusOptions, ResetOptions, ResetFieldOptions, AsyncDefaultValues, } from './types';
+export type { UseFormOptions, UseFormReturn, RegisterOptions, RegisterReturn, FormState, FieldState, FieldErrors, FieldError, FieldErrorValue, ErrorOption, SetErrorsOptions, FieldArray, FieldArrayItem, InferSchema, FormValues, FormPath, Path, PathValue, ArrayElement, ArrayPath, FieldPath, ValidationMode, SetFocusOptions, ResetOptions, ResetFieldOptions, AsyncDefaultValues, } from './types';

package/dist/types.d.ts

@@ -63,9 +63,20 @@ export type FormPath<TSchema extends ZodType> = Path<FormValues<TSchema>>;
 export type ArrayPath<T> = {
     [K in Path<T>]: PathValue<T, K> extends Array<unknown> ? K : never;
 }[Path<T>];
+/**
+ * Get non-array field paths (primitive fields and nested objects, excluding arrays).
+ * Useful for methods like register() that work with individual fields.
+ *
+ * @example
+ * type Form = { name: string; addresses: Address[] }
+ * type Fields = FieldPath<Form>  // 'name' (excludes 'addresses')
+ */
+export type FieldPath<T> = {
+    [K in Path<T>]: PathValue<T, K> extends Array<unknown> ? never : K;
+}[Path<T>];
 /**
  * Extract the value type at a given dot-notation path.
- * Used internally to ensure setValue/getValue have correct types.
+ * Used internally to ensure setValue/getValues have correct types.
  * Supports numeric string indices for array access (e.g., 'items.0.name').
  *
  * @example
@@ -76,14 +87,42 @@ export type ArrayPath<T> = {
  */
 export type PathValue<T, P extends string> = T extends unknown ? P extends `${infer K}.${infer Rest}` ? K extends keyof T ? PathValue<T[K], Rest> : T extends Array<infer U> ? K extends `${number}` ? PathValue<U, Rest> : never : never : P extends keyof T ? T[P] : T extends Array<infer U> ? P extends `${number}` ? U : never : never : never;
 /**
- * Single field error with type and message
+ * Single field error with type and message.
+ * When criteriaMode is 'all', the `types` property contains all validation errors.
  */
 export interface FieldError {
-    /** Error type identifier (e.g., 'required', 'minLength', 'custom') */
+    /** Error type identifier (e.g., 'required', 'too_small', 'invalid_string', 'custom') */
     type: string;
-    /** Error message to display */
+    /** Primary error message to display */
     message: string;
-    /** Additional error types when multiple validations fail */
+    /**
+     * Additional error types when multiple validations fail.
+     * Only populated when `criteriaMode: 'all'` is set in useForm options.
+     *
+     * @example Password with multiple requirements
+     * ```ts
+     * // Schema:
+     * const schema = z.object({
+     *   password: z.string()
+     *     .min(8, 'At least 8 characters')
+     *     .regex(/[A-Z]/, 'Needs uppercase letter')
+     *     .regex(/[0-9]/, 'Needs a number')
+     * })
+     *
+     * // With criteriaMode: 'all', error.types might be:
+     * // {
+     * //   too_small: 'At least 8 characters',
+     * //   invalid_string: ['Needs uppercase letter', 'Needs a number']
+     * // }
+     *
+     * // Template usage:
+     * // <ul v-if="isFieldError(error) && error.types">
+     * //   <li v-for="(messages, type) in error.types" :key="type">
+     * //     {{ Array.isArray(messages) ? messages.join(', ') : messages }}
+     * //   </li>
+     * // </ul>
+     * ```
+     */
     types?: Record<string, string | string[]>;
 }
 /**
@@ -145,6 +184,8 @@ export interface FormState<T> {
     isSubmitted: boolean;
     /** Whether the last submission was successful */
     isSubmitSuccessful: boolean;
+    /** Whether the form is disabled */
+    disabled: boolean;
 }
 /**
  * State of an individual field
@@ -236,6 +277,13 @@ export interface ResetOptions {
     /** Keep isSubmitSuccessful state after reset */
     keepIsSubmitSuccessful?: boolean;
 }
+/**
+ * Options for setErrors() bulk operation
+ */
+export interface SetErrorsOptions {
+    /** Replace all existing errors instead of merging (default: false) */
+    shouldReplace?: boolean;
+}
 /**
  * Options for registering a field
  * @template TValue - The type of the field value (inferred from field path)
@@ -296,6 +344,8 @@ export interface RegisterReturn<TValue = unknown> {
     onBlur: (e: Event) => void;
     /** Current value (for controlled mode) - only present when controlled: true */
     value?: Ref<TValue>;
+    /** Disabled state from form-level disabled option */
+    disabled?: boolean;
 }
 /**
  * Field metadata for dynamic arrays
@@ -347,32 +397,56 @@ export interface FieldArrayOptions<T = unknown> {
  * API for managing dynamic field arrays.
  * All methods that accept values are typed to match the array item type.
  *
+ * Most operations return a boolean indicating success or failure.
+ * Operations fail (return false) when:
+ * - maxLength rule would be exceeded (append, prepend, insert)
+ * - minLength rule would be violated (remove, removeAll, removeMany)
+ * - Index is out of bounds (remove, update, swap, move)
+ *
  * @template TItem - The type of items in the array (inferred from field path)
  *
  * @example
  * interface Address { street: string; city: string }
  * const addresses = fields('addresses') // FieldArray<Address>
  * addresses.append({ street: '123 Main', city: 'NYC' }) // Typed!
+ *
+ * @example Check if operation succeeded
+ * const success = addresses.append({ street: '', city: '' })
+ * if (!success) {
+ *   // Operation was rejected (e.g., maxLength exceeded)
+ *   showNotification('Cannot add more addresses')
+ * }
  */
 export interface FieldArray<TItem = unknown> {
     /** Current field items with metadata */
     value: FieldArrayItem[];
-    /** Append item(s) to end of array */
-    append: (value: TItem | TItem[], options?: FieldArrayFocusOptions) => void;
-    /** Prepend item(s) to beginning of array */
-    prepend: (value: TItem | TItem[], options?: FieldArrayFocusOptions) => void;
-    /** Remove item at index */
-    remove: (index: number) => void;
-    /** Insert item(s) at index */
-    insert: (index: number, value: TItem | TItem[], options?: FieldArrayFocusOptions) => void;
-    /** Swap two items */
-    swap: (indexA: number, indexB: number) => void;
-    /** Move item from one index to another */
-    move: (from: number, to: number) => void;
-    /** Update item at index (preserves key/identity) */
-    update: (index: number, value: TItem) => void;
-    /** Replace all items with new values */
-    replace: (values: TItem[]) => void;
+    /** Append item(s) to end of array. Returns false if maxLength exceeded. */
+    append: (value: TItem | TItem[], options?: FieldArrayFocusOptions) => boolean;
+    /** Prepend item(s) to beginning of array. Returns false if maxLength exceeded. */
+    prepend: (value: TItem | TItem[], options?: FieldArrayFocusOptions) => boolean;
+    /** Remove item at index. Returns false if minLength violated or index out of bounds. */
+    remove: (index: number) => boolean;
+    /**
+     * Remove all items from the array.
+     * Returns false if minLength > 0.
+     */
+    removeAll: () => boolean;
+    /**
+     * Remove multiple items by indices (handles any order, removes from highest to lowest).
+     * Returns false if minLength would be violated.
+     * @param indices - Array of indices to remove
+     */
+    removeMany: (indices: number[]) => boolean;
+    /** Insert item(s) at index. Returns false if maxLength exceeded. */
+    insert: (index: number, value: TItem | TItem[], options?: FieldArrayFocusOptions) => boolean;
+    /** Swap two items. Returns false if either index is out of bounds. */
+    swap: (indexA: number, indexB: number) => boolean;
+    /** Move item from one index to another. Returns false if from index is out of bounds. */
+    move: (from: number, to: number) => boolean;
+    /** Update item at index (preserves key/identity). Returns false if index out of bounds. */
+    update: (index: number, value: TItem) => boolean;
+    /** Replace all items with new values. Always succeeds (returns true). */
+    replace: (values: TItem[]) => boolean;
 }
 /**
  * Async default values function type
@@ -388,11 +462,65 @@ export type CriteriaMode = 'firstError' | 'all';
 export interface UseFormOptions<TSchema extends ZodType> {
     /** Zod schema for validation */
     schema: TSchema;
-    /** Default form values (can be a sync object or async function) */
+    /**
+     * Default form values. Can be a sync object or async function.
+     * Async function is useful for fetching initial values from an API.
+     *
+     * @example Sync default values
+     * ```ts
+     * useForm({
+     *   schema,
+     *   defaultValues: { email: '', name: '' }
+     * })
+     * ```
+     *
+     * @example Async default values (API fetch)
+     * ```ts
+     * useForm({
+     *   schema,
+     *   defaultValues: async () => {
+     *     const user = await api.getCurrentUser()
+     *     return { email: user.email, name: user.name }
+     *   },
+     *   onDefaultValuesError: (err) => console.error('Failed to load user:', err)
+     * })
+     * // Check formState.isLoading to show loading indicator
+     * ```
+     */
     defaultValues?: Partial<InferSchema<TSchema>> | AsyncDefaultValues<InferSchema<TSchema>>;
-    /** When to run validation */
+    /**
+     * When to run validation.
+     * - 'onSubmit' (default): Only validate on form submission
+     * - 'onBlur': Validate when field loses focus
+     * - 'onChange': Validate on every input change
+     * - 'onTouched': Validate after field touched, then on every change
+     *
+     * @example Different validation modes
+     * ```ts
+     * // Most performant - only show errors after submit attempt
+     * useForm({ schema, mode: 'onSubmit' })
+     *
+     * // Real-time feedback - validate as user types
+     * useForm({ schema, mode: 'onChange' })
+     *
+     * // Balanced - validate after first interaction
+     * useForm({ schema, mode: 'onTouched' })
+     * ```
+     */
     mode?: ValidationMode;
-    /** Revalidate on change after first submit */
+    /**
+     * Validation mode after first submission.
+     * Useful for "validate on submit, then real-time revalidation" pattern.
+     *
+     * @example Submit first, then real-time
+     * ```ts
+     * useForm({
+     *   schema,
+     *   mode: 'onSubmit',           // First submit validates all
+     *   reValidateMode: 'onChange'  // After submit, revalidate on change
+     * })
+     * ```
+     */
     reValidateMode?: ValidationMode;
     /** Remove field data when unmounted (default: false) */
     shouldUnregister?: boolean;
@@ -400,20 +528,135 @@ export interface UseFormOptions<TSchema extends ZodType> {
     onDefaultValuesError?: (error: unknown) => void;
     /** Focus first field with error on submit (default: true) */
     shouldFocusError?: boolean;
-    /** How to collect validation errors: 'firstError' or 'all' (default: 'firstError') */
+    /**
+     * How to collect validation errors.
+     * - 'firstError' (default): Stop at first error per field
+     * - 'all': Collect all errors for each field (populates FieldError.types)
+     *
+     * @example Show all validation errors (password requirements)
+     * ```ts
+     * const schema = z.object({
+     *   password: z.string()
+     *     .min(8, 'At least 8 characters')
+     *     .regex(/[A-Z]/, 'Needs uppercase letter')
+     *     .regex(/[0-9]/, 'Needs a number')
+     * })
+     *
+     * useForm({ schema, criteriaMode: 'all' })
+     *
+     * // In template - display all password requirements:
+     * // <ul v-if="formState.errors.password?.types">
+     * //   <li v-for="(msg, type) in formState.errors.password.types" :key="type">
+     * //     {{ msg }}
+     * //   </li>
+     * // </ul>
+     * ```
+     *
+     * @see isFieldError - Type guard for structured errors
+     * @see FieldError.types - Contains all error types when criteriaMode is 'all'
+     */
     criteriaMode?: CriteriaMode;
-    /** Delay before displaying validation errors in milliseconds (default: 0 = no delay) */
+    /**
+     * Delay in milliseconds before displaying validation errors.
+     * Prevents error flash during fast typing.
+     *
+     * @example Delay error display by 500ms
+     * ```ts
+     * useForm({
+     *   schema,
+     *   mode: 'onChange',
+     *   delayError: 500  // Wait 500ms before showing error
+     * })
+     * // If user fixes error within 500ms, error never appears
+     * ```
+     */
     delayError?: number;
     /**
      * External values to sync to form. Changes update formData without marking dirty.
      * Useful for server-fetched data or parent component state.
+     *
+     * @example Sync with parent component state
+     * ```ts
+     * const props = defineProps<{ userData: UserData }>()
+     *
+     * useForm({
+     *   schema,
+     *   values: computed(() => props.userData)  // Reactive sync
+     * })
+     * // When props.userData changes, form updates without becoming dirty
+     * ```
+     *
+     * @example Sync with API polling
+     * ```ts
+     * const { data: serverData } = useQuery('user', fetchUser)
+     *
+     * useForm({
+     *   schema,
+     *   values: serverData  // Ref from useQuery
+     * })
+     * ```
      */
     values?: MaybeRef<Partial<InferSchema<TSchema>>>;
     /**
      * External/server errors to merge with validation errors.
-     * Useful for server-side validation errors.
+     * These take precedence over client-side validation errors.
+     *
+     * @example Display server validation errors
+     * ```ts
+     * const serverErrors = ref({})
+     *
+     * const { handleSubmit } = useForm({
+     *   schema,
+     *   errors: serverErrors
+     * })
+     *
+     * const onSubmit = async (data) => {
+     *   try {
+     *     await api.submit(data)
+     *   } catch (err) {
+     *     if (err.validationErrors) {
+     *       serverErrors.value = err.validationErrors
+     *       // e.g., { email: 'Email already registered' }
+     *     }
+     *   }
+     * }
+     * ```
      */
     errors?: MaybeRef<Partial<FieldErrors<InferSchema<TSchema>>>>;
+    /**
+     * Disable the entire form. When true:
+     * - All registered fields receive `disabled` attribute
+     * - Form submission is prevented
+     * - Can be reactive (MaybeRef) to toggle dynamically
+     *
+     * @example Disable form during submission
+     * ```ts
+     * const isSubmitting = ref(false)
+     *
+     * useForm({
+     *   schema,
+     *   disabled: isSubmitting
+     * })
+     * ```
+     */
+    disabled?: MaybeRef<boolean>;
+    /**
+     * Enable browser's native validation API.
+     * When true:
+     * - Calls setCustomValidity() on inputs with error messages
+     * - Enables :valid/:invalid CSS pseudo-selectors
+     * - Shows native browser validation tooltips
+     *
+     * @example
+     * ```ts
+     * useForm({ schema, shouldUseNativeValidation: true })
+     *
+     * // CSS styling:
+     * // input:invalid { border-color: red; }
+     * // input:valid { border-color: green; }
+     * ```
+     */
+    shouldUseNativeValidation?: boolean;
 }
 /**
  * Return value from useForm composable.
@@ -454,7 +697,7 @@ export interface UseFormReturn<TSchema extends ZodType> {
      * Manage dynamic field arrays.
      * Returns a typed API for adding, removing, and reordering array items.
      *
-     * @param name - Array field path
+     * @param name - Array field path (must be an array field in the schema)
      * @param options - Optional configuration including validation rules
      * @returns Typed FieldArray API
      *
@@ -462,7 +705,7 @@ export interface UseFormReturn<TSchema extends ZodType> {
      * const addresses = fields('addresses')
      * addresses.append({ street: '', city: '' }) // Typed to Address
      */
-    fields: <TPath extends Path<InferSchema<TSchema>>>(name: TPath, options?: FieldArrayOptions<ArrayElement<PathValue<InferSchema<TSchema>, TPath>>>) => FieldArray<ArrayElement<PathValue<InferSchema<TSchema>, TPath>>>;
+    fields: <TPath extends ArrayPath<InferSchema<TSchema>>>(name: TPath, options?: FieldArrayOptions<ArrayElement<PathValue<InferSchema<TSchema>, TPath>>>) => FieldArray<ArrayElement<PathValue<InferSchema<TSchema>, TPath>>>;
     /**
      * Set field value programmatically
      * @param name - Field path
@@ -470,12 +713,6 @@ export interface UseFormReturn<TSchema extends ZodType> {
      * @param options - Options for validation/dirty/touched behavior
      */
     setValue: <TPath extends Path<InferSchema<TSchema>>>(name: TPath, value: PathValue<InferSchema<TSchema>, TPath>, options?: SetValueOptions) => void;
-    /**
-     * Get field value
-     * @param name - Field path
-     * @returns The field value (typed) or undefined if not set
-     */
-    getValue: <TPath extends Path<InferSchema<TSchema>>>(name: TPath) => PathValue<InferSchema<TSchema>, TPath> | undefined;
     /**
      * Reset form to default values
      * @param values - Optional new default values
@@ -515,6 +752,58 @@ export interface UseFormReturn<TSchema extends ZodType> {
      * @param error - Error option with message
      */
     setError: <TPath extends Path<InferSchema<TSchema>>>(name: TPath | 'root' | `root.${string}`, error: ErrorOption) => void;
+    /**
+     * Set multiple errors at once. Useful for server-side validation errors
+     * or bulk error handling scenarios.
+     *
+     * @param errors - Record of field paths to error messages or ErrorOption objects
+     * @param options - Optional configuration for merge behavior
+     *
+     * @example
+     * // Simple string errors
+     * setErrors({
+     *   email: 'Email already exists',
+     *   'user.name': 'Name is too short'
+     * })
+     *
+     * @example
+     * // Replace all errors
+     * setErrors({ email: 'New error' }, { shouldReplace: true })
+     */
+    setErrors: <TPath extends Path<InferSchema<TSchema>>>(errors: Partial<Record<TPath | 'root' | `root.${string}`, string | ErrorOption>>, options?: SetErrorsOptions) => void;
+    /**
+     * Check if the form or a specific field has validation errors
+     *
+     * @param fieldPath - Optional field path to check. If omitted, checks entire form.
+     * @returns true if errors exist, false otherwise
+     *
+     * @example
+     * if (hasErrors()) {
+     *   console.log('Form has validation errors')
+     * }
+     *
+     * @example
+     * if (hasErrors('email')) {
+     *   focusField('email')
+     * }
+     */
+    hasErrors: <TPath extends Path<InferSchema<TSchema>>>(fieldPath?: TPath | 'root' | `root.${string}`) => boolean;
+    /**
+     * Get validation errors for the form or a specific field
+     *
+     * @overload Get all form errors
+     * @overload Get error for a specific field
+     *
+     * @example
+     * const allErrors = getErrors()
+     *
+     * @example
+     * const emailError = getErrors('email')
+     */
+    getErrors: {
+        (): FieldErrors<InferSchema<TSchema>>;
+        <TPath extends Path<InferSchema<TSchema>>>(fieldPath: TPath | 'root' | `root.${string}`): FieldErrorValue | undefined;
+    };
     /**
      * Get all form values, a single value, or multiple values
      * @overload Get all form values

package/dist/utils/devWarnings.d.ts

@@ -0,0 +1,55 @@
+import { ZodType } from 'zod';
+export declare const __DEV__: boolean;
+/**
+ * Warn once per unique message (prevents spam on re-renders)
+ */
+export declare function warnOnce(message: string, key?: string): void;
+/**
+ * Warn every time (for errors that should always be shown)
+ */
+export declare function warn(message: string): void;
+/**
+ * Clear warning cache (useful for testing)
+ */
+export declare function clearWarningCache(): void;
+/**
+ * Validate a dot-notation path string for common syntax errors
+ * @returns Error message or null if valid
+ */
+export declare function validatePathSyntax(path: string): string | null;
+/**
+ * Check if a path exists in a Zod schema
+ * This is a runtime check to validate paths against the schema structure
+ */
+export declare function validatePathAgainstSchema(schema: ZodType, path: string): {
+    valid: boolean;
+    reason?: string;
+    availableFields?: string[];
+};
+/**
+ * Check if a path points to an array field in the schema
+ */
+export declare function isArrayFieldInSchema(schema: ZodType, path: string): boolean | null;
+/**
+ * Warn about registering an invalid path with fix suggestion
+ */
+export declare function warnInvalidPath(fnName: string, path: string, reason: string): void;
+/**
+ * Warn about path not in schema with suggestions
+ */
+export declare function warnPathNotInSchema(fnName: string, path: string, availableFields?: string[]): void;
+/**
+ * Warn about calling fields() on non-array path
+ */
+export declare function warnFieldsOnNonArray(path: string): void;
+/**
+ * Warn about silent field array operation failures
+ */
+export declare function warnArrayOperationRejected(operation: string, path: string, reason: 'maxLength' | 'minLength', details?: {
+    current: number;
+    limit: number;
+}): void;
+/**
+ * Warn about array operation with out of bounds index
+ */
+export declare function warnArrayIndexOutOfBounds(operation: string, path: string, index: number, length: number): void;