@sendbird/uikit-react-native-foundation 1.0.1 → 1.0.2

package/lib/typescript/src/styles/createTypography.d.ts

@@ -0,0 +1,6 @@
+import type { FontAttributes, UIKitTypography } from '../types';
+export declare type UIKitTypographyOverrides = Partial<UIKitTypography> & {
+    shared?: Partial<FontAttributes>;
+};
+declare const createTypography: (overrides?: UIKitTypographyOverrides, scaleFactor?: (dp: number) => number) => UIKitTypography;
+export default createTypography;

package/lib/typescript/src/styles/getDefaultHeaderHeight.d.ts

@@ -0,0 +1,2 @@
+declare const getDefaultHeaderHeight: (isLandscape: boolean) => 56 | 48;
+export default getDefaultHeaderHeight;

package/lib/typescript/src/styles/useHeaderStyle.d.ts

@@ -0,0 +1,2 @@
+declare const useHeaderStyle: () => import("./HeaderStyleContext").HeaderStyleContextType;
+export default useHeaderStyle;

package/lib/typescript/src/theme/DarkUIKitTheme.d.ts

@@ -0,0 +1,2 @@
+declare const DarkUIKitTheme: import("..").UIKitTheme;
+export default DarkUIKitTheme;

package/lib/typescript/src/theme/LightUIKitTheme.d.ts

@@ -0,0 +1,2 @@
+declare const LightUIKitTheme: import("..").UIKitTheme;
+export default LightUIKitTheme;

package/lib/typescript/src/theme/Palette.d.ts

@@ -0,0 +1,3 @@
+import type { UIKitPalette } from '../types';
+declare const Palette: UIKitPalette;
+export default Palette;

package/lib/typescript/src/theme/UIKitThemeContext.d.ts

@@ -0,0 +1,4 @@
+import React from 'react';
+import type { UIKitTheme } from '../types';
+declare const UIKitThemeContext: React.Context<UIKitTheme | null>;
+export default UIKitThemeContext;

package/lib/typescript/src/theme/UIKitThemeProvider.d.ts

@@ -0,0 +1,7 @@
+import React from 'react';
+import type { UIKitTheme } from '../types';
+declare type Props = React.PropsWithChildren<{
+    theme?: UIKitTheme;
+}>;
+declare const UIKitThemeProvider: ({ children, theme }: Props) => JSX.Element;
+export default UIKitThemeProvider;

package/lib/typescript/src/theme/createTheme.d.ts

@@ -0,0 +1,10 @@
+import { UIKitTypographyOverrides } from '../styles/createTypography';
+import type { UIKitColors, UIKitTheme } from '../types';
+declare type Options = {
+    colorScheme: UIKitTheme['colorScheme'];
+    colors: (palette: UIKitTheme['palette']) => UIKitColors;
+    palette?: UIKitTheme['palette'];
+    typography?: UIKitTypographyOverrides;
+};
+declare const createTheme: ({ colorScheme, palette, colors: createColors, typography, }: Options) => UIKitTheme;
+export default createTheme;

package/lib/typescript/src/theme/useUIKitTheme.d.ts

@@ -0,0 +1,3 @@
+import type { UIKitTheme } from '../types';
+declare const useUIKitTheme: () => UIKitTheme;
+export default useUIKitTheme;

package/lib/typescript/src/types.d.ts

@@ -0,0 +1,167 @@
+import type { ReactElement, ReactNode } from 'react';
+import type { TextStyle } from 'react-native';
+export interface UIKitTypography {
+    h1: FontAttributes;
+    h2: FontAttributes;
+    subtitle1: FontAttributes;
+    subtitle2: FontAttributes;
+    body1: FontAttributes;
+    body2: FontAttributes;
+    body3: FontAttributes;
+    button: FontAttributes;
+    caption1: FontAttributes;
+    caption2: FontAttributes;
+    caption3: FontAttributes;
+    caption4: FontAttributes;
+}
+export declare type TypoName = keyof UIKitTypography;
+export declare type FontAttributes = Pick<TextStyle, 'fontFamily' | 'fontSize' | 'lineHeight' | 'letterSpacing' | 'fontWeight'>;
+export declare type UIKitColorScheme = 'light' | 'dark';
+export interface UIKitTheme {
+    colorScheme: UIKitColorScheme;
+    select<V>(options: {
+        [key in UIKitColorScheme | 'default']?: V;
+    }): V;
+    palette: UIKitPalette;
+    colors: UIKitColors;
+    typography: UIKitTypography;
+}
+export declare type Component = 'Header' | 'Button' | 'Dialog' | 'Input' | 'Badge' | 'Placeholder' | 'Message' | 'DateSeparator' | 'GroupChannelPreview';
+export declare type GetColorTree<Tree extends {
+    Variant: {
+        [key in Component]: string;
+    };
+    State: {
+        [key in Component]: string;
+    };
+    ColorPart: {
+        [key in Component]: string;
+    };
+}> = Tree;
+export declare type ComponentColorTree = GetColorTree<{
+    Variant: {
+        Header: 'nav';
+        Button: 'contained' | 'text';
+        Dialog: 'default';
+        Input: 'default' | 'underline';
+        Badge: 'default';
+        Placeholder: 'default';
+        Message: 'incoming' | 'outgoing';
+        DateSeparator: 'default';
+        GroupChannelPreview: 'default';
+    };
+    State: {
+        Header: 'none';
+        Button: 'enabled' | 'pressed' | 'disabled';
+        Dialog: 'none';
+        Input: 'active' | 'disabled';
+        Badge: 'none';
+        Placeholder: 'none';
+        Message: 'enabled' | 'pressed';
+        DateSeparator: 'none';
+        GroupChannelPreview: 'none';
+    };
+    ColorPart: {
+        Header: 'background' | 'borderBottom';
+        Button: 'background' | 'content';
+        Dialog: 'background' | 'text' | 'message' | 'highlight' | 'destructive';
+        Input: 'text' | 'placeholder' | 'background' | 'highlight';
+        Badge: 'text' | 'background';
+        Placeholder: 'content' | 'highlight';
+        Message: 'textMsg' | 'textEdited' | 'textSenderName' | 'textTime' | 'background';
+        DateSeparator: 'text' | 'background';
+        GroupChannelPreview: 'textTitle' | 'textTitleCaption' | 'textBody' | 'memberCount' | 'bodyIcon' | 'background' | 'coverBackground' | 'bodyIconBackground' | 'separator';
+    };
+}>;
+export declare type ComponentColors<T extends Component> = {
+    [key in ComponentColorTree['Variant'][T]]: {
+        [key in ComponentColorTree['State'][T]]: {
+            [key in ComponentColorTree['ColorPart'][T]]: string;
+        };
+    };
+};
+export interface UIKitColors {
+    primary: string;
+    secondary: string;
+    error: string;
+    background: string;
+    text: string;
+    onBackground01: string;
+    onBackground02: string;
+    onBackground03: string;
+    onBackground04: string;
+    onBackgroundReverse01: string;
+    onBackgroundReverse02: string;
+    onBackgroundReverse03: string;
+    onBackgroundReverse04: string;
+    /**
+     * UI Colors has below structure
+     * Component.{Variant}.{State}.{ColorPart}
+     * @example
+     * ```
+     *  const { colors } = useUIKitTheme();
+     *  colors.ui.button.contained.disabled.backgroundColor
+     * ```
+     * */
+    ui: {
+        header: ComponentColors<'Header'>;
+        button: ComponentColors<'Button'>;
+        dialog: ComponentColors<'Dialog'>;
+        input: ComponentColors<'Input'>;
+        badge: ComponentColors<'Badge'>;
+        placeholder: ComponentColors<'Placeholder'>;
+        message: ComponentColors<'Message'>;
+        dateSeparator: ComponentColors<'DateSeparator'>;
+        groupChannelPreview: ComponentColors<'GroupChannelPreview'>;
+    };
+}
+export declare type HeaderElement = string | ReactElement | null;
+export declare type HeaderPartProps = {
+    title?: HeaderElement;
+    right?: HeaderElement;
+    left?: HeaderElement;
+    onPressLeft?: (...params: any[]) => any;
+    onPressRight?: (...params: any[]) => any;
+};
+export declare type BaseHeaderProps<HeaderParts extends HeaderPartProps = {}, AdditionalProps = {}> = {
+    titleAlign?: 'left' | 'center' | 'right';
+    children?: ReactNode;
+} & HeaderParts & AdditionalProps;
+export interface UIKitPalette {
+    primary100: string;
+    primary200: string;
+    primary300: string;
+    primary400: string;
+    primary500: string;
+    secondary100: string;
+    secondary200: string;
+    secondary300: string;
+    secondary400: string;
+    secondary500: string;
+    error100: string;
+    error200: string;
+    error300: string;
+    error400: string;
+    error500: string;
+    background50: string;
+    background100: string;
+    background200: string;
+    background300: string;
+    background400: string;
+    background500: string;
+    background600: string;
+    background700: string;
+    overlay01: string;
+    overlay02: string;
+    information: string;
+    highlight: string;
+    transparent: 'transparent';
+    onBackgroundLight01: string;
+    onBackgroundLight02: string;
+    onBackgroundLight03: string;
+    onBackgroundLight04: string;
+    onBackgroundDark01: string;
+    onBackgroundDark02: string;
+    onBackgroundDark03: string;
+    onBackgroundDark04: string;
+}

package/lib/typescript/src/ui/ActionMenu/index.d.ts

@@ -0,0 +1,16 @@
+export declare type ActionMenuItem = {
+    title?: string;
+    menuItems: {
+        title: string;
+        onPress?: (() => Promise<void>) | (() => void);
+        onError?: () => void;
+    }[];
+};
+declare type Props = {
+    visible: boolean;
+    onHide: () => void;
+    onError?: (error: unknown) => void;
+    onDismiss?: () => void;
+} & ActionMenuItem;
+declare const ActionMenu: ({ visible, onHide, onError, onDismiss, title, menuItems }: Props) => JSX.Element;
+export default ActionMenu;

package/lib/typescript/src/ui/Alert/index.d.ts

@@ -0,0 +1,13 @@
+import { AlertButton } from 'react-native';
+export declare type AlertItem = {
+    title?: string;
+    message?: string;
+    buttons?: AlertButton[];
+};
+declare type Props = {
+    visible: boolean;
+    onHide: () => void;
+    onDismiss?: () => void;
+} & AlertItem;
+declare const Alert: ({ onDismiss, visible, onHide, title, message, buttons }: Props) => JSX.Element;
+export default Alert;

package/lib/typescript/src/ui/Avatar/AvatarGroup.d.ts

@@ -0,0 +1,8 @@
+import React from 'react';
+import { StyleProp, ViewStyle } from 'react-native';
+declare type Props = React.PropsWithChildren<{
+    size?: number;
+    containerStyle?: StyleProp<ViewStyle>;
+}>;
+declare const AvatarGroup: ({ children, containerStyle, size }: Props) => JSX.Element;
+export default AvatarGroup;

package/lib/typescript/src/ui/Avatar/AvatarIcon.d.ts

@@ -0,0 +1,10 @@
+import { StyleProp, ViewStyle } from 'react-native';
+import Icon from '../Icon';
+declare type Props = {
+    icon: keyof typeof Icon.Assets;
+    size?: number;
+    backgroundColor?: string;
+    containerStyle?: StyleProp<ViewStyle>;
+};
+declare const AvatarIcon: ({ size, icon, containerStyle, backgroundColor }: Props) => JSX.Element;
+export default AvatarIcon;

package/lib/typescript/src/ui/Avatar/index.d.ts

@@ -0,0 +1,16 @@
+import { StyleProp, ViewStyle } from 'react-native';
+import AvatarGroup from './AvatarGroup';
+import AvatarIcon from './AvatarIcon';
+declare type SubComponents = {
+    Group: typeof AvatarGroup;
+    Icon: typeof AvatarIcon;
+};
+declare type Props = {
+    uri?: string;
+    size?: number;
+    square?: boolean;
+    muted?: boolean;
+    containerStyle?: StyleProp<ViewStyle>;
+};
+declare const Avatar: ((props: Props) => JSX.Element) & SubComponents;
+export default Avatar;

package/lib/typescript/src/ui/Badge/index.d.ts

@@ -0,0 +1,11 @@
+import { StyleProp, ViewStyle } from 'react-native';
+declare type Props = {
+    count: number;
+    maxCount?: number;
+    badgeColor?: string;
+    textColor?: string;
+    style?: StyleProp<ViewStyle>;
+    size?: 'small' | 'default';
+};
+declare const Badge: ({ count, maxCount, badgeColor, textColor, style, size }: Props) => JSX.Element;
+export default Badge;

package/lib/typescript/src/ui/BottomSheet/index.d.ts

@@ -0,0 +1,18 @@
+import type Icon from '../Icon';
+export declare type BottomSheetItem = {
+    sheetItems: {
+        icon?: keyof typeof Icon.Assets;
+        iconColor?: string;
+        title: string;
+        titleColor?: string;
+        onPress: () => void;
+    }[];
+};
+declare type Props = {
+    visible: boolean;
+    onHide: () => Promise<void>;
+    onError?: (error: unknown) => void;
+    onDismiss?: () => void;
+} & BottomSheetItem;
+declare const BottomSheet: ({ onDismiss, onHide, visible, sheetItems }: Props) => JSX.Element;
+export default BottomSheet;

package/lib/typescript/src/ui/Button/index.d.ts

@@ -0,0 +1,14 @@
+import React from 'react';
+import { StyleProp, ViewStyle } from 'react-native';
+import Icon from '../Icon';
+declare type Props = React.PropsWithChildren<{
+    style?: StyleProp<ViewStyle>;
+    icon?: keyof typeof Icon.Assets;
+    variant?: 'contained' | 'text';
+    disabled?: boolean;
+    onPress?: () => void;
+    buttonColor?: string;
+    contentColor?: string;
+}>;
+declare const Button: ({ icon, variant, buttonColor, contentColor, disabled, onPress, style, children, }: Props) => JSX.Element;
+export default Button;

package/lib/typescript/src/ui/ChannelFrozenBanner/index.d.ts

@@ -0,0 +1,9 @@
+import { StyleProp, ViewStyle } from 'react-native';
+declare type Props = {
+    style?: StyleProp<ViewStyle>;
+    text?: string;
+    textColor?: string;
+    backgroundColor?: string;
+};
+declare const ChannelFrozenBanner: ({ text, backgroundColor, textColor, style }: Props) => JSX.Element;
+export default ChannelFrozenBanner;

package/lib/typescript/src/ui/Dialog/DialogBox.d.ts

@@ -0,0 +1,7 @@
+import React from 'react';
+import { StyleProp, ViewStyle } from 'react-native';
+declare type Props = React.PropsWithChildren<{
+    style?: StyleProp<ViewStyle>;
+}>;
+declare const DialogBox: ({ style, children }: Props) => JSX.Element;
+export default DialogBox;

package/lib/typescript/src/ui/Dialog/DialogSheet.d.ts

@@ -0,0 +1,17 @@
+import React from 'react';
+import { StyleProp, ViewStyle } from 'react-native';
+import Icon from '../Icon';
+declare type Props = React.PropsWithChildren<{
+    style?: StyleProp<ViewStyle>;
+}>;
+declare const DialogSheet: ((props: Props) => JSX.Element) & {
+    Item: typeof SheetItem;
+};
+export declare type SheetItemProps = {
+    icon?: keyof typeof Icon.Assets;
+    iconColor?: string;
+    title: string;
+    titleColor?: string;
+};
+declare const SheetItem: ({ icon, title, iconColor, titleColor }: SheetItemProps) => JSX.Element;
+export default DialogSheet;

package/lib/typescript/src/ui/Dialog/index.d.ts

@@ -0,0 +1,46 @@
+import React from 'react';
+import type { ActionMenuItem } from '../ActionMenu';
+import type { AlertItem } from '../Alert';
+import type { BottomSheetItem } from '../BottomSheet';
+import type { PromptItem } from '../Prompt';
+declare type DialogJob = {
+    type: 'ActionMenu';
+    props: ActionMenuItem;
+} | {
+    type: 'Alert';
+    props: AlertItem;
+} | {
+    type: 'Prompt';
+    props: PromptItem;
+} | {
+    type: 'BottomSheet';
+    props: BottomSheetItem;
+};
+declare type DialogPropsBy<T extends DialogJob['type'], U extends DialogJob = DialogJob> = U extends {
+    type: T;
+    props: infer P;
+} ? P : never;
+declare type DialogContextType = {
+    openMenu: (props: DialogPropsBy<'ActionMenu'>) => void;
+    alert: (props: DialogPropsBy<'Alert'>) => void;
+    openPrompt: (props: DialogPropsBy<'Prompt'>) => void;
+    openSheet: (props: DialogPropsBy<'BottomSheet'>) => void;
+};
+declare type Props = React.PropsWithChildren<{
+    defaultLabels?: {
+        alert?: {
+            ok?: string;
+        };
+        prompt?: {
+            placeholder?: string;
+            ok?: string;
+            cancel?: string;
+        };
+    };
+}>;
+export declare const DialogProvider: ({ defaultLabels, children }: Props) => JSX.Element;
+export declare const useActionMenu: () => Pick<DialogContextType, "openMenu">;
+export declare const useAlert: () => Pick<DialogContextType, "alert">;
+export declare const usePrompt: () => Pick<DialogContextType, "openPrompt">;
+export declare const useBottomSheet: () => Pick<DialogContextType, "openSheet">;
+export {};

package/lib/typescript/src/ui/Divider/index.d.ts

@@ -0,0 +1,7 @@
+import { StyleProp, ViewStyle } from 'react-native';
+declare type Props = {
+    style?: StyleProp<ViewStyle>;
+    space?: number;
+};
+declare const Divider: ({ style, space }: Props) => JSX.Element;
+export default Divider;

package/lib/typescript/src/ui/GroupChannelPreview/index.d.ts

@@ -0,0 +1,17 @@
+import React from 'react';
+import Icon from '../Icon';
+declare type Props = {
+    customCover?: React.ReactElement;
+    coverUrl: string;
+    title: string;
+    titleCaption: string;
+    bodyIcon?: keyof typeof Icon.Assets;
+    body: string;
+    memberCount?: number;
+    badgeCount: number;
+    maxBadgeCount?: number;
+    frozen?: boolean;
+    notificationOff?: boolean;
+};
+declare const _default: React.MemoExoticComponent<({ customCover, coverUrl, memberCount, badgeCount, maxBadgeCount, body, bodyIcon, title, titleCaption, frozen, notificationOff, }: Props) => JSX.Element>;
+export default _default;

package/lib/typescript/src/ui/Header/index.d.ts

@@ -0,0 +1,25 @@
+import React from 'react';
+import { TouchableOpacityProps } from 'react-native';
+import type { BaseHeaderProps } from '../../index';
+import { TextProps } from '../Text';
+declare type HeaderElement = string | React.ReactElement | null;
+declare type HeaderProps = BaseHeaderProps<{
+    title?: HeaderElement;
+    left?: HeaderElement;
+    right?: HeaderElement;
+    onPressLeft?: () => void;
+    onPressRight?: () => void;
+}, {
+    clearTitleMargin?: boolean;
+}>;
+declare const Header: ((props: HeaderProps) => JSX.Element) & {
+    Button: typeof HeaderButton;
+    Title: typeof HeaderTitle;
+    Subtitle: typeof HeaderSubtitle;
+};
+declare const HeaderTitle: ({ children, style, ...props }: TextProps) => JSX.Element;
+declare const HeaderSubtitle: ({ children, style, ...props }: TextProps) => JSX.Element;
+declare const HeaderButton: ({ children, disabled, onPress, color, ...props }: TouchableOpacityProps & {
+    color?: string | undefined;
+}) => JSX.Element;
+export default Header;

package/lib/typescript/src/ui/Icon/index.d.ts

@@ -0,0 +1,14 @@
+import { ImageStyle, StyleProp, ViewStyle } from 'react-native';
+import IconAssets from '../../assets/icon';
+declare type IconNames = keyof typeof IconAssets;
+declare type Props = {
+    icon: IconNames;
+    color?: string;
+    size?: number;
+    style?: StyleProp<ImageStyle>;
+    containerStyle?: StyleProp<ViewStyle>;
+};
+declare const Icon: ((props: Props) => JSX.Element) & {
+    Assets: typeof IconAssets;
+};
+export default Icon;

package/lib/typescript/src/ui/LoadingSpinner/index.d.ts

@@ -0,0 +1,8 @@
+import { StyleProp, ViewStyle } from 'react-native';
+declare type Props = {
+    size?: number;
+    color?: string;
+    style?: StyleProp<ViewStyle>;
+};
+declare const LoadingSpinner: ({ size, color, style }: Props) => JSX.Element;
+export default LoadingSpinner;

package/lib/typescript/src/ui/MenuBar/index.d.ts

@@ -0,0 +1,15 @@
+import React from 'react';
+import Icon from '../Icon';
+export declare type MenuBarProps = {
+    variant?: 'default' | 'contained';
+    onPress: () => void;
+    disabled?: boolean;
+    icon: keyof typeof Icon.Assets;
+    iconColor?: string;
+    iconBackgroundColor?: string;
+    name: string;
+    actionLabel?: string;
+    actionItem?: React.ReactNode;
+};
+declare const MenuBar: ({ variant, disabled, onPress, name, icon, iconColor, iconBackgroundColor, actionLabel, actionItem, }: MenuBarProps) => JSX.Element;
+export default MenuBar;

package/lib/typescript/src/ui/Modal/index.d.ts

@@ -0,0 +1,17 @@
+import { ModalProps, StyleProp, ViewStyle } from 'react-native';
+declare type Props = {
+    type?: 'slide' | 'fade';
+    onClose: () => void;
+    backgroundStyle?: StyleProp<ViewStyle>;
+    disableBackgroundClose?: boolean;
+    enableKeyboardAvoid?: boolean;
+} & Omit<ModalProps, 'animationType' | 'onRequestClose'>;
+/**
+ * Modal Open: Triggered by Modal.props.visible state changed to true
+ * - visible true -> modalVisible true -> animation start
+ *
+ * Modal Close: Triggered by Modal.props.onClose() call
+ * - Modal.props.onClose() -> visible false -> animation start -> modalVisible false
+ * */
+declare const Modal: ({ children, onClose, backgroundStyle, onDismiss, type, visible, disableBackgroundClose, enableKeyboardAvoid, statusBarTranslucent, ...props }: Props) => JSX.Element;
+export default Modal;

package/lib/typescript/src/ui/Placeholder/index.d.ts

@@ -0,0 +1,10 @@
+import Icon from '../Icon';
+declare type Props = {
+    loading?: boolean;
+    icon: keyof typeof Icon.Assets;
+    message?: string;
+    errorRetryLabel?: string;
+    onPressRetry?: () => void;
+};
+declare const Placeholder: ({ icon, loading, message, errorRetryLabel, onPressRetry }: Props) => JSX.Element;
+export default Placeholder;

package/lib/typescript/src/ui/Prompt/index.d.ts

@@ -0,0 +1,17 @@
+export declare type PromptItem = {
+    title: string;
+    placeholder?: string;
+    defaultValue?: string;
+    onSubmit?: (text: string) => void;
+    submitLabel?: string;
+    onCancel?: () => void;
+    cancelLabel?: string;
+};
+declare type Props = {
+    visible: boolean;
+    onHide: () => void;
+    onDismiss?: () => void;
+    autoFocus?: boolean;
+} & PromptItem;
+declare const Prompt: ({ onDismiss, visible, onHide, autoFocus, title, defaultValue, placeholder, onSubmit, onCancel, submitLabel, cancelLabel, }: Props) => JSX.Element;
+export default Prompt;

package/lib/typescript/src/ui/Switch/index.d.ts

@@ -0,0 +1,11 @@
+import React from 'react';
+declare type SwitchProps = React.PropsWithChildren<{
+    trackColor?: string;
+    thumbColor?: string;
+    inactiveThumbColor?: string;
+    inactiveTrackColor?: string;
+    value: boolean;
+    onChangeValue: (val: boolean) => void;
+}>;
+declare const Switch: ({ value, onChangeValue, inactiveThumbColor, inactiveTrackColor, trackColor, thumbColor, }: SwitchProps) => JSX.Element;
+export default Switch;

package/lib/typescript/src/ui/Text/index.d.ts

@@ -0,0 +1,8 @@
+import { TextProps as RNTextProps } from 'react-native';
+import type { TypoName, UIKitTheme } from '../../types';
+declare type TypographyProps = Partial<Record<TypoName, boolean>>;
+export declare type TextProps = RNTextProps & TypographyProps & {
+    color?: ((colors: UIKitTheme['colors']) => string) | string;
+};
+declare const Text: ({ children, color, style, ...props }: TextProps) => JSX.Element;
+export default Text;

package/lib/typescript/src/ui/TextInput/index.d.ts

@@ -0,0 +1,6 @@
+import React from 'react';
+import { TextInput as RNTextInput, TextInputProps } from 'react-native';
+declare const TextInput: React.ForwardRefExoticComponent<{
+    variant?: "default" | "underline" | undefined;
+} & TextInputProps & React.RefAttributes<RNTextInput>>;
+export default TextInput;

package/lib/typescript/src/ui/Toast/index.d.ts

@@ -0,0 +1,18 @@
+import React from 'react';
+declare type ToastType = 'normal' | 'error' | 'success';
+declare type Context = {
+    show(text: string, type?: ToastType): void;
+};
+declare type Props = React.PropsWithChildren<{
+    top?: number;
+    bottom?: number;
+    visible: boolean;
+    type: ToastType;
+    children: string;
+}>;
+declare const Toast: ({ visible, type, children, top, bottom }: Props) => JSX.Element;
+export declare const ToastProvider: ({ children, dismissTimeout, }: React.PropsWithChildren<{
+    dismissTimeout?: number | undefined;
+}>) => JSX.Element;
+export declare const useToast: () => Context;
+export default Toast;

package/lib/typescript/src/ui/URLParsedText/index.d.ts

@@ -0,0 +1,8 @@
+import type { TextProps } from '../Text';
+declare type OnPressUrl = (url: string, httpProtocol: boolean) => void;
+declare type Props = TextProps & {
+    onPressUrl?: OnPressUrl;
+    strict?: boolean;
+};
+declare const URLParsedText: ({ children, onPressUrl, strict, ...props }: Props) => JSX.Element;
+export default URLParsedText;