@react-native-ohos/native-base 3.4.29-rc.1

package/lib/typescript/components/composites/Tabs/TabBar.d.ts

@@ -0,0 +1,10 @@
+import React from 'react';
+import type { ITabBarProps } from './types';
+declare const TabBar: React.MemoExoticComponent<React.ForwardRefExoticComponent<import("../../primitives/Box").InterfaceBoxProps<ITabBarProps> & {
+    align?: "center" | "end" | "start" | undefined;
+    isFitted?: boolean | undefined;
+    size?: "sm" | "md" | "lg" | undefined;
+    tablistRef?: React.RefObject<any> | undefined;
+    tabListProps?: import("react-native").ViewProps | undefined;
+} & React.RefAttributes<unknown>>>;
+export default TabBar;

package/lib/typescript/components/composites/Tabs/TabIcon.d.ts

@@ -0,0 +1,7 @@
+import React from 'react';
+declare const _default: React.MemoExoticComponent<React.ForwardRefExoticComponent<import("../../primitives/Icon/types").InterfaceIconProps & Partial<{}> & {
+    variant?: unknown;
+    size?: import("../../types").ThemeComponentSizeType<"Icon">;
+    colorScheme?: import("../../types").ColorSchemeType;
+} & React.RefAttributes<unknown>>>;
+export default _default;

package/lib/typescript/components/composites/Tabs/TabView.d.ts

@@ -0,0 +1,9 @@
+import React from 'react';
+declare const _default: React.MemoExoticComponent<React.ForwardRefExoticComponent<import("../../primitives/Box").InterfaceBoxProps<null> & {
+    variant?: unknown;
+    size?: unknown;
+    colorScheme?: import("../../types").ColorSchemeType;
+} & {
+    index?: number | undefined;
+} & React.RefAttributes<unknown>>>;
+export default _default;

package/lib/typescript/components/composites/Tabs/TabViews.d.ts

@@ -0,0 +1,7 @@
+import React from 'react';
+declare const TabViews: React.MemoExoticComponent<React.ForwardRefExoticComponent<import("../../primitives/Box").InterfaceBoxProps<null> & {
+    variant?: unknown;
+    size?: unknown;
+    colorScheme?: import("../../types").ColorSchemeType;
+} & React.RefAttributes<unknown>>>;
+export default TabViews;

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

@@ -0,0 +1,18 @@
+import React from 'react';
+import type { ITabsProps } from './types';
+declare const _default: React.MemoExoticComponent<React.ForwardRefExoticComponent<import("../../primitives/Box").InterfaceBoxProps<ITabsProps> & {
+    align?: "center" | "end" | "start" | undefined;
+    id?: string | undefined;
+    colorScheme?: import("../../types").ColorSchemeType;
+    index?: number | undefined;
+    defaultIndex?: number | undefined;
+    isFitted?: boolean | undefined;
+    isLazy?: boolean | undefined;
+    isManual?: boolean | undefined;
+    orientation?: "horizontal" | "vertical" | undefined;
+    size?: "sm" | "md" | "lg" | undefined;
+    variant?: "outline" | "filled" | "filled-outline" | undefined;
+    onChange?: ((index: number) => void) | undefined;
+    keyboardActivation?: "automatic" | "manual" | undefined;
+} & React.RefAttributes<unknown>>>;
+export default _default;

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

@@ -0,0 +1,5 @@
+export { TabsContext } from './Context';
+import type { ITabsComponentType } from './types';
+export type { ITabsProps, ITabBarProps, ITabProps, ITabViewsProps, ITabViewProps, ITabsContextProps, } from './types';
+declare const Tabs: ITabsComponentType;
+export { Tabs };

package/lib/typescript/components/composites/Tabs/types.d.ts

@@ -0,0 +1,70 @@
+import type { RefObject } from 'react';
+import type { ViewProps } from 'react-native';
+import type { IBoxProps, InterfaceBoxProps } from '../../primitives/Box';
+import type { InterfaceIconProps } from '../../primitives/Icon/types';
+import type { ColorSchemeType } from '../../../components/types';
+export declare type ITabsProps = InterfaceBoxProps<ITabsProps> & {
+    align?: 'center' | 'end' | 'start';
+    id?: string;
+    colorScheme?: ColorSchemeType;
+    index?: number;
+    defaultIndex?: number;
+    isFitted?: boolean;
+    isLazy?: boolean;
+    isManual?: boolean;
+    orientation?: 'horizontal' | 'vertical';
+    size?: 'sm' | 'md' | 'lg';
+    variant?: 'outline' | 'filled' | 'filled-outline';
+    onChange?: (index: number) => void;
+    keyboardActivation?: 'manual' | 'automatic';
+};
+export declare type ITabBarProps = InterfaceBoxProps<ITabBarProps> & {
+    align?: 'center' | 'end' | 'start';
+    isFitted?: boolean;
+    size?: 'sm' | 'md' | 'lg';
+    tablistRef?: RefObject<any>;
+    tabListProps?: ViewProps;
+};
+export declare type ITabProps = InterfaceBoxProps<ITabProps> & {
+    isDisabled?: boolean;
+    _active?: any;
+    _disabled?: any;
+    _hover?: any;
+    item?: any;
+};
+export declare type ITabViewsProps = IBoxProps;
+export declare type ITabViewProps = IBoxProps & {
+    index?: number;
+};
+export declare type ITabsContextProps = {
+    activeIconProps?: any;
+    inactiveIconProps?: any;
+    activeTabStyle?: any;
+    inactiveTabStyle?: any;
+    tabBarStyle?: any;
+    isFitted?: boolean;
+    align?: 'start' | 'center' | 'end';
+    state?: any;
+};
+export declare type ITabContextProps = {
+    isSelected?: boolean;
+};
+export declare type ITabsComponentType = ((props: ITabsProps & {
+    ref?: any;
+}) => JSX.Element) & {
+    Bar: React.MemoExoticComponent<(props: ITabBarProps & {
+        ref?: any;
+    }) => JSX.Element>;
+    Tab: React.MemoExoticComponent<(props: ITabProps & {
+        ref?: any;
+    }) => JSX.Element>;
+    Views: React.MemoExoticComponent<(props: ITabViewsProps & {
+        ref?: any;
+    }) => JSX.Element>;
+    View: React.MemoExoticComponent<(props: ITabViewProps & {
+        ref?: any;
+    }) => JSX.Element>;
+    Icon: React.MemoExoticComponent<(props: InterfaceIconProps & {
+        ref?: any;
+    }) => JSX.Element>;
+};

package/lib/typescript/components/composites/Tag/index.d.ts

@@ -0,0 +1,4 @@
+import type { IInputComponentType, ITagProps } from './types';
+declare const _default: IInputComponentType;
+export default _default;
+export type { ITagProps };

package/lib/typescript/components/composites/Tag/types.d.ts

@@ -0,0 +1,11 @@
+/// <reference types="react" />
+import type { CustomProps } from '../../../components/types';
+import type { InterfaceBoxProps } from '../../primitives/Box';
+import type { ColorSchemeType } from '../../../components/types';
+export interface InterfaceTagProps extends InterfaceBoxProps<ITagProps> {
+    variant?: 'solid' | 'subtle' | 'outline';
+    colorScheme?: ColorSchemeType;
+    size?: string | number;
+}
+export declare type IInputComponentType = (props: ITagProps) => JSX.Element;
+export declare type ITagProps = InterfaceTagProps & CustomProps<'Tag'>;

package/lib/typescript/components/composites/TextField/TextField.d.ts

@@ -0,0 +1,4 @@
+import React from 'react';
+import type { ITextFieldProps } from './types';
+declare const _default: React.MemoExoticComponent<React.ForwardRefExoticComponent<ITextFieldProps & React.RefAttributes<unknown>>>;
+export default _default;

package/lib/typescript/components/composites/TextField/index.d.ts

@@ -0,0 +1,2 @@
+export { default as TextField } from './TextField';
+export type { ITextFieldProps } from './types';

package/lib/typescript/components/composites/TextField/types.d.ts

@@ -0,0 +1,19 @@
+import type { IInputProps } from '../../primitives/Input';
+import type { InterfaceStackProps } from '../../primitives/Stack/Stack';
+import type { ISelectProps } from '../../primitives/Select';
+import type { ITextAreaProps } from '../../primitives/TextArea';
+import type { CustomProps } from '../../../components/types';
+declare type componentsSpecificProps = ({
+    component?: 'input';
+} & IInputProps) | ({
+    component?: 'textarea';
+} & ITextAreaProps) | ({
+    component?: 'select';
+} & ISelectProps);
+export declare type ITextFieldProps = (componentsSpecificProps & InterfaceStackProps & {
+    helperText?: string;
+    errorMessage?: string;
+    _helperTextProps?: any;
+    _errorMessageProps?: any;
+}) & CustomProps<'TextField'>;
+export {};

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

@@ -0,0 +1,19 @@
+import React from 'react';
+import type { IToastProps } from './types';
+export declare const ToastProvider: ({ children }: {
+    children: any;
+}) => JSX.Element;
+export declare const useToast: () => {
+    show: (props: IToastProps) => any;
+    close: (id: any) => void;
+    closeAll: () => void;
+    isActive: (id: any) => boolean;
+};
+export declare type IToastService = ReturnType<typeof useToast>;
+export declare const ToastRef: React.MutableRefObject<{
+    show: (props: IToastProps) => any;
+    close: (id: any) => void;
+    closeAll: () => void;
+    isActive: (id: any) => boolean;
+}>;
+export declare const Toast: IToastService;

package/lib/typescript/components/composites/Toast/ToastDummy.d.ts

@@ -0,0 +1,2 @@
+import type { IToastProps } from './types';
+export declare const Toast: (props: IToastProps) => void;

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

@@ -0,0 +1,2 @@
+export * from './Toast';
+export * from './types';

package/lib/typescript/components/composites/Toast/types.d.ts

@@ -0,0 +1,77 @@
+import type { ReactNode } from 'react';
+import type { ITextProps } from '../../primitives/Text';
+import type { InterfaceBoxProps } from '../../primitives/Box';
+import type { CustomProps } from '../../../components/types';
+export interface InterfaceToastProps extends InterfaceBoxProps<IToastProps> {
+    /**
+     * The title to be rendered in the Toast
+     */
+    title?: ReactNode;
+    /**
+     * The description of the toast
+     */
+    description?: ReactNode;
+    /**
+     * The delay before the toast hides (in milliseconds). If set to `null`, toast will never dismiss.
+     * @default 5000
+     */
+    duration?: number | null;
+    /**
+     * The `id` of the toast. Mostly used when you need to prevent duplicate. By default, we generate a unique `id` for each toast
+     */
+    id?: any;
+    /**
+     * Callback function to run side effects after the toast has closed.
+     */
+    onCloseComplete?: () => void;
+    /**
+     * The placement of the toast. Defaults to bottom
+     * @default bottom
+     */
+    placement?: 'top' | 'top-right' | 'top-left' | 'bottom' | 'bottom-left' | 'bottom-right';
+    /**
+     * Render a component toast component. Any component passed will receive 2 props: `id` and `onClose`.
+     */
+    render?: (props: any) => ReactNode;
+    /**
+     * For providing props to Title inside Toast
+     */
+    _title?: Partial<ITextProps>;
+    /**
+     * For providing props to Description inside Toast
+     */
+    _description?: Partial<ITextProps>;
+    /**
+     * The text to be announced by a screen reader when the Toast opens.
+     */
+    accessibilityAnnouncement?: string;
+    /**
+     * Determines the [accessibility announcement tone](https://reactnative.dev/docs/accessibility#accessibilityliveregion-android).
+     */
+    accessibilityLiveRegion?: 'none' | 'polite' | 'assertive';
+    /**
+     * If true and the keyboard is opened, the Toast will move up equivalent to the keyboard height.
+     * @default false
+     */
+    avoidKeyboard?: boolean;
+}
+export declare type IToast = {
+    id: number;
+    component: any;
+    config?: IToastProps;
+};
+export declare type IToastInfo = {
+    [key in any]: Array<IToast>;
+};
+export declare type IToastContext = {
+    toastInfo: IToastInfo;
+    setToastInfo: any;
+    setToast: (props: IToastProps) => any;
+    removeToast: (id: any) => void;
+    hideAll: () => void;
+    isActive: (id: any) => boolean;
+    visibleToasts: any;
+    setVisibleToasts: any;
+    hideToast: (id: any) => void;
+};
+export declare type IToastProps = InterfaceToastProps & CustomProps<'Toast'>;

package/lib/typescript/components/composites/Toast/utils.d.ts

@@ -0,0 +1,28 @@
+export declare const POSITIONS: {
+    bottom: {
+        bottom: number;
+        left: number;
+        right: number;
+    };
+    top: {
+        top: number;
+        left: number;
+        right: number;
+    };
+    'top-right': {
+        top: number;
+        right: number;
+    };
+    'top-left': {
+        top: number;
+        left: number;
+    };
+    'bottom-left': {
+        bottom: number;
+        left: number;
+    };
+    'bottom-right': {
+        bottom: number;
+        right: number;
+    };
+};

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

@@ -0,0 +1,3 @@
+/// <reference types="react" />
+import type { ITooltipProps } from './types';
+export declare const Tooltip: ({ label, children, onClose, onOpen, defaultIsOpen, placement, openDelay, closeDelay, closeOnClick, offset, isDisabled, hasArrow, arrowSize, isOpen: isOpenProp, ...props }: ITooltipProps) => JSX.Element | null;

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

@@ -0,0 +1,2 @@
+export { Tooltip } from './Tooltip';
+export type { ITooltipProps } from './types';

package/lib/typescript/components/composites/Tooltip/types.d.ts

@@ -0,0 +1,67 @@
+import type { CustomProps } from '../../../components/types';
+import type { InterfaceBoxProps } from '../../primitives/Box';
+export interface InterfaceTooltipProps extends InterfaceBoxProps<ITooltipProps> {
+    /**
+     * Text to be placed in the tooltip
+     */
+    label: string;
+    /**
+     * Whether the tooltip is opened. Useful for conrolling the open state
+     */
+    isOpen?: boolean;
+    /**
+     * Whether the tooltip is disabled
+     */
+    isDisabled?: boolean;
+    /**
+     * If true, the popover will be opened by default
+     */
+    defaultIsOpen?: boolean;
+    /**
+     * This function will be invoked when tooltip is closed. It'll also be called when user attempts to close the tooltip via Escape key
+     */
+    onClose?: () => void;
+    /**
+     * This function will be invoked when tooltip is opened
+     */
+    onOpen?: () => void;
+    /**
+     * Duration in ms to wait till displaying the tooltip
+     * @default 0
+     */
+    openDelay?: number;
+    /**
+     * Duration in ms to wait till hiding the tooltip
+     * @default 0
+     */
+    closeDelay?: number;
+    /**
+     * Tooltip placement
+     * @default bottom
+     */
+    placement?: 'top' | 'bottom' | 'left' | 'right' | 'top left' | 'top right' | 'bottom left' | 'bottom right' | 'right top' | 'right bottom' | 'left top' | 'left bottom';
+    /**
+     * Children passed will be used as Trigger element for the tooltip
+     */
+    children: any;
+    /**
+     * Whether tooltip should be closed on Trigger click
+     * @default true
+     */
+    closeOnClick?: boolean;
+    /**
+     * Size of the arrow
+     * @default 12
+     */
+    arrowSize?: number;
+    /**
+     * Whether tooltip should display arrow
+     * @default false
+     */
+    hasArrow?: boolean;
+    /**
+     * Distance between the trigger and the tooltip
+     */
+    offset?: number;
+}
+export declare type ITooltipProps = InterfaceTooltipProps & CustomProps<'Tooltip'>;

package/lib/typescript/components/composites/Transitions/Fade.d.ts

@@ -0,0 +1,12 @@
+import React from 'react';
+import type { IFadeProps } from './types';
+declare const _default: React.MemoExoticComponent<React.ForwardRefExoticComponent<import("../../primitives/Box").InterfaceBoxProps<IFadeProps> & {
+    in?: boolean | undefined;
+    entryDuration?: number | undefined;
+    exitDuration?: number | undefined;
+    delay?: number | undefined;
+    initial?: import("./types").ISupportedTransitions | undefined;
+    animate?: import("./types").ITransitionStyleProps | undefined;
+    exit?: import("./types").ITransitionStyleProps | undefined;
+} & React.RefAttributes<unknown>>>;
+export default _default;

package/lib/typescript/components/composites/Transitions/PresenceTransition.d.ts

@@ -0,0 +1,4 @@
+import React from 'react';
+import type { IPresenceTransitionProps } from './types';
+declare const _default: React.MemoExoticComponent<React.ForwardRefExoticComponent<IPresenceTransitionProps & React.RefAttributes<unknown>>>;
+export default _default;

package/lib/typescript/components/composites/Transitions/ScaleFade.d.ts

@@ -0,0 +1,12 @@
+import React from 'react';
+import type { IScaleFadeProps } from './types';
+declare const _default: React.MemoExoticComponent<React.ForwardRefExoticComponent<import("../../primitives/Box").InterfaceBoxProps<IScaleFadeProps> & {
+    in?: boolean | undefined;
+    duration?: number | undefined;
+    delay?: number | undefined;
+    initialScale?: number | undefined;
+    initial?: import("./types").ISupportedTransitions | undefined;
+    animate?: import("./types").ITransitionStyleProps | undefined;
+    exit?: import("./types").ITransitionStyleProps | undefined;
+} & React.RefAttributes<unknown>>>;
+export default _default;

package/lib/typescript/components/composites/Transitions/Slide.d.ts

@@ -0,0 +1,11 @@
+import React from 'react';
+import type { ISlideProps } from './types';
+export declare const Slide: React.MemoExoticComponent<React.ForwardRefExoticComponent<import("../../primitives/Box").InterfaceBoxProps<ISlideProps> & {
+    in?: boolean | undefined;
+    duration?: number | undefined;
+    delay?: number | undefined;
+    placement?: "top" | "right" | "bottom" | "left" | undefined;
+    overlay?: boolean | undefined;
+    _overlay?: import("../../primitives/Overlay").IOverlayProps | undefined;
+} & React.RefAttributes<unknown>>>;
+export default Slide;

package/lib/typescript/components/composites/Transitions/SlideFade.d.ts

@@ -0,0 +1,14 @@
+import React from 'react';
+import type { ISlideFadeProps } from './types';
+declare const _default: React.MemoExoticComponent<React.ForwardRefExoticComponent<import("../../primitives/Box").InterfaceBoxProps<ISlideFadeProps> & {
+    in?: boolean | undefined;
+    delay?: number | undefined;
+    duration?: number | undefined;
+    offsetX?: number | undefined;
+    offsetY?: number | undefined;
+} & Partial<{}> & {
+    variant?: unknown;
+    size?: unknown;
+    colorScheme?: import("../../types").ColorSchemeType;
+} & React.RefAttributes<unknown>>>;
+export default _default;

package/lib/typescript/components/composites/Transitions/Stagger.d.ts

@@ -0,0 +1,31 @@
+import type { ISupportedTransitions, ITransitionConfig } from './types';
+interface IStaggerConfig {
+    offset: number;
+    reverse?: boolean;
+}
+export interface IStaggerStyleProps extends ISupportedTransitions {
+    transition?: ITransitionConfig & {
+        stagger?: IStaggerConfig;
+    };
+}
+interface IStaggerProps {
+    children: any;
+    /**
+     * Initial styles before the transition starts
+     */
+    initial?: ISupportedTransitions;
+    /**
+     * The styles to which each child should animate to while entering.
+     */
+    animate?: IStaggerStyleProps;
+    /**
+     * The styles to which each child should animate to while exiting.
+     */
+    exit?: IStaggerStyleProps;
+    /**
+     * Determines whether to start the animation
+     */
+    visible?: boolean;
+}
+declare const Stagger: ({ children, ...restProps }: IStaggerProps) => any;
+export default Stagger;

package/lib/typescript/components/composites/Transitions/Transition.d.ts

@@ -0,0 +1,3 @@
+import React from 'react';
+import type { ITransitionProps } from './types';
+export declare const Transition: React.ForwardRefExoticComponent<ITransitionProps & React.RefAttributes<unknown>>;

package/lib/typescript/components/composites/Transitions/index.d.ts

@@ -0,0 +1,7 @@
+export { default as Fade } from './Fade';
+export { default as ScaleFade } from './ScaleFade';
+export { default as Slide } from './Slide';
+export { default as SlideFade } from './SlideFade';
+export { default as Stagger } from './Stagger';
+export { default as PresenceTransition } from './PresenceTransition';
+export type { IFadeProps, IScaleFadeProps, ISlideProps, ISlideFadeProps, } from './types';

package/lib/typescript/components/composites/Transitions/types.d.ts

@@ -0,0 +1,126 @@
+import type { ReactNode } from 'react';
+import type { ViewProps } from 'react-native';
+import type { CustomProps } from '../../../components/types';
+import type { InterfaceBoxProps } from '../../primitives/Box';
+import type { IOverlayProps } from '../../primitives/Overlay';
+export declare type IFadeProps = InterfaceBoxProps<IFadeProps> & {
+    in?: boolean;
+    entryDuration?: number;
+    exitDuration?: number;
+    delay?: number;
+    initial?: ISupportedTransitions;
+    animate?: ITransitionStyleProps;
+    exit?: ITransitionStyleProps;
+};
+export declare type IScaleFadeProps = InterfaceBoxProps<IScaleFadeProps> & {
+    in?: boolean;
+    duration?: number;
+    delay?: number;
+    initialScale?: number;
+    initial?: ISupportedTransitions;
+    animate?: ITransitionStyleProps;
+    exit?: ITransitionStyleProps;
+};
+export declare type ISlideProps = InterfaceBoxProps<ISlideProps> & {
+    in?: boolean;
+    duration?: number;
+    delay?: number;
+    placement?: 'top' | 'bottom' | 'right' | 'left';
+    overlay?: boolean;
+    /**
+     * Props to be passed to the Overlay used inside of Slide when overlay is true.
+     */
+    _overlay?: IOverlayProps;
+};
+export declare type ISlideFadeProps = InterfaceBoxProps<ISlideFadeProps> & {
+    in?: boolean;
+    delay?: number;
+    duration?: number;
+    offsetX?: number;
+    offsetY?: number;
+} & CustomProps<'Slide'>;
+export interface ISupportedTransitions {
+    opacity?: number;
+    translateY?: number;
+    translateX?: number;
+    scale?: number;
+    scaleX?: number;
+    scaleY?: number;
+    rotate?: string;
+}
+export interface ITransitionConfig {
+    type?: 'timing' | 'spring';
+    easing?: (value: number) => number;
+    overshootClamping?: boolean;
+    restDisplacementThreshold?: number;
+    restSpeedThreshold?: number;
+    velocity?: number | {
+        x: number;
+        y: number;
+    };
+    bounciness?: number;
+    speed?: number;
+    tension?: number;
+    friction?: number;
+    stiffness?: number;
+    mass?: number;
+    damping?: number;
+    delay?: number;
+    duration?: number;
+    useNativeDriver?: boolean;
+}
+export interface ITransitionStyleProps extends ISupportedTransitions {
+    transition?: ITransitionConfig;
+}
+export interface ITransitionProps extends ViewProps {
+    /**
+     * Callback invoked when the transition is completed.
+     */
+    onTransitionComplete?: (s: 'entered' | 'exited') => any;
+    /**
+     * Styles before the transition starts
+     */
+    initial?: ISupportedTransitions;
+    /**
+     * Entry animation styles
+     */
+    animate?: ITransitionStyleProps;
+    /**
+     * Exit animation styles
+     */
+    exit?: ITransitionStyleProps;
+    /**
+     * Determines whether to start the animation
+     */
+    visible?: boolean;
+    animationExited?: boolean;
+    children?: any;
+    as?: any;
+}
+export interface IPresenceTransitionProps extends ViewProps {
+    /**
+     * Callback invoked when the transition is completed.
+     */
+    onTransitionComplete?: (s: 'entered' | 'exited') => any;
+    /**
+     * Styles before the transition starts.
+     */
+    initial?: ISupportedTransitions;
+    /**
+     * Entry animation styles.
+     */
+    animate?: ITransitionStyleProps;
+    /**
+     * Exit animation styles.
+     */
+    exit?: ITransitionStyleProps;
+    /**
+     * Determines whether to start the animation.
+     */
+    visible?: boolean;
+    children?: ReactNode;
+    /**
+     * Accepts a Component to be rendered as Wrapper. Defaults to `View`.
+     */
+    as?: ReactNode;
+}

package/lib/typescript/components/composites/Typeahead/Typeahead.d.ts

@@ -0,0 +1,16 @@
+import React from 'react';
+import { ITypeaheadProps } from './types';
+export declare const Typeahead: React.ForwardRefExoticComponent<import("../../primitives/Box").InterfaceBoxProps<ITypeaheadProps> & {
+    options: any[];
+    renderItem?: ((item: any) => any) | undefined;
+    onChange?: ((value: string) => void) | undefined;
+    toggleIcon?: any;
+    dropdownHeight?: string | number | undefined;
+    inputValue?: string | undefined;
+    onSelectedItemChange?: ((value: any) => void) | undefined;
+    numberOfItems?: number | undefined;
+    getOptionLabel?: ((item: any) => string) | undefined;
+    getOptionKey?: ((item: any) => any) | undefined;
+    disabledKeys?: any[] | undefined;
+    label?: string | undefined;
+} & React.RefAttributes<unknown>>;

package/lib/typescript/components/composites/Typeahead/index.d.ts

@@ -0,0 +1,2 @@
+export { useTypeahead } from './useTypeahead';
+export { Typeahead } from './Typeahead';