@webority/mobile-ui 0.9.1 → 0.10.0

package/lib/typescript/commonjs/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';
+/**
+ * `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/commonjs/components/PaymentResult/index.d.ts

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

package/lib/typescript/commonjs/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';
+/**
+ * `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/commonjs/components/ScannerOverlay/index.d.ts

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

package/lib/typescript/commonjs/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';
 import type { SlotIcon } from '../AppIcon/slotIcon';
+import type { SearchScope, SearchSuggestion } from './SearchPanel';
+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/commonjs/components/SearchBar/SearchPanel.d.ts

@@ -0,0 +1,49 @@
+import type React from 'react';
+import type { HapticType } from '../../utils/hapticUtils';
+import type { SlotIcon } from '../AppIcon/slotIcon';
+/** 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/commonjs/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/commonjs/components/SearchBar/index.d.ts

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

package/lib/typescript/commonjs/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/commonjs/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;
     /**

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

@@ -0,0 +1,94 @@
+import type { StyleProp, ViewStyle } from 'react-native';
+import type { HapticType } from '../../utils/hapticUtils';
+import type { SignatureStroke } from './signatureGeometry';
+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/commonjs/components/SignaturePad/index.d.ts

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

package/lib/typescript/commonjs/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/commonjs/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/commonjs/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/commonjs/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/commonjs/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/commonjs/components/Sparkline/index.d.ts

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

package/lib/typescript/commonjs/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/commonjs/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';
 import type { SlotIcon } from '../AppIcon/slotIcon';
 import type { IconBadgeTone } from '../IconBadge';
+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/commonjs/components/StatTile/index.d.ts

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

package/lib/typescript/commonjs/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 };