@webority-technologies/mobile-ui 0.0.1

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

@@ -0,0 +1,3 @@
+export type { KeyboardToolbarProps } from './KeyboardToolbar';
+export { KeyboardToolbar } from './KeyboardToolbar';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1,46 @@
+import React from 'react';
+import type { GestureResponderEvent, View as RNView, StyleProp, TextStyle, ViewStyle } from 'react-native';
+import type { HapticType } from '../../utils/hapticUtils';
+import type { SwipeableAction } from '../Swipeable';
+export type ListItemSize = 'sm' | 'md' | 'lg';
+export interface ListItemProps {
+    title: string;
+    /**
+     * When true, renders the component as its authored skeleton placeholder shape.
+     * The placeholder mirrors the real layout's footprint so the UI doesn't reflow
+     * when data arrives. Use this while the data driving the component is being fetched.
+     */
+    loading?: boolean;
+    subtitle?: string;
+    description?: string;
+    left?: React.ReactNode;
+    right?: React.ReactNode;
+    onPress?: (event: GestureResponderEvent) => void;
+    /** Haptic feedback for interactions. Pass false to disable; pass a HapticType to override the default. */
+    haptic?: HapticType | false;
+    selected?: boolean;
+    disabled?: boolean;
+    size?: ListItemSize;
+    divider?: boolean;
+    chevron?: boolean;
+    /** Optional swipe-from-left actions. Wraps the row in a Swipeable when provided. */
+    leftActions?: SwipeableAction[];
+    /** Optional swipe-from-right actions. Wraps the row in a Swipeable when provided. */
+    rightActions?: SwipeableAction[];
+    accessibilityLabel?: string;
+    accessibilityHint?: string;
+    style?: StyleProp<ViewStyle>;
+    containerStyle?: StyleProp<ViewStyle>;
+    titleStyle?: StyleProp<TextStyle>;
+    subtitleStyle?: StyleProp<TextStyle>;
+    descriptionStyle?: StyleProp<TextStyle>;
+    leftSlotStyle?: StyleProp<ViewStyle>;
+    rightSlotStyle?: StyleProp<ViewStyle>;
+    testID?: string;
+}
+declare const ListItem: React.ForwardRefExoticComponent<ListItemProps & React.RefAttributes<RNView>> & {
+    Skeleton: React.FC<ListItemProps>;
+};
+export { ListItem };
+export default ListItem;
+//# sourceMappingURL=ListItem.d.ts.map

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

@@ -0,0 +1,4 @@
+export type { SwipeableAction } from '../Swipeable';
+export type { ListItemProps, ListItemSize } from './ListItem';
+export { default, ListItem } from './ListItem';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1,47 @@
+import React from 'react';
+import type { View as RNView, StyleProp, ViewStyle } from 'react-native';
+import type { HapticType } from '../../utils/hapticUtils';
+export type ModalPresentation = 'centered' | 'bottom' | 'fullScreen';
+/**
+ * Grace period between `visible` flipping false and the native modal being
+ * safely gone. Unmounting the tree (navigation reset, auth flip) before this
+ * elapses races Android's ReactModalHostView dismiss and NPE-crashes.
+ */
+export declare const MODAL_DISMISS_GRACE_MS = 300;
+export interface ModalProps {
+    visible: boolean;
+    onRequestClose: () => void;
+    presentation?: ModalPresentation;
+    backdropOpacity?: number;
+    backdropPressClose?: boolean;
+    animationDuration?: number;
+    accessibilityLabel?: string;
+    hardwareBackPress?: boolean;
+    children: React.ReactNode;
+    contentStyle?: StyleProp<ViewStyle>;
+    backdropStyle?: StyleProp<ViewStyle>;
+    /**
+     * Optional ref to the View that triggered the modal. When the modal closes,
+     * accessibility focus is restored to that View so screen-reader users land
+     * back where they invoked the dialog instead of at the top of the screen.
+     * Opt-in: when undefined, focus behaviour is unchanged.
+     */
+    restoreFocusRef?: React.RefObject<RNView | null>;
+    /**
+     * Fired once after the modal closes, MODAL_DISMISS_GRACE_MS after `visible`
+     * flips false — the earliest point it is safe to unmount the surrounding
+     * tree (navigate away, flip auth state) without racing the native dismiss
+     * on Android. Sequence follow-up work (or a follow-up modal) from here.
+     */
+    onDismissed?: () => void;
+    /**
+     * Haptic feedback for interactions. Pass false to disable; pass a HapticType
+     * to override the default.
+     */
+    haptic?: HapticType | false;
+    testID?: string;
+}
+declare const Modal: React.ForwardRefExoticComponent<ModalProps & React.RefAttributes<RNView>>;
+export { Modal };
+export default Modal;
+//# sourceMappingURL=Modal.d.ts.map

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

@@ -0,0 +1,3 @@
+export type { ModalPresentation, ModalProps } from './Modal';
+export { default, MODAL_DISMISS_GRACE_MS, Modal } from './Modal';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1,42 @@
+import React from 'react';
+import type { StyleProp, TextInputProps, TextStyle, ViewStyle } from 'react-native';
+import type { HapticType } from '../../utils';
+export type NumberInputSize = 'sm' | 'md' | 'lg';
+export type NumberInputVariant = 'inline' | 'horizontal' | 'stacked';
+export interface NumberInputRef {
+    focus: () => void;
+    blur: () => void;
+    clear: () => void;
+}
+export interface NumberInputProps {
+    value?: number;
+    defaultValue?: number;
+    onChange?: (value: number) => void;
+    min?: number;
+    max?: number;
+    step?: number;
+    allowDecimal?: boolean;
+    precision?: number;
+    label?: string;
+    helperText?: string;
+    error?: string;
+    disabled?: boolean;
+    size?: NumberInputSize;
+    variant?: NumberInputVariant;
+    unit?: string;
+    /** 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>;
+    inputStyle?: StyleProp<TextStyle>;
+    buttonStyle?: StyleProp<ViewStyle>;
+    unitStyle?: StyleProp<TextStyle>;
+    labelStyle?: StyleProp<TextStyle>;
+    textInputProps?: Omit<TextInputProps, 'value' | 'onChangeText' | 'onBlur' | 'keyboardType' | 'editable'>;
+    testID?: string;
+}
+declare const NumberInput: React.ForwardRefExoticComponent<NumberInputProps & React.RefAttributes<NumberInputRef>>;
+export { NumberInput };
+export default NumberInput;
+//# sourceMappingURL=NumberInput.d.ts.map

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

@@ -0,0 +1,3 @@
+export type { NumberInputProps, NumberInputRef, NumberInputSize, NumberInputVariant } from './NumberInput';
+export { default, NumberInput } from './NumberInput';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1,35 @@
+import type { StyleProp, TextStyle, ViewStyle } from 'react-native';
+import type { HapticType } from '../../utils';
+export type OTPInputSize = 'sm' | 'md' | 'lg';
+export interface OTPInputRef {
+    focus: () => void;
+    blur: () => void;
+    clear: () => void;
+}
+export interface OTPInputProps {
+    value?: string;
+    defaultValue?: string;
+    onChange?: (value: string) => void;
+    onComplete?: (value: string) => void;
+    length?: number;
+    keyboardType?: 'number-pad' | 'default';
+    autoFocus?: boolean;
+    disabled?: boolean;
+    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>;
+    textStyle?: StyleProp<TextStyle>;
+    testID?: string;
+}
+declare const OTPInput: import("react").ForwardRefExoticComponent<OTPInputProps & import("react").RefAttributes<OTPInputRef>>;
+export { OTPInput };
+export default OTPInput;
+//# sourceMappingURL=OTPInput.d.ts.map

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

@@ -0,0 +1,3 @@
+export type { OTPInputProps, OTPInputRef, OTPInputSize } from './OTPInput';
+export { default, OTPInput } from './OTPInput';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1,57 @@
+/**
+ * OptionSheet — the shared bottom-sheet option picker.
+ *
+ * Internal primitive behind Select and InlineSelect: RN Modal-backed slide-up
+ * sheet with backdrop fade, grab handle, optional title, optional client-side
+ * search, the option list (icon + label + description, single dot / multi
+ * checkbox) and the multi-select Done footer. Owns the open/close animations
+ * and the search query; selection STATE stays with the caller — the sheet
+ * only reports `onSelect(option)` and asks `isSelected(value)`.
+ *
+ * Also the home of the canonical option types (`SelectValue`, `SelectOption`)
+ * and accessor signatures shared by every option-picking component. Select
+ * re-exports them so the public import path is unchanged.
+ */
+import React from 'react';
+import type { StyleProp, TextStyle, ViewStyle } from 'react-native';
+export type SelectValue = string | number;
+export interface SelectOption {
+    label: string;
+    value: SelectValue;
+    description?: string;
+    disabled?: boolean;
+    icon?: React.ReactNode;
+}
+export interface OptionSheetProps {
+    open: boolean;
+    /** Requests close (backdrop tap, hardware back, multi Done). Caller flips `open`. */
+    onClose: () => void;
+    /** Sheet heading. Also the modal's a11y label fallback. */
+    title?: string;
+    options: ReadonlyArray<unknown>;
+    labelOf: (option: unknown) => string;
+    valueOf: (option: unknown) => SelectValue;
+    disabledOf: (option: unknown) => boolean;
+    descriptionOf: (option: unknown) => string | undefined;
+    iconOf: (option: unknown) => React.ReactNode;
+    isSelected: (value: SelectValue) => boolean;
+    /** Tap on an enabled option. Caller updates state and (for single-select) closes. */
+    onSelect: (option: unknown) => void;
+    /** Multi mode: checkboxes + Done footer instead of the selected dot. */
+    multi?: boolean;
+    searchable?: boolean;
+    /** Caret/selection colour of the search input — callers mirror their focus colour. Default: `colors.border.focus`. */
+    searchSelectionColor?: string;
+    accessibilityLabel?: string;
+    /** Style for every option row container (padding, background, etc.). Wins over the row defaults. */
+    optionStyle?: StyleProp<ViewStyle>;
+    /** Extra style merged onto the selected option row — wins over `optionStyle` and the default selected fill. */
+    selectedOptionStyle?: StyleProp<ViewStyle>;
+    /** Style for every option's label text. Wins over the label defaults. */
+    optionTextStyle?: StyleProp<TextStyle>;
+    /** Extra style merged onto the selected option's label text — wins over `optionTextStyle` and the default selected colour. */
+    selectedOptionTextStyle?: StyleProp<TextStyle>;
+}
+export declare const OptionSheet: React.FC<OptionSheetProps>;
+export default OptionSheet;
+//# sourceMappingURL=OptionSheet.d.ts.map

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

@@ -0,0 +1,58 @@
+import type { TextInput as RNTextInput, StyleProp, ViewStyle } from 'react-native';
+import type { HapticType } from '../../utils';
+import type { FieldBaseSize, FieldBaseVariant } from '../FieldBase';
+export interface CallingCode {
+    /** ISO 3166-1 alpha-2, used as the option's identity. */
+    iso: string;
+    /** Dial prefix WITHOUT the plus, e.g. '91'. */
+    code: string;
+    label: string;
+    /** Expected national-number length. Omit when it varies. */
+    nationalLength?: number;
+}
+/**
+ * A deliberately short default list — the countries the fleet actually ships to.
+ * Consumers needing the full set pass their own `countries`; shipping 240 entries
+ * (and their flags) in a component library is weight almost nobody uses.
+ */
+export declare const DEFAULT_CALLING_CODES: ReadonlyArray<CallingCode>;
+export interface PhoneNumberValue {
+    /** Dial prefix without the plus, e.g. '91'. */
+    callingCode: string;
+    /** Digits only, no prefix. */
+    nationalNumber: string;
+    /** ISO of the selected country. */
+    iso: string;
+}
+export interface PhoneNumberInputProps {
+    value?: PhoneNumberValue;
+    defaultValue?: PhoneNumberValue;
+    onChange?: (value: PhoneNumberValue) => void;
+    /** Fires with `+<code><national>` when the number reaches its expected length. */
+    onComplete?: (e164: string) => void;
+    countries?: ReadonlyArray<CallingCode>;
+    /** ISO to start on when no value is given. Default 'IN'. */
+    defaultIso?: string;
+    label?: string;
+    placeholder?: string;
+    helperText?: string;
+    error?: string;
+    required?: boolean;
+    disabled?: boolean;
+    size?: FieldBaseSize;
+    variant?: FieldBaseVariant;
+    countrySheetTitle?: string;
+    haptic?: HapticType | false;
+    style?: StyleProp<ViewStyle>;
+    testID?: string;
+}
+/** `+<code> <national>` — presentational only; the value stays structured. */
+export declare const formatE164: (value: PhoneNumberValue) => string;
+/**
+ * Country calling code + national number, kept as a structured value rather than
+ * one string. A single free-text phone field is where "+91", "0091", "091" and
+ * "9876543210" all arrive for the same number and the backend has to guess.
+ */
+export declare const PhoneNumberInput: import("react").ForwardRefExoticComponent<PhoneNumberInputProps & import("react").RefAttributes<RNTextInput>>;
+export default PhoneNumberInput;
+//# sourceMappingURL=PhoneNumberInput.d.ts.map

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

@@ -0,0 +1,3 @@
+export type { CallingCode, PhoneNumberInputProps, PhoneNumberValue } from './PhoneNumberInput';
+export { DEFAULT_CALLING_CODES, default, formatE164, PhoneNumberInput } from './PhoneNumberInput';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1,60 @@
+/**
+ * PickerTrigger — the tappable input field that opens a modal picker.
+ *
+ * Standalone read-only field built on FieldBase, used by DatePicker,
+ * TimePicker and DateRangePicker (and any consumer-built picker) to render
+ * the closed-state row that matches Input / Select pixel-for-pixel.
+ *
+ * The component is purely visual + interactive — it does not own picker
+ * state. Consumers either:
+ *   - Use the built-in trigger mode on a picker, which composes this
+ *     internally and manages its own open/close.
+ *   - Render PickerTrigger themselves alongside a controlled picker.
+ */
+import React from 'react';
+import type { View as RNView, StyleProp, TextStyle, ViewStyle } from 'react-native';
+import type { FieldBaseSize, FieldBaseVariant } from '../FieldBase';
+export type PickerTriggerSize = FieldBaseSize;
+export type PickerTriggerVariant = FieldBaseVariant;
+export interface PickerTriggerProps {
+    /** The currently selected value rendered as the trigger's primary text. */
+    value?: string;
+    /** Shown when `value` is empty. Falls back to "Select…". */
+    placeholder?: string;
+    /** Static label rendered above the field. */
+    label?: string;
+    /** Helper text shown below the field. Hidden when `error` is set. */
+    helperText?: string;
+    /** Error message shown below the field (and red-borders the field). */
+    error?: string;
+    /**
+     * Appends the required marker to the label. Marker text + colour come from
+     * `theme.components.field.{requiredMarker,requiredMarkerColor}` (default
+     * `'*'` in `colors.error`).
+     */
+    required?: boolean;
+    /** Tap handler — typically opens the modal picker. */
+    onPress: () => void;
+    /** Render a clear (×) affordance when `value` is non-empty. */
+    clearable?: boolean;
+    /** Called when the clear affordance is pressed. */
+    onClear?: () => void;
+    /** Leading icon slot (e.g. calendar / clock). */
+    leadingIcon?: React.ReactNode;
+    /** Trailing slot — defaults to a chevron when unset. Pass `null` to suppress. */
+    trailing?: React.ReactNode;
+    disabled?: boolean;
+    size?: PickerTriggerSize;
+    variant?: PickerTriggerVariant;
+    style?: StyleProp<ViewStyle>;
+    triggerStyle?: StyleProp<ViewStyle>;
+    valueStyle?: StyleProp<TextStyle>;
+    labelStyle?: StyleProp<TextStyle>;
+    messageStyle?: StyleProp<TextStyle>;
+    accessibilityLabel?: string;
+    testID?: string;
+}
+declare const PickerTrigger: React.ForwardRefExoticComponent<PickerTriggerProps & React.RefAttributes<RNView>>;
+export { PickerTrigger };
+export default PickerTrigger;
+//# sourceMappingURL=PickerTrigger.d.ts.map

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

@@ -0,0 +1,3 @@
+export type { PickerTriggerProps, PickerTriggerSize, PickerTriggerVariant } from './PickerTrigger';
+export { default, PickerTrigger } from './PickerTrigger';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1,33 @@
+import type { View as RNView, StyleProp, ViewStyle } from 'react-native';
+import type { GradientDefinition } from '../../theme/types';
+export type ProgressBarTone = 'primary' | 'success' | 'warning' | 'error';
+export interface ProgressBarSegment {
+    /** Fraction of the full track (0–1). */
+    value: number;
+    /** Explicit colour; falls back to `tone`. */
+    color?: string;
+    tone?: ProgressBarTone;
+}
+export interface ProgressBarProps {
+    progress?: number;
+    indeterminate?: boolean;
+    height?: number;
+    radius?: number;
+    tone?: ProgressBarTone;
+    trackColor?: string;
+    barColor?: string;
+    /** Gradient fill for the determinate bar — a `GradientDefinition` or a theme gradient token name. */
+    gradient?: GradientDefinition | string;
+    /** Render a multi-colour breakdown bar (usage split) instead of a single progress fill. */
+    segments?: ProgressBarSegment[];
+    animated?: boolean;
+    style?: StyleProp<ViewStyle>;
+    containerStyle?: StyleProp<ViewStyle>;
+    barStyle?: StyleProp<ViewStyle>;
+    accessibilityLabel?: string;
+    testID?: string;
+}
+declare const ProgressBar: import("react").ForwardRefExoticComponent<ProgressBarProps & import("react").RefAttributes<RNView>>;
+export { ProgressBar };
+export default ProgressBar;
+//# sourceMappingURL=ProgressBar.d.ts.map

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

@@ -0,0 +1,3 @@
+export type { ProgressBarProps, ProgressBarSegment, ProgressBarTone } from './ProgressBar';
+export { default, ProgressBar } from './ProgressBar';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1,33 @@
+import type { PressableProps, View as RNView, StyleProp, TextStyle, ViewStyle } from 'react-native';
+import type { HapticType } from '../../utils/hapticUtils';
+export type RadioSize = 'sm' | 'md' | 'lg';
+export type RadioTone = 'primary' | 'success' | 'warning' | 'error';
+export type RadioValue = string | number;
+export interface RadioGroupContextValue {
+    selectedValue: RadioValue | undefined;
+    onChange: (value: RadioValue) => void;
+    disabled: boolean;
+}
+export declare const RadioGroupContext: import("react").Context<RadioGroupContextValue | null>;
+export declare const useRadioGroup: () => RadioGroupContextValue | null;
+export interface RadioProps extends Omit<PressableProps, 'style' | 'children' | 'onPress'> {
+    value: RadioValue;
+    selected?: boolean;
+    onChange?: (value: RadioValue) => void;
+    disabled?: boolean;
+    label?: string;
+    size?: RadioSize;
+    tone?: RadioTone;
+    accessibilityLabel?: string;
+    haptic?: HapticType | false;
+    style?: StyleProp<ViewStyle>;
+    containerStyle?: StyleProp<ViewStyle>;
+    circleStyle?: StyleProp<ViewStyle>;
+    dotStyle?: StyleProp<ViewStyle>;
+    labelStyle?: StyleProp<TextStyle>;
+    testID?: string;
+}
+declare const Radio: import("react").ForwardRefExoticComponent<RadioProps & import("react").RefAttributes<RNView>>;
+export { Radio };
+export default Radio;
+//# sourceMappingURL=Radio.d.ts.map

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

@@ -0,0 +1,24 @@
+/**
+ * RadioDot — the bare animated radio indicator (ring + spring-scaled dot).
+ *
+ * Extracted from Radio so custom option templates (ChoiceGroup `renderOption`,
+ * bespoke cards) can embed the standard indicator without rebuilding the
+ * animation or the disabled/selected colour rules. Purely visual — no press
+ * handling, no a11y role; the parent control owns those.
+ */
+import React from 'react';
+import type { StyleProp, ViewStyle } from 'react-native';
+export type RadioDotSize = 'sm' | 'md' | 'lg';
+export interface RadioDotProps {
+    selected: boolean;
+    /** Fill colour of the inner dot + selected ring. Default `colors.primary`. */
+    color?: string;
+    disabled?: boolean;
+    /** Named size reads `theme.components.radio[size]`; a number is the outer diameter in px (inner = half). */
+    size?: RadioDotSize | number;
+    style?: StyleProp<ViewStyle>;
+    dotStyle?: StyleProp<ViewStyle>;
+}
+export declare const RadioDot: React.FC<RadioDotProps>;
+export default RadioDot;
+//# sourceMappingURL=RadioDot.d.ts.map

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

@@ -0,0 +1,17 @@
+import React from 'react';
+import type { StyleProp, ViewStyle } from 'react-native';
+import type { RadioValue } from './Radio';
+export interface RadioGroupProps {
+    value?: RadioValue;
+    defaultValue?: RadioValue;
+    onChange?: (value: RadioValue) => void;
+    children: React.ReactNode;
+    disabled?: boolean;
+    accessibilityLabel?: string;
+    style?: StyleProp<ViewStyle>;
+    testID?: string;
+}
+declare const RadioGroup: React.FC<RadioGroupProps>;
+export { RadioGroup };
+export default RadioGroup;
+//# sourceMappingURL=RadioGroup.d.ts.map

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

@@ -0,0 +1,7 @@
+export type { RadioGroupContextValue, RadioProps, RadioSize, RadioTone, RadioValue } from './Radio';
+export { default, Radio, RadioGroupContext, useRadioGroup } from './Radio';
+export type { RadioDotProps, RadioDotSize } from './RadioDot';
+export { RadioDot } from './RadioDot';
+export type { RadioGroupProps } from './RadioGroup';
+export { RadioGroup } from './RadioGroup';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1,37 @@
+import React from 'react';
+import type { View as RNView, StyleProp, 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 {
+    value: number;
+    onChange?: (value: number) => void;
+    max?: number;
+    allowHalf?: boolean;
+    readonly?: boolean;
+    size?: RatingSize;
+    tone?: RatingTone;
+    label?: string;
+    /**
+     * When true, renders the component as its authored skeleton placeholder shape.
+     * The placeholder mirrors the real layout's footprint so the UI doesn't reflow
+     * 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>;
+    starContainerStyle?: StyleProp<ViewStyle>;
+    testID?: string;
+}
+declare const Rating: React.ForwardRefExoticComponent<RatingProps & React.RefAttributes<RNView>> & {
+    Skeleton: React.FC<RatingProps>;
+};
+export { Rating };
+export default Rating;
+//# sourceMappingURL=Rating.d.ts.map

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

@@ -0,0 +1,3 @@
+export type { RatingProps, RatingSize, RatingTone } from './Rating';
+export { default, Rating } from './Rating';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1,43 @@
+import React from 'react';
+import type { StyleProp, ViewStyle } from 'react-native';
+import type { HapticType } from '../../utils';
+export interface RepeaterRenderArgs<T> {
+    item: T;
+    index: number;
+    /** Replace this row's value. */
+    update: (next: T) => void;
+    /** Remove this row. */
+    remove: () => void;
+    /** False when removing would breach `minRows`. */
+    canRemove: boolean;
+}
+export interface RepeaterProps<T> {
+    value: ReadonlyArray<T>;
+    onChange: (next: T[]) => void;
+    /** Builds a blank row. Called on add — must return a NEW object each time. */
+    createRow: () => T;
+    renderRow: (args: RepeaterRenderArgs<T>) => React.ReactNode;
+    addLabel?: string;
+    /** Per-row heading, e.g. `(i) => \`Line item ${i + 1}\``. */
+    rowLabel?: (index: number) => string;
+    /** Rows below this cannot be removed. Default 0. */
+    minRows?: number;
+    /** Add is hidden at this count. Omit for unlimited. */
+    maxRows?: number;
+    /** Remove affordance. Default true. */
+    removable?: boolean;
+    emptyText?: string;
+    disabled?: boolean;
+    haptic?: HapticType | false;
+    style?: StyleProp<ViewStyle>;
+    testID?: string;
+}
+/**
+ * Add / remove / edit a list of form rows — line items, phone numbers,
+ * addresses. Owns the array mechanics (immutably) so each screen stops
+ * re-deriving splice/map logic, and keeps the min/max rules in one place where
+ * they can't disagree between the add button and the remove button.
+ */
+export declare const Repeater: <T>({ value, onChange, createRow, renderRow, addLabel, rowLabel, minRows, maxRows, removable, emptyText, disabled, haptic, style, testID }: RepeaterProps<T>) => React.ReactElement;
+export default Repeater;
+//# sourceMappingURL=Repeater.d.ts.map

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

@@ -0,0 +1,3 @@
+export type { RepeaterProps, RepeaterRenderArgs } from './Repeater';
+export { default, Repeater } from './Repeater';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1,32 @@
+import React from 'react';
+import type { StyleProp, TextInputProps, ViewStyle } from 'react-native';
+import { TextInput } 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'> {
+    /** Current value. Optional / nullable — treated as empty string when undefined or null. */
+    value?: string | null;
+    onChangeText: (text: string) => void;
+    onSubmit?: (text: string) => void;
+    placeholder?: string;
+    autoFocus?: boolean;
+    disabled?: boolean;
+    showCancel?: boolean;
+    onCancel?: () => void;
+    onClear?: () => void;
+    leftIcon?: React.ReactNode;
+    debounceMs?: number;
+    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;
+}
+declare const SearchBar: React.ForwardRefExoticComponent<SearchBarProps & React.RefAttributes<TextInput>>;
+export { SearchBar };
+export default SearchBar;
+//# sourceMappingURL=SearchBar.d.ts.map

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

@@ -0,0 +1,3 @@
+export type { SearchBarProps, SearchBarSize, SearchBarVariant } from './SearchBar';
+export { default, SearchBar } from './SearchBar';
+//# sourceMappingURL=index.d.ts.map