@webority/mobile-ui 0.0.0-stage → 0.0.33

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

@@ -0,0 +1,25 @@
+/**
+ * The tint a pressed control paints over a fill in one of the theme's accent
+ * colours (primary, success, warning, error). The theme's own
+ * `surface.pressed` is meant for its surfaces: a dark wash in the light
+ * theme and a WHITE wash in the dark theme, which on a coloured fill reads
+ * as the control flashing white. A coloured fill darkens on press in either
+ * theme, so this is fixed rather than themed.
+ */
+export declare const ACCENT_PRESSED_TINT = "rgba(0, 0, 0, 0.12)";
+/**
+ * `#RRGGBB` → `#RRGGBBAA`: a tone colour at the given opacity, for a tinted
+ * fill behind text drawn in the full tone. Non-hex colours (named, `rgb()`,
+ * short or 8-digit hex) can't be suffixed; those return `fallback`, which a
+ * caller sets to the nearest flat theme surface.
+ */
+export declare const tintOf: (color: string, opacity: number, fallback: string) => string;
+/**
+ * The OPAQUE colour of `color` at `opacity` laid over `over`: what `tintOf`
+ * would look like on that surface, as a flat `#RRGGBB`. For a tint that sits
+ * on something it must hide (a badge over a photo), where a translucent tint
+ * would let the photo through. Either colour not a 6-digit hex returns
+ * `fallback`.
+ */
+export declare const blendOf: (color: string, opacity: number, over: string, fallback: string) => string;
+//# sourceMappingURL=color.d.ts.map

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

@@ -0,0 +1,16 @@
+/**
+ * The smooth "squircle" corner, the app-side counterpart of the website's CSS
+ * `corner-shape: squircle`. Spread it next to any `borderRadius`.
+ *
+ * iOS draws Apple's continuous curve through React Native's own
+ * `borderCurve: 'continuous'`; no dependency. Android has no equivalent and
+ * ignores the key, so it keeps the circular corner (a deliberate decision,
+ * 16-Sep-2026: drawing the shape there means an SVG path behind every field,
+ * card and button, with path-stroked borders, and was not worth it at the
+ * library's 10 to 16 px radii). The three curves, CSS squircle, Apple's and
+ * Figma's, look alike but are not identical.
+ */
+export declare const smoothCorners: {
+    readonly borderCurve: "continuous";
+};
+//# sourceMappingURL=corners.d.ts.map

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

@@ -0,0 +1,3 @@
+export type { BreakpointKey, ResponsiveScales, ScreenInfo } from './responsive';
+export { Breakpoints, isScreenSize, isTablet, ScreenDimensions, useScreenDimensions } 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,16 @@
+export type HapticType = 'selection' | 'impactLight' | 'impactMedium' | 'impactHeavy' | 'notificationSuccess' | 'notificationWarning' | 'notificationError';
+export declare const triggerHaptic: (type?: HapticType) => void;
+/**
+ * Replace the haptic backend. Intended for TESTS and for the showcase; an app
+ * gets expo-haptics without wiring anything. Pass `null` to restore it.
+ */
+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/hashString.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Two 32-bit FNV-style passes plus the length, as hex. Not cryptographic: it
+ * turns a URL into a short key that is safe as a storage key or a file name.
+ */
+export declare const hashString: (input: string) => string;
+//# sourceMappingURL=hashString.d.ts.map

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

@@ -0,0 +1,16 @@
+export { blendOf, tintOf } from './color';
+export { smoothCorners } from './corners';
+export type { FeedbackIntent } from './feedback';
+export { configureFeedback, feedback, hapticForIntent, isFeedbackEnabled } from './feedback';
+export type { HapticType } from './hapticUtils';
+export { resolveHaptic, setHapticImplementation, triggerHaptic } from './hapticUtils';
+export { mergeRefs } from './mergeRefs';
+export type { BreakpointKey, ResponsiveScales, ScreenInfo } from './responsive';
+export { Breakpoints, isScreenSize, isTablet, Responsive, ScreenDimensions, useScreenDimensions } from './responsive';
+export { shadowStyle } from './shadows';
+export type { SpacingToken } from './spacing';
+export { Margin, Padding, Spacing } from './spacing';
+export type { SquirclePathParams } from './squircle';
+export { SQUIRCLE_MIN_RADIUS, SQUIRCLE_SMOOTHING, squircleApplies, squircleHostRadius, squirclePath } from './squircle';
+export { warnUnknownProps } from './warnUnknownProps';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1,10 @@
+import type { Ref } from 'react';
+/**
+ * Fold several refs into one callback ref, so a component can hold its own
+ * ref to a host (to call `focus()` on it) while still forwarding the ref its
+ * consumer passed. Callback refs are called, object refs are assigned; a
+ * `null` or `undefined` entry is skipped. Memoise the result: React treats
+ * a new callback ref as a change and re-attaches on every render.
+ */
+export declare const mergeRefs: <T>(...refs: Array<Ref<T> | undefined>) => (node: T | null) => void;
+//# sourceMappingURL=mergeRefs.d.ts.map

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

@@ -0,0 +1,47 @@
+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 ScreenDimensions: {
+    readonly width: number;
+    readonly height: number;
+    readonly pixelRatio: number;
+    readonly fontScale: number;
+};
+declare const responsiveFor: (width: number, height: number) => {
+    width: (size: number) => number;
+    height: (size: number) => number;
+    size: (size: number) => number;
+    font: (size: number) => number;
+};
+export type ResponsiveScales = ReturnType<typeof responsiveFor>;
+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;
+};
+export interface ScreenInfo {
+    width: number;
+    height: number;
+    pixelRatio: number;
+    fontScale: number;
+    isTablet: boolean;
+    isScreenSize: (size: BreakpointKey) => boolean;
+    /** The same four scalers as `Responsive`, bound to the CURRENT window. */
+    responsive: ResponsiveScales;
+}
+/**
+ * The reactive form. `useWindowDimensions` re-renders the component whenever
+ * the window changes, so a layout branching on `isTablet` follows a rotation,
+ * an unfold or a split-screen resize instead of staying where it started.
+ */
+export declare const useScreenDimensions: () => ScreenInfo;
+export {};
+//# sourceMappingURL=responsive.d.ts.map

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

@@ -0,0 +1,22 @@
+import type { ViewStyle } from 'react-native';
+import type { ShadowScale } from '../theme/types';
+export declare const shadowStyle: (shadows: ShadowScale, level: keyof ShadowScale) => ViewStyle;
+/**
+ * Whether this platform draws a `boxShadow`. Android paints an outset box
+ * shadow only from API 28; below that the style is ignored, so a caller
+ * keeps the token's `elevation` there instead.
+ */
+export declare const supportsBoxShadow: () => boolean;
+/**
+ * A shadow token as a CSS `boxShadow` string, or `undefined` when the token
+ * draws nothing or its colour is not a hex value this can fold the opacity
+ * into.
+ *
+ * The legacy `shadow*` props are cast from the view's own layer, so on iOS
+ * `overflow: 'hidden'` clips them away entirely, and Android ignores all of
+ * them except `elevation`. A `boxShadow` survives the clip on iOS and draws
+ * the same blurred shadow on Android, so one token looks alike on both.
+ * `shadowRadius` is Core Animation's blur, about half of a CSS blur radius.
+ */
+export declare const toBoxShadow: (def: ViewStyle) => string | undefined;
+//# 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/squircle.d.ts

@@ -0,0 +1,65 @@
+/**
+ * Smooth ("squircle") corners as an SVG path.
+ *
+ * iOS draws Apple's continuous curve natively (`borderCurve: 'continuous'`,
+ * see `./corners`). Android has no such style, so the components draw the
+ * shape themselves with react-native-svg and this path.
+ *
+ * Ported from figma-squircle 1.1.0 by Tien Pham (MIT licence, copyright
+ * 2021, https://github.com/phamfoo/figma-squircle), which follows Figma's
+ * "Desperately seeking squircles" article and MartinRGB's approximation.
+ * Only the uniform-radius branch is kept: the components draw the shape
+ * only when all four corners agree and leave the platform's own corner in
+ * place otherwise. The curve is Figma's, not Apple's; the two are close
+ * but not identical.
+ */
+/** Figma's "iOS" corner-smoothing preset. */
+export declare const SQUIRCLE_SMOOTHING = 0.6;
+export interface SquirclePathParams {
+    width: number;
+    height: number;
+    /** Corner radius of the outer edge, before `inset`. */
+    radius: number;
+    /** 0 is a plain rounded rectangle, 1 the fullest curve. Default `SQUIRCLE_SMOOTHING`. */
+    smoothing?: number;
+    /**
+     * Shrinks the path on every side, for a stroke: a stroke of width `w`
+     * drawn on a path inset by `w / 2` lands its outer edge on the bounds.
+     */
+    inset?: number;
+}
+/**
+ * Below this radius the curve is not worth an overlay: the squircle bulges
+ * past the circle by about a sixth of the radius at the diagonal (1 dp at
+ * 6 dp, computed from the path), which is under a device pixel on most
+ * screens. Checkbox corners and small chips stay native.
+ */
+export declare const SQUIRCLE_MIN_RADIUS = 6;
+/**
+ * Whether a squircle is worth drawing for this box: a radius under
+ * `SQUIRCLE_MIN_RADIUS` changes nothing a user can see, and once the radius
+ * reaches half the shorter side (a pill) there is no straight run left for
+ * the curve to blend into.
+ */
+export declare const squircleApplies: (width: number, height: number, radius: number) => boolean;
+/**
+ * The native corner radius an OPAQUE host keeps under the overlay.
+ *
+ * Figma's squircle sits inside the circle of the same radius: it keeps the
+ * circle's arc at the diagonal and cuts deeper along the tangents. A host
+ * that must keep an opaque native background (an elevated surface, whose
+ * Android shadow is cast from its own outline) would therefore show its
+ * circular corner peeking out around the shape. Doubling the native radius
+ * pushes that circle inside the squircle everywhere (checked numerically at
+ * 1.8x and above); the shadow follows the deeper corner with no visible
+ * change. Capped at half the shorter side, as a pill would be.
+ */
+export declare const squircleHostRadius: (width: number, height: number, radius: number) => number;
+/**
+ * The closed path of a smooth-cornered rectangle whose bounds are
+ * `(inset, inset)` to `(width - inset, height - inset)`, drawn clockwise
+ * from the top edge. Every corner shares one radius; the radius and the
+ * smoothing are capped so the curve fits the box (Figma's own behaviour).
+ */
+export declare function squirclePath({ width, height, radius, smoothing, inset }: SquirclePathParams): string;
+//# sourceMappingURL=squircle.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/AmountSlider/AmountSlider.d.ts

@@ -0,0 +1,60 @@
+import type { View as RNView, StyleProp, TextStyle, ViewStyle } from 'react-native';
+import type { HapticType } from '../../utils/index.js';
+import type { SliderSize, SliderTone, SliderVariant } from '../Slider/index.js';
+/**
+ * How the big value is scaled for reading.
+ *
+ * - `indian`: Thousand, Lakh and Crore (`₹ 5 Lakh`, `₹ 1.25 Crore`).
+ * - `none`: the whole number with Indian digit grouping (`₹ 5,00,000`).
+ */
+export type AmountSliderUnits = 'indian' | 'none';
+export interface AmountSliderProps {
+    value?: number;
+    defaultValue?: number;
+    onChange?: (value: number) => void;
+    min?: number;
+    max?: number;
+    step?: number;
+    disabled?: boolean;
+    tone?: SliderTone;
+    size?: SliderSize;
+    /** The slider's look. Default `'inset'`, the design this component comes from. */
+    variant?: SliderVariant;
+    /** Drawn before the big value. Default `'₹'`; pass `''` for a plain number. */
+    prefix?: string;
+    /** Default `'indian'`. */
+    units?: AmountSliderUnits;
+    /**
+     * Text of the input box when it is not being edited. Default: INR with
+     * Indian grouping and no decimals (`₹5,00,000`).
+     */
+    formatInput?: (value: number) => string;
+    /**
+     * Duration in ms of one digit roll. Default `theme.motion.duration.normal`,
+     * which the ThemeProvider collapses to 0 when the OS asks for reduced
+     * motion.
+     */
+    animationDuration?: number;
+    haptic?: HapticType | false;
+    /** Read out for the slider. The input box reads `inputAccessibilityLabel`. */
+    accessibilityLabel?: string;
+    /** Default `'Amount'`. */
+    inputAccessibilityLabel?: string;
+    style?: StyleProp<ViewStyle>;
+    headerStyle?: StyleProp<ViewStyle>;
+    valueStyle?: StyleProp<TextStyle>;
+    unitStyle?: StyleProp<TextStyle>;
+    inputStyle?: StyleProp<ViewStyle>;
+    sliderStyle?: StyleProp<ViewStyle>;
+    testID?: string;
+}
+interface Scaled {
+    amount: number;
+    unit: string;
+}
+/** Splits a value into the number and unit the header shows. */
+export declare const scaleAmount: (value: number, units: AmountSliderUnits) => Scaled;
+declare const AmountSlider: import("react").ForwardRefExoticComponent<AmountSliderProps & import("react").RefAttributes<RNView>>;
+export { AmountSlider };
+export default AmountSlider;
+//# sourceMappingURL=AmountSlider.d.ts.map

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

@@ -0,0 +1,3 @@
+export type { AmountSliderProps, AmountSliderUnits } from './AmountSlider.js';
+export { AmountSlider, default } from './AmountSlider.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/AppIcon/AppIcon.d.ts

@@ -0,0 +1,55 @@
+/**
+ * AppIcon — the design system's icon set, on mobile.
+ *
+ * Draws the same Iconsax glyphs webority-ui's `AppIcon` draws on the web,
+ * keyed by the same names, so a feature that says `<AppIcon name="send" />`
+ * looks identical in the portal and in the app. Two tiers, both generated
+ * from webority-ui by `scripts/sync-icons.mjs` (never hand-edit them):
+ *
+ *   - the curated set: the design system's semantic names ("plus",
+ *     "eye-off", "alert-circle") in `glyphs.g.ts` (linear, evaluated at
+ *     import) and `variants.g.ts` (the five other styles, on first use);
+ *   - the full Iconsax catalogue: every name, every style, as one module per
+ *     style and first letter under `catalog/`, reached through the static
+ *     require map in `catalog.g.ts`. A shard is evaluated the first time an
+ *     icon from it is drawn, so app start does not pay for the catalogue.
+ *
+ * Rendering: the bodies are 24x24 SVG markup with `currentColor`; we wrap
+ * them in an `<svg>` at the requested size, substitute the colour, and hand
+ * the string to react-native-svg's `SvgXml`.
+ */
+import React from 'react';
+import type { StyleProp, ViewStyle } from 'react-native';
+import type { IconName } from './catalog.g.js';
+import { ICON_NAMES } from './catalog.g.js';
+import type { CuratedIconName } from './glyphs.g.js';
+import { CURATED_ICON_NAMES } from './glyphs.g.js';
+import type { IconVariantName } from './variants.g.js';
+export type { CuratedIconName, IconName };
+export { CURATED_ICON_NAMES, ICON_NAMES };
+/** `linear` is the default Iconsax style; the rest come from the lazy modules. */
+export type IconVariant = 'linear' | IconVariantName;
+export type AppIconSize = 'xs' | 'sm' | 'md' | 'lg' | 'xl';
+/** Pixel sizes behind the size tokens; a raw number is accepted too. */
+export declare const APP_ICON_SIZES: Record<AppIconSize, number>;
+export interface AppIconProps {
+    /** Icon name; the union is generated from the design system's icon map plus the full catalogue. */
+    name: IconName;
+    /** Size token or a pixel number. Default `'md'` (22). */
+    size?: AppIconSize | number;
+    /** Any colour string. Default `theme.colors.text.primary`. */
+    color?: string;
+    /** Iconsax style. Default `'linear'`. Names missing in a style fall back to linear. */
+    variant?: IconVariant;
+    style?: StyleProp<ViewStyle>;
+    /** Set when the icon carries meaning on its own; decorative icons stay silent for screen readers. */
+    accessibilityLabel?: string;
+    testID?: string;
+}
+/** Resolve the SVG body for a name + variant, or null when the name is unknown. */
+export declare const resolveGlyph: (name: string, variant?: IconVariant) => string | null;
+/** Build the complete SVG document AppIcon hands to react-native-svg. */
+export declare const buildIconXml: (body: string, size: number, color: string) => string;
+export declare const AppIcon: React.FC<AppIconProps>;
+export default AppIcon;
+//# sourceMappingURL=AppIcon.d.ts.map

package/lib/typescript/module/components/AppIcon/catalog/bold/a.g.d.ts

@@ -0,0 +1,2 @@
+export declare const SHARD: Record<string, string>;
+//# sourceMappingURL=a.g.d.ts.map

package/lib/typescript/module/components/AppIcon/catalog/bold/b.g.d.ts

@@ -0,0 +1,2 @@
+export declare const SHARD: Record<string, string>;
+//# sourceMappingURL=b.g.d.ts.map

package/lib/typescript/module/components/AppIcon/catalog/bold/c.g.d.ts

@@ -0,0 +1,2 @@
+export declare const SHARD: Record<string, string>;
+//# sourceMappingURL=c.g.d.ts.map

package/lib/typescript/module/components/AppIcon/catalog/bold/d.g.d.ts

@@ -0,0 +1,2 @@
+export declare const SHARD: Record<string, string>;
+//# sourceMappingURL=d.g.d.ts.map