@webority/mobile-ui 0.0.0-stage → 0.0.34

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

@@ -0,0 +1,48 @@
+import React from 'react';
+import type { View as RNView, StyleProp, TextStyle, ViewStyle } from 'react-native';
+/**
+ * The same semantic vocabulary Chip and Badge use, and the web library's
+ * `AppStatusBadge` (its `danger` is `error` here, the mobile theme's name).
+ * A semantic name survives a palette change; a colour name does not.
+ */
+export type StatusBadgeTone = 'success' | 'warning' | 'error' | 'info' | 'primary' | 'neutral';
+/**
+ * `soft` is the default: the tone at a light tint behind text in the tone,
+ * with a border in the tone so the pill has an edge on any surface. `outline`
+ * drops the fill. `solid` fills with the tone and draws the text on it.
+ */
+export type StatusBadgeVariant = 'soft' | 'outline' | 'solid';
+export type StatusBadgeSize = 'sm' | 'md';
+export interface StatusBadgeProps {
+    /** The status as the reader should see it ("Active", "Pending review"). */
+    label: string;
+    tone?: StatusBadgeTone;
+    variant?: StatusBadgeVariant;
+    size?: StatusBadgeSize;
+    /** A small disc before the label in the status colour. */
+    dot?: boolean;
+    /**
+     * A status colour of the app's own, `#RRGGBB`, for a status the backend
+     * names with a colour rather than a tone (a pipeline stage, a category).
+     * Fill, border, text and dot all derive from it, so nothing else needs
+     * naming. Wins over `tone`. A non-hex value falls back to the tone.
+     */
+    color?: string;
+    /**
+     * When true, renders the component as its authored skeleton placeholder shape.
+     * The placeholder mirrors the real layout's footprint so the UI doesn't reflow
+     * when data arrives. Use this while the data driving the component is being fetched.
+     */
+    loading?: boolean;
+    /** Defaults to the label. */
+    accessibilityLabel?: string;
+    style?: StyleProp<ViewStyle>;
+    textStyle?: StyleProp<TextStyle>;
+    testID?: string;
+}
+declare const StatusBadge: React.ForwardRefExoticComponent<StatusBadgeProps & React.RefAttributes<RNView>> & {
+    Skeleton: React.FC<StatusBadgeProps>;
+};
+export { StatusBadge };
+export default StatusBadge;
+//# sourceMappingURL=StatusBadge.d.ts.map

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

@@ -0,0 +1,3 @@
+export type { StatusBadgeProps, StatusBadgeSize, StatusBadgeTone, StatusBadgeVariant } from './StatusBadge';
+export { default, StatusBadge } from './StatusBadge';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1,77 @@
+import React from 'react';
+import type { View as RNView, StyleProp, TextStyle, ViewStyle } from 'react-native';
+import type { HapticType } from '../../utils/hapticUtils';
+/**
+ * `horizontal`: numbered circles in a row, joined by a line. `vertical`: the
+ * same circles in a column, with a description beside each. `segmented`: a
+ * "Step 1 of 3 · Label" caption over one bar per step, filled up to and
+ * including the active step.
+ */
+export type StepperVariant = 'horizontal' | 'vertical' | 'segmented';
+export type StepperTone = 'primary' | 'success';
+/**
+ * What a tap on a step does. Steps always run in order: every step before
+ * the active one is done, so a tap never leaves a gap. `none`: nothing, the
+ * stepper only shows progress. `back`: a done step becomes the active one.
+ * `select`: any step becomes the active one, and tapping the active step
+ * again leaves none active.
+ */
+export type StepperPressMode = 'none' | 'back' | 'select';
+export interface StepperStep {
+    key: string;
+    label: string;
+    description?: string;
+    icon?: React.ReactNode;
+}
+export interface StepperProps {
+    steps: StepperStep[];
+    /**
+     * Zero-based index of the current step. Every step before it is done and
+     * every step after it upcoming. `null` or a negative number for no active
+     * step (nothing done), `steps.length` for all done. Passing it makes the
+     * active step controlled; leave it out and the stepper keeps its own,
+     * starting at `defaultActiveStep`.
+     */
+    activeStep?: number | null;
+    /** Starting active step when `activeStep` is left out. Default 0. */
+    defaultActiveStep?: number | null;
+    /** What a tap on a step does. Default `none`. */
+    pressMode?: StepperPressMode;
+    /** Every accepted tap, with the step's index, before the state changes. */
+    onStepPress?: (index: number) => void;
+    /** The new active step after a tap; `null` for none. */
+    onActiveStepChange?: (index: number | null) => void;
+    variant?: StepperVariant;
+    tone?: StepperTone;
+    /**
+     * `segmented` only: the caption above the bars. Receives the zero-based
+     * index of the active step (`null` when none is active), the step count
+     * and that step. Default `Step 2 of 3 · Billing`, or `1 of 3 done` with no
+     * active step.
+     */
+    formatCaption?: (index: number | null, total: number, step: StepperStep | undefined) => string;
+    /**
+     * When true, renders the component as its authored skeleton placeholder shape.
+     * The placeholder mirrors the real layout's footprint so the UI doesn't reflow
+     * when data arrives. Use this while the data driving the component is being fetched.
+     */
+    loading?: boolean;
+    accessibilityLabel?: string;
+    style?: StyleProp<ViewStyle>;
+    containerStyle?: StyleProp<ViewStyle>;
+    circleStyle?: StyleProp<ViewStyle>;
+    labelStyle?: StyleProp<TextStyle>;
+    connectorStyle?: StyleProp<ViewStyle>;
+    /**
+     * Haptic feedback for interactions. Pass false to disable; pass a HapticType
+     * to override the default.
+     */
+    haptic?: HapticType | false;
+    testID?: string;
+}
+declare const Stepper: React.ForwardRefExoticComponent<StepperProps & React.RefAttributes<RNView>> & {
+    Skeleton: React.FC<StepperProps>;
+};
+export { Stepper };
+export default Stepper;
+//# sourceMappingURL=Stepper.d.ts.map

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

@@ -0,0 +1,3 @@
+export type { StepperPressMode, StepperProps, StepperStep, StepperTone, StepperVariant } from './Stepper';
+export { default, Stepper } from './Stepper';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1,50 @@
+/**
+ * Swipeable — Reanimated 3 + Gesture Handler 2 implementation.
+ *
+ * Wraps any content and reveals contextual actions when the user
+ * swipes left or right. Past `fullSwipeThreshold`, the first action
+ * fires automatically and the content slides off-screen.
+ *
+ * USAGE:
+ *
+ * <Swipeable
+ *   leftActions={[{ key: 'archive', label: 'Archive', tone: 'success', onPress: handleArchive }]}
+ *   rightActions={[{ key: 'delete', label: 'Delete', tone: 'error', onPress: handleDelete }]}
+ * >
+ *   <ListItem title="Inbox item" />
+ * </Swipeable>
+ */
+import React from 'react';
+import type { StyleProp, ViewStyle } from 'react-native';
+import type { HapticType } from '../../utils';
+export type SwipeableTone = 'primary' | 'success' | 'warning' | 'error' | 'neutral';
+export interface SwipeableAction {
+    key: string;
+    label: string;
+    icon?: React.ReactNode;
+    onPress: () => void;
+    tone?: SwipeableTone;
+}
+export interface SwipeableProps {
+    children: React.ReactNode;
+    leftActions?: SwipeableAction[];
+    rightActions?: SwipeableAction[];
+    /** px to fully reveal the row of actions; default 80 */
+    threshold?: number;
+    /** px past which the first action fires automatically + content slides off-screen; default 200 */
+    fullSwipeThreshold?: number;
+    onSwipeOpen?: (side: 'left' | 'right') => void;
+    onSwipeClose?: () => void;
+    disabled?: boolean;
+    /** Haptic feedback for interactions. Pass false to disable; pass a HapticType to override the default. */
+    haptic?: HapticType | false;
+    containerStyle?: StyleProp<ViewStyle>;
+    contentStyle?: StyleProp<ViewStyle>;
+    actionStyle?: StyleProp<ViewStyle>;
+    accessibilityLabel?: string;
+    testID?: string;
+}
+declare const Swipeable: React.FC<SwipeableProps>;
+export { Swipeable };
+export default Swipeable;
+//# sourceMappingURL=Swipeable.d.ts.map

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

@@ -0,0 +1,3 @@
+export type { SwipeableAction, SwipeableProps, SwipeableTone } from './Swipeable';
+export { default, Swipeable } from './Swipeable';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1,29 @@
+import type { PressableProps, View as RNView, StyleProp, ViewStyle } from 'react-native';
+import type { HapticType } from '../../utils/hapticUtils';
+export type SwitchSize = 'sm' | 'md' | 'lg';
+export type SwitchTone = 'primary' | 'success' | 'warning' | 'error';
+export interface SwitchProps extends Omit<PressableProps, 'style' | 'children' | 'onPress'> {
+    value?: boolean;
+    defaultValue?: boolean;
+    onChange?: (value: boolean) => void;
+    disabled?: boolean;
+    size?: SwitchSize;
+    tone?: SwitchTone;
+    label?: string;
+    accessibilityLabel?: string;
+    haptic?: HapticType | false;
+    /**
+     * When true, the thumb briefly scales up on value change (1 → 1.15 → 1).
+     * Use for playful/brand-flavored switches; default off for system feel.
+     */
+    bounce?: boolean;
+    style?: StyleProp<ViewStyle>;
+    containerStyle?: StyleProp<ViewStyle>;
+    trackStyle?: StyleProp<ViewStyle>;
+    thumbStyle?: StyleProp<ViewStyle>;
+    testID?: string;
+}
+declare const Switch: import("react").ForwardRefExoticComponent<SwitchProps & import("react").RefAttributes<RNView>>;
+export { Switch };
+export default Switch;
+//# sourceMappingURL=Switch.d.ts.map

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

@@ -0,0 +1,3 @@
+export type { SwitchProps, SwitchSize, SwitchTone } from './Switch';
+export { default, Switch } from './Switch';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1,99 @@
+/**
+ * Tabs — top tabs with an animated underline, pill or segmented indicator.
+ *
+ * Layout: equal-width row by default, or horizontal-scrollable when
+ * `scrollable` is true. The active indicator (underline, pill or segmented
+ * thumb) is an Animated.View positioned absolutely; its translateX + width
+ * spring to the measured layout of the active tab. Driven by native driver
+ * where possible (transform); width animates separately on the JS thread
+ * because RN's native driver does not support layout props.
+ *
+ * `segmented` borrows SegmentedControl's look (filled track, sliding thumb)
+ * for tabs that sit inside content, reading that control's size table and
+ * theme overrides so the two stay in step; the inset is the tabs' own token
+ * (tabs.trackPadding, 4). It is a look, not a semantic change: the roles
+ * stay tablist/tab, and a value choice is still SegmentedControl.
+ */
+import type { View as RNView, StyleProp, TextStyle, ViewStyle } from 'react-native';
+import { Animated } from 'react-native';
+import type { RadiusScale } from '../../theme/types';
+import type { HapticType } from '../../utils';
+import type { SlotIcon, SlotIconState } from '../AppIcon/slotIcon';
+export type TabsVariant = 'underline' | 'pills' | 'segmented';
+export type TabsSize = 'sm' | 'md' | 'lg';
+/** A theme radius token or a pixel number. */
+export type TabsRadius = keyof RadiusScale | number;
+export type TabsAlign = 'left' | 'center';
+/** What a tab knows about itself when it draws its icon. */
+export interface TabItemIconState extends SlotIconState {
+    focused: boolean;
+}
+/**
+ * A tab icon speaks the library's slot language: an AppIcon name
+ * (`icon: 'home'`), `{ name, variant }`, a render function that gets
+ * `{ color, size, focused, disabled }`, or any node drawn as is. A name is
+ * drawn in the label's colour at the tabs' icon size.
+ */
+export type TabItemIcon = SlotIcon<TabItemIconState>;
+export interface TabItem {
+    key: string;
+    label: string;
+    icon?: TabItemIcon;
+    /** Optional numeric/string badge — rendered inline after the label when provided. */
+    badge?: string | number;
+    disabled?: boolean;
+}
+export interface TabsProps {
+    tabs: TabItem[];
+    activeKey: string;
+    onChange: (key: string) => void;
+    variant?: TabsVariant;
+    /**
+     * Corner radius, a theme token or a pixel number. Rounds the segmented
+     * track (the thumb nests inside it, its corner the track's minus the inset),
+     * the pill, and the ends of the underline. Unset, each variant keeps its own
+     * default: `md` track with an `sm` thumb, a `full` pill, a square underline.
+     * The theme's `tabs.radius` token is the app-wide default under this prop.
+     */
+    radius?: TabsRadius;
+    /**
+     * Scales the type, the tab padding and the icon together. `md` is the
+     * default look. On the segmented variant the size is SegmentedControl's
+     * size of the same name.
+     */
+    size?: TabsSize;
+    scrollable?: boolean;
+    align?: TabsAlign;
+    style?: StyleProp<ViewStyle>;
+    /** Alias of `style`. Applied to the outer container View. Additive — both merge. */
+    containerStyle?: StyleProp<ViewStyle>;
+    tabStyle?: StyleProp<ViewStyle>;
+    /** Style override applied to each tab label Text. */
+    tabLabelStyle?: StyleProp<TextStyle>;
+    /** Style override applied to the per-tab icon wrapper. */
+    tabIconStyle?: StyleProp<ViewStyle>;
+    /** Style override applied to the per-tab badge wrapper. */
+    tabBadgeStyle?: StyleProp<ViewStyle>;
+    /** Style override applied to the bottom divider line (underline variant only). */
+    dividerStyle?: StyleProp<ViewStyle>;
+    /** Style override applied to the animated indicator (underline or pill). */
+    indicatorStyle?: StyleProp<ViewStyle>;
+    /**
+     * Optional fractional active-index (0..tabs.length-1). When supplied and
+     * every tab has been measured, the indicator's translateX + width track
+     * this value via interpolation instead of springing on activeKey change.
+     * Wire it to a horizontal pager's `scrollX / pageWidth` to make the
+     * indicator follow drags in real time. Press-driven `onChange` still fires
+     * the same way; consumers typically scroll the pager in response so the
+     * progress value catches up.
+     */
+    progress?: Animated.AnimatedInterpolation<number> | Animated.Value;
+    /** Haptic feedback for interactions. Pass false to disable; pass a HapticType to override the default. */
+    haptic?: HapticType | false;
+    accessibilityLabel?: string;
+    testID?: string;
+}
+declare const Tabs: import("react").ForwardRefExoticComponent<TabsProps & import("react").RefAttributes<RNView>>;
+export { Tabs };
+export default Tabs;
+//# sourceMappingURL=Tabs.d.ts.map

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

@@ -0,0 +1,3 @@
+export type { TabItem, TabItemIcon, TabItemIconState, TabsAlign, TabsProps, TabsRadius, TabsSize, TabsVariant } from './Tabs';
+export { default, Tabs } from './Tabs';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1,36 @@
+import type { TextInput as RNTextInput, StyleProp, ViewStyle } from 'react-native';
+import type { HapticType } from '../../utils';
+import type { FieldBaseSize, FieldBaseVariant } from '../FieldBase';
+export interface TagInputProps {
+    /** Controlled tags. */
+    value?: string[];
+    defaultValue?: string[];
+    onChange?: (tags: string[]) => void;
+    placeholder?: string;
+    label?: string;
+    helperText?: string;
+    error?: string;
+    required?: boolean;
+    disabled?: boolean;
+    size?: FieldBaseSize;
+    variant?: FieldBaseVariant;
+    /** Reject a tag past this count. Omit for unlimited. */
+    maxTags?: number;
+    /** Reject a tag that already exists (case-insensitive). Default true. */
+    unique?: boolean;
+    /** Validate or transform a candidate. Return null to reject it. */
+    transform?: (raw: string) => string | null;
+    /** Characters that commit the current draft in addition to submit. Default [',']. */
+    separators?: string[];
+    haptic?: HapticType | false;
+    style?: StyleProp<ViewStyle>;
+    testID?: string;
+}
+/**
+ * Chips as input — the "type a value, press enter, it becomes a tag" field.
+ * Chip renders a tag and Input takes text, but nothing joined them, so consumers
+ * built this by hand each time (and each one disagreed about backspace).
+ */
+export declare const TagInput: import("react").ForwardRefExoticComponent<TagInputProps & import("react").RefAttributes<RNTextInput>>;
+export default TagInput;
+//# sourceMappingURL=TagInput.d.ts.map

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

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

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

@@ -0,0 +1,24 @@
+import React from 'react';
+import type { TextProps as RNTextProps, Text as RNTextRef, StyleProp, TextStyle } from 'react-native';
+import type { FontWeightKey } from '../../theme';
+import type { TypographyScale } from '../../theme/types';
+export type TextVariant = 'display' | 'h1' | 'h2' | 'h3' | 'title' | 'body' | 'bodySmall' | 'caption' | 'label' | 'overline';
+export type TextColor = 'primary' | 'secondary' | 'tertiary' | 'inverse' | 'disabled' | 'link' | 'success' | 'warning' | 'error' | 'info';
+export interface TextProps extends Omit<RNTextProps, 'style'> {
+    variant?: TextVariant;
+    /** Text role token, semantic tone, or a raw colour string. Defaults per variant. */
+    color?: TextColor | (string & {});
+    /** Override the variant's weight. */
+    weight?: FontWeightKey;
+    /** Override the variant's size — a typography token or a pixel number. */
+    size?: keyof TypographyScale['fontSize'] | number;
+    align?: TextStyle['textAlign'];
+    italic?: boolean;
+    underline?: boolean;
+    children?: React.ReactNode;
+    style?: StyleProp<TextStyle>;
+}
+declare const Text: React.ForwardRefExoticComponent<TextProps & React.RefAttributes<RNTextRef>>;
+export { Text };
+export default Text;
+//# sourceMappingURL=Text.d.ts.map

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

@@ -0,0 +1,3 @@
+export type { TextColor, TextProps, TextVariant } from './Text';
+export { Text } from './Text';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1,62 @@
+import React from 'react';
+import type { StyleProp, ViewStyle } from 'react-native';
+import type { HapticType } from '../../utils/hapticUtils';
+import type { FieldBaseSize, FieldBaseVariant } from '../FieldBase';
+export type TimeFormat = '12h' | '24h';
+export type Period = 'AM' | 'PM';
+export type MinuteStep = 1 | 5 | 15 | 30;
+export interface TimeValue {
+    hour: number;
+    minute: number;
+}
+/**
+ * TimePicker supports two modes:
+ *
+ * 1. Controlled-modal mode — pass `visible`, `onChange`, `onClose`. The
+ *    component renders only the modal sheet and the caller owns open/close
+ *    state plus its own trigger UI.
+ * 2. Trigger mode — omit `visible`. The component renders a PickerTrigger
+ *    field (label / value / placeholder / chevron / clear / helper / error)
+ *    and manages its own modal open state. `onChange` is still called on
+ *    confirm.
+ */
+export interface TimePickerProps {
+    /** Controlled-modal visibility. When omitted, the component enters trigger mode. */
+    visible?: boolean;
+    value?: TimeValue | null;
+    onChange?: (time: TimeValue) => void;
+    onClose?: () => void;
+    format?: TimeFormat;
+    minuteStep?: MinuteStep;
+    title?: string;
+    confirmLabel?: string;
+    cancelLabel?: string;
+    testID?: string;
+    style?: StyleProp<ViewStyle>;
+    /** Outer container style applied to the bottom sheet. */
+    containerStyle?: StyleProp<ViewStyle>;
+    /** Style override for the title text container. */
+    headerLabelStyle?: StyleProp<ViewStyle>;
+    /** Style override for the cancel/confirm footer buttons. */
+    footerButtonStyle?: StyleProp<ViewStyle>;
+    label?: string;
+    placeholder?: string;
+    helperText?: string;
+    error?: string;
+    required?: boolean;
+    disabled?: boolean;
+    size?: FieldBaseSize;
+    variant?: FieldBaseVariant;
+    clearable?: boolean;
+    onClear?: () => void;
+    /** Override the trigger field's value formatting. Defaults to `format`-aware h:mm/HH:mm. */
+    formatValue?: (time: TimeValue) => string;
+    /** Style passed through to the PickerTrigger field row. */
+    triggerStyle?: StyleProp<ViewStyle>;
+    /** Haptic feedback for interactions. Pass false to disable; pass a HapticType to override the default. */
+    haptic?: HapticType | false;
+}
+declare const TimePicker: React.FC<TimePickerProps>;
+export { TimePicker };
+export default TimePicker;
+//# sourceMappingURL=TimePicker.d.ts.map

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

@@ -0,0 +1,3 @@
+export type { MinuteStep, Period, TimeFormat, TimePickerProps, TimeValue } from './TimePicker';
+export { default, TimePicker } from './TimePicker';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1,62 @@
+import React from 'react';
+import type { StyleProp, ViewStyle } from 'react-native';
+/**
+ * The status vocabulary is shared with the web library's AppTimeline so a
+ * sign-off history reads identically on both surfaces.
+ *
+ *   upcoming  — not started yet        (muted disc)
+ *   current   — in progress now        (warning)
+ *   done      — completed              (success)
+ *   onHold    — blocked / waiting      (info)
+ *   rejected  — declined / failed      (error)
+ *   cancelled — aborted                (muted)
+ *   skipped   — intentionally bypassed (muted)
+ *
+ * Every dot sits inside a soft halo of its own colour (the accent at 16
+ * percent), the web timeline's glow. The halo is a layout wrapper, not a
+ * platform shadow: a shadow cannot be coloured on Android and sits outside
+ * layout, while a wrapper keeps the connector spacing exact.
+ */
+export type TimelineStatus = 'upcoming' | 'current' | 'done' | 'onHold' | 'rejected' | 'cancelled' | 'skipped';
+export type TimelineVariant = 'feed' | 'progress';
+/** Same two names as the web library's AppTimeline; orthogonal to `variant`. */
+export type TimelineOrientation = 'vertical' | 'horizontal';
+export interface TimelineItem {
+    title: string;
+    description?: string;
+    /** Rendered under the title — a timestamp, an actor, a metadata line. */
+    meta?: string;
+    /** `progress` variant: drives the dot colour. Defaults to 'done' in a feed. */
+    status?: TimelineStatus;
+    /**
+     * Overrides the dot's colour; the halo follows it. For a stage the design
+     * paints in a colour no status produces, such as a brand-blue active dot.
+     */
+    color?: string;
+    /** Replaces the dot and its halo entirely, centred in the dot's slot. */
+    icon?: React.ReactNode;
+    /** Arbitrary content below the text block. */
+    children?: React.ReactNode;
+    key?: string;
+}
+export interface TimelineProps {
+    items: ReadonlyArray<TimelineItem>;
+    /** 'feed' is an audit trail; 'progress' is a status tracker. */
+    variant?: TimelineVariant;
+    /**
+     * `vertical` (default) stacks entries top to bottom beside a rail;
+     * `horizontal` gives each entry an equal column with the dot above its
+     * centred text and a connector running from one halo's edge to the next.
+     */
+    orientation?: TimelineOrientation;
+    style?: StyleProp<ViewStyle>;
+    testID?: string;
+}
+/**
+ * A chronological activity feed OR a status-progress tracker. Stepper covers a
+ * linear "which step am I on" flow; this covers "what has happened to this
+ * record", where entries carry their own status and can end in a terminal one.
+ */
+export declare const Timeline: React.FC<TimelineProps>;
+export default Timeline;
+//# sourceMappingURL=Timeline.d.ts.map

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

@@ -0,0 +1,3 @@
+export type { TimelineItem, TimelineOrientation, TimelineProps, TimelineStatus, TimelineVariant } from './Timeline';
+export { default, Timeline } from './Timeline';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1,44 @@
+import React from 'react';
+import type { StyleProp, TextStyle, ViewStyle } from 'react-native';
+import type { HapticType } from '../../utils/hapticUtils';
+export type ToastVariant = 'default' | 'success' | 'error' | 'warning' | 'info';
+export type ToastPosition = 'top' | 'bottom';
+export interface ToastAction {
+    label: string;
+    onPress: () => void;
+}
+export interface ToastOptions {
+    message: string;
+    description?: string;
+    variant?: ToastVariant;
+    position?: ToastPosition;
+    duration?: number;
+    action?: ToastAction;
+    haptic?: HapticType | false;
+    icon?: React.ReactNode;
+    /** Style applied to the toast container (override radius, padding, shadow per-toast). */
+    style?: StyleProp<ViewStyle>;
+    /** Alias of `style`. Applied to the toast container (merged additively). */
+    containerStyle?: StyleProp<ViewStyle>;
+    /** Style applied to the toast message Text. */
+    textStyle?: StyleProp<TextStyle>;
+    /** Style applied to the leading icon circle wrapper. */
+    iconCircleStyle?: StyleProp<ViewStyle>;
+    /** Style applied to the message Text (alias-ish of `textStyle` but kept distinct for slot symmetry). */
+    messageStyle?: StyleProp<TextStyle>;
+    /** Style applied to the trailing action Pressable. */
+    actionButtonStyle?: StyleProp<ViewStyle>;
+    testID?: string;
+}
+export interface ToastItem extends ToastOptions {
+    id: string;
+}
+export interface ToastProps {
+    toast: ToastItem;
+    index: number;
+    onDismiss: (id: string) => void;
+}
+declare const Toast: React.FC<ToastProps>;
+export { Toast };
+export default Toast;
+//# sourceMappingURL=Toast.d.ts.map

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

@@ -0,0 +1,26 @@
+import React from 'react';
+import type { ToastOptions, ToastPosition } from './Toast';
+export interface ToastApi {
+    show: (opts: ToastOptions) => string;
+    hide: (id: string) => void;
+    hideAll: () => void;
+}
+export interface ToastProviderProps {
+    children: React.ReactNode;
+    maxVisible?: number;
+    topOffset?: number;
+    bottomOffset?: number;
+}
+export declare const ToastProvider: React.FC<ToastProviderProps>;
+export declare const useToast: () => ToastApi;
+interface ToastGlobal {
+    show: (opts: ToastOptions) => string;
+    success: (message: string, opts?: Omit<ToastOptions, 'message' | 'variant'>) => string;
+    error: (message: string, opts?: Omit<ToastOptions, 'message' | 'variant'>) => string;
+    warning: (message: string, opts?: Omit<ToastOptions, 'message' | 'variant'>) => string;
+    info: (message: string, opts?: Omit<ToastOptions, 'message' | 'variant'>) => string;
+    hideAll: () => void;
+}
+export declare const toast: ToastGlobal;
+export type { ToastPosition };
+//# sourceMappingURL=ToastProvider.d.ts.map

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

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

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

@@ -0,0 +1,28 @@
+import React from 'react';
+import type { StyleProp, TextStyle, ViewStyle } from 'react-native';
+export type TooltipPlacement = 'top' | 'bottom' | 'left' | 'right' | 'auto';
+export type TooltipTrigger = 'longPress' | 'press' | 'manual';
+export interface TooltipProps {
+    content: string | React.ReactNode;
+    children: React.ReactElement;
+    placement?: TooltipPlacement;
+    trigger?: TooltipTrigger;
+    visible?: boolean;
+    onVisibleChange?: (visible: boolean) => void;
+    hideOnContentPress?: boolean;
+    maxWidth?: number;
+    showArrow?: boolean;
+    accessibilityLabel?: string;
+    style?: StyleProp<ViewStyle>;
+    /** Alias of `style`. Applied to the outer animated tooltip wrapper (merged additively). */
+    containerStyle?: StyleProp<ViewStyle>;
+    /** Style override applied to the arrow caret View. */
+    arrowStyle?: StyleProp<ViewStyle>;
+    /** Style override applied to the message Text (only when `content` is a string). */
+    messageStyle?: StyleProp<TextStyle>;
+    testID?: string;
+}
+declare const Tooltip: React.FC<TooltipProps>;
+export { Tooltip };
+export default Tooltip;
+//# sourceMappingURL=Tooltip.d.ts.map

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

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