@webority/mobile-ui 0.9.0 → 0.10.0

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

@@ -0,0 +1,94 @@
+import type { StyleProp, ViewStyle } from 'react-native';
+import type { HapticType } from '../../utils/hapticUtils.js';
+import type { SignatureStroke } from './signatureGeometry.js';
+export type SignatureMode = 'draw' | 'type';
+export interface SignaturePadLabels {
+    /** Screen-reader name of the pad. */
+    pad: string;
+    /** Screen-reader hint on the drawing pad. */
+    padHint: string;
+    /** Hint under the drawing pad. */
+    caption: string;
+    /** Hint under the typed-name preview. */
+    typedCaption: string;
+    undo: string;
+    clear: string;
+    typeInstead: string;
+    drawInstead: string;
+    typedLabel: string;
+    typedPlaceholder: string;
+    /** Screen-reader value while nothing is signed. */
+    empty: string;
+    /** Screen-reader value once signed. */
+    signed: string;
+    /** Spoken when the pad switches to typing, including at start under a screen reader. */
+    typingAnnouncement: string;
+    drawingAnnouncement: string;
+    clearedAnnouncement: string;
+    undoneAnnouncement: string;
+    /** Message of the error `toFile()` rejects with while nothing is signed. */
+    emptyError: string;
+}
+export interface SignaturePadRef {
+    /**
+     * Writes the signature as a PNG on an opaque ground and answers its uri: a file in the app's
+     * cache folder on iOS and Android, a data uri on web. Rejects while the pad is empty.
+     */
+    toFile: () => Promise<string>;
+    /** The signature as a standalone SVG document string, in the current mode. */
+    toSvg: () => string;
+    /** Clears the strokes in drawing mode, or the name in typing mode. */
+    clear: () => void;
+    /** Removes the last stroke (drawing mode only). */
+    undo: () => void;
+    /** True while the active mode has no signature. */
+    isEmpty: () => boolean;
+}
+export interface SignaturePadProps {
+    /** A signature kept from before: each stroke a list of [x, y] points in the pad's own dp. Read once, at mount. */
+    initialStrokes?: ReadonlyArray<SignatureStroke>;
+    /** Answers the whole signature after each stroke, Undo and Clear, in the shape of `initialStrokes`. */
+    onChange?: (strokes: SignatureStroke[]) => void;
+    /** A typed name kept from before. Read once, at mount. */
+    initialTypedName?: string;
+    /** Answers the typed name on each edit and on Clear. */
+    onTypedNameChange?: (name: string) => void;
+    /** The mode to start in. Under a screen reader an untouched pad starts in `'type'`. Default `'draw'`. */
+    defaultMode?: SignatureMode;
+    onModeChange?: (mode: SignatureMode) => void;
+    /**
+     * Answers whether the active mode holds a signature, once at mount and on each change. Gate the
+     * submit button on this; the ref's `isEmpty()` cannot re-render a screen.
+     */
+    onEmptyChange?: (isEmpty: boolean) => void;
+    /** Offers the type-your-name path. Turn it off only where a typed signature is not acceptable. Default `true`. */
+    allowTyped?: boolean;
+    /** The signer's name for the line under the pad ("Signed by Priya Raghavan, 11-Oct-2026, 3:42 PM"). */
+    signedBy?: string;
+    /** When it was signed, shown in IST. Defaults to the time of the last change made in this session; a kept signature shows no time. */
+    signedAt?: Date | string | number;
+    /** Pad height in dp. Default 180. */
+    height?: number;
+    /** Longest typed name. Default 100. */
+    maxNameLength?: number;
+    /** Ink of the strokes and the typed name. Defaults to the light theme's primary text, in both colour schemes. */
+    inkColor?: string;
+    /** Ground of the pad and of the PNG. Defaults to the light theme's elevated surface, in both colour schemes. */
+    paperColor?: string;
+    /**
+     * Font family of the typed name. Default a system script face: Snell Roundhand on iOS, `cursive`
+     * on Android and web. Register a script font in the app and pass its family name to use it.
+     */
+    scriptFontFamily?: string;
+    /** Texts, for localisation. Any key left out keeps its English default. */
+    labels?: Partial<SignaturePadLabels>;
+    /** Haptic on Undo, Clear and the mode switch; never while drawing. Pass `false` to disable. Default `'selection'`. */
+    haptic?: HapticType | false;
+    disabled?: boolean;
+    style?: StyleProp<ViewStyle>;
+    testID?: string;
+}
+declare const SignaturePad: import("react").ForwardRefExoticComponent<SignaturePadProps & import("react").RefAttributes<SignaturePadRef>>;
+export { SignaturePad };
+export default SignaturePad;
+//# sourceMappingURL=SignaturePad.d.ts.map

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

@@ -0,0 +1,4 @@
+export type { SignatureMode, SignaturePadLabels, SignaturePadProps, SignaturePadRef } from './SignaturePad.js';
+export { SignaturePad } from './SignaturePad.js';
+export type { SignaturePoint, SignatureStroke } from './signatureGeometry.js';
+//# sourceMappingURL=index.d.ts.map

package/lib/typescript/module/components/SignaturePad/signatureGeometry.d.ts

@@ -0,0 +1,36 @@
+/** One touch point in the pad's own coordinates (dp from its top-left corner), to one decimal. */
+export type SignaturePoint = readonly [number, number];
+/** One pen-down to pen-up line. */
+export type SignatureStroke = ReadonlyArray<SignaturePoint>;
+/** Width the exported SVG assumes before the pad has been laid out. */
+export declare const FALLBACK_WIDTH = 320;
+/** Where the typed name sits, as a fraction of the pad's height (the baseline rule sits there). */
+export declare const BASELINE_RATIO = 0.7;
+export declare const pointOf: (x: number, y: number) => SignaturePoint;
+export declare const distanceBetween: (a: SignaturePoint, b: SignaturePoint) => number;
+/**
+ * An SVG path through the points, smoothed with quadratic curves that use each
+ * point as a control point and the midpoint to the next as the end. Two points
+ * (a tap, which also draws a dot through the round line cap) stay a straight
+ * segment.
+ */
+export declare const strokePath: (points: SignatureStroke) => string;
+/** Font size that keeps a typed name inside the pad: large for short names, shrinking to a floor. */
+export declare const typedFontSize: (width: number, name: string) => number;
+export declare const escapeXml: (value: string) => string;
+export interface SignatureSvgInput {
+    width: number;
+    height: number;
+    /** `'draw'` writes the strokes, `'type'` writes the typed name. */
+    mode: 'draw' | 'type';
+    strokes: ReadonlyArray<SignatureStroke>;
+    typedName: string;
+    ink: string;
+    paper: string;
+    strokeWidth: number;
+    /** CSS font-family list for the typed name. */
+    fontFamily: string;
+}
+/** The signature as a standalone SVG document string, with the paper as an opaque ground. */
+export declare const buildSignatureSvg: (input: SignatureSvgInput) => string;
+//# sourceMappingURL=signatureGeometry.d.ts.map

package/lib/typescript/module/components/SignaturePad/writePng.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Writes a base64 PNG into the app's cache folder and answers its file uri.
+ * expo-file-system is read here, on the first signature saved, so nothing that
+ * imports the pad pays for it at start (the web build uses `writePng.web.ts`).
+ */
+export declare const writePng: (base64: string) => string;
+//# sourceMappingURL=writePng.d.ts.map

package/lib/typescript/module/components/SignaturePad/writePng.web.d.ts

@@ -0,0 +1,3 @@
+/** The browser has no cache folder: the PNG is answered as a data uri, usable as an image source or an upload body. */
+export declare const writePng: (base64: string) => string;
+//# sourceMappingURL=writePng.web.d.ts.map

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

@@ -0,0 +1,41 @@
+/**
+ * Sparkline: a small trend line with no axes, for a row or a tile.
+ *
+ * Drawn in real pixels with react-native-svg (the width is measured, or given),
+ * so the stroke and the last-point dot keep their shape. The range is the
+ * series' own: a sparkline shows the shape of the change, not its size. It
+ * reads as one image to a screen reader, with a label that states the start,
+ * end, low and high values, so nothing rests on the line's colour.
+ */
+import type { View as RNView, StyleProp, ViewStyle } from 'react-native';
+export type SparklineTone = 'primary' | 'success' | 'warning' | 'error' | 'info' | 'neutral';
+export interface SparklineProps {
+    /** The series, oldest first. Values that are not finite numbers are dropped. */
+    data: ReadonlyArray<number>;
+    /** Colour of the line. Default `'primary'`. Drawn in the tone's text ink so it holds 3:1 on the page in light and dark. */
+    tone?: SparklineTone;
+    /** Line colour override; wins over `tone`. */
+    color?: string;
+    /** Tint the area under the line. Default `false`. */
+    fill?: boolean;
+    /** Mark the last point with a dot. Default `true`. */
+    highlightLast?: boolean;
+    /** Height in points. Default `32`. */
+    height?: number;
+    /** Width in points. Default: the full width of a column parent; in a row, give a width or `flex: 1` through `style`. */
+    width?: number;
+    /** Line thickness in points. Default `2`. */
+    strokeWidth?: number;
+    /** What the series is, read first by a screen reader: "Collections, last 30 days". */
+    label?: string;
+    /** Writes a value into the default accessibility label. Default: the house number format (Indian grouping). */
+    formatLabel?: (value: number) => string;
+    /** Replaces the whole accessibility label. */
+    accessibilityLabel?: string;
+    style?: StyleProp<ViewStyle>;
+    testID?: string;
+}
+declare const Sparkline: import("react").ForwardRefExoticComponent<SparklineProps & import("react").RefAttributes<RNView>>;
+export { Sparkline };
+export default Sparkline;
+//# sourceMappingURL=Sparkline.d.ts.map

package/lib/typescript/module/components/Sparkline/geometry.d.ts

@@ -0,0 +1,20 @@
+export interface SparklineGeometry {
+    /** The line, an SVG path; empty when there is nothing to draw. */
+    line: string;
+    /** The line closed down to the bottom edge, for the area under it. */
+    area: string;
+    /** Where the last point sits. */
+    last: {
+        x: number;
+        y: number;
+    } | null;
+}
+/**
+ * Lays the series out in real pixels. The range is the series' own (a
+ * dynamic range, not zero based: a sparkline shows shape, not size); a flat
+ * series draws along the middle rather than dividing by a zero range. Values
+ * that are not finite numbers are dropped.
+ */
+export declare const sparklineGeometry: (data: ReadonlyArray<number>, width: number, height: number, inset: number) => SparklineGeometry;
+export declare const finiteValues: (data: ReadonlyArray<number>) => number[];
+//# sourceMappingURL=geometry.d.ts.map

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

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

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

@@ -1,13 +1,19 @@
 import type React from 'react';
 import type { View as RNView, StyleProp, ViewStyle } from 'react-native';
 export type SpinnerSize = 'sm' | 'md' | 'lg';
-export type SpinnerVariant = 'circular' | 'dots';
+export type SpinnerVariant = 'circular' | 'dots' | 'contained';
 export interface SpinnerProps {
     size?: SpinnerSize;
     color?: string;
     message?: string;
+    /** Ignored by `variant="contained"`, which fills its own parent instead. */
     overlay?: boolean;
     backdropColor?: string;
+    /**
+     * `'contained'` draws the indicator on a tinted round container and fills
+     * the card or section it sits in (no backdrop, no elevation), so one slow
+     * section can load without a full-screen spinner. Library default: `'circular'`.
+     */
     variant?: SpinnerVariant;
     accessibilityLabel?: string;
     style?: StyleProp<ViewStyle>;

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

@@ -3,6 +3,19 @@ import type { View as RNView, StyleProp, ViewStyle } from 'react-native';
 import type { IconVariant } from '../AppIcon/AppIcon.js';
 import type { SlotIcon } from '../AppIcon/slotIcon.js';
 import type { IconBadgeTone } from '../IconBadge/index.js';
+export interface StatTileTrend {
+    /**
+     * The change. A number is a percentage (12.4 for 12.4%) and is drawn without its own sign,
+     * because `direction` carries it; a string ("12 more") is drawn as given.
+     */
+    value: number | string;
+    /** Which way the figure moved. `'flat'` draws a dash and no sign. */
+    direction: 'up' | 'down' | 'flat';
+    /** Which direction is good news. Colours the change green or red. Default `'up'`. */
+    goodWhen?: 'up' | 'down';
+    /** What the change is measured against, written in full: "vs last month". */
+    period?: string;
+}
 export interface StatTileProps {
     /** What the figure measures, drawn small above it. */
     label: string;
@@ -16,11 +29,21 @@ export interface StatTileProps {
     tone?: IconBadgeTone;
     /** A small line under the figure (a period, a delta). */
     caption?: ReactNode;
+    /**
+     * How the figure changed. Drawn under the figure as an arrow, a sign and the change, so the
+     * direction never rests on colour alone: "+12.4% vs last month".
+     */
+    trend?: StatTileTrend;
+    /** A small chart under the tile's text, usually a `Sparkline`. */
+    sparkline?: ReactNode;
     /** Makes the tile pressable, with the button role. */
     onPress?: () => void;
     /** Draws a placeholder of the same footprint while the figure loads. */
     loading?: boolean;
-    /** Announced instead of the label and figure. Defaults to `"label, value"` for a text figure. */
+    /**
+     * Announced instead of the label and figure. Defaults to `"label, value"` for a text figure,
+     * with the change after it ("up 12.4% vs last month") when there is a `trend`.
+     */
     accessibilityLabel?: string;
     style?: StyleProp<ViewStyle>;
     testID?: string;

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

@@ -1,3 +1,3 @@
-export type { StatTileProps } from './StatTile.js';
+export type { StatTileProps, StatTileTrend } from './StatTile.js';
 export { default, StatTile } from './StatTile.js';
 //# sourceMappingURL=index.d.ts.map

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

@@ -29,10 +29,30 @@ export interface ToastOptions {
     /** Style applied to the trailing action Pressable. */
     actionButtonStyle?: StyleProp<ViewStyle>;
     testID?: string;
+    /**
+     * A toast shown with the same key replaces the one on screen. A pending
+     * `toast.undo` commit of the replaced toast runs first.
+     */
+    key?: string;
+    /**
+     * Draws a thin bar along the bottom edge that empties over the duration. It is
+     * drawn full and still under reduced motion, and not drawn when the toast does
+     * not time out.
+     */
+    countdown?: boolean;
 }
 export interface ToastItem extends ToastOptions {
     id: string;
 }
+/** What the provider shares with every toast it draws. */
+export interface ToastRuntime {
+    /** A screen reader is on (always false on web, where it cannot be detected). */
+    screenReaderOn: boolean;
+    /** The time left for a toast that was on screen before it moved to another host. */
+    readRemaining: (id: string) => number | undefined;
+    /** Stores the time left when a running toast unmounts, so its next host resumes it. */
+    writeRemaining: (id: string, remainingMs: number) => void;
+}
 export interface ToastProps {
     toast: ToastItem;
     index: number;
@@ -43,6 +63,7 @@ export interface ToastProps {
      * keeps its remaining time. Defaults to the moment this component mounts.
      */
     shownAt?: number;
+    runtime?: ToastRuntime;
 }
 declare const Toast: React.FC<ToastProps>;
 export { Toast };

package/lib/typescript/module/components/Toast/ToastProvider.d.ts

@@ -1,8 +1,28 @@
 import type React from 'react';
 import type { HapticType } from '../../utils/hapticUtils.js';
 import type { ToastOptions, ToastPosition, ToastVariant } from './Toast.js';
+export interface ToastUndoOptions extends Omit<ToastOptions, 'message' | 'variant' | 'action' | 'countdown' | 'duration'> {
+    /** Runs when Undo is pressed. The toast closes and `onCommit` never runs. */
+    onUndo: () => void;
+    /**
+     * Runs once when the toast ends any other way: it times out, is swiped away,
+     * is hidden, is pushed out by newer toasts, is replaced by a toast with the
+     * same `key`, or the provider unmounts. Do the irreversible part here.
+     */
+    onCommit?: () => void;
+    /** Label of the action button. Default `Undo`. */
+    undoLabel?: string;
+    /**
+     * How long Undo stays, in ms. Default `6000`, never shorter than `6000`; `0`
+     * keeps it until dismissed. With a screen reader on the toast waits to be
+     * dismissed whatever this is, so keep the item recoverable some other way.
+     */
+    duration?: number;
+}
 export interface ToastApi {
     show: (opts: ToastOptions) => string;
+    /** A toast with an Undo action and a countdown bar; see `ToastUndoOptions`. */
+    undo: (message: string, opts: ToastUndoOptions) => string;
     hide: (id: string) => void;
     hideAll: () => void;
 }
@@ -38,6 +58,7 @@ export declare const ToastHost: React.FC;
 export declare const useToast: () => ToastApi;
 interface ToastGlobal {
     show: (opts: ToastOptions) => string;
+    undo: (message: string, opts: ToastUndoOptions) => string;
     success: (message: string, opts?: Omit<ToastOptions, 'message' | 'variant'>) => string;
     error: (message: string, opts?: Omit<ToastOptions, 'message' | 'variant'>) => string;
     warning: (message: string, opts?: Omit<ToastOptions, 'message' | 'variant'>) => string;

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

@@ -1,5 +1,5 @@
 export type { ToastAction, ToastItem, ToastOptions, ToastPosition, ToastProps, ToastVariant } from './Toast.js';
 export { default, Toast } from './Toast.js';
-export type { ToastApi, ToastHaptics, ToastProviderProps } from './ToastProvider.js';
+export type { ToastApi, ToastHaptics, ToastProviderProps, ToastUndoOptions } from './ToastProvider.js';
 export { ToastHost, ToastProvider, toast, useToast } from './ToastProvider.js';
 //# sourceMappingURL=index.d.ts.map

package/lib/typescript/module/components/Tooltip/RichTooltipBody.d.ts

@@ -0,0 +1,27 @@
+import type React from 'react';
+import type { Text as RNText, View as RNView, StyleProp, TextStyle } from 'react-native';
+/** The one text button of a rich tooltip. */
+export interface TooltipAction {
+    label: string;
+    onPress: () => void;
+    accessibilityLabel?: string;
+}
+interface RichTooltipBodyProps {
+    title?: string;
+    content: string | React.ReactNode;
+    action?: TooltipAction;
+    onAction: () => void;
+    /** Takes screen reader focus on open: the title, or the text when there is none. */
+    focusRef: React.Ref<RNText>;
+    /** Takes keyboard focus on open on the web. */
+    actionRef: React.Ref<RNView>;
+    messageStyle?: StyleProp<TextStyle>;
+}
+/**
+ * The card of `variant="rich"`: a light surface with a title, the content and
+ * one action. Not a child of the close area, so every part is reachable by a
+ * screen reader on its own.
+ */
+export declare const RichTooltipBody: React.FC<RichTooltipBodyProps>;
+export {};
+//# sourceMappingURL=RichTooltipBody.d.ts.map

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

@@ -1,11 +1,33 @@
 import React from 'react';
 import type { StyleProp, TextStyle, ViewStyle } from 'react-native';
+import type { TooltipAction } from './RichTooltipBody.js';
+export type { TooltipAction } from './RichTooltipBody.js';
 export type TooltipPlacement = 'top' | 'bottom' | 'left' | 'right' | 'auto';
 export type TooltipTrigger = 'longPress' | 'press' | 'manual';
+/**
+ * `plain` is a short dark hint. `rich` is a light card with a `title`, the
+ * `content` and one `action`, the Material rich tooltip: it opens on press by
+ * default, stays until a tap outside, Back, Escape or its action, moves
+ * screen reader focus into itself and back to the trigger on close, and sits
+ * only above or below its trigger. Anything with inputs, a list or more than
+ * one action belongs in a BottomSheet.
+ */
+export type TooltipVariant = 'plain' | 'rich';
 export interface TooltipProps {
     content: string | React.ReactNode;
     children: React.ReactElement;
+    /** Default `'plain'`. */
+    variant?: TooltipVariant;
+    /** Rich only: one line over the content. */
+    title?: string;
+    /** Rich only: one text button. It runs after the tooltip has closed. */
+    action?: TooltipAction;
+    /** `left` and `right` read as `auto` on a rich tooltip. */
     placement?: TooltipPlacement;
+    /**
+     * Default `'longPress'`, or `'press'` for a rich tooltip. A long press is
+     * never attached to a child with its own `contextMenu`: the menu wins.
+     */
     trigger?: TooltipTrigger;
     visible?: boolean;
     onVisibleChange?: (visible: boolean) => void;
@@ -20,6 +42,8 @@ export interface TooltipProps {
     arrowStyle?: StyleProp<ViewStyle>;
     /** Style override applied to the message Text (only when `content` is a string). */
     messageStyle?: StyleProp<TextStyle>;
+    /** Accessible name of the tap-outside area. Default `'Close tooltip'`. */
+    closeLabel?: string;
     testID?: string;
 }
 declare const Tooltip: React.FC<TooltipProps>;

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

@@ -1,3 +1,3 @@
-export type { TooltipPlacement, TooltipProps, TooltipTrigger } from './Tooltip.js';
+export type { TooltipAction, TooltipPlacement, TooltipProps, TooltipTrigger, TooltipVariant } from './Tooltip.js';
 export { default, Tooltip } from './Tooltip.js';
 //# sourceMappingURL=index.d.ts.map

package/lib/typescript/module/components/Tooltip/tooltipPosition.d.ts

@@ -0,0 +1,35 @@
+import type { LayoutRectangle } from 'react-native';
+import type { PlacementViewport } from '../../utils/placement.js';
+export type TooltipSide = 'top' | 'bottom' | 'left' | 'right';
+export interface TooltipPosition {
+    top: number;
+    left: number;
+    placement: TooltipSide;
+    /** Distance of the arrow tip along the edge that faces the trigger. */
+    arrowOffset: number;
+}
+export interface TooltipLayout {
+    /** The trigger in window coordinates; null until measured. */
+    anchor: LayoutRectangle | null;
+    /** The bubble's measured size; zeros until its first layout. */
+    size: {
+        width: number;
+        height: number;
+    };
+    placement: TooltipSide | 'auto';
+    /** A rich tooltip only goes above or below its trigger. */
+    rich: boolean;
+    viewport: PlacementViewport;
+    maxWidth: number;
+    gap: number;
+    /** Least distance from each safe edge. */
+    padding: number;
+    arrowCornerPadding: number;
+}
+/**
+ * Where a tooltip bubble sits. Above and below go through the shared
+ * placement engine (the one Menu uses), so both flip and clamp alike; left
+ * and right stay a tooltip's own.
+ */
+export declare const resolveTooltipPosition: (layout: TooltipLayout) => TooltipPosition;
+//# sourceMappingURL=tooltipPosition.d.ts.map

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

@@ -0,0 +1,21 @@
+import type React from 'react';
+import type { StyleProp, ViewStyle } from 'react-native';
+export interface TypingIndicatorProps {
+    /** Shown beside the dots and read by screen readers, e.g. "Shannon is typing". */
+    label?: string;
+    /** Screen-reader name when there is no visible `label`. Default 'Typing'. */
+    accessibilityLabel?: string;
+    /** Draw the dots inside a `theirs` bubble. Default true. */
+    bubble?: boolean;
+    style?: StyleProp<ViewStyle>;
+    testID?: string;
+}
+/**
+ * Three pulsing dots, with an optional line such as "Shannon is typing", for
+ * the bottom of a `MessageList` (its `typing` slot). The pulse runs on the UI
+ * thread and stops under Reduce Motion. It is not announced: a person hears
+ * the reply when it arrives.
+ */
+export declare const TypingIndicator: React.FC<TypingIndicatorProps>;
+export default TypingIndicator;
+//# sourceMappingURL=TypingIndicator.d.ts.map

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

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

package/lib/typescript/module/components/WheelPicker/Wheel.d.ts

@@ -0,0 +1,34 @@
+import type React from 'react';
+import type { Theme } from '../../theme/types.js';
+import type { HapticType } from '../../utils/hapticUtils.js';
+export interface WheelItem {
+    value: string | number;
+    /** Text drawn in the row. */
+    label: string;
+    /** What a screen reader says for this value, such as "2 hours". Defaults to `label`. */
+    accessibilityLabel?: string;
+}
+export declare const WHEEL_VISIBLE_ITEMS = 5;
+export declare const WHEEL_CENTER_OFFSET: number;
+interface WheelProps {
+    label: string;
+    items: ReadonlyArray<WheelItem>;
+    selectedIndex: number;
+    onIndexChange: (index: number) => void;
+    itemHeight: number;
+    width?: number;
+    theme: Theme;
+    haptic?: HapticType | false;
+    disabled?: boolean;
+    reducedMotion: boolean;
+    testID?: string;
+}
+/**
+ * One scrolling column. It commits `onIndexChange` once the column rests on an
+ * item (momentum end on native, a short idle on web, where the browser has no
+ * snap-to-interval or momentum events), when a screen reader adjusts it, or
+ * when a key moves it. The caller owns `selectedIndex`.
+ */
+export declare const Wheel: React.FC<WheelProps>;
+export {};
+//# sourceMappingURL=Wheel.d.ts.map

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

@@ -0,0 +1,73 @@
+import type React from 'react';
+import type { StyleProp, ViewStyle } from 'react-native';
+import type { HapticType } from '../../utils/hapticUtils.js';
+import type { WheelItem } from './Wheel.js';
+export type { WheelItem } from './Wheel.js';
+export type WheelDurationStep = 1 | 5 | 15 | 30;
+export interface WheelPickerColumn {
+    /** Passed back to `onChange` in columns mode. */
+    key: string;
+    /** Names the column for a screen reader, such as "Hour". */
+    label: string;
+    items: ReadonlyArray<WheelItem>;
+    /** The selected item's `value`. A value that is not in `items` shows the first item. */
+    value: string | number;
+    /** Fixed width in points. Default 64 in columns mode; the list mode column fills the row. */
+    width?: number;
+    /** Text drawn after the column, such as ":" between hours and minutes. */
+    separator?: string;
+    /** Small unit label drawn beside the selected row, such as "min". */
+    unit?: string;
+    /** Empty space after the column (and its unit or separator), in points. */
+    gapAfter?: number;
+    testID?: string;
+}
+interface WheelPickerBaseProps {
+    /** Tick at each detent. `false` is silent; a `HapticType` replaces the default `denseTick`. */
+    haptic?: HapticType | false;
+    /** Locks scrolling and screen reader adjustment and dims the wheels. */
+    disabled?: boolean;
+    testID?: string;
+    /** Style of the row that holds the wheels. */
+    style?: StyleProp<ViewStyle>;
+}
+/** Several wheels side by side, each with its own items. */
+export interface WheelPickerColumnsProps extends WheelPickerBaseProps {
+    mode?: 'columns';
+    columns: ReadonlyArray<WheelPickerColumn>;
+    /** Fired with the column's `key` and the picked item's `value` once a wheel rests. */
+    onChange?: (key: string, value: string | number) => void;
+}
+/** One wheel over a short list of choices. */
+export interface WheelPickerListProps extends WheelPickerBaseProps {
+    mode: 'list';
+    items: ReadonlyArray<WheelItem | string | number>;
+    value?: string | number | null;
+    onChange?: (value: string | number) => void;
+    /** Names the wheel for a screen reader. Default "Value". */
+    label?: string;
+    /** Fixed width in points. Default fills the row. */
+    width?: number;
+}
+export interface WheelPickerDurationLabels {
+    hours?: string;
+    minutes?: string;
+    hourUnit?: string;
+    minuteUnit?: string;
+}
+/** Hours and minutes, up to 23 h 59 min, with the value as a whole number of minutes. */
+export interface WheelPickerDurationProps extends WheelPickerBaseProps {
+    mode: 'duration';
+    /** Duration in minutes. Clamped to `maxMinutes` and rounded to `minuteStep`. */
+    value: number;
+    onChange?: (minutes: number) => void;
+    minuteStep?: WheelDurationStep;
+    /** Upper bound in minutes. Default and ceiling 1439 (23 h 59 min). */
+    maxMinutes?: number;
+    labels?: WheelPickerDurationLabels;
+}
+export type WheelPickerProps = WheelPickerColumnsProps | WheelPickerListProps | WheelPickerDurationProps;
+declare const WheelPicker: React.FC<WheelPickerProps>;
+export { WheelPicker };
+export default WheelPicker;
+//# sourceMappingURL=WheelPicker.d.ts.map

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

@@ -0,0 +1,3 @@
+export type { WheelDurationStep, WheelItem, WheelPickerColumn, WheelPickerColumnsProps, WheelPickerDurationLabels, WheelPickerDurationProps, WheelPickerListProps, WheelPickerProps } from './WheelPicker.js';
+export { default, WheelPicker } from './WheelPicker.js';
+//# sourceMappingURL=index.d.ts.map