@webority/mobile-ui 0.0.0-stage → 0.0.34

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

@@ -0,0 +1,142 @@
+import React from 'react';
+import type { BlurEvent, FocusEvent, StyleProp, TextInputProps, TextStyle, ViewStyle } from 'react-native';
+import { TextInput } from 'react-native';
+import type { SlotIcon, SlotIconState } from '../AppIcon/slotIcon';
+import type { ButtonTone, ButtonVariant } from '../Button';
+export type InputSize = 'sm' | 'md' | 'lg';
+export type InputVariant = 'outlined' | 'filled' | 'underline';
+export type InputLabelMode = 'float' | 'top';
+/**
+ * What kind of field this is. One prop switches the whole behaviour set:
+ * - `'input'` (default): single-line text.
+ * - `'password'`: masked value, eye toggle in the trailing slot, no
+ *   auto-capitalisation or autocorrect.
+ * - `'textarea'`: multi-line, taller box, text anchored to the top. A
+ *   floating label rests on the first line and rises to the top edge like it
+ *   does on a single-line field.
+ */
+export type InputType = 'input' | 'password' | 'textarea';
+/** State handed to a `leftIcon` / `rightIcon` render function. */
+export interface InputSlotState extends SlotIconState {
+    focused: boolean;
+    error: boolean;
+    /** The field palette's icon colour for this state (`colors.field.icon*`). */
+    color: string;
+    /** The size ladder's icon size for the field's `size`. */
+    size: number;
+}
+/** An icon name, `{ name, variant }`, a node, or a render function; see `SlotIcon`. */
+export type InputSlotIcon = SlotIcon<InputSlotState>;
+/**
+ * A button beside the field box, for a "Verify" / "Apply" / "Look up" action
+ * on what was typed. Drawn with the library Button at the box's own height,
+ * outlined by default; the label stays above the box and the helper or error
+ * below it, not the button.
+ */
+export interface InputAction {
+    label: string;
+    onPress: () => void;
+    /** Shows the Button's spinner and blocks presses. */
+    loading?: boolean;
+    /** Blocks presses. The button is also disabled whenever the field is. */
+    disabled?: boolean;
+    /** Button variant. Default `'outline'`. */
+    variant?: ButtonVariant;
+    /** Button tone. Default `'primary'`. */
+    tone?: ButtonTone;
+    /** Icon before the button label; the Button's own `leftIcon` contract. */
+    icon?: SlotIcon;
+    testID?: string;
+}
+export interface InputProps extends Omit<TextInputProps, 'style'> {
+    label?: string;
+    placeholder?: string;
+    value?: string;
+    onChangeText?: (text: string) => void;
+    error?: string;
+    helperText?: string;
+    /** See {@link InputType}. Default `'input'`. */
+    type?: InputType;
+    /** Setting this alone also puts the field in password mode (same as `type="password"`). */
+    showPasswordToggle?: boolean;
+    /** React Native's own prop; masks the value without the eye toggle. `type="password"` is the usual way. */
+    secureTextEntry?: boolean;
+    disabled?: boolean;
+    /** React Native's own prop; same as `type="textarea"`. */
+    multiline?: boolean;
+    /**
+     * Leading slot. The easy form is an icon name, `leftIcon="user"`: the
+     * field draws that AppIcon in the palette's colour for its state (grey at
+     * rest, dark while focused, dimmed while disabled, exactly as the spec
+     * draws the phone glyph) and at the size ladder's icon size. Also accepts
+     * `{ name, variant }`, a render function that receives the slot state, or
+     * any node drawn as is. A leading icon also gets the spec's hairline
+     * divider between it and the text.
+     */
+    leftIcon?: InputSlotIcon;
+    /** Trailing slot; same contract as `leftIcon`. */
+    rightIcon?: InputSlotIcon;
+    /**
+     * A fixed unit drawn after the value in the trailing slot — `'km'`, `'%'`,
+     * `'/month'`. Same prop and same look as NumberInput's `unit`: the field's
+     * font size in the placeholder colour, so it reads as part of the field
+     * rather than of what was typed. Sits before `rightIcon` when both are set;
+     * the password eye keeps the slot to itself.
+     */
+    unit?: string;
+    /** Style applied to the unit text. */
+    unitStyle?: StyleProp<TextStyle>;
+    /** A button beside the box; see {@link InputAction}. */
+    action?: InputAction;
+    /** Style applied to the action button. */
+    actionStyle?: StyleProp<ViewStyle>;
+    size?: InputSize;
+    variant?: InputVariant;
+    /**
+     * - `'top'` (default): the design spec's static label, 12px semibold above
+     *   the field, permanently visible.
+     * - `'float'`: Material-Design floating label that animates from inside the
+     *   field to the top border on focus / when there's a value.
+     *
+     * Theme override: `theme.components.input.defaultLabelMode`.
+     */
+    labelMode?: InputLabelMode;
+    required?: boolean;
+    maxLength?: number;
+    /**
+     * Render the "n / maxLength" character counter below the field. Only
+     * applies when `maxLength` is set and `value` is controlled. Default `true`.
+     * Set `false` for fields that cap input without advertising it (amounts,
+     * codes).
+     */
+    showCounter?: boolean;
+    /**
+     * Format the raw `value` for display. Common uses: phone-number formatting
+     * ("5551234567" → "(555) 123-4567"), currency, postal codes, masked IDs.
+     * The TextInput shows `format(value)`; user input is passed to `parse` (or
+     * left raw) before reaching `onChangeText`.
+     */
+    format?: (raw: string) => string;
+    /**
+     * Reverse of `format` — strips the formatted display back to the canonical
+     * value the consumer wants in state. If omitted, defaults to identity.
+     */
+    parse?: (formatted: string) => string;
+    style?: StyleProp<ViewStyle>;
+    /** Style applied to the bordered field wrapper (the bit you'd colour or pad). Distinct from `style`, which targets the outermost container. */
+    containerStyle?: StyleProp<ViewStyle>;
+    inputStyle?: StyleProp<TextStyle>;
+    labelStyle?: StyleProp<TextStyle>;
+    /** Style applied to the helper/error text below the field. */
+    messageStyle?: StyleProp<TextStyle>;
+    /** Per-instance override for the field's corner radius. Wins over `theme.components.input.borderRadius` and size defaults. */
+    borderRadius?: number;
+    onFocus?: (e: FocusEvent) => void;
+    onBlur?: (e: BlurEvent) => void;
+    accessibilityLabel?: string;
+    testID?: string;
+}
+declare const Input: React.ForwardRefExoticComponent<InputProps & React.RefAttributes<TextInput>>;
+export { Input };
+export default Input;
+//# sourceMappingURL=Input.d.ts.map

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

@@ -0,0 +1,3 @@
+export type { InputAction, InputProps, InputSize, InputSlotIcon, InputSlotState, InputVariant } from './Input';
+export { default, Input } from './Input';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1,35 @@
+import React from 'react';
+import type { ScrollViewProps } from 'react-native';
+import { ScrollView } from 'react-native';
+export type SafeAreaEdge = 'top' | 'bottom' | 'left' | 'right';
+export interface KeyboardAwareScrollViewProps extends ScrollViewProps {
+    /** Gap kept between the focused field and the top of the keyboard. Default 24. */
+    extraScrollHeight?: number;
+    /** Disable the keyboard-following behaviour (still a normal ScrollView). Default false. */
+    disabled?: boolean;
+    /** Safe-area edges to pad. Default ['bottom']. */
+    safeAreaEdges?: SafeAreaEdge[];
+    /** Standard RefreshControl pass-through convenience. Ignored when `refreshControl` is set. */
+    refreshing?: boolean;
+    onRefresh?: () => void;
+    /** iOS keyboard animation duration to match when scrolling. Default 250. */
+    keyboardOpeningTime?: number;
+    /** Adds the extra bottom inset a tab bar needs. Default false. */
+    viewIsInsideTabBar?: boolean;
+    /** Scroll back to a fixed offset when the keyboard hides. */
+    resetScrollToCoords?: {
+        x: number;
+        y: number;
+    };
+}
+/**
+ * A ScrollView that keeps the focused input visible above the keyboard — no
+ * native dependency. On keyboard show it pads the content by the keyboard
+ * height and scrolls the focused TextInput so its bottom sits `extraScrollHeight`
+ * above the keyboard, but only when it would otherwise be covered (so already-
+ * visible fields don't jump). The classic measure-and-scroll approach, in pure RN.
+ */
+declare const KeyboardAwareScrollView: React.ForwardRefExoticComponent<KeyboardAwareScrollViewProps & React.RefAttributes<ScrollView>>;
+export { KeyboardAwareScrollView };
+export default KeyboardAwareScrollView;
+//# sourceMappingURL=KeyboardAwareScrollView.d.ts.map

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

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

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

@@ -0,0 +1,29 @@
+import React from 'react';
+import type { StyleProp, ViewStyle } from 'react-native';
+export interface KeyboardToolbarProps {
+    /** Label for the dismiss button. Default 'Done'. */
+    doneLabel?: string;
+    /** Show the prev/next chevrons. Default: true when prev/next handlers resolve. */
+    showNavigation?: boolean;
+    /** Override the dismiss action. Default: `Keyboard.dismiss()`. */
+    onDone?: () => void;
+    /** Override "next field". Default: the surrounding `<Form>`'s `focusNext`. */
+    onNext?: () => void;
+    /** Override "previous field". Default: the surrounding `<Form>`'s `focusPrev`. */
+    onPrev?: () => void;
+    /** Custom content rendered between the nav chevrons and the Done button. */
+    leading?: React.ReactNode;
+    style?: StyleProp<ViewStyle>;
+    testID?: string;
+}
+/**
+ * An accessory bar pinned just above the keyboard — pure RN, no native
+ * dependency. Shows a Done (dismiss) button and optional prev/next chevrons
+ * that, inside a `<Form>`, walk the registered field order. Render it at the
+ * screen root (a `flex: 1` ancestor) so its `bottom: keyboardHeight` offset
+ * lands it on top of the keyboard. Renders nothing while the keyboard is hidden.
+ */
+declare const KeyboardToolbar: React.FC<KeyboardToolbarProps>;
+export { KeyboardToolbar };
+export default KeyboardToolbar;
+//# sourceMappingURL=KeyboardToolbar.d.ts.map

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/LoaderOverlay/LoaderOverlay.d.ts

@@ -0,0 +1,25 @@
+import React from 'react';
+export declare const loader: {
+    show: (message?: string) => void;
+    hide: () => void;
+    wrap: <T>(work: Promise<T> | (() => Promise<T>), message?: string) => Promise<T>;
+    isVisible: () => boolean;
+    reset: () => void;
+};
+export declare const useLoader: () => typeof loader;
+export interface LoaderOverlayProps {
+    /**
+     * Replaces the default themed spinner. Lets an app supply a Lottie or brand
+     * animation without the library taking that dependency.
+     */
+    renderIndicator?: (message?: string) => React.ReactNode;
+    /** Overlay dim colour override; defaults to a themed scrim. */
+    backdropColor?: string;
+    /** Delay before the overlay actually appears, so a fast request never flashes it. Default 150ms. */
+    showDelayMs?: number;
+    /** Once visible, stay visible at least this long, so it never flickers. Default 400ms. */
+    minVisibleMs?: number;
+    testID?: string;
+}
+export declare const LoaderOverlay: React.FC<LoaderOverlayProps>;
+//# sourceMappingURL=LoaderOverlay.d.ts.map

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

@@ -0,0 +1,3 @@
+export type { LoaderOverlayProps } from './LoaderOverlay';
+export { LoaderOverlay, loader, useLoader } from './LoaderOverlay';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1,29 @@
+import React from 'react';
+import type { StyleProp, TextStyle, ViewStyle } from 'react-native';
+export interface MarkdownProps {
+    /** The markdown source. An empty or missing string renders nothing. */
+    children?: string;
+    /** Called instead of Linking.openURL when a link is pressed. */
+    onLinkPress?: (href: string) => void;
+    /**
+     * 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;
+    style?: StyleProp<ViewStyle>;
+    /** Applied to every text block, so a caller can set the base size or colour. */
+    textStyle?: StyleProp<TextStyle>;
+    testID?: string;
+}
+/**
+ * Renders a small, deliberate subset of markdown using the theme's own type
+ * scale and colours, with no dependency.
+ *
+ * It exists because Expo has no markdown module and the alternative on npm has
+ * not shipped since 2022. What it covers is what our content contains: release
+ * notes, help text and descriptions written by people. Nested lists, tables and
+ * inline HTML are out of scope on purpose — see parse.ts.
+ */
+export declare const Markdown: React.FC<MarkdownProps>;
+//# sourceMappingURL=Markdown.d.ts.map

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

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

package/lib/typescript/commonjs/components/Markdown/parse.d.ts

@@ -0,0 +1,58 @@
+/**
+ * A deliberately small CommonMark subset, parsed without a dependency.
+ *
+ * The scope is what our own content actually contains — release notes, help
+ * text, descriptions written by people in a web editor — not a spec-complete
+ * renderer. Nested lists, tables, footnotes, HTML blocks and reference links
+ * are out of scope on purpose: supporting them means a parser nobody here can
+ * maintain, and content that needs them is a sign it should not be markdown.
+ *
+ * Kept separate from the component so the grammar can be tested as data, with
+ * no rendering involved.
+ */
+export type InlineNode = {
+    type: 'text';
+    value: string;
+} | {
+    type: 'strong';
+    children: InlineNode[];
+} | {
+    type: 'em';
+    children: InlineNode[];
+} | {
+    type: 'code';
+    value: string;
+} | {
+    type: 'strike';
+    children: InlineNode[];
+} | {
+    type: 'link';
+    href: string;
+    children: InlineNode[];
+};
+export type BlockNode = {
+    type: 'heading';
+    level: 1 | 2 | 3 | 4 | 5 | 6;
+    children: InlineNode[];
+} | {
+    type: 'paragraph';
+    children: InlineNode[];
+} | {
+    type: 'listItem';
+    ordered: boolean;
+    index: number;
+    depth: number;
+    children: InlineNode[];
+} | {
+    type: 'quote';
+    children: InlineNode[];
+} | {
+    type: 'codeBlock';
+    value: string;
+    language?: string;
+} | {
+    type: 'rule';
+};
+export declare const parseInline: (input: string) => InlineNode[];
+export declare const parseMarkdown: (source: string) => BlockNode[];
+//# sourceMappingURL=parse.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,107 @@
+/**
+ * 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;
+}
+/** A titled group of options; the sheet lists groups in order under a header row each. */
+export interface OptionSheetSection {
+    title: string;
+    options: ReadonlyArray<unknown>;
+}
+/** What `renderOption` is told about the row it draws. */
+export interface OptionSheetRowState {
+    selected: boolean;
+    disabled: boolean;
+}
+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>;
+    /**
+     * Group the options under header rows instead of listing `options` flat
+     * (`options` is still read for nothing but is kept required so every caller
+     * names its list once). Search filters inside each group and drops a group
+     * that empties. PhoneNumberInput uses this for "Popular" over "All countries".
+     */
+    sections?: ReadonlyArray<OptionSheetSection>;
+    /** Draw the header row for a section yourself; the default is the title in the section ink. */
+    renderSectionHeader?: (title: string) => React.ReactNode;
+    /**
+     * Replace the row's content (icon + label + description) with your own. The
+     * pressable row, its accessibility state and the selected dot / checkbox
+     * stay, so a custom row is still a button to a screen reader.
+     */
+    renderOption?: (option: unknown, state: OptionSheetRowState) => React.ReactNode;
+    /**
+     * A rail of letters down the right edge; a tap jumps the list to the first
+     * option whose label starts with that letter. For a long list sorted by
+     * label (a country picker); with `sections` it indexes the LAST group, the
+     * full list, so a pinned group above does not catch the jump. Hidden while
+     * a search query is typed. Default false.
+     */
+    alphabetIndex?: boolean;
+    /** Placeholder of the search box. Default 'Search…'. */
+    searchPlaceholder?: string;
+    /** Copy shown when nothing matches. Default 'No options'. */
+    emptyText?: string;
+    labelOf: (option: unknown) => string;
+    /**
+     * Named `getValue`, not `valueOf`. Every object literal inherits
+     * `Object.prototype.valueOf`, so a prop of that name makes even
+     * `{ open: false }` fail to satisfy `Partial<OptionSheetProps>`, which poisons
+     * any wrapper or props-merge over this component. Its siblings labelOf,
+     * disabledOf and iconOf are safe; only this one collides.
+     */
+    getValue: (option: unknown) => SelectValue;
+    disabledOf: (option: unknown) => boolean;
+    /**
+     * A row that destroys something (ProfilePicker's "Remove photo"): its label
+     * is painted in `colors.error`. The row itself, its icon and its description
+     * are untouched, so the caller passes a matching icon. Default: none.
+     */
+    destructiveOf?: (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