@gnwebsoft/ui 4.0.0 → 4.0.1

package/dist/utils/index.d.ts

@@ -1,683 +0,0 @@
-import { PostModel, ApiResponse, ListResponse, JsonObject, RequestOptions, ValidationErrors } from '../types/index.js';
-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';
-import '../AsyncSelectPayload-B9-6l33R.js';
-import '../events-BcHVCLBz.js';
-import 'react';
-
-declare class api {
-    static filter<T, TFilter>(url: string, postModel: PostModel<TFilter>): Promise<ApiResponse<ListResponse<T>>>;
-    static post<T>(url: string, body?: JsonObject): 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?: JsonObject): Promise<ApiResponse<T>>;
-    static fetch(url: string, options?: RequestInit): Promise<Response>;
-    static tempFetch<T>(url: string, options?: RequestOptions): 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?: JsonObject): 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?: JsonObject): Promise<ApiResponse<T>>;
-    static fetch(url: string, options?: RequestInit): Promise<Response>;
-    static tempFetch<T>(url: string, options?: RequestOptions): 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: unknown, prefix?: string) => Record<string, unknown>;
-
-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;
-};
-
-/**
- * Type guard utilities for runtime type checking
- *
- * @packageDocumentation
- */
-/**
- * Type guard to check if a value is a non-null object (excluding arrays)
- *
- * @param value - The value to check
- * @returns True if the value is a plain object
- *
- * @example
- * ```typescript
- * if (isRecord(value)) {
- *   // value is Record<string, unknown>
- *   const keys = Object.keys(value);
- * }
- * ```
- *
- * @public
- */
-declare function isRecord(value: unknown): value is Record<string, unknown>;
-/**
- * Type guard to check if an object has a specific property
- *
- * @param obj - The object to check
- * @param key - The property key to look for
- * @returns True if the object has the property
- *
- * @example
- * ```typescript
- * if (hasProperty(obj, 'name')) {
- *   // obj is Record<'name', unknown>
- *   console.log(obj.name);
- * }
- * ```
- *
- * @public
- */
-declare function hasProperty<K extends PropertyKey>(obj: unknown, key: K): obj is Record<K, unknown>;
-/**
- * Type guard to check if a value is a non-empty string
- *
- * @param value - The value to check
- * @returns True if the value is a non-empty string
- *
- * @example
- * ```typescript
- * if (isNonEmptyString(value)) {
- *   // value is string with length > 0
- *   console.log(value.toUpperCase());
- * }
- * ```
- *
- * @public
- */
-declare function isNonEmptyString(value: unknown): value is string;
-/**
- * Type guard to check if a value is a valid array
- *
- * @param value - The value to check
- * @returns True if the value is an array
- *
- * @example
- * ```typescript
- * if (isArray(value)) {
- *   // value is unknown[]
- *   value.forEach(item => console.log(item));
- * }
- * ```
- *
- * @public
- */
-declare function isArray<T = unknown>(value: unknown): value is T[];
-/**
- * Type guard to check if a value is a non-empty array
- *
- * @param value - The value to check
- * @returns True if the value is a non-empty array
- *
- * @example
- * ```typescript
- * if (isNonEmptyArray(items)) {
- *   // items is [T, ...T[]] - guaranteed to have at least one element
- *   const first = items[0];  // Safe access
- * }
- * ```
- *
- * @public
- */
-declare function isNonEmptyArray<T>(value: unknown): value is [T, ...T[]];
-/**
- * Type guard to check if a value is a function
- *
- * @param value - The value to check
- * @returns True if the value is a function
- *
- * @example
- * ```typescript
- * if (isFunction(callback)) {
- *   // callback is (...args: unknown[]) => unknown
- *   callback();
- * }
- * ```
- *
- * @public
- */
-declare function isFunction(value: unknown): value is (...args: readonly unknown[]) => unknown;
-/**
- * Type guard to check if a value is a string
- *
- * @param value - The value to check
- * @returns True if the value is a string (including empty string)
- *
- * @example
- * ```typescript
- * if (isString(value)) {
- *   // value is string
- *   console.log(value.length);
- * }
- * ```
- *
- * @public
- */
-declare function isString(value: unknown): value is string;
-/**
- * Type guard to check if a value is a number (excluding NaN)
- *
- * @param value - The value to check
- * @returns True if the value is a valid number
- *
- * @example
- * ```typescript
- * if (isNumber(value)) {
- *   // value is number (not NaN)
- *   const doubled = value * 2;
- * }
- * ```
- *
- * @public
- */
-declare function isNumber(value: unknown): value is number;
-/**
- * Type guard to check if a value is a boolean
- *
- * @param value - The value to check
- * @returns True if the value is a boolean
- *
- * @example
- * ```typescript
- * if (isBoolean(value)) {
- *   // value is boolean
- *   console.log(!value);
- * }
- * ```
- *
- * @public
- */
-declare function isBoolean(value: unknown): value is boolean;
-/**
- * Type guard to check if a value is null
- *
- * @param value - The value to check
- * @returns True if the value is null
- *
- * @example
- * ```typescript
- * if (isNull(value)) {
- *   // value is null
- *   return defaultValue;
- * }
- * ```
- *
- * @public
- */
-declare function isNull(value: unknown): value is null;
-/**
- * Type guard to check if a value is undefined
- *
- * @param value - The value to check
- * @returns True if the value is undefined
- *
- * @example
- * ```typescript
- * if (isUndefined(value)) {
- *   // value is undefined
- *   return defaultValue;
- * }
- * ```
- *
- * @public
- */
-declare function isUndefined(value: unknown): value is undefined;
-/**
- * Type guard to check if a value is null or undefined
- *
- * @param value - The value to check
- * @returns True if the value is nullish
- *
- * @example
- * ```typescript
- * if (isNullish(value)) {
- *   // value is null | undefined
- *   return defaultValue;
- * }
- *
- * if (!isNullish(value)) {
- *   // value is NonNullable<typeof value>
- *   console.log(value);
- * }
- * ```
- *
- * @public
- */
-declare function isNullish(value: unknown): value is null | undefined;
-/**
- * Type guard to check if a value is defined (not null or undefined)
- *
- * @param value - The value to check
- * @returns True if the value is not null or undefined
- *
- * @example
- * ```typescript
- * const filtered = items.filter(isDefined);
- * // filtered has type: NonNullable<T>[]
- * ```
- *
- * @public
- */
-declare function isDefined<T>(value: T): value is NonNullable<T>;
-/**
- * Type guard to check if a value is a Date object
- *
- * @param value - The value to check
- * @returns True if the value is a Date
- *
- * @example
- * ```typescript
- * if (isDate(value)) {
- *   // value is Date
- *   console.log(value.toISOString());
- * }
- * ```
- *
- * @public
- */
-declare function isDate(value: unknown): value is Date;
-/**
- * Type guard to check if a value is a Promise
- *
- * @param value - The value to check
- * @returns True if the value is a Promise
- *
- * @example
- * ```typescript
- * if (isPromise(value)) {
- *   // value is Promise<unknown>
- *   const result = await value;
- * }
- * ```
- *
- * @public
- */
-declare function isPromise(value: unknown): value is Promise<unknown>;
-/**
- * Type guard to check if an error is an Error instance
- *
- * @param error - The error to check
- * @returns True if the error is an Error instance
- *
- * @example
- * ```typescript
- * try {
- *   // ...
- * } catch (error) {
- *   if (isError(error)) {
- *     // error is Error
- *     console.error(error.message);
- *   }
- * }
- * ```
- *
- * @public
- */
-declare function isError(error: unknown): error is Error;
-/**
- * Type guard to check if a value matches a specific type using a validator function
- *
- * @param value - The value to check
- * @param validator - Function that returns true if value matches the type
- * @returns True if the value matches the type
- *
- * @example
- * ```typescript
- * interface User {
- *   id: string;
- *   name: string;
- * }
- *
- * const isUser = (value: unknown): value is User =>
- *   isRecord(value) &&
- *   hasProperty(value, 'id') &&
- *   hasProperty(value, 'name') &&
- *   isString(value.id) &&
- *   isString(value.name);
- *
- * if (isUser(data)) {
- *   // data is User
- *   console.log(data.name);
- * }
- * ```
- *
- * @public
- */
-declare function matches<T>(value: unknown, validator: (value: unknown) => value is T): value is T;
-
-export { type PathArray, api, api2, flattenObjectKeys, getTimezone, handleServerErrors, hasProperty, isArray, isBoolean, isDate, isDefined, isError, isFunction, isNonEmptyArray, isNonEmptyString, isNull, isNullish, isNumber, isPromise, isRecord, isString, isUndefined, matches, propertyExists, readValueAsDate, removeLeadingTrailingSlashes, schemaTools, typedWatch, useWatchBatch, useWatchBoolean, useWatchConditional, useWatchDebounced, useWatchDefault, useWatchField, useWatchFields, useWatchForm, useWatchSelector, useWatchTransform };