@livelike/react-native/index.d.ts

LiveLike React Native package

/// <reference types="react" />
import * as React from 'react';
import React__default, { RefObject, PropsWithChildren, ComponentType, ReactNode } from 'react';
import * as react_native from 'react-native';
import { ImageSourcePropType, ViewStyle, ImageStyle, TextStyle, ColorSchemeName, StyleProp, FlatList, TextInput, ImageProps, Animated, TextProps } from 'react-native';
import * as _livelike_javascript from '@livelike/javascript';
import { IChatMessageResponsePayload as IChatMessageResponsePayload$1, IChatUserMessageResponsePayload as IChatUserMessageResponsePayload$1, IWidgetOptionItem as IWidgetOptionItem$1, IReactionEmoji as IReactionEmoji$1, ICoreInitApiArgs, IUserProfile, IMessageListIteratorResult, ISendMessageArgs, IChatRoomPayload, IUserReaction, IWidgetChoiceItem as IWidgetChoiceItem$1, IWidgetPayload as IWidgetPayload$1, IWidgetInteraction as IWidgetInteraction$1, IWidgetEarnableReward as IWidgetEarnableReward$1, INumberPredictionItemOption, WidgetKind as WidgetKind$1, IGif, IUserReactionCountDetail, INumberPredictionItem, ISliderInteractionItem, ITextAskInteractionItem, IWidgetKindInteractionsMap, IRewardTransaction } from '@livelike/javascript';
import { SliderProps } from '@miblanchard/react-native-slider';
import { ComponentStyleProp as ComponentStyleProp$1 } from '@livelike/react-native';

type IChatMessage = IChatMessageResponsePayload$1 & {
    isDeleted?: boolean;
};
type IChatUserMessage = IChatUserMessageResponsePayload$1 & {
    isDeleted?: boolean;
};

declare enum LLThemeType {
    DARK = "dark",
    LIGHT = "light"
}
type LLTheme = {
    text: string;
    secondaryText: string;
    background: string;
    secondaryBackground: string;
    popoverBackground: string;
    primaryButtonBackground: string;
    primaryPressedButtonBackground: string;
    primaryButtonText: string;
    border: string;
    info: string;
    error: string;
    widgetBackground: string;
    widgetOption: string;
    widgetSelectedOption: string;
    disabledButtonBackground: string;
    disabledButtonText: string;
    correct: string;
    incorrect: string;
    correctIncorrectText: string;
};
type LLThemes = Record<LLThemeType, LLTheme>;
type LLThemeAssets = {
    avatar: ImageSourcePropType;
    send: ImageSourcePropType;
    gif: ImageSourcePropType;
    sticker: ImageSourcePropType;
    close: ImageSourcePropType;
    bin: ImageSourcePropType;
    blockUser: ImageSourcePropType;
    flag: ImageSourcePropType;
    reaction: ImageSourcePropType;
    themeSwitch: ImageSourcePropType;
};

declare enum PopoverType {
    Menu = "menu",
    Reactions = "reactions"
}
type PopoverDetail = {
    messageId: string;
    popoverType: PopoverType | undefined;
};

declare enum BannerType {
    INFO = "info",
    ERROR = "ERROR"
}
type Banner = {
    type: BannerType;
    id: string;
    message: string;
};

declare enum WidgetResultState {
    SHOWN = "shown",
    HIDDEN = "hidden"
}
declare enum WidgetUIPhase {
    INTERACTIVE = "interactive",
    SUBMITTING = "submitting",
    SUBMITTED = "submitted",
    INTERACTIVE_TIMED_OUT = "interactive-timed-out",
    EXPIRED = "expired",
    FOLLOW_UP_PUBLISHED = "follow-up-published"
}
declare enum WidgetMode {
    POPUP = "popup",
    INTERACTIVE_TIMELINE = "interactive-timeline"
}

type LLFonts = {
    /** for fontWeight: 400 (or normal) */
    regular?: string;
    /** for fontStyle: "italic"  */
    italic?: string;
    /** for fontWeight: 100  */
    thin?: string;
    /** for fontWeight: 100 & fontStyle: "italic"  */
    thinItalic?: string;
    /** for fontWeight: 200  */
    extraLight?: string;
    /** for fontWeight: 200 & fontStyle: "italic"  */
    extraLightItalic?: string;
    /** for fontWeight: 300  */
    light?: string;
    /** for fontWeight: 300 & fontStyle: "italic"  */
    lightItalic?: string;
    /** for fontWeight: 500  */
    medium?: string;
    /** for fontWeight: 500 & fontStyle: "italic"  */
    mediumItalic?: string;
    /** for fontWeight: 600  */
    semiBold?: string;
    /** for fontWeight: 600 & fontStyle: "italic"  */
    semiBoldItalic?: string;
    /** for fontWeight: 700  */
    bold?: string;
    /** for fontWeight: 700 & fontStyle: "italic"  */
    boldItalic?: string;
    /** for fontWeight: 800  */
    extraBold?: string;
    /** for fontWeight: 800 & fontStyle: "italic"  */
    extraBoldItalic?: string;
    /** for fontWeight: 900  */
    black?: string;
    /** for fontWeight: 900 & fontStyle: "italic"  */
    blackItalic?: string;
};
type FontWeightType = 'thin' | 'extraLight' | 'light' | 'regular' | 'bold' | 'semiBold' | 'extraBold' | 'black';
type FontFamilyType = FontWeightType | `${FontWeightType}Italic` | 'italic';

type LLComponentStyleFn<TStyles> = (arg: {
    theme: LLTheme;
    fonts: LLFonts;
}) => TStyles;
type ComponentStyleProp<TStyles> = {
    styles?: Partial<TStyles>;
};
type createStylesArg<TStyles> = {
    componentStyles: TStyles;
    stylesProp?: Partial<TStyles>;
};

type TrackNumberPredictionWidgetInteractedArgs = {
    value: number;
    widgetOption: IWidgetOptionItem$1;
};

type LLChatMessageItemHeaderStyles = {
    headerContainer: ViewStyle;
    avatarImage: ImageStyle;
    titleContainer: ViewStyle;
    username: TextStyle;
    ownUsername: TextStyle;
    timestamp: TextStyle;
    ownTimestamp: TextStyle;
};
type LLChatMessageItemHeaderProps = ComponentStyleProp<LLChatMessageItemHeaderStyles> & {
    message: IChatUserMessage;
    isSelfMessage: boolean;
    formatMessageTimestamp?: (date: string) => string;
};
declare function LLChatMessageItemHeader({ message: messageDetails, isSelfMessage, styles: stylesProp, formatMessageTimestamp, }: LLChatMessageItemHeaderProps): React__default.JSX.Element;

type LLChatMessageItemBodyTextStyles = {
    text: TextStyle;
    deletedMessageText: TextStyle;
    selfMessageText: TextStyle;
    stickerImage: ImageStyle;
};
type LLChatMessageItemBodyTextProps = ComponentStyleProp<LLChatMessageItemBodyTextStyles> & {
    message: string;
    isDeleted: boolean;
    isSelfMessage: boolean;
};
declare const LLChatMessageItemBodyText: React__default.MemoExoticComponent<({ message, styles: stylesProp, isDeleted, isSelfMessage, }: LLChatMessageItemBodyTextProps) => React__default.JSX.Element>;

type LLChatMessageItemBodyStyles = {
    textContainer: ViewStyle;
    selfMessageTextContainer: ViewStyle;
    textContent: ViewStyle;
};
type LLChatMessageItemBodyProps = ComponentStyleProp<LLChatMessageItemBodyStyles> & {
    message: IChatUserMessage;
    isSelfMessage: boolean;
    ChatMessageItemBodyText?: typeof LLChatMessageItemBodyText;
    ChatMessageItemBodyTextStyles?: LLChatMessageItemBodyTextProps['styles'];
};
declare function LLChatMessageItemBody({ message: messageDetails, isSelfMessage, styles: stylesProp, ChatMessageItemBodyTextStyles, ChatMessageItemBodyText, }: LLChatMessageItemBodyProps): React__default.JSX.Element;

type LLReactionPickerItemStyles = {
    reactionIcon: ImageStyle;
};
type LLReactionPickerItemProps = ComponentStyleProp<LLReactionPickerItemStyles> & {
    reaction: IReactionEmoji$1;
    onPress: (id: string) => void;
};
declare const LLReactionPickerItem: ({ reaction, styles: stylesProp, onPress, }: LLReactionPickerItemProps) => React__default.JSX.Element;

type LLReactionPickerStyles = {
    pickerContainer: ViewStyle;
};
type LLReactionPickerProps = ComponentStyleProp<LLReactionPickerStyles> & {
    visible?: boolean;
    reactionSpaceId?: string;
    onPress: (reactionId: string) => void;
    ReactionItemComponentStyles?: LLReactionPickerItemProps['styles'];
    ReactionItemComponent?: typeof LLReactionPickerItem;
    onReactionPanelOpen?: () => void;
    onReactionPanelClose?: () => void;
};
/**
 * @description Provides stock UI for the Reaction picker component.
 * @param {Function} onPanelOpen - A callback function to be called when the panel opens. It is used for tracking analytics events when the component becomes visible.
 * @param {Function} onPanelClose - A callback function to be called when the panel closes. It is used for tracking analytics events when the component is unmounted as it becomes invisible.
 * @returns {JSX.Element} - Stock UI for the Reaction picker.
 */
declare function LLReactionPicker({ visible, styles: stylesProp, reactionSpaceId, onPress, ReactionItemComponentStyles, ReactionItemComponent, onReactionPanelOpen, onReactionPanelClose, }: LLReactionPickerProps): React__default.JSX.Element;

declare function useInit(initArg: ICoreInitApiArgs): {
    profile: IUserProfile;
    loaded: boolean;
};

type LLStoreUnsubscriber = () => void;
type LLStoreListener<TValue> = (value: TValue) => void;
type LLStore<TValue> = {
    value: TValue;
    get: () => TValue;
    set: (value: TValue) => void;
    notify: () => void;
    listeners: LLStoreListener<TValue>[];
    subscribe: (cb: LLStoreListener<TValue>) => LLStoreUnsubscriber;
};

type ChatMessagesState = {
    chatMessagesLoaded?: boolean;
    chatMessages: IChatMessage[];
    messageListIterator?: () => IMessageListIteratorResult;
    userAvatarUrl?: string;
};
type UpdateChatConfigActionArg = {
    roomId: string;
    userAvatarUrl?: string;
};

type UseChatMessageArg = {
    roomId: string;
};
declare function useChatRoomState({ roomId }: UseChatMessageArg): ChatMessagesState;
/**
 * @deprecated Use useChatRoomState hook instead
 */
declare function useChatMessages({ roomId }: UseChatMessageArg): ChatMessagesState;

declare function useChatMessagesEffect({ roomId }: {
    roomId: any;
}): void;

declare function useChatMessageActions({ roomId }: {
    roomId: any;
}): {
    sendChatMessage: (messageArgs: ISendMessageArgs) => Promise<any>;
    deleteChatMessage: ({ roomId, chatMessage }: {
        roomId: any;
        chatMessage: any;
    }) => void;
};

type UseChatRoomArg = {
    roomId: string;
};
declare function useChatRoom({ roomId }: UseChatRoomArg): {
    chatRoom: IChatRoomPayload;
};

declare function useStickerPicker(): {
    selectedStickerPackId: string;
    setSelectedStickerPackId: React.Dispatch<React.SetStateAction<string>>;
};

interface IAttribute {
    key: string;
    value: string;
}

declare enum ChatMessageEvent {
    MESSAGE_CREATED = "message-created",
    IMAGE_CREATED = "image-created",
    CUSTOM_MESSAGE_CREATED = "custom-message-created",
    MESSAGE_DELETED = "message-deleted",
    IMAGE_DELETED = "image-deleted",
    CHATROOM_UPDATED = "chatroom-updated"
}
declare const ChatUserMessageEventType: readonly [ChatMessageEvent.MESSAGE_CREATED, ChatMessageEvent.IMAGE_CREATED, ChatMessageEvent.MESSAGE_DELETED, ChatMessageEvent.IMAGE_DELETED, ChatMessageEvent.CHATROOM_UPDATED];

declare enum WidgetKind {
    ALERT = "alert",
    EMOJI_SLIDER = "emoji-slider",
    SOCIAL_EMBED = "social-embed",
    RICH_POST = "rich-post",
    CHEER_METER = "cheer-meter",
    TEXT_POLL = "text-poll",
    IMAGE_POLL = "image-poll",
    TEXT_QUIZ = "text-quiz",
    IMAGE_QUIZ = "image-quiz",
    TEXT_PREDICTION = "text-prediction",
    TEXT_PREDICTION_FOLLOW_UP = "text-prediction-follow-up",
    IMAGE_PREDICTION = "image-prediction",
    IMAGE_PREDICTION_FOLLOW_UP = "image-prediction-follow-up",
    TEXT_ASK = "text-ask",
    VIDEO_ALERT = "video-alert",
    TEXT_NUMBER_PREDICTION = "text-number-prediction",
    TEXT_NUMBER_PREDICTION_FOLLOW_UP = "text-number-prediction-follow-up",
    IMAGE_NUMBER_PREDICTION = "image-number-prediction",
    IMAGE_NUMBER_PREDICTION_FOLLOW_UP = "image-number-prediction-follow-up"
}

interface ISponsorPayload {
    /** sponsor resource id */
    id: string;
    /** sponsor resource url */
    url: string;
    /** application id */
    client_id: string;
    /** name of the sponsor */
    name: string;
    /** logo of the sponsor */
    logo_url: string;
    /** brand color of the sponsor */
    brand_color: string | null;
    /** sponsor click url */
    clickthrough_url: string | null;
}

interface IWidgetEarnableReward {
    reward_action_key: string;
    reward_item_amount: number;
    reward_item_id: string;
    reward_item_name: string;
}
interface IWidgetOptionItem {
    id: string;
    url: string;
    description?: string;
    image_url?: string;
    vote_count?: number;
    vote_url?: string;
    number?: number;
    /** for prediction widget if option is correct */
    is_correct?: boolean;
    /** for number prediction widget */
    correct_number?: number;
    earnable_rewards: IWidgetEarnableReward[];
    /** The ID of the reward item to give when this option is correct */
    reward_item_id?: string | null;
    /** The amount of the reward item to give when this option is correct */
    reward_item_amount?: number;
}
interface IWidgetChoiceItem {
    id: string;
    description?: string;
    image_url?: string;
    /** Total number of answers */
    answer_count: number;
    answer_url: string;
    /** If answer is correct */
    is_correct: boolean;
    translatable_fields: string[];
}
interface IWidgetAttribute extends IAttribute {
}
interface IWidgetPayload {
    id: string;
    kind: WidgetKind;
    /** application Id */
    client_id: string;
    /** Id of program the widget was created in */
    program_id: string;
    /** When widget was created */
    created_at: string;
    /** Widget duration */
    timeout: string;
    /** Sync time */
    program_date_time: string | null;
    /** Delay for when widget is published */
    publish_delay: string;
    /** User that created the widget */
    created_by: {
        id: string;
        name: string | null;
        image_url: string | null;
    };
    /** Widget reactions */
    reactions: IWidgetReaction[] | null;
    /** Widget custom data */
    custom_data?: string;
    /** Time widget was published */
    published_at?: string | null;
    /** Time widget was scheduled */
    scheduled_at?: string | null;
    /** Follow up widget payload for prediction widgets */
    follow_ups?: IWidgetPayload[];
    /** follow up url used to create followUp widget */
    follow_up_url?: string;
    /** Widget question */
    question?: string;
    /** Widget options array */
    options?: IWidgetOptionItem[];
    /** Widget choice array */
    choices?: IWidgetChoiceItem[];
    /** Follow Up Widget Text Prediction Id */
    text_prediction_id?: string;
    /** Follow Up Widget Image Prediction Id */
    image_prediction_id?: string;
    /** Follow Up Widget Text Number Prediction Id */
    text_number_prediction_id?: string;
    /** Follow Up Widget Image Number Prediction Id */
    image_number_prediction_id?: string;
    sponsors: ISponsorPayload[];
    url: string;
    subscribe_channel: string;
    interaction_url: string;
    impression_url: string;
    impression_count: number;
    unique_impression_count: number;
    /** total users engaged on the widget */
    engagement_count: number;
    engagement_percent: string;
    status: 'pending' | 'published' | 'in-flight';
    /** url to be used to schedule a widget for publishing */
    schedule_url: string;
    rewards_url: string | null;
    timetoken?: string;
    /** claim url that could be invoked to claim prediction rewards */
    claim_url?: string;
    reply_url?: string;
    /** vote_url used in the case of emoji slider and number prediction widget */
    vote_url?: string;
    earnable_rewards: IWidgetEarnableReward[];
    /** dateTime in UTC where after this dateTime,  widget is not interactable */
    interactive_until: string | null;
    widget_attributes: IWidgetAttribute[];
    pubnub_enabled: boolean;
    widget_interactions_url_template: string;
    /** ask widget or alert widget title */
    title?: string;
    /** ask widget prompt */
    prompt?: string;
    /** ask widget confirmation message */
    confirmation_message?: string;
    /** emoji slider attribute */
    average_magnitude?: string;
    /** emoji slider attribute */
    initial_magnitude?: string;
    /** alert widget widget text if present */
    text?: string;
    /** alert widget image url if present */
    image_url?: string;
    /** alert widget link label if present */
    link_label?: string;
    /** alert widget link url if present */
    link_url?: string;
    /** video on demand playback time in milliseconds */
    playback_time_ms?: number;
    /** correct option id for prediction widget */
    correct_option_id?: string;
    /** url to get text prediction widget details  */
    text_prediction_url?: string;
    /** url to get image prediction widget details  */
    image_prediction_url?: string;
    /** url to get image number prediction widget details */
    image_number_prediction_url?: string;
    items?: SocialEmbedItem[];
    comment?: string;
}
interface SocialEmbedItem {
    url: string;
    id: string;
    oembed: Oembed;
}
interface Oembed {
    provider_url: string;
    version: string;
    author_name: string;
    author_url: string;
    html: string;
    width: number;
    height?: number | null;
    url: string;
    cache_age: string;
    type: string;
    provider_name: string;
    title: string;
}
interface IWidgetReaction {
    /** Total reaction count */
    count: number;
    /** Reaction image url */
    file: string;
    /** Reaction id */
    id: string;
    /** Reaction file mimetype */
    mimetype: string;
    /** Reaction name */
    name: string;
    react_url: string;
    sequence: number;
}
interface IWidgetInteraction {
    id?: string;
    created_at: string;
    widget_kind: WidgetKind;
    url: string;
    option_id?: string;
    choice_id?: string;
    profile_id: string;
    widget_id: string;
    text?: string;
    votes?: IWidgetInteractionVoteArgs[];
    /** claim token present for prediction interaction */
    claim_token?: string;
    /** magnitude present for emoji slider */
    magnitude?: number;
    /** vote_count present for cheer meter widget */
    vote_count?: number;
}
interface IWidgetInteractionVoteArgs {
    id: string;
    created_at: string;
    number: number;
    option_id: string;
    url: string;
}

interface IMessageReaction {
    actionTimetoken: string;
    uuid: string;
    user_reaction_id: string;
}
interface IMessageReactions {
    [reactionId: string]: IMessageReaction[];
}
type DateTime = Date | string | number;
interface IBaseMessageResponsePayload {
    id: string;
    chat_room_id: string;
    sender_id: string;
    sender_nickname: string;
    sender_image_url?: string | null;
    sender_profile_url: string;
    badge_image_url?: string | null;
    created_at: string;
    program_date_time: DateTime | null;
    timetoken?: string;
    reactions?: IMessageReactions;
}
interface IMessageRequestPayload {
    client_message_id: string;
    message_event: ChatMessageEvent.IMAGE_CREATED | ChatMessageEvent.MESSAGE_CREATED;
    chat_room_id: string;
    sender_id: string;
    sender_nickname: string;
    sender_image_url?: string | null;
    sender_profile_url: string;
    badge_image_url?: string | null;
    program_date_time: DateTime | null;
    image_url?: string;
    image_width?: number;
    image_height?: number;
    message?: string;
    message_metadata: Record<string, unknown> | null;
}
interface IMessageResponsePayload extends Omit<IMessageRequestPayload, 'message_event'>, IBaseMessageResponsePayload {
    content_filter: string[];
    reactions?: IMessageReactions;
    filtered_message: string | null;
    filtered_sender_nickname: string | null;
    timetoken?: string;
    isFiltered?: boolean;
    message_event: (typeof ChatUserMessageEventType)[number];
}
type IQuoteMessagePropType = IMessageResponsePayload | Omit<IQuoteMessageResponsePayload, 'quote_message' | 'reactions'>;
interface IQuoteMessagePayload {
    quote_message: IQuoteMessagePropType;
    quote_message_id: string;
}
type IQuoteMessageResponsePayload = IQuoteMessagePayload & IMessageResponsePayload;
type IChatUserMessageResponsePayload = IMessageResponsePayload | IQuoteMessageResponsePayload;
type IChatMessageResponsePayload = IChatUserMessageResponsePayload | ICustomMessageResponsePayload;
interface ICustomMessageRequestPayload {
    program_date_time: DateTime | null;
    custom_data: string;
}
interface ICustomMessageResponsePayload extends ICustomMessageRequestPayload, IBaseMessageResponsePayload {
    message_event: ChatMessageEvent.CUSTOM_MESSAGE_CREATED;
}

interface IReactionEmoji {
    file: string;
    id: string;
    mimetype: string;
    name: string;
}
interface IReactionPack {
    id: string;
    name: string;
    url: string;
    emojis: IReactionEmoji[];
}

interface IStickerEmoji {
    file: string;
    id: string;
    mimetype: string;
    pack_id: string;
    pack_name: string;
    pack_url: string;
    shortcode: string;
    url: string;
}
interface IStickerPack {
    client_id: string;
    file: string;
    id: string;
    mimetype: string;
    name: string;
    stickers: IStickerEmoji[];
    stickers_url: string;
    url: string;
}

declare global {
    interface Window {
        PTEST: any;
    }
}

declare function useStickerPacks(): {
    stickerPacks: IStickerPack[];
};

declare function useLoadStickerPacksEffect(): void;

type UseThemeArg = {
    themeType?: ColorSchemeName;
};
declare function useTheme({ themeType: themeTypeArg }?: UseThemeArg): {
    themeType: LLThemeType | ColorSchemeName;
    themes: LLThemes;
    themeAssets: LLThemeAssets;
    theme: LLTheme;
    setThemeType: (newThemeType: LLThemeType) => void;
    setThemes: (_themes: LLThemes) => void;
};

type SetThemeFontsActionArg = {
    fonts: LLFonts;
};

type UpdateUserReactionActionArg = {
    reactionSpaceId: string;
    userReaction: Pick<IUserReaction, 'id' | 'reacted_by_id' | 'reaction_id' | 'target_id'>;
    profileId: string;
};

type WidgetState = {
    widgetPayload: IWidgetPayload$1;
    widgetUIPhase?: WidgetUIPhase;
    widgetInteractions?: IWidgetInteraction$1[];
    selectedOptionIndex?: number;
    widgetResultState?: WidgetResultState;
    widgetRewards?: IWidgetEarnableReward$1[];
    isTimelineWidget?: boolean;
};
type BaseWidgetActionArgs = {
    widgetId: string;
};
type UpdateWidgetPhaseActionArgs = BaseWidgetActionArgs & {
    widgetUIPhase: WidgetUIPhase;
};
type UpdateWidgetChoicesActionArgs = BaseWidgetActionArgs & {
    widgetChoices: Pick<IWidgetChoiceItem$1, 'id' | 'answer_count'>[];
};
type UpdateWidgetOptionsActionArgs = BaseWidgetActionArgs & {
    widgetOptions: Pick<IWidgetOptionItem$1, 'id' | 'vote_count'>[];
};
type UpdateSelectedOptionIndexActionArgs = BaseWidgetActionArgs & {
    selectedOptionIndex: number;
};
type UpdateWidgetResultStateActionArgs = BaseWidgetActionArgs & {
    widgetResultState: WidgetResultState;
};
type UpdateWidgetStateActionArgs = BaseWidgetActionArgs & {
    widgetState: Partial<WidgetState>;
};
type UpdateWidgetAverageMagnitudeArgs = BaseWidgetActionArgs & {
    averageMagnitude: string;
};

type IUpdateNumberPredictionOptionActionArg = {
    widgetId: string;
    numberOption: INumberPredictionItemOption;
    optionIndex: number;
};

type IUpdateSliderMagnitudeAction = {
    widgetId: string;
    magnitude: number;
};

type TimelineWidgetState = {
    widgetId: string;
    widgetKind: WidgetKind$1;
};
type TimelineWidgetsState = {
    widgets: TimelineWidgetState[];
};
type BaseTimelineWidgetsActionArgs = {
    programId: string;
};
type updateTimelineWidgetStateActionArgs = BaseTimelineWidgetsActionArgs & {
    widgetTimelineState: TimelineWidgetsState;
};
type UpdateTimelineWidgetsActionArgs = BaseTimelineWidgetsActionArgs & {
    widgets: TimelineWidgetState[];
    prepend?: boolean;
};

type IUpdateTextAskInputTextAction = {
    widgetId: string;
    inputText: string;
};

declare function useFonts(): {
    fonts: LLFonts;
    setFonts: ({ fonts }: SetThemeFontsActionArg) => void;
};

type UseFontFamilyArgs = {
    style: StyleProp<TextStyle>;
};
/**
 * @description useFontFamily hook returns an evaluated fontFamily based on fontWeight and fontStyle
 * This is useful in case of custom fonts.
 * @returns fontFamily and fontFamilyType
 */
declare function useFontFamily({ style }: UseFontFamilyArgs): {
    fontFamily: FontWeightType;
    fontFamilyType: FontFamilyType;
};

type UseStylesArg<TStyles> = {
    componentStylesFn: LLComponentStyleFn<TStyles>;
    stylesProp?: Partial<TStyles>;
};
declare function useStyles<TStyles>({ componentStylesFn, stylesProp, }: UseStylesArg<TStyles>): TStyles;

declare function useApi<ApiResponse = unknown>(apiFunction: () => Promise<ApiResponse>): {
    data: ApiResponse;
    error: string;
    isLoading: boolean;
    onApi: () => Promise<ApiResponse>;
};

type GifPickerState = {
    gifImages: IGif[];
    isLoading: boolean;
    error: null;
};
declare function useGifPicker(): {
    isLoading: boolean;
    gifImages: IGif[];
    loadNextGifImages: () => Promise<void>;
    onGifSearchInputChange: (gifSearchInput: any, { debounce }?: {
        debounce: boolean;
    }) => void;
    error: null;
};

declare function useBanner(): {
    banners: Banner[];
};

declare function useBannerActions(): {
    addBannerItem: ({ bannerType, bannerMessage }: {
        bannerType: any;
        bannerMessage: any;
    }) => void;
};

type UseAutoHideBannerEffectArg = {
    bannerAutoHideTimeout?: number;
};
declare const DEFAULT_BANNER_AUTO_HIDE_TIMEOUT = 4000;
declare function useAutoHideBannerEffect({ bannerAutoHideTimeout, }: {
    bannerAutoHideTimeout?: number;
}): void;

type UseReactionPackArg = {
    reactionSpaceId: string;
};
declare function useReactionPacks({ reactionSpaceId }: UseReactionPackArg): {
    reactionPacks: IReactionPack[];
};

type UserReactionState = IUserReactionCountDetail & {
    imageSrc: string;
};
type UserReactionsForTargetIdState = {
    [key: string]: UserReactionState;
};
type UseUserReactionsArg = {
    reactionSpaceId: string;
    targetId: string;
};
declare function useUserReactions({ reactionSpaceId, targetId, }: UseUserReactionsArg): {
    userReactions: UserReactionsForTargetIdState;
};

type UseMessageItemPopoverArg = {
    messageId?: string;
};
declare function useMessageItemPopover(arg?: UseMessageItemPopoverArg): {
    popoverDetail: PopoverDetail;
    showPopover: (args: PopoverDetail) => void;
    hidePopover: () => void;
};

declare function useAutoScroll({ ref }: {
    ref: RefObject<FlatList>;
}): {
    onScrollEndDrag: () => void;
    onContentSizeChangeHandler: (width: number, height: number) => void;
};

type UseLoadReactionPackArg = {
    reactionSpaceId: string;
};
declare function useLoadReactionPacksEffect({ reactionSpaceId, }: UseLoadReactionPackArg): void;

type UseReactionSpaceArg = {
    targetGroupId: string;
};
declare function useReactionSpace({ targetGroupId }: UseReactionSpaceArg): {
    reactionSpace: _livelike_javascript.IReactionSpace;
};

type UseLoadUserReactionsArg = {
    reactionSpaceId: string;
};
declare function useLoadUserReactions({ reactionSpaceId, }: UseLoadUserReactionsArg): {
    loadUserReactions: ({ targetIds }: {
        targetIds: string[];
    }) => void;
};

declare function useUserReactionsEffect({ reactionSpaceId }: {
    reactionSpaceId: any;
}): void;

declare function useSelectedFieldStore<Store extends LLStore<unknown>, SelectedValue>(store: Store, selectorFn?: () => SelectedValue): SelectedValue;

type UseLoadWidgetEffectArg = {
    widgetId: string;
    widgetKind: WidgetKind$1;
    programId: string;
};
declare function useLoadWidgetEffect({ widgetId, widgetKind, programId, }: UseLoadWidgetEffectArg): {
    isLoading: boolean;
    data: readonly [_livelike_javascript.IWidgetPayload, _livelike_javascript.IWidgetInteraction[], _livelike_javascript.IWidgetEarnableReward[]];
    onApi?: undefined;
    error?: undefined;
} | {
    onApi: () => Promise<readonly [_livelike_javascript.IWidgetPayload, _livelike_javascript.IWidgetInteraction[], _livelike_javascript.IRewardTransaction[]]>;
    isLoading: boolean;
    error: string;
    data: readonly [_livelike_javascript.IWidgetPayload, _livelike_javascript.IWidgetInteraction[], _livelike_javascript.IRewardTransaction[]];
};

type UseWidgetArg = {
    widgetId: string;
};
declare function useWidget({ widgetId }: UseWidgetArg): IWidgetPayload;

type UseWidgetInteractionsArg = {
    widgetId: string;
};
declare function useWidgetInteractions({ widgetId }: UseWidgetInteractionsArg): IWidgetInteraction[];

type UseWidgetActionsArg = {
    widgetId: string;
};
declare function useWidgetActions({ widgetId }: UseWidgetActionsArg): {
    updateWidgetUIPhaseAction: ({ widgetId, widgetUIPhase, }: UpdateWidgetPhaseActionArgs) => void;
    updateWidgetChoicesAction: ({ widgetId, widgetChoices, }: UpdateWidgetChoicesActionArgs) => void;
    updateWidgetOptionsAction: ({ widgetId, widgetOptions, }: UpdateWidgetOptionsActionArgs) => void;
    updateSelectedOptionIndexAction: ({ widgetId, selectedOptionIndex, }: UpdateSelectedOptionIndexActionArgs) => void;
    updateWidgetResultStateAction: ({ widgetId, widgetResultState, }: UpdateWidgetResultStateActionArgs) => void;
    updateWidgetStateAction: ({ widgetId, widgetState, }: UpdateWidgetStateActionArgs) => void;
    updateWidgetAverageMagnitude: ({ widgetId, averageMagnitude, }: UpdateWidgetAverageMagnitudeArgs) => void;
    updateNumberPredictionOptionAction: ({ widgetId, numberOption, optionIndex, }: IUpdateNumberPredictionOptionActionArg) => void;
    updateEmojiSliderMagnitudeAction: ({ widgetId, magnitude, }: IUpdateSliderMagnitudeAction) => void;
    updateTextAskInputTextAction: ({ widgetId, inputText, }: IUpdateTextAskInputTextAction) => void;
};

type UseWidgetOptionsArg = {
    widgetId: string;
};
declare function useWidgetOptions({ widgetId, }: UseWidgetOptionsArg): IWidgetOptionItem$1[];

type UseSelectedWidgetOption = {
    widgetId: string;
};
declare function useInteractedWidgetOption({ widgetId }: {
    widgetId: any;
}): _livelike_javascript.IWidgetOptionItem | _livelike_javascript.IWidgetChoiceItem;

type UseWidgetSelectedOptionIndexArg = {
    widgetId: string;
};
declare function useWidgetSelectedOptionIndex({ widgetId, }: UseWidgetSelectedOptionIndexArg): number;

type UseWidgetResultStateArg = {
    widgetId: string;
};
declare function useWidgetResultState({ widgetId }: UseWidgetResultStateArg): WidgetResultState;

type UseWidgetUIPhaseArg = {
    widgetId: string;
};
declare const useWidgetUIPhase: ({ widgetId }: UseWidgetUIPhaseArg) => WidgetUIPhase;

type UseIsWidgetDisabledArg = {
    widgetId: string;
};
declare const useIsWidgetDisabled: ({ widgetId }: UseIsWidgetDisabledArg) => boolean;

type UseIsWidgetOptionDisabledArg = {
    widgetId: string;
    optionIndex: number;
};
declare const useIsWidgetOptionDisabled: ({ widgetId, optionIndex, }: UseIsWidgetOptionDisabledArg) => boolean;

type UseWidgetInteractionActionsArg = {
    widgetId: string;
};
type WidgetUpdateInteractionActionArg = {
    interactionItem: IWidgetOptionItem$1;
};
type WidgetCreateInteractionActionArg = {
    interactionItem: IWidgetChoiceItem$1 | IWidgetOptionItem$1 | INumberPredictionItem | ISliderInteractionItem | ITextAskInteractionItem;
};
declare function useWidgetInteractionActions({ widgetId, }: UseWidgetInteractionActionsArg): {
    updateWidgetInteractionAction: ({ interactionItem }: WidgetUpdateInteractionActionArg) => Promise<void | _livelike_javascript.IWidgetInteraction>;
    createWidgetInteractionAction: ({ interactionItem }: WidgetCreateInteractionActionArg) => Promise<void | _livelike_javascript.IWidgetInteraction>;
};

type UseWidgetInteractiveTimeoutArg = {
    widgetId: string;
    /** custom interactiveTimeout, defaults to the timeout value set when creating widget in producer suite */
    interactiveTimeout?: number | null;
    /** function to be called when widget timeouts */
    onInteractiveTimeout?: () => void;
};
type UseWidgetInteractiveTimeoutResult = {
    /** resulted timeout value to be used by LLWidgetHeader */
    interactiveTimeout: number | null;
    /** resulted timeout handler function to be used by LLWidgetHeader */
    onInteractiveTimeout: () => void;
};
/**
 * @description useWidgetInteractiveTimeout hook is to derive resulted interactiveTimeout based on
 * the passed interactiveTimeout value that in turns drives widget UI phases.
 * For example, once the widget timeouts, widget UI phase would transition from INTERACTIVE to TIMED_OUT
 * which would turn the widget into a non interact-able widget.
 * Resulted interactiveTimeout value is used by `LLWidgetHeader` component.
 * @since 0.1.0
 */
declare const useWidgetInteractiveTimeout: ({ widgetId, interactiveTimeout: interactiveTimeoutProp, onInteractiveTimeout: onInteractiveTimeoutProp, }: UseWidgetInteractiveTimeoutArg) => UseWidgetInteractiveTimeoutResult;

type UseWidgetExpiryEffectArg = {
    widgetId: string;
};
/**
 * @description useWidgetExpiryEffect hook runs a timer to update widget UI phase to EXPIRED
 * once the expiry time has passed. Expiry time is set when creating widget from producer suite
 * @since 0.1.0
 */
declare function useWidgetExpiryEffect({ widgetId }: UseWidgetExpiryEffectArg): void;

type UseWidgetSponsorsArg = {
    widgetId: string;
};
declare function useWidgetSponsors({ widgetId }: UseWidgetSponsorsArg): ISponsorPayload[];

type UseWidgetKindArg = {
    widgetId: string;
};
declare function useWidgetKind({ widgetId }: UseWidgetKindArg): WidgetKind;

type UseWidgetChoicesArg = {
    widgetId: string;
};
declare function useWidgetChoices({ widgetId, }: UseWidgetChoicesArg): IWidgetChoiceItem$1[];

type UseWidgetRewardsArg = {
    widgetId: string;
};
declare function useWidgetRewards({ widgetId }: UseWidgetRewardsArg): IWidgetEarnableReward[];

type UseIsEndWidgetUIPhaseArg = {
    widgetId: string;
};
declare const useIsEndWidgetUIPhase: ({ widgetId, }: UseIsEndWidgetUIPhaseArg) => boolean;

type UseWidgetRewardsEffectArg = {
    widgetId: string;
};
declare const useWidgetRewardsEffect: ({ widgetId, }: UseWidgetRewardsEffectArg) => {
    slideInOutStyles: {
        translateY: any;
    }[];
};

type UseWidgetDismissArg = {
    widgetId: string;
    onDismiss?: () => void;
};
declare function useWidgetDismiss({ widgetId, onDismiss }: UseWidgetDismissArg): {
    dismiss: boolean;
    onDismissHandler: () => void;
};

type UsePredictionWidgetEffectArg = {
    widgetId: string;
    programId: string;
    inlineFollowUp?: boolean;
};
/**
 * @description Listens to prediction follow up updates, and updates widget state and return followup widget details
 * @param UsePredictionWidgetEffectArg
 * @returns object with "followUpWidget" prop
 */
declare const usePredictionWidgetEffect: ({ widgetId, programId, inlineFollowUp, }: UsePredictionWidgetEffectArg) => {
    followUpWidget: IWidgetPayload$1;
};

type UsePredictionClaimRewardEffectArg = {
    widgetId: string;
    widgetKind: WidgetKind$1;
};
/**
 * @description `usePredictionClaimRewardEffect` hook claims the prediction reward
 * whenever a prediction follow up based UI is rendered.
 * Internally it calls claimPredictionWidgetRewards JS API.
 */
declare function usePredictionClaimRewardEffect({ widgetId, widgetKind }: {
    widgetId: any;
    widgetKind: any;
}): void;

type UseUserNumberOptionsArg = {
    widgetId: string;
};
declare function useUserNumberOptions({ widgetId, }: UseUserNumberOptionsArg): INumberPredictionItemOption[];

type UseNumberPredictionWidgetOptionArg = {
    widgetId: string;
    optionIndex: number;
    numberOption: INumberPredictionItemOption;
};
type NumberPredictionWidgetOptionDetails = {
    widgetOption: IWidgetOptionItem$1;
    interactedNumberOption: INumberPredictionItemOption;
    showWidgetResult: boolean;
    isCorrect: boolean;
    isWidgetOptionDisabled: boolean;
};
declare function useNumberPredictionWidgetOption({ widgetId, optionIndex, numberOption, }: UseNumberPredictionWidgetOptionArg): NumberPredictionWidgetOptionDetails;

type UseUserSliderMagnitudeArg = {
    widgetId: string;
};
declare function useUserSliderMagnitude({ widgetId, }: UseUserSliderMagnitudeArg): number | undefined;

type UseEmojiSliderArg = {
    thumbImages: {
        min: number;
        imageUrl: string;
    }[];
    onSlidingComplete: (value: number) => void;
    onValueChange?: (value: number) => void;
    value: number;
    initialValue?: number;
};
/**
 * @description useEmojiSlider hook provides state logic and effects for LLEmojiSlider component
 */
declare const useEmojiSlider: ({ thumbImages, onValueChange, onSlidingComplete, initialValue, value, }: UseEmojiSliderArg) => {
    sliderInput: number;
    thumbImg: string;
    onSlidingCompleteHandler: ([value]: [any]) => void;
    onValueChangeHandler: ([value]: [any]) => void;
};

type UseLoadWidgetRewardsEffectArg = {
    widgetId: string;
};
declare function useLoadWidgetRewardsEffect({ widgetId }: {
    widgetId: any;
}): void;

type UseCheerMeterOnOptionPressArg = {
    widgetId: string;
    optionIndex: number;
    throttleTime: number;
};
declare const useCheerMeterOnOptionPress: ({ widgetId, optionIndex, throttleTime, }: UseCheerMeterOnOptionPressArg) => () => void;

type UseTimelineWidgetsArg = {
    programId: string;
};
declare function useTimelineWidgets({ programId }: UseTimelineWidgetsArg): TimelineWidgetState[];

type UseLoadTimelineWidgetEffectArg = {
    programId: string;
    mode: WidgetMode;
};
declare function useLoadTimelineWidgetEffect({ programId, mode, }: UseLoadTimelineWidgetEffectArg): {
    onApi: () => Promise<IWidgetDetails>;
    isLoading: boolean;
    error: string;
    data: IWidgetDetails;
    onLoadMore: () => Promise<void>;
};
type IWidgetDetails = [
    IWidgetPayload$1[],
    IWidgetKindInteractionsMap,
    IRewardTransaction[]
];

type useTimelineWidgetActionsArg = {
    programId: string;
};
declare function useTimelineWidgetActions({ programId, }: useTimelineWidgetActionsArg): {
    onWidgetInteractiveTimeout: (timedOutWidgetId: string) => void;
    updateTimelineWidgetStateAction: ({ programId, widgetTimelineState, }: updateTimelineWidgetStateActionArgs) => void;
    updateTimelineWidgetsAction: ({ programId, widgets, prepend, }: UpdateTimelineWidgetsActionArgs) => void;
};

type UseIsTimelineWidgetArg = {
    widgetId: string;
};
declare const useIsTimelineWidget: ({ widgetId }: UseIsTimelineWidgetArg) => boolean;

type UseTextAskInputTextArg = {
    widgetId: string;
};
declare function useTextAskInputText({ widgetId, }: UseTextAskInputTextArg): string | undefined;

type UseChatRoomActionsArg = {
    roomId: string;
};
declare function useChatRoomActions({ roomId }: UseChatRoomActionsArg): {
    updateChatConfig: (arg: UpdateChatConfigActionArg) => void;
    loadPrevMessages: () => Promise<IteratorResult<{
        messages: IChatMessageResponsePayload[];
    }, {
        messages: IChatMessageResponsePayload[];
    }>>;
};

declare function useAnalytics(): {
    getAnalyticsProvider: () => _livelike_javascript.IAnalyticsProvider;
    setAnalyticsProvider: (provider: _livelike_javascript.IAnalyticsProvider) => void;
    trackEvent: (event: string, trackObj: unknown) => void;
};

type UseChatMessageMenuItemActionsArg = {
    messageDetails: IChatMessage;
};
declare const useChatMessageMenuItemActions: ({ messageDetails, }: UseChatMessageMenuItemActionsArg) => {
    blockId: string;
    deleteMessageApiFn: () => Promise<any>;
    reportMessageApiFn: () => Promise<any>;
    blockUserApiFn: () => Promise<any>;
    unblockUserApiFn: () => Promise<any>;
    blockUnblockApiFn: () => Promise<any>;
};

type UseUserReactionActionsArg = {
    targetGroupId: string;
    targetId: string;
};
declare function useUserReactionActions({ targetGroupId, targetId, }: UseUserReactionActionsArg): {
    addReaction: (actionArgs: UpdateUserReactionActionArg) => void;
    removeReaction: (actionArgs: UpdateUserReactionActionArg, selfReactionId: string) => void;
};

type UseWidgetSubmitActionArg = {
    widgetId: string;
};
declare function useWidgetSubmitAction({ widgetId }: UseWidgetSubmitActionArg): {
    onInteractionSubmit: ({ interactionItem }: WidgetCreateInteractionActionArg) => Promise<void | IWidgetInteraction>;
};

type UseWidgetInteractedAnalyticsArgs = {
    widgetId: string;
};
declare function useWidgetInteractedAnalytics({ widgetId, }: UseWidgetInteractedAnalyticsArgs): {
    trackWidgetInteractedAction: <T>({ interactionItem }: {
        interactionItem: T;
    }) => void;
};

declare function useTrackKeyboardEffect(): void;

type useDebounceArgs = {
    callback: (...args: any[]) => void;
    timer: number;
};
declare function useDebounce({ callback, timer }: useDebounceArgs): (...args: any[]) => void;

type UseCustomFontStyleArgs = {
    style: StyleProp<TextStyle>;
};
/**
 * @description useCustomFontStyle hook returns an evaluated styles for Text based Component
 * based on fontWeight and fontStyle, these tweaked style are needed because of platform (IOS & Android)
 *  limitation for custom fonts
 * @returns styles
 */
declare function useCustomFontStyle({ style }: UseCustomFontStyleArgs): {
    color?: react_native.ColorValue;
    fontFamily?: string;
    fontSize?: number;
    letterSpacing?: number;
    lineHeight?: number;
    textAlign?: "center" | "auto" | "left" | "right" | "justify";
    textDecorationLine?: "none" | "underline" | "line-through" | "underline line-through";
    textDecorationStyle?: "solid" | "double" | "dotted" | "dashed";
    textDecorationColor?: react_native.ColorValue;
    textShadowColor?: react_native.ColorValue;
    textShadowOffset?: {
        width: number;
        height: number;
    };
    textShadowRadius?: number;
    textTransform?: "none" | "capitalize" | "uppercase" | "lowercase";
    testID?: string;
    fontVariant?: react_native.FontVariant[];
    writingDirection?: "auto" | "ltr" | "rtl";
    backfaceVisibility?: "hidden" | "visible";
    backgroundColor?: react_native.ColorValue;
    borderBlockColor?: react_native.ColorValue;
    borderBlockEndColor?: react_native.ColorValue;
    borderBlockStartColor?: react_native.ColorValue;
    borderBottomColor?: react_native.ColorValue;
    borderBottomEndRadius?: react_native.AnimatableNumericValue;
    borderBottomLeftRadius?: react_native.AnimatableNumericValue;
    borderBottomRightRadius?: react_native.AnimatableNumericValue;
    borderBottomStartRadius?: react_native.AnimatableNumericValue;
    borderColor?: react_native.ColorValue;
    borderCurve?: "circular" | "continuous";
    borderEndColor?: react_native.ColorValue;
    borderEndEndRadius?: react_native.AnimatableNumericValue;
    borderEndStartRadius?: react_native.AnimatableNumericValue;
    borderLeftColor?: react_native.ColorValue;
    borderRadius?: react_native.AnimatableNumericValue;
    borderRightColor?: react_native.ColorValue;
    borderStartColor?: react_native.ColorValue;
    borderStartEndRadius?: react_native.AnimatableNumericValue;
    borderStartStartRadius?: react_native.AnimatableNumericValue;
    borderStyle?: "solid" | "dotted" | "dashed";
    borderTopColor?: react_native.ColorValue;
    borderTopEndRadius?: react_native.AnimatableNumericValue;
    borderTopLeftRadius?: react_native.AnimatableNumericValue;
    borderTopRightRadius?: react_native.AnimatableNumericValue;
    borderTopStartRadius?: react_native.AnimatableNumericValue;
    opacity?: react_native.AnimatableNumericValue;
    elevation?: number;
    pointerEvents?: "none" | "auto" | "box-none" | "box-only";
    alignContent?: "center" | "flex-start" | "flex-end" | "stretch" | "space-between" | "space-around";
    alignItems?: react_native.FlexAlignType;
    alignSelf?: "auto" | react_native.FlexAlignType;
    aspectRatio?: string | number;
    borderBottomWidth?: number;
    borderEndWidth?: number;
    borderLeftWidth?: number;
    borderRightWidth?: number;
    borderStartWidth?: number;
    borderTopWidth?: number;
    borderWidth?: number;
    bottom?: react_native.DimensionValue;
    display?: "none" | "flex";
    end?: react_native.DimensionValue;
    flex?: number;
    flexBasis?: react_native.DimensionValue;
    flexDirection?: "row" | "column" | "row-reverse" | "column-reverse";
    rowGap?: number;
    gap?: number;
    columnGap?: number;
    flexGrow?: number;
    flexShrink?: number;
    flexWrap?: "wrap" | "nowrap" | "wrap-reverse";
    height?: react_native.DimensionValue;
    justifyContent?: "center" | "flex-start" | "flex-end" | "space-between" | "space-around" | "space-evenly";
    left?: react_native.DimensionValue;
    margin?: react_native.DimensionValue;
    marginBottom?: react_native.DimensionValue;
    marginEnd?: react_native.DimensionValue;
    marginHorizontal?: react_native.DimensionValue;
    marginLeft?: react_native.DimensionValue;
    marginRight?: react_native.DimensionValue;
    marginStart?: react_native.DimensionValue;
    marginTop?: react_native.DimensionValue;
    marginVertical?: react_native.DimensionValue;
    maxHeight?: react_native.DimensionValue;
    maxWidth?: react_native.DimensionValue;
    minHeight?: react_native.DimensionValue;
    minWidth?: react_native.DimensionValue;
    overflow?: "scroll" | "hidden" | "visible";
    padding?: react_native.DimensionValue;
    paddingBottom?: react_native.DimensionValue;
    paddingEnd?: react_native.DimensionValue;
    paddingHorizontal?: react_native.DimensionValue;
    paddingLeft?: react_native.DimensionValue;
    paddingRight?: react_native.DimensionValue;
    paddingStart?: react_native.DimensionValue;
    paddingTop?: react_native.DimensionValue;
    paddingVertical?: react_native.DimensionValue;
    position?: "absolute" | "relative";
    right?: react_native.DimensionValue;
    start?: react_native.DimensionValue;
    top?: react_native.DimensionValue;
    width?: react_native.DimensionValue;
    zIndex?: number;
    direction?: "inherit" | "ltr" | "rtl";
    shadowColor?: react_native.ColorValue;
    shadowOffset?: Readonly<{
        width: number;
        height: number;
    }>;
    shadowOpacity?: react_native.AnimatableNumericValue;
    shadowRadius?: number;
    transform?: string | (react_native.PerpectiveTransform | react_native.RotateTransform | react_native.RotateXTransform | react_native.RotateYTransform | react_native.RotateZTransform | react_native.ScaleTransform | react_native.ScaleXTransform | react_native.ScaleYTransform | react_native.TranslateXTransform | react_native.TranslateYTransform | react_native.SkewXTransform | react_native.SkewYTransform | react_native.MatrixTransform)[];
    transformMatrix?: number[];
    rotation?: react_native.AnimatableNumericValue;
    scaleX?: react_native.AnimatableNumericValue;
    scaleY?: react_native.AnimatableNumericValue;
    translateX?: react_native.AnimatableNumericValue;
    translateY?: react_native.AnimatableNumericValue;
    textAlignVertical?: "center" | "auto" | "top" | "bottom";
    verticalAlign?: "auto" | "top" | "bottom" | "middle";
    includeFontPadding?: boolean;
};

type LLUserReactionCountDetailStyles = {
    container: ViewStyle;
    reactionIcon: ImageStyle;
    reactionCountText: TextStyle;
    selfReactionContainer: ViewStyle;
    selfReactionCountText: TextStyle;
};
type LLUserReactionCountDetailProps = ComponentStyleProp<LLUserReactionCountDetailStyles> & {
    reaction: UserReactionState;
    onPress: (reactionId: string) => void;
};
declare const LLUserReactionCountDetail: ({ reaction, styles: stylesProp, onPress, }: LLUserReactionCountDetailProps) => React__default.JSX.Element;

type LLUserReactionCountsStyles = {
    reactionCountsContainer: ViewStyle;
    moreReactionsView: ViewStyle;
    moreReactionsText: TextStyle;
};
type LLUserReactionCountsProps = ComponentStyleProp<LLUserReactionCountsStyles> & {
    targetGroupId: string;
    targetId: string;
    showReactionPicker?: boolean;
    reactionsLimit?: number;
    onReactionItemPress?: () => void;
    UserReactionCountDetailComponent?: typeof LLUserReactionCountDetail;
    UserReactionCountDetailComponentStyles?: LLUserReactionCountDetailProps['styles'];
    MessageReactionPickerComponent?: typeof LLReactionPicker;
    MessageReactionPickerComponentStyles?: LLReactionPickerProps['styles'];
};
declare function LLUserReactionCounts({ targetGroupId, targetId, showReactionPicker, onReactionItemPress, styles: stylesProp, MessageReactionPickerComponentStyles, UserReactionCountDetailComponentStyles, reactionsLimit, UserReactionCountDetailComponent, MessageReactionPickerComponent, }: LLUserReactionCountsProps): React__default.JSX.Element;

type LLChatMessageItemFooterStyles = {
    footerContainer: ViewStyle;
    addReactionIcon: ImageStyle;
};
type LLChatMessageItemFooterProps = ComponentStyleProp<LLChatMessageItemFooterStyles> & {
    message: IChatUserMessage;
    UserReactionsCountComponent?: typeof LLUserReactionCounts;
    UserReactionsCountComponentStyles?: LLUserReactionCountsProps['styles'];
};
declare function LLChatMessageItemFooter({ message: messageDetails, styles: stylesProp, UserReactionsCountComponentStyles, UserReactionsCountComponent, }: LLChatMessageItemFooterProps): React__default.JSX.Element;

type LLChatMessageMenuStyles = {
    menuContainer: ViewStyle;
};
type LLChatMessageMenuProps = ComponentStyleProp<LLChatMessageMenuStyles> & PropsWithChildren<{
    visible: boolean;
}>;
declare function LLChatMessageMenu({ visible, styles: stylesProp, children, }: LLChatMessageMenuProps): React__default.JSX.Element;

type LLChatMessageMenuOptionStyles = {
    menuItem: ViewStyle;
    menuItemText: TextStyle;
    menuItemIcon: ImageStyle;
    menuItemTopDivider: ViewStyle;
    menuItemBottomDivider: ViewStyle;
};
type LLChatMessageMenuOptionProps<OnClickApiFnResponseData extends Promise<any>> = ComponentStyleProp<LLChatMessageMenuOptionStyles> & {
    icon: ImageSourcePropType;
    textDesc: string;
    divider?: Partial<{
        top: boolean;
        bottom: boolean;
    }>;
    onClickApiFn: () => OnClickApiFnResponseData;
};
declare function LLChatMessageMenuOption<OnClickApiFnResponseData extends Promise<any>>({ icon, textDesc, divider, onClickApiFn, styles: stylesProp, }: LLChatMessageMenuOptionProps<OnClickApiFnRe