@webority-technologies/mobile 0.0.22 → 0.0.24

package/lib/typescript/commonjs/components/OTPInput/OTPInput.d.ts

@@ -1,5 +1,6 @@
 import React from 'react';
 import type { StyleProp, TextStyle, ViewStyle } from 'react-native';
+import type { HapticType } from '../../utils';
 export type OTPInputSize = 'sm' | 'md' | 'lg';
 export interface OTPInputRef {
     focus: () => void;
@@ -7,8 +8,9 @@ export interface OTPInputRef {
     clear: () => void;
 }
 export interface OTPInputProps {
-    value: string;
-    onChange: (value: string) => void;
+    value?: string;
+    defaultValue?: string;
+    onChange?: (value: string) => void;
     onComplete?: (value: string) => void;
     length?: number;
     keyboardType?: 'number-pad' | 'default';
@@ -17,6 +19,11 @@ export interface OTPInputProps {
     error?: boolean | string;
     size?: OTPInputSize;
     secure?: boolean;
+    /**
+     * Haptic feedback for interactions. Pass false to disable; pass a HapticType
+     * to override the default.
+     */
+    haptic?: HapticType | false;
     accessibilityLabel?: string;
     style?: StyleProp<ViewStyle>;
     cellStyle?: StyleProp<ViewStyle>;

package/lib/typescript/commonjs/components/Radio/Radio.d.ts

@@ -7,7 +7,7 @@ export type RadioTone = 'primary' | 'success' | 'warning' | 'error';
 export type RadioValue = string | number;
 export interface RadioGroupContextValue {
     selectedValue: RadioValue | undefined;
-    onSelect: (value: RadioValue) => void;
+    onChange: (value: RadioValue) => void;
     disabled: boolean;
 }
 export declare const RadioGroupContext: React.Context<RadioGroupContextValue | null>;
@@ -15,7 +15,7 @@ export declare const useRadioGroup: () => RadioGroupContextValue | null;
 export interface RadioProps extends Omit<PressableProps, 'style' | 'children' | 'onPress'> {
     value: RadioValue;
     selected?: boolean;
-    onSelect?: (value: RadioValue) => void;
+    onChange?: (value: RadioValue) => void;
     disabled?: boolean;
     label?: string;
     size?: RadioSize;

package/lib/typescript/commonjs/components/Radio/RadioGroup.d.ts

@@ -2,8 +2,9 @@ import React from 'react';
 import type { StyleProp, ViewStyle } from 'react-native';
 import type { RadioValue } from './Radio';
 export interface RadioGroupProps {
-    value: RadioValue;
-    onChange: (value: RadioValue) => void;
+    value?: RadioValue;
+    defaultValue?: RadioValue;
+    onChange?: (value: RadioValue) => void;
     children: React.ReactNode;
     disabled?: boolean;
     accessibilityLabel?: string;

package/lib/typescript/commonjs/components/Rating/Rating.d.ts

@@ -1,5 +1,6 @@
 import React from 'react';
 import type { StyleProp, View as RNView, ViewStyle } from 'react-native';
+import type { HapticType } from '../../utils/hapticUtils';
 export type RatingTone = 'primary' | 'warning';
 export type RatingSize = 'sm' | 'md' | 'lg' | number;
 export interface RatingProps {
@@ -17,6 +18,11 @@ export interface RatingProps {
      * when data arrives. Use this while the data driving the component is being fetched.
      */
     loading?: boolean;
+    /**
+     * Haptic feedback for interactions. Pass false to disable; pass a HapticType
+     * to override the default.
+     */
+    haptic?: HapticType | false;
     accessibilityLabel?: string;
     style?: StyleProp<ViewStyle>;
     containerStyle?: StyleProp<ViewStyle>;

package/lib/typescript/commonjs/components/SearchBar/SearchBar.d.ts

@@ -1,6 +1,7 @@
 import React from 'react';
 import { TextInput } from 'react-native';
 import type { StyleProp, TextInputProps, ViewStyle } from 'react-native';
+import type { HapticType } from '../../utils/hapticUtils';
 export type SearchBarSize = 'sm' | 'md' | 'lg';
 export type SearchBarVariant = 'filled' | 'outlined';
 export interface SearchBarProps extends Omit<TextInputProps, 'style' | 'value' | 'onChangeText'> {
@@ -19,6 +20,8 @@ export interface SearchBarProps extends Omit<TextInputProps, 'style' | 'value' |
     size?: SearchBarSize;
     variant?: SearchBarVariant;
     cancelLabel?: string;
+    /** Haptic feedback for interactions. Pass false to disable; pass a HapticType to override the default. */
+    haptic?: HapticType | false;
     style?: StyleProp<ViewStyle>;
     accessibilityLabel?: string;
     testID?: string;

package/lib/typescript/commonjs/components/SegmentedControl/SegmentedControl.d.ts

@@ -8,6 +8,7 @@
 import React from 'react';
 import { View } from 'react-native';
 import type { StyleProp, TextStyle, ViewStyle } from 'react-native';
+import type { HapticType } from '../../utils';
 export type SegmentedControlSize = 'sm' | 'md';
 export type SegmentedControlTone = 'primary' | 'neutral';
 export type SegmentValue = string | number;
@@ -18,12 +19,15 @@ export interface SegmentItem {
 }
 export interface SegmentedControlProps {
     segments: SegmentItem[];
-    value: SegmentValue;
-    onChange: (value: SegmentValue) => void;
+    value?: SegmentValue;
+    defaultValue?: SegmentValue;
+    onChange?: (value: SegmentValue) => void;
     size?: SegmentedControlSize;
     fullWidth?: boolean;
     disabled?: boolean;
     tone?: SegmentedControlTone;
+    /** Haptic feedback for interactions. Pass false to disable; pass a HapticType to override the default. */
+    haptic?: HapticType | false;
     accessibilityLabel?: string;
     style?: StyleProp<ViewStyle>;
     containerStyle?: StyleProp<ViewStyle>;

package/lib/typescript/commonjs/components/Select/Select.d.ts

@@ -8,6 +8,7 @@
 import React from 'react';
 import { View } from 'react-native';
 import type { StyleProp, TextStyle, ViewStyle } from 'react-native';
+import type { HapticType } from '../../utils';
 export type SelectSize = 'sm' | 'md' | 'lg';
 export type SelectValue = string | number;
 export interface SelectOption {
@@ -38,6 +39,11 @@ interface BaseSelectProps<T = SelectOption> {
     getOptionIcon?: (option: T) => React.ReactNode;
     placeholder?: string;
     searchable?: boolean;
+    /**
+     * Haptic feedback for interactions. Pass false to disable; pass a HapticType
+     * to override the default.
+     */
+    haptic?: HapticType | false;
     label?: string;
     error?: string;
     disabled?: boolean;

package/lib/typescript/commonjs/components/Slider/Slider.d.ts

@@ -1,6 +1,7 @@
 import React from 'react';
 import { View } from 'react-native';
 import type { StyleProp, TextStyle, ViewStyle } from 'react-native';
+import type { HapticType } from '../../utils';
 export type SliderTone = 'primary' | 'success' | 'warning' | 'error';
 export type SliderSize = 'sm' | 'md' | 'lg';
 interface SliderCommonProps {
@@ -13,6 +14,8 @@ interface SliderCommonProps {
     showLabel?: boolean;
     formatLabel?: (value: number) => string;
     accessibilityLabel?: string;
+    /** Haptic feedback for drag/step/tap. Pass false to disable; pass a HapticType to override. */
+    haptic?: HapticType | false;
     style?: StyleProp<ViewStyle>;
     containerStyle?: StyleProp<ViewStyle>;
     trackStyle?: StyleProp<ViewStyle>;
@@ -29,13 +32,15 @@ interface SliderCommonProps {
 }
 interface SliderSingleProps extends SliderCommonProps {
     range?: false;
-    value: number;
-    onChange: (value: number) => void;
+    value?: number;
+    defaultValue?: number;
+    onChange?: (value: number) => void;
 }
 interface SliderRangeProps extends SliderCommonProps {
     range: true;
-    value: [number, number];
-    onChange: (value: [number, number]) => void;
+    value?: [number, number];
+    defaultValue?: [number, number];
+    onChange?: (value: [number, number]) => void;
 }
 export type SliderProps = SliderSingleProps | SliderRangeProps;
 declare const Slider: React.ForwardRefExoticComponent<SliderProps & React.RefAttributes<View>>;

package/lib/typescript/commonjs/components/Spinner/Spinner.d.ts

@@ -1,7 +1,7 @@
 import React from 'react';
 import { View } from 'react-native';
 import type { StyleProp, ViewStyle } from 'react-native';
-export type SpinnerSize = 'small' | 'medium' | 'large';
+export type SpinnerSize = 'sm' | 'md' | 'lg';
 export type SpinnerVariant = 'circular' | 'dots';
 export interface SpinnerProps {
     size?: SpinnerSize;

package/lib/typescript/commonjs/components/Stepper/Stepper.d.ts

@@ -1,5 +1,6 @@
 import React from 'react';
 import type { StyleProp, TextStyle, View as RNView, ViewStyle } from 'react-native';
+import type { HapticType } from '../../utils/hapticUtils';
 export type StepperVariant = 'horizontal' | 'vertical';
 export type StepperTone = 'primary' | 'success';
 export interface StepperStep {
@@ -33,6 +34,11 @@ export interface StepperProps {
     circleStyle?: StyleProp<ViewStyle>;
     labelStyle?: StyleProp<TextStyle>;
     connectorStyle?: StyleProp<ViewStyle>;
+    /**
+     * Haptic feedback for interactions. Pass false to disable; pass a HapticType
+     * to override the default.
+     */
+    haptic?: HapticType | false;
     testID?: string;
 }
 declare const Stepper: React.ForwardRefExoticComponent<StepperProps & React.RefAttributes<RNView>> & {

package/lib/typescript/commonjs/components/Swipeable/Swipeable.d.ts

@@ -16,6 +16,7 @@
  */
 import React from 'react';
 import type { StyleProp, ViewStyle } from 'react-native';
+import type { HapticType } from '../../utils';
 export type SwipeableTone = 'primary' | 'success' | 'warning' | 'error' | 'neutral';
 export interface SwipeableAction {
     key: string;
@@ -35,6 +36,8 @@ export interface SwipeableProps {
     onSwipeOpen?: (side: 'left' | 'right') => void;
     onSwipeClose?: () => void;
     disabled?: boolean;
+    /** Haptic feedback for interactions. Pass false to disable; pass a HapticType to override the default. */
+    haptic?: HapticType | false;
     containerStyle?: StyleProp<ViewStyle>;
     contentStyle?: StyleProp<ViewStyle>;
     actionStyle?: StyleProp<ViewStyle>;

package/lib/typescript/commonjs/components/Switch/Switch.d.ts

@@ -5,8 +5,9 @@ import type { HapticType } from '../../utils/hapticUtils';
 export type SwitchSize = 'sm' | 'md' | 'lg';
 export type SwitchTone = 'primary' | 'success' | 'warning' | 'error';
 export interface SwitchProps extends Omit<PressableProps, 'style' | 'children' | 'onPress'> {
-    value: boolean;
-    onValueChange: (value: boolean) => void;
+    value?: boolean;
+    defaultValue?: boolean;
+    onChange?: (value: boolean) => void;
     disabled?: boolean;
     size?: SwitchSize;
     tone?: SwitchTone;

package/lib/typescript/commonjs/components/Tabs/Tabs.d.ts

@@ -11,6 +11,7 @@
 import React from 'react';
 import { Animated, View } from 'react-native';
 import type { StyleProp, TextStyle, ViewStyle } from 'react-native';
+import type { HapticType } from '../../utils';
 export type TabsVariant = 'underline' | 'pills';
 export type TabsAlign = 'left' | 'center';
 export interface TabItem {
@@ -52,6 +53,8 @@ export interface TabsProps {
      * progress value catches up.
      */
     progress?: Animated.AnimatedInterpolation<number> | Animated.Value;
+    /** Haptic feedback for interactions. Pass false to disable; pass a HapticType to override the default. */
+    haptic?: HapticType | false;
     accessibilityLabel?: string;
     testID?: string;
 }

package/lib/typescript/commonjs/components/Text/Text.d.ts

@@ -0,0 +1,25 @@
+import React from 'react';
+import { Text as RNText } from 'react-native';
+import type { StyleProp, TextProps as RNTextProps, TextStyle } from 'react-native';
+import type { FontWeightKey } from '../../theme';
+import type { TypographyScale } from '../../theme/types';
+export type TextVariant = 'display' | 'h1' | 'h2' | 'h3' | 'title' | 'body' | 'bodySmall' | 'caption' | 'label' | 'overline';
+export type TextColor = 'primary' | 'secondary' | 'tertiary' | 'inverse' | 'disabled' | 'link' | 'success' | 'warning' | 'error' | 'info';
+export interface TextProps extends Omit<RNTextProps, 'style'> {
+    variant?: TextVariant;
+    /** Text role token, semantic tone, or a raw colour string. Defaults per variant. */
+    color?: TextColor | (string & {});
+    /** Override the variant's weight. */
+    weight?: FontWeightKey;
+    /** Override the variant's size — a typography token or a pixel number. */
+    size?: keyof TypographyScale['fontSize'] | number;
+    align?: TextStyle['textAlign'];
+    italic?: boolean;
+    underline?: boolean;
+    children?: React.ReactNode;
+    style?: StyleProp<TextStyle>;
+}
+declare const Text: React.ForwardRefExoticComponent<TextProps & React.RefAttributes<RNText>>;
+export { Text };
+export default Text;
+//# sourceMappingURL=Text.d.ts.map

package/lib/typescript/commonjs/components/Text/index.d.ts

@@ -0,0 +1,3 @@
+export { Text } from './Text';
+export type { TextProps, TextVariant, TextColor } from './Text';
+//# sourceMappingURL=index.d.ts.map

package/lib/typescript/commonjs/components/TimePicker/TimePicker.d.ts

@@ -1,5 +1,6 @@
 import React from 'react';
 import type { StyleProp, ViewStyle } from 'react-native';
+import type { HapticType } from '../../utils/hapticUtils';
 import type { FieldBaseSize, FieldBaseVariant } from '../FieldBase';
 export type TimeFormat = '12h' | '24h';
 export type Period = 'AM' | 'PM';
@@ -11,19 +12,19 @@ export interface TimeValue {
 /**
  * TimePicker supports two modes:
  *
- * 1. Controlled-modal mode — pass `visible`, `onSelect`, `onClose`. The
+ * 1. Controlled-modal mode — pass `visible`, `onChange`, `onClose`. The
  *    component renders only the modal sheet and the caller owns open/close
  *    state plus its own trigger UI.
  * 2. Trigger mode — omit `visible`. The component renders a PickerTrigger
  *    field (label / value / placeholder / chevron / clear / helper / error)
- *    and manages its own modal open state. `onSelect` is still called on
+ *    and manages its own modal open state. `onChange` is still called on
  *    confirm.
  */
 export interface TimePickerProps {
     /** Controlled-modal visibility. When omitted, the component enters trigger mode. */
     visible?: boolean;
     value?: TimeValue | null;
-    onSelect?: (time: TimeValue) => void;
+    onChange?: (time: TimeValue) => void;
     onClose?: () => void;
     format?: TimeFormat;
     minuteStep?: MinuteStep;
@@ -52,6 +53,8 @@ export interface TimePickerProps {
     formatValue?: (time: TimeValue) => string;
     /** Style passed through to the PickerTrigger field row. */
     triggerStyle?: StyleProp<ViewStyle>;
+    /** Haptic feedback for interactions. Pass false to disable; pass a HapticType to override the default. */
+    haptic?: HapticType | false;
 }
 declare const TimePicker: React.FC<TimePickerProps>;
 export { TimePicker };

package/lib/typescript/commonjs/components/index.d.ts

@@ -1,5 +1,7 @@
 export { Accordion, AccordionGroup } from './Accordion';
 export type { AccordionProps, AccordionGroupProps, AccordionVariant } from './Accordion';
+export { AnimatePresence } from './AnimatePresence';
+export type { AnimatePresenceProps, PresencePreset } from './AnimatePresence';
 export { Avatar, AvatarGroup } from './Avatar';
 export type { AvatarProps, AvatarShape, AvatarSize, AvatarStatus, AvatarGroupProps, AvatarGroupSpacing, AvatarGroupOverflowVariant } from './Avatar';
 export { Badge } from './Badge';
@@ -12,6 +14,14 @@ export { BottomSheet, useBottomSheet } from './BottomSheet';
 export type { BottomSheetContextValue, BottomSheetProps, BottomSheetRef } from './BottomSheet';
 export { Button } from './Button';
 export type { ButtonProps, ButtonVariant, ButtonTone, ButtonSize } from './Button';
+export { Box, Stack, Row, Spacer } from './Box';
+export type { BoxProps, StackProps, RowProps, SpacerProps } from './Box';
+export { Text } from './Text';
+export type { TextProps, TextVariant, TextColor } from './Text';
+export { KeyboardAwareScrollView } from './KeyboardAwareScrollView';
+export type { KeyboardAwareScrollViewProps } from './KeyboardAwareScrollView';
+export { KeyboardToolbar } from './KeyboardToolbar';
+export type { KeyboardToolbarProps } from './KeyboardToolbar';
 export { Card } from './Card';
 export type { CardProps, CardVariant, CardElevation, CardPadding, CardRadius } from './Card';
 export { Carousel } from './Carousel';

package/lib/typescript/commonjs/form/FormContext.d.ts

@@ -0,0 +1,17 @@
+import React from 'react';
+import type { FormApi, FormValues } from './types';
+export interface FormProps {
+    /** The object returned by {@link useForm}. */
+    form: FormApi<FormValues>;
+    children: React.ReactNode;
+}
+/**
+ * Provides a {@link useForm} instance to descendants so `<FormField name>`,
+ * {@link useField} and {@link useFieldArray} can bind by name.
+ */
+export declare const Form: React.FC<FormProps>;
+/** Read the surrounding form. Throws if there is no `<Form>` ancestor. */
+export declare function useFormContext<Values extends FormValues = FormValues>(): FormApi<Values>;
+/** Read the surrounding form, or null when there is no `<Form>` ancestor. */
+export declare function useOptionalFormContext(): FormApi<FormValues> | null;
+//# sourceMappingURL=FormContext.d.ts.map

package/lib/typescript/commonjs/form/index.d.ts

@@ -0,0 +1,9 @@
+export { useForm } from './useForm';
+export { useField, useFieldArray } from './useField';
+export type { FieldArrayApi } from './useField';
+export { Form, useFormContext, useOptionalFormContext } from './FormContext';
+export type { FormProps } from './FormContext';
+export { getPath, setPath, deletePath } from './path';
+export * as rules from './rules';
+export type { FormApi, FormConfig, FormValues, FormErrors, FormTouched, FieldState, FieldInputProps, FocusableNode, ValidationRule, ValidationResult, FieldRules, ValidationSchema, FormValidateFn, ValidateOn, SubmitHelpers } from './types';
+//# sourceMappingURL=index.d.ts.map

package/lib/typescript/commonjs/form/path.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Immutable get/set/delete for dot- and bracket-notation field paths
+ * ("address.city", "phones[0]", "items[2].qty"). Lets a single flat `name`
+ * string address nested values and array items, so the form engine can treat
+ * every field uniformly regardless of how deep it lives in the value tree.
+ */
+export declare const getPath: (obj: unknown, path: string) => unknown;
+export declare const setPath: <T>(obj: T, path: string, value: unknown) => T;
+export declare const deletePath: <T>(obj: T, path: string) => T;
+//# sourceMappingURL=path.d.ts.map

package/lib/typescript/commonjs/form/rules.d.ts

@@ -0,0 +1,31 @@
+import type { PasswordRules } from '../validators';
+import type { FormValues, ValidationRule } from './types';
+export declare const required: (message?: string) => ValidationRule;
+export declare const email: (message?: string) => ValidationRule;
+export declare const mobile: (message?: string) => ValidationRule;
+export declare const phone: (message?: string) => ValidationRule;
+export declare const url: (message?: string) => ValidationRule;
+export declare const numeric: (message?: string) => ValidationRule;
+export declare const integer: (message?: string) => ValidationRule;
+export declare const alphanumeric: (message?: string) => ValidationRule;
+export declare const pincode: (message?: string) => ValidationRule;
+export declare const pan: (message?: string) => ValidationRule;
+export declare const gstin: (message?: string) => ValidationRule;
+export declare const aadhaar: (message?: string) => ValidationRule;
+export declare const ifsc: (message?: string) => ValidationRule;
+export declare const minLength: (length: number, message?: string) => ValidationRule;
+export declare const maxLength: (length: number, message?: string) => ValidationRule;
+export declare const min: (n: number, message?: string) => ValidationRule;
+export declare const max: (n: number, message?: string) => ValidationRule;
+export declare const pattern: (regex: RegExp, message?: string) => ValidationRule;
+export declare const oneOf: (allowed: readonly unknown[], message?: string) => ValidationRule;
+/** Cross-field equality (e.g. confirm-password). `otherField` is a field path. */
+export declare const matches: (otherField: string, message?: string) => ValidationRule<unknown, FormValues>;
+export declare const strongPassword: (rules?: PasswordRules, message?: string) => ValidationRule;
+/**
+ * Wrap any custom check. Return `true` (valid), `false` (invalid → default
+ * message), or a string (invalid → that message). Async is supported — return
+ * a Promise of the same.
+ */
+export declare const custom: (fn: (value: any, allValues: FormValues) => boolean | string | Promise<boolean | string>, message?: string) => ValidationRule;
+//# sourceMappingURL=rules.d.ts.map

package/lib/typescript/commonjs/form/types.d.ts

@@ -0,0 +1,94 @@
+export type FormValues = Record<string, unknown>;
+export type FormErrors = Record<string, string | undefined>;
+export type FormTouched = Record<string, boolean>;
+export type ValidationResult = string | undefined | null | false;
+/**
+ * A single validation rule. Receives the field value and the whole values
+ * object (so cross-field rules work). Return an error message string when
+ * invalid, or any falsy value when valid. May be async — return a Promise for
+ * server-side checks ("is this email already registered?").
+ */
+export type ValidationRule<V = any, Values extends FormValues = FormValues> = (value: V, allValues: Values) => ValidationResult | Promise<ValidationResult>;
+export type FieldRules<V = any, Values extends FormValues = FormValues> = ValidationRule<V, Values> | ValidationRule<V, Values>[];
+/** Per-field rule map keyed by field path (e.g. `{ email: [rules.required(), rules.email()] }`). */
+export type ValidationSchema<Values extends FormValues = FormValues> = Record<string, FieldRules<any, Values>>;
+/** Form-level validate function returning an errors map keyed by field path. */
+export type FormValidateFn<Values extends FormValues = FormValues> = (values: Values) => FormErrors | Promise<FormErrors>;
+export type ValidateOn = 'change' | 'blur' | 'submit';
+export interface SubmitHelpers<Values extends FormValues = FormValues> {
+    setErrors: (errors: FormErrors) => void;
+    setFieldError: (name: string, error?: string) => void;
+    reset: (nextValues?: Partial<Values>) => void;
+    setSubmitting: (submitting: boolean) => void;
+}
+export interface FormConfig<Values extends FormValues = FormValues> {
+    initialValues: Values;
+    /** Either a per-field rule map or a single form-level validate function. */
+    validate?: ValidationSchema<Values> | FormValidateFn<Values>;
+    /** When validation first runs for a field. Library default: 'submit'. */
+    validateOn?: ValidateOn;
+    /** After a field has surfaced an error once, how it re-validates. Library default: 'change'. */
+    revalidateOn?: 'change' | 'blur';
+    onSubmit: (values: Values, helpers: SubmitHelpers<Values>) => void | Promise<void>;
+    /** Re-initialise values when `initialValues` changes (e.g. async-loaded edit form). Default: false. */
+    enableReinitialize?: boolean;
+}
+export interface FieldState<V = unknown> {
+    value: V;
+    /** Error the UI should show (gated by touched / submit). */
+    error: string | undefined;
+    /** Error regardless of touched — useful for `isValid`-style logic. */
+    rawError: string | undefined;
+    touched: boolean;
+    dirty: boolean;
+}
+/** Props an input needs to bind to a form field. Covers text and non-text controls. */
+export interface FieldInputProps<V = unknown> {
+    name: string;
+    value: V;
+    error: string | undefined;
+    touched: boolean;
+    /** Generic change handler (Select/Switch/DatePicker/Slider…). */
+    onChange: (value: V) => void;
+    /** Text-input alias of `onChange` (TextInput's `onChangeText`). */
+    onChangeText: (text: string) => void;
+    onBlur: () => void;
+    /** Marks this field as the focused one (drives KeyboardToolbar next/prev). */
+    onFocus: () => void;
+    setValue: (value: V, shouldValidate?: boolean) => void;
+}
+export interface FocusableNode {
+    focus?: () => void;
+    measureInWindow?: (cb: (x: number, y: number, w: number, h: number) => void) => void;
+}
+export interface FormApi<Values extends FormValues = FormValues> {
+    values: Values;
+    /** Touched/submit-gated errors — what the UI shows. */
+    errors: FormErrors;
+    /** Every current error regardless of touched. */
+    rawErrors: FormErrors;
+    touched: FormTouched;
+    dirty: boolean;
+    isValid: boolean;
+    isSubmitting: boolean;
+    isValidating: boolean;
+    submitCount: number;
+    setFieldValue: (name: string, value: unknown, shouldValidate?: boolean) => void;
+    setFieldTouched: (name: string, touched?: boolean, shouldValidate?: boolean) => void;
+    setFieldError: (name: string, error?: string) => void;
+    setValues: (next: Partial<Values> | ((prev: Values) => Values), shouldValidate?: boolean) => void;
+    setErrors: (errors: FormErrors) => void;
+    reset: (nextValues?: Partial<Values>) => void;
+    validate: () => Promise<FormErrors>;
+    validateField: (name: string) => Promise<string | undefined>;
+    submit: () => void;
+    getFieldState: (name: string) => FieldState;
+    getFieldProps: (name: string) => FieldInputProps;
+    handleBlur: (name: string) => void;
+    /** Move focus to the next / previous registered field (used by KeyboardToolbar). */
+    focusNext: () => void;
+    focusPrev: () => void;
+    /** Registers a focusable node so a failed submit can focus the first error. */
+    registerField: (name: string, node: FocusableNode | null) => void;
+}
+//# sourceMappingURL=types.d.ts.map

package/lib/typescript/commonjs/form/useField.d.ts

@@ -0,0 +1,27 @@
+import type { FieldInputProps } from './types';
+/**
+ * Bind a single field by name. Returns everything an input needs; pick the
+ * handler your control uses:
+ *   const email = useField('email');
+ *   <Input value={email.value} onChangeText={email.onChangeText} onBlur={email.onBlur} error={email.error} />
+ *   <Select value={country.value} onChange={country.onChange} error={country.error} />
+ *   <Switch value={!!agree.value} onChange={agree.onChange} />
+ */
+export declare function useField<V = unknown>(name: string): FieldInputProps<V>;
+export interface FieldArrayApi<T = unknown> {
+    /** Current array value (empty array when unset). */
+    fields: T[];
+    length: number;
+    push: (item: T) => void;
+    remove: (index: number) => void;
+    insert: (index: number, item: T) => void;
+    move: (from: number, to: number) => void;
+    replace: (index: number, item: T) => void;
+}
+/**
+ * Manage a repeating list field (phone numbers, line items, etc.) by name.
+ * Each helper writes the whole array back through the form so validation and
+ * dirty-tracking stay correct.
+ */
+export declare function useFieldArray<T = unknown>(name: string): FieldArrayApi<T>;
+//# sourceMappingURL=useField.d.ts.map

package/lib/typescript/commonjs/form/useForm.d.ts

@@ -0,0 +1,10 @@
+import type { FormApi, FormConfig, FormValues } from './types';
+/**
+ * Dependency-free form engine. Tracks values/errors/touched/dirty, runs
+ * synchronous and async validation (per-field rule maps or a form-level
+ * function), gates error display behind touched/submit, and on a failed submit
+ * focuses the first errored field. The returned object is rebuilt every render
+ * so `<Form>` consumers re-render on state changes.
+ */
+export declare function useForm<Values extends FormValues = FormValues>(config: FormConfig<Values>): FormApi<Values>;
+//# sourceMappingURL=useForm.d.ts.map

package/lib/typescript/commonjs/hooks/index.d.ts

@@ -3,4 +3,7 @@ export type { UseToggleResult } from './useToggle';
 export { useDebounce } from './useDebounce';
 export { usePressAnimation } from './usePressAnimation';
 export type { UsePressAnimationOptions, UsePressAnimationResult } from './usePressAnimation';
+export { useReducedMotion } from './useReducedMotion';
+export { useControllableState } from './useControllableState';
+export type { UseControllableStateOptions } from './useControllableState';
 //# sourceMappingURL=index.d.ts.map

package/lib/typescript/commonjs/hooks/useControllableState.d.ts

@@ -0,0 +1,17 @@
+export interface UseControllableStateOptions<T> {
+    /** Controlled value. When `undefined`, the hook manages state internally. */
+    value?: T;
+    /** Initial value used in uncontrolled mode. */
+    defaultValue: T;
+    /** Called on every change (both modes). */
+    onChange?: (value: T) => void;
+}
+/**
+ * Bridges controlled and uncontrolled usage for a value+onChange pair. When
+ * `value` is provided the component is controlled (the hook just forwards it
+ * and calls `onChange`); otherwise the hook owns the state, seeded from
+ * `defaultValue`. The controlled/uncontrolled decision is locked on first
+ * render so a component never flips modes mid-life.
+ */
+export declare function useControllableState<T>({ value, defaultValue, onChange }: UseControllableStateOptions<T>): [T, (next: T) => void];
+//# sourceMappingURL=useControllableState.d.ts.map

package/lib/typescript/commonjs/hooks/useReducedMotion.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Tracks the OS "Reduce Motion" accessibility setting. The library's
+ * ThemeProvider uses this to collapse `theme.motion` (durations → 0, springs →
+ * near-instant) so animations don't trigger vestibular discomfort; consumers
+ * can also read it directly to swap an animated path for a static one.
+ */
+export declare const useReducedMotion: () => boolean;
+//# sourceMappingURL=useReducedMotion.d.ts.map

package/lib/typescript/commonjs/index.d.ts

@@ -21,14 +21,16 @@ export { VersionCheck, useVersionCheck } from './versionCheck';
 export type { UpdateInfo, UpdateType, VersionData, VersionComparison, VersionCheckResult, VersionCheckType, ParsedVersion, Platform } from './versionCheck';
 export { ThemeProvider, useTheme, useThemeMode, setTheme, setColorMode, getColorMode, getTheme, resetTheme, subscribeTheme, mergeTheme, lightTheme, darkTheme } from './theme';
 export type { Theme, ThemeOverrides, ThemeProviderProps, IconRegistry, IconRenderer, ColorMode, ColorPalette, ColorSchemePreference, RadiusScale, ShadowDefinition, ShadowScale, SpacingScale, TypographyScale, MotionScale, DeepPartial } from './theme';
-export { useToggle, useDebounce, usePressAnimation } from './hooks';
-export type { UseToggleResult, UsePressAnimationOptions, UsePressAnimationResult } from './hooks';
+export { useToggle, useDebounce, usePressAnimation, useReducedMotion, useControllableState } from './hooks';
+export type { UseToggleResult, UsePressAnimationOptions, UsePressAnimationResult, UseControllableStateOptions } from './hooks';
 export { ScreenDimensions, Breakpoints, Responsive, isScreenSize, isTablet, Spacing, Padding, Margin, triggerHaptic, setHapticImplementation, shadowStyle, compressImage } from './utils';
 export type { BreakpointKey, SpacingToken, HapticType, CompressImageOptions } from './utils';
 export { formatDate, formatTime, formatDateTime, formatRelativeTime, formatPhone, normalizePhone, formatCurrency, formatNumber, formatPercent, formatCompactNumber, getInitials } from './formatters';
 export type { DateInput, DateStyle, TimeStyle, FormatCurrencyOptions } from './formatters';
 export { isNonEmpty, isEmail, isIndianMobile, isPhone, isUrl, isNumeric, isInteger, isAlphanumeric, isStrongPassword, isIndianPincode, isPan, isGstin, isAadhaar, isIfsc, isHexColor, isBetween, minLength, maxLength } from './validators';
 export type { PasswordRules } from './validators';
+export { useForm, useField, useFieldArray, Form, useFormContext, useOptionalFormContext, rules, getPath, setPath, deletePath } from './form';
+export type { FormApi, FormConfig, FormValues, FormErrors, FormTouched, FieldState, FieldInputProps, FocusableNode, ValidationRule, ValidationResult, FieldRules, ValidationSchema, FormValidateFn, ValidateOn, SubmitHelpers, FieldArrayApi } from './form';
 export { useNetworkStatus, getNetworkStatus, addNetworkStatusListener, NetworkStatusBanner } from './network';
 export type { NetworkStatus, NetworkConnectionType, NetworkStatusListener, NetworkStatusBannerProps } from './network';
 export { Permissions } from './permissions';