@webority/mobile-ui 0.9.0 → 0.10.0

package/lib/typescript/module/components/Menu/useContextMenu.d.ts

@@ -0,0 +1,58 @@
+import type React from 'react';
+import type { AccessibilityActionEvent, AccessibilityActionInfo, PressableProps, View as RNView } from 'react-native';
+import type { HapticType } from '../../utils/hapticUtils.js';
+import type { PlacementPreference } from '../../utils/placement.js';
+import type { MenuItem, MenuItems, MenuPresentation, MenuUnavailable } from './menuModel.js';
+/** The `contextMenu` prop of ListItem and Card. */
+export interface ContextMenuConfig {
+    items: MenuItems;
+    /** A short heading over the items; also the menu's accessible name. */
+    title?: string;
+    /** Up to three icon actions in a row above the list (the iOS "medium" layout). */
+    topActions?: ReadonlyArray<MenuItem>;
+    /**
+     * What lifts over the dimmed screen while the menu is open. Default: the
+     * row or card itself, drawn again in place; `false` for none.
+     */
+    preview?: React.ReactNode | false;
+    /** Default `'hide'`: the HIG drops unavailable items from a context menu. */
+    unavailable?: MenuUnavailable;
+    /** Default `'auto'`: a sheet on a phone past seven items or with a description. */
+    presentation?: MenuPresentation;
+    /** Preferred side of the pressed view. Default `'bottom'`. */
+    placement?: PlacementPreference;
+    onOpenChange?: (open: boolean) => void;
+    accessibilityLabel?: string;
+    /** Accessible name of the tap-outside area. Default `'Close menu'`. */
+    closeLabel?: string;
+    /** Accessible name of a submenu's Back row. Default `'Back'`. */
+    backLabel?: string;
+}
+export interface UseContextMenuOptions {
+    /** The host's `haptic` prop: `longPress` on open, `selection` on an action, unless overridden. */
+    haptic?: HapticType | false;
+    /** Screen reader actions the host already has; the menu's are added after them. */
+    accessibilityActions?: ReadonlyArray<AccessibilityActionInfo>;
+    onAccessibilityAction?: (event: AccessibilityActionEvent) => void;
+    testID?: string;
+}
+export interface ContextMenuBinding {
+    /** False when there is no config or nothing in it to show. */
+    enabled: boolean;
+    /** Merge onto the host's pressable; the menu measures it to anchor and lift it. */
+    hostRef: React.RefObject<RNView | null>;
+    /**
+     * Spread on the host's pressable after its own props: the long press, the
+     * screen reader actions and, on the web, right-click and Shift+F10.
+     * Empty when not enabled, so a host's own `onLongPress` survives.
+     */
+    hostProps: Partial<PressableProps>;
+    /** The menu itself, given the preview the host draws by default. */
+    renderSurface: (preview?: React.ReactNode) => React.ReactNode;
+}
+/**
+ * Wires a long-press menu onto a host view. ListItem and Card use it for
+ * their `contextMenu` prop; a host owns one Pressable and spreads `hostProps`.
+ */
+export declare const useContextMenu: (config: ContextMenuConfig | undefined, options?: UseContextMenuOptions) => ContextMenuBinding;
+//# sourceMappingURL=useContextMenu.d.ts.map

package/lib/typescript/module/components/Menu/webOnly.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Props only react-native-web understands (`onKeyDown`, `onContextMenu`, an
+ * ARIA role React Native's union lacks), typed as the host's props so they
+ * can be spread. The phones get nothing, so no unknown prop reaches them.
+ */
+export declare const webOnly: <T extends object>(props: object) => T | null;
+//# sourceMappingURL=webOnly.d.ts.map

package/lib/typescript/module/components/MessageBubble/MessageBubble.d.ts

@@ -0,0 +1,87 @@
+import { type DateValue } from '@webority/mobile-core';
+import type React from 'react';
+import type { StyleProp, ViewStyle } from 'react-native';
+import type { HapticType } from '../../utils/hapticUtils.js';
+export type MessageSide = 'mine' | 'theirs';
+/**
+ * Where a message sits in a run from one author. The joined corners go small
+ * and the author and time show only on the run's edges.
+ */
+export type MessageGroupPosition = 'single' | 'first' | 'middle' | 'last';
+export type MessageStatus = 'sending' | 'sent' | 'delivered' | 'read' | 'failed';
+/** The message this one answers, drawn as a quote at the top of the bubble. */
+export interface MessageReply {
+    author?: string;
+    text: string;
+    /** Jumps to the quoted message. */
+    onPress?: () => void;
+}
+/** A long-press action, also offered to screen readers as an accessibility action. */
+export interface MessageAction {
+    /** Stable id, e.g. `'copy'`. `onRetry` takes `'retry'` and `replyTo.onPress` `'openReply'`. */
+    name: string;
+    label: string;
+    onPress: () => void;
+}
+export interface MessageBubbleLabels {
+    you: string;
+    sending: string;
+    sent: string;
+    delivered: string;
+    read: string;
+    failed: string;
+    retry: string;
+    replyTo: (author: string | undefined) => string;
+}
+export declare const DEFAULT_MESSAGE_BUBBLE_LABELS: Readonly<MessageBubbleLabels>;
+export interface MessageBubbleProps {
+    side: MessageSide;
+    /**
+     * The message as plain text. Drawn when there are no `children`, read by
+     * screen readers, and announced once when a streaming reply completes.
+     */
+    text: string;
+    /** Rich content in place of `text` (a chart, an image, a renderer of your own). */
+    children?: React.ReactNode;
+    /** Draws `text` with the library `Markdown`. Ignored with `children`. */
+    markdown?: boolean;
+    /** Default `'single'`. */
+    groupPosition?: MessageGroupPosition;
+    /** Shown above the first message of a run of `theirs`; read before the text. */
+    author?: string;
+    /** Shown under the last message of a run, in the configured zone (IST by default). */
+    time?: DateValue;
+    /** Ticks under `mine`; read as a word ("Read"). */
+    status?: MessageStatus;
+    replyTo?: MessageReply;
+    /** The reply is still arriving: marked busy, announced once when it ends. */
+    streaming?: boolean;
+    /** A curated message shown under the bubble and announced at once. */
+    error?: string;
+    /** Shows Try again under a failed message, and offers it as an accessibility action. */
+    onRetry?: () => void;
+    /**
+     * Long-press actions (Copy, Reply). They are the screen reader's
+     * accessibility actions; a long press calls `onLongPress` to show them,
+     * typically in a menu. Without actions there is no long press.
+     */
+    actions?: ReadonlyArray<MessageAction>;
+    onLongPress?: () => void;
+    /** Content under the bubble on the same side (action cards, a rating). */
+    footer?: React.ReactNode;
+    labels?: Partial<MessageBubbleLabels>;
+    /** Long-press haptic. Default `'longPress'`. */
+    haptic?: HapticType | false;
+    style?: StyleProp<ViewStyle>;
+    testID?: string;
+}
+/**
+ * One chat message. `mine` sits on the trailing side in the brand tint and
+ * carries delivery ticks; `theirs` sits on the leading side on the secondary
+ * surface. Runs from one author share joined corners. The bubble reads as one
+ * element ("Asha, 4:32 PM, See you at six, Read") unless it holds `children`
+ * with no actions, when it stays open so links inside remain reachable.
+ */
+export declare const MessageBubble: React.FC<MessageBubbleProps>;
+export default MessageBubble;
+//# sourceMappingURL=MessageBubble.d.ts.map

package/lib/typescript/module/components/MessageBubble/index.d.ts

@@ -0,0 +1,3 @@
+export type { MessageAction, MessageBubbleLabels, MessageBubbleProps, MessageGroupPosition, MessageReply, MessageSide, MessageStatus } from './MessageBubble.js';
+export { DEFAULT_MESSAGE_BUBBLE_LABELS, default, MessageBubble } from './MessageBubble.js';
+//# sourceMappingURL=index.d.ts.map

package/lib/typescript/module/components/MessageList/MessageList.d.ts

@@ -0,0 +1,68 @@
+import { type DateValue } from '@webority/mobile-core';
+import type React from 'react';
+import type { FlatListProps } from 'react-native';
+import { type DateSeparatorLabels } from '../DateSeparator/index.js';
+import type { MessageGroupPosition } from '../MessageBubble/index.js';
+export interface MessageRenderInfo<T> {
+    item: T;
+    /** 0 is the newest. */
+    index: number;
+    /** Pass to `MessageBubble`; always `'single'` without `getAuthorKey`. */
+    groupPosition: MessageGroupPosition;
+}
+export interface MessageListLabels extends DateSeparatorLabels {
+    jumpToLatest: string;
+    newMessages: (count: number) => string;
+    /** The divider above the first unread message. */
+    unread: string;
+    loadingOlder: string;
+}
+export declare const DEFAULT_MESSAGE_LIST_LABELS: Readonly<MessageListLabels>;
+type OwnedListProps = 'data' | 'renderItem' | 'keyExtractor' | 'inverted' | 'onEndReached' | 'ListHeaderComponent' | 'ListFooterComponent' | 'ListEmptyComponent' | 'renderScrollComponent';
+export interface MessageListProps<T> extends Omit<FlatListProps<T>, OwnedListProps> {
+    /** Newest first, the order the list draws from the bottom up. */
+    messages: ReadonlyArray<T>;
+    keyExtractor: (item: T) => string;
+    /** Draws one message, usually a `MessageBubble` given `groupPosition`. */
+    renderMessage: (info: MessageRenderInfo<T>) => React.ReactElement | null;
+    /** Joins consecutive messages from one author into a run with shared corners. */
+    getAuthorKey?: (item: T) => string;
+    /** Draws a day separator ("Today", "Yesterday", "10-Oct-2026") where the day changes. */
+    getDate?: (item: T) => DateValue;
+    /** Draws the "New messages" divider above this message. */
+    firstUnreadKey?: string;
+    /** Called near the top of the history to load the page before the oldest. */
+    onLoadOlder?: () => void;
+    loadingOlder?: boolean;
+    /** False once the oldest page is in. Default true. */
+    hasOlder?: boolean;
+    /** Drawn under the newest message, e.g. a `TypingIndicator`. */
+    typing?: React.ReactNode;
+    /** Drawn while there are no messages. */
+    empty?: React.ReactNode;
+    /** A message to announce politely for each new message, e.g. "Asha: See you at six". */
+    getAnnouncement?: (item: T) => string | null | undefined;
+    /** True for a new message that should bring the list to the latest, such as the person's own. */
+    followNew?: (item: T) => boolean;
+    /**
+     * Lifts the newest messages above the keyboard through
+     * react-native-keyboard-controller's `KeyboardChatScrollView`. Default true;
+     * turn it off when a parent already moves with the keyboard.
+     */
+    keyboardAware?: boolean;
+    /** The `Composer`'s `keyboardOffset`. Default: the bottom safe-area inset. */
+    keyboardOffset?: number;
+    labels?: Partial<MessageListLabels>;
+    /** The reference for Today and Yesterday. Default: now. */
+    now?: Date;
+}
+/**
+ * A conversation: an inverted `FlatList` that starts at the newest message,
+ * draws day separators and an unread divider, joins runs from one author,
+ * loads older pages at the top without moving what is on screen, and lifts
+ * above the keyboard. Scrolled away from the latest, a jump button appears
+ * with the count of messages that arrived meanwhile.
+ */
+export declare function MessageList<T>({ messages, keyExtractor, renderMessage, getAuthorKey, getDate, firstUnreadKey, onLoadOlder, loadingOlder, hasOlder, typing, empty, getAnnouncement, followNew, keyboardAware, keyboardOffset, labels: labelOverrides, now, onScroll, contentContainerStyle, style, testID, ...rest }: MessageListProps<T>): React.ReactElement;
+export default MessageList;
+//# sourceMappingURL=MessageList.d.ts.map

package/lib/typescript/module/components/MessageList/index.d.ts

@@ -0,0 +1,3 @@
+export type { MessageListLabels, MessageListProps, MessageRenderInfo } from './MessageList.js';
+export { DEFAULT_MESSAGE_LIST_LABELS, default, MessageList } from './MessageList.js';
+//# sourceMappingURL=index.d.ts.map

package/lib/typescript/module/components/OnboardingPager/OnboardingPager.d.ts

@@ -0,0 +1,53 @@
+import type React from 'react';
+import type { HapticType } from '../../utils/hapticUtils.js';
+export interface OnboardingPage {
+    /** Stable identity of the page; also the list key. */
+    key: string;
+    /** The picture or illustration above the text: any node, for example an `Image`. */
+    art?: React.ReactNode;
+    title: string;
+    body: string;
+}
+export interface OnboardingPagerLabels {
+    skip?: string;
+    next?: string;
+    /** Spoken before the title of each page. Default `Step 2 of 3`. */
+    step?: (position: number, total: number) => string;
+    /** Names the page control for a screen reader. Default `Page`. */
+    pageControl?: string;
+}
+export interface OnboardingPagerProps {
+    /** Three or four is the sweet spot; more than six are not shown. */
+    pages: OnboardingPage[];
+    /** The final button was pressed. The app records that the intro was seen. */
+    onDone: () => void;
+    /** Skip was pressed, on any page. The app records that the intro was seen. */
+    onSkip: () => void;
+    /** Title of the final button. Default `Get started`. */
+    doneLabel?: string;
+    labels?: OnboardingPagerLabels;
+    /**
+     * Pads the top and bottom by the device safe-area insets. Pass false when the pager sits
+     * inside a screen that already handles them. Default true.
+     */
+    safeArea?: boolean;
+    /** Haptic on Skip, Next and the final button. `false` opts out. */
+    haptic?: HapticType | false;
+    testID?: string;
+}
+/**
+ * A first-launch intro: full-screen pages of art, title and body that swipe, a page
+ * control, Skip at the top on every page, and a footer button that reads Next and then
+ * the done label, so the flow never needs a swipe. Built on `Carousel`
+ * (no autoplay, no loop). The app owns whether the intro was seen: `onDone` and `onSkip`
+ * both mean "seen", and it stores that itself. A page whose text outgrows the screen at a
+ * large font size scrolls inside the page.
+ *
+ * The page control is one adjustable element for a screen reader (swipe up or down to change
+ * page); touching its leading half goes back one page, its trailing half forward one. Under
+ * Reduce Motion pages change without animation and the active dot changes at once.
+ */
+declare const OnboardingPager: React.FC<OnboardingPagerProps>;
+export { OnboardingPager };
+export default OnboardingPager;
+//# sourceMappingURL=OnboardingPager.d.ts.map

package/lib/typescript/module/components/OnboardingPager/index.d.ts

@@ -0,0 +1,3 @@
+export type { OnboardingPage, OnboardingPagerLabels, OnboardingPagerProps } from './OnboardingPager.js';
+export { default, OnboardingPager } from './OnboardingPager.js';
+//# sourceMappingURL=index.d.ts.map

package/lib/typescript/module/components/PaymentResult/PaymentResult.d.ts

@@ -0,0 +1,71 @@
+import type React from 'react';
+import type { StyleProp, ViewStyle } from 'react-native';
+import type { DescriptionItem } from '../Descriptions/index.js';
+/**
+ * `pending` is its own outcome, never a kind of failure: the bank has not said
+ * yes or no, so the money may still go through. `refunded` is a payment that
+ * was taken and has been returned.
+ */
+export type PaymentResultStatus = 'success' | 'pending' | 'failed' | 'refunded';
+export interface PaymentResultProps {
+    status: PaymentResultStatus;
+    /** Integer paise, as the API carries it. Shown in rupees with Indian digit grouping. */
+    amount: number;
+    /** ISO 4217 code of `amount`'s currency. Default `'INR'`. */
+    currency?: string;
+    /** Who was paid ("Capnix"). */
+    payee?: string;
+    /** The gateway or bank reference (a UPI RRN or UTR). Read digit by digit by a screen reader. */
+    reference?: string;
+    /** When the payment was made: an ISO string, a Date or epoch milliseconds. Shown in IST. */
+    paidAt?: string | number | Date;
+    /** How it was paid ("UPI, HDFC Bank ...4821"). */
+    method?: string;
+    /** Receipt rows after the built-in ones. A row with an empty value is dropped. */
+    rows?: ReadonlyArray<DescriptionItem>;
+    /**
+     * For `failed`: whether money left the account. `true` says it will come back; `false` says
+     * nothing was taken and is the only value that lets `onRetry` show. Left unset, the screen
+     * tells the person to check their statement first and offers no retry.
+     */
+    debited?: boolean;
+    /** Working days the bank takes to return a debited amount. Default 5. */
+    refundDays?: number;
+    /** For `pending`: when it should settle, shown in IST. Without it the usual window is stated. */
+    settlesBy?: string | number | Date;
+    /** Replaces the heading ("Payment successful"). */
+    title?: string;
+    /** Replaces the line under the amount. The pending safety lines are not replaceable. */
+    message?: string;
+    /** Shows a Share receipt button. The app builds and shares the receipt itself. */
+    onShare?: () => void;
+    /** Shows a Download button. */
+    onDownload?: () => void;
+    /** Shows a Done button. */
+    onDone?: () => void;
+    /** Shows Try again. Honoured only for a `failed` payment with `debited={false}`. */
+    onRetry?: () => void;
+    /** Shows Check status while `pending`. The app polls or refetches; this component never does. */
+    onRefresh?: () => void;
+    /** Puts Check status into its busy state. */
+    refreshing?: boolean;
+    /** Burst of confetti on success. Default true. Not played under Reduce Motion. */
+    celebrate?: boolean;
+    /**
+     * Haptic on the outcome: a success buzz for `success` and an error buzz for `failed`.
+     * `pending` and `refunded` never buzz. Default true.
+     */
+    haptic?: boolean;
+    style?: StyleProp<ViewStyle>;
+    testID?: string;
+}
+/**
+ * The end of a payment: what happened, how much, and what to do next. A UPI
+ * payment can sit between "sent" and "settled" for minutes or hours, and showing
+ * that as a failure, or offering Try again, is how people pay twice. So `pending`
+ * has its own mark, its own word and no retry, and a failed payment offers retry
+ * only when the caller says nothing was debited.
+ */
+export declare const PaymentResult: React.FC<PaymentResultProps>;
+export default PaymentResult;
+//# sourceMappingURL=PaymentResult.d.ts.map

package/lib/typescript/module/components/PaymentResult/index.d.ts

@@ -0,0 +1,3 @@
+export type { PaymentResultProps, PaymentResultStatus } from './PaymentResult.js';
+export { default, PaymentResult } from './PaymentResult.js';
+//# sourceMappingURL=index.d.ts.map

package/lib/typescript/module/components/ScannerOverlay/ScannerOverlay.d.ts

@@ -0,0 +1,74 @@
+import type React from 'react';
+import type { View as RNView, StyleProp, ViewStyle } from 'react-native';
+import type { HapticType } from '../../utils/hapticUtils.js';
+/**
+ * `scanning` waits for a code; `found` freezes the frame on success; `invalid`
+ * shows `labels.invalid` for a code the app does not accept. `noPermission` and
+ * `noCamera` replace the camera with a panel: the children are not rendered, so
+ * the app never mounts a camera it cannot use.
+ */
+export type ScannerOverlayState = 'scanning' | 'found' | 'invalid' | 'noPermission' | 'noCamera';
+export interface ScannerOverlayLabels {
+    /** Default 'Code found'. Spoken and shown when `state` is `found`. */
+    found: string;
+    /** Default 'This code cannot be used. Try another.' Shown when `state` is `invalid`. */
+    invalid: string;
+    /** Default 'Turn torch on'. */
+    torchOn: string;
+    /** Default 'Turn torch off'. */
+    torchOff: string;
+    /** Default 'Enter code instead'. */
+    manualEntry: string;
+    /** Default 'Upload from gallery'. */
+    gallery: string;
+    /** Default 'Camera access is off'. */
+    noPermissionTitle: string;
+    /** Default 'Allow camera access to scan a code.' */
+    noPermissionMessage: string;
+    /** Default 'Allow camera access'. */
+    permissionAction: string;
+    /** Default 'No camera found'. */
+    noCameraTitle: string;
+    /** Default 'This device has no camera available. You can still add the code another way.' */
+    noCameraMessage: string;
+}
+export interface ScannerOverlayProps {
+    /**
+     * The camera view (for example expo-camera's `CameraView`). It fills the
+     * overlay, and the overlay never touches it: mapping `torch` to the
+     * camera's `enableTorch` and `state` to its scan callback is the app's job.
+     */
+    children?: React.ReactNode;
+    /** Default `'scanning'`. */
+    state?: ScannerOverlayState;
+    /** The line under the frame while scanning. Default 'Point the camera at the code'. */
+    hint?: string;
+    /** Replaces any of the default texts. */
+    labels?: Partial<ScannerOverlayLabels>;
+    /** Whether the torch is on. Default `false`. */
+    torch?: boolean;
+    /** Shows the torch button, which calls this with the next value. Hidden when omitted. */
+    onTorchChange?: (next: boolean) => void;
+    /** Shows the 'Enter code instead' button. It stays reachable in every state, camera or not. */
+    onManualEntry?: () => void;
+    /** Shows the 'Upload from gallery' button. */
+    onGallery?: () => void;
+    /** Shows the button on the `noPermission` panel; the app asks or opens Settings. */
+    onPermissionAction?: () => void;
+    /**
+     * Side of the square cutout in points. Never below 240, so a code is large
+     * enough to frame, and never wider than the screen less its margins. Default 260.
+     */
+    frameSize?: number;
+    /**
+     * The torch button's press haptic; default `'selection'`. `false` also
+     * turns off the success and error haptics fired when `state` changes.
+     */
+    haptic?: HapticType | false;
+    style?: StyleProp<ViewStyle>;
+    testID?: string;
+}
+declare const ScannerOverlay: React.ForwardRefExoticComponent<ScannerOverlayProps & React.RefAttributes<RNView>>;
+export { ScannerOverlay };
+export default ScannerOverlay;
+//# sourceMappingURL=ScannerOverlay.d.ts.map

package/lib/typescript/module/components/ScannerOverlay/index.d.ts

@@ -0,0 +1,3 @@
+export type { ScannerOverlayLabels, ScannerOverlayProps, ScannerOverlayState } from './ScannerOverlay.js';
+export { default, ScannerOverlay } from './ScannerOverlay.js';
+//# sourceMappingURL=index.d.ts.map

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

@@ -2,6 +2,8 @@ import type { StyleProp, TextInputProps, TextStyle, ViewStyle } from 'react-nati
 import { TextInput } from 'react-native';
 import type { HapticType } from '../../utils/hapticUtils.js';
 import type { SlotIcon } from '../AppIcon/slotIcon.js';
+import type { SearchScope, SearchSuggestion } from './SearchPanel.js';
+export type { SearchScope, SearchSuggestion };
 export type SearchBarSize = 'sm' | 'md' | 'lg';
 export type SearchBarVariant = 'filled' | 'outlined' | 'underline';
 export type SearchBarLabelMode = 'top' | 'float';
@@ -33,6 +35,39 @@ export interface SearchBarProps extends Omit<TextInputProps, 'style' | 'value' |
      * (the pill). Ignored on `underline`, which is always square.
      */
     borderRadius?: number;
+    /**
+     * Chips under the field that narrow what is searched, for example All, People, Files.
+     * Put the broadest scope first: it is the one selected until the person picks another.
+     */
+    scopes?: SearchScope[];
+    /** The selected scope's `value`. Pass it to control the selection; leave it out to let the bar keep it. */
+    scope?: string;
+    onScopeChange?: (value: string) => void;
+    /**
+     * Searches to offer while the field is focused and empty, newest first. The app keeps
+     * them; `useRecentSearches` does it through mobile-core storage.
+     */
+    recents?: string[];
+    /** Heading above the recent searches. Default `'Recent searches'`. */
+    recentsTitle?: string;
+    /** Most recent searches drawn. Default 8. */
+    maxRecents?: number;
+    /** A recent search was tapped. The bar blurs the field; the app sets the text and runs the search. */
+    onSelectRecent?: (text: string) => void;
+    /** Shows a remove button on each recent search. */
+    onRemoveRecent?: (text: string) => void;
+    /** Shows a "Clear all" button above the recent searches. */
+    onClearRecents?: () => void;
+    /**
+     * Predicted searches to offer while the field is focused and has text. The app fetches
+     * them (from the debounced `onChangeText`); the part of each that matches the field is
+     * drawn emphasised. A string is shorthand for `{ text }`.
+     */
+    suggestions?: (string | SearchSuggestion)[];
+    /** Most suggestions drawn. Default 8. */
+    maxSuggestions?: number;
+    /** A suggestion was tapped. The bar blurs the field; the app sets the text and runs the search. */
+    onSelectSuggestion?: (suggestion: SearchSuggestion) => void;
     /** Haptic feedback for interactions. Pass false to disable; pass a HapticType to override the default. */
     haptic?: HapticType | false;
     style?: StyleProp<ViewStyle>;

package/lib/typescript/module/components/SearchBar/SearchPanel.d.ts

@@ -0,0 +1,49 @@
+import type React from 'react';
+import type { HapticType } from '../../utils/hapticUtils.js';
+import type { SlotIcon } from '../AppIcon/slotIcon.js';
+/** A named filter under the field, such as All, People or Files. */
+export interface SearchScope {
+    label: string;
+    value: string;
+}
+/** A row of predicted searches under the field. A plain string stands for `{ text }`. */
+export interface SearchSuggestion {
+    /** Identifies the row when two suggestions share text. Default: the text. */
+    id?: string;
+    /** The suggested search; the part that matches the field is drawn emphasised. */
+    text: string;
+    /** A second, quieter line under the text. */
+    subtitle?: string;
+    /** Replaces the magnifier. */
+    icon?: SlotIcon;
+}
+export declare const normalizeSuggestion: (item: string | SearchSuggestion) => SearchSuggestion;
+interface HoldProps {
+    /** Called on press-in, so the panel survives the field losing focus to the tap. */
+    onHold: () => void;
+    onRelease: () => void;
+}
+interface ScopeBarProps {
+    scopes: SearchScope[];
+    scope: string;
+    disabled: boolean;
+    haptic?: HapticType | false;
+    onChange: (value: string) => void;
+}
+export declare const SearchScopeBar: React.FC<ScopeBarProps>;
+interface RecentsProps extends HoldProps {
+    recents: string[];
+    title: string;
+    onSelect: (text: string) => void;
+    onRemove?: (text: string) => void;
+    onClear?: () => void;
+}
+export declare const SearchRecents: React.FC<RecentsProps>;
+interface SuggestionsProps extends HoldProps {
+    suggestions: SearchSuggestion[];
+    query: string;
+    onSelect: (item: SearchSuggestion) => void;
+}
+export declare const SearchSuggestions: React.FC<SuggestionsProps>;
+export {};
+//# sourceMappingURL=SearchPanel.d.ts.map

package/lib/typescript/module/components/SearchBar/highlight.d.ts

@@ -0,0 +1,14 @@
+export interface HighlightPart {
+    text: string;
+    match: boolean;
+    /** Where the run starts in the text; unique per run, so it serves as a list key. */
+    start: number;
+}
+/**
+ * Splits `text` into runs that match a word of `query` (case-insensitive) and
+ * runs that do not, so a suggestion row can draw the typed part differently.
+ * Every whitespace-separated word of the query is matched wherever it occurs;
+ * adjacent matches merge into one run. No query or no match gives one plain run.
+ */
+export declare const splitHighlight: (text: string, query: string) => HighlightPart[];
+//# sourceMappingURL=highlight.d.ts.map

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

@@ -1,3 +1,6 @@
 export type { SearchBarProps, SearchBarSize, SearchBarVariant } from './SearchBar.js';
 export { default, SearchBar } from './SearchBar.js';
+export type { SearchScope, SearchSuggestion } from './SearchPanel.js';
+export type { UseRecentSearchesOptions, UseRecentSearchesResult } from './useRecentSearches.js';
+export { useRecentSearches } from './useRecentSearches.js';
 //# sourceMappingURL=index.d.ts.map

package/lib/typescript/module/components/SearchBar/useRecentSearches.d.ts

@@ -0,0 +1,24 @@
+export interface UseRecentSearchesOptions {
+    /** Most searches kept; the oldest drops first. Default 8. */
+    max?: number;
+}
+export interface UseRecentSearchesResult {
+    /** Newest first. Empty until the saved list has loaded. */
+    recents: string[];
+    /** Puts `text` at the front. Blank text is ignored; the same text in any case moves up instead of repeating. */
+    add: (text: string) => void;
+    remove: (text: string) => void;
+    /** Empties the list and returns what it held, so a caller can offer undo with `replace`. */
+    clear: () => string[];
+    /** Swaps the whole list, for undo. */
+    replace: (next: string[]) => void;
+}
+/**
+ * The device-kept list behind `SearchBar`'s recent searches, saved through
+ * mobile-core `Storage` under `storageKey`. Give each search screen its own
+ * key. `SearchBar` only draws what it is handed; wire this hook's `recents`,
+ * `remove` and `clear` to its `recents`, `onRemoveRecent` and `onClearRecents`,
+ * and call `add` when a search is submitted.
+ */
+export declare const useRecentSearches: (storageKey: string, options?: UseRecentSearchesOptions) => UseRecentSearchesResult;
+//# sourceMappingURL=useRecentSearches.d.ts.map

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

@@ -76,7 +76,8 @@ interface BaseSelectProps<T = SelectOption> {
     /**
      * Fixed text drawn before the value: `'₹'`, `'+91'`. The same prop and look
      * as Input's `prefix`, in the placeholder colour. Sits after `leftIcon`. A
-     * node (a symbol with a subscript) is drawn as is, with the same gap.
+     * node (a symbol with a subscript) sits in the same Text with the same gap,
+     * so its base and subscript take that size and colour.
      */
     prefix?: React.ReactNode;
     /**