@webority/mobile-ui 0.0.0-stage → 0.0.34

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

@@ -0,0 +1,275 @@
+/**
+ * FieldBase — the unified field-box primitive.
+ *
+ * Every input-like control in the library (Input, Select, SearchBar,
+ * NumberInput, OTPInput cell, PickerTrigger) composes FieldBase so the
+ * height / radius / padding / border / fill / focus + disabled + error
+ * states stay identical across the library. Differences (pill SearchBar,
+ * OTP underline, NumberInput steppers) become explicit overrides via
+ * props or via theme tokens — never accidental drift.
+ *
+ * Responsibilities:
+ *   - Resolve size / variant dimensions from `theme.components.field`.
+ *   - Animate the border + background between idle / focused / error.
+ *   - Render leading + trailing slots either side of `children`.
+ *   - Become Pressable when `onPress` is set (Select, PickerTrigger).
+ *   - Apply disabled fill + cursor semantics.
+ *
+ * Non-responsibilities (the parent owns these):
+ *   - The actual TextInput / Text / nested editor.
+ *   - Floating / static labels rendered above the field.
+ *   - Helper / error / counter text rendered below the field.
+ *   - Shake-on-error or any cross-field animation.
+ */
+import React from 'react';
+import type { AccessibilityRole, AccessibilityState, StyleProp, TextStyle, ViewStyle } from 'react-native';
+import { Animated } from 'react-native';
+import type { FieldSide, FieldVariantTokens, ResolvedFieldSizeTokens, Theme } from '../../theme/types.js';
+export type FieldBaseSize = 'sm' | 'md' | 'lg';
+export type FieldBaseVariant = 'outlined' | 'filled' | 'underline';
+/**
+ * Pick the most "representative" side colour from a 4-side record. Used by
+ * consumers (Input's selectionColor, focus rings, etc.) that need a single
+ * colour to mirror the visible focus indicator. Priority: bottom → top →
+ * left → right, skipping `'transparent'`. The bottom-first order means
+ * underline variants pick their underline colour automatically.
+ */
+export declare const pickRepresentativeBorderColor: (sides: Record<FieldSide, string>) => string;
+export interface FieldBaseProps {
+    /** Resolves to dimension tokens at `theme.components.field[size]`. Default `'md'`. */
+    size?: FieldBaseSize;
+    /**
+     * Controls the resting fill + border treatment. Override the theme default
+     * (`theme.components.field.defaultVariant`) via this prop. Default `'outlined'`.
+     */
+    variant?: FieldBaseVariant;
+    /** Parent-controlled focus state — drives the border + fill animation. */
+    focused?: boolean;
+    /** Disabled state — wins over `focused` / `error`. */
+    disabled?: boolean;
+    /** Error state — visually wins over `focused`. */
+    error?: boolean;
+    /** Whether the field currently holds a value. Affects idle-empty vs idle-filled fill. */
+    filled?: boolean;
+    /** Slot to the left of `children`. Rendered inside the padded row. */
+    leading?: React.ReactNode;
+    /**
+     * Draw the spec's hairline rule between the leading slot and the content
+     * (icon | text). Only Input's leading icon wants it; SearchBar's magnifier,
+     * Select's prefix and the pickers leave it off. No-op without `leading`.
+     */
+    leadingDivider?: boolean;
+    /** Slot to the right of `children`. Rendered inside the padded row. */
+    trailing?: React.ReactNode;
+    /**
+     * Where the slots (and the divider) sit against the content. `'center'`
+     * (default) for a single-line field. `'top'` for a multi-line one, so the
+     * icon stays level with the first line however tall the box grows; pass
+     * `slotLineHeight` (the content's first-line height) so the icon is centred
+     * on that line rather than pinned to the padding edge.
+     */
+    slotAlign?: 'center' | 'top';
+    /** First-line height of the content, used only with `slotAlign="top"`. */
+    slotLineHeight?: number;
+    /**
+     * Cut a gap in the top border, in the box's outer coordinates: a floated
+     * outlined label sits in it so the rule never runs behind the text and the
+     * label needs no masking background. `width` may be animated so the gap
+     * opens as the label rises. Ignored when the top border has no width.
+     */
+    topNotch?: {
+        left: number;
+        width: number | Animated.AnimatedInterpolation<number>;
+    };
+    /** The editable / displayed content. TextInput, Text, OTP, anything. */
+    children?: React.ReactNode;
+    /**
+     * When provided, the entire field becomes Pressable. Use for Select /
+     * PickerTrigger / any non-text-input field. Disabled when `disabled` is true.
+     */
+    onPress?: () => void;
+    /**
+     * Whether a press reads as pressing a button: the pressed fill and the
+     * `button` role. Default `true`, the trigger fields (Select, PickerTrigger).
+     * `false` for a field that hosts a TextInput and uses `onPress` only to
+     * focus it: a tap on the padding or an icon then reaches the input the
+     * same as a tap on its text, with no flash and no extra accessible node.
+     * The accessibility props stay on the box, so the hosted input remains the
+     * element a screen reader lands on.
+     */
+    pressFeedback?: boolean;
+    /** Override `minHeight` (multiline Input). */
+    minHeight?: number;
+    /** Override `maxHeight` (rarely needed). */
+    maxHeight?: number;
+    /** Fixed pixel width — used by OTP cells. Suppresses default `flex: 1`. */
+    width?: number;
+    /** Fixed pixel height — used by OTP cells. Wins over `minHeight`. */
+    height?: number;
+    /** Override horizontal padding. */
+    paddingHorizontal?: number;
+    /** Override left padding. Wins over `paddingHorizontal`. */
+    paddingLeft?: number;
+    /** Override right padding. Wins over `paddingHorizontal`. */
+    paddingRight?: number;
+    /** Override vertical padding (single-line). Multiline parents usually leave this default. */
+    paddingVertical?: number;
+    /** Override corner radius (shorthand — all four corners). SearchBar pill uses this to apply `radius.full`. */
+    borderRadius?: number;
+    /** Top-left corner radius. Wins over `borderRadius`. */
+    borderTopLeftRadius?: number;
+    /** Top-right corner radius. Wins over `borderRadius`. */
+    borderTopRightRadius?: number;
+    /** Bottom-left corner radius. Wins over `borderRadius`. */
+    borderBottomLeftRadius?: number;
+    /** Bottom-right corner radius. Wins over `borderRadius`. */
+    borderBottomRightRadius?: number;
+    /** Override border width (shorthand — all four sides). OTP uses 1.5; everything else inherits `colors.border.width`. */
+    borderWidth?: number;
+    /** Top border width. Wins over `borderWidth`. */
+    borderTopWidth?: number;
+    /** Right border width. Wins over `borderWidth`. */
+    borderRightWidth?: number;
+    /** Bottom border width. Wins over `borderWidth`. */
+    borderBottomWidth?: number;
+    /** Left border width. Wins over `borderWidth`. */
+    borderLeftWidth?: number;
+    /** Gap between leading / children / trailing. Defaults to `theme.spacing.md` (the spec's 12px). */
+    gap?: number;
+    fillOverrides?: Partial<FieldVariantTokens>;
+    style?: StyleProp<ViewStyle>;
+    testID?: string;
+    accessibilityRole?: AccessibilityRole;
+    accessibilityLabel?: string;
+    accessibilityState?: AccessibilityState;
+    accessibilityHint?: string;
+}
+/**
+ * Resolved text styling for the editable / displayed content inside a field.
+ * Single source of truth so every field component (Input, NumberInput,
+ * Select, SearchBar, PickerTrigger) renders identical colour + weight +
+ * fontFamily for value text — and reads the placeholder colour from the
+ * same place. OTPInput intentionally overrides this with its own semibold
+ * display weight.
+ */
+export interface FieldTextStyleResolverOptions {
+    /** When true, returns the disabled foreground colour. */
+    disabled?: boolean;
+}
+export interface FieldTextStyle {
+    /** Foreground colour for the value text. */
+    color: string;
+    /** Placeholder foreground colour (TextInput's `placeholderTextColor` prop). */
+    placeholderColor: string;
+    /** `fontFamily` (when a brand font is registered) or `fontWeight` (otherwise). */
+    weightStyle: Pick<TextStyle, 'fontFamily' | 'fontWeight'>;
+}
+/**
+ * Resolve the canonical text style chunk for a field's value. Reads from
+ * `theme.components.field.{textColor,disabledTextColor,placeholderColor,fontWeight}`
+ * first, then the field palette (`theme.colors.field`); brand fonts wired via
+ * `typography.fontFamily` apply via the shared `fontFor` helper.
+ */
+export declare const resolveFieldTextStyle: (theme: Theme, options?: FieldTextStyleResolverOptions) => FieldTextStyle;
+/**
+ * The required-field marker appended to a field's label. Single source of
+ * truth for the whole field family (Input, Select, FormField, PickerTrigger →
+ * Date/Time/DateRange pickers). Themeable via
+ * `theme.components.field.{requiredMarker,requiredMarkerColor}`; font family /
+ * weight / size are inherited from the parent label `<Text>`.
+ */
+export declare const RequiredMark: React.FC;
+/**
+ * The placeholder of a required field that has no static label, drawn by the
+ * field itself with the required marker after it ("Enter your email *"). It
+ * is laid over the empty TextInput, whose own placeholder the field
+ * suppresses, in the same type as the input text, and the field removes it
+ * the moment it has a value: the star belongs to the hint, so it leaves with
+ * the hint rather than standing beside what the user typed. Inert to touch.
+ */
+export declare const RequiredPlaceholder: React.FC<{
+    text: string;
+    color: string;
+    fontSize: number;
+    weightStyle: TextStyle;
+    /** `'top'` for a multi-line field, whose text starts at the top of the box. */
+    align?: 'center' | 'top';
+    /** Vertical offset for the `'top'` case (the input's own optical nudge). */
+    paddingTop?: number;
+    textAlign?: TextStyle['textAlign'];
+}>;
+/**
+ * The circled-exclamation glyph that leads a field's error message. Uses the
+ * theme's `icons.error` renderer when one is registered; otherwise draws a
+ * ring-and-bang from views so the message never renders bare. Shared by
+ * every field component that shows an error line (Input, Select, FormField,
+ * the pickers) so the message row reads identically across the family.
+ */
+export declare const FieldErrorGlyph: React.FC<{
+    size: number;
+    color: string;
+}>;
+/**
+ * The static label above a field, per the design spec: `field.label` ink,
+ * the size ladder's `labelFontSize`, semibold, `labelGap` below. It stays on
+ * that ink through focus and error (the ring and the message row carry the
+ * error). Shared by Select, PickerTrigger, NumberInput; Input renders the
+ * same styling inline because it also owns the floating-label variant.
+ */
+export declare const FieldLabel: React.FC<{
+    children: React.ReactNode;
+    size?: FieldBaseSize;
+    required?: boolean;
+    style?: StyleProp<TextStyle>;
+}>;
+/**
+ * The helper / error line under a field: `messageFontSize`, `messageGap`
+ * from the box, `field.message` red with the circled-exclamation glyph when
+ * `error`, `text.secondary` otherwise. Renders nothing without text.
+ */
+export declare const FieldMessage: React.FC<{
+    text?: string;
+    error?: boolean;
+    size?: FieldBaseSize;
+    style?: StyleProp<TextStyle>;
+}>;
+/**
+ * Public re-export of the resolved size tokens — components that need to
+ * compute their own padding adjustments (e.g. multiline Input, icon-slot
+ * sizing) read from this rather than re-hardcoding the size table.
+ */
+export declare const resolveFieldSize: (theme: Theme, size: FieldBaseSize) => ResolvedFieldSizeTokens;
+/**
+ * Strict, fully-resolved colour set used internally. Mirrors `FieldVariantTokens`
+ * but every border colour / width is expanded to a 4-side record by the time
+ * the box renders, so the animation pipeline can treat per-side and shorthand
+ * the same way. `borderFocusedRepresentative` is a single colour pulled from
+ * the focused sides — exposed for consumers (Input's selectionColor) that
+ * need to mirror the visible focus indicator without re-resolving per side.
+ */
+interface ResolvedFieldColors {
+    backgroundIdleEmpty: string;
+    backgroundIdleFilled: string;
+    /** Optional override fill while focused — when undefined, focus animates from idle to idle (no fill change). */
+    backgroundFocused: string | undefined;
+    /** Optional override fill while in error — when undefined, error animates from idle to idle. */
+    backgroundError: string | undefined;
+    backgroundDisabled: string;
+    borderIdle: Record<FieldSide, string>;
+    borderFocused: Record<FieldSide, string>;
+    borderError: Record<FieldSide, string>;
+    borderDisabled: Record<FieldSide, string>;
+    borderWidth: Record<FieldSide, number>;
+    /** Single representative colour from `borderFocused` — first non-transparent side, bottom-priority. */
+    borderFocusedRepresentative: string;
+}
+/**
+ * Resolve the full set of state-aware fill + border colours for a given
+ * variant. Order: explicit override → theme token → library default. Border
+ * colour + width are normalized to per-side records here; callers that need
+ * a single colour read `borderFocusedRepresentative`.
+ */
+export declare const resolveVariantColors: (theme: Theme, variant: FieldBaseVariant, override?: Partial<FieldVariantTokens>) => ResolvedFieldColors;
+export declare const FieldBase: React.FC<FieldBaseProps>;
+export default FieldBase;
+//# sourceMappingURL=FieldBase.d.ts.map

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

@@ -0,0 +1,5 @@
+export type { FieldBaseProps, FieldBaseSize, FieldBaseVariant, FieldTextStyle, FieldTextStyleResolverOptions } from './FieldBase.js';
+export { default, FieldBase, FieldErrorGlyph, FieldLabel, FieldMessage, RequiredMark, RequiredPlaceholder, resolveFieldSize, resolveFieldTextStyle } from './FieldBase.js';
+export type { UseFloatingLabelOptions, UseFloatingLabelResult } from './useFloatingLabel.js';
+export { FLOATED_LABEL_SCALE, useFloatingLabel } from './useFloatingLabel.js';
+//# sourceMappingURL=index.d.ts.map

package/lib/typescript/module/components/FieldBase/useFloatingLabel.d.ts

@@ -0,0 +1,53 @@
+/**
+ * The field family's floating label, shared by Input and SearchBar.
+ *
+ * Resting, the label sits over the text (past any leading icon) at the
+ * field's font size; on focus or with a value it rises to the box's top edge
+ * at 85% scale and slides to the field's left edge, straight above the icon.
+ * On the outlined variant the top border is cut where the floated label
+ * lands (`topNotch`, handed to FieldBase), so the rule never runs behind the
+ * text and the label needs no masking background.
+ *
+ * The hook owns the animation, the label's measured layout (which sizes the
+ * notch) and the Animated.Text itself; the consumer places `node` inside the
+ * wrapper that also holds FieldBase (position relative, overflow visible)
+ * and passes `topNotch` through.
+ */
+import type { StyleProp, TextStyle } from 'react-native';
+import type { ResolvedFieldSizeTokens } from '../../theme/types.js';
+import type { FieldBaseProps, FieldBaseVariant } from './FieldBase.js';
+/** The floated label's scale; the outlined notch is sized from it. */
+export declare const FLOATED_LABEL_SCALE = 0.85;
+export interface UseFloatingLabelOptions {
+    label?: string;
+    /** Render at all (label present and the consumer's labelMode is 'float'). */
+    enabled: boolean;
+    /** Whether the label is up on the border right now (focused or holding a value). */
+    floated: boolean;
+    required?: boolean;
+    variant: FieldBaseVariant;
+    sizeTokens: ResolvedFieldSizeTokens;
+    /** Where the text starts past the leading slot (icon, gaps, divider), px. */
+    leadingOffset: number;
+    /** Width the trailing slot takes, for a right-aligned label, px. */
+    trailingOffset?: number;
+    textAlign?: 'left' | 'right' | 'center';
+    /** The field's left padding at rest; 0 for underline rows whose text is flush with the rule. */
+    paddingLeft: number;
+    /** Explicit line height of the field's text (textarea); the label box takes it too. */
+    lineHeight?: number;
+    /** Extra resting offset from the top padding (a textarea's optical nudge). */
+    restNudge?: number;
+    /** Float a little less (a textarea's exact line box needs 2px). */
+    floatTrim?: number;
+    color: string;
+    style?: StyleProp<TextStyle>;
+}
+export interface UseFloatingLabelResult {
+    /** The Animated.Text, or null when disabled. Place it beside FieldBase inside a relative wrapper. */
+    node: React.ReactNode;
+    /** Hand to FieldBase so the outlined top border opens under the floated label. */
+    topNotch: FieldBaseProps['topNotch'];
+}
+export declare const useFloatingLabel: ({ label, enabled, floated, required, variant, sizeTokens, leadingOffset, trailingOffset, textAlign, paddingLeft, lineHeight, restNudge, floatTrim, color, style }: UseFloatingLabelOptions) => UseFloatingLabelResult;
+//# sourceMappingURL=useFloatingLabel.d.ts.map

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

@@ -0,0 +1,156 @@
+/**
+ * FilePicker — attachment picking UI with pluggable native sources.
+ *
+ * The library owns the UI and behaviour: trigger (dashed card / list row /
+ * custom render prop), the source-chooser sheet (shared OptionSheet), enforced
+ * validation (maxFiles / maxSizeMB / accept / custom), the canonical file
+ * shape, per-file status + progress display, remove/retry affordances,
+ * a11y, haptics and theming.
+ *
+ * What it deliberately does NOT own:
+ *   - Native picking. Camera / gallery / document access lives in app-level
+ *     `sources` adapters (`pick(): Promise<PickedFileInput[]>`), so the
+ *     library stays zero-dependency and each app wires the native modules it
+ *     already ships. Throwing inside `pick` surfaces as a field error;
+ *     returning `[]` is a cancel.
+ *   - Networking. Uploads belong to the app's API client / outbox; the app
+ *     reflects them back via per-file `status` / `progress` and gets retry
+ *     taps through `onRetry`.
+ *   - Heavy processing. The async `process` hook runs per accepted file
+ *     (compression, EXIF strip, local copy) before it lands in `files` —
+ *     plug the app's image pipeline in there.
+ */
+import React from 'react';
+import type { StyleProp, ViewStyle } from 'react-native';
+import type { HapticType } from '../../utils/index.js';
+export type FilePickerVariant = 'card' | 'list';
+export type FilePickerFileStatus = 'idle' | 'processing' | 'uploading' | 'done' | 'error';
+export interface FilePickerFile {
+    /** Stable identity — generated by the library when the source doesn't provide one. */
+    id: string;
+    name: string;
+    /** Local content URI (freshly picked files). */
+    uri?: string;
+    /** Remote URL for already-uploaded files (edit screens). */
+    url?: string;
+    /** Remote thumbnail. Image files fall back to `uri` / `url`. */
+    thumbnailUrl?: string;
+    /** Mime type, e.g. `image/jpeg`. */
+    type?: string;
+    /** Bytes. */
+    size?: number;
+    /** Display-only upload state — the app sets these, the library renders them. */
+    status?: FilePickerFileStatus;
+    /** 0–1, rendered while `status === 'uploading'`. */
+    progress?: number;
+    /** Shown on the file while `status === 'error'`. */
+    error?: string;
+    /** Consumer payload — preserved untouched through every operation. */
+    meta?: Record<string, unknown>;
+}
+/** What a source's `pick()` resolves with — the library normalizes the rest. */
+export interface PickedFileInput {
+    uri: string;
+    name?: string;
+    type?: string;
+    size?: number;
+    meta?: Record<string, unknown>;
+}
+export interface FilePickerSource {
+    key: string;
+    label: string;
+    description?: string;
+    icon?: React.ReactNode;
+    /** Launch native picking. Resolve `[]` for user-cancel; throw for real failures. */
+    pick: () => Promise<PickedFileInput[]>;
+}
+/** Everything a custom `renderFile` template needs to paint one file. */
+export interface FilePickerFileState {
+    file: FilePickerFile;
+    index: number;
+    disabled: boolean;
+    remove: () => void;
+    retry?: () => void;
+}
+export interface FilePickerTriggerState {
+    /** Open a specific source, or the chooser sheet when omitted and >1 source. */
+    open: (sourceKey?: string) => void;
+    disabled: boolean;
+    fileCount: number;
+    atCapacity: boolean;
+}
+export interface FilePickerLabels {
+    /** Trigger text when no files are attached. Default 'Attach file'. */
+    trigger: string;
+    /** Add-affordance text/tile label once files exist. Default '+'. (card tile) / 'Add more' (list row). */
+    addMore: string;
+    /** Source chooser sheet title. Default 'Add from'. */
+    sheetTitle: string;
+    /** A11y label template for a file's remove button. */
+    removeFile: (name: string) => string;
+    /** Retry affordance a11y label. Default 'Retry upload'. */
+    retry: string;
+    errorTooMany: (maxFiles: number) => string;
+    errorTooLarge: (name: string, maxSizeMB: number) => string;
+    errorWrongType: (name: string) => string;
+}
+export interface FilePickerRef {
+    /** Open a source by key, or the chooser (sheet when >1 source). */
+    open: (sourceKey?: string) => void;
+    /** Remove all files. */
+    clear: () => void;
+}
+export interface FilePickerProps {
+    /** Controlled file list. */
+    files?: FilePickerFile[];
+    /** Uncontrolled initial list (edit screens can seed remote files here too). */
+    defaultFiles?: FilePickerFile[];
+    onChange?: (files: FilePickerFile[]) => void;
+    /** Native picking adapters. One source launches directly; several open the chooser sheet. */
+    sources: ReadonlyArray<FilePickerSource>;
+    maxFiles?: number;
+    /** Per-file size cap — oversized picks are rejected with a visible error. */
+    maxSizeMB?: number;
+    /** Accepted mime globs, e.g. `['image/*', 'application/pdf']`. Unset = accept all. */
+    accept?: ReadonlyArray<string>;
+    /** Custom per-file rule — return an error string to reject. */
+    validate?: (file: FilePickerFile) => string | null | undefined;
+    /**
+     * Async per-file transform between pick and `files` (compression, local
+     * copy). The file shows `processing` while it runs; a throw rejects the
+     * file with the thrown message as the field error.
+     */
+    process?: (file: FilePickerFile) => Promise<FilePickerFile>;
+    /** `card`: dashed upload card → horizontal thumbnail strip. `list`: rows with name/size/status. */
+    variant?: FilePickerVariant;
+    /** Full custom per-file template. Library keeps remove/retry handlers + a11y wiring via the state object. */
+    renderFile?: (state: FilePickerFileState) => React.ReactNode;
+    /** Replace the built-in trigger entirely; behaviour arrives via the state object. */
+    renderTrigger?: (state: FilePickerTriggerState) => React.ReactNode;
+    disabled?: boolean;
+    /** Hint under the trigger (e.g. "Up to 5 files, max 100MB each."). */
+    helperText?: string;
+    /** External error — wins over internal validation errors (form binding). */
+    error?: string;
+    labels?: Partial<FilePickerLabels>;
+    /** Haptics for pick/remove (selection) and rejections (error). Pass false to disable. */
+    haptic?: HapticType | false;
+    /** Files accepted by a pick (post-validation, post-process). */
+    onPick?: (files: FilePickerFile[]) => void;
+    onRemove?: (file: FilePickerFile) => void;
+    /** Each rejection message (also shown as the field error). */
+    onError?: (message: string, file?: FilePickerFile) => void;
+    /** Tap on a file tile/row — wire previews (ImageGallery) here. */
+    onFilePress?: (file: FilePickerFile) => void;
+    /** When set, files with `status 'error'` show a retry affordance that calls this. */
+    onRetry?: (file: FilePickerFile) => void;
+    style?: StyleProp<ViewStyle>;
+    accessibilityLabel?: string;
+    testID?: string;
+}
+export declare const formatFileSize: (bytes?: number) => string;
+export declare const matchesAccept: (type: string | undefined, accept?: ReadonlyArray<string>) => boolean;
+declare const FilePicker: React.ForwardRefExoticComponent<FilePickerProps & React.RefAttributes<FilePickerRef>>;
+export { FilePicker };
+export default FilePicker;
+//# sourceMappingURL=FilePicker.d.ts.map

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

@@ -0,0 +1,3 @@
+export type { FilePickerFile, FilePickerFileState, FilePickerFileStatus, FilePickerLabels, FilePickerProps, FilePickerRef, FilePickerSource, FilePickerTriggerState, FilePickerVariant, PickedFileInput } from './FilePicker.js';
+export { default, FilePicker, formatFileSize } from './FilePicker.js';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1,42 @@
+import { type DownloadHttpClient } from '@webority/mobile-core/download';
+import type React from 'react';
+import type { StyleProp, ViewStyle } from 'react-native';
+export interface FileViewerSource {
+    uri: string;
+    headers?: Record<string, string>;
+    /**
+     * Fetches a remote `uri`. Pass the app's signed-in client (mobile-core's
+     * `userClient`, or its own) for a document behind sign-in; defaults to
+     * mobile-core's `publicClient`.
+     */
+    client?: DownloadHttpClient;
+    /** Reuse a previously downloaded copy of this URL instead of re-fetching. Default true. */
+    cache?: boolean;
+}
+export interface FileViewerProps {
+    source: FileViewerSource;
+    onLoadComplete?: (numberOfPages: number) => void;
+    onPageChanged?: (page: number, numberOfPages: number) => void;
+    onError?: (error: Error) => void;
+    /** Replaces the default themed spinner shown while the document loads. */
+    loadingIndicator?: () => React.ReactNode;
+    style?: StyleProp<ViewStyle>;
+    testID?: string;
+    accessibilityLabel?: string;
+}
+/**
+ * Renders a PDF via our own native rasterizer (PDFKit on iOS, PdfRenderer on
+ * Android) — no third-party PDF dependency. Pages are paged through a plain
+ * `ScrollView` with manual windowed mounting (render the visible page ±
+ * `RENDER_WINDOW`), not a `FlatList` — a `VirtualizedList`-based component
+ * would trip React Native's "VirtualizedLists should never be nested inside
+ * plain ScrollViews" the moment a consumer embeds FileViewer in their own
+ * scrolling screen, which is a completely ordinary way to use it. Avoiding the
+ * VirtualizedList primitive entirely removes that whole class of warning
+ * rather than working around one instance of it. The WebView fallback
+ * consumer apps use for non-PDF office documents is a distinct rendering
+ * strategy and stays app-side.
+ */
+export declare const FileViewer: React.FC<FileViewerProps>;
+export default FileViewer;
+//# sourceMappingURL=FileViewer.d.ts.map

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

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

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

@@ -0,0 +1,66 @@
+import React from 'react';
+import type { View as RNView, StyleProp, ViewStyle } from 'react-native';
+import type { HapticType } from '../../utils/hapticUtils.js';
+export type FloatingActionButtonSize = 'sm' | 'md' | 'lg';
+export type FloatingActionButtonTone = 'primary' | 'success' | 'warning' | 'error' | 'neutral';
+export type FloatingActionButtonPosition = 'bottomRight' | 'bottomLeft' | 'bottomCenter';
+export interface FloatingActionButtonProps {
+    /** JSX element for the icon. The FAB sizes it via the `size` prop's iconSize token. */
+    icon: React.ReactNode;
+    onPress: () => void;
+    label?: string;
+    size?: FloatingActionButtonSize;
+    tone?: FloatingActionButtonTone;
+    position?: FloatingActionButtonPosition;
+    bottomOffset?: number;
+    disabled?: boolean;
+    hideOnScroll?: boolean;
+    isScrolling?: boolean;
+    accessibilityLabel: string;
+    accessibilityHint?: string;
+    /** Haptic feedback for interactions. Pass false to disable; pass a HapticType to override the default. */
+    haptic?: HapticType | false;
+    style?: StyleProp<ViewStyle>;
+    containerStyle?: StyleProp<ViewStyle>;
+    labelStyle?: StyleProp<ViewStyle>;
+    testID?: string;
+}
+declare const FloatingActionButton: React.ForwardRefExoticComponent<FloatingActionButtonProps & React.RefAttributes<RNView>>;
+export interface FloatingActionButtonGroupAction {
+    key: string;
+    icon: React.ReactNode;
+    label?: string;
+    onPress: () => void;
+    tone?: FloatingActionButtonTone;
+    accessibilityLabel: string;
+}
+export interface FloatingActionButtonGroupProps {
+    primaryIcon: React.ReactNode;
+    primaryActiveIcon?: React.ReactNode;
+    actions: FloatingActionButtonGroupAction[];
+    open?: boolean;
+    defaultOpen?: boolean;
+    onOpenChange?: (open: boolean) => void;
+    position?: FloatingActionButtonPosition;
+    bottomOffset?: number;
+    size?: FloatingActionButtonSize;
+    accessibilityLabel?: string;
+    /** Haptic feedback for interactions. Pass false to disable; pass a HapticType to override the default. */
+    haptic?: HapticType | false;
+    /**
+     * Slide the whole group off the bottom edge while `isScrolling` is true,
+     * the same way the single button does. An open group closes first.
+     */
+    hideOnScroll?: boolean;
+    /** Whether the list behind the group is scrolling right now; wire to your scroll handler. */
+    isScrolling?: boolean;
+    containerStyle?: StyleProp<ViewStyle>;
+    secondaryActionStyle?: StyleProp<ViewStyle>;
+    labelPillStyle?: StyleProp<ViewStyle>;
+    labelStyle?: StyleProp<ViewStyle>;
+    testID?: string;
+}
+declare const FloatingActionButtonGroup: React.FC<FloatingActionButtonGroupProps>;
+export { FloatingActionButton, FloatingActionButtonGroup };
+export default FloatingActionButton;
+//# sourceMappingURL=FloatingActionButton.d.ts.map

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

@@ -0,0 +1,3 @@
+export type { FloatingActionButtonGroupAction, FloatingActionButtonGroupProps, FloatingActionButtonPosition, FloatingActionButtonProps, FloatingActionButtonSize, FloatingActionButtonTone } from './FloatingActionButton.js';
+export { default, FloatingActionButton, FloatingActionButtonGroup } from './FloatingActionButton.js';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1,47 @@
+import React from 'react';
+import type { StyleProp, TextStyle, ViewStyle } from 'react-native';
+export interface ForceUpdateDialogProps {
+    /** Whether the dialog is visible. */
+    visible: boolean;
+    /** Called when the dialog is dismissed (only fired when `mandatory` is `false`). */
+    onClose?: () => void;
+    /**
+     * If `true`, hides the "Later" action and disables backdrop dismissal —
+     * use this for major version bumps that must not be skipped.
+     */
+    mandatory?: boolean;
+    /** Optional override of the destination URL (defaults to the platform store). */
+    updateUrl?: string | null;
+    /** Custom dialog title. */
+    title?: string;
+    /** Custom dialog message. */
+    message?: string;
+    /** Custom label for the primary "Update" action. */
+    updateLabel?: string;
+    /** Custom label for the dismiss action. Hidden when `mandatory`. */
+    laterLabel?: string;
+    /** Forwarded to the underlying Dialog container. */
+    containerStyle?: StyleProp<ViewStyle>;
+    /** Forwarded to the underlying Dialog title Text. */
+    titleStyle?: StyleProp<TextStyle>;
+    /** Forwarded to the underlying Dialog message Text. */
+    messageStyle?: StyleProp<TextStyle>;
+    testID?: string;
+}
+/**
+ * Drop-in update prompt that opens the App Store / Play Store on tap.
+ * Pair this with `useVersionCheck()` — render it when `isUpdateRequired` is true.
+ *
+ * @example
+ * const { isUpdateRequired, updateUrl } = useVersionCheck(isAppReady);
+ * return (
+ *   <ForceUpdateDialog
+ *     visible={isUpdateRequired}
+ *     mandatory
+ *     updateUrl={updateUrl}
+ *   />
+ * );
+ */
+export declare const ForceUpdateDialog: React.FC<ForceUpdateDialogProps>;
+export default ForceUpdateDialog;
+//# sourceMappingURL=ForceUpdateDialog.d.ts.map

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

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