@webority-technologies/mobile-ui 0.0.1

package/lib/typescript/commonjs/utils/dimensions.d.ts

@@ -0,0 +1,3 @@
+export type { BreakpointKey } from './responsive';
+export { Breakpoints, isScreenSize, isTablet, ScreenDimensions } from './responsive';
+//# sourceMappingURL=dimensions.d.ts.map

package/lib/typescript/commonjs/utils/feedback.d.ts

@@ -0,0 +1,45 @@
+import { type HapticType } from './hapticUtils';
+/**
+ * What the interaction MEANT, not which vibration to play.
+ *
+ * Call sites that pick a `HapticType` directly end up disagreeing with each
+ * other — one screen fires `impactMedium` on delete, the next fires
+ * `notificationWarning`, and the app stops speaking one language. Naming the
+ * intent moves that decision here, once.
+ */
+export type FeedbackIntent = 'tap' | 'select' | 'longPress' | 'created' | 'deleted' | 'restored' | 'toggledOn' | 'toggledOff' | 'succeeded' | 'warned' | 'failed';
+/**
+ * Gate every intent from one place, so an app's "haptics" setting needs no
+ * per-component plumbing.
+ */
+export declare const configureFeedback: (prefs: {
+    haptics: boolean;
+}) => void;
+export declare const isFeedbackEnabled: () => boolean;
+/** Resolve an intent to its haptic type without firing it. */
+export declare const hapticForIntent: (intent: FeedbackIntent) => HapticType;
+export declare const feedback: {
+    /** A plain press: button, row, chip. */
+    readonly tap: () => void;
+    /** Moving between options — segmented control, picker wheel, tab. */
+    readonly select: () => void;
+    /** A long-press threshold being crossed. */
+    readonly longPress: () => void;
+    /** Something now exists that did not before. */
+    readonly created: () => void;
+    /** Something was destroyed or removed. */
+    readonly deleted: () => void;
+    /** An undo landed. */
+    readonly restored: () => void;
+    /** A binary control turned on / off — switch, checkbox, favourite. */
+    readonly toggled: (on: boolean) => void;
+    /** A flow finished successfully. */
+    readonly succeeded: () => void;
+    /** A recoverable problem the user should notice. */
+    readonly warned: () => void;
+    /** A failure. */
+    readonly failed: () => void;
+    /** Escape hatch for an intent held in a variable. */
+    readonly fire: (intent: FeedbackIntent) => void;
+};
+//# sourceMappingURL=feedback.d.ts.map

package/lib/typescript/commonjs/utils/hapticUtils.d.ts

@@ -0,0 +1,12 @@
+export type HapticType = 'selection' | 'impactLight' | 'impactMedium' | 'impactHeavy' | 'notificationSuccess' | 'notificationWarning' | 'notificationError';
+export declare const triggerHaptic: (type?: HapticType) => void;
+export declare const setHapticImplementation: (impl: ((type: HapticType) => void) | null) => void;
+/**
+ * Resolves a component's `haptic` prop to the type that should fire, or null
+ * when haptics are off. `false` disables; a `HapticType` overrides; `undefined`
+ * falls back to the component's sensible default. Pair with `triggerHaptic`:
+ *   const h = resolveHaptic(haptic, 'selection');
+ *   if (h) triggerHaptic(h);
+ */
+export declare const resolveHaptic: (haptic: HapticType | false | undefined, fallbackType: HapticType) => HapticType | null;
+//# sourceMappingURL=hapticUtils.d.ts.map

package/lib/typescript/commonjs/utils/index.d.ts

@@ -0,0 +1,11 @@
+export type { FeedbackIntent } from './feedback';
+export { configureFeedback, feedback, hapticForIntent, isFeedbackEnabled } from './feedback';
+export type { HapticType } from './hapticUtils';
+export { resolveHaptic, setHapticImplementation, triggerHaptic } from './hapticUtils';
+export type { BreakpointKey } from './responsive';
+export { Breakpoints, isScreenSize, isTablet, Responsive, ScreenDimensions } from './responsive';
+export { shadowStyle } from './shadows';
+export type { SpacingToken } from './spacing';
+export { Margin, Padding, Spacing } from './spacing';
+export { warnUnknownProps } from './warnUnknownProps';
+//# sourceMappingURL=index.d.ts.map

package/lib/typescript/commonjs/utils/responsive.d.ts

@@ -0,0 +1,23 @@
+export declare const ScreenDimensions: {
+    readonly width: number;
+    readonly height: number;
+    readonly pixelRatio: number;
+    readonly fontScale: number;
+};
+export declare const Breakpoints: {
+    readonly xs: 0;
+    readonly sm: 360;
+    readonly md: 414;
+    readonly lg: 768;
+    readonly xl: 1024;
+};
+export type BreakpointKey = keyof typeof Breakpoints;
+export declare const isScreenSize: (size: BreakpointKey) => boolean;
+export declare const isTablet: () => boolean;
+export declare const Responsive: {
+    readonly width: (size: number) => number;
+    readonly height: (size: number) => number;
+    readonly size: (size: number) => number;
+    readonly font: (size: number) => number;
+};
+//# sourceMappingURL=responsive.d.ts.map

package/lib/typescript/commonjs/utils/shadows.d.ts

@@ -0,0 +1,4 @@
+import type { ViewStyle } from 'react-native';
+import type { ShadowScale } from '../theme/types';
+export declare const shadowStyle: (shadows: ShadowScale, level: keyof ShadowScale) => ViewStyle;
+//# sourceMappingURL=shadows.d.ts.map

package/lib/typescript/commonjs/utils/spacing.d.ts

@@ -0,0 +1,61 @@
+import type { SpacingScale } from '../theme/types';
+export type SpacingToken = keyof SpacingScale;
+export declare const Spacing: {
+    readonly none: 0;
+    readonly xxs: number;
+    readonly xs: number;
+    readonly sm: number;
+    readonly md: number;
+    readonly lg: number;
+    readonly xl: number;
+    readonly '2xl': number;
+    readonly '3xl': number;
+    readonly '4xl': number;
+};
+export declare const Padding: {
+    readonly all: (token: SpacingToken) => {
+        padding: number;
+    };
+    readonly horizontal: (token: SpacingToken) => {
+        paddingHorizontal: number;
+    };
+    readonly vertical: (token: SpacingToken) => {
+        paddingVertical: number;
+    };
+    readonly top: (token: SpacingToken) => {
+        paddingTop: number;
+    };
+    readonly bottom: (token: SpacingToken) => {
+        paddingBottom: number;
+    };
+    readonly left: (token: SpacingToken) => {
+        paddingLeft: number;
+    };
+    readonly right: (token: SpacingToken) => {
+        paddingRight: number;
+    };
+};
+export declare const Margin: {
+    readonly all: (token: SpacingToken) => {
+        margin: number;
+    };
+    readonly horizontal: (token: SpacingToken) => {
+        marginHorizontal: number;
+    };
+    readonly vertical: (token: SpacingToken) => {
+        marginVertical: number;
+    };
+    readonly top: (token: SpacingToken) => {
+        marginTop: number;
+    };
+    readonly bottom: (token: SpacingToken) => {
+        marginBottom: number;
+    };
+    readonly left: (token: SpacingToken) => {
+        marginLeft: number;
+    };
+    readonly right: (token: SpacingToken) => {
+        marginRight: number;
+    };
+};
+//# sourceMappingURL=spacing.d.ts.map

package/lib/typescript/commonjs/utils/warnUnknownProps.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Dev-time warning for props a component does not accept.
+ *
+ * This exists for a class of bug that nothing in a JS consumer's toolchain
+ * objects to. A component destructures the props it knows and ignores the rest,
+ * so a renamed or mistyped prop is simply dropped — silently, at every call
+ * site. The web library hit this three times in one day: `body` instead of
+ * `message` left nine destructive confirm dialogs with no explanatory text, and
+ * `name` instead of `icon` emptied an entire actions column across 23 call
+ * sites. Neither failed a build, a lint or a test.
+ *
+ * Our components are TypeScript, so a TS consumer is already protected at
+ * compile time. Several apps in the fleet are plain JS, and they get nothing —
+ * which is who this is for. The check therefore has to be a runtime one, and it
+ * has to run where the mistake is made: the consumer's dev server.
+ *
+ * DEV ONLY — the `__DEV__` guard means it costs a release build nothing.
+ */
+export declare const warnUnknownProps: (componentName: string, rest: Record<string, unknown> | undefined) => void;
+//# sourceMappingURL=warnUnknownProps.d.ts.map

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

@@ -0,0 +1,48 @@
+import React from 'react';
+import type { StyleProp, ViewStyle } from 'react-native';
+import type { HapticType } from '../../utils/hapticUtils.js';
+export type AccordionVariant = 'plain' | 'card';
+export interface AccordionProps {
+    title: string;
+    children: React.ReactNode;
+    id?: string;
+    expanded?: boolean;
+    defaultExpanded?: boolean;
+    onChange?: (expanded: boolean) => void;
+    icon?: React.ReactNode;
+    disabled?: boolean;
+    variant?: AccordionVariant;
+    accessibilityLabel?: string;
+    style?: StyleProp<ViewStyle>;
+    headerStyle?: StyleProp<ViewStyle>;
+    contentStyle?: StyleProp<ViewStyle>;
+    /** Style applied to the animated wrapper around the expandable content. */
+    contentWrapperStyle?: StyleProp<ViewStyle>;
+    /** Style applied to the outermost container View. */
+    containerStyle?: StyleProp<ViewStyle>;
+    testID?: string;
+    /**
+     * When true, renders the accordion as its authored skeleton placeholder
+     * shape (header row, collapsed body). Footprint matches the closed live
+     * accordion so the layout doesn't shift when data arrives.
+     */
+    loading?: boolean;
+    /** Haptic feedback for interactions. Pass false to disable; pass a HapticType to override the default. */
+    haptic?: HapticType | false;
+}
+export interface AccordionGroupProps {
+    children: React.ReactNode;
+    allowMultiple?: boolean;
+    defaultExpandedKeys?: string[];
+    expandedKeys?: string[];
+    onChange?: (keys: string[]) => void;
+    style?: StyleProp<ViewStyle>;
+    testID?: string;
+}
+declare const AccordionGroup: React.FC<AccordionGroupProps>;
+declare const Accordion: React.FC<AccordionProps> & {
+    Skeleton: React.FC<AccordionProps>;
+};
+export { Accordion, AccordionGroup };
+export default Accordion;
+//# sourceMappingURL=Accordion.d.ts.map

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

@@ -0,0 +1,3 @@
+export type { AccordionGroupProps, AccordionProps, AccordionVariant } from './Accordion.js';
+export { Accordion, AccordionGroup, default } from './Accordion.js';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1,30 @@
+import React from 'react';
+import type { StyleProp, ViewStyle } from 'react-native';
+export type PresencePreset = 'fade' | 'scale' | 'slide-up' | 'slide-down';
+export interface AnimatePresenceProps {
+    /**
+     * Render conditionally. When this goes null / undefined / false the exit
+     * animation plays before the content unmounts; when it returns the enter
+     * animation plays. Drive it like `{visible ? <Panel /> : null}`.
+     */
+    children?: React.ReactNode;
+    /** Enter/exit preset. Default `'fade'`. */
+    preset?: PresencePreset;
+    /** Animation duration (ms). Defaults to `theme.motion.duration.base`. */
+    duration?: number;
+    style?: StyleProp<ViewStyle>;
+    testID?: string;
+}
+/**
+ * Animates a single child in on mount and out on unmount. Thin, theme-aware
+ * wrapper over Reanimated's `entering`/`exiting` — Reanimated keeps the view
+ * alive to play the exit, so the parent only toggles a condition. Honors the OS
+ * Reduce Motion setting (renders instantly when reduced).
+ *
+ * For animating items inside a list, use Reanimated's `itemLayoutAnimation`
+ * on `Animated.FlatList` instead — this wrapper targets single conditional nodes.
+ */
+declare const AnimatePresence: React.FC<AnimatePresenceProps>;
+export { AnimatePresence };
+export default AnimatePresence;
+//# sourceMappingURL=AnimatePresence.d.ts.map

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

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

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

@@ -0,0 +1,50 @@
+import React from 'react';
+import type { View as RNView, StyleProp, ViewStyle } from 'react-native';
+import { Animated } from 'react-native';
+import type { HapticType } from '../../utils/hapticUtils.js';
+export type AppBarVariant = 'default' | 'large' | 'compact';
+export type AppBarTitleAlignment = 'left' | 'center';
+export interface AppBarAction {
+    icon: React.ReactNode;
+    onPress: () => void;
+    accessibilityLabel?: string;
+    testID?: string;
+}
+export interface AppBarRightAction extends AppBarAction {
+    badge?: number | string;
+}
+export interface AppBarProps {
+    title?: string;
+    subtitle?: string;
+    titleAlignment?: AppBarTitleAlignment;
+    leftAction?: AppBarAction;
+    rightActions?: AppBarRightAction[];
+    variant?: AppBarVariant;
+    transparent?: boolean;
+    /**
+     * Optional ScrollView vertical offset (Animated.Value) used to drive the
+     * "collapsing app bar" effect when `variant='large'`. As `scrollY` moves
+     * from 0 → 60, the large title shrinks/translates into the compact bar
+     * area and a bottom hairline border fades in.
+     */
+    scrollY?: Animated.Value | Animated.AnimatedInterpolation<number>;
+    style?: StyleProp<ViewStyle>;
+    /** Alias for `style` applied to the outer container (animated when collapsing). */
+    containerStyle?: StyleProp<ViewStyle>;
+    /** Style applied to the title Animated.Text. */
+    titleStyle?: StyleProp<ViewStyle>;
+    /** Style applied to the subtitle Animated.Text. */
+    subtitleStyle?: StyleProp<ViewStyle>;
+    /** Style applied to the right-action badge bubble. */
+    badgeStyle?: StyleProp<ViewStyle>;
+    /**
+     * Haptic feedback for interactions. Pass false to disable; pass a HapticType
+     * to override the default.
+     */
+    haptic?: HapticType | false;
+    testID?: string;
+}
+declare const AppBar: React.ForwardRefExoticComponent<AppBarProps & React.RefAttributes<RNView>>;
+export { AppBar };
+export default AppBar;
+//# sourceMappingURL=AppBar.d.ts.map

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

@@ -0,0 +1,3 @@
+export type { AppBarAction, AppBarProps, AppBarRightAction, AppBarTitleAlignment, AppBarVariant } from './AppBar.js';
+export { AppBar, default } from './AppBar.js';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1,39 @@
+import React from 'react';
+import type { StyleProp, ViewStyle } from 'react-native';
+export interface AsyncBlockProps {
+    /** Show the placeholder instead of content. */
+    loading?: boolean;
+    /** An error to show in place of content. Falsy means no error. */
+    error?: string | React.ReactNode;
+    /** The fetch succeeded with nothing to show. */
+    empty?: boolean;
+    /** Retry affordance on the error state. Omit to render the error without one. */
+    onRetry?: () => void;
+    /** Placeholder shaped like the content. Falls back to a centred Spinner. */
+    skeleton?: React.ReactNode;
+    /** Copy for the empty state. */
+    emptyTitle?: string;
+    emptyDescription?: string;
+    emptyIcon?: React.ReactNode;
+    /** Copy for the error state. `error` itself is used as the description when it is a string. */
+    errorTitle?: string;
+    retryLabel?: string;
+    /** Rendered once loaded, error-free and non-empty. */
+    children?: React.ReactNode;
+    style?: StyleProp<ViewStyle>;
+    testID?: string;
+}
+/**
+ * The loading / error / empty / content switcher every screen that fetches data
+ * needs. Without it each screen re-implements the same four-way branch and they
+ * disagree — one shows a spinner over stale rows, the next flashes an empty
+ * state mid-fetch.
+ *
+ * Precedence is fixed: `loading` wins over everything, then `error`, then
+ * `empty`, then `children`. A fetch that is both in flight and holding a stale
+ * error shows only the loading state, which is the least surprising reading of
+ * "still in flight".
+ */
+export declare const AsyncBlock: React.FC<AsyncBlockProps>;
+export default AsyncBlock;
+//# sourceMappingURL=AsyncBlock.d.ts.map

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

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

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

@@ -0,0 +1,53 @@
+import React from 'react';
+import type { StyleProp, TextStyle, ViewStyle } from 'react-native';
+import type { HapticType } from '../../utils/index.js';
+import type { InputSize, InputVariant } from '../Input/index.js';
+export interface AutocompleteProps<T = string> {
+    /** Candidate options to filter. */
+    options: ReadonlyArray<T>;
+    /** Controlled input text. */
+    value?: string;
+    /** Uncontrolled initial text. */
+    defaultValue?: string;
+    onChangeText?: (text: string) => void;
+    /** Fired when a suggestion is chosen. */
+    onSelect: (option: T) => void;
+    /** Read a display label from an option. Defaults to the option itself for strings. */
+    getOptionLabel?: (option: T) => string;
+    /** Stable React key per option. Defaults to label + index. */
+    getOptionKey?: (option: T) => string;
+    /** Custom match predicate. Defaults to a case-insensitive substring match on the label. */
+    filter?: (option: T, query: string) => boolean;
+    /** Minimum characters before suggestions appear. Default 1. */
+    minChars?: number;
+    /** Cap the number of suggestions shown. Default 8. */
+    maxResults?: number;
+    /** Text shown when nothing matches. Default "No matches". */
+    emptyText?: string;
+    /** Show a loading spinner in the dropdown — e.g. while fetching remote results. */
+    loading?: boolean;
+    /** `'client'` filters `options` locally; `'none'` shows them as-is (for server-side search). Default `'client'`. */
+    filterMode?: 'client' | 'none';
+    /** Text beside the loading spinner. Default "Searching…". */
+    loadingText?: string;
+    placeholder?: string;
+    label?: string;
+    error?: string;
+    helperText?: string;
+    disabled?: boolean;
+    size?: InputSize;
+    variant?: InputVariant;
+    /** Haptic on select. Default `'selection'`. */
+    haptic?: HapticType | false;
+    style?: StyleProp<ViewStyle>;
+    listStyle?: StyleProp<ViewStyle>;
+    optionTextStyle?: StyleProp<TextStyle>;
+    testID?: string;
+}
+declare function Autocomplete<T = string>(props: AutocompleteProps<T>): React.JSX.Element;
+declare namespace Autocomplete {
+    var displayName: string;
+}
+export { Autocomplete };
+export default Autocomplete;
+//# sourceMappingURL=Autocomplete.d.ts.map

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

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

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

@@ -0,0 +1,75 @@
+import React from 'react';
+import type { ImageSourcePropType, ImageStyle, View as RNView, StyleProp, TextStyle, ViewStyle } from 'react-native';
+/**
+ * Props passed to a custom {@link AvatarProps.ImageComponent}. They mirror what
+ * the built-in `<Image>` receives, so a plain RN `Image` is a valid drop-in.
+ * Supply a custom component to render images that need authenticated fetching,
+ * caching, or token refresh (the library stays auth-agnostic).
+ */
+export interface AvatarImageProps {
+    source: ImageSourcePropType;
+    style: StyleProp<ImageStyle>;
+    resizeMode: 'cover';
+    onError: () => void;
+    accessibilityIgnoresInvertColors?: boolean;
+}
+export type AvatarSize = 'xs' | 'sm' | 'md' | 'lg' | 'xl' | number;
+export type AvatarShape = 'circle' | 'square' | 'rounded';
+export type AvatarStatus = 'online' | 'offline' | 'busy' | 'away' | null;
+export type AvatarStatusPosition = 'topRight' | 'bottomRight';
+export interface AvatarProps {
+    source?: ImageSourcePropType;
+    /**
+     * Custom component used to render the image instead of the built-in `<Image>`.
+     * Receives {@link AvatarImageProps}. Use this when `source` points at a secured
+     * endpoint that needs auth headers / token refresh / caching — plug in the
+     * app's authenticated image loader. On error it should call `onError`, which
+     * triggers the initials fallback. When omitted, a plain RN `<Image>` is used.
+     */
+    ImageComponent?: React.ComponentType<AvatarImageProps>;
+    name?: string;
+    size?: AvatarSize;
+    shape?: AvatarShape;
+    status?: AvatarStatus;
+    statusPosition?: AvatarStatusPosition;
+    backgroundColor?: string;
+    color?: string;
+    /**
+     * Per-instance initials font size in pixels. Wins over theme tokens
+     * (`avatar.fontSize` and `avatar.fontSizeRatio`) and the size-derived default.
+     */
+    fontSize?: number;
+    /**
+     * 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>;
+    textStyle?: StyleProp<TextStyle>;
+    testID?: string;
+}
+declare const Avatar: React.ForwardRefExoticComponent<AvatarProps & React.RefAttributes<RNView>> & {
+    Skeleton: React.FC<AvatarProps>;
+};
+export type AvatarGroupSpacing = 'tight' | 'normal' | 'loose';
+export type AvatarGroupOverflowVariant = 'count' | 'plus';
+export interface AvatarGroupProps {
+    children: React.ReactElement<AvatarProps>[];
+    max?: number;
+    size?: AvatarSize;
+    spacing?: AvatarGroupSpacing;
+    overflowVariant?: AvatarGroupOverflowVariant;
+    accessibilityLabel?: string;
+    style?: StyleProp<ViewStyle>;
+    testID?: string;
+}
+declare const AvatarGroup: React.FC<AvatarGroupProps>;
+type AvatarComponent = typeof Avatar & {
+    Group: typeof AvatarGroup;
+};
+declare const AvatarWithGroup: AvatarComponent;
+export { Avatar, AvatarGroup };
+export default AvatarWithGroup;
+//# sourceMappingURL=Avatar.d.ts.map

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

@@ -0,0 +1,3 @@
+export type { AvatarGroupOverflowVariant, AvatarGroupProps, AvatarGroupSpacing, AvatarImageProps, AvatarProps, AvatarShape, AvatarSize, AvatarStatus, AvatarStatusPosition } from './Avatar.js';
+export { Avatar, AvatarGroup, default } from './Avatar.js';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1,34 @@
+import React from 'react';
+import type { View as RNView, StyleProp, TextStyle, ViewStyle } from 'react-native';
+export type BadgeVariant = 'standard' | 'dot';
+export type BadgeTone = 'primary' | 'success' | 'warning' | 'error' | 'neutral' | 'info';
+export type BadgeSize = 'sm' | 'md';
+export type BadgeAnchor = 'topRight' | 'topLeft' | 'bottomRight' | 'bottomLeft';
+export interface BadgeProps {
+    value?: number | string;
+    max?: number;
+    variant?: BadgeVariant;
+    tone?: BadgeTone;
+    size?: BadgeSize;
+    invisible?: boolean;
+    /**
+     * 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;
+    children?: React.ReactNode;
+    anchor?: BadgeAnchor;
+    pulse?: boolean;
+    accessibilityLabel?: string;
+    style?: StyleProp<ViewStyle>;
+    badgeStyle?: StyleProp<ViewStyle>;
+    textStyle?: StyleProp<TextStyle>;
+    testID?: string;
+}
+declare const Badge: React.ForwardRefExoticComponent<BadgeProps & React.RefAttributes<RNView>> & {
+    Skeleton: React.FC<BadgeProps>;
+};
+export { Badge };
+export default Badge;
+//# sourceMappingURL=Badge.d.ts.map

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

@@ -0,0 +1,3 @@
+export type { BadgeAnchor, BadgeProps, BadgeSize, BadgeTone, BadgeVariant } from './Badge.js';
+export { Badge, default } from './Badge.js';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1,47 @@
+import React from 'react';
+import type { View as RNView, StyleProp, ViewStyle } from 'react-native';
+import type { HapticType } from '../../utils/hapticUtils.js';
+export type BannerVariant = 'info' | 'success' | 'warning' | 'error' | 'neutral';
+export interface BannerAction {
+    label: string;
+    onPress: () => void;
+    tone?: 'primary' | 'neutral';
+}
+export interface BannerProps {
+    title?: string;
+    message: string | React.ReactNode;
+    variant?: BannerVariant;
+    icon?: React.ReactNode | false;
+    actions?: BannerAction[];
+    dismissible?: boolean;
+    onDismiss?: () => void;
+    /** Haptic feedback for interactions. Pass false to disable; pass a HapticType to override the default. */
+    haptic?: HapticType | false;
+    visible?: boolean;
+    animateMount?: boolean;
+    /**
+     * 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>;
+    /** Alias for `style` — applied to the outer animated container. */
+    containerStyle?: StyleProp<ViewStyle>;
+    /** Style applied to the auto-rendered icon circle (when no custom `icon` is provided). */
+    iconCircleStyle?: StyleProp<ViewStyle>;
+    /** Style applied to the leading tint bar. */
+    tintBarStyle?: StyleProp<ViewStyle>;
+    /** Style applied to the dismiss/close button. */
+    closeButtonStyle?: StyleProp<ViewStyle>;
+    /** Style applied to each action button (Pressable). */
+    actionButtonStyle?: StyleProp<ViewStyle>;
+    testID?: string;
+}
+declare const Banner: React.ForwardRefExoticComponent<BannerProps & React.RefAttributes<RNView>> & {
+    Skeleton: React.FC<BannerProps>;
+};
+export { Banner };
+export default Banner;
+//# sourceMappingURL=Banner.d.ts.map

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

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

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

@@ -0,0 +1,40 @@
+import React from 'react';
+import type { View as RNView, StyleProp, TextStyle, ViewStyle } from 'react-native';
+import type { HapticType } from '../../utils/index.js';
+export type BottomNavigationVariant = 'pill' | 'underline';
+export type BottomNavigationIndicatorPosition = 'top' | 'bottom';
+export type TabBadge = number | string | boolean | null;
+export interface TabIconProps {
+    color: string;
+    size: number;
+    focused: boolean;
+}
+export interface TabConfig {
+    key: string;
+    label: string;
+    icon: (props: TabIconProps) => React.ReactNode;
+    activeIcon?: (props: TabIconProps) => React.ReactNode;
+    badge?: TabBadge;
+}
+export interface BottomNavigationProps {
+    tabs: TabConfig[];
+    activeTab: string;
+    onChange: (tabKey: string) => void;
+    haptic?: HapticType | false;
+    showLabels?: boolean;
+    variant?: BottomNavigationVariant;
+    /**
+     * Where the active-tab line sits, for variants that draw a line
+     * (currently `underline`). Default `'bottom'` preserves the legacy look;
+     * `'top'` flips the line to sit just above the tab row.
+     */
+    indicatorPosition?: BottomNavigationIndicatorPosition;
+    style?: StyleProp<ViewStyle>;
+    indicatorStyle?: StyleProp<ViewStyle>;
+    labelStyle?: StyleProp<TextStyle>;
+    testID?: string;
+}
+declare const BottomNavigation: React.ForwardRefExoticComponent<BottomNavigationProps & React.RefAttributes<RNView>>;
+export { BottomNavigation };
+export default BottomNavigation;
+//# sourceMappingURL=BottomNavigation.d.ts.map