@itiseeron/component-lib 1.0.0

package/dist/index.d.ts

@@ -0,0 +1,744 @@
+import React from 'react';
+import PropTypes from 'prop-types';
+
+declare function HelloWorld(): JSX.Element;
+
+type ThinButtonProps = {
+    testID?: string;
+    key?: any;
+    text?: String;
+    children?: React.ReactNode;
+    onclick?: () => any;
+    containerStyle?: React.CSSProperties;
+    buttonStyle?: React.CSSProperties;
+    buttonTextStyle?: React.CSSProperties;
+};
+/**
+ * ------------------------------------------------------------
+ * Thin Button
+ * ------------------------------------------------------------
+ * A component that renders a clickable space
+ * with a border and text. This element is intended to be clicked
+ * to invoke a specific function. onClick, onPressIn, and onPressOut
+ * should have some callback that can communicate with the parent the
+ * next steps to take.
+ *
+ * @param {ThinButtonProps} props
+ */
+declare function ThinButton({ testID, text, containerStyle, buttonStyle, buttonTextStyle, onclick, children }: ThinButtonProps): JSX.Element;
+declare namespace ThinButton {
+    var propTypes: {
+        testID: PropTypes.Requireable<string>;
+        key: PropTypes.Requireable<any>;
+        text: PropTypes.Requireable<string>;
+        children: PropTypes.Requireable<object>;
+        onclick: PropTypes.Requireable<(...args: any[]) => any>;
+        containerStyle: PropTypes.Requireable<object>;
+        buttonStyle: PropTypes.Requireable<object>;
+        buttonTextStyle: PropTypes.Requireable<object>;
+    };
+}
+
+type CardProps = {
+    key?: any;
+    children?: React.ReactNode | React.FunctionComponent;
+    containerStyle?: React.CSSProperties;
+    wrapperStyle?: React.CSSProperties;
+    titleText?: String;
+    titleStyle?: React.CSSProperties;
+    subtitleText?: String;
+    subtitleStyle?: React.CSSProperties;
+    titleContainerStyle?: React.CSSProperties;
+    closeButtonContainerStyle?: React.CSSProperties;
+    closeButtonStyle?: React.CSSProperties;
+    showCloseButton?: Boolean;
+    onClickCloseButton?: (arg0?: any) => any;
+};
+/**
+ * ------------------------------------------------------------
+ * Card
+ * ------------------------------------------------------------
+ * Renders a space that appears to be a 'card' hovering over the
+ * parent. It has the capability of rendering a title, subtiltle, titledivider,
+ * as well as take in children components in typical React and React-Native
+ * fashion.
+ *
+ * @param {CardProps} props
+ * */
+declare function Card({ containerStyle, wrapperStyle, titleText, titleStyle, subtitleText, subtitleStyle, titleContainerStyle, closeButtonStyle, showCloseButton, onClickCloseButton: closeButtonPressedCallBack, children }: CardProps): JSX.Element;
+declare namespace Card {
+    var propTypes: {
+        key: PropTypes.Requireable<string>;
+        children: PropTypes.Requireable<any>;
+        containerStyle: PropTypes.Requireable<object>;
+        wrapperStyle: PropTypes.Requireable<object>;
+        title: PropTypes.Requireable<string>;
+        titleStyle: PropTypes.Requireable<object>;
+        subtitle: PropTypes.Requireable<string>;
+        subtitleStyle: PropTypes.Requireable<string>;
+        titleContainerStyle: PropTypes.Requireable<object>;
+        closeButtonStyle: PropTypes.Requireable<object>;
+        closeButtonContainerStyle: PropTypes.Requireable<object>;
+        showCloseButton: PropTypes.Requireable<object>;
+        closeButtonPressedCallBack: PropTypes.Requireable<(...args: any[]) => any>;
+    };
+}
+
+type InputFormProps = {
+    key?: any;
+    name?: string;
+    ref?: any;
+    testID?: string;
+    onInput?: (value: string) => any;
+    defaultValue?: string;
+    secureTextEntry?: boolean;
+    formTitleStyle?: React.CSSProperties;
+    containerStyle?: React.CSSProperties;
+    inputStyle?: React.CSSProperties;
+    errorStyle?: React.CSSProperties;
+    placeholder?: string;
+    value?: string;
+    errorMessage?: string;
+    numberOfLines?: number;
+    multiline?: boolean;
+    trim?: boolean;
+    maxLength?: number;
+};
+/**
+ * ------------------------------------------------------------
+ * Input Form
+ * ------------------------------------------------------------
+ * Renders an area where the user is able to input keyboard data.
+ * It inherits most of its functionality from the TextInput state but
+ * allows for a stylized version of it. It also is capable of rendering
+ * a title for the field for UI clarity through the name property.
+ *
+ * Uncontrolled by default (seeded from `defaultValue`, tracked
+ * internally). Pass `value` + `onInput` together to control it from
+ * a parent instead, the same duality NavigationBar uses for
+ * selection. `errorMessage` is shown under the field whenever it's
+ * set; there is no separate visibility flag to manage.
+ *
+ * @param {InputFormProps} props
+ * */
+declare function InputForm({ testID, name, onInput, defaultValue, secureTextEntry, formTitleStyle, containerStyle, inputStyle, errorStyle, placeholder, value: controlledValue, errorMessage, numberOfLines, multiline, trim, maxLength }: InputFormProps): JSX.Element;
+declare namespace InputForm {
+    var propTypes: {
+        key: PropTypes.Requireable<any>;
+        name: PropTypes.Requireable<string>;
+        testID: PropTypes.Requireable<string>;
+        onInput: PropTypes.Requireable<(...args: any[]) => any>;
+        defaultValue: PropTypes.Requireable<string>;
+        secureTextEntry: PropTypes.Requireable<boolean>;
+        formTitleStyle: PropTypes.Requireable<object>;
+        containerStyle: PropTypes.Requireable<object>;
+        inputStyle: PropTypes.Requireable<object>;
+        errorStyle: PropTypes.Requireable<object>;
+        placeholder: PropTypes.Requireable<string>;
+        value: PropTypes.Requireable<string>;
+        errorMessage: PropTypes.Requireable<string>;
+        numberOfLines: PropTypes.Requireable<number>;
+        multiline: PropTypes.Requireable<boolean>;
+        trim: PropTypes.Requireable<boolean>;
+        maxLength: PropTypes.Requireable<number>;
+    };
+}
+
+type NavigationBarViewProps = {
+    testID?: string;
+    items: NavItem[];
+    selectedKey?: string;
+    onItemSelect: (item: NavItem) => any;
+    containerStyle?: React.CSSProperties;
+    itemStyle?: React.CSSProperties;
+    activeItemStyle?: React.CSSProperties;
+    itemTextStyle?: React.CSSProperties;
+    activeItemTextStyle?: React.CSSProperties;
+};
+/**
+ * ------------------------------------------------------------
+ * Navigation Bar View
+ * ------------------------------------------------------------
+ * Pure presentation for a NavigationBar: renders `items` and calls
+ * `onItemSelect` when one is clicked. It holds no selection state
+ * and no knowledge of which clicks are valid (disabled/duplicate
+ * checks live in NavigationBar) — this component only decides how
+ * the bar looks. Swap it out for a fully custom look by passing a
+ * different `render` function to NavigationBar.
+ *
+ * @param {NavigationBarViewProps} props
+ * */
+declare function NavigationBarView({ testID, items, selectedKey, onItemSelect, containerStyle, itemStyle, activeItemStyle, itemTextStyle, activeItemTextStyle }: NavigationBarViewProps): JSX.Element;
+declare namespace NavigationBarView {
+    var propTypes: {
+        testID: PropTypes.Requireable<string>;
+        items: PropTypes.Validator<PropTypes.InferProps<{
+            key: PropTypes.Validator<string>;
+            label: PropTypes.Validator<string>;
+            icon: PropTypes.Requireable<PropTypes.ReactNodeLike>;
+            disabled: PropTypes.Requireable<boolean>;
+        }>[]>;
+        selectedKey: PropTypes.Requireable<string>;
+        onItemSelect: PropTypes.Validator<(...args: any[]) => any>;
+        containerStyle: PropTypes.Requireable<object>;
+        itemStyle: PropTypes.Requireable<object>;
+        activeItemStyle: PropTypes.Requireable<object>;
+        itemTextStyle: PropTypes.Requireable<object>;
+        activeItemTextStyle: PropTypes.Requireable<object>;
+    };
+}
+
+type NavItem = {
+    key: string;
+    label: string;
+    icon?: React.ReactNode;
+    disabled?: boolean;
+};
+type NavigationBarProps = {
+    key?: any;
+    testID?: string;
+    items: NavItem[];
+    defaultSelectedKey?: string;
+    selectedKey?: string;
+    onSelect?: (key: string, item: NavItem) => any;
+    render?: (viewProps: NavigationBarViewProps) => React.ReactElement;
+    containerStyle?: React.CSSProperties;
+    itemStyle?: React.CSSProperties;
+    activeItemStyle?: React.CSSProperties;
+    itemTextStyle?: React.CSSProperties;
+    activeItemTextStyle?: React.CSSProperties;
+};
+/**
+ * ------------------------------------------------------------
+ * Navigation Bar
+ * ------------------------------------------------------------
+ * Owns navigation *behavior* only: which item is selected, and the
+ * rules for changing that (a disabled item can't be selected, an
+ * already-selected item is a no-op). It has no opinion on markup or
+ * styling — that's delegated to `render`, which defaults to
+ * NavigationBarView. `render` is only ever handed the *result* of a
+ * selection decision (the current `selectedKey` and an `onItemSelect`
+ * callback bound to this component's own guarded `selectItem`), never
+ * a way to make that decision itself — so no presentation, default or
+ * custom, can bypass or replace how selection works.
+ *
+ * Uncontrolled by default (selection state lives here, seeded from
+ * `defaultSelectedKey` or the first item). Pass `selectedKey` +
+ * `onSelect` to control it from a parent instead.
+ *
+ * @param {NavigationBarProps} props
+ * */
+declare function NavigationBar({ testID, items, defaultSelectedKey, selectedKey: controlledSelectedKey, onSelect: onSelectCallback, render, containerStyle, itemStyle, activeItemStyle, itemTextStyle, activeItemTextStyle }: NavigationBarProps): React.ReactElement<any, string | React.JSXElementConstructor<any>>;
+declare namespace NavigationBar {
+    var propTypes: {
+        key: PropTypes.Requireable<any>;
+        testID: PropTypes.Requireable<string>;
+        items: PropTypes.Validator<PropTypes.InferProps<{
+            key: PropTypes.Validator<string>;
+            label: PropTypes.Validator<string>;
+            icon: PropTypes.Requireable<PropTypes.ReactNodeLike>;
+            disabled: PropTypes.Requireable<boolean>;
+        }>[]>;
+        defaultSelectedKey: PropTypes.Requireable<string>;
+        selectedKey: PropTypes.Requireable<string>;
+        onSelect: PropTypes.Requireable<(...args: any[]) => any>;
+        render: PropTypes.Requireable<(...args: any[]) => any>;
+        containerStyle: PropTypes.Requireable<object>;
+        itemStyle: PropTypes.Requireable<object>;
+        activeItemStyle: PropTypes.Requireable<object>;
+        itemTextStyle: PropTypes.Requireable<object>;
+        activeItemTextStyle: PropTypes.Requireable<object>;
+    };
+}
+
+type HamburgerMenuProps = {
+    key?: any;
+    testID?: string;
+    items: NavItem[];
+    defaultSelectedKey?: string;
+    selectedKey?: string;
+    onSelect?: (key: string, item: NavItem) => any;
+    icon?: React.ReactNode;
+    containerStyle?: React.CSSProperties;
+    buttonStyle?: React.CSSProperties;
+    iconStyle?: React.CSSProperties;
+    panelStyle?: React.CSSProperties;
+    itemStyle?: React.CSSProperties;
+    activeItemStyle?: React.CSSProperties;
+    itemTextStyle?: React.CSSProperties;
+    activeItemTextStyle?: React.CSSProperties;
+};
+/**
+ * ------------------------------------------------------------
+ * Hamburger Menu
+ * ------------------------------------------------------------
+ * A NavigationBar whose items live behind a toggle button instead of
+ * being shown inline. Selection behavior is NavigationBar's, reused
+ * as-is rather than reimplemented: one item is always selected
+ * (defaulting to the first), and a disabled or already-active item
+ * is a no-op. The only thing this component adds is presentation —
+ * the toggle button and side panel, rendered by HamburgerMenuView —
+ * so a HamburgerMenu and a NavigationBar built from the same `items`
+ * can never disagree about what "selected" means.
+ *
+ * `icon` overrides the default "☰" toggle glyph with any node; when
+ * left unset, `iconStyle` still styles the default glyph. All other
+ * `*Style` props are mutable the same way as Card's: each has a
+ * sensible default, override just the ones you need.
+ *
+ * @param {HamburgerMenuProps} props
+ * */
+declare function HamburgerMenu({ testID, items, defaultSelectedKey, selectedKey, onSelect, icon, containerStyle, buttonStyle, iconStyle, panelStyle, itemStyle, activeItemStyle, itemTextStyle, activeItemTextStyle }: HamburgerMenuProps): JSX.Element;
+declare namespace HamburgerMenu {
+    var propTypes: {
+        key: PropTypes.Requireable<any>;
+        testID: PropTypes.Requireable<string>;
+        items: PropTypes.Validator<PropTypes.InferProps<{
+            key: PropTypes.Validator<string>;
+            label: PropTypes.Validator<string>;
+            icon: PropTypes.Requireable<PropTypes.ReactNodeLike>;
+            disabled: PropTypes.Requireable<boolean>;
+        }>[]>;
+        defaultSelectedKey: PropTypes.Requireable<string>;
+        selectedKey: PropTypes.Requireable<string>;
+        onSelect: PropTypes.Requireable<(...args: any[]) => any>;
+        icon: PropTypes.Requireable<PropTypes.ReactNodeLike>;
+        containerStyle: PropTypes.Requireable<object>;
+        buttonStyle: PropTypes.Requireable<object>;
+        iconStyle: PropTypes.Requireable<object>;
+        panelStyle: PropTypes.Requireable<object>;
+        itemStyle: PropTypes.Requireable<object>;
+        activeItemStyle: PropTypes.Requireable<object>;
+        itemTextStyle: PropTypes.Requireable<object>;
+        activeItemTextStyle: PropTypes.Requireable<object>;
+    };
+}
+
+type HamburgerMenuViewProps = {
+    testID?: string;
+    items: NavItem[];
+    selectedKey?: string;
+    onItemSelect: (item: NavItem) => any;
+    icon?: React.ReactNode;
+    containerStyle?: React.CSSProperties;
+    buttonStyle?: React.CSSProperties;
+    iconStyle?: React.CSSProperties;
+    panelStyle?: React.CSSProperties;
+    itemStyle?: React.CSSProperties;
+    activeItemStyle?: React.CSSProperties;
+    itemTextStyle?: React.CSSProperties;
+    activeItemTextStyle?: React.CSSProperties;
+};
+/**
+ * ------------------------------------------------------------
+ * Hamburger Menu View
+ * ------------------------------------------------------------
+ * Pure presentation for a HamburgerMenu: a toggle button that shows
+ * or hides a side panel of items. Reuses NavigationBarView to render
+ * the panel's items, so opening the panel is the only new behavior
+ * introduced here (`isOpen` is local display state, not selection
+ * state) — clicking an item still goes through the same guarded
+ * `onItemSelect` handed down from NavigationBar, this view just also
+ * closes the panel afterward.
+ *
+ * @param {HamburgerMenuViewProps} props
+ * */
+declare function HamburgerMenuView({ testID, items, selectedKey, onItemSelect, icon, containerStyle, buttonStyle, iconStyle, panelStyle, itemStyle, activeItemStyle, itemTextStyle, activeItemTextStyle }: HamburgerMenuViewProps): JSX.Element;
+declare namespace HamburgerMenuView {
+    var propTypes: {
+        testID: PropTypes.Requireable<string>;
+        items: PropTypes.Validator<PropTypes.InferProps<{
+            key: PropTypes.Validator<string>;
+            label: PropTypes.Validator<string>;
+            icon: PropTypes.Requireable<PropTypes.ReactNodeLike>;
+            disabled: PropTypes.Requireable<boolean>;
+        }>[]>;
+        selectedKey: PropTypes.Requireable<string>;
+        onItemSelect: PropTypes.Validator<(...args: any[]) => any>;
+        icon: PropTypes.Requireable<PropTypes.ReactNodeLike>;
+        containerStyle: PropTypes.Requireable<object>;
+        buttonStyle: PropTypes.Requireable<object>;
+        iconStyle: PropTypes.Requireable<object>;
+        panelStyle: PropTypes.Requireable<object>;
+        itemStyle: PropTypes.Requireable<object>;
+        activeItemStyle: PropTypes.Requireable<object>;
+        itemTextStyle: PropTypes.Requireable<object>;
+        activeItemTextStyle: PropTypes.Requireable<object>;
+    };
+}
+
+type RadioOption = NavItem;
+type RadioButtonGroupProps = {
+    key?: any;
+    testID?: string;
+    items: RadioOption[];
+    defaultSelectedKey?: string;
+    selectedKey?: string;
+    onSelect?: (key: string, item: RadioOption) => any;
+    title?: string;
+    titleContainerStyle?: React.CSSProperties;
+    titleStyle?: React.CSSProperties;
+    containerStyle?: React.CSSProperties;
+    itemStyle?: React.CSSProperties;
+    activeItemStyle?: React.CSSProperties;
+    itemTextStyle?: React.CSSProperties;
+    activeItemTextStyle?: React.CSSProperties;
+};
+/**
+ * ------------------------------------------------------------
+ * Radio Button Group
+ * ------------------------------------------------------------
+ * A NavigationBar whose items render as a segmented radio control
+ * instead of a nav strip. Selection behavior is NavigationBar's,
+ * reused as-is: exactly one option is always selected (defaulting to
+ * the first), and a disabled or already-active option is a no-op.
+ * This component only supplies presentation — RadioButtonGroupView —
+ * so it can never disagree with a NavigationBar built from the same
+ * `items` about what "selected" means.
+ *
+ * Default styling mirrors homepairsUI's AccountTypeRadioButton
+ * (accent `#00ADE9` fill, `#1177B0` border when selected, muted
+ * `rgba(55,66,69,.5)` otherwise), generalized from its fixed
+ * two-option layout to any number of items. Every `*Style` prop is
+ * mutable the same way as Card's: each has that default, override
+ * just the ones you need.
+ *
+ * @param {RadioButtonGroupProps} props
+ * */
+declare function RadioButtonGroup({ testID, items, defaultSelectedKey, selectedKey, onSelect, title, titleContainerStyle, titleStyle, containerStyle, itemStyle, activeItemStyle, itemTextStyle, activeItemTextStyle }: RadioButtonGroupProps): JSX.Element;
+declare namespace RadioButtonGroup {
+    var propTypes: {
+        key: PropTypes.Requireable<any>;
+        testID: PropTypes.Requireable<string>;
+        items: PropTypes.Validator<PropTypes.InferProps<{
+            key: PropTypes.Validator<string>;
+            label: PropTypes.Validator<string>;
+            icon: PropTypes.Requireable<PropTypes.ReactNodeLike>;
+            disabled: PropTypes.Requireable<boolean>;
+        }>[]>;
+        defaultSelectedKey: PropTypes.Requireable<string>;
+        selectedKey: PropTypes.Requireable<string>;
+        onSelect: PropTypes.Requireable<(...args: any[]) => any>;
+        title: PropTypes.Requireable<string>;
+        titleContainerStyle: PropTypes.Requireable<object>;
+        titleStyle: PropTypes.Requireable<object>;
+        containerStyle: PropTypes.Requireable<object>;
+        itemStyle: PropTypes.Requireable<object>;
+        activeItemStyle: PropTypes.Requireable<object>;
+        itemTextStyle: PropTypes.Requireable<object>;
+        activeItemTextStyle: PropTypes.Requireable<object>;
+    };
+}
+
+type RadioButtonGroupViewProps = {
+    testID?: string;
+    items: NavItem[];
+    selectedKey?: string;
+    onItemSelect: (item: NavItem) => any;
+    title?: string;
+    titleContainerStyle?: React.CSSProperties;
+    titleStyle?: React.CSSProperties;
+    containerStyle?: React.CSSProperties;
+    itemStyle?: React.CSSProperties;
+    activeItemStyle?: React.CSSProperties;
+    itemTextStyle?: React.CSSProperties;
+    activeItemTextStyle?: React.CSSProperties;
+};
+/**
+ * ------------------------------------------------------------
+ * Radio Button Group View
+ * ------------------------------------------------------------
+ * Pure presentation for a RadioButtonGroup: a row of segments,
+ * rounded like a segmented control at the two outer edges, filled
+ * with the accent color when selected. Defaults (colors, radius,
+ * height, padding, font) mirror homepairsUI's AccountTypeRadioButton,
+ * generalized from its fixed two-option layout to any number of
+ * `items`. Holds no selection state itself — clicking a segment just
+ * calls `onItemSelect`, the same guarded callback NavigationBar hands
+ * to any of its views.
+ *
+ * @param {RadioButtonGroupViewProps} props
+ * */
+declare function RadioButtonGroupView({ testID, items, selectedKey, onItemSelect, title, titleContainerStyle, titleStyle, containerStyle, itemStyle, activeItemStyle, itemTextStyle, activeItemTextStyle }: RadioButtonGroupViewProps): JSX.Element;
+declare namespace RadioButtonGroupView {
+    var propTypes: {
+        testID: PropTypes.Requireable<string>;
+        items: PropTypes.Validator<PropTypes.InferProps<{
+            key: PropTypes.Validator<string>;
+            label: PropTypes.Validator<string>;
+            icon: PropTypes.Requireable<PropTypes.ReactNodeLike>;
+            disabled: PropTypes.Requireable<boolean>;
+        }>[]>;
+        selectedKey: PropTypes.Requireable<string>;
+        onItemSelect: PropTypes.Validator<(...args: any[]) => any>;
+        title: PropTypes.Requireable<string>;
+        titleContainerStyle: PropTypes.Requireable<object>;
+        titleStyle: PropTypes.Requireable<object>;
+        containerStyle: PropTypes.Requireable<object>;
+        itemStyle: PropTypes.Requireable<object>;
+        activeItemStyle: PropTypes.Requireable<object>;
+        itemTextStyle: PropTypes.Requireable<object>;
+        activeItemTextStyle: PropTypes.Requireable<object>;
+    };
+}
+
+type LoadingProps = {
+    key?: any;
+    testID?: string;
+    children?: React.ReactNode;
+    containerStyle?: React.CSSProperties;
+    wrapperStyle?: React.CSSProperties;
+    spinnerStyle?: React.CSSProperties;
+};
+/**
+ * ------------------------------------------------------------
+ * Loading
+ * ------------------------------------------------------------
+ * A card that should be shown while assets, requests, or async work
+ * are in flight. Mirrors homepairsUI's LoadingModal: built on this
+ * library's own Card, sized to a small centered panel with a
+ * spinner, and able to take children for a status message under it.
+ *
+ * @param {LoadingProps} props
+ * */
+declare function Loading({ testID, children, containerStyle, wrapperStyle, spinnerStyle }: LoadingProps): JSX.Element;
+declare namespace Loading {
+    var propTypes: {
+        key: PropTypes.Requireable<any>;
+        testID: PropTypes.Requireable<string>;
+        children: PropTypes.Requireable<PropTypes.ReactNodeLike>;
+        containerStyle: PropTypes.Requireable<object>;
+        wrapperStyle: PropTypes.Requireable<object>;
+        spinnerStyle: PropTypes.Requireable<object>;
+    };
+}
+
+type ThumbnailItem = NavItem;
+type ScrollMenuProps = {
+    key?: any;
+    testID?: string;
+    items: ThumbnailItem[];
+    defaultSelectedKey?: string;
+    selectedKey?: string;
+    onSelect?: (key: string, item: ThumbnailItem) => any;
+    containerStyle?: React.CSSProperties;
+    tileStyle?: React.CSSProperties;
+    activeTileStyle?: React.CSSProperties;
+    tileTextStyle?: React.CSSProperties;
+};
+/**
+ * ------------------------------------------------------------
+ * Scroll Menu
+ * ------------------------------------------------------------
+ * A NavigationBar whose items render as a horizontally scrollable
+ * strip of thumbnail tiles instead of a nav strip — think
+ * homepairsUI's PreferredProviderFlatList, generalized to any set of
+ * `items`. Selection behavior is NavigationBar's, reused as-is:
+ * exactly one tile is always selected (defaulting to the first), and
+ * a disabled or already-active tile is a no-op. This component only
+ * supplies presentation — ScrollMenuView — so it can never disagree
+ * with a NavigationBar built from the same `items` about what
+ * "selected" means.
+ *
+ * Every `*Style` prop is mutable the same way as Card's: each has a
+ * default drawn from homepairsUI's ImageTile/PreferredProviderFlatList
+ * styling, override just the ones you need.
+ *
+ * @param {ScrollMenuProps} props
+ * */
+declare function ScrollMenu({ testID, items, defaultSelectedKey, selectedKey, onSelect, containerStyle, tileStyle, activeTileStyle, tileTextStyle }: ScrollMenuProps): JSX.Element;
+declare namespace ScrollMenu {
+    var propTypes: {
+        key: PropTypes.Requireable<any>;
+        testID: PropTypes.Requireable<string>;
+        items: PropTypes.Validator<PropTypes.InferProps<{
+            key: PropTypes.Validator<string>;
+            label: PropTypes.Validator<string>;
+            icon: PropTypes.Requireable<PropTypes.ReactNodeLike>;
+            disabled: PropTypes.Requireable<boolean>;
+        }>[]>;
+        defaultSelectedKey: PropTypes.Requireable<string>;
+        selectedKey: PropTypes.Requireable<string>;
+        onSelect: PropTypes.Requireable<(...args: any[]) => any>;
+        containerStyle: PropTypes.Requireable<object>;
+        tileStyle: PropTypes.Requireable<object>;
+        activeTileStyle: PropTypes.Requireable<object>;
+        tileTextStyle: PropTypes.Requireable<object>;
+    };
+}
+
+type ScrollMenuViewProps = {
+    testID?: string;
+    items: NavItem[];
+    selectedKey?: string;
+    onItemSelect: (item: NavItem) => any;
+    containerStyle?: React.CSSProperties;
+    tileStyle?: React.CSSProperties;
+    activeTileStyle?: React.CSSProperties;
+    tileTextStyle?: React.CSSProperties;
+};
+/**
+ * ------------------------------------------------------------
+ * Scroll Menu View
+ * ------------------------------------------------------------
+ * Pure presentation for a ScrollMenu: a horizontally scrollable row
+ * of thumbnail tiles, sized and colored like homepairsUI's ImageTile
+ * (70x70, 7.5 radius, light border, dark strip background). Give an
+ * item a thumbnail via its `icon`, e.g.
+ * `icon: <img src={...} style={{width: '100%', height: '100%', objectFit: 'cover'}} />`;
+ * an item without an `icon` falls back to its `label` as centered
+ * text, mirroring the ImageTile/TextTile fallback in the original.
+ * Holds no selection state — clicking a tile just calls
+ * `onItemSelect`, the same guarded callback NavigationBar hands to
+ * any of its views.
+ *
+ * @param {ScrollMenuViewProps} props
+ * */
+declare function ScrollMenuView({ testID, items, selectedKey, onItemSelect, containerStyle, tileStyle, activeTileStyle, tileTextStyle }: ScrollMenuViewProps): JSX.Element;
+declare namespace ScrollMenuView {
+    var propTypes: {
+        testID: PropTypes.Requireable<string>;
+        items: PropTypes.Validator<PropTypes.InferProps<{
+            key: PropTypes.Validator<string>;
+            label: PropTypes.Validator<string>;
+            icon: PropTypes.Requireable<PropTypes.ReactNodeLike>;
+            disabled: PropTypes.Requireable<boolean>;
+        }>[]>;
+        selectedKey: PropTypes.Requireable<string>;
+        onItemSelect: PropTypes.Validator<(...args: any[]) => any>;
+        containerStyle: PropTypes.Requireable<object>;
+        tileStyle: PropTypes.Requireable<object>;
+        activeTileStyle: PropTypes.Requireable<object>;
+        tileTextStyle: PropTypes.Requireable<object>;
+    };
+}
+
+type ImageTileProps = {
+    key?: any;
+    testID?: string;
+    image: string;
+    enlarge?: boolean;
+    containerStyle?: React.CSSProperties;
+    imageStyle?: React.CSSProperties;
+};
+type TextTileProps = {
+    key?: any;
+    testID?: string;
+    text: string;
+    fontSize?: number;
+    containerStyle?: React.CSSProperties;
+    textStyle?: React.CSSProperties;
+};
+/**
+ * ------------------------------------------------------------
+ * Image Tile
+ * ------------------------------------------------------------
+ * A small unit that holds an image and is formatted in the shape of
+ * a rounded tile, matching homepairsUI's ImageTile (70x70, or 100x100
+ * with `enlarge`, 7.5 radius, light border). Often seen holding a
+ * service provider's logo, e.g. as an item's thumbnail in ScrollMenu.
+ *
+ * @param {ImageTileProps} props
+ * */
+declare function ImageTile({ testID, image, enlarge, containerStyle, imageStyle }: ImageTileProps): JSX.Element;
+declare namespace ImageTile {
+    var propTypes: {
+        key: PropTypes.Requireable<any>;
+        testID: PropTypes.Requireable<string>;
+        image: PropTypes.Validator<string>;
+        enlarge: PropTypes.Requireable<boolean>;
+        containerStyle: PropTypes.Requireable<object>;
+        imageStyle: PropTypes.Requireable<object>;
+    };
+}
+/**
+ * ------------------------------------------------------------
+ * Text Tile
+ * ------------------------------------------------------------
+ * A small unit that holds a string and is formatted in the shape of
+ * a rounded tile, matching homepairsUI's TextTile. Used as a fallback
+ * where an ImageTile would go but there's no image available (e.g.
+ * the hamburger menu, or an add-provider tile).
+ *
+ * @param {TextTileProps} props
+ * */
+declare function TextTile({ testID, text, fontSize, containerStyle, textStyle }: TextTileProps): JSX.Element;
+declare namespace TextTile {
+    var propTypes: {
+        key: PropTypes.Requireable<any>;
+        testID: PropTypes.Requireable<string>;
+        text: PropTypes.Validator<string>;
+        fontSize: PropTypes.Requireable<number>;
+        containerStyle: PropTypes.Requireable<object>;
+        textStyle: PropTypes.Requireable<object>;
+    };
+}
+
+type CustomMatcher = (query: string, text: string) => number | null;
+type MatchStrategy = 'substring' | 'prefix' | 'tokenized' | 'fuzzy' | 'regex' | CustomMatcher;
+
+type SearchBarProps<T = any> = Omit<InputFormProps, 'onInput' | 'value' | 'defaultValue'> & {
+    objects?: T[];
+    keys?: string[];
+    onResults?: (filtered: T[]) => any;
+    defaultValue?: string;
+    matchStrategy?: MatchStrategy;
+    caseSensitive?: boolean;
+    ignoreAccents?: boolean;
+    rank?: boolean;
+    debounceMs?: number;
+};
+/**
+ * ------------------------------------------------------------
+ * Search Bar
+ * ------------------------------------------------------------
+ * Wraps InputForm as-is (no styling of its own, same as homepairsUI's
+ * SearchForm) and adds filtering: on every keystroke, `objects` is
+ * filtered and the result is handed to `onResults`. With no `keys`,
+ * matching recurses through each object's own nested values; with
+ * `keys`, only those top-level fields are checked.
+ *
+ * `matchStrategy` picks the algorithm (default `'fuzzy'`, a
+ * subsequence match that tolerates typos and scores tighter matches
+ * higher — the same spirit as fzf/VS Code's go-to-file):
+ *   - `'fuzzy'`      query characters found in order, not necessarily together
+ *   - `'substring'`  plain includes() — exact and cheap
+ *   - `'prefix'`     matches the start of the text or of any word in it
+ *   - `'tokenized'`  every word in the query must appear somewhere (any order)
+ *   - `'regex'`      query is compiled as a RegExp; invalid patterns just match nothing
+ *
+ * `matchStrategy` also accepts a custom `(query, text) => score | null`
+ * function in place of one of those names — return `null` to exclude an
+ * item, or a number (higher = better) to include it; it receives the same
+ * case/accent-normalized query and searchable text the built-ins do.
+ *
+ * `caseSensitive` (default false) and `ignoreAccents` (default false,
+ * e.g. so "cafe" matches "café") normalize before matching. `rank`
+ * (default true) sorts survivors by match score — only meaningful for
+ * `'fuzzy'`, a no-op for the others since they all score 0.
+ * `debounceMs` (default 0) delays re-filtering after the last
+ * keystroke without delaying what's shown in the field itself.
+ *
+ * Filtering also re-runs (with the current search text, undebounced)
+ * whenever `objects` itself changes — e.g. after a fetch replaces the
+ * list — but not on mount, so the parent's own initial list stands
+ * until the user actually searches.
+ *
+ * @param {SearchBarProps} props
+ * */
+declare function SearchBar<T = any>({ objects, keys, onResults, defaultValue, matchStrategy, caseSensitive, ignoreAccents, rank, debounceMs, ...inputFormProps }: SearchBarProps<T>): JSX.Element;
+declare namespace SearchBar {
+    var propTypes: {
+        objects: PropTypes.Requireable<any[]>;
+        keys: PropTypes.Requireable<string[]>;
+        onResults: PropTypes.Requireable<(...args: any[]) => any>;
+        defaultValue: PropTypes.Requireable<string>;
+        matchStrategy: PropTypes.Requireable<NonNullable<string | ((...args: any[]) => any)>>;
+        caseSensitive: PropTypes.Requireable<boolean>;
+        ignoreAccents: PropTypes.Requireable<boolean>;
+        rank: PropTypes.Requireable<boolean>;
+        debounceMs: PropTypes.Requireable<number>;
+    };
+}
+
+export { Card, type CardProps, type CustomMatcher, HamburgerMenu, type HamburgerMenuProps, HamburgerMenuView, type HamburgerMenuViewProps, HelloWorld, ImageTile, type ImageTileProps, InputForm, type InputFormProps, Loading, type LoadingProps, type MatchStrategy, type NavItem, NavigationBar, type NavigationBarProps, NavigationBarView, type NavigationBarViewProps, RadioButtonGroup, type RadioButtonGroupProps, RadioButtonGroupView, type RadioButtonGroupViewProps, type RadioOption, ScrollMenu, type ScrollMenuProps, ScrollMenuView, type ScrollMenuViewProps, SearchBar, type SearchBarProps, TextTile, type TextTileProps, ThinButton, type ThinButtonProps, type ThumbnailItem };