@webority/mobile-ui 0.9.1 → 0.11.0

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

@@ -0,0 +1,39 @@
+import type { PermissionKind, PermissionStatus } from '@webority/mobile-core/permissions';
+import type React from 'react';
+import type { StyleProp, ViewStyle } from 'react-native';
+import type { HapticType } from '../../utils/hapticUtils';
+import type { SlotIcon } from '../AppIcon/slotIcon';
+export interface PermissionPromptFallback {
+    /** Names the other way to do the job ("Enter address instead"). */
+    label: string;
+    onPress: () => void;
+}
+export interface PermissionPromptProps {
+    kind: PermissionKind;
+    /** What the feature is ("Scan a receipt"). Read first by a screen reader. */
+    title: string;
+    /** One sentence: what the app does with the access, ending in a full stop. */
+    reason: string;
+    /** An AppIcon name or any node, drawn in a tinted disc above the title. */
+    icon?: SlotIcon;
+    /** The status each time it settles: after the first check finds nothing to ask, and after each request or Cancel. */
+    onResult: (status: PermissionStatus) => void;
+    /** The way to carry on without the access, shown in the unavailable state. */
+    fallback?: PermissionPromptFallback;
+    /** Haptic on each button press. Default `'selection'`. */
+    haptic?: HapticType | false;
+    style?: StyleProp<ViewStyle>;
+    testID?: string;
+}
+/**
+ * Explains why the app needs a permission before the system prompt, in the way
+ * each platform's review accepts. iOS gets one Continue button that opens the
+ * system prompt, with no way to leave first (App Review rejects a "Not now").
+ * Android asks straight away the first time and explains only after one
+ * refusal, with Cancel. Once access is refused or the device lacks it, the
+ * prompt becomes an inline state with the fallback, and Open Settings only
+ * when it was already off on arrival, never straight after a refusal.
+ */
+export declare const PermissionPrompt: React.FC<PermissionPromptProps>;
+export default PermissionPrompt;
+//# sourceMappingURL=PermissionPrompt.d.ts.map

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

@@ -0,0 +1,5 @@
+export type { PermissionPromptFallback, PermissionPromptProps } from './PermissionPrompt';
+export { default, PermissionPrompt } from './PermissionPrompt';
+export type { PermissionPromptView, UsePermissionPromptOptions, UsePermissionPromptResult } from './usePermissionPrompt';
+export { usePermissionPrompt } from './usePermissionPrompt';
+//# sourceMappingURL=index.d.ts.map

package/lib/typescript/commonjs/components/PermissionPrompt/usePermissionPrompt.d.ts

@@ -0,0 +1,44 @@
+import type { PermissionKind, PermissionStatus } from '@webority/mobile-core/permissions';
+/**
+ * - `pending`: the first status read, or on Android the system prompt asked straight away.
+ * - `explain`: the explainer with Continue (and Cancel on Android).
+ * - `unavailable`: the feature cannot work; offer the fallback.
+ * - `authorized`: granted or limited; the feature can run.
+ */
+export type PermissionPromptView = 'pending' | 'explain' | 'unavailable' | 'authorized';
+export interface UsePermissionPromptOptions {
+    /**
+     * Called each time the status settles with no question left open: when the first
+     * check finds nothing to ask (granted, limited, blocked or unavailable), and after
+     * each request or Cancel.
+     */
+    onResult?: (status: PermissionStatus) => void;
+}
+export interface UsePermissionPromptResult {
+    view: PermissionPromptView;
+    /** The latest status, `null` until the first check returns. */
+    status: PermissionStatus | null;
+    /** True while the system prompt is up. */
+    requesting: boolean;
+    /** Android only: the explainer offers Cancel, as Android requires; iOS and web never do. */
+    cancellable: boolean;
+    /**
+     * True only when the status was already `blocked` when this prompt opened, so
+     * Open Settings never appears straight after the person refused.
+     */
+    showSettings: boolean;
+    /** Shows the system prompt. Resolves the new status, or `null` when one is already up. */
+    request: () => Promise<PermissionStatus | null>;
+    /** Leaves the explainer for the unavailable state without asking. */
+    cancel: () => void;
+    openSettings: () => Promise<boolean>;
+}
+/**
+ * Decides what a permission prompt shows, by platform:
+ * - iOS and web explain first whenever a request can still show the system prompt.
+ * - Android asks straight away the first time, and explains only after one refusal
+ *   (`denied`), the case Android's rationale flow covers.
+ * - `blocked` or `unavailable` goes to the unavailable state.
+ */
+export declare const usePermissionPrompt: (kind: PermissionKind, { onResult }?: UsePermissionPromptOptions) => UsePermissionPromptResult;
+//# sourceMappingURL=usePermissionPrompt.d.ts.map

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

@@ -159,7 +159,10 @@ export interface PhoneNumberInputProps extends Pick<TextInputProps, 'returnKeyTy
     labelStyle?: StyleProp<TextStyle>;
     placeholder?: string;
     helperText?: string;
-    /** The app's own error text. Always wins over the built-in invalid-number message. */
+    /**
+     * The app's own error text, a string or a node; it replaces the built-in invalid-number message.
+     * `true` shows the error state and keeps the built-in message; `false` and `''` change nothing.
+     */
     error?: ReactNode;
     /**
      * Text under the field once the typed number is not a real number for the
@@ -169,7 +172,7 @@ export interface PhoneNumberInputProps extends Pick<TextInputProps, 'returnKeyTy
      * a cleared field earns that grace again. Default `'Enter a valid mobile
      * number'` under `validation="mobile"`, else `'Enter a valid number'`;
      * a string replaces the text, `false` turns the message off. Nothing shows
-     * under `validation={false}`, and `error` always wins.
+     * under `validation={false}`, and an `error` text always wins.
      */
     invalidMessage?: string | false;
     required?: boolean;

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

@@ -8,6 +8,8 @@ export interface RadioGroupContextValue {
     selectedValue: RadioValue | undefined;
     onChange: (value: RadioValue) => void;
     disabled: boolean;
+    /** The group is in error: every radio draws its empty ring in the error colour. */
+    error?: boolean;
 }
 export declare const RadioGroupContext: import("react").Context<RadioGroupContextValue | null>;
 export declare const useRadioGroup: () => RadioGroupContextValue | null;
@@ -16,10 +18,17 @@ export interface RadioProps extends Omit<PressableProps, 'style' | 'children' |
     selected?: boolean;
     onChange?: (value: RadioValue) => void;
     disabled?: boolean;
-    label?: string;
-    /** Secondary line under the label. */
-    description?: string;
-    /** Error line under the label (and description); also draws the empty ring in the error colour. */
+    /**
+     * A string, or a node for a symbol with a subscript. A node label needs an
+     * explicit `accessibilityLabel` (the radio's screen-reader name).
+     */
+    label?: ReactNode;
+    /** Secondary line under the label. A string or a node; a node description adds nothing to the accessibility hint. */
+    description?: ReactNode;
+    /**
+     * Error line under the label (and description); also draws the empty ring in the error colour.
+     * A string or a node; `true` shows the error state without a message.
+     */
     error?: ReactNode;
     size?: RadioSize;
     tone?: RadioTone;

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

@@ -7,6 +7,11 @@ export interface RadioGroupProps {
     onChange?: (value: RadioValue) => void;
     children: React.ReactNode;
     disabled?: boolean;
+    /**
+     * One error line under the group, and every radio's empty ring in the error colour. A string or
+     * a node; `true` shows the error state without a message.
+     */
+    error?: React.ReactNode;
     accessibilityLabel?: string;
     style?: StyleProp<ViewStyle>;
     testID?: string;

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

@@ -46,7 +46,11 @@ export interface SegmentedControlProps {
     label?: ReactNode;
     /** Helper line under the control. */
     helperText?: ReactNode;
-    /** Error line under the control, in the error colour. Replaces `helperText`. */
+    /**
+     * Error line under the control, in the error colour, with the control outlined (the underline
+     * look recolours its divider). Replaces `helperText`; `true` shows the error state without a
+     * message.
+     */
     error?: ReactNode;
     value?: SegmentValue;
     defaultValue?: SegmentValue;

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

@@ -34,6 +34,8 @@ interface BaseSelectProps<T = SelectOption> {
     /** Defaults to `(o) => (o as SelectOption).icon`. */
     getOptionIcon?: (option: T) => React.ReactNode;
     placeholder?: string;
+    /** Called with `true` when the option sheet opens and `false` when it closes. */
+    onOpenChange?: (open: boolean) => void;
     searchable?: boolean;
     /**
      * Haptic feedback for interactions. Pass false to disable; pass a HapticType
@@ -76,7 +78,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