@gnwebsoft/ui 3.0.0 → 3.0.2

package/dist/types/index.d.ts

@@ -1,44 +1,241 @@
 import { GridSortModel } from '@mui/x-data-grid';
-export { a as AsyncSelectMultiPayload, A as AsyncSelectPayload } from '../AsyncSelectPayload-Cz4bgak0.js';
-export { A as AsyncMultiSelectPayload, O as OptionItem, a as OptionItem2 } from '../OptionItem-oN6XnOTJ.js';
 
-type ValidationErrors = {
+/**
+ * Type definition for server validation errors structure.
+ *
+ * This type represents the format of validation errors returned from server APIs.
+ * It supports multiple error formats for each field, allowing flexibility in how
+ * validation errors are communicated and processed.
+ *
+ * @example
+ * String error messages:
+ * ```tsx
+ * const errors: ValidationErrors = {
+ *   email: 'Email is required',
+ *   username: 'Username must be unique'
+ * };
+ * ```
+ *
+ * @example
+ * Array of error messages:
+ * ```tsx
+ * const errors: ValidationErrors = {
+ *   password: [
+ *     'Password must be at least 8 characters',
+ *     'Password must contain at least one number',
+ *     'Password must contain at least one special character'
+ *   ]
+ * };
+ * ```
+ *
+ * @example
+ * Boolean flags for validation state:
+ * ```tsx
+ * const errors: ValidationErrors = {
+ *   termsAccepted: false, // Field is invalid
+ *   emailVerified: true   // Field has an error
+ * };
+ * ```
+ *
+ * @example
+ * Structured error objects:
+ * ```tsx
+ * const errors: ValidationErrors = {
+ *   dateOfBirth: {
+ *     key: 'DATE_INVALID',
+ *     message: 'Date of birth must be in the past'
+ *   }
+ * };
+ * ```
+ *
+ * @public
+ */
+interface ValidationErrors {
     [field: string]: string | string[] | boolean | {
         key: string;
         message: string;
     };
-};
+}
 
-type ApiResponse<TModel> = {
+/**
+ * Standardized API response structure for server communications.
+ *
+ * This type defines the common structure for API responses throughout the application,
+ * providing a consistent interface for handling server responses, errors, and data.
+ * It follows a standard error response format with optional success data.
+ *
+ * @template TModel - The type of data contained in the apiData field
+ *
+ * @example
+ * Success response with data:
+ * ```tsx
+ * const userResponse: ApiResponse<User> = {
+ *   status: 200,
+ *   apiData: {
+ *     id: 1,
+ *     name: 'John Doe',
+ *     email: 'john@example.com'
+ *   }
+ * };
+ * ```
+ *
+ * @example
+ * Error response with validation errors:
+ * ```tsx
+ * const errorResponse: ApiResponse<null> = {
+ *   type: 'validation_error',
+ *   title: 'Validation failed',
+ *   status: 400,
+ *   traceId: 'abc123',
+ *   errors: {
+ *     email: 'Email is required',
+ *     password: ['Too short', 'Must contain numbers']
+ *   },
+ *   modelErrors: true
+ * };
+ * ```
+ *
+ * @public
+ */
+interface ApiResponse<TModel> {
+    /**
+     * The type or category of the response/error
+     * @example "validation_error" | "server_error" | "success"
+     */
     type?: string;
+    /**
+     * Human-readable title or summary of the response
+     * @example "Validation Failed" | "User Created Successfully"
+     */
     title?: string;
+    /**
+     * HTTP status code of the response
+     * @example 200 | 400 | 500
+     */
     status?: number;
+    /**
+     * Unique identifier for tracing/debugging the request
+     * @example "abc123-def456-ghi789"
+     */
     traceId?: string;
+    /**
+     * Field-specific validation errors
+     */
     errors?: ValidationErrors;
+    /**
+     * Flag indicating if there are model validation errors
+     */
     modelErrors?: boolean;
+    /**
+     * The actual response data/payload
+     */
     apiData?: TModel;
-};
+}
 
-type OperationResponse = {
+interface AsyncSelectPayload {
+    query: string | null;
+    initialValue?: string | number | null;
+}
+interface AsyncSelectMultiPayload {
+    query: string | null;
+    initialValues?: string[] | number[] | null;
+}
+
+/**
+ * Standard option item structure for select components.
+ *
+ * This type defines the expected structure for option items used in
+ * select components throughout the application. It provides a consistent
+ * interface with string labels and values.
+ *
+ * @example
+ * Basic usage:
+ * ```tsx
+ * const categories: OptionItem[] = [
+ *   { Label: 'Technology', Value: 'tech' },
+ *   { Label: 'Finance', Value: 'finance' },
+ *   { Label: 'Healthcare', Value: 'health' }
+ * ];
+ * ```
+ *
+ * @public
+ */
+interface OptionItem {
+    /** Display text shown to the user */
+    Label: string;
+    /** Internal value used for form submission and identification */
+    Value: string;
+}
+/**
+ * Payload structure for async multi-select operations.
+ *
+ * This type defines the data structure used when performing asynchronous
+ * multi-select operations, typically for server-side filtering and loading
+ * of options with pre-selected values.
+ *
+ * @example
+ * Search with initial values:
+ * ```tsx
+ * const payload: AsyncMultiSelectPayload = {
+ *   query: 'john',
+ *   initialValues: ['user1', 'user2', 'user3']
+ * };
+ * ```
+ *
+ * @public
+ */
+interface AsyncMultiSelectPayload {
+    /** Search query string for filtering options */
+    query: string | null;
+    /** Pre-selected values to be included in the selection */
+    initialValues?: string[] | number[] | null;
+}
+/**
+ * Extended option item structure supporting both string and number values.
+ *
+ * This type extends the basic OptionItem to support numeric values,
+ * providing flexibility for different data types while maintaining
+ * the same label-value structure.
+ *
+ * @example
+ * Mixed value types:
+ * ```tsx
+ * const options: OptionItem2[] = [
+ *   { Label: 'First Option', Value: 1 },
+ *   { Label: 'Second Option', Value: 'second' },
+ *   { Label: 'Third Option', Value: 3 }
+ * ];
+ * ```
+ *
+ * @public
+ */
+interface OptionItem2 {
+    /** Display text shown to the user */
+    Label: string;
+    /** Internal value that can be either a number or string */
+    Value: number | string;
+}
+
+interface OperationResponse {
     id?: number;
     rowsAffected: number;
-};
+}
 
-type PostModel<TFilterModel> = {
+interface PostModel<TFilterModel> {
     filterModel?: TFilterModel;
     pageOffset: number;
     pageSize: number;
     sortField: string | null;
     sortOrder: "asc" | "desc" | null | undefined;
     sortModel?: GridSortModel;
-};
-type ListResponse<TGridModel> = {
+}
+interface ListResponse<TGridModel> {
     Data: TGridModel[];
     Total: number;
-};
-type ValueLabel = {
+}
+interface ValueLabel {
     Value: number | string;
     Label: string;
-};
+}
 
-export type { ApiResponse, ListResponse, OperationResponse, PostModel, ValidationErrors, ValueLabel };
+export type { ApiResponse, AsyncMultiSelectPayload, AsyncSelectMultiPayload, AsyncSelectPayload, ListResponse, OperationResponse, OptionItem, OptionItem2, PostModel, ValidationErrors, ValueLabel };

package/dist/types/index.js

@@ -1 +1,2 @@
-"use strict";require('../chunk-6BGQA4BQ.js');
+import "../chunk-DEPJRTVT.js";
+//# sourceMappingURL=data:application/json;base64,ewogICJ2ZXJzaW9uIjogMywKICAic291cmNlcyI6IFtdLAogICJzb3VyY2VzQ29udGVudCI6IFtdLAogICJtYXBwaW5ncyI6ICIiLAogICJuYW1lcyI6IFtdCn0K

package/dist/utils/index.cjs

@@ -0,0 +1,45 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+var _chunkZC7FGYL2cjs = require('../chunk-ZC7FGYL2.cjs');
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+exports.api = _chunkZC7FGYL2cjs.api; exports.api2 = _chunkZC7FGYL2cjs.api2; exports.flattenObjectKeys = _chunkZC7FGYL2cjs.flattenObjectKeys; exports.getTimezone = _chunkZC7FGYL2cjs.getTimezone; exports.handleServerErrors = _chunkZC7FGYL2cjs.handleServerErrors; exports.propertyExists = _chunkZC7FGYL2cjs.propertyExists; exports.readValueAsDate = _chunkZC7FGYL2cjs.readValueAsDate; exports.removeLeadingTrailingSlashes = _chunkZC7FGYL2cjs.removeLeadingTrailingSlashes; exports.schemaTools = _chunkZC7FGYL2cjs.schemaTools; exports.typedWatch = _chunkZC7FGYL2cjs.typedWatch; exports.useWatchBatch = _chunkZC7FGYL2cjs.useWatchBatch; exports.useWatchBoolean = _chunkZC7FGYL2cjs.useWatchBoolean; exports.useWatchConditional = _chunkZC7FGYL2cjs.useWatchConditional; exports.useWatchDebounced = _chunkZC7FGYL2cjs.useWatchDebounced; exports.useWatchDefault = _chunkZC7FGYL2cjs.useWatchDefault; exports.useWatchField = _chunkZC7FGYL2cjs.useWatchField; exports.useWatchFields = _chunkZC7FGYL2cjs.useWatchFields; exports.useWatchForm = _chunkZC7FGYL2cjs.useWatchForm; exports.useWatchSelector = _chunkZC7FGYL2cjs.useWatchSelector; exports.useWatchTransform = _chunkZC7FGYL2cjs.useWatchTransform;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbImQ6XFxQcm9qZWN0c1xcZ253ZWItbW9ub3JlcG9cXHBhY2thZ2VzXFx1aVxcZGlzdFxcdXRpbHNcXGluZGV4LmNqcyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTtBQUNFO0FBQ0E7QUFDQTtBQUNBO0FBQ0E7QUFDQTtBQUNBO0FBQ0E7QUFDQTtBQUNBO0FBQ0E7QUFDQTtBQUNBO0FBQ0E7QUFDQTtBQUNBO0FBQ0E7QUFDQTtBQUNBO0FBQ0E7QUFDRix5REFBOEI7QUFDOUI7QUFDRTtBQUNBO0FBQ0E7QUFDQTtBQUNBO0FBQ0E7QUFDQTtBQUNBO0FBQ0E7QUFDQTtBQUNBO0FBQ0E7QUFDQTtBQUNBO0FBQ0E7QUFDQTtBQUNBO0FBQ0E7QUFDQTtBQUNBO0FBQ0YsK3BDQUFDIiwiZmlsZSI6IkQ6XFxQcm9qZWN0c1xcZ253ZWItbW9ub3JlcG9cXHBhY2thZ2VzXFx1aVxcZGlzdFxcdXRpbHNcXGluZGV4LmNqcyJ9

package/dist/utils/index.d.cts

@@ -0,0 +1,366 @@
+import { PostModel, ApiResponse, ListResponse, ValidationErrors } from '../types/index.cjs';
+import { PickerValidDate } from '@mui/x-date-pickers';
+import { useLocalizationContext } from '@mui/x-date-pickers/internals';
+import * as react_hook_form from 'react-hook-form';
+import { FieldValues, UseFormSetError, Control, DeepPartialSkipArrayKey, Path, PathValue } from 'react-hook-form';
+import { z } from 'zod';
+import '@mui/x-data-grid';
+
+declare class api {
+    static filter<T, TFilter>(url: string, postModel: PostModel<TFilter>): Promise<ApiResponse<ListResponse<T>>>;
+    static post<T>(url: string, body?: any): Promise<ApiResponse<T>>;
+    static get<T>(url: string): Promise<ApiResponse<T>>;
+    static delete<T>(url: string): Promise<ApiResponse<T>>;
+    static put<T>(url: string, body?: any): Promise<ApiResponse<T>>;
+    static fetch(url: string, options?: any): Promise<Response>;
+    static tempFetch<T>(url: string, options?: any): Promise<ApiResponse<T>>;
+    static upload<T>(url: string, formData: FormData): Promise<ApiResponse<T>>;
+}
+
+declare class api2 {
+    static filter<T, TFilter>(url: string, postModel: PostModel<TFilter>): Promise<ApiResponse<ListResponse<T>>>;
+    static post<T>(url: string, body?: any): Promise<ApiResponse<T>>;
+    static get<T>(url: string): Promise<ApiResponse<T>>;
+    static delete<T>(url: string): Promise<ApiResponse<T>>;
+    static put<T>(url: string, body?: any): Promise<ApiResponse<T>>;
+    static fetch(url: string, options?: any): Promise<Response>;
+    static tempFetch<T>(url: string, options?: any): Promise<ApiResponse<T>>;
+    static upload<T>(url: string, formData: FormData): Promise<ApiResponse<T>>;
+}
+
+/**
+ * Recursively flattens an object into a flat structure with dot-notation keys.
+ *
+ * This utility function takes a nested object and converts it into a flat object
+ * where nested properties are represented using dot notation. It handles both
+ * nested objects and arrays, preserving all levels of the original structure
+ * as separate keys in the result.
+ *
+ * @example
+ * Basic object flattening:
+ * ```tsx
+ * const nested = {
+ *   user: {
+ *     name: 'John',
+ *     address: {
+ *       city: 'New York',
+ *       zip: '10001'
+ *     }
+ *   }
+ * };
+ *
+ * const flattened = flattenObjectKeys(nested);
+ * // Result:
+ * // {
+ * //   'user': { name: 'John', address: { city: 'New York', zip: '10001' } },
+ * //   'user.name': 'John',
+ * //   'user.address': { city: 'New York', zip: '10001' },
+ * //   'user.address.city': 'New York',
+ * //   'user.address.zip': '10001'
+ * // }
+ * ```
+ *
+ * @example
+ * Array handling:
+ * ```tsx
+ * const withArrays = {
+ *   items: [
+ *     { id: 1, name: 'Item 1' },
+ *     { id: 2, name: 'Item 2' }
+ *   ]
+ * };
+ *
+ * const flattened = flattenObjectKeys(withArrays);
+ * // Result includes:
+ * // {
+ * //   'items': [...],
+ * //   'items.0': { id: 1, name: 'Item 1' },
+ * //   'items.0.id': 1,
+ * //   'items.0.name': 'Item 1',
+ * //   'items.1': { id: 2, name: 'Item 2' },
+ * //   'items.1.id': 2,
+ * //   'items.1.name': 'Item 2'
+ * // }
+ * ```
+ *
+ * @param obj - The object to flatten
+ * @param prefix - Internal parameter for building key paths (used in recursion)
+ * @returns A flat object with dot-notation keys representing the original structure
+ *
+ * @public
+ */
+declare const flattenObjectKeys: (obj: any, prefix?: string) => {
+    [x: string]: any;
+};
+
+declare function getTimezone<TDate extends PickerValidDate>(adapter: ReturnType<typeof useLocalizationContext>, value: TDate): string | null;
+
+/**
+ * Configuration options for the handleServerErrors function.
+ *
+ * @template TFieldValues - The form values type
+ *
+ * @public
+ */
+interface HandleServerErrorsType<TFieldValues extends FieldValues = FieldValues> {
+    /**
+     * Server validation errors object containing field-specific error messages
+     * @example { email: 'Email is already taken', password: ['Too short', 'Must contain numbers'] }
+     */
+    errors?: ValidationErrors;
+    /**
+     * The setError function from react-hook-form for setting field errors
+     */
+    setError: UseFormSetError<TFieldValues>;
+}
+/**
+ * Processes server validation errors and applies them to react-hook-form fields.
+ *
+ * This utility function takes validation errors from a server response and automatically
+ * applies them to the corresponding form fields using react-hook-form's setError function.
+ * It supports various error formats including strings, arrays of strings, and boolean flags.
+ *
+ * The function uses object flattening to handle nested error structures and ensures
+ * that only valid field paths are processed.
+ *
+ * @example
+ * Basic usage with server response:
+ * ```tsx
+ * const { setError } = useForm();
+ *
+ * try {
+ *   await submitForm(data);
+ * } catch (error) {
+ *   handleServerErrors({
+ *     errors: error.response.data.errors,
+ *     setError
+ *   });
+ * }
+ * ```
+ *
+ * @example
+ * With different error formats:
+ * ```tsx
+ * const serverErrors = {
+ *   email: 'Email is already taken',
+ *   password: ['Too short', 'Must contain numbers'],
+ *   terms: true // Boolean flag indicating invalid
+ * };
+ *
+ * handleServerErrors({ errors: serverErrors, setError });
+ * // Results in:
+ * // - email field shows: "Email is already taken"
+ * // - password field shows: "Too short Must contain numbers"
+ * // - terms field shows: "Field is not valid."
+ * ```
+ *
+ * @template TFieldValues - The form values type
+ *
+ * @param args - Configuration object containing errors and setError function
+ *
+ * @public
+ */
+declare const handleServerErrors: <TFieldValues extends FieldValues = FieldValues>(args: HandleServerErrorsType<TFieldValues>) => void;
+
+/**
+ * Type-safe property existence checker that acts as a type guard.
+ *
+ * Checks if a given property exists on an object and narrows the TypeScript type
+ * to include that property. This is useful for safely accessing properties on
+ * objects of unknown structure while maintaining type safety.
+ *
+ * @template X - The type of the object being checked
+ * @template Y - The type of the property key (extends PropertyKey)
+ *
+ * @param obj - The object to check for the property
+ * @param prop - The property key to check for existence
+ *
+ * @returns A type predicate indicating whether the property exists on the object.
+ *          If true, the object type is narrowed to include the specified property.
+ *
+ * @example
+ * ```typescript
+ * const data: unknown = { name: "John", age: 30 };
+ *
+ * if (propertyExists(data, "name")) {
+ *   // TypeScript now knows data has a 'name' property
+ *   console.log(data.name); // Type-safe access
+ * }
+ *
+ * // Check for nested property existence
+ * if (propertyExists(obj, "user") && propertyExists(obj.user, "id")) {
+ *   console.log(obj.user.id); // Safe nested access
+ * }
+ * ```
+ *
+ * @since 2.18.45
+ */
+declare function propertyExists<X, Y extends PropertyKey>(obj: X, prop: Y): obj is X & Record<Y, unknown>;
+
+declare function readValueAsDate<TDate extends PickerValidDate>(adapter: ReturnType<typeof useLocalizationContext>, value: string | null | TDate): TDate | null;
+
+declare const removeLeadingTrailingSlashes: (route: string) => string;
+
+declare const schemaTools: {
+    date: ({ message }?: {
+        message?: string;
+    }) => z.ZodPipe<z.ZodCoercedString<unknown>, z.ZodTransform<string | null, string>>;
+    nullableDate: ({ message }?: {
+        message?: string;
+    }) => z.ZodPipe<z.ZodPipe<z.ZodCoercedString<unknown>, z.ZodTransform<string | null, string>>, z.ZodTransform<string | null, string | null>>;
+    dateRange: ({ message }?: {
+        message?: string;
+    }) => z.ZodObject<{
+        start: z.ZodCoercedDate<unknown>;
+        end: z.ZodCoercedDate<unknown>;
+    }, z.core.$strip>;
+    requiredString: ({ message, min, max }?: {
+        message?: string;
+        min?: number;
+        max?: number;
+    }) => z.ZodString;
+    email: ({ message }?: {
+        message?: string;
+    }) => z.ZodString;
+    url: ({ message }?: {
+        message?: string;
+    }) => z.ZodString;
+    phone: ({ message }?: {
+        message?: string;
+    }) => z.ZodString;
+    alphanumeric: ({ message }?: {
+        message?: string;
+    }) => z.ZodString;
+    slug: ({ message }?: {
+        message?: string;
+    }) => z.ZodString;
+    positiveNumber: ({ message, min, max }?: {
+        message?: string;
+        min?: number;
+        max?: number;
+    }) => z.ZodNumber;
+    nonNegativeNumber: ({ message, max }?: {
+        message?: string;
+        max?: number;
+    }) => z.ZodNumber;
+    integer: ({ message, min, max }?: {
+        message?: string;
+        min?: number;
+        max?: number;
+    }) => z.ZodNumber;
+    percentage: ({ message }?: {
+        message?: string;
+    }) => z.ZodNumber;
+    nonEmptyArray: <T>(schema: z.ZodSchema<T>, { message }?: {
+        message?: string;
+    }) => z.ZodArray<z.ZodType<T, unknown, z.core.$ZodTypeInternals<T, unknown>>>;
+    uniqueArray: <T>(schema: z.ZodSchema<T>, { message }?: {
+        message?: string;
+    }) => z.ZodArray<z.ZodType<T, unknown, z.core.$ZodTypeInternals<T, unknown>>>;
+    requiredBoolean: ({ message }?: {
+        message?: string;
+    }) => z.ZodBoolean;
+    nonEmptyObject: <T extends Record<string, unknown>>(schema: z.ZodSchema<T>, { message }?: {
+        message?: string;
+    }) => z.ZodType<T, unknown, z.core.$ZodTypeInternals<T, unknown>>;
+    fileSize: ({ maxSize, message }: {
+        maxSize: number;
+        message?: string;
+    }) => z.ZodCustom<File, File>;
+    fileType: ({ allowedTypes, message }: {
+        allowedTypes: string[];
+        message?: string;
+    }) => z.ZodCustom<File, File>;
+    conditional: <T, U>(condition: (data: T) => boolean, trueSchema: z.ZodSchema<U>, falseSchema: z.ZodSchema<U>) => z.ZodUnion<readonly [z.ZodType<U, unknown, z.core.$ZodTypeInternals<U, unknown>>, z.ZodType<U, unknown, z.core.$ZodTypeInternals<U, unknown>>]>;
+    transform: {
+        toLowerCase: z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>;
+        toUpperCase: z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>;
+        trim: z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>;
+        toNumber: z.ZodPipe<z.ZodString, z.ZodTransform<number, string>>;
+        toBoolean: z.ZodPipe<z.ZodString, z.ZodTransform<boolean, string>>;
+        parseJson: <T>(schema: z.ZodSchema<T>) => z.ZodPipe<z.ZodString, z.ZodTransform<Awaited<T>, string>>;
+    };
+};
+
+/**
+ * Core watch functions for React Hook Form
+ * These are the primary building blocks for form watching
+ */
+/**
+ * Utility type to ensure array elements are all Path<T>
+ */
+type PathArray<T extends FieldValues> = ReadonlyArray<Path<T>>;
+/**
+ * Hook to watch entire form - returns all form values
+ */
+declare const useWatchForm: <TFieldValues extends FieldValues>(control: Control<TFieldValues>) => DeepPartialSkipArrayKey<TFieldValues>;
+/**
+ * Hook to watch single field by path - supports any nested path
+ */
+declare const useWatchField: <TFieldValues extends FieldValues, TName extends Path<TFieldValues>>(control: Control<TFieldValues>, name: TName) => PathValue<TFieldValues, TName>;
+/**
+ * Hook to watch multiple fields by paths - returns array of values
+ */
+declare const useWatchFields: <TFieldValues extends FieldValues, TNames extends ReadonlyArray<Path<TFieldValues>>>(control: Control<TFieldValues>, names: TNames) => Array<PathValue<TFieldValues, TNames[number]>>;
+
+/**
+ * Utility watch functions for React Hook Form
+ * Enhanced functionality for specific use cases
+ */
+/**
+ * Watch field with transformation/selector
+ */
+declare const useWatchTransform: <TFieldValues extends FieldValues, TName extends Path<TFieldValues>, TOutput>(control: Control<TFieldValues>, name: TName, transform: (value: PathValue<TFieldValues, TName>) => TOutput) => TOutput;
+/**
+ * Watch field with default fallback value
+ */
+declare const useWatchDefault: <TFieldValues extends FieldValues, TName extends Path<TFieldValues>>(control: Control<TFieldValues>, name: TName, defaultValue: PathValue<TFieldValues, TName>) => PathValue<TFieldValues, TName>;
+/**
+ * Watch field as boolean with guaranteed boolean return
+ */
+declare const useWatchBoolean: <TFieldValues extends FieldValues, TName extends Path<TFieldValues>>(control: Control<TFieldValues>, name: TName, defaultValue?: boolean) => boolean;
+/**
+ * Watch multiple fields and return an object with field paths as keys
+ */
+declare const useWatchBatch: <TFieldValues extends FieldValues, TFields extends ReadonlyArray<Path<TFieldValues>>>(control: Control<TFieldValues>, fields: TFields) => { [K in TFields[number]]: PathValue<TFieldValues, K>; };
+/**
+ * Watch field conditionally based on boolean flag
+ */
+declare const useWatchConditional: <TFieldValues extends FieldValues, TName extends Path<TFieldValues>>(control: Control<TFieldValues>, name: TName, shouldWatch: boolean, fallback?: PathValue<TFieldValues, TName>) => PathValue<TFieldValues, TName> | undefined;
+/**
+ * Watch field with debounced updates
+ */
+declare const useWatchDebounced: <TFieldValues extends FieldValues, TName extends Path<TFieldValues>>(control: Control<TFieldValues>, name: TName, delay?: number) => PathValue<TFieldValues, TName>;
+/**
+ * Watch field with memoized selector function
+ */
+declare const useWatchSelector: <TFieldValues extends FieldValues, TName extends Path<TFieldValues>, TOutput>(control: Control<TFieldValues>, name: TName, selector: (value: PathValue<TFieldValues, TName>) => TOutput, deps?: React.DependencyList) => TOutput;
+
+/**
+ * Organized utilities by use case
+ * Provides a convenient object-based API for all watch functions
+ */
+declare const typedWatch: {
+    /** Watch entire form */
+    readonly form: <TFieldValues extends react_hook_form.FieldValues>(control: react_hook_form.Control<TFieldValues>) => react_hook_form.DeepPartialSkipArrayKey<TFieldValues>;
+    /** Watch single field */
+    readonly field: <TFieldValues extends react_hook_form.FieldValues, TName extends react_hook_form.Path<TFieldValues>>(control: react_hook_form.Control<TFieldValues>, name: TName) => react_hook_form.PathValue<TFieldValues, TName>;
+    /** Watch multiple fields */
+    readonly fields: <TFieldValues extends react_hook_form.FieldValues, TNames extends ReadonlyArray<react_hook_form.Path<TFieldValues>>>(control: react_hook_form.Control<TFieldValues>, names: TNames) => Array<react_hook_form.PathValue<TFieldValues, TNames[number]>>;
+    /** Watch with transformation */
+    readonly transform: <TFieldValues extends react_hook_form.FieldValues, TName extends react_hook_form.Path<TFieldValues>, TOutput>(control: react_hook_form.Control<TFieldValues>, name: TName, transform: (value: react_hook_form.PathValue<TFieldValues, TName>) => TOutput) => TOutput;
+    /** Watch with default value */
+    readonly withDefault: <TFieldValues extends react_hook_form.FieldValues, TName extends react_hook_form.Path<TFieldValues>>(control: react_hook_form.Control<TFieldValues>, name: TName, defaultValue: react_hook_form.PathValue<TFieldValues, TName>) => react_hook_form.PathValue<TFieldValues, TName>;
+    /** Watch as boolean */
+    readonly boolean: <TFieldValues extends react_hook_form.FieldValues, TName extends react_hook_form.Path<TFieldValues>>(control: react_hook_form.Control<TFieldValues>, name: TName, defaultValue?: boolean) => boolean;
+    /** Watch multiple with custom keys */
+    readonly batch: <TFieldValues extends react_hook_form.FieldValues, TFields extends ReadonlyArray<react_hook_form.Path<TFieldValues>>>(control: react_hook_form.Control<TFieldValues>, fields: TFields) => { [K in TFields[number]]: react_hook_form.PathValue<TFieldValues, K>; };
+    /** Watch conditionally */
+    readonly conditional: <TFieldValues extends react_hook_form.FieldValues, TName extends react_hook_form.Path<TFieldValues>>(control: react_hook_form.Control<TFieldValues>, name: TName, shouldWatch: boolean, fallback?: react_hook_form.PathValue<TFieldValues, TName>) => react_hook_form.PathValue<TFieldValues, TName> | undefined;
+    /** Watch with debouncing */
+    readonly debounced: <TFieldValues extends react_hook_form.FieldValues, TName extends react_hook_form.Path<TFieldValues>>(control: react_hook_form.Control<TFieldValues>, name: TName, delay?: number) => react_hook_form.PathValue<TFieldValues, TName>;
+    /** Watch with selector */
+    readonly selector: <TFieldValues extends react_hook_form.FieldValues, TName extends react_hook_form.Path<TFieldValues>, TOutput>(control: react_hook_form.Control<TFieldValues>, name: TName, selector: (value: react_hook_form.PathValue<TFieldValues, TName>) => TOutput, deps?: React.DependencyList) => TOutput;
+};
+
+export { type PathArray, api, api2, flattenObjectKeys, getTimezone, handleServerErrors, propertyExists, readValueAsDate, removeLeadingTrailingSlashes, schemaTools, typedWatch, useWatchBatch, useWatchBoolean, useWatchConditional, useWatchDebounced, useWatchDefault, useWatchField, useWatchFields, useWatchForm, useWatchSelector, useWatchTransform };