everkit-ui 0.1.0

package/dist/typescript/module/src/components/Input.d.ts

@@ -0,0 +1,50 @@
+/**
+ * Input — theme-agnostic labeled text field.
+ *
+ * Usage contract (carried over from the pilot consumers):
+ * - Do NOT wrap consumers in a `TouchableWithoutFeedback` or a full-screen
+ *   `Pressable onPress={Keyboard.dismiss}` — both swallow the first tap on iOS
+ *   (the "needs two taps to focus" bug).
+ * - The enclosing `ScrollView` / `FlatList` must set
+ *   `keyboardShouldPersistTaps="always"` so taps on inputs are not eaten while
+ *   the keyboard is open.
+ */
+import type React from 'react';
+import { type StyleProp, type TextInputProps, type ViewStyle } from 'react-native';
+export interface InputProps extends Omit<TextInputProps, 'className'> {
+    label?: string;
+    placeholder?: string;
+    value?: string;
+    onChangeText?: (text: string) => void;
+    error?: string;
+    leftIcon?: React.ReactNode;
+    rightIcon?: React.ReactNode;
+    disabled?: boolean;
+    /** Show a spinner in place of the field (e.g. while a photo scan fills it). */
+    loading?: boolean;
+    multiline?: boolean;
+    secureTextEntry?: boolean;
+    keyboardType?: TextInputProps['keyboardType'];
+    /** Optional inline style override, merged last so callers can retune layout. */
+    style?: StyleProp<ViewStyle>;
+}
+/**
+ * Theme-agnostic labeled field.
+ *
+ * Every colour comes INLINE from {@link useColors}: the container fills with
+ * `bg.secondary`, the border is `border.default` (or `semantic.error` when
+ * `error` is set), the label is `text.secondary`, the typed text is
+ * `text.primary`, and `placeholderTextColor` is `text.tertiary`. The field font
+ * also comes from the theme — `fontFamily` from `typography.fontFamily['body-md']`
+ * plus the `body-md` size/leading geometry — never a `font-*` className (those
+ * don't resolve reliably on native). Layout (flex, padding, radius) is applied
+ * INLINE from the library-owned {@link SPACE}/{@link RADIUS} scale, so the field
+ * renders with no NativeWind setup in the consumer; `style` is an inline
+ * override merged last.
+ *
+ * The multiline-vs-single-line geometry is the pure lifted {@link resolveInputStyle}
+ * helper. `loading` swaps the field for a {@link Spinner} (the library's own
+ * primitive) rather than coupling to an app's "reading…" indicator.
+ */
+export declare function Input({ label, placeholder, value, onChangeText, error, leftIcon, rightIcon, disabled, loading, multiline, secureTextEntry, keyboardType, style, ...rest }: InputProps): import("react/jsx-runtime").JSX.Element;
+//# sourceMappingURL=Input.d.ts.map

package/dist/typescript/module/src/components/Input.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Input.d.ts","sourceRoot":"","sources":["../../../../../src/components/Input.tsx"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AACH,OAAO,KAAK,KAAK,MAAM,OAAO,CAAA;AAC9B,OAAO,EAGL,KAAK,SAAS,EACd,KAAK,cAAc,EAEnB,KAAK,SAAS,EACf,MAAM,cAAc,CAAA;AAYrB,MAAM,WAAW,UAAW,SAAQ,IAAI,CAAC,cAAc,EAAE,WAAW,CAAC;IACnE,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,WAAW,CAAC,EAAE,MAAM,CAAA;IACpB,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,YAAY,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,CAAA;IACrC,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,QAAQ,CAAC,EAAE,KAAK,CAAC,SAAS,CAAA;IAC1B,SAAS,CAAC,EAAE,KAAK,CAAC,SAAS,CAAA;IAC3B,QAAQ,CAAC,EAAE,OAAO,CAAA;IAClB,+EAA+E;IAC/E,OAAO,CAAC,EAAE,OAAO,CAAA;IACjB,SAAS,CAAC,EAAE,OAAO,CAAA;IACnB,eAAe,CAAC,EAAE,OAAO,CAAA;IACzB,YAAY,CAAC,EAAE,cAAc,CAAC,cAAc,CAAC,CAAA;IAC7C,gFAAgF;IAChF,KAAK,CAAC,EAAE,SAAS,CAAC,SAAS,CAAC,CAAA;CAC7B;AAMD;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,KAAK,CAAC,EACpB,KAAK,EACL,WAAW,EACX,KAAK,EACL,YAAY,EACZ,KAAK,EACL,QAAQ,EACR,SAAS,EACT,QAAgB,EAChB,OAAe,EACf,SAAiB,EACjB,eAAe,EACf,YAAY,EACZ,KAAK,EACL,GAAG,IAAI,EACR,EAAE,UAAU,2CAmFZ"}

package/dist/typescript/module/src/components/KeyboardAware.d.ts

@@ -0,0 +1,27 @@
+import type { ReactNode } from 'react';
+import type { ViewStyle } from 'react-native';
+export interface KeyboardAwareProps {
+    children: ReactNode;
+    /**
+     * Overrides the default `{ flex: 1 }`. Most form screens want the default —
+     * pass a style only for bottom-sheet-style hosts that must hug their content.
+     */
+    style?: ViewStyle;
+    /** Pixels added between the keyboard top and the bottom of the avoided view. */
+    keyboardVerticalOffset?: number;
+    /** Set to `false` to turn the avoider into a passthrough. Defaults to `true`. */
+    enabled?: boolean;
+}
+/**
+ * The single allowed `KeyboardAvoidingView` callsite — a thin wrapper that bakes
+ * in the platform guard so screens never hardcode `behavior` and drift.
+ *
+ * The decision (iOS `'padding'`, Android `undefined`, default `{ flex: 1 }`,
+ * `enabled` default `true`) lives entirely in the pure lifted
+ * {@link resolveKeyboardAwareProps} helper. `behavior` is deliberately NOT part
+ * of the public API — `'padding'` on Android stacks with the system window
+ * adjustment and double-shifts, so callers cannot override it. Carries NO
+ * color/font of its own.
+ */
+export declare function KeyboardAware({ children, style, keyboardVerticalOffset, enabled, }: KeyboardAwareProps): import("react/jsx-runtime").JSX.Element;
+//# sourceMappingURL=KeyboardAware.d.ts.map

package/dist/typescript/module/src/components/KeyboardAware.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"KeyboardAware.d.ts","sourceRoot":"","sources":["../../../../../src/components/KeyboardAware.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,OAAO,CAAA;AACtC,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,cAAc,CAAA;AAI7C,MAAM,WAAW,kBAAkB;IACjC,QAAQ,EAAE,SAAS,CAAA;IACnB;;;OAGG;IACH,KAAK,CAAC,EAAE,SAAS,CAAA;IACjB,gFAAgF;IAChF,sBAAsB,CAAC,EAAE,MAAM,CAAA;IAC/B,iFAAiF;IACjF,OAAO,CAAC,EAAE,OAAO,CAAA;CAClB;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,aAAa,CAAC,EAC5B,QAAQ,EACR,KAAK,EACL,sBAAsB,EACtB,OAAO,GACR,EAAE,kBAAkB,2CAkBpB"}

package/dist/typescript/module/src/components/KeyboardScrollView.d.ts

@@ -0,0 +1,61 @@
+import { type ReactNode, type Ref } from 'react';
+import type { ScrollViewProps, StyleProp, ViewStyle } from 'react-native';
+import { ScrollView } from 'react-native';
+export interface KeyboardScrollViewProps {
+    children: ReactNode;
+    /** Forwarded to the inner ScrollView's `contentContainerStyle`. */
+    contentContainerStyle?: StyleProp<ViewStyle>;
+    /**
+     * NativeWind classes forwarded to the inner ScrollView's
+     * `contentContainerClassName`. Use this for layout tokens (e.g.
+     * `"px-6-ds flex-grow justify-center"`) instead of raw pixels.
+     */
+    contentContainerClassName?: string;
+    /** Forwarded to the inner ScrollView's `style`. Defaults to `{ flex: 1 }`. */
+    style?: StyleProp<ViewStyle>;
+    /** Forwarded to the underlying KeyboardAvoidingView. */
+    keyboardVerticalOffset?: number;
+    /**
+     * Default `true`. Set to `false` for nested screens that already sit inside a
+     * `<KeyboardAware>` and would otherwise double-shift on Android. Rare path.
+     */
+    enableKeyboardAvoidance?: boolean;
+    /** Forwarded to the inner ScrollView (RN's own `refreshControl` type). */
+    refreshControl?: ScrollViewProps['refreshControl'];
+    /** Forwarded to the inner ScrollView. */
+    showsVerticalScrollIndicator?: boolean;
+    /**
+     * iOS: auto-inset the scroll content for the keyboard and keep the focused
+     * input scrolled into view. Use this INSTEAD of the KAV for forms — pair it
+     * with `enableKeyboardAvoidance={false}` so the two don't double-shift.
+     */
+    automaticallyAdjustKeyboardInsets?: boolean;
+    /** Forwarded ScrollView ref. */
+    scrollRef?: Ref<ScrollView>;
+}
+/**
+ * Theme-agnostic "scroll body with keyboard avoider" — the ONE place
+ * TextInput-bearing screens are handled. Carries NO color/font of its own; all
+ * the keyboard rules live in the pure lifted {@link resolveKeyboardScrollViewProps}
+ * (the two locked scroll knobs) and {@link resolveKeyboardGapScrollTarget} (the
+ * iOS gap nudge).
+ *
+ * Behaviour baked in once:
+ *  - The first tap on a `<TextInput>` opens the keyboard (`keyboardShouldPersistTaps="always"`,
+ *    New-Arch-safe; no blanket ancestor `Pressable`, which starves child gestures).
+ *  - Tapping empty space while the keyboard is up dismisses it — a gesture-handler
+ *    Tap gated on `Keyboard.isVisible()`, so it never eats the first-tap focus.
+ *  - Dragging the body dismisses on BOTH platforms (`onScrollBeginDrag`), and on
+ *    iOS `keyboardDismissMode="interactive"` rides the keyboard off-screen.
+ *  - With `automaticallyAdjustKeyboardInsets`, a guaranteed `KEYBOARD_INPUT_GAP`
+ *    (12pt) is kept between the focused input and the keyboard frame (incl. the
+ *    iOS QuickType bar), which the native inset code alone leaves flush.
+ *
+ * IMPORTANT — do NOT put a sticky CTA inside this component. Render it as a
+ * SIBLING after `<KeyboardScrollView>` (e.g. via `<StickyBottomBar>`) so it stays
+ * anchored to the bottom and hides under the keyboard while typing. Putting it
+ * inside the avoider pushes the CTA UP over the body — the exact bug this exists
+ * to prevent.
+ */
+export declare function KeyboardScrollView({ children, contentContainerStyle, contentContainerClassName, style, keyboardVerticalOffset, enableKeyboardAvoidance, refreshControl, showsVerticalScrollIndicator, automaticallyAdjustKeyboardInsets, scrollRef, }: KeyboardScrollViewProps): import("react/jsx-runtime").JSX.Element;
+//# sourceMappingURL=KeyboardScrollView.d.ts.map

package/dist/typescript/module/src/components/KeyboardScrollView.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"KeyboardScrollView.d.ts","sourceRoot":"","sources":["../../../../../src/components/KeyboardScrollView.tsx"],"names":[],"mappings":"AAAA,OAAO,EAML,KAAK,SAAS,EACd,KAAK,GAAG,EACT,MAAM,OAAO,CAAA;AACd,OAAO,KAAK,EAIV,eAAe,EACf,SAAS,EACT,SAAS,EACV,MAAM,cAAc,CAAA;AACrB,OAAO,EAAsB,UAAU,EAAa,MAAM,cAAc,CAAA;AAQxE,MAAM,WAAW,uBAAuB;IACtC,QAAQ,EAAE,SAAS,CAAA;IACnB,mEAAmE;IACnE,qBAAqB,CAAC,EAAE,SAAS,CAAC,SAAS,CAAC,CAAA;IAC5C;;;;OAIG;IACH,yBAAyB,CAAC,EAAE,MAAM,CAAA;IAClC,8EAA8E;IAC9E,KAAK,CAAC,EAAE,SAAS,CAAC,SAAS,CAAC,CAAA;IAC5B,wDAAwD;IACxD,sBAAsB,CAAC,EAAE,MAAM,CAAA;IAC/B;;;OAGG;IACH,uBAAuB,CAAC,EAAE,OAAO,CAAA;IACjC,0EAA0E;IAC1E,cAAc,CAAC,EAAE,eAAe,CAAC,gBAAgB,CAAC,CAAA;IAClD,yCAAyC;IACzC,4BAA4B,CAAC,EAAE,OAAO,CAAA;IACtC;;;;OAIG;IACH,iCAAiC,CAAC,EAAE,OAAO,CAAA;IAC3C,gCAAgC;IAChC,SAAS,CAAC,EAAE,GAAG,CAAC,UAAU,CAAC,CAAA;CAC5B;AAED;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,wBAAgB,kBAAkB,CAAC,EACjC,QAAQ,EACR,qBAAqB,EACrB,yBAAyB,EACzB,KAAK,EACL,sBAAsB,EACtB,uBAAuB,EACvB,cAAc,EACd,4BAA4B,EAC5B,iCAAiC,EACjC,SAAS,GACV,EAAE,uBAAuB,2CA8GzB"}

package/dist/typescript/module/src/components/LegalBulletList.d.ts

@@ -0,0 +1,24 @@
+import { type StyleProp, type ViewStyle } from 'react-native';
+export interface LegalBulletListProps {
+    items: string[];
+    /**
+     * Spacing override for the list container, merged last so callers can retune
+     * layout. Defaults to the dense privacy / terms list spacing
+     * (`gap: SPACE['1.5']`, `marginTop: SPACE['1']`). Pass e.g. `{ gap: SPACE['3'] }`
+     * for a looser variant.
+     */
+    style?: StyleProp<ViewStyle>;
+}
+/**
+ * Theme-agnostic bulleted list — `• {item}` lines in `body-md`. Used by the
+ * legal screens for "you agree not to…" / "we collect…" lists.
+ *
+ * Colour comes INLINE from {@link useColors}: the bullet is `brand.primary` and
+ * the item text is `text.secondary` (the pilot consumer's var-backed
+ * `text-text-secondary` class is replaced with an inline colour). Layout (gap +
+ * margin) is applied INLINE from the library-owned {@link SPACE} scale, so the
+ * list renders with no NativeWind setup in the consumer; `style` is an inline
+ * override merged last.
+ */
+export declare function LegalBulletList({ items, style }: LegalBulletListProps): import("react/jsx-runtime").JSX.Element;
+//# sourceMappingURL=LegalBulletList.d.ts.map

package/dist/typescript/module/src/components/LegalBulletList.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"LegalBulletList.d.ts","sourceRoot":"","sources":["../../../../../src/components/LegalBulletList.tsx"],"names":[],"mappings":"AAAA,OAAO,EAAQ,KAAK,SAAS,EAAE,KAAK,SAAS,EAAE,MAAM,cAAc,CAAA;AAKnE,MAAM,WAAW,oBAAoB;IACnC,KAAK,EAAE,MAAM,EAAE,CAAA;IACf;;;;;OAKG;IACH,KAAK,CAAC,EAAE,SAAS,CAAC,SAAS,CAAC,CAAA;CAC7B;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,eAAe,CAAC,EAAE,KAAK,EAAE,KAAK,EAAE,EAAE,oBAAoB,2CAgBrE"}

package/dist/typescript/module/src/components/LegalSection.d.ts

@@ -0,0 +1,34 @@
+import { type StyleProp, type ViewStyle } from 'react-native';
+export interface LegalSubSection {
+    label: string;
+    body: string;
+}
+export interface LegalSectionProps {
+    heading: string;
+    /** Paragraph(s) shown above bullets / sub-sections. */
+    body: string | string[];
+    /** Optional bullet list rendered after `body`. */
+    bullets?: string[];
+    /** Optional named sub-blocks rendered after `body` (e.g. third-party services). */
+    subSections?: LegalSubSection[];
+    /** Optional paragraph(s) shown after bullets / sub-sections. */
+    footer?: string | string[];
+    /** Optional inline style override, merged last so callers can retune layout. */
+    style?: StyleProp<ViewStyle>;
+}
+/**
+ * Theme-agnostic legal section — one block of a privacy / terms screen: a
+ * `heading-lg` title, body paragraph(s), an optional {@link LegalBulletList},
+ * optional named sub-sections, and optional footer paragraph(s). This is the
+ * generic union of every shape espresso's and tea-companion's legal screens use.
+ *
+ * Colour comes INLINE from {@link useColors}: the heading + sub-section labels
+ * default to `text.primary` (via {@link Text}) and all body/footer copy is
+ * `text.secondary` (the pilot consumer's var-backed `text-text-secondary` class
+ * is replaced with an inline colour per the one styling rule). Layout (gaps +
+ * margins) is applied INLINE from the library-owned {@link SPACE} scale, so the
+ * section renders with no NativeWind setup in the consumer; `style` is an inline
+ * override merged last.
+ */
+export declare function LegalSection({ heading, body, bullets, subSections, footer, style, }: LegalSectionProps): import("react/jsx-runtime").JSX.Element;
+//# sourceMappingURL=LegalSection.d.ts.map

package/dist/typescript/module/src/components/LegalSection.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"LegalSection.d.ts","sourceRoot":"","sources":["../../../../../src/components/LegalSection.tsx"],"names":[],"mappings":"AAAA,OAAO,EAAoB,KAAK,SAAS,EAAE,KAAK,SAAS,EAAE,MAAM,cAAc,CAAA;AAM/E,MAAM,WAAW,eAAe;IAC9B,KAAK,EAAE,MAAM,CAAA;IACb,IAAI,EAAE,MAAM,CAAA;CACb;AAED,MAAM,WAAW,iBAAiB;IAChC,OAAO,EAAE,MAAM,CAAA;IACf,uDAAuD;IACvD,IAAI,EAAE,MAAM,GAAG,MAAM,EAAE,CAAA;IACvB,kDAAkD;IAClD,OAAO,CAAC,EAAE,MAAM,EAAE,CAAA;IAClB,mFAAmF;IACnF,WAAW,CAAC,EAAE,eAAe,EAAE,CAAA;IAC/B,gEAAgE;IAChE,MAAM,CAAC,EAAE,MAAM,GAAG,MAAM,EAAE,CAAA;IAC1B,gFAAgF;IAChF,KAAK,CAAC,EAAE,SAAS,CAAC,SAAS,CAAC,CAAA;CAC7B;AASD;;;;;;;;;;;;;GAaG;AACH,wBAAgB,YAAY,CAAC,EAC3B,OAAO,EACP,IAAI,EACJ,OAAO,EACP,WAAW,EACX,MAAM,EACN,KAAK,GACN,EAAE,iBAAiB,2CAyCnB"}

package/dist/typescript/module/src/components/LikeButton.d.ts

@@ -0,0 +1,37 @@
+import React from 'react';
+import { type GestureResponderEvent } from 'react-native';
+export interface LikeButtonProps {
+    isLiked: boolean;
+    likeCount: number;
+    /** Toggle the liked state. Receives nothing; flip `isLiked` in the parent. */
+    onLikePress: () => void;
+    /**
+     * Optional — opens a "who liked this" list when the count is tapped. Receives
+     * the press event so a caller can `stopPropagation()` to keep an enclosing
+     * card press from also firing.
+     */
+    onLikeCountPress?: (e: GestureResponderEvent) => void;
+    /** Icon size in dp. Defaults to `16`. */
+    size?: number;
+    /**
+     * Fire a light haptic on like (press-in of an unliked heart). Defaults to
+     * `true`. Uses the OPTIONAL `expo-haptics` peer directly — a silent no-op when
+     * it isn't installed. Pass `false` to disable.
+     */
+    haptic?: boolean;
+    /** Override the liked tint. Defaults to `colors.semantic.error`. */
+    likedColor?: string;
+}
+/**
+ * Theme-agnostic heart + count pair — the "like" affordance for a feed-style
+ * card. Owns the pop animation, an optional haptic, and the count accessibility
+ * label; stays a pure visual primitive, so callers decide what each Pressable
+ * does.
+ *
+ * Colour comes INLINE from {@link useColors}: a liked heart fills with
+ * `semantic.error` (overridable via `likedColor`) and an unliked heart is an
+ * outline in `text.tertiary`; the count shares the same tint. Haptics are
+ * decoupled from any app hook via the optional `expo-haptics` peer.
+ */
+export declare const LikeButton: React.NamedExoticComponent<LikeButtonProps>;
+//# sourceMappingURL=LikeButton.d.ts.map

package/dist/typescript/module/src/components/LikeButton.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"LikeButton.d.ts","sourceRoot":"","sources":["../../../../../src/components/LikeButton.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAsB,MAAM,OAAO,CAAA;AAC1C,OAAO,EAAmB,KAAK,qBAAqB,EAAE,MAAM,cAAc,CAAA;AAc1E,MAAM,WAAW,eAAe;IAC9B,OAAO,EAAE,OAAO,CAAA;IAChB,SAAS,EAAE,MAAM,CAAA;IACjB,8EAA8E;IAC9E,WAAW,EAAE,MAAM,IAAI,CAAA;IACvB;;;;OAIG;IACH,gBAAgB,CAAC,EAAE,CAAC,CAAC,EAAE,qBAAqB,KAAK,IAAI,CAAA;IACrD,yCAAyC;IACzC,IAAI,CAAC,EAAE,MAAM,CAAA;IACb;;;;OAIG;IACH,MAAM,CAAC,EAAE,OAAO,CAAA;IAChB,oEAAoE;IACpE,UAAU,CAAC,EAAE,MAAM,CAAA;CACpB;AAED;;;;;;;;;;GAUG;AACH,eAAO,MAAM,UAAU,6CA4DrB,CAAA"}

package/dist/typescript/module/src/components/LoadingScreen.d.ts

@@ -0,0 +1,17 @@
+import { type StyleProp, type ViewStyle } from 'react-native';
+export interface LoadingScreenProps {
+    /** Optional inline style override, merged last so callers can retune layout. */
+    style?: StyleProp<ViewStyle>;
+}
+/**
+ * Theme-agnostic full-bleed loading body — a centered spinner on a solid
+ * surface, used as the `isLoading` state of `<FormScreen>` / `<DetailScreen>`
+ * (the header stays painted above it).
+ *
+ * Color comes INLINE from {@link useColors}: the fill is `bg.primary` and the
+ * indicator is `brand.primary`. Layout (flex + centering) is applied INLINE so
+ * the screen renders with no NativeWind setup in the consumer; `style` is an
+ * inline override merged last.
+ */
+export declare function LoadingScreen({ style }?: LoadingScreenProps): import("react/jsx-runtime").JSX.Element;
+//# sourceMappingURL=LoadingScreen.d.ts.map

package/dist/typescript/module/src/components/LoadingScreen.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"LoadingScreen.d.ts","sourceRoot":"","sources":["../../../../../src/components/LoadingScreen.tsx"],"names":[],"mappings":"AAAA,OAAO,EAA2B,KAAK,SAAS,EAAE,KAAK,SAAS,EAAE,MAAM,cAAc,CAAA;AAGtF,MAAM,WAAW,kBAAkB;IACjC,gFAAgF;IAChF,KAAK,CAAC,EAAE,SAAS,CAAC,SAAS,CAAC,CAAA;CAC7B;AAED;;;;;;;;;GASG;AACH,wBAAgB,aAAa,CAAC,EAAE,KAAK,EAAE,GAAE,kBAAuB,2CAa/D"}

package/dist/typescript/module/src/components/NotesCard.d.ts

@@ -0,0 +1,17 @@
+export interface NotesCardProps {
+    /** Section heading at the top of the card. */
+    heading: string;
+    /** Body text — typically free-form notes. */
+    body: string;
+}
+/**
+ * Theme-agnostic notes card — a soft surface with a heading and a body
+ * paragraph (the "Tasting Notes" / "Notes" block pattern).
+ *
+ * Colour comes INLINE from {@link useColors}: the surface is `bg.card`, the
+ * heading defaults to `text.primary` (via {@link Text}), and the body is
+ * `text.secondary`. Elevation comes from the themed {@link useShadows} `sm`
+ * preset so each theme tunes its own dark-mode shadow.
+ */
+export declare function NotesCard({ heading, body }: NotesCardProps): import("react/jsx-runtime").JSX.Element;
+//# sourceMappingURL=NotesCard.d.ts.map

package/dist/typescript/module/src/components/NotesCard.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"NotesCard.d.ts","sourceRoot":"","sources":["../../../../../src/components/NotesCard.tsx"],"names":[],"mappings":"AAIA,MAAM,WAAW,cAAc;IAC7B,8CAA8C;IAC9C,OAAO,EAAE,MAAM,CAAA;IACf,6CAA6C;IAC7C,IAAI,EAAE,MAAM,CAAA;CACb;AAED;;;;;;;;GAQG;AACH,wBAAgB,SAAS,CAAC,EAAE,OAAO,EAAE,IAAI,EAAE,EAAE,cAAc,2CAe1D"}

package/dist/typescript/module/src/components/OnboardingSlide.d.ts

@@ -0,0 +1,31 @@
+import type { ReactNode } from 'react';
+import { type StyleProp, type ViewStyle } from 'react-native';
+export interface OnboardingSlideProps {
+    /** Icon or illustration rendered inside the accent circle. */
+    icon: ReactNode;
+    /** Background colour of the accent circle (e.g. a `colors.brand.*Light` tint). */
+    accent: string;
+    /** Display heading shown beneath the circle. */
+    heading: string;
+    /** Supporting paragraph beneath the heading. */
+    body: string;
+    /** Outer width — pass the screen width so the slide snaps inside a paged FlatList. */
+    width: number;
+    /** Optional inline style override, merged last so callers can retune layout. */
+    style?: StyleProp<ViewStyle>;
+}
+/**
+ * Theme-agnostic onboarding pager slide: an accent-coloured circle holding an
+ * icon, a heading, and a body paragraph. Rendered inside a paged horizontal
+ * FlatList (the app owns the pager + dots).
+ *
+ * Colour comes INLINE: the circle fill is the caller-supplied `accent` (a theme
+ * value, typically `colors.brand.*Light`), the heading defaults to `text.primary`
+ * (via {@link Text}), and the body is `text.secondary` from {@link useColors}.
+ * Layout (flex, padding, alignment, margins) is applied INLINE from the
+ * library-owned {@link SPACE} scale, so the slide renders with no NativeWind
+ * setup in the consumer; `width` is the paging geometry and `style` is an inline
+ * override merged last.
+ */
+export declare function OnboardingSlide({ icon, accent, heading, body, width, style, }: OnboardingSlideProps): import("react/jsx-runtime").JSX.Element;
+//# sourceMappingURL=OnboardingSlide.d.ts.map

package/dist/typescript/module/src/components/OnboardingSlide.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"OnboardingSlide.d.ts","sourceRoot":"","sources":["../../../../../src/components/OnboardingSlide.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,OAAO,CAAA;AACtC,OAAO,EAAQ,KAAK,SAAS,EAAE,KAAK,SAAS,EAAE,MAAM,cAAc,CAAA;AAOnE,MAAM,WAAW,oBAAoB;IACnC,8DAA8D;IAC9D,IAAI,EAAE,SAAS,CAAA;IACf,kFAAkF;IAClF,MAAM,EAAE,MAAM,CAAA;IACd,gDAAgD;IAChD,OAAO,EAAE,MAAM,CAAA;IACf,gDAAgD;IAChD,IAAI,EAAE,MAAM,CAAA;IACZ,sFAAsF;IACtF,KAAK,EAAE,MAAM,CAAA;IACb,gFAAgF;IAChF,KAAK,CAAC,EAAE,SAAS,CAAC,SAAS,CAAC,CAAA;CAC7B;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,eAAe,CAAC,EAC9B,IAAI,EACJ,MAAM,EACN,OAAO,EACP,IAAI,EACJ,KAAK,EACL,KAAK,GACN,EAAE,oBAAoB,2CAoCtB"}

package/dist/typescript/module/src/components/PhotoPicker.d.ts

@@ -0,0 +1,37 @@
+import { type StyleProp, type ViewStyle } from 'react-native';
+export interface PhotoPickerProps {
+    /** Current photo URIs (remote or local), in order. */
+    photos: string[];
+    /** Cap on photo count — the add tile hides once it's reached. Default `1`. */
+    maxPhotos?: number;
+    /**
+     * The add tile was tapped. The consumer launches its own picker (camera /
+     * gallery, permissions, compression — all platform concerns the library
+     * stays out of) and appends the result to `photos`.
+     */
+    onAddPress: () => void;
+    /** The remove badge was tapped for the photo at `index`. */
+    onRemove: (index: number) => void;
+    /** Thumbnail edge in px. Default `80`. */
+    thumbnailSize?: number;
+    /** Label under the add tile's camera icon. Default `'Add'`. */
+    addLabel?: string;
+    /** Inline layout override, merged onto the wrapping row. */
+    style?: StyleProp<ViewStyle>;
+}
+/**
+ * Theme-agnostic multi-photo grid — a wrapping row of thumbnails (each with a
+ * remove badge) plus an add tile that's shown until `maxPhotos` is reached.
+ *
+ * Headless about *picking*: it never touches `expo-image-picker`, permissions,
+ * or a source chooser. Tapping the add tile fires {@link onAddPress}, and the
+ * consumer runs its own pick flow and appends the URI; removing fires
+ * {@link onRemove} with the index. That keeps the platform/permission concern in
+ * the app and the visual grid here, reusable across sessions / teas / profiles.
+ *
+ * Colour comes INLINE from {@link useColors} (`bg.secondary` tiles,
+ * `border.default` frame, `semantic.error` remove badge, `text.inverse` glyph);
+ * spacing + radii from the {@link SPACE}/{@link RADIUS} scale.
+ */
+export declare function PhotoPicker({ photos, maxPhotos, onAddPress, onRemove, thumbnailSize, addLabel, style, }: PhotoPickerProps): import("react/jsx-runtime").JSX.Element;
+//# sourceMappingURL=PhotoPicker.d.ts.map

package/dist/typescript/module/src/components/PhotoPicker.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"PhotoPicker.d.ts","sourceRoot":"","sources":["../../../../../src/components/PhotoPicker.tsx"],"names":[],"mappings":"AAAA,OAAO,EAAmB,KAAK,SAAS,EAAE,KAAK,SAAS,EAAE,MAAM,cAAc,CAAA;AAO9E,MAAM,WAAW,gBAAgB;IAC/B,sDAAsD;IACtD,MAAM,EAAE,MAAM,EAAE,CAAA;IAChB,8EAA8E;IAC9E,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB;;;;OAIG;IACH,UAAU,EAAE,MAAM,IAAI,CAAA;IACtB,4DAA4D;IAC5D,QAAQ,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,IAAI,CAAA;IACjC,0CAA0C;IAC1C,aAAa,CAAC,EAAE,MAAM,CAAA;IACtB,+DAA+D;IAC/D,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,4DAA4D;IAC5D,KAAK,CAAC,EAAE,SAAS,CAAC,SAAS,CAAC,CAAA;CAC7B;AAKD;;;;;;;;;;;;;GAaG;AACH,wBAAgB,WAAW,CAAC,EAC1B,MAAM,EACN,SAAa,EACb,UAAU,EACV,QAAQ,EACR,aAAkB,EAClB,QAAgB,EAChB,KAAK,GACN,EAAE,gBAAgB,2CAoFlB"}

package/dist/typescript/module/src/components/PhotoStrip.d.ts

@@ -0,0 +1,32 @@
+import { type StyleProp, type ViewStyle } from 'react-native';
+export interface PhotoStripProps {
+    /** Photo URIs to render as horizontal thumbnails. */
+    photos: string[];
+    /** Fires with the 0-based index of the tapped thumbnail. */
+    onPhotoPress: (index: number) => void;
+    /** Optional section heading rendered above the strip. */
+    heading?: string;
+    /** Thumbnail size in points. Defaults to `160`. */
+    thumbnailSize?: number;
+    /**
+     * Offset added to the photo number announced for accessibility — set to `1`
+     * when the strip shows "extras" after a hero photo so the first thumbnail
+     * announces "View photo 2 fullscreen".
+     */
+    accessibilityIndexOffset?: number;
+    /** Optional inline style override, merged last so callers can retune layout. */
+    style?: StyleProp<ViewStyle>;
+}
+/**
+ * Theme-agnostic horizontal photo thumbnail strip. Tapping a thumbnail fires
+ * `onPhotoPress` with its index — the parent decides what happens (usually opens
+ * a fullscreen viewer; the library does not pull in an image-viewer dependency).
+ *
+ * Carries no colour of its own beyond the optional heading (`text.primary` via
+ * {@link Text}); thumbnails render through the library's {@link AppImage} so they
+ * get the shared cache policy. Layout (heading gap, thumbnail gap) is applied
+ * INLINE from the library-owned {@link SPACE} scale, so the strip renders with no
+ * NativeWind setup in the consumer; `style` is an inline override merged last.
+ */
+export declare function PhotoStrip({ photos, onPhotoPress, heading, thumbnailSize, accessibilityIndexOffset, style, }: PhotoStripProps): import("react/jsx-runtime").JSX.Element | null;
+//# sourceMappingURL=PhotoStrip.d.ts.map

package/dist/typescript/module/src/components/PhotoStrip.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"PhotoStrip.d.ts","sourceRoot":"","sources":["../../../../../src/components/PhotoStrip.tsx"],"names":[],"mappings":"AAAA,OAAO,EAA+B,KAAK,SAAS,EAAE,KAAK,SAAS,EAAE,MAAM,cAAc,CAAA;AAK1F,MAAM,WAAW,eAAe;IAC9B,qDAAqD;IACrD,MAAM,EAAE,MAAM,EAAE,CAAA;IAChB,4DAA4D;IAC5D,YAAY,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,IAAI,CAAA;IACrC,yDAAyD;IACzD,OAAO,CAAC,EAAE,MAAM,CAAA;IAChB,mDAAmD;IACnD,aAAa,CAAC,EAAE,MAAM,CAAA;IACtB;;;;OAIG;IACH,wBAAwB,CAAC,EAAE,MAAM,CAAA;IACjC,gFAAgF;IAChF,KAAK,CAAC,EAAE,SAAS,CAAC,SAAS,CAAC,CAAA;CAC7B;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,UAAU,CAAC,EACzB,MAAM,EACN,YAAY,EACZ,OAAO,EACP,aAAmB,EACnB,wBAA4B,EAC5B,KAAK,GACN,EAAE,eAAe,kDAiCjB"}

package/dist/typescript/module/src/components/PhotoViewer.d.ts

@@ -0,0 +1,35 @@
+/** A single viewable image. The bare `{ uri }` shape `react-native-image-viewing` expects. */
+export interface PhotoViewerImage {
+    uri: string;
+}
+export interface PhotoViewerProps {
+    /**
+     * Images to page through, as `{ uri }[]` or a plain `string[]` of URIs (the
+     * latter is normalised internally) — the consuming app injects the data.
+     */
+    images: PhotoViewerImage[] | string[];
+    /** Whether the lightbox is open. The parent owns this state. */
+    visible: boolean;
+    /** Index of the image shown first. Defaults to `0`. */
+    imageIndex?: number;
+    /** Fires when the viewer is dismissed (backdrop tap, swipe-down, or close button). */
+    onClose: () => void;
+    /** Fires with the 0-based index as the user pages between images. */
+    onIndexChange?: (index: number) => void;
+}
+/**
+ * Theme-agnostic fullscreen image lightbox — a thin wrapper over the optional
+ * `react-native-image-viewing` peer with a pure-black backdrop, swipe-to-close and
+ * double-tap-to-zoom, plus a custom header (index counter + close button).
+ *
+ * The backdrop is intrinsically black, so the header chrome is coloured from the
+ * theme's on-dark token ({@link useColors} `text.inverse`) for legibility; layout
+ * comes INLINE from {@link SPACE} / {@link RADIUS} and the safe-area inset. Side
+ * effects (open/close, paging) are injected via props — the parent owns `visible`,
+ * `imageIndex` and the data.
+ *
+ * `react-native-image-viewing` is an optional peer (see top of file); when it is
+ * absent the component renders nothing.
+ */
+export declare function PhotoViewer({ images, visible, imageIndex, onClose, onIndexChange }: PhotoViewerProps): import("react/jsx-runtime").JSX.Element | null;
+//# sourceMappingURL=PhotoViewer.d.ts.map

package/dist/typescript/module/src/components/PhotoViewer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"PhotoViewer.d.ts","sourceRoot":"","sources":["../../../../../src/components/PhotoViewer.tsx"],"names":[],"mappings":"AAoBA,8FAA8F;AAC9F,MAAM,WAAW,gBAAgB;IAC/B,GAAG,EAAE,MAAM,CAAA;CACZ;AAED,MAAM,WAAW,gBAAgB;IAC/B;;;OAGG;IACH,MAAM,EAAE,gBAAgB,EAAE,GAAG,MAAM,EAAE,CAAA;IACrC,gEAAgE;IAChE,OAAO,EAAE,OAAO,CAAA;IAChB,uDAAuD;IACvD,UAAU,CAAC,EAAE,MAAM,CAAA;IACnB,sFAAsF;IACtF,OAAO,EAAE,MAAM,IAAI,CAAA;IACnB,qEAAqE;IACrE,aAAa,CAAC,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,IAAI,CAAA;CACxC;AAOD;;;;;;;;;;;;;GAaG;AACH,wBAAgB,WAAW,CAAC,EAAE,MAAM,EAAE,OAAO,EAAE,UAAc,EAAE,OAAO,EAAE,aAAa,EAAE,EAAE,gBAAgB,kDAwBxG"}

package/dist/typescript/module/src/components/ProgressBar.d.ts

@@ -0,0 +1,43 @@
+import { type ReactNode } from 'react';
+import { type StyleProp, type ViewStyle } from 'react-native';
+export interface ProgressBarProps {
+    /** Fill ratio. Clamped to `0`–`1`. */
+    progress: number;
+    /** Optional caption shown on the left of the header row (e.g. a title). */
+    label?: string;
+    /** Optional caption shown on the right of the header row (e.g. a value). */
+    trailingLabel?: string;
+    /**
+     * Optional leading glyph rendered before `label` (the app passes its own
+     * lucide icon node — coloured by the caller).
+     */
+    icon?: ReactNode;
+    /** Override the fill colour. Defaults to `brand.primary`. */
+    color?: string;
+    /** Override the track (unfilled) colour. Defaults to `bg.secondary`. */
+    trackColor?: string;
+    /** Bar thickness in px. Defaults to `10`. */
+    height?: number;
+    /** Spring-animate the fill width on `progress` change. Defaults to `true`. */
+    animated?: boolean;
+    /** Optional inline style override, merged last so callers can retune layout. */
+    style?: StyleProp<ViewStyle>;
+}
+/**
+ * Theme-agnostic animated horizontal progress bar — a generic fill primitive.
+ * The header row (optional leading icon + `label`, with `trailingLabel` on the
+ * right) carries no domain meaning: names and values are injected by the caller.
+ *
+ * Colour comes INLINE from {@link useColors}: the fill defaults to
+ * `brand.primary` and the track to `bg.secondary`, both overridable via `color`
+ * / `trackColor`. The label tints from `color` (so it matches the fill) and the
+ * trailing label from `text.tertiary`. Layout (gaps + spacing) is applied INLINE
+ * from the library-owned {@link SPACE} scale, so the bar renders with no
+ * NativeWind setup in the consumer; `style` is an inline override merged last.
+ *
+ * When `animated` the fill width springs to `progress` on change (matching the
+ * source's `withSpring` feel); otherwise it snaps. `progress` is clamped to
+ * `0`–`1`.
+ */
+export declare function ProgressBar({ progress, label, trailingLabel, icon, color, trackColor, height, animated, style, }: ProgressBarProps): import("react/jsx-runtime").JSX.Element;
+//# sourceMappingURL=ProgressBar.d.ts.map

package/dist/typescript/module/src/components/ProgressBar.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ProgressBar.d.ts","sourceRoot":"","sources":["../../../../../src/components/ProgressBar.tsx"],"names":[],"mappings":"AAAA,OAAO,EAAa,KAAK,SAAS,EAAE,MAAM,OAAO,CAAA;AACjD,OAAO,EAAQ,KAAK,SAAS,EAAE,KAAK,SAAS,EAAE,MAAM,cAAc,CAAA;AAMnE,MAAM,WAAW,gBAAgB;IAC/B,sCAAsC;IACtC,QAAQ,EAAE,MAAM,CAAA;IAChB,2EAA2E;IAC3E,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,4EAA4E;IAC5E,aAAa,CAAC,EAAE,MAAM,CAAA;IACtB;;;OAGG;IACH,IAAI,CAAC,EAAE,SAAS,CAAA;IAChB,6DAA6D;IAC7D,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,wEAAwE;IACxE,UAAU,CAAC,EAAE,MAAM,CAAA;IACnB,6CAA6C;IAC7C,MAAM,CAAC,EAAE,MAAM,CAAA;IACf,8EAA8E;IAC9E,QAAQ,CAAC,EAAE,OAAO,CAAA;IAClB,gFAAgF;IAChF,KAAK,CAAC,EAAE,SAAS,CAAC,SAAS,CAAC,CAAA;CAC7B;AAKD;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,WAAW,CAAC,EAC1B,QAAQ,EACR,KAAK,EACL,aAAa,EACb,IAAI,EACJ,KAAK,EACL,UAAU,EACV,MAAuB,EACvB,QAAe,EACf,KAAK,GACN,EAAE,gBAAgB,2CAqElB"}

package/dist/typescript/module/src/components/ScreenGradient.d.ts

@@ -0,0 +1,25 @@
+import type { ReactNode } from 'react';
+import { type ViewStyle } from 'react-native';
+export interface ScreenGradientProps {
+    children: ReactNode;
+    /** Inline style merged onto the outer gradient (e.g. an extra `flex` rule). */
+    style?: ViewStyle;
+}
+/**
+ * Theme-agnostic full-screen background — the base every scaffold (`FormScreen`,
+ * `DetailScreen`, `AuthFormScreen`) wraps its content in.
+ *
+ * Color comes INLINE from {@link useColors}: the base stops are
+ * `colors.gradient.screen` (a `[string, string, ...]` tuple the theme owns), so
+ * the screen background follows any injected palette rather than a
+ * `bg-bg-primary` className (NativeWind's CSS-variable path doesn't resolve
+ * reliably on native — it left screens rendering plain white). A faint diagonal
+ * brand WASH is layered on top for depth; its color is DERIVED from
+ * `colors.brand.primary` at 10% via {@link hexToRgba} (never a literal brand
+ * rgba), fading to a generic `'transparent'`. Works in light and dark
+ * automatically.
+ *
+ * Usage: wrap a screen's content and put the (transparent) SafeAreaView inside.
+ */
+export declare function ScreenGradient({ children, style }: ScreenGradientProps): import("react/jsx-runtime").JSX.Element;
+//# sourceMappingURL=ScreenGradient.d.ts.map

package/dist/typescript/module/src/components/ScreenGradient.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ScreenGradient.d.ts","sourceRoot":"","sources":["../../../../../src/components/ScreenGradient.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,OAAO,CAAA;AACtC,OAAO,EAAc,KAAK,SAAS,EAAE,MAAM,cAAc,CAAA;AAKzD,MAAM,WAAW,mBAAmB;IAClC,QAAQ,EAAE,SAAS,CAAA;IACnB,+EAA+E;IAC/E,KAAK,CAAC,EAAE,SAAS,CAAA;CAClB;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,cAAc,CAAC,EAAE,QAAQ,EAAE,KAAK,EAAE,EAAE,mBAAmB,2CAwBtE"}

package/dist/typescript/module/src/components/ScreenHeader.d.ts

@@ -0,0 +1,48 @@
+import type { ReactNode } from 'react';
+import { type StyleProp, type ViewStyle } from 'react-native';
+export type ScreenHeaderVariant = 'detail' | 'form';
+export interface ScreenHeaderProps {
+    /**
+     * Big header copy. Optional because `variant="detail"` renders no title slot
+     * at all when omitted (a back-chevron-only header).
+     */
+    title?: string;
+    /** Small line below the title (e.g. a chat screen's "AI Assistant"). */
+    subtitle?: string;
+    /**
+     * Back-button handler. The consuming app passes its navigation callback here
+     * (e.g. `() => router.back()`); the library never imports a router. When
+     * omitted the chevron still renders but does nothing — pass `showBack={false}`
+     * (or `showBack={Boolean(onBack)}`) to hide it on screens with no back nav.
+     */
+    onBack?: () => void;
+    /** Render the back chevron. Defaults to `true`. */
+    showBack?: boolean;
+    /** Icon buttons / chips shown on the right of the header. */
+    rightActions?: ReactNode;
+    /**
+     * `'detail'` — no title slot when none is passed; larger/heavier title
+     * (`heading-lg`) when one is. `'form'` — plainer `display-sm` title. Controls
+     * title typography only. Defaults to `'detail'`.
+     */
+    variant?: ScreenHeaderVariant;
+    /** Optional inline style override, merged last so callers can retune layout. */
+    style?: StyleProp<ViewStyle>;
+}
+/**
+ * Theme-agnostic screen header — back chevron on the left, optional
+ * title + subtitle in the middle, optional right-action slot on the right.
+ * Safe-area is owned by the parent scaffold.
+ *
+ * Color comes INLINE from {@link useColors}: the chevron is `text.primary`, the
+ * title defaults to `text.primary` (via {@link Text}), and the subtitle is
+ * `text.secondary`. Layout (flex, padding, gap) is applied INLINE from the
+ * library-owned {@link SPACE} scale, so the header renders with no NativeWind
+ * setup in the consumer; `style` is an inline override merged last.
+ *
+ * Router-decoupled: `onBack` is a plain callback wired straight to the back
+ * Pressable's `onPress` — there is deliberately NO `expo-router` import and NO
+ * `router.back()` default. The consuming app supplies navigation.
+ */
+export declare function ScreenHeader({ title, subtitle, onBack, showBack, rightActions, variant, style, }: ScreenHeaderProps): import("react/jsx-runtime").JSX.Element;
+//# sourceMappingURL=ScreenHeader.d.ts.map

package/dist/typescript/module/src/components/ScreenHeader.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ScreenHeader.d.ts","sourceRoot":"","sources":["../../../../../src/components/ScreenHeader.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,OAAO,CAAA;AACtC,OAAO,EAA+B,KAAK,SAAS,EAAE,KAAK,SAAS,EAAE,MAAM,cAAc,CAAA;AAM1F,MAAM,MAAM,mBAAmB,GAAG,QAAQ,GAAG,MAAM,CAAA;AAEnD,MAAM,WAAW,iBAAiB;IAChC;;;OAGG;IACH,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,wEAAwE;IACxE,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB;;;;;OAKG;IACH,MAAM,CAAC,EAAE,MAAM,IAAI,CAAA;IACnB,mDAAmD;IACnD,QAAQ,CAAC,EAAE,OAAO,CAAA;IAClB,6DAA6D;IAC7D,YAAY,CAAC,EAAE,SAAS,CAAA;IACxB;;;;OAIG;IACH,OAAO,CAAC,EAAE,mBAAmB,CAAA;IAC7B,gFAAgF;IAChF,KAAK,CAAC,EAAE,SAAS,CAAC,SAAS,CAAC,CAAA;CAC7B;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,YAAY,CAAC,EAC3B,KAAK,EACL,QAAQ,EACR,MAAM,EACN,QAAe,EACf,YAAY,EACZ,OAAkB,EAClB,KAAK,GACN,EAAE,iBAAiB,2CAoCnB"}

package/dist/typescript/module/src/components/SearchInput.d.ts

@@ -0,0 +1,30 @@
+import { type StyleProp, type ViewStyle } from 'react-native';
+export interface SearchInputProps {
+    value: string;
+    onChangeText: (text: string) => void;
+    placeholder?: string;
+    /**
+     * Debounce in ms before `onChangeText` fires (the field updates instantly).
+     * Defaults to `300`. Pass `0` to fire on every keystroke.
+     */
+    debounceMs?: number;
+    /** Optional inline style override, merged last so callers can retune layout. */
+    style?: StyleProp<ViewStyle>;
+}
+/**
+ * Theme-agnostic debounced search field — a pill with a leading magnifier and a
+ * trailing clear button. The field updates immediately for a responsive feel
+ * while `onChangeText` is debounced (`debounceMs`) so list filtering doesn't run
+ * on every keystroke.
+ *
+ * Every colour comes INLINE from {@link useColors}: the pill fills with
+ * `bg.secondary`, the icons + placeholder are `text.tertiary`, and the typed
+ * text is `text.primary`. The field font comes from the theme's `body-md`
+ * variant (family + geometry) rather than a `font-*` className — the pilot
+ * consumer's hardcoded `font-quicksand-medium` is removed. Layout (flex,
+ * padding, radius) is applied INLINE from the library-owned {@link SPACE}/
+ * {@link RADIUS} scale, so the field renders with no NativeWind setup in the
+ * consumer; `style` is an inline override merged last.
+ */
+export declare function SearchInput({ value, onChangeText, placeholder, debounceMs, style, }: SearchInputProps): import("react/jsx-runtime").JSX.Element;
+//# sourceMappingURL=SearchInput.d.ts.map